[ { "path": ".codespell/.codespellrc", "content": "[codespell]\nquiet-level = 2\ncount =\nskip = ./deps,./src/crc16_slottable.h,tmp*,./.git,./lcov-html\nignore-words = ./.codespell/wordlist.txt\n" }, { "path": ".codespell/requirements.txt", "content": "codespell==2.2.5\n" }, { "path": ".codespell/wordlist.txt", "content": "ake\nbale\nfle\nfo\ngameboy\nmutli\nnd\nnees\noll\noptin\not\nsmove\nte\ntre\ncancelability\nist\nstatics\nfiletest\nro\nexat\nclen" }, { "path": ".gitattributes", "content": "# We set commands.c's merge driver to `binary` so when it conflicts during a\n# merge git will leave the local version unmodified. This way our Makefile\n# will rebuild it based on src/commands/*.json before trying to compile it.\n# Otherwise the file gets modified and gets the same timestamp as the .json\n# files. So the Makefile doesn't attempt to rebuild it before compiling.\nsrc/commands.c merge=binary\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: Bug report\nabout: Help us improve Redis by reporting a bug\ntitle: '[BUG]'\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the bug**\n\nA short description of the bug.\n\n**To reproduce**\n\nSteps to reproduce the behavior and/or a minimal code sample.\n\n**Expected behavior**\n\nA description of what you expected to happen.\n\n**Additional information**\n\nAny additional information that is relevant to the problem.\n" }, { "path": ".github/ISSUE_TEMPLATE/crash_report.md", "content": "---\nname: Crash report\nabout: Submit a crash report\ntitle: '[CRASH] '\nlabels: ''\nassignees: ''\n\n---\n\nNotice!\n- If a Redis module was involved, please open an issue in the module's repo instead!\n- If you're using docker on Apple M1, please make sure the image you're using was compiled for ARM!\n\n\n**Crash report**\n\nPaste the complete crash log between the quotes below. Please include a few lines from the log preceding the crash report to provide some context.\n\n```\n```\n\n**Additional information**\n\n1. OS distribution and version\n2. Steps to reproduce (if any)\n" }, { "path": ".github/ISSUE_TEMPLATE/feature_request.md", "content": "---\nname: Feature request\nabout: Suggest a feature for Redis\ntitle: '[NEW]'\nlabels: ''\nassignees: ''\n\n---\n\n**The problem/use-case that the feature addresses**\n\nA description of the problem that the feature will solve, or the use-case with which the feature will be used.\n\n**Description of the feature**\n\nA description of what you want to happen.\n\n**Alternatives you've considered**\n\nAny alternative solutions or features you've considered, including references to existing open and closed feature requests in this repository.\n\n**Additional information**\n\nAny additional information that is relevant to the feature request.\n" }, { "path": ".github/ISSUE_TEMPLATE/other_stuff.md", "content": "---\nname: Other\nabout: Can't find the right issue type? Use this one!\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n" }, { "path": ".github/ISSUE_TEMPLATE/question.md", "content": "---\nname: Question\nabout: Ask the Redis developers\ntitle: '[QUESTION]'\nlabels: ''\nassignees: ''\n\n---\n\nPlease keep in mind that this issue tracker should be used for reporting bugs or proposing improvements to the Redis server.\n\nGenerally, questions about using Redis should be directed to the [community](https://redis.io/community):\n\n* [the mailing list](https://groups.google.com/forum/#!forum/redis-db)\n* [the `redis` tag at StackOverflow](http://stackoverflow.com/questions/tagged/redis)\n* [/r/redis subreddit](http://www.reddit.com/r/redis)\n* [github discussions](https://github.com/redis/redis/discussions)\n\nIt is also possible that your question was already asked here, so please do a quick issues search before submitting. Lastly, if your question is about one of Redis' [clients](https://redis.io/clients), you may to contact your client's developers for help.\n\nThat said, please feel free to replace all this with your question :)\n" }, { "path": ".github/dependabot.yml", "content": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where the package manifests are located.\n# Please see the documentation for all configuration options:\n# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates\n\nversion: 2\nupdates:\n - package-ecosystem: github-actions\n directory: /\n schedule:\n interval: weekly\n - package-ecosystem: pip\n directory: /.codespell\n schedule:\n interval: weekly\n" }, { "path": ".github/workflows/ci.yml", "content": "name: CI\n\non: [push, pull_request]\n\njobs:\n\n test-ubuntu-latest:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: make\n # Fail build if there are warnings\n # build with TLS just for compilation coverage\n run: make REDIS_CFLAGS='-Werror' BUILD_TLS=yes\n - name: test\n run: |\n sudo apt-get install tcl8.6 tclx\n ./runtest --verbose --tags -slow --dump-logs\n - name: validate commands.def up to date\n run: |\n touch src/commands/ping.json\n make commands.def\n dirty=$(git diff)\n if [[ ! -z $dirty ]]; then echo $dirty; exit 1; fi\n\n test-sanitizer-address:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: make\n # build with TLS module just for compilation coverage\n run: make SANITIZER=address REDIS_CFLAGS='-Werror -DDEBUG_ASSERTIONS -DREDIS_TEST' BUILD_TLS=module\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx -y\n - name: test\n run: ./runtest --verbose --tags -slow --dump-logs\n\n build-debian-old:\n runs-on: ubuntu-latest\n container: debian:buster\n steps:\n - uses: actions/checkout@v4\n - name: make\n run: |\n sed -i 's|http://deb.debian.org/debian|http://archive.debian.org/debian|g' /etc/apt/sources.list\n sed -i 's|http://security.debian.org|http://archive.debian.org/debian-security|g' /etc/apt/sources.list\n apt-get update && apt-get install -y build-essential\n make REDIS_CFLAGS='-Werror'\n\n build-macos-latest:\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@v4\n - name: make\n # Fail build if there are warnings\n # build with TLS just for compilation coverage\n run: make REDIS_CFLAGS='-Werror' BUILD_TLS=yes\n\n build-32bit:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: make\n run: |\n sudo apt-get update && sudo apt-get install libc6-dev-i386 gcc-multilib\n make REDIS_CFLAGS='-Werror' 32bit\n\n build-libc-malloc:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: make\n run: make REDIS_CFLAGS='-Werror' MALLOC=libc\n\n build-centos-jemalloc:\n runs-on: ubuntu-latest\n container: quay.io/centos/centos:stream9\n steps:\n - uses: actions/checkout@v4\n - name: make\n run: |\n dnf -y install which gcc make\n make REDIS_CFLAGS='-Werror'\n\n build-old-chain-jemalloc:\n runs-on: ubuntu-latest\n container: ubuntu:20.04\n steps:\n - uses: actions/checkout@v4\n - name: make\n run: |\n apt-get update\n apt-get install -y gnupg2\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial main\" >> /etc/apt/sources.list\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial universe\" >> /etc/apt/sources.list\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32\n apt-get update\n apt-get install -y make gcc-4.8\n update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 100\n make CC=gcc REDIS_CFLAGS='-Werror'\n" }, { "path": ".github/workflows/codecov.yml", "content": "name: \"Codecov\"\n\n# Enabling on each push is to display the coverage changes in every PR, \n# where each PR needs to be compared against the coverage of the head commit\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n code-coverage:\n if: ${{ github.repository == 'redis/redis' }}\n runs-on: ubuntu-latest\n\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n\n - name: Install lcov and run test\n run: |\n sudo apt-get install lcov\n make lcov\n\n - name: Upload coverage reports to Codecov\n uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6\n env:\n CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}\n with:\n files: ./src/redis.info\n disable_search: true\n fail_ci_if_error: true\n\n" }, { "path": ".github/workflows/codeql-analysis.yml", "content": "name: \"CodeQL\"\n\non:\n pull_request:\n schedule:\n # run weekly new vulnerability was added to the database\n - cron: '0 0 * * 0'\n\njobs:\n analyze:\n name: Analyze\n runs-on: ubuntu-latest\n if: github.event_name != 'schedule' || github.repository == 'redis/redis'\n\n strategy:\n fail-fast: false\n matrix:\n language: [ 'cpp' ]\n\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n\n - name: Initialize CodeQL\n uses: github/codeql-action/init@v3\n with:\n languages: ${{ matrix.language }}\n\n - name: Autobuild\n uses: github/codeql-action/autobuild@v3\n\n - name: Perform CodeQL Analysis\n uses: github/codeql-action/analyze@v3\n" }, { "path": ".github/workflows/coverity.yml", "content": "# Creates and uploads a Coverity build on a schedule\nname: Coverity Scan\non:\n schedule:\n # Run once daily, since below 500k LOC can have 21 builds per week, per https://scan.coverity.com/faq#frequency\n - cron: '0 0 * * *'\n # Support manual execution\n workflow_dispatch:\njobs:\n coverity:\n if: github.repository == 'redis/redis'\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@main\n - name: Download and extract the Coverity Build Tool\n run: |\n wget -q https://scan.coverity.com/download/cxx/linux64 --post-data \"token=${COVERITY_SCAN_TOKEN}&project=redis-unstable\" -O cov-analysis-linux64.tar.gz\n mkdir cov-analysis-linux64\n tar xzf cov-analysis-linux64.tar.gz --strip 1 -C cov-analysis-linux64\n env:\n COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}\n - name: Install Redis dependencies\n run: sudo apt install -y gcc tcl8.6 tclx procps libssl-dev\n - name: Build with cov-build\n run: cov-analysis-linux64/bin/cov-build --dir cov-int make\n - name: Upload the result\n run: |\n tar czvf cov-int.tgz cov-int\n curl \\\n --form project=redis-unstable \\\n --form email=\"${COVERITY_SCAN_EMAIL}\" \\\n --form token=\"${COVERITY_SCAN_TOKEN}\" \\\n --form file=@cov-int.tgz \\\n https://scan.coverity.com/builds\n env:\n COVERITY_SCAN_EMAIL: ${{ secrets.COVERITY_SCAN_EMAIL }}\n COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}\n" }, { "path": ".github/workflows/daily.yml", "content": "name: Daily\n\non:\n pull_request:\n branches:\n # any PR to a release branch.\n - '[0-9].[0-9]'\n schedule:\n - cron: '0 0 * * *'\n workflow_dispatch:\n inputs:\n skipjobs:\n description: 'jobs to skip (delete the ones you wanna keep, do not leave empty)'\n default: 'valgrind,sanitizer,tls,freebsd,macos,alpine,32bit,iothreads,ubuntu,centos,malloc,specific,fortify,reply-schema,oldTC,defrag,vectorset,assert-keyspace,arm'\n skiptests:\n description: 'tests to skip (delete the ones you wanna keep, do not leave empty)'\n default: 'redis,modules,sentinel,cluster,unittest'\n test_args:\n description: 'extra test arguments'\n default: ''\n cluster_test_args:\n description: 'extra cluster / sentinel test arguments'\n default: ''\n use_repo:\n description: 'repo owner and name'\n default: 'redis/redis'\n use_git_ref:\n description: 'git branch or sha to use'\n default: 'unstable'\n\n\njobs:\n\n test-ubuntu-jemalloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'ubuntu')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DREDIS_TEST -DDEBUG_ASSERTIONS'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all --accurate\n\n test-ubuntu-arm:\n runs-on: ubuntu-24.04-arm\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'arm')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install -y tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all --accurate\n\n test-ubuntu-arm-libc-malloc:\n runs-on: ubuntu-24.04-arm\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n (!contains(github.event.inputs.skipjobs, 'arm') || !contains(github.event.inputs.skipjobs, 'malloc'))\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make MALLOC=libc REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install -y tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-arm-tls:\n runs-on: ubuntu-24.04-arm\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n (!contains(github.event.inputs.skipjobs, 'arm') || !contains(github.event.inputs.skipjobs, 'tls'))\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make BUILD_TLS=yes REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install -y tcl8.6 tclx tcl-tls\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --tls --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel --tls ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster --tls ${{github.event.inputs.cluster_test_args}}\n\n # Test with DEBUG_ASSERT_KEYSPACE enabled to verify keyspace consistency.\n # This enables additional runtime checks after each command for:\n # - Info keysizes histogram\n # - Cluster slot stats\n # Skips slow and defrag tests to avoid timeouts while maintaining good coverage.\n test-debug-assert-keyspace:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'assert-keyspace')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DREDIS_TEST -DDEBUG_ASSERT_KEYSPACE -DDEBUG_ASSERTIONS'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --verbose --tags \"-slow -defrag\" \\\n --dump-logs ${{github.event.inputs.test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-jemalloc-fortify:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'fortify')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apt-get update && apt-get install -y make gcc\n make CC=gcc REDIS_CFLAGS='-Werror -DREDIS_TEST -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3'\n - name: testprep\n run: sudo apt-get install -y tcl8.6 tclx procps\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all --accurate\n\n test-ubuntu-libc-malloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'malloc')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make MALLOC=libc REDIS_CFLAGS='-Werror'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-no-malloc-usable-size:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'malloc')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make MALLOC=libc CFLAGS=-DNO_MALLOC_USABLE_SIZE REDIS_CFLAGS='-Werror'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-32bit:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, '32bit')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n sudo apt-get update && sudo apt-get install libc6-dev-i386 gcc-multilib\n make 32bit REDIS_CFLAGS='-Werror -DREDIS_TEST'\n make -C tests/modules 32bit # the script below doesn't have an argument, we must build manually ahead of time\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all --accurate\n\n test-ubuntu-tls:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n make BUILD_TLS=yes REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n sudo apt-get install tcl8.6 tclx tcl-tls\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs --tls --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel --tls ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster --tls ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-tls-no-tls:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n make BUILD_TLS=yes REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n sudo apt-get install tcl8.6 tclx tcl-tls\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-io-threads:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'iothreads')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n make REDIS_CFLAGS='-Werror'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --config io-threads 4 --accurate --verbose --tags \"network iothreads psync2 repl failover\" --dump-logs ${{github.event.inputs.test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster --config io-threads 4 ${{github.event.inputs.cluster_test_args}}\n\n test-ubuntu-reclaim-cache:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'specific')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n make REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n sudo apt-get install vmtouch\n mkdir /tmp/master \n mkdir /tmp/slave\n - name: warm up\n run: |\n ./src/redis-server --daemonize yes --logfile /dev/null\n ./src/redis-benchmark -n 1 > /dev/null\n ./src/redis-cli save | grep OK > /dev/null\n vmtouch -v ./dump.rdb > /dev/null\n - name: test\n run: |\n echo \"test SAVE doesn't increase cache\"\n CACHE0=$(grep -w file /sys/fs/cgroup/memory.stat | awk '{print $2}')\n echo \"$CACHE0\"\n ./src/redis-server --daemonize yes --logfile /dev/null --dir /tmp/master --port 8080 --repl-diskless-sync no --pidfile /tmp/master/redis.pid --rdbcompression no --enable-debug-command yes\n ./src/redis-cli -p 8080 debug populate 10000 k 102400\n ./src/redis-server --daemonize yes --logfile /dev/null --dir /tmp/slave --port 8081 --repl-diskless-load disabled --rdbcompression no\n ./src/redis-cli -p 8080 save > /dev/null\n VMOUT=$(vmtouch -v /tmp/master/dump.rdb)\n echo $VMOUT\n grep -q \" 0%\" <<< $VMOUT \n CACHE=$(grep -w file /sys/fs/cgroup/memory.stat | awk '{print $2}')\n echo \"$CACHE\"\n if [ \"$(( $CACHE-$CACHE0 ))\" -gt \"8000000\" ]; then exit 1; fi\n\n echo \"test replication doesn't increase cache\"\n ./src/redis-cli -p 8081 REPLICAOF 127.0.0.1 8080 > /dev/null\n while [ $(./src/redis-cli -p 8081 info replication | grep \"master_link_status:down\") ]; do sleep 1; done;\n sleep 1 # wait for the completion of cache reclaim bio\n VMOUT=$(vmtouch -v /tmp/master/dump.rdb)\n echo $VMOUT\n grep -q \" 0%\" <<< $VMOUT \n VMOUT=$(vmtouch -v /tmp/slave/dump.rdb)\n echo $VMOUT\n grep -q \" 0%\" <<< $VMOUT \n CACHE=$(grep -w file /sys/fs/cgroup/memory.stat | awk '{print $2}')\n echo \"$CACHE\"\n if [ \"$(( $CACHE-$CACHE0 ))\" -gt \"8000000\" ]; then exit 1; fi\n \n echo \"test reboot doesn't increase cache\"\n PID=$(cat /tmp/master/redis.pid)\n kill -15 $PID\n while [ -x /proc/${PID} ]; do sleep 1; done\n ./src/redis-server --daemonize yes --logfile /dev/null --dir /tmp/master --port 8080\n while [ $(./src/redis-cli -p 8080 info persistence | grep \"loading:1\") ]; do sleep 1; done;\n sleep 1 # wait for the completion of cache reclaim bio\n VMOUT=$(vmtouch -v /tmp/master/dump.rdb)\n echo $VMOUT\n grep -q \" 0%\" <<< $VMOUT\n CACHE=$(grep -w file /sys/fs/cgroup/memory.stat | awk '{print $2}')\n echo \"$CACHE\"\n if [ \"$(( $CACHE-$CACHE0 ))\" -gt \"8000000\" ]; then exit 1; fi\n\n test-valgrind-test:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'valgrind') && !contains(github.event.inputs.skiptests, 'redis')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make valgrind REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx valgrind -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n # Note that valgrind's overhead doesn't pair well with io-threads so we\n # explicitly disable tests tagged with 'iothreads' - these are tests that\n # always run with io-threads enabled.\n run: ./runtest --valgrind --no-latency --verbose --clients 1 --timeout 2400 --tags -iothreads --dump-logs ${{github.event.inputs.test_args}}\n\n test-valgrind-misc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'valgrind') && !(contains(github.event.inputs.skiptests, 'modules') && contains(github.event.inputs.skiptests, 'unittest'))\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make valgrind REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx valgrind -y\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: |\n valgrind --track-origins=yes --suppressions=./src/valgrind.sup --show-reachable=no --show-possibly-lost=no --leak-check=full --log-file=err.txt ./src/redis-server test all --valgrind\n if grep -q 0x err.txt; then cat err.txt; exit 1; fi\n\n test-valgrind-no-malloc-usable-size-test:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'valgrind') && !contains(github.event.inputs.skiptests, 'redis')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make valgrind CFLAGS=\"-DNO_MALLOC_USABLE_SIZE -DREDIS_TEST\" REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx valgrind -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --valgrind --tags -iothreads --no-latency --verbose --clients 1 --timeout 2400 --dump-logs ${{github.event.inputs.test_args}}\n\n test-valgrind-no-malloc-usable-size-misc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'valgrind') && !(contains(github.event.inputs.skiptests, 'modules') && contains(github.event.inputs.skiptests, 'unittest'))\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make valgrind CFLAGS=\"-DNO_MALLOC_USABLE_SIZE -DREDIS_TEST\" REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx valgrind -y\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: |\n valgrind --track-origins=yes --suppressions=./src/valgrind.sup --show-reachable=no --show-possibly-lost=no --leak-check=full --log-file=err.txt ./src/redis-server test all --valgrind\n if grep -q 0x err.txt; then cat err.txt; exit 1; fi\n\n test-sanitizer-address:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'sanitizer')\n timeout-minutes: 360\n strategy:\n matrix:\n compiler: [ gcc, clang ]\n env:\n CC: ${{ matrix.compiler }}\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make SANITIZER=address REDIS_CFLAGS='-DREDIS_TEST -Werror -DDEBUG_ASSERTIONS'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all\n\n test-sanitizer-memory:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'sanitizer')\n timeout-minutes: 360\n env:\n CC: clang # MSan works only with clang\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make SANITIZER=memory REDIS_CFLAGS='-DREDIS_TEST -Werror -DDEBUG_ASSERTIONS'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all\n\n test-sanitizer-undefined:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'sanitizer')\n timeout-minutes: 360\n strategy:\n matrix:\n compiler: [ gcc, clang ]\n env:\n CC: ${{ matrix.compiler }}\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make SANITIZER=undefined REDIS_CFLAGS='-DREDIS_TEST -Werror' SKIP_VEC_SETS=yes LUA_DEBUG=yes # we (ab)use this flow to also check Lua C API violations\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n - name: unittest\n if: true && !contains(github.event.inputs.skiptests, 'unittest')\n run: ./src/redis-server test all --accurate\n\n test-sanitizer-thread:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'sanitizer')\n timeout-minutes: 360\n strategy:\n fail-fast: false # let gcc and clang both run until the end even if one of them fails\n matrix:\n compiler: [ gcc, clang ]\n env:\n CC: ${{ matrix.compiler }}\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n # TODO Investigate why jemalloc with clang TSan crash on start;\n # with gcc TSan, jemalloc works modulo sentinel tests hanging.\n run: make SANITIZER=thread USE_JEMALLOC=no REDIS_CFLAGS='-DREDIS_TEST -Werror -DDEBUG_ASSERTIONS'\n - name: testprep\n run: |\n sudo apt-get update\n sudo apt-get install tcl8.6 tclx -y\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --tsan --clients 1 --config io-threads 4 --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel --tsan ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster --config io-threads 2 ${{github.event.inputs.cluster_test_args}}\n\n test-centos-jemalloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'centos')\n container: quay.io/centos/centos:stream9\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n dnf -y install which gcc make\n make REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n dnf -y install epel-release\n dnf -y install tcl tcltls procps-ng /usr/bin/kill\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-centos-tls-module:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls')\n container: quay.io/centos/centos:stream9\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n dnf -y install which gcc make openssl-devel openssl\n make BUILD_TLS=module REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n dnf -y install epel-release\n dnf -y install tcl tcltls procps-ng /usr/bin/kill\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs --tls-module --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster --tls-module ${{github.event.inputs.cluster_test_args}}\n\n test-centos-tls-module-no-tls:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls')\n container: quay.io/centos/centos:stream9\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n dnf -y install which gcc make openssl-devel openssl\n make BUILD_TLS=module REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n dnf -y install epel-release\n dnf -y install tcl tcltls procps-ng /usr/bin/kill\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-macos-latest:\n runs-on: macos-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'macos') && !(contains(github.event.inputs.skiptests, 'redis') && contains(github.event.inputs.skiptests, 'modules'))\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror'\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --clients 1 --no-latency --dump-logs ${{github.event.inputs.test_args}}\n\n test-macos-latest-sentinel:\n runs-on: macos-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'macos') && !contains(github.event.inputs.skiptests, 'sentinel')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror'\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n\n test-macos-latest-cluster:\n runs-on: macos-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'macos') && !contains(github.event.inputs.skiptests, 'cluster')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror'\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n build-macos:\n strategy:\n matrix:\n os: [macos-14, macos-26]\n runs-on: ${{ matrix.os }}\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'macos')\n timeout-minutes: 360\n steps:\n - uses: maxim-lobanov/setup-xcode@v1\n with:\n xcode-version: latest\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DREDIS_TEST'\n\n test-freebsd:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'freebsd')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: test\n uses: cross-platform-actions/action@v0.30.0\n with:\n operating_system: freebsd\n environment_variables: MAKE\n version: 13.2\n shell: bash\n run: |\n sudo pkg install -y bash gmake lang/tcl86 lang/tclX gcc\n gmake\n ./runtest --single unit/keyspace --single unit/auth --single unit/networking --single unit/protocol\n\n test-alpine-jemalloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'alpine')\n container: alpine:latest\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apk add build-base\n make REDIS_CFLAGS='-Werror'\n - name: testprep\n run: apk add tcl procps tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-alpine-libc-malloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'alpine')\n container: alpine:latest\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apk add build-base\n make REDIS_CFLAGS='-Werror' USE_JEMALLOC=no CFLAGS=-DUSE_MALLOC_USABLE_SIZE\n - name: testprep\n run: apk add tcl procps tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n reply-schemas-validator:\n runs-on: ubuntu-latest\n timeout-minutes: 360\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'reply-schema')\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DLOG_REQ_RES'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --log-req-res --no-latency --dont-clean --force-resp3 --tags -slow --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel --log-req-res --dont-clean --force-resp3 ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster --log-req-res --dont-clean --force-resp3 ${{github.event.inputs.cluster_test_args}}\n - name: Install Python dependencies\n uses: py-actions/py-dependency-install@30aa0023464ed4b5b116bd9fbdab87acf01a484e # v4.1.0\n with:\n path: \"./utils/req-res-validator/requirements.txt\"\n - name: validator\n run: ./utils/req-res-log-validator.py --verbose --fail-missing-reply-schemas ${{ (!contains(github.event.inputs.skiptests, 'redis') && !contains(github.event.inputs.skiptests, 'module') && !contains(github.event.inputs.sentinel, 'redis') && !contains(github.event.inputs.skiptests, 'cluster')) && github.event.inputs.test_args == '' && github.event.inputs.cluster_test_args == '' && '--fail-commands-not-all-hit' || '' }}\n\n test-old-chain-jemalloc:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'oldTC')\n container: ubuntu:20.04\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apt-get update\n apt-get install -y gnupg2\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial main\" >> /etc/apt/sources.list\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial universe\" >> /etc/apt/sources.list\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32\n apt-get update\n apt-get install -y make gcc-4.8\n update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 100\n make CC=gcc REDIS_CFLAGS='-Werror'\n - name: testprep\n run: apt-get install -y tcl tcltls tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-old-chain-tls-module:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls') && !contains(github.event.inputs.skipjobs, 'oldTC')\n container: ubuntu:20.04\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apt-get update\n apt-get install -y gnupg2\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial main\" >> /etc/apt/sources.list\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial universe\" >> /etc/apt/sources.list\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32\n apt-get update\n apt-get install -y make gcc-4.8 openssl libssl-dev\n update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 100\n make CC=gcc BUILD_TLS=module REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n apt-get install -y tcl tcltls tclx\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs --tls-module --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster --tls-module ${{github.event.inputs.cluster_test_args}}\n\n test-old-chain-tls-module-no-tls:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'tls') && !contains(github.event.inputs.skipjobs, 'oldTC')\n container: ubuntu:20.04\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: |\n apt-get update\n apt-get install -y gnupg2 \n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial main\" >> /etc/apt/sources.list\n echo \"deb http://archive.ubuntu.com/ubuntu/ xenial universe\" >> /etc/apt/sources.list\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5\n apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32\n apt-get update\n apt-get install -y make gcc-4.8 openssl libssl-dev\n update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 100\n make BUILD_TLS=module CC=gcc REDIS_CFLAGS='-Werror'\n - name: testprep\n run: |\n apt-get install -y tcl tcltls tclx\n ./utils/gen-test-certs.sh\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: |\n ./runtest --accurate --verbose --dump-logs ${{github.event.inputs.test_args}}\n - name: sentinel tests\n if: true && !contains(github.event.inputs.skiptests, 'sentinel')\n run: |\n ./runtest-sentinel ${{github.event.inputs.cluster_test_args}}\n - name: cluster tests\n if: true && !contains(github.event.inputs.skiptests, 'cluster')\n run: |\n ./runtest-cluster ${{github.event.inputs.cluster_test_args}}\n\n test-sanitizer-force-defrag:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'defrag')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make SANITIZER=address DEBUG_DEFRAG=force REDIS_CFLAGS='-Werror'\n - name: testprep\n run: sudo apt-get install tcl8.6 tclx\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --debug-defrag --verbose --clients 1 ${{github.event.inputs.test_args}}\n\n test-vectorset:\n runs-on: ubuntu-latest\n if: |\n (github.event_name == 'workflow_dispatch' || (github.event_name != 'workflow_dispatch' && github.repository == 'redis/redis')) &&\n !contains(github.event.inputs.skipjobs, 'vectorset')\n timeout-minutes: 360\n steps:\n - name: prep\n if: github.event_name == 'workflow_dispatch'\n run: |\n echo \"GITHUB_REPOSITORY=${{github.event.inputs.use_repo}}\" >> $GITHUB_ENV\n echo \"GITHUB_HEAD_REF=${{github.event.inputs.use_git_ref}}\" >> $GITHUB_ENV\n echo \"skipjobs: ${{github.event.inputs.skipjobs}}\"\n echo \"skiptests: ${{github.event.inputs.skiptests}}\"\n echo \"test_args: ${{github.event.inputs.test_args}}\"\n echo \"cluster_test_args: ${{github.event.inputs.cluster_test_args}}\"\n - uses: actions/checkout@v4\n with:\n repository: ${{ env.GITHUB_REPOSITORY }}\n ref: ${{ env.GITHUB_HEAD_REF }}\n - name: make\n run: make REDIS_CFLAGS='-Werror -DREDIS_TEST'\n - name: testprep\n run: |\n sudo apt-get install tcl8.6 tclx\n sudo pip install redis\n - name: test\n if: true && !contains(github.event.inputs.skiptests, 'redis')\n run: ./runtest --accurate --verbose --dump-logs --single vectorset/vectorset ${{github.event.inputs.test_args}}\n" }, { "path": ".github/workflows/external.yml", "content": "name: External Server Tests\n\non:\n pull_request:\n push:\n schedule:\n - cron: '0 0 * * *'\n\njobs:\n test-external-standalone:\n runs-on: ubuntu-latest\n if: github.event_name != 'schedule' || github.repository == 'redis/redis'\n timeout-minutes: 360\n steps:\n - uses: actions/checkout@v4\n - name: Build\n run: make REDIS_CFLAGS=-Werror\n - name: Start redis-server\n run: |\n ./src/redis-server --daemonize yes --save \"\" --logfile external-redis.log \\\n --enable-protected-configs yes --enable-debug-command yes --enable-module-command yes\n - name: Run external test\n run: |\n ./runtest \\\n --host 127.0.0.1 --port 6379 \\\n --verbose \\\n --tags -slow\n - name: Archive redis log\n if: ${{ failure() }}\n uses: actions/upload-artifact@v4\n with:\n name: test-external-redis-log\n path: external-redis.log\n\n test-external-cluster:\n runs-on: ubuntu-latest\n if: github.event_name != 'schedule' || github.repository == 'redis/redis'\n timeout-minutes: 360\n steps:\n - uses: actions/checkout@v4\n - name: Build\n run: make REDIS_CFLAGS=-Werror\n - name: Start redis-server\n run: |\n ./src/redis-server --cluster-enabled yes --daemonize yes --save \"\" --logfile external-redis-cluster.log \\\n --enable-protected-configs yes --enable-debug-command yes --enable-module-command yes\n - name: Create a single node cluster\n run: ./src/redis-cli cluster addslots $(for slot in {0..16383}; do echo $slot; done); sleep 5\n - name: Run external test\n run: |\n ./runtest \\\n --host 127.0.0.1 --port 6379 \\\n --verbose \\\n --cluster-mode \\\n --tags -slow\n - name: Archive redis log\n if: ${{ failure() }}\n uses: actions/upload-artifact@v4\n with:\n name: test-external-cluster-log\n path: external-redis-cluster.log\n\n test-external-nodebug:\n runs-on: ubuntu-latest\n if: github.event_name != 'schedule' || github.repository == 'redis/redis'\n timeout-minutes: 360\n steps:\n - uses: actions/checkout@v4\n - name: Build\n run: make REDIS_CFLAGS=-Werror\n - name: Start redis-server\n run: |\n ./src/redis-server --daemonize yes --save \"\" --logfile external-redis-nodebug.log\n - name: Run external test\n run: |\n ./runtest \\\n --host 127.0.0.1 --port 6379 \\\n --verbose \\\n --tags \"-slow -needs:debug\"\n - name: Archive redis log\n if: ${{ failure() }}\n uses: actions/upload-artifact@v4\n with:\n name: test-external-redis-nodebug-log\n path: external-redis-nodebug.log\n" }, { "path": ".github/workflows/post-release-automation.yml", "content": "name: Post-Release Automation\n\non:\n release:\n types: [published]\n\njobs:\n extract-release-info:\n if: github.repository == 'redis/redis'\n runs-on: ubuntu-latest\n outputs:\n tag_name: ${{ steps.release-info.outputs.tag_name }}\n release_type: ${{ steps.release-info.outputs.release_type }}\n steps:\n - name: Checkout repository\n uses: actions/checkout@v5\n\n - name: Extract and validate release information\n id: release-info\n env:\n TAG_NAME: ${{ github.event.release.tag_name }}\n GH_TOKEN: ${{ github.token }}\n run: |\n echo \"tag_name=${TAG_NAME}\" >> $GITHUB_OUTPUT\n echo \"Release tag: ${TAG_NAME}\"\n\n LATEST_TAG=$(gh release view --json tagName --jq '.tagName')\n echo \"Latest release tag(from gh release): ${LATEST_TAG}\"\n\n if [[ \"${TAG_NAME}\" == \"${LATEST_TAG}\" ]]; then\n echo \"release_type=latest\" >> $GITHUB_OUTPUT\n echo \"Detected latest release: ${TAG_NAME}\"\n else\n echo \"release_type=non-latest\" >> $GITHUB_OUTPUT\n echo \"Detected non-latest release: ${TAG_NAME} (latest is ${LATEST_TAG})\"\n fi\n\n create-tarball:\n needs: extract-release-info\n runs-on: ubuntu-latest\n env:\n TAG_NAME: ${{ needs.extract-release-info.outputs.tag_name }}\n outputs:\n sha256: ${{ steps.checksum.outputs.sha256 }}\n size_mb: ${{ steps.size.outputs.size_mb }}\n size_warning: ${{ steps.size.outputs.size_warning }}\n steps:\n - name: Checkout repository\n uses: actions/checkout@v5\n with:\n ref: ${{ env.TAG_NAME }}\n fetch-depth: 0\n\n - name: Create tarball\n run: ./utils/releasetools/01_create_tarball.sh \"$TAG_NAME\"\n\n - name: Verify tarball size\n id: size\n run: |\n TARBALL=\"/tmp/redis-${TAG_NAME}.tar.gz\"\n SIZE_MB=$(du -m \"$TARBALL\" | cut -f1)\n echo \"Tarball size: ${SIZE_MB} MB\"\n echo \"size_mb=${SIZE_MB}\" >> $GITHUB_OUTPUT\n if [ \"$SIZE_MB\" -lt 3 ] || [ \"$SIZE_MB\" -gt 5 ]; then\n echo \"::warning::Tarball size ${SIZE_MB} MB is outside expected range (3-5 MB)\"\n echo \"size_warning=true\" >> $GITHUB_OUTPUT\n else\n echo \"size_warning=false\" >> $GITHUB_OUTPUT\n fi\n\n - name: Calculate SHA256 checksum\n id: checksum\n run: |\n TARBALL=\"/tmp/redis-${TAG_NAME}.tar.gz\"\n SHA256=$(shasum -a 256 \"$TARBALL\" | cut -d' ' -f1)\n echo \"SHA256: $SHA256\"\n echo \"sha256=$SHA256\" >> $GITHUB_OUTPUT\n\n - name: Upload tarball as artifact\n uses: actions/upload-artifact@v6\n with:\n name: redis-${{ env.TAG_NAME }}-tarball\n path: /tmp/redis-${{ env.TAG_NAME }}.tar.gz\n compression-level: 0\n\n # approval-gate:\n # needs: [extract-release-info, create-tarball]\n # if: needs.extract-release-info.outputs.release_type == 'latest'\n # runs-on: ubuntu-latest\n # steps:\n # - name: Approval gate\n # run: |\n # echo \"Latest release detected. Manual approval required for production deployment.\"\n # # TODO: Implement approval workflow\n # # This could use GitHub Environments with required reviewers\n # # or a manual approval step\n\n # upload-tarball:\n # needs: [extract-release-info, create-tarball, approval-gate]\n # if: always() && !cancelled() && needs.create-tarball.result == 'success' && (needs.approval-gate.result == 'success' || needs.approval-gate.result == 'skipped')\n # runs-on: ubuntu-latest\n # steps:\n # - name: Upload tarball\n # run: |\n # echo \"TODO: Implement tarball upload\"\n # # This will require:\n # # - SSH credentials/keys for upload to download.redis.io\n # # - Adaptation of utils/releasetools/02_upload_tarball.sh for CI environment\n\n # test-release-tarball:\n # needs: upload-tarball\n # runs-on: ubuntu-latest\n # steps:\n # - name: Test release tarball\n # run: |\n # echo \"TODO: Implement release testing using utils/releasetools/03_test_release.sh\"\n # # This will:\n # # - Download the uploaded tarball\n # # - Extract and build Redis\n\n # update-release-hashes:\n # needs: test-release-tarball\n # runs-on: ubuntu-latest\n # steps:\n # - name: Update release hashes\n # run: |\n # echo \"TODO: Implement hash update using utils/releasetools/04_release_hash.sh\"\n # # This will require:\n # # - Access to redis-hashes repository\n # # - Git credentials for committing and pushing\n\n summary-and-notify:\n needs: [extract-release-info, create-tarball] # update-release-hashes\n if: always() && github.repository == 'redis/redis'\n runs-on: ubuntu-latest\n env:\n TAG_NAME: ${{ needs.extract-release-info.outputs.tag_name }}\n RELEASE_TYPE: ${{ needs.extract-release-info.outputs.release_type }}\n SHA256: ${{ needs.create-tarball.outputs.sha256 }}\n SIZE_MB: ${{ needs.create-tarball.outputs.size_mb }}\n SIZE_WARNING: ${{ needs.create-tarball.outputs.size_warning }}\n steps:\n - name: Summary\n run: |\n {\n echo \"## Post-Release Automation Summary\"\n echo \"\"\n echo \"- **Release Tag:** ${TAG_NAME}\"\n echo \"- **Release Type:** ${RELEASE_TYPE}\"\n echo \"- **Tarball SHA256:** ${SHA256}\"\n echo \"- **Tarball Size:** ${SIZE_MB} MB\"\n if [ \"${SIZE_WARNING}\" == \"true\" ]; then\n echo \"\"\n echo \"> [!WARNING]\"\n echo \"> Tarball size is outside expected range, check the logs for details.\"\n fi\n } >> $GITHUB_STEP_SUMMARY\n\n # - name: Send Slack notification\n # run: |\n # echo \"TODO: Implement Slack notification\"\n # # This will require:\n # # - Slack webhook URL or bot token (stored in secrets)\n # # - Determine appropriate channel (e.g., #releases, #redis-releases)\n # # - Craft message with release information and workflow status\n" }, { "path": ".github/workflows/redis_docs_sync.yaml", "content": "name: redis_docs_sync\n\non:\n release:\n types: [published]\n\njobs:\n redis_docs_sync:\n if: github.repository == 'redis/redis'\n runs-on: ubuntu-latest\n steps:\n - name: Generate a token\n id: generate-token\n uses: actions/create-github-app-token@v1\n with:\n app-id: ${{ secrets.DOCS_APP_ID }}\n private-key: ${{ secrets.DOCS_APP_PRIVATE_KEY }}\n\n - name: Invoke workflow on redis/docs\n env:\n GH_TOKEN: ${{ steps.generate-token.outputs.token }}\n RELEASE_NAME: ${{ github.event.release.tag_name }}\n run: |\n LATEST_RELEASE=$(\n curl -Ls \\\n -H \"Accept: application/vnd.github+json\" \\\n -H \"Authorization: Bearer ${GH_TOKEN}\" \\\n -H \"X-GitHub-Api-Version: 2022-11-28\" \\\n https://api.github.com/repos/redis/redis/releases/latest \\\n | jq -r '.tag_name'\n )\n\n if [[ \"${LATEST_RELEASE}\" == \"${RELEASE_NAME}\" ]]; then\n gh workflow run -R redis/docs redis_docs_sync.yaml -f release=\"${RELEASE_NAME}\"\n fi\n" }, { "path": ".github/workflows/reply-schemas-linter.yml", "content": "name: Reply-schemas linter\n\non:\n push:\n paths:\n - 'src/commands/*.json'\n pull_request:\n paths:\n - 'src/commands/*.json'\n\njobs:\n reply-schemas-linter:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: Setup nodejs\n uses: actions/setup-node@v4\n - name: Install packages\n run: npm install ajv\n - name: linter\n run: node ./utils/reply_schema_linter.js\n\n" }, { "path": ".github/workflows/spell-check.yml", "content": "# A CI action that using codespell to check spell.\n# .github/.codespellrc is a config file.\n# .github/wordlist.txt is a list of words that will ignore word checks.\n# More details please check the following link:\n# https://github.com/codespell-project/codespell\nname: Spellcheck\n\non:\n push:\n pull_request:\n\njobs:\n build:\n name: Spellcheck\n runs-on: ubuntu-latest\n\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n\n - name: pip cache\n uses: actions/cache@v4\n with:\n path: ~/.cache/pip\n key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}\n restore-keys: ${{ runner.os }}-pip-\n\n - name: Install prerequisites\n run: sudo pip install -r ./.codespell/requirements.txt\n\n - name: Spell check\n run: codespell --config=./.codespell/.codespellrc\n" }, { "path": ".gitignore", "content": ".*.swp\n*.o\n*.xo\n*.so\n*.d\n*.log\ndump.rdb\nredis-benchmark\nredis-check-aof\nredis-check-rdb\nredis-check-dump\nredis-cli\nredis-sentinel\nredis-server\ndoc-tools\nrelease\nmisc/*\nsrc/release.h\nappendonly.aof*\nappendonlydir\nSHORT_TERM_TODO\nrelease.h\nsrc/transfer.sh\nsrc/configs\nredis.ds\nsrc/redis.conf\nsrc/nodes.conf\ndeps/lua/src/lua\ndeps/lua/src/luac\ndeps/lua/src/liblua.a\ndeps/hdr_histogram/libhdrhistogram.a\ndeps/fpconv/libfpconv.a\ntests/tls/*\n.make-*\n.prerequisites\n*.dSYM\nMakefile.dep\n.vscode/*\n.idea/*\n.ccls\n.ccls-cache/*\ncompile_commands.json\nredis.code-workspace\n" }, { "path": "00-RELEASENOTES", "content": "Hello! This file is just a placeholder, since this is the \"unstable\" branch\nof Redis, the place where all the development happens.\n\nThere is no release notes for this branch, it gets forked into another branch\nevery time there is a partial feature freeze in order to eventually create\na new stable release.\n\nUsually \"unstable\" is stable enough for you to use it in development environments\nhowever you should never use it in production environments. It is possible\nto download the latest stable release here:\n\n https://download.redis.io/redis-stable.tar.gz\n\nMore information is available at https://redis.io\n\nHappy hacking!\n" }, { "path": "BUGS", "content": "Please check https://github.com/redis/redis/issues\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "Contributor Covenant Code of Conduct\nOur Pledge\nWe as members, contributors, and leaders pledge to make participation in our\ncommunity a harassment-free experience for everyone, regardless of age, body\nsize, visible or invisible disability, ethnicity, sex characteristics, gender\nidentity and expression, level of experience, education, socio-economic status,\nnationality, personal appearance, race, religion, or sexual identity\nand orientation.\nWe pledge to act and interact in ways that contribute to an open, welcoming,\ndiverse, inclusive, and healthy community.\nOur Standards\nExamples of behavior that contributes to a positive environment for our\ncommunity include:\n\n* Demonstrating empathy and kindness toward other people\n* Being respectful of differing opinions, viewpoints, and experiences\n* Giving and gracefully accepting constructive feedback\n* Accepting responsibility and apologizing to those affected by our mistakes,\nand learning from the experience\n* Focusing on what is best not just for us as individuals, but for the\noverall community\n\nExamples of unacceptable behavior include:\n\n* The use of sexualized language or imagery, and sexual attention or\nadvances of any kind\n* Trolling, insulting or derogatory comments, and personal or political attacks\n* Public or private harassment\n* Publishing others' private information, such as a physical or email\naddress, without their explicit permission\n* Other conduct which could reasonably be considered inappropriate in a\nprofessional setting\n\nEnforcement Responsibilities\nCommunity leaders are responsible for clarifying and enforcing our standards of\nacceptable behavior and will take appropriate and fair corrective action in\nresponse to any behavior that they deem inappropriate, threatening, offensive,\nor harmful.\nCommunity leaders have the right and responsibility to remove, edit, or reject\ncomments, commits, code, wiki edits, issues, and other contributions that are\nnot aligned to this Code of Conduct, and will communicate reasons for moderation\ndecisions when appropriate.\nScope\nThis Code of Conduct applies within all community spaces, and also applies when\nan individual is officially representing the community in public spaces.\nExamples of representing our community include using an official e-mail address,\nposting via an official social media account, or acting as an appointed\nrepresentative at an online or offline event.\nEnforcement\nInstances of abusive, harassing, or otherwise unacceptable behavior may be\nreported to the community leaders responsible for enforcement at\nthis email address: redis@redis.io.\nAll complaints will be reviewed and investigated promptly and fairly.\nAll community leaders are obligated to respect the privacy and security of the\nreporter of any incident.\nEnforcement Guidelines\nCommunity leaders will follow these Community Impact Guidelines in determining\nthe consequences for any action they deem in violation of this Code of Conduct:\n1. Correction\nCommunity Impact: Use of inappropriate language or other behavior deemed\nunprofessional or unwelcome in the community.\nConsequence: A private, written warning from community leaders, providing\nclarity around the nature of the violation and an explanation of why the\nbehavior was inappropriate. A public apology may be requested.\n2. Warning\nCommunity Impact: A violation through a single incident or series\nof actions.\nConsequence: A warning with consequences for continued behavior. No\ninteraction with the people involved, including unsolicited interaction with\nthose enforcing the Code of Conduct, for a specified period of time. This\nincludes avoiding interactions in community spaces as well as external channels\nlike social media. Violating these terms may lead to a temporary or\npermanent ban.\n3. Temporary Ban\nCommunity Impact: A serious violation of community standards, including\nsustained inappropriate behavior.\nConsequence: A temporary ban from any sort of interaction or public\ncommunication with the community for a specified period of time. No public or\nprivate interaction with the people involved, including unsolicited interaction\nwith those enforcing the Code of Conduct, is allowed during this period.\nViolating these terms may lead to a permanent ban.\n4. Permanent Ban\nCommunity Impact: Demonstrating a pattern of violation of community\nstandards, including sustained inappropriate behavior, harassment of an\nindividual, or aggression toward or disparagement of classes of individuals.\nConsequence: A permanent ban from any sort of public interaction within\nthe community.\nAttribution\nThis Code of Conduct is adapted from the Contributor Covenant,\nversion 2.0, available at\nhttps://www.contributor-covenant.org/version/2/0/code_of_conduct.html.\nCommunity Impact Guidelines were inspired by Mozilla's code of conduct\nenforcement ladder.\nFor answers to common questions about this code of conduct, see the FAQ at\nhttps://www.contributor-covenant.org/faq. Translations are available at\nhttps://www.contributor-covenant.org/translations.\n" }, { "path": "CONTRIBUTING.md", "content": "By contributing code to the Redis project in any form you agree to the Redis Software Grant and\nContributor License Agreement attached below. Only contributions made under the Redis Software Grant\nand Contributor License Agreement may be accepted by Redis, and any contribution is subject to the\nterms of the Redis tri-license under RSALv2/SSPLv1/AGPLv3 as described in the LICENSE.txt file included in\nthe Redis source distribution.\n\n# REDIS SOFTWARE GRANT AND CONTRIBUTOR LICENSE AGREEMENT\n\nTo specify the intellectual property license granted in any Contribution, Redis Ltd., (\"**Redis**\")\nrequires a Software Grant and Contributor License Agreement (\"**Agreement**\"). This Agreement is for\nyour protection as a contributor as well as the protection of Redis and its users; it does not\nchange your rights to use your own Contribution for any other purpose permitted by this Agreement.\n\nBy making any Contribution, You accept and agree to the following terms and conditions for the\nContribution. Except for the license granted in this Agreement to Redis and the recipients of the\nsoftware distributed by Redis, You reserve all right, title, and interest in and to Your\nContribution.\n\n1. **Definitions**\n\n 1.1. \"**You**\" (or \"**Your**\") means the copyright owner or legal entity authorized by the\n copyright owner that is entering into this Agreement with Redis. For legal entities, the entity\n making a Contribution and all other entities that Control, are Controlled by, or are under\n common Control with that entity are considered to be a single contributor. For the purposes of\n this definition, \"**Control**\" means (i) the power, direct or indirect, to cause the direction\n or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty\n percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n 1.2. \"**Contribution**\" means the code, documentation, or any original work of authorship,\n including any modifications or additions to an existing work described above.\n\n2. \"**Work**\" means any software project stewarded by Redis.\n\n3. **Grant of Copyright License**. Subject to the terms and conditions of this Agreement, You grant\n to Redis and to the recipients of the software distributed by Redis a perpetual, worldwide,\n non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare\n derivative works of, publicly display, publicly perform, sublicense, and distribute Your\n Contribution and such derivative works.\n\n4. **Grant of Patent License**. Subject to the terms and conditions of this Agreement, You grant to\n Redis and to the recipients of the software distributed by Redis a perpetual, worldwide,\n non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent\n license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable by You that are necessarily\n infringed by Your Contribution alone or by a combination of Your Contribution with the Work to\n which such Contribution was submitted. If any entity institutes patent litigation against You or\n any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your\n Contribution, or the Work to which you have contributed, constitutes a direct or contributory\n patent infringement, then any patent licenses granted to the claimant entity under this Agreement\n for that Contribution or Work terminate as of the date such litigation is filed.\n\n5. **Representations and Warranties**. You represent and warrant that: (i) You are legally entitled\n to grant the above licenses; and (ii) if You are an entity, each employee or agent designated by\n You is authorized to submit the Contribution on behalf of You; and (iii) your Contribution is\n Your original work, and that it will not infringe on any third party's intellectual property\n right(s).\n\n6. **Disclaimer**. You are not expected to provide support for Your Contribution, except to the\n extent You desire to provide support. You may provide support for free, for a fee, or not at all.\n Unless required by applicable law or agreed to in writing, You provide Your Contribution on an\n \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,\n including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,\n MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.\n\n7. **Enforceability**. Nothing in this Agreement will be construed as creating any joint venture,\n employment relationship, or partnership between You and Redis. If any provision of this Agreement\n is held to be unenforceable, the remaining provisions of this Agreement will not be affected.\n This represents the entire agreement between You and Redis relating to the Contribution.\n\n# IMPORTANT: HOW TO USE REDIS GITHUB ISSUES\n\nGitHub issues SHOULD ONLY BE USED to report bugs and for DETAILED feature\nrequests. Everything else should be asked on Discord:\n \n https://discord.com/invite/redis\n\nPLEASE DO NOT POST GENERAL QUESTIONS that are not about bugs or suspected\nbugs in the GitHub issues system. We'll be delighted to help you and provide\nall the support on Discord.\n\nThere is also an active community of Redis users at Stack Overflow:\n\n https://stackoverflow.com/questions/tagged/redis\n\nIssues and pull requests for documentation belong on the redis-doc repo:\n\n https://github.com/redis/redis-doc\n\nIf you are reporting a security bug or vulnerability, see SECURITY.md.\n\n# How to provide a patch for a new feature\n\n1. If it is a major feature or a semantical change, please don't start coding\nstraight away: if your feature is not a conceptual fit you'll lose a lot of\ntime writing the code without any reason. Start by posting in the mailing list\nand creating an issue at Github with the description of, exactly, what you want\nto accomplish and why. Use cases are important for features to be accepted.\nHere you can see if there is consensus about your idea.\n\n2. If in step 1 you get an acknowledgment from the project leaders, use the\n following procedure to submit a patch:\n\n a. Fork Redis on GitHub ( https://docs.github.com/en/github/getting-started-with-github/fork-a-repo )\n b. Create a topic branch (git checkout -b my_branch)\n c. Push to your branch (git push origin my_branch)\n d. Initiate a pull request on GitHub ( https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request )\n e. Done :)\n\n3. Keep in mind that we are very overloaded, so issues and PRs sometimes wait\nfor a *very* long time. However this is not a lack of interest, as the project\ngets more and more users, we find ourselves in a constant need to prioritize\ncertain issues/PRs over others. If you think your issue/PR is very important\ntry to popularize it, have other users commenting and sharing their point of\nview, and so forth. This helps.\n\n4. For minor fixes - open a pull request on GitHub.\n\nAdditional information on the RSALv2/SSPLv1/AGPLv3 tri-license is also found in the LICENSE.txt file.\n" }, { "path": "INSTALL", "content": "See README\n" }, { "path": "LICENSE.txt", "content": "Starting with Redis 8, Redis Open Source is moving to a tri-licensing model with all new Redis code\ncontributions governed by the updated Redis Software Grant and Contributor License Agreement.\nAfter this release, contributions are subject to your choice of: (a) the Redis Source Available License v2\n(RSALv2);or (b) the Server Side Public License v1 (SSPLv1); or (c) the GNU Affero General Public License v3 (AGPLv3).\nRedis Open Source 7.2 and prior releases remain subject to the BSDv3 clause license as referenced\nin the REDISCONTRIBUTIONS.txt file.\n\nThe licensing structure for Redis 8.0 and subsequent releases is as follows:\n\n\n1. Redis Source Available License 2.0 (RSALv2) Agreement\n========================================================\n\nLast Update: December 30, 2023\n\nAcceptance\n----------\n\nThis Agreement sets forth the terms and conditions on which the Licensor\nmakes available the Software. By installing, downloading, accessing,\nUsing, or distributing any of the Software, You agree to all of the\nterms and conditions of this Agreement.\n\nIf You are receiving the Software on behalf of Your Company, You\nrepresent and warrant that You have the authority to agree to this\nAgreement on behalf of such entity.\n\nThe Licensor reserves the right to update this Agreement from time to\ntime.\n\nThe terms below have the meanings set forth below for purposes of this\nAgreement:\n\nDefinitions\n-----------\n\nAgreement: this Redis Source Available License 2.0 Agreement.\n\nControl: ownership, directly or indirectly, of substantially all the\nassets of an entity, or the power to direct its management and policies\nby vote, contract, or otherwise.\n\nLicense: the License as described in the License paragraph below.\n\nLicensor: the entity offering these terms, which includes Redis Ltd. on\nbehalf of itself and its subsidiaries and affiliates worldwide.\n\nModify, Modified, or Modification: copy from or adapt all or part of the\nwork in a fashion requiring copyright permission other than making an\nexact copy. The resulting work is called a Modified version of the\nearlier work.\n\nRedis: the Redis software as described in redis.com redis.io.\n\nSoftware: certain Software components designed to work with Redis and\nprovided to You under this Agreement.\n\nTrademark: the trademarks, service marks, and any other similar rights.\n\nUse: anything You do with the Software requiring one of Your Licenses.\n\nYou: the recipient of the Software, the individual or entity on whose\nbehalf You are agreeing to this Agreement.\n\nYour Company: any legal entity, sole proprietorship, or other kind of\norganization that You work for, plus all organizations that have control\nover, are under the control of, or are under common control with that\norganization.\n\nYour Licenses: means all the Licenses granted to You for the Software\nunder this Agreement.\n\nLicense\n-------\n\nThe Licensor grants You a non-exclusive, royalty-free, worldwide,\nnon-sublicensable, non-transferable license to use, copy, distribute,\nmake available, and prepare derivative works of the Software, in each\ncase subject to the limitations and conditions below.\n\nLimitations\n-----------\n\nYou may not make the functionality of the Software or a Modified version\navailable to third parties as a service or distribute the Software or a\nModified version in a manner that makes the functionality of the\nSoftware available to third parties.\n\nMaking the functionality of the Software or Modified version available\nto third parties includes, without limitation, enabling third parties to\ninteract with the functionality of the Software or Modified version in\ndistributed form or remotely through a computer network, offering a\nproduct or service, the value of which entirely or primarily derives\nfrom the value of the Software or Modified version, or offering a\nproduct or service that accomplishes for users the primary purpose of\nthe Software or Modified version.\n\nYou may not alter, remove, or obscure any licensing, copyright, or other\nnotices of the Licensor in the Software. Any use of the Licensor's\nTrademarks is subject to applicable law.\n\nPatents\n-------\n\nThe Licensor grants You a License, under any patent claims the Licensor\ncan License, or becomes able to License, to make, have made, use, sell,\noffer for sale, import and have imported the Software, in each case\nsubject to the limitations and conditions in this License. This License\ndoes not cover any patent claims that You cause to be infringed by\nModifications or additions to the Software. If You or Your Company make\nany written claim that the Software infringes or contributes to\ninfringement of any patent, your patent License for the Software granted\nunder this Agreement ends immediately. If Your Company makes such a\nclaim, your patent License ends immediately for work on behalf of Your\nCompany.\n\nNotices\n-------\n\nYou must ensure that anyone who gets a copy of any part of the Software\nfrom You also gets a copy of the terms and conditions in this Agreement.\n\nIf You modify the Software, You must include in any Modified copies of\nthe Software prominent notices stating that You have Modified the\nSoftware.\n\nNo Other Rights\n---------------\n\nThe terms and conditions of this Agreement do not imply any Licenses\nother than those expressly granted in this Agreement.\n\nTermination\n-----------\n\nIf You Use the Software in violation of this Agreement, such Use is not\nLicensed, and Your Licenses will automatically terminate. If the\nLicensor provides You with a notice of your violation, and You cease all\nviolations of this License no later than 30 days after You receive that\nnotice, Your Licenses will be reinstated retroactively. However, if You\nviolate this Agreement after such reinstatement, any additional\nviolation of this Agreement will cause your Licenses to terminate\nautomatically and permanently.\n\nNo Liability\n------------\n\nAs far as the law allows, the Software comes as is, without any\nwarranty or condition, and the Licensor will not be liable to You for\nany damages arising out of this Agreement or the Use or nature of the\nSoftware, under any kind of legal claim.\n\nGoverning Law and Jurisdiction\n------------------------------\n\nIf You are located in Asia, Pacific, Americas, or other jurisdictions\nnot listed below, the Agreement will be construed and enforced in all\nrespects in accordance with the laws of the State of California, U.S.A.,\nwithout reference to its choice of law rules. The courts located in the\nCounty of Santa Clara, California, have exclusive jurisdiction for all\npurposes relating to this Agreement.\n\nIf You are located in Israel, the Agreement will be construed and\nenforced in all respects in accordance with the laws of the State of\nIsrael without reference to its choice of law rules. The courts located\nin the Central District of the State of Israel have exclusive\njurisdiction for all purposes relating to this Agreement.\n\nIf You are located in Europe, United Kingdom, Middle East or Africa, the\nAgreement will be construed and enforced in all respects in accordance\nwith the laws of England and Wales without reference to its choice of\nlaw rules. The competent courts located in London, England, have\nexclusive jurisdiction for all purposes relating to this Agreement.\n\n\n\n2. Server Side Public License (SSPL)\n====================================\n\n Server Side Public License\n VERSION 1, OCTOBER 16, 2018\n\n Copyright (c) 2018 MongoDB, Inc.\n\n Everyone is permitted to copy and distribute verbatim copies of this\n license document, but changing it is not allowed.\n\n TERMS AND CONDITIONS\n\n 0. Definitions.\n\n \"This License\" refers to Server Side Public License.\n\n \"Copyright\" also means copyright-like laws that apply to other kinds of\n works, such as semiconductor masks.\n\n \"The Program\" refers to any copyrightable work licensed under this\n License. Each licensee is addressed as \"you\". \"Licensees\" and\n \"recipients\" may be individuals or organizations.\n\n To \"modify\" a work means to copy from or adapt all or part of the work in\n a fashion requiring copyright permission, other than the making of an\n exact copy. The resulting work is called a \"modified version\" of the\n earlier work or a work \"based on\" the earlier work.\n\n A \"covered work\" means either the unmodified Program or a work based on\n the Program.\n\n To \"propagate\" a work means to do anything with it that, without\n permission, would make you directly or secondarily liable for\n infringement under applicable copyright law, except executing it on a\n computer or modifying a private copy. Propagation includes copying,\n distribution (with or without modification), making available to the\n public, and in some countries other activities as well.\n\n To \"convey\" a work means any kind of propagation that enables other\n parties to make or receive copies. Mere interaction with a user through a\n computer network, with no transfer of a copy, is not conveying.\n\n An interactive user interface displays \"Appropriate Legal Notices\" to the\n extent that it includes a convenient and prominently visible feature that\n (1) displays an appropriate copyright notice, and (2) tells the user that\n there is no warranty for the work (except to the extent that warranties\n are provided), that licensees may convey the work under this License, and\n how to view a copy of this License. If the interface presents a list of\n user commands or options, such as a menu, a prominent item in the list\n meets this criterion.\n\n 1. Source Code.\n\n The \"source code\" for a work means the preferred form of the work for\n making modifications to it. \"Object code\" means any non-source form of a\n work.\n\n A \"Standard Interface\" means an interface that either is an official\n standard defined by a recognized standards body, or, in the case of\n interfaces specified for a particular programming language, one that is\n widely used among developers working in that language. The \"System\n Libraries\" of an executable work include anything, other than the work as\n a whole, that (a) is included in the normal form of packaging a Major\n Component, but which is not part of that Major Component, and (b) serves\n only to enable use of the work with that Major Component, or to implement\n a Standard Interface for which an implementation is available to the\n public in source code form. A \"Major Component\", in this context, means a\n major essential component (kernel, window system, and so on) of the\n specific operating system (if any) on which the executable work runs, or\n a compiler used to produce the work, or an object code interpreter used\n to run it.\n\n The \"Corresponding Source\" for a work in object code form means all the\n source code needed to generate, install, and (for an executable work) run\n the object code and to modify the work, including scripts to control\n those activities. However, it does not include the work's System\n Libraries, or general-purpose tools or generally available free programs\n which are used unmodified in performing those activities but which are\n not part of the work. For example, Corresponding Source includes\n interface definition files associated with source files for the work, and\n the source code for shared libraries and dynamically linked subprograms\n that the work is specifically designed to require, such as by intimate\n data communication or control flow between those subprograms and other\n parts of the work.\n\n The Corresponding Source need not include anything that users can\n regenerate automatically from other parts of the Corresponding Source.\n\n The Corresponding Source for a work in source code form is that same work.\n\n 2. Basic Permissions.\n\n All rights granted under this License are granted for the term of\n copyright on the Program, and are irrevocable provided the stated\n conditions are met. This License explicitly affirms your unlimited\n permission to run the unmodified Program, subject to section 13. The\n output from running a covered work is covered by this License only if the\n output, given its content, constitutes a covered work. This License\n acknowledges your rights of fair use or other equivalent, as provided by\n copyright law. Subject to section 13, you may make, run and propagate\n covered works that you do not convey, without conditions so long as your\n license otherwise remains in force. You may convey covered works to\n others for the sole purpose of having them make modifications exclusively\n for you, or provide you with facilities for running those works, provided\n that you comply with the terms of this License in conveying all\n material for which you do not control copyright. Those thus making or\n running the covered works for you must do so exclusively on your\n behalf, under your direction and control, on terms that prohibit them\n from making any copies of your copyrighted material outside their\n relationship with you.\n\n Conveying under any other circumstances is permitted solely under the\n conditions stated below. Sublicensing is not allowed; section 10 makes it\n unnecessary.\n\n 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n No covered work shall be deemed part of an effective technological\n measure under any applicable law fulfilling obligations under article 11\n of the WIPO copyright treaty adopted on 20 December 1996, or similar laws\n prohibiting or restricting circumvention of such measures.\n\n When you convey a covered work, you waive any legal power to forbid\n circumvention of technological measures to the extent such circumvention is\n effected by exercising rights under this License with respect to the\n covered work, and you disclaim any intention to limit operation or\n modification of the work as a means of enforcing, against the work's users,\n your or third parties' legal rights to forbid circumvention of\n technological measures.\n\n 4. Conveying Verbatim Copies.\n\n You may convey verbatim copies of the Program's source code as you\n receive it, in any medium, provided that you conspicuously and\n appropriately publish on each copy an appropriate copyright notice; keep\n intact all notices stating that this License and any non-permissive terms\n added in accord with section 7 apply to the code; keep intact all notices\n of the absence of any warranty; and give all recipients a copy of this\n License along with the Program. You may charge any price or no price for\n each copy that you convey, and you may offer support or warranty\n protection for a fee.\n\n 5. Conveying Modified Source Versions.\n\n You may convey a work based on the Program, or the modifications to\n produce it from the Program, in the form of source code under the terms\n of section 4, provided that you also meet all of these conditions:\n\n a) The work must carry prominent notices stating that you modified it,\n and giving a relevant date.\n\n b) The work must carry prominent notices stating that it is released\n under this License and any conditions added under section 7. This\n requirement modifies the requirement in section 4 to \"keep intact all\n notices\".\n\n c) You must license the entire work, as a whole, under this License to\n anyone who comes into possession of a copy. This License will therefore\n apply, along with any applicable section 7 additional terms, to the\n whole of the work, and all its parts, regardless of how they are\n packaged. This License gives no permission to license the work in any\n other way, but it does not invalidate such permission if you have\n separately received it.\n\n d) If the work has interactive user interfaces, each must display\n Appropriate Legal Notices; however, if the Program has interactive\n interfaces that do not display Appropriate Legal Notices, your work\n need not make them do so.\n\n A compilation of a covered work with other separate and independent\n works, which are not by their nature extensions of the covered work, and\n which are not combined with it such as to form a larger program, in or on\n a volume of a storage or distribution medium, is called an \"aggregate\" if\n the compilation and its resulting copyright are not used to limit the\n access or legal rights of the compilation's users beyond what the\n individual works permit. Inclusion of a covered work in an aggregate does\n not cause this License to apply to the other parts of the aggregate.\n\n 6. Conveying Non-Source Forms.\n\n You may convey a covered work in object code form under the terms of\n sections 4 and 5, provided that you also convey the machine-readable\n Corresponding Source under the terms of this License, in one of these\n ways:\n\n a) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by the\n Corresponding Source fixed on a durable physical medium customarily\n used for software interchange.\n\n b) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by a written\n offer, valid for at least three years and valid for as long as you\n offer spare parts or customer support for that product model, to give\n anyone who possesses the object code either (1) a copy of the\n Corresponding Source for all the software in the product that is\n covered by this License, on a durable physical medium customarily used\n for software interchange, for a price no more than your reasonable cost\n of physically performing this conveying of source, or (2) access to\n copy the Corresponding Source from a network server at no charge.\n\n c) Convey individual copies of the object code with a copy of the\n written offer to provide the Corresponding Source. This alternative is\n allowed only occasionally and noncommercially, and only if you received\n the object code with such an offer, in accord with subsection 6b.\n\n d) Convey the object code by offering access from a designated place\n (gratis or for a charge), and offer equivalent access to the\n Corresponding Source in the same way through the same place at no\n further charge. You need not require recipients to copy the\n Corresponding Source along with the object code. If the place to copy\n the object code is a network server, the Corresponding Source may be on\n a different server (operated by you or a third party) that supports\n equivalent copying facilities, provided you maintain clear directions\n next to the object code saying where to find the Corresponding Source.\n Regardless of what server hosts the Corresponding Source, you remain\n obligated to ensure that it is available for as long as needed to\n satisfy these requirements.\n\n e) Convey the object code using peer-to-peer transmission, provided you\n inform other peers where the object code and Corresponding Source of\n the work are being offered to the general public at no charge under\n subsection 6d.\n\n A separable portion of the object code, whose source code is excluded\n from the Corresponding Source as a System Library, need not be included\n in conveying the object code work.\n\n A \"User Product\" is either (1) a \"consumer product\", which means any\n tangible personal property which is normally used for personal, family,\n or household purposes, or (2) anything designed or sold for incorporation\n into a dwelling. In determining whether a product is a consumer product,\n doubtful cases shall be resolved in favor of coverage. For a particular\n product received by a particular user, \"normally used\" refers to a\n typical or common use of that class of product, regardless of the status\n of the particular user or of the way in which the particular user\n actually uses, or expects or is expected to use, the product. A product\n is a consumer product regardless of whether the product has substantial\n commercial, industrial or non-consumer uses, unless such uses represent\n the only significant mode of use of the product.\n\n \"Installation Information\" for a User Product means any methods,\n procedures, authorization keys, or other information required to install\n and execute modified versions of a covered work in that User Product from\n a modified version of its Corresponding Source. The information must\n suffice to ensure that the continued functioning of the modified object\n code is in no case prevented or interfered with solely because\n modification has been made.\n\n If you convey an object code work under this section in, or with, or\n specifically for use in, a User Product, and the conveying occurs as part\n of a transaction in which the right of possession and use of the User\n Product is transferred to the recipient in perpetuity or for a fixed term\n (regardless of how the transaction is characterized), the Corresponding\n Source conveyed under this section must be accompanied by the\n Installation Information. But this requirement does not apply if neither\n you nor any third party retains the ability to install modified object\n code on the User Product (for example, the work has been installed in\n ROM).\n\n The requirement to provide Installation Information does not include a\n requirement to continue to provide support service, warranty, or updates\n for a work that has been modified or installed by the recipient, or for\n the User Product in which it has been modified or installed. Access\n to a network may be denied when the modification itself materially\n and adversely affects the operation of the network or violates the\n rules and protocols for communication across the network.\n\n Corresponding Source conveyed, and Installation Information provided, in\n accord with this section must be in a format that is publicly documented\n (and with an implementation available to the public in source code form),\n and must require no special password or key for unpacking, reading or\n copying.\n\n 7. Additional Terms.\n\n \"Additional permissions\" are terms that supplement the terms of this\n License by making exceptions from one or more of its conditions.\n Additional permissions that are applicable to the entire Program shall be\n treated as though they were included in this License, to the extent that\n they are valid under applicable law. If additional permissions apply only\n to part of the Program, that part may be used separately under those\n permissions, but the entire Program remains governed by this License\n without regard to the additional permissions. When you convey a copy of\n a covered work, you may at your option remove any additional permissions\n from that copy, or from any part of it. (Additional permissions may be\n written to require their own removal in certain cases when you modify the\n work.) You may place additional permissions on material, added by you to\n a covered work, for which you have or can give appropriate copyright\n permission.\n\n Notwithstanding any other provision of this License, for material you add\n to a covered work, you may (if authorized by the copyright holders of\n that material) supplement the terms of this License with terms:\n\n a) Disclaiming warranty or limiting liability differently from the\n terms of sections 15 and 16 of this License; or\n\n b) Requiring preservation of specified reasonable legal notices or\n author attributions in that material or in the Appropriate Legal\n Notices displayed by works containing it; or\n\n c) Prohibiting misrepresentation of the origin of that material, or\n requiring that modified versions of such material be marked in\n reasonable ways as different from the original version; or\n\n d) Limiting the use for publicity purposes of names of licensors or\n authors of the material; or\n\n e) Declining to grant rights under trademark law for use of some trade\n names, trademarks, or service marks; or\n\n f) Requiring indemnification of licensors and authors of that material\n by anyone who conveys the material (or modified versions of it) with\n contractual assumptions of liability to the recipient, for any\n liability that these contractual assumptions directly impose on those\n licensors and authors.\n\n All other non-permissive additional terms are considered \"further\n restrictions\" within the meaning of section 10. If the Program as you\n received it, or any part of it, contains a notice stating that it is\n governed by this License along with a term that is a further restriction,\n you may remove that term. If a license document contains a further\n restriction but permits relicensing or conveying under this License, you\n may add to a covered work material governed by the terms of that license\n document, provided that the further restriction does not survive such\n relicensing or conveying.\n\n If you add terms to a covered work in accord with this section, you must\n place, in the relevant source files, a statement of the additional terms\n that apply to those files, or a notice indicating where to find the\n applicable terms. Additional terms, permissive or non-permissive, may be\n stated in the form of a separately written license, or stated as\n exceptions; the above requirements apply either way.\n\n 8. Termination.\n\n You may not propagate or modify a covered work except as expressly\n provided under this License. Any attempt otherwise to propagate or modify\n it is void, and will automatically terminate your rights under this\n License (including any patent licenses granted under the third paragraph\n of section 11).\n\n However, if you cease all violation of this License, then your license\n from a particular copyright holder is reinstated (a) provisionally,\n unless and until the copyright holder explicitly and finally terminates\n your license, and (b) permanently, if the copyright holder fails to\n notify you of the violation by some reasonable means prior to 60 days\n after the cessation.\n\n Moreover, your license from a particular copyright holder is reinstated\n permanently if the copyright holder notifies you of the violation by some\n reasonable means, this is the first time you have received notice of\n violation of this License (for any work) from that copyright holder, and\n you cure the violation prior to 30 days after your receipt of the notice.\n\n Termination of your rights under this section does not terminate the\n licenses of parties who have received copies or rights from you under\n this License. If your rights have been terminated and not permanently\n reinstated, you do not qualify to receive new licenses for the same\n material under section 10.\n\n 9. Acceptance Not Required for Having Copies.\n\n You are not required to accept this License in order to receive or run a\n copy of the Program. Ancillary propagation of a covered work occurring\n solely as a consequence of using peer-to-peer transmission to receive a\n copy likewise does not require acceptance. However, nothing other than\n this License grants you permission to propagate or modify any covered\n work. These actions infringe copyright if you do not accept this License.\n Therefore, by modifying or propagating a covered work, you indicate your\n acceptance of this License to do so.\n\n 10. Automatic Licensing of Downstream Recipients.\n\n Each time you convey a covered work, the recipient automatically receives\n a license from the original licensors, to run, modify and propagate that\n work, subject to this License. You are not responsible for enforcing\n compliance by third parties with this License.\n\n An \"entity transaction\" is a transaction transferring control of an\n organization, or substantially all assets of one, or subdividing an\n organization, or merging organizations. If propagation of a covered work\n results from an entity transaction, each party to that transaction who\n receives a copy of the work also receives whatever licenses to the work\n the party's predecessor in interest had or could give under the previous\n paragraph, plus a right to possession of the Corresponding Source of the\n work from the predecessor in interest, if the predecessor has it or can\n get it with reasonable efforts.\n\n You may not impose any further restrictions on the exercise of the rights\n granted or affirmed under this License. For example, you may not impose a\n license fee, royalty, or other charge for exercise of rights granted\n under this License, and you may not initiate litigation (including a\n cross-claim or counterclaim in a lawsuit) alleging that any patent claim\n is infringed by making, using, selling, offering for sale, or importing\n the Program or any portion of it.\n\n 11. Patents.\n\n A \"contributor\" is a copyright holder who authorizes use under this\n License of the Program or a work on which the Program is based. The work\n thus licensed is called the contributor's \"contributor version\".\n\n A contributor's \"essential patent claims\" are all patent claims owned or\n controlled by the contributor, whether already acquired or hereafter\n acquired, that would be infringed by some manner, permitted by this\n License, of making, using, or selling its contributor version, but do not\n include claims that would be infringed only as a consequence of further\n modification of the contributor version. For purposes of this definition,\n \"control\" includes the right to grant patent sublicenses in a manner\n consistent with the requirements of this License.\n\n Each contributor grants you a non-exclusive, worldwide, royalty-free\n patent license under the contributor's essential patent claims, to make,\n use, sell, offer for sale, import and otherwise run, modify and propagate\n the contents of its contributor version.\n\n In the following three paragraphs, a \"patent license\" is any express\n agreement or commitment, however denominated, not to enforce a patent\n (such as an express permission to practice a patent or covenant not to\n sue for patent infringement). To \"grant\" such a patent license to a party\n means to make such an agreement or commitment not to enforce a patent\n against the party.\n\n If you convey a covered work, knowingly relying on a patent license, and\n the Corresponding Source of the work is not available for anyone to copy,\n free of charge and under the terms of this License, through a publicly\n available network server or other readily accessible means, then you must\n either (1) cause the Corresponding Source to be so available, or (2)\n arrange to deprive yourself of the benefit of the patent license for this\n particular work, or (3) arrange, in a manner consistent with the\n requirements of this License, to extend the patent license to downstream\n recipients. \"Knowingly relying\" means you have actual knowledge that, but\n for the patent license, your conveying the covered work in a country, or\n your recipient's use of the covered work in a country, would infringe\n one or more identifiable patents in that country that you have reason\n to believe are valid.\n\n If, pursuant to or in connection with a single transaction or\n arrangement, you convey, or propagate by procuring conveyance of, a\n covered work, and grant a patent license to some of the parties receiving\n the covered work authorizing them to use, propagate, modify or convey a\n specific copy of the covered work, then the patent license you grant is\n automatically extended to all recipients of the covered work and works\n based on it.\n\n A patent license is \"discriminatory\" if it does not include within the\n scope of its coverage, prohibits the exercise of, or is conditioned on\n the non-exercise of one or more of the rights that are specifically\n granted under this License. You may not convey a covered work if you are\n a party to an arrangement with a third party that is in the business of\n distributing software, under which you make payment to the third party\n based on the extent of your activity of conveying the work, and under\n which the third party grants, to any of the parties who would receive the\n covered work from you, a discriminatory patent license (a) in connection\n with copies of the covered work conveyed by you (or copies made from\n those copies), or (b) primarily for and in connection with specific\n products or compilations that contain the covered work, unless you\n entered into that arrangement, or that patent license was granted, prior\n to 28 March 2007.\n\n Nothing in this License shall be construed as excluding or limiting any\n implied license or other defenses to infringement that may otherwise be\n available to you under applicable patent law.\n\n 12. No Surrender of Others' Freedom.\n\n If conditions are imposed on you (whether by court order, agreement or\n otherwise) that contradict the conditions of this License, they do not\n excuse you from the conditions of this License. If you cannot use,\n propagate or convey a covered work so as to satisfy simultaneously your\n obligations under this License and any other pertinent obligations, then\n as a consequence you may not use, propagate or convey it at all. For\n example, if you agree to terms that obligate you to collect a royalty for\n further conveying from those to whom you convey the Program, the only way\n you could satisfy both those terms and this License would be to refrain\n entirely from conveying the Program.\n\n 13. Offering the Program as a Service.\n\n If you make the functionality of the Program or a modified version\n available to third parties as a service, you must make the Service Source\n Code available via network download to everyone at no charge, under the\n terms of this License. Making the functionality of the Program or\n modified version available to third parties as a service includes,\n without limitation, enabling third parties to interact with the\n functionality of the Program or modified version remotely through a\n computer network, offering a service the value of which entirely or\n primarily derives from the value of the Program or modified version, or\n offering a service that accomplishes for users the primary purpose of the\n Program or modified version.\n\n \"Service Source Code\" means the Corresponding Source for the Program or\n the modified version, and the Corresponding Source for all programs that\n you use to make the Program or modified version available as a service,\n including, without limitation, management software, user interfaces,\n application program interfaces, automation software, monitoring software,\n backup software, storage software and hosting software, all such that a\n user could run an instance of the service using the Service Source Code\n you make available.\n\n 14. Revised Versions of this License.\n\n MongoDB, Inc. may publish revised and/or new versions of the Server Side\n Public License from time to time. Such new versions will be similar in\n spirit to the present version, but may differ in detail to address new\n problems or concerns.\n\n Each version is given a distinguishing version number. If the Program\n specifies that a certain numbered version of the Server Side Public\n License \"or any later version\" applies to it, you have the option of\n following the terms and conditions either of that numbered version or of\n any later version published by MongoDB, Inc. If the Program does not\n specify a version number of the Server Side Public License, you may\n choose any version ever published by MongoDB, Inc.\n\n If the Program specifies that a proxy can decide which future versions of\n the Server Side Public License can be used, that proxy's public statement\n of acceptance of a version permanently authorizes you to choose that\n version for the Program.\n\n Later license versions may give you additional or different permissions.\n However, no additional obligations are imposed on any author or copyright\n holder as a result of your choosing to follow a later version.\n\n 15. Disclaimer of Warranty.\n\n THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\n APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\n HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\n OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\n THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\n IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\n ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. Limitation of Liability.\n\n IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\n THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING\n ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF\n THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO\n LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU\n OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGES.\n\n 17. Interpretation of Sections 15 and 16.\n\n If the disclaimer of warranty and limitation of liability provided above\n cannot be given local legal effect according to their terms, reviewing\n courts shall apply local law that most closely approximates an absolute\n waiver of all civil liability in connection with the Program, unless a\n warranty or assumption of liability accompanies a copy of the Program in\n return for a fee.\n\n END OF TERMS AND CONDITIONS\n\n\n3. GNU AFFERO GENERAL PUBLIC LICENSE, Version 3, 19 Nov 2007\n========================================================\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n Preamble\n\n The GNU Affero General Public License is a free, copyleft license for\nsoftware and other kinds of works, specifically designed to ensure\ncooperation with the community in the case of network server software.\n\n The licenses for most software and other practical works are designed\nto take away your freedom to share and change the works. By contrast,\nour General Public Licenses are intended to guarantee your freedom to\nshare and change all versions of a program--to make sure it remains free\nsoftware for all its users.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthem if you wish), that you receive source code or can get it if you\nwant it, that you can change the software or use pieces of it in new\nfree programs, and that you know you can do these things.\n\n Developers that use our General Public Licenses protect your rights\nwith two steps: (1) assert copyright on the software, and (2) offer\nyou this License which gives you legal permission to copy, distribute\nand/or modify the software.\n\n A secondary benefit of defending all users' freedom is that\nimprovements made in alternate versions of the program, if they\nreceive widespread use, become available for other developers to\nincorporate. Many developers of free software are heartened and\nencouraged by the resulting cooperation. However, in the case of\nsoftware used on network servers, this result may fail to come about.\nThe GNU General Public License permits making a modified version and\nletting the public access it on a server without ever releasing its\nsource code to the public.\n\n The GNU Affero General Public License is designed specifically to\nensure that, in such cases, the modified source code becomes available\nto the community. It requires the operator of a network server to\nprovide the source code of the modified version running there to the\nusers of that server. Therefore, public use of a modified version, on\na publicly accessible server, gives the public access to the source\ncode of the modified version.\n\n An older license, called the Affero General Public License and\npublished by Affero, was designed to accomplish similar goals. This is\na different license, not a version of the Affero GPL, but Affero has\nreleased a new version of the Affero GPL which permits relicensing under\nthis license.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\n TERMS AND CONDITIONS\n\n 0. Definitions.\n\n \"This License\" refers to version 3 of the GNU Affero General Public License.\n\n \"Copyright\" also means copyright-like laws that apply to other kinds of\nworks, such as semiconductor masks.\n\n \"The Program\" refers to any copyrightable work licensed under this\nLicense. Each licensee is addressed as \"you\". \"Licensees\" and\n\"recipients\" may be individuals or organizations.\n\n To \"modify\" a work means to copy from or adapt all or part of the work\nin a fashion requiring copyright permission, other than the making of an\nexact copy. The resulting work is called a \"modified version\" of the\nearlier work or a work \"based on\" the earlier work.\n\n A \"covered work\" means either the unmodified Program or a work based\non the Program.\n\n To \"propagate\" a work means to do anything with it that, without\npermission, would make you directly or secondarily liable for\ninfringement under applicable copyright law, except executing it on a\ncomputer or modifying a private copy. Propagation includes copying,\ndistribution (with or without modification), making available to the\npublic, and in some countries other activities as well.\n\n To \"convey\" a work means any kind of propagation that enables other\nparties to make or receive copies. Mere interaction with a user through\na computer network, with no transfer of a copy, is not conveying.\n\n An interactive user interface displays \"Appropriate Legal Notices\"\nto the extent that it includes a convenient and prominently visible\nfeature that (1) displays an appropriate copyright notice, and (2)\ntells the user that there is no warranty for the work (except to the\nextent that warranties are provided), that licensees may convey the\nwork under this License, and how to view a copy of this License. If\nthe interface presents a list of user commands or options, such as a\nmenu, a prominent item in the list meets this criterion.\n\n 1. Source Code.\n\n The \"source code\" for a work means the preferred form of the work\nfor making modifications to it. \"Object code\" means any non-source\nform of a work.\n\n A \"Standard Interface\" means an interface that either is an official\nstandard defined by a recognized standards body, or, in the case of\ninterfaces specified for a particular programming language, one that\nis widely used among developers working in that language.\n\n The \"System Libraries\" of an executable work include anything, other\nthan the work as a whole, that (a) is included in the normal form of\npackaging a Major Component, but which is not part of that Major\nComponent, and (b) serves only to enable use of the work with that\nMajor Component, or to implement a Standard Interface for which an\nimplementation is available to the public in source code form. A\n\"Major Component\", in this context, means a major essential component\n(kernel, window system, and so on) of the specific operating system\n(if any) on which the executable work runs, or a compiler used to\nproduce the work, or an object code interpreter used to run it.\n\n The \"Corresponding Source\" for a work in object code form means all\nthe source code needed to generate, install, and (for an executable\nwork) run the object code and to modify the work, including scripts to\ncontrol those activities. However, it does not include the work's\nSystem Libraries, or general-purpose tools or generally available free\nprograms which are used unmodified in performing those activities but\nwhich are not part of the work. For example, Corresponding Source\nincludes interface definition files associated with source files for\nthe work, and the source code for shared libraries and dynamically\nlinked subprograms that the work is specifically designed to require,\nsuch as by intimate data communication or control flow between those\nsubprograms and other parts of the work.\n\n The Corresponding Source need not include anything that users\ncan regenerate automatically from other parts of the Corresponding\nSource.\n\n The Corresponding Source for a work in source code form is that\nsame work.\n\n 2. Basic Permissions.\n\n All rights granted under this License are granted for the term of\ncopyright on the Program, and are irrevocable provided the stated\nconditions are met. This License explicitly affirms your unlimited\npermission to run the unmodified Program. The output from running a\ncovered work is covered by this License only if the output, given its\ncontent, constitutes a covered work. This License acknowledges your\nrights of fair use or other equivalent, as provided by copyright law.\n\n You may make, run and propagate covered works that you do not\nconvey, without conditions so long as your license otherwise remains\nin force. You may convey covered works to others for the sole purpose\nof having them make modifications exclusively for you, or provide you\nwith facilities for running those works, provided that you comply with\nthe terms of this License in conveying all material for which you do\nnot control copyright. Those thus making or running the covered works\nfor you must do so exclusively on your behalf, under your direction\nand control, on terms that prohibit them from making any copies of\nyour copyrighted material outside their relationship with you.\n\n Conveying under any other circumstances is permitted solely under\nthe conditions stated below. Sublicensing is not allowed; section 10\nmakes it unnecessary.\n\n 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n No covered work shall be deemed part of an effective technological\nmeasure under any applicable law fulfilling obligations under article\n11 of the WIPO copyright treaty adopted on 20 December 1996, or\nsimilar laws prohibiting or restricting circumvention of such\nmeasures.\n\n When you convey a covered work, you waive any legal power to forbid\ncircumvention of technological measures to the extent such circumvention\nis effected by exercising rights under this License with respect to\nthe covered work, and you disclaim any intention to limit operation or\nmodification of the work as a means of enforcing, against the work's\nusers, your or third parties' legal rights to forbid circumvention of\ntechnological measures.\n\n 4. Conveying Verbatim Copies.\n\n You may convey verbatim copies of the Program's source code as you\nreceive it, in any medium, provided that you conspicuously and\nappropriately publish on each copy an appropriate copyright notice;\nkeep intact all notices stating that this License and any\nnon-permissive terms added in accord with section 7 apply to the code;\nkeep intact all notices of the absence of any warranty; and give all\nrecipients a copy of this License along with the Program.\n\n You may charge any price or no price for each copy that you convey,\nand you may offer support or warranty protection for a fee.\n\n 5. Conveying Modified Source Versions.\n\n You may convey a work based on the Program, or the modifications to\nproduce it from the Program, in the form of source code under the\nterms of section 4, provided that you also meet all of these conditions:\n\n a) The work must carry prominent notices stating that you modified\n it, and giving a relevant date.\n\n b) The work must carry prominent notices stating that it is\n released under this License and any conditions added under section\n 7. This requirement modifies the requirement in section 4 to\n \"keep intact all notices\".\n\n c) You must license the entire work, as a whole, under this\n License to anyone who comes into possession of a copy. This\n License will therefore apply, along with any applicable section 7\n additional terms, to the whole of the work, and all its parts,\n regardless of how they are packaged. This License gives no\n permission to license the work in any other way, but it does not\n invalidate such permission if you have separately received it.\n\n d) If the work has interactive user interfaces, each must display\n Appropriate Legal Notices; however, if the Program has interactive\n interfaces that do not display Appropriate Legal Notices, your\n work need not make them do so.\n\n A compilation of a covered work with other separate and independent\nworks, which are not by their nature extensions of the covered work,\nand which are not combined with it such as to form a larger program,\nin or on a volume of a storage or distribution medium, is called an\n\"aggregate\" if the compilation and its resulting copyright are not\nused to limit the access or legal rights of the compilation's users\nbeyond what the individual works permit. Inclusion of a covered work\nin an aggregate does not cause this License to apply to the other\nparts of the aggregate.\n\n 6. Conveying Non-Source Forms.\n\n You may convey a covered work in object code form under the terms\nof sections 4 and 5, provided that you also convey the\nmachine-readable Corresponding Source under the terms of this License,\nin one of these ways:\n\n a) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by the\n Corresponding Source fixed on a durable physical medium\n customarily used for software interchange.\n\n b) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by a\n written offer, valid for at least three years and valid for as\n long as you offer spare parts or customer support for that product\n model, to give anyone who possesses the object code either (1) a\n copy of the Corresponding Source for all the software in the\n product that is covered by this License, on a durable physical\n medium customarily used for software interchange, for a price no\n more than your reasonable cost of physically performing this\n conveying of source, or (2) access to copy the\n Corresponding Source from a network server at no charge.\n\n c) Convey individual copies of the object code with a copy of the\n written offer to provide the Corresponding Source. This\n alternative is allowed only occasionally and noncommercially, and\n only if you received the object code with such an offer, in accord\n with subsection 6b.\n\n d) Convey the object code by offering access from a designated\n place (gratis or for a charge), and offer equivalent access to the\n Corresponding Source in the same way through the same place at no\n further charge. You need not require recipients to copy the\n Corresponding Source along with the object code. If the place to\n copy the object code is a network server, the Corresponding Source\n may be on a different server (operated by you or a third party)\n that supports equivalent copying facilities, provided you maintain\n clear directions next to the object code saying where to find the\n Corresponding Source. Regardless of what server hosts the\n Corresponding Source, you remain obligated to ensure that it is\n available for as long as needed to satisfy these requirements.\n\n e) Convey the object code using peer-to-peer transmission, provided\n you inform other peers where the object code and Corresponding\n Source of the work are being offered to the general public at no\n charge under subsection 6d.\n\n A separable portion of the object code, whose source code is excluded\nfrom the Corresponding Source as a System Library, need not be\nincluded in conveying the object code work.\n\n A \"User Product\" is either (1) a \"consumer product\", which means any\ntangible personal property which is normally used for personal, family,\nor household purposes, or (2) anything designed or sold for incorporation\ninto a dwelling. In determining whether a product is a consumer product,\ndoubtful cases shall be resolved in favor of coverage. For a particular\nproduct received by a particular user, \"normally used\" refers to a\ntypical or common use of that class of product, regardless of the status\nof the particular user or of the way in which the particular user\nactually uses, or expects or is expected to use, the product. A product\nis a consumer product regardless of whether the product has substantial\ncommercial, industrial or non-consumer uses, unless such uses represent\nthe only significant mode of use of the product.\n\n \"Installation Information\" for a User Product means any methods,\nprocedures, authorization keys, or other information required to install\nand execute modified versions of a covered work in that User Product from\na modified version of its Corresponding Source. The information must\nsuffice to ensure that the continued functioning of the modified object\ncode is in no case prevented or interfered with solely because\nmodification has been made.\n\n If you convey an object code work under this section in, or with, or\nspecifically for use in, a User Product, and the conveying occurs as\npart of a transaction in which the right of possession and use of the\nUser Product is transferred to the recipient in perpetuity or for a\nfixed term (regardless of how the transaction is characterized), the\nCorresponding Source conveyed under this section must be accompanied\nby the Installation Information. But this requirement does not apply\nif neither you nor any third party retains the ability to install\nmodified object code on the User Product (for example, the work has\nbeen installed in ROM).\n\n The requirement to provide Installation Information does not include a\nrequirement to continue to provide support service, warranty, or updates\nfor a work that has been modified or installed by the recipient, or for\nthe User Product in which it has been modified or installed. Access to a\nnetwork may be denied when the modification itself materially and\nadversely affects the operation of the network or violates the rules and\nprotocols for communication across the network.\n\n Corresponding Source conveyed, and Installation Information provided,\nin accord with this section must be in a format that is publicly\ndocumented (and with an implementation available to the public in\nsource code form), and must require no special password or key for\nunpacking, reading or copying.\n\n 7. Additional Terms.\n\n \"Additional permissions\" are terms that supplement the terms of this\nLicense by making exceptions from one or more of its conditions.\nAdditional permissions that are applicable to the entire Program shall\nbe treated as though they were included in this License, to the extent\nthat they are valid under applicable law. If additional permissions\napply only to part of the Program, that part may be used separately\nunder those permissions, but the entire Program remains governed by\nthis License without regard to the additional permissions.\n\n When you convey a copy of a covered work, you may at your option\nremove any additional permissions from that copy, or from any part of\nit. (Additional permissions may be written to require their own\nremoval in certain cases when you modify the work.) You may place\nadditional permissions on material, added by you to a covered work,\nfor which you have or can give appropriate copyright permission.\n\n Notwithstanding any other provision of this License, for material you\nadd to a covered work, you may (if authorized by the copyright holders of\nthat material) supplement the terms of this License with terms:\n\n a) Disclaiming warranty or limiting liability differently from the\n terms of sections 15 and 16 of this License; or\n\n b) Requiring preservation of specified reasonable legal notices or\n author attributions in that material or in the Appropriate Legal\n Notices displayed by works containing it; or\n\n c) Prohibiting misrepresentation of the origin of that material, or\n requiring that modified versions of such material be marked in\n reasonable ways as different from the original version; or\n\n d) Limiting the use for publicity purposes of names of licensors or\n authors of the material; or\n\n e) Declining to grant rights under trademark law for use of some\n trade names, trademarks, or service marks; or\n\n f) Requiring indemnification of licensors and authors of that\n material by anyone who conveys the material (or modified versions of\n it) with contractual assumptions of liability to the recipient, for\n any liability that these contractual assumptions directly impose on\n those licensors and authors.\n\n All other non-permissive additional terms are considered \"further\nrestrictions\" within the meaning of section 10. If the Program as you\nreceived it, or any part of it, contains a notice stating that it is\ngoverned by this License along with a term that is a further\nrestriction, you may remove that term. If a license document contains\na further restriction but permits relicensing or conveying under this\nLicense, you may add to a covered work material governed by the terms\nof that license document, provided that the further restriction does\nnot survive such relicensing or conveying.\n\n If you add terms to a covered work in accord with this section, you\nmust place, in the relevant source files, a statement of the\nadditional terms that apply to those files, or a notice indicating\nwhere to find the applicable terms.\n\n Additional terms, permissive or non-permissive, may be stated in the\nform of a separately written license, or stated as exceptions;\nthe above requirements apply either way.\n\n 8. Termination.\n\n You may not propagate or modify a covered work except as expressly\nprovided under this License. Any attempt otherwise to propagate or\nmodify it is void, and will automatically terminate your rights under\nthis License (including any patent licenses granted under the third\nparagraph of section 11).\n\n However, if you cease all violation of this License, then your\nlicense from a particular copyright holder is reinstated (a)\nprovisionally, unless and until the copyright holder explicitly and\nfinally terminates your license, and (b) permanently, if the copyright\nholder fails to notify you of the violation by some reasonable means\nprior to 60 days after the cessation.\n\n Moreover, your license from a particular copyright holder is\nreinstated permanently if the copyright holder notifies you of the\nviolation by some reasonable means, this is the first time you have\nreceived notice of violation of this License (for any work) from that\ncopyright holder, and you cure the violation prior to 30 days after\nyour receipt of the notice.\n\n Termination of your rights under this section does not terminate the\nlicenses of parties who have received copies or rights from you under\nthis License. If your rights have been terminated and not permanently\nreinstated, you do not qualify to receive new licenses for the same\nmaterial under section 10.\n\n 9. Acceptance Not Required for Having Copies.\n\n You are not required to accept this License in order to receive or\nrun a copy of the Program. Ancillary propagation of a covered work\noccurring solely as a consequence of using peer-to-peer transmission\nto receive a copy likewise does not require acceptance. However,\nnothing other than this License grants you permission to propagate or\nmodify any covered work. These actions infringe copyright if you do\nnot accept this License. Therefore, by modifying or propagating a\ncovered work, you indicate your acceptance of this License to do so.\n\n 10. Automatic Licensing of Downstream Recipients.\n\n Each time you convey a covered work, the recipient automatically\nreceives a license from the original licensors, to run, modify and\npropagate that work, subject to this License. You are not responsible\nfor enforcing compliance by third parties with this License.\n\n An \"entity transaction\" is a transaction transferring control of an\norganization, or substantially all assets of one, or subdividing an\norganization, or merging organizations. If propagation of a covered\nwork results from an entity transaction, each party to that\ntransaction who receives a copy of the work also receives whatever\nlicenses to the work the party's predecessor in interest had or could\ngive under the previous paragraph, plus a right to possession of the\nCorresponding Source of the work from the predecessor in interest, if\nthe predecessor has it or can get it with reasonable efforts.\n\n You may not impose any further restrictions on the exercise of the\nrights granted or affirmed under this License. For example, you may\nnot impose a license fee, royalty, or other charge for exercise of\nrights granted under this License, and you may not initiate litigation\n(including a cross-claim or counterclaim in a lawsuit) alleging that\nany patent claim is infringed by making, using, selling, offering for\nsale, or importing the Program or any portion of it.\n\n 11. Patents.\n\n A \"contributor\" is a copyright holder who authorizes use under this\nLicense of the Program or a work on which the Program is based. The\nwork thus licensed is called the contributor's \"contributor version\".\n\n A contributor's \"essential patent claims\" are all patent claims\nowned or controlled by the contributor, whether already acquired or\nhereafter acquired, that would be infringed by some manner, permitted\nby this License, of making, using, or selling its contributor version,\nbut do not include claims that would be infringed only as a\nconsequence of further modification of the contributor version. For\npurposes of this definition, \"control\" includes the right to grant\npatent sublicenses in a manner consistent with the requirements of\nthis License.\n\n Each contributor grants you a non-exclusive, worldwide, royalty-free\npatent license under the contributor's essential patent claims, to\nmake, use, sell, offer for sale, import and otherwise run, modify and\npropagate the contents of its contributor version.\n\n In the following three paragraphs, a \"patent license\" is any express\nagreement or commitment, however denominated, not to enforce a patent\n(such as an express permission to practice a patent or covenant not to\nsue for patent infringement). To \"grant\" such a patent license to a\nparty means to make such an agreement or commitment not to enforce a\npatent against the party.\n\n If you convey a covered work, knowingly relying on a patent license,\nand the Corresponding Source of the work is not available for anyone\nto copy, free of charge and under the terms of this License, through a\npublicly available network server or other readily accessible means,\nthen you must either (1) cause the Corresponding Source to be so\navailable, or (2) arrange to deprive yourself of the benefit of the\npatent license for this particular work, or (3) arrange, in a manner\nconsistent with the requirements of this License, to extend the patent\nlicense to downstream recipients. \"Knowingly relying\" means you have\nactual knowledge that, but for the patent license, your conveying the\ncovered work in a country, or your recipient's use of the covered work\nin a country, would infringe one or more identifiable patents in that\ncountry that you have reason to believe are valid.\n\n If, pursuant to or in connection with a single transaction or\narrangement, you convey, or propagate by procuring conveyance of, a\ncovered work, and grant a patent license to some of the parties\nreceiving the covered work authorizing them to use, propagate, modify\nor convey a specific copy of the covered work, then the patent license\nyou grant is automatically extended to all recipients of the covered\nwork and works based on it.\n\n A patent license is \"discriminatory\" if it does not include within\nthe scope of its coverage, prohibits the exercise of, or is\nconditioned on the non-exercise of one or more of the rights that are\nspecifically granted under this License. You may not convey a covered\nwork if you are a party to an arrangement with a third party that is\nin the business of distributing software, under which you make payment\nto the third party based on the extent of your activity of conveying\nthe work, and under which the third party grants, to any of the\nparties who would receive the covered work from you, a discriminatory\npatent license (a) in connection with copies of the covered work\nconveyed by you (or copies made from those copies), or (b) primarily\nfor and in connection with specific products or compilations that\ncontain the covered work, unless you entered into that arrangement,\nor that patent license was granted, prior to 28 March 2007.\n\n Nothing in this License shall be construed as excluding or limiting\nany implied license or other defenses to infringement that may\notherwise be available to you under applicable patent law.\n\n 12. No Surrender of Others' Freedom.\n\n If conditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot convey a\ncovered work so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you may\nnot convey it at all. For example, if you agree to terms that obligate you\nto collect a royalty for further conveying from those to whom you convey\nthe Program, the only way you could satisfy both those terms and this\nLicense would be to refrain entirely from conveying the Program.\n\n 13. Remote Network Interaction; Use with the GNU General Public License.\n\n Notwithstanding any other provision of this License, if you modify the\nProgram, your modified version must prominently offer all users\ninteracting with it remotely through a computer network (if your version\nsupports such interaction) an opportunity to receive the Corresponding\nSource of your version by providing access to the Corresponding Source\nfrom a network server at no charge, through some standard or customary\nmeans of facilitating copying of software. This Corresponding Source\nshall include the Corresponding Source for any work covered by version 3\nof the GNU General Public License that is incorporated pursuant to the\nfollowing paragraph.\n\n Notwithstanding any other provision of this License, you have\npermission to link or combine any covered work with a work licensed\nunder version 3 of the GNU General Public License into a single\ncombined work, and to convey the resulting work. The terms of this\nLicense will continue to apply to the part which is the covered work,\nbut the work with which it is combined will remain governed by version\n3 of the GNU General Public License.\n\n 14. Revised Versions of this License.\n\n The Free Software Foundation may publish revised and/or new versions of\nthe GNU Affero General Public License from time to time. Such new versions\nwill be similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nProgram specifies that a certain numbered version of the GNU Affero General\nPublic License \"or any later version\" applies to it, you have the\noption of following the terms and conditions either of that numbered\nversion or of any later version published by the Free Software\nFoundation. If the Program does not specify a version number of the\nGNU Affero General Public License, you may choose any version ever published\nby the Free Software Foundation.\n\n If the Program specifies that a proxy can decide which future\nversions of the GNU Affero General Public License can be used, that proxy's\npublic statement of acceptance of a version permanently authorizes you\nto choose that version for the Program.\n\n Later license versions may give you additional or different\npermissions. However, no additional obligations are imposed on any\nauthor or copyright holder as a result of your choosing to follow a\nlater version.\n\n 15. Disclaimer of Warranty.\n\n THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\nAPPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\nHOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\nOF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\nTHE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\nIS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\nALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. Limitation of Liability.\n\n IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\nTHE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY\nGENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE\nUSE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF\nDATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD\nPARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),\nEVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF\nSUCH DAMAGES.\n\n 17. Interpretation of Sections 15 and 16.\n\n If the disclaimer of warranty and limitation of liability provided\nabove cannot be given local legal effect according to their terms,\nreviewing courts shall apply local law that most closely approximates\nan absolute waiver of all civil liability in connection with the\nProgram, unless a warranty or assumption of liability accompanies a\ncopy of the Program in return for a fee.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\nto attach them to the start of each source file to most effectively\nstate the exclusion of warranty; and each file should have at least\nthe \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software: you can redistribute it and/or modify\n it under the terms of the GNU Affero General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Affero General Public License for more details.\n\n You should have received a copy of the GNU Affero General Public License\n along with this program. If not, see .\n\nAlso add information on how to contact you by electronic and paper mail.\n\n If your software can interact with users remotely through a computer\nnetwork, you should also make sure that it provides a way for users to\nget its source. For example, if your program is a web application, its\ninterface could display a \"Source\" link that leads users to an archive\nof the code. There are many ways you could offer source, and different\nsolutions will be better for different programs; see section 13 for the\nspecific requirements.\n\n You should also get your employer (if you work as a programmer) or school,\nif any, to sign a \"copyright disclaimer\" for the program, if necessary.\nFor more information on this, and how to apply and follow the GNU AGPL, see\n.\n" }, { "path": "MANIFESTO", "content": "[Note: this is the Redis manifesto, for general information about\n installing and running Redis read the README file instead.]\n\nRedis Manifesto\n===============\n\n1 - A DSL for Abstract Data Types. Redis is a DSL (Domain Specific Language)\n that manipulates abstract data types and implemented as a TCP daemon.\n Commands manipulate a key space where keys are binary-safe strings and\n values are different kinds of abstract data types. Every data type\n represents an abstract version of a fundamental data structure. For instance\n Redis Lists are an abstract representation of linked lists. In Redis, the\n essence of a data type isn't just the kind of operations that the data types\n support, but also the space and time complexity of the data type and the\n operations performed upon it.\n\n2 - Memory storage is #1. The Redis data set, composed of defined key-value\n pairs, is primarily stored in the computer's memory. The amount of memory in\n all kinds of computers, including entry-level servers, is increasing\n significantly each year. Memory is fast, and allows Redis to have very\n predictable performance. Datasets composed of 10k or 40 millions keys will\n perform similarly. Complex data types like Redis Sorted Sets are easy to\n implement and manipulate in memory with good performance, making Redis very\n simple. Redis will continue to explore alternative options (where data can\n be optionally stored on disk, say) but the main goal of the project remains\n the development of an in-memory database.\n\n3 - Fundamental data structures for a fundamental API. The Redis API is a direct\n consequence of fundamental data structures. APIs can often be arbitrary but\n not an API that resembles the nature of fundamental data structures. If we\n ever meet intelligent life forms from another part of the universe, they'll\n likely know, understand and recognize the same basic data structures we have\n in our computer science books. Redis will avoid intermediate layers in API,\n so that the complexity is obvious and more complex operations can be\n performed as the sum of the basic operations.\n\n4 - We believe in code efficiency. Computers get faster and faster, yet we\n believe that abusing computing capabilities is not wise: the amount of\n operations you can do for a given amount of energy remains anyway a\n significant parameter: it allows to do more with less computers and, at\n the same time, having a smaller environmental impact. Similarly Redis is\n able to \"scale down\" to smaller devices. It is perfectly usable in a\n Raspberry Pi and other small ARM based computers. Faster code having\n just the layers of abstractions that are really needed will also result,\n often, in more predictable performances. We think likewise about memory\n usage, one of the fundamental goals of the Redis project is to\n incrementally build more and more memory efficient data structures, so that\n problems that were not approachable in RAM in the past will be perfectly\n fine to handle in the future.\n\n5 - Code is like a poem; it's not just something we write to reach some\n practical result. Sometimes people that are far from the Redis philosophy\n suggest using other code written by other authors (frequently in other\n languages) in order to implement something Redis currently lacks. But to us\n this is like if Shakespeare decided to end Enrico IV using the Paradiso from\n the Divina Commedia. Is using any external code a bad idea? Not at all. Like\n in \"One Thousand and One Nights\" smaller self contained stories are embedded\n in a bigger story, we'll be happy to use beautiful self contained libraries\n when needed. At the same time, when writing the Redis story we're trying to\n write smaller stories that will fit in to other code.\n\n6 - We're against complexity. We believe designing systems is a fight against\n complexity. We'll accept to fight the complexity when it's worthwhile but\n we'll try hard to recognize when a small feature is not worth 1000s of lines\n of code. Most of the time the best way to fight complexity is by not\n creating it at all. Complexity is also a form of lock-in: code that is\n very hard to understand cannot be modified by users in an independent way\n regardless of the license. One of the main Redis goals is to remain\n understandable, enough for a single programmer to have a clear idea of how\n it works in detail just reading the source code for a couple of weeks.\n\n7 - Threading is not a silver bullet. Instead of making Redis threaded we\n believe on the idea of an efficient (mostly) single threaded Redis core.\n Multiple of such cores, that may run in the same computer or may run\n in multiple computers, are abstracted away as a single big system by\n higher order protocols and features: Redis Cluster and the upcoming\n Redis Proxy are our main goals. A shared nothing approach is not just\n much simpler (see the previous point in this document), is also optimal\n in NUMA systems. In the specific case of Redis it allows for each instance\n to have a more limited amount of data, making the Redis persist-by-fork\n approach more sounding. In the future we may explore parallelism only for\n I/O, which is the low hanging fruit: minimal complexity could provide an\n improved single process experience.\n\n8 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits\n naturally into a distributed version of Redis and 2) a more complex API that\n supports multi-key operations. Both are useful if used judiciously but\n there's no way to make the more complex multi-keys API distributed in an\n opaque way without violating our other principles. We don't want to provide\n the illusion of something that will work magically when actually it can't in\n all cases. Instead we'll provide commands to quickly migrate keys from one\n instance to another to perform multi-key operations and expose the\n trade-offs to the user.\n\n9 - We optimize for joy. We believe writing code is a lot of hard work, and the\n only way it can be worth is by enjoying it. When there is no longer joy in\n writing code, the best thing to do is stop. To prevent this, we'll avoid\n taking paths that will make Redis less of a joy to develop.\n\n10 - All the above points are put together in what we call opportunistic\n programming: trying to get the most for the user with minimal increases\n in complexity (hanging fruits). Solve 95% of the problem with 5% of the\n code when it is acceptable. Avoid a fixed schedule but follow the flow of\n user requests, inspiration, Redis internal readiness for certain features\n (sometimes many past changes reach a critical point making a previously\n complex feature very easy to obtain).\n" }, { "path": "Makefile", "content": "# Top level makefile, the real stuff is at ./src/Makefile and in ./modules/Makefile\n\nSUBDIRS = src\nifeq ($(BUILD_WITH_MODULES), yes)\n\tifeq ($(MAKECMDGOALS),32bit)\n \t$(error BUILD_WITH_MODULES=yes is not supported on 32 bit systems)\n\tendif\n\tSUBDIRS += modules\nendif\n\ndefault: all\n\n.DEFAULT:\n\tfor dir in $(SUBDIRS); do $(MAKE) -C $$dir $@; done\n\ninstall:\n\tfor dir in $(SUBDIRS); do $(MAKE) -C $$dir $@; done\n\n.PHONY: install\n" }, { "path": "README.md", "content": "[![codecov](https://codecov.io/github/redis/redis/graph/badge.svg?token=6bVHb5fRuz)](https://codecov.io/github/redis/redis)\n\nThis document serves as both a quick start guide to Redis and a detailed resource for building it from source.\n\n- New to Redis? Start with [What is Redis](#what-is-redis) and [Getting Started](#getting-started)\n- Ready to build from source? Jump to [Build Redis from Source](#build-redis-from-source)\n- Want to contribute? See the [Code contributions](#code-contributions) section\n and [CONTRIBUTING.md](./CONTRIBUTING.md)\n- Looking for detailed documentation? Navigate to [redis.io/docs](https://redis.io/docs/)\n\n## Table of contents\n\n- [What is Redis?](#what-is-redis)\n - [Key use cases](#key-use-cases)\n- [Why choose Redis?](#why-choose-redis)\n- [What is Redis Open Source?](#what-is-redis-open-source)\n- [Getting started](#getting-started)\n - [Redis starter projects](#redis-starter-projects)\n - [Using Redis with client libraries](#using-redis-with-client-libraries)\n - [Using Redis with redis-cli](#using-redis-with-redis-cli)\n - [Using Redis with Redis Insight](#using-redis-with-redis-insight)\n- [Redis data types, processing engines, and capabilities](#redis-data-types-processing-engines-and-capabilities)\n- [Cloud hosted Redis](#cloud-hosted-redis)\n- [Community](#community)\n- [Build Redis from source](#build-redis-from-source)\n - [Build and run Redis with all data structures - Ubuntu 20.04 (Focal)](#build-and-run-redis-with-all-data-structures---ubuntu-2004-focal)\n - [Build and run Redis with all data structures - Ubuntu 22.04 (Jammy)](#build-and-run-redis-with-all-data-structures---ubuntu-2204-jammy)\n - [Build and run Redis with all data structures - Ubuntu 24.04 (Noble)](#build-and-run-redis-with-all-data-structures---ubuntu-2404-noble)\n - [Build and run Redis with all data structures - Debian 11 (Bullseye) / 12 (Bookworm)](#build-and-run-redis-with-all-data-structures---debian-11-bullseye--12-bookworm)\n - [Build and run Redis with all data structures - AlmaLinux 8.10 / Rocky Linux 8.10](#build-and-run-redis-with-all-data-structures---almalinux-810--rocky-linux-810)\n - [Build and run Redis with all data structures - AlmaLinux 9.5 / Rocky Linux 9.5](#build-and-run-redis-with-all-data-structures---almalinux-95--rocky-linux-95)\n - [Build and run Redis with all data structures - macOS 13 (Ventura) and macOS 14 (Sonoma)](#build-and-run-redis-with-all-data-structures---macos-13-ventura-and-macos-14-sonoma)\n - [Build and run Redis with all data structures - macOS 15 (Sequoia)](#build-and-run-redis-with-all-data-structures---macos-15-sequoia)\n - [Building Redis - flags and general notes](#building-redis---flags-and-general-notes)\n - [Fixing build problems with dependencies or cached build options](#fixing-build-problems-with-dependencies-or-cached-build-options)\n - [Fixing problems building 32 bit binaries](#fixing-problems-building-32-bit-binaries)\n - [Allocator](#allocator)\n - [Monotonic clock](#monotonic-clock)\n - [Verbose build](#verbose-build)\n - [Running Redis with TLS](#running-redis-with-tls)\n- [Code contributions](#code-contributions)\n- [Redis Trademarks](#redis-trademarks)\n\n## What is Redis?\n\nFor developers, who are building real-time data-driven applications, Redis is the preferred, fastest, and most feature-rich cache, data structure server, and document and vector query engine.\n\n### Key use cases\n\nRedis excels in various applications, including:\n\n- **Caching:** Supports multiple eviction policies, key expiration, and hash-field expiration.\n- **Distributed Session Store:** Offers flexible session data modeling (string, JSON, hash).\n- **Data Structure Server:** Provides low-level data structures (strings, lists, sets, hashes, sorted sets, JSON, etc.) with high-level semantics (counters, queues, leaderboards, rate limiters) and supports transactions & scripting.\n- **NoSQL Data Store:** Key-value, document, and time series data storage.\n- **Search and Query Engine:** Indexing for hash/JSON documents, supporting vector search, full-text search, geospatial queries, ranking, and aggregations via Redis Query Engine.\n- **Event Store & Message Broker:** Implements queues (lists), priority queues (sorted sets), event deduplication (sets), streams, and pub/sub with probabilistic stream processing capabilities.\n- **Vector Store for GenAI:** Integrates with AI applications (e.g. LangGraph, mem0) for short-term memory, long-term memory, LLM response caching (semantic caching), and retrieval augmented generation (RAG).\n- **Real-Time Analytics:** Powers personalization, recommendations, fraud detection, and risk assessment.\n\n## Why choose Redis?\n\nRedis is a popular choice for developers worldwide due to its combination of speed, flexibility, and rich feature set. Here's why people choose Redis for:\n\n- **Performance:** Because Redis keeps data primarily in memory and uses efficient data structures, it achieves extremely low latency (often sub-millisecond) for both read and write operations. This makes it ideal for applications demanding real-time responsiveness.\n- **Flexibility:** Redis isn't just a key-value store, it provides native support for a wide range of data structures and capabilities listed in [What is Redis?](#what-is-redis)\n- **Extensibility:** Redis is not limited to the built-in data structures, it has a [modules API](https://redis.io/docs/latest/develop/reference/modules/) that makes it possible to extend Redis functionality and rapidly implement new Redis commands\n- **Simplicity:** Redis has a simple, text-based protocol and [well-documented command set](https://redis.io/docs/latest/commands/)\n- **Ubiquity:** Redis is battle tested in production workloads at a massive scale. There is a good chance you indirectly interact with Redis several times daily\n- **Versatility**: Redis is the de facto standard for use cases such as:\n - **Caching:** quickly access frequently used data without needing to query your primary database\n - **Session management:** read and write user session data without hurting user experience or slowing down every API call\n - **Querying, sorting, and analytics:** perform deduplication, full text search, and secondary indexing on in-memory data as fast as possible\n - **Messaging and interservice communication:** job queues, message brokering, pub/sub, and streams for communicating between services\n - **Vector operations:** Long-term and short-term LLM memory, RAG content retrieval, semantic caching, semantic routing, and vector similarity search\n\nIn summary, Redis provides a powerful, fast, and flexible toolkit for solving a wide variety of data management challenges. If you want to know more, here is a list of starting points:\n\n- [**Introduction to Redis data types**](https://redis.io/docs/latest/develop/data-types/)\n- [**The full list of Redis commands**](https://redis.io/commands/)\n- [**Redis for AI**](https://redis.io/docs/latest/develop/ai/)\n- [**Redis documentation**](https://redis.io/documentation/)\n\n## What is Redis Open Source?\n\nRedis Community Edition (Redis CE) was renamed Redis Open Source with the v8.0 release.\n\nRedis Ltd. also offers [Redis Software](https://redis.io/enterprise/), a self-managed software with additional compliance, reliability, and resiliency for enterprise scaling,\nand [Redis Cloud](https://redis.io/cloud/), a fully managed service integrated with Google Cloud, Azure, and AWS for production-ready apps.\n\nRead more about the differences between Redis Open Source and Redis [here](https://redis.io/technology/advantages/).\n\n## Getting started\n\nIf you want to get up and running with Redis quickly without needing to build from source, use one of the following methods:\n\n- [**Redis Cloud**](https://cloud.redis.io/)\n- [**Official Redis Docker images (Alpine/Debian)**](https://hub.docker.com/_/redis)\n ```sh\n docker run -d -p 6379:6379 redis:latest\n ```\n- **Redis binary distributions**\n - [**Snap**](https://github.com/redis/redis-snap)\n - [**Homebrew**](https://github.com/redis/homebrew-redis)\n - [**RPM**](https://github.com/redis/redis-rpm)\n - [**Debian**](https://github.com/redis/redis-debian)\n- [**Redis quick start guides**](https://redis.io/docs/latest/develop/get-started/)\n\nIf you prefer to [build Redis from source](#build-redis-from-source) - see instructions below.\n\n### Redis starter projects\n\nTo get started as quickly as possible in your language of choice, use one of the following starter projects:\n\n- [**Python (redis-py)**](https://github.com/redis-developer/redis-starter-python)\n- [**C#/.NET (NRedisStack/StackExchange.Redis)**](https://github.com/redis-developer/redis-starter-csharp)\n- [**Go (go-redis)**](https://github.com/redis-developer/redis-starter-go)\n- [**JavaScript (node-redis)**](https://github.com/redis-developer/redis-starter-js)\n- [**Java/Spring (Jedis)**](https://github.com/redis-developer/redis-starter-java)\n\n### Using Redis with client libraries\n\nTo connect your application to Redis, you will need a client library. Redis has documented client libraries in most popular languages, with community-supported client libraries in additional languages.\n\n- [**Python (redis-py)**](https://redis.io/docs/latest/develop/clients/redis-py/)\n- [**Python (RedisVL)**](https://redis.io/docs/latest/integrate/redisvl/)\n- [**C#/.NET (NRedisStack/StackExchange.Redis)**](https://redis.io/docs/latest/develop/clients/dotnet/)\n- [**JavaScript (node-redis)**](https://redis.io/docs/latest/develop/clients/nodejs/)\n- [**Java (Jedis)**](https://redis.io/docs/latest/develop/clients/jedis/)\n- [**Java (Lettuce)**](https://redis.io/docs/latest/develop/clients/lettuce/)\n- [**Go (go-redis)**](https://redis.io/docs/latest/develop/clients/go/)\n- [**PHP (Predis)**](https://redis.io/docs/latest/develop/clients/php/)\n- [**C (hiredis)**](https://redis.io/docs/latest/develop/clients/hiredis/)\n- [**Full list of client libraries**](https://redis.io/docs/latest/develop/clients/)\n\n### Using Redis with redis-cli\n\n[`redis-cli`](https://redis.io/docs/latest/develop/tools/cli/) is Redis' command line interface. It is available as part of all the binary distributions and when you build Redis from source.\n\nYou can start a redis-server instance, and then, in another terminal try the following:\n\n```sh\ncd src\n./redis-cli\n```\n\n```text\nredis> ping\nPONG\nredis> set foo bar\nOK\nredis> get foo\n\"bar\"\nredis> incr mycounter\n(integer) 1\nredis> incr mycounter\n(integer) 2\nredis>\n```\n\n### Using Redis with Redis Insight\n\nFor a more visual and user-friendly experience, use [Redis Insight](https://redis.io/docs/latest/develop/tools/insight/) - a tool that lets you explore data, design, develop, and optimize your applications while also serving as a platform for Redis education and onboarding. Redis Insight integrates [Redis Copilot](https://redis.io/chat), a natural language AI assistant that improves the experience when working with data and commands.\n\n- [**Redis Insight documentation**](https://redis.io/docs/latest/develop/tools/insight/)\n- [**Redis Insight GitHub repository**](https://github.com/RedisInsight/RedisInsight)\n\n## Redis data types, processing engines, and capabilities\n\nRedis provides a variety of data types, processing engines, and capabilities to support a wide range of use cases:\n\n**Important:** Features marked with an asterisk (\\*) require Redis to be compiled with the `BUILD_WITH_MODULES=yes` flag when [building Redis from source](#build-redis-from-source)\n\n- [**String:**](https://redis.io/docs/latest/develop/data-types/strings) Sequences of bytes, including text, serialized objects, and binary arrays used for caching, counters, and bitwise operations.\n- [**JSON:**](https://redis.io/docs/latest/develop/data-types/json/) Nested JSON documents that are indexed and searchable using JSONPath expressions and with [Redis Query Engine](https://redis.io/docs/latest/develop/interact/search-and-query/)\n- [**Hash:**](https://redis.io/docs/latest/develop/data-types/hashes/) Field-value maps used to represent basic objects and store groupings of key-value pairs with support for [hash field expiration (TTL)](https://redis.io/docs/latest/develop/data-types/hashes/#field-expiration)\n- [**Redis Query Engine:**](https://redis.io/docs/latest/develop/interact/search-and-query/) Use Redis as a document database, a vector database, a secondary index, and a search engine. Define indexes for hash and JSON documents and then use a rich query language for vector search, full-text search, geospatial queries, and aggregations.\n- [**List:**](https://redis.io/docs/latest/develop/data-types/lists/) Linked lists of string values used as stacks, queues, and for queue management.\n- [**Set:**](https://redis.io/docs/latest/develop/data-types/sets/) Unordered collection of unique strings used for tracking unique items, relations, and common set operations (intersections, unions, differences).\n- [**Sorted set:**](https://redis.io/docs/latest/develop/data-types/sorted-sets/) Collection of unique strings ordered by an associated score used for leaderboards and rate limiters.\n- [**Vector set (beta):**](https://redis.io/docs/latest/develop/data-types/vector-sets/) Collection of vector embeddings used for semantic similarity search, semantic caching, semantic routing, and Retrieval Augmented Generation (RAG).\n- [**Geospatial indexes:**](https://redis.io/docs/latest/develop/data-types/geospatial/) Coordinates used for finding nearby points within a given radius or bounding box.\n- [**Bitmap:**](https://redis.io/docs/latest/develop/data-types/bitmaps/) A set of bit-oriented operations defined on the string type used for efficient set representations and object permissions.\n- [**Bitfield:**](https://redis.io/docs/latest/develop/data-types/bitfields/) Binary-encoded strings that let you set, increment, and get integer values of arbitrary bit length used for limited-range counters, numeric values, and multi-level object permissions such as role-based access control (RBAC)\n- [**Hyperloglog:**](https://redis.io/docs/latest/develop/data-types/probabilistic/hyperloglogs/) A probabilistic data structure for approximating the cardinality of a set used for analytics such as counting unique visits, form fills, etc.\n- \\*[**Bloom filter:**](https://redis.io/docs/latest/develop/data-types/probabilistic/bloom-filter/) A probabilistic data structure to check if a given value is present in a set. Used for fraud detection, ad placement, and unique column (i.e. username/email/slug) checks.\n- \\*[**Cuckoo filter:**](https://redis.io/docs/latest/develop/data-types/probabilistic/cuckoo-filter/) A probabilistic data structure for checking if a given value is present in a set while also allowing limited counting and deletions used in targeted advertising and coupon code validation.\n- \\*[**t-digest:**](https://redis.io/docs/latest/develop/data-types/probabilistic/t-digest/) A probabilistic data structure used for estimating the percentile of a large dataset without having to store and order all the data points. Used for hardware/software monitoring, online gaming, network traffic monitoring, and predictive maintenance.\n- \\*[**Top-k:**](https://redis.io/docs/latest/develop/data-types/probabilistic/top-k/) A probabilistic data structure for finding the most frequent values in a data stream used for trend discovery.\n- \\*[**Count-min sketch:**](https://redis.io/docs/latest/develop/data-types/probabilistic/count-min-sketch/) A probabilistic data structure for estimating how many times a given value appears in a data stream used for sales volume calculations.\n- [**Time series:**](https://redis.io/docs/latest/develop/data-types/timeseries/) Data points indexed in time order used for monitoring sensor data, asset\n tracking, and predictive analytics\n- [**Pub/sub**:](https://redis.io/docs/latest/develop/interact/pubsub/) A lightweight messaging capability. Publishers send messages to a channel, and subscribers receive messages from that channel.\n- [**Stream**:](https://redis.io/docs/latest/develop/data-types/streams/) An append-only log with random access capabilities and complex consumption strategies such as consumer groups. Used for event sourcing, sensor monitoring, and notifications.\n- [**Transaction:**](https://redis.io/docs/latest/develop/interact/transactions/) Allows the execution of a group of commands in a single step. A request sent by another client will never be served in the middle of the execution of a transaction. This guarantees that the commands are executed as a single isolated operation.\n- [**Programmability:**](https://redis.io/docs/latest/develop/interact/programmability/eval-intro/) Upload and execute Lua scripts on the server. Scripts can employ programmatic control structures and use most of the commands while executing to access the database. Because scripts are executed on the server, reading and writing data from scripts is very efficient.\n\n## Cloud hosted Redis\n\nFully-managed Redis with real-time performance at scale.\n\n[**Redis Cloud**](https://redis.io/cloud/)\n\n## Community\n\n[**Redis Community Resources**](https://redis.io/community/)\n\n## Build Redis from source\n\nThis section refers to building Redis from source. If you want to get up and running with Redis quickly without needing to build from source see the [Getting started section](#getting-started).\n\n### Build and run Redis with all data structures - Ubuntu 20.04 (Focal)\n\nTested with the following Docker image:\n\n- ubuntu:20.04\n\n1. Install required dependencies\n\n Update your package lists and install the necessary development tools and libraries:\n\n ```sh\n apt-get update\n apt-get install -y sudo\n sudo apt-get install -y --no-install-recommends ca-certificates wget dpkg-dev gcc g++ libc6-dev libssl-dev make git python3 python3-pip python3-venv python3-dev unzip rsync clang automake autoconf gcc-10 g++-10 libtool\n ```\n\n2. Use GCC 10 as the default compiler\n\n Update the system's default compiler to GCC 10:\n\n ```sh\n sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 --slave /usr/bin/g++ g++ /usr/bin/g++-10\n ```\n\n3. Install CMake\n\n Install CMake using `pip3` and link it for system-wide access:\n\n ```sh\n pip3 install cmake==3.31.6\n sudo ln -sf /usr/local/bin/cmake /usr/bin/cmake\n cmake --version\n ```\n\n Note: CMake version 3.31.6 is the latest supported version. Newer versions cannot be used.\n\n4. Download the Redis source\n\n Download a specific version of the Redis source code archive from GitHub.\n\n Replace `` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n5. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n6. Build Redis\n\n Set the necessary environment variables and compile Redis:\n\n ```sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n7. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - Ubuntu 22.04 (Jammy)\n\nTested with the following Docker image:\n\n- ubuntu:22.04\n\n1. Install required dependencies\n\n Update your package lists and install the necessary development tools and libraries:\n\n ```sh\n apt-get update\n apt-get install -y sudo\n sudo apt-get install -y --no-install-recommends ca-certificates wget dpkg-dev gcc g++ libc6-dev libssl-dev make git cmake python3 python3-pip python3-venv python3-dev unzip rsync clang automake autoconf libtool\n ```\n\n2. Install CMake\n\n Install CMake using `pip3` and link it for system-wide access:\n\n ```sh\n pip3 install cmake==3.31.6\n sudo ln -sf /usr/local/bin/cmake /usr/bin/cmake\n cmake --version\n ```\n\n Note: CMake version 3.31.6 is the latest supported version. Newer versions cannot be used.\n\n3. Download the Redis source\n\n Download a specific version of the Redis source code archive from GitHub.\n\n Replace `` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n4. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n5. Build Redis\n\n Set the necessary environment variables and build Redis:\n\n ```sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n6. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - Ubuntu 24.04 (Noble)\n\nTested with the following Docker image:\n\n- ubuntu:24.04\n\n1. Install required dependencies\n\n Update your package lists and install the necessary development tools and libraries:\n\n ```sh\n apt-get update\n apt-get install -y sudo\n sudo apt-get install -y --no-install-recommends ca-certificates wget dpkg-dev gcc g++ libc6-dev libssl-dev make git cmake python3 python3-pip python3-venv python3-dev unzip rsync clang automake autoconf libtool\n ```\n\n2. Download the Redis source\n\n Download a specific version of the Redis source code archive from GitHub.\n\n Replace `` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n3. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n4. Build Redis\n\n Set the necessary environment variables and build Redis:\n\n ```sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n5. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - Debian 11 (Bullseye) / 12 (Bookworm)\n\nTested with the following Docker images:\n\n- debian:bullseye\n- debian:bullseye-slim\n- debian:bookworm\n- debian:bookworm-slim\n\n1. Install required dependencies\n\n Update your package lists and install the necessary development tools and libraries:\n\n ```sh\n apt-get update\n apt-get install -y sudo\n sudo apt-get install -y --no-install-recommends ca-certificates wget dpkg-dev gcc g++ libc6-dev libssl-dev make git cmake python3 python3-pip python3-venv python3-dev unzip rsync clang automake autoconf libtool\n ```\n\n2. Download the Redis source\n\n Download a specific version of the Redis source code archive from GitHub.\n\n Replace `` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n3. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n4. Build Redis\n\n Set the necessary environment variables and build Redis:\n\n ```sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n5. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - AlmaLinux 8.10 / Rocky Linux 8.10\n\nTested with the following Docker images:\n\n- almalinux:8.10\n- almalinux:8.10-minimal\n- rockylinux/rockylinux:8.10\n- rockylinux/rockylinux:8.10-minimal\n\n1. Prepare the system\n\n For 8.10-minimal, install `sudo` and `dnf` as follows:\n\n ```sh\n microdnf install dnf sudo -y\n ```\n\n For 8.10 (regular), install sudo as follows:\n\n ```sh\n dnf install sudo -y\n ```\n\n Clean the package metadata, enable required repositories, and install development tools:\n\n ```sh\n sudo dnf clean all\n sudo tee /etc/yum.repos.d/goreleaser.repo > /dev/null <` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n5. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n6. Build Redis\n\n Enable the GCC toolset, set the necessary environment variables, and build Redis:\n\n ```sh\n source /etc/profile.d/gcc-toolset-13.sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n7. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - AlmaLinux 9.5 / Rocky Linux 9.5\n\nTested with the following Docker images:\n\n- almalinux:9.5\n- almalinux:9.5-minimal\n- rockylinux/rockylinux:9.5\n- rockylinux/rockylinux:9.5-minimal\n\n1. Prepare the system\n\n For 9.5-minimal, install `sudo` and `dnf` as follows:\n\n ```sh\n microdnf install dnf sudo -y\n ```\n\n For 9.5 (regular), install sudo as follows:\n\n ```sh\n dnf install sudo -y\n ```\n\n Clean the package metadata, enable required repositories, and install development tools:\n\n ```sh\n sudo tee /etc/yum.repos.d/goreleaser.repo > /dev/null <` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd /usr/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n5. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd /usr/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n6. Build Redis\n\n Enable the GCC toolset, set the necessary environment variables, and build Redis:\n\n ```sh\n source /etc/profile.d/gcc-toolset-13.sh\n cd /usr/src/redis-\n export BUILD_TLS=yes BUILD_WITH_MODULES=yes INSTALL_RUST_TOOLCHAIN=yes DISABLE_WERRORS=yes\n make -j \"$(nproc)\" all\n ```\n\n7. Run Redis\n\n ```sh\n cd /usr/src/redis-\n ./src/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - macOS 13 (Ventura) and macOS 14 (Sonoma)\n\n1. Install Homebrew\n\n If Homebrew is not already installed, follow the installation instructions on the [Homebrew home page](https://brew.sh/).\n\n2. Install required packages\n\n ```sh\n export HOMEBREW_NO_AUTO_UPDATE=1\n brew update\n brew install coreutils\n brew install make\n brew install openssl\n brew install llvm@18\n brew install cmake\n brew install gnu-sed\n brew install automake\n brew install libtool\n brew install wget\n ```\n\n3. Install Rust\n\n Rust is required to build the JSON package.\n\n ```sh\n RUST_INSTALLER=rust-1.80.1-$(if [ \"$(uname -m)\" = \"arm64\" ]; then echo \"aarch64\"; else echo \"x86_64\"; fi)-apple-darwin\n wget --quiet -O ${RUST_INSTALLER}.tar.xz https://static.rust-lang.org/dist/${RUST_INSTALLER}.tar.xz\n tar -xf ${RUST_INSTALLER}.tar.xz\n (cd ${RUST_INSTALLER} && sudo ./install.sh)\n ```\n\n4. Download the Redis source\n\n Download a specific version of the Redis source code archive from GitHub.\n\n Replace `` with the Redis version, for example: `8.0.0`.\n\n ```sh\n cd ~/src\n wget -O redis-.tar.gz https://github.com/redis/redis/archive/refs/tags/.tar.gz\n ```\n\n5. Extract the source archive\n\n Create a directory for the source code and extract the contents into it:\n\n ```sh\n cd ~/src\n tar xvf redis-.tar.gz\n rm redis-.tar.gz\n ```\n\n6. Build Redis\n\n ```sh\n cd ~/src/redis-\n export HOMEBREW_PREFIX=\"$(brew --prefix)\"\n export BUILD_WITH_MODULES=yes\n export BUILD_TLS=yes\n export DISABLE_WERRORS=yes\n PATH=\"$HOMEBREW_PREFIX/opt/libtool/libexec/gnubin:$HOMEBREW_PREFIX/opt/llvm@18/bin:$HOMEBREW_PREFIX/opt/make/libexec/gnubin:$HOMEBREW_PREFIX/opt/gnu-sed/libexec/gnubin:$HOMEBREW_PREFIX/opt/coreutils/libexec/gnubin:$PATH\"\n export LDFLAGS=\"-L$HOMEBREW_PREFIX/opt/llvm@18/lib\"\n export CPPFLAGS=\"-I$HOMEBREW_PREFIX/opt/llvm@18/include\"\n mkdir -p build_dir/etc\n make -C redis-8.0 -j \"$(nproc)\" all OS=macos\n make -C redis-8.0 install PREFIX=$(pwd)/build_dir OS=macos\n ```\n\n7. Run Redis\n\n ```sh\n export LC_ALL=en_US.UTF-8\n export LANG=en_US.UTF-8\n build_dir/bin/redis-server redis-full.conf\n ```\n\n### Build and run Redis with all data structures - macOS 15 (Sequoia)\n\nSupport and instructions will be provided at a later date.\n\n### Building Redis - flags and general notes\n\nRedis can be compiled and used on Linux, OSX, OpenBSD, NetBSD, FreeBSD.\nWe support big endian and little endian architectures, and both 32 bit and 64-bit systems.\n\nIt may compile on Solaris derived systems (for instance SmartOS) but our support for this platform is _best effort_ and Redis is not guaranteed to work as well as on Linux, OSX, and \\*BSD.\n\nTo build Redis with all the data structures (including JSON, time series, Bloom filter, cuckoo filter, count-min sketch, top-k, and t-digest) and with Redis Query Engine, make sure first that all the prerequisites are installed (see build instructions above, per operating system). You need to use the following flag in the make command:\n\n```sh\nmake BUILD_WITH_MODULES=yes\n```\n\nNote: `BUILD_WITH_MODULES=yes` is not supported on 32 bit systems.\n\nTo build Redis with just the core data structures, use:\n\n```sh\nmake\n```\n\nTo build with TLS support, you need OpenSSL development libraries (e.g. libssl-dev on Debian/Ubuntu) and the following flag in the make command:\n\n```sh\nmake BUILD_TLS=yes\n```\n\nTo build with systemd support, you need systemd development libraries (such as libsystemd-dev on Debian/Ubuntu or systemd-devel on CentOS), and the following flag:\n\n```sh\nmake USE_SYSTEMD=yes\n```\n\nTo append a suffix to Redis program names, add the following flag:\n\n```sh\nmake PROG_SUFFIX=\"-alt\"\n```\n\nYou can build a 32 bit Redis binary using:\n\n```sh\nmake 32bit\n```\n\nAfter building Redis, it is a good idea to test it using:\n\n```sh\nmake test\n```\n\nIf TLS is built, running the tests with TLS enabled (you will need `tcl-tls` installed):\n\n```sh\n./utils/gen-test-certs.sh\n./runtest --tls\n```\n\n### Fixing build problems with dependencies or cached build options\n\nRedis 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.\n\nWhen 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:\n\n```sh\nmake distclean\n```\n\nThis will clean: jemalloc, lua, hiredis, linenoise and other dependencies.\n\nAlso, 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`\ncommand.\n\n### Fixing problems building 32 bit binaries\n\nIf after building Redis with a 32 bit target you need to rebuild it\nwith a 64 bit target, or the other way around, you need to perform a `make distclean` in the root directory of the Redis distribution.\n\nIn case of build errors when trying to build a 32 bit binary of Redis, try the following steps:\n\n- Install the package libc6-dev-i386 (also try g++-multilib).\n- Try using the following command line instead of `make 32bit`:\n `make CFLAGS=\"-m32 -march=native\" LDFLAGS=\"-m32\"`\n\n### Allocator\n\nSelecting a non-default memory allocator when building Redis is done by setting the `MALLOC` environment variable. Redis is compiled and linked against libc malloc by default, except for jemalloc being the default on Linux systems. This default was picked because jemalloc has proven to have fewer fragmentation problems than libc malloc.\n\nTo force compiling against libc malloc, use:\n\n```sh\nmake MALLOC=libc\n```\n\nTo compile against jemalloc on Mac OS X systems, use:\n\n```sh\nmake MALLOC=jemalloc\n```\n\n### Monotonic clock\n\nBy default, Redis 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/\n\nOn ARM aarch64 systems, the hardware clock is enabled by default because the ARM Generic Timer is architecturally guaranteed to be available and monotonic on all ARMv8-A processors (see the *“The Generic Timer in AArch64 state”* section of the *Arm Architecture Reference Manual for Armv8-A*).\n\nTo build with support for the processor's internal instruction clock on other architectures, use:\n\n```sh\nmake CFLAGS=\"-DUSE_PROCESSOR_CLOCK\"\n```\n\n### Verbose build\n\nRedis will build with a user-friendly colorized output by default.\nIf you want to see a more verbose output, use the following:\n\n```sh\nmake V=1\n```\n\n### Running Redis with TLS\n\nPlease consult the [TLS.md](TLS.md) file for more information on how to use Redis with TLS.\n\n### Running Redis with the Query Engine and optional proprietary Intel SVS-VAMANA optimisations\n\n**License Disclaimer**\nIf you are using Redis Open Source under AGPLv3 or SSPLv1, you cannot use it together with the Intel Optimizations (Leanvec and LVQ binaries). The reason is that the Intel SVS license is not compatible with those licenses.\nThe Leanvec and LVQ techniques are closed source and are only available for use with Redis Open Source when distributed under the RSALv2 license.\nFor more details, please refer to the information provided by Intel [here](https://github.com/intel/ScalableVectorSearch).\n\nBy default, Redis with the Redis Query Engine supports SVS-VAMANA index with global 8-bit quantisation. To compile Redis with the Intel SVS-VAMANA optimisations, LeanVec and LVQ, use the following:\n\n```sh\nmake BUILD_INTEL_SVS_OPT=yes\n```\n\nAlternatively, you can export the variable before running the build step for your platform:\n\n```sh\nexport BUILD_INTEL_SVS_OPT=yes\nmake\n```\n\n\n## Code contributions\n\nBy contributing code to the Redis 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 Redis Software Grant and Contributor License Agreement. Please see the CONTRIBUTING.md file in this source distribution for more information. For security bugs and vulnerabilities, please see SECURITY.md and the description of the ability of users to backport security patches under Redis Open Source 7.4+ under BSDv3. Open Source Redis releases are subject to the following licenses:\n\n1. Version 7.2.x and prior releases are subject to BSDv3. These contributions to the original Redis core project are owned by their contributors and licensed under the 3BSDv3 license as referenced in the REDISCONTRIBUTIONS.txt file. Any copy of that license in this repository applies only to those contributions;\n\n2. Versions 7.4.x to 7.8.x are subject to your choice of RSALv2 or SSPLv1; and\n\n3. Version 8.0.x and subsequent releases are subject to the tri-license RSALv2/SSPLv1/AGPLv3 at your option as referenced in the LICENSE.txt file.\n\n## Redis Trademarks\n\nThe purpose of a trademark is to identify the goods and services of a person or company without causing confusion. As the registered owner of its name and logo, Redis accepts certain limited uses of its trademarks, but it has requirements that must be followed as described in its Trademark Guidelines available at: https://redis.io/legal/trademark-policy/.\n" }, { "path": "REDISCONTRIBUTIONS.txt", "content": "Copyright (c) 2006-Present, Redis Ltd. and Contributors\nAll rights reserved.\n\nNote: Continued Applicability of the BSD-3-Clause License\n\nDespite the shift to the dual-licensing model with version 7.4 (RSALv2 or SSPLv1) and\nthe shift to a tri-license option with version 8.0 (RSALv2/SSPLv1/AGPLv3), portions of\nRedis Open Source remain available subject to the BSD-3-Clause License (BSD).\nSee below for the full BSD license:\n\nRedistribution and use in source and binary forms, with or without modification, are permitted\nprovided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions\nand the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions\nand the following disclaimer in the documentation and/or other materials provided with the\ndistribution.\n\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse\nor promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR\nIMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\nCONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER\nIN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\nTHE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "SECURITY.md", "content": "# Security Policy\n\n## Supported Versions\n\nRedis is generally backward compatible with very few exceptions, so we\nrecommend users to always use the latest version to experience stability,\nperformance and security.\n\nWe generally backport security issues to a single previous major version,\nunless this is not possible or feasible with a reasonable effort.\n\n| Version | Supported |\n|---------|------------------------------------------------------------------------|\n| 8.6.x | :white_check_mark: |\n| 8.4.x | :white_check_mark: |\n| 8.2.x | :white_check_mark: |\n| 8.0.x | :x: |\n| 7.4.x | :white_check_mark: |\n| 7.2.x | :white_check_mark: support extended till 7.4 end of support |\n| < 7.2.x | :x: |\n| 6.2.x | :white_check_mark: support extended |\n| < 6.2.x | :x: |\n\n## Reporting a Vulnerability\n\nIf you believe you have found a security vulnerability, to ensure proper review \nand assessment, we kindly ask vulnerability reports be submitted through\nour [Redis Vulnerability Disclosure Program.](https://redis.io/redis-responsible-vulnerability-disclosure/)\n\nWe have found this path to be beneficial for both researchers and us for \na number of reasons. Including, offering fast response times to researchers and \nopportunities for us to invite those with exceptional reports into closed paid \nengagements. \n\nFor those averse to using our chosen platform, we will also accept reports directly\nvia GitHub's \"Report a Vulnerability\". \n\nTo contact the security team directly with questions use: [security@redis.com](mailto:security@redis.com)\n\n\n## Responsible Disclosure\n\nIn some cases, we may apply a responsible disclosure process to reported or\notherwise discovered vulnerabilities. We will usually do that for a critical\nvulnerability, and only if we have a good reason to believe information about\nit is not yet public.\n\nThis process involves providing an early notification about the vulnerability,\nits impact and mitigations to a short list of vendors under a time-limited\nembargo on public disclosure.\n\nIf you believe you should be on the list, please contact us and we will\nconsider your request based on the above criteria.\n\n## Support across Operating Systems, Architectures, and Compilers\n\nRedis is primarily tested on modern Linux distributions, using contemporary\nIntel and AMD x86_64 CPUs, as well as ARM-based CPUs, and recent versions of\nthe GCC compiler.\nVulnerability reports that rely on unsupported or uncommon environments\n(for example, 32-bit architectures, non-Linux operating systems, or outdated\ntoolchains) may be considered out of scope, even if the issue is technically\nvalid. Such reports will be evaluated on a case-by-case basis at our discretion.\n\n## License Compatibility\n\nFor security vulnerability patches released under Redis Open Source 7.4 and \nthereafter, Redis permits users of earlier versions (7.2 and prior) to access \npatches under the BSD3 license noted in REDISCONTRIBUTIONS.txt instead of the \nfull license requirements described in LICENSE.txt. Security fixes are tested \nonly against the specific versions for which they are provided. Applicability \nor portability to other versions or forks has not been evaluated.\n" }, { "path": "TLS.md", "content": "TLS Support\n===========\n\nGetting Started\n---------------\n\n### Building\n\nTo build with TLS support you'll need OpenSSL development libraries (e.g.\nlibssl-dev on Debian/Ubuntu).\n\nTo build TLS support as Redis built-in:\nRun `make BUILD_TLS=yes`.\n\nOr to build TLS as Redis module:\nRun `make BUILD_TLS=module`.\n\nNote that sentinel mode does not support TLS module.\n\n### Tests\n\nTo run Redis test suite with TLS, you'll need TLS support for TCL (i.e.\n`tcl-tls` package on Debian/Ubuntu).\n\n1. Run `./utils/gen-test-certs.sh` to generate a root CA and a server\n certificate.\n\n2. Run `./runtest --tls` or `./runtest-cluster --tls` to run Redis and Redis\n Cluster tests in TLS mode.\n\n3. Run `./runtest --tls-module` or `./runtest-cluster --tls-module` to\n run Redis and Redis cluster tests in TLS mode with Redis module.\n\n### Running manually\n\nTo manually run a Redis server with TLS mode (assuming `gen-test-certs.sh` was\ninvoked so sample certificates/keys are available):\n\nFor TLS built-in mode:\n ./src/redis-server --tls-port 6379 --port 0 \\\n --tls-cert-file ./tests/tls/redis.crt \\\n --tls-key-file ./tests/tls/redis.key \\\n --tls-ca-cert-file ./tests/tls/ca.crt\n\nFor TLS module mode:\n ./src/redis-server --tls-port 6379 --port 0 \\\n --tls-cert-file ./tests/tls/redis.crt \\\n --tls-key-file ./tests/tls/redis.key \\\n --tls-ca-cert-file ./tests/tls/ca.crt \\\n --loadmodule src/redis-tls.so\n\nTo connect to this Redis server with `redis-cli`:\n\n ./src/redis-cli --tls \\\n --cert ./tests/tls/redis.crt \\\n --key ./tests/tls/redis.key \\\n --cacert ./tests/tls/ca.crt\n\nThis will disable TCP and enable TLS on port 6379. It's also possible to have\nboth TCP and TLS available, but you'll need to assign different ports.\n\nTo make a Replica connect to the master using TLS, use `--tls-replication yes`,\nand to make Redis Cluster use TLS across nodes use `--tls-cluster yes`.\n\nConnections\n-----------\n\nAll socket operations now go through a connection abstraction layer that hides\nI/O and read/write event handling from the caller.\n\n**Multi-threading I/O is not currently supported for TLS**, as a TLS connection\nneeds to do its own manipulation of AE events which is not thread safe. The\nsolution is probably to manage independent AE loops for I/O threads and longer\nterm association of connections with threads. This may potentially improve\noverall performance as well.\n\nSync IO for TLS is currently implemented in a hackish way, i.e. making the\nsocket blocking and configuring socket-level timeout. This means the timeout\nvalue may not be so accurate, and there would be a lot of syscall overhead.\nHowever I believe that getting rid of syncio completely in favor of pure async\nwork is probably a better move than trying to fix that. For replication it would\nprobably not be so hard. For cluster keys migration it might be more difficult,\nbut there are probably other good reasons to improve that part anyway.\n\nTo-Do List\n----------\n\n- [ ] redis-benchmark support. The current implementation is a mix of using\n hiredis for parsing and basic networking (establishing connections), but\n directly manipulating sockets for most actions. This will need to be cleaned\n up for proper TLS support. The best approach is probably to migrate to hiredis\n async mode.\n- [ ] redis-cli `--slave` and `--rdb` support.\n\nMulti-port\n----------\n\nConsider the implications of allowing TLS to be configured on a separate port,\nmaking Redis listening on multiple ports:\n\n1. Startup banner port notification\n2. Proctitle\n3. How slaves announce themselves\n4. Cluster bus port calculation\n" }, { "path": "codecov.yml", "content": "coverage:\n status:\n patch:\n default:\n informational: true\n project:\n default:\n informational: true\n\ncomment:\n require_changes: false\n require_head: false\n require_base: false\n layout: \"condensed_header, diff, files\"\n hide_project_coverage: false\n behavior: default\n\ngithub_checks:\n annotations: false\n" }, { "path": "deps/Makefile", "content": "# Redis dependency Makefile\n\nuname_S:= $(shell sh -c 'uname -s 2>/dev/null || echo not')\n\nLUA_DEBUG?=no\nLUA_COVERAGE?=no\n\nCCCOLOR=\"\\033[34m\"\nLINKCOLOR=\"\\033[34;1m\"\nSRCCOLOR=\"\\033[33m\"\nBINCOLOR=\"\\033[37;1m\"\nMAKECOLOR=\"\\033[32;1m\"\nENDCOLOR=\"\\033[0m\"\n\nDEPS_CFLAGS := $(CFLAGS)\nDEPS_LDFLAGS := $(LDFLAGS)\nCLANG := $(findstring clang,$(shell sh -c '$(CC) --version | head -1'))\n\n# MSan looks for errors related to uninitialized memory.\n# Make sure to build the dependencies with MSan as it needs all the code to be instrumented.\n# A library could be used to initialize memory but if it's not build with --fsanitize=memory then\n# MSan doesn't know about it and will spit false positive error when that memory is then used.\nifeq ($(SANITIZER),memory)\nifeq (clang, $(CLANG))\n\tDEPS_CFLAGS+=-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-sanitize-recover=all -fno-omit-frame-pointer\n\tDEPS_LDFLAGS+=-fsanitize=memory\nelse\n $(error \"MemorySanitizer needs to be compiled and linked with clang. Please use CC=clang\")\nendif\nendif\n\ndefault:\n\t@echo \"Explicit target required\"\n\n.PHONY: default\n\n# Prerequisites target\n.make-prerequisites:\n\t@touch $@\n\n# Clean everything when CFLAGS is different\nifneq ($(shell sh -c '[ -f .make-cflags ] && cat .make-cflags || echo none'), $(CFLAGS))\n.make-cflags: distclean\n\t-(echo \"$(CFLAGS)\" > .make-cflags)\n.make-prerequisites: .make-cflags\nendif\n\n# Clean everything when LDFLAGS is different\nifneq ($(shell sh -c '[ -f .make-ldflags ] && cat .make-ldflags || echo none'), $(LDFLAGS))\n.make-ldflags: distclean\n\t-(echo \"$(LDFLAGS)\" > .make-ldflags)\n.make-prerequisites: .make-ldflags\nendif\n\ndistclean:\n\t-(cd hiredis && $(MAKE) clean) > /dev/null || true\n\t-(cd linenoise && $(MAKE) clean) > /dev/null || true\n\t-(cd lua && $(MAKE) clean) > /dev/null || true\n\t-(cd jemalloc && [ -f Makefile ] && $(MAKE) distclean) > /dev/null || true\n\t-(cd hdr_histogram && $(MAKE) clean) > /dev/null || true\n\t-(cd fpconv && $(MAKE) clean) > /dev/null || true\n\t-(cd xxhash && $(MAKE) clean) > /dev/null || true\n\t-(rm -f .make-*)\n\n.PHONY: distclean\n\nifneq (,$(filter $(BUILD_TLS),yes module))\n HIREDIS_MAKE_FLAGS = USE_SSL=1\nendif\n\n# Special care is needed to pass additional CFLAGS/LDFLAGS to hiredis as it\n# modifies these variables in its Makefile.\nhiredis: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd hiredis && $(MAKE) static $(HIREDIS_MAKE_FLAGS) HIREDIS_CFLAGS=\"$(DEPS_CFLAGS)\" HIREDIS_LDFLAGS=\"$(DEPS_LDFLAGS)\"\n\n.PHONY: hiredis\n\nlinenoise: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd linenoise && $(MAKE) CFLAGS=\"$(DEPS_CFLAGS)\" LDFLAGS=\"$(DEPS_LDFLAGS)\"\n\n.PHONY: linenoise\n\nhdr_histogram: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd hdr_histogram && $(MAKE) CFLAGS=\"$(DEPS_CFLAGS)\" LDFLAGS=\"$(DEPS_LDFLAGS)\"\n\n.PHONY: hdr_histogram\n\nfpconv: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd fpconv && $(MAKE) CFLAGS=\"$(DEPS_CFLAGS)\" LDFLAGS=\"$(DEPS_LDFLAGS)\"\n\n.PHONY: fpconv\n\nXXHASH_CFLAGS = -fPIC $(DEPS_CFLAGS)\nxxhash: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd xxhash && $(MAKE) lib CFLAGS=\"$(XXHASH_CFLAGS)\" LDFLAGS=\"$(DEPS_LDFLAGS)\"\n.PHONY: xxhash\n\nifeq ($(uname_S),SunOS)\n\t# Make isinf() available\n\tLUA_CFLAGS= -D__C99FEATURES__=1\nendif\n\nLUA_CFLAGS+= -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC='' -DLUA_USE_MKSTEMP $(DEPS_CFLAGS)\nLUA_LDFLAGS+= $(DEPS_LDFLAGS)\nifeq ($(LUA_DEBUG),yes)\n\tLUA_CFLAGS+= -O0 -g -DLUA_USE_APICHECK\nelse\n\tLUA_CFLAGS+= -O2 \nendif\nifeq ($(LUA_COVERAGE),yes)\n\tLUA_CFLAGS += -fprofile-arcs -ftest-coverage\n\tLUA_LDFLAGS += -fprofile-arcs -ftest-coverage\nendif\n\n# lua's Makefile defines AR=\"ar rcu\", which is unusual, and makes it more\n# challenging to cross-compile lua (and redis). These defines make it easier\n# to fit redis into cross-compilation environments, which typically set AR.\nAR=ar\nARFLAGS=rc\n\nlua: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd lua/src && $(MAKE) all CFLAGS=\"$(LUA_CFLAGS)\" MYLDFLAGS=\"$(LUA_LDFLAGS)\" AR=\"$(AR) $(ARFLAGS)\"\n\n.PHONY: lua\n\nJEMALLOC_CFLAGS=$(CFLAGS)\nJEMALLOC_LDFLAGS=$(LDFLAGS)\n\nifneq ($(DEB_HOST_GNU_TYPE),)\nJEMALLOC_CONFIGURE_OPTS += --host=$(DEB_HOST_GNU_TYPE)\nendif\n\njemalloc: .make-prerequisites\n\t@printf '%b %b\\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)\n\tcd jemalloc && ./configure --disable-cxx --with-version=5.3.0-0-g0 --with-lg-quantum=3 --disable-cache-oblivious --with-jemalloc-prefix=je_ CFLAGS=\"$(JEMALLOC_CFLAGS)\" LDFLAGS=\"$(JEMALLOC_LDFLAGS)\" $(JEMALLOC_CONFIGURE_OPTS)\n\tcd jemalloc && $(MAKE) lib/libjemalloc.a\n\n.PHONY: jemalloc\n" }, { "path": "deps/README.md", "content": "This directory contains all Redis dependencies, except for the libc that\nshould be provided by the operating system.\n\n* **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.\n* **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.\n* **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.\n* **lua** is Lua 5.1 with minor changes for security and additional libraries.\n* **hdr_histogram** Used for per-command latency tracking histograms.\n\nHow to upgrade the above dependencies\n===\n\nJemalloc\n---\n\nJemalloc is modified with changes that allow us to implement the Redis\nactive defragmentation logic. However this feature of Redis is not mandatory\nand Redis is able to understand if the Jemalloc version it is compiled\nagainst supports such Redis-specific modifications. So in theory, if you\nare not interested in the active defragmentation, you can replace Jemalloc\njust following these steps:\n\n1. Remove the jemalloc directory.\n2. Substitute it with the new jemalloc source tree.\n3. Edit the Makefile located in the same directory as the README you are\n reading, and change the --with-version in the Jemalloc configure script\n options with the version you are using. This is required because otherwise\n Jemalloc configuration script is broken and will not work nested in another\n git repository.\n\nHowever 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.\n\nIf you want to upgrade Jemalloc while also providing support for\nactive defragmentation, in addition to the above steps you need to perform\nthe following additional steps:\n\n5. In Jemalloc tree, file `include/jemalloc/jemalloc_macros.h.in`, make sure\n to add `#define JEMALLOC_FRAG_HINT`.\n6. Implement the function `je_get_defrag_hint()` inside `src/jemalloc.c`. You\n can see how it is implemented in the current Jemalloc source tree shipped\n with Redis, and rewrite it according to the new Jemalloc internals, if they\n changed, otherwise you could just copy the old implementation if you are\n upgrading just to a similar version of Jemalloc.\n\n#### Updating/upgrading jemalloc\n\nThe jemalloc directory is pulled as a subtree from the upstream jemalloc github repo. To update it you should run from the project root:\n\n1. `git subtree pull --prefix deps/jemalloc https://github.com/jemalloc/jemalloc.git --squash`
\nThis should hopefully merge the local changes into the new version.\n2. In case any conflicts arise (due to our changes) you'll need to resolve them and commit.\n3. Reconfigure jemalloc:
\n```sh\nrm deps/jemalloc/VERSION deps/jemalloc/configure\ncd deps/jemalloc\n./autogen.sh --with-version=-0-g0\n```\n4. Update jemalloc's version in `deps/Makefile`: search for \"`--with-version=-0-g0`\" and update it accordingly.\n5. Commit the changes (VERSION,configure,Makefile).\n\nHiredis\n---\n\nHiredis is used by Sentinel, `redis-cli` and `redis-benchmark`. Like Redis, uses the SDS string library, but not necessarily the same version. In order to avoid conflicts, this version has all SDS identifiers prefixed by `hi`.\n\n1. `git subtree pull --prefix deps/hiredis https://github.com/redis/hiredis.git --squash`
\nThis should hopefully merge the local changes into the new version.\n2. Conflicts will arise (due to our changes) you'll need to resolve them and commit.\n\nLinenoise\n---\n\nLinenoise is rarely upgraded as needed. The upgrade process is trivial since\nRedis uses a non modified version of linenoise, so to upgrade just do the\nfollowing:\n\n1. Remove the linenoise directory.\n2. Substitute it with the new linenoise source tree.\n\nLua\n---\n\nWe use Lua 5.1 and no upgrade is planned currently, since we don't want to break\nLua scripts for new Lua features: in the context of Redis Lua scripts the\ncapabilities of 5.1 are usually more than enough, the release is rock solid,\nand we definitely don't want to break old scripts.\n\nSo upgrading of Lua is up to the Redis project maintainers and should be a\nmanual procedure performed by taking a diff between the different versions.\n\nCurrently we have at least the following differences between official Lua 5.1\nand our version:\n\n1. Makefile is modified to allow a different compiler than GCC.\n2. 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`.\n3. 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.\n\nHdr_Histogram\n---\n\nUpdated source can be found here: https://github.com/HdrHistogram/HdrHistogram_c\nWe use a customized version based on master branch commit e4448cf6d1cd08fff519812d3b1e58bd5a94ac42.\n1. Compare all changes under /hdr_histogram directory to upstream master commit e4448cf6d1cd08fff519812d3b1e58bd5a94ac42\n2. Copy updated files from newer version onto files in /hdr_histogram.\n3. Apply the changes from 1 above to the updated files.\n\n" }, { "path": "deps/fpconv/LICENSE.txt", "content": "Boost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n" }, { "path": "deps/fpconv/Makefile", "content": "STD=\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS)\nR_LDFLAGS= $(LDFLAGS)\nDEBUG= -g\n\nR_CC=$(CC) $(R_CFLAGS)\nR_LD=$(CC) $(R_LDFLAGS)\n\nAR= ar\nARFLAGS= rcs\n\nlibfpconv.a: fpconv_dtoa.o\n\t$(AR) $(ARFLAGS) $@ $+\n\nfpconv_dtoa.o: fpconv_dtoa.h fpconv_dtoa.c\n\n.c.o:\n\t$(R_CC) -c $< \n\nclean:\n\trm -f *.o\n\trm -f *.a\n\n\n" }, { "path": "deps/fpconv/README.md", "content": "libfpconv\n\n----------------------------------------------\n\nFast and accurate double to string conversion based on Florian Loitsch's Grisu-algorithm[1].\n\nThis port contains a subset of the 'C' version of Fast and accurate double to string conversion based on Florian Loitsch's Grisu-algorithm available at [github.com/night-shift/fpconv](https://github.com/night-shift/fpconv)).\n\n[1] https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf\n" }, { "path": "deps/fpconv/fpconv_dtoa.c", "content": "/* fpconv_dtoa.c -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on Florian Loitsch's\n * Grisu-algorithm[1].\n *\n * [1] https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf\n * ----------------------------------------------------------------------------\n *\n * Copyright (c) 2013-2019, night-shift \n * Copyright (c) 2009, Florian Loitsch < florian.loitsch at inria dot fr >\n * All rights reserved.\n *\n * Boost Software License - Version 1.0 - August 17th, 2003\n *\n * Permission is hereby granted, free of charge, to any person or organization\n * obtaining a copy of the software and accompanying documentation covered by\n * this license (the \"Software\") to use, reproduce, display, distribute,\n * execute, and transmit the Software, and to prepare derivative works of the\n * Software, and to permit third-parties to whom the Software is furnished to\n * do so, all subject to the following:\n *\n * The copyright notices in the Software and this entire statement, including\n * the above license grant, this restriction and the following disclaimer,\n * must be included in all copies of the Software, in whole or in part, and\n * all derivative works of the Software, unless such copies or derivative\n * works are solely in the form of machine-executable object code generated by\n * a source language processor.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\n * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\n * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n#include \"fpconv_dtoa.h\"\n\n#include \"fpconv_powers.h\"\n\n#include \n#include \n\n#define fracmask 0x000FFFFFFFFFFFFFU\n#define expmask 0x7FF0000000000000U\n#define hiddenbit 0x0010000000000000U\n#define signmask 0x8000000000000000U\n#define expbias (1023 + 52)\n\n#define absv(n) ((n) < 0 ? -(n) : (n))\n#define minv(a, b) ((a) < (b) ? (a) : (b))\n\nstatic uint64_t tens[] = { 10000000000000000000U,\n 1000000000000000000U,\n 100000000000000000U,\n 10000000000000000U,\n 1000000000000000U,\n 100000000000000U,\n 10000000000000U,\n 1000000000000U,\n 100000000000U,\n 10000000000U,\n 1000000000U,\n 100000000U,\n 10000000U,\n 1000000U,\n 100000U,\n 10000U,\n 1000U,\n 100U,\n 10U,\n 1U };\n\nstatic inline uint64_t get_dbits(double d) {\n union\n {\n double dbl;\n uint64_t i;\n } dbl_bits = { d };\n\n return dbl_bits.i;\n}\n\nstatic Fp build_fp(double d) {\n uint64_t bits = get_dbits(d);\n\n Fp fp;\n fp.frac = bits & fracmask;\n fp.exp = (bits & expmask) >> 52;\n\n if (fp.exp) {\n fp.frac += hiddenbit;\n fp.exp -= expbias;\n\n } else {\n fp.exp = -expbias + 1;\n }\n\n return fp;\n}\n\nstatic void normalize(Fp *fp) {\n while ((fp->frac & hiddenbit) == 0) {\n fp->frac <<= 1;\n fp->exp--;\n }\n\n int shift = 64 - 52 - 1;\n fp->frac <<= shift;\n fp->exp -= shift;\n}\n\nstatic void get_normalized_boundaries(Fp *fp, Fp *lower, Fp *upper) {\n upper->frac = (fp->frac << 1) + 1;\n upper->exp = fp->exp - 1;\n\n while ((upper->frac & (hiddenbit << 1)) == 0) {\n upper->frac <<= 1;\n upper->exp--;\n }\n\n int u_shift = 64 - 52 - 2;\n\n upper->frac <<= u_shift;\n upper->exp = upper->exp - u_shift;\n\n int l_shift = fp->frac == hiddenbit ? 2 : 1;\n\n lower->frac = (fp->frac << l_shift) - 1;\n lower->exp = fp->exp - l_shift;\n\n lower->frac <<= lower->exp - upper->exp;\n lower->exp = upper->exp;\n}\n\nstatic Fp multiply(Fp *a, Fp *b) {\n const uint64_t lomask = 0x00000000FFFFFFFF;\n\n uint64_t ah_bl = (a->frac >> 32) * (b->frac & lomask);\n uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);\n uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);\n uint64_t ah_bh = (a->frac >> 32) * (b->frac >> 32);\n\n uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);\n /* round up */\n tmp += 1U << 31;\n\n Fp fp = { ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32), a->exp + b->exp + 64 };\n\n return fp;\n}\n\nstatic void round_digit(char *digits,\n int ndigits,\n uint64_t delta,\n uint64_t rem,\n uint64_t kappa,\n uint64_t frac) {\n while (rem < frac && delta - rem >= kappa &&\n (rem + kappa < frac || frac - rem > rem + kappa - frac)) {\n digits[ndigits - 1]--;\n rem += kappa;\n }\n}\n\nstatic int generate_digits(Fp *fp, Fp *upper, Fp *lower, char *digits, int *K) {\n uint64_t wfrac = upper->frac - fp->frac;\n uint64_t delta = upper->frac - lower->frac;\n\n Fp one;\n one.frac = 1ULL << -upper->exp;\n one.exp = upper->exp;\n\n uint64_t part1 = upper->frac >> -one.exp;\n uint64_t part2 = upper->frac & (one.frac - 1);\n\n int idx = 0, kappa = 10;\n uint64_t *divp;\n /* 1000000000 */\n for (divp = tens + 10; kappa > 0; divp++) {\n uint64_t div = *divp;\n unsigned digit = part1 / div;\n\n if (digit || idx) {\n digits[idx++] = digit + '0';\n }\n\n part1 -= digit * div;\n kappa--;\n\n uint64_t tmp = (part1 << -one.exp) + part2;\n if (tmp <= delta) {\n *K += kappa;\n round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac);\n\n return idx;\n }\n }\n\n /* 10 */\n uint64_t *unit = tens + 18;\n\n while (true) {\n part2 *= 10;\n delta *= 10;\n kappa--;\n\n unsigned digit = part2 >> -one.exp;\n if (digit || idx) {\n digits[idx++] = digit + '0';\n }\n\n part2 &= one.frac - 1;\n if (part2 < delta) {\n *K += kappa;\n round_digit(digits, idx, delta, part2, one.frac, wfrac * *unit);\n\n return idx;\n }\n\n unit--;\n }\n}\n\nstatic int grisu2(double d, char *digits, int *K) {\n Fp w = build_fp(d);\n\n Fp lower, upper;\n get_normalized_boundaries(&w, &lower, &upper);\n\n normalize(&w);\n\n int k;\n Fp cp = find_cachedpow10(upper.exp, &k);\n\n w = multiply(&w, &cp);\n upper = multiply(&upper, &cp);\n lower = multiply(&lower, &cp);\n\n lower.frac++;\n upper.frac--;\n\n *K = -k;\n\n return generate_digits(&w, &upper, &lower, digits, K);\n}\n\nstatic int emit_digits(char *digits, int ndigits, char *dest, int K, bool neg) {\n int exp = absv(K + ndigits - 1);\n\n /* write plain integer */\n if (K >= 0 && (exp < (ndigits + 7))) {\n memcpy(dest, digits, ndigits);\n memset(dest + ndigits, '0', K);\n\n return ndigits + K;\n }\n\n /* write decimal w/o scientific notation */\n if (K < 0 && (K > -7 || exp < 4)) {\n int offset = ndigits - absv(K);\n /* fp < 1.0 -> write leading zero */\n if (offset <= 0) {\n offset = -offset;\n dest[0] = '0';\n dest[1] = '.';\n memset(dest + 2, '0', offset);\n memcpy(dest + offset + 2, digits, ndigits);\n\n return ndigits + 2 + offset;\n\n /* fp > 1.0 */\n } else {\n memcpy(dest, digits, offset);\n dest[offset] = '.';\n memcpy(dest + offset + 1, digits + offset, ndigits - offset);\n\n return ndigits + 1;\n }\n }\n\n /* write decimal w/ scientific notation */\n ndigits = minv(ndigits, 18 - neg);\n\n int idx = 0;\n dest[idx++] = digits[0];\n\n if (ndigits > 1) {\n dest[idx++] = '.';\n memcpy(dest + idx, digits + 1, ndigits - 1);\n idx += ndigits - 1;\n }\n\n dest[idx++] = 'e';\n\n char sign = K + ndigits - 1 < 0 ? '-' : '+';\n dest[idx++] = sign;\n\n int cent = 0;\n\n if (exp > 99) {\n cent = exp / 100;\n dest[idx++] = cent + '0';\n exp -= cent * 100;\n }\n if (exp > 9) {\n int dec = exp / 10;\n dest[idx++] = dec + '0';\n exp -= dec * 10;\n\n } else if (cent) {\n dest[idx++] = '0';\n }\n\n dest[idx++] = exp % 10 + '0';\n\n return idx;\n}\n\nstatic int filter_special(double fp, char *dest) {\n if (fp == 0.0) {\n dest[0] = '0';\n return 1;\n }\n\n uint64_t bits = get_dbits(fp);\n\n bool nan = (bits & expmask) == expmask;\n\n if (!nan) {\n return 0;\n }\n\n if (bits & fracmask) {\n dest[0] = 'n';\n dest[1] = 'a';\n dest[2] = 'n';\n\n } else {\n dest[0] = 'i';\n dest[1] = 'n';\n dest[2] = 'f';\n }\n\n return 3;\n}\n\nint fpconv_dtoa(double d, char dest[24]) {\n char digits[18];\n\n int str_len = 0;\n bool neg = false;\n\n if (get_dbits(d) & signmask) {\n dest[0] = '-';\n str_len++;\n neg = true;\n }\n\n int spec = filter_special(d, dest + str_len);\n\n if (spec) {\n return str_len + spec;\n }\n\n int K = 0;\n int ndigits = grisu2(d, digits, &K);\n\n str_len += emit_digits(digits, ndigits, dest + str_len, K, neg);\n\n return str_len;\n}\n" }, { "path": "deps/fpconv/fpconv_dtoa.h", "content": "/* fpconv_dtoa.h -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on Florian Loitsch's\n * Grisu-algorithm[1].\n *\n * [1] https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf\n * ----------------------------------------------------------------------------\n *\n * Copyright (c) 2013-2019, night-shift \n * Copyright (c) 2009, Florian Loitsch < florian.loitsch at inria dot fr >\n * All rights reserved.\n *\n * Boost Software License - Version 1.0 - August 17th, 2003\n *\n * Permission is hereby granted, free of charge, to any person or organization\n * obtaining a copy of the software and accompanying documentation covered by\n * this license (the \"Software\") to use, reproduce, display, distribute,\n * execute, and transmit the Software, and to prepare derivative works of the\n * Software, and to permit third-parties to whom the Software is furnished to\n * do so, all subject to the following:\n *\n * The copyright notices in the Software and this entire statement, including\n * the above license grant, this restriction and the following disclaimer,\n * must be included in all copies of the Software, in whole or in part, and\n * all derivative works of the Software, unless such copies or derivative\n * works are solely in the form of machine-executable object code generated by\n * a source language processor.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\n * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\n * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n#ifndef FPCONV_DTOA_H\n#define FPCONV_DTOA_H\n\nint fpconv_dtoa(double fp, char dest[24]);\n\n#endif\n\n/* [1] http://florian.loitsch.com/publications/dtoa-pldi2010.pdf */\n" }, { "path": "deps/fpconv/fpconv_powers.h", "content": "/* fpconv_powers.h -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on Florian Loitsch's\n * Grisu-algorithm[1].\n *\n * [1] https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf\n * ----------------------------------------------------------------------------\n *\n * Copyright (c) 2021, Redis Labs\n * Copyright (c) 2013-2019, night-shift \n * Copyright (c) 2009, Florian Loitsch < florian.loitsch at inria dot fr >\n * All rights reserved.\n *\n * Boost Software License - Version 1.0 - August 17th, 2003\n *\n * Permission is hereby granted, free of charge, to any person or organization\n * obtaining a copy of the software and accompanying documentation covered by\n * this license (the \"Software\") to use, reproduce, display, distribute,\n * execute, and transmit the Software, and to prepare derivative works of the\n * Software, and to permit third-parties to whom the Software is furnished to\n * do so, all subject to the following:\n *\n * The copyright notices in the Software and this entire statement, including\n * the above license grant, this restriction and the following disclaimer,\n * must be included in all copies of the Software, in whole or in part, and\n * all derivative works of the Software, unless such copies or derivative\n * works are solely in the form of machine-executable object code generated by\n * a source language processor.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\n * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\n * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n#include \n\n#define npowers 87\n#define steppowers 8\n#define firstpower -348 /* 10 ^ -348 */\n\n#define expmax -32\n#define expmin -60\n\n\ntypedef struct Fp {\n uint64_t frac;\n int exp;\n} Fp;\n\nstatic Fp powers_ten[] = {\n { 18054884314459144840U, -1220 }, { 13451937075301367670U, -1193 },\n { 10022474136428063862U, -1166 }, { 14934650266808366570U, -1140 },\n { 11127181549972568877U, -1113 }, { 16580792590934885855U, -1087 },\n { 12353653155963782858U, -1060 }, { 18408377700990114895U, -1034 },\n { 13715310171984221708U, -1007 }, { 10218702384817765436U, -980 },\n { 15227053142812498563U, -954 }, { 11345038669416679861U, -927 },\n { 16905424996341287883U, -901 }, { 12595523146049147757U, -874 },\n { 9384396036005875287U, -847 }, { 13983839803942852151U, -821 },\n { 10418772551374772303U, -794 }, { 15525180923007089351U, -768 },\n { 11567161174868858868U, -741 }, { 17236413322193710309U, -715 },\n { 12842128665889583758U, -688 }, { 9568131466127621947U, -661 },\n { 14257626930069360058U, -635 }, { 10622759856335341974U, -608 },\n { 15829145694278690180U, -582 }, { 11793632577567316726U, -555 },\n { 17573882009934360870U, -529 }, { 13093562431584567480U, -502 },\n { 9755464219737475723U, -475 }, { 14536774485912137811U, -449 },\n { 10830740992659433045U, -422 }, { 16139061738043178685U, -396 },\n { 12024538023802026127U, -369 }, { 17917957937422433684U, -343 },\n { 13349918974505688015U, -316 }, { 9946464728195732843U, -289 },\n { 14821387422376473014U, -263 }, { 11042794154864902060U, -236 },\n { 16455045573212060422U, -210 }, { 12259964326927110867U, -183 },\n { 18268770466636286478U, -157 }, { 13611294676837538539U, -130 },\n { 10141204801825835212U, -103 }, { 15111572745182864684U, -77 },\n { 11258999068426240000U, -50 }, { 16777216000000000000U, -24 },\n { 12500000000000000000U, 3 }, { 9313225746154785156U, 30 },\n { 13877787807814456755U, 56 }, { 10339757656912845936U, 83 },\n { 15407439555097886824U, 109 }, { 11479437019748901445U, 136 },\n { 17105694144590052135U, 162 }, { 12744735289059618216U, 189 },\n { 9495567745759798747U, 216 }, { 14149498560666738074U, 242 },\n { 10542197943230523224U, 269 }, { 15709099088952724970U, 295 },\n { 11704190886730495818U, 322 }, { 17440603504673385349U, 348 },\n { 12994262207056124023U, 375 }, { 9681479787123295682U, 402 },\n { 14426529090290212157U, 428 }, { 10748601772107342003U, 455 },\n { 16016664761464807395U, 481 }, { 11933345169920330789U, 508 },\n { 17782069995880619868U, 534 }, { 13248674568444952270U, 561 },\n { 9871031767461413346U, 588 }, { 14708983551653345445U, 614 },\n { 10959046745042015199U, 641 }, { 16330252207878254650U, 667 },\n { 12166986024289022870U, 694 }, { 18130221999122236476U, 720 },\n { 13508068024458167312U, 747 }, { 10064294952495520794U, 774 },\n { 14996968138956309548U, 800 }, { 11173611982879273257U, 827 },\n { 16649979327439178909U, 853 }, { 12405201291620119593U, 880 },\n { 9242595204427927429U, 907 }, { 13772540099066387757U, 933 },\n { 10261342003245940623U, 960 }, { 15290591125556738113U, 986 },\n { 11392378155556871081U, 1013 }, { 16975966327722178521U, 1039 },\n { 12648080533535911531U, 1066 }\n};\n\n/**\n * Grisu needs a cache of precomputed powers-of-ten.\n * This function, given an exponent and an integer k\n * return the normalized floating-point approximation of the power of 10.\n * @param exp\n * @param k\n * @return\n */\nstatic Fp find_cachedpow10(int exp, int* k)\n{\n const double one_log_ten = 0.30102999566398114;\n\n const int approx = -(exp + npowers) * one_log_ten;\n int idx = (approx - firstpower) / steppowers;\n\n while(1) {\n int current = exp + powers_ten[idx].exp + 64;\n\n if(current < expmin) {\n idx++;\n continue;\n }\n\n if(current > expmax) {\n idx--;\n continue;\n }\n\n *k = (firstpower + idx * steppowers);\n\n return powers_ten[idx];\n }\n}\n" }, { "path": "deps/hdr_histogram/COPYING.txt", "content": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN\n ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS\n INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES\n REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS\n PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM\n THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED\n HEREUNDER.\n\nStatement of Purpose\n\nThe laws of most jurisdictions throughout the world automatically confer\nexclusive Copyright and Related Rights (defined below) upon the creator\nand subsequent owner(s) (each and all, an \"owner\") of an original work of\nauthorship and/or a database (each, a \"Work\").\n\nCertain owners wish to permanently relinquish those rights to a Work for\nthe purpose of contributing to a commons of creative, cultural and\nscientific works (\"Commons\") that the public can reliably and without fear\nof later claims of infringement build upon, modify, incorporate in other\nworks, reuse and redistribute as freely as possible in any form whatsoever\nand for any purposes, including without limitation commercial purposes.\nThese owners may contribute to the Commons to promote the ideal of a free\nculture and the further production of creative, cultural and scientific\nworks, or to gain reputation or greater distribution for their Work in\npart through the use and efforts of others.\n\nFor these and/or other purposes and motivations, and without any\nexpectation of additional consideration or compensation, the person\nassociating CC0 with a Work (the \"Affirmer\"), to the extent that he or she\nis an owner of Copyright and Related Rights in the Work, voluntarily\nelects to apply CC0 to the Work and publicly distribute the Work under its\nterms, with knowledge of his or her Copyright and Related Rights in the\nWork and the meaning and intended legal effect of CC0 on those rights.\n\n1. Copyright and Related Rights. A Work made available under CC0 may be\nprotected by copyright and related or neighboring rights (\"Copyright and\nRelated Rights\"). Copyright and Related Rights include, but are not\nlimited to, the following:\n\n i. the right to reproduce, adapt, distribute, perform, display,\n communicate, and translate a Work;\n ii. moral rights retained by the original author(s) and/or performer(s);\niii. publicity and privacy rights pertaining to a person's image or\n likeness depicted in a Work;\n iv. rights protecting against unfair competition in regards to a Work,\n subject to the limitations in paragraph 4(a), below;\n v. rights protecting the extraction, dissemination, use and reuse of data\n in a Work;\n vi. database rights (such as those arising under Directive 96/9/EC of the\n European Parliament and of the Council of 11 March 1996 on the legal\n protection of databases, and under any national implementation\n thereof, including any amended or successor version of such\n directive); and\nvii. other similar, equivalent or corresponding rights throughout the\n world based on applicable law or treaty, and any national\n implementations thereof.\n\n2. Waiver. To the greatest extent permitted by, but not in contravention\nof, applicable law, Affirmer hereby overtly, fully, permanently,\nirrevocably and unconditionally waives, abandons, and surrenders all of\nAffirmer's Copyright and Related Rights and associated claims and causes\nof action, whether now known or unknown (including existing as well as\nfuture claims and causes of action), in the Work (i) in all territories\nworldwide, (ii) for the maximum duration provided by applicable law or\ntreaty (including future time extensions), (iii) in any current or future\nmedium and for any number of copies, and (iv) for any purpose whatsoever,\nincluding without limitation commercial, advertising or promotional\npurposes (the \"Waiver\"). Affirmer makes the Waiver for the benefit of each\nmember of the public at large and to the detriment of Affirmer's heirs and\nsuccessors, fully intending that such Waiver shall not be subject to\nrevocation, rescission, cancellation, termination, or any other legal or\nequitable action to disrupt the quiet enjoyment of the Work by the public\nas contemplated by Affirmer's express Statement of Purpose.\n\n3. Public License Fallback. Should any part of the Waiver for any reason\nbe judged legally invalid or ineffective under applicable law, then the\nWaiver shall be preserved to the maximum extent permitted taking into\naccount Affirmer's express Statement of Purpose. In addition, to the\nextent the Waiver is so judged Affirmer hereby grants to each affected\nperson a royalty-free, non transferable, non sublicensable, non exclusive,\nirrevocable and unconditional license to exercise Affirmer's Copyright and\nRelated Rights in the Work (i) in all territories worldwide, (ii) for the\nmaximum duration provided by applicable law or treaty (including future\ntime extensions), (iii) in any current or future medium and for any number\nof copies, and (iv) for any purpose whatsoever, including without\nlimitation commercial, advertising or promotional purposes (the\n\"License\"). The License shall be deemed effective as of the date CC0 was\napplied by Affirmer to the Work. Should any part of the License for any\nreason be judged legally invalid or ineffective under applicable law, such\npartial invalidity or ineffectiveness shall not invalidate the remainder\nof the License, and in such case Affirmer hereby affirms that he or she\nwill not (i) exercise any of his or her remaining Copyright and Related\nRights in the Work or (ii) assert any associated claims and causes of\naction with respect to the Work, in either case contrary to Affirmer's\nexpress Statement of Purpose.\n\n4. Limitations and Disclaimers.\n\n a. No trademark or patent rights held by Affirmer are waived, abandoned,\n surrendered, licensed or otherwise affected by this document.\n b. Affirmer offers the Work as-is and makes no representations or\n warranties of any kind concerning the Work, express, implied,\n statutory or otherwise, including without limitation warranties of\n title, merchantability, fitness for a particular purpose, non\n infringement, or the absence of latent or other defects, accuracy, or\n the present or absence of errors, whether or not discoverable, all to\n the greatest extent permissible under applicable law.\n c. Affirmer disclaims responsibility for clearing rights of other persons\n that may apply to the Work or any use thereof, including without\n limitation any person's Copyright and Related Rights in the Work.\n Further, Affirmer disclaims responsibility for obtaining any necessary\n consents, permissions or other rights required for any use of the\n Work.\n d. Affirmer understands and acknowledges that Creative Commons is not a\n party to this document and has no duty or obligation with respect to\n this CC0 or use of the Work.\n" }, { "path": "deps/hdr_histogram/LICENSE.txt", "content": "The code in this repository code was Written by Gil Tene, Michael Barker,\nand Matt Warren, and released to the public domain, as explained at\nhttp://creativecommons.org/publicdomain/zero/1.0/\n\nFor users of this code who wish to consume it under the \"BSD\" license\nrather than under the public domain or CC0 contribution text mentioned\nabove, the code found under this directory is *also* provided under the\nfollowing license (commonly referred to as the BSD 2-Clause License). This\nlicense does not detract from the above stated release of the code into\nthe public domain, and simply represents an additional license granted by\nthe Author.\n\n-----------------------------------------------------------------------------\n** Beginning of \"BSD 2-Clause License\" text. **\n\n Copyright (c) 2012, 2013, 2014 Gil Tene\n Copyright (c) 2014 Michael Barker\n Copyright (c) 2014 Matt Warren\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "deps/hdr_histogram/Makefile", "content": "STD= -std=c99\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) -DHDR_MALLOC_INCLUDE=\\\"hdr_redis_malloc.h\\\"\nR_LDFLAGS= $(LDFLAGS)\nDEBUG= -g\n\nR_CC=$(CC) $(R_CFLAGS)\nR_LD=$(CC) $(R_LDFLAGS)\n\nAR= ar\nARFLAGS= rcs\n\nlibhdrhistogram.a: hdr_histogram.o\n\t$(AR) $(ARFLAGS) $@ $+\n\nhdr_histogram.o: hdr_histogram.h hdr_histogram.c\n\n.c.o:\n\t$(R_CC) -c $< \n\nclean:\n\trm -f *.o\n\trm -f *.a\n\n\n" }, { "path": "deps/hdr_histogram/README.md", "content": "HdrHistogram_c: 'C' port of High Dynamic Range (HDR) Histogram\n\nHdrHistogram\n----------------------------------------------\n\n[![Gitter chat](https://badges.gitter.im/HdrHistogram/HdrHistogram.png)](https://gitter.im/HdrHistogram/HdrHistogram)\n\nThis port contains a subset of the functionality supported by the Java\nimplementation. The current supported features are:\n\n* Standard histogram with 64 bit counts (32/16 bit counts not supported)\n* All iterator types (all values, recorded, percentiles, linear, logarithmic)\n* Histogram serialisation (encoding version 1.2, decoding 1.0-1.2)\n* Reader/writer phaser and interval recorder\n\nFeatures not supported, but planned\n\n* Auto-resizing of histograms\n\nFeatures unlikely to be implemented\n\n* Double histograms\n* Atomic/Concurrent histograms\n* 16/32 bit histograms\n\n# Simple Tutorial\n\n## Recording values\n\n```C\n#include \n\nstruct hdr_histogram* histogram;\n\n// Initialise the histogram\nhdr_init(\n 1, // Minimum value\n INT64_C(3600000000), // Maximum value\n 3, // Number of significant figures\n &histogram) // Pointer to initialise\n\n// Record value\nhdr_record_value(\n histogram, // Histogram to record to\n value) // Value to record\n\n// Record value n times\nhdr_record_values(\n histogram, // Histogram to record to\n value, // Value to record\n 10) // Record value 10 times\n\n// Record value with correction for co-ordinated omission.\nhdr_record_corrected_value(\n histogram, // Histogram to record to\n value, // Value to record\n 1000) // Record with expected interval of 1000.\n\n// Print out the values of the histogram\nhdr_percentiles_print(\n histogram,\n stdout, // File to write to\n 5, // Granularity of printed values\n 1.0, // Multiplier for results\n CLASSIC); // Format CLASSIC/CSV supported.\n```\n\n## More examples\n\nFor more detailed examples of recording and logging results look at the\n[hdr_decoder](examples/hdr_decoder.c)\nand [hiccup](examples/hiccup.c)\nexamples. You can run hiccup and decoder\nand pipe the results of one into the other.\n\n```\n$ ./examples/hiccup | ./examples/hdr_decoder\n```\n" }, { "path": "deps/hdr_histogram/hdr_atomic.h", "content": "/**\n * hdr_atomic.h\n * Written by Philip Orwig and released to the public domain,\n * as explained at http://creativecommons.org/publicdomain/zero/1.0/\n */\n\n#ifndef HDR_ATOMIC_H__\n#define HDR_ATOMIC_H__\n\n\n#if defined(_MSC_VER)\n\n#include \n#include \n#include \n\nstatic void __inline * hdr_atomic_load_pointer(void** pointer)\n{\n\t_ReadBarrier();\n\treturn *pointer;\n}\n\nstatic void hdr_atomic_store_pointer(void** pointer, void* value)\n{\n\t_WriteBarrier();\n\t*pointer = value;\n}\n\nstatic int64_t __inline hdr_atomic_load_64(int64_t* field)\n{ \n\t_ReadBarrier();\n\treturn *field;\n}\n\nstatic void __inline hdr_atomic_store_64(int64_t* field, int64_t value)\n{\n\t_WriteBarrier();\n\t*field = value;\n}\n\nstatic int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, int64_t value)\n{\n#if defined(_WIN64)\n return _InterlockedExchange64(field, value);\n#else\n int64_t comparand;\n int64_t initial_value = *field;\n do\n {\n comparand = initial_value;\n initial_value = _InterlockedCompareExchange64(field, value, comparand);\n }\n while (comparand != initial_value);\n\n return initial_value;\n#endif\n}\n\nstatic int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value)\n{\n#if defined(_WIN64)\n\treturn _InterlockedExchangeAdd64(field, value) + value;\n#else\n int64_t comparand;\n int64_t initial_value = *field;\n do\n {\n comparand = initial_value;\n initial_value = _InterlockedCompareExchange64(field, comparand + value, comparand);\n }\n while (comparand != initial_value);\n\n return initial_value + value;\n#endif\n}\n\nstatic bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)\n{\n return *expected == _InterlockedCompareExchange64(field, desired, *expected);\n}\n\n#elif defined(__ATOMIC_SEQ_CST)\n\n#define hdr_atomic_load_pointer(x) __atomic_load_n(x, __ATOMIC_SEQ_CST)\n#define hdr_atomic_store_pointer(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST)\n#define hdr_atomic_load_64(x) __atomic_load_n(x, __ATOMIC_SEQ_CST)\n#define hdr_atomic_store_64(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST)\n#define hdr_atomic_exchange_64(f,i) __atomic_exchange_n(f,i, __ATOMIC_SEQ_CST)\n#define hdr_atomic_add_fetch_64(field, value) __atomic_add_fetch(field, value, __ATOMIC_SEQ_CST)\n#define hdr_atomic_compare_exchange_64(field, expected, desired) __atomic_compare_exchange_n(field, expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)\n\n#elif defined(__x86_64__)\n\n#include \n#include \n\nstatic inline void* hdr_atomic_load_pointer(void** pointer)\n{\n void* p = *pointer;\n\tasm volatile (\"\" ::: \"memory\");\n\treturn p;\n}\n\nstatic inline void hdr_atomic_store_pointer(void** pointer, void* value)\n{\n asm volatile (\"lock; xchgq %0, %1\" : \"+q\" (value), \"+m\" (*pointer));\n}\n\nstatic inline int64_t hdr_atomic_load_64(int64_t* field)\n{\n int64_t i = *field;\n\tasm volatile (\"\" ::: \"memory\");\n\treturn i;\n}\n\nstatic inline void hdr_atomic_store_64(int64_t* field, int64_t value)\n{\n asm volatile (\"lock; xchgq %0, %1\" : \"+q\" (value), \"+m\" (*field));\n}\n\nstatic inline int64_t hdr_atomic_exchange_64(volatile int64_t* field, int64_t value)\n{\n int64_t result = 0;\n asm volatile (\"lock; xchgq %1, %2\" : \"=r\" (result), \"+q\" (value), \"+m\" (*field));\n return result;\n}\n\nstatic inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value)\n{\n return __sync_add_and_fetch(field, value);\n}\n\nstatic inline bool hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)\n{\n int64_t original;\n asm volatile( \"lock; cmpxchgq %2, %1\" : \"=a\"(original), \"+m\"(*field) : \"q\"(desired), \"0\"(*expected));\n return original == *expected;\n}\n\n#else\n\n#error \"Unable to determine atomic operations for your platform\"\n\n#endif\n\n#endif /* HDR_ATOMIC_H__ */\n" }, { "path": "deps/hdr_histogram/hdr_histogram.c", "content": "/**\n * hdr_histogram.c\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativecommons.org/publicdomain/zero/1.0/\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"hdr_histogram.h\"\n#include \"hdr_tests.h\"\n#include \"hdr_atomic.h\"\n\n#ifndef HDR_MALLOC_INCLUDE\n#define HDR_MALLOC_INCLUDE \"hdr_malloc.h\"\n#endif\n\n#include HDR_MALLOC_INCLUDE\n\n/* ###### ####### ## ## ## ## ######## ###### */\n/* ## ## ## ## ## ## ### ## ## ## ## */\n/* ## ## ## ## ## #### ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ###### */\n/* ## ## ## ## ## ## #### ## ## */\n/* ## ## ## ## ## ## ## ### ## ## ## */\n/* ###### ####### ####### ## ## ## ###### */\n\nstatic int32_t normalize_index(const struct hdr_histogram* h, int32_t index)\n{\n int32_t normalized_index;\n int32_t adjustment = 0;\n if (h->normalizing_index_offset == 0)\n {\n return index;\n }\n\n normalized_index = index - h->normalizing_index_offset;\n\n if (normalized_index < 0)\n {\n adjustment = h->counts_len;\n }\n else if (normalized_index >= h->counts_len)\n {\n adjustment = -h->counts_len;\n }\n\n return normalized_index + adjustment;\n}\n\nstatic int64_t counts_get_direct(const struct hdr_histogram* h, int32_t index)\n{\n return h->counts[index];\n}\n\nstatic int64_t counts_get_normalised(const struct hdr_histogram* h, int32_t index)\n{\n return counts_get_direct(h, normalize_index(h, index));\n}\n\nstatic void counts_inc_normalised(\n struct hdr_histogram* h, int32_t index, int64_t value)\n{\n int32_t normalised_index = normalize_index(h, index);\n h->counts[normalised_index] += value;\n h->total_count += value;\n}\n\nstatic void counts_inc_normalised_atomic(\n struct hdr_histogram* h, int32_t index, int64_t value)\n{\n int32_t normalised_index = normalize_index(h, index);\n\n hdr_atomic_add_fetch_64(&h->counts[normalised_index], value);\n hdr_atomic_add_fetch_64(&h->total_count, value);\n}\n\nstatic void update_min_max(struct hdr_histogram* h, int64_t value)\n{\n h->min_value = (value < h->min_value && value != 0) ? value : h->min_value;\n h->max_value = (value > h->max_value) ? value : h->max_value;\n}\n\nstatic void update_min_max_atomic(struct hdr_histogram* h, int64_t value)\n{\n int64_t current_min_value;\n int64_t current_max_value;\n do\n {\n current_min_value = hdr_atomic_load_64(&h->min_value);\n\n if (0 == value || current_min_value <= value)\n {\n break;\n }\n }\n while (!hdr_atomic_compare_exchange_64(&h->min_value, ¤t_min_value, value));\n\n do\n {\n current_max_value = hdr_atomic_load_64(&h->max_value);\n\n if (value <= current_max_value)\n {\n break;\n }\n }\n while (!hdr_atomic_compare_exchange_64(&h->max_value, ¤t_max_value, value));\n}\n\n\n/* ## ## ######## #### ## #### ######## ## ## */\n/* ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## #### */\n/* ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## */\n/* ####### ## #### ######## #### ## ## */\n\nstatic int64_t power(int64_t base, int64_t exp)\n{\n int64_t result = 1;\n while(exp)\n {\n result *= base; exp--;\n }\n return result;\n}\n\n#if defined(_MSC_VER)\n# if defined(_WIN64)\n# pragma intrinsic(_BitScanReverse64)\n# else\n# pragma intrinsic(_BitScanReverse)\n# endif\n#endif\n\nstatic int32_t count_leading_zeros_64(int64_t value)\n{\n#if defined(_MSC_VER)\n uint32_t leading_zero = 0;\n#if defined(_WIN64)\n _BitScanReverse64(&leading_zero, value);\n#else\n uint32_t high = value >> 32;\n if (_BitScanReverse(&leading_zero, high))\n {\n leading_zero += 32;\n }\n else\n {\n uint32_t low = value & 0x00000000FFFFFFFF;\n _BitScanReverse(&leading_zero, low);\n }\n#endif\n return 63 - leading_zero; /* smallest power of 2 containing value */\n#else\n return __builtin_clzll(value); /* smallest power of 2 containing value */\n#endif\n}\n\nstatic int32_t get_bucket_index(const struct hdr_histogram* h, int64_t value)\n{\n int32_t pow2ceiling = 64 - count_leading_zeros_64(value | h->sub_bucket_mask); /* smallest power of 2 containing value */\n return pow2ceiling - h->unit_magnitude - (h->sub_bucket_half_count_magnitude + 1);\n}\n\nstatic int32_t get_sub_bucket_index(int64_t value, int32_t bucket_index, int32_t unit_magnitude)\n{\n return (int32_t)(value >> (bucket_index + unit_magnitude));\n}\n\nstatic int32_t counts_index(const struct hdr_histogram* h, int32_t bucket_index, int32_t sub_bucket_index)\n{\n /* Calculate the index for the first entry in the bucket: */\n /* (The following is the equivalent of ((bucket_index + 1) * subBucketHalfCount) ): */\n int32_t bucket_base_index = (bucket_index + 1) << h->sub_bucket_half_count_magnitude;\n /* Calculate the offset in the bucket: */\n int32_t offset_in_bucket = sub_bucket_index - h->sub_bucket_half_count;\n /* The following is the equivalent of ((sub_bucket_index - subBucketHalfCount) + bucketBaseIndex; */\n return bucket_base_index + offset_in_bucket;\n}\n\nstatic int64_t value_from_index(int32_t bucket_index, int32_t sub_bucket_index, int32_t unit_magnitude)\n{\n return ((int64_t) sub_bucket_index) << (bucket_index + unit_magnitude);\n}\n\nint32_t counts_index_for(const struct hdr_histogram* h, int64_t value)\n{\n int32_t bucket_index = get_bucket_index(h, value);\n int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude);\n\n return counts_index(h, bucket_index, sub_bucket_index);\n}\n\nint64_t hdr_value_at_index(const struct hdr_histogram *h, int32_t index)\n{\n int32_t bucket_index = (index >> h->sub_bucket_half_count_magnitude) - 1;\n int32_t sub_bucket_index = (index & (h->sub_bucket_half_count - 1)) + h->sub_bucket_half_count;\n\n if (bucket_index < 0)\n {\n sub_bucket_index -= h->sub_bucket_half_count;\n bucket_index = 0;\n }\n\n return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude);\n}\n\nint64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h, int64_t value)\n{\n int32_t bucket_index = get_bucket_index(h, value);\n int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude);\n int32_t adjusted_bucket = (sub_bucket_index >= h->sub_bucket_count) ? (bucket_index + 1) : bucket_index;\n return INT64_C(1) << (h->unit_magnitude + adjusted_bucket);\n}\n\nstatic int64_t size_of_equivalent_value_range_given_bucket_indices(\n const struct hdr_histogram *h,\n int32_t bucket_index,\n int32_t sub_bucket_index)\n{\n const int32_t adjusted_bucket = (sub_bucket_index >= h->sub_bucket_count) ? (bucket_index + 1) : bucket_index;\n return INT64_C(1) << (h->unit_magnitude + adjusted_bucket);\n}\n\nstatic int64_t lowest_equivalent_value(const struct hdr_histogram* h, int64_t value)\n{\n int32_t bucket_index = get_bucket_index(h, value);\n int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude);\n return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude);\n}\n\nstatic int64_t lowest_equivalent_value_given_bucket_indices(\n const struct hdr_histogram *h,\n int32_t bucket_index,\n int32_t sub_bucket_index)\n{\n return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude);\n}\n\nint64_t hdr_next_non_equivalent_value(const struct hdr_histogram *h, int64_t value)\n{\n return lowest_equivalent_value(h, value) + hdr_size_of_equivalent_value_range(h, value);\n}\n\nstatic int64_t highest_equivalent_value(const struct hdr_histogram* h, int64_t value)\n{\n return hdr_next_non_equivalent_value(h, value) - 1;\n}\n\nint64_t hdr_median_equivalent_value(const struct hdr_histogram *h, int64_t value)\n{\n return lowest_equivalent_value(h, value) + (hdr_size_of_equivalent_value_range(h, value) >> 1);\n}\n\nstatic int64_t non_zero_min(const struct hdr_histogram* h)\n{\n if (INT64_MAX == h->min_value)\n {\n return INT64_MAX;\n }\n\n return lowest_equivalent_value(h, h->min_value);\n}\n\nvoid hdr_reset_internal_counters(struct hdr_histogram* h)\n{\n int min_non_zero_index = -1;\n int max_index = -1;\n int64_t observed_total_count = 0;\n int i;\n\n for (i = 0; i < h->counts_len; i++)\n {\n int64_t count_at_index;\n\n if ((count_at_index = counts_get_direct(h, i)) > 0)\n {\n observed_total_count += count_at_index;\n max_index = i;\n if (min_non_zero_index == -1 && i != 0)\n {\n min_non_zero_index = i;\n }\n }\n }\n\n if (max_index == -1)\n {\n h->max_value = 0;\n }\n else\n {\n int64_t max_value = hdr_value_at_index(h, max_index);\n h->max_value = highest_equivalent_value(h, max_value);\n }\n\n if (min_non_zero_index == -1)\n {\n h->min_value = INT64_MAX;\n }\n else\n {\n h->min_value = hdr_value_at_index(h, min_non_zero_index);\n }\n\n h->total_count = observed_total_count;\n}\n\nstatic int32_t buckets_needed_to_cover_value(int64_t value, int32_t sub_bucket_count, int32_t unit_magnitude)\n{\n int64_t smallest_untrackable_value = ((int64_t) sub_bucket_count) << unit_magnitude;\n int32_t buckets_needed = 1;\n while (smallest_untrackable_value <= value)\n {\n if (smallest_untrackable_value > INT64_MAX / 2)\n {\n return buckets_needed + 1;\n }\n smallest_untrackable_value <<= 1;\n buckets_needed++;\n }\n\n return buckets_needed;\n}\n\n/* ## ## ######## ## ## ####### ######## ## ## */\n/* ### ### ## ### ### ## ## ## ## ## ## */\n/* #### #### ## #### #### ## ## ## ## #### */\n/* ## ### ## ###### ## ### ## ## ## ######## ## */\n/* ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ######## ## ## ####### ## ## ## */\n\nint hdr_calculate_bucket_config(\n int64_t lowest_discernible_value,\n int64_t highest_trackable_value,\n int significant_figures,\n struct hdr_histogram_bucket_config* cfg)\n{\n int32_t sub_bucket_count_magnitude;\n int64_t largest_value_with_single_unit_resolution;\n\n if (lowest_discernible_value < 1 ||\n significant_figures < 1 || 5 < significant_figures ||\n lowest_discernible_value * 2 > highest_trackable_value)\n {\n return EINVAL;\n }\n\n cfg->lowest_discernible_value = lowest_discernible_value;\n cfg->significant_figures = significant_figures;\n cfg->highest_trackable_value = highest_trackable_value;\n\n largest_value_with_single_unit_resolution = 2 * power(10, significant_figures);\n sub_bucket_count_magnitude = (int32_t) ceil(log((double)largest_value_with_single_unit_resolution) / log(2));\n cfg->sub_bucket_half_count_magnitude = ((sub_bucket_count_magnitude > 1) ? sub_bucket_count_magnitude : 1) - 1;\n\n double unit_magnitude = log((double)lowest_discernible_value) / log(2);\n if (INT32_MAX < unit_magnitude)\n {\n return EINVAL;\n }\n\n cfg->unit_magnitude = (int32_t) unit_magnitude;\n cfg->sub_bucket_count = (int32_t) pow(2, (cfg->sub_bucket_half_count_magnitude + 1));\n cfg->sub_bucket_half_count = cfg->sub_bucket_count / 2;\n cfg->sub_bucket_mask = ((int64_t) cfg->sub_bucket_count - 1) << cfg->unit_magnitude;\n\n if (cfg->unit_magnitude + cfg->sub_bucket_half_count_magnitude > 61)\n {\n return EINVAL;\n }\n\n cfg->bucket_count = buckets_needed_to_cover_value(highest_trackable_value, cfg->sub_bucket_count, (int32_t)cfg->unit_magnitude);\n cfg->counts_len = (cfg->bucket_count + 1) * (cfg->sub_bucket_count / 2);\n\n return 0;\n}\n\nvoid hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram_bucket_config* cfg)\n{\n h->lowest_discernible_value = cfg->lowest_discernible_value;\n h->highest_trackable_value = cfg->highest_trackable_value;\n h->unit_magnitude = (int32_t)cfg->unit_magnitude;\n h->significant_figures = (int32_t)cfg->significant_figures;\n h->sub_bucket_half_count_magnitude = cfg->sub_bucket_half_count_magnitude;\n h->sub_bucket_half_count = cfg->sub_bucket_half_count;\n h->sub_bucket_mask = cfg->sub_bucket_mask;\n h->sub_bucket_count = cfg->sub_bucket_count;\n h->min_value = INT64_MAX;\n h->max_value = 0;\n h->normalizing_index_offset = 0;\n h->conversion_ratio = 1.0;\n h->bucket_count = cfg->bucket_count;\n h->counts_len = cfg->counts_len;\n h->total_count = 0;\n}\n\nint hdr_init(\n int64_t lowest_discernible_value,\n int64_t highest_trackable_value,\n int significant_figures,\n struct hdr_histogram** result)\n{\n int64_t* counts;\n struct hdr_histogram_bucket_config cfg;\n struct hdr_histogram* histogram;\n\n int r = hdr_calculate_bucket_config(lowest_discernible_value, highest_trackable_value, significant_figures, &cfg);\n if (r)\n {\n return r;\n }\n\n counts = (int64_t*) hdr_calloc((size_t) cfg.counts_len, sizeof(int64_t));\n if (!counts)\n {\n return ENOMEM;\n }\n\n histogram = (struct hdr_histogram*) hdr_calloc(1, sizeof(struct hdr_histogram));\n if (!histogram)\n {\n hdr_free(counts);\n return ENOMEM;\n }\n\n histogram->counts = counts;\n\n hdr_init_preallocated(histogram, &cfg);\n *result = histogram;\n\n return 0;\n}\n\nvoid hdr_close(struct hdr_histogram* h)\n{\n if (h) {\n\thdr_free(h->counts);\n\thdr_free(h);\n }\n}\n\nint hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result)\n{\n return hdr_init(1, highest_trackable_value, significant_figures, result);\n}\n\n/* reset a histogram to zero. */\nvoid hdr_reset(struct hdr_histogram *h)\n{\n h->total_count=0;\n h->min_value = INT64_MAX;\n h->max_value = 0;\n memset(h->counts, 0, (sizeof(int64_t) * h->counts_len));\n}\n\nsize_t hdr_get_memory_size(struct hdr_histogram *h)\n{\n return sizeof(struct hdr_histogram) + h->counts_len * sizeof(int64_t);\n}\n\n/* ## ## ######## ######## ### ######## ######## ###### */\n/* ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ######## ## ## ## ## ## ###### ###### */\n/* ## ## ## ## ## ######### ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## */\n/* ####### ## ######## ## ## ## ######## ###### */\n\n\nbool hdr_record_value(struct hdr_histogram* h, int64_t value)\n{\n return hdr_record_values(h, value, 1);\n}\n\nbool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value)\n{\n return hdr_record_values_atomic(h, value, 1);\n}\n\nbool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count)\n{\n int32_t counts_index;\n\n if (value < 0)\n {\n return false;\n }\n\n counts_index = counts_index_for(h, value);\n\n if (counts_index < 0 || h->counts_len <= counts_index)\n {\n return false;\n }\n\n counts_inc_normalised(h, counts_index, count);\n update_min_max(h, value);\n\n return true;\n}\n\nbool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count)\n{\n int32_t counts_index;\n\n if (value < 0)\n {\n return false;\n }\n\n counts_index = counts_index_for(h, value);\n\n if (counts_index < 0 || h->counts_len <= counts_index)\n {\n return false;\n }\n\n counts_inc_normalised_atomic(h, counts_index, count);\n update_min_max_atomic(h, value);\n\n return true;\n}\n\nbool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval)\n{\n return hdr_record_corrected_values(h, value, 1, expected_interval);\n}\n\nbool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval)\n{\n return hdr_record_corrected_values_atomic(h, value, 1, expected_interval);\n}\n\nbool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)\n{\n int64_t missing_value;\n\n if (!hdr_record_values(h, value, count))\n {\n return false;\n }\n\n if (expected_interval <= 0 || value <= expected_interval)\n {\n return true;\n }\n\n missing_value = value - expected_interval;\n for (; missing_value >= expected_interval; missing_value -= expected_interval)\n {\n if (!hdr_record_values(h, missing_value, count))\n {\n return false;\n }\n }\n\n return true;\n}\n\nbool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)\n{\n int64_t missing_value;\n\n if (!hdr_record_values_atomic(h, value, count))\n {\n return false;\n }\n\n if (expected_interval <= 0 || value <= expected_interval)\n {\n return true;\n }\n\n missing_value = value - expected_interval;\n for (; missing_value >= expected_interval; missing_value -= expected_interval)\n {\n if (!hdr_record_values_atomic(h, missing_value, count))\n {\n return false;\n }\n }\n\n return true;\n}\n\nint64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from)\n{\n struct hdr_iter iter;\n int64_t dropped = 0;\n hdr_iter_recorded_init(&iter, from);\n\n while (hdr_iter_next(&iter))\n {\n int64_t value = iter.value;\n int64_t count = iter.count;\n\n if (!hdr_record_values(h, value, count))\n {\n dropped += count;\n }\n }\n\n return dropped;\n}\n\nint64_t hdr_add_while_correcting_for_coordinated_omission(\n struct hdr_histogram* h, struct hdr_histogram* from, int64_t expected_interval)\n{\n struct hdr_iter iter;\n int64_t dropped = 0;\n hdr_iter_recorded_init(&iter, from);\n\n while (hdr_iter_next(&iter))\n {\n int64_t value = iter.value;\n int64_t count = iter.count;\n\n if (!hdr_record_corrected_values(h, value, count, expected_interval))\n {\n dropped += count;\n }\n }\n\n return dropped;\n}\n\n\n\n/* ## ## ### ## ## ## ######## ###### */\n/* ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ###### ###### */\n/* ## ## ######### ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## */\n/* ### ## ## ######## ####### ######## ###### */\n\n\nint64_t hdr_max(const struct hdr_histogram* h)\n{\n if (0 == h->max_value)\n {\n return 0;\n }\n\n return highest_equivalent_value(h, h->max_value);\n}\n\nint64_t hdr_min(const struct hdr_histogram* h)\n{\n if (0 < hdr_count_at_index(h, 0))\n {\n return 0;\n }\n\n return non_zero_min(h);\n}\n\nstatic int64_t get_value_from_idx_up_to_count(const struct hdr_histogram* h, int64_t count_at_percentile)\n{\n int64_t count_to_idx = 0;\n\n count_at_percentile = 0 < count_at_percentile ? count_at_percentile : 1;\n for (int32_t idx = 0; idx < h->counts_len; idx++)\n {\n count_to_idx += h->counts[idx];\n if (count_to_idx >= count_at_percentile)\n {\n return hdr_value_at_index(h, idx);\n }\n }\n\n return 0;\n}\n\n\nint64_t hdr_value_at_percentile(const struct hdr_histogram* h, double percentile)\n{\n double requested_percentile = percentile < 100.0 ? percentile : 100.0;\n int64_t count_at_percentile =\n (int64_t) (((requested_percentile / 100) * h->total_count) + 0.5);\n int64_t value_from_idx = get_value_from_idx_up_to_count(h, count_at_percentile);\n if (percentile == 0.0)\n {\n return lowest_equivalent_value(h, value_from_idx);\n }\n return highest_equivalent_value(h, value_from_idx);\n}\n\nint hdr_value_at_percentiles(const struct hdr_histogram *h, const double *percentiles, int64_t *values, size_t length)\n{\n if (NULL == percentiles || NULL == values)\n {\n return EINVAL;\n }\n\n struct hdr_iter iter;\n const int64_t total_count = h->total_count;\n // to avoid allocations we use the values array for intermediate computation\n // i.e. to store the expected cumulative count at each percentile\n for (size_t i = 0; i < length; i++)\n {\n const double requested_percentile = percentiles[i] < 100.0 ? percentiles[i] : 100.0;\n const int64_t count_at_percentile =\n (int64_t) (((requested_percentile / 100) * total_count) + 0.5);\n values[i] = count_at_percentile > 1 ? count_at_percentile : 1;\n }\n\n hdr_iter_init(&iter, h);\n int64_t total = 0;\n size_t at_pos = 0;\n while (hdr_iter_next(&iter) && at_pos < length)\n {\n total += iter.count;\n while (at_pos < length && total >= values[at_pos])\n {\n values[at_pos] = highest_equivalent_value(h, iter.value);\n at_pos++;\n }\n }\n return 0;\n}\n\ndouble hdr_mean(const struct hdr_histogram* h)\n{\n struct hdr_iter iter;\n int64_t total = 0;\n\n hdr_iter_init(&iter, h);\n\n while (hdr_iter_next(&iter))\n {\n if (0 != iter.count)\n {\n total += iter.count * hdr_median_equivalent_value(h, iter.value);\n }\n }\n\n return (total * 1.0) / h->total_count;\n}\n\ndouble hdr_stddev(const struct hdr_histogram* h)\n{\n double mean = hdr_mean(h);\n double geometric_dev_total = 0.0;\n\n struct hdr_iter iter;\n hdr_iter_init(&iter, h);\n\n while (hdr_iter_next(&iter))\n {\n if (0 != iter.count)\n {\n double dev = (hdr_median_equivalent_value(h, iter.value) * 1.0) - mean;\n geometric_dev_total += (dev * dev) * iter.count;\n }\n }\n\n return sqrt(geometric_dev_total / h->total_count);\n}\n\nbool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a, int64_t b)\n{\n return lowest_equivalent_value(h, a) == lowest_equivalent_value(h, b);\n}\n\nint64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64_t value)\n{\n return lowest_equivalent_value(h, value);\n}\n\nint64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value)\n{\n return counts_get_normalised(h, counts_index_for(h, value));\n}\n\nint64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index)\n{\n return counts_get_normalised(h, index);\n}\n\n\n/* #### ######## ######## ######## ### ######## ####### ######## ###### */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ###### ######## ## ## ## ## ## ######## ###### */\n/* ## ## ## ## ## ######### ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* #### ## ######## ## ## ## ## ## ####### ## ## ###### */\n\n\nstatic bool has_buckets(struct hdr_iter* iter)\n{\n return iter->counts_index < iter->h->counts_len;\n}\n\nstatic bool has_next(struct hdr_iter* iter)\n{\n return iter->cumulative_count < iter->total_count;\n}\n\nstatic bool move_next(struct hdr_iter* iter)\n{\n iter->counts_index++;\n\n if (!has_buckets(iter))\n {\n return false;\n }\n\n iter->count = counts_get_normalised(iter->h, iter->counts_index);\n iter->cumulative_count += iter->count;\n const int64_t value = hdr_value_at_index(iter->h, iter->counts_index);\n const int32_t bucket_index = get_bucket_index(iter->h, value);\n const int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, iter->h->unit_magnitude);\n const int64_t leq = lowest_equivalent_value_given_bucket_indices(iter->h, bucket_index, sub_bucket_index);\n const int64_t size_of_equivalent_value_range = size_of_equivalent_value_range_given_bucket_indices(\n iter->h, bucket_index, sub_bucket_index);\n iter->lowest_equivalent_value = leq;\n iter->value = value;\n iter->highest_equivalent_value = leq + size_of_equivalent_value_range - 1;\n iter->median_equivalent_value = leq + (size_of_equivalent_value_range >> 1);\n\n return true;\n}\n\nstatic int64_t peek_next_value_from_index(struct hdr_iter* iter)\n{\n return hdr_value_at_index(iter->h, iter->counts_index + 1);\n}\n\nstatic bool next_value_greater_than_reporting_level_upper_bound(\n struct hdr_iter *iter, int64_t reporting_level_upper_bound)\n{\n if (iter->counts_index >= iter->h->counts_len)\n {\n return false;\n }\n\n return peek_next_value_from_index(iter) > reporting_level_upper_bound;\n}\n\nstatic bool basic_iter_next(struct hdr_iter *iter)\n{\n if (!has_next(iter) || iter->counts_index >= iter->h->counts_len)\n {\n return false;\n }\n\n move_next(iter);\n\n return true;\n}\n\nstatic void update_iterated_values(struct hdr_iter* iter, int64_t new_value_iterated_to)\n{\n iter->value_iterated_from = iter->value_iterated_to;\n iter->value_iterated_to = new_value_iterated_to;\n}\n\nstatic bool all_values_iter_next(struct hdr_iter* iter)\n{\n bool result = move_next(iter);\n\n if (result)\n {\n update_iterated_values(iter, iter->value);\n }\n\n return result;\n}\n\nvoid hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h)\n{\n iter->h = h;\n\n iter->counts_index = -1;\n iter->total_count = h->total_count;\n iter->count = 0;\n iter->cumulative_count = 0;\n iter->value = 0;\n iter->highest_equivalent_value = 0;\n iter->value_iterated_from = 0;\n iter->value_iterated_to = 0;\n\n iter->_next_fp = all_values_iter_next;\n}\n\nbool hdr_iter_next(struct hdr_iter* iter)\n{\n return iter->_next_fp(iter);\n}\n\n/* ######## ######## ######## ###### ######## ## ## ######## #### ## ######## ###### */\n/* ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## #### ## ## ## ## ## ## */\n/* ######## ###### ######## ## ###### ## ## ## ## ## ## ###### ###### */\n/* ## ## ## ## ## ## ## #### ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## */\n/* ## ######## ## ## ###### ######## ## ## ## #### ######## ######## ###### */\n\nstatic bool percentile_iter_next(struct hdr_iter* iter)\n{\n int64_t temp, half_distance, percentile_reporting_ticks;\n\n struct hdr_iter_percentiles* percentiles = &iter->specifics.percentiles;\n\n if (!has_next(iter))\n {\n if (percentiles->seen_last_value)\n {\n return false;\n }\n\n percentiles->seen_last_value = true;\n percentiles->percentile = 100.0;\n\n return true;\n }\n\n if (iter->counts_index == -1 && !basic_iter_next(iter))\n {\n return false;\n }\n\n do\n {\n double current_percentile = (100.0 * (double) iter->cumulative_count) / iter->h->total_count;\n if (iter->count != 0 &&\n percentiles->percentile_to_iterate_to <= current_percentile)\n {\n update_iterated_values(iter, highest_equivalent_value(iter->h, iter->value));\n\n percentiles->percentile = percentiles->percentile_to_iterate_to;\n temp = (int64_t)(log(100 / (100.0 - (percentiles->percentile_to_iterate_to))) / log(2)) + 1;\n half_distance = (int64_t) pow(2, (double) temp);\n percentile_reporting_ticks = percentiles->ticks_per_half_distance * half_distance;\n percentiles->percentile_to_iterate_to += 100.0 / percentile_reporting_ticks;\n\n return true;\n }\n }\n while (basic_iter_next(iter));\n\n return true;\n}\n\nvoid hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_histogram* h, int32_t ticks_per_half_distance)\n{\n iter->h = h;\n\n hdr_iter_init(iter, h);\n\n iter->specifics.percentiles.seen_last_value = false;\n iter->specifics.percentiles.ticks_per_half_distance = ticks_per_half_distance;\n iter->specifics.percentiles.percentile_to_iterate_to = 0.0;\n iter->specifics.percentiles.percentile = 0.0;\n\n iter->_next_fp = percentile_iter_next;\n}\n\nstatic void format_line_string(char* str, size_t len, int significant_figures, format_type format)\n{\n#if defined(_MSC_VER)\n#define snprintf _snprintf\n#pragma warning(push)\n#pragma warning(disable: 4996)\n#endif\n const char* format_str = \"%s%d%s\";\n\n switch (format)\n {\n case CSV:\n snprintf(str, len, format_str, \"%.\", significant_figures, \"f,%f,%d,%.2f\\n\");\n break;\n case CLASSIC:\n snprintf(str, len, format_str, \"%12.\", significant_figures, \"f %12f %12d %12.2f\\n\");\n break;\n default:\n snprintf(str, len, format_str, \"%12.\", significant_figures, \"f %12f %12d %12.2f\\n\");\n }\n#if defined(_MSC_VER)\n#undef snprintf\n#pragma warning(pop)\n#endif\n}\n\n\n/* ######## ######## ###### ####### ######## ######## ######## ######## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ######## ###### ## ## ## ######## ## ## ###### ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ######## ###### ####### ## ## ######## ######## ######## */\n\n\nstatic bool recorded_iter_next(struct hdr_iter* iter)\n{\n while (basic_iter_next(iter))\n {\n if (iter->count != 0)\n {\n update_iterated_values(iter, iter->value);\n\n iter->specifics.recorded.count_added_in_this_iteration_step = iter->count;\n return true;\n }\n }\n\n return false;\n}\n\nvoid hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h)\n{\n hdr_iter_init(iter, h);\n\n iter->specifics.recorded.count_added_in_this_iteration_step = 0;\n\n iter->_next_fp = recorded_iter_next;\n}\n\n/* ## #### ## ## ######## ### ######## */\n/* ## ## ### ## ## ## ## ## ## */\n/* ## ## #### ## ## ## ## ## ## */\n/* ## ## ## ## ## ###### ## ## ######## */\n/* ## ## ## #### ## ######### ## ## */\n/* ## ## ## ### ## ## ## ## ## */\n/* ######## #### ## ## ######## ## ## ## ## */\n\n\nstatic bool iter_linear_next(struct hdr_iter* iter)\n{\n struct hdr_iter_linear* linear = &iter->specifics.linear;\n\n linear->count_added_in_this_iteration_step = 0;\n\n if (has_next(iter) ||\n next_value_greater_than_reporting_level_upper_bound(\n iter, linear->next_value_reporting_level_lowest_equivalent))\n {\n do\n {\n if (iter->value >= linear->next_value_reporting_level_lowest_equivalent)\n {\n update_iterated_values(iter, linear->next_value_reporting_level);\n\n linear->next_value_reporting_level += linear->value_units_per_bucket;\n linear->next_value_reporting_level_lowest_equivalent =\n lowest_equivalent_value(iter->h, linear->next_value_reporting_level);\n\n return true;\n }\n\n if (!move_next(iter))\n {\n return true;\n }\n\n linear->count_added_in_this_iteration_step += iter->count;\n }\n while (true);\n }\n\n return false;\n}\n\n\nvoid hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histogram* h, int64_t value_units_per_bucket)\n{\n hdr_iter_init(iter, h);\n\n iter->specifics.linear.count_added_in_this_iteration_step = 0;\n iter->specifics.linear.value_units_per_bucket = value_units_per_bucket;\n iter->specifics.linear.next_value_reporting_level = value_units_per_bucket;\n iter->specifics.linear.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_per_bucket);\n\n iter->_next_fp = iter_linear_next;\n}\n\nvoid hdr_iter_linear_set_value_units_per_bucket(struct hdr_iter* iter, int64_t value_units_per_bucket)\n{\n iter->specifics.linear.value_units_per_bucket = value_units_per_bucket;\n}\n\n/* ## ####### ###### ### ######## #### ######## ## ## ## ## #### ###### */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ### ### ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## #### #### ## ## */\n/* ## ## ## ## #### ## ## ######## ## ## ######### ## ### ## ## ## */\n/* ## ## ## ## ## ######### ## ## ## ## ## ## ## ## ## ## */\n/* ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## */\n/* ######## ####### ###### ## ## ## ## #### ## ## ## ## ## #### ###### */\n\nstatic bool log_iter_next(struct hdr_iter *iter)\n{\n struct hdr_iter_log* logarithmic = &iter->specifics.log;\n\n logarithmic->count_added_in_this_iteration_step = 0;\n\n if (has_next(iter) ||\n next_value_greater_than_reporting_level_upper_bound(\n iter, logarithmic->next_value_reporting_level_lowest_equivalent))\n {\n do\n {\n if (iter->value >= logarithmic->next_value_reporting_level_lowest_equivalent)\n {\n update_iterated_values(iter, logarithmic->next_value_reporting_level);\n\n logarithmic->next_value_reporting_level *= (int64_t)logarithmic->log_base;\n logarithmic->next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(iter->h, logarithmic->next_value_reporting_level);\n\n return true;\n }\n\n if (!move_next(iter))\n {\n return true;\n }\n\n logarithmic->count_added_in_this_iteration_step += iter->count;\n }\n while (true);\n }\n\n return false;\n}\n\nvoid hdr_iter_log_init(\n struct hdr_iter* iter,\n const struct hdr_histogram* h,\n int64_t value_units_first_bucket,\n double log_base)\n{\n hdr_iter_init(iter, h);\n iter->specifics.log.count_added_in_this_iteration_step = 0;\n iter->specifics.log.log_base = log_base;\n iter->specifics.log.next_value_reporting_level = value_units_first_bucket;\n iter->specifics.log.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_first_bucket);\n\n iter->_next_fp = log_iter_next;\n}\n\n/* Printing. */\n\nstatic const char* format_head_string(format_type format)\n{\n switch (format)\n {\n case CSV:\n return \"%s,%s,%s,%s\\n\";\n case CLASSIC:\n default:\n return \"%12s %12s %12s %12s\\n\\n\";\n }\n}\n\nstatic const char CLASSIC_FOOTER[] =\n \"#[Mean = %12.3f, StdDeviation = %12.3f]\\n\"\n \"#[Max = %12.3f, Total count = %12\" PRIu64 \"]\\n\"\n \"#[Buckets = %12d, SubBuckets = %12d]\\n\";\n\nint hdr_percentiles_print(\n struct hdr_histogram* h, FILE* stream, int32_t ticks_per_half_distance,\n double value_scale, format_type format)\n{\n char line_format[25];\n const char* head_format;\n int rc = 0;\n struct hdr_iter iter;\n struct hdr_iter_percentiles * percentiles;\n\n format_line_string(line_format, 25, h->significant_figures, format);\n head_format = format_head_string(format);\n\n hdr_iter_percentile_init(&iter, h, ticks_per_half_distance);\n\n if (fprintf(\n stream, head_format,\n \"Value\", \"Percentile\", \"TotalCount\", \"1/(1-Percentile)\") < 0)\n {\n rc = EIO;\n goto cleanup;\n }\n\n percentiles = &iter.specifics.percentiles;\n while (hdr_iter_next(&iter))\n {\n double value = iter.highest_equivalent_value / value_scale;\n double percentile = percentiles->percentile / 100.0;\n int64_t total_count = iter.cumulative_count;\n double inverted_percentile = (1.0 / (1.0 - percentile));\n\n if (fprintf(\n stream, line_format, value, percentile, total_count, inverted_percentile) < 0)\n {\n rc = EIO;\n goto cleanup;\n }\n }\n\n if (CLASSIC == format)\n {\n double mean = hdr_mean(h) / value_scale;\n double stddev = hdr_stddev(h) / value_scale;\n double max = hdr_max(h) / value_scale;\n\n if (fprintf(\n stream, CLASSIC_FOOTER, mean, stddev, max,\n h->total_count, h->bucket_count, h->sub_bucket_count) < 0)\n {\n rc = EIO;\n goto cleanup;\n }\n }\n\n cleanup:\n return rc;\n}\n" }, { "path": "deps/hdr_histogram/hdr_histogram.h", "content": "/**\n * hdr_histogram.h\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativecommons.org/publicdomain/zero/1.0/\n *\n * The source for the hdr_histogram utilises a few C99 constructs, specifically\n * the use of stdint/stdbool and inline variable declaration.\n */\n\n#ifndef HDR_HISTOGRAM_H\n#define HDR_HISTOGRAM_H 1\n\n#include \n#include \n#include \n\nstruct hdr_histogram\n{\n int64_t lowest_discernible_value;\n int64_t highest_trackable_value;\n int32_t unit_magnitude;\n int32_t significant_figures;\n int32_t sub_bucket_half_count_magnitude;\n int32_t sub_bucket_half_count;\n int64_t sub_bucket_mask;\n int32_t sub_bucket_count;\n int32_t bucket_count;\n int64_t min_value;\n int64_t max_value;\n int32_t normalizing_index_offset;\n double conversion_ratio;\n int32_t counts_len;\n int64_t total_count;\n int64_t* counts;\n};\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/**\n * Allocate the memory and initialise the hdr_histogram.\n *\n * Due to the size of the histogram being the result of some reasonably\n * involved math on the input parameters this function it is tricky to stack allocate.\n * The histogram should be released with hdr_close\n *\n * @param lowest_discernible_value The smallest possible value that is distinguishable from 0.\n * Must be a positive integer that is >= 1. May be internally rounded down to nearest power of 2.\n * @param highest_trackable_value The largest possible value to be put into the\n * histogram.\n * @param significant_figures The level of precision for this histogram, i.e. the number\n * of figures in a decimal number that will be maintained. E.g. a value of 3 will mean\n * the results from the histogram will be accurate up to the first three digits. Must\n * be a value between 1 and 5 (inclusive).\n * @param result Output parameter to capture allocated histogram.\n * @return 0 on success, EINVAL if lowest_discernible_value is < 1 or the\n * significant_figure value is outside of the allowed range, ENOMEM if malloc\n * failed.\n */\nint hdr_init(\n int64_t lowest_discernible_value,\n int64_t highest_trackable_value,\n int significant_figures,\n struct hdr_histogram** result);\n\n/**\n * Free the memory and close the hdr_histogram.\n *\n * @param h The histogram you want to close.\n */\nvoid hdr_close(struct hdr_histogram* h);\n\n/**\n * Allocate the memory and initialise the hdr_histogram. This is the equivalent of calling\n * hdr_init(1, highest_trackable_value, significant_figures, result);\n *\n * @deprecated use hdr_init.\n */\nint hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result);\n\n\n/**\n * Reset a histogram to zero - empty out a histogram and re-initialise it\n *\n * If you want to re-use an existing histogram, but reset everything back to zero, this\n * is the routine to use.\n *\n * @param h The histogram you want to reset to empty.\n *\n */\nvoid hdr_reset(struct hdr_histogram* h);\n\n/**\n * Get the memory size of the hdr_histogram.\n *\n * @param h \"This\" pointer\n * @return The amount of memory used by the hdr_histogram in bytes\n */\nsize_t hdr_get_memory_size(struct hdr_histogram* h);\n\n/**\n * Records a value in the histogram, will round this value of to a precision at or better\n * than the significant_figure specified at construction time.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_value(struct hdr_histogram* h, int64_t value);\n\n/**\n * Records a value in the histogram, will round this value of to a precision at or better\n * than the significant_figure specified at construction time.\n *\n * Will record this value atomically, however the whole structure may appear inconsistent\n * when read concurrently with this update. Do NOT mix calls to this method with calls\n * to non-atomic updates.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value);\n\n/**\n * Records count values in the histogram, will round this value of to a\n * precision at or better than the significant_figure specified at construction\n * time.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param count Number of 'value's to add to the histogram\n * @return false if any value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count);\n\n/**\n * Records count values in the histogram, will round this value of to a\n * precision at or better than the significant_figure specified at construction\n * time.\n *\n * Will record this value atomically, however the whole structure may appear inconsistent\n * when read concurrently with this update. Do NOT mix calls to this method with calls\n * to non-atomic updates.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param count Number of 'value's to add to the histogram\n * @return false if any value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count);\n\n/**\n * Record a value in the histogram and backfill based on an expected interval.\n *\n * Records a value in the histogram, will round this value of to a precision at or better\n * than the significant_figure specified at construction time. This is specifically used\n * for recording latency. If the value is larger than the expected_interval then the\n * latency recording system has experienced co-ordinated omission. This method fills in the\n * values that would have occurred had the client providing the load not been blocked.\n\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param expected_interval The delay between recording values.\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval);\n\n/**\n * Record a value in the histogram and backfill based on an expected interval.\n *\n * Records a value in the histogram, will round this value of to a precision at or better\n * than the significant_figure specified at construction time. This is specifically used\n * for recording latency. If the value is larger than the expected_interval then the\n * latency recording system has experienced co-ordinated omission. This method fills in the\n * values that would have occurred had the client providing the load not been blocked.\n *\n * Will record this value atomically, however the whole structure may appear inconsistent\n * when read concurrently with this update. Do NOT mix calls to this method with calls\n * to non-atomic updates.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param expected_interval The delay between recording values.\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval);\n\n/**\n * Record a value in the histogram 'count' times. Applies the same correcting logic\n * as 'hdr_record_corrected_value'.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param count Number of 'value's to add to the histogram\n * @param expected_interval The delay between recording values.\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval);\n\n/**\n * Record a value in the histogram 'count' times. Applies the same correcting logic\n * as 'hdr_record_corrected_value'.\n *\n * Will record this value atomically, however the whole structure may appear inconsistent\n * when read concurrently with this update. Do NOT mix calls to this method with calls\n * to non-atomic updates.\n *\n * @param h \"This\" pointer\n * @param value Value to add to the histogram\n * @param count Number of 'value's to add to the histogram\n * @param expected_interval The delay between recording values.\n * @return false if the value is larger than the highest_trackable_value and can't be recorded,\n * true otherwise.\n */\nbool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval);\n\n/**\n * Adds all of the values from 'from' to 'this' histogram. Will return the\n * number of values that are dropped when copying. Values will be dropped\n * if they around outside of h.lowest_discernible_value and\n * h.highest_trackable_value.\n *\n * @param h \"This\" pointer\n * @param from Histogram to copy values from.\n * @return The number of values dropped when copying.\n */\nint64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from);\n\n/**\n * Adds all of the values from 'from' to 'this' histogram. Will return the\n * number of values that are dropped when copying. Values will be dropped\n * if they around outside of h.lowest_discernible_value and\n * h.highest_trackable_value.\n *\n * @param h \"This\" pointer\n * @param from Histogram to copy values from.\n * @return The number of values dropped when copying.\n */\nint64_t hdr_add_while_correcting_for_coordinated_omission(\n struct hdr_histogram* h, struct hdr_histogram* from, int64_t expected_interval);\n\n/**\n * Get minimum value from the histogram. Will return 2^63-1 if the histogram\n * is empty.\n *\n * @param h \"This\" pointer\n */\nint64_t hdr_min(const struct hdr_histogram* h);\n\n/**\n * Get maximum value from the histogram. Will return 0 if the histogram\n * is empty.\n *\n * @param h \"This\" pointer\n */\nint64_t hdr_max(const struct hdr_histogram* h);\n\n/**\n * Get the value at a specific percentile.\n *\n * @param h \"This\" pointer.\n * @param percentile The percentile to get the value for\n */\nint64_t hdr_value_at_percentile(const struct hdr_histogram* h, double percentile);\n\n/**\n * Get the values at the given percentiles.\n *\n * @param h \"This\" pointer.\n * @param percentiles The ordered percentiles array to get the values for.\n * @param length Number of elements in the arrays.\n * @param values Destination array containing the values at the given percentiles.\n * The values array should be allocated by the caller.\n * @return 0 on success, ENOMEM if the provided destination array is null.\n */\nint hdr_value_at_percentiles(const struct hdr_histogram *h, const double *percentiles, int64_t *values, size_t length);\n\n/**\n * Gets the standard deviation for the values in the histogram.\n *\n * @param h \"This\" pointer\n * @return The standard deviation\n */\ndouble hdr_stddev(const struct hdr_histogram* h);\n\n/**\n * Gets the mean for the values in the histogram.\n *\n * @param h \"This\" pointer\n * @return The mean\n */\ndouble hdr_mean(const struct hdr_histogram* h);\n\n/**\n * Determine if two values are equivalent with the histogram's resolution.\n * Where \"equivalent\" means that value samples recorded for any two\n * equivalent values are counted in a common total count.\n *\n * @param h \"This\" pointer\n * @param a first value to compare\n * @param b second value to compare\n * @return 'true' if values are equivalent with the histogram's resolution.\n */\nbool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a, int64_t b);\n\n/**\n * Get the lowest value that is equivalent to the given value within the histogram's resolution.\n * Where \"equivalent\" means that value samples recorded for any two\n * equivalent values are counted in a common total count.\n *\n * @param h \"This\" pointer\n * @param value The given value\n * @return The lowest value that is equivalent to the given value within the histogram's resolution.\n */\nint64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64_t value);\n\n/**\n * Get the count of recorded values at a specific value\n * (to within the histogram resolution at the value level).\n *\n * @param h \"This\" pointer\n * @param value The value for which to provide the recorded count\n * @return The total count of values recorded in the histogram within the value range that is\n * {@literal >=} lowestEquivalentValue(value) and {@literal <=} highestEquivalentValue(value)\n */\nint64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value);\n\nint64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index);\n\nint64_t hdr_value_at_index(const struct hdr_histogram* h, int32_t index);\n\nstruct hdr_iter_percentiles\n{\n bool seen_last_value;\n int32_t ticks_per_half_distance;\n double percentile_to_iterate_to;\n double percentile;\n};\n\nstruct hdr_iter_recorded\n{\n int64_t count_added_in_this_iteration_step;\n};\n\nstruct hdr_iter_linear\n{\n int64_t value_units_per_bucket;\n int64_t count_added_in_this_iteration_step;\n int64_t next_value_reporting_level;\n int64_t next_value_reporting_level_lowest_equivalent;\n};\n\nstruct hdr_iter_log\n{\n double log_base;\n int64_t count_added_in_this_iteration_step;\n int64_t next_value_reporting_level;\n int64_t next_value_reporting_level_lowest_equivalent;\n};\n\n/**\n * The basic iterator. This is a generic structure\n * that supports all of the types of iteration. Use\n * the appropriate initialiser to get the desired\n * iteration.\n *\n * @\n */\nstruct hdr_iter\n{\n const struct hdr_histogram* h;\n /** raw index into the counts array */\n int32_t counts_index;\n /** snapshot of the length at the time the iterator is created */\n int64_t total_count;\n /** value directly from array for the current counts_index */\n int64_t count;\n /** sum of all of the counts up to and including the count at this index */\n int64_t cumulative_count;\n /** The current value based on counts_index */\n int64_t value;\n int64_t highest_equivalent_value;\n int64_t lowest_equivalent_value;\n int64_t median_equivalent_value;\n int64_t value_iterated_from;\n int64_t value_iterated_to;\n\n union\n {\n struct hdr_iter_percentiles percentiles;\n struct hdr_iter_recorded recorded;\n struct hdr_iter_linear linear;\n struct hdr_iter_log log;\n } specifics;\n\n bool (* _next_fp)(struct hdr_iter* iter);\n\n};\n\n/**\n * Initalises the basic iterator.\n *\n * @param itr 'This' pointer\n * @param h The histogram to iterate over\n */\nvoid hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h);\n\n/**\n * Initialise the iterator for use with percentiles.\n */\nvoid hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_histogram* h, int32_t ticks_per_half_distance);\n\n/**\n * Initialise the iterator for use with recorded values.\n */\nvoid hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h);\n\n/**\n * Initialise the iterator for use with linear values.\n */\nvoid hdr_iter_linear_init(\n struct hdr_iter* iter,\n const struct hdr_histogram* h,\n int64_t value_units_per_bucket);\n\n/**\n * Update the iterator value units per bucket\n */\nvoid hdr_iter_linear_set_value_units_per_bucket(struct hdr_iter* iter, int64_t value_units_per_bucket);\n\n/**\n * Initialise the iterator for use with logarithmic values\n */\nvoid hdr_iter_log_init(\n struct hdr_iter* iter,\n const struct hdr_histogram* h,\n int64_t value_units_first_bucket,\n double log_base);\n\n/**\n * Iterate to the next value for the iterator. If there are no more values\n * available return faluse.\n *\n * @param itr 'This' pointer\n * @return 'false' if there are no values remaining for this iterator.\n */\nbool hdr_iter_next(struct hdr_iter* iter);\n\ntypedef enum\n{\n CLASSIC,\n CSV\n} format_type;\n\n/**\n * Print out a percentile based histogram to the supplied stream. Note that\n * this call will not flush the FILE, this is left up to the user.\n *\n * @param h 'This' pointer\n * @param stream The FILE to write the output to\n * @param ticks_per_half_distance The number of iteration steps per half-distance to 100%\n * @param value_scale Scale the output values by this amount\n * @param format_type Format to use, e.g. CSV.\n * @return 0 on success, error code on failure. EIO if an error occurs writing\n * the output.\n */\nint hdr_percentiles_print(\n struct hdr_histogram* h, FILE* stream, int32_t ticks_per_half_distance,\n double value_scale, format_type format);\n\n/**\n* Internal allocation methods, used by hdr_dbl_histogram.\n*/\nstruct hdr_histogram_bucket_config\n{\n int64_t lowest_discernible_value;\n int64_t highest_trackable_value;\n int64_t unit_magnitude;\n int64_t significant_figures;\n int32_t sub_bucket_half_count_magnitude;\n int32_t sub_bucket_half_count;\n int64_t sub_bucket_mask;\n int32_t sub_bucket_count;\n int32_t bucket_count;\n int32_t counts_len;\n};\n\nint hdr_calculate_bucket_config(\n int64_t lowest_discernible_value,\n int64_t highest_trackable_value,\n int significant_figures,\n struct hdr_histogram_bucket_config* cfg);\n\nvoid hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram_bucket_config* cfg);\n\nint64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h, int64_t value);\n\nint64_t hdr_next_non_equivalent_value(const struct hdr_histogram* h, int64_t value);\n\nint64_t hdr_median_equivalent_value(const struct hdr_histogram* h, int64_t value);\n\n/**\n * Used to reset counters after importing data manually into the histogram, used by the logging code\n * and other custom serialisation tools.\n */\nvoid hdr_reset_internal_counters(struct hdr_histogram* h);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n" }, { "path": "deps/hdr_histogram/hdr_redis_malloc.h", "content": "#ifndef HDR_MALLOC_H__\n#define HDR_MALLOC_H__\n\nvoid *zmalloc(size_t size);\nvoid *zcalloc_num(size_t num, size_t size);\nvoid *zrealloc(void *ptr, size_t size);\nvoid zfree(void *ptr);\n\n#define hdr_malloc zmalloc\n#define hdr_calloc zcalloc_num\n#define hdr_realloc zrealloc\n#define hdr_free zfree\n#endif\n" }, { "path": "deps/hdr_histogram/hdr_tests.h", "content": "#ifndef HDR_TESTS_H\n#define HDR_TESTS_H\n\n/* These are functions used in tests and are not intended for normal usage. */\n\n#include \"hdr_histogram.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\nint32_t counts_index_for(const struct hdr_histogram* h, int64_t value);\nint hdr_encode_compressed(struct hdr_histogram* h, uint8_t** compressed_histogram, size_t* compressed_len);\nint hdr_decode_compressed(uint8_t* buffer, size_t length, struct hdr_histogram** histogram);\nvoid hdr_base64_decode_block(const char* input, uint8_t* output);\nvoid hdr_base64_encode_block(const uint8_t* input, char* output);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n" }, { "path": "deps/hiredis/.github/release-drafter-config.yml", "content": "name-template: '$NEXT_MAJOR_VERSION'\ntag-template: 'v$NEXT_MAJOR_VERSION'\nautolabeler:\n - label: 'maintenance'\n files:\n - '*.md'\n - '.github/*'\n - label: 'bug'\n branch:\n - '/bug-.+'\n - label: 'maintenance'\n branch:\n - '/maintenance-.+'\n - label: 'feature'\n branch:\n - '/feature-.+'\ncategories:\n - title: 'Breaking Changes'\n labels:\n - 'breakingchange'\n\n - title: '🧪 Experimental Features'\n labels:\n - 'experimental'\n - title: '🚀 New Features'\n labels:\n - 'feature'\n - 'enhancement'\n - title: '🐛 Bug Fixes'\n labels:\n - 'fix'\n - 'bugfix'\n - 'bug'\n - 'BUG'\n - title: '🧰 Maintenance'\n label: 'maintenance'\nchange-template: '- $TITLE @$AUTHOR (#$NUMBER)'\nexclude-labels:\n - 'skip-changelog'\ntemplate: |\n ## Changes\n\n $CHANGES\n\n ## Contributors\n We'd like to thank all the contributors who worked on this release!\n\n $CONTRIBUTORS\n\n" }, { "path": "deps/hiredis/.github/workflows/build.yml", "content": "name: Build and test\non: [push, pull_request]\n\njobs:\n ubuntu:\n name: Ubuntu\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v3\n\n - name: Install dependencies\n run: |\n curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg\n echo \"deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main\" | sudo tee /etc/apt/sources.list.d/redis.list\n sudo apt-get update\n sudo apt-get install -y redis-server valgrind libevent-dev\n\n - name: Build using cmake\n env:\n EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON\n CFLAGS: -Werror\n CXXFLAGS: -Werror\n run: mkdir build && cd build && cmake .. && make\n\n - name: Build using makefile\n run: USE_SSL=1 TEST_ASYNC=1 make\n\n - name: Run tests\n env:\n SKIPS_AS_FAILS: 1\n TEST_SSL: 1\n run: $GITHUB_WORKSPACE/test.sh\n\n # - name: Run tests under valgrind\n # env:\n # SKIPS_AS_FAILS: 1\n # TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full\n # run: $GITHUB_WORKSPACE/test.sh\n\n centos7:\n name: CentOS 7\n runs-on: ubuntu-latest\n container: centos:7\n steps:\n - uses: actions/checkout@v3\n\n - name: Install dependencies\n run: |\n yum -y install http://rpms.remirepo.net/enterprise/remi-release-7.rpm\n yum -y --enablerepo=remi install redis\n yum -y install gcc gcc-c++ make openssl openssl-devel cmake3 valgrind libevent-devel\n\n - name: Build using cmake\n env:\n EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON\n CFLAGS: -Werror\n CXXFLAGS: -Werror\n run: mkdir build && cd build && cmake3 .. && make\n\n - name: Build using Makefile\n run: USE_SSL=1 TEST_ASYNC=1 make\n\n - name: Run tests\n env:\n SKIPS_AS_FAILS: 1\n TEST_SSL: 1\n run: $GITHUB_WORKSPACE/test.sh\n\n - name: Run tests under valgrind\n env:\n SKIPS_AS_FAILS: 1\n TEST_SSL: 1\n TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full\n run: $GITHUB_WORKSPACE/test.sh\n\n centos8:\n name: RockyLinux 8\n runs-on: ubuntu-latest\n container: rockylinux:8\n steps:\n - uses: actions/checkout@v3\n\n - name: Install dependencies\n run: |\n dnf -y upgrade --refresh\n dnf -y install https://rpms.remirepo.net/enterprise/remi-release-8.rpm\n dnf -y module install redis:remi-6.0\n dnf -y group install \"Development Tools\"\n dnf -y install openssl-devel cmake valgrind libevent-devel\n\n - name: Build using cmake\n env:\n EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON\n CFLAGS: -Werror\n CXXFLAGS: -Werror\n run: mkdir build && cd build && cmake .. && make\n\n - name: Build using Makefile\n run: USE_SSL=1 TEST_ASYNC=1 make\n\n - name: Run tests\n env:\n SKIPS_AS_FAILS: 1\n TEST_SSL: 1\n run: $GITHUB_WORKSPACE/test.sh\n\n - name: Run tests under valgrind\n env:\n SKIPS_AS_FAILS: 1\n TEST_SSL: 1\n TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full\n run: $GITHUB_WORKSPACE/test.sh\n\n freebsd:\n runs-on: macos-12\n name: FreeBSD\n steps:\n - uses: actions/checkout@v3\n\n - name: Build in FreeBSD\n uses: vmactions/freebsd-vm@v0\n with:\n prepare: pkg install -y gmake cmake\n run: |\n mkdir build && cd build && cmake .. && make && cd ..\n gmake\n\n macos:\n name: macOS\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@v3\n\n - name: Install dependencies\n run: |\n brew install openssl redis@7.0\n brew link redis@7.0 --force\n\n - name: Build hiredis\n run: USE_SSL=1 make\n\n - name: Run tests\n env:\n TEST_SSL: 1\n run: $GITHUB_WORKSPACE/test.sh\n\n windows:\n name: Windows\n runs-on: windows-latest\n steps:\n - uses: actions/checkout@v3\n\n - name: Install dependencies\n run: |\n choco install -y ninja memurai-developer\n\n - uses: ilammy/msvc-dev-cmd@v1\n - name: Build hiredis\n run: |\n mkdir build && cd build\n cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DENABLE_EXAMPLES=ON\n ninja -v\n\n - name: Run tests\n run: |\n ./build/hiredis-test.exe\n\n - name: Install Cygwin Action\n uses: cygwin/cygwin-install-action@v2\n with:\n packages: make git gcc-core\n\n - name: Build in cygwin\n env:\n HIREDIS_PATH: ${{ github.workspace }}\n run: |\n make clean && make\n" }, { "path": "deps/hiredis/.github/workflows/release-drafter.yml", "content": "name: Release Drafter\n\non:\n push:\n # branches to consider in the event; optional, defaults to all\n branches:\n - master\n\njobs:\n update_release_draft:\n runs-on: ubuntu-latest\n steps:\n # Drafts your next Release notes as Pull Requests are merged into \"master\"\n - uses: release-drafter/release-drafter@v5\n with:\n # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml\n config-name: release-drafter-config.yml\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n" }, { "path": "deps/hiredis/.github/workflows/test.yml", "content": "name: C/C++ CI\n\non:\n push:\n branches: [ master ]\n pull_request:\n branches: [ master ]\n\njobs:\n full-build:\n name: Build all, plus default examples, run tests against redis\n runs-on: ubuntu-latest\n env:\n # the docker image used by the test.sh\n REDIS_DOCKER: redis:alpine\n\n steps:\n - name: Install prerequisites\n run: sudo apt-get update && sudo apt-get install -y libev-dev libevent-dev libglib2.0-dev libssl-dev valgrind\n - uses: actions/checkout@v3\n - name: Run make\n run: make all examples\n - name: Run unittests\n run: make check\n - name: Run tests with valgrind\n env:\n TEST_PREFIX: valgrind --error-exitcode=100\n SKIPS_ARG: --skip-throughput\n run: make check\n\n build-32-bit:\n name: Build and test minimal 32 bit linux\n runs-on: ubuntu-latest\n steps:\n - name: Install prerequisites\n run: sudo apt-get update && sudo apt-get install gcc-multilib\n - uses: actions/checkout@v3\n - name: Run make\n run: make all\n env:\n PLATFORM_FLAGS: -m32\n - name: Run unittests\n env:\n REDIS_DOCKER: redis:alpine\n run: make check\n\n build-arm:\n name: Cross-compile and test arm linux with Qemu\n runs-on: ubuntu-latest\n strategy:\n matrix:\n include:\n - name: arm\n toolset: arm-linux-gnueabi\n emulator: qemu-arm\n - name: aarch64\n toolset: aarch64-linux-gnu\n emulator: qemu-aarch64\n\n steps:\n - name: Install qemu\n if: matrix.emulator\n run: sudo apt-get update && sudo apt-get install -y qemu-user\n - name: Install platform toolset\n if: matrix.toolset\n run: sudo apt-get install -y gcc-${{matrix.toolset}}\n - uses: actions/checkout@v3\n - name: Run make\n run: make all\n env:\n CC: ${{matrix.toolset}}-gcc\n AR: ${{matrix.toolset}}-ar\n - name: Run unittests\n env:\n REDIS_DOCKER: redis:alpine\n TEST_PREFIX: ${{matrix.emulator}} -L /usr/${{matrix.toolset}}/\n run: make check\n\n build-windows:\n name: Build and test on windows 64 bit Intel\n runs-on: windows-latest\n steps:\n - uses: microsoft/setup-msbuild@v1.0.2\n - uses: actions/checkout@v3\n - name: Run CMake (shared lib)\n run: cmake -Wno-dev CMakeLists.txt\n - name: Build hiredis (shared lib)\n run: MSBuild hiredis.vcxproj /p:Configuration=Debug\n - name: Run CMake (static lib)\n run: cmake -Wno-dev CMakeLists.txt -DBUILD_SHARED_LIBS=OFF\n - name: Build hiredis (static lib)\n run: MSBuild hiredis.vcxproj /p:Configuration=Debug\n - name: Build hiredis-test\n run: MSBuild hiredis-test.vcxproj /p:Configuration=Debug\n # use memurai, redis compatible server, since it is easy to install. Can't\n # install official redis containers on the windows runner\n - name: Install Memurai redis server\n run: choco install -y memurai-developer.install\n - name: Run tests\n run: Debug\\hiredis-test.exe\n" }, { "path": "deps/hiredis/.gitignore", "content": "/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", "content": "language: c\ncompiler:\n - gcc\n - clang\n\nos:\n - linux\n - osx\n\ndist: bionic\n\nbranches:\n only:\n - staging\n - trying\n - master\n - /^release\\/.*$/\n\ninstall:\n - if [ \"$TRAVIS_COMPILER\" != \"mingw\" ]; then\n wget https://github.com/redis/redis/archive/6.0.6.tar.gz;\n tar -xzvf 6.0.6.tar.gz;\n pushd redis-6.0.6 && BUILD_TLS=yes make && export PATH=$PWD/src:$PATH && popd;\n fi;\n\nbefore_script:\n - if [ \"$TRAVIS_OS_NAME\" == \"osx\" ]; then\n curl -O https://distfiles.macports.org/MacPorts/MacPorts-2.6.2-10.13-HighSierra.pkg;\n sudo installer -pkg MacPorts-2.6.2-10.13-HighSierra.pkg -target /;\n export PATH=$PATH:/opt/local/bin && sudo port -v selfupdate;\n sudo port -N install openssl redis;\n fi;\n\naddons:\n apt:\n packages:\n - libc6-dbg\n - libc6-dev\n - libc6:i386\n - libc6-dev-i386\n - libc6-dbg:i386\n - gcc-multilib\n - g++-multilib\n - libssl-dev\n - libssl-dev:i386\n - valgrind\n\nenv:\n - BITS=\"32\"\n - BITS=\"64\"\n\nscript:\n - EXTRA_CMAKE_OPTS=\"-DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON\";\n if [ \"$TRAVIS_OS_NAME\" == \"osx\" ]; then\n if [ \"$BITS\" == \"32\" ]; then\n CFLAGS=\"-m32 -Werror\";\n CXXFLAGS=\"-m32 -Werror\";\n LDFLAGS=\"-m32\";\n EXTRA_CMAKE_OPTS=;\n else\n CFLAGS=\"-Werror\";\n CXXFLAGS=\"-Werror\";\n fi;\n else\n TEST_PREFIX=\"valgrind --track-origins=yes --leak-check=full\";\n if [ \"$BITS\" == \"32\" ]; then\n CFLAGS=\"-m32 -Werror\";\n CXXFLAGS=\"-m32 -Werror\";\n LDFLAGS=\"-m32\";\n EXTRA_CMAKE_OPTS=;\n else\n CFLAGS=\"-Werror\";\n CXXFLAGS=\"-Werror\";\n fi;\n fi;\n export CFLAGS CXXFLAGS LDFLAGS TEST_PREFIX EXTRA_CMAKE_OPTS\n - make && make clean;\n if [ \"$TRAVIS_OS_NAME\" == \"osx\" ]; then\n if [ \"$BITS\" == \"64\" ]; then\n OPENSSL_PREFIX=\"$(ls -d /usr/local/Cellar/openssl@1.1/*)\" USE_SSL=1 make;\n fi;\n else\n USE_SSL=1 make;\n fi;\n - mkdir build/ && cd build/\n - cmake .. ${EXTRA_CMAKE_OPTS}\n - make VERBOSE=1\n - if [ \"$BITS\" == \"64\" ]; then\n TEST_SSL=1 SKIPS_AS_FAILS=1 ctest -V;\n else\n SKIPS_AS_FAILS=1 ctest -V;\n fi;\n\njobs:\n include:\n # Windows MinGW cross compile on Linux\n - os: linux\n dist: xenial\n compiler: mingw\n addons:\n apt:\n packages:\n - ninja-build\n - gcc-mingw-w64-x86-64\n - g++-mingw-w64-x86-64\n script:\n - mkdir build && cd build\n - CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_WITH_INSTALL_RPATH=on\n - ninja -v\n\n # Windows MSVC 2017\n - os: windows\n compiler: msvc\n env:\n - MATRIX_EVAL=\"CC=cl.exe && CXX=cl.exe\"\n before_install:\n - eval \"${MATRIX_EVAL}\"\n install:\n - choco install ninja\n - choco install -y memurai-developer\n script:\n - mkdir build && cd build\n - cmd.exe //C 'C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Auxiliary\\Build\\vcvarsall.bat' amd64 '&&'\n cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DENABLE_EXAMPLES=ON '&&' ninja -v\n - ./hiredis-test.exe\n" }, { "path": "deps/hiredis/CHANGELOG.md", "content": "## [1.2.0](https://github.com/redis/hiredis/tree/v1.2.0) - (2023-06-04)\n\nAnnouncing Hiredis v1.2.0 with with new adapters, and a great many bug fixes.\n\n## 🚀 New Features\n\n- Add sdevent adapter @Oipo (#1144)\n- Allow specifying the keepalive interval @michael-grunder (#1168)\n- Add RedisModule adapter @tezc (#1182)\n- Helper for setting TCP_USER_TIMEOUT socket option @zuiderkwast (#1188)\n\n## 🐛 Bug Fixes\n\n- Fix a typo in b6a052f. @yossigo (#1190)\n- Fix wincrypt symbols conflict @hudayou (#1151)\n- Don't attempt to set a timeout if we are in an error state. @michael-grunder (#1180)\n- Accept -nan per the RESP3 spec recommendation. @michael-grunder (#1178)\n- Fix colliding option values @zuiderkwast (#1172)\n- Ensure functionality without `_MSC_VER` definition @windyakin (#1194)\n\n## 🧰 Maintenance\n\n- Add a test for the TCP_USER_TIMEOUT option. @michael-grunder (#1192)\n- Add -Werror as a default. @yossigo (#1193)\n- CI: Update homebrew Redis version. @yossigo (#1191)\n- Fix typo in makefile. @michael-grunder (#1179)\n- Write a version file for the CMake package @Neverlord (#1165)\n- CMakeLists.txt: respect BUILD_SHARED_LIBS @ffontaine (#1147)\n- Cmake static or shared @autoantwort (#1160)\n- fix typo @tillkruss (#1153)\n- Add a test ensuring we don't clobber connection error. @michael-grunder (#1181)\n- Search for openssl on macOS @michael-grunder (#1169)\n\n\n## Contributors\nWe'd like to thank all the contributors who worked on this release!\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n## [1.1.0](https://github.com/redis/hiredis/tree/v1.1.0) - (2022-11-15)\n\nAnnouncing Hiredis v1.1.0 GA with better SSL convenience, new async adapters and a great many bug fixes.\n\n**NOTE**: Hiredis can now return `nan` in addition to `-inf` and `inf` when returning a `REDIS_REPLY_DOUBLE`.\n\n## 🐛 Bug Fixes\n\n- Add support for nan in RESP3 double [@filipecosta90](https://github.com/filipecosta90)\n ([\\#1133](https://github.com/redis/hiredis/pull/1133))\n\n## 🧰 Maintenance\n\n- Add an example that calls redisCommandArgv [@michael-grunder](https://github.com/michael-grunder)\n ([\\#1140](https://github.com/redis/hiredis/pull/1140))\n- fix flag reference [@pata00](https://github.com/pata00) ([\\#1136](https://github.com/redis/hiredis/pull/1136))\n- Make freeing a NULL redisAsyncContext a no op. [@michael-grunder](https://github.com/michael-grunder)\n ([\\#1135](https://github.com/redis/hiredis/pull/1135))\n- CI updates ([@bjosv](https://github.com/redis/bjosv) ([\\#1139](https://github.com/redis/hiredis/pull/1139))\n\n\n## Contributors\nWe'd like to thank all the contributors who worked on this release!\n\n\n\n\n\n\n## [1.1.0-rc1](https://github.com/redis/hiredis/tree/v1.1.0-rc1) - (2022-11-06)\n\nAnnouncing Hiredis v1.1.0-rc1, with better SSL convenience, new async adapters, and a great many bug fixes.\n\n## 🚀 New Features\n\n- Add possibility to prefer IPv6, IPv4 or unspecified [@zuiderkwast](https://github.com/zuiderkwast)\n ([\\#1096](https://github.com/redis/hiredis/pull/1096))\n- Add adapters/libhv [@ithewei](https://github.com/ithewei) ([\\#904](https://github.com/redis/hiredis/pull/904))\n- Add timeout support to libhv adapter. [@michael-grunder](https://github.com/michael-grunder) ([\\#1109](https://github.com/redis/hiredis/pull/1109))\n- set default SSL verification path [@adobeturchenko](https://github.com/adobeturchenko) ([\\#928](https://github.com/redis/hiredis/pull/928))\n- Introduce .close method for redisContextFuncs [@pizhenwei](https://github.com/pizhenwei) ([\\#1094](https://github.com/redis/hiredis/pull/1094))\n- Make it possible to set SSL verify mode [@stanhu](https://github.com/stanhu) ([\\#1085](https://github.com/redis/hiredis/pull/1085))\n- Polling adapter and example [@kristjanvalur](https://github.com/kristjanvalur) ([\\#932](https://github.com/redis/hiredis/pull/932))\n- Unsubscribe handling in async [@bjosv](https://github.com/bjosv) ([\\#1047](https://github.com/redis/hiredis/pull/1047))\n- Add timeout support for libuv adapter [@MichaelSuen-thePointer](https://github.com/@MichaelSuenthePointer) ([\\#1016](https://github.com/redis/hiredis/pull/1016))\n\n## 🐛 Bug Fixes\n\n- Update for MinGW cross compile [@bit0fun](https://github.com/bit0fun) ([\\#1127](https://github.com/redis/hiredis/pull/1127))\n- fixed CPP build error with adapters/libhv.h [@mtdxc](https://github.com/mtdxc) ([\\#1125](https://github.com/redis/hiredis/pull/1125))\n- Fix protocol error\n [@michael-grunder](https://github.com/michael-grunder),\n [@mtuleika-appcast](https://github.com/mtuleika-appcast) ([\\#1106](https://github.com/redis/hiredis/pull/1106))\n- Use a windows specific keepalive function. [@michael-grunder](https://github.com/michael-grunder) ([\\#1104](https://github.com/redis/hiredis/pull/1104))\n- Fix CMake config path on Linux. [@xkszltl](https://github.com/xkszltl) ([\\#989](https://github.com/redis/hiredis/pull/989))\n- Fix potential fault at createDoubleObject [@afcidk](https://github.com/afcidk) ([\\#964](https://github.com/redis/hiredis/pull/964))\n- Fix some undefined behavior [@jengab](https://github.com/jengab) ([\\#1091](https://github.com/redis/hiredis/pull/1091))\n- Copy OOM errors to redisAsyncContext when finding subscribe callback [@bjosv](https://github.com/bjosv) ([\\#1090](https://github.com/redis/hiredis/pull/1090))\n- Maintain backward compatibility with our onConnect callback. [@michael-grunder](https://github.com/michael-grunder) ([\\#1087](https://github.com/redis/hiredis/pull/1087))\n- Fix PUSH handler tests for Redis >= 7.0.5 [@michael-grunder](https://github.com/michael-grunder) ([\\#1121](https://github.com/redis/hiredis/pull/1121))\n- fix heap-buffer-overflow [@zhangtaoXT5](https://github.com/zhangtaoXT5) ([\\#957](https://github.com/redis/hiredis/pull/957))\n- Fix heap-buffer-overflow issue in redisvFormatCommad [@bjosv](https://github.com/bjosv) ([\\#1097](https://github.com/redis/hiredis/pull/1097))\n- Polling adapter requires sockcompat.h [@michael-grunder](https://github.com/michael-grunder) ([\\#1095](https://github.com/redis/hiredis/pull/1095))\n- Illumos test fixes, error message difference for bad hostname test. [@devnexen](https://github.com/devnexen) ([\\#901](https://github.com/redis/hiredis/pull/901))\n- Remove semicolon after do-while in \\_EL\\_CLEANUP [@sundb](https://github.com/sundb) ([\\#905](https://github.com/redis/hiredis/pull/905))\n- Stability: Support calling redisAsyncCommand and redisAsyncDisconnect from the onConnected callback [@kristjanvalur](https://github.com/kristjanvalur)\n ([\\#931](https://github.com/redis/hiredis/pull/931))\n- Fix async connect on Windows [@kristjanvalur](https://github.com/kristjanvalur) ([\\#1073](https://github.com/redis/hiredis/pull/1073))\n- Fix tests so they work for Redis 7.0 [@michael-grunder](https://github.com/michael-grunder) ([\\#1072](https://github.com/redis/hiredis/pull/1072))\n- Fix warnings on Win64 [@orgads](https://github.com/orgads) ([\\#1058](https://github.com/redis/hiredis/pull/1058))\n- Handle push notifications before or after reply. [@yossigo](https://github.com/yossigo) ([\\#1062](https://github.com/redis/hiredis/pull/1062))\n- Update hiredis sds with improvements found in redis [@bjosv](https://github.com/bjosv) ([\\#1045](https://github.com/redis/hiredis/pull/1045))\n- Avoid incorrect call to the previous reply's callback [@bjosv](https://github.com/bjosv) ([\\#1040](https://github.com/redis/hiredis/pull/1040))\n- fix building on AIX and SunOS [\\#1031](https://github.com/redis/hiredis/pull/1031) ([@scddev](https://github.com/scddev))\n- Allow sending commands after sending an unsubscribe [@bjosv](https://github.com/bjosv) ([\\#1036](https://github.com/redis/hiredis/pull/1036))\n- Correction for command timeout during pubsub [@bjosv](https://github.com/bjosv) ([\\#1038](https://github.com/redis/hiredis/pull/1038))\n- Fix adapters/libevent.h compilation for 64-bit Windows [@pbtummillo](https://github.com/pbtummillo) ([\\#937](https://github.com/redis/hiredis/pull/937))\n- Fix integer overflow when format command larger than 4GB [@sundb](https://github.com/sundb) ([\\#1030](https://github.com/redis/hiredis/pull/1030))\n- Handle array response during subscribe in RESP3 [@bjosv](https://github.com/bjosv) ([\\#1014](https://github.com/redis/hiredis/pull/1014))\n- Support PING while subscribing (RESP2) [@bjosv](https://github.com/bjosv) ([\\#1027](https://github.com/redis/hiredis/pull/1027))\n\n## 🧰 Maintenance\n\n- CI fixes in preparation of release [@michael-grunder](https://github.com/michael-grunder) ([\\#1130](https://github.com/redis/hiredis/pull/1130))\n- Add do while(0) (protection for macros [@afcidk](https://github.com/afcidk) [\\#959](https://github.com/redis/hiredis/pull/959))\n- Fixup of PR734: Coverage of hiredis.c [@bjosv](https://github.com/bjosv) ([\\#1124](https://github.com/redis/hiredis/pull/1124))\n- CMake corrections for building on Windows [@bjosv](https://github.com/bjosv) ([\\#1122](https://github.com/redis/hiredis/pull/1122))\n- Install on windows fixes [@bjosv](https://github.com/bjosv) ([\\#1117](https://github.com/redis/hiredis/pull/1117))\n- Add libhv example to our standard Makefile [@michael-grunder](https://github.com/michael-grunder) ([\\#1108](https://github.com/redis/hiredis/pull/1108))\n- Additional include directory given by pkg-config [@bjosv](https://github.com/bjosv) ([\\#1118](https://github.com/redis/hiredis/pull/1118))\n- Use __attribute__ when building with Clang on Windows [@bjosv](https://github.com/bjosv) ([\\#1115](https://github.com/redis/hiredis/pull/1115))\n- Minor refactor [@michael-grunder](https://github.com/michael-grunder) ([\\#1110](https://github.com/redis/hiredis/pull/1110))\n- Fix pkgconfig result for hiredis_ssl [@bjosv](https://github.com/bjosv) ([\\#1107](https://github.com/redis/hiredis/pull/1107))\n- Update documentation to explain redisConnectWithOptions. [@michael-grunder](https://github.com/michael-grunder) ([\\#1099](https://github.com/redis/hiredis/pull/1099))\n- uvadapter: reduce number of uv_poll_start calls [@noxiouz](https://github.com/noxiouz) ([\\#1098](https://github.com/redis/hiredis/pull/1098))\n- Regression test for off-by-one parsing error [@bugwz](https://github.com/bugwz) ([\\#1092](https://github.com/redis/hiredis/pull/1092))\n- CMake: remove dict.c form hiredis_sources [@Lipraxde](https://github.com/Lipraxde) ([\\#1055](https://github.com/redis/hiredis/pull/1055))\n- Do store command timeout in the context for redisSetTimeout [@catterer](https://github.com/catterer) ([\\#593](https://github.com/redis/hiredis/pull/593), [\\#1093](https://github.com/redis/hiredis/pull/1093))\n- Add GitHub Actions CI workflow for hiredis: Arm, Arm64, 386, windows. [@kristjanvalur](https://github.com/kristjanvalur) ([\\#943](https://github.com/redis/hiredis/pull/943))\n- CI: bump macOS runner version [@SukkaW](https://github.com/SukkaW) ([\\#1079](https://github.com/redis/hiredis/pull/1079))\n- Support for generating release notes [@chayim](https://github.com/chayim) ([\\#1083](https://github.com/redis/hiredis/pull/1083))\n- Improve example for SSL initialization in README.md [@stanhu](https://github.com/stanhu) ([\\#1084](https://github.com/redis/hiredis/pull/1084))\n- Fix README typos [@bjosv](https://github.com/bjosv) ([\\#1080](https://github.com/redis/hiredis/pull/1080))\n- fix cmake version [@smmir-cent](https://github.com/@smmircent) ([\\#1050](https://github.com/redis/hiredis/pull/1050))\n- Use the same name for static and shared libraries [@orgads](https://github.com/orgads) ([\\#1057](https://github.com/redis/hiredis/pull/1057))\n- Embed debug information in windows static .lib file [@kristjanvalur](https://github.com/kristjanvalur) ([\\#1054](https://github.com/redis/hiredis/pull/1054))\n- Improved async documentation [@kristjanvalur](https://github.com/kristjanvalur) ([\\#1074](https://github.com/redis/hiredis/pull/1074))\n- Use official repository for redis package. [@yossigo](https://github.com/yossigo) ([\\#1061](https://github.com/redis/hiredis/pull/1061))\n- Whitelist hiredis repo path in cygwin [@michael-grunder](https://github.com/michael-grunder) ([\\#1063](https://github.com/redis/hiredis/pull/1063))\n- CentOS 8 is EOL, switch to RockyLinux [@michael-grunder](https://github.com/michael-grunder) ([\\#1046](https://github.com/redis/hiredis/pull/1046))\n- CMakeLists.txt: allow building without a C++ compiler [@ffontaine](https://github.com/ffontaine) ([\\#872](https://github.com/redis/hiredis/pull/872))\n- Makefile: move SSL options into a block and refine rules [@pizhenwei](https://github.com/pizhenwei) ([\\#997](https://github.com/redis/hiredis/pull/997))\n- Update CMakeLists.txt for more portability [@EricDeng1001](https://github.com/EricDeng1001) ([\\#1005](https://github.com/redis/hiredis/pull/1005))\n- FreeBSD build fixes + CI [@michael-grunder](https://github.com/michael-grunder) ([\\#1026](https://github.com/redis/hiredis/pull/1026))\n- Add asynchronous test for pubsub using RESP3 [@bjosv](https://github.com/bjosv) ([\\#1012](https://github.com/redis/hiredis/pull/1012))\n- Trigger CI failure when Valgrind issues are found [@bjosv](https://github.com/bjosv) ([\\#1011](https://github.com/redis/hiredis/pull/1011))\n- Move to using make directly in Cygwin [@michael-grunder](https://github.com/michael-grunder) ([\\#1020](https://github.com/redis/hiredis/pull/1020))\n- Add asynchronous API tests [@bjosv](https://github.com/bjosv) ([\\#1010](https://github.com/redis/hiredis/pull/1010))\n- Correcting the build target `coverage` for enabled SSL [@bjosv](https://github.com/bjosv) ([\\#1009](https://github.com/redis/hiredis/pull/1009))\n- GH Actions: Run SSL tests during CI [@bjosv](https://github.com/bjosv) ([\\#1008](https://github.com/redis/hiredis/pull/1008))\n- GH: Actions - Add valgrind and CMake [@michael-grunder](https://github.com/michael-grunder) ([\\#1004](https://github.com/redis/hiredis/pull/1004))\n- Add Centos8 tests in GH Actions [@michael-grunder](https://github.com/michael-grunder) ([\\#1001](https://github.com/redis/hiredis/pull/1001))\n- We should run actions on PRs [@michael-grunder](https://github.com/michael-grunder) (([\\#1000](https://github.com/redis/hiredis/pull/1000))\n- Add Cygwin test in GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\\#999](https://github.com/redis/hiredis/pull/999))\n- Add Windows tests in GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\\#996](https://github.com/redis/hiredis/pull/996))\n- Switch to GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\\#995](https://github.com/redis/hiredis/pull/995))\n- Minor refactor of CVE-2021-32765 fix. [@michael-grunder](https://github.com/michael-grunder) ([\\#993](https://github.com/redis/hiredis/pull/993))\n- Remove extra comma from CMake var. [@xkszltl](https://github.com/xkszltl) ([\\#988](https://github.com/redis/hiredis/pull/988))\n- Add REDIS\\_OPT\\_PREFER\\_UNSPEC [@michael-grunder](https://github.com/michael-grunder) ([\\#1101](https://github.com/redis/hiredis/pull/1101))\n\n## Contributors\nWe'd like to thank all the contributors who worked on this release!\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n## [1.0.2](https://github.com/redis/hiredis/tree/v1.0.2) - (2021-10-07)\n\nAnnouncing Hiredis v1.0.2, which fixes CVE-2021-32765 but returns the SONAME to the correct value of `1.0.0`.\n\n- [Revert SONAME bump](https://github.com/redis/hiredis/commit/d4e6f109a064690cde64765c654e679fea1d3548)\n ([Michael Grunder](https://github.com/michael-grunder))\n\n## [1.0.1](https://github.com/redis/hiredis/tree/v1.0.1) - (2021-10-04)\n\nThis release erroneously bumped the SONAME, please use [1.0.2](https://github.com/redis/hiredis/tree/v1.0.2)\n\nAnnouncing Hiredis v1.0.1, a security release fixing CVE-2021-32765\n\n- Fix for [CVE-2021-32765](https://github.com/redis/hiredis/security/advisories/GHSA-hfm9-39pp-55p2)\n [commit](https://github.com/redis/hiredis/commit/76a7b10005c70babee357a7d0f2becf28ec7ed1e)\n ([Yossi Gottlieb](https://github.com/yossigo))\n\n_Thanks to [Yossi Gottlieb](https://github.com/yossigo) for the security fix and to [Microsoft Security Vulnerability Research](https://www.microsoft.com/en-us/msrc/msvr) for finding the bug._ :sparkling_heart:\n\n## [1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) - (2020-08-03)\n\nAnnouncing Hiredis v1.0.0, which adds support for RESP3, SSL connections, allocator injection, and better Windows support! :tada:\n\n_A big thanks to everyone who helped with this release. The following list includes everyone who contributed at least five lines, sorted by lines contributed._ :sparkling_heart:\n\n[Michael Grunder](https://github.com/michael-grunder), [Yossi Gottlieb](https://github.com/yossigo),\n[Mark Nunberg](https://github.com/mnunberg), [Marcus Geelnard](https://github.com/mbitsnbites),\n[Justin Brewer](https://github.com/justinbrewer), [Valentino Geron](https://github.com/valentinogeron),\n[Minun Dragonation](https://github.com/dragonation), [Omri Steiner](https://github.com/OmriSteiner),\n[Sangmoon Yi](https://github.com/jman-krafton), [Jinjiazh](https://github.com/jinjiazhang),\n[Odin Hultgren Van Der Horst](https://github.com/Miniwoffer), [Muhammad Zahalqa](https://github.com/tryfinally),\n[Nick Rivera](https://github.com/heronr), [Qi Yang](https://github.com/movebean),\n[kevin1018](https://github.com/kevin1018)\n\n[Full Changelog](https://github.com/redis/hiredis/compare/v0.14.1...v1.0.0)\n\n**BREAKING CHANGES**:\n\n* `redisOptions` now has two timeout fields. One for connecting, and one for commands. If you're presently using `options->timeout` you will need to change it to use `options->connect_timeout`. (See [example](https://github.com/redis/hiredis/commit/38b5ae543f5c99eb4ccabbe277770fc6bc81226f#diff-86ba39d37aa829c8c82624cce4f049fbL36))\n\n* Bulk and multi-bulk lengths less than -1 or greater than `LLONG_MAX` are now protocol errors. This is consistent\n with the RESP specification. On 32-bit platforms, the upper bound is lowered to `SIZE_MAX`.\n\n* `redisReplyObjectFunctions.createArray` now takes `size_t` for its length parameter.\n\n**New features:**\n- Support for RESP3\n [\\#697](https://github.com/redis/hiredis/pull/697),\n [\\#805](https://github.com/redis/hiredis/pull/805),\n [\\#819](https://github.com/redis/hiredis/pull/819),\n [\\#841](https://github.com/redis/hiredis/pull/841)\n ([Yossi Gottlieb](https://github.com/yossigo), [Michael Grunder](https://github.com/michael-grunder))\n- Support for SSL connections\n [\\#645](https://github.com/redis/hiredis/pull/645),\n [\\#699](https://github.com/redis/hiredis/pull/699),\n [\\#702](https://github.com/redis/hiredis/pull/702),\n [\\#708](https://github.com/redis/hiredis/pull/708),\n [\\#711](https://github.com/redis/hiredis/pull/711),\n [\\#821](https://github.com/redis/hiredis/pull/821),\n [more](https://github.com/redis/hiredis/pulls?q=is%3Apr+is%3Amerged+SSL)\n ([Mark Nunberg](https://github.com/mnunberg), [Yossi Gottlieb](https://github.com/yossigo))\n- Run-time allocator injection\n [\\#800](https://github.com/redis/hiredis/pull/800)\n ([Michael Grunder](https://github.com/michael-grunder))\n- Improved Windows support (including MinGW and Windows CI)\n [\\#652](https://github.com/redis/hiredis/pull/652),\n [\\#663](https://github.com/redis/hiredis/pull/663)\n ([Marcus Geelnard](https://www.bitsnbites.eu/author/m/))\n- Adds support for distinct connect and command timeouts\n [\\#839](https://github.com/redis/hiredis/pull/839),\n [\\#829](https://github.com/redis/hiredis/pull/829)\n ([Valentino Geron](https://github.com/valentinogeron))\n- Add generic pointer and destructor to `redisContext` that users can use for context.\n [\\#855](https://github.com/redis/hiredis/pull/855)\n ([Michael Grunder](https://github.com/michael-grunder))\n\n**Closed issues (that involved code changes):**\n\n- Makefile does not install TLS libraries [\\#809](https://github.com/redis/hiredis/issues/809)\n- redisConnectWithOptions should not set command timeout [\\#722](https://github.com/redis/hiredis/issues/722), [\\#829](https://github.com/redis/hiredis/pull/829) ([valentinogeron](https://github.com/valentinogeron))\n- Fix integer overflow in `sdsrange` [\\#827](https://github.com/redis/hiredis/issues/827)\n- INFO & CLUSTER commands failed when using RESP3 [\\#802](https://github.com/redis/hiredis/issues/802)\n- Windows compatibility patches [\\#687](https://github.com/redis/hiredis/issues/687), [\\#838](https://github.com/redis/hiredis/issues/838), [\\#842](https://github.com/redis/hiredis/issues/842)\n- RESP3 PUSH messages incorrectly use pending callback [\\#825](https://github.com/redis/hiredis/issues/825)\n- Asynchronous PSUBSCRIBE command fails when using RESP3 [\\#815](https://github.com/redis/hiredis/issues/815)\n- New SSL API [\\#804](https://github.com/redis/hiredis/issues/804), [\\#813](https://github.com/redis/hiredis/issues/813)\n- Hard-coded limit of nested reply depth [\\#794](https://github.com/redis/hiredis/issues/794)\n- Fix TCP_NODELAY in Windows/OSX [\\#679](https://github.com/redis/hiredis/issues/679), [\\#690](https://github.com/redis/hiredis/issues/690), [\\#779](https://github.com/redis/hiredis/issues/779), [\\#785](https://github.com/redis/hiredis/issues/785),\n- Added timers to libev adapter. [\\#778](https://github.com/redis/hiredis/issues/778), [\\#795](https://github.com/redis/hiredis/pull/795)\n- Initialization discards const qualifier [\\#777](https://github.com/redis/hiredis/issues/777)\n- \\[BUG\\]\\[MinGW64\\] Error setting socket timeout [\\#775](https://github.com/redis/hiredis/issues/775)\n- undefined reference to hi_malloc [\\#769](https://github.com/redis/hiredis/issues/769)\n- hiredis pkg-config file incorrectly ignores multiarch libdir spec'n [\\#767](https://github.com/redis/hiredis/issues/767)\n- Don't use -G to build shared object on Solaris [\\#757](https://github.com/redis/hiredis/issues/757)\n- error when make USE\\_SSL=1 [\\#748](https://github.com/redis/hiredis/issues/748)\n- Allow to change SSL Mode [\\#646](https://github.com/redis/hiredis/issues/646)\n- hiredis/adapters/libevent.h memleak [\\#618](https://github.com/redis/hiredis/issues/618)\n- redisLibuvPoll crash when server closes the connetion [\\#545](https://github.com/redis/hiredis/issues/545)\n- about redisAsyncDisconnect question [\\#518](https://github.com/redis/hiredis/issues/518)\n- hiredis adapters libuv error for help [\\#508](https://github.com/redis/hiredis/issues/508)\n- API/ABI changes analysis [\\#506](https://github.com/redis/hiredis/issues/506)\n- Memory leak patch in Redis [\\#502](https://github.com/redis/hiredis/issues/502)\n- Remove the depth limitation [\\#421](https://github.com/redis/hiredis/issues/421)\n\n**Merged pull requests:**\n\n- Move SSL management to a distinct private pointer [\\#855](https://github.com/redis/hiredis/pull/855) ([michael-grunder](https://github.com/michael-grunder))\n- Move include to sockcompat.h to maintain style [\\#850](https://github.com/redis/hiredis/pull/850) ([michael-grunder](https://github.com/michael-grunder))\n- Remove erroneous tag and add license to push example [\\#849](https://github.com/redis/hiredis/pull/849) ([michael-grunder](https://github.com/michael-grunder))\n- fix windows compiling with mingw [\\#848](https://github.com/redis/hiredis/pull/848) ([rmalizia44](https://github.com/rmalizia44))\n- Some Windows quality of life improvements. [\\#846](https://github.com/redis/hiredis/pull/846) ([michael-grunder](https://github.com/michael-grunder))\n- Use \\_WIN32 define instead of WIN32 [\\#845](https://github.com/redis/hiredis/pull/845) ([michael-grunder](https://github.com/michael-grunder))\n- Non Linux CI fixes [\\#844](https://github.com/redis/hiredis/pull/844) ([michael-grunder](https://github.com/michael-grunder))\n- Resp3 oob push support [\\#841](https://github.com/redis/hiredis/pull/841) ([michael-grunder](https://github.com/michael-grunder))\n- fix \\#785: defer TCP\\_NODELAY in async tcp connections [\\#836](https://github.com/redis/hiredis/pull/836) ([OmriSteiner](https://github.com/OmriSteiner))\n- sdsrange overflow fix [\\#830](https://github.com/redis/hiredis/pull/830) ([michael-grunder](https://github.com/michael-grunder))\n- Use explicit pointer casting for c++ compatibility [\\#826](https://github.com/redis/hiredis/pull/826) ([aureus1](https://github.com/aureus1))\n- Document allocator injection and completeness fix in test.c [\\#824](https://github.com/redis/hiredis/pull/824) ([michael-grunder](https://github.com/michael-grunder))\n- Use unique names for allocator struct members [\\#823](https://github.com/redis/hiredis/pull/823) ([michael-grunder](https://github.com/michael-grunder))\n- New SSL API to replace redisSecureConnection\\(\\). [\\#821](https://github.com/redis/hiredis/pull/821) ([yossigo](https://github.com/yossigo))\n- Add logic to handle RESP3 push messages [\\#819](https://github.com/redis/hiredis/pull/819) ([michael-grunder](https://github.com/michael-grunder))\n- Use standrad isxdigit instead of custom helper function. [\\#814](https://github.com/redis/hiredis/pull/814) ([tryfinally](https://github.com/tryfinally))\n- Fix missing SSL build/install options. [\\#812](https://github.com/redis/hiredis/pull/812) ([yossigo](https://github.com/yossigo))\n- Add link to ABI tracker [\\#808](https://github.com/redis/hiredis/pull/808) ([michael-grunder](https://github.com/michael-grunder))\n- Resp3 verbatim string support [\\#805](https://github.com/redis/hiredis/pull/805) ([michael-grunder](https://github.com/michael-grunder))\n- Allow users to replace allocator and handle OOM everywhere. [\\#800](https://github.com/redis/hiredis/pull/800) ([michael-grunder](https://github.com/michael-grunder))\n- Remove nested depth limitation. [\\#797](https://github.com/redis/hiredis/pull/797) ([michael-grunder](https://github.com/michael-grunder))\n- Attempt to fix compilation on Solaris [\\#796](https://github.com/redis/hiredis/pull/796) ([michael-grunder](https://github.com/michael-grunder))\n- Support timeouts in libev adapater [\\#795](https://github.com/redis/hiredis/pull/795) ([michael-grunder](https://github.com/michael-grunder))\n- Fix pkgconfig when installing to a custom lib dir [\\#793](https://github.com/redis/hiredis/pull/793) ([michael-grunder](https://github.com/michael-grunder))\n- Fix USE\\_SSL=1 make/cmake on OSX and CMake tests [\\#789](https://github.com/redis/hiredis/pull/789) ([michael-grunder](https://github.com/michael-grunder))\n- Use correct libuv call on Windows [\\#784](https://github.com/redis/hiredis/pull/784) ([michael-grunder](https://github.com/michael-grunder))\n- Added CMake package config and fixed hiredis\\_ssl on Windows [\\#783](https://github.com/redis/hiredis/pull/783) ([michael-grunder](https://github.com/michael-grunder))\n- CMake: Set hiredis\\_ssl shared object version. [\\#780](https://github.com/redis/hiredis/pull/780) ([yossigo](https://github.com/yossigo))\n- Win32 tests and timeout fix [\\#776](https://github.com/redis/hiredis/pull/776) ([michael-grunder](https://github.com/michael-grunder))\n- Provides an optional cleanup callback for async data. [\\#768](https://github.com/redis/hiredis/pull/768) ([heronr](https://github.com/heronr))\n- Housekeeping fixes [\\#764](https://github.com/redis/hiredis/pull/764) ([michael-grunder](https://github.com/michael-grunder))\n- install alloc.h [\\#756](https://github.com/redis/hiredis/pull/756) ([ch1aki](https://github.com/ch1aki))\n- fix spelling mistakes [\\#746](https://github.com/redis/hiredis/pull/746) ([ShooterIT](https://github.com/ShooterIT))\n- Free the reply in redisGetReply when passed NULL [\\#741](https://github.com/redis/hiredis/pull/741) ([michael-grunder](https://github.com/michael-grunder))\n- Fix dead code in sslLogCallback relating to should\\_log variable. [\\#737](https://github.com/redis/hiredis/pull/737) ([natoscott](https://github.com/natoscott))\n- Fix typo in dict.c. [\\#731](https://github.com/redis/hiredis/pull/731) ([Kevin-Xi](https://github.com/Kevin-Xi))\n- Adding an option to DISABLE\\_TESTS [\\#727](https://github.com/redis/hiredis/pull/727) ([pbotros](https://github.com/pbotros))\n- Update README with SSL support. [\\#720](https://github.com/redis/hiredis/pull/720) ([yossigo](https://github.com/yossigo))\n- Fixes leaks in unit tests [\\#715](https://github.com/redis/hiredis/pull/715) ([michael-grunder](https://github.com/michael-grunder))\n- SSL Tests [\\#711](https://github.com/redis/hiredis/pull/711) ([yossigo](https://github.com/yossigo))\n- SSL Reorganization [\\#708](https://github.com/redis/hiredis/pull/708) ([yossigo](https://github.com/yossigo))\n- Fix MSVC build. [\\#706](https://github.com/redis/hiredis/pull/706) ([yossigo](https://github.com/yossigo))\n- SSL: Properly report SSL\\_connect\\(\\) errors. [\\#702](https://github.com/redis/hiredis/pull/702) ([yossigo](https://github.com/yossigo))\n- Silent SSL trace to stdout by default. [\\#699](https://github.com/redis/hiredis/pull/699) ([yossigo](https://github.com/yossigo))\n- Port RESP3 support from Redis. [\\#697](https://github.com/redis/hiredis/pull/697) ([yossigo](https://github.com/yossigo))\n- Removed whitespace before newline [\\#691](https://github.com/redis/hiredis/pull/691) ([Miniwoffer](https://github.com/Miniwoffer))\n- Add install adapters header files [\\#688](https://github.com/redis/hiredis/pull/688) ([kevin1018](https://github.com/kevin1018))\n- Remove unnecessary null check before free [\\#684](https://github.com/redis/hiredis/pull/684) ([qlyoung](https://github.com/qlyoung))\n- redisReaderGetReply leak memory [\\#671](https://github.com/redis/hiredis/pull/671) ([movebean](https://github.com/movebean))\n- fix timeout code in windows [\\#670](https://github.com/redis/hiredis/pull/670) ([jman-krafton](https://github.com/jman-krafton))\n- test: fix errstr matching for musl libc [\\#665](https://github.com/redis/hiredis/pull/665) ([ghost](https://github.com/ghost))\n- Windows: MinGW fixes and Windows Travis builders [\\#663](https://github.com/redis/hiredis/pull/663) ([mbitsnbites](https://github.com/mbitsnbites))\n- The setsockopt and getsockopt API diffs from BSD socket and WSA one [\\#662](https://github.com/redis/hiredis/pull/662) ([dragonation](https://github.com/dragonation))\n- Fix Compile Error On Windows \\(Visual Studio\\) [\\#658](https://github.com/redis/hiredis/pull/658) ([jinjiazhang](https://github.com/jinjiazhang))\n- Fix NXDOMAIN test case [\\#653](https://github.com/redis/hiredis/pull/653) ([michael-grunder](https://github.com/michael-grunder))\n- Add MinGW support [\\#652](https://github.com/redis/hiredis/pull/652) ([mbitsnbites](https://github.com/mbitsnbites))\n- SSL Support [\\#645](https://github.com/redis/hiredis/pull/645) ([mnunberg](https://github.com/mnunberg))\n- Fix Invalid argument after redisAsyncConnectUnix [\\#644](https://github.com/redis/hiredis/pull/644) ([codehz](https://github.com/codehz))\n- Makefile: use predefined AR [\\#632](https://github.com/redis/hiredis/pull/632) ([Mic92](https://github.com/Mic92))\n- FreeBSD build fix [\\#628](https://github.com/redis/hiredis/pull/628) ([devnexen](https://github.com/devnexen))\n- Fix errors not propagating properly with libuv.h. [\\#624](https://github.com/redis/hiredis/pull/624) ([yossigo](https://github.com/yossigo))\n- Update README.md [\\#621](https://github.com/redis/hiredis/pull/621) ([Crunsher](https://github.com/Crunsher))\n- Fix redisBufferRead documentation [\\#620](https://github.com/redis/hiredis/pull/620) ([hacst](https://github.com/hacst))\n- Add CPPFLAGS to REAL\\_CFLAGS [\\#614](https://github.com/redis/hiredis/pull/614) ([thomaslee](https://github.com/thomaslee))\n- Update createArray to take size\\_t [\\#597](https://github.com/redis/hiredis/pull/597) ([justinbrewer](https://github.com/justinbrewer))\n- fix common realloc mistake and add null check more [\\#580](https://github.com/redis/hiredis/pull/580) ([charsyam](https://github.com/charsyam))\n- Proper error reporting for connect failures [\\#578](https://github.com/redis/hiredis/pull/578) ([mnunberg](https://github.com/mnunberg))\n\n\\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*\n\n## [1.0.0-rc1](https://github.com/redis/hiredis/tree/v1.0.0-rc1) - (2020-07-29)\n\n_Note: There were no changes to code between v1.0.0-rc1 and v1.0.0 so see v1.0.0 for changelog_\n\n### 0.14.1 (2020-03-13)\n\n* Adds safe allocation wrappers (CVE-2020-7105, #747, #752) (Michael Grunder)\n\n### 0.14.0 (2018-09-25)\n**BREAKING CHANGES**:\n\n* Change `redisReply.len` to `size_t`, as it denotes the the size of a string\n\n User code should compare this to `size_t` values as well.\n If it was used to compare to other values, casting might be necessary or can be removed, if casting was applied before.\n\n* Make string2ll static to fix conflict with Redis (Tom Lee [c3188b])\n* Use -dynamiclib instead of -shared for OSX (Ryan Schmidt [a65537])\n* Use string2ll from Redis w/added tests (Michael Grunder [7bef04, 60f622])\n* Makefile - OSX compilation fixes (Ryan Schmidt [881fcb, 0e9af8])\n* Remove redundant NULL checks (Justin Brewer [54acc8, 58e6b8])\n* Fix bulk and multi-bulk length truncation (Justin Brewer [109197])\n* Fix SIGSEGV in OpenBSD by checking for NULL before calling freeaddrinfo (Justin Brewer [546d94])\n* Several POSIX compatibility fixes (Justin Brewer [bbeab8, 49bbaa, d1c1b6])\n* Makefile - Compatibility fixes (Dimitri Vorobiev [3238cf, 12a9d1])\n* Makefile - Fix make install on FreeBSD (Zach Shipko [a2ef2b])\n* Makefile - don't assume $(INSTALL) is cp (Igor Gnatenko [725a96])\n* Separate side-effect causing function from assert and small cleanup (amallia [b46413, 3c3234])\n* Don't send negative values to `__redisAsyncCommand` (Frederik Deweerdt [706129])\n* Fix leak if setsockopt fails (Frederik Deweerdt [e21c9c])\n* Fix libevent leak (zfz [515228])\n* Clean up GCC warning (Ichito Nagata [2ec774])\n* Keep track of errno in `__redisSetErrorFromErrno()` as snprintf may use it (Jin Qing [25cd88])\n* Solaris compilation fix (Donald Whyte [41b07d])\n* Reorder linker arguments when building examples (Tustfarm-heart [06eedd])\n* Keep track of subscriptions in case of rapid subscribe/unsubscribe (Hyungjin Kim [073dc8, be76c5, d46999])\n* libuv use after free fix (Paul Scott [cbb956])\n* Properly close socket fd on reconnect attempt (WSL [64d1ec])\n* Skip valgrind in OSX tests (Jan-Erik Rediger [9deb78])\n* Various updates for Travis testing OSX (Ted Nyman [fa3774, 16a459, bc0ea5])\n* Update libevent (Chris Xin [386802])\n* Change sds.h for building in C++ projects (Ali Volkan ATLI [f5b32e])\n* Use proper format specifier in redisFormatSdsCommandArgv (Paulino Huerta, Jan-Erik Rediger [360a06, 8655a6])\n* Better handling of NULL reply in example code (Jan-Erik Rediger [1b8ed3])\n* Prevent overflow when formatting an error (Jan-Erik Rediger [0335cb])\n* Compatibility fix for strerror_r (Tom Lee [bb1747])\n* Properly detect integer parse/overflow errors (Justin Brewer [93421f])\n* Adds CI for Windows and cygwin fixes (owent, [6c53d6, 6c3e40])\n* Catch a buffer overflow when formatting the error message\n* Import latest upstream sds. This breaks applications that are linked against the old hiredis v0.13\n* Fix warnings, when compiled with -Wshadow\n* Make hiredis compile in Cygwin on Windows, now CI-tested\n* Bulk and multi-bulk lengths less than -1 or greater than `LLONG_MAX` are now\n protocol errors. This is consistent with the RESP specification. On 32-bit\n platforms, the upper bound is lowered to `SIZE_MAX`.\n\n* Remove backwards compatibility macro's\n\nThis removes the following old function aliases, use the new name now:\n\n| Old | New |\n| --------------------------- | ---------------------- |\n| redisReplyReaderCreate | redisReaderCreate |\n| redisReplyReaderCreate | redisReaderCreate |\n| redisReplyReaderFree | redisReaderFree |\n| redisReplyReaderFeed | redisReaderFeed |\n| redisReplyReaderGetReply | redisReaderGetReply |\n| redisReplyReaderSetPrivdata | redisReaderSetPrivdata |\n| redisReplyReaderGetObject | redisReaderGetObject |\n| redisReplyReaderGetError | redisReaderGetError |\n\n* The `DEBUG` variable in the Makefile was renamed to `DEBUG_FLAGS`\n\nPreviously it broke some builds for people that had `DEBUG` set to some arbitrary value,\ndue to debugging other software.\nBy renaming we avoid unintentional name clashes.\n\nSimply rename `DEBUG` to `DEBUG_FLAGS` in your environment to make it working again.\n\n### 0.13.3 (2015-09-16)\n\n* Revert \"Clear `REDIS_CONNECTED` flag when connection is closed\".\n* Make tests pass on FreeBSD (Thanks, Giacomo Olgeni)\n\n\nIf the `REDIS_CONNECTED` flag is cleared,\nthe async onDisconnect callback function will never be called.\nThis causes problems as the disconnect is never reported back to the user.\n\n### 0.13.2 (2015-08-25)\n\n* Prevent crash on pending replies in async code (Thanks, @switch-st)\n* Clear `REDIS_CONNECTED` flag when connection is closed (Thanks, Jerry Jacobs)\n* Add MacOS X addapter (Thanks, @dizzus)\n* Add Qt adapter (Thanks, Pietro Cerutti)\n* Add Ivykis adapter (Thanks, Gergely Nagy)\n\nAll adapters are provided as is and are only tested where possible.\n\n### 0.13.1 (2015-05-03)\n\nThis is a bug fix release.\nThe new `reconnect` method introduced new struct members, which clashed with pre-defined names in pre-C99 code.\nAnother commit forced C99 compilation just to make it work, but of course this is not desirable for outside projects.\nOther non-C99 code can now use hiredis as usual again.\nSorry for the inconvenience.\n\n* Fix memory leak in async reply handling (Salvatore Sanfilippo)\n* Rename struct member to avoid name clash with pre-c99 code (Alex Balashov, ncopa)\n\n### 0.13.0 (2015-04-16)\n\nThis release adds a minimal Windows compatibility layer.\nThe parser, standalone since v0.12.0, can now be compiled on Windows\n(and thus used in other client libraries as well)\n\n* Windows compatibility layer for parser code (tzickel)\n* Properly escape data printed to PKGCONF file (Dan Skorupski)\n* Fix tests when assert() undefined (Keith Bennett, Matt Stancliff)\n* Implement a reconnect method for the client context, this changes the structure of `redisContext` (Aaron Bedra)\n\n### 0.12.1 (2015-01-26)\n\n* Fix `make install`: DESTDIR support, install all required files, install PKGCONF in proper location\n* Fix `make test` as 32 bit build on 64 bit platform\n\n### 0.12.0 (2015-01-22)\n\n* Add optional KeepAlive support\n\n* Try again on EINTR errors\n\n* Add libuv adapter\n\n* Add IPv6 support\n\n* Remove possibility of multiple close on same fd\n\n* Add ability to bind source address on connect\n\n* Add redisConnectFd() and redisFreeKeepFd()\n\n* Fix getaddrinfo() memory leak\n\n* Free string if it is unused (fixes memory leak)\n\n* Improve redisAppendCommandArgv performance 2.5x\n\n* Add support for SO_REUSEADDR\n\n* Fix redisvFormatCommand format parsing\n\n* Add GLib 2.0 adapter\n\n* Refactor reading code into read.c\n\n* Fix errno error buffers to not clobber errors\n\n* Generate pkgconf during build\n\n* Silence _BSD_SOURCE warnings\n\n* Improve digit counting for multibulk creation\n\n\n### 0.11.0\n\n* Increase the maximum multi-bulk reply depth to 7.\n\n* Increase the read buffer size from 2k to 16k.\n\n* Use poll(2) instead of select(2) to support large fds (>= 1024).\n\n### 0.10.1\n\n* Makefile overhaul. Important to check out if you override one or more\n variables using environment variables or via arguments to the \"make\" tool.\n\n* Issue #45: Fix potential memory leak for a multi bulk reply with 0 elements\n being created by the default reply object functions.\n\n* Issue #43: Don't crash in an asynchronous context when Redis returns an error\n reply after the connection has been made (this happens when the maximum\n number of connections is reached).\n\n### 0.10.0\n\n* See commit log.\n" }, { "path": "deps/hiredis/CMakeLists.txt", "content": "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)\n\nOPTION(BUILD_SHARED_LIBS \"Build shared libraries\" ON)\nOPTION(ENABLE_SSL \"Build hiredis_ssl for SSL support\" OFF)\nOPTION(DISABLE_TESTS \"If tests should be compiled or not\" OFF)\nOPTION(ENABLE_SSL_TESTS \"Should we test SSL connections\" OFF)\nOPTION(ENABLE_EXAMPLES \"Enable building hiredis examples\" OFF)\nOPTION(ENABLE_ASYNC_TESTS \"Should we run all asynchronous API tests\" OFF)\n\nMACRO(getVersionBit name)\n SET(VERSION_REGEX \"^#define ${name} (.+)$\")\n FILE(STRINGS \"${CMAKE_CURRENT_SOURCE_DIR}/hiredis.h\"\n VERSION_BIT REGEX ${VERSION_REGEX})\n STRING(REGEX REPLACE ${VERSION_REGEX} \"\\\\1\" ${name} \"${VERSION_BIT}\")\nENDMACRO(getVersionBit)\n\ngetVersionBit(HIREDIS_MAJOR)\ngetVersionBit(HIREDIS_MINOR)\ngetVersionBit(HIREDIS_PATCH)\ngetVersionBit(HIREDIS_SONAME)\nSET(VERSION \"${HIREDIS_MAJOR}.${HIREDIS_MINOR}.${HIREDIS_PATCH}\")\nMESSAGE(\"Detected version: ${VERSION}\")\n\nPROJECT(hiredis LANGUAGES \"C\" VERSION \"${VERSION}\")\nINCLUDE(GNUInstallDirs)\n\n# Hiredis requires C99\nSET(CMAKE_C_STANDARD 99)\nSET(CMAKE_DEBUG_POSTFIX d)\n\nSET(hiredis_sources\n alloc.c\n async.c\n hiredis.c\n net.c\n read.c\n sds.c\n sockcompat.c)\n\nSET(hiredis_sources ${hiredis_sources})\n\nIF(WIN32)\n ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -DWIN32_LEAN_AND_MEAN)\nENDIF()\n\nADD_LIBRARY(hiredis ${hiredis_sources})\nADD_LIBRARY(hiredis::hiredis ALIAS hiredis)\nset(hiredis_export_name hiredis CACHE STRING \"Name of the exported target\")\nset_target_properties(hiredis PROPERTIES EXPORT_NAME ${hiredis_export_name})\n\nSET_TARGET_PROPERTIES(hiredis\n PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE\n VERSION \"${HIREDIS_SONAME}\")\nIF(MSVC)\n SET_TARGET_PROPERTIES(hiredis\n PROPERTIES COMPILE_FLAGS /Z7)\nENDIF()\nIF(WIN32)\n TARGET_LINK_LIBRARIES(hiredis PUBLIC ws2_32 crypt32)\nELSEIF(CMAKE_SYSTEM_NAME MATCHES \"FreeBSD\")\n TARGET_LINK_LIBRARIES(hiredis PUBLIC m)\nELSEIF(CMAKE_SYSTEM_NAME MATCHES \"SunOS\")\n TARGET_LINK_LIBRARIES(hiredis PUBLIC socket)\nENDIF()\n\nTARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC $ $)\n\nCONFIGURE_FILE(hiredis.pc.in hiredis.pc @ONLY)\n\nset(CPACK_PACKAGE_VENDOR \"Redis\")\nset(CPACK_PACKAGE_DESCRIPTION \"\\\nHiredis is a minimalistic C client library for the Redis database.\n\nIt is minimalistic because it just adds minimal support for the protocol, \\\nbut at the same time it uses a high level printf-alike API in order to make \\\nit much higher level than otherwise suggested by its minimal code base and the \\\nlack of explicit bindings for every Redis command.\n\nApart from supporting sending commands and receiving replies, it comes with a \\\nreply parser that is decoupled from the I/O layer. It is a stream parser designed \\\nfor easy reusability, which can for instance be used in higher level language bindings \\\nfor efficient reply parsing.\n\nHiredis only supports the binary-safe Redis protocol, so you can use it with any Redis \\\nversion >= 1.2.0.\n\nThe library comes with multiple APIs. There is the synchronous API, the asynchronous API \\\nand the reply parsing API.\")\nset(CPACK_PACKAGE_HOMEPAGE_URL \"https://github.com/redis/hiredis\")\nset(CPACK_PACKAGE_CONTACT \"michael dot grunder at gmail dot com\")\nset(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)\nset(CPACK_RPM_PACKAGE_AUTOREQPROV ON)\n\ninclude(CPack)\n\nINSTALL(TARGETS hiredis\n EXPORT hiredis-targets\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})\n\nif (MSVC AND BUILD_SHARED_LIBS)\n INSTALL(FILES $\n DESTINATION ${CMAKE_INSTALL_BINDIR}\n CONFIGURATIONS Debug RelWithDebInfo)\nendif()\n\n# For NuGet packages\nINSTALL(FILES hiredis.targets\n DESTINATION build/native)\n\nINSTALL(FILES hiredis.h read.h sds.h async.h alloc.h sockcompat.h\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)\n\nINSTALL(DIRECTORY adapters\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)\n\nINSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis.pc\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)\n\nexport(EXPORT hiredis-targets\n FILE \"${CMAKE_CURRENT_BINARY_DIR}/hiredis-targets.cmake\"\n NAMESPACE hiredis::)\n\nif(WIN32)\n SET(CMAKE_CONF_INSTALL_DIR share/hiredis)\nelse()\n SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/hiredis)\nendif()\nSET(INCLUDE_INSTALL_DIR include)\ninclude(CMakePackageConfigHelpers)\nwrite_basic_package_version_file(\"${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake\"\n COMPATIBILITY SameMajorVersion)\nconfigure_package_config_file(hiredis-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake\n INSTALL_DESTINATION ${CMAKE_CONF_INSTALL_DIR}\n PATH_VARS INCLUDE_INSTALL_DIR)\n\nINSTALL(EXPORT hiredis-targets\n FILE hiredis-targets.cmake\n NAMESPACE hiredis::\n DESTINATION ${CMAKE_CONF_INSTALL_DIR})\n\nINSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake\n ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake\n DESTINATION ${CMAKE_CONF_INSTALL_DIR})\n\n\nIF(ENABLE_SSL)\n IF (NOT OPENSSL_ROOT_DIR)\n IF (APPLE)\n SET(OPENSSL_ROOT_DIR \"/usr/local/opt/openssl\")\n ENDIF()\n ENDIF()\n FIND_PACKAGE(OpenSSL REQUIRED)\n SET(hiredis_ssl_sources\n ssl.c)\n ADD_LIBRARY(hiredis_ssl ${hiredis_ssl_sources})\n ADD_LIBRARY(hiredis::hiredis_ssl ALIAS hiredis_ssl)\n\n IF (APPLE AND BUILD_SHARED_LIBS)\n SET_PROPERTY(TARGET hiredis_ssl PROPERTY LINK_FLAGS \"-Wl,-undefined -Wl,dynamic_lookup\")\n ENDIF()\n\n SET_TARGET_PROPERTIES(hiredis_ssl\n PROPERTIES\n WINDOWS_EXPORT_ALL_SYMBOLS TRUE\n VERSION \"${HIREDIS_SONAME}\")\n IF(MSVC)\n SET_TARGET_PROPERTIES(hiredis_ssl\n PROPERTIES COMPILE_FLAGS /Z7)\n ENDIF()\n TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE OpenSSL::SSL)\n IF(WIN32)\n TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE hiredis)\n ENDIF()\n CONFIGURE_FILE(hiredis_ssl.pc.in hiredis_ssl.pc @ONLY)\n\n INSTALL(TARGETS hiredis_ssl\n EXPORT hiredis_ssl-targets\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})\n\n if (MSVC AND BUILD_SHARED_LIBS)\n INSTALL(FILES $\n DESTINATION ${CMAKE_INSTALL_BINDIR}\n CONFIGURATIONS Debug RelWithDebInfo)\n endif()\n\n INSTALL(FILES hiredis_ssl.h\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)\n\n INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl.pc\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)\n\n export(EXPORT hiredis_ssl-targets\n FILE \"${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-targets.cmake\"\n NAMESPACE hiredis::)\n\n if(WIN32)\n SET(CMAKE_CONF_INSTALL_DIR share/hiredis_ssl)\n else()\n SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/hiredis_ssl)\n endif()\n configure_package_config_file(hiredis_ssl-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-config.cmake\n INSTALL_DESTINATION ${CMAKE_CONF_INSTALL_DIR}\n PATH_VARS INCLUDE_INSTALL_DIR)\n\n INSTALL(EXPORT hiredis_ssl-targets\n FILE hiredis_ssl-targets.cmake\n NAMESPACE hiredis::\n DESTINATION ${CMAKE_CONF_INSTALL_DIR})\n\n INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-config.cmake\n DESTINATION ${CMAKE_CONF_INSTALL_DIR})\nENDIF()\n\nIF(NOT DISABLE_TESTS)\n ENABLE_TESTING()\n ADD_EXECUTABLE(hiredis-test test.c)\n TARGET_LINK_LIBRARIES(hiredis-test hiredis)\n IF(ENABLE_SSL_TESTS)\n ADD_DEFINITIONS(-DHIREDIS_TEST_SSL=1)\n TARGET_LINK_LIBRARIES(hiredis-test hiredis_ssl)\n ENDIF()\n IF(ENABLE_ASYNC_TESTS)\n ADD_DEFINITIONS(-DHIREDIS_TEST_ASYNC=1)\n TARGET_LINK_LIBRARIES(hiredis-test event)\n ENDIF()\n ADD_TEST(NAME hiredis-test\n COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test.sh)\nENDIF()\n\n# Add examples\nIF(ENABLE_EXAMPLES)\n ADD_SUBDIRECTORY(examples)\nENDIF(ENABLE_EXAMPLES)\n" }, { "path": "deps/hiredis/COPYING", "content": "Copyright (c) 2009-2011, Salvatore Sanfilippo \nCopyright (c) 2010-2011, Pieter Noordhuis \n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of Redis nor the names of its contributors may be used\n to endorse or promote products derived from this software without specific\n prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\nANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "deps/hiredis/Makefile", "content": "# Hiredis Makefile\n# Copyright (C) 2010-2011 Salvatore Sanfilippo \n# Copyright (C) 2010-2011 Pieter Noordhuis \n# This file is released under the BSD license, see the COPYING file\n\nOBJ=alloc.o net.o hiredis.o sds.o async.o read.o sockcompat.o\nEXAMPLES=hiredis-example hiredis-example-libevent hiredis-example-libev hiredis-example-glib hiredis-example-push hiredis-example-poll\nTESTS=hiredis-test\nLIBNAME=libhiredis\nPKGCONFNAME=hiredis.pc\n\nHIREDIS_MAJOR=$(shell grep HIREDIS_MAJOR hiredis.h | awk '{print $$3}')\nHIREDIS_MINOR=$(shell grep HIREDIS_MINOR hiredis.h | awk '{print $$3}')\nHIREDIS_PATCH=$(shell grep HIREDIS_PATCH hiredis.h | awk '{print $$3}')\nHIREDIS_SONAME=$(shell grep HIREDIS_SONAME hiredis.h | awk '{print $$3}')\n\n# Installation related variables and target\nPREFIX?=/usr/local\nINCLUDE_PATH?=include/hiredis\nLIBRARY_PATH?=lib\nPKGCONF_PATH?=pkgconfig\nINSTALL_INCLUDE_PATH= $(DESTDIR)$(PREFIX)/$(INCLUDE_PATH)\nINSTALL_LIBRARY_PATH= $(DESTDIR)$(PREFIX)/$(LIBRARY_PATH)\nINSTALL_PKGCONF_PATH= $(INSTALL_LIBRARY_PATH)/$(PKGCONF_PATH)\n\n# redis-server configuration used for testing\nREDIS_PORT=56379\nREDIS_SERVER=redis-server\ndefine REDIS_TEST_CONFIG\n\tdaemonize yes\n\tpidfile /tmp/hiredis-test-redis.pid\n\tport $(REDIS_PORT)\n\tbind 127.0.0.1\n\tunixsocket /tmp/hiredis-test-redis.sock\nendef\nexport REDIS_TEST_CONFIG\n\n# Flags passed from outside so as not to override CFLAGS or LDFLAGS as they may\n# be changed inside this Makefile\nHIREDIS_CFLAGS=\nHIREDIS_LDFLAGS=\n\n# Fallback to gcc when $CC is not in $PATH.\nCC:=$(shell sh -c 'type $${CC%% *} >/dev/null 2>/dev/null && echo $(CC) || echo gcc')\nCXX:=$(shell sh -c 'type $${CXX%% *} >/dev/null 2>/dev/null && echo $(CXX) || echo g++')\nOPTIMIZATION?=-O3\nWARNINGS=-Wall -Wextra -Werror -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers\nDEBUG_FLAGS?= -g -ggdb\nREAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS) $(PLATFORM_FLAGS) $(HIREDIS_CFLAGS)\nREAL_LDFLAGS=$(LDFLAGS) $(HIREDIS_LDFLAGS)\n\nDYLIBSUFFIX=so\nSTLIBSUFFIX=a\nDYLIB_MINOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_SONAME)\nDYLIB_MAJOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_MAJOR)\nDYLIBNAME=$(LIBNAME).$(DYLIBSUFFIX)\n\nDYLIB_MAKE_CMD=$(CC) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(DYLIB_MINOR_NAME)\nSTLIBNAME=$(LIBNAME).$(STLIBSUFFIX)\nSTLIB_MAKE_CMD=$(AR) rcs\n\n#################### SSL variables start ####################\nSSL_OBJ=ssl.o\nSSL_LIBNAME=libhiredis_ssl\nSSL_PKGCONFNAME=hiredis_ssl.pc\nSSL_INSTALLNAME=install-ssl\nSSL_DYLIB_MINOR_NAME=$(SSL_LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_SONAME)\nSSL_DYLIB_MAJOR_NAME=$(SSL_LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_MAJOR)\nSSL_DYLIBNAME=$(SSL_LIBNAME).$(DYLIBSUFFIX)\nSSL_STLIBNAME=$(SSL_LIBNAME).$(STLIBSUFFIX)\nSSL_DYLIB_MAKE_CMD=$(CC) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(SSL_DYLIB_MINOR_NAME)\n\nUSE_SSL?=0\nifeq ($(USE_SSL),1)\n # This is required for test.c only\n CFLAGS+=-DHIREDIS_TEST_SSL\n EXAMPLES+=hiredis-example-ssl hiredis-example-libevent-ssl\n SSL_STLIB=$(SSL_STLIBNAME)\n SSL_DYLIB=$(SSL_DYLIBNAME)\n SSL_PKGCONF=$(SSL_PKGCONFNAME)\n SSL_INSTALL=$(SSL_INSTALLNAME)\nelse\n SSL_STLIB=\n SSL_DYLIB=\n SSL_PKGCONF=\n SSL_INSTALL=\nendif\n##################### SSL variables end #####################\n\n\n# Platform-specific overrides\nuname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n\n# This is required for test.c only\nifeq ($(TEST_ASYNC),1)\n export CFLAGS+=-DHIREDIS_TEST_ASYNC\nendif\n\nifeq ($(USE_SSL),1)\n ifndef OPENSSL_PREFIX\n ifeq ($(uname_S),Darwin)\n SEARCH_PATH1=/opt/homebrew/opt/openssl\n SEARCH_PATH2=/usr/local/opt/openssl\n\n ifneq ($(wildcard $(SEARCH_PATH1)),)\n OPENSSL_PREFIX=$(SEARCH_PATH1)\n else ifneq ($(wildcard $(SEARCH_PATH2)),)\n OPENSSL_PREFIX=$(SEARCH_PATH2)\n endif\n endif\n endif\n\n ifdef OPENSSL_PREFIX\n CFLAGS+=-I$(OPENSSL_PREFIX)/include\n SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib\n endif\n\n SSL_LDFLAGS+=-lssl -lcrypto\nendif\n\nifeq ($(uname_S),FreeBSD)\n LDFLAGS+=-lm\n IS_GCC=$(shell sh -c '$(CC) --version 2>/dev/null |egrep -i -c \"gcc\"')\n ifeq ($(IS_GCC),1)\n REAL_CFLAGS+=-pedantic\n endif\nelse\n REAL_CFLAGS+=-pedantic\nendif\n\nifeq ($(uname_S),SunOS)\n IS_SUN_CC=$(shell sh -c '$(CC) -V 2>&1 |egrep -i -c \"sun|studio\"')\n ifeq ($(IS_SUN_CC),1)\n SUN_SHARED_FLAG=-G\n else\n SUN_SHARED_FLAG=-shared\n endif\n REAL_LDFLAGS+= -ldl -lnsl -lsocket\n DYLIB_MAKE_CMD=$(CC) $(SUN_SHARED_FLAG) -o $(DYLIBNAME) -h $(DYLIB_MINOR_NAME) $(LDFLAGS)\n SSL_DYLIB_MAKE_CMD=$(CC) $(SUN_SHARED_FLAG) -o $(SSL_DYLIBNAME) -h $(SSL_DYLIB_MINOR_NAME) $(LDFLAGS) $(SSL_LDFLAGS)\nendif\nifeq ($(uname_S),Darwin)\n DYLIBSUFFIX=dylib\n DYLIB_MINOR_NAME=$(LIBNAME).$(HIREDIS_SONAME).$(DYLIBSUFFIX)\n DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)\n SSL_DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(SSL_DYLIB_MINOR_NAME) -o $(SSL_DYLIBNAME) $(LDFLAGS) $(SSL_LDFLAGS)\n DYLIB_PLUGIN=-Wl,-undefined -Wl,dynamic_lookup\nendif\n\nall: dynamic static hiredis-test pkgconfig\n\ndynamic: $(DYLIBNAME) $(SSL_DYLIB)\n\nstatic: $(STLIBNAME) $(SSL_STLIB)\n\npkgconfig: $(PKGCONFNAME) $(SSL_PKGCONF)\n\n# Deps (use make dep to generate this)\nalloc.o: alloc.c fmacros.h alloc.h\nasync.o: async.c fmacros.h alloc.h async.h hiredis.h read.h sds.h net.h dict.c dict.h win32.h async_private.h\ndict.o: dict.c fmacros.h alloc.h dict.h\nhiredis.o: hiredis.c fmacros.h hiredis.h read.h sds.h alloc.h net.h async.h win32.h\nnet.o: net.c fmacros.h net.h hiredis.h read.h sds.h alloc.h sockcompat.h win32.h\nread.o: read.c fmacros.h alloc.h read.h sds.h win32.h\nsds.o: sds.c sds.h sdsalloc.h alloc.h\nsockcompat.o: sockcompat.c sockcompat.h\ntest.o: test.c fmacros.h hiredis.h read.h sds.h alloc.h net.h sockcompat.h win32.h\n\n$(DYLIBNAME): $(OBJ)\n\t$(DYLIB_MAKE_CMD) -o $(DYLIBNAME) $(OBJ) $(REAL_LDFLAGS)\n\n$(STLIBNAME): $(OBJ)\n\t$(STLIB_MAKE_CMD) $(STLIBNAME) $(OBJ)\n\n#################### SSL building rules start ####################\n$(SSL_DYLIBNAME): $(SSL_OBJ)\n\t$(SSL_DYLIB_MAKE_CMD) $(DYLIB_PLUGIN) -o $(SSL_DYLIBNAME) $(SSL_OBJ) $(REAL_LDFLAGS) $(LDFLAGS) $(SSL_LDFLAGS)\n\n$(SSL_STLIBNAME): $(SSL_OBJ)\n\t$(STLIB_MAKE_CMD) $(SSL_STLIBNAME) $(SSL_OBJ)\n\n$(SSL_OBJ): ssl.c hiredis.h read.h sds.h alloc.h async.h win32.h async_private.h\n#################### SSL building rules end ####################\n\n# Binaries:\nhiredis-example-libevent: examples/example-libevent.c adapters/libevent.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -levent $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-libevent-ssl: examples/example-libevent-ssl.c adapters/libevent.h $(STLIBNAME) $(SSL_STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -levent $(STLIBNAME) $(SSL_STLIBNAME) $(REAL_LDFLAGS) $(SSL_LDFLAGS)\n\nhiredis-example-libev: examples/example-libev.c adapters/libev.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -lev $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-libhv: examples/example-libhv.c adapters/libhv.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -lhv $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-glib: examples/example-glib.c adapters/glib.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(shell pkg-config --cflags --libs glib-2.0) $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-ivykis: examples/example-ivykis.c adapters/ivykis.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -livykis $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-macosx: examples/example-macosx.c adapters/macosx.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -framework CoreFoundation $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-ssl: examples/example-ssl.c $(STLIBNAME) $(SSL_STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(SSL_STLIBNAME) $(REAL_LDFLAGS) $(SSL_LDFLAGS)\n\nhiredis-example-poll: examples/example-poll.c adapters/poll.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(REAL_LDFLAGS)\n\nifndef AE_DIR\nhiredis-example-ae:\n\t@echo \"Please specify AE_DIR (e.g. /src)\"\n\t@false\nelse\nhiredis-example-ae: examples/example-ae.c adapters/ae.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. -I$(AE_DIR) $< $(AE_DIR)/ae.o $(AE_DIR)/zmalloc.o $(AE_DIR)/../deps/jemalloc/lib/libjemalloc.a -pthread $(STLIBNAME)\nendif\n\nifndef LIBUV_DIR\n# dynamic link libuv.so\nhiredis-example-libuv: examples/example-libuv.c adapters/libuv.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. -I$(LIBUV_DIR)/include $< -luv -lpthread -lrt $(STLIBNAME) $(REAL_LDFLAGS)\nelse\n# use user provided static lib\nhiredis-example-libuv: examples/example-libuv.c adapters/libuv.h $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. -I$(LIBUV_DIR)/include $< $(LIBUV_DIR)/.libs/libuv.a -lpthread -lrt $(STLIBNAME) $(REAL_LDFLAGS)\nendif\n\nifeq ($(and $(QT_MOC),$(QT_INCLUDE_DIR),$(QT_LIBRARY_DIR)),)\nhiredis-example-qt:\n\t@echo \"Please specify QT_MOC, QT_INCLUDE_DIR AND QT_LIBRARY_DIR\"\n\t@false\nelse\nhiredis-example-qt: examples/example-qt.cpp adapters/qt.h $(STLIBNAME)\n\t$(QT_MOC) adapters/qt.h -I. -I$(QT_INCLUDE_DIR) -I$(QT_INCLUDE_DIR)/QtCore | \\\n\t $(CXX) -x c++ -o qt-adapter-moc.o -c - $(REAL_CFLAGS) -I. -I$(QT_INCLUDE_DIR) -I$(QT_INCLUDE_DIR)/QtCore\n\t$(QT_MOC) examples/example-qt.h -I. -I$(QT_INCLUDE_DIR) -I$(QT_INCLUDE_DIR)/QtCore | \\\n\t $(CXX) -x c++ -o qt-example-moc.o -c - $(REAL_CFLAGS) -I. -I$(QT_INCLUDE_DIR) -I$(QT_INCLUDE_DIR)/QtCore\n\t$(CXX) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. -I$(QT_INCLUDE_DIR) -I$(QT_INCLUDE_DIR)/QtCore -L$(QT_LIBRARY_DIR) qt-adapter-moc.o qt-example-moc.o $< -pthread $(STLIBNAME) -lQtCore\nendif\n\nhiredis-example: examples/example.c $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(REAL_LDFLAGS)\n\nhiredis-example-push: examples/example-push.c $(STLIBNAME)\n\t$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(REAL_LDFLAGS)\n\nexamples: $(EXAMPLES)\n\nTEST_LIBS = $(STLIBNAME) $(SSL_STLIB)\nTEST_LDFLAGS = $(SSL_LDFLAGS)\nifeq ($(USE_SSL),1)\n TEST_LDFLAGS += -pthread\nendif\nifeq ($(TEST_ASYNC),1)\n TEST_LDFLAGS += -levent\nendif\n\nhiredis-test: test.o $(TEST_LIBS)\n\t$(CC) -o $@ $(REAL_CFLAGS) -I. $^ $(REAL_LDFLAGS) $(TEST_LDFLAGS)\n\nhiredis-%: %.o $(STLIBNAME)\n\t$(CC) $(REAL_CFLAGS) -o $@ $< $(TEST_LIBS) $(REAL_LDFLAGS)\n\ntest: hiredis-test\n\t./hiredis-test\n\ncheck: hiredis-test\n\tTEST_SSL=$(USE_SSL) ./test.sh\n\n.c.o:\n\t$(CC) -std=c99 -c $(REAL_CFLAGS) $<\n\nclean:\n\trm -rf $(DYLIBNAME) $(STLIBNAME) $(SSL_DYLIBNAME) $(SSL_STLIBNAME) $(TESTS) $(PKGCONFNAME) examples/hiredis-example* *.o *.gcda *.gcno *.gcov\n\ndep:\n\t$(CC) $(CPPFLAGS) $(CFLAGS) -MM *.c\n\nINSTALL?= cp -pPR\n\n$(PKGCONFNAME): hiredis.h\n\t@echo \"Generating $@ for pkgconfig...\"\n\t@echo prefix=$(PREFIX) > $@\n\t@echo exec_prefix=\\$${prefix} >> $@\n\t@echo libdir=$(PREFIX)/$(LIBRARY_PATH) >> $@\n\t@echo includedir=$(PREFIX)/include >> $@\n\t@echo pkgincludedir=$(PREFIX)/$(INCLUDE_PATH) >> $@\n\t@echo >> $@\n\t@echo Name: hiredis >> $@\n\t@echo Description: Minimalistic C client library for Redis. >> $@\n\t@echo Version: $(HIREDIS_MAJOR).$(HIREDIS_MINOR).$(HIREDIS_PATCH) >> $@\n\t@echo Libs: -L\\$${libdir} -lhiredis >> $@\n\t@echo Cflags: -I\\$${pkgincludedir} -I\\$${includedir} -D_FILE_OFFSET_BITS=64 >> $@\n\n$(SSL_PKGCONFNAME): hiredis_ssl.h\n\t@echo \"Generating $@ for pkgconfig...\"\n\t@echo prefix=$(PREFIX) > $@\n\t@echo exec_prefix=\\$${prefix} >> $@\n\t@echo libdir=$(PREFIX)/$(LIBRARY_PATH) >> $@\n\t@echo includedir=$(PREFIX)/include >> $@\n\t@echo pkgincludedir=$(PREFIX)/$(INCLUDE_PATH) >> $@\n\t@echo >> $@\n\t@echo Name: hiredis_ssl >> $@\n\t@echo Description: SSL Support for hiredis. >> $@\n\t@echo Version: $(HIREDIS_MAJOR).$(HIREDIS_MINOR).$(HIREDIS_PATCH) >> $@\n\t@echo Requires: hiredis >> $@\n\t@echo Libs: -L\\$${libdir} -lhiredis_ssl >> $@\n\t@echo Libs.private: -lssl -lcrypto >> $@\n\ninstall: $(DYLIBNAME) $(STLIBNAME) $(PKGCONFNAME) $(SSL_INSTALL)\n\tmkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_INCLUDE_PATH)/adapters $(INSTALL_LIBRARY_PATH)\n\t$(INSTALL) hiredis.h async.h read.h sds.h alloc.h sockcompat.h $(INSTALL_INCLUDE_PATH)\n\t$(INSTALL) adapters/*.h $(INSTALL_INCLUDE_PATH)/adapters\n\t$(INSTALL) $(DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(DYLIB_MINOR_NAME)\n\tcd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIBNAME) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)\n\t$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)\n\tmkdir -p $(INSTALL_PKGCONF_PATH)\n\t$(INSTALL) $(PKGCONFNAME) $(INSTALL_PKGCONF_PATH)\n\ninstall-ssl: $(SSL_DYLIBNAME) $(SSL_STLIBNAME) $(SSL_PKGCONFNAME)\n\tmkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_LIBRARY_PATH)\n\t$(INSTALL) hiredis_ssl.h $(INSTALL_INCLUDE_PATH)\n\t$(INSTALL) $(SSL_DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(SSL_DYLIB_MINOR_NAME)\n\tcd $(INSTALL_LIBRARY_PATH) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIBNAME) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIB_MAJOR_NAME)\n\t$(INSTALL) $(SSL_STLIBNAME) $(INSTALL_LIBRARY_PATH)\n\tmkdir -p $(INSTALL_PKGCONF_PATH)\n\t$(INSTALL) $(SSL_PKGCONFNAME) $(INSTALL_PKGCONF_PATH)\n\n32bit:\n\t@echo \"\"\n\t@echo \"WARNING: if this fails under Linux you probably need to install libc6-dev-i386\"\n\t@echo \"\"\n\t$(MAKE) CFLAGS=\"-m32\" LDFLAGS=\"-m32\"\n\n32bit-vars:\n\t$(eval CFLAGS=-m32)\n\t$(eval LDFLAGS=-m32)\n\ngprof:\n\t$(MAKE) CFLAGS=\"-pg\" LDFLAGS=\"-pg\"\n\ngcov:\n\t$(MAKE) CFLAGS+=\"-fprofile-arcs -ftest-coverage\" LDFLAGS=\"-fprofile-arcs\"\n\ncoverage: gcov\n\tmake check\n\tmkdir -p tmp/lcov\n\tlcov -d . -c --exclude '/usr*' -o tmp/lcov/hiredis.info\n\tlcov -q -l tmp/lcov/hiredis.info\n\tgenhtml --legend -q -o tmp/lcov/report tmp/lcov/hiredis.info\n\nnoopt:\n\t$(MAKE) OPTIMIZATION=\"\"\n\n.PHONY: all test check clean dep install 32bit 32bit-vars gprof gcov noopt\n" }, { "path": "deps/hiredis/README.md", "content": "\n[![Build Status](https://github.com/redis/hiredis/actions/workflows/build.yml/badge.svg)](https://github.com/redis/hiredis/actions/workflows/build.yml)\n\n**This Readme reflects the latest changed in the master branch. See [v1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) for the Readme and documentation for the latest release ([API/ABI history](https://abi-laboratory.pro/?view=timeline&l=hiredis)).**\n\n# HIREDIS\n\nHiredis is a minimalistic C client library for the [Redis](https://redis.io/) database.\n\nIt is minimalistic because it just adds minimal support for the protocol, but\nat the same time it uses a high level printf-alike API in order to make it\nmuch higher level than otherwise suggested by its minimal code base and the\nlack of explicit bindings for every Redis command.\n\nApart from supporting sending commands and receiving replies, it comes with\na reply parser that is decoupled from the I/O layer. It\nis a stream parser designed for easy reusability, which can for instance be used\nin higher level language bindings for efficient reply parsing.\n\nHiredis only supports the binary-safe Redis protocol, so you can use it with any\nRedis version >= 1.2.0.\n\nThe library comes with multiple APIs. There is the\n*synchronous API*, the *asynchronous API* and the *reply parsing API*.\n\n## Upgrading to `1.1.0`\n\nAlmost all users will simply need to recompile their applications against the newer version of hiredis.\n\n**NOTE**: Hiredis can now return `nan` in addition to `-inf` and `inf` in a `REDIS_REPLY_DOUBLE`.\n Applications that deal with `RESP3` doubles should make sure to account for this.\n\n## Upgrading to `1.0.2`\n\nNOTE: v1.0.1 erroneously bumped SONAME, which is why it is skipped here.\n\nVersion 1.0.2 is simply 1.0.0 with a fix for [CVE-2021-32765](https://github.com/redis/hiredis/security/advisories/GHSA-hfm9-39pp-55p2). They are otherwise identical.\n\n## Upgrading to `1.0.0`\n\nVersion 1.0.0 marks the first stable release of Hiredis.\nIt includes some minor breaking changes, mostly to make the exposed API more uniform and self-explanatory.\nIt also bundles the updated `sds` library, to sync up with upstream and Redis.\nFor code changes see the [Changelog](CHANGELOG.md).\n\n_Note: As described below, a few member names have been changed but most applications should be able to upgrade with minor code changes and recompiling._\n\n## IMPORTANT: Breaking changes from `0.14.1` -> `1.0.0`\n\n* `redisContext` has two additional members (`free_privdata`, and `privctx`).\n* `redisOptions.timeout` has been renamed to `redisOptions.connect_timeout`, and we've added `redisOptions.command_timeout`.\n* `redisReplyObjectFunctions.createArray` now takes `size_t` instead of `int` for its length parameter.\n\n## IMPORTANT: Breaking changes when upgrading from 0.13.x -> 0.14.x\n\nBulk and multi-bulk lengths less than -1 or greater than `LLONG_MAX` are now\nprotocol errors. This is consistent with the RESP specification. On 32-bit\nplatforms, the upper bound is lowered to `SIZE_MAX`.\n\nChange `redisReply.len` to `size_t`, as it denotes the the size of a string\n\nUser code should compare this to `size_t` values as well. If it was used to\ncompare to other values, casting might be necessary or can be removed, if\ncasting was applied before.\n\n## Upgrading from `<0.9.0`\n\nVersion 0.9.0 is a major overhaul of hiredis in every aspect. However, upgrading existing\ncode using hiredis should not be a big pain. The key thing to keep in mind when\nupgrading is that hiredis >= 0.9.0 uses a `redisContext*` to keep state, in contrast to\nthe stateless 0.0.1 that only has a file descriptor to work with.\n\n## Synchronous API\n\nTo consume the synchronous API, there are only a few function calls that need to be introduced:\n\n```c\nredisContext *redisConnect(const char *ip, int port);\nvoid *redisCommand(redisContext *c, const char *format, ...);\nvoid freeReplyObject(void *reply);\n```\n\n### Connecting\n\nThe function `redisConnect` is used to create a so-called `redisContext`. The\ncontext is where Hiredis holds state for a connection. The `redisContext`\nstruct has an integer `err` field that is non-zero when the connection is in\nan error state. The field `errstr` will contain a string with a description of\nthe error. More information on errors can be found in the **Errors** section.\nAfter trying to connect to Redis using `redisConnect` you should\ncheck the `err` field to see if establishing the connection was successful:\n\n```c\nredisContext *c = redisConnect(\"127.0.0.1\", 6379);\nif (c == NULL || c->err) {\n if (c) {\n printf(\"Error: %s\\n\", c->errstr);\n // handle error\n } else {\n printf(\"Can't allocate redis context\\n\");\n }\n}\n```\n\nOne can also use `redisConnectWithOptions` which takes a `redisOptions` argument\nthat can be configured with endpoint information as well as many different flags\nto change how the `redisContext` will be configured.\n\n```c\nredisOptions opt = {0};\n\n/* One can set the endpoint with one of our helper macros */\nif (tcp) {\n REDIS_OPTIONS_SET_TCP(&opt, \"localhost\", 6379);\n} else {\n REDIS_OPTIONS_SET_UNIX(&opt, \"/tmp/redis.sock\");\n}\n\n/* And privdata can be specified with another helper */\nREDIS_OPTIONS_SET_PRIVDATA(&opt, myPrivData, myPrivDataDtor);\n\n/* Finally various options may be set via the `options` member, as described below */\nopt->options |= REDIS_OPT_PREFER_IPV4;\n```\n\nIf a connection is lost, `int redisReconnect(redisContext *c)` can be used to restore the connection using the same endpoint and options as the given context.\n\n### Configurable redisOptions flags\n\nThere are several flags you may set in the `redisOptions` struct to change default behavior. You can specify the flags via the `redisOptions->options` member.\n\n| Flag | Description |\n| --- | --- |\n| REDIS\\_OPT\\_NONBLOCK | Tells hiredis to make a non-blocking connection. |\n| REDIS\\_OPT\\_REUSEADDR | Tells hiredis to set the [SO_REUSEADDR](https://man7.org/linux/man-pages/man7/socket.7.html) socket option |\n| REDIS\\_OPT\\_PREFER\\_IPV4
REDIS\\_OPT\\_PREFER_IPV6
REDIS\\_OPT\\_PREFER\\_IP\\_UNSPEC | Informs hiredis to either prefer IPv4 or IPv6 when invoking [getaddrinfo](https://man7.org/linux/man-pages/man3/gai_strerror.3.html). `REDIS_OPT_PREFER_IP_UNSPEC` will cause hiredis to specify `AF_UNSPEC` in the getaddrinfo call, which means both IPv4 and IPv6 addresses will be searched simultaneously.
Hiredis prefers IPv4 by default. |\n| REDIS\\_OPT\\_NO\\_PUSH\\_AUTOFREE | Tells hiredis to not install the default RESP3 PUSH handler (which just intercepts and frees the replies). This is useful in situations where you want to process these messages in-band. |\n| REDIS\\_OPT\\_NOAUTOFREEREPLIES | **ASYNC**: tells hiredis not to automatically invoke `freeReplyObject` after executing the reply callback. |\n| REDIS\\_OPT\\_NOAUTOFREE | **ASYNC**: Tells hiredis not to automatically free the `redisAsyncContext` on connection/communication failure, but only if the user makes an explicit call to `redisAsyncDisconnect` or `redisAsyncFree` |\n\n*Note: A `redisContext` is not thread-safe.*\n\n### Other configuration using socket options\n\nThe following socket options are applied directly to the underlying socket.\nThe values are not stored in the `redisContext`, so they are not automatically applied when reconnecting using `redisReconnect()`.\nThese functions return `REDIS_OK` on success.\nOn failure, `REDIS_ERR` is returned and the underlying connection is closed.\n\nTo configure these for an asyncronous context (see *Asynchronous API* below), use `ac->c` to get the redisContext out of an asyncRedisContext.\n\n```C\nint redisEnableKeepAlive(redisContext *c);\nint redisEnableKeepAliveWithInterval(redisContext *c, int interval);\n```\n\nEnables TCP keepalive by setting the following socket options (with some variations depending on OS):\n\n* `SO_KEEPALIVE`;\n* `TCP_KEEPALIVE` or `TCP_KEEPIDLE`, value configurable using the `interval` parameter, default 15 seconds;\n* `TCP_KEEPINTVL` set to 1/3 of `interval`;\n* `TCP_KEEPCNT` set to 3.\n\n```C\nint redisSetTcpUserTimeout(redisContext *c, unsigned int timeout);\n```\n\nSet the `TCP_USER_TIMEOUT` Linux-specific socket option which is as described in the `tcp` man page:\n\n> When the value is greater than 0, it specifies the maximum amount of time in milliseconds that trans mitted data may remain unacknowledged before TCP will forcibly close the corresponding connection and return ETIMEDOUT to the application.\n> If the option value is specified as 0, TCP will use the system default.\n\n### Sending commands\n\nThere are several ways to issue commands to Redis. The first that will be introduced is\n`redisCommand`. This function takes a format similar to printf. In the simplest form,\nit is used like this:\n```c\nreply = redisCommand(context, \"SET foo bar\");\n```\n\nThe specifier `%s` interpolates a string in the command, and uses `strlen` to\ndetermine the length of the string:\n```c\nreply = redisCommand(context, \"SET foo %s\", value);\n```\nWhen you need to pass binary safe strings in a command, the `%b` specifier can be\nused. Together with a pointer to the string, it requires a `size_t` length argument\nof the string:\n```c\nreply = redisCommand(context, \"SET foo %b\", value, (size_t) valuelen);\n```\nInternally, Hiredis splits the command in different arguments and will\nconvert it to the protocol used to communicate with Redis.\nOne or more spaces separates arguments, so you can use the specifiers\nanywhere in an argument:\n```c\nreply = redisCommand(context, \"SET key:%s %s\", myid, value);\n```\n\n### Using replies\n\nThe return value of `redisCommand` holds a reply when the command was\nsuccessfully executed. When an error occurs, the return value is `NULL` and\nthe `err` field in the context will be set (see section on **Errors**).\nOnce an error is returned the context cannot be reused and you should set up\na new connection.\n\nThe standard replies that `redisCommand` are of the type `redisReply`. The\n`type` field in the `redisReply` should be used to test what kind of reply\nwas received:\n\n### RESP2\n\n* **`REDIS_REPLY_STATUS`**:\n * The command replied with a status reply. The status string can be accessed using `reply->str`.\n The length of this string can be accessed using `reply->len`.\n\n* **`REDIS_REPLY_ERROR`**:\n * The command replied with an error. The error string can be accessed identical to `REDIS_REPLY_STATUS`.\n\n* **`REDIS_REPLY_INTEGER`**:\n * The command replied with an integer. The integer value can be accessed using the\n `reply->integer` field of type `long long`.\n\n* **`REDIS_REPLY_NIL`**:\n * The command replied with a **nil** object. There is no data to access.\n\n* **`REDIS_REPLY_STRING`**:\n * A bulk (string) reply. The value of the reply can be accessed using `reply->str`.\n The length of this string can be accessed using `reply->len`.\n\n* **`REDIS_REPLY_ARRAY`**:\n * A multi bulk reply. The number of elements in the multi bulk reply is stored in\n `reply->elements`. Every element in the multi bulk reply is a `redisReply` object as well\n and can be accessed via `reply->element[..index..]`.\n Redis may reply with nested arrays but this is fully supported.\n\n### RESP3\n\nHiredis also supports every new `RESP3` data type which are as follows. For more information about the protocol see the `RESP3` [specification.](https://github.com/antirez/RESP3/blob/master/spec.md)\n\n* **`REDIS_REPLY_DOUBLE`**:\n * The command replied with a double-precision floating point number.\n The value is stored as a string in the `str` member, and can be converted with `strtod` or similar.\n\n* **`REDIS_REPLY_BOOL`**:\n * A boolean true/false reply.\n The value is stored in the `integer` member and will be either `0` or `1`.\n\n* **`REDIS_REPLY_MAP`**:\n * An array with the added invariant that there will always be an even number of elements.\n The MAP is functionally equivalent to `REDIS_REPLY_ARRAY` except for the previously mentioned invariant.\n\n* **`REDIS_REPLY_SET`**:\n * An array response where each entry is unique.\n Like the MAP type, the data is identical to an array response except there are no duplicate values.\n\n* **`REDIS_REPLY_PUSH`**:\n * An array that can be generated spontaneously by Redis.\n This array response will always contain at least two subelements. The first contains the type of `PUSH` message (e.g. `message`, or `invalidate`), and the second being a sub-array with the `PUSH` payload itself.\n\n* **`REDIS_REPLY_ATTR`**:\n * An array structurally identical to a `MAP` but intended as meta-data about a reply.\n _As of Redis 6.0.6 this reply type is not used in Redis_\n\n* **`REDIS_REPLY_BIGNUM`**:\n * A string representing an arbitrarily large signed or unsigned integer value.\n The number will be encoded as a string in the `str` member of `redisReply`.\n\n* **`REDIS_REPLY_VERB`**:\n * A verbatim string, intended to be presented to the user without modification.\n The string payload is stored in the `str` member, and type data is stored in the `vtype` member (e.g. `txt` for raw text or `md` for markdown).\n\nReplies should be freed using the `freeReplyObject()` function.\nNote that this function will take care of freeing sub-reply objects\ncontained in arrays and nested arrays, so there is no need for the user to\nfree the sub replies (it is actually harmful and will corrupt the memory).\n\n**Important:** the current version of hiredis (1.0.0) frees replies when the\nasynchronous API is used. This means you should not call `freeReplyObject` when\nyou use this API. The reply is cleaned up by hiredis _after_ the callback\nreturns. We may introduce a flag to make this configurable in future versions of the library.\n\n### Cleaning up\n\nTo disconnect and free the context the following function can be used:\n```c\nvoid redisFree(redisContext *c);\n```\nThis function immediately closes the socket and then frees the allocations done in\ncreating the context.\n\n### Sending commands (cont'd)\n\nTogether with `redisCommand`, the function `redisCommandArgv` can be used to issue commands.\nIt has the following prototype:\n```c\nvoid *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);\n```\nIt takes the number of arguments `argc`, an array of strings `argv` and the lengths of the\narguments `argvlen`. For convenience, `argvlen` may be set to `NULL` and the function will\nuse `strlen(3)` on every argument to determine its length. Obviously, when any of the arguments\nneed to be binary safe, the entire array of lengths `argvlen` should be provided.\n\nThe return value has the same semantic as `redisCommand`.\n\n### Pipelining\n\nTo explain how Hiredis supports pipelining in a blocking connection, there needs to be\nunderstanding of the internal execution flow.\n\nWhen any of the functions in the `redisCommand` family is called, Hiredis first formats the\ncommand according to the Redis protocol. The formatted command is then put in the output buffer\nof the context. This output buffer is dynamic, so it can hold any number of commands.\nAfter the command is put in the output buffer, `redisGetReply` is called. This function has the\nfollowing two execution paths:\n\n1. The input buffer is non-empty:\n * Try to parse a single reply from the input buffer and return it\n * If no reply could be parsed, continue at *2*\n2. The input buffer is empty:\n * Write the **entire** output buffer to the socket\n * Read from the socket until a single reply could be parsed\n\nThe function `redisGetReply` is exported as part of the Hiredis API and can be used when a reply\nis expected on the socket. To pipeline commands, the only thing that needs to be done is\nfilling up the output buffer. For this cause, two commands can be used that are identical\nto the `redisCommand` family, apart from not returning a reply:\n```c\nvoid redisAppendCommand(redisContext *c, const char *format, ...);\nvoid redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);\n```\nAfter calling either function one or more times, `redisGetReply` can be used to receive the\nsubsequent replies. The return value for this function is either `REDIS_OK` or `REDIS_ERR`, where\nthe latter means an error occurred while reading a reply. Just as with the other commands,\nthe `err` field in the context can be used to find out what the cause of this error is.\n\nThe following examples shows a simple pipeline (resulting in only a single call to `write(2)` and\na single call to `read(2)`):\n```c\nredisReply *reply;\nredisAppendCommand(context,\"SET foo bar\");\nredisAppendCommand(context,\"GET foo\");\nredisGetReply(context,(void**)&reply); // reply for SET\nfreeReplyObject(reply);\nredisGetReply(context,(void**)&reply); // reply for GET\nfreeReplyObject(reply);\n```\nThis API can also be used to implement a blocking subscriber:\n```c\nreply = redisCommand(context,\"SUBSCRIBE foo\");\nfreeReplyObject(reply);\nwhile(redisGetReply(context,(void *)&reply) == REDIS_OK) {\n // consume message\n freeReplyObject(reply);\n}\n```\n### Errors\n\nWhen a function call is not successful, depending on the function either `NULL` or `REDIS_ERR` is\nreturned. The `err` field inside the context will be non-zero and set to one of the\nfollowing constants:\n\n* **`REDIS_ERR_IO`**:\n There was an I/O error while creating the connection, trying to write\n to the socket or read from the socket. If you included `errno.h` in your\n application, you can use the global `errno` variable to find out what is\n wrong.\n\n* **`REDIS_ERR_EOF`**:\n The server closed the connection which resulted in an empty read.\n\n* **`REDIS_ERR_PROTOCOL`**:\n There was an error while parsing the protocol.\n\n* **`REDIS_ERR_OTHER`**:\n Any other error. Currently, it is only used when a specified hostname to connect\n to cannot be resolved.\n\nIn every case, the `errstr` field in the context will be set to hold a string representation\nof the error.\n\n## Asynchronous API\n\nHiredis comes with an asynchronous API that works easily with any event library.\nExamples are bundled that show using Hiredis with [libev](http://software.schmorp.de/pkg/libev.html)\nand [libevent](http://monkey.org/~provos/libevent/).\n\n### Connecting\n\nThe function `redisAsyncConnect` can be used to establish a non-blocking connection to\nRedis. It returns a pointer to the newly created `redisAsyncContext` struct. The `err` field\nshould be checked after creation to see if there were errors creating the connection.\nBecause the connection that will be created is non-blocking, the kernel is not able to\ninstantly return if the specified host and port is able to accept a connection.\nIn case of error, it is the caller's responsibility to free the context using `redisAsyncFree()`\n\n*Note: A `redisAsyncContext` is not thread-safe.*\n\nAn application function creating a connection might look like this:\n\n```c\nvoid appConnect(myAppData *appData)\n{\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n printf(\"Error: %s\\n\", c->errstr);\n // handle error\n redisAsyncFree(c);\n c = NULL;\n } else {\n appData->context = c;\n appData->connecting = 1;\n c->data = appData; /* store application pointer for the callbacks */\n redisAsyncSetConnectCallback(c, appOnConnect);\n redisAsyncSetDisconnectCallback(c, appOnDisconnect);\n }\n}\n\n```\n\n\nThe asynchronous context _should_ hold a *connect* callback function that is called when the connection\nattempt completes, either successfully or with an error.\nIt _can_ also hold a *disconnect* callback function that is called when the\nconnection is disconnected (either because of an error or per user request). Both callbacks should\nhave the following prototype:\n```c\nvoid(const redisAsyncContext *c, int status);\n```\n\nOn a *connect*, the `status` argument is set to `REDIS_OK` if the connection attempt succeeded. In this\ncase, the context is ready to accept commands. If it is called with `REDIS_ERR` then the\nconnection attempt failed. The `err` field in the context can be accessed to find out the cause of the error.\nAfter a failed connection attempt, the context object is automatically freed by the library after calling\nthe connect callback. This may be a good point to create a new context and retry the connection.\n\nOn a disconnect, the `status` argument is set to `REDIS_OK` when disconnection was initiated by the\nuser, or `REDIS_ERR` when the disconnection was caused by an error. When it is `REDIS_ERR`, the `err`\nfield in the context can be accessed to find out the cause of the error.\n\nThe context object is always freed after the disconnect callback fired. When a reconnect is needed,\nthe disconnect callback is a good point to do so.\n\nSetting the connect or disconnect callbacks can only be done once per context. For subsequent calls the\napi will return `REDIS_ERR`. The function to set the callbacks have the following prototype:\n```c\n/* Alternatively you can use redisAsyncSetConnectCallbackNC which will be passed a non-const\n redisAsyncContext* on invocation (e.g. allowing writes to the privdata member). */\nint redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn);\nint redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn);\n```\n`ac->data` may be used to pass user data to both callbacks. A typical implementation\nmight look something like this:\n```c\nvoid appOnConnect(redisAsyncContext *c, int status)\n{\n myAppData *appData = (myAppData*)c->data; /* get my application specific context*/\n appData->connecting = 0;\n if (status == REDIS_OK) {\n appData->connected = 1;\n } else {\n appData->connected = 0;\n appData->err = c->err;\n appData->context = NULL; /* avoid stale pointer when callback returns */\n }\n appAttemptReconnect();\n}\n\nvoid appOnDisconnect(redisAsyncContext *c, int status)\n{\n myAppData *appData = (myAppData*)c->data; /* get my application specific context*/\n appData->connected = 0;\n appData->err = c->err;\n appData->context = NULL; /* avoid stale pointer when callback returns */\n if (status == REDIS_OK) {\n appNotifyDisconnectCompleted(mydata);\n } else {\n appNotifyUnexpectedDisconnect(mydata);\n appAttemptReconnect();\n }\n}\n```\n\n### Sending commands and their callbacks\n\nIn an asynchronous context, commands are automatically pipelined due to the nature of an event loop.\nTherefore, unlike the synchronous API, there is only a single way to send commands.\nBecause commands are sent to Redis asynchronously, issuing a command requires a callback function\nthat is called when the reply is received. Reply callbacks should have the following prototype:\n```c\nvoid(redisAsyncContext *c, void *reply, void *privdata);\n```\nThe `privdata` argument can be used to curry arbitrary data to the callback from the point where\nthe command is initially queued for execution.\n\nThe functions that can be used to issue commands in an asynchronous context are:\n```c\nint redisAsyncCommand(\n redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,\n const char *format, ...);\nint redisAsyncCommandArgv(\n redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,\n int argc, const char **argv, const size_t *argvlen);\n```\nBoth functions work like their blocking counterparts. The return value is `REDIS_OK` when the command\nwas successfully added to the output buffer and `REDIS_ERR` otherwise. Example: when the connection\nis being disconnected per user-request, no new commands may be added to the output buffer and `REDIS_ERR` is\nreturned on calls to the `redisAsyncCommand` family.\n\nIf the reply for a command with a `NULL` callback is read, it is immediately freed. When the callback\nfor a command is non-`NULL`, the memory is freed immediately following the callback: the reply is only\nvalid for the duration of the callback.\n\nAll pending callbacks are called with a `NULL` reply when the context encountered an error.\n\nFor every command issued, with the exception of **SUBSCRIBE** and **PSUBSCRIBE**, the callback is\ncalled exactly once. Even if the context object id disconnected or deleted, every pending callback\nwill be called with a `NULL` reply.\n\nFor **SUBSCRIBE** and **PSUBSCRIBE**, the callbacks may be called repeatedly until an `unsubscribe`\nmessage arrives. This will be the last invocation of the callback. In case of error, the callbacks\nmay receive a final `NULL` reply instead.\n\n### Disconnecting\n\nAn asynchronous connection can be terminated using:\n```c\nvoid redisAsyncDisconnect(redisAsyncContext *ac);\n```\nWhen this function is called, the connection is **not** immediately terminated. Instead, new\ncommands are no longer accepted and the connection is only terminated when all pending commands\nhave been written to the socket, their respective replies have been read and their respective\ncallbacks have been executed. After this, the disconnection callback is executed with the\n`REDIS_OK` status and the context object is freed.\n\nThe connection can be forcefully disconnected using\n```c\nvoid redisAsyncFree(redisAsyncContext *ac);\n```\nIn this case, nothing more is written to the socket, all pending callbacks are called with a `NULL`\nreply and the disconnection callback is called with `REDIS_OK`, after which the context object\nis freed.\n\n\n### Hooking it up to event library *X*\n\nThere are a few hooks that need to be set on the context object after it is created.\nSee the `adapters/` directory for bindings to *libev* and *libevent*.\n\n## Reply parsing API\n\nHiredis comes with a reply parsing API that makes it easy for writing higher\nlevel language bindings.\n\nThe reply parsing API consists of the following functions:\n```c\nredisReader *redisReaderCreate(void);\nvoid redisReaderFree(redisReader *reader);\nint redisReaderFeed(redisReader *reader, const char *buf, size_t len);\nint redisReaderGetReply(redisReader *reader, void **reply);\n```\nThe same set of functions are used internally by hiredis when creating a\nnormal Redis context, the above API just exposes it to the user for a direct\nusage.\n\n### Usage\n\nThe function `redisReaderCreate` creates a `redisReader` structure that holds a\nbuffer with unparsed data and state for the protocol parser.\n\nIncoming data -- most likely from a socket -- can be placed in the internal\nbuffer of the `redisReader` using `redisReaderFeed`. This function will make a\ncopy of the buffer pointed to by `buf` for `len` bytes. This data is parsed\nwhen `redisReaderGetReply` is called. This function returns an integer status\nand a reply object (as described above) via `void **reply`. The returned status\ncan be either `REDIS_OK` or `REDIS_ERR`, where the latter means something went\nwrong (either a protocol error, or an out of memory error).\n\nThe parser limits the level of nesting for multi bulk payloads to 7. If the\nmulti bulk nesting level is higher than this, the parser returns an error.\n\n### Customizing replies\n\nThe function `redisReaderGetReply` creates `redisReply` and makes the function\nargument `reply` point to the created `redisReply` variable. For instance, if\nthe response of type `REDIS_REPLY_STATUS` then the `str` field of `redisReply`\nwill hold the status as a vanilla C string. However, the functions that are\nresponsible for creating instances of the `redisReply` can be customized by\nsetting the `fn` field on the `redisReader` struct. This should be done\nimmediately after creating the `redisReader`.\n\nFor example, [hiredis-rb](https://github.com/pietern/hiredis-rb/blob/master/ext/hiredis_ext/reader.c)\nuses customized reply object functions to create Ruby objects.\n\n### Reader max buffer\n\nBoth when using the Reader API directly or when using it indirectly via a\nnormal Redis context, the redisReader structure uses a buffer in order to\naccumulate data from the server.\nUsually this buffer is destroyed when it is empty and is larger than 16\nKiB in order to avoid wasting memory in unused buffers\n\nHowever when working with very big payloads destroying the buffer may slow\ndown performances considerably, so it is possible to modify the max size of\nan idle buffer changing the value of the `maxbuf` field of the reader structure\nto the desired value. The special value of 0 means that there is no maximum\nvalue for an idle buffer, so the buffer will never get freed.\n\nFor instance if you have a normal Redis context you can set the maximum idle\nbuffer to zero (unlimited) just with:\n```c\ncontext->reader->maxbuf = 0;\n```\nThis should be done only in order to maximize performances when working with\nlarge payloads. The context should be set back to `REDIS_READER_MAX_BUF` again\nas soon as possible in order to prevent allocation of useless memory.\n\n### Reader max array elements\n\nBy default the hiredis reply parser sets the maximum number of multi-bulk elements\nto 2^32 - 1 or 4,294,967,295 entries. If you need to process multi-bulk replies\nwith more than this many elements you can set the value higher or to zero, meaning\nunlimited with:\n```c\ncontext->reader->maxelements = 0;\n```\n\n## SSL/TLS Support\n\n### Building\n\nSSL/TLS support is not built by default and requires an explicit flag:\n\n make USE_SSL=1\n\nThis requires OpenSSL development package (e.g. including header files to be\navailable.\n\nWhen enabled, SSL/TLS support is built into extra `libhiredis_ssl.a` and\n`libhiredis_ssl.so` static/dynamic libraries. This leaves the original libraries\nunaffected so no additional dependencies are introduced.\n\n### Using it\n\nFirst, you'll need to make sure you include the SSL header file:\n\n```c\n#include \n#include \n```\n\nYou will also need to link against `libhiredis_ssl`, **in addition** to\n`libhiredis` and add `-lssl -lcrypto` to satisfy its dependencies.\n\nHiredis implements SSL/TLS on top of its normal `redisContext` or\n`redisAsyncContext`, so you will need to establish a connection first and then\ninitiate an SSL/TLS handshake.\n\n#### Hiredis OpenSSL Wrappers\n\nBefore Hiredis can negotiate an SSL/TLS connection, it is necessary to\ninitialize OpenSSL and create a context. You can do that in two ways:\n\n1. Work directly with the OpenSSL API to initialize the library's global context\n and create `SSL_CTX *` and `SSL *` contexts. With an `SSL *` object you can\n call `redisInitiateSSL()`.\n2. Work with a set of Hiredis-provided wrappers around OpenSSL, create a\n `redisSSLContext` object to hold configuration and use\n `redisInitiateSSLWithContext()` to initiate the SSL/TLS handshake.\n\n```c\n/* An Hiredis SSL context. It holds SSL configuration and can be reused across\n * many contexts.\n */\nredisSSLContext *ssl_context;\n\n/* An error variable to indicate what went wrong, if the context fails to\n * initialize.\n */\nredisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;\n\n/* Initialize global OpenSSL state.\n *\n * You should call this only once when your app initializes, and only if\n * you don't explicitly or implicitly initialize OpenSSL it elsewhere.\n */\nredisInitOpenSSL();\n\n/* Create SSL context */\nssl_context = redisCreateSSLContext(\n \"cacertbundle.crt\", /* File name of trusted CA/ca bundle file, optional */\n \"/path/to/certs\", /* Path of trusted certificates, optional */\n \"client_cert.pem\", /* File name of client certificate file, optional */\n \"client_key.pem\", /* File name of client private key, optional */\n \"redis.mydomain.com\", /* Server name to request (SNI), optional */\n &ssl_error);\n\nif(ssl_context == NULL || ssl_error != REDIS_SSL_CTX_NONE) {\n /* Handle error and abort... */\n /* e.g.\n printf(\"SSL error: %s\\n\",\n (ssl_error != REDIS_SSL_CTX_NONE) ?\n redisSSLContextGetError(ssl_error) : \"Unknown error\");\n // Abort\n */\n}\n\n/* Create Redis context and establish connection */\nc = redisConnect(\"localhost\", 6443);\nif (c == NULL || c->err) {\n /* Handle error and abort... */\n}\n\n/* Negotiate SSL/TLS */\nif (redisInitiateSSLWithContext(c, ssl_context) != REDIS_OK) {\n /* Handle error, in c->err / c->errstr */\n}\n```\n\n## RESP3 PUSH replies\nRedis 6.0 introduced PUSH replies with the reply-type `>`. These messages are generated spontaneously and can arrive at any time, so must be handled using callbacks.\n\n### Default behavior\nHiredis installs handlers on `redisContext` and `redisAsyncContext` by default, which will intercept and free any PUSH replies detected. This means existing code will work as-is after upgrading to Redis 6 and switching to `RESP3`.\n\n### Custom PUSH handler prototypes\nThe callback prototypes differ between `redisContext` and `redisAsyncContext`.\n\n#### redisContext\n```c\nvoid my_push_handler(void *privdata, void *reply) {\n /* Handle the reply */\n\n /* Note: We need to free the reply in our custom handler for\n blocking contexts. This lets us keep the reply if\n we want. */\n freeReplyObject(reply);\n}\n```\n\n#### redisAsyncContext\n```c\nvoid my_async_push_handler(redisAsyncContext *ac, void *reply) {\n /* Handle the reply */\n\n /* Note: Because async hiredis always frees replies, you should\n not call freeReplyObject in an async push callback. */\n}\n```\n\n### Installing a custom handler\nThere are two ways to set your own PUSH handlers.\n\n1. Set `push_cb` or `async_push_cb` in the `redisOptions` struct and connect with `redisConnectWithOptions` or `redisAsyncConnectWithOptions`.\n ```c\n redisOptions = {0};\n REDIS_OPTIONS_SET_TCP(&options, \"127.0.0.1\", 6379);\n options->push_cb = my_push_handler;\n redisContext *context = redisConnectWithOptions(&options);\n ```\n2. Call `redisSetPushCallback` or `redisAsyncSetPushCallback` on a connected context.\n ```c\n redisContext *context = redisConnect(\"127.0.0.1\", 6379);\n redisSetPushCallback(context, my_push_handler);\n ```\n\n _Note `redisSetPushCallback` and `redisAsyncSetPushCallback` both return any currently configured handler, making it easy to override and then return to the old value._\n\n### Specifying no handler\nIf you have a unique use-case where you don't want hiredis to automatically intercept and free PUSH replies, you will want to configure no handler at all. This can be done in two ways.\n1. Set the `REDIS_OPT_NO_PUSH_AUTOFREE` flag in `redisOptions` and leave the callback function pointer `NULL`.\n ```c\n redisOptions = {0};\n REDIS_OPTIONS_SET_TCP(&options, \"127.0.0.1\", 6379);\n options->options |= REDIS_OPT_NO_PUSH_AUTOFREE;\n redisContext *context = redisConnectWithOptions(&options);\n ```\n3. Call `redisSetPushCallback` with `NULL` once connected.\n ```c\n redisContext *context = redisConnect(\"127.0.0.1\", 6379);\n redisSetPushCallback(context, NULL);\n ```\n\n _Note: With no handler configured, calls to `redisCommand` may generate more than one reply, so this strategy is only applicable when there's some kind of blocking `redisGetReply()` loop (e.g. `MONITOR` or `SUBSCRIBE` workloads)._\n\n## Allocator injection\n\nHiredis uses a pass-thru structure of function pointers defined in [alloc.h](https://github.com/redis/hiredis/blob/f5d25850/alloc.h#L41) that contain the currently configured allocation and deallocation functions. By default they just point to libc (`malloc`, `calloc`, `realloc`, etc).\n\n### Overriding\n\nOne can override the allocators like so:\n\n```c\nhiredisAllocFuncs myfuncs = {\n .mallocFn = my_malloc,\n .callocFn = my_calloc,\n .reallocFn = my_realloc,\n .strdupFn = my_strdup,\n .freeFn = my_free,\n};\n\n// Override allocators (function returns current allocators if needed)\nhiredisAllocFuncs orig = hiredisSetAllocators(&myfuncs);\n```\n\nTo reset the allocators to their default libc function simply call:\n\n```c\nhiredisResetAllocators();\n```\n\n## AUTHORS\n\nSalvatore Sanfilippo (antirez at gmail),\\\nPieter Noordhuis (pcnoordhuis at gmail)\\\nMichael Grunder (michael dot grunder at gmail)\n\n_Hiredis is released under the BSD license._\n" }, { "path": "deps/hiredis/adapters/ae.h", "content": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_AE_H__\n#define __HIREDIS_AE_H__\n#include \n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct redisAeEvents {\n redisAsyncContext *context;\n aeEventLoop *loop;\n int fd;\n int reading, writing;\n} redisAeEvents;\n\nstatic void redisAeReadEvent(aeEventLoop *el, int fd, void *privdata, int mask) {\n ((void)el); ((void)fd); ((void)mask);\n\n redisAeEvents *e = (redisAeEvents*)privdata;\n redisAsyncHandleRead(e->context);\n}\n\nstatic void redisAeWriteEvent(aeEventLoop *el, int fd, void *privdata, int mask) {\n ((void)el); ((void)fd); ((void)mask);\n\n redisAeEvents *e = (redisAeEvents*)privdata;\n redisAsyncHandleWrite(e->context);\n}\n\nstatic void redisAeAddRead(void *privdata) {\n redisAeEvents *e = (redisAeEvents*)privdata;\n aeEventLoop *loop = e->loop;\n if (!e->reading) {\n e->reading = 1;\n aeCreateFileEvent(loop,e->fd,AE_READABLE,redisAeReadEvent,e);\n }\n}\n\nstatic void redisAeDelRead(void *privdata) {\n redisAeEvents *e = (redisAeEvents*)privdata;\n aeEventLoop *loop = e->loop;\n if (e->reading) {\n e->reading = 0;\n aeDeleteFileEvent(loop,e->fd,AE_READABLE);\n }\n}\n\nstatic void redisAeAddWrite(void *privdata) {\n redisAeEvents *e = (redisAeEvents*)privdata;\n aeEventLoop *loop = e->loop;\n if (!e->writing) {\n e->writing = 1;\n aeCreateFileEvent(loop,e->fd,AE_WRITABLE,redisAeWriteEvent,e);\n }\n}\n\nstatic void redisAeDelWrite(void *privdata) {\n redisAeEvents *e = (redisAeEvents*)privdata;\n aeEventLoop *loop = e->loop;\n if (e->writing) {\n e->writing = 0;\n aeDeleteFileEvent(loop,e->fd,AE_WRITABLE);\n }\n}\n\nstatic void redisAeCleanup(void *privdata) {\n redisAeEvents *e = (redisAeEvents*)privdata;\n redisAeDelRead(privdata);\n redisAeDelWrite(privdata);\n hi_free(e);\n}\n\nstatic int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisAeEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisAeEvents*)hi_malloc(sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n e->context = ac;\n e->loop = loop;\n e->fd = c->fd;\n e->reading = e->writing = 0;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisAeAddRead;\n ac->ev.delRead = redisAeDelRead;\n ac->ev.addWrite = redisAeAddWrite;\n ac->ev.delWrite = redisAeDelWrite;\n ac->ev.cleanup = redisAeCleanup;\n ac->ev.data = e;\n\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/glib.h", "content": "#ifndef __HIREDIS_GLIB_H__\n#define __HIREDIS_GLIB_H__\n\n#include \n\n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct\n{\n GSource source;\n redisAsyncContext *ac;\n GPollFD poll_fd;\n} RedisSource;\n\nstatic void\nredis_source_add_read (gpointer data)\n{\n RedisSource *source = (RedisSource *)data;\n g_return_if_fail(source);\n source->poll_fd.events |= G_IO_IN;\n g_main_context_wakeup(g_source_get_context((GSource *)data));\n}\n\nstatic void\nredis_source_del_read (gpointer data)\n{\n RedisSource *source = (RedisSource *)data;\n g_return_if_fail(source);\n source->poll_fd.events &= ~G_IO_IN;\n g_main_context_wakeup(g_source_get_context((GSource *)data));\n}\n\nstatic void\nredis_source_add_write (gpointer data)\n{\n RedisSource *source = (RedisSource *)data;\n g_return_if_fail(source);\n source->poll_fd.events |= G_IO_OUT;\n g_main_context_wakeup(g_source_get_context((GSource *)data));\n}\n\nstatic void\nredis_source_del_write (gpointer data)\n{\n RedisSource *source = (RedisSource *)data;\n g_return_if_fail(source);\n source->poll_fd.events &= ~G_IO_OUT;\n g_main_context_wakeup(g_source_get_context((GSource *)data));\n}\n\nstatic void\nredis_source_cleanup (gpointer data)\n{\n RedisSource *source = (RedisSource *)data;\n\n g_return_if_fail(source);\n\n redis_source_del_read(source);\n redis_source_del_write(source);\n /*\n * It is not our responsibility to remove ourself from the\n * current main loop. However, we will remove the GPollFD.\n */\n if (source->poll_fd.fd >= 0) {\n g_source_remove_poll((GSource *)data, &source->poll_fd);\n source->poll_fd.fd = -1;\n }\n}\n\nstatic gboolean\nredis_source_prepare (GSource *source,\n gint *timeout_)\n{\n RedisSource *redis = (RedisSource *)source;\n *timeout_ = -1;\n return !!(redis->poll_fd.events & redis->poll_fd.revents);\n}\n\nstatic gboolean\nredis_source_check (GSource *source)\n{\n RedisSource *redis = (RedisSource *)source;\n return !!(redis->poll_fd.events & redis->poll_fd.revents);\n}\n\nstatic gboolean\nredis_source_dispatch (GSource *source,\n GSourceFunc callback,\n gpointer user_data)\n{\n RedisSource *redis = (RedisSource *)source;\n\n if ((redis->poll_fd.revents & G_IO_OUT)) {\n redisAsyncHandleWrite(redis->ac);\n redis->poll_fd.revents &= ~G_IO_OUT;\n }\n\n if ((redis->poll_fd.revents & G_IO_IN)) {\n redisAsyncHandleRead(redis->ac);\n redis->poll_fd.revents &= ~G_IO_IN;\n }\n\n if (callback) {\n return callback(user_data);\n }\n\n return TRUE;\n}\n\nstatic void\nredis_source_finalize (GSource *source)\n{\n RedisSource *redis = (RedisSource *)source;\n\n if (redis->poll_fd.fd >= 0) {\n g_source_remove_poll(source, &redis->poll_fd);\n redis->poll_fd.fd = -1;\n }\n}\n\nstatic GSource *\nredis_source_new (redisAsyncContext *ac)\n{\n static GSourceFuncs source_funcs = {\n .prepare = redis_source_prepare,\n .check = redis_source_check,\n .dispatch = redis_source_dispatch,\n .finalize = redis_source_finalize,\n };\n redisContext *c = &ac->c;\n RedisSource *source;\n\n g_return_val_if_fail(ac != NULL, NULL);\n\n source = (RedisSource *)g_source_new(&source_funcs, sizeof *source);\n if (source == NULL)\n return NULL;\n\n source->ac = ac;\n source->poll_fd.fd = c->fd;\n source->poll_fd.events = 0;\n source->poll_fd.revents = 0;\n g_source_add_poll((GSource *)source, &source->poll_fd);\n\n ac->ev.addRead = redis_source_add_read;\n ac->ev.delRead = redis_source_del_read;\n ac->ev.addWrite = redis_source_add_write;\n ac->ev.delWrite = redis_source_del_write;\n ac->ev.cleanup = redis_source_cleanup;\n ac->ev.data = source;\n\n return (GSource *)source;\n}\n\n#endif /* __HIREDIS_GLIB_H__ */\n" }, { "path": "deps/hiredis/adapters/ivykis.h", "content": "#ifndef __HIREDIS_IVYKIS_H__\n#define __HIREDIS_IVYKIS_H__\n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct redisIvykisEvents {\n redisAsyncContext *context;\n struct iv_fd fd;\n} redisIvykisEvents;\n\nstatic void redisIvykisReadEvent(void *arg) {\n redisAsyncContext *context = (redisAsyncContext *)arg;\n redisAsyncHandleRead(context);\n}\n\nstatic void redisIvykisWriteEvent(void *arg) {\n redisAsyncContext *context = (redisAsyncContext *)arg;\n redisAsyncHandleWrite(context);\n}\n\nstatic void redisIvykisAddRead(void *privdata) {\n redisIvykisEvents *e = (redisIvykisEvents*)privdata;\n iv_fd_set_handler_in(&e->fd, redisIvykisReadEvent);\n}\n\nstatic void redisIvykisDelRead(void *privdata) {\n redisIvykisEvents *e = (redisIvykisEvents*)privdata;\n iv_fd_set_handler_in(&e->fd, NULL);\n}\n\nstatic void redisIvykisAddWrite(void *privdata) {\n redisIvykisEvents *e = (redisIvykisEvents*)privdata;\n iv_fd_set_handler_out(&e->fd, redisIvykisWriteEvent);\n}\n\nstatic void redisIvykisDelWrite(void *privdata) {\n redisIvykisEvents *e = (redisIvykisEvents*)privdata;\n iv_fd_set_handler_out(&e->fd, NULL);\n}\n\nstatic void redisIvykisCleanup(void *privdata) {\n redisIvykisEvents *e = (redisIvykisEvents*)privdata;\n\n iv_fd_unregister(&e->fd);\n hi_free(e);\n}\n\nstatic int redisIvykisAttach(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisIvykisEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisIvykisEvents*)hi_malloc(sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n e->context = ac;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisIvykisAddRead;\n ac->ev.delRead = redisIvykisDelRead;\n ac->ev.addWrite = redisIvykisAddWrite;\n ac->ev.delWrite = redisIvykisDelWrite;\n ac->ev.cleanup = redisIvykisCleanup;\n ac->ev.data = e;\n\n /* Initialize and install read/write events */\n IV_FD_INIT(&e->fd);\n e->fd.fd = c->fd;\n e->fd.handler_in = redisIvykisReadEvent;\n e->fd.handler_out = redisIvykisWriteEvent;\n e->fd.handler_err = NULL;\n e->fd.cookie = e->context;\n\n iv_fd_register(&e->fd);\n\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/libev.h", "content": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_LIBEV_H__\n#define __HIREDIS_LIBEV_H__\n#include \n#include \n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct redisLibevEvents {\n redisAsyncContext *context;\n struct ev_loop *loop;\n int reading, writing;\n ev_io rev, wev;\n ev_timer timer;\n} redisLibevEvents;\n\nstatic void redisLibevReadEvent(EV_P_ ev_io *watcher, int revents) {\n#if EV_MULTIPLICITY\n ((void)EV_A);\n#endif\n ((void)revents);\n\n redisLibevEvents *e = (redisLibevEvents*)watcher->data;\n redisAsyncHandleRead(e->context);\n}\n\nstatic void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) {\n#if EV_MULTIPLICITY\n ((void)EV_A);\n#endif\n ((void)revents);\n\n redisLibevEvents *e = (redisLibevEvents*)watcher->data;\n redisAsyncHandleWrite(e->context);\n}\n\nstatic void redisLibevAddRead(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n if (!e->reading) {\n e->reading = 1;\n ev_io_start(EV_A_ &e->rev);\n }\n}\n\nstatic void redisLibevDelRead(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n if (e->reading) {\n e->reading = 0;\n ev_io_stop(EV_A_ &e->rev);\n }\n}\n\nstatic void redisLibevAddWrite(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n if (!e->writing) {\n e->writing = 1;\n ev_io_start(EV_A_ &e->wev);\n }\n}\n\nstatic void redisLibevDelWrite(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n if (e->writing) {\n e->writing = 0;\n ev_io_stop(EV_A_ &e->wev);\n }\n}\n\nstatic void redisLibevStopTimer(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n ev_timer_stop(EV_A_ &e->timer);\n}\n\nstatic void redisLibevCleanup(void *privdata) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n redisLibevDelRead(privdata);\n redisLibevDelWrite(privdata);\n redisLibevStopTimer(privdata);\n hi_free(e);\n}\n\nstatic void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {\n#if EV_MULTIPLICITY\n ((void)EV_A);\n#endif\n ((void)revents);\n redisLibevEvents *e = (redisLibevEvents*)timer->data;\n redisAsyncHandleTimeout(e->context);\n}\n\nstatic void redisLibevSetTimeout(void *privdata, struct timeval tv) {\n redisLibevEvents *e = (redisLibevEvents*)privdata;\n#if EV_MULTIPLICITY\n struct ev_loop *loop = e->loop;\n#endif\n\n if (!ev_is_active(&e->timer)) {\n ev_init(&e->timer, redisLibevTimeout);\n e->timer.data = e;\n }\n\n e->timer.repeat = tv.tv_sec + tv.tv_usec / 1000000.00;\n ev_timer_again(EV_A_ &e->timer);\n}\n\nstatic int redisLibevAttach(EV_P_ redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisLibevEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisLibevEvents*)hi_calloc(1, sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n e->context = ac;\n#if EV_MULTIPLICITY\n e->loop = EV_A;\n#else\n e->loop = NULL;\n#endif\n e->rev.data = e;\n e->wev.data = e;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisLibevAddRead;\n ac->ev.delRead = redisLibevDelRead;\n ac->ev.addWrite = redisLibevAddWrite;\n ac->ev.delWrite = redisLibevDelWrite;\n ac->ev.cleanup = redisLibevCleanup;\n ac->ev.scheduleTimer = redisLibevSetTimeout;\n ac->ev.data = e;\n\n /* Initialize read/write events */\n ev_io_init(&e->rev,redisLibevReadEvent,c->fd,EV_READ);\n ev_io_init(&e->wev,redisLibevWriteEvent,c->fd,EV_WRITE);\n return REDIS_OK;\n}\n\n#endif\n" }, { "path": "deps/hiredis/adapters/libevent.h", "content": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_LIBEVENT_H__\n#define __HIREDIS_LIBEVENT_H__\n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\n#define REDIS_LIBEVENT_DELETED 0x01\n#define REDIS_LIBEVENT_ENTERED 0x02\n\ntypedef struct redisLibeventEvents {\n redisAsyncContext *context;\n struct event *ev;\n struct event_base *base;\n struct timeval tv;\n short flags;\n short state;\n} redisLibeventEvents;\n\nstatic void redisLibeventDestroy(redisLibeventEvents *e) {\n hi_free(e);\n}\n\nstatic void redisLibeventHandler(evutil_socket_t fd, short event, void *arg) {\n ((void)fd);\n redisLibeventEvents *e = (redisLibeventEvents*)arg;\n e->state |= REDIS_LIBEVENT_ENTERED;\n\n #define CHECK_DELETED() if (e->state & REDIS_LIBEVENT_DELETED) {\\\n redisLibeventDestroy(e);\\\n return; \\\n }\n\n if ((event & EV_TIMEOUT) && (e->state & REDIS_LIBEVENT_DELETED) == 0) {\n redisAsyncHandleTimeout(e->context);\n CHECK_DELETED();\n }\n\n if ((event & EV_READ) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) {\n redisAsyncHandleRead(e->context);\n CHECK_DELETED();\n }\n\n if ((event & EV_WRITE) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) {\n redisAsyncHandleWrite(e->context);\n CHECK_DELETED();\n }\n\n e->state &= ~REDIS_LIBEVENT_ENTERED;\n #undef CHECK_DELETED\n}\n\nstatic void redisLibeventUpdate(void *privdata, short flag, int isRemove) {\n redisLibeventEvents *e = (redisLibeventEvents *)privdata;\n const struct timeval *tv = e->tv.tv_sec || e->tv.tv_usec ? &e->tv : NULL;\n\n if (isRemove) {\n if ((e->flags & flag) == 0) {\n return;\n } else {\n e->flags &= ~flag;\n }\n } else {\n if (e->flags & flag) {\n return;\n } else {\n e->flags |= flag;\n }\n }\n\n event_del(e->ev);\n event_assign(e->ev, e->base, e->context->c.fd, e->flags | EV_PERSIST,\n redisLibeventHandler, privdata);\n event_add(e->ev, tv);\n}\n\nstatic void redisLibeventAddRead(void *privdata) {\n redisLibeventUpdate(privdata, EV_READ, 0);\n}\n\nstatic void redisLibeventDelRead(void *privdata) {\n redisLibeventUpdate(privdata, EV_READ, 1);\n}\n\nstatic void redisLibeventAddWrite(void *privdata) {\n redisLibeventUpdate(privdata, EV_WRITE, 0);\n}\n\nstatic void redisLibeventDelWrite(void *privdata) {\n redisLibeventUpdate(privdata, EV_WRITE, 1);\n}\n\nstatic void redisLibeventCleanup(void *privdata) {\n redisLibeventEvents *e = (redisLibeventEvents*)privdata;\n if (!e) {\n return;\n }\n event_del(e->ev);\n event_free(e->ev);\n e->ev = NULL;\n\n if (e->state & REDIS_LIBEVENT_ENTERED) {\n e->state |= REDIS_LIBEVENT_DELETED;\n } else {\n redisLibeventDestroy(e);\n }\n}\n\nstatic void redisLibeventSetTimeout(void *privdata, struct timeval tv) {\n redisLibeventEvents *e = (redisLibeventEvents *)privdata;\n short flags = e->flags;\n e->flags = 0;\n e->tv = tv;\n redisLibeventUpdate(e, flags, 0);\n}\n\nstatic int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {\n redisContext *c = &(ac->c);\n redisLibeventEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisLibeventEvents*)hi_calloc(1, sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n e->context = ac;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisLibeventAddRead;\n ac->ev.delRead = redisLibeventDelRead;\n ac->ev.addWrite = redisLibeventAddWrite;\n ac->ev.delWrite = redisLibeventDelWrite;\n ac->ev.cleanup = redisLibeventCleanup;\n ac->ev.scheduleTimer = redisLibeventSetTimeout;\n ac->ev.data = e;\n\n /* Initialize and install read/write events */\n e->ev = event_new(base, c->fd, EV_READ | EV_WRITE, redisLibeventHandler, e);\n e->base = base;\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/libhv.h", "content": "#ifndef __HIREDIS_LIBHV_H__\n#define __HIREDIS_LIBHV_H__\n\n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct redisLibhvEvents {\n hio_t *io;\n htimer_t *timer;\n} redisLibhvEvents;\n\nstatic void redisLibhvHandleEvents(hio_t* io) {\n redisAsyncContext* context = (redisAsyncContext*)hevent_userdata(io);\n int events = hio_events(io);\n int revents = hio_revents(io);\n if (context && (events & HV_READ) && (revents & HV_READ)) {\n redisAsyncHandleRead(context);\n }\n if (context && (events & HV_WRITE) && (revents & HV_WRITE)) {\n redisAsyncHandleWrite(context);\n }\n}\n\nstatic void redisLibhvAddRead(void *privdata) {\n redisLibhvEvents* events = (redisLibhvEvents*)privdata;\n hio_add(events->io, redisLibhvHandleEvents, HV_READ);\n}\n\nstatic void redisLibhvDelRead(void *privdata) {\n redisLibhvEvents* events = (redisLibhvEvents*)privdata;\n hio_del(events->io, HV_READ);\n}\n\nstatic void redisLibhvAddWrite(void *privdata) {\n redisLibhvEvents* events = (redisLibhvEvents*)privdata;\n hio_add(events->io, redisLibhvHandleEvents, HV_WRITE);\n}\n\nstatic void redisLibhvDelWrite(void *privdata) {\n redisLibhvEvents* events = (redisLibhvEvents*)privdata;\n hio_del(events->io, HV_WRITE);\n}\n\nstatic void redisLibhvCleanup(void *privdata) {\n redisLibhvEvents* events = (redisLibhvEvents*)privdata;\n\n if (events->timer)\n htimer_del(events->timer);\n\n hio_close(events->io);\n hevent_set_userdata(events->io, NULL);\n\n hi_free(events);\n}\n\nstatic void redisLibhvTimeout(htimer_t* timer) {\n hio_t* io = (hio_t*)hevent_userdata(timer);\n redisAsyncHandleTimeout((redisAsyncContext*)hevent_userdata(io));\n}\n\nstatic void redisLibhvSetTimeout(void *privdata, struct timeval tv) {\n redisLibhvEvents* events;\n uint32_t millis;\n hloop_t* loop;\n\n events = (redisLibhvEvents*)privdata;\n millis = tv.tv_sec * 1000 + tv.tv_usec / 1000;\n\n if (millis == 0) {\n /* Libhv disallows zero'd timers so treat this as a delete or NO OP */\n if (events->timer) {\n htimer_del(events->timer);\n events->timer = NULL;\n }\n } else if (events->timer == NULL) {\n /* Add new timer */\n loop = hevent_loop(events->io);\n events->timer = htimer_add(loop, redisLibhvTimeout, millis, 1);\n hevent_set_userdata(events->timer, events->io);\n } else {\n /* Update existing timer */\n htimer_reset(events->timer, millis);\n }\n}\n\nstatic int redisLibhvAttach(redisAsyncContext* ac, hloop_t* loop) {\n redisContext *c = &(ac->c);\n redisLibhvEvents *events;\n hio_t* io = NULL;\n\n if (ac->ev.data != NULL) {\n return REDIS_ERR;\n }\n\n /* Create container struct to keep track of our io and any timer */\n events = (redisLibhvEvents*)hi_malloc(sizeof(*events));\n if (events == NULL) {\n return REDIS_ERR;\n }\n\n io = hio_get(loop, c->fd);\n if (io == NULL) {\n hi_free(events);\n return REDIS_ERR;\n }\n\n hevent_set_userdata(io, ac);\n\n events->io = io;\n events->timer = NULL;\n\n ac->ev.addRead = redisLibhvAddRead;\n ac->ev.delRead = redisLibhvDelRead;\n ac->ev.addWrite = redisLibhvAddWrite;\n ac->ev.delWrite = redisLibhvDelWrite;\n ac->ev.cleanup = redisLibhvCleanup;\n ac->ev.scheduleTimer = redisLibhvSetTimeout;\n ac->ev.data = events;\n\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/libsdevent.h", "content": "#ifndef HIREDIS_LIBSDEVENT_H\n#define HIREDIS_LIBSDEVENT_H\n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n\n#define REDIS_LIBSDEVENT_DELETED 0x01\n#define REDIS_LIBSDEVENT_ENTERED 0x02\n\ntypedef struct redisLibsdeventEvents {\n redisAsyncContext *context;\n struct sd_event *event;\n struct sd_event_source *fdSource;\n struct sd_event_source *timerSource;\n int fd;\n short flags;\n short state;\n} redisLibsdeventEvents;\n\nstatic void redisLibsdeventDestroy(redisLibsdeventEvents *e) {\n if (e->fdSource) {\n e->fdSource = sd_event_source_disable_unref(e->fdSource);\n }\n if (e->timerSource) {\n e->timerSource = sd_event_source_disable_unref(e->timerSource);\n }\n sd_event_unref(e->event);\n hi_free(e);\n}\n\nstatic int redisLibsdeventTimeoutHandler(sd_event_source *s, uint64_t usec, void *userdata) {\n ((void)s);\n ((void)usec);\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n redisAsyncHandleTimeout(e->context);\n return 0;\n}\n\nstatic int redisLibsdeventHandler(sd_event_source *s, int fd, uint32_t event, void *userdata) {\n ((void)s);\n ((void)fd);\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n e->state |= REDIS_LIBSDEVENT_ENTERED;\n\n#define CHECK_DELETED() if (e->state & REDIS_LIBSDEVENT_DELETED) {\\\n redisLibsdeventDestroy(e);\\\n return 0; \\\n }\n\n if ((event & EPOLLIN) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) {\n redisAsyncHandleRead(e->context);\n CHECK_DELETED();\n }\n\n if ((event & EPOLLOUT) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) {\n redisAsyncHandleWrite(e->context);\n CHECK_DELETED();\n }\n\n e->state &= ~REDIS_LIBSDEVENT_ENTERED;\n#undef CHECK_DELETED\n\n return 0;\n}\n\nstatic void redisLibsdeventAddRead(void *userdata) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n\n if (e->flags & EPOLLIN) {\n return;\n }\n\n e->flags |= EPOLLIN;\n\n if (e->flags & EPOLLOUT) {\n sd_event_source_set_io_events(e->fdSource, e->flags);\n } else {\n sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e);\n }\n}\n\nstatic void redisLibsdeventDelRead(void *userdata) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n\n e->flags &= ~EPOLLIN;\n\n if (e->flags) {\n sd_event_source_set_io_events(e->fdSource, e->flags);\n } else {\n e->fdSource = sd_event_source_disable_unref(e->fdSource);\n }\n}\n\nstatic void redisLibsdeventAddWrite(void *userdata) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n\n if (e->flags & EPOLLOUT) {\n return;\n }\n\n e->flags |= EPOLLOUT;\n\n if (e->flags & EPOLLIN) {\n sd_event_source_set_io_events(e->fdSource, e->flags);\n } else {\n sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e);\n }\n}\n\nstatic void redisLibsdeventDelWrite(void *userdata) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n\n e->flags &= ~EPOLLOUT;\n\n if (e->flags) {\n sd_event_source_set_io_events(e->fdSource, e->flags);\n } else {\n e->fdSource = sd_event_source_disable_unref(e->fdSource);\n }\n}\n\nstatic void redisLibsdeventCleanup(void *userdata) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;\n\n if (!e) {\n return;\n }\n\n if (e->state & REDIS_LIBSDEVENT_ENTERED) {\n e->state |= REDIS_LIBSDEVENT_DELETED;\n } else {\n redisLibsdeventDestroy(e);\n }\n}\n\nstatic void redisLibsdeventSetTimeout(void *userdata, struct timeval tv) {\n redisLibsdeventEvents *e = (redisLibsdeventEvents *)userdata;\n\n uint64_t usec = tv.tv_sec * 1000000 + tv.tv_usec;\n if (!e->timerSource) {\n sd_event_add_time_relative(e->event, &e->timerSource, CLOCK_MONOTONIC, usec, 1, redisLibsdeventTimeoutHandler, e);\n } else {\n sd_event_source_set_time_relative(e->timerSource, usec);\n }\n}\n\nstatic int redisLibsdeventAttach(redisAsyncContext *ac, struct sd_event *event) {\n redisContext *c = &(ac->c);\n redisLibsdeventEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisLibsdeventEvents*)hi_calloc(1, sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n /* Initialize and increase event refcount */\n e->context = ac;\n e->event = event;\n e->fd = c->fd;\n sd_event_ref(event);\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisLibsdeventAddRead;\n ac->ev.delRead = redisLibsdeventDelRead;\n ac->ev.addWrite = redisLibsdeventAddWrite;\n ac->ev.delWrite = redisLibsdeventDelWrite;\n ac->ev.cleanup = redisLibsdeventCleanup;\n ac->ev.scheduleTimer = redisLibsdeventSetTimeout;\n ac->ev.data = e;\n\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/libuv.h", "content": "#ifndef __HIREDIS_LIBUV_H__\n#define __HIREDIS_LIBUV_H__\n#include \n#include \n#include \"../hiredis.h\"\n#include \"../async.h\"\n#include \n\ntypedef struct redisLibuvEvents {\n redisAsyncContext* context;\n uv_poll_t handle;\n uv_timer_t timer;\n int events;\n} redisLibuvEvents;\n\n\nstatic void redisLibuvPoll(uv_poll_t* handle, int status, int events) {\n redisLibuvEvents* p = (redisLibuvEvents*)handle->data;\n int ev = (status ? p->events : events);\n\n if (p->context != NULL && (ev & UV_READABLE)) {\n redisAsyncHandleRead(p->context);\n }\n if (p->context != NULL && (ev & UV_WRITABLE)) {\n redisAsyncHandleWrite(p->context);\n }\n}\n\n\nstatic void redisLibuvAddRead(void *privdata) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n if (p->events & UV_READABLE) {\n return;\n }\n\n p->events |= UV_READABLE;\n\n uv_poll_start(&p->handle, p->events, redisLibuvPoll);\n}\n\n\nstatic void redisLibuvDelRead(void *privdata) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n p->events &= ~UV_READABLE;\n\n if (p->events) {\n uv_poll_start(&p->handle, p->events, redisLibuvPoll);\n } else {\n uv_poll_stop(&p->handle);\n }\n}\n\n\nstatic void redisLibuvAddWrite(void *privdata) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n if (p->events & UV_WRITABLE) {\n return;\n }\n\n p->events |= UV_WRITABLE;\n\n uv_poll_start(&p->handle, p->events, redisLibuvPoll);\n}\n\n\nstatic void redisLibuvDelWrite(void *privdata) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n p->events &= ~UV_WRITABLE;\n\n if (p->events) {\n uv_poll_start(&p->handle, p->events, redisLibuvPoll);\n } else {\n uv_poll_stop(&p->handle);\n }\n}\n\nstatic void on_timer_close(uv_handle_t *handle) {\n redisLibuvEvents* p = (redisLibuvEvents*)handle->data;\n p->timer.data = NULL;\n if (!p->handle.data) {\n // both timer and handle are closed\n hi_free(p);\n }\n // else, wait for `on_handle_close`\n}\n\nstatic void on_handle_close(uv_handle_t *handle) {\n redisLibuvEvents* p = (redisLibuvEvents*)handle->data;\n p->handle.data = NULL;\n if (!p->timer.data) {\n // timer never started, or timer already destroyed\n hi_free(p);\n }\n // else, wait for `on_timer_close`\n}\n\n// libuv removed `status` parameter since v0.11.23\n// see: https://github.com/libuv/libuv/blob/v0.11.23/include/uv.h\n#if (UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR < 11) || \\\n (UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR == 11 && UV_VERSION_PATCH < 23)\nstatic void redisLibuvTimeout(uv_timer_t *timer, int status) {\n (void)status; // unused\n#else\nstatic void redisLibuvTimeout(uv_timer_t *timer) {\n#endif\n redisLibuvEvents *e = (redisLibuvEvents*)timer->data;\n redisAsyncHandleTimeout(e->context);\n}\n\nstatic void redisLibuvSetTimeout(void *privdata, struct timeval tv) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n uint64_t millsec = tv.tv_sec * 1000 + tv.tv_usec / 1000.0;\n if (!p->timer.data) {\n // timer is uninitialized\n if (uv_timer_init(p->handle.loop, &p->timer) != 0) {\n return;\n }\n p->timer.data = p;\n }\n // updates the timeout if the timer has already started\n // or start the timer\n uv_timer_start(&p->timer, redisLibuvTimeout, millsec, 0);\n}\n\nstatic void redisLibuvCleanup(void *privdata) {\n redisLibuvEvents* p = (redisLibuvEvents*)privdata;\n\n p->context = NULL; // indicate that context might no longer exist\n if (p->timer.data) {\n uv_close((uv_handle_t*)&p->timer, on_timer_close);\n }\n uv_close((uv_handle_t*)&p->handle, on_handle_close);\n}\n\n\nstatic int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) {\n redisContext *c = &(ac->c);\n\n if (ac->ev.data != NULL) {\n return REDIS_ERR;\n }\n\n ac->ev.addRead = redisLibuvAddRead;\n ac->ev.delRead = redisLibuvDelRead;\n ac->ev.addWrite = redisLibuvAddWrite;\n ac->ev.delWrite = redisLibuvDelWrite;\n ac->ev.cleanup = redisLibuvCleanup;\n ac->ev.scheduleTimer = redisLibuvSetTimeout;\n\n redisLibuvEvents* p = (redisLibuvEvents*)hi_malloc(sizeof(*p));\n if (p == NULL)\n return REDIS_ERR;\n\n memset(p, 0, sizeof(*p));\n\n if (uv_poll_init_socket(loop, &p->handle, c->fd) != 0) {\n return REDIS_ERR;\n }\n\n ac->ev.data = p;\n p->handle.data = p;\n p->context = ac;\n\n return REDIS_OK;\n}\n#endif\n" }, { "path": "deps/hiredis/adapters/macosx.h", "content": "//\n// Created by Дмитрий Бахвалов on 13.07.15.\n// Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#ifndef __HIREDIS_MACOSX_H__\n#define __HIREDIS_MACOSX_H__\n\n#include \n\n#include \"../hiredis.h\"\n#include \"../async.h\"\n\ntypedef struct {\n redisAsyncContext *context;\n CFSocketRef socketRef;\n CFRunLoopSourceRef sourceRef;\n} RedisRunLoop;\n\nstatic int freeRedisRunLoop(RedisRunLoop* redisRunLoop) {\n if( redisRunLoop != NULL ) {\n if( redisRunLoop->sourceRef != NULL ) {\n CFRunLoopSourceInvalidate(redisRunLoop->sourceRef);\n CFRelease(redisRunLoop->sourceRef);\n }\n if( redisRunLoop->socketRef != NULL ) {\n CFSocketInvalidate(redisRunLoop->socketRef);\n CFRelease(redisRunLoop->socketRef);\n }\n hi_free(redisRunLoop);\n }\n return REDIS_ERR;\n}\n\nstatic void redisMacOSAddRead(void *privdata) {\n RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata;\n CFSocketEnableCallBacks(redisRunLoop->socketRef, kCFSocketReadCallBack);\n}\n\nstatic void redisMacOSDelRead(void *privdata) {\n RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata;\n CFSocketDisableCallBacks(redisRunLoop->socketRef, kCFSocketReadCallBack);\n}\n\nstatic void redisMacOSAddWrite(void *privdata) {\n RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata;\n CFSocketEnableCallBacks(redisRunLoop->socketRef, kCFSocketWriteCallBack);\n}\n\nstatic void redisMacOSDelWrite(void *privdata) {\n RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata;\n CFSocketDisableCallBacks(redisRunLoop->socketRef, kCFSocketWriteCallBack);\n}\n\nstatic void redisMacOSCleanup(void *privdata) {\n RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata;\n freeRedisRunLoop(redisRunLoop);\n}\n\nstatic void redisMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCallBackType callbackType, CFDataRef __unused address, const void __unused *data, void *info) {\n redisAsyncContext* context = (redisAsyncContext*) info;\n\n switch (callbackType) {\n case kCFSocketReadCallBack:\n redisAsyncHandleRead(context);\n break;\n\n case kCFSocketWriteCallBack:\n redisAsyncHandleWrite(context);\n break;\n\n default:\n break;\n }\n}\n\nstatic int redisMacOSAttach(redisAsyncContext *redisAsyncCtx, CFRunLoopRef runLoop) {\n redisContext *redisCtx = &(redisAsyncCtx->c);\n\n /* Nothing should be attached when something is already attached */\n if( redisAsyncCtx->ev.data != NULL ) return REDIS_ERR;\n\n RedisRunLoop* redisRunLoop = (RedisRunLoop*) hi_calloc(1, sizeof(RedisRunLoop));\n if (redisRunLoop == NULL)\n return REDIS_ERR;\n\n /* Setup redis stuff */\n redisRunLoop->context = redisAsyncCtx;\n\n redisAsyncCtx->ev.addRead = redisMacOSAddRead;\n redisAsyncCtx->ev.delRead = redisMacOSDelRead;\n redisAsyncCtx->ev.addWrite = redisMacOSAddWrite;\n redisAsyncCtx->ev.delWrite = redisMacOSDelWrite;\n redisAsyncCtx->ev.cleanup = redisMacOSCleanup;\n redisAsyncCtx->ev.data = redisRunLoop;\n\n /* Initialize and install read/write events */\n CFSocketContext socketCtx = { 0, redisAsyncCtx, NULL, NULL, NULL };\n\n redisRunLoop->socketRef = CFSocketCreateWithNative(NULL, redisCtx->fd,\n kCFSocketReadCallBack | kCFSocketWriteCallBack,\n redisMacOSAsyncCallback,\n &socketCtx);\n if( !redisRunLoop->socketRef ) return freeRedisRunLoop(redisRunLoop);\n\n redisRunLoop->sourceRef = CFSocketCreateRunLoopSource(NULL, redisRunLoop->socketRef, 0);\n if( !redisRunLoop->sourceRef ) return freeRedisRunLoop(redisRunLoop);\n\n CFRunLoopAddSource(runLoop, redisRunLoop->sourceRef, kCFRunLoopDefaultMode);\n\n return REDIS_OK;\n}\n\n#endif\n\n" }, { "path": "deps/hiredis/adapters/poll.h", "content": "\n#ifndef HIREDIS_POLL_H\n#define HIREDIS_POLL_H\n\n#include \"../async.h\"\n#include \"../sockcompat.h\"\n#include // for memset\n#include \n\n/* Values to return from redisPollTick */\n#define REDIS_POLL_HANDLED_READ 1\n#define REDIS_POLL_HANDLED_WRITE 2\n#define REDIS_POLL_HANDLED_TIMEOUT 4\n\n/* An adapter to allow manual polling of the async context by checking the state\n * of the underlying file descriptor. Useful in cases where there is no formal\n * IO event loop but regular ticking can be used, such as in game engines. */\n\ntypedef struct redisPollEvents {\n redisAsyncContext *context;\n redisFD fd;\n char reading, writing;\n char in_tick;\n char deleted;\n double deadline;\n} redisPollEvents;\n\nstatic double redisPollTimevalToDouble(struct timeval *tv) {\n if (tv == NULL)\n return 0.0;\n return tv->tv_sec + tv->tv_usec / 1000000.00;\n}\n\nstatic double redisPollGetNow(void) {\n#ifndef _MSC_VER\n struct timeval tv;\n gettimeofday(&tv,NULL);\n return redisPollTimevalToDouble(&tv);\n#else\n FILETIME ft;\n ULARGE_INTEGER li;\n GetSystemTimeAsFileTime(&ft);\n li.HighPart = ft.dwHighDateTime;\n li.LowPart = ft.dwLowDateTime;\n return (double)li.QuadPart * 1e-7;\n#endif\n}\n\n/* Poll for io, handling any pending callbacks. The timeout argument can be\n * positive to wait for a maximum given time for IO, zero to poll, or negative\n * to wait forever */\nstatic int redisPollTick(redisAsyncContext *ac, double timeout) {\n int reading, writing;\n struct pollfd pfd;\n int handled;\n int ns;\n int itimeout;\n\n redisPollEvents *e = (redisPollEvents*)ac->ev.data;\n if (!e)\n return 0;\n\n /* local flags, won't get changed during callbacks */\n reading = e->reading;\n writing = e->writing;\n if (!reading && !writing)\n return 0;\n\n pfd.fd = e->fd;\n pfd.events = 0;\n if (reading)\n pfd.events = POLLIN; \n if (writing)\n pfd.events |= POLLOUT;\n\n if (timeout >= 0.0) {\n itimeout = (int)(timeout * 1000.0);\n } else {\n itimeout = -1;\n }\n\n ns = poll(&pfd, 1, itimeout);\n if (ns < 0) {\n /* ignore the EINTR error */\n if (errno != EINTR)\n return ns;\n ns = 0;\n }\n \n handled = 0;\n e->in_tick = 1;\n if (ns) {\n if (reading && (pfd.revents & POLLIN)) {\n redisAsyncHandleRead(ac);\n handled |= REDIS_POLL_HANDLED_READ;\n }\n /* on Windows, connection failure is indicated with the Exception fdset.\n * handle it the same as writable. */\n if (writing && (pfd.revents & (POLLOUT | POLLERR))) {\n /* context Read callback may have caused context to be deleted, e.g.\n by doing an redisAsyncDisconnect() */\n if (!e->deleted) {\n redisAsyncHandleWrite(ac);\n handled |= REDIS_POLL_HANDLED_WRITE;\n }\n }\n }\n\n /* perform timeouts */\n if (!e->deleted && e->deadline != 0.0) {\n double now = redisPollGetNow();\n if (now >= e->deadline) {\n /* deadline has passed. disable timeout and perform callback */\n e->deadline = 0.0;\n redisAsyncHandleTimeout(ac);\n handled |= REDIS_POLL_HANDLED_TIMEOUT;\n }\n }\n\n /* do a delayed cleanup if required */\n if (e->deleted)\n hi_free(e);\n else\n e->in_tick = 0;\n\n return handled;\n}\n\nstatic void redisPollAddRead(void *data) {\n redisPollEvents *e = (redisPollEvents*)data;\n e->reading = 1;\n}\n\nstatic void redisPollDelRead(void *data) {\n redisPollEvents *e = (redisPollEvents*)data;\n e->reading = 0;\n}\n\nstatic void redisPollAddWrite(void *data) {\n redisPollEvents *e = (redisPollEvents*)data;\n e->writing = 1;\n}\n\nstatic void redisPollDelWrite(void *data) {\n redisPollEvents *e = (redisPollEvents*)data;\n e->writing = 0;\n}\n\nstatic void redisPollCleanup(void *data) {\n redisPollEvents *e = (redisPollEvents*)data;\n\n /* if we are currently processing a tick, postpone deletion */\n if (e->in_tick)\n e->deleted = 1;\n else\n hi_free(e);\n}\n\nstatic void redisPollScheduleTimer(void *data, struct timeval tv)\n{\n redisPollEvents *e = (redisPollEvents*)data;\n double now = redisPollGetNow();\n e->deadline = now + redisPollTimevalToDouble(&tv);\n}\n\nstatic int redisPollAttach(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisPollEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisPollEvents*)hi_malloc(sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n memset(e, 0, sizeof(*e));\n\n e->context = ac;\n e->fd = c->fd;\n e->reading = e->writing = 0;\n e->in_tick = e->deleted = 0;\n e->deadline = 0.0;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisPollAddRead;\n ac->ev.delRead = redisPollDelRead;\n ac->ev.addWrite = redisPollAddWrite;\n ac->ev.delWrite = redisPollDelWrite;\n ac->ev.scheduleTimer = redisPollScheduleTimer;\n ac->ev.cleanup = redisPollCleanup;\n ac->ev.data = e;\n\n return REDIS_OK;\n}\n#endif /* HIREDIS_POLL_H */\n" }, { "path": "deps/hiredis/adapters/qt.h", "content": "/*-\n * Copyright (C) 2014 Pietro Cerutti \n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n * SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_QT_H__\n#define __HIREDIS_QT_H__\n#include \n#include \"../async.h\"\n\nstatic void RedisQtAddRead(void *);\nstatic void RedisQtDelRead(void *);\nstatic void RedisQtAddWrite(void *);\nstatic void RedisQtDelWrite(void *);\nstatic void RedisQtCleanup(void *);\n\nclass RedisQtAdapter : public QObject {\n\n Q_OBJECT\n\n friend\n void RedisQtAddRead(void * adapter) {\n RedisQtAdapter * a = static_cast(adapter);\n a->addRead();\n }\n\n friend\n void RedisQtDelRead(void * adapter) {\n RedisQtAdapter * a = static_cast(adapter);\n a->delRead();\n }\n\n friend\n void RedisQtAddWrite(void * adapter) {\n RedisQtAdapter * a = static_cast(adapter);\n a->addWrite();\n }\n\n friend\n void RedisQtDelWrite(void * adapter) {\n RedisQtAdapter * a = static_cast(adapter);\n a->delWrite();\n }\n\n friend\n void RedisQtCleanup(void * adapter) {\n RedisQtAdapter * a = static_cast(adapter);\n a->cleanup();\n }\n\n public:\n RedisQtAdapter(QObject * parent = 0)\n : QObject(parent), m_ctx(0), m_read(0), m_write(0) { }\n\n ~RedisQtAdapter() {\n if (m_ctx != 0) {\n m_ctx->ev.data = NULL;\n }\n }\n\n int setContext(redisAsyncContext * ac) {\n if (ac->ev.data != NULL) {\n return REDIS_ERR;\n }\n m_ctx = ac;\n m_ctx->ev.data = this;\n m_ctx->ev.addRead = RedisQtAddRead;\n m_ctx->ev.delRead = RedisQtDelRead;\n m_ctx->ev.addWrite = RedisQtAddWrite;\n m_ctx->ev.delWrite = RedisQtDelWrite;\n m_ctx->ev.cleanup = RedisQtCleanup;\n return REDIS_OK;\n }\n\n private:\n void addRead() {\n if (m_read) return;\n m_read = new QSocketNotifier(m_ctx->c.fd, QSocketNotifier::Read, 0);\n connect(m_read, SIGNAL(activated(int)), this, SLOT(read()));\n }\n\n void delRead() {\n if (!m_read) return;\n delete m_read;\n m_read = 0;\n }\n\n void addWrite() {\n if (m_write) return;\n m_write = new QSocketNotifier(m_ctx->c.fd, QSocketNotifier::Write, 0);\n connect(m_write, SIGNAL(activated(int)), this, SLOT(write()));\n }\n\n void delWrite() {\n if (!m_write) return;\n delete m_write;\n m_write = 0;\n }\n\n void cleanup() {\n delRead();\n delWrite();\n }\n\n private slots:\n void read() { redisAsyncHandleRead(m_ctx); }\n void write() { redisAsyncHandleWrite(m_ctx); }\n\n private:\n redisAsyncContext * m_ctx;\n QSocketNotifier * m_read;\n QSocketNotifier * m_write;\n};\n\n#endif /* !__HIREDIS_QT_H__ */\n" }, { "path": "deps/hiredis/adapters/redismoduleapi.h", "content": "#ifndef __HIREDIS_REDISMODULEAPI_H__\n#define __HIREDIS_REDISMODULEAPI_H__\n\n#include \"redismodule.h\"\n\n#include \"../async.h\"\n#include \"../hiredis.h\"\n\n#include \n\ntypedef struct redisModuleEvents {\n redisAsyncContext *context;\n RedisModuleCtx *module_ctx;\n int fd;\n int reading, writing;\n int timer_active;\n RedisModuleTimerID timer_id;\n} redisModuleEvents;\n\nstatic inline void redisModuleReadEvent(int fd, void *privdata, int mask) {\n (void) fd;\n (void) mask;\n\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n redisAsyncHandleRead(e->context);\n}\n\nstatic inline void redisModuleWriteEvent(int fd, void *privdata, int mask) {\n (void) fd;\n (void) mask;\n\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n redisAsyncHandleWrite(e->context);\n}\n\nstatic inline void redisModuleAddRead(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n if (!e->reading) {\n e->reading = 1;\n RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_READABLE, redisModuleReadEvent, e);\n }\n}\n\nstatic inline void redisModuleDelRead(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n if (e->reading) {\n e->reading = 0;\n RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_READABLE);\n }\n}\n\nstatic inline void redisModuleAddWrite(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n if (!e->writing) {\n e->writing = 1;\n RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_WRITABLE, redisModuleWriteEvent, e);\n }\n}\n\nstatic inline void redisModuleDelWrite(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n if (e->writing) {\n e->writing = 0;\n RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_WRITABLE);\n }\n}\n\nstatic inline void redisModuleStopTimer(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n if (e->timer_active) {\n RedisModule_StopTimer(e->module_ctx, e->timer_id, NULL);\n }\n e->timer_active = 0;\n}\n\nstatic inline void redisModuleCleanup(void *privdata) {\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n redisModuleDelRead(privdata);\n redisModuleDelWrite(privdata);\n redisModuleStopTimer(privdata);\n hi_free(e);\n}\n\nstatic inline void redisModuleTimeout(RedisModuleCtx *ctx, void *privdata) {\n (void) ctx;\n\n redisModuleEvents *e = (redisModuleEvents*)privdata;\n e->timer_active = 0;\n redisAsyncHandleTimeout(e->context);\n}\n\nstatic inline void redisModuleSetTimeout(void *privdata, struct timeval tv) {\n redisModuleEvents* e = (redisModuleEvents*)privdata;\n\n redisModuleStopTimer(privdata);\n\n mstime_t millis = tv.tv_sec * 1000 + tv.tv_usec / 1000.0;\n e->timer_id = RedisModule_CreateTimer(e->module_ctx, millis, redisModuleTimeout, e);\n e->timer_active = 1;\n}\n\n/* Check if Redis version is compatible with the adapter. */\nstatic inline int redisModuleCompatibilityCheck(void) {\n if (!RedisModule_EventLoopAdd ||\n !RedisModule_EventLoopDel ||\n !RedisModule_CreateTimer ||\n !RedisModule_StopTimer) {\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\nstatic inline int redisModuleAttach(redisAsyncContext *ac, RedisModuleCtx *module_ctx) {\n redisContext *c = &(ac->c);\n redisModuleEvents *e;\n\n /* Nothing should be attached when something is already attached */\n if (ac->ev.data != NULL)\n return REDIS_ERR;\n\n /* Create container for context and r/w events */\n e = (redisModuleEvents*)hi_malloc(sizeof(*e));\n if (e == NULL)\n return REDIS_ERR;\n\n e->context = ac;\n e->module_ctx = module_ctx;\n e->fd = c->fd;\n e->reading = e->writing = 0;\n e->timer_active = 0;\n\n /* Register functions to start/stop listening for events */\n ac->ev.addRead = redisModuleAddRead;\n ac->ev.delRead = redisModuleDelRead;\n ac->ev.addWrite = redisModuleAddWrite;\n ac->ev.delWrite = redisModuleDelWrite;\n ac->ev.cleanup = redisModuleCleanup;\n ac->ev.scheduleTimer = redisModuleSetTimeout;\n ac->ev.data = e;\n\n return REDIS_OK;\n}\n\n#endif\n" }, { "path": "deps/hiredis/alloc.c", "content": "/*\n * Copyright (c) 2020, Michael Grunder \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \"alloc.h\"\n#include \n#include \n\nhiredisAllocFuncs hiredisAllocFns = {\n .mallocFn = malloc,\n .callocFn = calloc,\n .reallocFn = realloc,\n .strdupFn = strdup,\n .freeFn = free,\n};\n\n/* Override hiredis' allocators with ones supplied by the user */\nhiredisAllocFuncs hiredisSetAllocators(hiredisAllocFuncs *override) {\n hiredisAllocFuncs orig = hiredisAllocFns;\n\n hiredisAllocFns = *override;\n\n return orig;\n}\n\n/* Reset allocators to use libc defaults */\nvoid hiredisResetAllocators(void) {\n hiredisAllocFns = (hiredisAllocFuncs) {\n .mallocFn = malloc,\n .callocFn = calloc,\n .reallocFn = realloc,\n .strdupFn = strdup,\n .freeFn = free,\n };\n}\n\n#ifdef _WIN32\n\nvoid *hi_malloc(size_t size) {\n return hiredisAllocFns.mallocFn(size);\n}\n\nvoid *hi_calloc(size_t nmemb, size_t size) {\n /* Overflow check as the user can specify any arbitrary allocator */\n if (SIZE_MAX / size < nmemb)\n return NULL;\n\n return hiredisAllocFns.callocFn(nmemb, size);\n}\n\nvoid *hi_realloc(void *ptr, size_t size) {\n return hiredisAllocFns.reallocFn(ptr, size);\n}\n\nchar *hi_strdup(const char *str) {\n return hiredisAllocFns.strdupFn(str);\n}\n\nvoid hi_free(void *ptr) {\n hiredisAllocFns.freeFn(ptr);\n}\n\n#endif\n" }, { "path": "deps/hiredis/alloc.h", "content": "/*\n * Copyright (c) 2020, Michael Grunder \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef HIREDIS_ALLOC_H\n#define HIREDIS_ALLOC_H\n\n#include /* for size_t */\n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* Structure pointing to our actually configured allocators */\ntypedef struct hiredisAllocFuncs {\n void *(*mallocFn)(size_t);\n void *(*callocFn)(size_t,size_t);\n void *(*reallocFn)(void*,size_t);\n char *(*strdupFn)(const char*);\n void (*freeFn)(void*);\n} hiredisAllocFuncs;\n\nhiredisAllocFuncs hiredisSetAllocators(hiredisAllocFuncs *ha);\nvoid hiredisResetAllocators(void);\n\n#ifndef _WIN32\n\n/* Hiredis' configured allocator function pointer struct */\nextern hiredisAllocFuncs hiredisAllocFns;\n\nstatic inline void *hi_malloc(size_t size) {\n return hiredisAllocFns.mallocFn(size);\n}\n\nstatic inline void *hi_calloc(size_t nmemb, size_t size) {\n /* Overflow check as the user can specify any arbitrary allocator */\n if (SIZE_MAX / size < nmemb)\n return NULL;\n\n return hiredisAllocFns.callocFn(nmemb, size);\n}\n\nstatic inline void *hi_realloc(void *ptr, size_t size) {\n return hiredisAllocFns.reallocFn(ptr, size);\n}\n\nstatic inline char *hi_strdup(const char *str) {\n return hiredisAllocFns.strdupFn(str);\n}\n\nstatic inline void hi_free(void *ptr) {\n hiredisAllocFns.freeFn(ptr);\n}\n\n#else\n\nvoid *hi_malloc(size_t size);\nvoid *hi_calloc(size_t nmemb, size_t size);\nvoid *hi_realloc(void *ptr, size_t size);\nchar *hi_strdup(const char *str);\nvoid hi_free(void *ptr);\n\n#endif\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* HIREDIS_ALLOC_H */\n" }, { "path": "deps/hiredis/appveyor.yml", "content": "# Appveyor configuration file for CI build of hiredis on Windows (under Cygwin)\nenvironment:\n matrix:\n - CYG_BASH: C:\\cygwin64\\bin\\bash\n CC: gcc\n - CYG_BASH: C:\\cygwin\\bin\\bash\n CC: gcc\n CFLAGS: -m32\n CXXFLAGS: -m32\n LDFLAGS: -m32\n\nclone_depth: 1\n\n# Attempt to ensure we don't try to convert line endings to Win32 CRLF as this will cause build to fail\ninit:\n - git config --global core.autocrlf input\n\n# Install needed build dependencies\ninstall:\n - '%CYG_BASH% -lc \"cygcheck -dc cygwin\"'\n\nbuild_script:\n - 'echo building...'\n - '%CYG_BASH% -lc \"cd $APPVEYOR_BUILD_FOLDER; exec 0\n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \"alloc.h\"\n#include \n#include \n#ifndef _MSC_VER\n#include \n#endif\n#include \n#include \n#include \n#include \"async.h\"\n#include \"net.h\"\n#include \"dict.c\"\n#include \"sds.h\"\n#include \"win32.h\"\n\n#include \"async_private.h\"\n\n#ifdef NDEBUG\n#undef assert\n#define assert(e) (void)(e)\n#endif\n\n/* Forward declarations of hiredis.c functions */\nint __redisAppendCommand(redisContext *c, const char *cmd, size_t len);\nvoid __redisSetError(redisContext *c, int type, const char *str);\n\n/* Functions managing dictionary of callbacks for pub/sub. */\nstatic unsigned int callbackHash(const void *key) {\n return dictGenHashFunction((const unsigned char *)key,\n hi_sdslen((const hisds)key));\n}\n\nstatic void *callbackValDup(void *privdata, const void *src) {\n ((void) privdata);\n redisCallback *dup;\n\n dup = hi_malloc(sizeof(*dup));\n if (dup == NULL)\n return NULL;\n\n memcpy(dup,src,sizeof(*dup));\n return dup;\n}\n\nstatic int callbackKeyCompare(void *privdata, const void *key1, const void *key2) {\n int l1, l2;\n ((void) privdata);\n\n l1 = hi_sdslen((const hisds)key1);\n l2 = hi_sdslen((const hisds)key2);\n if (l1 != l2) return 0;\n return memcmp(key1,key2,l1) == 0;\n}\n\nstatic void callbackKeyDestructor(void *privdata, void *key) {\n ((void) privdata);\n hi_sdsfree((hisds)key);\n}\n\nstatic void callbackValDestructor(void *privdata, void *val) {\n ((void) privdata);\n hi_free(val);\n}\n\nstatic dictType callbackDict = {\n callbackHash,\n NULL,\n callbackValDup,\n callbackKeyCompare,\n callbackKeyDestructor,\n callbackValDestructor\n};\n\nstatic redisAsyncContext *redisAsyncInitialize(redisContext *c) {\n redisAsyncContext *ac;\n dict *channels = NULL, *patterns = NULL;\n\n channels = dictCreate(&callbackDict,NULL);\n if (channels == NULL)\n goto oom;\n\n patterns = dictCreate(&callbackDict,NULL);\n if (patterns == NULL)\n goto oom;\n\n ac = hi_realloc(c,sizeof(redisAsyncContext));\n if (ac == NULL)\n goto oom;\n\n c = &(ac->c);\n\n /* The regular connect functions will always set the flag REDIS_CONNECTED.\n * For the async API, we want to wait until the first write event is\n * received up before setting this flag, so reset it here. */\n c->flags &= ~REDIS_CONNECTED;\n\n ac->err = 0;\n ac->errstr = NULL;\n ac->data = NULL;\n ac->dataCleanup = NULL;\n\n ac->ev.data = NULL;\n ac->ev.addRead = NULL;\n ac->ev.delRead = NULL;\n ac->ev.addWrite = NULL;\n ac->ev.delWrite = NULL;\n ac->ev.cleanup = NULL;\n ac->ev.scheduleTimer = NULL;\n\n ac->onConnect = NULL;\n ac->onConnectNC = NULL;\n ac->onDisconnect = NULL;\n\n ac->replies.head = NULL;\n ac->replies.tail = NULL;\n ac->sub.replies.head = NULL;\n ac->sub.replies.tail = NULL;\n ac->sub.channels = channels;\n ac->sub.patterns = patterns;\n ac->sub.pending_unsubs = 0;\n\n return ac;\noom:\n if (channels) dictRelease(channels);\n if (patterns) dictRelease(patterns);\n return NULL;\n}\n\n/* We want the error field to be accessible directly instead of requiring\n * an indirection to the redisContext struct. */\nstatic void __redisAsyncCopyError(redisAsyncContext *ac) {\n if (!ac)\n return;\n\n redisContext *c = &(ac->c);\n ac->err = c->err;\n ac->errstr = c->errstr;\n}\n\nredisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *options) {\n redisOptions myOptions = *options;\n redisContext *c;\n redisAsyncContext *ac;\n\n /* Clear any erroneously set sync callback and flag that we don't want to\n * use freeReplyObject by default. */\n myOptions.push_cb = NULL;\n myOptions.options |= REDIS_OPT_NO_PUSH_AUTOFREE;\n\n myOptions.options |= REDIS_OPT_NONBLOCK;\n c = redisConnectWithOptions(&myOptions);\n if (c == NULL) {\n return NULL;\n }\n\n ac = redisAsyncInitialize(c);\n if (ac == NULL) {\n redisFree(c);\n return NULL;\n }\n\n /* Set any configured async push handler */\n redisAsyncSetPushCallback(ac, myOptions.async_push_cb);\n\n __redisAsyncCopyError(ac);\n return ac;\n}\n\nredisAsyncContext *redisAsyncConnect(const char *ip, int port) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n return redisAsyncConnectWithOptions(&options);\n}\n\nredisAsyncContext *redisAsyncConnectBind(const char *ip, int port,\n const char *source_addr) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.endpoint.tcp.source_addr = source_addr;\n return redisAsyncConnectWithOptions(&options);\n}\n\nredisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,\n const char *source_addr) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.options |= REDIS_OPT_REUSEADDR;\n options.endpoint.tcp.source_addr = source_addr;\n return redisAsyncConnectWithOptions(&options);\n}\n\nredisAsyncContext *redisAsyncConnectUnix(const char *path) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_UNIX(&options, path);\n return redisAsyncConnectWithOptions(&options);\n}\n\nstatic int\nredisAsyncSetConnectCallbackImpl(redisAsyncContext *ac, redisConnectCallback *fn,\n redisConnectCallbackNC *fn_nc)\n{\n /* If either are already set, this is an error */\n if (ac->onConnect || ac->onConnectNC)\n return REDIS_ERR;\n\n if (fn) {\n ac->onConnect = fn;\n } else if (fn_nc) {\n ac->onConnectNC = fn_nc;\n }\n\n /* The common way to detect an established connection is to wait for\n * the first write event to be fired. This assumes the related event\n * library functions are already set. */\n _EL_ADD_WRITE(ac);\n\n return REDIS_OK;\n}\n\nint redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn) {\n return redisAsyncSetConnectCallbackImpl(ac, fn, NULL);\n}\n\nint redisAsyncSetConnectCallbackNC(redisAsyncContext *ac, redisConnectCallbackNC *fn) {\n return redisAsyncSetConnectCallbackImpl(ac, NULL, fn);\n}\n\nint redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn) {\n if (ac->onDisconnect == NULL) {\n ac->onDisconnect = fn;\n return REDIS_OK;\n }\n return REDIS_ERR;\n}\n\n/* Helper functions to push/shift callbacks */\nstatic int __redisPushCallback(redisCallbackList *list, redisCallback *source) {\n redisCallback *cb;\n\n /* Copy callback from stack to heap */\n cb = hi_malloc(sizeof(*cb));\n if (cb == NULL)\n return REDIS_ERR_OOM;\n\n if (source != NULL) {\n memcpy(cb,source,sizeof(*cb));\n cb->next = NULL;\n }\n\n /* Store callback in list */\n if (list->head == NULL)\n list->head = cb;\n if (list->tail != NULL)\n list->tail->next = cb;\n list->tail = cb;\n return REDIS_OK;\n}\n\nstatic int __redisShiftCallback(redisCallbackList *list, redisCallback *target) {\n redisCallback *cb = list->head;\n if (cb != NULL) {\n list->head = cb->next;\n if (cb == list->tail)\n list->tail = NULL;\n\n /* Copy callback from heap to stack */\n if (target != NULL)\n memcpy(target,cb,sizeof(*cb));\n hi_free(cb);\n return REDIS_OK;\n }\n return REDIS_ERR;\n}\n\nstatic void __redisRunCallback(redisAsyncContext *ac, redisCallback *cb, redisReply *reply) {\n redisContext *c = &(ac->c);\n if (cb->fn != NULL) {\n c->flags |= REDIS_IN_CALLBACK;\n cb->fn(ac,reply,cb->privdata);\n c->flags &= ~REDIS_IN_CALLBACK;\n }\n}\n\nstatic void __redisRunPushCallback(redisAsyncContext *ac, redisReply *reply) {\n if (ac->push_cb != NULL) {\n ac->c.flags |= REDIS_IN_CALLBACK;\n ac->push_cb(ac, reply);\n ac->c.flags &= ~REDIS_IN_CALLBACK;\n }\n}\n\nstatic void __redisRunConnectCallback(redisAsyncContext *ac, int status)\n{\n if (ac->onConnect == NULL && ac->onConnectNC == NULL)\n return;\n\n if (!(ac->c.flags & REDIS_IN_CALLBACK)) {\n ac->c.flags |= REDIS_IN_CALLBACK;\n if (ac->onConnect) {\n ac->onConnect(ac, status);\n } else {\n ac->onConnectNC(ac, status);\n }\n ac->c.flags &= ~REDIS_IN_CALLBACK;\n } else {\n /* already in callback */\n if (ac->onConnect) {\n ac->onConnect(ac, status);\n } else {\n ac->onConnectNC(ac, status);\n }\n }\n}\n\nstatic void __redisRunDisconnectCallback(redisAsyncContext *ac, int status)\n{\n if (ac->onDisconnect) {\n if (!(ac->c.flags & REDIS_IN_CALLBACK)) {\n ac->c.flags |= REDIS_IN_CALLBACK;\n ac->onDisconnect(ac, status);\n ac->c.flags &= ~REDIS_IN_CALLBACK;\n } else {\n /* already in callback */\n ac->onDisconnect(ac, status);\n }\n }\n}\n\n/* Helper function to free the context. */\nstatic void __redisAsyncFree(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisCallback cb;\n dictIterator it;\n dictEntry *de;\n\n /* Execute pending callbacks with NULL reply. */\n while (__redisShiftCallback(&ac->replies,&cb) == REDIS_OK)\n __redisRunCallback(ac,&cb,NULL);\n while (__redisShiftCallback(&ac->sub.replies,&cb) == REDIS_OK)\n __redisRunCallback(ac,&cb,NULL);\n\n /* Run subscription callbacks with NULL reply */\n if (ac->sub.channels) {\n dictInitIterator(&it,ac->sub.channels);\n while ((de = dictNext(&it)) != NULL)\n __redisRunCallback(ac,dictGetEntryVal(de),NULL);\n\n dictRelease(ac->sub.channels);\n }\n\n if (ac->sub.patterns) {\n dictInitIterator(&it,ac->sub.patterns);\n while ((de = dictNext(&it)) != NULL)\n __redisRunCallback(ac,dictGetEntryVal(de),NULL);\n\n dictRelease(ac->sub.patterns);\n }\n\n /* Signal event lib to clean up */\n _EL_CLEANUP(ac);\n\n /* Execute disconnect callback. When redisAsyncFree() initiated destroying\n * this context, the status will always be REDIS_OK. */\n if (c->flags & REDIS_CONNECTED) {\n int status = ac->err == 0 ? REDIS_OK : REDIS_ERR;\n if (c->flags & REDIS_FREEING)\n status = REDIS_OK;\n __redisRunDisconnectCallback(ac, status);\n }\n\n if (ac->dataCleanup) {\n ac->dataCleanup(ac->data);\n }\n\n /* Cleanup self */\n redisFree(c);\n}\n\n/* Free the async context. When this function is called from a callback,\n * control needs to be returned to redisProcessCallbacks() before actual\n * free'ing. To do so, a flag is set on the context which is picked up by\n * redisProcessCallbacks(). Otherwise, the context is immediately free'd. */\nvoid redisAsyncFree(redisAsyncContext *ac) {\n if (ac == NULL)\n return;\n\n redisContext *c = &(ac->c);\n\n c->flags |= REDIS_FREEING;\n if (!(c->flags & REDIS_IN_CALLBACK))\n __redisAsyncFree(ac);\n}\n\n/* Helper function to make the disconnect happen and clean up. */\nvoid __redisAsyncDisconnect(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n\n /* Make sure error is accessible if there is any */\n __redisAsyncCopyError(ac);\n\n if (ac->err == 0) {\n /* For clean disconnects, there should be no pending callbacks. */\n int ret = __redisShiftCallback(&ac->replies,NULL);\n assert(ret == REDIS_ERR);\n } else {\n /* Disconnection is caused by an error, make sure that pending\n * callbacks cannot call new commands. */\n c->flags |= REDIS_DISCONNECTING;\n }\n\n /* cleanup event library on disconnect.\n * this is safe to call multiple times */\n _EL_CLEANUP(ac);\n\n /* For non-clean disconnects, __redisAsyncFree() will execute pending\n * callbacks with a NULL-reply. */\n if (!(c->flags & REDIS_NO_AUTO_FREE)) {\n __redisAsyncFree(ac);\n }\n}\n\n/* Tries to do a clean disconnect from Redis, meaning it stops new commands\n * from being issued, but tries to flush the output buffer and execute\n * callbacks for all remaining replies. When this function is called from a\n * callback, there might be more replies and we can safely defer disconnecting\n * to redisProcessCallbacks(). Otherwise, we can only disconnect immediately\n * when there are no pending callbacks. */\nvoid redisAsyncDisconnect(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n c->flags |= REDIS_DISCONNECTING;\n\n /** unset the auto-free flag here, because disconnect undoes this */\n c->flags &= ~REDIS_NO_AUTO_FREE;\n if (!(c->flags & REDIS_IN_CALLBACK) && ac->replies.head == NULL)\n __redisAsyncDisconnect(ac);\n}\n\nstatic int __redisGetSubscribeCallback(redisAsyncContext *ac, redisReply *reply, redisCallback *dstcb) {\n redisContext *c = &(ac->c);\n dict *callbacks;\n redisCallback *cb = NULL;\n dictEntry *de;\n int pvariant;\n char *stype;\n hisds sname = NULL;\n\n /* Match reply with the expected format of a pushed message.\n * The type and number of elements (3 to 4) are specified at:\n * https://redis.io/docs/latest/develop/interact/pubsub/#format-of-pushed-messages */\n if ((reply->type == REDIS_REPLY_ARRAY && !(c->flags & REDIS_SUPPORTS_PUSH) && reply->elements >= 3) ||\n reply->type == REDIS_REPLY_PUSH) {\n assert(reply->element[0]->type == REDIS_REPLY_STRING);\n stype = reply->element[0]->str;\n pvariant = (tolower(stype[0]) == 'p') ? 1 : 0;\n\n if (pvariant)\n callbacks = ac->sub.patterns;\n else\n callbacks = ac->sub.channels;\n\n /* Locate the right callback */\n if (reply->element[1]->type == REDIS_REPLY_STRING) {\n sname = hi_sdsnewlen(reply->element[1]->str,reply->element[1]->len);\n if (sname == NULL) goto oom;\n\n if ((de = dictFind(callbacks,sname)) != NULL) {\n cb = dictGetEntryVal(de);\n memcpy(dstcb,cb,sizeof(*dstcb));\n }\n }\n\n /* If this is an subscribe reply decrease pending counter. */\n if (strcasecmp(stype+pvariant,\"subscribe\") == 0) {\n assert(cb != NULL);\n cb->pending_subs -= 1;\n\n } else if (strcasecmp(stype+pvariant,\"unsubscribe\") == 0) {\n if (cb == NULL)\n ac->sub.pending_unsubs -= 1;\n else if (cb->pending_subs == 0)\n dictDelete(callbacks,sname);\n\n /* If this was the last unsubscribe message, revert to\n * non-subscribe mode. */\n assert(reply->element[2]->type == REDIS_REPLY_INTEGER);\n\n /* Unset subscribed flag only when no pipelined pending subscribe\n * or pending unsubscribe replies. */\n if (reply->element[2]->integer == 0\n && dictSize(ac->sub.channels) == 0\n && dictSize(ac->sub.patterns) == 0\n && ac->sub.pending_unsubs == 0) {\n c->flags &= ~REDIS_SUBSCRIBED;\n\n /* Move ongoing regular command callbacks. */\n redisCallback cb;\n while (__redisShiftCallback(&ac->sub.replies,&cb) == REDIS_OK) {\n __redisPushCallback(&ac->replies,&cb);\n }\n }\n }\n hi_sdsfree(sname);\n } else {\n /* Shift callback for pending command in subscribed context. */\n __redisShiftCallback(&ac->sub.replies,dstcb);\n }\n return REDIS_OK;\noom:\n __redisSetError(&(ac->c), REDIS_ERR_OOM, \"Out of memory\");\n __redisAsyncCopyError(ac);\n return REDIS_ERR;\n}\n\n#define redisIsSpontaneousPushReply(r) \\\n (redisIsPushReply(r) && !redisIsSubscribeReply(r))\n\nstatic int redisIsSubscribeReply(redisReply *reply) {\n char *str;\n size_t len, off;\n\n /* We will always have at least one string with the subscribe/message type */\n if (reply->elements < 1 || reply->element[0]->type != REDIS_REPLY_STRING ||\n reply->element[0]->len < sizeof(\"message\") - 1)\n {\n return 0;\n }\n\n /* Get the string/len moving past 'p' if needed */\n off = tolower(reply->element[0]->str[0]) == 'p';\n str = reply->element[0]->str + off;\n len = reply->element[0]->len - off;\n\n return !strncasecmp(str, \"subscribe\", len) ||\n !strncasecmp(str, \"message\", len) ||\n !strncasecmp(str, \"unsubscribe\", len);\n}\n\nvoid redisProcessCallbacks(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n void *reply = NULL;\n int status;\n\n while((status = redisGetReply(c,&reply)) == REDIS_OK) {\n if (reply == NULL) {\n /* When the connection is being disconnected and there are\n * no more replies, this is the cue to really disconnect. */\n if (c->flags & REDIS_DISCONNECTING && hi_sdslen(c->obuf) == 0\n && ac->replies.head == NULL) {\n __redisAsyncDisconnect(ac);\n return;\n }\n /* When the connection is not being disconnected, simply stop\n * trying to get replies and wait for the next loop tick. */\n break;\n }\n\n /* Keep track of push message support for subscribe handling */\n if (redisIsPushReply(reply)) c->flags |= REDIS_SUPPORTS_PUSH;\n\n /* Send any non-subscribe related PUSH messages to our PUSH handler\n * while allowing subscribe related PUSH messages to pass through.\n * This allows existing code to be backward compatible and work in\n * either RESP2 or RESP3 mode. */\n if (redisIsSpontaneousPushReply(reply)) {\n __redisRunPushCallback(ac, reply);\n c->reader->fn->freeObject(reply);\n continue;\n }\n\n /* Even if the context is subscribed, pending regular\n * callbacks will get a reply before pub/sub messages arrive. */\n redisCallback cb = {NULL, NULL, 0, 0, NULL};\n if (__redisShiftCallback(&ac->replies,&cb) != REDIS_OK) {\n /*\n * A spontaneous reply in a not-subscribed context can be the error\n * reply that is sent when a new connection exceeds the maximum\n * number of allowed connections on the server side.\n *\n * This is seen as an error instead of a regular reply because the\n * server closes the connection after sending it.\n *\n * To prevent the error from being overwritten by an EOF error the\n * connection is closed here. See issue #43.\n *\n * Another possibility is that the server is loading its dataset.\n * In this case we also want to close the connection, and have the\n * user wait until the server is ready to take our request.\n */\n if (((redisReply*)reply)->type == REDIS_REPLY_ERROR) {\n c->err = REDIS_ERR_OTHER;\n snprintf(c->errstr,sizeof(c->errstr),\"%s\",((redisReply*)reply)->str);\n c->reader->fn->freeObject(reply);\n __redisAsyncDisconnect(ac);\n return;\n }\n /* No more regular callbacks and no errors, the context *must* be subscribed. */\n assert(c->flags & REDIS_SUBSCRIBED);\n if (c->flags & REDIS_SUBSCRIBED)\n __redisGetSubscribeCallback(ac,reply,&cb);\n }\n\n if (cb.fn != NULL) {\n __redisRunCallback(ac,&cb,reply);\n if (!(c->flags & REDIS_NO_AUTO_FREE_REPLIES)){\n c->reader->fn->freeObject(reply);\n }\n\n /* Proceed with free'ing when redisAsyncFree() was called. */\n if (c->flags & REDIS_FREEING) {\n __redisAsyncFree(ac);\n return;\n }\n } else {\n /* No callback for this reply. This can either be a NULL callback,\n * or there were no callbacks to begin with. Either way, don't\n * abort with an error, but simply ignore it because the client\n * doesn't know what the server will spit out over the wire. */\n c->reader->fn->freeObject(reply);\n }\n\n /* If in monitor mode, repush the callback */\n if (c->flags & REDIS_MONITORING) {\n __redisPushCallback(&ac->replies,&cb);\n }\n }\n\n /* Disconnect when there was an error reading the reply */\n if (status != REDIS_OK)\n __redisAsyncDisconnect(ac);\n}\n\nstatic void __redisAsyncHandleConnectFailure(redisAsyncContext *ac) {\n __redisRunConnectCallback(ac, REDIS_ERR);\n __redisAsyncDisconnect(ac);\n}\n\n/* Internal helper function to detect socket status the first time a read or\n * write event fires. When connecting was not successful, the connect callback\n * is called with a REDIS_ERR status and the context is free'd. */\nstatic int __redisAsyncHandleConnect(redisAsyncContext *ac) {\n int completed = 0;\n redisContext *c = &(ac->c);\n\n if (redisCheckConnectDone(c, &completed) == REDIS_ERR) {\n /* Error! */\n if (redisCheckSocketError(c) == REDIS_ERR)\n __redisAsyncCopyError(ac);\n __redisAsyncHandleConnectFailure(ac);\n return REDIS_ERR;\n } else if (completed == 1) {\n /* connected! */\n if (c->connection_type == REDIS_CONN_TCP &&\n redisSetTcpNoDelay(c) == REDIS_ERR) {\n __redisAsyncHandleConnectFailure(ac);\n return REDIS_ERR;\n }\n\n /* flag us as fully connect, but allow the callback\n * to disconnect. For that reason, permit the function\n * to delete the context here after callback return.\n */\n c->flags |= REDIS_CONNECTED;\n __redisRunConnectCallback(ac, REDIS_OK);\n if ((ac->c.flags & REDIS_DISCONNECTING)) {\n redisAsyncDisconnect(ac);\n return REDIS_ERR;\n } else if ((ac->c.flags & REDIS_FREEING)) {\n redisAsyncFree(ac);\n return REDIS_ERR;\n }\n return REDIS_OK;\n } else {\n return REDIS_OK;\n }\n}\n\nvoid redisAsyncRead(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n\n if (redisBufferRead(c) == REDIS_ERR) {\n __redisAsyncDisconnect(ac);\n } else {\n /* Always re-schedule reads */\n _EL_ADD_READ(ac);\n redisProcessCallbacks(ac);\n }\n}\n\n/* This function should be called when the socket is readable.\n * It processes all replies that can be read and executes their callbacks.\n */\nvoid redisAsyncHandleRead(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n /* must not be called from a callback */\n assert(!(c->flags & REDIS_IN_CALLBACK));\n\n if (!(c->flags & REDIS_CONNECTED)) {\n /* Abort connect was not successful. */\n if (__redisAsyncHandleConnect(ac) != REDIS_OK)\n return;\n /* Try again later when the context is still not connected. */\n if (!(c->flags & REDIS_CONNECTED))\n return;\n }\n\n c->funcs->async_read(ac);\n}\n\nvoid redisAsyncWrite(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n int done = 0;\n\n if (redisBufferWrite(c,&done) == REDIS_ERR) {\n __redisAsyncDisconnect(ac);\n } else {\n /* Continue writing when not done, stop writing otherwise */\n if (!done)\n _EL_ADD_WRITE(ac);\n else\n _EL_DEL_WRITE(ac);\n\n /* Always schedule reads after writes */\n _EL_ADD_READ(ac);\n }\n}\n\nvoid redisAsyncHandleWrite(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n /* must not be called from a callback */\n assert(!(c->flags & REDIS_IN_CALLBACK));\n\n if (!(c->flags & REDIS_CONNECTED)) {\n /* Abort connect was not successful. */\n if (__redisAsyncHandleConnect(ac) != REDIS_OK)\n return;\n /* Try again later when the context is still not connected. */\n if (!(c->flags & REDIS_CONNECTED))\n return;\n }\n\n c->funcs->async_write(ac);\n}\n\nvoid redisAsyncHandleTimeout(redisAsyncContext *ac) {\n redisContext *c = &(ac->c);\n redisCallback cb;\n /* must not be called from a callback */\n assert(!(c->flags & REDIS_IN_CALLBACK));\n\n if ((c->flags & REDIS_CONNECTED)) {\n if (ac->replies.head == NULL && ac->sub.replies.head == NULL) {\n /* Nothing to do - just an idle timeout */\n return;\n }\n\n if (!ac->c.command_timeout ||\n (!ac->c.command_timeout->tv_sec && !ac->c.command_timeout->tv_usec)) {\n /* A belated connect timeout arriving, ignore */\n return;\n }\n }\n\n if (!c->err) {\n __redisSetError(c, REDIS_ERR_TIMEOUT, \"Timeout\");\n __redisAsyncCopyError(ac);\n }\n\n if (!(c->flags & REDIS_CONNECTED)) {\n __redisRunConnectCallback(ac, REDIS_ERR);\n }\n\n while (__redisShiftCallback(&ac->replies, &cb) == REDIS_OK) {\n __redisRunCallback(ac, &cb, NULL);\n }\n\n /**\n * TODO: Don't automatically sever the connection,\n * rather, allow to ignore responses before the queue is clear\n */\n __redisAsyncDisconnect(ac);\n}\n\n/* Sets a pointer to the first argument and its length starting at p. Returns\n * the number of bytes to skip to get to the following argument. */\nstatic const char *nextArgument(const char *start, const char **str, size_t *len) {\n const char *p = start;\n if (p[0] != '$') {\n p = strchr(p,'$');\n if (p == NULL) return NULL;\n }\n\n *len = (int)strtol(p+1,NULL,10);\n p = strchr(p,'\\r');\n assert(p);\n *str = p+2;\n return p+2+(*len)+2;\n}\n\n/* Helper function for the redisAsyncCommand* family of functions. Writes a\n * formatted command to the output buffer and registers the provided callback\n * function with the context. */\nstatic int __redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *cmd, size_t len) {\n redisContext *c = &(ac->c);\n redisCallback cb;\n struct dict *cbdict;\n dictIterator it;\n dictEntry *de;\n redisCallback *existcb;\n int pvariant, hasnext;\n const char *cstr, *astr;\n size_t clen, alen;\n const char *p;\n hisds sname;\n int ret;\n\n /* Don't accept new commands when the connection is about to be closed. */\n if (c->flags & (REDIS_DISCONNECTING | REDIS_FREEING)) return REDIS_ERR;\n\n /* Setup callback */\n cb.fn = fn;\n cb.privdata = privdata;\n cb.pending_subs = 1;\n cb.unsubscribe_sent = 0;\n\n /* Find out which command will be appended. */\n p = nextArgument(cmd,&cstr,&clen);\n assert(p != NULL);\n hasnext = (p[0] == '$');\n pvariant = (tolower(cstr[0]) == 'p') ? 1 : 0;\n cstr += pvariant;\n clen -= pvariant;\n\n if (hasnext && strncasecmp(cstr,\"subscribe\\r\\n\",11) == 0) {\n c->flags |= REDIS_SUBSCRIBED;\n\n /* Add every channel/pattern to the list of subscription callbacks. */\n while ((p = nextArgument(p,&astr,&alen)) != NULL) {\n sname = hi_sdsnewlen(astr,alen);\n if (sname == NULL)\n goto oom;\n\n if (pvariant)\n cbdict = ac->sub.patterns;\n else\n cbdict = ac->sub.channels;\n\n de = dictFind(cbdict,sname);\n\n if (de != NULL) {\n existcb = dictGetEntryVal(de);\n cb.pending_subs = existcb->pending_subs + 1;\n }\n\n ret = dictReplace(cbdict,sname,&cb);\n\n if (ret == 0) hi_sdsfree(sname);\n }\n } else if (strncasecmp(cstr,\"unsubscribe\\r\\n\",13) == 0) {\n /* It is only useful to call (P)UNSUBSCRIBE when the context is\n * subscribed to one or more channels or patterns. */\n if (!(c->flags & REDIS_SUBSCRIBED)) return REDIS_ERR;\n\n if (pvariant)\n cbdict = ac->sub.patterns;\n else\n cbdict = ac->sub.channels;\n\n if (hasnext) {\n /* Send an unsubscribe with specific channels/patterns.\n * Bookkeeping the number of expected replies */\n while ((p = nextArgument(p,&astr,&alen)) != NULL) {\n sname = hi_sdsnewlen(astr,alen);\n if (sname == NULL)\n goto oom;\n\n de = dictFind(cbdict,sname);\n if (de != NULL) {\n existcb = dictGetEntryVal(de);\n if (existcb->unsubscribe_sent == 0)\n existcb->unsubscribe_sent = 1;\n else\n /* Already sent, reply to be ignored */\n ac->sub.pending_unsubs += 1;\n } else {\n /* Not subscribed to, reply to be ignored */\n ac->sub.pending_unsubs += 1;\n }\n hi_sdsfree(sname);\n }\n } else {\n /* Send an unsubscribe without specific channels/patterns.\n * Bookkeeping the number of expected replies */\n int no_subs = 1;\n dictInitIterator(&it,cbdict);\n while ((de = dictNext(&it)) != NULL) {\n existcb = dictGetEntryVal(de);\n if (existcb->unsubscribe_sent == 0) {\n existcb->unsubscribe_sent = 1;\n no_subs = 0;\n }\n }\n /* Unsubscribing to all channels/patterns, where none is\n * subscribed to, results in a single reply to be ignored. */\n if (no_subs == 1)\n ac->sub.pending_unsubs += 1;\n }\n\n /* (P)UNSUBSCRIBE does not have its own response: every channel or\n * pattern that is unsubscribed will receive a message. This means we\n * should not append a callback function for this command. */\n } else if (strncasecmp(cstr,\"monitor\\r\\n\",9) == 0) {\n /* Set monitor flag and push callback */\n c->flags |= REDIS_MONITORING;\n if (__redisPushCallback(&ac->replies,&cb) != REDIS_OK)\n goto oom;\n } else {\n if (c->flags & REDIS_SUBSCRIBED) {\n if (__redisPushCallback(&ac->sub.replies,&cb) != REDIS_OK)\n goto oom;\n } else {\n if (__redisPushCallback(&ac->replies,&cb) != REDIS_OK)\n goto oom;\n }\n }\n\n __redisAppendCommand(c,cmd,len);\n\n /* Always schedule a write when the write buffer is non-empty */\n _EL_ADD_WRITE(ac);\n\n return REDIS_OK;\noom:\n __redisSetError(&(ac->c), REDIS_ERR_OOM, \"Out of memory\");\n __redisAsyncCopyError(ac);\n return REDIS_ERR;\n}\n\nint redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, va_list ap) {\n char *cmd;\n int len;\n int status;\n len = redisvFormatCommand(&cmd,format,ap);\n\n /* We don't want to pass -1 or -2 to future functions as a length. */\n if (len < 0)\n return REDIS_ERR;\n\n status = __redisAsyncCommand(ac,fn,privdata,cmd,len);\n hi_free(cmd);\n return status;\n}\n\nint redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, ...) {\n va_list ap;\n int status;\n va_start(ap,format);\n status = redisvAsyncCommand(ac,fn,privdata,format,ap);\n va_end(ap);\n return status;\n}\n\nint redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen) {\n hisds cmd;\n long long len;\n int status;\n len = redisFormatSdsCommandArgv(&cmd,argc,argv,argvlen);\n if (len < 0)\n return REDIS_ERR;\n status = __redisAsyncCommand(ac,fn,privdata,cmd,len);\n hi_sdsfree(cmd);\n return status;\n}\n\nint redisAsyncFormattedCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *cmd, size_t len) {\n int status = __redisAsyncCommand(ac,fn,privdata,cmd,len);\n return status;\n}\n\nredisAsyncPushFn *redisAsyncSetPushCallback(redisAsyncContext *ac, redisAsyncPushFn *fn) {\n redisAsyncPushFn *old = ac->push_cb;\n ac->push_cb = fn;\n return old;\n}\n\nint redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv) {\n if (!ac->c.command_timeout) {\n ac->c.command_timeout = hi_calloc(1, sizeof(tv));\n if (ac->c.command_timeout == NULL) {\n __redisSetError(&ac->c, REDIS_ERR_OOM, \"Out of memory\");\n __redisAsyncCopyError(ac);\n return REDIS_ERR;\n }\n }\n\n if (tv.tv_sec != ac->c.command_timeout->tv_sec ||\n tv.tv_usec != ac->c.command_timeout->tv_usec)\n {\n *ac->c.command_timeout = tv;\n }\n\n return REDIS_OK;\n}\n" }, { "path": "deps/hiredis/async.h", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_ASYNC_H\n#define __HIREDIS_ASYNC_H\n#include \"hiredis.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\nstruct redisAsyncContext; /* need forward declaration of redisAsyncContext */\nstruct dict; /* dictionary header is included in async.c */\n\n/* Reply callback prototype and container */\ntypedef void (redisCallbackFn)(struct redisAsyncContext*, void*, void*);\ntypedef struct redisCallback {\n struct redisCallback *next; /* simple singly linked list */\n redisCallbackFn *fn;\n int pending_subs;\n int unsubscribe_sent;\n void *privdata;\n} redisCallback;\n\n/* List of callbacks for either regular replies or pub/sub */\ntypedef struct redisCallbackList {\n redisCallback *head, *tail;\n} redisCallbackList;\n\n/* Connection callback prototypes */\ntypedef void (redisDisconnectCallback)(const struct redisAsyncContext*, int status);\ntypedef void (redisConnectCallback)(const struct redisAsyncContext*, int status);\ntypedef void (redisConnectCallbackNC)(struct redisAsyncContext *, int status);\ntypedef void(redisTimerCallback)(void *timer, void *privdata);\n\n/* Context for an async connection to Redis */\ntypedef struct redisAsyncContext {\n /* Hold the regular context, so it can be realloc'ed. */\n redisContext c;\n\n /* Setup error flags so they can be used directly. */\n int err;\n char *errstr;\n\n /* Not used by hiredis */\n void *data;\n void (*dataCleanup)(void *privdata);\n\n /* Event library data and hooks */\n struct {\n void *data;\n\n /* Hooks that are called when the library expects to start\n * reading/writing. These functions should be idempotent. */\n void (*addRead)(void *privdata);\n void (*delRead)(void *privdata);\n void (*addWrite)(void *privdata);\n void (*delWrite)(void *privdata);\n void (*cleanup)(void *privdata);\n void (*scheduleTimer)(void *privdata, struct timeval tv);\n } ev;\n\n /* Called when either the connection is terminated due to an error or per\n * user request. The status is set accordingly (REDIS_OK, REDIS_ERR). */\n redisDisconnectCallback *onDisconnect;\n\n /* Called when the first write event was received. */\n redisConnectCallback *onConnect;\n redisConnectCallbackNC *onConnectNC;\n\n /* Regular command callbacks */\n redisCallbackList replies;\n\n /* Address used for connect() */\n struct sockaddr *saddr;\n size_t addrlen;\n\n /* Subscription callbacks */\n struct {\n redisCallbackList replies;\n struct dict *channels;\n struct dict *patterns;\n int pending_unsubs;\n } sub;\n\n /* Any configured RESP3 PUSH handler */\n redisAsyncPushFn *push_cb;\n} redisAsyncContext;\n\n/* Functions that proxy to hiredis */\nredisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *options);\nredisAsyncContext *redisAsyncConnect(const char *ip, int port);\nredisAsyncContext *redisAsyncConnectBind(const char *ip, int port, const char *source_addr);\nredisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,\n const char *source_addr);\nredisAsyncContext *redisAsyncConnectUnix(const char *path);\nint redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn);\nint redisAsyncSetConnectCallbackNC(redisAsyncContext *ac, redisConnectCallbackNC *fn);\nint redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn);\n\nredisAsyncPushFn *redisAsyncSetPushCallback(redisAsyncContext *ac, redisAsyncPushFn *fn);\nint redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv);\nvoid redisAsyncDisconnect(redisAsyncContext *ac);\nvoid redisAsyncFree(redisAsyncContext *ac);\n\n/* Handle read/write events */\nvoid redisAsyncHandleRead(redisAsyncContext *ac);\nvoid redisAsyncHandleWrite(redisAsyncContext *ac);\nvoid redisAsyncHandleTimeout(redisAsyncContext *ac);\nvoid redisAsyncRead(redisAsyncContext *ac);\nvoid redisAsyncWrite(redisAsyncContext *ac);\n\n/* Command functions for an async context. Write the command to the\n * output buffer and register the provided callback. */\nint redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, va_list ap);\nint redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, ...);\nint redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen);\nint redisAsyncFormattedCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *cmd, size_t len);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n" }, { "path": "deps/hiredis/async_private.h", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_ASYNC_PRIVATE_H\n#define __HIREDIS_ASYNC_PRIVATE_H\n\n#define _EL_ADD_READ(ctx) \\\n do { \\\n refreshTimeout(ctx); \\\n if ((ctx)->ev.addRead) (ctx)->ev.addRead((ctx)->ev.data); \\\n } while (0)\n#define _EL_DEL_READ(ctx) do { \\\n if ((ctx)->ev.delRead) (ctx)->ev.delRead((ctx)->ev.data); \\\n } while(0)\n#define _EL_ADD_WRITE(ctx) \\\n do { \\\n refreshTimeout(ctx); \\\n if ((ctx)->ev.addWrite) (ctx)->ev.addWrite((ctx)->ev.data); \\\n } while (0)\n#define _EL_DEL_WRITE(ctx) do { \\\n if ((ctx)->ev.delWrite) (ctx)->ev.delWrite((ctx)->ev.data); \\\n } while(0)\n#define _EL_CLEANUP(ctx) do { \\\n if ((ctx)->ev.cleanup) (ctx)->ev.cleanup((ctx)->ev.data); \\\n ctx->ev.cleanup = NULL; \\\n } while(0)\n\nstatic inline void refreshTimeout(redisAsyncContext *ctx) {\n #define REDIS_TIMER_ISSET(tvp) \\\n (tvp && ((tvp)->tv_sec || (tvp)->tv_usec))\n\n #define REDIS_EL_TIMER(ac, tvp) \\\n if ((ac)->ev.scheduleTimer && REDIS_TIMER_ISSET(tvp)) { \\\n (ac)->ev.scheduleTimer((ac)->ev.data, *(tvp)); \\\n }\n\n if (ctx->c.flags & REDIS_CONNECTED) {\n REDIS_EL_TIMER(ctx, ctx->c.command_timeout);\n } else {\n REDIS_EL_TIMER(ctx, ctx->c.connect_timeout);\n }\n}\n\nvoid __redisAsyncDisconnect(redisAsyncContext *ac);\nvoid redisProcessCallbacks(redisAsyncContext *ac);\n\n#endif /* __HIREDIS_ASYNC_PRIVATE_H */\n" }, { "path": "deps/hiredis/dict.c", "content": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-random-element operations. Hash tables will auto resize if needed\n * tables of power of two in size are used, collisions are handled by\n * chaining. See the source code for more information... :)\n *\n * Copyright (c) 2006-2010, Salvatore Sanfilippo \n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \"alloc.h\"\n#include \n#include \n#include \n#include \"dict.h\"\n\n/* -------------------------- private prototypes ---------------------------- */\n\nstatic int _dictExpandIfNeeded(dict *ht);\nstatic unsigned long _dictNextPower(unsigned long size);\nstatic int _dictKeyIndex(dict *ht, const void *key);\nstatic int _dictInit(dict *ht, dictType *type, void *privDataPtr);\n\n/* -------------------------- hash functions -------------------------------- */\n\n/* Generic hash function (a popular one from Bernstein).\n * I tested a few and this was the best. */\nstatic unsigned int dictGenHashFunction(const unsigned char *buf, int len) {\n unsigned int hash = 5381;\n\n while (len--)\n hash = ((hash << 5) + hash) + (*buf++); /* hash * 33 + c */\n return hash;\n}\n\n/* ----------------------------- API implementation ------------------------- */\n\n/* Reset an hashtable already initialized with ht_init().\n * NOTE: This function should only called by ht_destroy(). */\nstatic void _dictReset(dict *ht) {\n ht->table = NULL;\n ht->size = 0;\n ht->sizemask = 0;\n ht->used = 0;\n}\n\n/* Create a new hash table */\nstatic dict *dictCreate(dictType *type, void *privDataPtr) {\n dict *ht = hi_malloc(sizeof(*ht));\n if (ht == NULL)\n return NULL;\n\n _dictInit(ht,type,privDataPtr);\n return ht;\n}\n\n/* Initialize the hash table */\nstatic int _dictInit(dict *ht, dictType *type, void *privDataPtr) {\n _dictReset(ht);\n ht->type = type;\n ht->privdata = privDataPtr;\n return DICT_OK;\n}\n\n/* Expand or create the hashtable */\nstatic int dictExpand(dict *ht, unsigned long size) {\n dict n; /* the new hashtable */\n unsigned long realsize = _dictNextPower(size), i;\n\n /* the size is invalid if it is smaller than the number of\n * elements already inside the hashtable */\n if (ht->used > size)\n return DICT_ERR;\n\n _dictInit(&n, ht->type, ht->privdata);\n n.size = realsize;\n n.sizemask = realsize-1;\n n.table = hi_calloc(realsize,sizeof(dictEntry*));\n if (n.table == NULL)\n return DICT_ERR;\n\n /* Copy all the elements from the old to the new table:\n * note that if the old hash table is empty ht->size is zero,\n * so dictExpand just creates an hash table. */\n n.used = ht->used;\n for (i = 0; i < ht->size && ht->used > 0; i++) {\n dictEntry *he, *nextHe;\n\n if (ht->table[i] == NULL) continue;\n\n /* For each hash entry on this slot... */\n he = ht->table[i];\n while(he) {\n unsigned int h;\n\n nextHe = he->next;\n /* Get the new element index */\n h = dictHashKey(ht, he->key) & n.sizemask;\n he->next = n.table[h];\n n.table[h] = he;\n ht->used--;\n /* Pass to the next element */\n he = nextHe;\n }\n }\n assert(ht->used == 0);\n hi_free(ht->table);\n\n /* Remap the new hashtable in the old */\n *ht = n;\n return DICT_OK;\n}\n\n/* Add an element to the target hash table */\nstatic int dictAdd(dict *ht, void *key, void *val) {\n int index;\n dictEntry *entry;\n\n /* Get the index of the new element, or -1 if\n * the element already exists. */\n if ((index = _dictKeyIndex(ht, key)) == -1)\n return DICT_ERR;\n\n /* Allocates the memory and stores key */\n entry = hi_malloc(sizeof(*entry));\n if (entry == NULL)\n return DICT_ERR;\n\n entry->next = ht->table[index];\n ht->table[index] = entry;\n\n /* Set the hash entry fields. */\n dictSetHashKey(ht, entry, key);\n dictSetHashVal(ht, entry, val);\n ht->used++;\n return DICT_OK;\n}\n\n/* Add an element, discarding the old if the key already exists.\n * Return 1 if the key was added from scratch, 0 if there was already an\n * element with such key and dictReplace() just performed a value update\n * operation. */\nstatic int dictReplace(dict *ht, void *key, void *val) {\n dictEntry *entry, auxentry;\n\n /* Try to add the element. If the key\n * does not exists dictAdd will succeed. */\n if (dictAdd(ht, key, val) == DICT_OK)\n return 1;\n /* It already exists, get the entry */\n entry = dictFind(ht, key);\n if (entry == NULL)\n return 0;\n\n /* Free the old value and set the new one */\n /* Set the new value and free the old one. Note that it is important\n * to do that in this order, as the value may just be exactly the same\n * as the previous one. In this context, think to reference counting,\n * you want to increment (set), and then decrement (free), and not the\n * reverse. */\n auxentry = *entry;\n dictSetHashVal(ht, entry, val);\n dictFreeEntryVal(ht, &auxentry);\n return 0;\n}\n\n/* Search and remove an element */\nstatic int dictDelete(dict *ht, const void *key) {\n unsigned int h;\n dictEntry *de, *prevde;\n\n if (ht->size == 0)\n return DICT_ERR;\n h = dictHashKey(ht, key) & ht->sizemask;\n de = ht->table[h];\n\n prevde = NULL;\n while(de) {\n if (dictCompareHashKeys(ht,key,de->key)) {\n /* Unlink the element from the list */\n if (prevde)\n prevde->next = de->next;\n else\n ht->table[h] = de->next;\n\n dictFreeEntryKey(ht,de);\n dictFreeEntryVal(ht,de);\n hi_free(de);\n ht->used--;\n return DICT_OK;\n }\n prevde = de;\n de = de->next;\n }\n return DICT_ERR; /* not found */\n}\n\n/* Destroy an entire hash table */\nstatic int _dictClear(dict *ht) {\n unsigned long i;\n\n /* Free all the elements */\n for (i = 0; i < ht->size && ht->used > 0; i++) {\n dictEntry *he, *nextHe;\n\n if ((he = ht->table[i]) == NULL) continue;\n while(he) {\n nextHe = he->next;\n dictFreeEntryKey(ht, he);\n dictFreeEntryVal(ht, he);\n hi_free(he);\n ht->used--;\n he = nextHe;\n }\n }\n /* Free the table and the allocated cache structure */\n hi_free(ht->table);\n /* Re-initialize the table */\n _dictReset(ht);\n return DICT_OK; /* never fails */\n}\n\n/* Clear & Release the hash table */\nstatic void dictRelease(dict *ht) {\n _dictClear(ht);\n hi_free(ht);\n}\n\nstatic dictEntry *dictFind(dict *ht, const void *key) {\n dictEntry *he;\n unsigned int h;\n\n if (ht->size == 0) return NULL;\n h = dictHashKey(ht, key) & ht->sizemask;\n he = ht->table[h];\n while(he) {\n if (dictCompareHashKeys(ht, key, he->key))\n return he;\n he = he->next;\n }\n return NULL;\n}\n\nstatic void dictInitIterator(dictIterator *iter, dict *ht) {\n iter->ht = ht;\n iter->index = -1;\n iter->entry = NULL;\n iter->nextEntry = NULL;\n}\n\nstatic dictEntry *dictNext(dictIterator *iter) {\n while (1) {\n if (iter->entry == NULL) {\n iter->index++;\n if (iter->index >=\n (signed)iter->ht->size) break;\n iter->entry = iter->ht->table[iter->index];\n } else {\n iter->entry = iter->nextEntry;\n }\n if (iter->entry) {\n /* We need to save the 'next' here, the iterator user\n * may delete the entry we are returning. */\n iter->nextEntry = iter->entry->next;\n return iter->entry;\n }\n }\n return NULL;\n}\n\n/* ------------------------- private functions ------------------------------ */\n\n/* Expand the hash table if needed */\nstatic int _dictExpandIfNeeded(dict *ht) {\n /* If the hash table is empty expand it to the initial size,\n * if the table is \"full\" double its size. */\n if (ht->size == 0)\n return dictExpand(ht, DICT_HT_INITIAL_SIZE);\n if (ht->used == ht->size)\n return dictExpand(ht, ht->size*2);\n return DICT_OK;\n}\n\n/* Our hash table capability is a power of two */\nstatic unsigned long _dictNextPower(unsigned long size) {\n unsigned long i = DICT_HT_INITIAL_SIZE;\n\n if (size >= LONG_MAX) return LONG_MAX;\n while(1) {\n if (i >= size)\n return i;\n i *= 2;\n }\n}\n\n/* Returns the index of a free slot that can be populated with\n * an hash entry for the given 'key'.\n * If the key already exists, -1 is returned. */\nstatic int _dictKeyIndex(dict *ht, const void *key) {\n unsigned int h;\n dictEntry *he;\n\n /* Expand the hashtable if needed */\n if (_dictExpandIfNeeded(ht) == DICT_ERR)\n return -1;\n /* Compute the key hash value */\n h = dictHashKey(ht, key) & ht->sizemask;\n /* Search if this slot does not already contain the given key */\n he = ht->table[h];\n while(he) {\n if (dictCompareHashKeys(ht, key, he->key))\n return -1;\n he = he->next;\n }\n return h;\n}\n\n" }, { "path": "deps/hiredis/dict.h", "content": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-random-element operations. Hash tables will auto resize if needed\n * tables of power of two in size are used, collisions are handled by\n * chaining. See the source code for more information... :)\n *\n * Copyright (c) 2006-2010, Salvatore Sanfilippo \n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __DICT_H\n#define __DICT_H\n\n#define DICT_OK 0\n#define DICT_ERR 1\n\n/* Unused arguments generate annoying warnings... */\n#define DICT_NOTUSED(V) ((void) V)\n\ntypedef struct dictEntry {\n void *key;\n void *val;\n struct dictEntry *next;\n} dictEntry;\n\ntypedef struct dictType {\n unsigned int (*hashFunction)(const void *key);\n void *(*keyDup)(void *privdata, const void *key);\n void *(*valDup)(void *privdata, const void *obj);\n int (*keyCompare)(void *privdata, const void *key1, const void *key2);\n void (*keyDestructor)(void *privdata, void *key);\n void (*valDestructor)(void *privdata, void *obj);\n} dictType;\n\ntypedef struct dict {\n dictEntry **table;\n dictType *type;\n unsigned long size;\n unsigned long sizemask;\n unsigned long used;\n void *privdata;\n} dict;\n\ntypedef struct dictIterator {\n dict *ht;\n int index;\n dictEntry *entry, *nextEntry;\n} dictIterator;\n\n/* This is the initial size of every hash table */\n#define DICT_HT_INITIAL_SIZE 4\n\n/* ------------------------------- Macros ------------------------------------*/\n#define dictFreeEntryVal(ht, entry) \\\n if ((ht)->type->valDestructor) \\\n (ht)->type->valDestructor((ht)->privdata, (entry)->val)\n\n#define dictSetHashVal(ht, entry, _val_) do { \\\n if ((ht)->type->valDup) \\\n entry->val = (ht)->type->valDup((ht)->privdata, _val_); \\\n else \\\n entry->val = (_val_); \\\n} while(0)\n\n#define dictFreeEntryKey(ht, entry) \\\n if ((ht)->type->keyDestructor) \\\n (ht)->type->keyDestructor((ht)->privdata, (entry)->key)\n\n#define dictSetHashKey(ht, entry, _key_) do { \\\n if ((ht)->type->keyDup) \\\n entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \\\n else \\\n entry->key = (_key_); \\\n} while(0)\n\n#define dictCompareHashKeys(ht, key1, key2) \\\n (((ht)->type->keyCompare) ? \\\n (ht)->type->keyCompare((ht)->privdata, key1, key2) : \\\n (key1) == (key2))\n\n#define dictHashKey(ht, key) (ht)->type->hashFunction(key)\n\n#define dictGetEntryKey(he) ((he)->key)\n#define dictGetEntryVal(he) ((he)->val)\n#define dictSlots(ht) ((ht)->size)\n#define dictSize(ht) ((ht)->used)\n\n/* API */\nstatic unsigned int dictGenHashFunction(const unsigned char *buf, int len);\nstatic dict *dictCreate(dictType *type, void *privDataPtr);\nstatic int dictExpand(dict *ht, unsigned long size);\nstatic int dictAdd(dict *ht, void *key, void *val);\nstatic int dictReplace(dict *ht, void *key, void *val);\nstatic int dictDelete(dict *ht, const void *key);\nstatic void dictRelease(dict *ht);\nstatic dictEntry * dictFind(dict *ht, const void *key);\nstatic void dictInitIterator(dictIterator *iter, dict *ht);\nstatic dictEntry *dictNext(dictIterator *iter);\n\n#endif /* __DICT_H */\n" }, { "path": "deps/hiredis/examples/CMakeLists.txt", "content": "INCLUDE(FindPkgConfig)\n# Check for GLib\n\nPKG_CHECK_MODULES(GLIB2 glib-2.0)\nif (GLIB2_FOUND)\n INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})\n LINK_DIRECTORIES(${GLIB2_LIBRARY_DIRS})\n ADD_EXECUTABLE(example-glib example-glib.c)\n TARGET_LINK_LIBRARIES(example-glib hiredis ${GLIB2_LIBRARIES})\nENDIF(GLIB2_FOUND)\n\nFIND_PATH(LIBEV ev.h\n HINTS /usr/local /usr/opt/local\n ENV LIBEV_INCLUDE_DIR)\n\nif (LIBEV)\n # Just compile and link with libev\n ADD_EXECUTABLE(example-libev example-libev.c)\n TARGET_LINK_LIBRARIES(example-libev hiredis ev)\nENDIF()\n\nFIND_PATH(LIBEVENT event.h)\nif (LIBEVENT)\n ADD_EXECUTABLE(example-libevent example-libevent.c)\n TARGET_LINK_LIBRARIES(example-libevent hiredis event)\nENDIF()\n\nFIND_PATH(LIBHV hv/hv.h)\nIF (LIBHV)\n ADD_EXECUTABLE(example-libhv example-libhv.c)\n TARGET_LINK_LIBRARIES(example-libhv hiredis hv)\nENDIF()\n\nFIND_PATH(LIBUV uv.h)\nIF (LIBUV)\n ADD_EXECUTABLE(example-libuv example-libuv.c)\n TARGET_LINK_LIBRARIES(example-libuv hiredis uv)\nENDIF()\n\nFIND_PATH(LIBSDEVENT systemd/sd-event.h)\nIF (LIBSDEVENT)\n ADD_EXECUTABLE(example-libsdevent example-libsdevent.c)\n TARGET_LINK_LIBRARIES(example-libsdevent hiredis systemd)\nENDIF()\n\nIF (APPLE)\n FIND_LIBRARY(CF CoreFoundation)\n ADD_EXECUTABLE(example-macosx example-macosx.c)\n TARGET_LINK_LIBRARIES(example-macosx hiredis ${CF})\nENDIF()\n\nIF (ENABLE_SSL)\n ADD_EXECUTABLE(example-ssl example-ssl.c)\n TARGET_LINK_LIBRARIES(example-ssl hiredis hiredis_ssl)\nENDIF()\n\nADD_EXECUTABLE(example example.c)\nTARGET_LINK_LIBRARIES(example hiredis)\n\nADD_EXECUTABLE(example-push example-push.c)\nTARGET_LINK_LIBRARIES(example-push hiredis)\n" }, { "path": "deps/hiredis/examples/example-ae.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n/* Put event loop in the global scope, so it can be explicitly stopped */\nstatic aeEventLoop *loop;\n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n aeStop(loop);\n return;\n }\n\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n aeStop(loop);\n return;\n }\n\n printf(\"Disconnected...\\n\");\n aeStop(loop);\n}\n\nint main (int argc, char **argv) {\n signal(SIGPIPE, SIG_IGN);\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n loop = aeCreateEventLoop(64);\n redisAeAttach(loop, c);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n aeMain(loop);\n return 0;\n}\n\n" }, { "path": "deps/hiredis/examples/example-glib.c", "content": "#include \n\n#include \n#include \n#include \n\nstatic GMainLoop *mainloop;\n\nstatic void\nconnect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,\n int status)\n{\n if (status != REDIS_OK) {\n g_printerr(\"Failed to connect: %s\\n\", ac->errstr);\n g_main_loop_quit(mainloop);\n } else {\n g_printerr(\"Connected...\\n\");\n }\n}\n\nstatic void\ndisconnect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,\n int status)\n{\n if (status != REDIS_OK) {\n g_error(\"Failed to disconnect: %s\", ac->errstr);\n } else {\n g_printerr(\"Disconnected...\\n\");\n g_main_loop_quit(mainloop);\n }\n}\n\nstatic void\ncommand_cb(redisAsyncContext *ac,\n gpointer r,\n gpointer user_data G_GNUC_UNUSED)\n{\n redisReply *reply = r;\n\n if (reply) {\n g_print(\"REPLY: %s\\n\", reply->str);\n }\n\n redisAsyncDisconnect(ac);\n}\n\ngint\nmain (gint argc G_GNUC_UNUSED,\n gchar *argv[] G_GNUC_UNUSED)\n{\n redisAsyncContext *ac;\n GMainContext *context = NULL;\n GSource *source;\n\n ac = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (ac->err) {\n g_printerr(\"%s\\n\", ac->errstr);\n exit(EXIT_FAILURE);\n }\n\n source = redis_source_new(ac);\n mainloop = g_main_loop_new(context, FALSE);\n g_source_attach(source, context);\n\n redisAsyncSetConnectCallback(ac, connect_cb);\n redisAsyncSetDisconnectCallback(ac, disconnect_cb);\n redisAsyncCommand(ac, command_cb, NULL, \"SET key 1234\");\n redisAsyncCommand(ac, command_cb, NULL, \"GET key\");\n\n g_main_loop_run(mainloop);\n\n return EXIT_SUCCESS;\n}\n" }, { "path": "deps/hiredis/examples/example-ivykis.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n iv_init();\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisIvykisAttach(c);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n\n iv_main();\n\n iv_deinit();\n\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libev.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisLibevAttach(EV_DEFAULT_ c);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n ev_loop(EV_DEFAULT_ 0);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libevent-ssl.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n struct event_base *base = event_base_new();\n if (argc < 5) {\n fprintf(stderr,\n \"Usage: %s [ca]\\n\", argv[0]);\n exit(1);\n }\n\n const char *value = argv[1];\n size_t nvalue = strlen(value);\n\n const char *hostname = argv[2];\n int port = atoi(argv[3]);\n\n const char *cert = argv[4];\n const char *certKey = argv[5];\n const char *caCert = argc > 5 ? argv[6] : NULL;\n\n redisSSLContext *ssl;\n redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;\n\n redisInitOpenSSL();\n\n ssl = redisCreateSSLContext(caCert, NULL,\n cert, certKey, NULL, &ssl_error);\n if (!ssl) {\n printf(\"Error: %s\\n\", redisSSLContextGetError(ssl_error));\n return 1;\n }\n\n redisAsyncContext *c = redisAsyncConnect(hostname, port);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n if (redisInitiateSSLWithContext(&c->c, ssl) != REDIS_OK) {\n printf(\"SSL Error!\\n\");\n exit(1);\n }\n\n redisLibeventAttach(c,base);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", value, nvalue);\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n event_base_dispatch(base);\n\n redisFreeSSLContext(ssl);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libevent.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) {\n if (c->errstr) {\n printf(\"errstr: %s\\n\", c->errstr);\n }\n return;\n }\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n struct event_base *base = event_base_new();\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, \"127.0.0.1\", 6379);\n struct timeval tv = {0};\n tv.tv_sec = 1;\n options.connect_timeout = &tv;\n\n\n redisAsyncContext *c = redisAsyncConnectWithOptions(&options);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisLibeventAttach(c,base);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n event_base_dispatch(base);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libhv.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid debugCallback(redisAsyncContext *c, void *r, void *privdata) {\n (void)privdata;\n redisReply *reply = r;\n\n if (reply == NULL) {\n printf(\"`DEBUG SLEEP` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n hloop_t* loop = hloop_new(HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS);\n redisLibhvAttach(c, loop);\n redisAsyncSetTimeout(c, (struct timeval){.tv_sec = 0, .tv_usec = 500000});\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n redisAsyncCommand(c, debugCallback, NULL, \"DEBUG SLEEP %d\", 1);\n hloop_run(loop);\n hloop_free(&loop);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libsdevent.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid debugCallback(redisAsyncContext *c, void *r, void *privdata) {\n (void)privdata;\n redisReply *reply = r;\n if (reply == NULL) {\n /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */\n printf(\"`DEBUG SLEEP` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/\n redisAsyncDisconnect(c);\n}\n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) {\n printf(\"`GET key` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n printf(\"`GET key` result: argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* start another request that demonstrate timeout */\n redisAsyncCommand(c, debugCallback, NULL, \"DEBUG SLEEP %f\", 1.5);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"connect error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"disconnect because of error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n signal(SIGPIPE, SIG_IGN);\n\n struct sd_event *event;\n sd_event_default(&event);\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n printf(\"Error: %s\\n\", c->errstr);\n redisAsyncFree(c);\n return 1;\n }\n\n redisLibsdeventAttach(c,event);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});\n\n /*\n In this demo, we first `set key`, then `get key` to demonstrate the basic usage of libsdevent adapter.\n Then in `getCallback`, we start a `debug sleep` command to create 1.5 second long request.\n Because we have set a 1 second timeout to the connection, the command will always fail with a\n timeout error, which is shown in the `debugCallback`.\n */\n\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n\n /* sd-event does not quit when there are no handlers registered. Manually exit after 1.5 seconds */\n sd_event_source *s;\n sd_event_add_time_relative(event, &s, CLOCK_MONOTONIC, 1500000, 1, NULL, NULL);\n\n sd_event_loop(event);\n sd_event_source_disable_unref(s);\n sd_event_unref(event);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-libuv.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid debugCallback(redisAsyncContext *c, void *r, void *privdata) {\n (void)privdata; //unused\n redisReply *reply = r;\n if (reply == NULL) {\n /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */\n printf(\"`DEBUG SLEEP` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/\n redisAsyncDisconnect(c);\n}\n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) {\n printf(\"`GET key` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n printf(\"`GET key` result: argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* start another request that demonstrate timeout */\n redisAsyncCommand(c, debugCallback, NULL, \"DEBUG SLEEP %f\", 1.5);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"connect error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"disconnect because of error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n#ifndef _WIN32\n signal(SIGPIPE, SIG_IGN);\n#endif\n\n uv_loop_t* loop = uv_default_loop();\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisLibuvAttach(c,loop);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});\n\n /*\n In this demo, we first `set key`, then `get key` to demonstrate the basic usage of libuv adapter.\n Then in `getCallback`, we start a `debug sleep` command to create 1.5 second long request.\n Because we have set a 1 second timeout to the connection, the command will always fail with a\n timeout error, which is shown in the `debugCallback`.\n */\n\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n\n uv_run(loop, UV_RUN_DEFAULT);\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-macosx.c", "content": "//\n// Created by Дмитрий Бахвалов on 13.07.15.\n// Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#include \n\n#include \n#include \n#include \n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n CFRunLoopStop(CFRunLoopGetCurrent());\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n signal(SIGPIPE, SIG_IGN);\n\n CFRunLoopRef loop = CFRunLoopGetCurrent();\n if( !loop ) {\n printf(\"Error: Cannot get current run loop\\n\");\n return 1;\n }\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisMacOSAttach(c, loop);\n\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n\n CFRunLoopRun();\n\n return 0;\n}\n\n" }, { "path": "deps/hiredis/examples/example-poll.c", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n/* Put in the global scope, so that loop can be explicitly stopped */\nstatic int exit_loop = 0;\n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) return;\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* Disconnect after receiving the reply to GET */\n redisAsyncDisconnect(c);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n exit_loop = 1;\n return;\n }\n\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n exit_loop = 1;\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n\n printf(\"Disconnected...\\n\");\n}\n\nint main (int argc, char **argv) {\n signal(SIGPIPE, SIG_IGN);\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n redisPollAttach(c);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", argv[argc-1], strlen(argv[argc-1]));\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n while (!exit_loop)\n {\n redisPollTick(c, 0.1);\n }\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-push.c", "content": "/*\n * Copyright (c) 2020, Michael Grunder \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n#include \n#include \n#include \n#include \n\n#define KEY_COUNT 5\n\n#define panicAbort(fmt, ...) \\\n do { \\\n fprintf(stderr, \"%s:%d:%s(): \" fmt, __FILE__, __LINE__, __func__, __VA_ARGS__); \\\n exit(-1); \\\n } while (0)\n\nstatic void assertReplyAndFree(redisContext *context, redisReply *reply, int type) {\n if (reply == NULL)\n panicAbort(\"NULL reply from server (error: %s)\", context->errstr);\n\n if (reply->type != type) {\n if (reply->type == REDIS_REPLY_ERROR)\n fprintf(stderr, \"Redis Error: %s\\n\", reply->str);\n\n panicAbort(\"Expected reply type %d but got type %d\", type, reply->type);\n }\n\n freeReplyObject(reply);\n}\n\n/* Switch to the RESP3 protocol and enable client tracking */\nstatic void enableClientTracking(redisContext *c) {\n redisReply *reply = redisCommand(c, \"HELLO 3\");\n if (reply == NULL || c->err) {\n panicAbort(\"NULL reply or server error (error: %s)\", c->errstr);\n }\n\n if (reply->type != REDIS_REPLY_MAP) {\n fprintf(stderr, \"Error: Can't send HELLO 3 command. Are you sure you're \");\n fprintf(stderr, \"connected to redis-server >= 6.0.0?\\nRedis error: %s\\n\",\n reply->type == REDIS_REPLY_ERROR ? reply->str : \"(unknown)\");\n exit(-1);\n }\n\n freeReplyObject(reply);\n\n /* Enable client tracking */\n reply = redisCommand(c, \"CLIENT TRACKING ON\");\n assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);\n}\n\nvoid pushReplyHandler(void *privdata, void *r) {\n redisReply *reply = r;\n int *invalidations = privdata;\n\n /* Sanity check on the invalidation reply */\n if (reply->type != REDIS_REPLY_PUSH || reply->elements != 2 ||\n reply->element[1]->type != REDIS_REPLY_ARRAY ||\n reply->element[1]->element[0]->type != REDIS_REPLY_STRING)\n {\n panicAbort(\"%s\", \"Can't parse PUSH message!\");\n }\n\n /* Increment our invalidation count */\n *invalidations += 1;\n\n printf(\"pushReplyHandler(): INVALIDATE '%s' (invalidation count: %d)\\n\",\n reply->element[1]->element[0]->str, *invalidations);\n\n freeReplyObject(reply);\n}\n\n/* We aren't actually freeing anything here, but it is included to show that we can\n * have hiredis call our data destructor when freeing the context */\nvoid privdata_dtor(void *privdata) {\n unsigned int *icount = privdata;\n printf(\"privdata_dtor(): In context privdata dtor (invalidations: %u)\\n\", *icount);\n}\n\nint main(int argc, char **argv) {\n unsigned int j, invalidations = 0;\n redisContext *c;\n redisReply *reply;\n\n const char *hostname = (argc > 1) ? argv[1] : \"127.0.0.1\";\n int port = (argc > 2) ? atoi(argv[2]) : 6379;\n\n redisOptions o = {0};\n REDIS_OPTIONS_SET_TCP(&o, hostname, port);\n\n /* Set our context privdata to the address of our invalidation counter. Each\n * time our PUSH handler is called, hiredis will pass the privdata for context.\n *\n * This could also be done after we create the context like so:\n *\n * c->privdata = &invalidations;\n * c->free_privdata = privdata_dtor;\n */\n REDIS_OPTIONS_SET_PRIVDATA(&o, &invalidations, privdata_dtor);\n\n /* Set our custom PUSH message handler */\n o.push_cb = pushReplyHandler;\n\n c = redisConnectWithOptions(&o);\n if (c == NULL || c->err)\n panicAbort(\"Connection error: %s\", c ? c->errstr : \"OOM\");\n\n /* Enable RESP3 and turn on client tracking */\n enableClientTracking(c);\n\n /* Set some keys and then read them back. Once we do that, Redis will deliver\n * invalidation push messages whenever the key is modified */\n for (j = 0; j < KEY_COUNT; j++) {\n reply = redisCommand(c, \"SET key:%d initial:%d\", j, j);\n assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);\n\n reply = redisCommand(c, \"GET key:%d\", j);\n assertReplyAndFree(c, reply, REDIS_REPLY_STRING);\n }\n\n /* Trigger invalidation messages by updating keys we just read */\n for (j = 0; j < KEY_COUNT; j++) {\n printf(\" main(): SET key:%d update:%d\\n\", j, j);\n reply = redisCommand(c, \"SET key:%d update:%d\", j, j);\n assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);\n printf(\" main(): SET REPLY OK\\n\");\n }\n\n printf(\"\\nTotal detected invalidations: %d, expected: %d\\n\", invalidations, KEY_COUNT);\n\n /* PING server */\n redisFree(c);\n}\n" }, { "path": "deps/hiredis/examples/example-qt.cpp", "content": "#include \nusing namespace std;\n\n#include \n#include \n\n#include \"example-qt.h\"\n\nvoid getCallback(redisAsyncContext *, void * r, void * privdata) {\n\n redisReply * reply = static_cast(r);\n ExampleQt * ex = static_cast(privdata);\n if (reply == nullptr || ex == nullptr) return;\n\n cout << \"key: \" << reply->str << endl;\n\n ex->finish();\n}\n\nvoid ExampleQt::run() {\n\n m_ctx = redisAsyncConnect(\"localhost\", 6379);\n\n if (m_ctx->err) {\n cerr << \"Error: \" << m_ctx->errstr << endl;\n redisAsyncFree(m_ctx);\n emit finished();\n }\n\n m_adapter.setContext(m_ctx);\n\n redisAsyncCommand(m_ctx, NULL, NULL, \"SET key %s\", m_value);\n redisAsyncCommand(m_ctx, getCallback, this, \"GET key\");\n}\n\nint main (int argc, char **argv) {\n\n QCoreApplication app(argc, argv);\n\n ExampleQt example(argv[argc-1]);\n\n QObject::connect(&example, SIGNAL(finished()), &app, SLOT(quit()));\n QTimer::singleShot(0, &example, SLOT(run()));\n\n return app.exec();\n}\n" }, { "path": "deps/hiredis/examples/example-qt.h", "content": "#ifndef __HIREDIS_EXAMPLE_QT_H\n#define __HIREDIS_EXAMPLE_QT_H\n\n#include \n\nclass ExampleQt : public QObject {\n\n Q_OBJECT\n\n public:\n ExampleQt(const char * value, QObject * parent = 0)\n : QObject(parent), m_value(value) {}\n\n signals:\n void finished();\n\n public slots:\n void run();\n\n private:\n void finish() { emit finished(); }\n\n private:\n const char * m_value;\n redisAsyncContext * m_ctx;\n RedisQtAdapter m_adapter;\n\n friend\n void getCallback(redisAsyncContext *, void *, void *);\n};\n\n#endif /* !__HIREDIS_EXAMPLE_QT_H */\n" }, { "path": "deps/hiredis/examples/example-redismoduleapi.c", "content": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nvoid debugCallback(redisAsyncContext *c, void *r, void *privdata) {\n (void)privdata; //unused\n redisReply *reply = r;\n if (reply == NULL) {\n /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */\n printf(\"`DEBUG SLEEP` error: %s\\n\", c->errstr ? c->errstr : \"unknown error\");\n return;\n }\n /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/\n redisAsyncDisconnect(c);\n}\n\nvoid getCallback(redisAsyncContext *c, void *r, void *privdata) {\n redisReply *reply = r;\n if (reply == NULL) {\n if (c->errstr) {\n printf(\"errstr: %s\\n\", c->errstr);\n }\n return;\n }\n printf(\"argv[%s]: %s\\n\", (char*)privdata, reply->str);\n\n /* start another request that demonstrate timeout */\n redisAsyncCommand(c, debugCallback, NULL, \"DEBUG SLEEP %f\", 1.5);\n}\n\nvoid connectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Connected...\\n\");\n}\n\nvoid disconnectCallback(const redisAsyncContext *c, int status) {\n if (status != REDIS_OK) {\n printf(\"Error: %s\\n\", c->errstr);\n return;\n }\n printf(\"Disconnected...\\n\");\n}\n\n/*\n * This example requires Redis 7.0 or above.\n *\n * 1- Compile this file as a shared library. Directory of \"redismodule.h\" must\n * be in the include path.\n * gcc -fPIC -shared -I../../redis/src/ -I.. example-redismoduleapi.c -o example-redismoduleapi.so\n *\n * 2- Load module:\n * redis-server --loadmodule ./example-redismoduleapi.so value\n */\nint RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n\n int ret = RedisModule_Init(ctx, \"example-redismoduleapi\", 1, REDISMODULE_APIVER_1);\n if (ret != REDISMODULE_OK) {\n printf(\"error module init \\n\");\n return REDISMODULE_ERR;\n }\n\n if (redisModuleCompatibilityCheck() != REDIS_OK) {\n printf(\"Redis 7.0 or above is required! \\n\");\n return REDISMODULE_ERR;\n }\n\n redisAsyncContext *c = redisAsyncConnect(\"127.0.0.1\", 6379);\n if (c->err) {\n /* Let *c leak for now... */\n printf(\"Error: %s\\n\", c->errstr);\n return 1;\n }\n\n size_t len;\n const char *val = RedisModule_StringPtrLen(argv[argc-1], &len);\n\n RedisModuleCtx *module_ctx = RedisModule_GetDetachedThreadSafeContext(ctx);\n redisModuleAttach(c, module_ctx);\n redisAsyncSetConnectCallback(c,connectCallback);\n redisAsyncSetDisconnectCallback(c,disconnectCallback);\n redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});\n\n /*\n In this demo, we first `set key`, then `get key` to demonstrate the basic usage of the adapter.\n Then in `getCallback`, we start a `debug sleep` command to create 1.5 second long request.\n Because we have set a 1 second timeout to the connection, the command will always fail with a\n timeout error, which is shown in the `debugCallback`.\n */\n\n redisAsyncCommand(c, NULL, NULL, \"SET key %b\", val, len);\n redisAsyncCommand(c, getCallback, (char*)\"end-1\", \"GET key\");\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example-ssl.c", "content": "#include \n#include \n#include \n\n#include \n#include \n\n#ifdef _MSC_VER\n#include /* For struct timeval */\n#endif\n\nint main(int argc, char **argv) {\n unsigned int j;\n redisSSLContext *ssl;\n redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;\n redisContext *c;\n redisReply *reply;\n if (argc < 4) {\n printf(\"Usage: %s [ca]\\n\", argv[0]);\n exit(1);\n }\n const char *hostname = (argc > 1) ? argv[1] : \"127.0.0.1\";\n int port = atoi(argv[2]);\n const char *cert = argv[3];\n const char *key = argv[4];\n const char *ca = argc > 4 ? argv[5] : NULL;\n\n redisInitOpenSSL();\n ssl = redisCreateSSLContext(ca, NULL, cert, key, NULL, &ssl_error);\n if (!ssl || ssl_error != REDIS_SSL_CTX_NONE) {\n printf(\"SSL Context error: %s\\n\", redisSSLContextGetError(ssl_error));\n exit(1);\n }\n\n struct timeval tv = { 1, 500000 }; // 1.5 seconds\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, hostname, port);\n options.connect_timeout = &tv;\n c = redisConnectWithOptions(&options);\n\n if (c == NULL || c->err) {\n if (c) {\n printf(\"Connection error: %s\\n\", c->errstr);\n redisFree(c);\n } else {\n printf(\"Connection error: can't allocate redis context\\n\");\n }\n exit(1);\n }\n\n if (redisInitiateSSLWithContext(c, ssl) != REDIS_OK) {\n printf(\"Couldn't initialize SSL!\\n\");\n printf(\"Error: %s\\n\", c->errstr);\n redisFree(c);\n exit(1);\n }\n\n /* PING server */\n reply = redisCommand(c,\"PING\");\n printf(\"PING: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Set a key */\n reply = redisCommand(c,\"SET %s %s\", \"foo\", \"hello world\");\n printf(\"SET: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Set a key using binary safe API */\n reply = redisCommand(c,\"SET %b %b\", \"bar\", (size_t) 3, \"hello\", (size_t) 5);\n printf(\"SET (binary API): %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Try a GET and two INCR */\n reply = redisCommand(c,\"GET foo\");\n printf(\"GET foo: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n reply = redisCommand(c,\"INCR counter\");\n printf(\"INCR counter: %lld\\n\", reply->integer);\n freeReplyObject(reply);\n /* again ... */\n reply = redisCommand(c,\"INCR counter\");\n printf(\"INCR counter: %lld\\n\", reply->integer);\n freeReplyObject(reply);\n\n /* Create a list of numbers, from 0 to 9 */\n reply = redisCommand(c,\"DEL mylist\");\n freeReplyObject(reply);\n for (j = 0; j < 10; j++) {\n char buf[64];\n\n snprintf(buf,64,\"%u\",j);\n reply = redisCommand(c,\"LPUSH mylist element-%s\", buf);\n freeReplyObject(reply);\n }\n\n /* Let's check what we have inside the list */\n reply = redisCommand(c,\"LRANGE mylist 0 -1\");\n if (reply->type == REDIS_REPLY_ARRAY) {\n for (j = 0; j < reply->elements; j++) {\n printf(\"%u) %s\\n\", j, reply->element[j]->str);\n }\n }\n freeReplyObject(reply);\n\n /* Disconnects and frees the context */\n redisFree(c);\n\n redisFreeSSLContext(ssl);\n\n return 0;\n}\n" }, { "path": "deps/hiredis/examples/example.c", "content": "#include \n#include \n#include \n#include \n\n#ifdef _MSC_VER\n#include /* For struct timeval */\n#endif\n\nstatic void example_argv_command(redisContext *c, size_t n) {\n char **argv, tmp[42];\n size_t *argvlen;\n redisReply *reply;\n\n /* We're allocating two additional elements for command and key */\n argv = malloc(sizeof(*argv) * (2 + n));\n argvlen = malloc(sizeof(*argvlen) * (2 + n));\n\n /* First the command */\n argv[0] = (char*)\"RPUSH\";\n argvlen[0] = sizeof(\"RPUSH\") - 1;\n\n /* Now our key */\n argv[1] = (char*)\"argvlist\";\n argvlen[1] = sizeof(\"argvlist\") - 1;\n\n /* Now add the entries we wish to add to the list */\n for (size_t i = 2; i < (n + 2); i++) {\n argvlen[i] = snprintf(tmp, sizeof(tmp), \"argv-element-%zu\", i - 2);\n argv[i] = strdup(tmp);\n }\n\n /* Execute the command using redisCommandArgv. We're sending the arguments with\n * two explicit arrays. One for each argument's string, and the other for its\n * length. */\n reply = redisCommandArgv(c, n + 2, (const char **)argv, (const size_t*)argvlen);\n\n if (reply == NULL || c->err) {\n fprintf(stderr, \"Error: Couldn't execute redisCommandArgv\\n\");\n exit(1);\n }\n\n if (reply->type == REDIS_REPLY_INTEGER) {\n printf(\"%s reply: %lld\\n\", argv[0], reply->integer);\n }\n\n freeReplyObject(reply);\n\n /* Clean up */\n for (size_t i = 2; i < (n + 2); i++) {\n free(argv[i]);\n }\n\n free(argv);\n free(argvlen);\n}\n\nint main(int argc, char **argv) {\n unsigned int j, isunix = 0;\n redisContext *c;\n redisReply *reply;\n const char *hostname = (argc > 1) ? argv[1] : \"127.0.0.1\";\n\n if (argc > 2) {\n if (*argv[2] == 'u' || *argv[2] == 'U') {\n isunix = 1;\n /* in this case, host is the path to the unix socket */\n printf(\"Will connect to unix socket @%s\\n\", hostname);\n }\n }\n\n int port = (argc > 2) ? atoi(argv[2]) : 6379;\n\n struct timeval timeout = { 1, 500000 }; // 1.5 seconds\n if (isunix) {\n c = redisConnectUnixWithTimeout(hostname, timeout);\n } else {\n c = redisConnectWithTimeout(hostname, port, timeout);\n }\n if (c == NULL || c->err) {\n if (c) {\n printf(\"Connection error: %s\\n\", c->errstr);\n redisFree(c);\n } else {\n printf(\"Connection error: can't allocate redis context\\n\");\n }\n exit(1);\n }\n\n /* PING server */\n reply = redisCommand(c,\"PING\");\n printf(\"PING: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Set a key */\n reply = redisCommand(c,\"SET %s %s\", \"foo\", \"hello world\");\n printf(\"SET: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Set a key using binary safe API */\n reply = redisCommand(c,\"SET %b %b\", \"bar\", (size_t) 3, \"hello\", (size_t) 5);\n printf(\"SET (binary API): %s\\n\", reply->str);\n freeReplyObject(reply);\n\n /* Try a GET and two INCR */\n reply = redisCommand(c,\"GET foo\");\n printf(\"GET foo: %s\\n\", reply->str);\n freeReplyObject(reply);\n\n reply = redisCommand(c,\"INCR counter\");\n printf(\"INCR counter: %lld\\n\", reply->integer);\n freeReplyObject(reply);\n /* again ... */\n reply = redisCommand(c,\"INCR counter\");\n printf(\"INCR counter: %lld\\n\", reply->integer);\n freeReplyObject(reply);\n\n /* Create a list of numbers, from 0 to 9 */\n reply = redisCommand(c,\"DEL mylist\");\n freeReplyObject(reply);\n for (j = 0; j < 10; j++) {\n char buf[64];\n\n snprintf(buf,64,\"%u\",j);\n reply = redisCommand(c,\"LPUSH mylist element-%s\", buf);\n freeReplyObject(reply);\n }\n\n /* Let's check what we have inside the list */\n reply = redisCommand(c,\"LRANGE mylist 0 -1\");\n if (reply->type == REDIS_REPLY_ARRAY) {\n for (j = 0; j < reply->elements; j++) {\n printf(\"%u) %s\\n\", j, reply->element[j]->str);\n }\n }\n freeReplyObject(reply);\n\n /* See function for an example of redisCommandArgv */\n example_argv_command(c, 10);\n\n /* Disconnects and frees the context */\n redisFree(c);\n\n return 0;\n}\n" }, { "path": "deps/hiredis/fmacros.h", "content": "#ifndef __HIREDIS_FMACRO_H\n#define __HIREDIS_FMACRO_H\n\n#ifndef _AIX\n#define _XOPEN_SOURCE 600\n#define _POSIX_C_SOURCE 200112L\n#endif\n\n#if defined(__APPLE__) && defined(__MACH__)\n/* Enable TCP_KEEPALIVE */\n#define _DARWIN_C_SOURCE\n#endif\n\n#endif\n" }, { "path": "deps/hiredis/fuzzing/format_command_fuzzer.c", "content": "/*\n * Copyright (c) 2020, Salvatore Sanfilippo \n * Copyright (c) 2020, Pieter Noordhuis \n * Copyright (c) 2020, Matt Stancliff ,\n * Jan-Erik Rediger \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \n#include \n#include \"hiredis.h\"\n\nint LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {\n char *new_str, *cmd;\n\n if (size < 3)\n return 0;\n\n new_str = malloc(size+1);\n if (new_str == NULL)\n return 0;\n\n memcpy(new_str, data, size);\n new_str[size] = '\\0';\n\n if (redisFormatCommand(&cmd, new_str) != -1)\n hi_free(cmd);\n\n free(new_str);\n return 0;\n}\n" }, { "path": "deps/hiredis/hiredis-config.cmake.in", "content": "@PACKAGE_INIT@\n\nset_and_check(hiredis_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\nIF (NOT TARGET hiredis::@hiredis_export_name@)\n\tINCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis-targets.cmake)\nENDIF()\n\nSET(hiredis_LIBRARIES hiredis::@hiredis_export_name@)\nSET(hiredis_INCLUDE_DIRS ${hiredis_INCLUDEDIR})\n\ncheck_required_components(hiredis)\n\n" }, { "path": "deps/hiredis/hiredis.c", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2014, Pieter Noordhuis \n * Copyright (c) 2015, Matt Stancliff ,\n * Jan-Erik Rediger \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \n#include \n#include \n#include \n#include \n\n#include \"hiredis.h\"\n#include \"net.h\"\n#include \"sds.h\"\n#include \"async.h\"\n#include \"win32.h\"\n\nextern int redisContextUpdateConnectTimeout(redisContext *c, const struct timeval *timeout);\nextern int redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout);\n\nstatic redisContextFuncs redisContextDefaultFuncs = {\n .close = redisNetClose,\n .free_privctx = NULL,\n .async_read = redisAsyncRead,\n .async_write = redisAsyncWrite,\n .read = redisNetRead,\n .write = redisNetWrite\n};\n\nstatic redisReply *createReplyObject(int type);\nstatic void *createStringObject(const redisReadTask *task, char *str, size_t len);\nstatic void *createArrayObject(const redisReadTask *task, size_t elements);\nstatic void *createIntegerObject(const redisReadTask *task, long long value);\nstatic void *createDoubleObject(const redisReadTask *task, double value, char *str, size_t len);\nstatic void *createNilObject(const redisReadTask *task);\nstatic void *createBoolObject(const redisReadTask *task, int bval);\n\n/* Default set of functions to build the reply. Keep in mind that such a\n * function returning NULL is interpreted as OOM. */\nstatic redisReplyObjectFunctions defaultFunctions = {\n createStringObject,\n createArrayObject,\n createIntegerObject,\n createDoubleObject,\n createNilObject,\n createBoolObject,\n freeReplyObject\n};\n\n/* Create a reply object */\nstatic redisReply *createReplyObject(int type) {\n redisReply *r = hi_calloc(1,sizeof(*r));\n\n if (r == NULL)\n return NULL;\n\n r->type = type;\n return r;\n}\n\n/* Free a reply object */\nvoid freeReplyObject(void *reply) {\n redisReply *r = reply;\n size_t j;\n\n if (r == NULL)\n return;\n\n switch(r->type) {\n case REDIS_REPLY_INTEGER:\n case REDIS_REPLY_NIL:\n case REDIS_REPLY_BOOL:\n break; /* Nothing to free */\n case REDIS_REPLY_ARRAY:\n case REDIS_REPLY_MAP:\n case REDIS_REPLY_SET:\n case REDIS_REPLY_PUSH:\n if (r->element != NULL) {\n for (j = 0; j < r->elements; j++)\n freeReplyObject(r->element[j]);\n hi_free(r->element);\n }\n break;\n case REDIS_REPLY_ERROR:\n case REDIS_REPLY_STATUS:\n case REDIS_REPLY_STRING:\n case REDIS_REPLY_DOUBLE:\n case REDIS_REPLY_VERB:\n case REDIS_REPLY_BIGNUM:\n hi_free(r->str);\n break;\n }\n hi_free(r);\n}\n\nstatic void *createStringObject(const redisReadTask *task, char *str, size_t len) {\n redisReply *r, *parent;\n char *buf;\n\n r = createReplyObject(task->type);\n if (r == NULL)\n return NULL;\n\n assert(task->type == REDIS_REPLY_ERROR ||\n task->type == REDIS_REPLY_STATUS ||\n task->type == REDIS_REPLY_STRING ||\n task->type == REDIS_REPLY_VERB ||\n task->type == REDIS_REPLY_BIGNUM);\n\n /* Copy string value */\n if (task->type == REDIS_REPLY_VERB) {\n buf = hi_malloc(len-4+1); /* Skip 4 bytes of verbatim type header. */\n if (buf == NULL) goto oom;\n\n memcpy(r->vtype,str,3);\n r->vtype[3] = '\\0';\n memcpy(buf,str+4,len-4);\n buf[len-4] = '\\0';\n r->len = len - 4;\n } else {\n buf = hi_malloc(len+1);\n if (buf == NULL) goto oom;\n\n memcpy(buf,str,len);\n buf[len] = '\\0';\n r->len = len;\n }\n r->str = buf;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n\noom:\n freeReplyObject(r);\n return NULL;\n}\n\nstatic void *createArrayObject(const redisReadTask *task, size_t elements) {\n redisReply *r, *parent;\n\n r = createReplyObject(task->type);\n if (r == NULL)\n return NULL;\n\n if (elements > 0) {\n r->element = hi_calloc(elements,sizeof(redisReply*));\n if (r->element == NULL) {\n freeReplyObject(r);\n return NULL;\n }\n }\n\n r->elements = elements;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n}\n\nstatic void *createIntegerObject(const redisReadTask *task, long long value) {\n redisReply *r, *parent;\n\n r = createReplyObject(REDIS_REPLY_INTEGER);\n if (r == NULL)\n return NULL;\n\n r->integer = value;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n}\n\nstatic void *createDoubleObject(const redisReadTask *task, double value, char *str, size_t len) {\n redisReply *r, *parent;\n\n if (len == SIZE_MAX) // Prevents hi_malloc(0) if len equals to SIZE_MAX\n return NULL;\n\n r = createReplyObject(REDIS_REPLY_DOUBLE);\n if (r == NULL)\n return NULL;\n\n r->dval = value;\n r->str = hi_malloc(len+1);\n if (r->str == NULL) {\n freeReplyObject(r);\n return NULL;\n }\n\n /* The double reply also has the original protocol string representing a\n * double as a null terminated string. This way the caller does not need\n * to format back for string conversion, especially since Redis does efforts\n * to make the string more human readable avoiding the calssical double\n * decimal string conversion artifacts. */\n memcpy(r->str, str, len);\n r->str[len] = '\\0';\n r->len = len;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n}\n\nstatic void *createNilObject(const redisReadTask *task) {\n redisReply *r, *parent;\n\n r = createReplyObject(REDIS_REPLY_NIL);\n if (r == NULL)\n return NULL;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n}\n\nstatic void *createBoolObject(const redisReadTask *task, int bval) {\n redisReply *r, *parent;\n\n r = createReplyObject(REDIS_REPLY_BOOL);\n if (r == NULL)\n return NULL;\n\n r->integer = bval != 0;\n\n if (task->parent) {\n parent = task->parent->obj;\n assert(parent->type == REDIS_REPLY_ARRAY ||\n parent->type == REDIS_REPLY_MAP ||\n parent->type == REDIS_REPLY_SET ||\n parent->type == REDIS_REPLY_PUSH);\n parent->element[task->idx] = r;\n }\n return r;\n}\n\n/* Return the number of digits of 'v' when converted to string in radix 10.\n * Implementation borrowed from link in redis/src/util.c:string2ll(). */\nstatic uint32_t countDigits(uint64_t v) {\n uint32_t result = 1;\n for (;;) {\n if (v < 10) return result;\n if (v < 100) return result + 1;\n if (v < 1000) return result + 2;\n if (v < 10000) return result + 3;\n v /= 10000U;\n result += 4;\n }\n}\n\n/* Helper that calculates the bulk length given a certain string length. */\nstatic size_t bulklen(size_t len) {\n return 1+countDigits(len)+2+len+2;\n}\n\nint redisvFormatCommand(char **target, const char *format, va_list ap) {\n const char *c = format;\n char *cmd = NULL; /* final command */\n int pos; /* position in final command */\n hisds curarg, newarg; /* current argument */\n int touched = 0; /* was the current argument touched? */\n char **curargv = NULL, **newargv = NULL;\n int argc = 0;\n int totlen = 0;\n int error_type = 0; /* 0 = no error; -1 = memory error; -2 = format error */\n int j;\n\n /* Abort if there is not target to set */\n if (target == NULL)\n return -1;\n\n /* Build the command string accordingly to protocol */\n curarg = hi_sdsempty();\n if (curarg == NULL)\n return -1;\n\n while(*c != '\\0') {\n if (*c != '%' || c[1] == '\\0') {\n if (*c == ' ') {\n if (touched) {\n newargv = hi_realloc(curargv,sizeof(char*)*(argc+1));\n if (newargv == NULL) goto memory_err;\n curargv = newargv;\n curargv[argc++] = curarg;\n totlen += bulklen(hi_sdslen(curarg));\n\n /* curarg is put in argv so it can be overwritten. */\n curarg = hi_sdsempty();\n if (curarg == NULL) goto memory_err;\n touched = 0;\n }\n } else {\n newarg = hi_sdscatlen(curarg,c,1);\n if (newarg == NULL) goto memory_err;\n curarg = newarg;\n touched = 1;\n }\n } else {\n char *arg;\n size_t size;\n\n /* Set newarg so it can be checked even if it is not touched. */\n newarg = curarg;\n\n switch(c[1]) {\n case 's':\n arg = va_arg(ap,char*);\n size = strlen(arg);\n if (size > 0)\n newarg = hi_sdscatlen(curarg,arg,size);\n break;\n case 'b':\n arg = va_arg(ap,char*);\n size = va_arg(ap,size_t);\n if (size > 0)\n newarg = hi_sdscatlen(curarg,arg,size);\n break;\n case '%':\n newarg = hi_sdscat(curarg,\"%\");\n break;\n default:\n /* Try to detect printf format */\n {\n static const char intfmts[] = \"diouxX\";\n static const char flags[] = \"#0-+ \";\n char _format[16];\n const char *_p = c+1;\n size_t _l = 0;\n va_list _cpy;\n\n /* Flags */\n while (*_p != '\\0' && strchr(flags,*_p) != NULL) _p++;\n\n /* Field width */\n while (*_p != '\\0' && isdigit((int) *_p)) _p++;\n\n /* Precision */\n if (*_p == '.') {\n _p++;\n while (*_p != '\\0' && isdigit((int) *_p)) _p++;\n }\n\n /* Copy va_list before consuming with va_arg */\n va_copy(_cpy,ap);\n\n /* Make sure we have more characters otherwise strchr() accepts\n * '\\0' as an integer specifier. This is checked after above\n * va_copy() to avoid UB in fmt_invalid's call to va_end(). */\n if (*_p == '\\0') goto fmt_invalid;\n\n /* Integer conversion (without modifiers) */\n if (strchr(intfmts,*_p) != NULL) {\n va_arg(ap,int);\n goto fmt_valid;\n }\n\n /* Double conversion (without modifiers) */\n if (strchr(\"eEfFgGaA\",*_p) != NULL) {\n va_arg(ap,double);\n goto fmt_valid;\n }\n\n /* Size: char */\n if (_p[0] == 'h' && _p[1] == 'h') {\n _p += 2;\n if (*_p != '\\0' && strchr(intfmts,*_p) != NULL) {\n va_arg(ap,int); /* char gets promoted to int */\n goto fmt_valid;\n }\n goto fmt_invalid;\n }\n\n /* Size: short */\n if (_p[0] == 'h') {\n _p += 1;\n if (*_p != '\\0' && strchr(intfmts,*_p) != NULL) {\n va_arg(ap,int); /* short gets promoted to int */\n goto fmt_valid;\n }\n goto fmt_invalid;\n }\n\n /* Size: long long */\n if (_p[0] == 'l' && _p[1] == 'l') {\n _p += 2;\n if (*_p != '\\0' && strchr(intfmts,*_p) != NULL) {\n va_arg(ap,long long);\n goto fmt_valid;\n }\n goto fmt_invalid;\n }\n\n /* Size: long */\n if (_p[0] == 'l') {\n _p += 1;\n if (*_p != '\\0' && strchr(intfmts,*_p) != NULL) {\n va_arg(ap,long);\n goto fmt_valid;\n }\n goto fmt_invalid;\n }\n\n fmt_invalid:\n va_end(_cpy);\n goto format_err;\n\n fmt_valid:\n _l = (_p+1)-c;\n if (_l < sizeof(_format)-2) {\n memcpy(_format,c,_l);\n _format[_l] = '\\0';\n newarg = hi_sdscatvprintf(curarg,_format,_cpy);\n\n /* Update current position (note: outer blocks\n * increment c twice so compensate here) */\n c = _p-1;\n }\n\n va_end(_cpy);\n break;\n }\n }\n\n if (newarg == NULL) goto memory_err;\n curarg = newarg;\n\n touched = 1;\n c++;\n if (*c == '\\0')\n break;\n }\n c++;\n }\n\n /* Add the last argument if needed */\n if (touched) {\n newargv = hi_realloc(curargv,sizeof(char*)*(argc+1));\n if (newargv == NULL) goto memory_err;\n curargv = newargv;\n curargv[argc++] = curarg;\n totlen += bulklen(hi_sdslen(curarg));\n } else {\n hi_sdsfree(curarg);\n }\n\n /* Clear curarg because it was put in curargv or was free'd. */\n curarg = NULL;\n\n /* Add bytes needed to hold multi bulk count */\n totlen += 1+countDigits(argc)+2;\n\n /* Build the command at protocol level */\n cmd = hi_malloc(totlen+1);\n if (cmd == NULL) goto memory_err;\n\n pos = sprintf(cmd,\"*%d\\r\\n\",argc);\n for (j = 0; j < argc; j++) {\n pos += sprintf(cmd+pos,\"$%zu\\r\\n\",hi_sdslen(curargv[j]));\n memcpy(cmd+pos,curargv[j],hi_sdslen(curargv[j]));\n pos += hi_sdslen(curargv[j]);\n hi_sdsfree(curargv[j]);\n cmd[pos++] = '\\r';\n cmd[pos++] = '\\n';\n }\n assert(pos == totlen);\n cmd[pos] = '\\0';\n\n hi_free(curargv);\n *target = cmd;\n return totlen;\n\nformat_err:\n error_type = -2;\n goto cleanup;\n\nmemory_err:\n error_type = -1;\n goto cleanup;\n\ncleanup:\n if (curargv) {\n while(argc--)\n hi_sdsfree(curargv[argc]);\n hi_free(curargv);\n }\n\n hi_sdsfree(curarg);\n hi_free(cmd);\n\n return error_type;\n}\n\n/* Format a command according to the Redis protocol. This function\n * takes a format similar to printf:\n *\n * %s represents a C null terminated string you want to interpolate\n * %b represents a binary safe string\n *\n * When using %b you need to provide both the pointer to the string\n * and the length in bytes as a size_t. Examples:\n *\n * len = redisFormatCommand(target, \"GET %s\", mykey);\n * len = redisFormatCommand(target, \"SET %s %b\", mykey, myval, myvallen);\n */\nint redisFormatCommand(char **target, const char *format, ...) {\n va_list ap;\n int len;\n va_start(ap,format);\n len = redisvFormatCommand(target,format,ap);\n va_end(ap);\n\n /* The API says \"-1\" means bad result, but we now also return \"-2\" in some\n * cases. Force the return value to always be -1. */\n if (len < 0)\n len = -1;\n\n return len;\n}\n\n/* Format a command according to the Redis protocol using an hisds string and\n * hi_sdscatfmt for the processing of arguments. This function takes the\n * number of arguments, an array with arguments and an array with their\n * lengths. If the latter is set to NULL, strlen will be used to compute the\n * argument lengths.\n */\nlong long redisFormatSdsCommandArgv(hisds *target, int argc, const char **argv,\n const size_t *argvlen)\n{\n hisds cmd, aux;\n unsigned long long totlen, len;\n int j;\n\n /* Abort on a NULL target */\n if (target == NULL)\n return -1;\n\n /* Calculate our total size */\n totlen = 1+countDigits(argc)+2;\n for (j = 0; j < argc; j++) {\n len = argvlen ? argvlen[j] : strlen(argv[j]);\n totlen += bulklen(len);\n }\n\n /* Use an SDS string for command construction */\n cmd = hi_sdsempty();\n if (cmd == NULL)\n return -1;\n\n /* We already know how much storage we need */\n aux = hi_sdsMakeRoomFor(cmd, totlen);\n if (aux == NULL) {\n hi_sdsfree(cmd);\n return -1;\n }\n\n cmd = aux;\n\n /* Construct command */\n cmd = hi_sdscatfmt(cmd, \"*%i\\r\\n\", argc);\n for (j=0; j < argc; j++) {\n len = argvlen ? argvlen[j] : strlen(argv[j]);\n cmd = hi_sdscatfmt(cmd, \"$%U\\r\\n\", len);\n cmd = hi_sdscatlen(cmd, argv[j], len);\n cmd = hi_sdscatlen(cmd, \"\\r\\n\", sizeof(\"\\r\\n\")-1);\n }\n\n assert(hi_sdslen(cmd)==totlen);\n\n *target = cmd;\n return totlen;\n}\n\nvoid redisFreeSdsCommand(hisds cmd) {\n hi_sdsfree(cmd);\n}\n\n/* Format a command according to the Redis protocol. This function takes the\n * number of arguments, an array with arguments and an array with their\n * lengths. If the latter is set to NULL, strlen will be used to compute the\n * argument lengths.\n */\nlong long redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen) {\n char *cmd = NULL; /* final command */\n size_t pos; /* position in final command */\n size_t len, totlen;\n int j;\n\n /* Abort on a NULL target */\n if (target == NULL)\n return -1;\n\n /* Calculate number of bytes needed for the command */\n totlen = 1+countDigits(argc)+2;\n for (j = 0; j < argc; j++) {\n len = argvlen ? argvlen[j] : strlen(argv[j]);\n totlen += bulklen(len);\n }\n\n /* Build the command at protocol level */\n cmd = hi_malloc(totlen+1);\n if (cmd == NULL)\n return -1;\n\n pos = sprintf(cmd,\"*%d\\r\\n\",argc);\n for (j = 0; j < argc; j++) {\n len = argvlen ? argvlen[j] : strlen(argv[j]);\n pos += sprintf(cmd+pos,\"$%zu\\r\\n\",len);\n memcpy(cmd+pos,argv[j],len);\n pos += len;\n cmd[pos++] = '\\r';\n cmd[pos++] = '\\n';\n }\n assert(pos == totlen);\n cmd[pos] = '\\0';\n\n *target = cmd;\n return totlen;\n}\n\nvoid redisFreeCommand(char *cmd) {\n hi_free(cmd);\n}\n\nvoid __redisSetError(redisContext *c, int type, const char *str) {\n size_t len;\n\n c->err = type;\n if (str != NULL) {\n len = strlen(str);\n len = len < (sizeof(c->errstr)-1) ? len : (sizeof(c->errstr)-1);\n memcpy(c->errstr,str,len);\n c->errstr[len] = '\\0';\n } else {\n /* Only REDIS_ERR_IO may lack a description! */\n assert(type == REDIS_ERR_IO);\n strerror_r(errno, c->errstr, sizeof(c->errstr));\n }\n}\n\nredisReader *redisReaderCreate(void) {\n return redisReaderCreateWithFunctions(&defaultFunctions);\n}\n\nstatic void redisPushAutoFree(void *privdata, void *reply) {\n (void)privdata;\n freeReplyObject(reply);\n}\n\nstatic redisContext *redisContextInit(void) {\n redisContext *c;\n\n c = hi_calloc(1, sizeof(*c));\n if (c == NULL)\n return NULL;\n\n c->funcs = &redisContextDefaultFuncs;\n\n c->obuf = hi_sdsempty();\n c->reader = redisReaderCreate();\n c->fd = REDIS_INVALID_FD;\n\n if (c->obuf == NULL || c->reader == NULL) {\n redisFree(c);\n return NULL;\n }\n\n return c;\n}\n\nvoid redisFree(redisContext *c) {\n if (c == NULL)\n return;\n\n if (c->funcs && c->funcs->close) {\n c->funcs->close(c);\n }\n\n hi_sdsfree(c->obuf);\n redisReaderFree(c->reader);\n hi_free(c->tcp.host);\n hi_free(c->tcp.source_addr);\n hi_free(c->unix_sock.path);\n hi_free(c->connect_timeout);\n hi_free(c->command_timeout);\n hi_free(c->saddr);\n\n if (c->privdata && c->free_privdata)\n c->free_privdata(c->privdata);\n\n if (c->funcs && c->funcs->free_privctx)\n c->funcs->free_privctx(c->privctx);\n\n memset(c, 0xff, sizeof(*c));\n hi_free(c);\n}\n\nredisFD redisFreeKeepFd(redisContext *c) {\n redisFD fd = c->fd;\n c->fd = REDIS_INVALID_FD;\n redisFree(c);\n return fd;\n}\n\nint redisReconnect(redisContext *c) {\n c->err = 0;\n memset(c->errstr, '\\0', strlen(c->errstr));\n\n if (c->privctx && c->funcs->free_privctx) {\n c->funcs->free_privctx(c->privctx);\n c->privctx = NULL;\n }\n\n if (c->funcs && c->funcs->close) {\n c->funcs->close(c);\n }\n\n hi_sdsfree(c->obuf);\n redisReaderFree(c->reader);\n\n c->obuf = hi_sdsempty();\n c->reader = redisReaderCreate();\n\n if (c->obuf == NULL || c->reader == NULL) {\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return REDIS_ERR;\n }\n\n int ret = REDIS_ERR;\n if (c->connection_type == REDIS_CONN_TCP) {\n ret = redisContextConnectBindTcp(c, c->tcp.host, c->tcp.port,\n c->connect_timeout, c->tcp.source_addr);\n } else if (c->connection_type == REDIS_CONN_UNIX) {\n ret = redisContextConnectUnix(c, c->unix_sock.path, c->connect_timeout);\n } else {\n /* Something bad happened here and shouldn't have. There isn't\n enough information in the context to reconnect. */\n __redisSetError(c,REDIS_ERR_OTHER,\"Not enough information to reconnect\");\n ret = REDIS_ERR;\n }\n\n if (c->command_timeout != NULL && (c->flags & REDIS_BLOCK) && c->fd != REDIS_INVALID_FD) {\n redisContextSetTimeout(c, *c->command_timeout);\n }\n\n return ret;\n}\n\nredisContext *redisConnectWithOptions(const redisOptions *options) {\n redisContext *c = redisContextInit();\n if (c == NULL) {\n return NULL;\n }\n if (!(options->options & REDIS_OPT_NONBLOCK)) {\n c->flags |= REDIS_BLOCK;\n }\n if (options->options & REDIS_OPT_REUSEADDR) {\n c->flags |= REDIS_REUSEADDR;\n }\n if (options->options & REDIS_OPT_NOAUTOFREE) {\n c->flags |= REDIS_NO_AUTO_FREE;\n }\n if (options->options & REDIS_OPT_NOAUTOFREEREPLIES) {\n c->flags |= REDIS_NO_AUTO_FREE_REPLIES;\n }\n if (options->options & REDIS_OPT_PREFER_IPV4) {\n c->flags |= REDIS_PREFER_IPV4;\n }\n if (options->options & REDIS_OPT_PREFER_IPV6) {\n c->flags |= REDIS_PREFER_IPV6;\n }\n\n /* Set any user supplied RESP3 PUSH handler or use freeReplyObject\n * as a default unless specifically flagged that we don't want one. */\n if (options->push_cb != NULL)\n redisSetPushCallback(c, options->push_cb);\n else if (!(options->options & REDIS_OPT_NO_PUSH_AUTOFREE))\n redisSetPushCallback(c, redisPushAutoFree);\n\n c->privdata = options->privdata;\n c->free_privdata = options->free_privdata;\n\n if (redisContextUpdateConnectTimeout(c, options->connect_timeout) != REDIS_OK ||\n redisContextUpdateCommandTimeout(c, options->command_timeout) != REDIS_OK) {\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return c;\n }\n\n if (options->type == REDIS_CONN_TCP) {\n redisContextConnectBindTcp(c, options->endpoint.tcp.ip,\n options->endpoint.tcp.port, options->connect_timeout,\n options->endpoint.tcp.source_addr);\n } else if (options->type == REDIS_CONN_UNIX) {\n redisContextConnectUnix(c, options->endpoint.unix_socket,\n options->connect_timeout);\n } else if (options->type == REDIS_CONN_USERFD) {\n c->fd = options->endpoint.fd;\n c->flags |= REDIS_CONNECTED;\n } else {\n redisFree(c);\n return NULL;\n }\n\n if (c->err == 0 && c->fd != REDIS_INVALID_FD &&\n options->command_timeout != NULL && (c->flags & REDIS_BLOCK))\n {\n redisContextSetTimeout(c, *options->command_timeout);\n }\n\n return c;\n}\n\n/* Connect to a Redis instance. On error the field error in the returned\n * context will be set to the return value of the error function.\n * When no set of reply functions is given, the default set will be used. */\nredisContext *redisConnect(const char *ip, int port) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.connect_timeout = &tv;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectNonBlock(const char *ip, int port) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.options |= REDIS_OPT_NONBLOCK;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectBindNonBlock(const char *ip, int port,\n const char *source_addr) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.endpoint.tcp.source_addr = source_addr;\n options.options |= REDIS_OPT_NONBLOCK;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,\n const char *source_addr) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, ip, port);\n options.endpoint.tcp.source_addr = source_addr;\n options.options |= REDIS_OPT_NONBLOCK|REDIS_OPT_REUSEADDR;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectUnix(const char *path) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_UNIX(&options, path);\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_UNIX(&options, path);\n options.connect_timeout = &tv;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectUnixNonBlock(const char *path) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_UNIX(&options, path);\n options.options |= REDIS_OPT_NONBLOCK;\n return redisConnectWithOptions(&options);\n}\n\nredisContext *redisConnectFd(redisFD fd) {\n redisOptions options = {0};\n options.type = REDIS_CONN_USERFD;\n options.endpoint.fd = fd;\n return redisConnectWithOptions(&options);\n}\n\n/* Set read/write timeout on a blocking socket. */\nint redisSetTimeout(redisContext *c, const struct timeval tv) {\n if (c->flags & REDIS_BLOCK)\n return redisContextSetTimeout(c,tv);\n return REDIS_ERR;\n}\n\nint redisEnableKeepAliveWithInterval(redisContext *c, int interval) {\n return redisKeepAlive(c, interval);\n}\n\n/* Enable connection KeepAlive. */\nint redisEnableKeepAlive(redisContext *c) {\n return redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL);\n}\n\n/* Set the socket option TCP_USER_TIMEOUT. */\nint redisSetTcpUserTimeout(redisContext *c, unsigned int timeout) {\n return redisContextSetTcpUserTimeout(c, timeout);\n}\n\n/* Set a user provided RESP3 PUSH handler and return any old one set. */\nredisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) {\n redisPushFn *old = c->push_cb;\n c->push_cb = fn;\n return old;\n}\n\n/* Use this function to handle a read event on the descriptor. It will try\n * and read some bytes from the socket and feed them to the reply parser.\n *\n * After this function is called, you may use redisGetReplyFromReader to\n * see if there is a reply available. */\nint redisBufferRead(redisContext *c) {\n char buf[1024*16];\n int nread;\n\n /* Return early when the context has seen an error. */\n if (c->err)\n return REDIS_ERR;\n\n nread = c->funcs->read(c, buf, sizeof(buf));\n if (nread < 0) {\n return REDIS_ERR;\n }\n if (nread > 0 && redisReaderFeed(c->reader, buf, nread) != REDIS_OK) {\n __redisSetError(c, c->reader->err, c->reader->errstr);\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\n/* Write the output buffer to the socket.\n *\n * Returns REDIS_OK when the buffer is empty, or (a part of) the buffer was\n * successfully written to the socket. When the buffer is empty after the\n * write operation, \"done\" is set to 1 (if given).\n *\n * Returns REDIS_ERR if an unrecoverable error occurred in the underlying\n * c->funcs->write function.\n */\nint redisBufferWrite(redisContext *c, int *done) {\n\n /* Return early when the context has seen an error. */\n if (c->err)\n return REDIS_ERR;\n\n if (hi_sdslen(c->obuf) > 0) {\n ssize_t nwritten = c->funcs->write(c);\n if (nwritten < 0) {\n return REDIS_ERR;\n } else if (nwritten > 0) {\n if (nwritten == (ssize_t)hi_sdslen(c->obuf)) {\n hi_sdsfree(c->obuf);\n c->obuf = hi_sdsempty();\n if (c->obuf == NULL)\n goto oom;\n } else {\n if (hi_sdsrange(c->obuf,nwritten,-1) < 0) goto oom;\n }\n }\n }\n if (done != NULL) *done = (hi_sdslen(c->obuf) == 0);\n return REDIS_OK;\n\noom:\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return REDIS_ERR;\n}\n\n/* Internal helper that returns 1 if the reply was a RESP3 PUSH\n * message and we handled it with a user-provided callback. */\nstatic int redisHandledPushReply(redisContext *c, void *reply) {\n if (reply && c->push_cb && redisIsPushReply(reply)) {\n c->push_cb(c->privdata, reply);\n return 1;\n }\n\n return 0;\n}\n\n/* Get a reply from our reader or set an error in the context. */\nint redisGetReplyFromReader(redisContext *c, void **reply) {\n if (redisReaderGetReply(c->reader, reply) == REDIS_ERR) {\n __redisSetError(c,c->reader->err,c->reader->errstr);\n return REDIS_ERR;\n }\n\n return REDIS_OK;\n}\n\n/* Internal helper to get the next reply from our reader while handling\n * any PUSH messages we encounter along the way. This is separate from\n * redisGetReplyFromReader so as to not change its behavior. */\nstatic int redisNextInBandReplyFromReader(redisContext *c, void **reply) {\n do {\n if (redisGetReplyFromReader(c, reply) == REDIS_ERR)\n return REDIS_ERR;\n } while (redisHandledPushReply(c, *reply));\n\n return REDIS_OK;\n}\n\nint redisGetReply(redisContext *c, void **reply) {\n int wdone = 0;\n void *aux = NULL;\n\n /* Try to read pending replies */\n if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR)\n return REDIS_ERR;\n\n /* For the blocking context, flush output buffer and read reply */\n if (aux == NULL && c->flags & REDIS_BLOCK) {\n /* Write until done */\n do {\n if (redisBufferWrite(c,&wdone) == REDIS_ERR)\n return REDIS_ERR;\n } while (!wdone);\n\n /* Read until there is a reply */\n do {\n if (redisBufferRead(c) == REDIS_ERR)\n return REDIS_ERR;\n\n if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR)\n return REDIS_ERR;\n } while (aux == NULL);\n }\n\n /* Set reply or free it if we were passed NULL */\n if (reply != NULL) {\n *reply = aux;\n } else {\n freeReplyObject(aux);\n }\n\n return REDIS_OK;\n}\n\n\n/* Helper function for the redisAppendCommand* family of functions.\n *\n * Write a formatted command to the output buffer. When this family\n * is used, you need to call redisGetReply yourself to retrieve\n * the reply (or replies in pub/sub).\n */\nint __redisAppendCommand(redisContext *c, const char *cmd, size_t len) {\n hisds newbuf;\n\n newbuf = hi_sdscatlen(c->obuf,cmd,len);\n if (newbuf == NULL) {\n __redisSetError(c,REDIS_ERR_OOM,\"Out of memory\");\n return REDIS_ERR;\n }\n\n c->obuf = newbuf;\n return REDIS_OK;\n}\n\nint redisAppendFormattedCommand(redisContext *c, const char *cmd, size_t len) {\n\n if (__redisAppendCommand(c, cmd, len) != REDIS_OK) {\n return REDIS_ERR;\n }\n\n return REDIS_OK;\n}\n\nint redisvAppendCommand(redisContext *c, const char *format, va_list ap) {\n char *cmd;\n int len;\n\n len = redisvFormatCommand(&cmd,format,ap);\n if (len == -1) {\n __redisSetError(c,REDIS_ERR_OOM,\"Out of memory\");\n return REDIS_ERR;\n } else if (len == -2) {\n __redisSetError(c,REDIS_ERR_OTHER,\"Invalid format string\");\n return REDIS_ERR;\n }\n\n if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {\n hi_free(cmd);\n return REDIS_ERR;\n }\n\n hi_free(cmd);\n return REDIS_OK;\n}\n\nint redisAppendCommand(redisContext *c, const char *format, ...) {\n va_list ap;\n int ret;\n\n va_start(ap,format);\n ret = redisvAppendCommand(c,format,ap);\n va_end(ap);\n return ret;\n}\n\nint redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) {\n hisds cmd;\n long long len;\n\n len = redisFormatSdsCommandArgv(&cmd,argc,argv,argvlen);\n if (len == -1) {\n __redisSetError(c,REDIS_ERR_OOM,\"Out of memory\");\n return REDIS_ERR;\n }\n\n if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {\n hi_sdsfree(cmd);\n return REDIS_ERR;\n }\n\n hi_sdsfree(cmd);\n return REDIS_OK;\n}\n\n/* Helper function for the redisCommand* family of functions.\n *\n * Write a formatted command to the output buffer. If the given context is\n * blocking, immediately read the reply into the \"reply\" pointer. When the\n * context is non-blocking, the \"reply\" pointer will not be used and the\n * command is simply appended to the write buffer.\n *\n * Returns the reply when a reply was successfully retrieved. Returns NULL\n * otherwise. When NULL is returned in a blocking context, the error field\n * in the context will be set.\n */\nstatic void *__redisBlockForReply(redisContext *c) {\n void *reply;\n\n if (c->flags & REDIS_BLOCK) {\n if (redisGetReply(c,&reply) != REDIS_OK)\n return NULL;\n return reply;\n }\n return NULL;\n}\n\nvoid *redisvCommand(redisContext *c, const char *format, va_list ap) {\n if (redisvAppendCommand(c,format,ap) != REDIS_OK)\n return NULL;\n return __redisBlockForReply(c);\n}\n\nvoid *redisCommand(redisContext *c, const char *format, ...) {\n va_list ap;\n va_start(ap,format);\n void *reply = redisvCommand(c,format,ap);\n va_end(ap);\n return reply;\n}\n\nvoid *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) {\n if (redisAppendCommandArgv(c,argc,argv,argvlen) != REDIS_OK)\n return NULL;\n return __redisBlockForReply(c);\n}\n" }, { "path": "deps/hiredis/hiredis.h", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2014, Pieter Noordhuis \n * Copyright (c) 2015, Matt Stancliff ,\n * Jan-Erik Rediger \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_H\n#define __HIREDIS_H\n#include \"read.h\"\n#include /* for va_list */\n#ifndef _MSC_VER\n#include /* for struct timeval */\n#else\nstruct timeval; /* forward declaration */\ntypedef long long ssize_t;\n#endif\n#include /* uintXX_t, etc */\n#include \"sds.h\" /* for hisds */\n#include \"alloc.h\" /* for allocation wrappers */\n\n#define HIREDIS_MAJOR 1\n#define HIREDIS_MINOR 2\n#define HIREDIS_PATCH 0\n#define HIREDIS_SONAME 1.1.0\n\n/* Connection type can be blocking or non-blocking and is set in the\n * least significant bit of the flags field in redisContext. */\n#define REDIS_BLOCK 0x1\n\n/* Connection may be disconnected before being free'd. The second bit\n * in the flags field is set when the context is connected. */\n#define REDIS_CONNECTED 0x2\n\n/* The async API might try to disconnect cleanly and flush the output\n * buffer and read all subsequent replies before disconnecting.\n * This flag means no new commands can come in and the connection\n * should be terminated once all replies have been read. */\n#define REDIS_DISCONNECTING 0x4\n\n/* Flag specific to the async API which means that the context should be clean\n * up as soon as possible. */\n#define REDIS_FREEING 0x8\n\n/* Flag that is set when an async callback is executed. */\n#define REDIS_IN_CALLBACK 0x10\n\n/* Flag that is set when the async context has one or more subscriptions. */\n#define REDIS_SUBSCRIBED 0x20\n\n/* Flag that is set when monitor mode is active */\n#define REDIS_MONITORING 0x40\n\n/* Flag that is set when we should set SO_REUSEADDR before calling bind() */\n#define REDIS_REUSEADDR 0x80\n\n/* Flag that is set when the async connection supports push replies. */\n#define REDIS_SUPPORTS_PUSH 0x100\n\n/**\n * Flag that indicates the user does not want the context to\n * be automatically freed upon error\n */\n#define REDIS_NO_AUTO_FREE 0x200\n\n/* Flag that indicates the user does not want replies to be automatically freed */\n#define REDIS_NO_AUTO_FREE_REPLIES 0x400\n\n/* Flags to prefer IPv6 or IPv4 when doing DNS lookup. (If both are set,\n * AF_UNSPEC is used.) */\n#define REDIS_PREFER_IPV4 0x800\n#define REDIS_PREFER_IPV6 0x1000\n\n#define REDIS_KEEPALIVE_INTERVAL 15 /* seconds */\n\n/* number of times we retry to connect in the case of EADDRNOTAVAIL and\n * SO_REUSEADDR is being used. */\n#define REDIS_CONNECT_RETRIES 10\n\n/* Forward declarations for structs defined elsewhere */\nstruct redisAsyncContext;\nstruct redisContext;\n\n/* RESP3 push helpers and callback prototypes */\n#define redisIsPushReply(r) (((redisReply*)(r))->type == REDIS_REPLY_PUSH)\ntypedef void (redisPushFn)(void *, void *);\ntypedef void (redisAsyncPushFn)(struct redisAsyncContext *, void *);\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* This is the reply object returned by redisCommand() */\ntypedef struct redisReply {\n int type; /* REDIS_REPLY_* */\n long long integer; /* The integer when type is REDIS_REPLY_INTEGER */\n double dval; /* The double when type is REDIS_REPLY_DOUBLE */\n size_t len; /* Length of string */\n char *str; /* Used for REDIS_REPLY_ERROR, REDIS_REPLY_STRING\n REDIS_REPLY_VERB, REDIS_REPLY_DOUBLE (in additional to dval),\n and REDIS_REPLY_BIGNUM. */\n char vtype[4]; /* Used for REDIS_REPLY_VERB, contains the null\n terminated 3 character content type, such as \"txt\". */\n size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */\n struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */\n} redisReply;\n\nredisReader *redisReaderCreate(void);\n\n/* Function to free the reply objects hiredis returns by default. */\nvoid freeReplyObject(void *reply);\n\n/* Functions to format a command according to the protocol. */\nint redisvFormatCommand(char **target, const char *format, va_list ap);\nint redisFormatCommand(char **target, const char *format, ...);\nlong long redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen);\nlong long redisFormatSdsCommandArgv(hisds *target, int argc, const char ** argv, const size_t *argvlen);\nvoid redisFreeCommand(char *cmd);\nvoid redisFreeSdsCommand(hisds cmd);\n\nenum redisConnectionType {\n REDIS_CONN_TCP,\n REDIS_CONN_UNIX,\n REDIS_CONN_USERFD\n};\n\nstruct redisSsl;\n\n#define REDIS_OPT_NONBLOCK 0x01\n#define REDIS_OPT_REUSEADDR 0x02\n#define REDIS_OPT_NOAUTOFREE 0x04 /* Don't automatically free the async\n * object on a connection failure, or\n * other implicit conditions. Only free\n * on an explicit call to disconnect()\n * or free() */\n#define REDIS_OPT_NO_PUSH_AUTOFREE 0x08 /* Don't automatically intercept and\n * free RESP3 PUSH replies. */\n#define REDIS_OPT_NOAUTOFREEREPLIES 0x10 /* Don't automatically free replies. */\n#define REDIS_OPT_PREFER_IPV4 0x20 /* Prefer IPv4 in DNS lookups. */\n#define REDIS_OPT_PREFER_IPV6 0x40 /* Prefer IPv6 in DNS lookups. */\n#define REDIS_OPT_PREFER_IP_UNSPEC (REDIS_OPT_PREFER_IPV4 | REDIS_OPT_PREFER_IPV6)\n\n/* In Unix systems a file descriptor is a regular signed int, with -1\n * representing an invalid descriptor. In Windows it is a SOCKET\n * (32- or 64-bit unsigned integer depending on the architecture), where\n * all bits set (~0) is INVALID_SOCKET. */\n#ifndef _WIN32\ntypedef int redisFD;\n#define REDIS_INVALID_FD -1\n#else\n#ifdef _WIN64\ntypedef unsigned long long redisFD; /* SOCKET = 64-bit UINT_PTR */\n#else\ntypedef unsigned long redisFD; /* SOCKET = 32-bit UINT_PTR */\n#endif\n#define REDIS_INVALID_FD ((redisFD)(~0)) /* INVALID_SOCKET */\n#endif\n\ntypedef struct {\n /*\n * the type of connection to use. This also indicates which\n * `endpoint` member field to use\n */\n int type;\n /* bit field of REDIS_OPT_xxx */\n int options;\n /* timeout value for connect operation. If NULL, no timeout is used */\n const struct timeval *connect_timeout;\n /* timeout value for commands. If NULL, no timeout is used. This can be\n * updated at runtime with redisSetTimeout/redisAsyncSetTimeout. */\n const struct timeval *command_timeout;\n union {\n /** use this field for tcp/ip connections */\n struct {\n const char *source_addr;\n const char *ip;\n int port;\n } tcp;\n /** use this field for unix domain sockets */\n const char *unix_socket;\n /**\n * use this field to have hiredis operate an already-open\n * file descriptor */\n redisFD fd;\n } endpoint;\n\n /* Optional user defined data/destructor */\n void *privdata;\n void (*free_privdata)(void *);\n\n /* A user defined PUSH message callback */\n redisPushFn *push_cb;\n redisAsyncPushFn *async_push_cb;\n} redisOptions;\n\n/**\n * Helper macros to initialize options to their specified fields.\n */\n#define REDIS_OPTIONS_SET_TCP(opts, ip_, port_) do { \\\n (opts)->type = REDIS_CONN_TCP; \\\n (opts)->endpoint.tcp.ip = ip_; \\\n (opts)->endpoint.tcp.port = port_; \\\n } while(0)\n\n#define REDIS_OPTIONS_SET_UNIX(opts, path) do { \\\n (opts)->type = REDIS_CONN_UNIX; \\\n (opts)->endpoint.unix_socket = path; \\\n } while(0)\n\n#define REDIS_OPTIONS_SET_PRIVDATA(opts, data, dtor) do { \\\n (opts)->privdata = data; \\\n (opts)->free_privdata = dtor; \\\n } while(0)\n\ntypedef struct redisContextFuncs {\n void (*close)(struct redisContext *);\n void (*free_privctx)(void *);\n void (*async_read)(struct redisAsyncContext *);\n void (*async_write)(struct redisAsyncContext *);\n\n /* Read/Write data to the underlying communication stream, returning the\n * number of bytes read/written. In the event of an unrecoverable error\n * these functions shall return a value < 0. In the event of a\n * recoverable error, they should return 0. */\n ssize_t (*read)(struct redisContext *, char *, size_t);\n ssize_t (*write)(struct redisContext *);\n} redisContextFuncs;\n\n\n/* Context for a connection to Redis */\ntypedef struct redisContext {\n const redisContextFuncs *funcs; /* Function table */\n\n int err; /* Error flags, 0 when there is no error */\n char errstr[128]; /* String representation of error when applicable */\n redisFD fd;\n int flags;\n char *obuf; /* Write buffer */\n redisReader *reader; /* Protocol reader */\n\n enum redisConnectionType connection_type;\n struct timeval *connect_timeout;\n struct timeval *command_timeout;\n\n struct {\n char *host;\n char *source_addr;\n int port;\n } tcp;\n\n struct {\n char *path;\n } unix_sock;\n\n /* For non-blocking connect */\n struct sockaddr *saddr;\n size_t addrlen;\n\n /* Optional data and corresponding destructor users can use to provide\n * context to a given redisContext. Not used by hiredis. */\n void *privdata;\n void (*free_privdata)(void *);\n\n /* Internal context pointer presently used by hiredis to manage\n * SSL connections. */\n void *privctx;\n\n /* An optional RESP3 PUSH handler */\n redisPushFn *push_cb;\n} redisContext;\n\nredisContext *redisConnectWithOptions(const redisOptions *options);\nredisContext *redisConnect(const char *ip, int port);\nredisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv);\nredisContext *redisConnectNonBlock(const char *ip, int port);\nredisContext *redisConnectBindNonBlock(const char *ip, int port,\n const char *source_addr);\nredisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,\n const char *source_addr);\nredisContext *redisConnectUnix(const char *path);\nredisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv);\nredisContext *redisConnectUnixNonBlock(const char *path);\nredisContext *redisConnectFd(redisFD fd);\n\n/**\n * Reconnect the given context using the saved information.\n *\n * This re-uses the exact same connect options as in the initial connection.\n * host, ip (or path), timeout and bind address are reused,\n * flags are used unmodified from the existing context.\n *\n * Returns REDIS_OK on successful connect or REDIS_ERR otherwise.\n */\nint redisReconnect(redisContext *c);\n\nredisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn);\nint redisSetTimeout(redisContext *c, const struct timeval tv);\nint redisEnableKeepAlive(redisContext *c);\nint redisEnableKeepAliveWithInterval(redisContext *c, int interval);\nint redisSetTcpUserTimeout(redisContext *c, unsigned int timeout);\nvoid redisFree(redisContext *c);\nredisFD redisFreeKeepFd(redisContext *c);\nint redisBufferRead(redisContext *c);\nint redisBufferWrite(redisContext *c, int *done);\n\n/* In a blocking context, this function first checks if there are unconsumed\n * replies to return and returns one if so. Otherwise, it flushes the output\n * buffer to the socket and reads until it has a reply. In a non-blocking\n * context, it will return unconsumed replies until there are no more. */\nint redisGetReply(redisContext *c, void **reply);\nint redisGetReplyFromReader(redisContext *c, void **reply);\n\n/* Write a formatted command to the output buffer. Use these functions in blocking mode\n * to get a pipeline of commands. */\nint redisAppendFormattedCommand(redisContext *c, const char *cmd, size_t len);\n\n/* Write a command to the output buffer. Use these functions in blocking mode\n * to get a pipeline of commands. */\nint redisvAppendCommand(redisContext *c, const char *format, va_list ap);\nint redisAppendCommand(redisContext *c, const char *format, ...);\nint redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);\n\n/* Issue a command to Redis. In a blocking context, it is identical to calling\n * redisAppendCommand, followed by redisGetReply. The function will return\n * NULL if there was an error in performing the request, otherwise it will\n * return the reply. In a non-blocking context, it is identical to calling\n * only redisAppendCommand and will always return NULL. */\nvoid *redisvCommand(redisContext *c, const char *format, va_list ap);\nvoid *redisCommand(redisContext *c, const char *format, ...);\nvoid *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n" }, { "path": "deps/hiredis/hiredis.pc.in", "content": "prefix=@CMAKE_INSTALL_PREFIX@\ninstall_libdir=@CMAKE_INSTALL_LIBDIR@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/${install_libdir}\nincludedir=${prefix}/include\npkgincludedir=${includedir}/hiredis\n\nName: hiredis\nDescription: Minimalistic C client library for Redis.\nVersion: @PROJECT_VERSION@\nLibs: -L${libdir} -lhiredis\nCflags: -I${pkgincludedir} -I${includedir} -D_FILE_OFFSET_BITS=64\n" }, { "path": "deps/hiredis/hiredis.targets", "content": "\n\n \n \n $(MSBuildThisFileDirectory)\\..\\..\\include;%(AdditionalIncludeDirectories)\n \n \n $(MSBuildThisFileDirectory)\\..\\..\\lib;%(AdditionalLibraryDirectories)\n \n \n" }, { "path": "deps/hiredis/hiredis_ssl-config.cmake.in", "content": "@PACKAGE_INIT@\n\nset_and_check(hiredis_ssl_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\ninclude(CMakeFindDependencyMacro)\nfind_dependency(OpenSSL)\n\nIF (NOT TARGET hiredis::hiredis_ssl)\n\tINCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis_ssl-targets.cmake)\nENDIF()\n\nSET(hiredis_ssl_LIBRARIES hiredis::hiredis_ssl)\nSET(hiredis_ssl_INCLUDE_DIRS ${hiredis_ssl_INCLUDEDIR})\n\ncheck_required_components(hiredis_ssl)\n\n" }, { "path": "deps/hiredis/hiredis_ssl.h", "content": "\n/*\n * Copyright (c) 2019, Redis Labs\n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __HIREDIS_SSL_H\n#define __HIREDIS_SSL_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* This is the underlying struct for SSL in ssl.h, which is not included to\n * keep build dependencies short here.\n */\nstruct ssl_st;\n\n/* A wrapper around OpenSSL SSL_CTX to allow easy SSL use without directly\n * calling OpenSSL.\n */\ntypedef struct redisSSLContext redisSSLContext;\n\n/**\n * Initialization errors that redisCreateSSLContext() may return.\n */\n\ntypedef enum {\n REDIS_SSL_CTX_NONE = 0, /* No Error */\n REDIS_SSL_CTX_CREATE_FAILED, /* Failed to create OpenSSL SSL_CTX */\n REDIS_SSL_CTX_CERT_KEY_REQUIRED, /* Client cert and key must both be specified or skipped */\n REDIS_SSL_CTX_CA_CERT_LOAD_FAILED, /* Failed to load CA Certificate or CA Path */\n REDIS_SSL_CTX_CLIENT_CERT_LOAD_FAILED, /* Failed to load client certificate */\n REDIS_SSL_CTX_CLIENT_DEFAULT_CERT_FAILED, /* Failed to set client default certificate directory */\n REDIS_SSL_CTX_PRIVATE_KEY_LOAD_FAILED, /* Failed to load private key */\n REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED, /* Failed to open system certificate store */\n REDIS_SSL_CTX_OS_CERT_ADD_FAILED /* Failed to add CA certificates obtained from system to the SSL context */\n} redisSSLContextError;\n\n/* Constants that mirror OpenSSL's verify modes. By default,\n * REDIS_SSL_VERIFY_PEER is used with redisCreateSSLContext().\n * Some Redis clients disable peer verification if there are no\n * certificates specified.\n */\n#define REDIS_SSL_VERIFY_NONE 0x00\n#define REDIS_SSL_VERIFY_PEER 0x01\n#define REDIS_SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02\n#define REDIS_SSL_VERIFY_CLIENT_ONCE 0x04\n#define REDIS_SSL_VERIFY_POST_HANDSHAKE 0x08\n\n/* Options to create an OpenSSL context. */\ntypedef struct {\n const char *cacert_filename;\n const char *capath;\n const char *cert_filename;\n const char *private_key_filename;\n const char *server_name;\n int verify_mode;\n} redisSSLOptions;\n\n/**\n * Return the error message corresponding with the specified error code.\n */\n\nconst char *redisSSLContextGetError(redisSSLContextError error);\n\n/**\n * Helper function to initialize the OpenSSL library.\n *\n * OpenSSL requires one-time initialization before it can be used. Callers should\n * call this function only once, and only if OpenSSL is not directly initialized\n * elsewhere.\n */\nint redisInitOpenSSL(void);\n\n/**\n * Helper function to initialize an OpenSSL context that can be used\n * to initiate SSL connections.\n *\n * cacert_filename is an optional name of a CA certificate/bundle file to load\n * and use for validation.\n *\n * capath is an optional directory path where trusted CA certificate files are\n * stored in an OpenSSL-compatible structure.\n *\n * cert_filename and private_key_filename are optional names of a client side\n * certificate and private key files to use for authentication. They need to\n * be both specified or omitted.\n *\n * server_name is an optional and will be used as a server name indication\n * (SNI) TLS extension.\n *\n * If error is non-null, it will be populated in case the context creation fails\n * (returning a NULL).\n */\n\nredisSSLContext *redisCreateSSLContext(const char *cacert_filename, const char *capath,\n const char *cert_filename, const char *private_key_filename,\n const char *server_name, redisSSLContextError *error);\n\n/**\n * Helper function to initialize an OpenSSL context that can be used\n * to initiate SSL connections. This is a more extensible version of redisCreateSSLContext().\n *\n * options contains a structure of SSL options to use.\n *\n * If error is non-null, it will be populated in case the context creation fails\n * (returning a NULL).\n*/\nredisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *options,\n redisSSLContextError *error);\n\n/**\n * Free a previously created OpenSSL context.\n */\nvoid redisFreeSSLContext(redisSSLContext *redis_ssl_ctx);\n\n/**\n * Initiate SSL on an existing redisContext.\n *\n * This is similar to redisInitiateSSL() but does not require the caller\n * to directly interact with OpenSSL, and instead uses a redisSSLContext\n * previously created using redisCreateSSLContext().\n */\n\nint redisInitiateSSLWithContext(redisContext *c, redisSSLContext *redis_ssl_ctx);\n\n/**\n * Initiate SSL/TLS negotiation on a provided OpenSSL SSL object.\n */\n\nint redisInitiateSSL(redisContext *c, struct ssl_st *ssl);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __HIREDIS_SSL_H */\n" }, { "path": "deps/hiredis/hiredis_ssl.pc.in", "content": "prefix=@CMAKE_INSTALL_PREFIX@\ninstall_libdir=@CMAKE_INSTALL_LIBDIR@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/${install_libdir}\nincludedir=${prefix}/include\npkgincludedir=${includedir}/hiredis\n\nName: hiredis_ssl\nDescription: SSL Support for hiredis.\nVersion: @PROJECT_VERSION@\nRequires: hiredis\nLibs: -L${libdir} -lhiredis_ssl\nLibs.private: -lssl -lcrypto\n" }, { "path": "deps/hiredis/net.c", "content": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2014, Pieter Noordhuis \n * Copyright (c) 2015, Matt Stancliff ,\n * Jan-Erik Rediger \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"net.h\"\n#include \"sds.h\"\n#include \"sockcompat.h\"\n#include \"win32.h\"\n\n/* Defined in hiredis.c */\nvoid __redisSetError(redisContext *c, int type, const char *str);\n\nint redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout);\n\nvoid redisNetClose(redisContext *c) {\n if (c && c->fd != REDIS_INVALID_FD) {\n close(c->fd);\n c->fd = REDIS_INVALID_FD;\n }\n}\n\nssize_t redisNetRead(redisContext *c, char *buf, size_t bufcap) {\n ssize_t nread = recv(c->fd, buf, bufcap, 0);\n if (nread == -1) {\n if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {\n /* Try again later */\n return 0;\n } else if(errno == ETIMEDOUT && (c->flags & REDIS_BLOCK)) {\n /* especially in windows */\n __redisSetError(c, REDIS_ERR_TIMEOUT, \"recv timeout\");\n return -1;\n } else {\n __redisSetError(c, REDIS_ERR_IO, strerror(errno));\n return -1;\n }\n } else if (nread == 0) {\n __redisSetError(c, REDIS_ERR_EOF, \"Server closed the connection\");\n return -1;\n } else {\n return nread;\n }\n}\n\nssize_t redisNetWrite(redisContext *c) {\n ssize_t nwritten;\n\n nwritten = send(c->fd, c->obuf, hi_sdslen(c->obuf), 0);\n if (nwritten < 0) {\n if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {\n /* Try again */\n return 0;\n } else {\n __redisSetError(c, REDIS_ERR_IO, strerror(errno));\n return -1;\n }\n }\n\n return nwritten;\n}\n\nstatic void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {\n int errorno = errno; /* snprintf() may change errno */\n char buf[128] = { 0 };\n size_t len = 0;\n\n if (prefix != NULL)\n len = snprintf(buf,sizeof(buf),\"%s: \",prefix);\n strerror_r(errorno, (char *)(buf + len), sizeof(buf) - len);\n __redisSetError(c,type,buf);\n}\n\nstatic int redisSetReuseAddr(redisContext *c) {\n int on = 1;\n if (setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);\n redisNetClose(c);\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\nstatic int redisCreateSocket(redisContext *c, int type) {\n redisFD s;\n if ((s = socket(type, SOCK_STREAM, 0)) == REDIS_INVALID_FD) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);\n return REDIS_ERR;\n }\n c->fd = s;\n if (type == AF_INET) {\n if (redisSetReuseAddr(c) == REDIS_ERR) {\n return REDIS_ERR;\n }\n }\n return REDIS_OK;\n}\n\nstatic int redisSetBlocking(redisContext *c, int blocking) {\n#ifndef _WIN32\n int flags;\n\n /* Set the socket nonblocking.\n * Note that fcntl(2) for F_GETFL and F_SETFL can't be\n * interrupted by a signal. */\n if ((flags = fcntl(c->fd, F_GETFL)) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"fcntl(F_GETFL)\");\n redisNetClose(c);\n return REDIS_ERR;\n }\n\n if (blocking)\n flags &= ~O_NONBLOCK;\n else\n flags |= O_NONBLOCK;\n\n if (fcntl(c->fd, F_SETFL, flags) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"fcntl(F_SETFL)\");\n redisNetClose(c);\n return REDIS_ERR;\n }\n#else\n u_long mode = blocking ? 0 : 1;\n if (ioctl(c->fd, FIONBIO, &mode) == -1) {\n __redisSetErrorFromErrno(c, REDIS_ERR_IO, \"ioctl(FIONBIO)\");\n redisNetClose(c);\n return REDIS_ERR;\n }\n#endif /* _WIN32 */\n return REDIS_OK;\n}\n\nint redisKeepAlive(redisContext *c, int interval) {\n int val = 1;\n redisFD fd = c->fd;\n\n#ifndef _WIN32\n if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){\n __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));\n return REDIS_ERR;\n }\n\n val = interval;\n\n#if defined(__APPLE__) && defined(__MACH__)\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) {\n __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));\n return REDIS_ERR;\n }\n#else\n#if defined(__GLIBC__) && !defined(__FreeBSD_kernel__)\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {\n __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));\n return REDIS_ERR;\n }\n\n val = interval/3;\n if (val == 0) val = 1;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {\n __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));\n return REDIS_ERR;\n }\n\n val = 3;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {\n __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));\n return REDIS_ERR;\n }\n#endif\n#endif\n#else\n int res;\n\n res = win32_redisKeepAlive(fd, interval * 1000);\n if (res != 0) {\n __redisSetError(c, REDIS_ERR_OTHER, strerror(res));\n return REDIS_ERR;\n }\n#endif\n return REDIS_OK;\n}\n\nint redisSetTcpNoDelay(redisContext *c) {\n int yes = 1;\n if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"setsockopt(TCP_NODELAY)\");\n redisNetClose(c);\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\nint redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout) {\n int res;\n#ifdef TCP_USER_TIMEOUT\n res = setsockopt(c->fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout, sizeof(timeout));\n#else\n res = -1;\n errno = ENOTSUP;\n (void)timeout;\n#endif\n if (res == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"setsockopt(TCP_USER_TIMEOUT)\");\n redisNetClose(c);\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\n#define __MAX_MSEC (((LONG_MAX) - 999) / 1000)\n\nstatic int redisContextTimeoutMsec(redisContext *c, long *result)\n{\n const struct timeval *timeout = c->connect_timeout;\n long msec = -1;\n\n /* Only use timeout when not NULL. */\n if (timeout != NULL) {\n if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) {\n __redisSetError(c, REDIS_ERR_IO, \"Invalid timeout specified\");\n *result = msec;\n return REDIS_ERR;\n }\n\n msec = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);\n\n if (msec < 0 || msec > INT_MAX) {\n msec = INT_MAX;\n }\n }\n\n *result = msec;\n return REDIS_OK;\n}\n\nstatic int redisContextWaitReady(redisContext *c, long msec) {\n struct pollfd wfd[1];\n\n wfd[0].fd = c->fd;\n wfd[0].events = POLLOUT;\n\n if (errno == EINPROGRESS) {\n int res;\n\n if ((res = poll(wfd, 1, msec)) == -1) {\n __redisSetErrorFromErrno(c, REDIS_ERR_IO, \"poll(2)\");\n redisNetClose(c);\n return REDIS_ERR;\n } else if (res == 0) {\n errno = ETIMEDOUT;\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);\n redisNetClose(c);\n return REDIS_ERR;\n }\n\n if (redisCheckConnectDone(c, &res) != REDIS_OK || res == 0) {\n redisCheckSocketError(c);\n return REDIS_ERR;\n }\n\n return REDIS_OK;\n }\n\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);\n redisNetClose(c);\n return REDIS_ERR;\n}\n\nint redisCheckConnectDone(redisContext *c, int *completed) {\n int rc = connect(c->fd, (const struct sockaddr *)c->saddr, c->addrlen);\n if (rc == 0) {\n *completed = 1;\n return REDIS_OK;\n }\n int error = errno;\n if (error == EINPROGRESS) {\n /* must check error to see if connect failed. Get the socket error */\n int fail, so_error;\n socklen_t optlen = sizeof(so_error);\n fail = getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &so_error, &optlen);\n if (fail == 0) {\n if (so_error == 0) {\n /* Socket is connected! */\n *completed = 1;\n return REDIS_OK;\n }\n /* connection error; */\n errno = so_error;\n error = so_error;\n }\n }\n switch (error) {\n case EISCONN:\n *completed = 1;\n return REDIS_OK;\n case EALREADY:\n case EWOULDBLOCK:\n *completed = 0;\n return REDIS_OK;\n default:\n return REDIS_ERR;\n }\n}\n\nint redisCheckSocketError(redisContext *c) {\n int err = 0, errno_saved = errno;\n socklen_t errlen = sizeof(err);\n\n if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"getsockopt(SO_ERROR)\");\n return REDIS_ERR;\n }\n\n if (err == 0) {\n err = errno_saved;\n }\n\n if (err) {\n errno = err;\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);\n return REDIS_ERR;\n }\n\n return REDIS_OK;\n}\n\nint redisContextSetTimeout(redisContext *c, const struct timeval tv) {\n const void *to_ptr = &tv;\n size_t to_sz = sizeof(tv);\n\n if (redisContextUpdateCommandTimeout(c, &tv) != REDIS_OK) {\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return REDIS_ERR;\n }\n if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,to_ptr,to_sz) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"setsockopt(SO_RCVTIMEO)\");\n return REDIS_ERR;\n }\n if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,to_ptr,to_sz) == -1) {\n __redisSetErrorFromErrno(c,REDIS_ERR_IO,\"setsockopt(SO_SNDTIMEO)\");\n return REDIS_ERR;\n }\n return REDIS_OK;\n}\n\nint redisContextUpdateConnectTimeout(redisContext *c, const struct timeval *timeout) {\n /* Same timeval struct, short circuit */\n if (c->connect_timeout == timeout)\n return REDIS_OK;\n\n /* Allocate context timeval if we need to */\n if (c->connect_timeout == NULL) {\n c->connect_timeout = hi_malloc(sizeof(*c->connect_timeout));\n if (c->connect_timeout == NULL)\n return REDIS_ERR;\n }\n\n memcpy(c->connect_timeout, timeout, sizeof(*c->connect_timeout));\n return REDIS_OK;\n}\n\nint redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout) {\n /* Same timeval struct, short circuit */\n if (c->command_timeout == timeout)\n return REDIS_OK;\n\n /* Allocate context timeval if we need to */\n if (c->command_timeout == NULL) {\n c->command_timeout = hi_malloc(sizeof(*c->command_timeout));\n if (c->command_timeout == NULL)\n return REDIS_ERR;\n }\n\n memcpy(c->command_timeout, timeout, sizeof(*c->command_timeout));\n return REDIS_OK;\n}\n\nstatic int _redisContextConnectTcp(redisContext *c, const char *addr, int port,\n const struct timeval *timeout,\n const char *source_addr) {\n redisFD s;\n int rv, n;\n char _port[6]; /* strlen(\"65535\"); */\n struct addrinfo hints, *servinfo, *bservinfo, *p, *b;\n int blocking = (c->flags & REDIS_BLOCK);\n int reuseaddr = (c->flags & REDIS_REUSEADDR);\n int reuses = 0;\n long timeout_msec = -1;\n\n servinfo = NULL;\n c->connection_type = REDIS_CONN_TCP;\n c->tcp.port = port;\n\n /* We need to take possession of the passed parameters\n * to make them reusable for a reconnect.\n * We also carefully check we don't free data we already own,\n * as in the case of the reconnect method.\n *\n * This is a bit ugly, but atleast it works and doesn't leak memory.\n **/\n if (c->tcp.host != addr) {\n hi_free(c->tcp.host);\n\n c->tcp.host = hi_strdup(addr);\n if (c->tcp.host == NULL)\n goto oom;\n }\n\n if (timeout) {\n if (redisContextUpdateConnectTimeout(c, timeout) == REDIS_ERR)\n goto oom;\n } else {\n hi_free(c->connect_timeout);\n c->connect_timeout = NULL;\n }\n\n if (redisContextTimeoutMsec(c, &timeout_msec) != REDIS_OK) {\n goto error;\n }\n\n if (source_addr == NULL) {\n hi_free(c->tcp.source_addr);\n c->tcp.source_addr = NULL;\n } else if (c->tcp.source_addr != source_addr) {\n hi_free(c->tcp.source_addr);\n c->tcp.source_addr = hi_strdup(source_addr);\n }\n\n snprintf(_port, 6, \"%d\", port);\n memset(&hints,0,sizeof(hints));\n hints.ai_family = AF_INET;\n hints.ai_socktype = SOCK_STREAM;\n\n /* DNS lookup. To use dual stack, set both flags to prefer both IPv4 and\n * IPv6. By default, for historical reasons, we try IPv4 first and then we\n * try IPv6 only if no IPv4 address was found. */\n if (c->flags & REDIS_PREFER_IPV6 && c->flags & REDIS_PREFER_IPV4)\n hints.ai_family = AF_UNSPEC;\n else if (c->flags & REDIS_PREFER_IPV6)\n hints.ai_family = AF_INET6;\n else\n hints.ai_family = AF_INET;\n\n rv = getaddrinfo(c->tcp.host, _port, &hints, &servinfo);\n if (rv != 0 && hints.ai_family != AF_UNSPEC) {\n /* Try again with the other IP version. */\n hints.ai_family = (hints.ai_family == AF_INET) ? AF_INET6 : AF_INET;\n rv = getaddrinfo(c->tcp.host, _port, &hints, &servinfo);\n }\n if (rv != 0) {\n __redisSetError(c, REDIS_ERR_OTHER, gai_strerror(rv));\n return REDIS_ERR;\n }\n for (p = servinfo; p != NULL; p = p->ai_next) {\naddrretry:\n if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == REDIS_INVALID_FD)\n continue;\n\n c->fd = s;\n if (redisSetBlocking(c,0) != REDIS_OK)\n goto error;\n if (c->tcp.source_addr) {\n int bound = 0;\n /* Using getaddrinfo saves us from self-determining IPv4 vs IPv6 */\n if ((rv = getaddrinfo(c->tcp.source_addr, NULL, &hints, &bservinfo)) != 0) {\n char buf[128];\n snprintf(buf,sizeof(buf),\"Can't get addr: %s\",gai_strerror(rv));\n __redisSetError(c,REDIS_ERR_OTHER,buf);\n goto error;\n }\n\n if (reuseaddr) {\n n = 1;\n if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*) &n,\n sizeof(n)) < 0) {\n freeaddrinfo(bservinfo);\n goto error;\n }\n }\n\n for (b = bservinfo; b != NULL; b = b->ai_next) {\n if (bind(s,b->ai_addr,b->ai_addrlen) != -1) {\n bound = 1;\n break;\n }\n }\n freeaddrinfo(bservinfo);\n if (!bound) {\n char buf[128];\n snprintf(buf,sizeof(buf),\"Can't bind socket: %s\",strerror(errno));\n __redisSetError(c,REDIS_ERR_OTHER,buf);\n goto error;\n }\n }\n\n /* For repeat connection */\n hi_free(c->saddr);\n c->saddr = hi_malloc(p->ai_addrlen);\n if (c->saddr == NULL)\n goto oom;\n\n memcpy(c->saddr, p->ai_addr, p->ai_addrlen);\n c->addrlen = p->ai_addrlen;\n\n if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {\n if (errno == EHOSTUNREACH) {\n redisNetClose(c);\n continue;\n } else if (errno == EINPROGRESS) {\n if (blocking) {\n goto wait_for_ready;\n }\n /* This is ok.\n * Note that even when it's in blocking mode, we unset blocking\n * for `connect()`\n */\n } else if (errno == EADDRNOTAVAIL && reuseaddr) {\n if (++reuses >= REDIS_CONNECT_RETRIES) {\n goto error;\n } else {\n redisNetClose(c);\n goto addrretry;\n }\n } else {\n wait_for_ready:\n if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)\n goto error;\n if (redisSetTcpNoDelay(c) != REDIS_OK)\n goto error;\n }\n }\n if (blocking && redisSetBlocking(c,1) != REDIS_OK)\n goto error;\n\n c->flags |= REDIS_CONNECTED;\n rv = REDIS_OK;\n goto end;\n }\n if (p == NULL) {\n char buf[128];\n snprintf(buf,sizeof(buf),\"Can't create socket: %s\",strerror(errno));\n __redisSetError(c,REDIS_ERR_OTHER,buf);\n goto error;\n }\n\noom:\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\nerror:\n rv = REDIS_ERR;\nend:\n if(servinfo) {\n freeaddrinfo(servinfo);\n }\n\n return rv; // Need to return REDIS_OK if alright\n}\n\nint redisContextConnectTcp(redisContext *c, const char *addr, int port,\n const struct timeval *timeout) {\n return _redisContextConnectTcp(c, addr, port, timeout, NULL);\n}\n\nint redisContextConnectBindTcp(redisContext *c, const char *addr, int port,\n const struct timeval *timeout,\n const char *source_addr) {\n return _redisContextConnectTcp(c, addr, port, timeout, source_addr);\n}\n\nint redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout) {\n#ifndef _WIN32\n int blocking = (c->flags & REDIS_BLOCK);\n struct sockaddr_un *sa;\n long timeout_msec = -1;\n\n if (redisCreateSocket(c,AF_UNIX) < 0)\n return REDIS_ERR;\n if (redisSetBlocking(c,0) != REDIS_OK)\n return REDIS_ERR;\n\n c->connection_type = REDIS_CONN_UNIX;\n if (c->unix_sock.path != path) {\n hi_free(c->unix_sock.path);\n\n c->unix_sock.path = hi_strdup(path);\n if (c->unix_sock.path == NULL)\n goto oom;\n }\n\n if (timeout) {\n if (redisContextUpdateConnectTimeout(c, timeout) == REDIS_ERR)\n goto oom;\n } else {\n hi_free(c->connect_timeout);\n c->connect_timeout = NULL;\n }\n\n if (redisContextTimeoutMsec(c,&timeout_msec) != REDIS_OK)\n return REDIS_ERR;\n\n /* Don't leak sockaddr if we're reconnecting */\n if (c->saddr) hi_free(c->saddr);\n\n sa = (struct sockaddr_un*)(c->saddr = hi_malloc(sizeof(struct sockaddr_un)));\n if (sa == NULL)\n goto oom;\n\n c->addrlen = sizeof(struct sockaddr_un);\n sa->sun_family = AF_UNIX;\n strncpy(sa->sun_path, path, sizeof(sa->sun_path) - 1);\n if (connect(c->fd, (struct sockaddr*)sa, sizeof(*sa)) == -1) {\n if (errno == EINPROGRESS && !blocking) {\n /* This is ok. */\n } else {\n if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)\n return REDIS_ERR;\n }\n }\n\n /* Reset socket to be blocking after connect(2). */\n if (blocking && redisSetBlocking(c,1) != REDIS_OK)\n return REDIS_ERR;\n\n c->flags |= REDIS_CONNECTED;\n return REDIS_OK;\n#else\n /* We currently do not support Unix sockets for Windows. */\n /* TODO(m): https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/ */\n errno = EPROTONOSUPPORT;\n return REDIS_ERR;\n#endif /* _WIN32 */\noom:\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return REDIS_ERR;\n}\n" }, { "path": "deps/hiredis/net.h", "content": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2014, Pieter Noordhuis \n * Copyright (c) 2015, Matt Stancliff ,\n * Jan-Erik Rediger \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __NET_H\n#define __NET_H\n\n#include \"hiredis.h\"\n\nvoid redisNetClose(redisContext *c);\nssize_t redisNetRead(redisContext *c, char *buf, size_t bufcap);\nssize_t redisNetWrite(redisContext *c);\n\nint redisCheckSocketError(redisContext *c);\nint redisContextSetTimeout(redisContext *c, const struct timeval tv);\nint redisContextConnectTcp(redisContext *c, const char *addr, int port, const struct timeval *timeout);\nint redisContextConnectBindTcp(redisContext *c, const char *addr, int port,\n const struct timeval *timeout,\n const char *source_addr);\nint redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout);\nint redisKeepAlive(redisContext *c, int interval);\nint redisCheckConnectDone(redisContext *c, int *completed);\n\nint redisSetTcpNoDelay(redisContext *c);\nint redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout);\n\n#endif\n" }, { "path": "deps/hiredis/read.c", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \n#include \n#ifndef _MSC_VER\n#include \n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n\n#include \"alloc.h\"\n#include \"read.h\"\n#include \"sds.h\"\n#include \"win32.h\"\n\n/* Initial size of our nested reply stack and how much we grow it when needd */\n#define REDIS_READER_STACK_SIZE 9\n\nstatic void __redisReaderSetError(redisReader *r, int type, const char *str) {\n size_t len;\n\n if (r->reply != NULL && r->fn && r->fn->freeObject) {\n r->fn->freeObject(r->reply);\n r->reply = NULL;\n }\n\n /* Clear input buffer on errors. */\n hi_sdsfree(r->buf);\n r->buf = NULL;\n r->pos = r->len = 0;\n\n /* Reset task stack. */\n r->ridx = -1;\n\n /* Set error. */\n r->err = type;\n len = strlen(str);\n len = len < (sizeof(r->errstr)-1) ? len : (sizeof(r->errstr)-1);\n memcpy(r->errstr,str,len);\n r->errstr[len] = '\\0';\n}\n\nstatic size_t chrtos(char *buf, size_t size, char byte) {\n size_t len = 0;\n\n switch(byte) {\n case '\\\\':\n case '\"':\n len = snprintf(buf,size,\"\\\"\\\\%c\\\"\",byte);\n break;\n case '\\n': len = snprintf(buf,size,\"\\\"\\\\n\\\"\"); break;\n case '\\r': len = snprintf(buf,size,\"\\\"\\\\r\\\"\"); break;\n case '\\t': len = snprintf(buf,size,\"\\\"\\\\t\\\"\"); break;\n case '\\a': len = snprintf(buf,size,\"\\\"\\\\a\\\"\"); break;\n case '\\b': len = snprintf(buf,size,\"\\\"\\\\b\\\"\"); break;\n default:\n if (isprint(byte))\n len = snprintf(buf,size,\"\\\"%c\\\"\",byte);\n else\n len = snprintf(buf,size,\"\\\"\\\\x%02x\\\"\",(unsigned char)byte);\n break;\n }\n\n return len;\n}\n\nstatic void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {\n char cbuf[8], sbuf[128];\n\n chrtos(cbuf,sizeof(cbuf),byte);\n snprintf(sbuf,sizeof(sbuf),\n \"Protocol error, got %s as reply type byte\", cbuf);\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,sbuf);\n}\n\nstatic void __redisReaderSetErrorOOM(redisReader *r) {\n __redisReaderSetError(r,REDIS_ERR_OOM,\"Out of memory\");\n}\n\nstatic char *readBytes(redisReader *r, unsigned int bytes) {\n char *p;\n if (r->len-r->pos >= bytes) {\n p = r->buf+r->pos;\n r->pos += bytes;\n return p;\n }\n return NULL;\n}\n\n/* Find pointer to \\r\\n. */\nstatic char *seekNewline(char *s, size_t len) {\n char *ret;\n\n /* We cannot match with fewer than 2 bytes */\n if (len < 2)\n return NULL;\n\n /* Search up to len - 1 characters */\n len--;\n\n /* Look for the \\r */\n while ((ret = memchr(s, '\\r', len)) != NULL) {\n if (ret[1] == '\\n') {\n /* Found. */\n break;\n }\n /* Continue searching. */\n ret++;\n len -= ret - s;\n s = ret;\n }\n\n return ret;\n}\n\n/* Convert a string into a long long. Returns REDIS_OK if the string could be\n * parsed into a (non-overflowing) long long, REDIS_ERR otherwise. The value\n * will be set to the parsed value when appropriate.\n *\n * Note that this function demands that the string strictly represents\n * a long long: no spaces or other characters before or after the string\n * representing the number are accepted, nor zeroes at the start if not\n * for the string \"0\" representing the zero number.\n *\n * Because of its strictness, it is safe to use this function to check if\n * you can convert a string into a long long, and obtain back the string\n * from the number without any loss in the string representation. */\nstatic int string2ll(const char *s, size_t slen, long long *value) {\n const char *p = s;\n size_t plen = 0;\n int negative = 0;\n unsigned long long v;\n\n if (plen == slen)\n return REDIS_ERR;\n\n /* Special case: first and only digit is 0. */\n if (slen == 1 && p[0] == '0') {\n if (value != NULL) *value = 0;\n return REDIS_OK;\n }\n\n if (p[0] == '-') {\n negative = 1;\n p++; plen++;\n\n /* Abort on only a negative sign. */\n if (plen == slen)\n return REDIS_ERR;\n }\n\n /* First digit should be 1-9, otherwise the string should just be 0. */\n if (p[0] >= '1' && p[0] <= '9') {\n v = p[0]-'0';\n p++; plen++;\n } else if (p[0] == '0' && slen == 1) {\n *value = 0;\n return REDIS_OK;\n } else {\n return REDIS_ERR;\n }\n\n while (plen < slen && p[0] >= '0' && p[0] <= '9') {\n if (v > (ULLONG_MAX / 10)) /* Overflow. */\n return REDIS_ERR;\n v *= 10;\n\n if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */\n return REDIS_ERR;\n v += p[0]-'0';\n\n p++; plen++;\n }\n\n /* Return if not all bytes were used. */\n if (plen < slen)\n return REDIS_ERR;\n\n if (negative) {\n if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */\n return REDIS_ERR;\n if (value != NULL) *value = -v;\n } else {\n if (v > LLONG_MAX) /* Overflow. */\n return REDIS_ERR;\n if (value != NULL) *value = v;\n }\n return REDIS_OK;\n}\n\nstatic char *readLine(redisReader *r, int *_len) {\n char *p, *s;\n int len;\n\n p = r->buf+r->pos;\n s = seekNewline(p,(r->len-r->pos));\n if (s != NULL) {\n len = s-(r->buf+r->pos);\n r->pos += len+2; /* skip \\r\\n */\n if (_len) *_len = len;\n return p;\n }\n return NULL;\n}\n\nstatic void moveToNextTask(redisReader *r) {\n redisReadTask *cur, *prv;\n while (r->ridx >= 0) {\n /* Return a.s.a.p. when the stack is now empty. */\n if (r->ridx == 0) {\n r->ridx--;\n return;\n }\n\n cur = r->task[r->ridx];\n prv = r->task[r->ridx-1];\n assert(prv->type == REDIS_REPLY_ARRAY ||\n prv->type == REDIS_REPLY_MAP ||\n prv->type == REDIS_REPLY_SET ||\n prv->type == REDIS_REPLY_PUSH);\n if (cur->idx == prv->elements-1) {\n r->ridx--;\n } else {\n /* Reset the type because the next item can be anything */\n assert(cur->idx < prv->elements);\n cur->type = -1;\n cur->elements = -1;\n cur->idx++;\n return;\n }\n }\n}\n\nstatic int processLineItem(redisReader *r) {\n redisReadTask *cur = r->task[r->ridx];\n void *obj;\n char *p;\n int len;\n\n if ((p = readLine(r,&len)) != NULL) {\n if (cur->type == REDIS_REPLY_INTEGER) {\n long long v;\n\n if (string2ll(p, len, &v) == REDIS_ERR) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad integer value\");\n return REDIS_ERR;\n }\n\n if (r->fn && r->fn->createInteger) {\n obj = r->fn->createInteger(cur,v);\n } else {\n obj = (void*)REDIS_REPLY_INTEGER;\n }\n } else if (cur->type == REDIS_REPLY_DOUBLE) {\n char buf[326], *eptr;\n double d;\n\n if ((size_t)len >= sizeof(buf)) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Double value is too large\");\n return REDIS_ERR;\n }\n\n memcpy(buf,p,len);\n buf[len] = '\\0';\n\n if (len == 3 && strcasecmp(buf,\"inf\") == 0) {\n d = INFINITY; /* Positive infinite. */\n } else if (len == 4 && strcasecmp(buf,\"-inf\") == 0) {\n d = -INFINITY; /* Negative infinite. */\n } else if ((len == 3 && strcasecmp(buf,\"nan\") == 0) ||\n (len == 4 && strcasecmp(buf, \"-nan\") == 0)) {\n d = NAN; /* nan. */\n } else {\n d = strtod((char*)buf,&eptr);\n /* RESP3 only allows \"inf\", \"-inf\", and finite values, while\n * strtod() allows other variations on infinity,\n * etc. We explicity handle our two allowed infinite cases and NaN\n * above, so strtod() should only result in finite values. */\n if (buf[0] == '\\0' || eptr != &buf[len] || !isfinite(d)) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad double value\");\n return REDIS_ERR;\n }\n }\n\n if (r->fn && r->fn->createDouble) {\n obj = r->fn->createDouble(cur,d,buf,len);\n } else {\n obj = (void*)REDIS_REPLY_DOUBLE;\n }\n } else if (cur->type == REDIS_REPLY_NIL) {\n if (len != 0) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad nil value\");\n return REDIS_ERR;\n }\n\n if (r->fn && r->fn->createNil)\n obj = r->fn->createNil(cur);\n else\n obj = (void*)REDIS_REPLY_NIL;\n } else if (cur->type == REDIS_REPLY_BOOL) {\n int bval;\n\n if (len != 1 || !strchr(\"tTfF\", p[0])) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad bool value\");\n return REDIS_ERR;\n }\n\n bval = p[0] == 't' || p[0] == 'T';\n if (r->fn && r->fn->createBool)\n obj = r->fn->createBool(cur,bval);\n else\n obj = (void*)REDIS_REPLY_BOOL;\n } else if (cur->type == REDIS_REPLY_BIGNUM) {\n /* Ensure all characters are decimal digits (with possible leading\n * minus sign). */\n for (int i = 0; i < len; i++) {\n /* XXX Consider: Allow leading '+'? Error on leading '0's? */\n if (i == 0 && p[0] == '-') continue;\n if (p[i] < '0' || p[i] > '9') {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad bignum value\");\n return REDIS_ERR;\n }\n }\n if (r->fn && r->fn->createString)\n obj = r->fn->createString(cur,p,len);\n else\n obj = (void*)REDIS_REPLY_BIGNUM;\n } else {\n /* Type will be error or status. */\n for (int i = 0; i < len; i++) {\n if (p[i] == '\\r' || p[i] == '\\n') {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad simple string value\");\n return REDIS_ERR;\n }\n }\n if (r->fn && r->fn->createString)\n obj = r->fn->createString(cur,p,len);\n else\n obj = (void*)(uintptr_t)(cur->type);\n }\n\n if (obj == NULL) {\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n }\n\n /* Set reply if this is the root object. */\n if (r->ridx == 0) r->reply = obj;\n moveToNextTask(r);\n return REDIS_OK;\n }\n\n return REDIS_ERR;\n}\n\nstatic int processBulkItem(redisReader *r) {\n redisReadTask *cur = r->task[r->ridx];\n void *obj = NULL;\n char *p, *s;\n long long len;\n unsigned long bytelen;\n int success = 0;\n\n p = r->buf+r->pos;\n s = seekNewline(p,r->len-r->pos);\n if (s != NULL) {\n p = r->buf+r->pos;\n bytelen = s-(r->buf+r->pos)+2; /* include \\r\\n */\n\n if (string2ll(p, bytelen - 2, &len) == REDIS_ERR) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad bulk string length\");\n return REDIS_ERR;\n }\n\n if (len < -1 || (LLONG_MAX > SIZE_MAX && len > (long long)SIZE_MAX)) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bulk string length out of range\");\n return REDIS_ERR;\n }\n\n if (len == -1) {\n /* The nil object can always be created. */\n if (r->fn && r->fn->createNil)\n obj = r->fn->createNil(cur);\n else\n obj = (void*)REDIS_REPLY_NIL;\n success = 1;\n } else {\n /* Only continue when the buffer contains the entire bulk item. */\n bytelen += len+2; /* include \\r\\n */\n if (r->pos+bytelen <= r->len) {\n if ((cur->type == REDIS_REPLY_VERB && len < 4) ||\n (cur->type == REDIS_REPLY_VERB && s[5] != ':'))\n {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Verbatim string 4 bytes of content type are \"\n \"missing or incorrectly encoded.\");\n return REDIS_ERR;\n }\n if (r->fn && r->fn->createString)\n obj = r->fn->createString(cur,s+2,len);\n else\n obj = (void*)(uintptr_t)cur->type;\n success = 1;\n }\n }\n\n /* Proceed when obj was created. */\n if (success) {\n if (obj == NULL) {\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n }\n\n r->pos += bytelen;\n\n /* Set reply if this is the root object. */\n if (r->ridx == 0) r->reply = obj;\n moveToNextTask(r);\n return REDIS_OK;\n }\n }\n\n return REDIS_ERR;\n}\n\nstatic int redisReaderGrow(redisReader *r) {\n redisReadTask **aux;\n int newlen;\n\n /* Grow our stack size */\n newlen = r->tasks + REDIS_READER_STACK_SIZE;\n aux = hi_realloc(r->task, sizeof(*r->task) * newlen);\n if (aux == NULL)\n goto oom;\n\n r->task = aux;\n\n /* Allocate new tasks */\n for (; r->tasks < newlen; r->tasks++) {\n r->task[r->tasks] = hi_calloc(1, sizeof(**r->task));\n if (r->task[r->tasks] == NULL)\n goto oom;\n }\n\n return REDIS_OK;\noom:\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n}\n\n/* Process the array, map and set types. */\nstatic int processAggregateItem(redisReader *r) {\n redisReadTask *cur = r->task[r->ridx];\n void *obj;\n char *p;\n long long elements;\n int root = 0, len;\n\n if (r->ridx == r->tasks - 1) {\n if (redisReaderGrow(r) == REDIS_ERR)\n return REDIS_ERR;\n }\n\n if ((p = readLine(r,&len)) != NULL) {\n if (string2ll(p, len, &elements) == REDIS_ERR) {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Bad multi-bulk length\");\n return REDIS_ERR;\n }\n\n root = (r->ridx == 0);\n\n if (elements < -1 || (LLONG_MAX > SIZE_MAX && elements > SIZE_MAX) ||\n (r->maxelements > 0 && elements > r->maxelements))\n {\n __redisReaderSetError(r,REDIS_ERR_PROTOCOL,\n \"Multi-bulk length out of range\");\n return REDIS_ERR;\n }\n\n if (elements == -1) {\n if (r->fn && r->fn->createNil)\n obj = r->fn->createNil(cur);\n else\n obj = (void*)REDIS_REPLY_NIL;\n\n if (obj == NULL) {\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n }\n\n moveToNextTask(r);\n } else {\n if (cur->type == REDIS_REPLY_MAP) elements *= 2;\n\n if (r->fn && r->fn->createArray)\n obj = r->fn->createArray(cur,elements);\n else\n obj = (void*)(uintptr_t)cur->type;\n\n if (obj == NULL) {\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n }\n\n /* Modify task stack when there are more than 0 elements. */\n if (elements > 0) {\n cur->elements = elements;\n cur->obj = obj;\n r->ridx++;\n r->task[r->ridx]->type = -1;\n r->task[r->ridx]->elements = -1;\n r->task[r->ridx]->idx = 0;\n r->task[r->ridx]->obj = NULL;\n r->task[r->ridx]->parent = cur;\n r->task[r->ridx]->privdata = r->privdata;\n } else {\n moveToNextTask(r);\n }\n }\n\n /* Set reply if this is the root object. */\n if (root) r->reply = obj;\n return REDIS_OK;\n }\n\n return REDIS_ERR;\n}\n\nstatic int processItem(redisReader *r) {\n redisReadTask *cur = r->task[r->ridx];\n char *p;\n\n /* check if we need to read type */\n if (cur->type < 0) {\n if ((p = readBytes(r,1)) != NULL) {\n switch (p[0]) {\n case '-':\n cur->type = REDIS_REPLY_ERROR;\n break;\n case '+':\n cur->type = REDIS_REPLY_STATUS;\n break;\n case ':':\n cur->type = REDIS_REPLY_INTEGER;\n break;\n case ',':\n cur->type = REDIS_REPLY_DOUBLE;\n break;\n case '_':\n cur->type = REDIS_REPLY_NIL;\n break;\n case '$':\n cur->type = REDIS_REPLY_STRING;\n break;\n case '*':\n cur->type = REDIS_REPLY_ARRAY;\n break;\n case '%':\n cur->type = REDIS_REPLY_MAP;\n break;\n case '~':\n cur->type = REDIS_REPLY_SET;\n break;\n case '#':\n cur->type = REDIS_REPLY_BOOL;\n break;\n case '=':\n cur->type = REDIS_REPLY_VERB;\n break;\n case '>':\n cur->type = REDIS_REPLY_PUSH;\n break;\n case '(':\n cur->type = REDIS_REPLY_BIGNUM;\n break;\n default:\n __redisReaderSetErrorProtocolByte(r,*p);\n return REDIS_ERR;\n }\n } else {\n /* could not consume 1 byte */\n return REDIS_ERR;\n }\n }\n\n /* process typed item */\n switch(cur->type) {\n case REDIS_REPLY_ERROR:\n case REDIS_REPLY_STATUS:\n case REDIS_REPLY_INTEGER:\n case REDIS_REPLY_DOUBLE:\n case REDIS_REPLY_NIL:\n case REDIS_REPLY_BOOL:\n case REDIS_REPLY_BIGNUM:\n return processLineItem(r);\n case REDIS_REPLY_STRING:\n case REDIS_REPLY_VERB:\n return processBulkItem(r);\n case REDIS_REPLY_ARRAY:\n case REDIS_REPLY_MAP:\n case REDIS_REPLY_SET:\n case REDIS_REPLY_PUSH:\n return processAggregateItem(r);\n default:\n assert(NULL);\n return REDIS_ERR; /* Avoid warning. */\n }\n}\n\nredisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn) {\n redisReader *r;\n\n r = hi_calloc(1,sizeof(redisReader));\n if (r == NULL)\n return NULL;\n\n r->buf = hi_sdsempty();\n if (r->buf == NULL)\n goto oom;\n\n r->task = hi_calloc(REDIS_READER_STACK_SIZE, sizeof(*r->task));\n if (r->task == NULL)\n goto oom;\n\n for (; r->tasks < REDIS_READER_STACK_SIZE; r->tasks++) {\n r->task[r->tasks] = hi_calloc(1, sizeof(**r->task));\n if (r->task[r->tasks] == NULL)\n goto oom;\n }\n\n r->fn = fn;\n r->maxbuf = REDIS_READER_MAX_BUF;\n r->maxelements = REDIS_READER_MAX_ARRAY_ELEMENTS;\n r->ridx = -1;\n\n return r;\noom:\n redisReaderFree(r);\n return NULL;\n}\n\nvoid redisReaderFree(redisReader *r) {\n if (r == NULL)\n return;\n\n if (r->reply != NULL && r->fn && r->fn->freeObject)\n r->fn->freeObject(r->reply);\n\n if (r->task) {\n /* We know r->task[i] is allocated if i < r->tasks */\n for (int i = 0; i < r->tasks; i++) {\n hi_free(r->task[i]);\n }\n\n hi_free(r->task);\n }\n\n hi_sdsfree(r->buf);\n hi_free(r);\n}\n\nint redisReaderFeed(redisReader *r, const char *buf, size_t len) {\n hisds newbuf;\n\n /* Return early when this reader is in an erroneous state. */\n if (r->err)\n return REDIS_ERR;\n\n /* Copy the provided buffer. */\n if (buf != NULL && len >= 1) {\n /* Destroy internal buffer when it is empty and is quite large. */\n if (r->len == 0 && r->maxbuf != 0 && hi_sdsavail(r->buf) > r->maxbuf) {\n hi_sdsfree(r->buf);\n r->buf = hi_sdsempty();\n if (r->buf == 0) goto oom;\n\n r->pos = 0;\n }\n\n newbuf = hi_sdscatlen(r->buf,buf,len);\n if (newbuf == NULL) goto oom;\n\n r->buf = newbuf;\n r->len = hi_sdslen(r->buf);\n }\n\n return REDIS_OK;\noom:\n __redisReaderSetErrorOOM(r);\n return REDIS_ERR;\n}\n\nint redisReaderGetReply(redisReader *r, void **reply) {\n /* Default target pointer to NULL. */\n if (reply != NULL)\n *reply = NULL;\n\n /* Return early when this reader is in an erroneous state. */\n if (r->err)\n return REDIS_ERR;\n\n /* When the buffer is empty, there will never be a reply. */\n if (r->len == 0)\n return REDIS_OK;\n\n /* Set first item to process when the stack is empty. */\n if (r->ridx == -1) {\n r->task[0]->type = -1;\n r->task[0]->elements = -1;\n r->task[0]->idx = -1;\n r->task[0]->obj = NULL;\n r->task[0]->parent = NULL;\n r->task[0]->privdata = r->privdata;\n r->ridx = 0;\n }\n\n /* Process items in reply. */\n while (r->ridx >= 0)\n if (processItem(r) != REDIS_OK)\n break;\n\n /* Return ASAP when an error occurred. */\n if (r->err)\n return REDIS_ERR;\n\n /* Discard part of the buffer when we've consumed at least 1k, to avoid\n * doing unnecessary calls to memmove() in sds.c. */\n if (r->pos >= 1024) {\n if (hi_sdsrange(r->buf,r->pos,-1) < 0) return REDIS_ERR;\n r->pos = 0;\n r->len = hi_sdslen(r->buf);\n }\n\n /* Emit a reply when there is one. */\n if (r->ridx == -1) {\n if (reply != NULL) {\n *reply = r->reply;\n } else if (r->reply != NULL && r->fn && r->fn->freeObject) {\n r->fn->freeObject(r->reply);\n }\n r->reply = NULL;\n }\n return REDIS_OK;\n}\n" }, { "path": "deps/hiredis/read.h", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2011, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n\n#ifndef __HIREDIS_READ_H\n#define __HIREDIS_READ_H\n#include /* for size_t */\n\n#define REDIS_ERR -1\n#define REDIS_OK 0\n\n/* When an error occurs, the err flag in a context is set to hold the type of\n * error that occurred. REDIS_ERR_IO means there was an I/O error and you\n * should use the \"errno\" variable to find out what is wrong.\n * For other values, the \"errstr\" field will hold a description. */\n#define REDIS_ERR_IO 1 /* Error in read or write */\n#define REDIS_ERR_EOF 3 /* End of file */\n#define REDIS_ERR_PROTOCOL 4 /* Protocol error */\n#define REDIS_ERR_OOM 5 /* Out of memory */\n#define REDIS_ERR_TIMEOUT 6 /* Timed out */\n#define REDIS_ERR_OTHER 2 /* Everything else... */\n\n#define REDIS_REPLY_STRING 1\n#define REDIS_REPLY_ARRAY 2\n#define REDIS_REPLY_INTEGER 3\n#define REDIS_REPLY_NIL 4\n#define REDIS_REPLY_STATUS 5\n#define REDIS_REPLY_ERROR 6\n#define REDIS_REPLY_DOUBLE 7\n#define REDIS_REPLY_BOOL 8\n#define REDIS_REPLY_MAP 9\n#define REDIS_REPLY_SET 10\n#define REDIS_REPLY_ATTR 11\n#define REDIS_REPLY_PUSH 12\n#define REDIS_REPLY_BIGNUM 13\n#define REDIS_REPLY_VERB 14\n\n/* Default max unused reader buffer. */\n#define REDIS_READER_MAX_BUF (1024*16)\n\n/* Default multi-bulk element limit */\n#define REDIS_READER_MAX_ARRAY_ELEMENTS ((1LL<<32) - 1)\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\ntypedef struct redisReadTask {\n int type;\n long long elements; /* number of elements in multibulk container */\n int idx; /* index in parent (array) object */\n void *obj; /* holds user-generated value for a read task */\n struct redisReadTask *parent; /* parent task */\n void *privdata; /* user-settable arbitrary field */\n} redisReadTask;\n\ntypedef struct redisReplyObjectFunctions {\n void *(*createString)(const redisReadTask*, char*, size_t);\n void *(*createArray)(const redisReadTask*, size_t);\n void *(*createInteger)(const redisReadTask*, long long);\n void *(*createDouble)(const redisReadTask*, double, char*, size_t);\n void *(*createNil)(const redisReadTask*);\n void *(*createBool)(const redisReadTask*, int);\n void (*freeObject)(void*);\n} redisReplyObjectFunctions;\n\ntypedef struct redisReader {\n int err; /* Error flags, 0 when there is no error */\n char errstr[128]; /* String representation of error when applicable */\n\n char *buf; /* Read buffer */\n size_t pos; /* Buffer cursor */\n size_t len; /* Buffer length */\n size_t maxbuf; /* Max length of unused buffer */\n long long maxelements; /* Max multi-bulk elements */\n\n redisReadTask **task;\n int tasks;\n\n int ridx; /* Index of current read task */\n void *reply; /* Temporary reply pointer */\n\n redisReplyObjectFunctions *fn;\n void *privdata;\n} redisReader;\n\n/* Public API for the protocol parser. */\nredisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn);\nvoid redisReaderFree(redisReader *r);\nint redisReaderFeed(redisReader *r, const char *buf, size_t len);\nint redisReaderGetReply(redisReader *r, void **reply);\n\n#define redisReaderSetPrivdata(_r, _p) (int)(((redisReader*)(_r))->privdata = (_p))\n#define redisReaderGetObject(_r) (((redisReader*)(_r))->reply)\n#define redisReaderGetError(_r) (((redisReader*)(_r))->errstr)\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n" }, { "path": "deps/hiredis/sds.c", "content": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo \n * Copyright (c) 2015, Oran Agra\n * Copyright (c) 2015, Redis Labs, Inc\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"fmacros.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"sds.h\"\n#include \"sdsalloc.h\"\n\nstatic inline int hi_sdsHdrSize(char type) {\n switch(type&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n return sizeof(struct hisdshdr5);\n case HI_SDS_TYPE_8:\n return sizeof(struct hisdshdr8);\n case HI_SDS_TYPE_16:\n return sizeof(struct hisdshdr16);\n case HI_SDS_TYPE_32:\n return sizeof(struct hisdshdr32);\n case HI_SDS_TYPE_64:\n return sizeof(struct hisdshdr64);\n }\n return 0;\n}\n\nstatic inline char hi_sdsReqType(size_t string_size) {\n if (string_size < 32)\n return HI_SDS_TYPE_5;\n if (string_size < 0xff)\n return HI_SDS_TYPE_8;\n if (string_size < 0xffff)\n return HI_SDS_TYPE_16;\n if (string_size < 0xffffffff)\n return HI_SDS_TYPE_32;\n return HI_SDS_TYPE_64;\n}\n\n/* Create a new hisds string with the content specified by the 'init' pointer\n * and 'initlen'.\n * If NULL is used for 'init' the string is initialized with zero bytes.\n *\n * The string is always null-terminated (all the hisds strings are, always) so\n * even if you create an hisds string with:\n *\n * mystring = hi_sdsnewlen(\"abc\",3);\n *\n * You can print the string with printf() as there is an implicit \\0 at the\n * end of the string. However the string is binary safe and can contain\n * \\0 characters in the middle, as the length is stored in the hisds header. */\nhisds hi_sdsnewlen(const void *init, size_t initlen) {\n void *sh;\n hisds s;\n char type = hi_sdsReqType(initlen);\n /* Empty strings are usually created in order to append. Use type 8\n * since type 5 is not good at this. */\n if (type == HI_SDS_TYPE_5 && initlen == 0) type = HI_SDS_TYPE_8;\n int hdrlen = hi_sdsHdrSize(type);\n unsigned char *fp; /* flags pointer. */\n\n if (hdrlen+initlen+1 <= initlen) return NULL; /* Catch size_t overflow */\n sh = hi_s_malloc(hdrlen+initlen+1);\n if (sh == NULL) return NULL;\n if (!init)\n memset(sh, 0, hdrlen+initlen+1);\n s = (char*)sh+hdrlen;\n fp = ((unsigned char*)s)-1;\n switch(type) {\n case HI_SDS_TYPE_5: {\n *fp = type | (initlen << HI_SDS_TYPE_BITS);\n break;\n }\n case HI_SDS_TYPE_8: {\n HI_SDS_HDR_VAR(8,s);\n sh->len = initlen;\n sh->alloc = initlen;\n *fp = type;\n break;\n }\n case HI_SDS_TYPE_16: {\n HI_SDS_HDR_VAR(16,s);\n sh->len = initlen;\n sh->alloc = initlen;\n *fp = type;\n break;\n }\n case HI_SDS_TYPE_32: {\n HI_SDS_HDR_VAR(32,s);\n sh->len = initlen;\n sh->alloc = initlen;\n *fp = type;\n break;\n }\n case HI_SDS_TYPE_64: {\n HI_SDS_HDR_VAR(64,s);\n sh->len = initlen;\n sh->alloc = initlen;\n *fp = type;\n break;\n }\n }\n if (initlen && init)\n memcpy(s, init, initlen);\n s[initlen] = '\\0';\n return s;\n}\n\n/* Create an empty (zero length) hisds string. Even in this case the string\n * always has an implicit null term. */\nhisds hi_sdsempty(void) {\n return hi_sdsnewlen(\"\",0);\n}\n\n/* Create a new hisds string starting from a null terminated C string. */\nhisds hi_sdsnew(const char *init) {\n size_t initlen = (init == NULL) ? 0 : strlen(init);\n return hi_sdsnewlen(init, initlen);\n}\n\n/* Duplicate an hisds string. */\nhisds hi_sdsdup(const hisds s) {\n return hi_sdsnewlen(s, hi_sdslen(s));\n}\n\n/* Free an hisds string. No operation is performed if 's' is NULL. */\nvoid hi_sdsfree(hisds s) {\n if (s == NULL) return;\n hi_s_free((char*)s-hi_sdsHdrSize(s[-1]));\n}\n\n/* Set the hisds string length to the length as obtained with strlen(), so\n * considering as content only up to the first null term character.\n *\n * This function is useful when the hisds string is hacked manually in some\n * way, like in the following example:\n *\n * s = hi_sdsnew(\"foobar\");\n * s[2] = '\\0';\n * hi_sdsupdatelen(s);\n * printf(\"%d\\n\", hi_sdslen(s));\n *\n * The output will be \"2\", but if we comment out the call to hi_sdsupdatelen()\n * the output will be \"6\" as the string was modified but the logical length\n * remains 6 bytes. */\nvoid hi_sdsupdatelen(hisds s) {\n size_t reallen = strlen(s);\n hi_sdssetlen(s, reallen);\n}\n\n/* Modify an hisds string in-place to make it empty (zero length).\n * However all the existing buffer is not discarded but set as free space\n * so that next append operations will not require allocations up to the\n * number of bytes previously available. */\nvoid hi_sdsclear(hisds s) {\n hi_sdssetlen(s, 0);\n s[0] = '\\0';\n}\n\n/* Enlarge the free space at the end of the hisds string so that the caller\n * is sure that after calling this function can overwrite up to addlen\n * bytes after the end of the string, plus one more byte for nul term.\n *\n * Note: this does not change the *length* of the hisds string as returned\n * by hi_sdslen(), but only the free buffer space we have. */\nhisds hi_sdsMakeRoomFor(hisds s, size_t addlen) {\n void *sh, *newsh;\n size_t avail = hi_sdsavail(s);\n size_t len, newlen, reqlen;\n char type, oldtype = s[-1] & HI_SDS_TYPE_MASK;\n int hdrlen;\n\n /* Return ASAP if there is enough space left. */\n if (avail >= addlen) return s;\n\n len = hi_sdslen(s);\n sh = (char*)s-hi_sdsHdrSize(oldtype);\n reqlen = newlen = (len+addlen);\n if (newlen <= len) return NULL; /* Catch size_t overflow */\n if (newlen < HI_SDS_MAX_PREALLOC)\n newlen *= 2;\n else\n newlen += HI_SDS_MAX_PREALLOC;\n\n type = hi_sdsReqType(newlen);\n\n /* Don't use type 5: the user is appending to the string and type 5 is\n * not able to remember empty space, so hi_sdsMakeRoomFor() must be called\n * at every appending operation. */\n if (type == HI_SDS_TYPE_5) type = HI_SDS_TYPE_8;\n\n hdrlen = hi_sdsHdrSize(type);\n if (hdrlen+newlen+1 <= reqlen) return NULL; /* Catch size_t overflow */\n if (oldtype==type) {\n newsh = hi_s_realloc(sh, hdrlen+newlen+1);\n if (newsh == NULL) return NULL;\n s = (char*)newsh+hdrlen;\n } else {\n /* Since the header size changes, need to move the string forward,\n * and can't use realloc */\n newsh = hi_s_malloc(hdrlen+newlen+1);\n if (newsh == NULL) return NULL;\n memcpy((char*)newsh+hdrlen, s, len+1);\n hi_s_free(sh);\n s = (char*)newsh+hdrlen;\n s[-1] = type;\n hi_sdssetlen(s, len);\n }\n hi_sdssetalloc(s, newlen);\n return s;\n}\n\n/* Reallocate the hisds string so that it has no free space at the end. The\n * contained string remains not altered, but next concatenation operations\n * will require a reallocation.\n *\n * After the call, the passed hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call. */\nhisds hi_sdsRemoveFreeSpace(hisds s) {\n void *sh, *newsh;\n char type, oldtype = s[-1] & HI_SDS_TYPE_MASK;\n int hdrlen;\n size_t len = hi_sdslen(s);\n sh = (char*)s-hi_sdsHdrSize(oldtype);\n\n type = hi_sdsReqType(len);\n hdrlen = hi_sdsHdrSize(type);\n if (oldtype==type) {\n newsh = hi_s_realloc(sh, hdrlen+len+1);\n if (newsh == NULL) return NULL;\n s = (char*)newsh+hdrlen;\n } else {\n newsh = hi_s_malloc(hdrlen+len+1);\n if (newsh == NULL) return NULL;\n memcpy((char*)newsh+hdrlen, s, len+1);\n hi_s_free(sh);\n s = (char*)newsh+hdrlen;\n s[-1] = type;\n hi_sdssetlen(s, len);\n }\n hi_sdssetalloc(s, len);\n return s;\n}\n\n/* Return the total size of the allocation of the specifed hisds string,\n * including:\n * 1) The hisds header before the pointer.\n * 2) The string.\n * 3) The free buffer at the end if any.\n * 4) The implicit null term.\n */\nsize_t hi_sdsAllocSize(hisds s) {\n size_t alloc = hi_sdsalloc(s);\n return hi_sdsHdrSize(s[-1])+alloc+1;\n}\n\n/* Return the pointer of the actual SDS allocation (normally SDS strings\n * are referenced by the start of the string buffer). */\nvoid *hi_sdsAllocPtr(hisds s) {\n return (void*) (s-hi_sdsHdrSize(s[-1]));\n}\n\n/* Increment the hisds length and decrements the left free space at the\n * end of the string according to 'incr'. Also set the null term\n * in the new end of the string.\n *\n * This function is used in order to fix the string length after the\n * user calls hi_sdsMakeRoomFor(), writes something after the end of\n * the current string, and finally needs to set the new length.\n *\n * Note: it is possible to use a negative increment in order to\n * right-trim the string.\n *\n * Usage example:\n *\n * Using hi_sdsIncrLen() and hi_sdsMakeRoomFor() it is possible to mount the\n * following schema, to cat bytes coming from the kernel to the end of an\n * hisds string without copying into an intermediate buffer:\n *\n * oldlen = hi_hi_sdslen(s);\n * s = hi_sdsMakeRoomFor(s, BUFFER_SIZE);\n * nread = read(fd, s+oldlen, BUFFER_SIZE);\n * ... check for nread <= 0 and handle it ...\n * hi_sdsIncrLen(s, nread);\n */\nvoid hi_sdsIncrLen(hisds s, int incr) {\n unsigned char flags = s[-1];\n size_t len;\n switch(flags&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5: {\n unsigned char *fp = ((unsigned char*)s)-1;\n unsigned char oldlen = HI_SDS_TYPE_5_LEN(flags);\n assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));\n *fp = HI_SDS_TYPE_5 | ((oldlen+incr) << HI_SDS_TYPE_BITS);\n len = oldlen+incr;\n break;\n }\n case HI_SDS_TYPE_8: {\n HI_SDS_HDR_VAR(8,s);\n assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));\n len = (sh->len += incr);\n break;\n }\n case HI_SDS_TYPE_16: {\n HI_SDS_HDR_VAR(16,s);\n assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));\n len = (sh->len += incr);\n break;\n }\n case HI_SDS_TYPE_32: {\n HI_SDS_HDR_VAR(32,s);\n assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));\n len = (sh->len += incr);\n break;\n }\n case HI_SDS_TYPE_64: {\n HI_SDS_HDR_VAR(64,s);\n assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));\n len = (sh->len += incr);\n break;\n }\n default: len = 0; /* Just to avoid compilation warnings. */\n }\n s[len] = '\\0';\n}\n\n/* Grow the hisds to have the specified length. Bytes that were not part of\n * the original length of the hisds will be set to zero.\n *\n * if the specified length is smaller than the current length, no operation\n * is performed. */\nhisds hi_sdsgrowzero(hisds s, size_t len) {\n size_t curlen = hi_sdslen(s);\n\n if (len <= curlen) return s;\n s = hi_sdsMakeRoomFor(s,len-curlen);\n if (s == NULL) return NULL;\n\n /* Make sure added region doesn't contain garbage */\n memset(s+curlen,0,(len-curlen+1)); /* also set trailing \\0 byte */\n hi_sdssetlen(s, len);\n return s;\n}\n\n/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the\n * end of the specified hisds string 's'.\n *\n * After the call, the passed hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call. */\nhisds hi_sdscatlen(hisds s, const void *t, size_t len) {\n size_t curlen = hi_sdslen(s);\n\n s = hi_sdsMakeRoomFor(s,len);\n if (s == NULL) return NULL;\n memcpy(s+curlen, t, len);\n hi_sdssetlen(s, curlen+len);\n s[curlen+len] = '\\0';\n return s;\n}\n\n/* Append the specified null termianted C string to the hisds string 's'.\n *\n * After the call, the passed hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call. */\nhisds hi_sdscat(hisds s, const char *t) {\n return hi_sdscatlen(s, t, strlen(t));\n}\n\n/* Append the specified hisds 't' to the existing hisds 's'.\n *\n * After the call, the modified hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call. */\nhisds hi_sdscatsds(hisds s, const hisds t) {\n return hi_sdscatlen(s, t, hi_sdslen(t));\n}\n\n/* Destructively modify the hisds string 's' to hold the specified binary\n * safe string pointed by 't' of length 'len' bytes. */\nhisds hi_sdscpylen(hisds s, const char *t, size_t len) {\n if (hi_sdsalloc(s) < len) {\n s = hi_sdsMakeRoomFor(s,len-hi_sdslen(s));\n if (s == NULL) return NULL;\n }\n memcpy(s, t, len);\n s[len] = '\\0';\n hi_sdssetlen(s, len);\n return s;\n}\n\n/* Like hi_sdscpylen() but 't' must be a null-terminated string so that the length\n * of the string is obtained with strlen(). */\nhisds hi_sdscpy(hisds s, const char *t) {\n return hi_sdscpylen(s, t, strlen(t));\n}\n\n/* Helper for hi_sdscatlonglong() doing the actual number -> string\n * conversion. 's' must point to a string with room for at least\n * HI_SDS_LLSTR_SIZE bytes.\n *\n * The function returns the length of the null-terminated string\n * representation stored at 's'. */\n#define HI_SDS_LLSTR_SIZE 21\nint hi_sdsll2str(char *s, long long value) {\n char *p, aux;\n unsigned long long v;\n size_t l;\n\n /* Generate the string representation, this method produces\n * an reversed string. */\n v = (value < 0) ? -value : value;\n p = s;\n do {\n *p++ = '0'+(v%10);\n v /= 10;\n } while(v);\n if (value < 0) *p++ = '-';\n\n /* Compute length and add null term. */\n l = p-s;\n *p = '\\0';\n\n /* Reverse the string. */\n p--;\n while(s < p) {\n aux = *s;\n *s = *p;\n *p = aux;\n s++;\n p--;\n }\n return l;\n}\n\n/* Identical hi_sdsll2str(), but for unsigned long long type. */\nint hi_sdsull2str(char *s, unsigned long long v) {\n char *p, aux;\n size_t l;\n\n /* Generate the string representation, this method produces\n * an reversed string. */\n p = s;\n do {\n *p++ = '0'+(v%10);\n v /= 10;\n } while(v);\n\n /* Compute length and add null term. */\n l = p-s;\n *p = '\\0';\n\n /* Reverse the string. */\n p--;\n while(s < p) {\n aux = *s;\n *s = *p;\n *p = aux;\n s++;\n p--;\n }\n return l;\n}\n\n/* Create an hisds string from a long long value. It is much faster than:\n *\n * hi_sdscatprintf(hi_sdsempty(),\"%lld\\n\", value);\n */\nhisds hi_sdsfromlonglong(long long value) {\n char buf[HI_SDS_LLSTR_SIZE];\n int len = hi_sdsll2str(buf,value);\n\n return hi_sdsnewlen(buf,len);\n}\n\n/* Like hi_sdscatprintf() but gets va_list instead of being variadic. */\nhisds hi_sdscatvprintf(hisds s, const char *fmt, va_list ap) {\n va_list cpy;\n char staticbuf[1024], *buf = staticbuf, *t;\n size_t buflen = strlen(fmt)*2;\n\n /* We try to start using a static buffer for speed.\n * If not possible we revert to heap allocation. */\n if (buflen > sizeof(staticbuf)) {\n buf = hi_s_malloc(buflen);\n if (buf == NULL) return NULL;\n } else {\n buflen = sizeof(staticbuf);\n }\n\n /* Try with buffers two times bigger every time we fail to\n * fit the string in the current buffer size. */\n while(1) {\n buf[buflen-2] = '\\0';\n va_copy(cpy,ap);\n vsnprintf(buf, buflen, fmt, cpy);\n va_end(cpy);\n if (buf[buflen-2] != '\\0') {\n if (buf != staticbuf) hi_s_free(buf);\n buflen *= 2;\n buf = hi_s_malloc(buflen);\n if (buf == NULL) return NULL;\n continue;\n }\n break;\n }\n\n /* Finally concat the obtained string to the SDS string and return it. */\n t = hi_sdscat(s, buf);\n if (buf != staticbuf) hi_s_free(buf);\n return t;\n}\n\n/* Append to the hisds string 's' a string obtained using printf-alike format\n * specifier.\n *\n * After the call, the modified hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call.\n *\n * Example:\n *\n * s = hi_sdsnew(\"Sum is: \");\n * s = hi_sdscatprintf(s,\"%d+%d = %d\",a,b,a+b).\n *\n * Often you need to create a string from scratch with the printf-alike\n * format. When this is the need, just use hi_sdsempty() as the target string:\n *\n * s = hi_sdscatprintf(hi_sdsempty(), \"... your format ...\", args);\n */\nhisds hi_sdscatprintf(hisds s, const char *fmt, ...) {\n va_list ap;\n char *t;\n va_start(ap, fmt);\n t = hi_sdscatvprintf(s,fmt,ap);\n va_end(ap);\n return t;\n}\n\n/* This function is similar to hi_sdscatprintf, but much faster as it does\n * not rely on sprintf() family functions implemented by the libc that\n * are often very slow. Moreover directly handling the hisds string as\n * new data is concatenated provides a performance improvement.\n *\n * However this function only handles an incompatible subset of printf-alike\n * format specifiers:\n *\n * %s - C String\n * %S - SDS string\n * %i - signed int\n * %I - 64 bit signed integer (long long, int64_t)\n * %u - unsigned int\n * %U - 64 bit unsigned integer (unsigned long long, uint64_t)\n * %% - Verbatim \"%\" character.\n */\nhisds hi_sdscatfmt(hisds s, char const *fmt, ...) {\n const char *f = fmt;\n long i;\n va_list ap;\n\n va_start(ap,fmt);\n i = hi_sdslen(s); /* Position of the next byte to write to dest str. */\n while(*f) {\n char next, *str;\n size_t l;\n long long num;\n unsigned long long unum;\n\n /* Make sure there is always space for at least 1 char. */\n if (hi_sdsavail(s)==0) {\n s = hi_sdsMakeRoomFor(s,1);\n if (s == NULL) goto fmt_error;\n }\n\n switch(*f) {\n case '%':\n next = *(f+1);\n f++;\n switch(next) {\n case 's':\n case 'S':\n str = va_arg(ap,char*);\n l = (next == 's') ? strlen(str) : hi_sdslen(str);\n if (hi_sdsavail(s) < l) {\n s = hi_sdsMakeRoomFor(s,l);\n if (s == NULL) goto fmt_error;\n }\n memcpy(s+i,str,l);\n hi_sdsinclen(s,l);\n i += l;\n break;\n case 'i':\n case 'I':\n if (next == 'i')\n num = va_arg(ap,int);\n else\n num = va_arg(ap,long long);\n {\n char buf[HI_SDS_LLSTR_SIZE];\n l = hi_sdsll2str(buf,num);\n if (hi_sdsavail(s) < l) {\n s = hi_sdsMakeRoomFor(s,l);\n if (s == NULL) goto fmt_error;\n }\n memcpy(s+i,buf,l);\n hi_sdsinclen(s,l);\n i += l;\n }\n break;\n case 'u':\n case 'U':\n if (next == 'u')\n unum = va_arg(ap,unsigned int);\n else\n unum = va_arg(ap,unsigned long long);\n {\n char buf[HI_SDS_LLSTR_SIZE];\n l = hi_sdsull2str(buf,unum);\n if (hi_sdsavail(s) < l) {\n s = hi_sdsMakeRoomFor(s,l);\n if (s == NULL) goto fmt_error;\n }\n memcpy(s+i,buf,l);\n hi_sdsinclen(s,l);\n i += l;\n }\n break;\n default: /* Handle %% and generally %. */\n s[i++] = next;\n hi_sdsinclen(s,1);\n break;\n }\n break;\n default:\n s[i++] = *f;\n hi_sdsinclen(s,1);\n break;\n }\n f++;\n }\n va_end(ap);\n\n /* Add null-term */\n s[i] = '\\0';\n return s;\n\nfmt_error:\n va_end(ap);\n return NULL;\n}\n\n/* Remove the part of the string from left and from right composed just of\n * contiguous characters found in 'cset', that is a null terminted C string.\n *\n * After the call, the modified hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call.\n *\n * Example:\n *\n * s = hi_sdsnew(\"AA...AA.a.aa.aHelloWorld :::\");\n * s = hi_sdstrim(s,\"Aa. :\");\n * printf(\"%s\\n\", s);\n *\n * Output will be just \"Hello World\".\n */\nhisds hi_sdstrim(hisds s, const char *cset) {\n char *start, *end, *sp, *ep;\n size_t len;\n\n sp = start = s;\n ep = end = s+hi_sdslen(s)-1;\n while(sp <= end && strchr(cset, *sp)) sp++;\n while(ep > sp && strchr(cset, *ep)) ep--;\n len = (sp > ep) ? 0 : ((ep-sp)+1);\n if (s != sp) memmove(s, sp, len);\n s[len] = '\\0';\n hi_sdssetlen(s,len);\n return s;\n}\n\n/* Turn the string into a smaller (or equal) string containing only the\n * substring specified by the 'start' and 'end' indexes.\n *\n * start and end can be negative, where -1 means the last character of the\n * string, -2 the penultimate character, and so forth.\n *\n * The interval is inclusive, so the start and end characters will be part\n * of the resulting string.\n *\n * The string is modified in-place.\n *\n * Return value:\n * -1 (error) if hi_sdslen(s) is larger than maximum positive ssize_t value.\n * 0 on success.\n *\n * Example:\n *\n * s = hi_sdsnew(\"Hello World\");\n * hi_sdsrange(s,1,-1); => \"ello World\"\n */\nint hi_sdsrange(hisds s, ssize_t start, ssize_t end) {\n size_t newlen, len = hi_sdslen(s);\n if (len > SSIZE_MAX) return -1;\n\n if (len == 0) return 0;\n if (start < 0) {\n start = len+start;\n if (start < 0) start = 0;\n }\n if (end < 0) {\n end = len+end;\n if (end < 0) end = 0;\n }\n newlen = (start > end) ? 0 : (end-start)+1;\n if (newlen != 0) {\n if (start >= (ssize_t)len) {\n newlen = 0;\n } else if (end >= (ssize_t)len) {\n end = len-1;\n newlen = (start > end) ? 0 : (end-start)+1;\n }\n } else {\n start = 0;\n }\n if (start && newlen) memmove(s, s+start, newlen);\n s[newlen] = 0;\n hi_sdssetlen(s,newlen);\n return 0;\n}\n\n/* Apply tolower() to every character of the sds string 's'. */\nvoid hi_sdstolower(hisds s) {\n size_t len = hi_sdslen(s), j;\n\n for (j = 0; j < len; j++) s[j] = tolower(s[j]);\n}\n\n/* Apply toupper() to every character of the sds string 's'. */\nvoid hi_sdstoupper(hisds s) {\n size_t len = hi_sdslen(s), j;\n\n for (j = 0; j < len; j++) s[j] = toupper(s[j]);\n}\n\n/* Compare two hisds strings s1 and s2 with memcmp().\n *\n * Return value:\n *\n * positive if s1 > s2.\n * negative if s1 < s2.\n * 0 if s1 and s2 are exactly the same binary string.\n *\n * If two strings share exactly the same prefix, but one of the two has\n * additional characters, the longer string is considered to be greater than\n * the smaller one. */\nint hi_sdscmp(const hisds s1, const hisds s2) {\n size_t l1, l2, minlen;\n int cmp;\n\n l1 = hi_sdslen(s1);\n l2 = hi_sdslen(s2);\n minlen = (l1 < l2) ? l1 : l2;\n cmp = memcmp(s1,s2,minlen);\n if (cmp == 0) return l1-l2;\n return cmp;\n}\n\n/* Split 's' with separator in 'sep'. An array\n * of hisds strings is returned. *count will be set\n * by reference to the number of tokens returned.\n *\n * On out of memory, zero length string, zero length\n * separator, NULL is returned.\n *\n * Note that 'sep' is able to split a string using\n * a multi-character separator. For example\n * hi_sdssplit(\"foo_-_bar\",\"_-_\"); will return two\n * elements \"foo\" and \"bar\".\n *\n * This version of the function is binary-safe but\n * requires length arguments. hi_sdssplit() is just the\n * same function but for zero-terminated strings.\n */\nhisds *hi_sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) {\n int elements = 0, slots = 5, start = 0, j;\n hisds *tokens;\n\n if (seplen < 1 || len < 0) return NULL;\n\n tokens = hi_s_malloc(sizeof(hisds)*slots);\n if (tokens == NULL) return NULL;\n\n if (len == 0) {\n *count = 0;\n return tokens;\n }\n for (j = 0; j < (len-(seplen-1)); j++) {\n /* make sure there is room for the next element and the final one */\n if (slots < elements+2) {\n hisds *newtokens;\n\n slots *= 2;\n newtokens = hi_s_realloc(tokens,sizeof(hisds)*slots);\n if (newtokens == NULL) goto cleanup;\n tokens = newtokens;\n }\n /* search the separator */\n if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {\n tokens[elements] = hi_sdsnewlen(s+start,j-start);\n if (tokens[elements] == NULL) goto cleanup;\n elements++;\n start = j+seplen;\n j = j+seplen-1; /* skip the separator */\n }\n }\n /* Add the final element. We are sure there is room in the tokens array. */\n tokens[elements] = hi_sdsnewlen(s+start,len-start);\n if (tokens[elements] == NULL) goto cleanup;\n elements++;\n *count = elements;\n return tokens;\n\ncleanup:\n {\n int i;\n for (i = 0; i < elements; i++) hi_sdsfree(tokens[i]);\n hi_s_free(tokens);\n *count = 0;\n return NULL;\n }\n}\n\n/* Free the result returned by hi_sdssplitlen(), or do nothing if 'tokens' is NULL. */\nvoid hi_sdsfreesplitres(hisds *tokens, int count) {\n if (!tokens) return;\n while(count--)\n hi_sdsfree(tokens[count]);\n hi_s_free(tokens);\n}\n\n/* Append to the hisds string \"s\" an escaped string representation where\n * all the non-printable characters (tested with isprint()) are turned into\n * escapes in the form \"\\n\\r\\a....\" or \"\\x\".\n *\n * After the call, the modified hisds string is no longer valid and all the\n * references must be substituted with the new pointer returned by the call. */\nhisds hi_sdscatrepr(hisds s, const char *p, size_t len) {\n s = hi_sdscatlen(s,\"\\\"\",1);\n while(len--) {\n switch(*p) {\n case '\\\\':\n case '\"':\n s = hi_sdscatprintf(s,\"\\\\%c\",*p);\n break;\n case '\\n': s = hi_sdscatlen(s,\"\\\\n\",2); break;\n case '\\r': s = hi_sdscatlen(s,\"\\\\r\",2); break;\n case '\\t': s = hi_sdscatlen(s,\"\\\\t\",2); break;\n case '\\a': s = hi_sdscatlen(s,\"\\\\a\",2); break;\n case '\\b': s = hi_sdscatlen(s,\"\\\\b\",2); break;\n default:\n if (isprint(*p))\n s = hi_sdscatprintf(s,\"%c\",*p);\n else\n s = hi_sdscatprintf(s,\"\\\\x%02x\",(unsigned char)*p);\n break;\n }\n p++;\n }\n return hi_sdscatlen(s,\"\\\"\",1);\n}\n\n/* Helper function for hi_sdssplitargs() that converts a hex digit into an\n * integer from 0 to 15 */\nstatic int hi_hex_digit_to_int(char c) {\n switch(c) {\n case '0': return 0;\n case '1': return 1;\n case '2': return 2;\n case '3': return 3;\n case '4': return 4;\n case '5': return 5;\n case '6': return 6;\n case '7': return 7;\n case '8': return 8;\n case '9': return 9;\n case 'a': case 'A': return 10;\n case 'b': case 'B': return 11;\n case 'c': case 'C': return 12;\n case 'd': case 'D': return 13;\n case 'e': case 'E': return 14;\n case 'f': case 'F': return 15;\n default: return 0;\n }\n}\n\n/* Split a line into arguments, where every argument can be in the\n * following programming-language REPL-alike form:\n *\n * foo bar \"newline are supported\\n\" and \"\\xff\\x00otherstuff\"\n *\n * The number of arguments is stored into *argc, and an array\n * of hisds is returned.\n *\n * The caller should free the resulting array of hisds strings with\n * hi_sdsfreesplitres().\n *\n * Note that hi_sdscatrepr() is able to convert back a string into\n * a quoted string in the same format hi_sdssplitargs() is able to parse.\n *\n * The function returns the allocated tokens on success, even when the\n * input string is empty, or NULL if the input contains unbalanced\n * quotes or closed quotes followed by non space characters\n * as in: \"foo\"bar or \"foo'\n */\nhisds *hi_sdssplitargs(const char *line, int *argc) {\n const char *p = line;\n char *current = NULL;\n char **vector = NULL;\n\n *argc = 0;\n while(1) {\n /* skip blanks */\n while(*p && isspace((int) *p)) p++;\n if (*p) {\n /* get a token */\n int inq=0; /* set to 1 if we are in \"quotes\" */\n int insq=0; /* set to 1 if we are in 'single quotes' */\n int done=0;\n\n if (current == NULL) current = hi_sdsempty();\n while(!done) {\n if (inq) {\n if (*p == '\\\\' && *(p+1) == 'x' &&\n isxdigit((int) *(p+2)) &&\n isxdigit((int) *(p+3)))\n {\n unsigned char byte;\n\n byte = (hi_hex_digit_to_int(*(p+2))*16)+\n hi_hex_digit_to_int(*(p+3));\n current = hi_sdscatlen(current,(char*)&byte,1);\n p += 3;\n } else if (*p == '\\\\' && *(p+1)) {\n char c;\n\n p++;\n switch(*p) {\n case 'n': c = '\\n'; break;\n case 'r': c = '\\r'; break;\n case 't': c = '\\t'; break;\n case 'b': c = '\\b'; break;\n case 'a': c = '\\a'; break;\n default: c = *p; break;\n }\n current = hi_sdscatlen(current,&c,1);\n } else if (*p == '\"') {\n /* closing quote must be followed by a space or\n * nothing at all. */\n if (*(p+1) && !isspace((int) *(p+1))) goto err;\n done=1;\n } else if (!*p) {\n /* unterminated quotes */\n goto err;\n } else {\n current = hi_sdscatlen(current,p,1);\n }\n } else if (insq) {\n if (*p == '\\\\' && *(p+1) == '\\'') {\n p++;\n current = hi_sdscatlen(current,\"'\",1);\n } else if (*p == '\\'') {\n /* closing quote must be followed by a space or\n * nothing at all. */\n if (*(p+1) && !isspace((int) *(p+1))) goto err;\n done=1;\n } else if (!*p) {\n /* unterminated quotes */\n goto err;\n } else {\n current = hi_sdscatlen(current,p,1);\n }\n } else {\n switch(*p) {\n case ' ':\n case '\\n':\n case '\\r':\n case '\\t':\n case '\\0':\n done=1;\n break;\n case '\"':\n inq=1;\n break;\n case '\\'':\n insq=1;\n break;\n default:\n current = hi_sdscatlen(current,p,1);\n break;\n }\n }\n if (*p) p++;\n }\n /* add the token to the vector */\n {\n char **new_vector = hi_s_realloc(vector,((*argc)+1)*sizeof(char*));\n if (new_vector == NULL) {\n hi_s_free(vector);\n return NULL;\n }\n\n vector = new_vector;\n vector[*argc] = current;\n (*argc)++;\n current = NULL;\n }\n } else {\n /* Even on empty input string return something not NULL. */\n if (vector == NULL) vector = hi_s_malloc(sizeof(void*));\n return vector;\n }\n }\n\nerr:\n while((*argc)--)\n hi_sdsfree(vector[*argc]);\n hi_s_free(vector);\n if (current) hi_sdsfree(current);\n *argc = 0;\n return NULL;\n}\n\n/* Modify the string substituting all the occurrences of the set of\n * characters specified in the 'from' string to the corresponding character\n * in the 'to' array.\n *\n * For instance: hi_sdsmapchars(mystring, \"ho\", \"01\", 2)\n * will have the effect of turning the string \"hello\" into \"0ell1\".\n *\n * The function returns the hisds string pointer, that is always the same\n * as the input pointer since no resize is needed. */\nhisds hi_sdsmapchars(hisds s, const char *from, const char *to, size_t setlen) {\n size_t j, i, l = hi_sdslen(s);\n\n for (j = 0; j < l; j++) {\n for (i = 0; i < setlen; i++) {\n if (s[j] == from[i]) {\n s[j] = to[i];\n break;\n }\n }\n }\n return s;\n}\n\n/* Join an array of C strings using the specified separator (also a C string).\n * Returns the result as an hisds string. */\nhisds hi_sdsjoin(char **argv, int argc, char *sep) {\n hisds join = hi_sdsempty();\n int j;\n\n for (j = 0; j < argc; j++) {\n join = hi_sdscat(join, argv[j]);\n if (j != argc-1) join = hi_sdscat(join,sep);\n }\n return join;\n}\n\n/* Like hi_sdsjoin, but joins an array of SDS strings. */\nhisds hi_sdsjoinsds(hisds *argv, int argc, const char *sep, size_t seplen) {\n hisds join = hi_sdsempty();\n int j;\n\n for (j = 0; j < argc; j++) {\n join = hi_sdscatsds(join, argv[j]);\n if (j != argc-1) join = hi_sdscatlen(join,sep,seplen);\n }\n return join;\n}\n\n/* Wrappers to the allocators used by SDS. Note that SDS will actually\n * just use the macros defined into sdsalloc.h in order to avoid to pay\n * the overhead of function calls. Here we define these wrappers only for\n * the programs SDS is linked to, if they want to touch the SDS internals\n * even if they use a different allocator. */\nvoid *hi_sds_malloc(size_t size) { return hi_s_malloc(size); }\nvoid *hi_sds_realloc(void *ptr, size_t size) { return hi_s_realloc(ptr,size); }\nvoid hi_sds_free(void *ptr) { hi_s_free(ptr); }\n\n#if defined(HI_SDS_TEST_MAIN)\n#include \n#include \"testhelp.h\"\n#include \"limits.h\"\n\n#define UNUSED(x) (void)(x)\nint hi_sdsTest(void) {\n {\n hisds x = hi_sdsnew(\"foo\"), y;\n\n test_cond(\"Create a string and obtain the length\",\n hi_sdslen(x) == 3 && memcmp(x,\"foo\\0\",4) == 0)\n\n hi_sdsfree(x);\n x = hi_sdsnewlen(\"foo\",2);\n test_cond(\"Create a string with specified length\",\n hi_sdslen(x) == 2 && memcmp(x,\"fo\\0\",3) == 0)\n\n x = hi_sdscat(x,\"bar\");\n test_cond(\"Strings concatenation\",\n hi_sdslen(x) == 5 && memcmp(x,\"fobar\\0\",6) == 0);\n\n x = hi_sdscpy(x,\"a\");\n test_cond(\"hi_sdscpy() against an originally longer string\",\n hi_sdslen(x) == 1 && memcmp(x,\"a\\0\",2) == 0)\n\n x = hi_sdscpy(x,\"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\");\n test_cond(\"hi_sdscpy() against an originally shorter string\",\n hi_sdslen(x) == 33 &&\n memcmp(x,\"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\\0\",33) == 0)\n\n hi_sdsfree(x);\n x = hi_sdscatprintf(hi_sdsempty(),\"%d\",123);\n test_cond(\"hi_sdscatprintf() seems working in the base case\",\n hi_sdslen(x) == 3 && memcmp(x,\"123\\0\",4) == 0)\n\n hi_sdsfree(x);\n x = hi_sdsnew(\"--\");\n x = hi_sdscatfmt(x, \"Hello %s World %I,%I--\", \"Hi!\", LLONG_MIN,LLONG_MAX);\n test_cond(\"hi_sdscatfmt() seems working in the base case\",\n hi_sdslen(x) == 60 &&\n memcmp(x,\"--Hello Hi! World -9223372036854775808,\"\n \"9223372036854775807--\",60) == 0)\n printf(\"[%s]\\n\",x);\n\n hi_sdsfree(x);\n x = hi_sdsnew(\"--\");\n x = hi_sdscatfmt(x, \"%u,%U--\", UINT_MAX, ULLONG_MAX);\n test_cond(\"hi_sdscatfmt() seems working with unsigned numbers\",\n hi_sdslen(x) == 35 &&\n memcmp(x,\"--4294967295,18446744073709551615--\",35) == 0)\n\n hi_sdsfree(x);\n x = hi_sdsnew(\" x \");\n hi_sdstrim(x,\" x\");\n test_cond(\"hi_sdstrim() works when all chars match\",\n hi_sdslen(x) == 0)\n\n hi_sdsfree(x);\n x = hi_sdsnew(\" x \");\n hi_sdstrim(x,\" \");\n test_cond(\"hi_sdstrim() works when a single char remains\",\n hi_sdslen(x) == 1 && x[0] == 'x')\n\n hi_sdsfree(x);\n x = hi_sdsnew(\"xxciaoyyy\");\n hi_sdstrim(x,\"xy\");\n test_cond(\"hi_sdstrim() correctly trims characters\",\n hi_sdslen(x) == 4 && memcmp(x,\"ciao\\0\",5) == 0)\n\n y = hi_sdsdup(x);\n hi_sdsrange(y,1,1);\n test_cond(\"hi_sdsrange(...,1,1)\",\n hi_sdslen(y) == 1 && memcmp(y,\"i\\0\",2) == 0)\n\n hi_sdsfree(y);\n y = hi_sdsdup(x);\n hi_sdsrange(y,1,-1);\n test_cond(\"hi_sdsrange(...,1,-1)\",\n hi_sdslen(y) == 3 && memcmp(y,\"iao\\0\",4) == 0)\n\n hi_sdsfree(y);\n y = hi_sdsdup(x);\n hi_sdsrange(y,-2,-1);\n test_cond(\"hi_sdsrange(...,-2,-1)\",\n hi_sdslen(y) == 2 && memcmp(y,\"ao\\0\",3) == 0)\n\n hi_sdsfree(y);\n y = hi_sdsdup(x);\n hi_sdsrange(y,2,1);\n test_cond(\"hi_sdsrange(...,2,1)\",\n hi_sdslen(y) == 0 && memcmp(y,\"\\0\",1) == 0)\n\n hi_sdsfree(y);\n y = hi_sdsdup(x);\n hi_sdsrange(y,1,100);\n test_cond(\"hi_sdsrange(...,1,100)\",\n hi_sdslen(y) == 3 && memcmp(y,\"iao\\0\",4) == 0)\n\n hi_sdsfree(y);\n y = hi_sdsdup(x);\n hi_sdsrange(y,100,100);\n test_cond(\"hi_sdsrange(...,100,100)\",\n hi_sdslen(y) == 0 && memcmp(y,\"\\0\",1) == 0)\n\n hi_sdsfree(y);\n hi_sdsfree(x);\n x = hi_sdsnew(\"foo\");\n y = hi_sdsnew(\"foa\");\n test_cond(\"hi_sdscmp(foo,foa)\", hi_sdscmp(x,y) > 0)\n\n hi_sdsfree(y);\n hi_sdsfree(x);\n x = hi_sdsnew(\"bar\");\n y = hi_sdsnew(\"bar\");\n test_cond(\"hi_sdscmp(bar,bar)\", hi_sdscmp(x,y) == 0)\n\n hi_sdsfree(y);\n hi_sdsfree(x);\n x = hi_sdsnew(\"aar\");\n y = hi_sdsnew(\"bar\");\n test_cond(\"hi_sdscmp(bar,bar)\", hi_sdscmp(x,y) < 0)\n\n hi_sdsfree(y);\n hi_sdsfree(x);\n x = hi_sdsnewlen(\"\\a\\n\\0foo\\r\",7);\n y = hi_sdscatrepr(hi_sdsempty(),x,hi_sdslen(x));\n test_cond(\"hi_sdscatrepr(...data...)\",\n memcmp(y,\"\\\"\\\\a\\\\n\\\\x00foo\\\\r\\\"\",15) == 0)\n\n {\n unsigned int oldfree;\n char *p;\n int step = 10, j, i;\n\n hi_sdsfree(x);\n hi_sdsfree(y);\n x = hi_sdsnew(\"0\");\n test_cond(\"hi_sdsnew() free/len buffers\", hi_sdslen(x) == 1 && hi_sdsavail(x) == 0);\n\n /* Run the test a few times in order to hit the first two\n * SDS header types. */\n for (i = 0; i < 10; i++) {\n int oldlen = hi_sdslen(x);\n x = hi_sdsMakeRoomFor(x,step);\n int type = x[-1]&HI_SDS_TYPE_MASK;\n\n test_cond(\"sdsMakeRoomFor() len\", hi_sdslen(x) == oldlen);\n if (type != HI_SDS_TYPE_5) {\n test_cond(\"hi_sdsMakeRoomFor() free\", hi_sdsavail(x) >= step);\n oldfree = hi_sdsavail(x);\n }\n p = x+oldlen;\n for (j = 0; j < step; j++) {\n p[j] = 'A'+j;\n }\n hi_sdsIncrLen(x,step);\n }\n test_cond(\"hi_sdsMakeRoomFor() content\",\n memcmp(\"0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ\",x,101) == 0);\n test_cond(\"sdsMakeRoomFor() final length\",hi_sdslen(x)==101);\n\n hi_sdsfree(x);\n }\n }\n test_report();\n return 0;\n}\n#endif\n\n#ifdef HI_SDS_TEST_MAIN\nint main(void) {\n return hi_sdsTest();\n}\n#endif\n" }, { "path": "deps/hiredis/sds.h", "content": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo \n * Copyright (c) 2015, Oran Agra\n * Copyright (c) 2015, Redis Labs, Inc\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef HIREDIS_SDS_H\n#define HIREDIS_SDS_H\n\n#define HI_SDS_MAX_PREALLOC (1024*1024)\n#ifdef _MSC_VER\ntypedef long long ssize_t;\n#define SSIZE_MAX (LLONG_MAX >> 1)\n#ifndef __clang__\n#define __attribute__(x)\n#endif\n#endif\n\n#include \n#include \n#include \n\ntypedef char *hisds;\n\n/* Note: sdshdr5 is never used, we just access the flags byte directly.\n * However is here to document the layout of type 5 SDS strings. */\nstruct __attribute__ ((__packed__)) hisdshdr5 {\n unsigned char flags; /* 3 lsb of type, and 5 msb of string length */\n char buf[];\n};\nstruct __attribute__ ((__packed__)) hisdshdr8 {\n uint8_t len; /* used */\n uint8_t alloc; /* excluding the header and null terminator */\n unsigned char flags; /* 3 lsb of type, 5 unused bits */\n char buf[];\n};\nstruct __attribute__ ((__packed__)) hisdshdr16 {\n uint16_t len; /* used */\n uint16_t alloc; /* excluding the header and null terminator */\n unsigned char flags; /* 3 lsb of type, 5 unused bits */\n char buf[];\n};\nstruct __attribute__ ((__packed__)) hisdshdr32 {\n uint32_t len; /* used */\n uint32_t alloc; /* excluding the header and null terminator */\n unsigned char flags; /* 3 lsb of type, 5 unused bits */\n char buf[];\n};\nstruct __attribute__ ((__packed__)) hisdshdr64 {\n uint64_t len; /* used */\n uint64_t alloc; /* excluding the header and null terminator */\n unsigned char flags; /* 3 lsb of type, 5 unused bits */\n char buf[];\n};\n\n#define HI_SDS_TYPE_5 0\n#define HI_SDS_TYPE_8 1\n#define HI_SDS_TYPE_16 2\n#define HI_SDS_TYPE_32 3\n#define HI_SDS_TYPE_64 4\n#define HI_SDS_TYPE_MASK 7\n#define HI_SDS_TYPE_BITS 3\n#define HI_SDS_HDR_VAR(T,s) struct hisdshdr##T *sh = (struct hisdshdr##T *)((s)-(sizeof(struct hisdshdr##T)));\n#define HI_SDS_HDR(T,s) ((struct hisdshdr##T *)((s)-(sizeof(struct hisdshdr##T))))\n#define HI_SDS_TYPE_5_LEN(f) ((f)>>HI_SDS_TYPE_BITS)\n\nstatic inline size_t hi_sdslen(const hisds s) {\n unsigned char flags = s[-1];\n switch(flags & HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n return HI_SDS_TYPE_5_LEN(flags);\n case HI_SDS_TYPE_8:\n return HI_SDS_HDR(8,s)->len;\n case HI_SDS_TYPE_16:\n return HI_SDS_HDR(16,s)->len;\n case HI_SDS_TYPE_32:\n return HI_SDS_HDR(32,s)->len;\n case HI_SDS_TYPE_64:\n return HI_SDS_HDR(64,s)->len;\n }\n return 0;\n}\n\nstatic inline size_t hi_sdsavail(const hisds s) {\n unsigned char flags = s[-1];\n switch(flags&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5: {\n return 0;\n }\n case HI_SDS_TYPE_8: {\n HI_SDS_HDR_VAR(8,s);\n return sh->alloc - sh->len;\n }\n case HI_SDS_TYPE_16: {\n HI_SDS_HDR_VAR(16,s);\n return sh->alloc - sh->len;\n }\n case HI_SDS_TYPE_32: {\n HI_SDS_HDR_VAR(32,s);\n return sh->alloc - sh->len;\n }\n case HI_SDS_TYPE_64: {\n HI_SDS_HDR_VAR(64,s);\n return sh->alloc - sh->len;\n }\n }\n return 0;\n}\n\nstatic inline void hi_sdssetlen(hisds s, size_t newlen) {\n unsigned char flags = s[-1];\n switch(flags&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n {\n unsigned char *fp = ((unsigned char*)s)-1;\n *fp = (unsigned char)(HI_SDS_TYPE_5 | (newlen << HI_SDS_TYPE_BITS));\n }\n break;\n case HI_SDS_TYPE_8:\n HI_SDS_HDR(8,s)->len = (uint8_t)newlen;\n break;\n case HI_SDS_TYPE_16:\n HI_SDS_HDR(16,s)->len = (uint16_t)newlen;\n break;\n case HI_SDS_TYPE_32:\n HI_SDS_HDR(32,s)->len = (uint32_t)newlen;\n break;\n case HI_SDS_TYPE_64:\n HI_SDS_HDR(64,s)->len = (uint64_t)newlen;\n break;\n }\n}\n\nstatic inline void hi_sdsinclen(hisds s, size_t inc) {\n unsigned char flags = s[-1];\n switch(flags&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n {\n unsigned char *fp = ((unsigned char*)s)-1;\n unsigned char newlen = HI_SDS_TYPE_5_LEN(flags)+(unsigned char)inc;\n *fp = HI_SDS_TYPE_5 | (newlen << HI_SDS_TYPE_BITS);\n }\n break;\n case HI_SDS_TYPE_8:\n HI_SDS_HDR(8,s)->len += (uint8_t)inc;\n break;\n case HI_SDS_TYPE_16:\n HI_SDS_HDR(16,s)->len += (uint16_t)inc;\n break;\n case HI_SDS_TYPE_32:\n HI_SDS_HDR(32,s)->len += (uint32_t)inc;\n break;\n case HI_SDS_TYPE_64:\n HI_SDS_HDR(64,s)->len += (uint64_t)inc;\n break;\n }\n}\n\n/* hi_sdsalloc() = hi_sdsavail() + hi_sdslen() */\nstatic inline size_t hi_sdsalloc(const hisds s) {\n unsigned char flags = s[-1];\n switch(flags & HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n return HI_SDS_TYPE_5_LEN(flags);\n case HI_SDS_TYPE_8:\n return HI_SDS_HDR(8,s)->alloc;\n case HI_SDS_TYPE_16:\n return HI_SDS_HDR(16,s)->alloc;\n case HI_SDS_TYPE_32:\n return HI_SDS_HDR(32,s)->alloc;\n case HI_SDS_TYPE_64:\n return HI_SDS_HDR(64,s)->alloc;\n }\n return 0;\n}\n\nstatic inline void hi_sdssetalloc(hisds s, size_t newlen) {\n unsigned char flags = s[-1];\n switch(flags&HI_SDS_TYPE_MASK) {\n case HI_SDS_TYPE_5:\n /* Nothing to do, this type has no total allocation info. */\n break;\n case HI_SDS_TYPE_8:\n HI_SDS_HDR(8,s)->alloc = (uint8_t)newlen;\n break;\n case HI_SDS_TYPE_16:\n HI_SDS_HDR(16,s)->alloc = (uint16_t)newlen;\n break;\n case HI_SDS_TYPE_32:\n HI_SDS_HDR(32,s)->alloc = (uint32_t)newlen;\n break;\n case HI_SDS_TYPE_64:\n HI_SDS_HDR(64,s)->alloc = (uint64_t)newlen;\n break;\n }\n}\n\nhisds hi_sdsnewlen(const void *init, size_t initlen);\nhisds hi_sdsnew(const char *init);\nhisds hi_sdsempty(void);\nhisds hi_sdsdup(const hisds s);\nvoid hi_sdsfree(hisds s);\nhisds hi_sdsgrowzero(hisds s, size_t len);\nhisds hi_sdscatlen(hisds s, const void *t, size_t len);\nhisds hi_sdscat(hisds s, const char *t);\nhisds hi_sdscatsds(hisds s, const hisds t);\nhisds hi_sdscpylen(hisds s, const char *t, size_t len);\nhisds hi_sdscpy(hisds s, const char *t);\n\nhisds hi_sdscatvprintf(hisds s, const char *fmt, va_list ap);\n#ifdef __GNUC__\nhisds hi_sdscatprintf(hisds s, const char *fmt, ...)\n __attribute__((format(printf, 2, 3)));\n#else\nhisds hi_sdscatprintf(hisds s, const char *fmt, ...);\n#endif\n\nhisds hi_sdscatfmt(hisds s, char const *fmt, ...);\nhisds hi_sdstrim(hisds s, const char *cset);\nint hi_sdsrange(hisds s, ssize_t start, ssize_t end);\nvoid hi_sdsupdatelen(hisds s);\nvoid hi_sdsclear(hisds s);\nint hi_sdscmp(const hisds s1, const hisds s2);\nhisds *hi_sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);\nvoid hi_sdsfreesplitres(hisds *tokens, int count);\nvoid hi_sdstolower(hisds s);\nvoid hi_sdstoupper(hisds s);\nhisds hi_sdsfromlonglong(long long value);\nhisds hi_sdscatrepr(hisds s, const char *p, size_t len);\nhisds *hi_sdssplitargs(const char *line, int *argc);\nhisds hi_sdsmapchars(hisds s, const char *from, const char *to, size_t setlen);\nhisds hi_sdsjoin(char **argv, int argc, char *sep);\nhisds hi_sdsjoinsds(hisds *argv, int argc, const char *sep, size_t seplen);\n\n/* Low level functions exposed to the user API */\nhisds hi_sdsMakeRoomFor(hisds s, size_t addlen);\nvoid hi_sdsIncrLen(hisds s, int incr);\nhisds hi_sdsRemoveFreeSpace(hisds s);\nsize_t hi_sdsAllocSize(hisds s);\nvoid *hi_sdsAllocPtr(hisds s);\n\n/* Export the allocator used by SDS to the program using SDS.\n * Sometimes the program SDS is linked to, may use a different set of\n * allocators, but may want to allocate or free things that SDS will\n * respectively free or allocate. */\nvoid *hi_sds_malloc(size_t size);\nvoid *hi_sds_realloc(void *ptr, size_t size);\nvoid hi_sds_free(void *ptr);\n\n#ifdef REDIS_TEST\nint hi_sdsTest(int argc, char *argv[]);\n#endif\n\n#endif /* HIREDIS_SDS_H */\n" }, { "path": "deps/hiredis/sdsalloc.h", "content": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo \n * Copyright (c) 2015, Oran Agra\n * Copyright (c) 2015, Redis Labs, Inc\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n/* SDS allocator selection.\n *\n * This file is used in order to change the SDS allocator at compile time.\n * Just define the following defines to what you want to use. Also add\n * the include of your alternate allocator if needed (not needed in order\n * to use the default libc allocator). */\n\n#include \"alloc.h\"\n\n#define hi_s_malloc hi_malloc\n#define hi_s_realloc hi_realloc\n#define hi_s_free hi_free\n" }, { "path": "deps/hiredis/sdscompat.h", "content": "/*\n * Copyright (c) 2020, Michael Grunder \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n/*\n * SDS compatibility header.\n *\n * This simple file maps sds types and calls to their unique hiredis symbol names.\n * It's useful when we build Hiredis as a dependency of Redis and want to call\n * Hiredis' sds symbols rather than the ones built into Redis, as the libraries\n * have slightly diverged and could cause hard to track down ABI incompatibility\n * bugs.\n *\n */\n\n#ifndef HIREDIS_SDS_COMPAT\n#define HIREDIS_SDS_COMPAT\n\n#define sds hisds\n\n#define sdslen hi_sdslen\n#define sdsavail hi_sdsavail\n#define sdssetlen hi_sdssetlen\n#define sdsinclen hi_sdsinclen\n#define sdsalloc hi_sdsalloc\n#define sdssetalloc hi_sdssetalloc\n\n#define sdsAllocPtr hi_sdsAllocPtr\n#define sdsAllocSize hi_sdsAllocSize\n#define sdscat hi_sdscat\n#define sdscatfmt hi_sdscatfmt\n#define sdscatlen hi_sdscatlen\n#define sdscatprintf hi_sdscatprintf\n#define sdscatrepr hi_sdscatrepr\n#define sdscatsds hi_sdscatsds\n#define sdscatvprintf hi_sdscatvprintf\n#define sdsclear hi_sdsclear\n#define sdscmp hi_sdscmp\n#define sdscpy hi_sdscpy\n#define sdscpylen hi_sdscpylen\n#define sdsdup hi_sdsdup\n#define sdsempty hi_sdsempty\n#define sds_free hi_sds_free\n#define sdsfree hi_sdsfree\n#define sdsfreesplitres hi_sdsfreesplitres\n#define sdsfromlonglong hi_sdsfromlonglong\n#define sdsgrowzero hi_sdsgrowzero\n#define sdsIncrLen hi_sdsIncrLen\n#define sdsjoin hi_sdsjoin\n#define sdsjoinsds hi_sdsjoinsds\n#define sdsll2str hi_sdsll2str\n#define sdsMakeRoomFor hi_sdsMakeRoomFor\n#define sds_malloc hi_sds_malloc\n#define sdsmapchars hi_sdsmapchars\n#define sdsnew hi_sdsnew\n#define sdsnewlen hi_sdsnewlen\n#define sdsrange hi_sdsrange\n#define sds_realloc hi_sds_realloc\n#define sdsRemoveFreeSpace hi_sdsRemoveFreeSpace\n#define sdssplitargs hi_sdssplitargs\n#define sdssplitlen hi_sdssplitlen\n#define sdstolower hi_sdstolower\n#define sdstoupper hi_sdstoupper\n#define sdstrim hi_sdstrim\n#define sdsull2str hi_sdsull2str\n#define sdsupdatelen hi_sdsupdatelen\n\n#endif /* HIREDIS_SDS_COMPAT */\n" }, { "path": "deps/hiredis/sockcompat.c", "content": "/*\n * Copyright (c) 2019, Marcus Geelnard \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#define REDIS_SOCKCOMPAT_IMPLEMENTATION\n#include \"sockcompat.h\"\n\n#ifdef _WIN32\nstatic int _wsaErrorToErrno(int err) {\n switch (err) {\n case WSAEWOULDBLOCK:\n return EWOULDBLOCK;\n case WSAEINPROGRESS:\n return EINPROGRESS;\n case WSAEALREADY:\n return EALREADY;\n case WSAENOTSOCK:\n return ENOTSOCK;\n case WSAEDESTADDRREQ:\n return EDESTADDRREQ;\n case WSAEMSGSIZE:\n return EMSGSIZE;\n case WSAEPROTOTYPE:\n return EPROTOTYPE;\n case WSAENOPROTOOPT:\n return ENOPROTOOPT;\n case WSAEPROTONOSUPPORT:\n return EPROTONOSUPPORT;\n case WSAEOPNOTSUPP:\n return EOPNOTSUPP;\n case WSAEAFNOSUPPORT:\n return EAFNOSUPPORT;\n case WSAEADDRINUSE:\n return EADDRINUSE;\n case WSAEADDRNOTAVAIL:\n return EADDRNOTAVAIL;\n case WSAENETDOWN:\n return ENETDOWN;\n case WSAENETUNREACH:\n return ENETUNREACH;\n case WSAENETRESET:\n return ENETRESET;\n case WSAECONNABORTED:\n return ECONNABORTED;\n case WSAECONNRESET:\n return ECONNRESET;\n case WSAENOBUFS:\n return ENOBUFS;\n case WSAEISCONN:\n return EISCONN;\n case WSAENOTCONN:\n return ENOTCONN;\n case WSAETIMEDOUT:\n return ETIMEDOUT;\n case WSAECONNREFUSED:\n return ECONNREFUSED;\n case WSAELOOP:\n return ELOOP;\n case WSAENAMETOOLONG:\n return ENAMETOOLONG;\n case WSAEHOSTUNREACH:\n return EHOSTUNREACH;\n case WSAENOTEMPTY:\n return ENOTEMPTY;\n default:\n /* We just return a generic I/O error if we could not find a relevant error. */\n return EIO;\n }\n}\n\nstatic void _updateErrno(int success) {\n errno = success ? 0 : _wsaErrorToErrno(WSAGetLastError());\n}\n\nstatic int _initWinsock() {\n static int s_initialized = 0;\n if (!s_initialized) {\n static WSADATA wsadata;\n int err = WSAStartup(MAKEWORD(2,2), &wsadata);\n if (err != 0) {\n errno = _wsaErrorToErrno(err);\n return 0;\n }\n s_initialized = 1;\n }\n return 1;\n}\n\nint win32_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {\n /* Note: This function is likely to be called before other functions, so run init here. */\n if (!_initWinsock()) {\n return EAI_FAIL;\n }\n\n switch (getaddrinfo(node, service, hints, res)) {\n case 0: return 0;\n case WSATRY_AGAIN: return EAI_AGAIN;\n case WSAEINVAL: return EAI_BADFLAGS;\n case WSAEAFNOSUPPORT: return EAI_FAMILY;\n case WSA_NOT_ENOUGH_MEMORY: return EAI_MEMORY;\n case WSAHOST_NOT_FOUND: return EAI_NONAME;\n case WSATYPE_NOT_FOUND: return EAI_SERVICE;\n case WSAESOCKTNOSUPPORT: return EAI_SOCKTYPE;\n default: return EAI_FAIL; /* Including WSANO_RECOVERY */\n }\n}\n\nconst char *win32_gai_strerror(int errcode) {\n switch (errcode) {\n case 0: errcode = 0; break;\n case EAI_AGAIN: errcode = WSATRY_AGAIN; break;\n case EAI_BADFLAGS: errcode = WSAEINVAL; break;\n case EAI_FAMILY: errcode = WSAEAFNOSUPPORT; break;\n case EAI_MEMORY: errcode = WSA_NOT_ENOUGH_MEMORY; break;\n case EAI_NONAME: errcode = WSAHOST_NOT_FOUND; break;\n case EAI_SERVICE: errcode = WSATYPE_NOT_FOUND; break;\n case EAI_SOCKTYPE: errcode = WSAESOCKTNOSUPPORT; break;\n default: errcode = WSANO_RECOVERY; break; /* Including EAI_FAIL */\n }\n return gai_strerror(errcode);\n}\n\nvoid win32_freeaddrinfo(struct addrinfo *res) {\n freeaddrinfo(res);\n}\n\nSOCKET win32_socket(int domain, int type, int protocol) {\n SOCKET s;\n\n /* Note: This function is likely to be called before other functions, so run init here. */\n if (!_initWinsock()) {\n return INVALID_SOCKET;\n }\n\n _updateErrno((s = socket(domain, type, protocol)) != INVALID_SOCKET);\n return s;\n}\n\nint win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp) {\n int ret = ioctlsocket(fd, (long)request, argp);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen) {\n int ret = bind(sockfd, addr, addrlen);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen) {\n int ret = connect(sockfd, addr, addrlen);\n _updateErrno(ret != SOCKET_ERROR);\n\n /* For Winsock connect(), the WSAEWOULDBLOCK error means the same thing as\n * EINPROGRESS for POSIX connect(), so we do that translation to keep POSIX\n * logic consistent.\n * Additionally, WSAALREADY is can be reported as WSAEINVAL to and this is\n * translated to EIO. Convert appropriately\n */\n int err = errno;\n if (err == EWOULDBLOCK) {\n errno = EINPROGRESS;\n }\n else if (err == EIO) {\n errno = EALREADY;\n }\n\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval, socklen_t *optlen) {\n int ret = 0;\n if ((level == SOL_SOCKET) && ((optname == SO_RCVTIMEO) || (optname == SO_SNDTIMEO))) {\n if (*optlen >= sizeof (struct timeval)) {\n struct timeval *tv = optval;\n DWORD timeout = 0;\n socklen_t dwlen = 0;\n ret = getsockopt(sockfd, level, optname, (char *)&timeout, &dwlen);\n tv->tv_sec = timeout / 1000;\n tv->tv_usec = (timeout * 1000) % 1000000;\n } else {\n ret = WSAEFAULT;\n }\n *optlen = sizeof (struct timeval);\n } else {\n ret = getsockopt(sockfd, level, optname, (char*)optval, optlen);\n }\n if (ret != SOCKET_ERROR && level == SOL_SOCKET && optname == SO_ERROR) {\n /* translate SO_ERROR codes, if non-zero */\n int err = *(int*)optval;\n if (err != 0) {\n err = _wsaErrorToErrno(err);\n *(int*)optval = err;\n }\n }\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen) {\n int ret = 0;\n if ((level == SOL_SOCKET) && ((optname == SO_RCVTIMEO) || (optname == SO_SNDTIMEO))) {\n const struct timeval *tv = optval;\n DWORD timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;\n ret = setsockopt(sockfd, level, optname, (const char*)&timeout, sizeof(DWORD));\n } else {\n ret = setsockopt(sockfd, level, optname, (const char*)optval, optlen);\n }\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_close(SOCKET fd) {\n int ret = closesocket(fd);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags) {\n int ret = recv(sockfd, (char*)buf, (int)len, flags);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags) {\n int ret = send(sockfd, (const char*)buf, (int)len, flags);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_poll(struct pollfd *fds, nfds_t nfds, int timeout) {\n int ret = WSAPoll(fds, nfds, timeout);\n _updateErrno(ret != SOCKET_ERROR);\n return ret != SOCKET_ERROR ? ret : -1;\n}\n\nint win32_redisKeepAlive(SOCKET sockfd, int interval_ms) {\n struct tcp_keepalive cfg;\n DWORD bytes_in;\n int res;\n\n cfg.onoff = 1;\n cfg.keepaliveinterval = interval_ms;\n cfg.keepalivetime = interval_ms;\n\n res = WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, &cfg,\n sizeof(struct tcp_keepalive), NULL, 0,\n &bytes_in, NULL, NULL);\n\n return res == 0 ? 0 : _wsaErrorToErrno(res);\n}\n\n#endif /* _WIN32 */\n" }, { "path": "deps/hiredis/sockcompat.h", "content": "/*\n * Copyright (c) 2019, Marcus Geelnard \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __SOCKCOMPAT_H\n#define __SOCKCOMPAT_H\n\n#ifndef _WIN32\n/* For POSIX systems we use the standard BSD socket API. */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#else\n/* For Windows we use winsock. */\n#undef _WIN32_WINNT\n#define _WIN32_WINNT 0x0600 /* To get WSAPoll etc. */\n#include \n#include \n#include \n#include \n#include \n\n#ifdef _MSC_VER\ntypedef long long ssize_t;\n#endif\n\n/* Emulate the parts of the BSD socket API that we need (override the winsock signatures). */\nint win32_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);\nconst char *win32_gai_strerror(int errcode);\nvoid win32_freeaddrinfo(struct addrinfo *res);\nSOCKET win32_socket(int domain, int type, int protocol);\nint win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp);\nint win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);\nint win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);\nint win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval, socklen_t *optlen);\nint win32_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen);\nint win32_close(SOCKET fd);\nssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags);\nssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags);\ntypedef ULONG nfds_t;\nint win32_poll(struct pollfd *fds, nfds_t nfds, int timeout);\n\nint win32_redisKeepAlive(SOCKET sockfd, int interval_ms);\n\n#ifndef REDIS_SOCKCOMPAT_IMPLEMENTATION\n#define getaddrinfo(node, service, hints, res) win32_getaddrinfo(node, service, hints, res)\n#undef gai_strerror\n#define gai_strerror(errcode) win32_gai_strerror(errcode)\n#define freeaddrinfo(res) win32_freeaddrinfo(res)\n#define socket(domain, type, protocol) win32_socket(domain, type, protocol)\n#define ioctl(fd, request, argp) win32_ioctl(fd, request, argp)\n#define bind(sockfd, addr, addrlen) win32_bind(sockfd, addr, addrlen)\n#define connect(sockfd, addr, addrlen) win32_connect(sockfd, addr, addrlen)\n#define getsockopt(sockfd, level, optname, optval, optlen) win32_getsockopt(sockfd, level, optname, optval, optlen)\n#define setsockopt(sockfd, level, optname, optval, optlen) win32_setsockopt(sockfd, level, optname, optval, optlen)\n#define close(fd) win32_close(fd)\n#define recv(sockfd, buf, len, flags) win32_recv(sockfd, buf, len, flags)\n#define send(sockfd, buf, len, flags) win32_send(sockfd, buf, len, flags)\n#define poll(fds, nfds, timeout) win32_poll(fds, nfds, timeout)\n#endif /* REDIS_SOCKCOMPAT_IMPLEMENTATION */\n#endif /* _WIN32 */\n\n#endif /* __SOCKCOMPAT_H */\n" }, { "path": "deps/hiredis/ssl.c", "content": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo \n * Copyright (c) 2010-2011, Pieter Noordhuis \n * Copyright (c) 2019, Redis Labs\n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \"hiredis.h\"\n#include \"async.h\"\n#include \"net.h\"\n\n#include \n#include \n#include \n#ifdef _WIN32\n#include \n#include \n#ifdef OPENSSL_IS_BORINGSSL\n#undef X509_NAME\n#undef X509_EXTENSIONS\n#undef PKCS7_ISSUER_AND_SERIAL\n#undef PKCS7_SIGNER_INFO\n#undef OCSP_REQUEST\n#undef OCSP_RESPONSE\n#endif\n#else\n#include \n#endif\n\n#include \n#include \n\n#include \"win32.h\"\n#include \"async_private.h\"\n#include \"hiredis_ssl.h\"\n\n#define OPENSSL_1_1_0 0x10100000L\n\nvoid __redisSetError(redisContext *c, int type, const char *str);\n\nstruct redisSSLContext {\n /* Associated OpenSSL SSL_CTX as created by redisCreateSSLContext() */\n SSL_CTX *ssl_ctx;\n\n /* Requested SNI, or NULL */\n char *server_name;\n};\n\n/* The SSL connection context is attached to SSL/TLS connections as a privdata. */\ntypedef struct redisSSL {\n /**\n * OpenSSL SSL object.\n */\n SSL *ssl;\n\n /**\n * SSL_write() requires to be called again with the same arguments it was\n * previously called with in the event of an SSL_read/SSL_write situation\n */\n size_t lastLen;\n\n /** Whether the SSL layer requires read (possibly before a write) */\n int wantRead;\n\n /**\n * Whether a write was requested prior to a read. If set, the write()\n * should resume whenever a read takes place, if possible\n */\n int pendingWrite;\n} redisSSL;\n\n/* Forward declaration */\nredisContextFuncs redisContextSSLFuncs;\n\n/**\n * OpenSSL global initialization and locking handling callbacks.\n * Note that this is only required for OpenSSL < 1.1.0.\n */\n\n#if OPENSSL_VERSION_NUMBER < OPENSSL_1_1_0\n#define HIREDIS_USE_CRYPTO_LOCKS\n#endif\n\n#ifdef HIREDIS_USE_CRYPTO_LOCKS\n#ifdef _WIN32\ntypedef CRITICAL_SECTION sslLockType;\nstatic void sslLockInit(sslLockType* l) {\n InitializeCriticalSection(l);\n}\nstatic void sslLockAcquire(sslLockType* l) {\n EnterCriticalSection(l);\n}\nstatic void sslLockRelease(sslLockType* l) {\n LeaveCriticalSection(l);\n}\n#else\ntypedef pthread_mutex_t sslLockType;\nstatic void sslLockInit(sslLockType *l) {\n pthread_mutex_init(l, NULL);\n}\nstatic void sslLockAcquire(sslLockType *l) {\n pthread_mutex_lock(l);\n}\nstatic void sslLockRelease(sslLockType *l) {\n pthread_mutex_unlock(l);\n}\n#endif\n\nstatic sslLockType* ossl_locks;\n\nstatic void opensslDoLock(int mode, int lkid, const char *f, int line) {\n sslLockType *l = ossl_locks + lkid;\n\n if (mode & CRYPTO_LOCK) {\n sslLockAcquire(l);\n } else {\n sslLockRelease(l);\n }\n\n (void)f;\n (void)line;\n}\n\nstatic int initOpensslLocks(void) {\n unsigned ii, nlocks;\n if (CRYPTO_get_locking_callback() != NULL) {\n /* Someone already set the callback before us. Don't destroy it! */\n return REDIS_OK;\n }\n nlocks = CRYPTO_num_locks();\n ossl_locks = hi_malloc(sizeof(*ossl_locks) * nlocks);\n if (ossl_locks == NULL)\n return REDIS_ERR;\n\n for (ii = 0; ii < nlocks; ii++) {\n sslLockInit(ossl_locks + ii);\n }\n CRYPTO_set_locking_callback(opensslDoLock);\n return REDIS_OK;\n}\n#endif /* HIREDIS_USE_CRYPTO_LOCKS */\n\nint redisInitOpenSSL(void)\n{\n SSL_library_init();\n#ifdef HIREDIS_USE_CRYPTO_LOCKS\n initOpensslLocks();\n#endif\n\n return REDIS_OK;\n}\n\n/**\n * redisSSLContext helper context destruction.\n */\n\nconst char *redisSSLContextGetError(redisSSLContextError error)\n{\n switch (error) {\n case REDIS_SSL_CTX_NONE:\n return \"No Error\";\n case REDIS_SSL_CTX_CREATE_FAILED:\n return \"Failed to create OpenSSL SSL_CTX\";\n case REDIS_SSL_CTX_CERT_KEY_REQUIRED:\n return \"Client cert and key must both be specified or skipped\";\n case REDIS_SSL_CTX_CA_CERT_LOAD_FAILED:\n return \"Failed to load CA Certificate or CA Path\";\n case REDIS_SSL_CTX_CLIENT_CERT_LOAD_FAILED:\n return \"Failed to load client certificate\";\n case REDIS_SSL_CTX_PRIVATE_KEY_LOAD_FAILED:\n return \"Failed to load private key\";\n case REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED:\n return \"Failed to open system certificate store\";\n case REDIS_SSL_CTX_OS_CERT_ADD_FAILED:\n return \"Failed to add CA certificates obtained from system to the SSL context\";\n default:\n return \"Unknown error code\";\n }\n}\n\nvoid redisFreeSSLContext(redisSSLContext *ctx)\n{\n if (!ctx)\n return;\n\n if (ctx->server_name) {\n hi_free(ctx->server_name);\n ctx->server_name = NULL;\n }\n\n if (ctx->ssl_ctx) {\n SSL_CTX_free(ctx->ssl_ctx);\n ctx->ssl_ctx = NULL;\n }\n\n hi_free(ctx);\n}\n\n\n/**\n * redisSSLContext helper context initialization.\n */\n\nredisSSLContext *redisCreateSSLContext(const char *cacert_filename, const char *capath,\n const char *cert_filename, const char *private_key_filename,\n const char *server_name, redisSSLContextError *error)\n{\n redisSSLOptions options = {\n .cacert_filename = cacert_filename,\n .capath = capath,\n .cert_filename = cert_filename,\n .private_key_filename = private_key_filename,\n .server_name = server_name,\n .verify_mode = REDIS_SSL_VERIFY_PEER,\n };\n\n return redisCreateSSLContextWithOptions(&options, error);\n}\n\nredisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *options, redisSSLContextError *error) {\n const char *cacert_filename = options->cacert_filename;\n const char *capath = options->capath;\n const char *cert_filename = options->cert_filename;\n const char *private_key_filename = options->private_key_filename;\n const char *server_name = options->server_name;\n\n#ifdef _WIN32\n HCERTSTORE win_store = NULL;\n PCCERT_CONTEXT win_ctx = NULL;\n#endif\n\n redisSSLContext *ctx = hi_calloc(1, sizeof(redisSSLContext));\n if (ctx == NULL)\n goto error;\n\n const SSL_METHOD *ssl_method;\n#if OPENSSL_VERSION_NUMBER >= OPENSSL_1_1_0\n ssl_method = TLS_client_method();\n#else\n ssl_method = SSLv23_client_method();\n#endif\n\n ctx->ssl_ctx = SSL_CTX_new(ssl_method);\n if (!ctx->ssl_ctx) {\n if (error) *error = REDIS_SSL_CTX_CREATE_FAILED;\n goto error;\n }\n\n#if OPENSSL_VERSION_NUMBER >= OPENSSL_1_1_0\n SSL_CTX_set_min_proto_version(ctx->ssl_ctx, TLS1_2_VERSION);\n#else\n SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1);\n#endif\n\n SSL_CTX_set_verify(ctx->ssl_ctx, options->verify_mode, NULL);\n\n if ((cert_filename != NULL && private_key_filename == NULL) ||\n (private_key_filename != NULL && cert_filename == NULL)) {\n if (error) *error = REDIS_SSL_CTX_CERT_KEY_REQUIRED;\n goto error;\n }\n\n if (capath || cacert_filename) {\n#ifdef _WIN32\n if (0 == strcmp(cacert_filename, \"wincert\")) {\n win_store = CertOpenSystemStore(NULL, \"Root\");\n if (!win_store) {\n if (error) *error = REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED;\n goto error;\n }\n X509_STORE* store = SSL_CTX_get_cert_store(ctx->ssl_ctx);\n while (win_ctx = CertEnumCertificatesInStore(win_store, win_ctx)) {\n X509* x509 = NULL;\n x509 = d2i_X509(NULL, (const unsigned char**)&win_ctx->pbCertEncoded, win_ctx->cbCertEncoded);\n if (x509) {\n if ((1 != X509_STORE_add_cert(store, x509)) ||\n (1 != SSL_CTX_add_client_CA(ctx->ssl_ctx, x509)))\n {\n if (error) *error = REDIS_SSL_CTX_OS_CERT_ADD_FAILED;\n goto error;\n }\n X509_free(x509);\n }\n }\n CertFreeCertificateContext(win_ctx);\n CertCloseStore(win_store, 0);\n } else\n#endif\n if (!SSL_CTX_load_verify_locations(ctx->ssl_ctx, cacert_filename, capath)) {\n if (error) *error = REDIS_SSL_CTX_CA_CERT_LOAD_FAILED;\n goto error;\n }\n } else {\n if (!SSL_CTX_set_default_verify_paths(ctx->ssl_ctx)) {\n if (error) *error = REDIS_SSL_CTX_CLIENT_DEFAULT_CERT_FAILED;\n goto error;\n }\n }\n\n if (cert_filename) {\n if (!SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx, cert_filename)) {\n if (error) *error = REDIS_SSL_CTX_CLIENT_CERT_LOAD_FAILED;\n goto error;\n }\n if (!SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, private_key_filename, SSL_FILETYPE_PEM)) {\n if (error) *error = REDIS_SSL_CTX_PRIVATE_KEY_LOAD_FAILED;\n goto error;\n }\n }\n\n if (server_name)\n ctx->server_name = hi_strdup(server_name);\n\n return ctx;\n\nerror:\n#ifdef _WIN32\n CertFreeCertificateContext(win_ctx);\n CertCloseStore(win_store, 0);\n#endif\n redisFreeSSLContext(ctx);\n return NULL;\n}\n\n/**\n * SSL Connection initialization.\n */\n\n\nstatic int redisSSLConnect(redisContext *c, SSL *ssl) {\n if (c->privctx) {\n __redisSetError(c, REDIS_ERR_OTHER, \"redisContext was already associated\");\n return REDIS_ERR;\n }\n\n redisSSL *rssl = hi_calloc(1, sizeof(redisSSL));\n if (rssl == NULL) {\n __redisSetError(c, REDIS_ERR_OOM, \"Out of memory\");\n return REDIS_ERR;\n }\n\n c->funcs = &redisContextSSLFuncs;\n rssl->ssl = ssl;\n\n SSL_set_mode(rssl->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);\n SSL_set_fd(rssl->ssl, c->fd);\n SSL_set_connect_state(rssl->ssl);\n\n ERR_clear_error();\n int rv = SSL_connect(rssl->ssl);\n if (rv == 1) {\n c->privctx = rssl;\n return REDIS_OK;\n }\n\n rv = SSL_get_error(rssl->ssl, rv);\n if (((c->flags & REDIS_BLOCK) == 0) &&\n (rv == SSL_ERROR_WANT_READ || rv == SSL_ERROR_WANT_WRITE)) {\n c->privctx = rssl;\n return REDIS_OK;\n }\n\n if (c->err == 0) {\n char err[512];\n if (rv == SSL_ERROR_SYSCALL)\n snprintf(err,sizeof(err)-1,\"SSL_connect failed: %s\",strerror(errno));\n else {\n unsigned long e = ERR_peek_last_error();\n snprintf(err,sizeof(err)-1,\"SSL_connect failed: %s\",\n ERR_reason_error_string(e));\n }\n __redisSetError(c, REDIS_ERR_IO, err);\n }\n\n hi_free(rssl);\n return REDIS_ERR;\n}\n\n/**\n * A wrapper around redisSSLConnect() for users who manage their own context and\n * create their own SSL object.\n */\n\nint redisInitiateSSL(redisContext *c, SSL *ssl) {\n return redisSSLConnect(c, ssl);\n}\n\n/**\n * A wrapper around redisSSLConnect() for users who use redisSSLContext and don't\n * manage their own SSL objects.\n */\n\nint redisInitiateSSLWithContext(redisContext *c, redisSSLContext *redis_ssl_ctx)\n{\n if (!c || !redis_ssl_ctx)\n return REDIS_ERR;\n\n /* We want to verify that redisSSLConnect() won't fail on this, as it will\n * not own the SSL object in that case and we'll end up leaking.\n */\n if (c->privctx)\n return REDIS_ERR;\n\n SSL *ssl = SSL_new(redis_ssl_ctx->ssl_ctx);\n if (!ssl) {\n __redisSetError(c, REDIS_ERR_OTHER, \"Couldn't create new SSL instance\");\n goto error;\n }\n\n if (redis_ssl_ctx->server_name) {\n if (!SSL_set_tlsext_host_name(ssl, redis_ssl_ctx->server_name)) {\n __redisSetError(c, REDIS_ERR_OTHER, \"Failed to set server_name/SNI\");\n goto error;\n }\n }\n\n if (redisSSLConnect(c, ssl) != REDIS_OK) {\n goto error;\n }\n\n return REDIS_OK;\n\nerror:\n if (ssl)\n SSL_free(ssl);\n return REDIS_ERR;\n}\n\nstatic int maybeCheckWant(redisSSL *rssl, int rv) {\n /**\n * If the error is WANT_READ or WANT_WRITE, the appropriate flags are set\n * and true is returned. False is returned otherwise\n */\n if (rv == SSL_ERROR_WANT_READ) {\n rssl->wantRead = 1;\n return 1;\n } else if (rv == SSL_ERROR_WANT_WRITE) {\n rssl->pendingWrite = 1;\n return 1;\n } else {\n return 0;\n }\n}\n\n/**\n * Implementation of redisContextFuncs for SSL connections.\n */\n\nstatic void redisSSLFree(void *privctx){\n redisSSL *rsc = privctx;\n\n if (!rsc) return;\n if (rsc->ssl) {\n SSL_free(rsc->ssl);\n rsc->ssl = NULL;\n }\n hi_free(rsc);\n}\n\nstatic ssize_t redisSSLRead(redisContext *c, char *buf, size_t bufcap) {\n redisSSL *rssl = c->privctx;\n\n int nread = SSL_read(rssl->ssl, buf, bufcap);\n if (nread > 0) {\n return nread;\n } else if (nread == 0) {\n __redisSetError(c, REDIS_ERR_EOF, \"Server closed the connection\");\n return -1;\n } else {\n int err = SSL_get_error(rssl->ssl, nread);\n if (c->flags & REDIS_BLOCK) {\n /**\n * In blocking mode, we should never end up in a situation where\n * we get an error without it being an actual error, except\n * in the case of EINTR, which can be spuriously received from\n * debuggers or whatever.\n */\n if (errno == EINTR) {\n return 0;\n } else {\n const char *msg = NULL;\n if (errno == EAGAIN) {\n msg = \"Resource temporarily unavailable\";\n }\n __redisSetError(c, REDIS_ERR_IO, msg);\n return -1;\n }\n }\n\n /**\n * We can very well get an EWOULDBLOCK/EAGAIN, however\n */\n if (maybeCheckWant(rssl, err)) {\n return 0;\n } else {\n __redisSetError(c, REDIS_ERR_IO, NULL);\n return -1;\n }\n }\n}\n\nstatic ssize_t redisSSLWrite(redisContext *c) {\n redisSSL *rssl = c->privctx;\n\n size_t len = rssl->lastLen ? rssl->lastLen : hi_sdslen(c->obuf);\n int rv = SSL_write(rssl->ssl, c->obuf, len);\n\n if (rv > 0) {\n rssl->lastLen = 0;\n } else if (rv < 0) {\n rssl->lastLen = len;\n\n int err = SSL_get_error(rssl->ssl, rv);\n if ((c->flags & REDIS_BLOCK) == 0 && maybeCheckWant(rssl, err)) {\n return 0;\n } else {\n __redisSetError(c, REDIS_ERR_IO, NULL);\n return -1;\n }\n }\n return rv;\n}\n\nstatic void redisSSLAsyncRead(redisAsyncContext *ac) {\n int rv;\n redisSSL *rssl = ac->c.privctx;\n redisContext *c = &ac->c;\n\n rssl->wantRead = 0;\n\n if (rssl->pendingWrite) {\n int done;\n\n /* This is probably just a write event */\n rssl->pendingWrite = 0;\n rv = redisBufferWrite(c, &done);\n if (rv == REDIS_ERR) {\n __redisAsyncDisconnect(ac);\n return;\n } else if (!done) {\n _EL_ADD_WRITE(ac);\n }\n }\n\n rv = redisBufferRead(c);\n if (rv == REDIS_ERR) {\n __redisAsyncDisconnect(ac);\n } else {\n _EL_ADD_READ(ac);\n redisProcessCallbacks(ac);\n }\n}\n\nstatic void redisSSLAsyncWrite(redisAsyncContext *ac) {\n int rv, done = 0;\n redisSSL *rssl = ac->c.privctx;\n redisContext *c = &ac->c;\n\n rssl->pendingWrite = 0;\n rv = redisBufferWrite(c, &done);\n if (rv == REDIS_ERR) {\n __redisAsyncDisconnect(ac);\n return;\n }\n\n if (!done) {\n if (rssl->wantRead) {\n /* Need to read-before-write */\n rssl->pendingWrite = 1;\n _EL_DEL_WRITE(ac);\n } else {\n /* No extra reads needed, just need to write more */\n _EL_ADD_WRITE(ac);\n }\n } else {\n /* Already done! */\n _EL_DEL_WRITE(ac);\n }\n\n /* Always reschedule a read */\n _EL_ADD_READ(ac);\n}\n\nredisContextFuncs redisContextSSLFuncs = {\n .close = redisNetClose,\n .free_privctx = redisSSLFree,\n .async_read = redisSSLAsyncRead,\n .async_write = redisSSLAsyncWrite,\n .read = redisSSLRead,\n .write = redisSSLWrite\n};\n\n" }, { "path": "deps/hiredis/test.c", "content": "#include \"fmacros.h\"\n#include \"sockcompat.h\"\n#include \n#include \n#include \n#ifndef _WIN32\n#include \n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n\n#include \"hiredis.h\"\n#include \"async.h\"\n#include \"adapters/poll.h\"\n#ifdef HIREDIS_TEST_SSL\n#include \"hiredis_ssl.h\"\n#endif\n#ifdef HIREDIS_TEST_ASYNC\n#include \"adapters/libevent.h\"\n#include \n#endif\n#include \"net.h\"\n#include \"win32.h\"\n\nenum connection_type {\n CONN_TCP,\n CONN_UNIX,\n CONN_FD,\n CONN_SSL\n};\n\nstruct config {\n enum connection_type type;\n struct timeval connect_timeout;\n\n struct {\n const char *host;\n int port;\n } tcp;\n\n struct {\n const char *path;\n } unix_sock;\n\n struct {\n const char *host;\n int port;\n const char *ca_cert;\n const char *cert;\n const char *key;\n } ssl;\n};\n\nstruct privdata {\n int dtor_counter;\n};\n\nstruct pushCounters {\n int nil;\n int str;\n};\n\nstatic int insecure_calloc_calls;\n\n#ifdef HIREDIS_TEST_SSL\nredisSSLContext *_ssl_ctx = NULL;\n#endif\n\n/* The following lines make up our testing \"framework\" :) */\nstatic int tests = 0, fails = 0, skips = 0;\n#define test(_s) { printf(\"#%02d \", ++tests); printf(_s); }\n#define test_cond(_c) if(_c) printf(\"\\033[0;32mPASSED\\033[0;0m\\n\"); else {printf(\"\\033[0;31mFAILED\\033[0;0m\\n\"); fails++;}\n#define test_skipped() { printf(\"\\033[01;33mSKIPPED\\033[0;0m\\n\"); skips++; }\n\nstatic void millisleep(int ms)\n{\n#ifdef _MSC_VER\n Sleep(ms);\n#else\n usleep(ms*1000);\n#endif\n}\n\nstatic long long usec(void) {\n#ifndef _MSC_VER\n struct timeval tv;\n gettimeofday(&tv,NULL);\n return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;\n#else\n FILETIME ft;\n GetSystemTimeAsFileTime(&ft);\n return (((long long)ft.dwHighDateTime << 32) | ft.dwLowDateTime) / 10;\n#endif\n}\n\n/* The assert() calls below have side effects, so we need assert()\n * even if we are compiling without asserts (-DNDEBUG). */\n#ifdef NDEBUG\n#undef assert\n#define assert(e) (void)(e)\n#endif\n\n/* Helper to extract Redis version information. Aborts on any failure. */\n#define REDIS_VERSION_FIELD \"redis_version:\"\nvoid get_redis_version(redisContext *c, int *majorptr, int *minorptr) {\n redisReply *reply;\n char *eptr, *s, *e;\n int major, minor;\n\n reply = redisCommand(c, \"INFO\");\n if (reply == NULL || c->err || reply->type != REDIS_REPLY_STRING)\n goto abort;\n if ((s = strstr(reply->str, REDIS_VERSION_FIELD)) == NULL)\n goto abort;\n\n s += strlen(REDIS_VERSION_FIELD);\n\n /* We need a field terminator and at least 'x.y.z' (5) bytes of data */\n if ((e = strstr(s, \"\\r\\n\")) == NULL || (e - s) < 5)\n goto abort;\n\n /* Extract version info */\n major = strtol(s, &eptr, 10);\n if (*eptr != '.') goto abort;\n minor = strtol(eptr+1, NULL, 10);\n\n /* Push info the caller wants */\n if (majorptr) *majorptr = major;\n if (minorptr) *minorptr = minor;\n\n freeReplyObject(reply);\n return;\n\nabort:\n freeReplyObject(reply);\n fprintf(stderr, \"Error: Cannot determine Redis version, aborting\\n\");\n exit(1);\n}\n\nstatic redisContext *select_database(redisContext *c) {\n redisReply *reply;\n\n /* Switch to DB 9 for testing, now that we know we can chat. */\n reply = redisCommand(c,\"SELECT 9\");\n assert(reply != NULL);\n freeReplyObject(reply);\n\n /* Make sure the DB is emtpy */\n reply = redisCommand(c,\"DBSIZE\");\n assert(reply != NULL);\n if (reply->type == REDIS_REPLY_INTEGER && reply->integer == 0) {\n /* Awesome, DB 9 is empty and we can continue. */\n freeReplyObject(reply);\n } else {\n printf(\"Database #9 is not empty, test can not continue\\n\");\n exit(1);\n }\n\n return c;\n}\n\n/* Switch protocol */\nstatic void send_hello(redisContext *c, int version) {\n redisReply *reply;\n int expected;\n\n reply = redisCommand(c, \"HELLO %d\", version);\n expected = version == 3 ? REDIS_REPLY_MAP : REDIS_REPLY_ARRAY;\n assert(reply != NULL && reply->type == expected);\n freeReplyObject(reply);\n}\n\n/* Togggle client tracking */\nstatic void send_client_tracking(redisContext *c, const char *str) {\n redisReply *reply;\n\n reply = redisCommand(c, \"CLIENT TRACKING %s\", str);\n assert(reply != NULL && reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n}\n\nstatic int disconnect(redisContext *c, int keep_fd) {\n redisReply *reply;\n\n /* Make sure we're on DB 9. */\n reply = redisCommand(c,\"SELECT 9\");\n assert(reply != NULL);\n freeReplyObject(reply);\n reply = redisCommand(c,\"FLUSHDB\");\n assert(reply != NULL);\n freeReplyObject(reply);\n\n /* Free the context as well, but keep the fd if requested. */\n if (keep_fd)\n return redisFreeKeepFd(c);\n redisFree(c);\n return -1;\n}\n\nstatic void do_ssl_handshake(redisContext *c) {\n#ifdef HIREDIS_TEST_SSL\n redisInitiateSSLWithContext(c, _ssl_ctx);\n if (c->err) {\n printf(\"SSL error: %s\\n\", c->errstr);\n redisFree(c);\n exit(1);\n }\n#else\n (void) c;\n#endif\n}\n\nstatic redisContext *do_connect(struct config config) {\n redisContext *c = NULL;\n\n if (config.type == CONN_TCP) {\n c = redisConnect(config.tcp.host, config.tcp.port);\n } else if (config.type == CONN_SSL) {\n c = redisConnect(config.ssl.host, config.ssl.port);\n } else if (config.type == CONN_UNIX) {\n c = redisConnectUnix(config.unix_sock.path);\n } else if (config.type == CONN_FD) {\n /* Create a dummy connection just to get an fd to inherit */\n redisContext *dummy_ctx = redisConnectUnix(config.unix_sock.path);\n if (dummy_ctx) {\n int fd = disconnect(dummy_ctx, 1);\n printf(\"Connecting to inherited fd %d\\n\", fd);\n c = redisConnectFd(fd);\n }\n } else {\n assert(NULL);\n }\n\n if (c == NULL) {\n printf(\"Connection error: can't allocate redis context\\n\");\n exit(1);\n } else if (c->err) {\n printf(\"Connection error: %s\\n\", c->errstr);\n redisFree(c);\n exit(1);\n }\n\n if (config.type == CONN_SSL) {\n do_ssl_handshake(c);\n }\n\n return select_database(c);\n}\n\nstatic void do_reconnect(redisContext *c, struct config config) {\n redisReconnect(c);\n\n if (config.type == CONN_SSL) {\n do_ssl_handshake(c);\n }\n}\n\nstatic void test_format_commands(void) {\n char *cmd;\n int len;\n\n test(\"Format command without interpolation: \");\n len = redisFormatCommand(&cmd,\"SET foo bar\");\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(3+2));\n hi_free(cmd);\n\n test(\"Format command with %%s string interpolation: \");\n len = redisFormatCommand(&cmd,\"SET %s %s\",\"foo\",\"bar\");\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(3+2));\n hi_free(cmd);\n\n test(\"Format command with %%s and an empty string: \");\n len = redisFormatCommand(&cmd,\"SET %s %s\",\"foo\",\"\");\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$0\\r\\n\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(0+2));\n hi_free(cmd);\n\n test(\"Format command with an empty string in between proper interpolations: \");\n len = redisFormatCommand(&cmd,\"SET %s %s\",\"\",\"foo\");\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$0\\r\\n\\r\\n$3\\r\\nfoo\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(0+2)+4+(3+2));\n hi_free(cmd);\n\n test(\"Format command with %%b string interpolation: \");\n len = redisFormatCommand(&cmd,\"SET %b %b\",\"foo\",(size_t)3,\"b\\0r\",(size_t)3);\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$3\\r\\nb\\0r\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(3+2));\n hi_free(cmd);\n\n test(\"Format command with %%b and an empty string: \");\n len = redisFormatCommand(&cmd,\"SET %b %b\",\"foo\",(size_t)3,\"\",(size_t)0);\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$0\\r\\n\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(0+2));\n hi_free(cmd);\n\n test(\"Format command with literal %%: \");\n len = redisFormatCommand(&cmd,\"SET %% %%\");\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$1\\r\\n%\\r\\n$1\\r\\n%\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(1+2)+4+(1+2));\n hi_free(cmd);\n\n /* Vararg width depends on the type. These tests make sure that the\n * width is correctly determined using the format and subsequent varargs\n * can correctly be interpolated. */\n#define INTEGER_WIDTH_TEST(fmt, type) do { \\\n type value = 123; \\\n test(\"Format command with printf-delegation (\" #type \"): \"); \\\n len = redisFormatCommand(&cmd,\"key:%08\" fmt \" str:%s\", value, \"hello\"); \\\n test_cond(strncmp(cmd,\"*2\\r\\n$12\\r\\nkey:00000123\\r\\n$9\\r\\nstr:hello\\r\\n\",len) == 0 && \\\n len == 4+5+(12+2)+4+(9+2)); \\\n hi_free(cmd); \\\n} while(0)\n\n#define FLOAT_WIDTH_TEST(type) do { \\\n type value = 123.0; \\\n test(\"Format command with printf-delegation (\" #type \"): \"); \\\n len = redisFormatCommand(&cmd,\"key:%08.3f str:%s\", value, \"hello\"); \\\n test_cond(strncmp(cmd,\"*2\\r\\n$12\\r\\nkey:0123.000\\r\\n$9\\r\\nstr:hello\\r\\n\",len) == 0 && \\\n len == 4+5+(12+2)+4+(9+2)); \\\n hi_free(cmd); \\\n} while(0)\n\n INTEGER_WIDTH_TEST(\"d\", int);\n INTEGER_WIDTH_TEST(\"hhd\", char);\n INTEGER_WIDTH_TEST(\"hd\", short);\n INTEGER_WIDTH_TEST(\"ld\", long);\n INTEGER_WIDTH_TEST(\"lld\", long long);\n INTEGER_WIDTH_TEST(\"u\", unsigned int);\n INTEGER_WIDTH_TEST(\"hhu\", unsigned char);\n INTEGER_WIDTH_TEST(\"hu\", unsigned short);\n INTEGER_WIDTH_TEST(\"lu\", unsigned long);\n INTEGER_WIDTH_TEST(\"llu\", unsigned long long);\n FLOAT_WIDTH_TEST(float);\n FLOAT_WIDTH_TEST(double);\n\n test(\"Format command with unhandled printf format (specifier 'p' not supported): \");\n len = redisFormatCommand(&cmd,\"key:%08p %b\",(void*)1234,\"foo\",(size_t)3);\n test_cond(len == -1);\n\n test(\"Format command with invalid printf format (specifier missing): \");\n len = redisFormatCommand(&cmd,\"%-\");\n test_cond(len == -1);\n\n const char *argv[3];\n argv[0] = \"SET\";\n argv[1] = \"foo\\0xxx\";\n argv[2] = \"bar\";\n size_t lens[3] = { 3, 7, 3 };\n int argc = 3;\n\n test(\"Format command by passing argc/argv without lengths: \");\n len = redisFormatCommandArgv(&cmd,argc,argv,NULL);\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(3+2));\n hi_free(cmd);\n\n test(\"Format command by passing argc/argv with lengths: \");\n len = redisFormatCommandArgv(&cmd,argc,argv,lens);\n test_cond(strncmp(cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$7\\r\\nfoo\\0xxx\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(7+2)+4+(3+2));\n hi_free(cmd);\n\n hisds sds_cmd;\n\n sds_cmd = NULL;\n test(\"Format command into hisds by passing argc/argv without lengths: \");\n len = redisFormatSdsCommandArgv(&sds_cmd,argc,argv,NULL);\n test_cond(strncmp(sds_cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$3\\r\\nfoo\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(3+2)+4+(3+2));\n hi_sdsfree(sds_cmd);\n\n sds_cmd = NULL;\n test(\"Format command into hisds by passing argc/argv with lengths: \");\n len = redisFormatSdsCommandArgv(&sds_cmd,argc,argv,lens);\n test_cond(strncmp(sds_cmd,\"*3\\r\\n$3\\r\\nSET\\r\\n$7\\r\\nfoo\\0xxx\\r\\n$3\\r\\nbar\\r\\n\",len) == 0 &&\n len == 4+4+(3+2)+4+(7+2)+4+(3+2));\n hi_sdsfree(sds_cmd);\n}\n\nstatic void test_append_formatted_commands(struct config config) {\n redisContext *c;\n redisReply *reply;\n char *cmd;\n int len;\n\n c = do_connect(config);\n\n test(\"Append format command: \");\n\n len = redisFormatCommand(&cmd, \"SET foo bar\");\n\n test_cond(redisAppendFormattedCommand(c, cmd, len) == REDIS_OK);\n\n assert(redisGetReply(c, (void*)&reply) == REDIS_OK);\n\n hi_free(cmd);\n freeReplyObject(reply);\n\n disconnect(c, 0);\n}\n\nstatic void test_tcp_options(struct config cfg) {\n redisContext *c;\n\n c = do_connect(cfg);\n\n test(\"We can enable TCP_KEEPALIVE: \");\n test_cond(redisEnableKeepAlive(c) == REDIS_OK);\n\n#ifdef TCP_USER_TIMEOUT\n test(\"We can set TCP_USER_TIMEOUT: \");\n test_cond(redisSetTcpUserTimeout(c, 100) == REDIS_OK);\n#else\n test(\"Setting TCP_USER_TIMEOUT errors when unsupported: \");\n test_cond(redisSetTcpUserTimeout(c, 100) == REDIS_ERR && c->err == REDIS_ERR_IO);\n#endif\n\n redisFree(c);\n}\n\nstatic void test_reply_reader(void) {\n redisReader *reader;\n void *reply, *root;\n int ret;\n int i;\n\n test(\"Error handling in reply parser: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\"@foo\\r\\n\",6);\n ret = redisReaderGetReply(reader,NULL);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Protocol error, got \\\"@\\\" as reply type byte\") == 0);\n redisReaderFree(reader);\n\n /* when the reply already contains multiple items, they must be free'd\n * on an error. valgrind will bark when this doesn't happen. */\n test(\"Memory cleanup in reply parser: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\"*2\\r\\n\",4);\n redisReaderFeed(reader,(char*)\"$5\\r\\nhello\\r\\n\",11);\n redisReaderFeed(reader,(char*)\"@foo\\r\\n\",6);\n ret = redisReaderGetReply(reader,NULL);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Protocol error, got \\\"@\\\" as reply type byte\") == 0);\n redisReaderFree(reader);\n\n reader = redisReaderCreate();\n test(\"Can handle arbitrarily nested multi-bulks: \");\n for (i = 0; i < 128; i++) {\n redisReaderFeed(reader,(char*)\"*1\\r\\n\", 4);\n }\n redisReaderFeed(reader,(char*)\"$6\\r\\nLOLWUT\\r\\n\",12);\n ret = redisReaderGetReply(reader,&reply);\n root = reply; /* Keep track of the root reply */\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_ARRAY &&\n ((redisReply*)reply)->elements == 1);\n\n test(\"Can parse arbitrarily nested multi-bulks correctly: \");\n while(i--) {\n assert(reply != NULL && ((redisReply*)reply)->type == REDIS_REPLY_ARRAY);\n reply = ((redisReply*)reply)->element[0];\n }\n test_cond(((redisReply*)reply)->type == REDIS_REPLY_STRING &&\n !memcmp(((redisReply*)reply)->str, \"LOLWUT\", 6));\n freeReplyObject(root);\n redisReaderFree(reader);\n\n test(\"Correctly parses LLONG_MAX: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \":9223372036854775807\\r\\n\",22);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->integer == LLONG_MAX);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error when > LLONG_MAX: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \":9223372036854775808\\r\\n\",22);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bad integer value\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Correctly parses LLONG_MIN: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \":-9223372036854775808\\r\\n\",23);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->integer == LLONG_MIN);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error when < LLONG_MIN: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \":-9223372036854775809\\r\\n\",23);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bad integer value\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error when array < -1: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"*-2\\r\\n+asdf\\r\\n\",12);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Multi-bulk length out of range\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error when bulk < -1: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"$-2\\r\\nasdf\\r\\n\",11);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bulk string length out of range\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can configure maximum multi-bulk elements: \");\n reader = redisReaderCreate();\n reader->maxelements = 1024;\n redisReaderFeed(reader, \"*1025\\r\\n\", 7);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr, \"Multi-bulk length out of range\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Multi-bulk never overflows regardless of maxelements: \");\n size_t bad_mbulk_len = (SIZE_MAX / sizeof(void *)) + 3;\n char bad_mbulk_reply[100];\n snprintf(bad_mbulk_reply, sizeof(bad_mbulk_reply), \"*%llu\\r\\n+asdf\\r\\n\",\n (unsigned long long) bad_mbulk_len);\n\n reader = redisReaderCreate();\n reader->maxelements = 0; /* Don't rely on default limit */\n redisReaderFeed(reader, bad_mbulk_reply, strlen(bad_mbulk_reply));\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR && strcasecmp(reader->errstr, \"Out of memory\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n#if LLONG_MAX > SIZE_MAX\n test(\"Set error when array > SIZE_MAX: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"*9223372036854775807\\r\\n+asdf\\r\\n\",29);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Multi-bulk length out of range\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error when bulk > SIZE_MAX: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"$9223372036854775807\\r\\nasdf\\r\\n\",28);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bulk string length out of range\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n#endif\n\n test(\"Works with NULL functions for reply: \");\n reader = redisReaderCreate();\n reader->fn = NULL;\n redisReaderFeed(reader,(char*)\"+OK\\r\\n\",5);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK && reply == (void*)REDIS_REPLY_STATUS);\n redisReaderFree(reader);\n\n test(\"Works when a single newline (\\\\r\\\\n) covers two calls to feed: \");\n reader = redisReaderCreate();\n reader->fn = NULL;\n redisReaderFeed(reader,(char*)\"+OK\\r\",4);\n ret = redisReaderGetReply(reader,&reply);\n assert(ret == REDIS_OK && reply == NULL);\n redisReaderFeed(reader,(char*)\"\\n\",1);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK && reply == (void*)REDIS_REPLY_STATUS);\n redisReaderFree(reader);\n\n test(\"Don't reset state after protocol error: \");\n reader = redisReaderCreate();\n reader->fn = NULL;\n redisReaderFeed(reader,(char*)\"x\",1);\n ret = redisReaderGetReply(reader,&reply);\n assert(ret == REDIS_ERR);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR && reply == NULL);\n redisReaderFree(reader);\n\n test(\"Don't reset state after protocol error(not segfault): \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\"*3\\r\\n$3\\r\\nSET\\r\\n$5\\r\\nhello\\r\\n$\", 25);\n ret = redisReaderGetReply(reader,&reply);\n assert(ret == REDIS_OK);\n redisReaderFeed(reader,(char*)\"3\\r\\nval\\r\\n\", 8);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_ARRAY &&\n ((redisReply*)reply)->elements == 3);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n /* Regression test for issue #45 on GitHub. */\n test(\"Don't do empty allocation for empty multi bulk: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\"*0\\r\\n\",4);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_ARRAY &&\n ((redisReply*)reply)->elements == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n /* RESP3 verbatim strings (GitHub issue #802) */\n test(\"Can parse RESP3 verbatim strings: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\"=10\\r\\ntxt:LOLWUT\\r\\n\",17);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_VERB &&\n !memcmp(((redisReply*)reply)->str,\"LOLWUT\", 6));\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n /* RESP3 push messages (Github issue #815) */\n test(\"Can parse RESP3 push messages: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,(char*)\">2\\r\\n$6\\r\\nLOLWUT\\r\\n:42\\r\\n\",21);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_PUSH &&\n ((redisReply*)reply)->elements == 2 &&\n ((redisReply*)reply)->element[0]->type == REDIS_REPLY_STRING &&\n !memcmp(((redisReply*)reply)->element[0]->str,\"LOLWUT\",6) &&\n ((redisReply*)reply)->element[1]->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->element[1]->integer == 42);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 doubles: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \",3.14159265358979323846\\r\\n\",25);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&\n fabs(((redisReply*)reply)->dval - 3.14159265358979323846) < 0.00000001 &&\n ((redisReply*)reply)->len == 22 &&\n strcmp(((redisReply*)reply)->str, \"3.14159265358979323846\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error on invalid RESP3 double: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \",3.14159\\000265358979323846\\r\\n\",26);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bad double value\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Correctly parses RESP3 double INFINITY: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \",inf\\r\\n\",6);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&\n isinf(((redisReply*)reply)->dval) &&\n ((redisReply*)reply)->dval > 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Correctly parses RESP3 double NaN: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \",nan\\r\\n\",6);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&\n isnan(((redisReply*)reply)->dval));\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Correctly parses RESP3 double -Nan: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \",-nan\\r\\n\", 7);\n ret = redisReaderGetReply(reader, &reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&\n isnan(((redisReply*)reply)->dval));\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 nil: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"_\\r\\n\",3);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_NIL);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error on invalid RESP3 nil: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"_nil\\r\\n\",6);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bad nil value\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 bool (true): \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"#t\\r\\n\",4);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_BOOL &&\n ((redisReply*)reply)->integer);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 bool (false): \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"#f\\r\\n\",4);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_BOOL &&\n !((redisReply*)reply)->integer);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Set error on invalid RESP3 bool: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"#foobar\\r\\n\",9);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_ERR &&\n strcasecmp(reader->errstr,\"Bad bool value\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 map: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"%2\\r\\n+first\\r\\n:123\\r\\n$6\\r\\nsecond\\r\\n#t\\r\\n\",34);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_MAP &&\n ((redisReply*)reply)->elements == 4 &&\n ((redisReply*)reply)->element[0]->type == REDIS_REPLY_STATUS &&\n ((redisReply*)reply)->element[0]->len == 5 &&\n !strcmp(((redisReply*)reply)->element[0]->str,\"first\") &&\n ((redisReply*)reply)->element[1]->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->element[1]->integer == 123 &&\n ((redisReply*)reply)->element[2]->type == REDIS_REPLY_STRING &&\n ((redisReply*)reply)->element[2]->len == 6 &&\n !strcmp(((redisReply*)reply)->element[2]->str,\"second\") &&\n ((redisReply*)reply)->element[3]->type == REDIS_REPLY_BOOL &&\n ((redisReply*)reply)->element[3]->integer);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 set: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"~5\\r\\n+orange\\r\\n$5\\r\\napple\\r\\n#f\\r\\n:100\\r\\n:999\\r\\n\",40);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_SET &&\n ((redisReply*)reply)->elements == 5 &&\n ((redisReply*)reply)->element[0]->type == REDIS_REPLY_STATUS &&\n ((redisReply*)reply)->element[0]->len == 6 &&\n !strcmp(((redisReply*)reply)->element[0]->str,\"orange\") &&\n ((redisReply*)reply)->element[1]->type == REDIS_REPLY_STRING &&\n ((redisReply*)reply)->element[1]->len == 5 &&\n !strcmp(((redisReply*)reply)->element[1]->str,\"apple\") &&\n ((redisReply*)reply)->element[2]->type == REDIS_REPLY_BOOL &&\n !((redisReply*)reply)->element[2]->integer &&\n ((redisReply*)reply)->element[3]->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->element[3]->integer == 100 &&\n ((redisReply*)reply)->element[4]->type == REDIS_REPLY_INTEGER &&\n ((redisReply*)reply)->element[4]->integer == 999);\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 bignum: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader,\"(3492890328409238509324850943850943825024385\\r\\n\",46);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_BIGNUM &&\n ((redisReply*)reply)->len == 43 &&\n !strcmp(((redisReply*)reply)->str,\"3492890328409238509324850943850943825024385\"));\n freeReplyObject(reply);\n redisReaderFree(reader);\n\n test(\"Can parse RESP3 doubles in an array: \");\n reader = redisReaderCreate();\n redisReaderFeed(reader, \"*1\\r\\n,3.14159265358979323846\\r\\n\",31);\n ret = redisReaderGetReply(reader,&reply);\n test_cond(ret == REDIS_OK &&\n ((redisReply*)reply)->type == REDIS_REPLY_ARRAY &&\n ((redisReply*)reply)->elements == 1 &&\n ((redisReply*)reply)->element[0]->type == REDIS_REPLY_DOUBLE &&\n fabs(((redisReply*)reply)->element[0]->dval - 3.14159265358979323846) < 0.00000001 &&\n ((redisReply*)reply)->element[0]->len == 22 &&\n strcmp(((redisReply*)reply)->element[0]->str, \"3.14159265358979323846\") == 0);\n freeReplyObject(reply);\n redisReaderFree(reader);\n}\n\nstatic void test_free_null(void) {\n void *redisCtx = NULL;\n void *reply = NULL;\n\n test(\"Don't fail when redisFree is passed a NULL value: \");\n redisFree(redisCtx);\n test_cond(redisCtx == NULL);\n\n test(\"Don't fail when freeReplyObject is passed a NULL value: \");\n freeReplyObject(reply);\n test_cond(reply == NULL);\n}\n\nstatic void *hi_malloc_fail(size_t size) {\n (void)size;\n return NULL;\n}\n\nstatic void *hi_calloc_fail(size_t nmemb, size_t size) {\n (void)nmemb;\n (void)size;\n return NULL;\n}\n\nstatic void *hi_calloc_insecure(size_t nmemb, size_t size) {\n (void)nmemb;\n (void)size;\n insecure_calloc_calls++;\n return (void*)0xdeadc0de;\n}\n\nstatic void *hi_realloc_fail(void *ptr, size_t size) {\n (void)ptr;\n (void)size;\n return NULL;\n}\n\nstatic void test_allocator_injection(void) {\n void *ptr;\n\n hiredisAllocFuncs ha = {\n .mallocFn = hi_malloc_fail,\n .callocFn = hi_calloc_fail,\n .reallocFn = hi_realloc_fail,\n .strdupFn = strdup,\n .freeFn = free,\n };\n\n // Override hiredis allocators\n hiredisSetAllocators(&ha);\n\n test(\"redisContext uses injected allocators: \");\n redisContext *c = redisConnect(\"localhost\", 6379);\n test_cond(c == NULL);\n\n test(\"redisReader uses injected allocators: \");\n redisReader *reader = redisReaderCreate();\n test_cond(reader == NULL);\n\n /* Make sure hiredis itself protects against a non-overflow checking calloc */\n test(\"hiredis calloc wrapper protects against overflow: \");\n ha.callocFn = hi_calloc_insecure;\n hiredisSetAllocators(&ha);\n ptr = hi_calloc((SIZE_MAX / sizeof(void*)) + 3, sizeof(void*));\n test_cond(ptr == NULL && insecure_calloc_calls == 0);\n\n // Return allocators to default\n hiredisResetAllocators();\n}\n\n#define HIREDIS_BAD_DOMAIN \"idontexist-noreally.com\"\nstatic void test_blocking_connection_errors(void) {\n struct addrinfo hints = {.ai_family = AF_INET};\n struct addrinfo *ai_tmp = NULL;\n redisContext *c;\n\n int rv = getaddrinfo(HIREDIS_BAD_DOMAIN, \"6379\", &hints, &ai_tmp);\n if (rv != 0) {\n // Address does *not* exist\n test(\"Returns error when host cannot be resolved: \");\n // First see if this domain name *actually* resolves to NXDOMAIN\n c = redisConnect(HIREDIS_BAD_DOMAIN, 6379);\n test_cond(\n c->err == REDIS_ERR_OTHER &&\n (strcmp(c->errstr, \"Name or service not known\") == 0 ||\n strcmp(c->errstr, \"Can't resolve: \" HIREDIS_BAD_DOMAIN) == 0 ||\n strcmp(c->errstr, \"Name does not resolve\") == 0 ||\n strcmp(c->errstr, \"nodename nor servname provided, or not known\") == 0 ||\n strcmp(c->errstr, \"node name or service name not known\") == 0 ||\n strcmp(c->errstr, \"No address associated with hostname\") == 0 ||\n strcmp(c->errstr, \"Temporary failure in name resolution\") == 0 ||\n strcmp(c->errstr, \"hostname nor servname provided, or not known\") == 0 ||\n strcmp(c->errstr, \"no address associated with name\") == 0 ||\n strcmp(c->errstr, \"No such host is known. \") == 0));\n redisFree(c);\n } else {\n printf(\"Skipping NXDOMAIN test. Found evil ISP!\\n\");\n freeaddrinfo(ai_tmp);\n }\n\n#ifndef _WIN32\n redisOptions opt = {0};\n struct timeval tv;\n\n test(\"Returns error when the port is not open: \");\n c = redisConnect((char*)\"localhost\", 1);\n test_cond(c->err == REDIS_ERR_IO &&\n strcmp(c->errstr,\"Connection refused\") == 0);\n redisFree(c);\n\n\n /* Verify we don't regress from the fix in PR #1180 */\n test(\"We don't clobber connection exception with setsockopt error: \");\n tv = (struct timeval){.tv_sec = 0, .tv_usec = 500000};\n opt.command_timeout = opt.connect_timeout = &tv;\n REDIS_OPTIONS_SET_TCP(&opt, \"localhost\", 10337);\n c = redisConnectWithOptions(&opt);\n test_cond(c->err == REDIS_ERR_IO &&\n strcmp(c->errstr, \"Connection refused\") == 0);\n redisFree(c);\n\n test(\"Returns error when the unix_sock socket path doesn't accept connections: \");\n c = redisConnectUnix((char*)\"/tmp/idontexist.sock\");\n test_cond(c->err == REDIS_ERR_IO); /* Don't care about the message... */\n redisFree(c);\n#endif\n}\n\n/* Test push handler */\nvoid push_handler(void *privdata, void *r) {\n struct pushCounters *pcounts = privdata;\n redisReply *reply = r, *payload;\n\n assert(reply && reply->type == REDIS_REPLY_PUSH && reply->elements == 2);\n\n payload = reply->element[1];\n if (payload->type == REDIS_REPLY_ARRAY) {\n payload = payload->element[0];\n }\n\n if (payload->type == REDIS_REPLY_STRING) {\n pcounts->str++;\n } else if (payload->type == REDIS_REPLY_NIL) {\n pcounts->nil++;\n }\n\n freeReplyObject(reply);\n}\n\n/* Dummy function just to test setting a callback with redisOptions */\nvoid push_handler_async(redisAsyncContext *ac, void *reply) {\n (void)ac;\n (void)reply;\n}\n\nstatic void test_resp3_push_handler(redisContext *c) {\n struct pushCounters pc = {0};\n redisPushFn *old = NULL;\n redisReply *reply;\n void *privdata;\n\n /* Switch to RESP3 and turn on client tracking */\n send_hello(c, 3);\n send_client_tracking(c, \"ON\");\n privdata = c->privdata;\n c->privdata = &pc;\n\n reply = redisCommand(c, \"GET key:0\");\n assert(reply != NULL);\n freeReplyObject(reply);\n\n test(\"RESP3 PUSH messages are handled out of band by default: \");\n reply = redisCommand(c, \"SET key:0 val:0\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n\n assert((reply = redisCommand(c, \"GET key:0\")) != NULL);\n freeReplyObject(reply);\n\n old = redisSetPushCallback(c, push_handler);\n test(\"We can set a custom RESP3 PUSH handler: \");\n reply = redisCommand(c, \"SET key:0 val:0\");\n /* We need another command because depending on the version of Redis, the\n * notification may be delivered after the command's reply. */\n assert(reply != NULL);\n freeReplyObject(reply);\n reply = redisCommand(c, \"PING\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && pc.str == 1);\n freeReplyObject(reply);\n\n test(\"We properly handle a NIL invalidation payload: \");\n reply = redisCommand(c, \"FLUSHDB\");\n assert(reply != NULL);\n freeReplyObject(reply);\n reply = redisCommand(c, \"PING\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && pc.nil == 1);\n freeReplyObject(reply);\n\n /* Unset the push callback and generate an invalidate message making\n * sure it is not handled out of band. */\n test(\"With no handler, PUSH replies come in-band: \");\n redisSetPushCallback(c, NULL);\n assert((reply = redisCommand(c, \"GET key:0\")) != NULL);\n freeReplyObject(reply);\n assert((reply = redisCommand(c, \"SET key:0 invalid\")) != NULL);\n /* Depending on Redis version, we may receive either push notification or\n * status reply. Both cases are valid. */\n if (reply->type == REDIS_REPLY_STATUS) {\n freeReplyObject(reply);\n reply = redisCommand(c, \"PING\");\n }\n test_cond(reply->type == REDIS_REPLY_PUSH);\n freeReplyObject(reply);\n\n test(\"With no PUSH handler, no replies are lost: \");\n assert(redisGetReply(c, (void**)&reply) == REDIS_OK);\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n\n /* Return to the originally set PUSH handler */\n assert(old != NULL);\n redisSetPushCallback(c, old);\n\n /* Switch back to RESP2 and disable tracking */\n c->privdata = privdata;\n send_client_tracking(c, \"OFF\");\n send_hello(c, 2);\n}\n\nredisOptions get_redis_tcp_options(struct config config) {\n redisOptions options = {0};\n REDIS_OPTIONS_SET_TCP(&options, config.tcp.host, config.tcp.port);\n return options;\n}\n\nstatic void test_resp3_push_options(struct config config) {\n redisAsyncContext *ac;\n redisContext *c;\n redisOptions options;\n\n test(\"We set a default RESP3 handler for redisContext: \");\n options = get_redis_tcp_options(config);\n assert((c = redisConnectWithOptions(&options)) != NULL);\n test_cond(c->push_cb != NULL);\n redisFree(c);\n\n test(\"We don't set a default RESP3 push handler for redisAsyncContext: \");\n options = get_redis_tcp_options(config);\n assert((ac = redisAsyncConnectWithOptions(&options)) != NULL);\n test_cond(ac->c.push_cb == NULL);\n redisAsyncFree(ac);\n\n test(\"Our REDIS_OPT_NO_PUSH_AUTOFREE flag works: \");\n options = get_redis_tcp_options(config);\n options.options |= REDIS_OPT_NO_PUSH_AUTOFREE;\n assert((c = redisConnectWithOptions(&options)) != NULL);\n test_cond(c->push_cb == NULL);\n redisFree(c);\n\n test(\"We can use redisOptions to set a custom PUSH handler for redisContext: \");\n options = get_redis_tcp_options(config);\n options.push_cb = push_handler;\n assert((c = redisConnectWithOptions(&options)) != NULL);\n test_cond(c->push_cb == push_handler);\n redisFree(c);\n\n test(\"We can use redisOptions to set a custom PUSH handler for redisAsyncContext: \");\n options = get_redis_tcp_options(config);\n options.async_push_cb = push_handler_async;\n assert((ac = redisAsyncConnectWithOptions(&options)) != NULL);\n test_cond(ac->push_cb == push_handler_async);\n redisAsyncFree(ac);\n}\n\nvoid free_privdata(void *privdata) {\n struct privdata *data = privdata;\n data->dtor_counter++;\n}\n\nstatic void test_privdata_hooks(struct config config) {\n struct privdata data = {0};\n redisOptions options;\n redisContext *c;\n\n test(\"We can use redisOptions to set privdata: \");\n options = get_redis_tcp_options(config);\n REDIS_OPTIONS_SET_PRIVDATA(&options, &data, free_privdata);\n assert((c = redisConnectWithOptions(&options)) != NULL);\n test_cond(c->privdata == &data);\n\n test(\"Our privdata destructor fires when we free the context: \");\n redisFree(c);\n test_cond(data.dtor_counter == 1);\n}\n\nstatic void test_blocking_connection(struct config config) {\n redisContext *c;\n redisReply *reply;\n int major;\n\n c = do_connect(config);\n\n test(\"Is able to deliver commands: \");\n reply = redisCommand(c,\"PING\");\n test_cond(reply->type == REDIS_REPLY_STATUS &&\n strcasecmp(reply->str,\"pong\") == 0)\n freeReplyObject(reply);\n\n test(\"Is a able to send commands verbatim: \");\n reply = redisCommand(c,\"SET foo bar\");\n test_cond (reply->type == REDIS_REPLY_STATUS &&\n strcasecmp(reply->str,\"ok\") == 0)\n freeReplyObject(reply);\n\n test(\"%%s String interpolation works: \");\n reply = redisCommand(c,\"SET %s %s\",\"foo\",\"hello world\");\n freeReplyObject(reply);\n reply = redisCommand(c,\"GET foo\");\n test_cond(reply->type == REDIS_REPLY_STRING &&\n strcmp(reply->str,\"hello world\") == 0);\n freeReplyObject(reply);\n\n test(\"%%b String interpolation works: \");\n reply = redisCommand(c,\"SET %b %b\",\"foo\",(size_t)3,\"hello\\x00world\",(size_t)11);\n freeReplyObject(reply);\n reply = redisCommand(c,\"GET foo\");\n test_cond(reply->type == REDIS_REPLY_STRING &&\n memcmp(reply->str,\"hello\\x00world\",11) == 0)\n\n test(\"Binary reply length is correct: \");\n test_cond(reply->len == 11)\n freeReplyObject(reply);\n\n test(\"Can parse nil replies: \");\n reply = redisCommand(c,\"GET nokey\");\n test_cond(reply->type == REDIS_REPLY_NIL)\n freeReplyObject(reply);\n\n /* test 7 */\n test(\"Can parse integer replies: \");\n reply = redisCommand(c,\"INCR mycounter\");\n test_cond(reply->type == REDIS_REPLY_INTEGER && reply->integer == 1)\n freeReplyObject(reply);\n\n test(\"Can parse multi bulk replies: \");\n freeReplyObject(redisCommand(c,\"LPUSH mylist foo\"));\n freeReplyObject(redisCommand(c,\"LPUSH mylist bar\"));\n reply = redisCommand(c,\"LRANGE mylist 0 -1\");\n test_cond(reply->type == REDIS_REPLY_ARRAY &&\n reply->elements == 2 &&\n !memcmp(reply->element[0]->str,\"bar\",3) &&\n !memcmp(reply->element[1]->str,\"foo\",3))\n freeReplyObject(reply);\n\n /* m/e with multi bulk reply *before* other reply.\n * specifically test ordering of reply items to parse. */\n test(\"Can handle nested multi bulk replies: \");\n freeReplyObject(redisCommand(c,\"MULTI\"));\n freeReplyObject(redisCommand(c,\"LRANGE mylist 0 -1\"));\n freeReplyObject(redisCommand(c,\"PING\"));\n reply = (redisCommand(c,\"EXEC\"));\n test_cond(reply->type == REDIS_REPLY_ARRAY &&\n reply->elements == 2 &&\n reply->element[0]->type == REDIS_REPLY_ARRAY &&\n reply->element[0]->elements == 2 &&\n !memcmp(reply->element[0]->element[0]->str,\"bar\",3) &&\n !memcmp(reply->element[0]->element[1]->str,\"foo\",3) &&\n reply->element[1]->type == REDIS_REPLY_STATUS &&\n strcasecmp(reply->element[1]->str,\"pong\") == 0);\n freeReplyObject(reply);\n\n test(\"Send command by passing argc/argv: \");\n const char *argv[3] = {\"SET\", \"foo\", \"bar\"};\n size_t argvlen[3] = {3, 3, 3};\n reply = redisCommandArgv(c,3,argv,argvlen);\n test_cond(reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n\n /* Make sure passing NULL to redisGetReply is safe */\n test(\"Can pass NULL to redisGetReply: \");\n assert(redisAppendCommand(c, \"PING\") == REDIS_OK);\n test_cond(redisGetReply(c, NULL) == REDIS_OK);\n\n get_redis_version(c, &major, NULL);\n if (major >= 6) test_resp3_push_handler(c);\n test_resp3_push_options(config);\n\n test_privdata_hooks(config);\n\n disconnect(c, 0);\n}\n\n/* Send DEBUG SLEEP 0 to detect if we have this command */\nstatic int detect_debug_sleep(redisContext *c) {\n int detected;\n redisReply *reply = redisCommand(c, \"DEBUG SLEEP 0\\r\\n\");\n\n if (reply == NULL || c->err) {\n const char *cause = c->err ? c->errstr : \"(none)\";\n fprintf(stderr, \"Error testing for DEBUG SLEEP (Redis error: %s), exiting\\n\", cause);\n exit(-1);\n }\n\n detected = reply->type == REDIS_REPLY_STATUS;\n freeReplyObject(reply);\n\n return detected;\n}\n\nstatic void test_blocking_connection_timeouts(struct config config) {\n redisContext *c;\n redisReply *reply;\n ssize_t s;\n const char *sleep_cmd = \"DEBUG SLEEP 3\\r\\n\";\n struct timeval tv;\n\n c = do_connect(config);\n test(\"Successfully completes a command when the timeout is not exceeded: \");\n reply = redisCommand(c,\"SET foo fast\");\n freeReplyObject(reply);\n tv.tv_sec = 0;\n tv.tv_usec = 10000;\n redisSetTimeout(c, tv);\n reply = redisCommand(c, \"GET foo\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STRING && memcmp(reply->str, \"fast\", 4) == 0);\n freeReplyObject(reply);\n disconnect(c, 0);\n\n c = do_connect(config);\n test(\"Does not return a reply when the command times out: \");\n if (detect_debug_sleep(c)) {\n redisAppendFormattedCommand(c, sleep_cmd, strlen(sleep_cmd));\n\n // flush connection buffer without waiting for the reply\n s = c->funcs->write(c);\n assert(s == (ssize_t)hi_sdslen(c->obuf));\n hi_sdsfree(c->obuf);\n c->obuf = hi_sdsempty();\n\n tv.tv_sec = 0;\n tv.tv_usec = 10000;\n redisSetTimeout(c, tv);\n reply = redisCommand(c, \"GET foo\");\n#ifndef _WIN32\n test_cond(s > 0 && reply == NULL && c->err == REDIS_ERR_IO &&\n strcmp(c->errstr, \"Resource temporarily unavailable\") == 0);\n#else\n test_cond(s > 0 && reply == NULL && c->err == REDIS_ERR_TIMEOUT &&\n strcmp(c->errstr, \"recv timeout\") == 0);\n#endif\n freeReplyObject(reply);\n\n // wait for the DEBUG SLEEP to complete so that Redis server is unblocked for the following tests\n millisleep(3000);\n } else {\n test_skipped();\n }\n\n test(\"Reconnect properly reconnects after a timeout: \");\n do_reconnect(c, config);\n reply = redisCommand(c, \"PING\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, \"PONG\") == 0);\n freeReplyObject(reply);\n\n test(\"Reconnect properly uses owned parameters: \");\n config.tcp.host = \"foo\";\n config.unix_sock.path = \"foo\";\n do_reconnect(c, config);\n reply = redisCommand(c, \"PING\");\n test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, \"PONG\") == 0);\n freeReplyObject(reply);\n\n disconnect(c, 0);\n}\n\nstatic void test_blocking_io_errors(struct config config) {\n redisContext *c;\n redisReply *reply;\n void *_reply;\n int major, minor;\n\n /* Connect to target given by config. */\n c = do_connect(config);\n get_redis_version(c, &major, &minor);\n\n test(\"Returns I/O error when the connection is lost: \");\n reply = redisCommand(c,\"QUIT\");\n if (major > 2 || (major == 2 && minor > 0)) {\n /* > 2.0 returns OK on QUIT and read() should be issued once more\n * to know the descriptor is at EOF. */\n test_cond(strcasecmp(reply->str,\"OK\") == 0 &&\n redisGetReply(c,&_reply) == REDIS_ERR);\n freeReplyObject(reply);\n } else {\n test_cond(reply == NULL);\n }\n\n#ifndef _WIN32\n /* On 2.0, QUIT will cause the connection to be closed immediately and\n * the read(2) for the reply on QUIT will set the error to EOF.\n * On >2.0, QUIT will return with OK and another read(2) needed to be\n * issued to find out the socket was closed by the server. In both\n * conditions, the error will be set to EOF. */\n assert(c->err == REDIS_ERR_EOF &&\n strcmp(c->errstr,\"Server closed the connection\") == 0);\n#endif\n redisFree(c);\n\n c = do_connect(config);\n test(\"Returns I/O error on socket timeout: \");\n struct timeval tv = { 0, 1000 };\n assert(redisSetTimeout(c,tv) == REDIS_OK);\n int respcode = redisGetReply(c,&_reply);\n#ifndef _WIN32\n test_cond(respcode == REDIS_ERR && c->err == REDIS_ERR_IO && errno == EAGAIN);\n#else\n test_cond(respcode == REDIS_ERR && c->err == REDIS_ERR_TIMEOUT);\n#endif\n redisFree(c);\n}\n\nstatic void test_invalid_timeout_errors(struct config config) {\n redisContext *c;\n\n test(\"Set error when an invalid timeout usec value is used during connect: \");\n\n config.connect_timeout.tv_sec = 0;\n config.connect_timeout.tv_usec = 10000001;\n\n if (config.type == CONN_TCP || config.type == CONN_SSL) {\n c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.connect_timeout);\n } else if(config.type == CONN_UNIX) {\n c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);\n } else {\n assert(NULL);\n }\n\n test_cond(c->err == REDIS_ERR_IO && strcmp(c->errstr, \"Invalid timeout specified\") == 0);\n redisFree(c);\n\n test(\"Set error when an invalid timeout sec value is used during connect: \");\n\n config.connect_timeout.tv_sec = (((LONG_MAX) - 999) / 1000) + 1;\n config.connect_timeout.tv_usec = 0;\n\n if (config.type == CONN_TCP || config.type == CONN_SSL) {\n c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.connect_timeout);\n } else if(config.type == CONN_UNIX) {\n c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);\n } else {\n assert(NULL);\n }\n\n test_cond(c->err == REDIS_ERR_IO && strcmp(c->errstr, \"Invalid timeout specified\") == 0);\n redisFree(c);\n}\n\n/* Wrap malloc to abort on failure so OOM checks don't make the test logic\n * harder to follow. */\nvoid *hi_malloc_safe(size_t size) {\n void *ptr = hi_malloc(size);\n if (ptr == NULL) {\n fprintf(stderr, \"Error: Out of memory\\n\");\n exit(-1);\n }\n\n return ptr;\n}\n\nstatic void test_throughput(struct config config) {\n redisContext *c = do_connect(config);\n redisReply **replies;\n int i, num;\n long long t1, t2;\n\n test(\"Throughput:\\n\");\n for (i = 0; i < 500; i++)\n freeReplyObject(redisCommand(c,\"LPUSH mylist foo\"));\n\n num = 1000;\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n t1 = usec();\n for (i = 0; i < num; i++) {\n replies[i] = redisCommand(c,\"PING\");\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_STATUS);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx PING: %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n t1 = usec();\n for (i = 0; i < num; i++) {\n replies[i] = redisCommand(c,\"LRANGE mylist 0 499\");\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_ARRAY);\n assert(replies[i] != NULL && replies[i]->elements == 500);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx LRANGE with 500 elements: %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n t1 = usec();\n for (i = 0; i < num; i++) {\n replies[i] = redisCommand(c, \"INCRBY incrkey %d\", 1000000);\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_INTEGER);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx INCRBY: %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n num = 10000;\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n for (i = 0; i < num; i++)\n redisAppendCommand(c,\"PING\");\n t1 = usec();\n for (i = 0; i < num; i++) {\n assert(redisGetReply(c, (void*)&replies[i]) == REDIS_OK);\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_STATUS);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx PING (pipelined): %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n for (i = 0; i < num; i++)\n redisAppendCommand(c,\"LRANGE mylist 0 499\");\n t1 = usec();\n for (i = 0; i < num; i++) {\n assert(redisGetReply(c, (void*)&replies[i]) == REDIS_OK);\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_ARRAY);\n assert(replies[i] != NULL && replies[i]->elements == 500);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx LRANGE with 500 elements (pipelined): %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n replies = hi_malloc_safe(sizeof(redisReply*)*num);\n for (i = 0; i < num; i++)\n redisAppendCommand(c,\"INCRBY incrkey %d\", 1000000);\n t1 = usec();\n for (i = 0; i < num; i++) {\n assert(redisGetReply(c, (void*)&replies[i]) == REDIS_OK);\n assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_INTEGER);\n }\n t2 = usec();\n for (i = 0; i < num; i++) freeReplyObject(replies[i]);\n hi_free(replies);\n printf(\"\\t(%dx INCRBY (pipelined): %.3fs)\\n\", num, (t2-t1)/1000000.0);\n\n disconnect(c, 0);\n}\n\n// static long __test_callback_flags = 0;\n// static void __test_callback(redisContext *c, void *privdata) {\n// ((void)c);\n// /* Shift to detect execution order */\n// __test_callback_flags <<= 8;\n// __test_callback_flags |= (long)privdata;\n// }\n//\n// static void __test_reply_callback(redisContext *c, redisReply *reply, void *privdata) {\n// ((void)c);\n// /* Shift to detect execution order */\n// __test_callback_flags <<= 8;\n// __test_callback_flags |= (long)privdata;\n// if (reply) freeReplyObject(reply);\n// }\n//\n// static redisContext *__connect_nonblock() {\n// /* Reset callback flags */\n// __test_callback_flags = 0;\n// return redisConnectNonBlock(\"127.0.0.1\", port, NULL);\n// }\n//\n// static void test_nonblocking_connection() {\n// redisContext *c;\n// int wdone = 0;\n//\n// test(\"Calls command callback when command is issued: \");\n// c = __connect_nonblock();\n// redisSetCommandCallback(c,__test_callback,(void*)1);\n// redisCommand(c,\"PING\");\n// test_cond(__test_callback_flags == 1);\n// redisFree(c);\n//\n// test(\"Calls disconnect callback on redisDisconnect: \");\n// c = __connect_nonblock();\n// redisSetDisconnectCallback(c,__test_callback,(void*)2);\n// redisDisconnect(c);\n// test_cond(__test_callback_flags == 2);\n// redisFree(c);\n//\n// test(\"Calls disconnect callback and free callback on redisFree: \");\n// c = __connect_nonblock();\n// redisSetDisconnectCallback(c,__test_callback,(void*)2);\n// redisSetFreeCallback(c,__test_callback,(void*)4);\n// redisFree(c);\n// test_cond(__test_callback_flags == ((2 << 8) | 4));\n//\n// test(\"redisBufferWrite against empty write buffer: \");\n// c = __connect_nonblock();\n// test_cond(redisBufferWrite(c,&wdone) == REDIS_OK && wdone == 1);\n// redisFree(c);\n//\n// test(\"redisBufferWrite against not yet connected fd: \");\n// c = __connect_nonblock();\n// redisCommand(c,\"PING\");\n// test_cond(redisBufferWrite(c,NULL) == REDIS_ERR &&\n// strncmp(c->error,\"write:\",6) == 0);\n// redisFree(c);\n//\n// test(\"redisBufferWrite against closed fd: \");\n// c = __connect_nonblock();\n// redisCommand(c,\"PING\");\n// redisDisconnect(c);\n// test_cond(redisBufferWrite(c,NULL) == REDIS_ERR &&\n// strncmp(c->error,\"write:\",6) == 0);\n// redisFree(c);\n//\n// test(\"Process callbacks in the right sequence: \");\n// c = __connect_nonblock();\n// redisCommandWithCallback(c,__test_reply_callback,(void*)1,\"PING\");\n// redisCommandWithCallback(c,__test_reply_callback,(void*)2,\"PING\");\n// redisCommandWithCallback(c,__test_reply_callback,(void*)3,\"PING\");\n//\n// /* Write output buffer */\n// wdone = 0;\n// while(!wdone) {\n// usleep(500);\n// redisBufferWrite(c,&wdone);\n// }\n//\n// /* Read until at least one callback is executed (the 3 replies will\n// * arrive in a single packet, causing all callbacks to be executed in\n// * a single pass). */\n// while(__test_callback_flags == 0) {\n// assert(redisBufferRead(c) == REDIS_OK);\n// redisProcessCallbacks(c);\n// }\n// test_cond(__test_callback_flags == 0x010203);\n// redisFree(c);\n//\n// test(\"redisDisconnect executes pending callbacks with NULL reply: \");\n// c = __connect_nonblock();\n// redisSetDisconnectCallback(c,__test_callback,(void*)1);\n// redisCommandWithCallback(c,__test_reply_callback,(void*)2,\"PING\");\n// redisDisconnect(c);\n// test_cond(__test_callback_flags == 0x0201);\n// redisFree(c);\n// }\n\n#ifdef HIREDIS_TEST_ASYNC\n\n#pragma GCC diagnostic ignored \"-Woverlength-strings\" /* required on gcc 4.8.x due to assert statements */\n\nstruct event_base *base;\n\ntypedef struct TestState {\n redisOptions *options;\n int checkpoint;\n int resp3;\n int disconnect;\n} TestState;\n\n/* Helper to disconnect and stop event loop */\nvoid async_disconnect(redisAsyncContext *ac) {\n redisAsyncDisconnect(ac);\n event_base_loopbreak(base);\n}\n\n/* Testcase timeout, will trigger a failure */\nvoid timeout_cb(int fd, short event, void *arg) {\n (void) fd; (void) event; (void) arg;\n printf(\"Timeout in async testing!\\n\");\n exit(1);\n}\n\n/* Unexpected call, will trigger a failure */\nvoid unexpected_cb(redisAsyncContext *ac, void *r, void *privdata) {\n (void) ac; (void) r;\n printf(\"Unexpected call: %s\\n\",(char*)privdata);\n exit(1);\n}\n\n/* Helper function to publish a message via own client. */\nvoid publish_msg(redisOptions *options, const char* channel, const char* msg) {\n redisContext *c = redisConnectWithOptions(options);\n assert(c != NULL);\n redisReply *reply = redisCommand(c,\"PUBLISH %s %s\",channel,msg);\n assert(reply->type == REDIS_REPLY_INTEGER && reply->integer == 1);\n freeReplyObject(reply);\n disconnect(c, 0);\n}\n\n/* Expect a reply of type INTEGER */\nvoid integer_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n assert(reply != NULL && reply->type == REDIS_REPLY_INTEGER);\n state->checkpoint++;\n if (state->disconnect) async_disconnect(ac);\n}\n\n/* Subscribe callback for test_pubsub_handling and test_pubsub_handling_resp3:\n * - a published message triggers an unsubscribe\n * - a command is sent before the unsubscribe response is received. */\nvoid subscribe_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n\n assert(reply != NULL &&\n reply->type == (state->resp3 ? REDIS_REPLY_PUSH : REDIS_REPLY_ARRAY) &&\n reply->elements == 3);\n\n if (strcmp(reply->element[0]->str,\"subscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"mychannel\") == 0 &&\n reply->element[2]->str == NULL);\n publish_msg(state->options,\"mychannel\",\"Hello!\");\n } else if (strcmp(reply->element[0]->str,\"message\") == 0) {\n assert(strcmp(reply->element[1]->str,\"mychannel\") == 0 &&\n strcmp(reply->element[2]->str,\"Hello!\") == 0);\n state->checkpoint++;\n\n /* Unsubscribe after receiving the published message. Send unsubscribe\n * which should call the callback registered during subscribe */\n redisAsyncCommand(ac,unexpected_cb,\n (void*)\"unsubscribe should call subscribe_cb()\",\n \"unsubscribe\");\n /* Send a regular command after unsubscribing, then disconnect */\n state->disconnect = 1;\n redisAsyncCommand(ac,integer_cb,state,\"LPUSH mylist foo\");\n\n } else if (strcmp(reply->element[0]->str,\"unsubscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"mychannel\") == 0 &&\n reply->element[2]->str == NULL);\n } else {\n printf(\"Unexpected pubsub command: %s\\n\", reply->element[0]->str);\n exit(1);\n }\n}\n\n/* Expect a reply of type ARRAY */\nvoid array_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n assert(reply != NULL && reply->type == REDIS_REPLY_ARRAY);\n state->checkpoint++;\n if (state->disconnect) async_disconnect(ac);\n}\n\n/* Expect a NULL reply */\nvoid null_cb(redisAsyncContext *ac, void *r, void *privdata) {\n (void) ac;\n assert(r == NULL);\n TestState *state = privdata;\n state->checkpoint++;\n}\n\nstatic void test_pubsub_handling(struct config config) {\n test(\"Subscribe, handle published message and unsubscribe: \");\n /* Setup event dispatcher with a testcase timeout */\n base = event_base_new();\n struct event *timeout = evtimer_new(base, timeout_cb, NULL);\n assert(timeout != NULL);\n\n evtimer_assign(timeout,base,timeout_cb,NULL);\n struct timeval timeout_tv = {.tv_sec = 10};\n evtimer_add(timeout, &timeout_tv);\n\n /* Connect */\n redisOptions options = get_redis_tcp_options(config);\n redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);\n assert(ac != NULL && ac->err == 0);\n redisLibeventAttach(ac,base);\n\n /* Start subscribe */\n TestState state = {.options = &options};\n redisAsyncCommand(ac,subscribe_cb,&state,\"subscribe mychannel\");\n\n /* Make sure non-subscribe commands are handled */\n redisAsyncCommand(ac,array_cb,&state,\"PING\");\n\n /* Start event dispatching loop */\n test_cond(event_base_dispatch(base) == 0);\n event_free(timeout);\n event_base_free(base);\n\n /* Verify test checkpoints */\n assert(state.checkpoint == 3);\n}\n\n/* Unexpected push message, will trigger a failure */\nvoid unexpected_push_cb(redisAsyncContext *ac, void *r) {\n (void) ac; (void) r;\n printf(\"Unexpected call to the PUSH callback!\\n\");\n exit(1);\n}\n\nstatic void test_pubsub_handling_resp3(struct config config) {\n test(\"Subscribe, handle published message and unsubscribe using RESP3: \");\n /* Setup event dispatcher with a testcase timeout */\n base = event_base_new();\n struct event *timeout = evtimer_new(base, timeout_cb, NULL);\n assert(timeout != NULL);\n\n evtimer_assign(timeout,base,timeout_cb,NULL);\n struct timeval timeout_tv = {.tv_sec = 10};\n evtimer_add(timeout, &timeout_tv);\n\n /* Connect */\n redisOptions options = get_redis_tcp_options(config);\n redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);\n assert(ac != NULL && ac->err == 0);\n redisLibeventAttach(ac,base);\n\n /* Not expecting any push messages in this test */\n redisAsyncSetPushCallback(ac, unexpected_push_cb);\n\n /* Switch protocol */\n redisAsyncCommand(ac,NULL,NULL,\"HELLO 3\");\n\n /* Start subscribe */\n TestState state = {.options = &options, .resp3 = 1};\n redisAsyncCommand(ac,subscribe_cb,&state,\"subscribe mychannel\");\n\n /* Make sure non-subscribe commands are handled in RESP3 */\n redisAsyncCommand(ac,integer_cb,&state,\"LPUSH mylist foo\");\n redisAsyncCommand(ac,integer_cb,&state,\"LPUSH mylist foo\");\n redisAsyncCommand(ac,integer_cb,&state,\"LPUSH mylist foo\");\n /* Handle an array with 3 elements as a non-subscribe command */\n redisAsyncCommand(ac,array_cb,&state,\"LRANGE mylist 0 2\");\n\n /* Start event dispatching loop */\n test_cond(event_base_dispatch(base) == 0);\n event_free(timeout);\n event_base_free(base);\n\n /* Verify test checkpoints */\n assert(state.checkpoint == 6);\n}\n\n/* Subscribe callback for test_command_timeout_during_pubsub:\n * - a subscribe response triggers a published message\n * - the published message triggers a command that times out\n * - the command timeout triggers a disconnect */\nvoid subscribe_with_timeout_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n\n /* The non-clean disconnect should trigger the\n * subscription callback with a NULL reply. */\n if (reply == NULL) {\n state->checkpoint++;\n event_base_loopbreak(base);\n return;\n }\n\n assert(reply->type == (state->resp3 ? REDIS_REPLY_PUSH : REDIS_REPLY_ARRAY) &&\n reply->elements == 3);\n\n if (strcmp(reply->element[0]->str,\"subscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"mychannel\") == 0 &&\n reply->element[2]->str == NULL);\n publish_msg(state->options,\"mychannel\",\"Hello!\");\n state->checkpoint++;\n } else if (strcmp(reply->element[0]->str,\"message\") == 0) {\n assert(strcmp(reply->element[1]->str,\"mychannel\") == 0 &&\n strcmp(reply->element[2]->str,\"Hello!\") == 0);\n state->checkpoint++;\n\n /* Send a command that will trigger a timeout */\n redisAsyncCommand(ac,null_cb,state,\"DEBUG SLEEP 3\");\n redisAsyncCommand(ac,null_cb,state,\"LPUSH mylist foo\");\n } else {\n printf(\"Unexpected pubsub command: %s\\n\", reply->element[0]->str);\n exit(1);\n }\n}\n\nstatic void test_command_timeout_during_pubsub(struct config config) {\n test(\"Command timeout during Pub/Sub: \");\n /* Setup event dispatcher with a testcase timeout */\n base = event_base_new();\n struct event *timeout = evtimer_new(base,timeout_cb,NULL);\n assert(timeout != NULL);\n\n evtimer_assign(timeout,base,timeout_cb,NULL);\n struct timeval timeout_tv = {.tv_sec = 10};\n evtimer_add(timeout,&timeout_tv);\n\n /* Connect */\n redisOptions options = get_redis_tcp_options(config);\n redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);\n assert(ac != NULL && ac->err == 0);\n redisLibeventAttach(ac,base);\n\n /* Configure a command timout */\n struct timeval command_timeout = {.tv_sec = 2};\n redisAsyncSetTimeout(ac,command_timeout);\n\n /* Not expecting any push messages in this test */\n redisAsyncSetPushCallback(ac,unexpected_push_cb);\n\n /* Switch protocol */\n redisAsyncCommand(ac,NULL,NULL,\"HELLO 3\");\n\n /* Start subscribe */\n TestState state = {.options = &options, .resp3 = 1};\n redisAsyncCommand(ac,subscribe_with_timeout_cb,&state,\"subscribe mychannel\");\n\n /* Start event dispatching loop */\n assert(event_base_dispatch(base) == 0);\n event_free(timeout);\n event_base_free(base);\n\n /* Verify test checkpoints */\n test_cond(state.checkpoint == 5);\n}\n\n/* Subscribe callback for test_pubsub_multiple_channels */\nvoid subscribe_channel_a_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n\n assert(reply != NULL && reply->type == REDIS_REPLY_ARRAY &&\n reply->elements == 3);\n\n if (strcmp(reply->element[0]->str,\"subscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"A\") == 0);\n publish_msg(state->options,\"A\",\"Hello!\");\n state->checkpoint++;\n } else if (strcmp(reply->element[0]->str,\"message\") == 0) {\n assert(strcmp(reply->element[1]->str,\"A\") == 0 &&\n strcmp(reply->element[2]->str,\"Hello!\") == 0);\n state->checkpoint++;\n\n /* Unsubscribe to channels, including channel X & Z which we don't subscribe to */\n redisAsyncCommand(ac,unexpected_cb,\n (void*)\"unsubscribe should not call unexpected_cb()\",\n \"unsubscribe B X A A Z\");\n /* Unsubscribe to patterns, none which we subscribe to */\n redisAsyncCommand(ac,unexpected_cb,\n (void*)\"punsubscribe should not call unexpected_cb()\",\n \"punsubscribe\");\n /* Send a regular command after unsubscribing, then disconnect */\n state->disconnect = 1;\n redisAsyncCommand(ac,integer_cb,state,\"LPUSH mylist foo\");\n } else if (strcmp(reply->element[0]->str,\"unsubscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"A\") == 0);\n state->checkpoint++;\n } else {\n printf(\"Unexpected pubsub command: %s\\n\", reply->element[0]->str);\n exit(1);\n }\n}\n\n/* Subscribe callback for test_pubsub_multiple_channels */\nvoid subscribe_channel_b_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n (void)ac;\n\n assert(reply != NULL && reply->type == REDIS_REPLY_ARRAY &&\n reply->elements == 3);\n\n if (strcmp(reply->element[0]->str,\"subscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"B\") == 0);\n state->checkpoint++;\n } else if (strcmp(reply->element[0]->str,\"unsubscribe\") == 0) {\n assert(strcmp(reply->element[1]->str,\"B\") == 0);\n state->checkpoint++;\n } else {\n printf(\"Unexpected pubsub command: %s\\n\", reply->element[0]->str);\n exit(1);\n }\n}\n\n/* Test handling of multiple channels\n * - subscribe to channel A and B\n * - a published message on A triggers an unsubscribe of channel B, X, A and Z\n * where channel X and Z are not subscribed to.\n * - the published message also triggers an unsubscribe to patterns. Since no\n * pattern is subscribed to the responded pattern element type is NIL.\n * - a command sent after unsubscribe triggers a disconnect */\nstatic void test_pubsub_multiple_channels(struct config config) {\n test(\"Subscribe to multiple channels: \");\n /* Setup event dispatcher with a testcase timeout */\n base = event_base_new();\n struct event *timeout = evtimer_new(base,timeout_cb,NULL);\n assert(timeout != NULL);\n\n evtimer_assign(timeout,base,timeout_cb,NULL);\n struct timeval timeout_tv = {.tv_sec = 10};\n evtimer_add(timeout,&timeout_tv);\n\n /* Connect */\n redisOptions options = get_redis_tcp_options(config);\n redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);\n assert(ac != NULL && ac->err == 0);\n redisLibeventAttach(ac,base);\n\n /* Not expecting any push messages in this test */\n redisAsyncSetPushCallback(ac,unexpected_push_cb);\n\n /* Start subscribing to two channels */\n TestState state = {.options = &options};\n redisAsyncCommand(ac,subscribe_channel_a_cb,&state,\"subscribe A\");\n redisAsyncCommand(ac,subscribe_channel_b_cb,&state,\"subscribe B\");\n\n /* Start event dispatching loop */\n assert(event_base_dispatch(base) == 0);\n event_free(timeout);\n event_base_free(base);\n\n /* Verify test checkpoints */\n test_cond(state.checkpoint == 6);\n}\n\n/* Command callback for test_monitor() */\nvoid monitor_cb(redisAsyncContext *ac, void *r, void *privdata) {\n redisReply *reply = r;\n TestState *state = privdata;\n\n /* NULL reply is received when BYE triggers a disconnect. */\n if (reply == NULL) {\n event_base_loopbreak(base);\n return;\n }\n\n assert(reply != NULL && reply->type == REDIS_REPLY_STATUS);\n state->checkpoint++;\n\n if (state->checkpoint == 1) {\n /* Response from MONITOR */\n redisContext *c = redisConnectWithOptions(state->options);\n assert(c != NULL);\n redisReply *reply = redisCommand(c,\"SET first 1\");\n assert(reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n redisFree(c);\n } else if (state->checkpoint == 2) {\n /* Response for monitored command 'SET first 1' */\n assert(strstr(reply->str,\"first\") != NULL);\n redisContext *c = redisConnectWithOptions(state->options);\n assert(c != NULL);\n redisReply *reply = redisCommand(c,\"SET second 2\");\n assert(reply->type == REDIS_REPLY_STATUS);\n freeReplyObject(reply);\n redisFree(c);\n } else if (state->checkpoint == 3) {\n /* Response for monitored command 'SET second 2' */\n assert(strstr(reply->str,\"second\") != NULL);\n /* Send QUIT to disconnect */\n redisAsyncCommand(ac,NULL,NULL,\"QUIT\");\n }\n}\n\n/* Test handling of the monitor command\n * - sends MONITOR to enable monitoring.\n * - sends SET commands via separate clients to be monitored.\n * - sends QUIT to stop monitoring and disconnect. */\nstatic void test_monitor(struct config config) {\n test(\"Enable monitoring: \");\n /* Setup event dispatcher with a testcase timeout */\n base = event_base_new();\n struct event *timeout = evtimer_new(base, timeout_cb, NULL);\n assert(timeout != NULL);\n\n evtimer_assign(timeout,base,timeout_cb,NULL);\n struct timeval timeout_tv = {.tv_sec = 10};\n evtimer_add(timeout, &timeout_tv);\n\n /* Connect */\n redisOptions options = get_redis_tcp_options(config);\n redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);\n assert(ac != NULL && ac->err == 0);\n redisLibeventAttach(ac,base);\n\n /* Not expecting any push messages in this test */\n redisAsyncSetPushCallback(ac,unexpected_push_cb);\n\n /* Start monitor */\n TestState state = {.options = &options};\n redisAsyncCommand(ac,monitor_cb,&state,\"monitor\");\n\n /* Start event dispatching loop */\n test_cond(event_base_dispatch(base) == 0);\n event_free(timeout);\n event_base_free(base);\n\n /* Verify test checkpoints */\n assert(state.checkpoint == 3);\n}\n#endif /* HIREDIS_TEST_ASYNC */\n\n/* tests for async api using polling adapter, requires no extra libraries*/\n\n/* enum for the test cases, the callbacks have different logic based on them */\ntypedef enum astest_no\n{\n ASTEST_CONNECT=0,\n ASTEST_CONN_TIMEOUT,\n ASTEST_PINGPONG,\n ASTEST_PINGPONG_TIMEOUT,\n ASTEST_ISSUE_931,\n ASTEST_ISSUE_931_PING\n}astest_no;\n\n/* a static context for the async tests */\nstruct _astest {\n redisAsyncContext *ac;\n astest_no testno;\n int counter;\n int connects;\n int connect_status;\n int disconnects;\n int pongs;\n int disconnect_status;\n int connected;\n int err;\n char errstr[256];\n};\nstatic struct _astest astest;\n\n/* async callbacks */\nstatic void asCleanup(void* data)\n{\n struct _astest *t = (struct _astest *)data;\n t->ac = NULL;\n}\n\nstatic void commandCallback(struct redisAsyncContext *ac, void* _reply, void* _privdata);\n\nstatic void connectCallback(redisAsyncContext *c, int status) {\n struct _astest *t = (struct _astest *)c->data;\n assert(t == &astest);\n assert(t->connects == 0);\n t->err = c->err;\n strcpy(t->errstr, c->errstr);\n t->connects++;\n t->connect_status = status;\n t->connected = status == REDIS_OK ? 1 : -1;\n\n if (t->testno == ASTEST_ISSUE_931) {\n /* disconnect again */\n redisAsyncDisconnect(c);\n }\n else if (t->testno == ASTEST_ISSUE_931_PING)\n {\n redisAsyncCommand(c, commandCallback, NULL, \"PING\");\n }\n}\nstatic void disconnectCallback(const redisAsyncContext *c, int status) {\n assert(c->data == (void*)&astest);\n assert(astest.disconnects == 0);\n astest.err = c->err;\n strcpy(astest.errstr, c->errstr);\n astest.disconnects++;\n astest.disconnect_status = status;\n astest.connected = 0;\n}\n\nstatic void commandCallback(struct redisAsyncContext *ac, void* _reply, void* _privdata)\n{\n redisReply *reply = (redisReply*)_reply;\n struct _astest *t = (struct _astest *)ac->data;\n assert(t == &astest);\n (void)_privdata;\n t->err = ac->err;\n strcpy(t->errstr, ac->errstr);\n t->counter++;\n if (t->testno == ASTEST_PINGPONG ||t->testno == ASTEST_ISSUE_931_PING)\n {\n assert(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, \"PONG\") == 0);\n t->pongs++;\n redisAsyncFree(ac);\n }\n if (t->testno == ASTEST_PINGPONG_TIMEOUT)\n {\n /* two ping pongs */\n assert(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, \"PONG\") == 0);\n t->pongs++;\n if (t->counter == 1) {\n int status = redisAsyncCommand(ac, commandCallback, NULL, \"PING\");\n assert(status == REDIS_OK);\n } else {\n redisAsyncFree(ac);\n }\n }\n}\n\nstatic redisAsyncContext *do_aconnect(struct config config, astest_no testno)\n{\n redisOptions options = {0};\n memset(&astest, 0, sizeof(astest));\n\n astest.testno = testno;\n astest.connect_status = astest.disconnect_status = -2;\n\n if (config.type == CONN_TCP) {\n options.type = REDIS_CONN_TCP;\n options.connect_timeout = &config.connect_timeout;\n REDIS_OPTIONS_SET_TCP(&options, config.tcp.host, config.tcp.port);\n } else if (config.type == CONN_SSL) {\n options.type = REDIS_CONN_TCP;\n options.connect_timeout = &config.connect_timeout;\n REDIS_OPTIONS_SET_TCP(&options, config.ssl.host, config.ssl.port);\n } else if (config.type == CONN_UNIX) {\n options.type = REDIS_CONN_UNIX;\n options.endpoint.unix_socket = config.unix_sock.path;\n } else if (config.type == CONN_FD) {\n options.type = REDIS_CONN_USERFD;\n /* Create a dummy connection just to get an fd to inherit */\n redisContext *dummy_ctx = redisConnectUnix(config.unix_sock.path);\n if (dummy_ctx) {\n redisFD fd = disconnect(dummy_ctx, 1);\n printf(\"Connecting to inherited fd %d\\n\", (int)fd);\n options.endpoint.fd = fd;\n }\n }\n redisAsyncContext *c = redisAsyncConnectWithOptions(&options);\n assert(c);\n astest.ac = c;\n c->data = &astest;\n c->dataCleanup = asCleanup;\n redisPollAttach(c);\n redisAsyncSetConnectCallbackNC(c, connectCallback);\n redisAsyncSetDisconnectCallback(c, disconnectCallback);\n return c;\n}\n\nstatic void as_printerr(void) {\n printf(\"Async err %d : %s\\n\", astest.err, astest.errstr);\n}\n\n#define ASASSERT(e) do { \\\n if (!(e)) \\\n as_printerr(); \\\n assert(e); \\\n} while (0);\n\nstatic void test_async_polling(struct config config) {\n int status;\n redisAsyncContext *c;\n struct config defaultconfig = config;\n\n test(\"Async connect: \");\n c = do_aconnect(config, ASTEST_CONNECT);\n assert(c);\n while(astest.connected == 0)\n redisPollTick(c, 0.1);\n assert(astest.connects == 1);\n ASASSERT(astest.connect_status == REDIS_OK);\n assert(astest.disconnects == 0);\n test_cond(astest.connected == 1);\n\n test(\"Async free after connect: \");\n assert(astest.ac != NULL);\n redisAsyncFree(c);\n assert(astest.disconnects == 1);\n assert(astest.ac == NULL);\n test_cond(astest.disconnect_status == REDIS_OK);\n\n if (config.type == CONN_TCP || config.type == CONN_SSL) {\n /* timeout can only be simulated with network */\n test(\"Async connect timeout: \");\n config.tcp.host = \"192.168.254.254\"; /* blackhole ip */\n config.connect_timeout.tv_usec = 100000;\n c = do_aconnect(config, ASTEST_CONN_TIMEOUT);\n assert(c);\n assert(c->err == 0);\n while(astest.connected == 0)\n redisPollTick(c, 0.1);\n assert(astest.connected == -1);\n /*\n * freeing should not be done, clearing should have happened.\n *redisAsyncFree(c);\n */\n assert(astest.ac == NULL);\n test_cond(astest.connect_status == REDIS_ERR);\n config = defaultconfig;\n }\n\n /* Test a ping/pong after connection */\n test(\"Async PING/PONG: \");\n c = do_aconnect(config, ASTEST_PINGPONG);\n while(astest.connected == 0)\n redisPollTick(c, 0.1);\n status = redisAsyncCommand(c, commandCallback, NULL, \"PING\");\n assert(status == REDIS_OK);\n while(astest.ac)\n redisPollTick(c, 0.1);\n test_cond(astest.pongs == 1);\n\n /* Test a ping/pong after connection that didn't time out.\n * see https://github.com/redis/hiredis/issues/945\n */\n if (config.type == CONN_TCP || config.type == CONN_SSL) {\n test(\"Async PING/PONG after connect timeout: \");\n config.connect_timeout.tv_usec = 10000; /* 10ms */\n c = do_aconnect(config, ASTEST_PINGPONG_TIMEOUT);\n while(astest.connected == 0)\n redisPollTick(c, 0.1);\n /* sleep 0.1 s, allowing old timeout to arrive */\n millisleep(10);\n status = redisAsyncCommand(c, commandCallback, NULL, \"PING\");\n assert(status == REDIS_OK);\n while(astest.ac)\n redisPollTick(c, 0.1);\n test_cond(astest.pongs == 2);\n config = defaultconfig;\n }\n\n /* Test disconnect from an on_connect callback\n * see https://github.com/redis/hiredis/issues/931\n */\n test(\"Disconnect from onConnected callback (Issue #931): \");\n c = do_aconnect(config, ASTEST_ISSUE_931);\n while(astest.disconnects == 0)\n redisPollTick(c, 0.1);\n assert(astest.connected == 0);\n assert(astest.connects == 1);\n test_cond(astest.disconnects == 1);\n\n /* Test ping/pong from an on_connect callback\n * see https://github.com/redis/hiredis/issues/931\n */\n test(\"Ping/Pong from onConnected callback (Issue #931): \");\n c = do_aconnect(config, ASTEST_ISSUE_931_PING);\n /* connect callback issues ping, reponse callback destroys context */\n while(astest.ac)\n redisPollTick(c, 0.1);\n assert(astest.connected == 0);\n assert(astest.connects == 1);\n assert(astest.disconnects == 1);\n test_cond(astest.pongs == 1);\n}\n/* End of Async polling_adapter driven tests */\n\nint main(int argc, char **argv) {\n struct config cfg = {\n .tcp = {\n .host = \"127.0.0.1\",\n .port = 6379\n },\n .unix_sock = {\n .path = \"/tmp/redis.sock\"\n }\n };\n int throughput = 1;\n int test_inherit_fd = 1;\n int skips_as_fails = 0;\n int test_unix_socket;\n\n /* Parse command line options. */\n argv++; argc--;\n while (argc) {\n if (argc >= 2 && !strcmp(argv[0],\"-h\")) {\n argv++; argc--;\n cfg.tcp.host = argv[0];\n } else if (argc >= 2 && !strcmp(argv[0],\"-p\")) {\n argv++; argc--;\n cfg.tcp.port = atoi(argv[0]);\n } else if (argc >= 2 && !strcmp(argv[0],\"-s\")) {\n argv++; argc--;\n cfg.unix_sock.path = argv[0];\n } else if (argc >= 1 && !strcmp(argv[0],\"--skip-throughput\")) {\n throughput = 0;\n } else if (argc >= 1 && !strcmp(argv[0],\"--skip-inherit-fd\")) {\n test_inherit_fd = 0;\n } else if (argc >= 1 && !strcmp(argv[0],\"--skips-as-fails\")) {\n skips_as_fails = 1;\n#ifdef HIREDIS_TEST_SSL\n } else if (argc >= 2 && !strcmp(argv[0],\"--ssl-port\")) {\n argv++; argc--;\n cfg.ssl.port = atoi(argv[0]);\n } else if (argc >= 2 && !strcmp(argv[0],\"--ssl-host\")) {\n argv++; argc--;\n cfg.ssl.host = argv[0];\n } else if (argc >= 2 && !strcmp(argv[0],\"--ssl-ca-cert\")) {\n argv++; argc--;\n cfg.ssl.ca_cert = argv[0];\n } else if (argc >= 2 && !strcmp(argv[0],\"--ssl-cert\")) {\n argv++; argc--;\n cfg.ssl.cert = argv[0];\n } else if (argc >= 2 && !strcmp(argv[0],\"--ssl-key\")) {\n argv++; argc--;\n cfg.ssl.key = argv[0];\n#endif\n } else {\n fprintf(stderr, \"Invalid argument: %s\\n\", argv[0]);\n exit(1);\n }\n argv++; argc--;\n }\n\n#ifndef _WIN32\n /* Ignore broken pipe signal (for I/O error tests). */\n signal(SIGPIPE, SIG_IGN);\n\n test_unix_socket = access(cfg.unix_sock.path, F_OK) == 0;\n\n#else\n /* Unix sockets don't exist in Windows */\n test_unix_socket = 0;\n#endif\n\n test_allocator_injection();\n\n test_format_commands();\n test_reply_reader();\n test_blocking_connection_errors();\n test_free_null();\n\n printf(\"\\nTesting against TCP connection (%s:%d):\\n\", cfg.tcp.host, cfg.tcp.port);\n cfg.type = CONN_TCP;\n test_blocking_connection(cfg);\n test_blocking_connection_timeouts(cfg);\n test_blocking_io_errors(cfg);\n test_invalid_timeout_errors(cfg);\n test_append_formatted_commands(cfg);\n test_tcp_options(cfg);\n if (throughput) test_throughput(cfg);\n\n printf(\"\\nTesting against Unix socket connection (%s): \", cfg.unix_sock.path);\n if (test_unix_socket) {\n printf(\"\\n\");\n cfg.type = CONN_UNIX;\n test_blocking_connection(cfg);\n test_blocking_connection_timeouts(cfg);\n test_blocking_io_errors(cfg);\n test_invalid_timeout_errors(cfg);\n if (throughput) test_throughput(cfg);\n } else {\n test_skipped();\n }\n\n#ifdef HIREDIS_TEST_SSL\n if (cfg.ssl.port && cfg.ssl.host) {\n\n redisInitOpenSSL();\n _ssl_ctx = redisCreateSSLContext(cfg.ssl.ca_cert, NULL, cfg.ssl.cert, cfg.ssl.key, NULL, NULL);\n assert(_ssl_ctx != NULL);\n\n printf(\"\\nTesting against SSL connection (%s:%d):\\n\", cfg.ssl.host, cfg.ssl.port);\n cfg.type = CONN_SSL;\n\n test_blocking_connection(cfg);\n test_blocking_connection_timeouts(cfg);\n test_blocking_io_errors(cfg);\n test_invalid_timeout_errors(cfg);\n test_append_formatted_commands(cfg);\n if (throughput) test_throughput(cfg);\n\n redisFreeSSLContext(_ssl_ctx);\n _ssl_ctx = NULL;\n }\n#endif\n\n#ifdef HIREDIS_TEST_ASYNC\n cfg.type = CONN_TCP;\n printf(\"\\nTesting asynchronous API against TCP connection (%s:%d):\\n\", cfg.tcp.host, cfg.tcp.port);\n cfg.type = CONN_TCP;\n\n int major;\n redisContext *c = do_connect(cfg);\n get_redis_version(c, &major, NULL);\n disconnect(c, 0);\n\n test_pubsub_handling(cfg);\n test_pubsub_multiple_channels(cfg);\n test_monitor(cfg);\n if (major >= 6) {\n test_pubsub_handling_resp3(cfg);\n test_command_timeout_during_pubsub(cfg);\n }\n#endif /* HIREDIS_TEST_ASYNC */\n\n cfg.type = CONN_TCP;\n printf(\"\\nTesting asynchronous API using polling_adapter TCP (%s:%d):\\n\", cfg.tcp.host, cfg.tcp.port);\n test_async_polling(cfg);\n if (test_unix_socket) {\n cfg.type = CONN_UNIX;\n printf(\"\\nTesting asynchronous API using polling_adapter UNIX (%s):\\n\", cfg.unix_sock.path);\n test_async_polling(cfg);\n }\n\n if (test_inherit_fd) {\n printf(\"\\nTesting against inherited fd (%s): \", cfg.unix_sock.path);\n if (test_unix_socket) {\n printf(\"\\n\");\n cfg.type = CONN_FD;\n test_blocking_connection(cfg);\n } else {\n test_skipped();\n }\n }\n\n if (fails || (skips_as_fails && skips)) {\n printf(\"*** %d TESTS FAILED ***\\n\", fails);\n if (skips) {\n printf(\"*** %d TESTS SKIPPED ***\\n\", skips);\n }\n return 1;\n }\n\n printf(\"ALL TESTS PASSED (%d skipped)\\n\", skips);\n return 0;\n}\n" }, { "path": "deps/hiredis/test.sh", "content": "#!/bin/sh -ue\n\nREDIS_SERVER=${REDIS_SERVER:-redis-server}\nREDIS_PORT=${REDIS_PORT:-56379}\nREDIS_SSL_PORT=${REDIS_SSL_PORT:-56443}\nTEST_SSL=${TEST_SSL:-0}\nSKIPS_AS_FAILS=${SKIPS_AS_FAILS:-0}\nENABLE_DEBUG_CMD=\nSSL_TEST_ARGS=\nSKIPS_ARG=${SKIPS_ARG:-}\nREDIS_DOCKER=${REDIS_DOCKER:-}\n\n# We need to enable the DEBUG command for redis-server >= 7.0.0\nREDIS_MAJOR_VERSION=\"$(redis-server --version|awk -F'[^0-9]+' '{ print $2 }')\"\nif [ \"$REDIS_MAJOR_VERSION\" -gt \"6\" ]; then\n ENABLE_DEBUG_CMD=\"enable-debug-command local\"\nfi\n\ntmpdir=$(mktemp -d)\nPID_FILE=${tmpdir}/hiredis-test-redis.pid\nSOCK_FILE=${tmpdir}/hiredis-test-redis.sock\n\nif [ \"$TEST_SSL\" = \"1\" ]; then\n SSL_CA_CERT=${tmpdir}/ca.crt\n SSL_CA_KEY=${tmpdir}/ca.key\n SSL_CERT=${tmpdir}/redis.crt\n SSL_KEY=${tmpdir}/redis.key\n\n openssl genrsa -out ${tmpdir}/ca.key 4096\n openssl req \\\n -x509 -new -nodes -sha256 \\\n -key ${SSL_CA_KEY} \\\n -days 3650 \\\n -subj '/CN=Hiredis Test CA' \\\n -out ${SSL_CA_CERT}\n openssl genrsa -out ${SSL_KEY} 2048\n openssl req \\\n -new -sha256 \\\n -key ${SSL_KEY} \\\n -subj '/CN=Hiredis Test Cert' | \\\n openssl x509 \\\n -req -sha256 \\\n -CA ${SSL_CA_CERT} \\\n -CAkey ${SSL_CA_KEY} \\\n -CAserial ${tmpdir}/ca.txt \\\n -CAcreateserial \\\n -days 365 \\\n -out ${SSL_CERT}\n\n SSL_TEST_ARGS=\"--ssl-host 127.0.0.1 --ssl-port ${REDIS_SSL_PORT} --ssl-ca-cert ${SSL_CA_CERT} --ssl-cert ${SSL_CERT} --ssl-key ${SSL_KEY}\"\nfi\n\ncleanup() {\n if [ -n \"${REDIS_DOCKER}\" ] ; then\n docker kill redis-test-server\n else\n set +e\n kill $(cat ${PID_FILE})\n fi\n rm -rf ${tmpdir}\n}\ntrap cleanup INT TERM EXIT\n\n# base config\ncat > ${tmpdir}/redis.conf <> ${tmpdir}/redis.conf <> ${tmpdir}/redis.conf < /* for struct timeval */\n\n#ifndef inline\n#define inline __inline\n#endif\n\n#ifndef strcasecmp\n#define strcasecmp stricmp\n#endif\n\n#ifndef strncasecmp\n#define strncasecmp strnicmp\n#endif\n\n#ifndef va_copy\n#define va_copy(d,s) ((d) = (s))\n#endif\n\n#ifndef snprintf\n#define snprintf c99_snprintf\n\n__inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)\n{\n int count = -1;\n\n if (size != 0)\n count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);\n if (count == -1)\n count = _vscprintf(format, ap);\n\n return count;\n}\n\n__inline int c99_snprintf(char* str, size_t size, const char* format, ...)\n{\n int count;\n va_list ap;\n\n va_start(ap, format);\n count = c99_vsnprintf(str, size, format, ap);\n va_end(ap);\n\n return count;\n}\n#endif\n#endif /* _MSC_VER */\n\n#ifdef _WIN32\n#define strerror_r(errno,buf,len) strerror_s(buf,len,errno)\n#endif /* _WIN32 */\n\n#endif /* _WIN32_HELPER_INCLUDE */\n" }, { "path": "deps/jemalloc/.appveyor.yml", "content": "version: '{build}'\n\nenvironment:\n matrix:\n - MSYSTEM: MINGW64\n CPU: x86_64\n MSVC: amd64\n CONFIG_FLAGS: --enable-debug\n - MSYSTEM: MINGW64\n CPU: x86_64\n CONFIG_FLAGS: --enable-debug\n - MSYSTEM: MINGW32\n CPU: i686\n MSVC: x86\n CONFIG_FLAGS: --enable-debug\n - MSYSTEM: MINGW32\n CPU: i686\n CONFIG_FLAGS: --enable-debug\n - MSYSTEM: MINGW64\n CPU: x86_64\n MSVC: amd64\n - MSYSTEM: MINGW64\n CPU: x86_64\n - MSYSTEM: MINGW32\n CPU: i686\n MSVC: x86\n - MSYSTEM: MINGW32\n CPU: i686\n\ninstall:\n - set PATH=c:\\msys64\\%MSYSTEM%\\bin;c:\\msys64\\usr\\bin;%PATH%\n - if defined MSVC call \"c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" %MSVC%\n - if defined MSVC pacman --noconfirm -Rsc mingw-w64-%CPU%-gcc gcc\n\nbuild_script:\n - bash -c \"autoconf\"\n - bash -c \"./configure $CONFIG_FLAGS\"\n - mingw32-make\n - file lib/jemalloc.dll\n - mingw32-make tests\n - mingw32-make -k check\n" }, { "path": "deps/jemalloc/.autom4te.cfg", "content": "begin-language: \"Autoconf-without-aclocal-m4\"\nargs: --no-cache\nend-language: \"Autoconf-without-aclocal-m4\"\n" }, { "path": "deps/jemalloc/.cirrus.yml", "content": "env:\n CIRRUS_CLONE_DEPTH: 1\n ARCH: amd64\n\ntask:\n matrix:\n env:\n DEBUG_CONFIG: --enable-debug\n env:\n DEBUG_CONFIG: --disable-debug\n matrix:\n - env:\n PROF_CONFIG: --enable-prof\n - env:\n PROF_CONFIG: --disable-prof\n matrix:\n - name: 64-bit\n env:\n CC:\n CXX:\n - name: 32-bit\n env:\n CC: cc -m32\n CXX: c++ -m32\n matrix:\n - env:\n UNCOMMON_CONFIG:\n - env:\n UNCOMMON_CONFIG: --with-lg-page=16 --with-malloc-conf=tcache:false\n freebsd_instance:\n matrix:\n image: freebsd-12-3-release-amd64\n install_script:\n - sed -i.bak -e 's,pkg+http://pkg.FreeBSD.org/\\${ABI}/quarterly,pkg+http://pkg.FreeBSD.org/\\${ABI}/latest,' /etc/pkg/FreeBSD.conf\n - pkg upgrade -y\n - pkg install -y autoconf gmake\n script:\n - autoconf\n # We don't perfectly track freebsd stdlib.h definitions. This is fine when\n # we count as a system header, but breaks otherwise, like during these\n # tests.\n - ./configure --with-jemalloc-prefix=ci_ ${DEBUG_CONFIG} ${PROF_CONFIG} ${UNCOMMON_CONFIG}\n - export JFLAG=`sysctl -n kern.smp.cpus`\n - gmake -j${JFLAG}\n - gmake -j${JFLAG} tests\n - gmake check\n" }, { "path": "deps/jemalloc/.clang-format", "content": "# jemalloc targets clang-format version 8. We include every option it supports\n# here, but comment out the ones that aren't relevant for us.\n---\n# AccessModifierOffset: -2\nAlignAfterOpenBracket: DontAlign\nAlignConsecutiveAssignments: false\nAlignConsecutiveDeclarations: false\nAlignEscapedNewlines: Right\nAlignOperands: false\nAlignTrailingComments: false\nAllowAllParametersOfDeclarationOnNextLine: true\nAllowShortBlocksOnASingleLine: false\nAllowShortCaseLabelsOnASingleLine: false\nAllowShortFunctionsOnASingleLine: Empty\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\nAlwaysBreakAfterReturnType: AllDefinitions\nAlwaysBreakBeforeMultilineStrings: true\n# AlwaysBreakTemplateDeclarations: Yes\nBinPackArguments: true\nBinPackParameters: true\nBraceWrapping:\n AfterClass: false\n AfterControlStatement: false\n AfterEnum: false\n AfterFunction: false\n AfterNamespace: false\n AfterObjCDeclaration: false\n AfterStruct: false\n AfterUnion: false\n BeforeCatch: false\n BeforeElse: false\n IndentBraces: false\n# BreakAfterJavaFieldAnnotations: true\nBreakBeforeBinaryOperators: NonAssignment\nBreakBeforeBraces: Attach\nBreakBeforeTernaryOperators: true\n# BreakConstructorInitializers: BeforeColon\n# BreakInheritanceList: BeforeColon\nBreakStringLiterals: false\nColumnLimit: 80\n# CommentPragmas: ''\n# CompactNamespaces: true\n# ConstructorInitializerAllOnOneLineOrOnePerLine: true\n# ConstructorInitializerIndentWidth: 4\nContinuationIndentWidth: 2\nCpp11BracedListStyle: true\nDerivePointerAlignment: false\nDisableFormat: false\nExperimentalAutoDetectBinPacking: false\nFixNamespaceComments: true\nForEachMacros: [ ql_foreach, qr_foreach, ]\n# IncludeBlocks: Preserve\n# IncludeCategories:\n# - Regex: '^<.*\\.h(pp)?>'\n# Priority: 1\n# IncludeIsMainRegex: ''\nIndentCaseLabels: false\nIndentPPDirectives: AfterHash\nIndentWidth: 4\nIndentWrappedFunctionNames: false\n# JavaImportGroups: []\n# JavaScriptQuotes: Leave\n# JavaScriptWrapImports: True\nKeepEmptyLinesAtTheStartOfBlocks: false\nLanguage: Cpp\nMacroBlockBegin: ''\nMacroBlockEnd: ''\nMaxEmptyLinesToKeep: 1\n# NamespaceIndentation: None\n# ObjCBinPackProtocolList: Auto\n# ObjCBlockIndentWidth: 2\n# ObjCSpaceAfterProperty: false\n# ObjCSpaceBeforeProtocolList: false\n\nPenaltyBreakAssignment: 2\nPenaltyBreakBeforeFirstCallParameter: 1\nPenaltyBreakComment: 300\nPenaltyBreakFirstLessLess: 120\nPenaltyBreakString: 1000\n# PenaltyBreakTemplateDeclaration: 10\nPenaltyExcessCharacter: 1000000\nPenaltyReturnTypeOnItsOwnLine: 60\nPointerAlignment: Right\n# RawStringFormats:\n# - Language: TextProto\n# Delimiters:\n# - 'pb'\n# - 'proto'\n# EnclosingFunctions:\n# - 'PARSE_TEXT_PROTO'\n# BasedOnStyle: google\n# - Language: Cpp\n# Delimiters:\n# - 'cc'\n# - 'cpp'\n# BasedOnStyle: llvm\n# CanonicalDelimiter: 'cc'\nReflowComments: true\nSortIncludes: false\nSpaceAfterCStyleCast: false\n# SpaceAfterTemplateKeyword: true\nSpaceBeforeAssignmentOperators: true\n# SpaceBeforeCpp11BracedList: false\n# SpaceBeforeCtorInitializerColon: true\n# SpaceBeforeInheritanceColon: true\nSpaceBeforeParens: ControlStatements\n# SpaceBeforeRangeBasedForLoopColon: true\nSpaceInEmptyParentheses: false\nSpacesBeforeTrailingComments: 2\nSpacesInAngles: false\nSpacesInCStyleCastParentheses: false\n# SpacesInContainerLiterals: false\nSpacesInParentheses: false\nSpacesInSquareBrackets: false\n# Standard: Cpp11\n# This is nominally supported in clang-format version 8, but not in the build\n# used by some of the core jemalloc developers.\n# StatementMacros: []\nTabWidth: 8\nUseTab: Never\n...\n" }, { "path": "deps/jemalloc/.gitattributes", "content": "* text=auto eol=lf\n" }, { "path": "deps/jemalloc/.gitignore", "content": "/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/doc/manpages.xsl\n/doc/jemalloc.xml\n/doc/jemalloc.html\n/doc/jemalloc.3\n\n/doc_internal/PROFILING_INTERNALS.pdf\n\n/jemalloc.pc\n\n/lib/\n\n/Makefile\n\n/include/jemalloc/internal/jemalloc_preamble.h\n/include/jemalloc/internal/jemalloc_internal_defs.h\n/include/jemalloc/internal/private_namespace.gen.h\n/include/jemalloc/internal/private_namespace.h\n/include/jemalloc/internal/private_namespace_jet.gen.h\n/include/jemalloc/internal/private_namespace_jet.h\n/include/jemalloc/internal/private_symbols.awk\n/include/jemalloc/internal/private_symbols_jet.awk\n/include/jemalloc/internal/public_namespace.h\n/include/jemalloc/internal/public_symbols.txt\n/include/jemalloc/internal/public_unnamespace.h\n/include/jemalloc/jemalloc.h\n/include/jemalloc/jemalloc_defs.h\n/include/jemalloc/jemalloc_macros.h\n/include/jemalloc/jemalloc_mangle.h\n/include/jemalloc/jemalloc_mangle_jet.h\n/include/jemalloc/jemalloc_protos.h\n/include/jemalloc/jemalloc_protos_jet.h\n/include/jemalloc/jemalloc_rename.h\n/include/jemalloc/jemalloc_typedefs.h\n\n/src/*.[od]\n/src/*.sym\n\n/run_tests.out/\n\n/test/test.sh\ntest/include/test/jemalloc_test.h\ntest/include/test/jemalloc_test_defs.h\n\n/test/integration/[A-Za-z]*\n!/test/integration/cpp/\n!/test/integration/[A-Za-z]*.*\n/test/integration/*.[od]\n/test/integration/*.out\n\n/test/integration/cpp/[A-Za-z]*\n!/test/integration/cpp/[A-Za-z]*.*\n/test/integration/cpp/*.[od]\n/test/integration/cpp/*.out\n\n/test/src/*.[od]\n\n/test/stress/[A-Za-z]*\n!/test/stress/[A-Za-z]*.*\n/test/stress/*.[od]\n/test/stress/*.out\n\n/test/unit/[A-Za-z]*\n!/test/unit/[A-Za-z]*.*\n/test/unit/*.[od]\n/test/unit/*.out\n\n/test/analyze/[A-Za-z]*\n!/test/analyze/[A-Za-z]*.*\n/test/analyze/*.[od]\n/test/analyze/*.out\n\n/VERSION\n\n*.pdb\n*.sdf\n*.opendb\n*.VC.db\n*.opensdf\n*.cachefile\n*.suo\n*.user\n*.sln.docstates\n*.tmp\n.vs/\n/msvc/Win32/\n/msvc/x64/\n/msvc/projects/*/*/Debug*/\n/msvc/projects/*/*/Release*/\n/msvc/projects/*/*/Win32/\n/msvc/projects/*/*/x64/\n" }, { "path": "deps/jemalloc/.travis.yml", "content": "# This config file is generated by ./scripts/gen_travis.py.\n# Do not edit by hand.\n\n# We use 'minimal', because 'generic' makes Windows VMs hang at startup. Also\n# the software provided by 'generic' is simply not needed for our tests.\n# Differences are explained here:\n# https://docs.travis-ci.com/user/languages/minimal-and-generic/\nlanguage: minimal\ndist: focal\n\njobs:\n include:\n - os: windows\n arch: amd64\n env: CC=gcc CXX=g++ EXTRA_CFLAGS=\"-fcommon\"\n - os: windows\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-fcommon\"\n - os: windows\n arch: amd64\n env: CC=cl.exe CXX=cl.exe\n - os: windows\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes EXTRA_CFLAGS=\"-fcommon\"\n - os: windows\n arch: amd64\n env: CC=cl.exe CXX=cl.exe CONFIGURE_FLAGS=\"--enable-debug\"\n - os: windows\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-fcommon\"\n - os: windows\n arch: amd64\n env: CC=cl.exe CXX=cl.exe CROSS_COMPILE_32BIT=yes\n - os: windows\n arch: amd64\n env: CC=cl.exe CXX=cl.exe CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --enable-prof-libunwind\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --enable-prof --enable-prof-libunwind\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --enable-prof-libunwind --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-prof --enable-prof-libunwind\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --enable-prof --enable-prof-libunwind --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug --enable-prof --enable-prof-libunwind\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-prof --enable-prof-libunwind --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: freebsd\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes CONFIGURE_FLAGS=\"--enable-debug --enable-prof --enable-prof-libunwind --with-lg-page=16 --with-malloc-conf=tcache:false\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=clang CXX=clang++ CONFIGURE_FLAGS=\"--with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes COMPILER_FLAGS=\"-m32\" CONFIGURE_FLAGS=\"--with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks --with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16 --with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false,dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false,percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false,background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary,percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary,background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=percpu_arena:percpu,background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=dss:primary\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=percpu_arena:percpu\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: linux\n arch: ppc64le\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=background_thread:true\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CROSS_COMPILE_32BIT=yes EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-stats\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--disable-libdl\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-opt-safety-checks\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-lg-page=16\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n - os: osx\n arch: amd64\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--with-malloc-conf=tcache:false\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds -Wno-unknown-warning-option -Wno-ignored-attributes -Wno-deprecated-declarations\"\n # Development build\n - os: linux\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --disable-cache-oblivious --enable-stats --enable-log --enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n # --enable-expermental-smallocx:\n - os: linux\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug --enable-experimental-smallocx --enable-stats --enable-prof\" EXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n\n\nbefore_install:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/before_install.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/before_install.sh\n fi\n\nbefore_script:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/before_script.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/before_script.sh\n else\n scripts/gen_travis.py > travis_script && diff .travis.yml travis_script\n autoconf\n # If COMPILER_FLAGS are not empty, add them to CC and CXX\n ./configure ${COMPILER_FLAGS:+ CC=\"$CC $COMPILER_FLAGS\" CXX=\"$CXX $COMPILER_FLAGS\"} $CONFIGURE_FLAGS\n make -j3\n make -j3 tests\n fi\n\nscript:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/script.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/script.sh\n else\n make check\n fi\n\n" }, { "path": "deps/jemalloc/COPYING", "content": "Unless otherwise specified, files in the jemalloc source distribution are\nsubject to the following license:\n--------------------------------------------------------------------------------\nCopyright (C) 2002-present Jason Evans .\nAll rights reserved.\nCopyright (C) 2007-2012 Mozilla Foundation. All rights reserved.\nCopyright (C) 2009-present Facebook, Inc. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n1. Redistributions of source code must retain the above copyright notice(s),\n this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice(s),\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY EXPRESS\nOR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO\nEVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT,\nINCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\nOR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\nADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n--------------------------------------------------------------------------------\n" }, { "path": "deps/jemalloc/ChangeLog", "content": "Following are change highlights associated with official releases. Important\nbug fixes are all mentioned, but some internal enhancements are omitted here for\nbrevity. Much more detail can be found in the git revision history:\n\n https://github.com/jemalloc/jemalloc\n\n* 5.3.0 (May 6, 2022)\n\n This release contains many speed and space optimizations, from micro\n optimizations on common paths to rework of internal data structures and\n locking schemes, and many more too detailed to list below. Multiple percent\n of system level metric improvements were measured in tested production\n workloads. The release has gone through large-scale production testing.\n\n New features:\n - Add the thread.idle mallctl which hints that the calling thread will be\n idle for a nontrivial period of time. (@davidtgoldblatt)\n - Allow small size classes to be the maximum size class to cache in the\n thread-specific cache, through the opt.[lg_]tcache_max option. (@interwq,\n @jordalgo)\n - Make the behavior of realloc(ptr, 0) configurable with opt.zero_realloc.\n (@davidtgoldblatt)\n - Add 'make uninstall' support. (@sangshuduo, @Lapenkov)\n - Support C++17 over-aligned allocation. (@marksantaniello)\n - Add the thread.peak mallctl for approximate per-thread peak memory tracking.\n (@davidtgoldblatt)\n - Add interval-based stats output opt.stats_interval. (@interwq)\n - Add prof.prefix to override filename prefixes for dumps. (@zhxchen17)\n - Add high resolution timestamp support for profiling. (@tyroguru)\n - Add the --collapsed flag to jeprof for flamegraph generation.\n (@igorwwwwwwwwwwwwwwwwwwww)\n - Add the --debug-syms-by-id option to jeprof for debug symbols discovery.\n (@DeannaGelbart)\n - Add the opt.prof_leak_error option to exit with error code when leak is\n detected using opt.prof_final. (@yunxuo)\n - Add opt.cache_oblivious as an runtime alternative to config.cache_oblivious.\n (@interwq)\n - Add mallctl interfaces:\n + opt.zero_realloc (@davidtgoldblatt)\n + opt.cache_oblivious (@interwq)\n + opt.prof_leak_error (@yunxuo)\n + opt.stats_interval (@interwq)\n + opt.stats_interval_opts (@interwq)\n + opt.tcache_max (@interwq)\n + opt.trust_madvise (@azat)\n + prof.prefix (@zhxchen17)\n + stats.zero_reallocs (@davidtgoldblatt)\n + thread.idle (@davidtgoldblatt)\n + thread.peak.{read,reset} (@davidtgoldblatt)\n\n Bug fixes:\n - Fix the synchronization around explicit tcache creation which could cause\n invalid tcache identifiers. This regression was first released in 5.0.0.\n (@yoshinorim, @davidtgoldblatt)\n - Fix a profiling biasing issue which could cause incorrect heap usage and\n object counts. This issue existed in all previous releases with the heap\n profiling feature. (@davidtgoldblatt)\n - Fix the order of stats counter updating on large realloc which could cause\n failed assertions. This regression was first released in 5.0.0. (@azat)\n - Fix the locking on the arena destroy mallctl, which could cause concurrent\n arena creations to fail. This functionality was first introduced in 5.0.0.\n (@interwq)\n\n Portability improvements:\n - Remove nothrow from system function declarations on macOS and FreeBSD.\n (@davidtgoldblatt, @fredemmott, @leres)\n - Improve overcommit and page alignment settings on NetBSD. (@zoulasc)\n - Improve CPU affinity support on BSD platforms. (@devnexen)\n - Improve utrace detection and support. (@devnexen)\n - Improve QEMU support with MADV_DONTNEED zeroed pages detection. (@azat)\n - Add memcntl support on Solaris / illumos. (@devnexen)\n - Improve CPU_SPINWAIT on ARM. (@AWSjswinney)\n - Improve TSD cleanup on FreeBSD. (@Lapenkov)\n - Disable percpu_arena if the CPU count cannot be reliably detected. (@azat)\n - Add malloc_size(3) override support. (@devnexen)\n - Add mmap VM_MAKE_TAG support. (@devnexen)\n - Add support for MADV_[NO]CORE. (@devnexen)\n - Add support for DragonFlyBSD. (@devnexen)\n - Fix the QUANTUM setting on MIPS64. (@brooksdavis)\n - Add the QUANTUM setting for ARC. (@vineetgarc)\n - Add the QUANTUM setting for LoongArch. (@wangjl-uos)\n - Add QNX support. (@jqian-aurora)\n - Avoid atexit(3) calls unless the relevant profiling features are enabled.\n (@BusyJay, @laiwei-rice, @interwq)\n - Fix unknown option detection when using Clang. (@Lapenkov)\n - Fix symbol conflict with musl libc. (@georgthegreat)\n - Add -Wimplicit-fallthrough checks. (@nickdesaulniers)\n - Add __forceinline support on MSVC. (@santagada)\n - Improve FreeBSD and Windows CI support. (@Lapenkov)\n - Add CI support for PPC64LE architecture. (@ezeeyahoo)\n\n Incompatible changes:\n - Maximum size class allowed in tcache (opt.[lg_]tcache_max) now has an upper\n bound of 8MiB. (@interwq)\n\n Optimizations and refactors (@davidtgoldblatt, @Lapenkov, @interwq):\n - Optimize the common cases of the thread cache operations.\n - Optimize internal data structures, including RB tree and pairing heap.\n - Optimize the internal locking on extent management.\n - Extract and refactor the internal page allocator and interface modules.\n\n Documentation:\n - Fix doc build with --with-install-suffix. (@lawmurray, @interwq)\n - Add PROFILING_INTERNALS.md. (@davidtgoldblatt)\n - Ensure the proper order of doc building and installation. (@Mingli-Yu)\n\n* 5.2.1 (August 5, 2019)\n\n This release is primarily about Windows. A critical virtual memory leak is\n resolved on all Windows platforms. The regression was present in all releases\n since 5.0.0.\n\n Bug fixes:\n - Fix a severe virtual memory leak on Windows. This regression was first\n released in 5.0.0. (@Ignition, @j0t, @frederik-h, @davidtgoldblatt,\n @interwq)\n - Fix size 0 handling in posix_memalign(). This regression was first released\n in 5.2.0. (@interwq)\n - Fix the prof_log unit test which may observe unexpected backtraces from\n compiler optimizations. The test was first added in 5.2.0. (@marxin,\n @gnzlbg, @interwq)\n - Fix the declaration of the extent_avail tree. This regression was first\n released in 5.1.0. (@zoulasc)\n - Fix an incorrect reference in jeprof. This functionality was first released\n in 3.0.0. (@prehistoric-penguin)\n - Fix an assertion on the deallocation fast-path. This regression was first\n released in 5.2.0. (@yinan1048576)\n - Fix the TLS_MODEL attribute in headers. This regression was first released\n in 5.0.0. (@zoulasc, @interwq)\n\n Optimizations and refactors:\n - Implement opt.retain on Windows and enable by default on 64-bit. (@interwq,\n @davidtgoldblatt)\n - Optimize away a branch on the operator delete[] path. (@mgrice)\n - Add format annotation to the format generator function. (@zoulasc)\n - Refactor and improve the size class header generation. (@yinan1048576)\n - Remove best fit. (@djwatson)\n - Avoid blocking on background thread locks for stats. (@oranagra, @interwq)\n\n* 5.2.0 (April 2, 2019)\n\n This release includes a few notable improvements, which are summarized below:\n 1) improved fast-path performance from the optimizations by @djwatson; 2)\n reduced virtual memory fragmentation and metadata usage; and 3) bug fixes on\n setting the number of background threads. In addition, peak / spike memory\n usage is improved with certain allocation patterns. As usual, the release and\n prior dev versions have gone through large-scale production testing.\n\n New features:\n - Implement oversize_threshold, which uses a dedicated arena for allocations\n crossing the specified threshold to reduce fragmentation. (@interwq)\n - Add extents usage information to stats. (@tyleretzel)\n - Log time information for sampled allocations. (@tyleretzel)\n - Support 0 size in sdallocx. (@djwatson)\n - Output rate for certain counters in malloc_stats. (@zinoale)\n - Add configure option --enable-readlinkat, which allows the use of readlinkat\n over readlink. (@davidtgoldblatt)\n - Add configure options --{enable,disable}-{static,shared} to allow not\n building unwanted libraries. (@Ericson2314)\n - Add configure option --disable-libdl to enable fully static builds.\n (@interwq)\n - Add mallctl interfaces:\n\t+ opt.oversize_threshold (@interwq)\n\t+ stats.arenas..extent_avail (@tyleretzel)\n\t+ stats.arenas..extents..n{dirty,muzzy,retained} (@tyleretzel)\n\t+ stats.arenas..extents..{dirty,muzzy,retained}_bytes\n\t (@tyleretzel)\n\n Portability improvements:\n - Update MSVC builds. (@maksqwe, @rustyx)\n - Workaround a compiler optimizer bug on s390x. (@rkmisra)\n - Make use of pthread_set_name_np(3) on FreeBSD. (@trasz)\n - Implement malloc_getcpu() to enable percpu_arena for windows. (@santagada)\n - Link against -pthread instead of -lpthread. (@paravoid)\n - Make background_thread not dependent on libdl. (@interwq)\n - Add stringify to fix a linker directive issue on MSVC. (@daverigby)\n - Detect and fall back when 8-bit atomics are unavailable. (@interwq)\n - Fall back to the default pthread_create if dlsym(3) fails. (@interwq)\n\n Optimizations and refactors:\n - Refactor the TSD module. (@davidtgoldblatt)\n - Avoid taking extents_muzzy mutex when muzzy is disabled. (@interwq)\n - Avoid taking large_mtx for auto arenas on the tcache flush path. (@interwq)\n - Optimize ixalloc by avoiding a size lookup. (@interwq)\n - Implement opt.oversize_threshold which uses a dedicated arena for requests\n crossing the threshold, also eagerly purges the oversize extents. Default\n the threshold to 8 MiB. (@interwq)\n - Clean compilation with -Wextra. (@gnzlbg, @jasone)\n - Refactor the size class module. (@davidtgoldblatt)\n - Refactor the stats emitter. (@tyleretzel)\n - Optimize pow2_ceil. (@rkmisra)\n - Avoid runtime detection of lazy purging on FreeBSD. (@trasz)\n - Optimize mmap(2) alignment handling on FreeBSD. (@trasz)\n - Improve error handling for THP state initialization. (@jsteemann)\n - Rework the malloc() fast path. (@djwatson)\n - Rework the free() fast path. (@djwatson)\n - Refactor and optimize the tcache fill / flush paths. (@djwatson)\n - Optimize sync / lwsync on PowerPC. (@chmeeedalf)\n - Bypass extent_dalloc() when retain is enabled. (@interwq)\n - Optimize the locking on large deallocation. (@interwq)\n - Reduce the number of pages committed from sanity checking in debug build.\n (@trasz, @interwq)\n - Deprecate OSSpinLock. (@interwq)\n - Lower the default number of background threads to 4 (when the feature\n is enabled). (@interwq)\n - Optimize the trylock spin wait. (@djwatson)\n - Use arena index for arena-matching checks. (@interwq)\n - Avoid forced decay on thread termination when using background threads.\n (@interwq)\n - Disable muzzy decay by default. (@djwatson, @interwq)\n - Only initialize libgcc unwinder when profiling is enabled. (@paravoid,\n @interwq)\n\n Bug fixes (all only relevant to jemalloc 5.x):\n - Fix background thread index issues with max_background_threads. (@djwatson,\n @interwq)\n - Fix stats output for opt.lg_extent_max_active_fit. (@interwq)\n - Fix opt.prof_prefix initialization. (@davidtgoldblatt)\n - Properly trigger decay on tcache destroy. (@interwq, @amosbird)\n - Fix tcache.flush. (@interwq)\n - Detect whether explicit extent zero out is necessary with huge pages or\n custom extent hooks, which may change the purge semantics. (@interwq)\n - Fix a side effect caused by extent_max_active_fit combined with decay-based\n purging, where freed extents can accumulate and not be reused for an\n extended period of time. (@interwq, @mpghf)\n - Fix a missing unlock on extent register error handling. (@zoulasc)\n\n Testing:\n - Simplify the Travis script output. (@gnzlbg)\n - Update the test scripts for FreeBSD. (@devnexen)\n - Add unit tests for the producer-consumer pattern. (@interwq)\n - Add Cirrus-CI config for FreeBSD builds. (@jasone)\n - Add size-matching sanity checks on tcache flush. (@davidtgoldblatt,\n @interwq)\n\n Incompatible changes:\n - Remove --with-lg-page-sizes. (@davidtgoldblatt)\n\n Documentation:\n - Attempt to build docs by default, however skip doc building when xsltproc\n is missing. (@interwq, @cmuellner)\n\n* 5.1.0 (May 4, 2018)\n\n This release is primarily about fine-tuning, ranging from several new features\n to numerous notable performance and portability enhancements. The release and\n prior dev versions have been running in multiple large scale applications for\n months, and the cumulative improvements are substantial in many cases.\n\n Given the long and successful production runs, this release is likely a good\n candidate for applications to upgrade, from both jemalloc 5.0 and before. For\n performance-critical applications, the newly added TUNING.md provides\n guidelines on jemalloc tuning.\n\n New features:\n - Implement transparent huge page support for internal metadata. (@interwq)\n - Add opt.thp to allow enabling / disabling transparent huge pages for all\n mappings. (@interwq)\n - Add maximum background thread count option. (@djwatson)\n - Allow prof_active to control opt.lg_prof_interval and prof.gdump.\n (@interwq)\n - Allow arena index lookup based on allocation addresses via mallctl.\n (@lionkov)\n - Allow disabling initial-exec TLS model. (@davidtgoldblatt, @KenMacD)\n - Add opt.lg_extent_max_active_fit to set the max ratio between the size of\n the active extent selected (to split off from) and the size of the requested\n allocation. (@interwq, @davidtgoldblatt)\n - Add retain_grow_limit to set the max size when growing virtual address\n space. (@interwq)\n - Add mallctl interfaces:\n + arena..retain_grow_limit (@interwq)\n + arenas.lookup (@lionkov)\n + max_background_threads (@djwatson)\n + opt.lg_extent_max_active_fit (@interwq)\n + opt.max_background_threads (@djwatson)\n + opt.metadata_thp (@interwq)\n + opt.thp (@interwq)\n + stats.metadata_thp (@interwq)\n\n Portability improvements:\n - Support GNU/kFreeBSD configuration. (@paravoid)\n - Support m68k, nios2 and SH3 architectures. (@paravoid)\n - Fall back to FD_CLOEXEC when O_CLOEXEC is unavailable. (@zonyitoo)\n - Fix symbol listing for cross-compiling. (@tamird)\n - Fix high bits computation on ARM. (@davidtgoldblatt, @paravoid)\n - Disable the CPU_SPINWAIT macro for Power. (@davidtgoldblatt, @marxin)\n - Fix MSVC 2015 & 2017 builds. (@rustyx)\n - Improve RISC-V support. (@EdSchouten)\n - Set name mangling script in strict mode. (@nicolov)\n - Avoid MADV_HUGEPAGE on ARM. (@marxin)\n - Modify configure to determine return value of strerror_r.\n (@davidtgoldblatt, @cferris1000)\n - Make sure CXXFLAGS is tested with CPP compiler. (@nehaljwani)\n - Fix 32-bit build on MSVC. (@rustyx)\n - Fix external symbol on MSVC. (@maksqwe)\n - Avoid a printf format specifier warning. (@jasone)\n - Add configure option --disable-initial-exec-tls which can allow jemalloc to\n be dynamically loaded after program startup. (@davidtgoldblatt, @KenMacD)\n - AArch64: Add ILP32 support. (@cmuellner)\n - Add --with-lg-vaddr configure option to support cross compiling.\n (@cmuellner, @davidtgoldblatt)\n\n Optimizations and refactors:\n - Improve active extent fit with extent_max_active_fit. This considerably\n reduces fragmentation over time and improves virtual memory and metadata\n usage. (@davidtgoldblatt, @interwq)\n - Eagerly coalesce large extents to reduce fragmentation. (@interwq)\n - sdallocx: only read size info when page aligned (i.e. possibly sampled),\n which speeds up the sized deallocation path significantly. (@interwq)\n - Avoid attempting new mappings for in place expansion with retain, since\n it rarely succeeds in practice and causes high overhead. (@interwq)\n - Refactor OOM handling in newImpl. (@wqfish)\n - Add internal fine-grained logging functionality for debugging use.\n (@davidtgoldblatt)\n - Refactor arena / tcache interactions. (@davidtgoldblatt)\n - Refactor extent management with dumpable flag. (@davidtgoldblatt)\n - Add runtime detection of lazy purging. (@interwq)\n - Use pairing heap instead of red-black tree for extents_avail. (@djwatson)\n - Use sysctl on startup in FreeBSD. (@trasz)\n - Use thread local prng state instead of atomic. (@djwatson)\n - Make decay to always purge one more extent than before, because in\n practice large extents are usually the ones that cross the decay threshold.\n Purging the additional extent helps save memory as well as reduce VM\n fragmentation. (@interwq)\n - Fast division by dynamic values. (@davidtgoldblatt)\n - Improve the fit for aligned allocation. (@interwq, @edwinsmith)\n - Refactor extent_t bitpacking. (@rkmisra)\n - Optimize the generated assembly for ticker operations. (@davidtgoldblatt)\n - Convert stats printing to use a structured text emitter. (@davidtgoldblatt)\n - Remove preserve_lru feature for extents management. (@djwatson)\n - Consolidate two memory loads into one on the fast deallocation path.\n (@davidtgoldblatt, @interwq)\n\n Bug fixes (most of the issues are only relevant to jemalloc 5.0):\n - Fix deadlock with multithreaded fork in OS X. (@davidtgoldblatt)\n - Validate returned file descriptor before use. (@zonyitoo)\n - Fix a few background thread initialization and shutdown issues. (@interwq)\n - Fix an extent coalesce + decay race by taking both coalescing extents off\n the LRU list. (@interwq)\n - Fix potentially unbound increase during decay, caused by one thread keep\n stashing memory to purge while other threads generating new pages. The\n number of pages to purge is checked to prevent this. (@interwq)\n - Fix a FreeBSD bootstrap assertion. (@strejda, @interwq)\n - Handle 32 bit mutex counters. (@rkmisra)\n - Fix a indexing bug when creating background threads. (@davidtgoldblatt,\n @binliu19)\n - Fix arguments passed to extent_init. (@yuleniwo, @interwq)\n - Fix addresses used for ordering mutexes. (@rkmisra)\n - Fix abort_conf processing during bootstrap. (@interwq)\n - Fix include path order for out-of-tree builds. (@cmuellner)\n\n Incompatible changes:\n - Remove --disable-thp. (@interwq)\n - Remove mallctl interfaces:\n + config.thp (@interwq)\n\n Documentation:\n - Add TUNING.md. (@interwq, @davidtgoldblatt, @djwatson)\n\n* 5.0.1 (July 1, 2017)\n\n This bugfix release fixes several issues, most of which are obscure enough\n that typical applications are not impacted.\n\n Bug fixes:\n - Update decay->nunpurged before purging, in order to avoid potential update\n races and subsequent incorrect purging volume. (@interwq)\n - Only abort on dlsym(3) error if the failure impacts an enabled feature (lazy\n locking and/or background threads). This mitigates an initialization\n failure bug for which we still do not have a clear reproduction test case.\n (@interwq)\n - Modify tsd management so that it neither crashes nor leaks if a thread's\n only allocation activity is to call free() after TLS destructors have been\n executed. This behavior was observed when operating with GNU libc, and is\n unlikely to be an issue with other libc implementations. (@interwq)\n - Mask signals during background thread creation. This prevents signals from\n being inadvertently delivered to background threads. (@jasone,\n @davidtgoldblatt, @interwq)\n - Avoid inactivity checks within background threads, in order to prevent\n recursive mutex acquisition. (@interwq)\n - Fix extent_grow_retained() to use the specified hooks when the\n arena..extent_hooks mallctl is used to override the default hooks.\n (@interwq)\n - Add missing reentrancy support for custom extent hooks which allocate.\n (@interwq)\n - Post-fork(2), re-initialize the list of tcaches associated with each arena\n to contain no tcaches except the forking thread's. (@interwq)\n - Add missing post-fork(2) mutex reinitialization for extent_grow_mtx. This\n fixes potential deadlocks after fork(2). (@interwq)\n - Enforce minimum autoconf version (currently 2.68), since 2.63 is known to\n generate corrupt configure scripts. (@jasone)\n - Ensure that the configured page size (--with-lg-page) is no larger than the\n configured huge page size (--with-lg-hugepage). (@jasone)\n\n* 5.0.0 (June 13, 2017)\n\n Unlike all previous jemalloc releases, this release does not use naturally\n aligned \"chunks\" for virtual memory management, and instead uses page-aligned\n \"extents\". This change has few externally visible effects, but the internal\n impacts are... extensive. Many other internal changes combine to make this\n the most cohesively designed version of jemalloc so far, with ample\n opportunity for further enhancements.\n\n Continuous integration is now an integral aspect of development thanks to the\n efforts of @davidtgoldblatt, and the dev branch tends to remain reasonably\n stable on the tested platforms (Linux, FreeBSD, macOS, and Windows). As a\n side effect the official release frequency may decrease over time.\n\n New features:\n - Implement optional per-CPU arena support; threads choose which arena to use\n based on current CPU rather than on fixed thread-->arena associations.\n (@interwq)\n - Implement two-phase decay of unused dirty pages. Pages transition from\n dirty-->muzzy-->clean, where the first phase transition relies on\n madvise(... MADV_FREE) semantics, and the second phase transition discards\n pages such that they are replaced with demand-zeroed pages on next access.\n (@jasone)\n - Increase decay time resolution from seconds to milliseconds. (@jasone)\n - Implement opt-in per CPU background threads, and use them for asynchronous\n decay-driven unused dirty page purging. (@interwq)\n - Add mutex profiling, which collects a variety of statistics useful for\n diagnosing overhead/contention issues. (@interwq)\n - Add C++ new/delete operator bindings. (@djwatson)\n - Support manually created arena destruction, such that all data and metadata\n are discarded. Add MALLCTL_ARENAS_DESTROYED for accessing merged stats\n associated with destroyed arenas. (@jasone)\n - Add MALLCTL_ARENAS_ALL as a fixed index for use in accessing\n merged/destroyed arena statistics via mallctl. (@jasone)\n - Add opt.abort_conf to optionally abort if invalid configuration options are\n detected during initialization. (@interwq)\n - Add opt.stats_print_opts, so that e.g. JSON output can be selected for the\n stats dumped during exit if opt.stats_print is true. (@jasone)\n - Add --with-version=VERSION for use when embedding jemalloc into another\n project's git repository. (@jasone)\n - Add --disable-thp to support cross compiling. (@jasone)\n - Add --with-lg-hugepage to support cross compiling. (@jasone)\n - Add mallctl interfaces (various authors):\n + background_thread\n + opt.abort_conf\n + opt.retain\n + opt.percpu_arena\n + opt.background_thread\n + opt.{dirty,muzzy}_decay_ms\n + opt.stats_print_opts\n + arena..initialized\n + arena..destroy\n + arena..{dirty,muzzy}_decay_ms\n + arena..extent_hooks\n + arenas.{dirty,muzzy}_decay_ms\n + arenas.bin..slab_size\n + arenas.nlextents\n + arenas.lextent..size\n + arenas.create\n + stats.background_thread.{num_threads,num_runs,run_interval}\n + stats.mutexes.{ctl,background_thread,prof,reset}.\n {num_ops,num_spin_acq,num_wait,max_wait_time,total_wait_time,max_num_thds,\n num_owner_switch}\n + stats.arenas..{dirty,muzzy}_decay_ms\n + stats.arenas..uptime\n + stats.arenas..{pmuzzy,base,internal,resident}\n + stats.arenas..{dirty,muzzy}_{npurge,nmadvise,purged}\n + stats.arenas..bins..{nslabs,reslabs,curslabs}\n + stats.arenas..bins..mutex.\n {num_ops,num_spin_acq,num_wait,max_wait_time,total_wait_time,max_num_thds,\n num_owner_switch}\n + stats.arenas..lextents..{nmalloc,ndalloc,nrequests,curlextents}\n + stats.arenas.i.mutexes.{large,extent_avail,extents_dirty,extents_muzzy,\n extents_retained,decay_dirty,decay_muzzy,base,tcache_list}.\n {num_ops,num_spin_acq,num_wait,max_wait_time,total_wait_time,max_num_thds,\n num_owner_switch}\n\n Portability improvements:\n - Improve reentrant allocation support, such that deadlock is less likely if\n e.g. a system library call in turn allocates memory. (@davidtgoldblatt,\n @interwq)\n - Support static linking of jemalloc with glibc. (@djwatson)\n\n Optimizations and refactors:\n - Organize virtual memory as \"extents\" of virtual memory pages, rather than as\n naturally aligned \"chunks\", and store all metadata in arbitrarily distant\n locations. This reduces virtual memory external fragmentation, and will\n interact better with huge pages (not yet explicitly supported). (@jasone)\n - Fold large and huge size classes together; only small and large size classes\n remain. (@jasone)\n - Unify the allocation paths, and merge most fast-path branching decisions.\n (@davidtgoldblatt, @interwq)\n - Embed per thread automatic tcache into thread-specific data, which reduces\n conditional branches and dereferences. Also reorganize tcache to increase\n fast-path data locality. (@interwq)\n - Rewrite atomics to closely model the C11 API, convert various\n synchronization from mutex-based to atomic, and use the explicit memory\n ordering control to resolve various hypothetical races without increasing\n synchronization overhead. (@davidtgoldblatt)\n - Extensively optimize rtree via various methods:\n + Add multiple layers of rtree lookup caching, since rtree lookups are now\n part of fast-path deallocation. (@interwq)\n + Determine rtree layout at compile time. (@jasone)\n + Make the tree shallower for common configurations. (@jasone)\n + Embed the root node in the top-level rtree data structure, thus avoiding\n one level of indirection. (@jasone)\n + Further specialize leaf elements as compared to internal node elements,\n and directly embed extent metadata needed for fast-path deallocation.\n (@jasone)\n + Ignore leading always-zero address bits (architecture-specific).\n (@jasone)\n - Reorganize headers (ongoing work) to make them hermetic, and disentangle\n various module dependencies. (@davidtgoldblatt)\n - Convert various internal data structures such as size class metadata from\n boot-time-initialized to compile-time-initialized. Propagate resulting data\n structure simplifications, such as making arena metadata fixed-size.\n (@jasone)\n - Simplify size class lookups when constrained to size classes that are\n multiples of the page size. This speeds lookups, but the primary benefit is\n complexity reduction in code that was the source of numerous regressions.\n (@jasone)\n - Lock individual extents when possible for localized extent operations,\n rather than relying on a top-level arena lock. (@davidtgoldblatt, @jasone)\n - Use first fit layout policy instead of best fit, in order to improve\n packing. (@jasone)\n - If munmap(2) is not in use, use an exponential series to grow each arena's\n virtual memory, so that the number of disjoint virtual memory mappings\n remains low. (@jasone)\n - Implement per arena base allocators, so that arenas never share any virtual\n memory pages. (@jasone)\n - Automatically generate private symbol name mangling macros. (@jasone)\n\n Incompatible changes:\n - Replace chunk hooks with an expanded/normalized set of extent hooks.\n (@jasone)\n - Remove ratio-based purging. (@jasone)\n - Remove --disable-tcache. (@jasone)\n - Remove --disable-tls. (@jasone)\n - Remove --enable-ivsalloc. (@jasone)\n - Remove --with-lg-size-class-group. (@jasone)\n - Remove --with-lg-tiny-min. (@jasone)\n - Remove --disable-cc-silence. (@jasone)\n - Remove --enable-code-coverage. (@jasone)\n - Remove --disable-munmap (replaced by opt.retain). (@jasone)\n - Remove Valgrind support. (@jasone)\n - Remove quarantine support. (@jasone)\n - Remove redzone support. (@jasone)\n - Remove mallctl interfaces (various authors):\n + config.munmap\n + config.tcache\n + config.tls\n + config.valgrind\n + opt.lg_chunk\n + opt.purge\n + opt.lg_dirty_mult\n + opt.decay_time\n + opt.quarantine\n + opt.redzone\n + opt.thp\n + arena..lg_dirty_mult\n + arena..decay_time\n + arena..chunk_hooks\n + arenas.initialized\n + arenas.lg_dirty_mult\n + arenas.decay_time\n + arenas.bin..run_size\n + arenas.nlruns\n + arenas.lrun..size\n + arenas.nhchunks\n + arenas.hchunk..size\n + arenas.extend\n + stats.cactive\n + stats.arenas..lg_dirty_mult\n + stats.arenas..decay_time\n + stats.arenas..metadata.{mapped,allocated}\n + stats.arenas..{npurge,nmadvise,purged}\n + stats.arenas..huge.{allocated,nmalloc,ndalloc,nrequests}\n + stats.arenas..bins..{nruns,reruns,curruns}\n + stats.arenas..lruns..{nmalloc,ndalloc,nrequests,curruns}\n + stats.arenas..hchunks..{nmalloc,ndalloc,nrequests,curhchunks}\n\n Bug fixes:\n - Improve interval-based profile dump triggering to dump only one profile when\n a single allocation's size exceeds the interval. (@jasone)\n - Use prefixed function names (as controlled by --with-jemalloc-prefix) when\n pruning backtrace frames in jeprof. (@jasone)\n\n* 4.5.0 (February 28, 2017)\n\n This is the first release to benefit from much broader continuous integration\n testing, thanks to @davidtgoldblatt. Had we had this testing infrastructure\n in place for prior releases, it would have caught all of the most serious\n regressions fixed by this release.\n\n New features:\n - Add --disable-thp and the opt.thp mallctl to provide opt-out mechanisms for\n transparent huge page integration. (@jasone)\n - Update zone allocator integration to work with macOS 10.12. (@glandium)\n - Restructure *CFLAGS configuration, so that CFLAGS behaves typically, and\n EXTRA_CFLAGS provides a way to specify e.g. -Werror during building, but not\n during configuration. (@jasone, @ronawho)\n\n Bug fixes:\n - Fix DSS (sbrk(2)-based) allocation. This regression was first released in\n 4.3.0. (@jasone)\n - Handle race in per size class utilization computation. This functionality\n was first released in 4.0.0. (@interwq)\n - Fix lock order reversal during gdump. (@jasone)\n - Fix/refactor tcache synchronization. This regression was first released in\n 4.0.0. (@jasone)\n - Fix various JSON-formatted malloc_stats_print() bugs. This functionality\n was first released in 4.3.0. (@jasone)\n - Fix huge-aligned allocation. This regression was first released in 4.4.0.\n (@jasone)\n - When transparent huge page integration is enabled, detect what state pages\n start in according to the kernel's current operating mode, and only convert\n arena chunks to non-huge during purging if that is not their initial state.\n This functionality was first released in 4.4.0. (@jasone)\n - Fix lg_chunk clamping for the --enable-cache-oblivious --disable-fill case.\n This regression was first released in 4.0.0. (@jasone, @428desmo)\n - Properly detect sparc64 when building for Linux. (@glaubitz)\n\n* 4.4.0 (December 3, 2016)\n\n New features:\n - Add configure support for *-*-linux-android. (@cferris1000, @jasone)\n - Add the --disable-syscall configure option, for use on systems that place\n security-motivated limitations on syscall(2). (@jasone)\n - Add support for Debian GNU/kFreeBSD. (@thesam)\n\n Optimizations:\n - Add extent serial numbers and use them where appropriate as a sort key that\n is higher priority than address, so that the allocation policy prefers older\n extents. This tends to improve locality (decrease fragmentation) when\n memory grows downward. (@jasone)\n - Refactor madvise(2) configuration so that MADV_FREE is detected and utilized\n on Linux 4.5 and newer. (@jasone)\n - Mark partially purged arena chunks as non-huge-page. This improves\n interaction with Linux's transparent huge page functionality. (@jasone)\n\n Bug fixes:\n - Fix size class computations for edge conditions involving extremely large\n allocations. This regression was first released in 4.0.0. (@jasone,\n @ingvarha)\n - Remove overly restrictive assertions related to the cactive statistic. This\n regression was first released in 4.1.0. (@jasone)\n - Implement a more reliable detection scheme for os_unfair_lock on macOS.\n (@jszakmeister)\n\n* 4.3.1 (November 7, 2016)\n\n Bug fixes:\n - Fix a severe virtual memory leak. This regression was first released in\n 4.3.0. (@interwq, @jasone)\n - Refactor atomic and prng APIs to restore support for 32-bit platforms that\n use pre-C11 toolchains, e.g. FreeBSD's mips. (@jasone)\n\n* 4.3.0 (November 4, 2016)\n\n This is the first release that passes the test suite for multiple Windows\n configurations, thanks in large part to @glandium setting up continuous\n integration via AppVeyor (and Travis CI for Linux and OS X).\n\n New features:\n - Add \"J\" (JSON) support to malloc_stats_print(). (@jasone)\n - Add Cray compiler support. (@ronawho)\n\n Optimizations:\n - Add/use adaptive spinning for bootstrapping and radix tree node\n initialization. (@jasone)\n\n Bug fixes:\n - Fix large allocation to search starting in the optimal size class heap,\n which can substantially reduce virtual memory churn and fragmentation. This\n regression was first released in 4.0.0. (@mjp41, @jasone)\n - Fix stats.arenas..nthreads accounting. (@interwq)\n - Fix and simplify decay-based purging. (@jasone)\n - Make DSS (sbrk(2)-related) operations lockless, which resolves potential\n deadlocks during thread exit. (@jasone)\n - Fix over-sized allocation of radix tree leaf nodes. (@mjp41, @ogaun,\n @jasone)\n - Fix over-sized allocation of arena_t (plus associated stats) data\n structures. (@jasone, @interwq)\n - Fix EXTRA_CFLAGS to not affect configuration. (@jasone)\n - Fix a Valgrind integration bug. (@ronawho)\n - Disallow 0x5a junk filling when running in Valgrind. (@jasone)\n - Fix a file descriptor leak on Linux. This regression was first released in\n 4.2.0. (@vsarunas, @jasone)\n - Fix static linking of jemalloc with glibc. (@djwatson)\n - Use syscall(2) rather than {open,read,close}(2) during boot on Linux. This\n works around other libraries' system call wrappers performing reentrant\n allocation. (@kspinka, @Whissi, @jasone)\n - Fix OS X default zone replacement to work with OS X 10.12. (@glandium,\n @jasone)\n - Fix cached memory management to avoid needless commit/decommit operations\n during purging, which resolves permanent virtual memory map fragmentation\n issues on Windows. (@mjp41, @jasone)\n - Fix TSD fetches to avoid (recursive) allocation. This is relevant to\n non-TLS and Windows configurations. (@jasone)\n - Fix malloc_conf overriding to work on Windows. (@jasone)\n - Forcibly disable lazy-lock on Windows (was forcibly *enabled*). (@jasone)\n\n* 4.2.1 (June 8, 2016)\n\n Bug fixes:\n - Fix bootstrapping issues for configurations that require allocation during\n tsd initialization (e.g. --disable-tls). (@cferris1000, @jasone)\n - Fix gettimeofday() version of nstime_update(). (@ronawho)\n - Fix Valgrind regressions in calloc() and chunk_alloc_wrapper(). (@ronawho)\n - Fix potential VM map fragmentation regression. (@jasone)\n - Fix opt_zero-triggered in-place huge reallocation zeroing. (@jasone)\n - Fix heap profiling context leaks in reallocation edge cases. (@jasone)\n\n* 4.2.0 (May 12, 2016)\n\n New features:\n - Add the arena..reset mallctl, which makes it possible to discard all of\n an arena's allocations in a single operation. (@jasone)\n - Add the stats.retained and stats.arenas..retained statistics. (@jasone)\n - Add the --with-version configure option. (@jasone)\n - Support --with-lg-page values larger than actual page size. (@jasone)\n\n Optimizations:\n - Use pairing heaps rather than red-black trees for various hot data\n structures. (@djwatson, @jasone)\n - Streamline fast paths of rtree operations. (@jasone)\n - Optimize the fast paths of calloc() and [m,d,sd]allocx(). (@jasone)\n - Decommit unused virtual memory if the OS does not overcommit. (@jasone)\n - Specify MAP_NORESERVE on Linux if [heuristic] overcommit is active, in order\n to avoid unfortunate interactions during fork(2). (@jasone)\n\n Bug fixes:\n - Fix chunk accounting related to triggering gdump profiles. (@jasone)\n - Link against librt for clock_gettime(2) if glibc < 2.17. (@jasone)\n - Scale leak report summary according to sampling probability. (@jasone)\n\n* 4.1.1 (May 3, 2016)\n\n This bugfix release resolves a variety of mostly minor issues, though the\n bitmap fix is critical for 64-bit Windows.\n\n Bug fixes:\n - Fix the linear scan version of bitmap_sfu() to shift by the proper amount\n even when sizeof(long) is not the same as sizeof(void *), as on 64-bit\n Windows. (@jasone)\n - Fix hashing functions to avoid unaligned memory accesses (and resulting\n crashes). This is relevant at least to some ARM-based platforms.\n (@rkmisra)\n - Fix fork()-related lock rank ordering reversals. These reversals were\n unlikely to cause deadlocks in practice except when heap profiling was\n enabled and active. (@jasone)\n - Fix various chunk leaks in OOM code paths. (@jasone)\n - Fix malloc_stats_print() to print opt.narenas correctly. (@jasone)\n - Fix MSVC-specific build/test issues. (@rustyx, @yuslepukhin)\n - Fix a variety of test failures that were due to test fragility rather than\n core bugs. (@jasone)\n\n* 4.1.0 (February 28, 2016)\n\n This release is primarily about optimizations, but it also incorporates a lot\n of portability-motivated refactoring and enhancements. Many people worked on\n this release, to an extent that even with the omission here of minor changes\n (see git revision history), and of the people who reported and diagnosed\n issues, so much of the work was contributed that starting with this release,\n changes are annotated with author credits to help reflect the collaborative\n effort involved.\n\n New features:\n - Implement decay-based unused dirty page purging, a major optimization with\n mallctl API impact. This is an alternative to the existing ratio-based\n unused dirty page purging, and is intended to eventually become the sole\n purging mechanism. New mallctls:\n + opt.purge\n + opt.decay_time\n + arena..decay\n + arena..decay_time\n + arenas.decay_time\n + stats.arenas..decay_time\n (@jasone, @cevans87)\n - Add --with-malloc-conf, which makes it possible to embed a default\n options string during configuration. This was motivated by the desire to\n specify --with-malloc-conf=purge:decay , since the default must remain\n purge:ratio until the 5.0.0 release. (@jasone)\n - Add MS Visual Studio 2015 support. (@rustyx, @yuslepukhin)\n - Make *allocx() size class overflow behavior defined. The maximum\n size class is now less than PTRDIFF_MAX to protect applications against\n numerical overflow, and all allocation functions are guaranteed to indicate\n errors rather than potentially crashing if the request size exceeds the\n maximum size class. (@jasone)\n - jeprof:\n + Add raw heap profile support. (@jasone)\n + Add --retain and --exclude for backtrace symbol filtering. (@jasone)\n\n Optimizations:\n - Optimize the fast path to combine various bootstrapping and configuration\n checks and execute more streamlined code in the common case. (@interwq)\n - Use linear scan for small bitmaps (used for small object tracking). In\n addition to speeding up bitmap operations on 64-bit systems, this reduces\n allocator metadata overhead by approximately 0.2%. (@djwatson)\n - Separate arena_avail trees, which substantially speeds up run tree\n operations. (@djwatson)\n - Use memoization (boot-time-computed table) for run quantization. Separate\n arena_avail trees reduced the importance of this optimization. (@jasone)\n - Attempt mmap-based in-place huge reallocation. This can dramatically speed\n up incremental huge reallocation. (@jasone)\n\n Incompatible changes:\n - Make opt.narenas unsigned rather than size_t. (@jasone)\n\n Bug fixes:\n - Fix stats.cactive accounting regression. (@rustyx, @jasone)\n - Handle unaligned keys in hash(). This caused problems for some ARM systems.\n (@jasone, @cferris1000)\n - Refactor arenas array. In addition to fixing a fork-related deadlock, this\n makes arena lookups faster and simpler. (@jasone)\n - Move retained memory allocation out of the default chunk allocation\n function, to a location that gets executed even if the application installs\n a custom chunk allocation function. This resolves a virtual memory leak.\n (@buchgr)\n - Fix a potential tsd cleanup leak. (@cferris1000, @jasone)\n - Fix run quantization. In practice this bug had no impact unless\n applications requested memory with alignment exceeding one page.\n (@jasone, @djwatson)\n - Fix LinuxThreads-specific bootstrapping deadlock. (Cosmin Paraschiv)\n - jeprof:\n + Don't discard curl options if timeout is not defined. (@djwatson)\n + Detect failed profile fetches. (@djwatson)\n - Fix stats.arenas..{dss,lg_dirty_mult,decay_time,pactive,pdirty} for\n --disable-stats case. (@jasone)\n\n* 4.0.4 (October 24, 2015)\n\n This bugfix release fixes another xallocx() regression. No other regressions\n have come to light in over a month, so this is likely a good starting point\n for people who prefer to wait for \"dot one\" releases with all the major issues\n shaken out.\n\n Bug fixes:\n - Fix xallocx(..., MALLOCX_ZERO to zero the last full trailing page of large\n allocations that have been randomly assigned an offset of 0 when\n --enable-cache-oblivious configure option is enabled.\n\n* 4.0.3 (September 24, 2015)\n\n This bugfix release continues the trend of xallocx() and heap profiling fixes.\n\n Bug fixes:\n - Fix xallocx(..., MALLOCX_ZERO) to zero all trailing bytes of large\n allocations when --enable-cache-oblivious configure option is enabled.\n - Fix xallocx(..., MALLOCX_ZERO) to zero trailing bytes of huge allocations\n when resizing from/to a size class that is not a multiple of the chunk size.\n - Fix prof_tctx_dump_iter() to filter out nodes that were created after heap\n profile dumping started.\n - Work around a potentially bad thread-specific data initialization\n interaction with NPTL (glibc's pthreads implementation).\n\n* 4.0.2 (September 21, 2015)\n\n This bugfix release addresses a few bugs specific to heap profiling.\n\n Bug fixes:\n - Fix ixallocx_prof_sample() to never modify nor create sampled small\n allocations. xallocx() is in general incapable of moving small allocations,\n so this fix removes buggy code without loss of generality.\n - Fix irallocx_prof_sample() to always allocate large regions, even when\n alignment is non-zero.\n - Fix prof_alloc_rollback() to read tdata from thread-specific data rather\n than dereferencing a potentially invalid tctx.\n\n* 4.0.1 (September 15, 2015)\n\n This is a bugfix release that is somewhat high risk due to the amount of\n refactoring required to address deep xallocx() problems. As a side effect of\n these fixes, xallocx() now tries harder to partially fulfill requests for\n optional extra space. Note that a couple of minor heap profiling\n optimizations are included, but these are better thought of as performance\n fixes that were integral to discovering most of the other bugs.\n\n Optimizations:\n - Avoid a chunk metadata read in arena_prof_tctx_set(), since it is in the\n fast path when heap profiling is enabled. Additionally, split a special\n case out into arena_prof_tctx_reset(), which also avoids chunk metadata\n reads.\n - Optimize irallocx_prof() to optimistically update the sampler state. The\n prior implementation appears to have been a holdover from when\n rallocx()/xallocx() functionality was combined as rallocm().\n\n Bug fixes:\n - Fix TLS configuration such that it is enabled by default for platforms on\n which it works correctly.\n - Fix arenas_cache_cleanup() and arena_get_hard() to handle\n allocation/deallocation within the application's thread-specific data\n cleanup functions even after arenas_cache is torn down.\n - Fix xallocx() bugs related to size+extra exceeding HUGE_MAXCLASS.\n - Fix chunk purge hook calls for in-place huge shrinking reallocation to\n specify the old chunk size rather than the new chunk size. This bug caused\n no correctness issues for the default chunk purge function, but was\n visible to custom functions set via the \"arena..chunk_hooks\" mallctl.\n - Fix heap profiling bugs:\n + Fix heap profiling to distinguish among otherwise identical sample sites\n with interposed resets (triggered via the \"prof.reset\" mallctl). This bug\n could cause data structure corruption that would most likely result in a\n segfault.\n + Fix irealloc_prof() to prof_alloc_rollback() on OOM.\n + Make one call to prof_active_get_unlocked() per allocation event, and use\n the result throughout the relevant functions that handle an allocation\n event. Also add a missing check in prof_realloc(). These fixes protect\n allocation events against concurrent prof_active changes.\n + Fix ixallocx_prof() to pass usize_max and zero to ixallocx_prof_sample()\n in the correct order.\n + Fix prof_realloc() to call prof_free_sampled_object() after calling\n prof_malloc_sample_object(). Prior to this fix, if tctx and old_tctx were\n the same, the tctx could have been prematurely destroyed.\n - Fix portability bugs:\n + Don't bitshift by negative amounts when encoding/decoding run sizes in\n chunk header maps. This affected systems with page sizes greater than 8\n KiB.\n + Rename index_t to szind_t to avoid an existing type on Solaris.\n + Add JEMALLOC_CXX_THROW to the memalign() function prototype, in order to\n match glibc and avoid compilation errors when including both\n jemalloc/jemalloc.h and malloc.h in C++ code.\n + Don't assume that /bin/sh is appropriate when running size_classes.sh\n during configuration.\n + Consider __sparcv9 a synonym for __sparc64__ when defining LG_QUANTUM.\n + Link tests to librt if it contains clock_gettime(2).\n\n* 4.0.0 (August 17, 2015)\n\n This version contains many speed and space optimizations, both minor and\n major. The major themes are generalization, unification, and simplification.\n Although many of these optimizations cause no visible behavior change, their\n cumulative effect is substantial.\n\n New features:\n - Normalize size class spacing to be consistent across the complete size\n range. By default there are four size classes per size doubling, but this\n is now configurable via the --with-lg-size-class-group option. Also add the\n --with-lg-page, --with-lg-page-sizes, --with-lg-quantum, and\n --with-lg-tiny-min options, which can be used to tweak page and size class\n settings. Impacts:\n + Worst case performance for incrementally growing/shrinking reallocation\n is improved because there are far fewer size classes, and therefore\n copying happens less often.\n + Internal fragmentation is limited to 20% for all but the smallest size\n classes (those less than four times the quantum). (1B + 4 KiB)\n and (1B + 4 MiB) previously suffered nearly 50% internal fragmentation.\n + Chunk fragmentation tends to be lower because there are fewer distinct run\n sizes to pack.\n - Add support for explicit tcaches. The \"tcache.create\", \"tcache.flush\", and\n \"tcache.destroy\" mallctls control tcache lifetime and flushing, and the\n MALLOCX_TCACHE(tc) and MALLOCX_TCACHE_NONE flags to the *allocx() API\n control which tcache is used for each operation.\n - Implement per thread heap profiling, as well as the ability to\n enable/disable heap profiling on a per thread basis. Add the \"prof.reset\",\n \"prof.lg_sample\", \"thread.prof.name\", \"thread.prof.active\",\n \"opt.prof_thread_active_init\", \"prof.thread_active_init\", and\n \"thread.prof.active\" mallctls.\n - Add support for per arena application-specified chunk allocators, configured\n via the \"arena..chunk_hooks\" mallctl.\n - Refactor huge allocation to be managed by arenas, so that arenas now\n function as general purpose independent allocators. This is important in\n the context of user-specified chunk allocators, aside from the scalability\n benefits. Related new statistics:\n + The \"stats.arenas..huge.allocated\", \"stats.arenas..huge.nmalloc\",\n \"stats.arenas..huge.ndalloc\", and \"stats.arenas..huge.nrequests\"\n mallctls provide high level per arena huge allocation statistics.\n + The \"arenas.nhchunks\", \"arenas.hchunk..size\",\n \"stats.arenas..hchunks..nmalloc\",\n \"stats.arenas..hchunks..ndalloc\",\n \"stats.arenas..hchunks..nrequests\", and\n \"stats.arenas..hchunks..curhchunks\" mallctls provide per size class\n statistics.\n - Add the 'util' column to malloc_stats_print() output, which reports the\n proportion of available regions that are currently in use for each small\n size class.\n - Add \"alloc\" and \"free\" modes for for junk filling (see the \"opt.junk\"\n mallctl), so that it is possible to separately enable junk filling for\n allocation versus deallocation.\n - Add the jemalloc-config script, which provides information about how\n jemalloc was configured, and how to integrate it into application builds.\n - Add metadata statistics, which are accessible via the \"stats.metadata\",\n \"stats.arenas..metadata.mapped\", and\n \"stats.arenas..metadata.allocated\" mallctls.\n - Add the \"stats.resident\" mallctl, which reports the upper limit of\n physically resident memory mapped by the allocator.\n - Add per arena control over unused dirty page purging, via the\n \"arenas.lg_dirty_mult\", \"arena..lg_dirty_mult\", and\n \"stats.arenas..lg_dirty_mult\" mallctls.\n - Add the \"prof.gdump\" mallctl, which makes it possible to toggle the gdump\n feature on/off during program execution.\n - Add sdallocx(), which implements sized deallocation. The primary\n optimization over dallocx() is the removal of a metadata read, which often\n suffers an L1 cache miss.\n - Add missing header includes in jemalloc/jemalloc.h, so that applications\n only have to #include .\n - Add support for additional platforms:\n + Bitrig\n + Cygwin\n + DragonFlyBSD\n + iOS\n + OpenBSD\n + OpenRISC/or1k\n\n Optimizations:\n - Maintain dirty runs in per arena LRUs rather than in per arena trees of\n dirty-run-containing chunks. In practice this change significantly reduces\n dirty page purging volume.\n - Integrate whole chunks into the unused dirty page purging machinery. This\n reduces the cost of repeated huge allocation/deallocation, because it\n effectively introduces a cache of chunks.\n - Split the arena chunk map into two separate arrays, in order to increase\n cache locality for the frequently accessed bits.\n - Move small run metadata out of runs, into arena chunk headers. This reduces\n run fragmentation, smaller runs reduce external fragmentation for small size\n classes, and packed (less uniformly aligned) metadata layout improves CPU\n cache set distribution.\n - Randomly distribute large allocation base pointer alignment relative to page\n boundaries in order to more uniformly utilize CPU cache sets. This can be\n disabled via the --disable-cache-oblivious configure option, and queried via\n the \"config.cache_oblivious\" mallctl.\n - Micro-optimize the fast paths for the public API functions.\n - Refactor thread-specific data to reside in a single structure. This assures\n that only a single TLS read is necessary per call into the public API.\n - Implement in-place huge allocation growing and shrinking.\n - Refactor rtree (radix tree for chunk lookups) to be lock-free, and make\n additional optimizations that reduce maximum lookup depth to one or two\n levels. This resolves what was a concurrency bottleneck for per arena huge\n allocation, because a global data structure is critical for determining\n which arenas own which huge allocations.\n\n Incompatible changes:\n - Replace --enable-cc-silence with --disable-cc-silence to suppress spurious\n warnings by default.\n - Assure that the constness of malloc_usable_size()'s return type matches that\n of the system implementation.\n - Change the heap profile dump format to support per thread heap profiling,\n rename pprof to jeprof, and enhance it with the --thread= option. As a\n result, the bundled jeprof must now be used rather than the upstream\n (gperftools) pprof.\n - Disable \"opt.prof_final\" by default, in order to avoid atexit(3), which can\n internally deadlock on some platforms.\n - Change the \"arenas.nlruns\" mallctl type from size_t to unsigned.\n - Replace the \"stats.arenas..bins..allocated\" mallctl with\n \"stats.arenas..bins..curregs\".\n - Ignore MALLOC_CONF in set{uid,gid,cap} binaries.\n - Ignore MALLOCX_ARENA(a) in dallocx(), in favor of using the\n MALLOCX_TCACHE(tc) and MALLOCX_TCACHE_NONE flags to control tcache usage.\n\n Removed features:\n - Remove the *allocm() API, which is superseded by the *allocx() API.\n - Remove the --enable-dss options, and make dss non-optional on all platforms\n which support sbrk(2).\n - Remove the \"arenas.purge\" mallctl, which was obsoleted by the\n \"arena..purge\" mallctl in 3.1.0.\n - Remove the unnecessary \"opt.valgrind\" mallctl; jemalloc automatically\n detects whether it is running inside Valgrind.\n - Remove the \"stats.huge.allocated\", \"stats.huge.nmalloc\", and\n \"stats.huge.ndalloc\" mallctls.\n - Remove the --enable-mremap option.\n - Remove the \"stats.chunks.current\", \"stats.chunks.total\", and\n \"stats.chunks.high\" mallctls.\n\n Bug fixes:\n - Fix the cactive statistic to decrease (rather than increase) when active\n memory decreases. This regression was first released in 3.5.0.\n - Fix OOM handling in memalign() and valloc(). A variant of this bug existed\n in all releases since 2.0.0, which introduced these functions.\n - Fix an OOM-related regression in arena_tcache_fill_small(), which could\n cause cache corruption on OOM. This regression was present in all releases\n from 2.2.0 through 3.6.0.\n - Fix size class overflow handling for malloc(), posix_memalign(), memalign(),\n calloc(), and realloc() when profiling is enabled.\n - Fix the \"arena..dss\" mallctl to return an error if \"primary\" or\n \"secondary\" precedence is specified, but sbrk(2) is not supported.\n - Fix fallback lg_floor() implementations to handle extremely large inputs.\n - Ensure the default purgeable zone is after the default zone on OS X.\n - Fix latent bugs in atomic_*().\n - Fix the \"arena..dss\" mallctl to handle read-only calls.\n - Fix tls_model configuration to enable the initial-exec model when possible.\n - Mark malloc_conf as a weak symbol so that the application can override it.\n - Correctly detect glibc's adaptive pthread mutexes.\n - Fix the --without-export configure option.\n\n* 3.6.0 (March 31, 2014)\n\n This version contains a critical bug fix for a regression present in 3.5.0 and\n 3.5.1.\n\n Bug fixes:\n - Fix a regression in arena_chunk_alloc() that caused crashes during\n small/large allocation if chunk allocation failed. In the absence of this\n bug, chunk allocation failure would result in allocation failure, e.g. NULL\n return from malloc(). This regression was introduced in 3.5.0.\n - Fix backtracing for gcc intrinsics-based backtracing by specifying\n -fno-omit-frame-pointer to gcc. Note that the application (and all the\n libraries it links to) must also be compiled with this option for\n backtracing to be reliable.\n - Use dss allocation precedence for huge allocations as well as small/large\n allocations.\n - Fix test assertion failure message formatting. This bug did not manifest on\n x86_64 systems because of implementation subtleties in va_list.\n - Fix inconsequential test failures for hash and SFMT code.\n\n New features:\n - Support heap profiling on FreeBSD. This feature depends on the proc\n filesystem being mounted during heap profile dumping.\n\n* 3.5.1 (February 25, 2014)\n\n This version primarily addresses minor bugs in test code.\n\n Bug fixes:\n - Configure Solaris/Illumos to use MADV_FREE.\n - Fix junk filling for mremap(2)-based huge reallocation. This is only\n relevant if configuring with the --enable-mremap option specified.\n - Avoid compilation failure if 'restrict' C99 keyword is not supported by the\n compiler.\n - Add a configure test for SSE2 rather than assuming it is usable on i686\n systems. This fixes test compilation errors, especially on 32-bit Linux\n systems.\n - Fix mallctl argument size mismatches (size_t vs. uint64_t) in the stats unit\n test.\n - Fix/remove flawed alignment-related overflow tests.\n - Prevent compiler optimizations that could change backtraces in the\n prof_accum unit test.\n\n* 3.5.0 (January 22, 2014)\n\n This version focuses on refactoring and automated testing, though it also\n includes some non-trivial heap profiling optimizations not mentioned below.\n\n New features:\n - Add the *allocx() API, which is a successor to the experimental *allocm()\n API. The *allocx() functions are slightly simpler to use because they have\n fewer parameters, they directly return the results of primary interest, and\n mallocx()/rallocx() avoid the strict aliasing pitfall that\n allocm()/rallocm() share with posix_memalign(). Note that *allocm() is\n slated for removal in the next non-bugfix release.\n - Add support for LinuxThreads.\n\n Bug fixes:\n - Unless heap profiling is enabled, disable floating point code and don't link\n with libm. This, in combination with e.g. EXTRA_CFLAGS=-mno-sse on x64\n systems, makes it possible to completely disable floating point register\n use. Some versions of glibc neglect to save/restore caller-saved floating\n point registers during dynamic lazy symbol loading, and the symbol loading\n code uses whatever malloc the application happens to have linked/loaded\n with, the result being potential floating point register corruption.\n - Report ENOMEM rather than EINVAL if an OOM occurs during heap profiling\n backtrace creation in imemalign(). This bug impacted posix_memalign() and\n aligned_alloc().\n - Fix a file descriptor leak in a prof_dump_maps() error path.\n - Fix prof_dump() to close the dump file descriptor for all relevant error\n paths.\n - Fix rallocm() to use the arena specified by the ALLOCM_ARENA(s) flag for\n allocation, not just deallocation.\n - Fix a data race for large allocation stats counters.\n - Fix a potential infinite loop during thread exit. This bug occurred on\n Solaris, and could affect other platforms with similar pthreads TSD\n implementations.\n - Don't junk-fill reallocations unless usable size changes. This fixes a\n violation of the *allocx()/*allocm() semantics.\n - Fix growing large reallocation to junk fill new space.\n - Fix huge deallocation to junk fill when munmap is disabled.\n - Change the default private namespace prefix from empty to je_, and change\n --with-private-namespace-prefix so that it prepends an additional prefix\n rather than replacing je_. This reduces the likelihood of applications\n which statically link jemalloc experiencing symbol name collisions.\n - Add missing private namespace mangling (relevant when\n --with-private-namespace is specified).\n - Add and use JEMALLOC_INLINE_C so that static inline functions are marked as\n static even for debug builds.\n - Add a missing mutex unlock in a malloc_init_hard() error path. In practice\n this error path is never executed.\n - Fix numerous bugs in malloc_strotumax() error handling/reporting. These\n bugs had no impact except for malformed inputs.\n - Fix numerous bugs in malloc_snprintf(). These bugs were not exercised by\n existing calls, so they had no impact.\n\n* 3.4.1 (October 20, 2013)\n\n Bug fixes:\n - Fix a race in the \"arenas.extend\" mallctl that could cause memory corruption\n of internal data structures and subsequent crashes.\n - Fix Valgrind integration flaws that caused Valgrind warnings about reads of\n uninitialized memory in:\n + arena chunk headers\n + internal zero-initialized data structures (relevant to tcache and prof\n code)\n - Preserve errno during the first allocation. A readlink(2) call during\n initialization fails unless /etc/malloc.conf exists, so errno was typically\n set during the first allocation prior to this fix.\n - Fix compilation warnings reported by gcc 4.8.1.\n\n* 3.4.0 (June 2, 2013)\n\n This version is essentially a small bugfix release, but the addition of\n aarch64 support requires that the minor version be incremented.\n\n Bug fixes:\n - Fix race-triggered deadlocks in chunk_record(). These deadlocks were\n typically triggered by multiple threads concurrently deallocating huge\n objects.\n\n New features:\n - Add support for the aarch64 architecture.\n\n* 3.3.1 (March 6, 2013)\n\n This version fixes bugs that are typically encountered only when utilizing\n custom run-time options.\n\n Bug fixes:\n - Fix a locking order bug that could cause deadlock during fork if heap\n profiling were enabled.\n - Fix a chunk recycling bug that could cause the allocator to lose track of\n whether a chunk was zeroed. On FreeBSD, NetBSD, and OS X, it could cause\n corruption if allocating via sbrk(2) (unlikely unless running with the\n \"dss:primary\" option specified). This was completely harmless on Linux\n unless using mlockall(2) (and unlikely even then, unless the\n --disable-munmap configure option or the \"dss:primary\" option was\n specified). This regression was introduced in 3.1.0 by the\n mlockall(2)/madvise(2) interaction fix.\n - Fix TLS-related memory corruption that could occur during thread exit if the\n thread never allocated memory. Only the quarantine and prof facilities were\n susceptible.\n - Fix two quarantine bugs:\n + Internal reallocation of the quarantined object array leaked the old\n array.\n + Reallocation failure for internal reallocation of the quarantined object\n array (very unlikely) resulted in memory corruption.\n - Fix Valgrind integration to annotate all internally allocated memory in a\n way that keeps Valgrind happy about internal data structure access.\n - Fix building for s390 systems.\n\n* 3.3.0 (January 23, 2013)\n\n This version includes a few minor performance improvements in addition to the\n listed new features and bug fixes.\n\n New features:\n - Add clipping support to lg_chunk option processing.\n - Add the --enable-ivsalloc option.\n - Add the --without-export option.\n - Add the --disable-zone-allocator option.\n\n Bug fixes:\n - Fix \"arenas.extend\" mallctl to output the number of arenas.\n - Fix chunk_recycle() to unconditionally inform Valgrind that returned memory\n is undefined.\n - Fix build break on FreeBSD related to alloca.h.\n\n* 3.2.0 (November 9, 2012)\n\n In addition to a couple of bug fixes, this version modifies page run\n allocation and dirty page purging algorithms in order to better control\n page-level virtual memory fragmentation.\n\n Incompatible changes:\n - Change the \"opt.lg_dirty_mult\" default from 5 to 3 (32:1 to 8:1).\n\n Bug fixes:\n - Fix dss/mmap allocation precedence code to use recyclable mmap memory only\n after primary dss allocation fails.\n - Fix deadlock in the \"arenas.purge\" mallctl. This regression was introduced\n in 3.1.0 by the addition of the \"arena..purge\" mallctl.\n\n* 3.1.0 (October 16, 2012)\n\n New features:\n - Auto-detect whether running inside Valgrind, thus removing the need to\n manually specify MALLOC_CONF=valgrind:true.\n - Add the \"arenas.extend\" mallctl, which allows applications to create\n manually managed arenas.\n - Add the ALLOCM_ARENA() flag for {,r,d}allocm().\n - Add the \"opt.dss\", \"arena..dss\", and \"stats.arenas..dss\" mallctls,\n which provide control over dss/mmap precedence.\n - Add the \"arena..purge\" mallctl, which obsoletes \"arenas.purge\".\n - Define LG_QUANTUM for hppa.\n\n Incompatible changes:\n - Disable tcache by default if running inside Valgrind, in order to avoid\n making unallocated objects appear reachable to Valgrind.\n - Drop const from malloc_usable_size() argument on Linux.\n\n Bug fixes:\n - Fix heap profiling crash if sampled object is freed via realloc(p, 0).\n - Remove const from __*_hook variable declarations, so that glibc can modify\n them during process forking.\n - Fix mlockall(2)/madvise(2) interaction.\n - Fix fork(2)-related deadlocks.\n - Fix error return value for \"thread.tcache.enabled\" mallctl.\n\n* 3.0.0 (May 11, 2012)\n\n Although this version adds some major new features, the primary focus is on\n internal code cleanup that facilitates maintainability and portability, most\n of which is not reflected in the ChangeLog. This is the first release to\n incorporate substantial contributions from numerous other developers, and the\n result is a more broadly useful allocator (see the git revision history for\n contribution details). Note that the license has been unified, thanks to\n Facebook granting a license under the same terms as the other copyright\n holders (see COPYING).\n\n New features:\n - Implement Valgrind support, redzones, and quarantine.\n - Add support for additional platforms:\n + FreeBSD\n + Mac OS X Lion\n + MinGW\n + Windows (no support yet for replacing the system malloc)\n - Add support for additional architectures:\n + MIPS\n + SH4\n + Tilera\n - Add support for cross compiling.\n - Add nallocm(), which rounds a request size up to the nearest size class\n without actually allocating.\n - Implement aligned_alloc() (blame C11).\n - Add the \"thread.tcache.enabled\" mallctl.\n - Add the \"opt.prof_final\" mallctl.\n - Update pprof (from gperftools 2.0).\n - Add the --with-mangling option.\n - Add the --disable-experimental option.\n - Add the --disable-munmap option, and make it the default on Linux.\n - Add the --enable-mremap option, which disables use of mremap(2) by default.\n\n Incompatible changes:\n - Enable stats by default.\n - Enable fill by default.\n - Disable lazy locking by default.\n - Rename the \"tcache.flush\" mallctl to \"thread.tcache.flush\".\n - Rename the \"arenas.pagesize\" mallctl to \"arenas.page\".\n - Change the \"opt.lg_prof_sample\" default from 0 to 19 (1 B to 512 KiB).\n - Change the \"opt.prof_accum\" default from true to false.\n\n Removed features:\n - Remove the swap feature, including the \"config.swap\", \"swap.avail\",\n \"swap.prezeroed\", \"swap.nfds\", and \"swap.fds\" mallctls.\n - Remove highruns statistics, including the\n \"stats.arenas..bins..highruns\" and\n \"stats.arenas..lruns..highruns\" mallctls.\n - As part of small size class refactoring, remove the \"opt.lg_[qc]space_max\",\n \"arenas.cacheline\", \"arenas.subpage\", \"arenas.[tqcs]space_{min,max}\", and\n \"arenas.[tqcs]bins\" mallctls.\n - Remove the \"arenas.chunksize\" mallctl.\n - Remove the \"opt.lg_prof_tcmax\" option.\n - Remove the \"opt.lg_prof_bt_max\" option.\n - Remove the \"opt.lg_tcache_gc_sweep\" option.\n - Remove the --disable-tiny option, including the \"config.tiny\" mallctl.\n - Remove the --enable-dynamic-page-shift configure option.\n - Remove the --enable-sysv configure option.\n\n Bug fixes:\n - Fix a statistics-related bug in the \"thread.arena\" mallctl that could cause\n invalid statistics and crashes.\n - Work around TLS deallocation via free() on Linux. This bug could cause\n write-after-free memory corruption.\n - Fix a potential deadlock that could occur during interval- and\n growth-triggered heap profile dumps.\n - Fix large calloc() zeroing bugs due to dropping chunk map unzeroed flags.\n - Fix chunk_alloc_dss() to stop claiming memory is zeroed. This bug could\n cause memory corruption and crashes with --enable-dss specified.\n - Fix fork-related bugs that could cause deadlock in children between fork\n and exec.\n - Fix malloc_stats_print() to honor 'b' and 'l' in the opts parameter.\n - Fix realloc(p, 0) to act like free(p).\n - Do not enforce minimum alignment in memalign().\n - Check for NULL pointer in malloc_usable_size().\n - Fix an off-by-one heap profile statistics bug that could be observed in\n interval- and growth-triggered heap profiles.\n - Fix the \"epoch\" mallctl to update cached stats even if the passed in epoch\n is 0.\n - Fix bin->runcur management to fix a layout policy bug. This bug did not\n affect correctness.\n - Fix a bug in choose_arena_hard() that potentially caused more arenas to be\n initialized than necessary.\n - Add missing \"opt.lg_tcache_max\" mallctl implementation.\n - Use glibc allocator hooks to make mixed allocator usage less likely.\n - Fix build issues for --disable-tcache.\n - Don't mangle pthread_create() when --with-private-namespace is specified.\n\n* 2.2.5 (November 14, 2011)\n\n Bug fixes:\n - Fix huge_ralloc() race when using mremap(2). This is a serious bug that\n could cause memory corruption and/or crashes.\n - Fix huge_ralloc() to maintain chunk statistics.\n - Fix malloc_stats_print(..., \"a\") output.\n\n* 2.2.4 (November 5, 2011)\n\n Bug fixes:\n - Initialize arenas_tsd before using it. This bug existed for 2.2.[0-3], as\n well as for --disable-tls builds in earlier releases.\n - Do not assume a 4 KiB page size in test/rallocm.c.\n\n* 2.2.3 (August 31, 2011)\n\n This version fixes numerous bugs related to heap profiling.\n\n Bug fixes:\n - Fix a prof-related race condition. This bug could cause memory corruption,\n but only occurred in non-default configurations (prof_accum:false).\n - Fix off-by-one backtracing issues (make sure that prof_alloc_prep() is\n excluded from backtraces).\n - Fix a prof-related bug in realloc() (only triggered by OOM errors).\n - Fix prof-related bugs in allocm() and rallocm().\n - Fix prof_tdata_cleanup() for --disable-tls builds.\n - Fix a relative include path, to fix objdir builds.\n\n* 2.2.2 (July 30, 2011)\n\n Bug fixes:\n - Fix a build error for --disable-tcache.\n - Fix assertions in arena_purge() (for real this time).\n - Add the --with-private-namespace option. This is a workaround for symbol\n conflicts that can inadvertently arise when using static libraries.\n\n* 2.2.1 (March 30, 2011)\n\n Bug fixes:\n - Implement atomic operations for x86/x64. This fixes compilation failures\n for versions of gcc that are still in wide use.\n - Fix an assertion in arena_purge().\n\n* 2.2.0 (March 22, 2011)\n\n This version incorporates several improvements to algorithms and data\n structures that tend to reduce fragmentation and increase speed.\n\n New features:\n - Add the \"stats.cactive\" mallctl.\n - Update pprof (from google-perftools 1.7).\n - Improve backtracing-related configuration logic, and add the\n --disable-prof-libgcc option.\n\n Bug fixes:\n - Change default symbol visibility from \"internal\", to \"hidden\", which\n decreases the overhead of library-internal function calls.\n - Fix symbol visibility so that it is also set on OS X.\n - Fix a build dependency regression caused by the introduction of the .pic.o\n suffix for PIC object files.\n - Add missing checks for mutex initialization failures.\n - Don't use libgcc-based backtracing except on x64, where it is known to work.\n - Fix deadlocks on OS X that were due to memory allocation in\n pthread_mutex_lock().\n - Heap profiling-specific fixes:\n + Fix memory corruption due to integer overflow in small region index\n computation, when using a small enough sample interval that profiling\n context pointers are stored in small run headers.\n + Fix a bootstrap ordering bug that only occurred with TLS disabled.\n + Fix a rallocm() rsize bug.\n + Fix error detection bugs for aligned memory allocation.\n\n* 2.1.3 (March 14, 2011)\n\n Bug fixes:\n - Fix a cpp logic regression (due to the \"thread.{de,}allocatedp\" mallctl fix\n for OS X in 2.1.2).\n - Fix a \"thread.arena\" mallctl bug.\n - Fix a thread cache stats merging bug.\n\n* 2.1.2 (March 2, 2011)\n\n Bug fixes:\n - Fix \"thread.{de,}allocatedp\" mallctl for OS X.\n - Add missing jemalloc.a to build system.\n\n* 2.1.1 (January 31, 2011)\n\n Bug fixes:\n - Fix aligned huge reallocation (affected allocm()).\n - Fix the ALLOCM_LG_ALIGN macro definition.\n - Fix a heap dumping deadlock.\n - Fix a \"thread.arena\" mallctl bug.\n\n* 2.1.0 (December 3, 2010)\n\n This version incorporates some optimizations that can't quite be considered\n bug fixes.\n\n New features:\n - Use Linux's mremap(2) for huge object reallocation when possible.\n - Avoid locking in mallctl*() when possible.\n - Add the \"thread.[de]allocatedp\" mallctl's.\n - Convert the manual page source from roff to DocBook, and generate both roff\n and HTML manuals.\n\n Bug fixes:\n - Fix a crash due to incorrect bootstrap ordering. This only impacted\n --enable-debug --enable-dss configurations.\n - Fix a minor statistics bug for mallctl(\"swap.avail\", ...).\n\n* 2.0.1 (October 29, 2010)\n\n Bug fixes:\n - Fix a race condition in heap profiling that could cause undefined behavior\n if \"opt.prof_accum\" were disabled.\n - Add missing mutex unlocks for some OOM error paths in the heap profiling\n code.\n - Fix a compilation error for non-C99 builds.\n\n* 2.0.0 (October 24, 2010)\n\n This version focuses on the experimental *allocm() API, and on improved\n run-time configuration/introspection. Nonetheless, numerous performance\n improvements are also included.\n\n New features:\n - Implement the experimental {,r,s,d}allocm() API, which provides a superset\n of the functionality available via malloc(), calloc(), posix_memalign(),\n realloc(), malloc_usable_size(), and free(). These functions can be used to\n allocate/reallocate aligned zeroed memory, ask for optional extra memory\n during reallocation, prevent object movement during reallocation, etc.\n - Replace JEMALLOC_OPTIONS/JEMALLOC_PROF_PREFIX with MALLOC_CONF, which is\n more human-readable, and more flexible. For example:\n JEMALLOC_OPTIONS=AJP\n is now:\n MALLOC_CONF=abort:true,fill:true,stats_print:true\n - Port to Apple OS X. Sponsored by Mozilla.\n - Make it possible for the application to control thread-->arena mappings via\n the \"thread.arena\" mallctl.\n - Add compile-time support for all TLS-related functionality via pthreads TSD.\n This is mainly of interest for OS X, which does not support TLS, but has a\n TSD implementation with similar performance.\n - Override memalign() and valloc() if they are provided by the system.\n - Add the \"arenas.purge\" mallctl, which can be used to synchronously purge all\n dirty unused pages.\n - Make cumulative heap profiling data optional, so that it is possible to\n limit the amount of memory consumed by heap profiling data structures.\n - Add per thread allocation counters that can be accessed via the\n \"thread.allocated\" and \"thread.deallocated\" mallctls.\n\n Incompatible changes:\n - Remove JEMALLOC_OPTIONS and malloc_options (see MALLOC_CONF above).\n - Increase default backtrace depth from 4 to 128 for heap profiling.\n - Disable interval-based profile dumps by default.\n\n Bug fixes:\n - Remove bad assertions in fork handler functions. These assertions could\n cause aborts for some combinations of configure settings.\n - Fix strerror_r() usage to deal with non-standard semantics in GNU libc.\n - Fix leak context reporting. This bug tended to cause the number of contexts\n to be underreported (though the reported number of objects and bytes were\n correct).\n - Fix a realloc() bug for large in-place growing reallocation. This bug could\n cause memory corruption, but it was hard to trigger.\n - Fix an allocation bug for small allocations that could be triggered if\n multiple threads raced to create a new run of backing pages.\n - Enhance the heap profiler to trigger samples based on usable size, rather\n than request size.\n - Fix a heap profiling bug due to sometimes losing track of requested object\n size for sampled objects.\n\n* 1.0.3 (August 12, 2010)\n\n Bug fixes:\n - Fix the libunwind-based implementation of stack backtracing (used for heap\n profiling). This bug could cause zero-length backtraces to be reported.\n - Add a missing mutex unlock in library initialization code. If multiple\n threads raced to initialize malloc, some of them could end up permanently\n blocked.\n\n* 1.0.2 (May 11, 2010)\n\n Bug fixes:\n - Fix junk filling of large objects, which could cause memory corruption.\n - Add MAP_NORESERVE support for chunk mapping, because otherwise virtual\n memory limits could cause swap file configuration to fail. Contributed by\n Jordan DeLong.\n\n* 1.0.1 (April 14, 2010)\n\n Bug fixes:\n - Fix compilation when --enable-fill is specified.\n - Fix threads-related profiling bugs that affected accuracy and caused memory\n to be leaked during thread exit.\n - Fix dirty page purging race conditions that could cause crashes.\n - Fix crash in tcache flushing code during thread destruction.\n\n* 1.0.0 (April 11, 2010)\n\n This release focuses on speed and run-time introspection. Numerous\n algorithmic improvements make this release substantially faster than its\n predecessors.\n\n New features:\n - Implement autoconf-based configuration system.\n - Add mallctl*(), for the purposes of introspection and run-time\n configuration.\n - Make it possible for the application to manually flush a thread's cache, via\n the \"tcache.flush\" mallctl.\n - Base maximum dirty page count on proportion of active memory.\n - Compute various additional run-time statistics, including per size class\n statistics for large objects.\n - Expose malloc_stats_print(), which can be called repeatedly by the\n application.\n - Simplify the malloc_message() signature to only take one string argument,\n and incorporate an opaque data pointer argument for use by the application\n in combination with malloc_stats_print().\n - Add support for allocation backed by one or more swap files, and allow the\n application to disable over-commit if swap files are in use.\n - Implement allocation profiling and leak checking.\n\n Removed features:\n - Remove the dynamic arena rebalancing code, since thread-specific caching\n reduces its utility.\n\n Bug fixes:\n - Modify chunk allocation to work when address space layout randomization\n (ASLR) is in use.\n - Fix thread cleanup bugs related to TLS destruction.\n - Handle 0-size allocation requests in posix_memalign().\n - Fix a chunk leak. The leaked chunks were never touched, so this impacted\n virtual memory usage, but not physical memory usage.\n\n* linux_2008082[78]a (August 27/28, 2008)\n\n These snapshot releases are the simple result of incorporating Linux-specific\n support into the FreeBSD malloc sources.\n\n--------------------------------------------------------------------------------\nvim:filetype=text:textwidth=80\n" }, { "path": "deps/jemalloc/INSTALL.md", "content": "Building and installing a packaged release of jemalloc can be as simple as\ntyping the following while in the root directory of the source tree:\n\n ./configure\n make\n make install\n\nIf building from unpackaged developer sources, the simplest command sequence\nthat might work is:\n\n ./autogen.sh\n make\n make install\n\nYou can uninstall the installed build artifacts like this:\n\n make uninstall\n\nNotes:\n - \"autoconf\" needs to be installed\n - Documentation is built by the default target only when xsltproc is\navailable. Build will warn but not stop if the dependency is missing.\n\n\n## Advanced configuration\n\nThe 'configure' script supports numerous options that allow control of which\nfunctionality is enabled, where jemalloc is installed, etc. Optionally, pass\nany of the following arguments (not a definitive list) to 'configure':\n\n* `--help`\n\n Print a definitive list of options.\n\n* `--prefix=`\n\n Set the base directory in which to install. For example:\n\n ./configure --prefix=/usr/local\n\n will cause files to be installed into /usr/local/include, /usr/local/lib,\n and /usr/local/man.\n\n* `--with-version=(..--g|VERSION)`\n\n The VERSION file is mandatory for successful configuration, and the\n following steps are taken to assure its presence:\n 1) If --with-version=..--g is specified,\n generate VERSION using the specified value.\n 2) If --with-version is not specified in either form and the source\n directory is inside a git repository, try to generate VERSION via 'git\n describe' invocations that pattern-match release tags.\n 3) If VERSION is missing, generate it with a bogus version:\n 0.0.0-0-g0000000000000000000000000000000000000000\n\n Note that --with-version=VERSION bypasses (1) and (2), which simplifies\n VERSION configuration when embedding a jemalloc release into another\n project's git repository.\n\n* `--with-rpath=`\n\n Embed one or more library paths, so that libjemalloc can find the libraries\n it is linked to. This works only on ELF-based systems.\n\n* `--with-mangling=`\n\n Mangle public symbols specified in which is a comma-separated list of\n name:mangled pairs.\n\n For example, to use ld's --wrap option as an alternative method for\n overriding libc's malloc implementation, specify something like:\n\n --with-mangling=malloc:__wrap_malloc,free:__wrap_free[...]\n\n Note that mangling happens prior to application of the prefix specified by\n --with-jemalloc-prefix, and mangled symbols are then ignored when applying\n the prefix.\n\n* `--with-jemalloc-prefix=`\n\n Prefix all public APIs with . For example, if is\n \"prefix_\", API changes like the following occur:\n\n malloc() --> prefix_malloc()\n malloc_conf --> prefix_malloc_conf\n /etc/malloc.conf --> /etc/prefix_malloc.conf\n MALLOC_CONF --> PREFIX_MALLOC_CONF\n\n This makes it possible to use jemalloc at the same time as the system\n allocator, or even to use multiple copies of jemalloc simultaneously.\n\n By default, the prefix is \"\", except on OS X, where it is \"je_\". On OS X,\n jemalloc overlays the default malloc zone, but makes no attempt to actually\n replace the \"malloc\", \"calloc\", etc. symbols.\n\n* `--without-export`\n\n Don't export public APIs. This can be useful when building jemalloc as a\n static library, or to avoid exporting public APIs when using the zone\n allocator on OSX.\n\n* `--with-private-namespace=`\n\n Prefix all library-private APIs with je_. For shared libraries,\n symbol visibility mechanisms prevent these symbols from being exported, but\n for static libraries, naming collisions are a real possibility. By\n default, is empty, which results in a symbol prefix of je_ .\n\n* `--with-install-suffix=`\n\n Append to the base name of all installed files, such that multiple\n versions of jemalloc can coexist in the same installation directory. For\n example, libjemalloc.so.0 becomes libjemalloc.so.0.\n\n* `--with-malloc-conf=`\n\n Embed `` as a run-time options string that is processed prior to\n the malloc_conf global variable, the /etc/malloc.conf symlink, and the\n MALLOC_CONF environment variable. For example, to change the default decay\n time to 30 seconds:\n\n --with-malloc-conf=decay_ms:30000\n\n* `--enable-debug`\n\n Enable assertions and validation code. This incurs a substantial\n performance hit, but is very useful during application development.\n\n* `--disable-stats`\n\n Disable statistics gathering functionality. See the \"opt.stats_print\"\n option documentation for usage details.\n\n* `--enable-prof`\n\n Enable heap profiling and leak detection functionality. See the \"opt.prof\"\n option documentation for usage details. When enabled, there are several\n approaches to backtracing, and the configure script chooses the first one\n in the following list that appears to function correctly:\n\n + libunwind (requires --enable-prof-libunwind)\n + libgcc (unless --disable-prof-libgcc)\n + gcc intrinsics (unless --disable-prof-gcc)\n\n* `--enable-prof-libunwind`\n\n Use the libunwind library (http://www.nongnu.org/libunwind/) for stack\n backtracing.\n\n* `--disable-prof-libgcc`\n\n Disable the use of libgcc's backtracing functionality.\n\n* `--disable-prof-gcc`\n\n Disable the use of gcc intrinsics for backtracing.\n\n* `--with-static-libunwind=`\n\n Statically link against the specified libunwind.a rather than dynamically\n linking with -lunwind.\n\n* `--disable-fill`\n\n Disable support for junk/zero filling of memory. See the \"opt.junk\" and\n \"opt.zero\" option documentation for usage details.\n\n* `--disable-zone-allocator`\n\n Disable zone allocator for Darwin. This means jemalloc won't be hooked as\n the default allocator on OSX/iOS.\n\n* `--enable-utrace`\n\n Enable utrace(2)-based allocation tracing. This feature is not broadly\n portable (FreeBSD has it, but Linux and OS X do not).\n\n* `--enable-xmalloc`\n\n Enable support for optional immediate termination due to out-of-memory\n errors, as is commonly implemented by \"xmalloc\" wrapper function for malloc.\n See the \"opt.xmalloc\" option documentation for usage details.\n\n* `--enable-lazy-lock`\n\n Enable code that wraps pthread_create() to detect when an application\n switches from single-threaded to multi-threaded mode, so that it can avoid\n mutex locking/unlocking operations while in single-threaded mode. In\n practice, this feature usually has little impact on performance unless\n thread-specific caching is disabled.\n\n* `--disable-cache-oblivious`\n\n Disable cache-oblivious large allocation alignment by default, for large\n allocation requests with no alignment constraints. If this feature is\n disabled, all large allocations are page-aligned as an implementation\n artifact, which can severely harm CPU cache utilization. However, the\n cache-oblivious layout comes at the cost of one extra page per large\n allocation, which in the most extreme case increases physical memory usage\n for the 16 KiB size class to 20 KiB.\n\n* `--disable-syscall`\n\n Disable use of syscall(2) rather than {open,read,write,close}(2). This is\n intended as a workaround for systems that place security limitations on\n syscall(2).\n\n* `--disable-cxx`\n\n Disable C++ integration. This will cause new and delete operator\n implementations to be omitted.\n\n* `--with-xslroot=`\n\n Specify where to find DocBook XSL stylesheets when building the\n documentation.\n\n* `--with-lg-page=`\n\n Specify the base 2 log of the allocator page size, which must in turn be at\n least as large as the system page size. By default the configure script\n determines the host's page size and sets the allocator page size equal to\n the system page size, so this option need not be specified unless the\n system page size may change between configuration and execution, e.g. when\n cross compiling.\n\n* `--with-lg-hugepage=`\n\n Specify the base 2 log of the system huge page size. This option is useful\n when cross compiling, or when overriding the default for systems that do\n not explicitly support huge pages.\n\n* `--with-lg-quantum=`\n\n Specify the base 2 log of the minimum allocation alignment. jemalloc needs\n to know the minimum alignment that meets the following C standard\n requirement (quoted from the April 12, 2011 draft of the C11 standard):\n\n > The pointer returned if the allocation succeeds is suitably aligned so\n that it may be assigned to a pointer to any type of object with a\n fundamental alignment requirement and then used to access such an object\n or an array of such objects in the space allocated [...]\n\n This setting is architecture-specific, and although jemalloc includes known\n safe values for the most commonly used modern architectures, there is a\n wrinkle related to GNU libc (glibc) that may impact your choice of\n . On most modern architectures, this mandates 16-byte\n alignment (=4), but the glibc developers chose not to meet this\n requirement for performance reasons. An old discussion can be found at\n . Unlike glibc,\n jemalloc does follow the C standard by default (caveat: jemalloc\n technically cheats for size classes smaller than the quantum), but the fact\n that Linux systems already work around this allocator noncompliance means\n that it is generally safe in practice to let jemalloc's minimum alignment\n follow glibc's lead. If you specify `--with-lg-quantum=3` during\n configuration, jemalloc will provide additional size classes that are not\n 16-byte-aligned (24, 40, and 56).\n\n* `--with-lg-vaddr=`\n\n Specify the number of significant virtual address bits. By default, the\n configure script attempts to detect virtual address size on those platforms\n where it knows how, and picks a default otherwise. This option may be\n useful when cross-compiling.\n\n* `--disable-initial-exec-tls`\n\n Disable the initial-exec TLS model for jemalloc's internal thread-local\n storage (on those platforms that support explicit settings). This can allow\n jemalloc to be dynamically loaded after program startup (e.g. using dlopen).\n Note that in this case, there will be two malloc implementations operating\n in the same process, which will almost certainly result in confusing runtime\n crashes if pointers leak from one implementation to the other.\n\n* `--disable-libdl`\n\n Disable the usage of libdl, namely dlsym(3) which is required by the lazy\n lock option. This can allow building static binaries.\n\nThe following environment variables (not a definitive list) impact configure's\nbehavior:\n\n* `CFLAGS=\"?\"`\n* `CXXFLAGS=\"?\"`\n\n Pass these flags to the C/C++ compiler. Any flags set by the configure\n script are prepended, which means explicitly set flags generally take\n precedence. Take care when specifying flags such as -Werror, because\n configure tests may be affected in undesirable ways.\n\n* `EXTRA_CFLAGS=\"?\"`\n* `EXTRA_CXXFLAGS=\"?\"`\n\n Append these flags to CFLAGS/CXXFLAGS, without passing them to the\n compiler(s) during configuration. This makes it possible to add flags such\n as -Werror, while allowing the configure script to determine what other\n flags are appropriate for the specified configuration.\n\n* `CPPFLAGS=\"?\"`\n\n Pass these flags to the C preprocessor. Note that CFLAGS is not passed to\n 'cpp' when 'configure' is looking for include files, so you must use\n CPPFLAGS instead if you need to help 'configure' find header files.\n\n* `LD_LIBRARY_PATH=\"?\"`\n\n 'ld' uses this colon-separated list to find libraries.\n\n* `LDFLAGS=\"?\"`\n\n Pass these flags when linking.\n\n* `PATH=\"?\"`\n\n 'configure' uses this to find programs.\n\nIn some cases it may be necessary to work around configuration results that do\nnot match reality. For example, Linux 4.5 added support for the MADV_FREE flag\nto madvise(2), which can cause problems if building on a host with MADV_FREE\nsupport and deploying to a target without. To work around this, use a cache\nfile to override the relevant configuration variable defined in configure.ac,\ne.g.:\n\n echo \"je_cv_madv_free=no\" > config.cache && ./configure -C\n\n\n## Advanced compilation\n\nTo build only parts of jemalloc, use the following targets:\n\n build_lib_shared\n build_lib_static\n build_lib\n build_doc_html\n build_doc_man\n build_doc\n\nTo install only parts of jemalloc, use the following targets:\n\n install_bin\n install_include\n install_lib_shared\n install_lib_static\n install_lib_pc\n install_lib\n install_doc_html\n install_doc_man\n install_doc\n\nTo clean up build results to varying degrees, use the following make targets:\n\n clean\n distclean\n relclean\n\n\n## Advanced installation\n\nOptionally, define make variables when invoking make, including (not\nexclusively):\n\n* `INCLUDEDIR=\"?\"`\n\n Use this as the installation prefix for header files.\n\n* `LIBDIR=\"?\"`\n\n Use this as the installation prefix for libraries.\n\n* `MANDIR=\"?\"`\n\n Use this as the installation prefix for man pages.\n\n* `DESTDIR=\"?\"`\n\n Prepend DESTDIR to INCLUDEDIR, LIBDIR, DATADIR, and MANDIR. This is useful\n when installing to a different path than was specified via --prefix.\n\n* `CC=\"?\"`\n\n Use this to invoke the C compiler.\n\n* `CFLAGS=\"?\"`\n\n Pass these flags to the compiler.\n\n* `CPPFLAGS=\"?\"`\n\n Pass these flags to the C preprocessor.\n\n* `LDFLAGS=\"?\"`\n\n Pass these flags when linking.\n\n* `PATH=\"?\"`\n\n Use this to search for programs used during configuration and building.\n\n\n## Development\n\nIf you intend to make non-trivial changes to jemalloc, use the 'autogen.sh'\nscript rather than 'configure'. This re-generates 'configure', enables\nconfiguration dependency rules, and enables re-generation of automatically\ngenerated source files.\n\nThe build system supports using an object directory separate from the source\ntree. For example, you can create an 'obj' directory, and from within that\ndirectory, issue configuration and build commands:\n\n autoconf\n mkdir obj\n cd obj\n ../configure --enable-autogen\n make\n\n\n## Documentation\n\nThe manual page is generated in both html and roff formats. Any web browser\ncan be used to view the html manual. The roff manual page can be formatted\nprior to installation via the following command:\n\n nroff -man -t doc/jemalloc.3\n" }, { "path": "deps/jemalloc/Makefile.in", "content": "# Clear out all vpaths, then set just one (default vpath) for the main build\n# directory.\nvpath\nvpath % .\n\n# Clear the default suffixes, so that built-in rules are not used.\n.SUFFIXES :\n\nSHELL := /bin/sh\n\nCC := @CC@\nCXX := @CXX@\n\n# Configuration parameters.\nDESTDIR =\nBINDIR := $(DESTDIR)@BINDIR@\nINCLUDEDIR := $(DESTDIR)@INCLUDEDIR@\nLIBDIR := $(DESTDIR)@LIBDIR@\nDATADIR := $(DESTDIR)@DATADIR@\nMANDIR := $(DESTDIR)@MANDIR@\nsrcroot := @srcroot@\nobjroot := @objroot@\nabs_srcroot := @abs_srcroot@\nabs_objroot := @abs_objroot@\n\n# Build parameters.\nCPPFLAGS := @CPPFLAGS@ -I$(objroot)include -I$(srcroot)include\nCONFIGURE_CFLAGS := @CONFIGURE_CFLAGS@\nSPECIFIED_CFLAGS := @SPECIFIED_CFLAGS@\nEXTRA_CFLAGS := @EXTRA_CFLAGS@\nCFLAGS := $(strip $(CONFIGURE_CFLAGS) $(SPECIFIED_CFLAGS) $(EXTRA_CFLAGS))\nCONFIGURE_CXXFLAGS := @CONFIGURE_CXXFLAGS@\nSPECIFIED_CXXFLAGS := @SPECIFIED_CXXFLAGS@\nEXTRA_CXXFLAGS := @EXTRA_CXXFLAGS@\nCXXFLAGS := $(strip $(CONFIGURE_CXXFLAGS) $(SPECIFIED_CXXFLAGS) $(EXTRA_CXXFLAGS))\nLDFLAGS := @LDFLAGS@\nEXTRA_LDFLAGS := @EXTRA_LDFLAGS@\nLIBS := @LIBS@\nRPATH_EXTRA := @RPATH_EXTRA@\nSO := @so@\nIMPORTLIB := @importlib@\nO := @o@\nA := @a@\nEXE := @exe@\nLIBPREFIX := @libprefix@\nREV := @rev@\ninstall_suffix := @install_suffix@\nABI := @abi@\nXSLTPROC := @XSLTPROC@\nXSLROOT := @XSLROOT@\nAUTOCONF := @AUTOCONF@\n_RPATH = @RPATH@\nRPATH = $(if $(1),$(call _RPATH,$(1)))\ncfghdrs_in := $(addprefix $(srcroot),@cfghdrs_in@)\ncfghdrs_out := @cfghdrs_out@\ncfgoutputs_in := $(addprefix $(srcroot),@cfgoutputs_in@)\ncfgoutputs_out := @cfgoutputs_out@\nenable_autogen := @enable_autogen@\nenable_doc := @enable_doc@\nenable_shared := @enable_shared@\nenable_static := @enable_static@\nenable_prof := @enable_prof@\nenable_zone_allocator := @enable_zone_allocator@\nenable_experimental_smallocx := @enable_experimental_smallocx@\nMALLOC_CONF := @JEMALLOC_CPREFIX@MALLOC_CONF\nlink_whole_archive := @link_whole_archive@\nDSO_LDFLAGS = @DSO_LDFLAGS@\nSOREV = @SOREV@\nPIC_CFLAGS = @PIC_CFLAGS@\nCTARGET = @CTARGET@\nLDTARGET = @LDTARGET@\nTEST_LD_MODE = @TEST_LD_MODE@\nMKLIB = @MKLIB@\nAR = @AR@\nARFLAGS = @ARFLAGS@\nDUMP_SYMS = @DUMP_SYMS@\nAWK := @AWK@\nCC_MM = @CC_MM@\nLM := @LM@\nINSTALL = @INSTALL@\n\nifeq (macho, $(ABI))\nTEST_LIBRARY_PATH := DYLD_FALLBACK_LIBRARY_PATH=\"$(objroot)lib\"\nelse\nifeq (pecoff, $(ABI))\nTEST_LIBRARY_PATH := PATH=\"$(PATH):$(objroot)lib\"\nelse\nTEST_LIBRARY_PATH :=\nendif\nendif\n\nLIBJEMALLOC := $(LIBPREFIX)jemalloc$(install_suffix)\n\n# Lists of files.\nBINS := $(objroot)bin/jemalloc-config $(objroot)bin/jemalloc.sh $(objroot)bin/jeprof\nC_HDRS := $(objroot)include/jemalloc/jemalloc$(install_suffix).h\nC_SRCS := $(srcroot)src/jemalloc.c \\\n\t$(srcroot)src/arena.c \\\n\t$(srcroot)src/background_thread.c \\\n\t$(srcroot)src/base.c \\\n\t$(srcroot)src/bin.c \\\n\t$(srcroot)src/bin_info.c \\\n\t$(srcroot)src/bitmap.c \\\n\t$(srcroot)src/buf_writer.c \\\n\t$(srcroot)src/cache_bin.c \\\n\t$(srcroot)src/ckh.c \\\n\t$(srcroot)src/counter.c \\\n\t$(srcroot)src/ctl.c \\\n\t$(srcroot)src/decay.c \\\n\t$(srcroot)src/div.c \\\n\t$(srcroot)src/ecache.c \\\n\t$(srcroot)src/edata.c \\\n\t$(srcroot)src/edata_cache.c \\\n\t$(srcroot)src/ehooks.c \\\n\t$(srcroot)src/emap.c \\\n\t$(srcroot)src/eset.c \\\n\t$(srcroot)src/exp_grow.c \\\n\t$(srcroot)src/extent.c \\\n\t$(srcroot)src/extent_dss.c \\\n\t$(srcroot)src/extent_mmap.c \\\n\t$(srcroot)src/fxp.c \\\n\t$(srcroot)src/san.c \\\n\t$(srcroot)src/san_bump.c \\\n\t$(srcroot)src/hook.c \\\n\t$(srcroot)src/hpa.c \\\n\t$(srcroot)src/hpa_hooks.c \\\n\t$(srcroot)src/hpdata.c \\\n\t$(srcroot)src/inspect.c \\\n\t$(srcroot)src/large.c \\\n\t$(srcroot)src/log.c \\\n\t$(srcroot)src/malloc_io.c \\\n\t$(srcroot)src/mutex.c \\\n\t$(srcroot)src/nstime.c \\\n\t$(srcroot)src/pa.c \\\n\t$(srcroot)src/pa_extra.c \\\n\t$(srcroot)src/pai.c \\\n\t$(srcroot)src/pac.c \\\n\t$(srcroot)src/pages.c \\\n\t$(srcroot)src/peak_event.c \\\n\t$(srcroot)src/prof.c \\\n\t$(srcroot)src/prof_data.c \\\n\t$(srcroot)src/prof_log.c \\\n\t$(srcroot)src/prof_recent.c \\\n\t$(srcroot)src/prof_stats.c \\\n\t$(srcroot)src/prof_sys.c \\\n\t$(srcroot)src/psset.c \\\n\t$(srcroot)src/rtree.c \\\n\t$(srcroot)src/safety_check.c \\\n\t$(srcroot)src/sc.c \\\n\t$(srcroot)src/sec.c \\\n\t$(srcroot)src/stats.c \\\n\t$(srcroot)src/sz.c \\\n\t$(srcroot)src/tcache.c \\\n\t$(srcroot)src/test_hooks.c \\\n\t$(srcroot)src/thread_event.c \\\n\t$(srcroot)src/ticker.c \\\n\t$(srcroot)src/tsd.c \\\n\t$(srcroot)src/witness.c\nifeq ($(enable_zone_allocator), 1)\nC_SRCS += $(srcroot)src/zone.c\nendif\nifeq ($(IMPORTLIB),$(SO))\nSTATIC_LIBS := $(objroot)lib/$(LIBJEMALLOC).$(A)\nendif\nifdef PIC_CFLAGS\nSTATIC_LIBS += $(objroot)lib/$(LIBJEMALLOC)_pic.$(A)\nelse\nSTATIC_LIBS += $(objroot)lib/$(LIBJEMALLOC)_s.$(A)\nendif\nDSOS := $(objroot)lib/$(LIBJEMALLOC).$(SOREV)\nifneq ($(SOREV),$(SO))\nDSOS += $(objroot)lib/$(LIBJEMALLOC).$(SO)\nendif\nifeq (1, $(link_whole_archive))\nLJEMALLOC := -Wl,--whole-archive -L$(objroot)lib -l$(LIBJEMALLOC) -Wl,--no-whole-archive\nelse\nLJEMALLOC := $(objroot)lib/$(LIBJEMALLOC).$(IMPORTLIB)\nendif\nPC := $(objroot)jemalloc.pc\nDOCS_XML := $(objroot)doc/jemalloc$(install_suffix).xml\nDOCS_HTML := $(DOCS_XML:$(objroot)%.xml=$(objroot)%.html)\nDOCS_MAN3 := $(DOCS_XML:$(objroot)%.xml=$(objroot)%.3)\nDOCS := $(DOCS_HTML) $(DOCS_MAN3)\nC_TESTLIB_SRCS := $(srcroot)test/src/btalloc.c $(srcroot)test/src/btalloc_0.c \\\n\t$(srcroot)test/src/btalloc_1.c $(srcroot)test/src/math.c \\\n\t$(srcroot)test/src/mtx.c $(srcroot)test/src/sleep.c \\\n\t$(srcroot)test/src/SFMT.c $(srcroot)test/src/test.c \\\n\t$(srcroot)test/src/thd.c $(srcroot)test/src/timer.c\nifeq (1, $(link_whole_archive))\nC_UTIL_INTEGRATION_SRCS :=\nC_UTIL_CPP_SRCS :=\nelse\nC_UTIL_INTEGRATION_SRCS := $(srcroot)src/nstime.c $(srcroot)src/malloc_io.c \\\n\t$(srcroot)src/ticker.c\nC_UTIL_CPP_SRCS := $(srcroot)src/nstime.c $(srcroot)src/malloc_io.c\nendif\nTESTS_UNIT := \\\n\t$(srcroot)test/unit/a0.c \\\n\t$(srcroot)test/unit/arena_decay.c \\\n\t$(srcroot)test/unit/arena_reset.c \\\n\t$(srcroot)test/unit/atomic.c \\\n\t$(srcroot)test/unit/background_thread.c \\\n\t$(srcroot)test/unit/background_thread_enable.c \\\n\t$(srcroot)test/unit/base.c \\\n\t$(srcroot)test/unit/batch_alloc.c \\\n\t$(srcroot)test/unit/binshard.c \\\n\t$(srcroot)test/unit/bitmap.c \\\n\t$(srcroot)test/unit/bit_util.c \\\n\t$(srcroot)test/unit/buf_writer.c \\\n\t$(srcroot)test/unit/cache_bin.c \\\n\t$(srcroot)test/unit/ckh.c \\\n\t$(srcroot)test/unit/counter.c \\\n\t$(srcroot)test/unit/decay.c \\\n\t$(srcroot)test/unit/div.c \\\n\t$(srcroot)test/unit/double_free.c \\\n\t$(srcroot)test/unit/edata_cache.c \\\n\t$(srcroot)test/unit/emitter.c \\\n\t$(srcroot)test/unit/extent_quantize.c \\\n\t${srcroot}test/unit/fb.c \\\n\t$(srcroot)test/unit/fork.c \\\n\t${srcroot}test/unit/fxp.c \\\n\t${srcroot}test/unit/san.c \\\n\t${srcroot}test/unit/san_bump.c \\\n\t$(srcroot)test/unit/hash.c \\\n\t$(srcroot)test/unit/hook.c \\\n\t$(srcroot)test/unit/hpa.c \\\n\t$(srcroot)test/unit/hpa_background_thread.c \\\n\t$(srcroot)test/unit/hpdata.c \\\n\t$(srcroot)test/unit/huge.c \\\n\t$(srcroot)test/unit/inspect.c \\\n\t$(srcroot)test/unit/junk.c \\\n\t$(srcroot)test/unit/junk_alloc.c \\\n\t$(srcroot)test/unit/junk_free.c \\\n\t$(srcroot)test/unit/log.c \\\n\t$(srcroot)test/unit/mallctl.c \\\n\t$(srcroot)test/unit/malloc_conf_2.c \\\n\t$(srcroot)test/unit/malloc_io.c \\\n\t$(srcroot)test/unit/math.c \\\n\t$(srcroot)test/unit/mpsc_queue.c \\\n\t$(srcroot)test/unit/mq.c \\\n\t$(srcroot)test/unit/mtx.c \\\n\t$(srcroot)test/unit/nstime.c \\\n\t$(srcroot)test/unit/oversize_threshold.c \\\n\t$(srcroot)test/unit/pa.c \\\n\t$(srcroot)test/unit/pack.c \\\n\t$(srcroot)test/unit/pages.c \\\n\t$(srcroot)test/unit/peak.c \\\n\t$(srcroot)test/unit/ph.c \\\n\t$(srcroot)test/unit/prng.c \\\n\t$(srcroot)test/unit/prof_accum.c \\\n\t$(srcroot)test/unit/prof_active.c \\\n\t$(srcroot)test/unit/prof_gdump.c \\\n\t$(srcroot)test/unit/prof_hook.c \\\n\t$(srcroot)test/unit/prof_idump.c \\\n\t$(srcroot)test/unit/prof_log.c \\\n\t$(srcroot)test/unit/prof_mdump.c \\\n\t$(srcroot)test/unit/prof_recent.c \\\n\t$(srcroot)test/unit/prof_reset.c \\\n\t$(srcroot)test/unit/prof_stats.c \\\n\t$(srcroot)test/unit/prof_tctx.c \\\n\t$(srcroot)test/unit/prof_thread_name.c \\\n\t$(srcroot)test/unit/prof_sys_thread_name.c \\\n\t$(srcroot)test/unit/psset.c \\\n\t$(srcroot)test/unit/ql.c \\\n\t$(srcroot)test/unit/qr.c \\\n\t$(srcroot)test/unit/rb.c \\\n\t$(srcroot)test/unit/retained.c \\\n\t$(srcroot)test/unit/rtree.c \\\n\t$(srcroot)test/unit/safety_check.c \\\n\t$(srcroot)test/unit/sc.c \\\n\t$(srcroot)test/unit/sec.c \\\n\t$(srcroot)test/unit/seq.c \\\n\t$(srcroot)test/unit/SFMT.c \\\n\t$(srcroot)test/unit/size_check.c \\\n\t$(srcroot)test/unit/size_classes.c \\\n\t$(srcroot)test/unit/slab.c \\\n\t$(srcroot)test/unit/smoothstep.c \\\n\t$(srcroot)test/unit/spin.c \\\n\t$(srcroot)test/unit/stats.c \\\n\t$(srcroot)test/unit/stats_print.c \\\n\t$(srcroot)test/unit/sz.c \\\n\t$(srcroot)test/unit/tcache_max.c \\\n\t$(srcroot)test/unit/test_hooks.c \\\n\t$(srcroot)test/unit/thread_event.c \\\n\t$(srcroot)test/unit/ticker.c \\\n\t$(srcroot)test/unit/tsd.c \\\n\t$(srcroot)test/unit/uaf.c \\\n\t$(srcroot)test/unit/witness.c \\\n\t$(srcroot)test/unit/zero.c \\\n\t$(srcroot)test/unit/zero_realloc_abort.c \\\n\t$(srcroot)test/unit/zero_realloc_free.c \\\n\t$(srcroot)test/unit/zero_realloc_alloc.c \\\n\t$(srcroot)test/unit/zero_reallocs.c\nifeq (@enable_prof@, 1)\nTESTS_UNIT += \\\n\t$(srcroot)test/unit/arena_reset_prof.c \\\n\t$(srcroot)test/unit/batch_alloc_prof.c\nendif\nTESTS_INTEGRATION := $(srcroot)test/integration/aligned_alloc.c \\\n\t$(srcroot)test/integration/allocated.c \\\n\t$(srcroot)test/integration/extent.c \\\n\t$(srcroot)test/integration/malloc.c \\\n\t$(srcroot)test/integration/mallocx.c \\\n\t$(srcroot)test/integration/MALLOCX_ARENA.c \\\n\t$(srcroot)test/integration/overflow.c \\\n\t$(srcroot)test/integration/posix_memalign.c \\\n\t$(srcroot)test/integration/rallocx.c \\\n\t$(srcroot)test/integration/sdallocx.c \\\n\t$(srcroot)test/integration/slab_sizes.c \\\n\t$(srcroot)test/integration/thread_arena.c \\\n\t$(srcroot)test/integration/thread_tcache_enabled.c \\\n\t$(srcroot)test/integration/xallocx.c\nifeq (@enable_experimental_smallocx@, 1)\nTESTS_INTEGRATION += \\\n $(srcroot)test/integration/smallocx.c\nendif\nifeq (@enable_cxx@, 1)\nCPP_SRCS := $(srcroot)src/jemalloc_cpp.cpp\nTESTS_INTEGRATION_CPP := $(srcroot)test/integration/cpp/basic.cpp \\\n\t$(srcroot)test/integration/cpp/infallible_new_true.cpp \\\n\t$(srcroot)test/integration/cpp/infallible_new_false.cpp\nelse\nCPP_SRCS :=\nTESTS_INTEGRATION_CPP :=\nendif\nTESTS_ANALYZE := $(srcroot)test/analyze/prof_bias.c \\\n\t$(srcroot)test/analyze/rand.c \\\n\t$(srcroot)test/analyze/sizes.c\nTESTS_STRESS := $(srcroot)test/stress/batch_alloc.c \\\n\t$(srcroot)test/stress/fill_flush.c \\\n\t$(srcroot)test/stress/hookbench.c \\\n\t$(srcroot)test/stress/large_microbench.c \\\n\t$(srcroot)test/stress/mallctl.c \\\n\t$(srcroot)test/stress/microbench.c\n\n\nTESTS := $(TESTS_UNIT) $(TESTS_INTEGRATION) $(TESTS_INTEGRATION_CPP) \\\n\t$(TESTS_ANALYZE) $(TESTS_STRESS)\n\nPRIVATE_NAMESPACE_HDRS := $(objroot)include/jemalloc/internal/private_namespace.h $(objroot)include/jemalloc/internal/private_namespace_jet.h\nPRIVATE_NAMESPACE_GEN_HDRS := $(PRIVATE_NAMESPACE_HDRS:%.h=%.gen.h)\nC_SYM_OBJS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.sym.$(O))\nC_SYMS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.sym)\nC_OBJS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.$(O))\nCPP_OBJS := $(CPP_SRCS:$(srcroot)%.cpp=$(objroot)%.$(O))\nC_PIC_OBJS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.pic.$(O))\nCPP_PIC_OBJS := $(CPP_SRCS:$(srcroot)%.cpp=$(objroot)%.pic.$(O))\nC_JET_SYM_OBJS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.jet.sym.$(O))\nC_JET_SYMS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.jet.sym)\nC_JET_OBJS := $(C_SRCS:$(srcroot)%.c=$(objroot)%.jet.$(O))\nC_TESTLIB_UNIT_OBJS := $(C_TESTLIB_SRCS:$(srcroot)%.c=$(objroot)%.unit.$(O))\nC_TESTLIB_INTEGRATION_OBJS := $(C_TESTLIB_SRCS:$(srcroot)%.c=$(objroot)%.integration.$(O))\nC_UTIL_INTEGRATION_OBJS := $(C_UTIL_INTEGRATION_SRCS:$(srcroot)%.c=$(objroot)%.integration.$(O))\nC_TESTLIB_ANALYZE_OBJS := $(C_TESTLIB_SRCS:$(srcroot)%.c=$(objroot)%.analyze.$(O))\nC_TESTLIB_STRESS_OBJS := $(C_TESTLIB_SRCS:$(srcroot)%.c=$(objroot)%.stress.$(O))\nC_TESTLIB_OBJS := $(C_TESTLIB_UNIT_OBJS) $(C_TESTLIB_INTEGRATION_OBJS) \\\n\t$(C_UTIL_INTEGRATION_OBJS) $(C_TESTLIB_ANALYZE_OBJS) \\\n\t$(C_TESTLIB_STRESS_OBJS)\n\nTESTS_UNIT_OBJS := $(TESTS_UNIT:$(srcroot)%.c=$(objroot)%.$(O))\nTESTS_INTEGRATION_OBJS := $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%.$(O))\nTESTS_INTEGRATION_CPP_OBJS := $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%.$(O))\nTESTS_ANALYZE_OBJS := $(TESTS_ANALYZE:$(srcroot)%.c=$(objroot)%.$(O))\nTESTS_STRESS_OBJS := $(TESTS_STRESS:$(srcroot)%.c=$(objroot)%.$(O))\nTESTS_OBJS := $(TESTS_UNIT_OBJS) $(TESTS_INTEGRATION_OBJS) $(TESTS_ANALYZE_OBJS) \\\n\t$(TESTS_STRESS_OBJS)\nTESTS_CPP_OBJS := $(TESTS_INTEGRATION_CPP_OBJS)\n\n.PHONY: all dist build_doc_html build_doc_man build_doc\n.PHONY: install_bin install_include install_lib\n.PHONY: install_doc_html install_doc_man install_doc install\n.PHONY: tests check clean distclean relclean\n\n.SECONDARY : $(PRIVATE_NAMESPACE_GEN_HDRS) $(TESTS_OBJS) $(TESTS_CPP_OBJS)\n\n# Default target.\nall: build_lib\n\ndist: build_doc\n\n$(objroot)doc/%$(install_suffix).html : $(objroot)doc/%.xml $(srcroot)doc/stylesheet.xsl $(objroot)doc/html.xsl\nifneq ($(XSLROOT),)\n\t$(XSLTPROC) -o $@ $(objroot)doc/html.xsl $<\nelse\nifeq ($(wildcard $(DOCS_HTML)),)\n\t@echo \"

Missing xsltproc. Doc not built.

\" > $@\nendif\n\t@echo \"Missing xsltproc. \"$@\" not (re)built.\"\nendif\n\n$(objroot)doc/%$(install_suffix).3 : $(objroot)doc/%.xml $(srcroot)doc/stylesheet.xsl $(objroot)doc/manpages.xsl\nifneq ($(XSLROOT),)\n\t$(XSLTPROC) -o $@ $(objroot)doc/manpages.xsl $<\n# The -o option (output filename) of xsltproc may not work (it uses the\n# in the .xml file). Manually add the suffix if so.\n ifneq ($(install_suffix),)\n\t@if [ -f $(objroot)doc/jemalloc.3 ]; then \\\n\t\tmv $(objroot)doc/jemalloc.3 $(objroot)doc/jemalloc$(install_suffix).3 ; \\\n\tfi\n endif\nelse\nifeq ($(wildcard $(DOCS_MAN3)),)\n\t@echo \"Missing xsltproc. Doc not built.\" > $@\nendif\n\t@echo \"Missing xsltproc. \"$@\" not (re)built.\"\nendif\n\nbuild_doc_html: $(DOCS_HTML)\nbuild_doc_man: $(DOCS_MAN3)\nbuild_doc: $(DOCS)\n\n#\n# Include generated dependency files.\n#\nifdef CC_MM\n-include $(C_SYM_OBJS:%.$(O)=%.d)\n-include $(C_OBJS:%.$(O)=%.d)\n-include $(CPP_OBJS:%.$(O)=%.d)\n-include $(C_PIC_OBJS:%.$(O)=%.d)\n-include $(CPP_PIC_OBJS:%.$(O)=%.d)\n-include $(C_JET_SYM_OBJS:%.$(O)=%.d)\n-include $(C_JET_OBJS:%.$(O)=%.d)\n-include $(C_TESTLIB_OBJS:%.$(O)=%.d)\n-include $(TESTS_OBJS:%.$(O)=%.d)\n-include $(TESTS_CPP_OBJS:%.$(O)=%.d)\nendif\n\n$(C_SYM_OBJS): $(objroot)src/%.sym.$(O): $(srcroot)src/%.c\n$(C_SYM_OBJS): CPPFLAGS += -DJEMALLOC_NO_PRIVATE_NAMESPACE\n$(C_SYMS): $(objroot)src/%.sym: $(objroot)src/%.sym.$(O)\n$(C_OBJS): $(objroot)src/%.$(O): $(srcroot)src/%.c\n$(CPP_OBJS): $(objroot)src/%.$(O): $(srcroot)src/%.cpp\n$(C_PIC_OBJS): $(objroot)src/%.pic.$(O): $(srcroot)src/%.c\n$(C_PIC_OBJS): CFLAGS += $(PIC_CFLAGS)\n$(CPP_PIC_OBJS): $(objroot)src/%.pic.$(O): $(srcroot)src/%.cpp\n$(CPP_PIC_OBJS): CXXFLAGS += $(PIC_CFLAGS)\n$(C_JET_SYM_OBJS): $(objroot)src/%.jet.sym.$(O): $(srcroot)src/%.c\n$(C_JET_SYM_OBJS): CPPFLAGS += -DJEMALLOC_JET -DJEMALLOC_NO_PRIVATE_NAMESPACE\n$(C_JET_SYMS): $(objroot)src/%.jet.sym: $(objroot)src/%.jet.sym.$(O)\n$(C_JET_OBJS): $(objroot)src/%.jet.$(O): $(srcroot)src/%.c\n$(C_JET_OBJS): CPPFLAGS += -DJEMALLOC_JET\n$(C_TESTLIB_UNIT_OBJS): $(objroot)test/src/%.unit.$(O): $(srcroot)test/src/%.c\n$(C_TESTLIB_UNIT_OBJS): CPPFLAGS += -DJEMALLOC_UNIT_TEST\n$(C_TESTLIB_INTEGRATION_OBJS): $(objroot)test/src/%.integration.$(O): $(srcroot)test/src/%.c\n$(C_TESTLIB_INTEGRATION_OBJS): CPPFLAGS += -DJEMALLOC_INTEGRATION_TEST\n$(C_UTIL_INTEGRATION_OBJS): $(objroot)src/%.integration.$(O): $(srcroot)src/%.c\n$(C_TESTLIB_ANALYZE_OBJS): $(objroot)test/src/%.analyze.$(O): $(srcroot)test/src/%.c\n$(C_TESTLIB_ANALYZE_OBJS): CPPFLAGS += -DJEMALLOC_ANALYZE_TEST\n$(C_TESTLIB_STRESS_OBJS): $(objroot)test/src/%.stress.$(O): $(srcroot)test/src/%.c\n$(C_TESTLIB_STRESS_OBJS): CPPFLAGS += -DJEMALLOC_STRESS_TEST -DJEMALLOC_STRESS_TESTLIB\n$(C_TESTLIB_OBJS): CPPFLAGS += -I$(srcroot)test/include -I$(objroot)test/include\n$(TESTS_UNIT_OBJS): CPPFLAGS += -DJEMALLOC_UNIT_TEST\n$(TESTS_INTEGRATION_OBJS): CPPFLAGS += -DJEMALLOC_INTEGRATION_TEST\n$(TESTS_INTEGRATION_CPP_OBJS): CPPFLAGS += -DJEMALLOC_INTEGRATION_CPP_TEST\n$(TESTS_ANALYZE_OBJS): CPPFLAGS += -DJEMALLOC_ANALYZE_TEST\n$(TESTS_STRESS_OBJS): CPPFLAGS += -DJEMALLOC_STRESS_TEST\n$(TESTS_OBJS): $(objroot)test/%.$(O): $(srcroot)test/%.c\n$(TESTS_CPP_OBJS): $(objroot)test/%.$(O): $(srcroot)test/%.cpp\n$(TESTS_OBJS): CPPFLAGS += -I$(srcroot)test/include -I$(objroot)test/include\n$(TESTS_CPP_OBJS): CPPFLAGS += -I$(srcroot)test/include -I$(objroot)test/include\nifneq ($(IMPORTLIB),$(SO))\n$(CPP_OBJS) $(C_SYM_OBJS) $(C_OBJS) $(C_JET_SYM_OBJS) $(C_JET_OBJS): CPPFLAGS += -DDLLEXPORT\nendif\n\n# Dependencies.\nifndef CC_MM\nHEADER_DIRS = $(srcroot)include/jemalloc/internal \\\n\t$(objroot)include/jemalloc $(objroot)include/jemalloc/internal\nHEADERS = $(filter-out $(PRIVATE_NAMESPACE_HDRS),$(wildcard $(foreach dir,$(HEADER_DIRS),$(dir)/*.h)))\n$(C_SYM_OBJS) $(C_OBJS) $(CPP_OBJS) $(C_PIC_OBJS) $(CPP_PIC_OBJS) $(C_JET_SYM_OBJS) $(C_JET_OBJS) $(C_TESTLIB_OBJS) $(TESTS_OBJS) $(TESTS_CPP_OBJS): $(HEADERS)\n$(TESTS_OBJS) $(TESTS_CPP_OBJS): $(objroot)test/include/test/jemalloc_test.h\nendif\n\n$(C_OBJS) $(CPP_OBJS) $(C_PIC_OBJS) $(CPP_PIC_OBJS) $(C_TESTLIB_INTEGRATION_OBJS) $(C_UTIL_INTEGRATION_OBJS) $(TESTS_INTEGRATION_OBJS) $(TESTS_INTEGRATION_CPP_OBJS): $(objroot)include/jemalloc/internal/private_namespace.h\n$(C_JET_OBJS) $(C_TESTLIB_UNIT_OBJS) $(C_TESTLIB_ANALYZE_OBJS) $(C_TESTLIB_STRESS_OBJS) $(TESTS_UNIT_OBJS) $(TESTS_ANALYZE_OBJS) $(TESTS_STRESS_OBJS): $(objroot)include/jemalloc/internal/private_namespace_jet.h\n\n$(C_SYM_OBJS) $(C_OBJS) $(C_PIC_OBJS) $(C_JET_SYM_OBJS) $(C_JET_OBJS) $(C_TESTLIB_OBJS) $(TESTS_OBJS): %.$(O):\n\t@mkdir -p $(@D)\n\t$(CC) $(CFLAGS) -c $(CPPFLAGS) $(CTARGET) $<\nifdef CC_MM\n\t@$(CC) -MM $(CPPFLAGS) -MT $@ -o $(@:%.$(O)=%.d) $<\nendif\n\n$(C_SYMS): %.sym:\n\t@mkdir -p $(@D)\n\t$(DUMP_SYMS) $< | $(AWK) -f $(objroot)include/jemalloc/internal/private_symbols.awk > $@\n\n$(C_JET_SYMS): %.sym:\n\t@mkdir -p $(@D)\n\t$(DUMP_SYMS) $< | $(AWK) -f $(objroot)include/jemalloc/internal/private_symbols_jet.awk > $@\n\n$(objroot)include/jemalloc/internal/private_namespace.gen.h: $(C_SYMS)\n\t$(SHELL) $(srcroot)include/jemalloc/internal/private_namespace.sh $^ > $@\n\n$(objroot)include/jemalloc/internal/private_namespace_jet.gen.h: $(C_JET_SYMS)\n\t$(SHELL) $(srcroot)include/jemalloc/internal/private_namespace.sh $^ > $@\n\n%.h: %.gen.h\n\t@if ! `cmp -s $< $@` ; then echo \"cp $< $@\"; cp $< $@ ; fi\n\n$(CPP_OBJS) $(CPP_PIC_OBJS) $(TESTS_CPP_OBJS): %.$(O):\n\t@mkdir -p $(@D)\n\t$(CXX) $(CXXFLAGS) -c $(CPPFLAGS) $(CTARGET) $<\nifdef CC_MM\n\t@$(CXX) -MM $(CPPFLAGS) -MT $@ -o $(@:%.$(O)=%.d) $<\nendif\n\nifneq ($(SOREV),$(SO))\n%.$(SO) : %.$(SOREV)\n\t@mkdir -p $(@D)\n\tln -sf $( $(srcroot)config.stamp.in\n\n$(objroot)config.stamp : $(cfgoutputs_in) $(cfghdrs_in) $(srcroot)configure\n\t./$(objroot)config.status\n\t@touch $@\n\n# There must be some action in order for make to re-read Makefile when it is\n# out of date.\n$(cfgoutputs_out) $(cfghdrs_out) : $(objroot)config.stamp\n\t@true\nendif\n" }, { "path": "deps/jemalloc/README", "content": "jemalloc is a general purpose malloc(3) implementation that emphasizes\nfragmentation avoidance and scalable concurrency support. jemalloc first came\ninto use as the FreeBSD libc allocator in 2005, and since then it has found its\nway into numerous applications that rely on its predictable behavior. In 2010\njemalloc development efforts broadened to include developer support features\nsuch as heap profiling and extensive monitoring/tuning hooks. Modern jemalloc\nreleases continue to be integrated back into FreeBSD, and therefore versatility\nremains critical. Ongoing development efforts trend toward making jemalloc\namong the best allocators for a broad range of demanding applications, and\neliminating/mitigating weaknesses that have practical repercussions for real\nworld applications.\n\nThe COPYING file contains copyright and licensing information.\n\nThe INSTALL file contains information on how to configure, build, and install\njemalloc.\n\nThe ChangeLog file contains a brief summary of changes for each release.\n\nURL: http://jemalloc.net/\n" }, { "path": "deps/jemalloc/TUNING.md", "content": "This document summarizes the common approaches for performance fine tuning with\njemalloc (as of 5.3.0). The default configuration of jemalloc tends to work\nreasonably well in practice, and most applications should not have to tune any\noptions. However, in order to cover a wide range of applications and avoid\npathological cases, the default setting is sometimes kept conservative and\nsuboptimal, even for many common workloads. When jemalloc is properly tuned for\na specific application / workload, it is common to improve system level metrics\nby a few percent, or make favorable trade-offs.\n\n\n## Notable runtime options for performance tuning\n\nRuntime options can be set via\n[malloc_conf](http://jemalloc.net/jemalloc.3.html#tuning).\n\n* [background_thread](http://jemalloc.net/jemalloc.3.html#background_thread)\n\n Enabling jemalloc background threads generally improves the tail latency for\n application threads, since unused memory purging is shifted to the dedicated\n background threads. In addition, unintended purging delay caused by\n application inactivity is avoided with background threads.\n\n Suggested: `background_thread:true` when jemalloc managed threads can be\n allowed.\n\n* [metadata_thp](http://jemalloc.net/jemalloc.3.html#opt.metadata_thp)\n\n Allowing jemalloc to utilize transparent huge pages for its internal\n metadata usually reduces TLB misses significantly, especially for programs\n with large memory footprint and frequent allocation / deallocation\n activities. Metadata memory usage may increase due to the use of huge\n pages.\n\n Suggested for allocation intensive programs: `metadata_thp:auto` or\n `metadata_thp:always`, which is expected to improve CPU utilization at a\n small memory cost.\n\n* [dirty_decay_ms](http://jemalloc.net/jemalloc.3.html#opt.dirty_decay_ms) and\n [muzzy_decay_ms](http://jemalloc.net/jemalloc.3.html#opt.muzzy_decay_ms)\n\n Decay time determines how fast jemalloc returns unused pages back to the\n operating system, and therefore provides a fairly straightforward trade-off\n between CPU and memory usage. Shorter decay time purges unused pages faster\n to reduces memory usage (usually at the cost of more CPU cycles spent on\n purging), and vice versa.\n\n Suggested: tune the values based on the desired trade-offs.\n\n* [narenas](http://jemalloc.net/jemalloc.3.html#opt.narenas)\n\n By default jemalloc uses multiple arenas to reduce internal lock contention.\n However high arena count may also increase overall memory fragmentation,\n since arenas manage memory independently. When high degree of parallelism\n is not expected at the allocator level, lower number of arenas often\n improves memory usage.\n\n Suggested: if low parallelism is expected, try lower arena count while\n monitoring CPU and memory usage.\n\n* [percpu_arena](http://jemalloc.net/jemalloc.3.html#opt.percpu_arena)\n\n Enable dynamic thread to arena association based on running CPU. This has\n the potential to improve locality, e.g. when thread to CPU affinity is\n present.\n \n Suggested: try `percpu_arena:percpu` or `percpu_arena:phycpu` if\n thread migration between processors is expected to be infrequent.\n\nExamples:\n\n* High resource consumption application, prioritizing CPU utilization:\n\n `background_thread:true,metadata_thp:auto` combined with relaxed decay time\n (increased `dirty_decay_ms` and / or `muzzy_decay_ms`,\n e.g. `dirty_decay_ms:30000,muzzy_decay_ms:30000`).\n\n* High resource consumption application, prioritizing memory usage:\n\n `background_thread:true,tcache_max:4096` combined with shorter decay time\n (decreased `dirty_decay_ms` and / or `muzzy_decay_ms`,\n e.g. `dirty_decay_ms:5000,muzzy_decay_ms:5000`), and lower arena count\n (e.g. number of CPUs).\n\n* Low resource consumption application:\n\n `narenas:1,tcache_max:1024` combined with shorter decay time (decreased\n `dirty_decay_ms` and / or `muzzy_decay_ms`,e.g.\n `dirty_decay_ms:1000,muzzy_decay_ms:0`).\n\n* Extremely conservative -- minimize memory usage at all costs, only suitable when\nallocation activity is very rare:\n\n `narenas:1,tcache:false,dirty_decay_ms:0,muzzy_decay_ms:0`\n\nNote that it is recommended to combine the options with `abort_conf:true` which\naborts immediately on illegal options.\n\n## Beyond runtime options\n\nIn addition to the runtime options, there are a number of programmatic ways to\nimprove application performance with jemalloc.\n\n* [Explicit arenas](http://jemalloc.net/jemalloc.3.html#arenas.create)\n\n Manually created arenas can help performance in various ways, e.g. by\n managing locality and contention for specific usages. For example,\n applications can explicitly allocate frequently accessed objects from a\n dedicated arena with\n [mallocx()](http://jemalloc.net/jemalloc.3.html#MALLOCX_ARENA) to improve\n locality. In addition, explicit arenas often benefit from individually\n tuned options, e.g. relaxed [decay\n time](http://jemalloc.net/jemalloc.3.html#arena.i.dirty_decay_ms) if\n frequent reuse is expected.\n\n* [Extent hooks](http://jemalloc.net/jemalloc.3.html#arena.i.extent_hooks)\n\n Extent hooks allow customization for managing underlying memory. One use\n case for performance purpose is to utilize huge pages -- for example,\n [HHVM](https://github.com/facebook/hhvm/blob/master/hphp/util/alloc.cpp)\n uses explicit arenas with customized extent hooks to manage 1GB huge pages\n for frequently accessed data, which reduces TLB misses significantly.\n\n* [Explicit thread-to-arena\n binding](http://jemalloc.net/jemalloc.3.html#thread.arena)\n\n It is common for some threads in an application to have different memory\n access / allocation patterns. Threads with heavy workloads often benefit\n from explicit binding, e.g. binding very active threads to dedicated arenas\n may reduce contention at the allocator level.\n" }, { "path": "deps/jemalloc/VERSION", "content": "5.3.0-0-g0\n" }, { "path": "deps/jemalloc/autogen.sh", "content": "#!/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\ndone\n\necho \"./configure --enable-autogen $@\"\n./configure --enable-autogen $@\nif [ $? -ne 0 ]; then\n echo \"Error $? in ./configure\"\n exit 1\nfi\n" }, { "path": "deps/jemalloc/bin/jemalloc-config.in", "content": "#!/bin/sh\n\nusage() {\n\tcat <\nOptions:\n --help | -h : Print usage.\n --version : Print jemalloc version.\n --revision : Print shared library revision number.\n --config : Print configure options used to build jemalloc.\n --prefix : Print installation directory prefix.\n --bindir : Print binary installation directory.\n --datadir : Print data installation directory.\n --includedir : Print include installation directory.\n --libdir : Print library installation directory.\n --mandir : Print manual page installation directory.\n --cc : Print compiler used to build jemalloc.\n --cflags : Print compiler flags used to build jemalloc.\n --cppflags : Print preprocessor flags used to build jemalloc.\n --cxxflags : Print C++ compiler flags used to build jemalloc.\n --ldflags : Print library flags used to build jemalloc.\n --libs : Print libraries jemalloc was linked against.\nEOF\n}\n\nprefix=\"@prefix@\"\nexec_prefix=\"@exec_prefix@\"\n\ncase \"$1\" in\n--help | -h)\n\tusage\n\texit 0\n\t;;\n--version)\n\techo \"@jemalloc_version@\"\n\t;;\n--revision)\n\techo \"@rev@\"\n\t;;\n--config)\n\techo \"@CONFIG@\"\n\t;;\n--prefix)\n\techo \"@PREFIX@\"\n\t;;\n--bindir)\n\techo \"@BINDIR@\"\n\t;;\n--datadir)\n\techo \"@DATADIR@\"\n\t;;\n--includedir)\n\techo \"@INCLUDEDIR@\"\n\t;;\n--libdir)\n\techo \"@LIBDIR@\"\n\t;;\n--mandir)\n\techo \"@MANDIR@\"\n\t;;\n--cc)\n\techo \"@CC@\"\n\t;;\n--cflags)\n\techo \"@CFLAGS@\"\n\t;;\n--cppflags)\n\techo \"@CPPFLAGS@\"\n\t;;\n--cxxflags)\n\techo \"@CXXFLAGS@\"\n\t;;\n--ldflags)\n\techo \"@LDFLAGS@ @EXTRA_LDFLAGS@\"\n\t;;\n--libs)\n\techo \"@LIBS@\"\n\t;;\n*)\n\tusage\n\texit 1\nesac\n" }, { "path": "deps/jemalloc/bin/jemalloc.sh.in", "content": "#!/bin/sh\n\nprefix=@prefix@\nexec_prefix=@exec_prefix@\nlibdir=@libdir@\n\n@LD_PRELOAD_VAR@=${libdir}/libjemalloc.@SOREV@\nexport @LD_PRELOAD_VAR@\nexec \"$@\"\n" }, { "path": "deps/jemalloc/bin/jeprof.in", "content": "#! /usr/bin/env perl\n\n# Copyright (c) 1998-2007, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are\n# met:\n#\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# * Redistributions in binary form must reproduce the above\n# copyright notice, this list of conditions and the following disclaimer\n# in the documentation and/or other materials provided with the\n# distribution.\n# * Neither the name of Google Inc. nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n# \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n# ---\n# Program for printing the profile generated by common/profiler.cc,\n# or by the heap profiler (common/debugallocation.cc)\n#\n# The profile contains a sequence of entries of the form:\n# \n# This program parses the profile, and generates user-readable\n# output.\n#\n# Examples:\n#\n# % tools/jeprof \"program\" \"profile\"\n# Enters \"interactive\" mode\n#\n# % tools/jeprof --text \"program\" \"profile\"\n# Generates one line per procedure\n#\n# % tools/jeprof --gv \"program\" \"profile\"\n# Generates annotated call-graph and displays via \"gv\"\n#\n# % tools/jeprof --gv --focus=Mutex \"program\" \"profile\"\n# Restrict to code paths that involve an entry that matches \"Mutex\"\n#\n# % tools/jeprof --gv --focus=Mutex --ignore=string \"program\" \"profile\"\n# Restrict to code paths that involve an entry that matches \"Mutex\"\n# and does not match \"string\"\n#\n# % tools/jeprof --list=IBF_CheckDocid \"program\" \"profile\"\n# Generates disassembly listing of all routines with at least one\n# sample that match the --list= pattern. The listing is\n# annotated with the flat and cumulative sample counts at each line.\n#\n# % tools/jeprof --disasm=IBF_CheckDocid \"program\" \"profile\"\n# Generates disassembly listing of all routines with at least one\n# sample that match the --disasm= pattern. The listing is\n# annotated with the flat and cumulative sample counts at each PC value.\n#\n# TODO: Use color to indicate files?\n\nuse strict;\nuse warnings;\nuse Getopt::Long;\nuse Cwd;\n\nmy $JEPROF_VERSION = \"@jemalloc_version@\";\nmy $PPROF_VERSION = \"2.0\";\n\n# These are the object tools we use which can come from a\n# user-specified location using --tools, from the JEPROF_TOOLS\n# environment variable, or from the environment.\nmy %obj_tool_map = (\n \"objdump\" => \"objdump\",\n \"nm\" => \"nm\",\n \"addr2line\" => \"addr2line\",\n \"c++filt\" => \"c++filt\",\n ## ConfigureObjTools may add architecture-specific entries:\n #\"nm_pdb\" => \"nm-pdb\", # for reading windows (PDB-format) executables\n #\"addr2line_pdb\" => \"addr2line-pdb\", # ditto\n #\"otool\" => \"otool\", # equivalent of objdump on OS X\n);\n# NOTE: these are lists, so you can put in commandline flags if you want.\nmy @DOT = (\"dot\"); # leave non-absolute, since it may be in /usr/local\nmy @GV = (\"gv\");\nmy @EVINCE = (\"evince\"); # could also be xpdf or perhaps acroread\nmy @KCACHEGRIND = (\"kcachegrind\");\nmy @PS2PDF = (\"ps2pdf\");\n# These are used for dynamic profiles\nmy @URL_FETCHER = (\"curl\", \"-s\", \"--fail\");\n\n# These are the web pages that servers need to support for dynamic profiles\nmy $HEAP_PAGE = \"/pprof/heap\";\nmy $PROFILE_PAGE = \"/pprof/profile\"; # must support cgi-param \"?seconds=#\"\nmy $PMUPROFILE_PAGE = \"/pprof/pmuprofile(?:\\\\?.*)?\"; # must support cgi-param\n # ?seconds=#&event=x&period=n\nmy $GROWTH_PAGE = \"/pprof/growth\";\nmy $CONTENTION_PAGE = \"/pprof/contention\";\nmy $WALL_PAGE = \"/pprof/wall(?:\\\\?.*)?\"; # accepts options like namefilter\nmy $FILTEREDPROFILE_PAGE = \"/pprof/filteredprofile(?:\\\\?.*)?\";\nmy $CENSUSPROFILE_PAGE = \"/pprof/censusprofile(?:\\\\?.*)?\"; # must support cgi-param\n # \"?seconds=#\",\n # \"?tags_regexp=#\" and\n # \"?type=#\".\nmy $SYMBOL_PAGE = \"/pprof/symbol\"; # must support symbol lookup via POST\nmy $PROGRAM_NAME_PAGE = \"/pprof/cmdline\";\n\n# These are the web pages that can be named on the command line.\n# All the alternatives must begin with /.\nmy $PROFILES = \"($HEAP_PAGE|$PROFILE_PAGE|$PMUPROFILE_PAGE|\" .\n \"$GROWTH_PAGE|$CONTENTION_PAGE|$WALL_PAGE|\" .\n \"$FILTEREDPROFILE_PAGE|$CENSUSPROFILE_PAGE)\";\n\n# default binary name\nmy $UNKNOWN_BINARY = \"(unknown)\";\n\n# There is a pervasive dependency on the length (in hex characters,\n# i.e., nibbles) of an address, distinguishing between 32-bit and\n# 64-bit profiles. To err on the safe size, default to 64-bit here:\nmy $address_length = 16;\n\nmy $dev_null = \"/dev/null\";\nif (! -e $dev_null && $^O =~ /MSWin/) { # $^O is the OS perl was built for\n $dev_null = \"nul\";\n}\n\n# A list of paths to search for shared object files\nmy @prefix_list = ();\n\n# Special routine name that should not have any symbols.\n# Used as separator to parse \"addr2line -i\" output.\nmy $sep_symbol = '_fini';\nmy $sep_address = undef;\n\n##### Argument parsing #####\n\nsub usage_string {\n return < \n is a space separated list of profile names.\njeprof [options] \n is a list of profile files where each file contains\n the necessary symbol mappings as well as profile data (likely generated\n with --raw).\njeprof [options] \n is a remote form. Symbols are obtained from host:port$SYMBOL_PAGE\n\n Each name can be:\n /path/to/profile - a path to a profile file\n host:port[/] - a location of a service to get profile from\n\n The / can be $HEAP_PAGE, $PROFILE_PAGE, /pprof/pmuprofile,\n $GROWTH_PAGE, $CONTENTION_PAGE, /pprof/wall,\n $CENSUSPROFILE_PAGE, or /pprof/filteredprofile.\n For instance:\n jeprof http://myserver.com:80$HEAP_PAGE\n If / is omitted, the service defaults to $PROFILE_PAGE (cpu profiling).\njeprof --symbols \n Maps addresses to symbol names. In this mode, stdin should be a\n list of library mappings, in the same format as is found in the heap-\n and cpu-profile files (this loosely matches that of /proc/self/maps\n on linux), followed by a list of hex addresses to map, one per line.\n\n For more help with querying remote servers, including how to add the\n necessary server-side support code, see this filename (or one like it):\n\n /usr/doc/gperftools-$PPROF_VERSION/pprof_remote_servers.html\n\nOptions:\n --cum Sort by cumulative data\n --base= Subtract from before display\n --interactive Run in interactive mode (interactive \"help\" gives help) [default]\n --seconds= Length of time for dynamic profiles [default=30 secs]\n --add_lib= Read additional symbols and line info from the given library\n --lib_prefix= Comma separated list of library path prefixes\n\nReporting Granularity:\n --addresses Report at address level\n --lines Report at source line level\n --functions Report at function level [default]\n --files Report at source file level\n\nOutput type:\n --text Generate text report\n --callgrind Generate callgrind format to stdout\n --gv Generate Postscript and display\n --evince Generate PDF and display\n --web Generate SVG and display\n --list= Generate source listing of matching routines\n --disasm= Generate disassembly of matching routines\n --symbols Print demangled symbol names found at given addresses\n --dot Generate DOT file to stdout\n --ps Generate Postcript to stdout\n --pdf Generate PDF to stdout\n --svg Generate SVG to stdout\n --gif Generate GIF to stdout\n --raw Generate symbolized jeprof data (useful with remote fetch)\n --collapsed Generate collapsed stacks for building flame graphs\n (see http://www.brendangregg.com/flamegraphs.html)\n\nHeap-Profile Options:\n --inuse_space Display in-use (mega)bytes [default]\n --inuse_objects Display in-use objects\n --alloc_space Display allocated (mega)bytes\n --alloc_objects Display allocated objects\n --show_bytes Display space in bytes\n --drop_negative Ignore negative differences\n\nContention-profile options:\n --total_delay Display total delay at each region [default]\n --contentions Display number of delays at each region\n --mean_delay Display mean delay at each region\n\nCall-graph Options:\n --nodecount= Show at most so many nodes [default=80]\n --nodefraction= Hide nodes below *total [default=.005]\n --edgefraction= Hide edges below *total [default=.001]\n --maxdegree= Max incoming/outgoing edges per node [default=8]\n --focus= Focus on backtraces with nodes matching \n --thread= Show profile for thread \n --ignore= Ignore backtraces with nodes matching \n --scale= Set GV scaling [default=0]\n --heapcheck Make nodes with non-0 object counts\n (i.e. direct leak generators) more visible\n --retain= Retain only nodes that match \n --exclude= Exclude all nodes that match \n\nMiscellaneous:\n --tools=[,...] \\$PATH for object tool pathnames\n --test Run unit tests\n --help This message\n --version Version information\n --debug-syms-by-id (Linux only) Find debug symbol files by build ID as well as by name\n\nEnvironment Variables:\n JEPROF_TMPDIR Profiles directory. Defaults to \\$HOME/jeprof\n JEPROF_TOOLS Prefix for object tools pathnames\n\nExamples:\n\njeprof /bin/ls ls.prof\n Enters \"interactive\" mode\njeprof --text /bin/ls ls.prof\n Outputs one line per procedure\njeprof --web /bin/ls ls.prof\n Displays annotated call-graph in web browser\njeprof --gv /bin/ls ls.prof\n Displays annotated call-graph via 'gv'\njeprof --gv --focus=Mutex /bin/ls ls.prof\n Restricts to code paths including a .*Mutex.* entry\njeprof --gv --focus=Mutex --ignore=string /bin/ls ls.prof\n Code paths including Mutex but not string\njeprof --list=getdir /bin/ls ls.prof\n (Per-line) annotated source listing for getdir()\njeprof --disasm=getdir /bin/ls ls.prof\n (Per-PC) annotated disassembly for getdir()\n\njeprof http://localhost:1234/\n Enters \"interactive\" mode\njeprof --text localhost:1234\n Outputs one line per procedure for localhost:1234\njeprof --raw localhost:1234 > ./local.raw\njeprof --text ./local.raw\n Fetches a remote profile for later analysis and then\n analyzes it in text mode.\nEOF\n}\n\nsub version_string {\n return < \\$main::opt_help,\n \"version!\" => \\$main::opt_version,\n \"cum!\" => \\$main::opt_cum,\n \"base=s\" => \\$main::opt_base,\n \"seconds=i\" => \\$main::opt_seconds,\n \"add_lib=s\" => \\$main::opt_lib,\n \"lib_prefix=s\" => \\$main::opt_lib_prefix,\n \"functions!\" => \\$main::opt_functions,\n \"lines!\" => \\$main::opt_lines,\n \"addresses!\" => \\$main::opt_addresses,\n \"files!\" => \\$main::opt_files,\n \"text!\" => \\$main::opt_text,\n \"callgrind!\" => \\$main::opt_callgrind,\n \"list=s\" => \\$main::opt_list,\n \"disasm=s\" => \\$main::opt_disasm,\n \"symbols!\" => \\$main::opt_symbols,\n \"gv!\" => \\$main::opt_gv,\n \"evince!\" => \\$main::opt_evince,\n \"web!\" => \\$main::opt_web,\n \"dot!\" => \\$main::opt_dot,\n \"ps!\" => \\$main::opt_ps,\n \"pdf!\" => \\$main::opt_pdf,\n \"svg!\" => \\$main::opt_svg,\n \"gif!\" => \\$main::opt_gif,\n \"raw!\" => \\$main::opt_raw,\n \"collapsed!\" => \\$main::opt_collapsed,\n \"interactive!\" => \\$main::opt_interactive,\n \"nodecount=i\" => \\$main::opt_nodecount,\n \"nodefraction=f\" => \\$main::opt_nodefraction,\n \"edgefraction=f\" => \\$main::opt_edgefraction,\n \"maxdegree=i\" => \\$main::opt_maxdegree,\n \"focus=s\" => \\$main::opt_focus,\n \"thread=s\" => \\$main::opt_thread,\n \"ignore=s\" => \\$main::opt_ignore,\n \"scale=i\" => \\$main::opt_scale,\n \"heapcheck\" => \\$main::opt_heapcheck,\n \"retain=s\" => \\$main::opt_retain,\n \"exclude=s\" => \\$main::opt_exclude,\n \"inuse_space!\" => \\$main::opt_inuse_space,\n \"inuse_objects!\" => \\$main::opt_inuse_objects,\n \"alloc_space!\" => \\$main::opt_alloc_space,\n \"alloc_objects!\" => \\$main::opt_alloc_objects,\n \"show_bytes!\" => \\$main::opt_show_bytes,\n \"drop_negative!\" => \\$main::opt_drop_negative,\n \"total_delay!\" => \\$main::opt_total_delay,\n \"contentions!\" => \\$main::opt_contentions,\n \"mean_delay!\" => \\$main::opt_mean_delay,\n \"tools=s\" => \\$main::opt_tools,\n \"test!\" => \\$main::opt_test,\n \"debug!\" => \\$main::opt_debug,\n \"debug-syms-by-id!\" => \\$main::opt_debug_syms_by_id,\n # Undocumented flags used only by unittests:\n \"test_stride=i\" => \\$main::opt_test_stride,\n ) || usage(\"Invalid option(s)\");\n\n # Deal with the standard --help and --version\n if ($main::opt_help) {\n print usage_string();\n exit(0);\n }\n\n if ($main::opt_version) {\n print version_string();\n exit(0);\n }\n\n # Disassembly/listing/symbols mode requires address-level info\n if ($main::opt_disasm || $main::opt_list || $main::opt_symbols) {\n $main::opt_functions = 0;\n $main::opt_lines = 0;\n $main::opt_addresses = 1;\n $main::opt_files = 0;\n }\n\n # Check heap-profiling flags\n if ($main::opt_inuse_space +\n $main::opt_inuse_objects +\n $main::opt_alloc_space +\n $main::opt_alloc_objects > 1) {\n usage(\"Specify at most on of --inuse/--alloc options\");\n }\n\n # Check output granularities\n my $grains =\n $main::opt_functions +\n $main::opt_lines +\n $main::opt_addresses +\n $main::opt_files +\n 0;\n if ($grains > 1) {\n usage(\"Only specify one output granularity option\");\n }\n if ($grains == 0) {\n $main::opt_functions = 1;\n }\n\n # Check output modes\n my $modes =\n $main::opt_text +\n $main::opt_callgrind +\n ($main::opt_list eq '' ? 0 : 1) +\n ($main::opt_disasm eq '' ? 0 : 1) +\n ($main::opt_symbols == 0 ? 0 : 1) +\n $main::opt_gv +\n $main::opt_evince +\n $main::opt_web +\n $main::opt_dot +\n $main::opt_ps +\n $main::opt_pdf +\n $main::opt_svg +\n $main::opt_gif +\n $main::opt_raw +\n $main::opt_collapsed +\n $main::opt_interactive +\n 0;\n if ($modes > 1) {\n usage(\"Only specify one output mode\");\n }\n if ($modes == 0) {\n if (-t STDOUT) { # If STDOUT is a tty, activate interactive mode\n $main::opt_interactive = 1;\n } else {\n $main::opt_text = 1;\n }\n }\n\n if ($main::opt_test) {\n RunUnitTests();\n # Should not return\n exit(1);\n }\n\n # Binary name and profile arguments list\n $main::prog = \"\";\n @main::pfile_args = ();\n\n # Remote profiling without a binary (using $SYMBOL_PAGE instead)\n if (@ARGV > 0) {\n if (IsProfileURL($ARGV[0])) {\n $main::use_symbol_page = 1;\n } elsif (IsSymbolizedProfileFile($ARGV[0])) {\n $main::use_symbolized_profile = 1;\n $main::prog = $UNKNOWN_BINARY; # will be set later from the profile file\n }\n }\n\n if ($main::use_symbol_page || $main::use_symbolized_profile) {\n # We don't need a binary!\n my %disabled = ('--lines' => $main::opt_lines,\n '--disasm' => $main::opt_disasm);\n for my $option (keys %disabled) {\n usage(\"$option cannot be used without a binary\") if $disabled{$option};\n }\n # Set $main::prog later...\n scalar(@ARGV) || usage(\"Did not specify profile file\");\n } elsif ($main::opt_symbols) {\n # --symbols needs a binary-name (to run nm on, etc) but not profiles\n $main::prog = shift(@ARGV) || usage(\"Did not specify program\");\n } else {\n $main::prog = shift(@ARGV) || usage(\"Did not specify program\");\n scalar(@ARGV) || usage(\"Did not specify profile file\");\n }\n\n # Parse profile file/location arguments\n foreach my $farg (@ARGV) {\n if ($farg =~ m/(.*)\\@([0-9]+)(|\\/.*)$/ ) {\n my $machine = $1;\n my $num_machines = $2;\n my $path = $3;\n for (my $i = 0; $i < $num_machines; $i++) {\n unshift(@main::pfile_args, \"$i.$machine$path\");\n }\n } else {\n unshift(@main::pfile_args, $farg);\n }\n }\n\n if ($main::use_symbol_page) {\n unless (IsProfileURL($main::pfile_args[0])) {\n error(\"The first profile should be a remote form to use $SYMBOL_PAGE\\n\");\n }\n CheckSymbolPage();\n $main::prog = FetchProgramName();\n } elsif (!$main::use_symbolized_profile) { # may not need objtools!\n ConfigureObjTools($main::prog)\n }\n\n # Break the opt_lib_prefix into the prefix_list array\n @prefix_list = split (',', $main::opt_lib_prefix);\n\n # Remove trailing / from the prefixes, in the list to prevent\n # searching things like /my/path//lib/mylib.so\n foreach (@prefix_list) {\n s|/+$||;\n }\n\n # Flag to prevent us from trying over and over to use\n # elfutils if it's not installed (used only with\n # --debug-syms-by-id option).\n $main::gave_up_on_elfutils = 0;\n}\n\nsub FilterAndPrint {\n my ($profile, $symbols, $libs, $thread) = @_;\n\n # Get total data in profile\n my $total = TotalProfile($profile);\n\n # Remove uniniteresting stack items\n $profile = RemoveUninterestingFrames($symbols, $profile);\n\n # Focus?\n if ($main::opt_focus ne '') {\n $profile = FocusProfile($symbols, $profile, $main::opt_focus);\n }\n\n # Ignore?\n if ($main::opt_ignore ne '') {\n $profile = IgnoreProfile($symbols, $profile, $main::opt_ignore);\n }\n\n my $calls = ExtractCalls($symbols, $profile);\n\n # Reduce profiles to required output granularity, and also clean\n # each stack trace so a given entry exists at most once.\n my $reduced = ReduceProfile($symbols, $profile);\n\n # Get derived profiles\n my $flat = FlatProfile($reduced);\n my $cumulative = CumulativeProfile($reduced);\n\n # Print\n if (!$main::opt_interactive) {\n if ($main::opt_disasm) {\n PrintDisassembly($libs, $flat, $cumulative, $main::opt_disasm);\n } elsif ($main::opt_list) {\n PrintListing($total, $libs, $flat, $cumulative, $main::opt_list, 0);\n } elsif ($main::opt_text) {\n # Make sure the output is empty when have nothing to report\n # (only matters when --heapcheck is given but we must be\n # compatible with old branches that did not pass --heapcheck always):\n if ($total != 0) {\n printf(\"Total%s: %s %s\\n\",\n (defined($thread) ? \" (t$thread)\" : \"\"),\n Unparse($total), Units());\n }\n PrintText($symbols, $flat, $cumulative, -1);\n } elsif ($main::opt_raw) {\n PrintSymbolizedProfile($symbols, $profile, $main::prog);\n } elsif ($main::opt_collapsed) {\n PrintCollapsedStacks($symbols, $profile);\n } elsif ($main::opt_callgrind) {\n PrintCallgrind($calls);\n } else {\n if (PrintDot($main::prog, $symbols, $profile, $flat, $cumulative, $total)) {\n if ($main::opt_gv) {\n RunGV(TempName($main::next_tmpfile, \"ps\"), \"\");\n } elsif ($main::opt_evince) {\n RunEvince(TempName($main::next_tmpfile, \"pdf\"), \"\");\n } elsif ($main::opt_web) {\n my $tmp = TempName($main::next_tmpfile, \"svg\");\n RunWeb($tmp);\n # The command we run might hand the file name off\n # to an already running browser instance and then exit.\n # Normally, we'd remove $tmp on exit (right now),\n # but fork a child to remove $tmp a little later, so that the\n # browser has time to load it first.\n delete $main::tempnames{$tmp};\n if (fork() == 0) {\n sleep 5;\n unlink($tmp);\n exit(0);\n }\n }\n } else {\n cleanup();\n exit(1);\n }\n }\n } else {\n InteractiveMode($profile, $symbols, $libs, $total);\n }\n}\n\nsub Main() {\n Init();\n $main::collected_profile = undef;\n @main::profile_files = ();\n $main::op_time = time();\n\n # Printing symbols is special and requires a lot less info that most.\n if ($main::opt_symbols) {\n PrintSymbols(*STDIN); # Get /proc/maps and symbols output from stdin\n return;\n }\n\n # Fetch all profile data\n FetchDynamicProfiles();\n\n # this will hold symbols that we read from the profile files\n my $symbol_map = {};\n\n # Read one profile, pick the last item on the list\n my $data = ReadProfile($main::prog, pop(@main::profile_files));\n my $profile = $data->{profile};\n my $pcs = $data->{pcs};\n my $libs = $data->{libs}; # Info about main program and shared libraries\n $symbol_map = MergeSymbols($symbol_map, $data->{symbols});\n\n # Add additional profiles, if available.\n if (scalar(@main::profile_files) > 0) {\n foreach my $pname (@main::profile_files) {\n my $data2 = ReadProfile($main::prog, $pname);\n $profile = AddProfile($profile, $data2->{profile});\n $pcs = AddPcs($pcs, $data2->{pcs});\n $symbol_map = MergeSymbols($symbol_map, $data2->{symbols});\n }\n }\n\n # Subtract base from profile, if specified\n if ($main::opt_base ne '') {\n my $base = ReadProfile($main::prog, $main::opt_base);\n $profile = SubtractProfile($profile, $base->{profile});\n $pcs = AddPcs($pcs, $base->{pcs});\n $symbol_map = MergeSymbols($symbol_map, $base->{symbols});\n }\n\n # Collect symbols\n my $symbols;\n if ($main::use_symbolized_profile) {\n $symbols = FetchSymbols($pcs, $symbol_map);\n } elsif ($main::use_symbol_page) {\n $symbols = FetchSymbols($pcs);\n } else {\n # TODO(csilvers): $libs uses the /proc/self/maps data from profile1,\n # which may differ from the data from subsequent profiles, especially\n # if they were run on different machines. Use appropriate libs for\n # each pc somehow.\n $symbols = ExtractSymbols($libs, $pcs);\n }\n\n if (!defined($main::opt_thread)) {\n FilterAndPrint($profile, $symbols, $libs);\n }\n if (defined($data->{threads})) {\n foreach my $thread (sort { $a <=> $b } keys(%{$data->{threads}})) {\n if (defined($main::opt_thread) &&\n ($main::opt_thread eq '*' || $main::opt_thread == $thread)) {\n my $thread_profile = $data->{threads}{$thread};\n FilterAndPrint($thread_profile, $symbols, $libs, $thread);\n }\n }\n }\n\n cleanup();\n exit(0);\n}\n\n##### Entry Point #####\n\nMain();\n\n# Temporary code to detect if we're running on a Goobuntu system.\n# These systems don't have the right stuff installed for the special\n# Readline libraries to work, so as a temporary workaround, we default\n# to using the normal stdio code, rather than the fancier readline-based\n# code\nsub ReadlineMightFail {\n if (-e '/lib/libtermcap.so.2') {\n return 0; # libtermcap exists, so readline should be okay\n } else {\n return 1;\n }\n}\n\nsub RunGV {\n my $fname = shift;\n my $bg = shift; # \"\" or \" &\" if we should run in background\n if (!system(ShellEscape(@GV, \"--version\") . \" >$dev_null 2>&1\")) {\n # Options using double dash are supported by this gv version.\n # Also, turn on noantialias to better handle bug in gv for\n # postscript files with large dimensions.\n # TODO: Maybe we should not pass the --noantialias flag\n # if the gv version is known to work properly without the flag.\n system(ShellEscape(@GV, \"--scale=$main::opt_scale\", \"--noantialias\", $fname)\n . $bg);\n } else {\n # Old gv version - only supports options that use single dash.\n print STDERR ShellEscape(@GV, \"-scale\", $main::opt_scale) . \"\\n\";\n system(ShellEscape(@GV, \"-scale\", \"$main::opt_scale\", $fname) . $bg);\n }\n}\n\nsub RunEvince {\n my $fname = shift;\n my $bg = shift; # \"\" or \" &\" if we should run in background\n system(ShellEscape(@EVINCE, $fname) . $bg);\n}\n\nsub RunWeb {\n my $fname = shift;\n print STDERR \"Loading web page file:///$fname\\n\";\n\n if (`uname` =~ /Darwin/) {\n # OS X: open will use standard preference for SVG files.\n system(\"/usr/bin/open\", $fname);\n return;\n }\n\n # Some kind of Unix; try generic symlinks, then specific browsers.\n # (Stop once we find one.)\n # Works best if the browser is already running.\n my @alt = (\n \"/etc/alternatives/gnome-www-browser\",\n \"/etc/alternatives/x-www-browser\",\n \"google-chrome\",\n \"firefox\",\n );\n foreach my $b (@alt) {\n if (system($b, $fname) == 0) {\n return;\n }\n }\n\n print STDERR \"Could not load web browser.\\n\";\n}\n\nsub RunKcachegrind {\n my $fname = shift;\n my $bg = shift; # \"\" or \" &\" if we should run in background\n print STDERR \"Starting '@KCACHEGRIND \" . $fname . $bg . \"'\\n\";\n system(ShellEscape(@KCACHEGRIND, $fname) . $bg);\n}\n\n\n##### Interactive helper routines #####\n\nsub InteractiveMode {\n $| = 1; # Make output unbuffered for interactive mode\n my ($orig_profile, $symbols, $libs, $total) = @_;\n\n print STDERR \"Welcome to jeprof! For help, type 'help'.\\n\";\n\n # Use ReadLine if it's installed and input comes from a console.\n if ( -t STDIN &&\n !ReadlineMightFail() &&\n defined(eval {require Term::ReadLine}) ) {\n my $term = new Term::ReadLine 'jeprof';\n while ( defined ($_ = $term->readline('(jeprof) '))) {\n $term->addhistory($_) if /\\S/;\n if (!InteractiveCommand($orig_profile, $symbols, $libs, $total, $_)) {\n last; # exit when we get an interactive command to quit\n }\n }\n } else { # don't have readline\n while (1) {\n print STDERR \"(jeprof) \";\n $_ = ;\n last if ! defined $_ ;\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n\n # Save some flags that might be reset by InteractiveCommand()\n my $save_opt_lines = $main::opt_lines;\n\n if (!InteractiveCommand($orig_profile, $symbols, $libs, $total, $_)) {\n last; # exit when we get an interactive command to quit\n }\n\n # Restore flags\n $main::opt_lines = $save_opt_lines;\n }\n }\n}\n\n# Takes two args: orig profile, and command to run.\n# Returns 1 if we should keep going, or 0 if we were asked to quit\nsub InteractiveCommand {\n my($orig_profile, $symbols, $libs, $total, $command) = @_;\n $_ = $command; # just to make future m//'s easier\n if (!defined($_)) {\n print STDERR \"\\n\";\n return 0;\n }\n if (m/^\\s*quit/) {\n return 0;\n }\n if (m/^\\s*help/) {\n InteractiveHelpMessage();\n return 1;\n }\n # Clear all the mode options -- mode is controlled by \"$command\"\n $main::opt_text = 0;\n $main::opt_callgrind = 0;\n $main::opt_disasm = 0;\n $main::opt_list = 0;\n $main::opt_gv = 0;\n $main::opt_evince = 0;\n $main::opt_cum = 0;\n\n if (m/^\\s*(text|top)(\\d*)\\s*(.*)/) {\n $main::opt_text = 1;\n\n my $line_limit = ($2 ne \"\") ? int($2) : 10;\n\n my $routine;\n my $ignore;\n ($routine, $ignore) = ParseInteractiveArgs($3);\n\n my $profile = ProcessProfile($total, $orig_profile, $symbols, \"\", $ignore);\n my $reduced = ReduceProfile($symbols, $profile);\n\n # Get derived profiles\n my $flat = FlatProfile($reduced);\n my $cumulative = CumulativeProfile($reduced);\n\n PrintText($symbols, $flat, $cumulative, $line_limit);\n return 1;\n }\n if (m/^\\s*callgrind\\s*([^ \\n]*)/) {\n $main::opt_callgrind = 1;\n\n # Get derived profiles\n my $calls = ExtractCalls($symbols, $orig_profile);\n my $filename = $1;\n if ( $1 eq '' ) {\n $filename = TempName($main::next_tmpfile, \"callgrind\");\n }\n PrintCallgrind($calls, $filename);\n if ( $1 eq '' ) {\n RunKcachegrind($filename, \" & \");\n $main::next_tmpfile++;\n }\n\n return 1;\n }\n if (m/^\\s*(web)?list\\s*(.+)/) {\n my $html = (defined($1) && ($1 eq \"web\"));\n $main::opt_list = 1;\n\n my $routine;\n my $ignore;\n ($routine, $ignore) = ParseInteractiveArgs($2);\n\n my $profile = ProcessProfile($total, $orig_profile, $symbols, \"\", $ignore);\n my $reduced = ReduceProfile($symbols, $profile);\n\n # Get derived profiles\n my $flat = FlatProfile($reduced);\n my $cumulative = CumulativeProfile($reduced);\n\n PrintListing($total, $libs, $flat, $cumulative, $routine, $html);\n return 1;\n }\n if (m/^\\s*disasm\\s*(.+)/) {\n $main::opt_disasm = 1;\n\n my $routine;\n my $ignore;\n ($routine, $ignore) = ParseInteractiveArgs($1);\n\n # Process current profile to account for various settings\n my $profile = ProcessProfile($total, $orig_profile, $symbols, \"\", $ignore);\n my $reduced = ReduceProfile($symbols, $profile);\n\n # Get derived profiles\n my $flat = FlatProfile($reduced);\n my $cumulative = CumulativeProfile($reduced);\n\n PrintDisassembly($libs, $flat, $cumulative, $routine);\n return 1;\n }\n if (m/^\\s*(gv|web|evince)\\s*(.*)/) {\n $main::opt_gv = 0;\n $main::opt_evince = 0;\n $main::opt_web = 0;\n if ($1 eq \"gv\") {\n $main::opt_gv = 1;\n } elsif ($1 eq \"evince\") {\n $main::opt_evince = 1;\n } elsif ($1 eq \"web\") {\n $main::opt_web = 1;\n }\n\n my $focus;\n my $ignore;\n ($focus, $ignore) = ParseInteractiveArgs($2);\n\n # Process current profile to account for various settings\n my $profile = ProcessProfile($total, $orig_profile, $symbols,\n $focus, $ignore);\n my $reduced = ReduceProfile($symbols, $profile);\n\n # Get derived profiles\n my $flat = FlatProfile($reduced);\n my $cumulative = CumulativeProfile($reduced);\n\n if (PrintDot($main::prog, $symbols, $profile, $flat, $cumulative, $total)) {\n if ($main::opt_gv) {\n RunGV(TempName($main::next_tmpfile, \"ps\"), \" &\");\n } elsif ($main::opt_evince) {\n RunEvince(TempName($main::next_tmpfile, \"pdf\"), \" &\");\n } elsif ($main::opt_web) {\n RunWeb(TempName($main::next_tmpfile, \"svg\"));\n }\n $main::next_tmpfile++;\n }\n return 1;\n }\n if (m/^\\s*$/) {\n return 1;\n }\n print STDERR \"Unknown command: try 'help'.\\n\";\n return 1;\n}\n\n\nsub ProcessProfile {\n my $total_count = shift;\n my $orig_profile = shift;\n my $symbols = shift;\n my $focus = shift;\n my $ignore = shift;\n\n # Process current profile to account for various settings\n my $profile = $orig_profile;\n printf(\"Total: %s %s\\n\", Unparse($total_count), Units());\n if ($focus ne '') {\n $profile = FocusProfile($symbols, $profile, $focus);\n my $focus_count = TotalProfile($profile);\n printf(\"After focusing on '%s': %s %s of %s (%0.1f%%)\\n\",\n $focus,\n Unparse($focus_count), Units(),\n Unparse($total_count), ($focus_count*100.0) / $total_count);\n }\n if ($ignore ne '') {\n $profile = IgnoreProfile($symbols, $profile, $ignore);\n my $ignore_count = TotalProfile($profile);\n printf(\"After ignoring '%s': %s %s of %s (%0.1f%%)\\n\",\n $ignore,\n Unparse($ignore_count), Units(),\n Unparse($total_count),\n ($ignore_count*100.0) / $total_count);\n }\n\n return $profile;\n}\n\nsub InteractiveHelpMessage {\n print STDERR <{$k};\n my @addrs = split(/\\n/, $k);\n if ($#addrs >= 0) {\n my $depth = $#addrs + 1;\n # int(foo / 2**32) is the only reliable way to get rid of bottom\n # 32 bits on both 32- and 64-bit systems.\n print pack('L*', $count & 0xFFFFFFFF, int($count / 2**32));\n print pack('L*', $depth & 0xFFFFFFFF, int($depth / 2**32));\n\n foreach my $full_addr (@addrs) {\n my $addr = $full_addr;\n $addr =~ s/0x0*//; # strip off leading 0x, zeroes\n if (length($addr) > 16) {\n print STDERR \"Invalid address in profile: $full_addr\\n\";\n next;\n }\n my $low_addr = substr($addr, -8); # get last 8 hex chars\n my $high_addr = substr($addr, -16, 8); # get up to 8 more hex chars\n print pack('L*', hex('0x' . $low_addr), hex('0x' . $high_addr));\n }\n }\n }\n}\n\n# Print symbols and profile data\nsub PrintSymbolizedProfile {\n my $symbols = shift;\n my $profile = shift;\n my $prog = shift;\n\n $SYMBOL_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $symbol_marker = $&;\n\n print '--- ', $symbol_marker, \"\\n\";\n if (defined($prog)) {\n print 'binary=', $prog, \"\\n\";\n }\n while (my ($pc, $name) = each(%{$symbols})) {\n my $sep = ' ';\n print '0x', $pc;\n # We have a list of function names, which include the inlined\n # calls. They are separated (and terminated) by --, which is\n # illegal in function names.\n for (my $j = 2; $j <= $#{$name}; $j += 3) {\n print $sep, $name->[$j];\n $sep = '--';\n }\n print \"\\n\";\n }\n print '---', \"\\n\";\n\n my $profile_marker;\n if ($main::profile_type eq 'heap') {\n $HEAP_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n $profile_marker = $&;\n } elsif ($main::profile_type eq 'growth') {\n $GROWTH_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n $profile_marker = $&;\n } elsif ($main::profile_type eq 'contention') {\n $CONTENTION_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n $profile_marker = $&;\n } else { # elsif ($main::profile_type eq 'cpu')\n $PROFILE_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n $profile_marker = $&;\n }\n\n print '--- ', $profile_marker, \"\\n\";\n if (defined($main::collected_profile)) {\n # if used with remote fetch, simply dump the collected profile to output.\n open(SRC, \"<$main::collected_profile\");\n while () {\n print $_;\n }\n close(SRC);\n } else {\n # --raw/http: For everything to work correctly for non-remote profiles, we\n # would need to extend PrintProfileData() to handle all possible profile\n # types, re-enable the code that is currently disabled in ReadCPUProfile()\n # and FixCallerAddresses(), and remove the remote profile dumping code in\n # the block above.\n die \"--raw/http: jeprof can only dump remote profiles for --raw\\n\";\n # dump a cpu-format profile to standard out\n PrintProfileData($profile);\n }\n}\n\n# Print text output\nsub PrintText {\n my $symbols = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $line_limit = shift;\n\n my $total = TotalProfile($flat);\n\n # Which profile to sort by?\n my $s = $main::opt_cum ? $cumulative : $flat;\n\n my $running_sum = 0;\n my $lines = 0;\n foreach my $k (sort { GetEntry($s, $b) <=> GetEntry($s, $a) || $a cmp $b }\n keys(%{$cumulative})) {\n my $f = GetEntry($flat, $k);\n my $c = GetEntry($cumulative, $k);\n $running_sum += $f;\n\n my $sym = $k;\n if (exists($symbols->{$k})) {\n $sym = $symbols->{$k}->[0] . \" \" . $symbols->{$k}->[1];\n if ($main::opt_addresses) {\n $sym = $k . \" \" . $sym;\n }\n }\n\n if ($f != 0 || $c != 0) {\n printf(\"%8s %6s %6s %8s %6s %s\\n\",\n Unparse($f),\n Percent($f, $total),\n Percent($running_sum, $total),\n Unparse($c),\n Percent($c, $total),\n $sym);\n }\n $lines++;\n last if ($line_limit >= 0 && $lines >= $line_limit);\n }\n}\n\n# Callgrind format has a compression for repeated function and file\n# names. You show the name the first time, and just use its number\n# subsequently. This can cut down the file to about a third or a\n# quarter of its uncompressed size. $key and $val are the key/value\n# pair that would normally be printed by callgrind; $map is a map from\n# value to number.\nsub CompressedCGName {\n my($key, $val, $map) = @_;\n my $idx = $map->{$val};\n # For very short keys, providing an index hurts rather than helps.\n if (length($val) <= 3) {\n return \"$key=$val\\n\";\n } elsif (defined($idx)) {\n return \"$key=($idx)\\n\";\n } else {\n # scalar(keys $map) gives the number of items in the map.\n $idx = scalar(keys(%{$map})) + 1;\n $map->{$val} = $idx;\n return \"$key=($idx) $val\\n\";\n }\n}\n\n# Print the call graph in a way that's suiteable for callgrind.\nsub PrintCallgrind {\n my $calls = shift;\n my $filename;\n my %filename_to_index_map;\n my %fnname_to_index_map;\n\n if ($main::opt_interactive) {\n $filename = shift;\n print STDERR \"Writing callgrind file to '$filename'.\\n\"\n } else {\n $filename = \"&STDOUT\";\n }\n open(CG, \">$filename\");\n printf CG (\"events: Hits\\n\\n\");\n foreach my $call ( map { $_->[0] }\n sort { $a->[1] cmp $b ->[1] ||\n $a->[2] <=> $b->[2] }\n map { /([^:]+):(\\d+):([^ ]+)( -> ([^:]+):(\\d+):(.+))?/;\n [$_, $1, $2] }\n keys %$calls ) {\n my $count = int($calls->{$call});\n $call =~ /([^:]+):(\\d+):([^ ]+)( -> ([^:]+):(\\d+):(.+))?/;\n my ( $caller_file, $caller_line, $caller_function,\n $callee_file, $callee_line, $callee_function ) =\n ( $1, $2, $3, $5, $6, $7 );\n\n # TODO(csilvers): for better compression, collect all the\n # caller/callee_files and functions first, before printing\n # anything, and only compress those referenced more than once.\n printf CG CompressedCGName(\"fl\", $caller_file, \\%filename_to_index_map);\n printf CG CompressedCGName(\"fn\", $caller_function, \\%fnname_to_index_map);\n if (defined $6) {\n printf CG CompressedCGName(\"cfl\", $callee_file, \\%filename_to_index_map);\n printf CG CompressedCGName(\"cfn\", $callee_function, \\%fnname_to_index_map);\n printf CG (\"calls=$count $callee_line\\n\");\n }\n printf CG (\"$caller_line $count\\n\\n\");\n }\n}\n\n# Print disassembly for all all routines that match $main::opt_disasm\nsub PrintDisassembly {\n my $libs = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $disasm_opts = shift;\n\n my $total = TotalProfile($flat);\n\n foreach my $lib (@{$libs}) {\n my $symbol_table = GetProcedureBoundaries($lib->[0], $disasm_opts);\n my $offset = AddressSub($lib->[1], $lib->[3]);\n foreach my $routine (sort ByName keys(%{$symbol_table})) {\n my $start_addr = $symbol_table->{$routine}->[0];\n my $end_addr = $symbol_table->{$routine}->[1];\n # See if there are any samples in this routine\n my $length = hex(AddressSub($end_addr, $start_addr));\n my $addr = AddressAdd($start_addr, $offset);\n for (my $i = 0; $i < $length; $i++) {\n if (defined($cumulative->{$addr})) {\n PrintDisassembledFunction($lib->[0], $offset,\n $routine, $flat, $cumulative,\n $start_addr, $end_addr, $total);\n last;\n }\n $addr = AddressInc($addr);\n }\n }\n }\n}\n\n# Return reference to array of tuples of the form:\n# [start_address, filename, linenumber, instruction, limit_address]\n# E.g.,\n# [\"0x806c43d\", \"/foo/bar.cc\", 131, \"ret\", \"0x806c440\"]\nsub Disassemble {\n my $prog = shift;\n my $offset = shift;\n my $start_addr = shift;\n my $end_addr = shift;\n\n my $objdump = $obj_tool_map{\"objdump\"};\n my $cmd = ShellEscape($objdump, \"-C\", \"-d\", \"-l\", \"--no-show-raw-insn\",\n \"--start-address=0x$start_addr\",\n \"--stop-address=0x$end_addr\", $prog);\n open(OBJDUMP, \"$cmd |\") || error(\"$cmd: $!\\n\");\n my @result = ();\n my $filename = \"\";\n my $linenumber = -1;\n my $last = [\"\", \"\", \"\", \"\"];\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n chop;\n if (m|\\s*([^:\\s]+):(\\d+)\\s*$|) {\n # Location line of the form:\n # :\n $filename = $1;\n $linenumber = $2;\n } elsif (m/^ +([0-9a-f]+):\\s*(.*)/) {\n # Disassembly line -- zero-extend address to full length\n my $addr = HexExtend($1);\n my $k = AddressAdd($addr, $offset);\n $last->[4] = $k; # Store ending address for previous instruction\n $last = [$k, $filename, $linenumber, $2, $end_addr];\n push(@result, $last);\n }\n }\n close(OBJDUMP);\n return @result;\n}\n\n# The input file should contain lines of the form /proc/maps-like\n# output (same format as expected from the profiles) or that looks\n# like hex addresses (like \"0xDEADBEEF\"). We will parse all\n# /proc/maps output, and for all the hex addresses, we will output\n# \"short\" symbol names, one per line, in the same order as the input.\nsub PrintSymbols {\n my $maps_and_symbols_file = shift;\n\n # ParseLibraries expects pcs to be in a set. Fine by us...\n my @pclist = (); # pcs in sorted order\n my $pcs = {};\n my $map = \"\";\n foreach my $line (<$maps_and_symbols_file>) {\n $line =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n if ($line =~ /\\b(0x[0-9a-f]+)\\b/i) {\n push(@pclist, HexExtend($1));\n $pcs->{$pclist[-1]} = 1;\n } else {\n $map .= $line;\n }\n }\n\n my $libs = ParseLibraries($main::prog, $map, $pcs);\n my $symbols = ExtractSymbols($libs, $pcs);\n\n foreach my $pc (@pclist) {\n # ->[0] is the shortname, ->[2] is the full name\n print(($symbols->{$pc}->[0] || \"??\") . \"\\n\");\n }\n}\n\n\n# For sorting functions by name\nsub ByName {\n return ShortFunctionName($a) cmp ShortFunctionName($b);\n}\n\n# Print source-listing for all all routines that match $list_opts\nsub PrintListing {\n my $total = shift;\n my $libs = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $list_opts = shift;\n my $html = shift;\n\n my $output = \\*STDOUT;\n my $fname = \"\";\n\n if ($html) {\n # Arrange to write the output to a temporary file\n $fname = TempName($main::next_tmpfile, \"html\");\n $main::next_tmpfile++;\n if (!open(TEMP, \">$fname\")) {\n print STDERR \"$fname: $!\\n\";\n return;\n }\n $output = \\*TEMP;\n print $output HtmlListingHeader();\n printf $output (\"
%s
Total: %s %s
\\n\",\n $main::prog, Unparse($total), Units());\n }\n\n my $listed = 0;\n foreach my $lib (@{$libs}) {\n my $symbol_table = GetProcedureBoundaries($lib->[0], $list_opts);\n my $offset = AddressSub($lib->[1], $lib->[3]);\n foreach my $routine (sort ByName keys(%{$symbol_table})) {\n # Print if there are any samples in this routine\n my $start_addr = $symbol_table->{$routine}->[0];\n my $end_addr = $symbol_table->{$routine}->[1];\n my $length = hex(AddressSub($end_addr, $start_addr));\n my $addr = AddressAdd($start_addr, $offset);\n for (my $i = 0; $i < $length; $i++) {\n if (defined($cumulative->{$addr})) {\n $listed += PrintSource(\n $lib->[0], $offset,\n $routine, $flat, $cumulative,\n $start_addr, $end_addr,\n $html,\n $output);\n last;\n }\n $addr = AddressInc($addr);\n }\n }\n }\n\n if ($html) {\n if ($listed > 0) {\n print $output HtmlListingFooter();\n close($output);\n RunWeb($fname);\n } else {\n close($output);\n unlink($fname);\n }\n }\n}\n\nsub HtmlListingHeader {\n return <<'EOF';\n\n\n\nPprof listing\n\n\n\n\nEOF\n}\n\nsub HtmlListingFooter {\n return <<'EOF';\n\n\nEOF\n}\n\nsub HtmlEscape {\n my $text = shift;\n $text =~ s/&/&/g;\n $text =~ s//>/g;\n return $text;\n}\n\n# Returns the indentation of the line, if it has any non-whitespace\n# characters. Otherwise, returns -1.\nsub Indentation {\n my $line = shift;\n if (m/^(\\s*)\\S/) {\n return length($1);\n } else {\n return -1;\n }\n}\n\n# If the symbol table contains inlining info, Disassemble() may tag an\n# instruction with a location inside an inlined function. But for\n# source listings, we prefer to use the location in the function we\n# are listing. So use MapToSymbols() to fetch full location\n# information for each instruction and then pick out the first\n# location from a location list (location list contains callers before\n# callees in case of inlining).\n#\n# After this routine has run, each entry in $instructions contains:\n# [0] start address\n# [1] filename for function we are listing\n# [2] line number for function we are listing\n# [3] disassembly\n# [4] limit address\n# [5] most specific filename (may be different from [1] due to inlining)\n# [6] most specific line number (may be different from [2] due to inlining)\nsub GetTopLevelLineNumbers {\n my ($lib, $offset, $instructions) = @_;\n my $pcs = [];\n for (my $i = 0; $i <= $#{$instructions}; $i++) {\n push(@{$pcs}, $instructions->[$i]->[0]);\n }\n my $symbols = {};\n MapToSymbols($lib, $offset, $pcs, $symbols);\n for (my $i = 0; $i <= $#{$instructions}; $i++) {\n my $e = $instructions->[$i];\n push(@{$e}, $e->[1]);\n push(@{$e}, $e->[2]);\n my $addr = $e->[0];\n my $sym = $symbols->{$addr};\n if (defined($sym)) {\n if ($#{$sym} >= 2 && $sym->[1] =~ m/^(.*):(\\d+)$/) {\n $e->[1] = $1; # File name\n $e->[2] = $2; # Line number\n }\n }\n }\n}\n\n# Print source-listing for one routine\nsub PrintSource {\n my $prog = shift;\n my $offset = shift;\n my $routine = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $start_addr = shift;\n my $end_addr = shift;\n my $html = shift;\n my $output = shift;\n\n # Disassemble all instructions (just to get line numbers)\n my @instructions = Disassemble($prog, $offset, $start_addr, $end_addr);\n GetTopLevelLineNumbers($prog, $offset, \\@instructions);\n\n # Hack 1: assume that the first source file encountered in the\n # disassembly contains the routine\n my $filename = undef;\n for (my $i = 0; $i <= $#instructions; $i++) {\n if ($instructions[$i]->[2] >= 0) {\n $filename = $instructions[$i]->[1];\n last;\n }\n }\n if (!defined($filename)) {\n print STDERR \"no filename found in $routine\\n\";\n return 0;\n }\n\n # Hack 2: assume that the largest line number from $filename is the\n # end of the procedure. This is typically safe since if P1 contains\n # an inlined call to P2, then P2 usually occurs earlier in the\n # source file. If this does not work, we might have to compute a\n # density profile or just print all regions we find.\n my $lastline = 0;\n for (my $i = 0; $i <= $#instructions; $i++) {\n my $f = $instructions[$i]->[1];\n my $l = $instructions[$i]->[2];\n if (($f eq $filename) && ($l > $lastline)) {\n $lastline = $l;\n }\n }\n\n # Hack 3: assume the first source location from \"filename\" is the start of\n # the source code.\n my $firstline = 1;\n for (my $i = 0; $i <= $#instructions; $i++) {\n if ($instructions[$i]->[1] eq $filename) {\n $firstline = $instructions[$i]->[2];\n last;\n }\n }\n\n # Hack 4: Extend last line forward until its indentation is less than\n # the indentation we saw on $firstline\n my $oldlastline = $lastline;\n {\n if (!open(FILE, \"<$filename\")) {\n print STDERR \"$filename: $!\\n\";\n return 0;\n }\n my $l = 0;\n my $first_indentation = -1;\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n $l++;\n my $indent = Indentation($_);\n if ($l >= $firstline) {\n if ($first_indentation < 0 && $indent >= 0) {\n $first_indentation = $indent;\n last if ($first_indentation == 0);\n }\n }\n if ($l >= $lastline && $indent >= 0) {\n if ($indent >= $first_indentation) {\n $lastline = $l+1;\n } else {\n last;\n }\n }\n }\n close(FILE);\n }\n\n # Assign all samples to the range $firstline,$lastline,\n # Hack 4: If an instruction does not occur in the range, its samples\n # are moved to the next instruction that occurs in the range.\n my $samples1 = {}; # Map from line number to flat count\n my $samples2 = {}; # Map from line number to cumulative count\n my $running1 = 0; # Unassigned flat counts\n my $running2 = 0; # Unassigned cumulative counts\n my $total1 = 0; # Total flat counts\n my $total2 = 0; # Total cumulative counts\n my %disasm = (); # Map from line number to disassembly\n my $running_disasm = \"\"; # Unassigned disassembly\n my $skip_marker = \"---\\n\";\n if ($html) {\n $skip_marker = \"\";\n for (my $l = $firstline; $l <= $lastline; $l++) {\n $disasm{$l} = \"\";\n }\n }\n my $last_dis_filename = '';\n my $last_dis_linenum = -1;\n my $last_touched_line = -1; # To detect gaps in disassembly for a line\n foreach my $e (@instructions) {\n # Add up counts for all address that fall inside this instruction\n my $c1 = 0;\n my $c2 = 0;\n for (my $a = $e->[0]; $a lt $e->[4]; $a = AddressInc($a)) {\n $c1 += GetEntry($flat, $a);\n $c2 += GetEntry($cumulative, $a);\n }\n\n if ($html) {\n my $dis = sprintf(\" %6s %6s \\t\\t%8s: %s \",\n HtmlPrintNumber($c1),\n HtmlPrintNumber($c2),\n UnparseAddress($offset, $e->[0]),\n CleanDisassembly($e->[3]));\n\n # Append the most specific source line associated with this instruction\n if (length($dis) < 80) { $dis .= (' ' x (80 - length($dis))) };\n $dis = HtmlEscape($dis);\n my $f = $e->[5];\n my $l = $e->[6];\n if ($f ne $last_dis_filename) {\n $dis .= sprintf(\"%s:%d\",\n HtmlEscape(CleanFileName($f)), $l);\n } elsif ($l ne $last_dis_linenum) {\n # De-emphasize the unchanged file name portion\n $dis .= sprintf(\"%s\" .\n \":%d\",\n HtmlEscape(CleanFileName($f)), $l);\n } else {\n # De-emphasize the entire location\n $dis .= sprintf(\"%s:%d\",\n HtmlEscape(CleanFileName($f)), $l);\n }\n $last_dis_filename = $f;\n $last_dis_linenum = $l;\n $running_disasm .= $dis;\n $running_disasm .= \"\\n\";\n }\n\n $running1 += $c1;\n $running2 += $c2;\n $total1 += $c1;\n $total2 += $c2;\n my $file = $e->[1];\n my $line = $e->[2];\n if (($file eq $filename) &&\n ($line >= $firstline) &&\n ($line <= $lastline)) {\n # Assign all accumulated samples to this line\n AddEntry($samples1, $line, $running1);\n AddEntry($samples2, $line, $running2);\n $running1 = 0;\n $running2 = 0;\n if ($html) {\n if ($line != $last_touched_line && $disasm{$line} ne '') {\n $disasm{$line} .= \"\\n\";\n }\n $disasm{$line} .= $running_disasm;\n $running_disasm = '';\n $last_touched_line = $line;\n }\n }\n }\n\n # Assign any leftover samples to $lastline\n AddEntry($samples1, $lastline, $running1);\n AddEntry($samples2, $lastline, $running2);\n if ($html) {\n if ($lastline != $last_touched_line && $disasm{$lastline} ne '') {\n $disasm{$lastline} .= \"\\n\";\n }\n $disasm{$lastline} .= $running_disasm;\n }\n\n if ($html) {\n printf $output (\n \"

%s

%s\\n
\\n\" .\n      \"Total:%6s %6s (flat / cumulative %s)\\n\",\n      HtmlEscape(ShortFunctionName($routine)),\n      HtmlEscape(CleanFileName($filename)),\n      Unparse($total1),\n      Unparse($total2),\n      Units());\n  } else {\n    printf $output (\n      \"ROUTINE ====================== %s in %s\\n\" .\n      \"%6s %6s Total %s (flat / cumulative)\\n\",\n      ShortFunctionName($routine),\n      CleanFileName($filename),\n      Unparse($total1),\n      Unparse($total2),\n      Units());\n  }\n  if (!open(FILE, \"<$filename\")) {\n    print STDERR \"$filename: $!\\n\";\n    return 0;\n  }\n  my $l = 0;\n  while () {\n    s/\\r//g;         # turn windows-looking lines into unix-looking lines\n    $l++;\n    if ($l >= $firstline - 5 &&\n        (($l <= $oldlastline + 5) || ($l <= $lastline))) {\n      chop;\n      my $text = $_;\n      if ($l == $firstline) { print $output $skip_marker; }\n      my $n1 = GetEntry($samples1, $l);\n      my $n2 = GetEntry($samples2, $l);\n      if ($html) {\n        # Emit a span that has one of the following classes:\n        #    livesrc -- has samples\n        #    deadsrc -- has disassembly, but with no samples\n        #    nop     -- has no matching disasembly\n        # Also emit an optional span containing disassembly.\n        my $dis = $disasm{$l};\n        my $asm = \"\";\n        if (defined($dis) && $dis ne '') {\n          $asm = \"\" . $dis . \"\";\n        }\n        my $source_class = (($n1 + $n2 > 0)\n                            ? \"livesrc\"\n                            : (($asm ne \"\") ? \"deadsrc\" : \"nop\"));\n        printf $output (\n          \"%5d \" .\n          \"%6s %6s %s%s\\n\",\n          $l, $source_class,\n          HtmlPrintNumber($n1),\n          HtmlPrintNumber($n2),\n          HtmlEscape($text),\n          $asm);\n      } else {\n        printf $output(\n          \"%6s %6s %4d: %s\\n\",\n          UnparseAlt($n1),\n          UnparseAlt($n2),\n          $l,\n          $text);\n      }\n      if ($l == $lastline)  { print $output $skip_marker; }\n    };\n  }\n  close(FILE);\n  if ($html) {\n    print $output \"
\\n\";\n }\n return 1;\n}\n\n# Return the source line for the specified file/linenumber.\n# Returns undef if not found.\nsub SourceLine {\n my $file = shift;\n my $line = shift;\n\n # Look in cache\n if (!defined($main::source_cache{$file})) {\n if (100 < scalar keys(%main::source_cache)) {\n # Clear the cache when it gets too big\n $main::source_cache = ();\n }\n\n # Read all lines from the file\n if (!open(FILE, \"<$file\")) {\n print STDERR \"$file: $!\\n\";\n $main::source_cache{$file} = []; # Cache the negative result\n return undef;\n }\n my $lines = [];\n push(@{$lines}, \"\"); # So we can use 1-based line numbers as indices\n while () {\n push(@{$lines}, $_);\n }\n close(FILE);\n\n # Save the lines in the cache\n $main::source_cache{$file} = $lines;\n }\n\n my $lines = $main::source_cache{$file};\n if (($line < 0) || ($line > $#{$lines})) {\n return undef;\n } else {\n return $lines->[$line];\n }\n}\n\n# Print disassembly for one routine with interspersed source if available\nsub PrintDisassembledFunction {\n my $prog = shift;\n my $offset = shift;\n my $routine = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $start_addr = shift;\n my $end_addr = shift;\n my $total = shift;\n\n # Disassemble all instructions\n my @instructions = Disassemble($prog, $offset, $start_addr, $end_addr);\n\n # Make array of counts per instruction\n my @flat_count = ();\n my @cum_count = ();\n my $flat_total = 0;\n my $cum_total = 0;\n foreach my $e (@instructions) {\n # Add up counts for all address that fall inside this instruction\n my $c1 = 0;\n my $c2 = 0;\n for (my $a = $e->[0]; $a lt $e->[4]; $a = AddressInc($a)) {\n $c1 += GetEntry($flat, $a);\n $c2 += GetEntry($cumulative, $a);\n }\n push(@flat_count, $c1);\n push(@cum_count, $c2);\n $flat_total += $c1;\n $cum_total += $c2;\n }\n\n # Print header with total counts\n printf(\"ROUTINE ====================== %s\\n\" .\n \"%6s %6s %s (flat, cumulative) %.1f%% of total\\n\",\n ShortFunctionName($routine),\n Unparse($flat_total),\n Unparse($cum_total),\n Units(),\n ($cum_total * 100.0) / $total);\n\n # Process instructions in order\n my $current_file = \"\";\n for (my $i = 0; $i <= $#instructions; ) {\n my $e = $instructions[$i];\n\n # Print the new file name whenever we switch files\n if ($e->[1] ne $current_file) {\n $current_file = $e->[1];\n my $fname = $current_file;\n $fname =~ s|^\\./||; # Trim leading \"./\"\n\n # Shorten long file names\n if (length($fname) >= 58) {\n $fname = \"...\" . substr($fname, -55);\n }\n printf(\"-------------------- %s\\n\", $fname);\n }\n\n # TODO: Compute range of lines to print together to deal with\n # small reorderings.\n my $first_line = $e->[2];\n my $last_line = $first_line;\n my %flat_sum = ();\n my %cum_sum = ();\n for (my $l = $first_line; $l <= $last_line; $l++) {\n $flat_sum{$l} = 0;\n $cum_sum{$l} = 0;\n }\n\n # Find run of instructions for this range of source lines\n my $first_inst = $i;\n while (($i <= $#instructions) &&\n ($instructions[$i]->[2] >= $first_line) &&\n ($instructions[$i]->[2] <= $last_line)) {\n $e = $instructions[$i];\n $flat_sum{$e->[2]} += $flat_count[$i];\n $cum_sum{$e->[2]} += $cum_count[$i];\n $i++;\n }\n my $last_inst = $i - 1;\n\n # Print source lines\n for (my $l = $first_line; $l <= $last_line; $l++) {\n my $line = SourceLine($current_file, $l);\n if (!defined($line)) {\n $line = \"?\\n\";\n next;\n } else {\n $line =~ s/^\\s+//;\n }\n printf(\"%6s %6s %5d: %s\",\n UnparseAlt($flat_sum{$l}),\n UnparseAlt($cum_sum{$l}),\n $l,\n $line);\n }\n\n # Print disassembly\n for (my $x = $first_inst; $x <= $last_inst; $x++) {\n my $e = $instructions[$x];\n printf(\"%6s %6s %8s: %6s\\n\",\n UnparseAlt($flat_count[$x]),\n UnparseAlt($cum_count[$x]),\n UnparseAddress($offset, $e->[0]),\n CleanDisassembly($e->[3]));\n }\n }\n}\n\n# Print DOT graph\nsub PrintDot {\n my $prog = shift;\n my $symbols = shift;\n my $raw = shift;\n my $flat = shift;\n my $cumulative = shift;\n my $overall_total = shift;\n\n # Get total\n my $local_total = TotalProfile($flat);\n my $nodelimit = int($main::opt_nodefraction * $local_total);\n my $edgelimit = int($main::opt_edgefraction * $local_total);\n my $nodecount = $main::opt_nodecount;\n\n # Find nodes to include\n my @list = (sort { abs(GetEntry($cumulative, $b)) <=>\n abs(GetEntry($cumulative, $a))\n || $a cmp $b }\n keys(%{$cumulative}));\n my $last = $nodecount - 1;\n if ($last > $#list) {\n $last = $#list;\n }\n while (($last >= 0) &&\n (abs(GetEntry($cumulative, $list[$last])) <= $nodelimit)) {\n $last--;\n }\n if ($last < 0) {\n print STDERR \"No nodes to print\\n\";\n return 0;\n }\n\n if ($nodelimit > 0 || $edgelimit > 0) {\n printf STDERR (\"Dropping nodes with <= %s %s; edges with <= %s abs(%s)\\n\",\n Unparse($nodelimit), Units(),\n Unparse($edgelimit), Units());\n }\n\n # Open DOT output file\n my $output;\n my $escaped_dot = ShellEscape(@DOT);\n my $escaped_ps2pdf = ShellEscape(@PS2PDF);\n if ($main::opt_gv) {\n my $escaped_outfile = ShellEscape(TempName($main::next_tmpfile, \"ps\"));\n $output = \"| $escaped_dot -Tps2 >$escaped_outfile\";\n } elsif ($main::opt_evince) {\n my $escaped_outfile = ShellEscape(TempName($main::next_tmpfile, \"pdf\"));\n $output = \"| $escaped_dot -Tps2 | $escaped_ps2pdf - $escaped_outfile\";\n } elsif ($main::opt_ps) {\n $output = \"| $escaped_dot -Tps2\";\n } elsif ($main::opt_pdf) {\n $output = \"| $escaped_dot -Tps2 | $escaped_ps2pdf - -\";\n } elsif ($main::opt_web || $main::opt_svg) {\n # We need to post-process the SVG, so write to a temporary file always.\n my $escaped_outfile = ShellEscape(TempName($main::next_tmpfile, \"svg\"));\n $output = \"| $escaped_dot -Tsvg >$escaped_outfile\";\n } elsif ($main::opt_gif) {\n $output = \"| $escaped_dot -Tgif\";\n } else {\n $output = \">&STDOUT\";\n }\n open(DOT, $output) || error(\"$output: $!\\n\");\n\n # Title\n printf DOT (\"digraph \\\"%s; %s %s\\\" {\\n\",\n $prog,\n Unparse($overall_total),\n Units());\n if ($main::opt_pdf) {\n # The output is more printable if we set the page size for dot.\n printf DOT (\"size=\\\"8,11\\\"\\n\");\n }\n printf DOT (\"node [width=0.375,height=0.25];\\n\");\n\n # Print legend\n printf DOT (\"Legend [shape=box,fontsize=24,shape=plaintext,\" .\n \"label=\\\"%s\\\\l%s\\\\l%s\\\\l%s\\\\l%s\\\\l\\\"];\\n\",\n $prog,\n sprintf(\"Total %s: %s\", Units(), Unparse($overall_total)),\n sprintf(\"Focusing on: %s\", Unparse($local_total)),\n sprintf(\"Dropped nodes with <= %s abs(%s)\",\n Unparse($nodelimit), Units()),\n sprintf(\"Dropped edges with <= %s %s\",\n Unparse($edgelimit), Units())\n );\n\n # Print nodes\n my %node = ();\n my $nextnode = 1;\n foreach my $a (@list[0..$last]) {\n # Pick font size\n my $f = GetEntry($flat, $a);\n my $c = GetEntry($cumulative, $a);\n\n my $fs = 8;\n if ($local_total > 0) {\n $fs = 8 + (50.0 * sqrt(abs($f * 1.0 / $local_total)));\n }\n\n $node{$a} = $nextnode++;\n my $sym = $a;\n $sym =~ s/\\s+/\\\\n/g;\n $sym =~ s/::/\\\\n/g;\n\n # Extra cumulative info to print for non-leaves\n my $extra = \"\";\n if ($f != $c) {\n $extra = sprintf(\"\\\\rof %s (%s)\",\n Unparse($c),\n Percent($c, $local_total));\n }\n my $style = \"\";\n if ($main::opt_heapcheck) {\n if ($f > 0) {\n # make leak-causing nodes more visible (add a background)\n $style = \",style=filled,fillcolor=gray\"\n } elsif ($f < 0) {\n # make anti-leak-causing nodes (which almost never occur)\n # stand out as well (triple border)\n $style = \",peripheries=3\"\n }\n }\n\n printf DOT (\"N%d [label=\\\"%s\\\\n%s (%s)%s\\\\r\" .\n \"\\\",shape=box,fontsize=%.1f%s];\\n\",\n $node{$a},\n $sym,\n Unparse($f),\n Percent($f, $local_total),\n $extra,\n $fs,\n $style,\n );\n }\n\n # Get edges and counts per edge\n my %edge = ();\n my $n;\n my $fullname_to_shortname_map = {};\n FillFullnameToShortnameMap($symbols, $fullname_to_shortname_map);\n foreach my $k (keys(%{$raw})) {\n # TODO: omit low %age edges\n $n = $raw->{$k};\n my @translated = TranslateStack($symbols, $fullname_to_shortname_map, $k);\n for (my $i = 1; $i <= $#translated; $i++) {\n my $src = $translated[$i];\n my $dst = $translated[$i-1];\n #next if ($src eq $dst); # Avoid self-edges?\n if (exists($node{$src}) && exists($node{$dst})) {\n my $edge_label = \"$src\\001$dst\";\n if (!exists($edge{$edge_label})) {\n $edge{$edge_label} = 0;\n }\n $edge{$edge_label} += $n;\n }\n }\n }\n\n # Print edges (process in order of decreasing counts)\n my %indegree = (); # Number of incoming edges added per node so far\n my %outdegree = (); # Number of outgoing edges added per node so far\n foreach my $e (sort { $edge{$b} <=> $edge{$a} } keys(%edge)) {\n my @x = split(/\\001/, $e);\n $n = $edge{$e};\n\n # Initialize degree of kept incoming and outgoing edges if necessary\n my $src = $x[0];\n my $dst = $x[1];\n if (!exists($outdegree{$src})) { $outdegree{$src} = 0; }\n if (!exists($indegree{$dst})) { $indegree{$dst} = 0; }\n\n my $keep;\n if ($indegree{$dst} == 0) {\n # Keep edge if needed for reachability\n $keep = 1;\n } elsif (abs($n) <= $edgelimit) {\n # Drop if we are below --edgefraction\n $keep = 0;\n } elsif ($outdegree{$src} >= $main::opt_maxdegree ||\n $indegree{$dst} >= $main::opt_maxdegree) {\n # Keep limited number of in/out edges per node\n $keep = 0;\n } else {\n $keep = 1;\n }\n\n if ($keep) {\n $outdegree{$src}++;\n $indegree{$dst}++;\n\n # Compute line width based on edge count\n my $fraction = abs($local_total ? (3 * ($n / $local_total)) : 0);\n if ($fraction > 1) { $fraction = 1; }\n my $w = $fraction * 2;\n if ($w < 1 && ($main::opt_web || $main::opt_svg)) {\n # SVG output treats line widths < 1 poorly.\n $w = 1;\n }\n\n # Dot sometimes segfaults if given edge weights that are too large, so\n # we cap the weights at a large value\n my $edgeweight = abs($n) ** 0.7;\n if ($edgeweight > 100000) { $edgeweight = 100000; }\n $edgeweight = int($edgeweight);\n\n my $style = sprintf(\"setlinewidth(%f)\", $w);\n if ($x[1] =~ m/\\(inline\\)/) {\n $style .= \",dashed\";\n }\n\n # Use a slightly squashed function of the edge count as the weight\n printf DOT (\"N%s -> N%s [label=%s, weight=%d, style=\\\"%s\\\"];\\n\",\n $node{$x[0]},\n $node{$x[1]},\n Unparse($n),\n $edgeweight,\n $style);\n }\n }\n\n print DOT (\"}\\n\");\n close(DOT);\n\n if ($main::opt_web || $main::opt_svg) {\n # Rewrite SVG to be more usable inside web browser.\n RewriteSvg(TempName($main::next_tmpfile, \"svg\"));\n }\n\n return 1;\n}\n\nsub RewriteSvg {\n my $svgfile = shift;\n\n open(SVG, $svgfile) || die \"open temp svg: $!\";\n my @svg = ;\n close(SVG);\n unlink $svgfile;\n my $svg = join('', @svg);\n\n # Dot's SVG output is\n #\n # \n # \n # ...\n # \n # \n #\n # Change it to\n #\n # \n # $svg_javascript\n # \n # \n # ...\n # \n # \n # \n\n # Fix width, height; drop viewBox.\n $svg =~ s/(?s) above first \n my $svg_javascript = SvgJavascript();\n my $viewport = \"\\n\";\n $svg =~ s/ above .\n $svg =~ s/(.*)(<\\/svg>)/$1<\\/g>$2/;\n $svg =~ s/$svgfile\") || die \"open $svgfile: $!\";\n print SVG $svg;\n close(SVG);\n }\n}\n\nsub SvgJavascript {\n return <<'EOF';\n\nEOF\n}\n\n# Provides a map from fullname to shortname for cases where the\n# shortname is ambiguous. The symlist has both the fullname and\n# shortname for all symbols, which is usually fine, but sometimes --\n# such as overloaded functions -- two different fullnames can map to\n# the same shortname. In that case, we use the address of the\n# function to disambiguate the two. This function fills in a map that\n# maps fullnames to modified shortnames in such cases. If a fullname\n# is not present in the map, the 'normal' shortname provided by the\n# symlist is the appropriate one to use.\nsub FillFullnameToShortnameMap {\n my $symbols = shift;\n my $fullname_to_shortname_map = shift;\n my $shortnames_seen_once = {};\n my $shortnames_seen_more_than_once = {};\n\n foreach my $symlist (values(%{$symbols})) {\n # TODO(csilvers): deal with inlined symbols too.\n my $shortname = $symlist->[0];\n my $fullname = $symlist->[2];\n if ($fullname !~ /<[0-9a-fA-F]+>$/) { # fullname doesn't end in an address\n next; # the only collisions we care about are when addresses differ\n }\n if (defined($shortnames_seen_once->{$shortname}) &&\n $shortnames_seen_once->{$shortname} ne $fullname) {\n $shortnames_seen_more_than_once->{$shortname} = 1;\n } else {\n $shortnames_seen_once->{$shortname} = $fullname;\n }\n }\n\n foreach my $symlist (values(%{$symbols})) {\n my $shortname = $symlist->[0];\n my $fullname = $symlist->[2];\n # TODO(csilvers): take in a list of addresses we care about, and only\n # store in the map if $symlist->[1] is in that list. Saves space.\n next if defined($fullname_to_shortname_map->{$fullname});\n if (defined($shortnames_seen_more_than_once->{$shortname})) {\n if ($fullname =~ /<0*([^>]*)>$/) { # fullname has address at end of it\n $fullname_to_shortname_map->{$fullname} = \"$shortname\\@$1\";\n }\n }\n }\n}\n\n# Return a small number that identifies the argument.\n# Multiple calls with the same argument will return the same number.\n# Calls with different arguments will return different numbers.\nsub ShortIdFor {\n my $key = shift;\n my $id = $main::uniqueid{$key};\n if (!defined($id)) {\n $id = keys(%main::uniqueid) + 1;\n $main::uniqueid{$key} = $id;\n }\n return $id;\n}\n\n# Translate a stack of addresses into a stack of symbols\nsub TranslateStack {\n my $symbols = shift;\n my $fullname_to_shortname_map = shift;\n my $k = shift;\n\n my @addrs = split(/\\n/, $k);\n my @result = ();\n for (my $i = 0; $i <= $#addrs; $i++) {\n my $a = $addrs[$i];\n\n # Skip large addresses since they sometimes show up as fake entries on RH9\n if (length($a) > 8 && $a gt \"7fffffffffffffff\") {\n next;\n }\n\n if ($main::opt_disasm || $main::opt_list) {\n # We want just the address for the key\n push(@result, $a);\n next;\n }\n\n my $symlist = $symbols->{$a};\n if (!defined($symlist)) {\n $symlist = [$a, \"\", $a];\n }\n\n # We can have a sequence of symbols for a particular entry\n # (more than one symbol in the case of inlining). Callers\n # come before callees in symlist, so walk backwards since\n # the translated stack should contain callees before callers.\n for (my $j = $#{$symlist}; $j >= 2; $j -= 3) {\n my $func = $symlist->[$j-2];\n my $fileline = $symlist->[$j-1];\n my $fullfunc = $symlist->[$j];\n if (defined($fullname_to_shortname_map->{$fullfunc})) {\n $func = $fullname_to_shortname_map->{$fullfunc};\n }\n if ($j > 2) {\n $func = \"$func (inline)\";\n }\n\n # Do not merge nodes corresponding to Callback::Run since that\n # causes confusing cycles in dot display. Instead, we synthesize\n # a unique name for this frame per caller.\n if ($func =~ m/Callback.*::Run$/) {\n my $caller = ($i > 0) ? $addrs[$i-1] : 0;\n $func = \"Run#\" . ShortIdFor($caller);\n }\n\n if ($main::opt_addresses) {\n push(@result, \"$a $func $fileline\");\n } elsif ($main::opt_lines) {\n if ($func eq '??' && $fileline eq '??:0') {\n push(@result, \"$a\");\n } else {\n push(@result, \"$func $fileline\");\n }\n } elsif ($main::opt_functions) {\n if ($func eq '??') {\n push(@result, \"$a\");\n } else {\n push(@result, $func);\n }\n } elsif ($main::opt_files) {\n if ($fileline eq '??:0' || $fileline eq '') {\n push(@result, \"$a\");\n } else {\n my $f = $fileline;\n $f =~ s/:\\d+$//;\n push(@result, $f);\n }\n } else {\n push(@result, $a);\n last; # Do not print inlined info\n }\n }\n }\n\n # print join(\",\", @addrs), \" => \", join(\",\", @result), \"\\n\";\n return @result;\n}\n\n# Generate percent string for a number and a total\nsub Percent {\n my $num = shift;\n my $tot = shift;\n if ($tot != 0) {\n return sprintf(\"%.1f%%\", $num * 100.0 / $tot);\n } else {\n return ($num == 0) ? \"nan\" : (($num > 0) ? \"+inf\" : \"-inf\");\n }\n}\n\n# Generate pretty-printed form of number\nsub Unparse {\n my $num = shift;\n if ($main::profile_type eq 'heap' || $main::profile_type eq 'growth') {\n if ($main::opt_inuse_objects || $main::opt_alloc_objects) {\n return sprintf(\"%d\", $num);\n } else {\n if ($main::opt_show_bytes) {\n return sprintf(\"%d\", $num);\n } else {\n return sprintf(\"%.1f\", $num / 1048576.0);\n }\n }\n } elsif ($main::profile_type eq 'contention' && !$main::opt_contentions) {\n return sprintf(\"%.3f\", $num / 1e9); # Convert nanoseconds to seconds\n } else {\n return sprintf(\"%d\", $num);\n }\n}\n\n# Alternate pretty-printed form: 0 maps to \".\"\nsub UnparseAlt {\n my $num = shift;\n if ($num == 0) {\n return \".\";\n } else {\n return Unparse($num);\n }\n}\n\n# Alternate pretty-printed form: 0 maps to \"\"\nsub HtmlPrintNumber {\n my $num = shift;\n if ($num == 0) {\n return \"\";\n } else {\n return Unparse($num);\n }\n}\n\n# Return output units\nsub Units {\n if ($main::profile_type eq 'heap' || $main::profile_type eq 'growth') {\n if ($main::opt_inuse_objects || $main::opt_alloc_objects) {\n return \"objects\";\n } else {\n if ($main::opt_show_bytes) {\n return \"B\";\n } else {\n return \"MB\";\n }\n }\n } elsif ($main::profile_type eq 'contention' && !$main::opt_contentions) {\n return \"seconds\";\n } else {\n return \"samples\";\n }\n}\n\n##### Profile manipulation code #####\n\n# Generate flattened profile:\n# If count is charged to stack [a,b,c,d], in generated profile,\n# it will be charged to [a]\nsub FlatProfile {\n my $profile = shift;\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n if ($#addrs >= 0) {\n AddEntry($result, $addrs[0], $count);\n }\n }\n return $result;\n}\n\n# Generate cumulative profile:\n# If count is charged to stack [a,b,c,d], in generated profile,\n# it will be charged to [a], [b], [c], [d]\nsub CumulativeProfile {\n my $profile = shift;\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n foreach my $a (@addrs) {\n AddEntry($result, $a, $count);\n }\n }\n return $result;\n}\n\n# If the second-youngest PC on the stack is always the same, returns\n# that pc. Otherwise, returns undef.\nsub IsSecondPcAlwaysTheSame {\n my $profile = shift;\n\n my $second_pc = undef;\n foreach my $k (keys(%{$profile})) {\n my @addrs = split(/\\n/, $k);\n if ($#addrs < 1) {\n return undef;\n }\n if (not defined $second_pc) {\n $second_pc = $addrs[1];\n } else {\n if ($second_pc ne $addrs[1]) {\n return undef;\n }\n }\n }\n return $second_pc;\n}\n\nsub ExtractSymbolNameInlineStack {\n my $symbols = shift;\n my $address = shift;\n\n my @stack = ();\n\n if (exists $symbols->{$address}) {\n my @localinlinestack = @{$symbols->{$address}};\n for (my $i = $#localinlinestack; $i > 0; $i-=3) {\n my $file = $localinlinestack[$i-1];\n my $fn = $localinlinestack[$i-0];\n\n if ($file eq \"?\" || $file eq \":0\") {\n $file = \"??:0\";\n }\n if ($fn eq '??') {\n # If we can't get the symbol name, at least use the file information.\n $fn = $file;\n }\n my $suffix = \"[inline]\";\n if ($i == 2) {\n $suffix = \"\";\n }\n push (@stack, $fn.$suffix);\n }\n }\n else {\n # If we can't get a symbol name, at least fill in the address.\n push (@stack, $address);\n }\n\n return @stack;\n}\n\nsub ExtractSymbolLocation {\n my $symbols = shift;\n my $address = shift;\n # 'addr2line' outputs \"??:0\" for unknown locations; we do the\n # same to be consistent.\n my $location = \"??:0:unknown\";\n if (exists $symbols->{$address}) {\n my $file = $symbols->{$address}->[1];\n if ($file eq \"?\") {\n $file = \"??:0\"\n }\n $location = $file . \":\" . $symbols->{$address}->[0];\n }\n return $location;\n}\n\n# Extracts a graph of calls.\nsub ExtractCalls {\n my $symbols = shift;\n my $profile = shift;\n\n my $calls = {};\n while( my ($stack_trace, $count) = each %$profile ) {\n my @address = split(/\\n/, $stack_trace);\n my $destination = ExtractSymbolLocation($symbols, $address[0]);\n AddEntry($calls, $destination, $count);\n for (my $i = 1; $i <= $#address; $i++) {\n my $source = ExtractSymbolLocation($symbols, $address[$i]);\n my $call = \"$source -> $destination\";\n AddEntry($calls, $call, $count);\n $destination = $source;\n }\n }\n\n return $calls;\n}\n\nsub FilterFrames {\n my $symbols = shift;\n my $profile = shift;\n\n if ($main::opt_retain eq '' && $main::opt_exclude eq '') {\n return $profile;\n }\n\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n my @path = ();\n foreach my $a (@addrs) {\n my $sym;\n if (exists($symbols->{$a})) {\n $sym = $symbols->{$a}->[0];\n } else {\n $sym = $a;\n }\n if ($main::opt_retain ne '' && $sym !~ m/$main::opt_retain/) {\n next;\n }\n if ($main::opt_exclude ne '' && $sym =~ m/$main::opt_exclude/) {\n next;\n }\n push(@path, $a);\n }\n if (scalar(@path) > 0) {\n my $reduced_path = join(\"\\n\", @path);\n AddEntry($result, $reduced_path, $count);\n }\n }\n\n return $result;\n}\n\nsub PrintCollapsedStacks {\n my $symbols = shift;\n my $profile = shift;\n\n while (my ($stack_trace, $count) = each %$profile) {\n my @address = split(/\\n/, $stack_trace);\n my @names = reverse ( map { ExtractSymbolNameInlineStack($symbols, $_) } @address );\n printf(\"%s %d\\n\", join(\";\", @names), $count);\n }\n}\n\nsub RemoveUninterestingFrames {\n my $symbols = shift;\n my $profile = shift;\n\n # List of function names to skip\n my %skip = ();\n my $skip_regexp = 'NOMATCH';\n if ($main::profile_type eq 'heap' || $main::profile_type eq 'growth') {\n foreach my $name ('@JEMALLOC_PREFIX@calloc',\n 'cfree',\n '@JEMALLOC_PREFIX@malloc',\n 'newImpl',\n 'void* newImpl',\n '@JEMALLOC_PREFIX@free',\n '@JEMALLOC_PREFIX@memalign',\n '@JEMALLOC_PREFIX@posix_memalign',\n '@JEMALLOC_PREFIX@aligned_alloc',\n 'pvalloc',\n '@JEMALLOC_PREFIX@valloc',\n '@JEMALLOC_PREFIX@realloc',\n '@JEMALLOC_PREFIX@mallocx',\n '@JEMALLOC_PREFIX@rallocx',\n '@JEMALLOC_PREFIX@xallocx',\n '@JEMALLOC_PREFIX@dallocx',\n '@JEMALLOC_PREFIX@sdallocx',\n '@JEMALLOC_PREFIX@sdallocx_noflags',\n 'tc_calloc',\n 'tc_cfree',\n 'tc_malloc',\n 'tc_free',\n 'tc_memalign',\n 'tc_posix_memalign',\n 'tc_pvalloc',\n 'tc_valloc',\n 'tc_realloc',\n 'tc_new',\n 'tc_delete',\n 'tc_newarray',\n 'tc_deletearray',\n 'tc_new_nothrow',\n 'tc_newarray_nothrow',\n 'do_malloc',\n '::do_malloc', # new name -- got moved to an unnamed ns\n '::do_malloc_or_cpp_alloc',\n 'DoSampledAllocation',\n 'simple_alloc::allocate',\n '__malloc_alloc_template::allocate',\n '__builtin_delete',\n '__builtin_new',\n '__builtin_vec_delete',\n '__builtin_vec_new',\n 'operator new',\n 'operator new[]',\n # The entry to our memory-allocation routines on OS X\n 'malloc_zone_malloc',\n 'malloc_zone_calloc',\n 'malloc_zone_valloc',\n 'malloc_zone_realloc',\n 'malloc_zone_memalign',\n 'malloc_zone_free',\n # These mark the beginning/end of our custom sections\n '__start_google_malloc',\n '__stop_google_malloc',\n '__start_malloc_hook',\n '__stop_malloc_hook') {\n $skip{$name} = 1;\n $skip{\"_\" . $name} = 1; # Mach (OS X) adds a _ prefix to everything\n }\n # TODO: Remove TCMalloc once everything has been\n # moved into the tcmalloc:: namespace and we have flushed\n # old code out of the system.\n $skip_regexp = \"TCMalloc|^tcmalloc::\";\n } elsif ($main::profile_type eq 'contention') {\n foreach my $vname ('base::RecordLockProfileData',\n 'base::SubmitMutexProfileData',\n 'base::SubmitSpinLockProfileData',\n 'Mutex::Unlock',\n 'Mutex::UnlockSlow',\n 'Mutex::ReaderUnlock',\n 'MutexLock::~MutexLock',\n 'SpinLock::Unlock',\n 'SpinLock::SlowUnlock',\n 'SpinLockHolder::~SpinLockHolder') {\n $skip{$vname} = 1;\n }\n } elsif ($main::profile_type eq 'cpu') {\n # Drop signal handlers used for CPU profile collection\n # TODO(dpeng): this should not be necessary; it's taken\n # care of by the general 2nd-pc mechanism below.\n foreach my $name ('ProfileData::Add', # historical\n 'ProfileData::prof_handler', # historical\n 'CpuProfiler::prof_handler',\n '__FRAME_END__',\n '__pthread_sighandler',\n '__restore') {\n $skip{$name} = 1;\n }\n } else {\n # Nothing skipped for unknown types\n }\n\n if ($main::profile_type eq 'cpu') {\n # If all the second-youngest program counters are the same,\n # this STRONGLY suggests that it is an artifact of measurement,\n # i.e., stack frames pushed by the CPU profiler signal handler.\n # Hence, we delete them.\n # (The topmost PC is read from the signal structure, not from\n # the stack, so it does not get involved.)\n while (my $second_pc = IsSecondPcAlwaysTheSame($profile)) {\n my $result = {};\n my $func = '';\n if (exists($symbols->{$second_pc})) {\n $second_pc = $symbols->{$second_pc}->[0];\n }\n print STDERR \"Removing $second_pc from all stack traces.\\n\";\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n splice @addrs, 1, 1;\n my $reduced_path = join(\"\\n\", @addrs);\n AddEntry($result, $reduced_path, $count);\n }\n $profile = $result;\n }\n }\n\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n my @path = ();\n foreach my $a (@addrs) {\n if (exists($symbols->{$a})) {\n my $func = $symbols->{$a}->[0];\n if ($skip{$func} || ($func =~ m/$skip_regexp/)) {\n # Throw away the portion of the backtrace seen so far, under the\n # assumption that previous frames were for functions internal to the\n # allocator.\n @path = ();\n next;\n }\n }\n push(@path, $a);\n }\n my $reduced_path = join(\"\\n\", @path);\n AddEntry($result, $reduced_path, $count);\n }\n\n $result = FilterFrames($symbols, $result);\n\n return $result;\n}\n\n# Reduce profile to granularity given by user\nsub ReduceProfile {\n my $symbols = shift;\n my $profile = shift;\n my $result = {};\n my $fullname_to_shortname_map = {};\n FillFullnameToShortnameMap($symbols, $fullname_to_shortname_map);\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @translated = TranslateStack($symbols, $fullname_to_shortname_map, $k);\n my @path = ();\n my %seen = ();\n $seen{''} = 1; # So that empty keys are skipped\n foreach my $e (@translated) {\n # To avoid double-counting due to recursion, skip a stack-trace\n # entry if it has already been seen\n if (!$seen{$e}) {\n $seen{$e} = 1;\n push(@path, $e);\n }\n }\n my $reduced_path = join(\"\\n\", @path);\n AddEntry($result, $reduced_path, $count);\n }\n return $result;\n}\n\n# Does the specified symbol array match the regexp?\nsub SymbolMatches {\n my $sym = shift;\n my $re = shift;\n if (defined($sym)) {\n for (my $i = 0; $i < $#{$sym}; $i += 3) {\n if ($sym->[$i] =~ m/$re/ || $sym->[$i+1] =~ m/$re/) {\n return 1;\n }\n }\n }\n return 0;\n}\n\n# Focus only on paths involving specified regexps\nsub FocusProfile {\n my $symbols = shift;\n my $profile = shift;\n my $focus = shift;\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n foreach my $a (@addrs) {\n # Reply if it matches either the address/shortname/fileline\n if (($a =~ m/$focus/) || SymbolMatches($symbols->{$a}, $focus)) {\n AddEntry($result, $k, $count);\n last;\n }\n }\n }\n return $result;\n}\n\n# Focus only on paths not involving specified regexps\nsub IgnoreProfile {\n my $symbols = shift;\n my $profile = shift;\n my $ignore = shift;\n my $result = {};\n foreach my $k (keys(%{$profile})) {\n my $count = $profile->{$k};\n my @addrs = split(/\\n/, $k);\n my $matched = 0;\n foreach my $a (@addrs) {\n # Reply if it matches either the address/shortname/fileline\n if (($a =~ m/$ignore/) || SymbolMatches($symbols->{$a}, $ignore)) {\n $matched = 1;\n last;\n }\n }\n if (!$matched) {\n AddEntry($result, $k, $count);\n }\n }\n return $result;\n}\n\n# Get total count in profile\nsub TotalProfile {\n my $profile = shift;\n my $result = 0;\n foreach my $k (keys(%{$profile})) {\n $result += $profile->{$k};\n }\n return $result;\n}\n\n# Add A to B\nsub AddProfile {\n my $A = shift;\n my $B = shift;\n\n my $R = {};\n # add all keys in A\n foreach my $k (keys(%{$A})) {\n my $v = $A->{$k};\n AddEntry($R, $k, $v);\n }\n # add all keys in B\n foreach my $k (keys(%{$B})) {\n my $v = $B->{$k};\n AddEntry($R, $k, $v);\n }\n return $R;\n}\n\n# Merges symbol maps\nsub MergeSymbols {\n my $A = shift;\n my $B = shift;\n\n my $R = {};\n foreach my $k (keys(%{$A})) {\n $R->{$k} = $A->{$k};\n }\n if (defined($B)) {\n foreach my $k (keys(%{$B})) {\n $R->{$k} = $B->{$k};\n }\n }\n return $R;\n}\n\n\n# Add A to B\nsub AddPcs {\n my $A = shift;\n my $B = shift;\n\n my $R = {};\n # add all keys in A\n foreach my $k (keys(%{$A})) {\n $R->{$k} = 1\n }\n # add all keys in B\n foreach my $k (keys(%{$B})) {\n $R->{$k} = 1\n }\n return $R;\n}\n\n# Subtract B from A\nsub SubtractProfile {\n my $A = shift;\n my $B = shift;\n\n my $R = {};\n foreach my $k (keys(%{$A})) {\n my $v = $A->{$k} - GetEntry($B, $k);\n if ($v < 0 && $main::opt_drop_negative) {\n $v = 0;\n }\n AddEntry($R, $k, $v);\n }\n if (!$main::opt_drop_negative) {\n # Take care of when subtracted profile has more entries\n foreach my $k (keys(%{$B})) {\n if (!exists($A->{$k})) {\n AddEntry($R, $k, 0 - $B->{$k});\n }\n }\n }\n return $R;\n}\n\n# Get entry from profile; zero if not present\nsub GetEntry {\n my $profile = shift;\n my $k = shift;\n if (exists($profile->{$k})) {\n return $profile->{$k};\n } else {\n return 0;\n }\n}\n\n# Add entry to specified profile\nsub AddEntry {\n my $profile = shift;\n my $k = shift;\n my $n = shift;\n if (!exists($profile->{$k})) {\n $profile->{$k} = 0;\n }\n $profile->{$k} += $n;\n}\n\n# Add a stack of entries to specified profile, and add them to the $pcs\n# list.\nsub AddEntries {\n my $profile = shift;\n my $pcs = shift;\n my $stack = shift;\n my $count = shift;\n my @k = ();\n\n foreach my $e (split(/\\s+/, $stack)) {\n my $pc = HexExtend($e);\n $pcs->{$pc} = 1;\n push @k, $pc;\n }\n AddEntry($profile, (join \"\\n\", @k), $count);\n}\n\n##### Code to profile a server dynamically #####\n\nsub CheckSymbolPage {\n my $url = SymbolPageURL();\n my $command = ShellEscape(@URL_FETCHER, $url);\n open(SYMBOL, \"$command |\") or error($command);\n my $line = ;\n $line =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n close(SYMBOL);\n unless (defined($line)) {\n error(\"$url doesn't exist\\n\");\n }\n\n if ($line =~ /^num_symbols:\\s+(\\d+)$/) {\n if ($1 == 0) {\n error(\"Stripped binary. No symbols available.\\n\");\n }\n } else {\n error(\"Failed to get the number of symbols from $url\\n\");\n }\n}\n\nsub IsProfileURL {\n my $profile_name = shift;\n if (-f $profile_name) {\n printf STDERR \"Using local file $profile_name.\\n\";\n return 0;\n }\n return 1;\n}\n\nsub ParseProfileURL {\n my $profile_name = shift;\n\n if (!defined($profile_name) || $profile_name eq \"\") {\n return ();\n }\n\n # Split profile URL - matches all non-empty strings, so no test.\n $profile_name =~ m,^(https?://)?([^/]+)(.*?)(/|$PROFILES)?$,;\n\n my $proto = $1 || \"http://\";\n my $hostport = $2;\n my $prefix = $3;\n my $profile = $4 || \"/\";\n\n my $host = $hostport;\n $host =~ s/:.*//;\n\n my $baseurl = \"$proto$hostport$prefix\";\n return ($host, $baseurl, $profile);\n}\n\n# We fetch symbols from the first profile argument.\nsub SymbolPageURL {\n my ($host, $baseURL, $path) = ParseProfileURL($main::pfile_args[0]);\n return \"$baseURL$SYMBOL_PAGE\";\n}\n\nsub FetchProgramName() {\n my ($host, $baseURL, $path) = ParseProfileURL($main::pfile_args[0]);\n my $url = \"$baseURL$PROGRAM_NAME_PAGE\";\n my $command_line = ShellEscape(@URL_FETCHER, $url);\n open(CMDLINE, \"$command_line |\") or error($command_line);\n my $cmdline = ;\n $cmdline =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n close(CMDLINE);\n error(\"Failed to get program name from $url\\n\") unless defined($cmdline);\n $cmdline =~ s/\\x00.+//; # Remove argv[1] and latters.\n $cmdline =~ s!\\n!!g; # Remove LFs.\n return $cmdline;\n}\n\n# Gee, curl's -L (--location) option isn't reliable at least\n# with its 7.12.3 version. Curl will forget to post data if\n# there is a redirection. This function is a workaround for\n# curl. Redirection happens on borg hosts.\nsub ResolveRedirectionForCurl {\n my $url = shift;\n my $command_line = ShellEscape(@URL_FETCHER, \"--head\", $url);\n open(CMDLINE, \"$command_line |\") or error($command_line);\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n if (/^Location: (.*)/) {\n $url = $1;\n }\n }\n close(CMDLINE);\n return $url;\n}\n\n# Add a timeout flat to URL_FETCHER. Returns a new list.\nsub AddFetchTimeout {\n my $timeout = shift;\n my @fetcher = @_;\n if (defined($timeout)) {\n if (join(\" \", @fetcher) =~ m/\\bcurl -s/) {\n push(@fetcher, \"--max-time\", sprintf(\"%d\", $timeout));\n } elsif (join(\" \", @fetcher) =~ m/\\brpcget\\b/) {\n push(@fetcher, sprintf(\"--deadline=%d\", $timeout));\n }\n }\n return @fetcher;\n}\n\n# Reads a symbol map from the file handle name given as $1, returning\n# the resulting symbol map. Also processes variables relating to symbols.\n# Currently, the only variable processed is 'binary=' which updates\n# $main::prog to have the correct program name.\nsub ReadSymbols {\n my $in = shift;\n my $map = {};\n while (<$in>) {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n # Removes all the leading zeroes from the symbols, see comment below.\n if (m/^0x0*([0-9a-f]+)\\s+(.+)/) {\n $map->{$1} = $2;\n } elsif (m/^---/) {\n last;\n } elsif (m/^([a-z][^=]*)=(.*)$/ ) {\n my ($variable, $value) = ($1, $2);\n for ($variable, $value) {\n s/^\\s+//;\n s/\\s+$//;\n }\n if ($variable eq \"binary\") {\n if ($main::prog ne $UNKNOWN_BINARY && $main::prog ne $value) {\n printf STDERR (\"Warning: Mismatched binary name '%s', using '%s'.\\n\",\n $main::prog, $value);\n }\n $main::prog = $value;\n } else {\n printf STDERR (\"Ignoring unknown variable in symbols list: \" .\n \"'%s' = '%s'\\n\", $variable, $value);\n }\n }\n }\n return $map;\n}\n\nsub URLEncode {\n my $str = shift;\n $str =~ s/([^A-Za-z0-9\\-_.!~*'()])/ sprintf \"%%%02x\", ord $1 /eg;\n return $str;\n}\n\nsub AppendSymbolFilterParams {\n my $url = shift;\n my @params = ();\n if ($main::opt_retain ne '') {\n push(@params, sprintf(\"retain=%s\", URLEncode($main::opt_retain)));\n }\n if ($main::opt_exclude ne '') {\n push(@params, sprintf(\"exclude=%s\", URLEncode($main::opt_exclude)));\n }\n if (scalar @params > 0) {\n $url = sprintf(\"%s?%s\", $url, join(\"&\", @params));\n }\n return $url;\n}\n\n# Fetches and processes symbols to prepare them for use in the profile output\n# code. If the optional 'symbol_map' arg is not given, fetches symbols from\n# $SYMBOL_PAGE for all PC values found in profile. Otherwise, the raw symbols\n# are assumed to have already been fetched into 'symbol_map' and are simply\n# extracted and processed.\nsub FetchSymbols {\n my $pcset = shift;\n my $symbol_map = shift;\n\n my %seen = ();\n my @pcs = grep { !$seen{$_}++ } keys(%$pcset); # uniq\n\n if (!defined($symbol_map)) {\n my $post_data = join(\"+\", sort((map {\"0x\" . \"$_\"} @pcs)));\n\n open(POSTFILE, \">$main::tmpfile_sym\");\n print POSTFILE $post_data;\n close(POSTFILE);\n\n my $url = SymbolPageURL();\n\n my $command_line;\n if (join(\" \", @URL_FETCHER) =~ m/\\bcurl -s/) {\n $url = ResolveRedirectionForCurl($url);\n $url = AppendSymbolFilterParams($url);\n $command_line = ShellEscape(@URL_FETCHER, \"-d\", \"\\@$main::tmpfile_sym\",\n $url);\n } else {\n $url = AppendSymbolFilterParams($url);\n $command_line = (ShellEscape(@URL_FETCHER, \"--post\", $url)\n . \" < \" . ShellEscape($main::tmpfile_sym));\n }\n # We use c++filt in case $SYMBOL_PAGE gives us mangled symbols.\n my $escaped_cppfilt = ShellEscape($obj_tool_map{\"c++filt\"});\n open(SYMBOL, \"$command_line | $escaped_cppfilt |\") or error($command_line);\n $symbol_map = ReadSymbols(*SYMBOL{IO});\n close(SYMBOL);\n }\n\n my $symbols = {};\n foreach my $pc (@pcs) {\n my $fullname;\n # For 64 bits binaries, symbols are extracted with 8 leading zeroes.\n # Then /symbol reads the long symbols in as uint64, and outputs\n # the result with a \"0x%08llx\" format which get rid of the zeroes.\n # By removing all the leading zeroes in both $pc and the symbols from\n # /symbol, the symbols match and are retrievable from the map.\n my $shortpc = $pc;\n $shortpc =~ s/^0*//;\n # Each line may have a list of names, which includes the function\n # and also other functions it has inlined. They are separated (in\n # PrintSymbolizedProfile), by --, which is illegal in function names.\n my $fullnames;\n if (defined($symbol_map->{$shortpc})) {\n $fullnames = $symbol_map->{$shortpc};\n } else {\n $fullnames = \"0x\" . $pc; # Just use addresses\n }\n my $sym = [];\n $symbols->{$pc} = $sym;\n foreach my $fullname (split(\"--\", $fullnames)) {\n my $name = ShortFunctionName($fullname);\n push(@{$sym}, $name, \"?\", $fullname);\n }\n }\n return $symbols;\n}\n\nsub BaseName {\n my $file_name = shift;\n $file_name =~ s!^.*/!!; # Remove directory name\n return $file_name;\n}\n\nsub MakeProfileBaseName {\n my ($binary_name, $profile_name) = @_;\n my ($host, $baseURL, $path) = ParseProfileURL($profile_name);\n my $binary_shortname = BaseName($binary_name);\n return sprintf(\"%s.%s.%s\",\n $binary_shortname, $main::op_time, $host);\n}\n\nsub FetchDynamicProfile {\n my $binary_name = shift;\n my $profile_name = shift;\n my $fetch_name_only = shift;\n my $encourage_patience = shift;\n\n if (!IsProfileURL($profile_name)) {\n return $profile_name;\n } else {\n my ($host, $baseURL, $path) = ParseProfileURL($profile_name);\n if ($path eq \"\" || $path eq \"/\") {\n # Missing type specifier defaults to cpu-profile\n $path = $PROFILE_PAGE;\n }\n\n my $profile_file = MakeProfileBaseName($binary_name, $profile_name);\n\n my $url = \"$baseURL$path\";\n my $fetch_timeout = undef;\n if ($path =~ m/$PROFILE_PAGE|$PMUPROFILE_PAGE/) {\n if ($path =~ m/[?]/) {\n $url .= \"&\";\n } else {\n $url .= \"?\";\n }\n $url .= sprintf(\"seconds=%d\", $main::opt_seconds);\n $fetch_timeout = $main::opt_seconds * 1.01 + 60;\n # Set $profile_type for consumption by PrintSymbolizedProfile.\n $main::profile_type = 'cpu';\n } else {\n # For non-CPU profiles, we add a type-extension to\n # the target profile file name.\n my $suffix = $path;\n $suffix =~ s,/,.,g;\n $profile_file .= $suffix;\n # Set $profile_type for consumption by PrintSymbolizedProfile.\n if ($path =~ m/$HEAP_PAGE/) {\n $main::profile_type = 'heap';\n } elsif ($path =~ m/$GROWTH_PAGE/) {\n $main::profile_type = 'growth';\n } elsif ($path =~ m/$CONTENTION_PAGE/) {\n $main::profile_type = 'contention';\n }\n }\n\n my $profile_dir = $ENV{\"JEPROF_TMPDIR\"} || ($ENV{HOME} . \"/jeprof\");\n if (! -d $profile_dir) {\n mkdir($profile_dir)\n || die(\"Unable to create profile directory $profile_dir: $!\\n\");\n }\n my $tmp_profile = \"$profile_dir/.tmp.$profile_file\";\n my $real_profile = \"$profile_dir/$profile_file\";\n\n if ($fetch_name_only > 0) {\n return $real_profile;\n }\n\n my @fetcher = AddFetchTimeout($fetch_timeout, @URL_FETCHER);\n my $cmd = ShellEscape(@fetcher, $url) . \" > \" . ShellEscape($tmp_profile);\n if ($path =~ m/$PROFILE_PAGE|$PMUPROFILE_PAGE|$CENSUSPROFILE_PAGE/){\n print STDERR \"Gathering CPU profile from $url for $main::opt_seconds seconds to\\n ${real_profile}\\n\";\n if ($encourage_patience) {\n print STDERR \"Be patient...\\n\";\n }\n } else {\n print STDERR \"Fetching $path profile from $url to\\n ${real_profile}\\n\";\n }\n\n (system($cmd) == 0) || error(\"Failed to get profile: $cmd: $!\\n\");\n (system(\"mv\", $tmp_profile, $real_profile) == 0) || error(\"Unable to rename profile\\n\");\n print STDERR \"Wrote profile to $real_profile\\n\";\n $main::collected_profile = $real_profile;\n return $main::collected_profile;\n }\n}\n\n# Collect profiles in parallel\nsub FetchDynamicProfiles {\n my $items = scalar(@main::pfile_args);\n my $levels = log($items) / log(2);\n\n if ($items == 1) {\n $main::profile_files[0] = FetchDynamicProfile($main::prog, $main::pfile_args[0], 0, 1);\n } else {\n # math rounding issues\n if ((2 ** $levels) < $items) {\n $levels++;\n }\n my $count = scalar(@main::pfile_args);\n for (my $i = 0; $i < $count; $i++) {\n $main::profile_files[$i] = FetchDynamicProfile($main::prog, $main::pfile_args[$i], 1, 0);\n }\n print STDERR \"Fetching $count profiles, Be patient...\\n\";\n FetchDynamicProfilesRecurse($levels, 0, 0);\n $main::collected_profile = join(\" \\\\\\n \", @main::profile_files);\n }\n}\n\n# Recursively fork a process to get enough processes\n# collecting profiles\nsub FetchDynamicProfilesRecurse {\n my $maxlevel = shift;\n my $level = shift;\n my $position = shift;\n\n if (my $pid = fork()) {\n $position = 0 | ($position << 1);\n TryCollectProfile($maxlevel, $level, $position);\n wait;\n } else {\n $position = 1 | ($position << 1);\n TryCollectProfile($maxlevel, $level, $position);\n cleanup();\n exit(0);\n }\n}\n\n# Collect a single profile\nsub TryCollectProfile {\n my $maxlevel = shift;\n my $level = shift;\n my $position = shift;\n\n if ($level >= ($maxlevel - 1)) {\n if ($position < scalar(@main::pfile_args)) {\n FetchDynamicProfile($main::prog, $main::pfile_args[$position], 0, 0);\n }\n } else {\n FetchDynamicProfilesRecurse($maxlevel, $level+1, $position);\n }\n}\n\n##### Parsing code #####\n\n# Provide a small streaming-read module to handle very large\n# cpu-profile files. Stream in chunks along a sliding window.\n# Provides an interface to get one 'slot', correctly handling\n# endian-ness differences. A slot is one 32-bit or 64-bit word\n# (depending on the input profile). We tell endianness and bit-size\n# for the profile by looking at the first 8 bytes: in cpu profiles,\n# the second slot is always 3 (we'll accept anything that's not 0).\nBEGIN {\n package CpuProfileStream;\n\n sub new {\n my ($class, $file, $fname) = @_;\n my $self = { file => $file,\n base => 0,\n stride => 512 * 1024, # must be a multiple of bitsize/8\n slots => [],\n unpack_code => \"\", # N for big-endian, V for little\n perl_is_64bit => 1, # matters if profile is 64-bit\n };\n bless $self, $class;\n # Let unittests adjust the stride\n if ($main::opt_test_stride > 0) {\n $self->{stride} = $main::opt_test_stride;\n }\n # Read the first two slots to figure out bitsize and endianness.\n my $slots = $self->{slots};\n my $str;\n read($self->{file}, $str, 8);\n # Set the global $address_length based on what we see here.\n # 8 is 32-bit (8 hexadecimal chars); 16 is 64-bit (16 hexadecimal chars).\n $address_length = ($str eq (chr(0)x8)) ? 16 : 8;\n if ($address_length == 8) {\n if (substr($str, 6, 2) eq chr(0)x2) {\n $self->{unpack_code} = 'V'; # Little-endian.\n } elsif (substr($str, 4, 2) eq chr(0)x2) {\n $self->{unpack_code} = 'N'; # Big-endian\n } else {\n ::error(\"$fname: header size >= 2**16\\n\");\n }\n @$slots = unpack($self->{unpack_code} . \"*\", $str);\n } else {\n # If we're a 64-bit profile, check if we're a 64-bit-capable\n # perl. Otherwise, each slot will be represented as a float\n # instead of an int64, losing precision and making all the\n # 64-bit addresses wrong. We won't complain yet, but will\n # later if we ever see a value that doesn't fit in 32 bits.\n my $has_q = 0;\n eval { $has_q = pack(\"Q\", \"1\") ? 1 : 1; };\n if (!$has_q) {\n $self->{perl_is_64bit} = 0;\n }\n read($self->{file}, $str, 8);\n if (substr($str, 4, 4) eq chr(0)x4) {\n # We'd love to use 'Q', but it's a) not universal, b) not endian-proof.\n $self->{unpack_code} = 'V'; # Little-endian.\n } elsif (substr($str, 0, 4) eq chr(0)x4) {\n $self->{unpack_code} = 'N'; # Big-endian\n } else {\n ::error(\"$fname: header size >= 2**32\\n\");\n }\n my @pair = unpack($self->{unpack_code} . \"*\", $str);\n # Since we know one of the pair is 0, it's fine to just add them.\n @$slots = (0, $pair[0] + $pair[1]);\n }\n return $self;\n }\n\n # Load more data when we access slots->get(X) which is not yet in memory.\n sub overflow {\n my ($self) = @_;\n my $slots = $self->{slots};\n $self->{base} += $#$slots + 1; # skip over data we're replacing\n my $str;\n read($self->{file}, $str, $self->{stride});\n if ($address_length == 8) { # the 32-bit case\n # This is the easy case: unpack provides 32-bit unpacking primitives.\n @$slots = unpack($self->{unpack_code} . \"*\", $str);\n } else {\n # We need to unpack 32 bits at a time and combine.\n my @b32_values = unpack($self->{unpack_code} . \"*\", $str);\n my @b64_values = ();\n for (my $i = 0; $i < $#b32_values; $i += 2) {\n # TODO(csilvers): if this is a 32-bit perl, the math below\n # could end up in a too-large int, which perl will promote\n # to a double, losing necessary precision. Deal with that.\n # Right now, we just die.\n my ($lo, $hi) = ($b32_values[$i], $b32_values[$i+1]);\n if ($self->{unpack_code} eq 'N') { # big-endian\n ($lo, $hi) = ($hi, $lo);\n }\n my $value = $lo + $hi * (2**32);\n if (!$self->{perl_is_64bit} && # check value is exactly represented\n (($value % (2**32)) != $lo || int($value / (2**32)) != $hi)) {\n ::error(\"Need a 64-bit perl to process this 64-bit profile.\\n\");\n }\n push(@b64_values, $value);\n }\n @$slots = @b64_values;\n }\n }\n\n # Access the i-th long in the file (logically), or -1 at EOF.\n sub get {\n my ($self, $idx) = @_;\n my $slots = $self->{slots};\n while ($#$slots >= 0) {\n if ($idx < $self->{base}) {\n # The only time we expect a reference to $slots[$i - something]\n # after referencing $slots[$i] is reading the very first header.\n # Since $stride > |header|, that shouldn't cause any lookback\n # errors. And everything after the header is sequential.\n print STDERR \"Unexpected look-back reading CPU profile\";\n return -1; # shrug, don't know what better to return\n } elsif ($idx > $self->{base} + $#$slots) {\n $self->overflow();\n } else {\n return $slots->[$idx - $self->{base}];\n }\n }\n # If we get here, $slots is [], which means we've reached EOF\n return -1; # unique since slots is supposed to hold unsigned numbers\n }\n}\n\n# Reads the top, 'header' section of a profile, and returns the last\n# line of the header, commonly called a 'header line'. The header\n# section of a profile consists of zero or more 'command' lines that\n# are instructions to jeprof, which jeprof executes when reading the\n# header. All 'command' lines start with a %. After the command\n# lines is the 'header line', which is a profile-specific line that\n# indicates what type of profile it is, and perhaps other global\n# information about the profile. For instance, here's a header line\n# for a heap profile:\n# heap profile: 53: 38236 [ 5525: 1284029] @ heapprofile\n# For historical reasons, the CPU profile does not contain a text-\n# readable header line. If the profile looks like a CPU profile,\n# this function returns \"\". If no header line could be found, this\n# function returns undef.\n#\n# The following commands are recognized:\n# %warn -- emit the rest of this line to stderr, prefixed by 'WARNING:'\n#\n# The input file should be in binmode.\nsub ReadProfileHeader {\n local *PROFILE = shift;\n my $firstchar = \"\";\n my $line = \"\";\n read(PROFILE, $firstchar, 1);\n seek(PROFILE, -1, 1); # unread the firstchar\n if ($firstchar !~ /[[:print:]]/) { # is not a text character\n return \"\";\n }\n while (defined($line = )) {\n $line =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n if ($line =~ /^%warn\\s+(.*)/) { # 'warn' command\n # Note this matches both '%warn blah\\n' and '%warn\\n'.\n print STDERR \"WARNING: $1\\n\"; # print the rest of the line\n } elsif ($line =~ /^%/) {\n print STDERR \"Ignoring unknown command from profile header: $line\";\n } else {\n # End of commands, must be the header line.\n return $line;\n }\n }\n return undef; # got to EOF without seeing a header line\n}\n\nsub IsSymbolizedProfileFile {\n my $file_name = shift;\n if (!(-e $file_name) || !(-r $file_name)) {\n return 0;\n }\n # Check if the file contains a symbol-section marker.\n open(TFILE, \"<$file_name\");\n binmode TFILE;\n my $firstline = ReadProfileHeader(*TFILE);\n close(TFILE);\n if (!$firstline) {\n return 0;\n }\n $SYMBOL_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $symbol_marker = $&;\n return $firstline =~ /^--- *$symbol_marker/;\n}\n\n# Parse profile generated by common/profiler.cc and return a reference\n# to a map:\n# $result->{version} Version number of profile file\n# $result->{period} Sampling period (in microseconds)\n# $result->{profile} Profile object\n# $result->{threads} Map of thread IDs to profile objects\n# $result->{map} Memory map info from profile\n# $result->{pcs} Hash of all PC values seen, key is hex address\nsub ReadProfile {\n my $prog = shift;\n my $fname = shift;\n my $result; # return value\n\n $CONTENTION_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $contention_marker = $&;\n $GROWTH_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $growth_marker = $&;\n $SYMBOL_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $symbol_marker = $&;\n $PROFILE_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $profile_marker = $&;\n $HEAP_PAGE =~ m,[^/]+$,; # matches everything after the last slash\n my $heap_marker = $&;\n\n # Look at first line to see if it is a heap or a CPU profile.\n # CPU profile may start with no header at all, and just binary data\n # (starting with \\0\\0\\0\\0) -- in that case, don't try to read the\n # whole firstline, since it may be gigabytes(!) of data.\n open(PROFILE, \"<$fname\") || error(\"$fname: $!\\n\");\n binmode PROFILE; # New perls do UTF-8 processing\n my $header = ReadProfileHeader(*PROFILE);\n if (!defined($header)) { # means \"at EOF\"\n error(\"Profile is empty.\\n\");\n }\n\n my $symbols;\n if ($header =~ m/^--- *$symbol_marker/o) {\n # Verify that the user asked for a symbolized profile\n if (!$main::use_symbolized_profile) {\n # we have both a binary and symbolized profiles, abort\n error(\"FATAL ERROR: Symbolized profile\\n $fname\\ncannot be used with \" .\n \"a binary arg. Try again without passing\\n $prog\\n\");\n }\n # Read the symbol section of the symbolized profile file.\n $symbols = ReadSymbols(*PROFILE{IO});\n # Read the next line to get the header for the remaining profile.\n $header = ReadProfileHeader(*PROFILE) || \"\";\n }\n\n if ($header =~ m/^--- *($heap_marker|$growth_marker)/o) {\n # Skip \"--- ...\" line for profile types that have their own headers.\n $header = ReadProfileHeader(*PROFILE) || \"\";\n }\n\n $main::profile_type = '';\n\n if ($header =~ m/^heap profile:.*$growth_marker/o) {\n $main::profile_type = 'growth';\n $result = ReadHeapProfile($prog, *PROFILE, $header);\n } elsif ($header =~ m/^heap profile:/) {\n $main::profile_type = 'heap';\n $result = ReadHeapProfile($prog, *PROFILE, $header);\n } elsif ($header =~ m/^heap/) {\n $main::profile_type = 'heap';\n $result = ReadThreadedHeapProfile($prog, $fname, $header);\n } elsif ($header =~ m/^--- *$contention_marker/o) {\n $main::profile_type = 'contention';\n $result = ReadSynchProfile($prog, *PROFILE);\n } elsif ($header =~ m/^--- *Stacks:/) {\n print STDERR\n \"Old format contention profile: mistakenly reports \" .\n \"condition variable signals as lock contentions.\\n\";\n $main::profile_type = 'contention';\n $result = ReadSynchProfile($prog, *PROFILE);\n } elsif ($header =~ m/^--- *$profile_marker/) {\n # the binary cpu profile data starts immediately after this line\n $main::profile_type = 'cpu';\n $result = ReadCPUProfile($prog, $fname, *PROFILE);\n } else {\n if (defined($symbols)) {\n # a symbolized profile contains a format we don't recognize, bail out\n error(\"$fname: Cannot recognize profile section after symbols.\\n\");\n }\n # no ascii header present -- must be a CPU profile\n $main::profile_type = 'cpu';\n $result = ReadCPUProfile($prog, $fname, *PROFILE);\n }\n\n close(PROFILE);\n\n # if we got symbols along with the profile, return those as well\n if (defined($symbols)) {\n $result->{symbols} = $symbols;\n }\n\n return $result;\n}\n\n# Subtract one from caller pc so we map back to call instr.\n# However, don't do this if we're reading a symbolized profile\n# file, in which case the subtract-one was done when the file\n# was written.\n#\n# We apply the same logic to all readers, though ReadCPUProfile uses an\n# independent implementation.\nsub FixCallerAddresses {\n my $stack = shift;\n # --raw/http: Always subtract one from pc's, because PrintSymbolizedProfile()\n # dumps unadjusted profiles.\n {\n $stack =~ /(\\s)/;\n my $delimiter = $1;\n my @addrs = split(' ', $stack);\n my @fixedaddrs;\n $#fixedaddrs = $#addrs;\n if ($#addrs >= 0) {\n $fixedaddrs[0] = $addrs[0];\n }\n for (my $i = 1; $i <= $#addrs; $i++) {\n $fixedaddrs[$i] = AddressSub($addrs[$i], \"0x1\");\n }\n return join $delimiter, @fixedaddrs;\n }\n}\n\n# CPU profile reader\nsub ReadCPUProfile {\n my $prog = shift;\n my $fname = shift; # just used for logging\n local *PROFILE = shift;\n my $version;\n my $period;\n my $i;\n my $profile = {};\n my $pcs = {};\n\n # Parse string into array of slots.\n my $slots = CpuProfileStream->new(*PROFILE, $fname);\n\n # Read header. The current header version is a 5-element structure\n # containing:\n # 0: header count (always 0)\n # 1: header \"words\" (after this one: 3)\n # 2: format version (0)\n # 3: sampling period (usec)\n # 4: unused padding (always 0)\n if ($slots->get(0) != 0 ) {\n error(\"$fname: not a profile file, or old format profile file\\n\");\n }\n $i = 2 + $slots->get(1);\n $version = $slots->get(2);\n $period = $slots->get(3);\n # Do some sanity checking on these header values.\n if ($version > (2**32) || $period > (2**32) || $i > (2**32) || $i < 5) {\n error(\"$fname: not a profile file, or corrupted profile file\\n\");\n }\n\n # Parse profile\n while ($slots->get($i) != -1) {\n my $n = $slots->get($i++);\n my $d = $slots->get($i++);\n if ($d > (2**16)) { # TODO(csilvers): what's a reasonable max-stack-depth?\n my $addr = sprintf(\"0%o\", $i * ($address_length == 8 ? 4 : 8));\n print STDERR \"At index $i (address $addr):\\n\";\n error(\"$fname: stack trace depth >= 2**32\\n\");\n }\n if ($slots->get($i) == 0) {\n # End of profile data marker\n $i += $d;\n last;\n }\n\n # Make key out of the stack entries\n my @k = ();\n for (my $j = 0; $j < $d; $j++) {\n my $pc = $slots->get($i+$j);\n # Subtract one from caller pc so we map back to call instr.\n $pc--;\n $pc = sprintf(\"%0*x\", $address_length, $pc);\n $pcs->{$pc} = 1;\n push @k, $pc;\n }\n\n AddEntry($profile, (join \"\\n\", @k), $n);\n $i += $d;\n }\n\n # Parse map\n my $map = '';\n seek(PROFILE, $i * 4, 0);\n read(PROFILE, $map, (stat PROFILE)[7]);\n\n my $r = {};\n $r->{version} = $version;\n $r->{period} = $period;\n $r->{profile} = $profile;\n $r->{libs} = ParseLibraries($prog, $map, $pcs);\n $r->{pcs} = $pcs;\n\n return $r;\n}\n\nsub HeapProfileIndex {\n my $index = 1;\n if ($main::opt_inuse_space) {\n $index = 1;\n } elsif ($main::opt_inuse_objects) {\n $index = 0;\n } elsif ($main::opt_alloc_space) {\n $index = 3;\n } elsif ($main::opt_alloc_objects) {\n $index = 2;\n }\n return $index;\n}\n\nsub ReadMappedLibraries {\n my $fh = shift;\n my $map = \"\";\n # Read the /proc/self/maps data\n while (<$fh>) {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n $map .= $_;\n }\n return $map;\n}\n\nsub ReadMemoryMap {\n my $fh = shift;\n my $map = \"\";\n # Read /proc/self/maps data as formatted by DumpAddressMap()\n my $buildvar = \"\";\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n # Parse \"build=\" specification if supplied\n if (m/^\\s*build=(.*)\\n/) {\n $buildvar = $1;\n }\n\n # Expand \"$build\" variable if available\n $_ =~ s/\\$build\\b/$buildvar/g;\n\n $map .= $_;\n }\n return $map;\n}\n\nsub AdjustSamples {\n my ($sample_adjustment, $sampling_algorithm, $n1, $s1, $n2, $s2) = @_;\n if ($sample_adjustment) {\n if ($sampling_algorithm == 2) {\n # Remote-heap version 2\n # The sampling frequency is the rate of a Poisson process.\n # This means that the probability of sampling an allocation of\n # size X with sampling rate Y is 1 - exp(-X/Y)\n if ($n1 != 0) {\n my $ratio = (($s1*1.0)/$n1)/($sample_adjustment);\n my $scale_factor = 1/(1 - exp(-$ratio));\n $n1 *= $scale_factor;\n $s1 *= $scale_factor;\n }\n if ($n2 != 0) {\n my $ratio = (($s2*1.0)/$n2)/($sample_adjustment);\n my $scale_factor = 1/(1 - exp(-$ratio));\n $n2 *= $scale_factor;\n $s2 *= $scale_factor;\n }\n } else {\n # Remote-heap version 1\n my $ratio;\n $ratio = (($s1*1.0)/$n1)/($sample_adjustment);\n if ($ratio < 1) {\n $n1 /= $ratio;\n $s1 /= $ratio;\n }\n $ratio = (($s2*1.0)/$n2)/($sample_adjustment);\n if ($ratio < 1) {\n $n2 /= $ratio;\n $s2 /= $ratio;\n }\n }\n }\n return ($n1, $s1, $n2, $s2);\n}\n\nsub ReadHeapProfile {\n my $prog = shift;\n local *PROFILE = shift;\n my $header = shift;\n\n my $index = HeapProfileIndex();\n\n # Find the type of this profile. The header line looks like:\n # heap profile: 1246: 8800744 [ 1246: 8800744] @ /266053\n # There are two pairs , the first inuse objects/space, and the\n # second allocated objects/space. This is followed optionally by a profile\n # type, and if that is present, optionally by a sampling frequency.\n # For remote heap profiles (v1):\n # The interpretation of the sampling frequency is that the profiler, for\n # each sample, calculates a uniformly distributed random integer less than\n # the given value, and records the next sample after that many bytes have\n # been allocated. Therefore, the expected sample interval is half of the\n # given frequency. By default, if not specified, the expected sample\n # interval is 128KB. Only remote-heap-page profiles are adjusted for\n # sample size.\n # For remote heap profiles (v2):\n # The sampling frequency is the rate of a Poisson process. This means that\n # the probability of sampling an allocation of size X with sampling rate Y\n # is 1 - exp(-X/Y)\n # For version 2, a typical header line might look like this:\n # heap profile: 1922: 127792360 [ 1922: 127792360] @ _v2/524288\n # the trailing number (524288) is the sampling rate. (Version 1 showed\n # double the 'rate' here)\n my $sampling_algorithm = 0;\n my $sample_adjustment = 0;\n chomp($header);\n my $type = \"unknown\";\n if ($header =~ m\"^heap profile:\\s*(\\d+):\\s+(\\d+)\\s+\\[\\s*(\\d+):\\s+(\\d+)\\](\\s*@\\s*([^/]*)(/(\\d+))?)?\") {\n if (defined($6) && ($6 ne '')) {\n $type = $6;\n my $sample_period = $8;\n # $type is \"heapprofile\" for profiles generated by the\n # heap-profiler, and either \"heap\" or \"heap_v2\" for profiles\n # generated by sampling directly within tcmalloc. It can also\n # be \"growth\" for heap-growth profiles. The first is typically\n # found for profiles generated locally, and the others for\n # remote profiles.\n if (($type eq \"heapprofile\") || ($type !~ /heap/) ) {\n # No need to adjust for the sampling rate with heap-profiler-derived data\n $sampling_algorithm = 0;\n } elsif ($type =~ /_v2/) {\n $sampling_algorithm = 2; # version 2 sampling\n if (defined($sample_period) && ($sample_period ne '')) {\n $sample_adjustment = int($sample_period);\n }\n } else {\n $sampling_algorithm = 1; # version 1 sampling\n if (defined($sample_period) && ($sample_period ne '')) {\n $sample_adjustment = int($sample_period)/2;\n }\n }\n } else {\n # We detect whether or not this is a remote-heap profile by checking\n # that the total-allocated stats ($n2,$s2) are exactly the\n # same as the in-use stats ($n1,$s1). It is remotely conceivable\n # that a non-remote-heap profile may pass this check, but it is hard\n # to imagine how that could happen.\n # In this case it's so old it's guaranteed to be remote-heap version 1.\n my ($n1, $s1, $n2, $s2) = ($1, $2, $3, $4);\n if (($n1 == $n2) && ($s1 == $s2)) {\n # This is likely to be a remote-heap based sample profile\n $sampling_algorithm = 1;\n }\n }\n }\n\n if ($sampling_algorithm > 0) {\n # For remote-heap generated profiles, adjust the counts and sizes to\n # account for the sample rate (we sample once every 128KB by default).\n if ($sample_adjustment == 0) {\n # Turn on profile adjustment.\n $sample_adjustment = 128*1024;\n print STDERR \"Adjusting heap profiles for 1-in-128KB sampling rate\\n\";\n } else {\n printf STDERR (\"Adjusting heap profiles for 1-in-%d sampling rate\\n\",\n $sample_adjustment);\n }\n if ($sampling_algorithm > 1) {\n # We don't bother printing anything for the original version (version 1)\n printf STDERR \"Heap version $sampling_algorithm\\n\";\n }\n }\n\n my $profile = {};\n my $pcs = {};\n my $map = \"\";\n\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n if (/^MAPPED_LIBRARIES:/) {\n $map .= ReadMappedLibraries(*PROFILE);\n last;\n }\n\n if (/^--- Memory map:/) {\n $map .= ReadMemoryMap(*PROFILE);\n last;\n }\n\n # Read entry of the form:\n # : [: ] @ a1 a2 a3 ... an\n s/^\\s*//;\n s/\\s*$//;\n if (m/^\\s*(\\d+):\\s+(\\d+)\\s+\\[\\s*(\\d+):\\s+(\\d+)\\]\\s+@\\s+(.*)$/) {\n my $stack = $5;\n my ($n1, $s1, $n2, $s2) = ($1, $2, $3, $4);\n my @counts = AdjustSamples($sample_adjustment, $sampling_algorithm,\n $n1, $s1, $n2, $s2);\n AddEntries($profile, $pcs, FixCallerAddresses($stack), $counts[$index]);\n }\n }\n\n my $r = {};\n $r->{version} = \"heap\";\n $r->{period} = 1;\n $r->{profile} = $profile;\n $r->{libs} = ParseLibraries($prog, $map, $pcs);\n $r->{pcs} = $pcs;\n return $r;\n}\n\nsub ReadThreadedHeapProfile {\n my ($prog, $fname, $header) = @_;\n\n my $index = HeapProfileIndex();\n my $sampling_algorithm = 0;\n my $sample_adjustment = 0;\n chomp($header);\n my $type = \"unknown\";\n # Assuming a very specific type of header for now.\n if ($header =~ m\"^heap_v2/(\\d+)\") {\n $type = \"_v2\";\n $sampling_algorithm = 2;\n $sample_adjustment = int($1);\n }\n if ($type ne \"_v2\" || !defined($sample_adjustment)) {\n die \"Threaded heap profiles require v2 sampling with a sample rate\\n\";\n }\n\n my $profile = {};\n my $thread_profiles = {};\n my $pcs = {};\n my $map = \"\";\n my $stack = \"\";\n\n while () {\n s/\\r//g;\n if (/^MAPPED_LIBRARIES:/) {\n $map .= ReadMappedLibraries(*PROFILE);\n last;\n }\n\n if (/^--- Memory map:/) {\n $map .= ReadMemoryMap(*PROFILE);\n last;\n }\n\n # Read entry of the form:\n # @ a1 a2 ... an\n # t*: : [: ]\n # t1: : [: ]\n # ...\n # tn: : [: ]\n s/^\\s*//;\n s/\\s*$//;\n if (m/^@\\s+(.*)$/) {\n $stack = $1;\n } elsif (m/^\\s*(t(\\*|\\d+)):\\s+(\\d+):\\s+(\\d+)\\s+\\[\\s*(\\d+):\\s+(\\d+)\\]$/) {\n if ($stack eq \"\") {\n # Still in the header, so this is just a per-thread summary.\n next;\n }\n my $thread = $2;\n my ($n1, $s1, $n2, $s2) = ($3, $4, $5, $6);\n my @counts = AdjustSamples($sample_adjustment, $sampling_algorithm,\n $n1, $s1, $n2, $s2);\n if ($thread eq \"*\") {\n AddEntries($profile, $pcs, FixCallerAddresses($stack), $counts[$index]);\n } else {\n if (!exists($thread_profiles->{$thread})) {\n $thread_profiles->{$thread} = {};\n }\n AddEntries($thread_profiles->{$thread}, $pcs,\n FixCallerAddresses($stack), $counts[$index]);\n }\n }\n }\n\n my $r = {};\n $r->{version} = \"heap\";\n $r->{period} = 1;\n $r->{profile} = $profile;\n $r->{threads} = $thread_profiles;\n $r->{libs} = ParseLibraries($prog, $map, $pcs);\n $r->{pcs} = $pcs;\n return $r;\n}\n\nsub ReadSynchProfile {\n my $prog = shift;\n local *PROFILE = shift;\n my $header = shift;\n\n my $map = '';\n my $profile = {};\n my $pcs = {};\n my $sampling_period = 1;\n my $cyclespernanosec = 2.8; # Default assumption for old binaries\n my $seen_clockrate = 0;\n my $line;\n\n my $index = 0;\n if ($main::opt_total_delay) {\n $index = 0;\n } elsif ($main::opt_contentions) {\n $index = 1;\n } elsif ($main::opt_mean_delay) {\n $index = 2;\n }\n\n while ( $line = ) {\n $line =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n if ( $line =~ /^\\s*(\\d+)\\s+(\\d+) \\@\\s*(.*?)\\s*$/ ) {\n my ($cycles, $count, $stack) = ($1, $2, $3);\n\n # Convert cycles to nanoseconds\n $cycles /= $cyclespernanosec;\n\n # Adjust for sampling done by application\n $cycles *= $sampling_period;\n $count *= $sampling_period;\n\n my @values = ($cycles, $count, $cycles / $count);\n AddEntries($profile, $pcs, FixCallerAddresses($stack), $values[$index]);\n\n } elsif ( $line =~ /^(slow release).*thread \\d+ \\@\\s*(.*?)\\s*$/ ||\n $line =~ /^\\s*(\\d+) \\@\\s*(.*?)\\s*$/ ) {\n my ($cycles, $stack) = ($1, $2);\n if ($cycles !~ /^\\d+$/) {\n next;\n }\n\n # Convert cycles to nanoseconds\n $cycles /= $cyclespernanosec;\n\n # Adjust for sampling done by application\n $cycles *= $sampling_period;\n\n AddEntries($profile, $pcs, FixCallerAddresses($stack), $cycles);\n\n } elsif ( $line =~ m/^([a-z][^=]*)=(.*)$/ ) {\n my ($variable, $value) = ($1,$2);\n for ($variable, $value) {\n s/^\\s+//;\n s/\\s+$//;\n }\n if ($variable eq \"cycles/second\") {\n $cyclespernanosec = $value / 1e9;\n $seen_clockrate = 1;\n } elsif ($variable eq \"sampling period\") {\n $sampling_period = $value;\n } elsif ($variable eq \"ms since reset\") {\n # Currently nothing is done with this value in jeprof\n # So we just silently ignore it for now\n } elsif ($variable eq \"discarded samples\") {\n # Currently nothing is done with this value in jeprof\n # So we just silently ignore it for now\n } else {\n printf STDERR (\"Ignoring unnknown variable in /contention output: \" .\n \"'%s' = '%s'\\n\",$variable,$value);\n }\n } else {\n # Memory map entry\n $map .= $line;\n }\n }\n\n if (!$seen_clockrate) {\n printf STDERR (\"No cycles/second entry in profile; Guessing %.1f GHz\\n\",\n $cyclespernanosec);\n }\n\n my $r = {};\n $r->{version} = 0;\n $r->{period} = $sampling_period;\n $r->{profile} = $profile;\n $r->{libs} = ParseLibraries($prog, $map, $pcs);\n $r->{pcs} = $pcs;\n return $r;\n}\n\n# Given a hex value in the form \"0x1abcd\" or \"1abcd\", return either\n# \"0001abcd\" or \"000000000001abcd\", depending on the current (global)\n# address length.\nsub HexExtend {\n my $addr = shift;\n\n $addr =~ s/^(0x)?0*//;\n my $zeros_needed = $address_length - length($addr);\n if ($zeros_needed < 0) {\n printf STDERR \"Warning: address $addr is longer than address length $address_length\\n\";\n return $addr;\n }\n return (\"0\" x $zeros_needed) . $addr;\n}\n\n##### Symbol extraction #####\n\n# Aggressively search the lib_prefix values for the given library\n# If all else fails, just return the name of the library unmodified.\n# If the lib_prefix is \"/my/path,/other/path\" and $file is \"/lib/dir/mylib.so\"\n# it will search the following locations in this order, until it finds a file:\n# /my/path/lib/dir/mylib.so\n# /other/path/lib/dir/mylib.so\n# /my/path/dir/mylib.so\n# /other/path/dir/mylib.so\n# /my/path/mylib.so\n# /other/path/mylib.so\n# /lib/dir/mylib.so (returned as last resort)\nsub FindLibrary {\n my $file = shift;\n my $suffix = $file;\n\n # Search for the library as described above\n do {\n foreach my $prefix (@prefix_list) {\n my $fullpath = $prefix . $suffix;\n if (-e $fullpath) {\n return $fullpath;\n }\n }\n } while ($suffix =~ s|^/[^/]+/|/|);\n return $file;\n}\n\n# Return path to library with debugging symbols.\n# For libc libraries, the copy in /usr/lib/debug contains debugging symbols\nsub DebuggingLibrary {\n my $file = shift;\n \n if ($file !~ m|^/|) {\n return undef;\n }\n \n # Find debug symbol file if it's named after the library's name.\n \n if (-f \"/usr/lib/debug$file\") { \n if($main::opt_debug) { print STDERR \"found debug info for $file in /usr/lib/debug$file\\n\"; }\n return \"/usr/lib/debug$file\";\n } elsif (-f \"/usr/lib/debug$file.debug\") {\n if($main::opt_debug) { print STDERR \"found debug info for $file in /usr/lib/debug$file.debug\\n\"; }\n return \"/usr/lib/debug$file.debug\"; \n }\n\n if(!$main::opt_debug_syms_by_id) {\n if($main::opt_debug) { print STDERR \"no debug symbols found for $file\\n\" };\n return undef;\n }\n\n # Find debug file if it's named after the library's build ID.\n \n my $readelf = '';\n if (!$main::gave_up_on_elfutils) {\n $readelf = qx/eu-readelf -n ${file}/;\n if ($?) {\n print STDERR \"Cannot run eu-readelf. To use --debug-syms-by-id you must be on Linux, with elfutils installed.\\n\";\n $main::gave_up_on_elfutils = 1;\n return undef;\n }\n my $buildID = $1 if $readelf =~ /Build ID: ([A-Fa-f0-9]+)/s;\n if (defined $buildID && length $buildID > 0) {\n my $symbolFile = '/usr/lib/debug/.build-id/' . substr($buildID, 0, 2) . '/' . substr($buildID, 2) . '.debug';\n if (-e $symbolFile) {\n if($main::opt_debug) { print STDERR \"found debug symbol file $symbolFile for $file\\n\" };\n return $symbolFile;\n } else {\n if($main::opt_debug) { print STDERR \"no debug symbol file found for $file, build ID: $buildID\\n\" };\n return undef;\n }\n }\n }\n\n if($main::opt_debug) { print STDERR \"no debug symbols found for $file, build ID unknown\\n\" };\n return undef;\n}\n\n\n# Parse text section header of a library using objdump\nsub ParseTextSectionHeaderFromObjdump {\n my $lib = shift;\n\n my $size = undef;\n my $vma;\n my $file_offset;\n # Get objdump output from the library file to figure out how to\n # map between mapped addresses and addresses in the library.\n my $cmd = ShellEscape($obj_tool_map{\"objdump\"}, \"-h\", $lib);\n open(OBJDUMP, \"$cmd |\") || error(\"$cmd: $!\\n\");\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n # Idx Name Size VMA LMA File off Algn\n # 10 .text 00104b2c 420156f0 420156f0 000156f0 2**4\n # For 64-bit objects, VMA and LMA will be 16 hex digits, size and file\n # offset may still be 8. But AddressSub below will still handle that.\n my @x = split;\n if (($#x >= 6) && ($x[1] eq '.text')) {\n $size = $x[2];\n $vma = $x[3];\n $file_offset = $x[5];\n last;\n }\n }\n close(OBJDUMP);\n\n if (!defined($size)) {\n return undef;\n }\n\n my $r = {};\n $r->{size} = $size;\n $r->{vma} = $vma;\n $r->{file_offset} = $file_offset;\n\n return $r;\n}\n\n# Parse text section header of a library using otool (on OS X)\nsub ParseTextSectionHeaderFromOtool {\n my $lib = shift;\n\n my $size = undef;\n my $vma = undef;\n my $file_offset = undef;\n # Get otool output from the library file to figure out how to\n # map between mapped addresses and addresses in the library.\n my $command = ShellEscape($obj_tool_map{\"otool\"}, \"-l\", $lib);\n open(OTOOL, \"$command |\") || error(\"$command: $!\\n\");\n my $cmd = \"\";\n my $sectname = \"\";\n my $segname = \"\";\n foreach my $line () {\n $line =~ s/\\r//g; # turn windows-looking lines into unix-looking lines\n # Load command <#>\n # cmd LC_SEGMENT\n # [...]\n # Section\n # sectname __text\n # segname __TEXT\n # addr 0x000009f8\n # size 0x00018b9e\n # offset 2552\n # align 2^2 (4)\n # We will need to strip off the leading 0x from the hex addresses,\n # and convert the offset into hex.\n if ($line =~ /Load command/) {\n $cmd = \"\";\n $sectname = \"\";\n $segname = \"\";\n } elsif ($line =~ /Section/) {\n $sectname = \"\";\n $segname = \"\";\n } elsif ($line =~ /cmd (\\w+)/) {\n $cmd = $1;\n } elsif ($line =~ /sectname (\\w+)/) {\n $sectname = $1;\n } elsif ($line =~ /segname (\\w+)/) {\n $segname = $1;\n } elsif (!(($cmd eq \"LC_SEGMENT\" || $cmd eq \"LC_SEGMENT_64\") &&\n $sectname eq \"__text\" &&\n $segname eq \"__TEXT\")) {\n next;\n } elsif ($line =~ /\\baddr 0x([0-9a-fA-F]+)/) {\n $vma = $1;\n } elsif ($line =~ /\\bsize 0x([0-9a-fA-F]+)/) {\n $size = $1;\n } elsif ($line =~ /\\boffset ([0-9]+)/) {\n $file_offset = sprintf(\"%016x\", $1);\n }\n if (defined($vma) && defined($size) && defined($file_offset)) {\n last;\n }\n }\n close(OTOOL);\n\n if (!defined($vma) || !defined($size) || !defined($file_offset)) {\n return undef;\n }\n\n my $r = {};\n $r->{size} = $size;\n $r->{vma} = $vma;\n $r->{file_offset} = $file_offset;\n\n return $r;\n}\n\nsub ParseTextSectionHeader {\n # obj_tool_map(\"otool\") is only defined if we're in a Mach-O environment\n if (defined($obj_tool_map{\"otool\"})) {\n my $r = ParseTextSectionHeaderFromOtool(@_);\n if (defined($r)){\n return $r;\n }\n }\n # If otool doesn't work, or we don't have it, fall back to objdump\n return ParseTextSectionHeaderFromObjdump(@_);\n}\n\n# Split /proc/pid/maps dump into a list of libraries\nsub ParseLibraries {\n return if $main::use_symbol_page; # We don't need libraries info.\n my $prog = Cwd::abs_path(shift);\n my $map = shift;\n my $pcs = shift;\n\n my $result = [];\n my $h = \"[a-f0-9]+\";\n my $zero_offset = HexExtend(\"0\");\n\n my $buildvar = \"\";\n foreach my $l (split(\"\\n\", $map)) {\n if ($l =~ m/^\\s*build=(.*)$/) {\n $buildvar = $1;\n }\n\n my $start;\n my $finish;\n my $offset;\n my $lib;\n if ($l =~ /^($h)-($h)\\s+..x.\\s+($h)\\s+\\S+:\\S+\\s+\\d+\\s+(\\S+\\.(so|dll|dylib|bundle)((\\.\\d+)+\\w*(\\.\\d+){0,3})?)$/i) {\n # Full line from /proc/self/maps. Example:\n # 40000000-40015000 r-xp 00000000 03:01 12845071 /lib/ld-2.3.2.so\n $start = HexExtend($1);\n $finish = HexExtend($2);\n $offset = HexExtend($3);\n $lib = $4;\n $lib =~ s|\\\\|/|g; # turn windows-style paths into unix-style paths\n } elsif ($l =~ /^\\s*($h)-($h):\\s*(\\S+\\.so(\\.\\d+)*)/) {\n # Cooked line from DumpAddressMap. Example:\n # 40000000-40015000: /lib/ld-2.3.2.so\n $start = HexExtend($1);\n $finish = HexExtend($2);\n $offset = $zero_offset;\n $lib = $3;\n } elsif (($l =~ /^($h)-($h)\\s+..x.\\s+($h)\\s+\\S+:\\S+\\s+\\d+\\s+(\\S+)$/i) && ($4 eq $prog)) {\n # PIEs and address space randomization do not play well with our\n # default assumption that main executable is at lowest\n # addresses. So we're detecting main executable in\n # /proc/self/maps as well.\n $start = HexExtend($1);\n $finish = HexExtend($2);\n $offset = HexExtend($3);\n $lib = $4;\n $lib =~ s|\\\\|/|g; # turn windows-style paths into unix-style paths\n }\n # FreeBSD 10.0 virtual memory map /proc/curproc/map as defined in\n # function procfs_doprocmap (sys/fs/procfs/procfs_map.c)\n #\n # Example:\n # 0x800600000 0x80061a000 26 0 0xfffff800035a0000 r-x 75 33 0x1004 COW NC vnode /libexec/ld-elf.s\n # o.1 NCH -1\n elsif ($l =~ /^(0x$h)\\s(0x$h)\\s\\d+\\s\\d+\\s0x$h\\sr-x\\s\\d+\\s\\d+\\s0x\\d+\\s(COW|NCO)\\s(NC|NNC)\\svnode\\s(\\S+\\.so(\\.\\d+)*)/) {\n $start = HexExtend($1);\n $finish = HexExtend($2);\n $offset = $zero_offset;\n $lib = FindLibrary($5);\n\n } else {\n next;\n }\n\n # Expand \"$build\" variable if available\n $lib =~ s/\\$build\\b/$buildvar/g;\n\n $lib = FindLibrary($lib);\n\n # Check for pre-relocated libraries, which use pre-relocated symbol tables\n # and thus require adjusting the offset that we'll use to translate\n # VM addresses into symbol table addresses.\n # Only do this if we're not going to fetch the symbol table from a\n # debugging copy of the library.\n if (!DebuggingLibrary($lib)) {\n my $text = ParseTextSectionHeader($lib);\n if (defined($text)) {\n my $vma_offset = AddressSub($text->{vma}, $text->{file_offset});\n $offset = AddressAdd($offset, $vma_offset);\n }\n }\n\n if($main::opt_debug) { printf STDERR \"$start:$finish ($offset) $lib\\n\"; }\n push(@{$result}, [$lib, $start, $finish, $offset]);\n }\n\n # Append special entry for additional library (not relocated)\n if ($main::opt_lib ne \"\") {\n my $text = ParseTextSectionHeader($main::opt_lib);\n if (defined($text)) {\n my $start = $text->{vma};\n my $finish = AddressAdd($start, $text->{size});\n\n push(@{$result}, [$main::opt_lib, $start, $finish, $start]);\n }\n }\n\n # Append special entry for the main program. This covers\n # 0..max_pc_value_seen, so that we assume pc values not found in one\n # of the library ranges will be treated as coming from the main\n # program binary.\n my $min_pc = HexExtend(\"0\");\n my $max_pc = $min_pc; # find the maximal PC value in any sample\n foreach my $pc (keys(%{$pcs})) {\n if (HexExtend($pc) gt $max_pc) { $max_pc = HexExtend($pc); }\n }\n push(@{$result}, [$prog, $min_pc, $max_pc, $zero_offset]);\n\n return $result;\n}\n\n# Add two hex addresses of length $address_length.\n# Run jeprof --test for unit test if this is changed.\nsub AddressAdd {\n my $addr1 = shift;\n my $addr2 = shift;\n my $sum;\n\n if ($address_length == 8) {\n # Perl doesn't cope with wraparound arithmetic, so do it explicitly:\n $sum = (hex($addr1)+hex($addr2)) % (0x10000000 * 16);\n return sprintf(\"%08x\", $sum);\n\n } else {\n # Do the addition in 7-nibble chunks to trivialize carry handling.\n\n if ($main::opt_debug and $main::opt_test) {\n print STDERR \"AddressAdd $addr1 + $addr2 = \";\n }\n\n my $a1 = substr($addr1,-7);\n $addr1 = substr($addr1,0,-7);\n my $a2 = substr($addr2,-7);\n $addr2 = substr($addr2,0,-7);\n $sum = hex($a1) + hex($a2);\n my $c = 0;\n if ($sum > 0xfffffff) {\n $c = 1;\n $sum -= 0x10000000;\n }\n my $r = sprintf(\"%07x\", $sum);\n\n $a1 = substr($addr1,-7);\n $addr1 = substr($addr1,0,-7);\n $a2 = substr($addr2,-7);\n $addr2 = substr($addr2,0,-7);\n $sum = hex($a1) + hex($a2) + $c;\n $c = 0;\n if ($sum > 0xfffffff) {\n $c = 1;\n $sum -= 0x10000000;\n }\n $r = sprintf(\"%07x\", $sum) . $r;\n\n $sum = hex($addr1) + hex($addr2) + $c;\n if ($sum > 0xff) { $sum -= 0x100; }\n $r = sprintf(\"%02x\", $sum) . $r;\n\n if ($main::opt_debug and $main::opt_test) { print STDERR \"$r\\n\"; }\n\n return $r;\n }\n}\n\n\n# Subtract two hex addresses of length $address_length.\n# Run jeprof --test for unit test if this is changed.\nsub AddressSub {\n my $addr1 = shift;\n my $addr2 = shift;\n my $diff;\n\n if ($address_length == 8) {\n # Perl doesn't cope with wraparound arithmetic, so do it explicitly:\n $diff = (hex($addr1)-hex($addr2)) % (0x10000000 * 16);\n return sprintf(\"%08x\", $diff);\n\n } else {\n # Do the addition in 7-nibble chunks to trivialize borrow handling.\n # if ($main::opt_debug) { print STDERR \"AddressSub $addr1 - $addr2 = \"; }\n\n my $a1 = hex(substr($addr1,-7));\n $addr1 = substr($addr1,0,-7);\n my $a2 = hex(substr($addr2,-7));\n $addr2 = substr($addr2,0,-7);\n my $b = 0;\n if ($a2 > $a1) {\n $b = 1;\n $a1 += 0x10000000;\n }\n $diff = $a1 - $a2;\n my $r = sprintf(\"%07x\", $diff);\n\n $a1 = hex(substr($addr1,-7));\n $addr1 = substr($addr1,0,-7);\n $a2 = hex(substr($addr2,-7)) + $b;\n $addr2 = substr($addr2,0,-7);\n $b = 0;\n if ($a2 > $a1) {\n $b = 1;\n $a1 += 0x10000000;\n }\n $diff = $a1 - $a2;\n $r = sprintf(\"%07x\", $diff) . $r;\n\n $a1 = hex($addr1);\n $a2 = hex($addr2) + $b;\n if ($a2 > $a1) { $a1 += 0x100; }\n $diff = $a1 - $a2;\n $r = sprintf(\"%02x\", $diff) . $r;\n\n # if ($main::opt_debug) { print STDERR \"$r\\n\"; }\n\n return $r;\n }\n}\n\n# Increment a hex addresses of length $address_length.\n# Run jeprof --test for unit test if this is changed.\nsub AddressInc {\n my $addr = shift;\n my $sum;\n\n if ($address_length == 8) {\n # Perl doesn't cope with wraparound arithmetic, so do it explicitly:\n $sum = (hex($addr)+1) % (0x10000000 * 16);\n return sprintf(\"%08x\", $sum);\n\n } else {\n # Do the addition in 7-nibble chunks to trivialize carry handling.\n # We are always doing this to step through the addresses in a function,\n # and will almost never overflow the first chunk, so we check for this\n # case and exit early.\n\n # if ($main::opt_debug) { print STDERR \"AddressInc $addr1 = \"; }\n\n my $a1 = substr($addr,-7);\n $addr = substr($addr,0,-7);\n $sum = hex($a1) + 1;\n my $r = sprintf(\"%07x\", $sum);\n if ($sum <= 0xfffffff) {\n $r = $addr . $r;\n # if ($main::opt_debug) { print STDERR \"$r\\n\"; }\n return HexExtend($r);\n } else {\n $r = \"0000000\";\n }\n\n $a1 = substr($addr,-7);\n $addr = substr($addr,0,-7);\n $sum = hex($a1) + 1;\n $r = sprintf(\"%07x\", $sum) . $r;\n if ($sum <= 0xfffffff) {\n $r = $addr . $r;\n # if ($main::opt_debug) { print STDERR \"$r\\n\"; }\n return HexExtend($r);\n } else {\n $r = \"00000000000000\";\n }\n\n $sum = hex($addr) + 1;\n if ($sum > 0xff) { $sum -= 0x100; }\n $r = sprintf(\"%02x\", $sum) . $r;\n\n # if ($main::opt_debug) { print STDERR \"$r\\n\"; }\n return $r;\n }\n}\n\n# Extract symbols for all PC values found in profile\nsub ExtractSymbols {\n my $libs = shift;\n my $pcset = shift;\n\n my $symbols = {};\n\n # Map each PC value to the containing library. To make this faster,\n # we sort libraries by their starting pc value (highest first), and\n # advance through the libraries as we advance the pc. Sometimes the\n # addresses of libraries may overlap with the addresses of the main\n # binary, so to make sure the libraries 'win', we iterate over the\n # libraries in reverse order (which assumes the binary doesn't start\n # in the middle of a library, which seems a fair assumption).\n my @pcs = (sort { $a cmp $b } keys(%{$pcset})); # pcset is 0-extended strings\n foreach my $lib (sort {$b->[1] cmp $a->[1]} @{$libs}) {\n my $libname = $lib->[0];\n my $start = $lib->[1];\n my $finish = $lib->[2];\n my $offset = $lib->[3];\n\n # Use debug library if it exists\n my $debug_libname = DebuggingLibrary($libname);\n if ($debug_libname) {\n $libname = $debug_libname;\n }\n\n # Get list of pcs that belong in this library.\n my $contained = [];\n my ($start_pc_index, $finish_pc_index);\n # Find smallest finish_pc_index such that $finish < $pc[$finish_pc_index].\n for ($finish_pc_index = $#pcs + 1; $finish_pc_index > 0;\n $finish_pc_index--) {\n last if $pcs[$finish_pc_index - 1] le $finish;\n }\n # Find smallest start_pc_index such that $start <= $pc[$start_pc_index].\n for ($start_pc_index = $finish_pc_index; $start_pc_index > 0;\n $start_pc_index--) {\n last if $pcs[$start_pc_index - 1] lt $start;\n }\n # This keeps PC values higher than $pc[$finish_pc_index] in @pcs,\n # in case there are overlaps in libraries and the main binary.\n @{$contained} = splice(@pcs, $start_pc_index,\n $finish_pc_index - $start_pc_index);\n # Map to symbols\n MapToSymbols($libname, AddressSub($start, $offset), $contained, $symbols);\n }\n\n return $symbols;\n}\n\n# Map list of PC values to symbols for a given image\nsub MapToSymbols {\n my $image = shift;\n my $offset = shift;\n my $pclist = shift;\n my $symbols = shift;\n\n my $debug = 0;\n\n # Ignore empty binaries\n if ($#{$pclist} < 0) { return; }\n\n # Figure out the addr2line command to use\n my $addr2line = $obj_tool_map{\"addr2line\"};\n my $cmd = ShellEscape($addr2line, \"-f\", \"-C\", \"-e\", $image);\n if (exists $obj_tool_map{\"addr2line_pdb\"}) {\n $addr2line = $obj_tool_map{\"addr2line_pdb\"};\n $cmd = ShellEscape($addr2line, \"--demangle\", \"-f\", \"-C\", \"-e\", $image);\n }\n\n # If \"addr2line\" isn't installed on the system at all, just use\n # nm to get what info we can (function names, but not line numbers).\n if (system(ShellEscape($addr2line, \"--help\") . \" >$dev_null 2>&1\") != 0) {\n MapSymbolsWithNM($image, $offset, $pclist, $symbols);\n return;\n }\n\n # \"addr2line -i\" can produce a variable number of lines per input\n # address, with no separator that allows us to tell when data for\n # the next address starts. So we find the address for a special\n # symbol (_fini) and interleave this address between all real\n # addresses passed to addr2line. The name of this special symbol\n # can then be used as a separator.\n $sep_address = undef; # May be filled in by MapSymbolsWithNM()\n my $nm_symbols = {};\n MapSymbolsWithNM($image, $offset, $pclist, $nm_symbols);\n if (defined($sep_address)) {\n # Only add \" -i\" to addr2line if the binary supports it.\n # addr2line --help returns 0, but not if it sees an unknown flag first.\n if (system(\"$cmd -i --help >$dev_null 2>&1\") == 0) {\n $cmd .= \" -i\";\n } else {\n $sep_address = undef; # no need for sep_address if we don't support -i\n }\n }\n\n # Make file with all PC values with intervening 'sep_address' so\n # that we can reliably detect the end of inlined function list\n open(ADDRESSES, \">$main::tmpfile_sym\") || error(\"$main::tmpfile_sym: $!\\n\");\n if ($debug) { print(\"---- $image ---\\n\"); }\n for (my $i = 0; $i <= $#{$pclist}; $i++) {\n # addr2line always reads hex addresses, and does not need '0x' prefix.\n if ($debug) { printf STDERR (\"%s\\n\", $pclist->[$i]); }\n printf ADDRESSES (\"%s\\n\", AddressSub($pclist->[$i], $offset));\n if (defined($sep_address)) {\n printf ADDRESSES (\"%s\\n\", $sep_address);\n }\n }\n close(ADDRESSES);\n if ($debug) {\n print(\"----\\n\");\n system(\"cat\", $main::tmpfile_sym);\n print(\"----\\n\");\n system(\"$cmd < \" . ShellEscape($main::tmpfile_sym));\n print(\"----\\n\");\n }\n\n open(SYMBOLS, \"$cmd <\" . ShellEscape($main::tmpfile_sym) . \" |\")\n || error(\"$cmd: $!\\n\");\n my $count = 0; # Index in pclist\n while () {\n # Read fullfunction and filelineinfo from next pair of lines\n s/\\r?\\n$//g;\n my $fullfunction = $_;\n $_ = ;\n s/\\r?\\n$//g;\n my $filelinenum = $_;\n\n if (defined($sep_address) && $fullfunction eq $sep_symbol) {\n # Terminating marker for data for this address\n $count++;\n next;\n }\n\n $filelinenum =~ s|\\\\|/|g; # turn windows-style paths into unix-style paths\n\n my $pcstr = $pclist->[$count];\n my $function = ShortFunctionName($fullfunction);\n my $nms = $nm_symbols->{$pcstr};\n if (defined($nms)) {\n if ($fullfunction eq '??') {\n # nm found a symbol for us.\n $function = $nms->[0];\n $fullfunction = $nms->[2];\n } else {\n\t# MapSymbolsWithNM tags each routine with its starting address,\n\t# useful in case the image has multiple occurrences of this\n\t# routine. (It uses a syntax that resembles template parameters,\n\t# that are automatically stripped out by ShortFunctionName().)\n\t# addr2line does not provide the same information. So we check\n\t# if nm disambiguated our symbol, and if so take the annotated\n\t# (nm) version of the routine-name. TODO(csilvers): this won't\n\t# catch overloaded, inlined symbols, which nm doesn't see.\n\t# Better would be to do a check similar to nm's, in this fn.\n\tif ($nms->[2] =~ m/^\\Q$function\\E/) { # sanity check it's the right fn\n\t $function = $nms->[0];\n\t $fullfunction = $nms->[2];\n\t}\n }\n }\n\n # Prepend to accumulated symbols for pcstr\n # (so that caller comes before callee)\n my $sym = $symbols->{$pcstr};\n if (!defined($sym)) {\n $sym = [];\n $symbols->{$pcstr} = $sym;\n }\n unshift(@{$sym}, $function, $filelinenum, $fullfunction);\n if ($debug) { printf STDERR (\"%s => [%s]\\n\", $pcstr, join(\" \", @{$sym})); }\n if (!defined($sep_address)) {\n # Inlining is off, so this entry ends immediately\n $count++;\n }\n }\n close(SYMBOLS);\n}\n\n# Use nm to map the list of referenced PCs to symbols. Return true iff we\n# are able to read procedure information via nm.\nsub MapSymbolsWithNM {\n my $image = shift;\n my $offset = shift;\n my $pclist = shift;\n my $symbols = shift;\n\n # Get nm output sorted by increasing address\n my $symbol_table = GetProcedureBoundaries($image, \".\");\n if (!%{$symbol_table}) {\n return 0;\n }\n # Start addresses are already the right length (8 or 16 hex digits).\n my @names = sort { $symbol_table->{$a}->[0] cmp $symbol_table->{$b}->[0] }\n keys(%{$symbol_table});\n\n if ($#names < 0) {\n # No symbols: just use addresses\n foreach my $pc (@{$pclist}) {\n my $pcstr = \"0x\" . $pc;\n $symbols->{$pc} = [$pcstr, \"?\", $pcstr];\n }\n return 0;\n }\n\n # Sort addresses so we can do a join against nm output\n my $index = 0;\n my $fullname = $names[0];\n my $name = ShortFunctionName($fullname);\n foreach my $pc (sort { $a cmp $b } @{$pclist}) {\n # Adjust for mapped offset\n my $mpc = AddressSub($pc, $offset);\n while (($index < $#names) && ($mpc ge $symbol_table->{$fullname}->[1])){\n $index++;\n $fullname = $names[$index];\n $name = ShortFunctionName($fullname);\n }\n if ($mpc lt $symbol_table->{$fullname}->[1]) {\n $symbols->{$pc} = [$name, \"?\", $fullname];\n } else {\n my $pcstr = \"0x\" . $pc;\n $symbols->{$pc} = [$pcstr, \"?\", $pcstr];\n }\n }\n return 1;\n}\n\nsub ShortFunctionName {\n my $function = shift;\n while ($function =~ s/\\([^()]*\\)(\\s*const)?//g) { } # Argument types\n while ($function =~ s/<[^<>]*>//g) { } # Remove template arguments\n $function =~ s/^.*\\s+(\\w+::)/$1/; # Remove leading type\n return $function;\n}\n\n# Trim overly long symbols found in disassembler output\nsub CleanDisassembly {\n my $d = shift;\n while ($d =~ s/\\([^()%]*\\)(\\s*const)?//g) { } # Argument types, not (%rax)\n while ($d =~ s/(\\w+)<[^<>]*>/$1/g) { } # Remove template arguments\n return $d;\n}\n\n# Clean file name for display\nsub CleanFileName {\n my ($f) = @_;\n $f =~ s|^/proc/self/cwd/||;\n $f =~ s|^\\./||;\n return $f;\n}\n\n# Make address relative to section and clean up for display\nsub UnparseAddress {\n my ($offset, $address) = @_;\n $address = AddressSub($address, $offset);\n $address =~ s/^0x//;\n $address =~ s/^0*//;\n return $address;\n}\n\n##### Miscellaneous #####\n\n# Find the right versions of the above object tools to use. The\n# argument is the program file being analyzed, and should be an ELF\n# 32-bit or ELF 64-bit executable file. The location of the tools\n# is determined by considering the following options in this order:\n# 1) --tools option, if set\n# 2) JEPROF_TOOLS environment variable, if set\n# 3) the environment\nsub ConfigureObjTools {\n my $prog_file = shift;\n\n # Check for the existence of $prog_file because /usr/bin/file does not\n # predictably return error status in prod.\n (-e $prog_file) || error(\"$prog_file does not exist.\\n\");\n\n my $file_type = undef;\n if (-e \"/usr/bin/file\") {\n # Follow symlinks (at least for systems where \"file\" supports that).\n my $escaped_prog_file = ShellEscape($prog_file);\n $file_type = `/usr/bin/file -L $escaped_prog_file 2>$dev_null ||\n /usr/bin/file $escaped_prog_file`;\n } elsif ($^O == \"MSWin32\") {\n $file_type = \"MS Windows\";\n } else {\n print STDERR \"WARNING: Can't determine the file type of $prog_file\";\n }\n\n if ($file_type =~ /64-bit/) {\n # Change $address_length to 16 if the program file is ELF 64-bit.\n # We can't detect this from many (most?) heap or lock contention\n # profiles, since the actual addresses referenced are generally in low\n # memory even for 64-bit programs.\n $address_length = 16;\n }\n\n if ($file_type =~ /MS Windows/) {\n # For windows, we provide a version of nm and addr2line as part of\n # the opensource release, which is capable of parsing\n # Windows-style PDB executables. It should live in the path, or\n # in the same directory as jeprof.\n $obj_tool_map{\"nm_pdb\"} = \"nm-pdb\";\n $obj_tool_map{\"addr2line_pdb\"} = \"addr2line-pdb\";\n }\n\n if ($file_type =~ /Mach-O/) {\n # OS X uses otool to examine Mach-O files, rather than objdump.\n $obj_tool_map{\"otool\"} = \"otool\";\n $obj_tool_map{\"addr2line\"} = \"false\"; # no addr2line\n $obj_tool_map{\"objdump\"} = \"false\"; # no objdump\n }\n\n # Go fill in %obj_tool_map with the pathnames to use:\n foreach my $tool (keys %obj_tool_map) {\n $obj_tool_map{$tool} = ConfigureTool($obj_tool_map{$tool});\n }\n}\n\n# Returns the path of a caller-specified object tool. If --tools or\n# JEPROF_TOOLS are specified, then returns the full path to the tool\n# with that prefix. Otherwise, returns the path unmodified (which\n# means we will look for it on PATH).\nsub ConfigureTool {\n my $tool = shift;\n my $path;\n\n # --tools (or $JEPROF_TOOLS) is a comma separated list, where each\n # item is either a) a pathname prefix, or b) a map of the form\n # :. First we look for an entry of type (b) for our\n # tool. If one is found, we use it. Otherwise, we consider all the\n # pathname prefixes in turn, until one yields an existing file. If\n # none does, we use a default path.\n my $tools = $main::opt_tools || $ENV{\"JEPROF_TOOLS\"} || \"\";\n if ($tools =~ m/(,|^)\\Q$tool\\E:([^,]*)/) {\n $path = $2;\n # TODO(csilvers): sanity-check that $path exists? Hard if it's relative.\n } elsif ($tools ne '') {\n foreach my $prefix (split(',', $tools)) {\n next if ($prefix =~ /:/); # ignore \"tool:fullpath\" entries in the list\n if (-x $prefix . $tool) {\n $path = $prefix . $tool;\n last;\n }\n }\n if (!$path) {\n error(\"No '$tool' found with prefix specified by \" .\n \"--tools (or \\$JEPROF_TOOLS) '$tools'\\n\");\n }\n } else {\n # ... otherwise use the version that exists in the same directory as\n # jeprof. If there's nothing there, use $PATH.\n $0 =~ m,[^/]*$,; # this is everything after the last slash\n my $dirname = $`; # this is everything up to and including the last slash\n if (-x \"$dirname$tool\") {\n $path = \"$dirname$tool\";\n } else {\n $path = $tool;\n }\n }\n if ($main::opt_debug) { print STDERR \"Using '$path' for '$tool'.\\n\"; }\n return $path;\n}\n\nsub ShellEscape {\n my @escaped_words = ();\n foreach my $word (@_) {\n my $escaped_word = $word;\n if ($word =~ m![^a-zA-Z0-9/.,_=-]!) { # check for anything not in whitelist\n $escaped_word =~ s/'/'\\\\''/;\n $escaped_word = \"'$escaped_word'\";\n }\n push(@escaped_words, $escaped_word);\n }\n return join(\" \", @escaped_words);\n}\n\nsub cleanup {\n unlink($main::tmpfile_sym);\n unlink(keys %main::tempnames);\n\n # We leave any collected profiles in $HOME/jeprof in case the user wants\n # to look at them later. We print a message informing them of this.\n if ((scalar(@main::profile_files) > 0) &&\n defined($main::collected_profile)) {\n if (scalar(@main::profile_files) == 1) {\n print STDERR \"Dynamically gathered profile is in $main::collected_profile\\n\";\n }\n print STDERR \"If you want to investigate this profile further, you can do:\\n\";\n print STDERR \"\\n\";\n print STDERR \" jeprof \\\\\\n\";\n print STDERR \" $main::prog \\\\\\n\";\n print STDERR \" $main::collected_profile\\n\";\n print STDERR \"\\n\";\n }\n}\n\nsub sighandler {\n cleanup();\n exit(1);\n}\n\nsub error {\n my $msg = shift;\n print STDERR $msg;\n cleanup();\n exit(1);\n}\n\n\n# Run $nm_command and get all the resulting procedure boundaries whose\n# names match \"$regexp\" and returns them in a hashtable mapping from\n# procedure name to a two-element vector of [start address, end address]\nsub GetProcedureBoundariesViaNm {\n my $escaped_nm_command = shift; # shell-escaped\n my $regexp = shift;\n\n my $symbol_table = {};\n open(NM, \"$escaped_nm_command |\") || error(\"$escaped_nm_command: $!\\n\");\n my $last_start = \"0\";\n my $routine = \"\";\n while () {\n s/\\r//g; # turn windows-looking lines into unix-looking lines\n if (m/^\\s*([0-9a-f]+) (.) (..*)/) {\n my $start_val = $1;\n my $type = $2;\n my $this_routine = $3;\n\n # It's possible for two symbols to share the same address, if\n # one is a zero-length variable (like __start_google_malloc) or\n # one symbol is a weak alias to another (like __libc_malloc).\n # In such cases, we want to ignore all values except for the\n # actual symbol, which in nm-speak has type \"T\". The logic\n # below does this, though it's a bit tricky: what happens when\n # we have a series of lines with the same address, is the first\n # one gets queued up to be processed. However, it won't\n # *actually* be processed until later, when we read a line with\n # a different address. That means that as long as we're reading\n # lines with the same address, we have a chance to replace that\n # item in the queue, which we do whenever we see a 'T' entry --\n # that is, a line with type 'T'. If we never see a 'T' entry,\n # we'll just go ahead and process the first entry (which never\n # got touched in the queue), and ignore the others.\n if ($start_val eq $last_start && $type =~ /t/i) {\n # We are the 'T' symbol at this address, replace previous symbol.\n $routine = $this_routine;\n next;\n } elsif ($start_val eq $last_start) {\n # We're not the 'T' symbol at this address, so ignore us.\n next;\n }\n\n if ($this_routine eq $sep_symbol) {\n $sep_address = HexExtend($start_val);\n }\n\n # Tag this routine with the starting address in case the image\n # has multiple occurrences of this routine. We use a syntax\n # that resembles template parameters that are automatically\n # stripped out by ShortFunctionName()\n $this_routine .= \"<$start_val>\";\n\n if (defined($routine) && $routine =~ m/$regexp/) {\n $symbol_table->{$routine} = [HexExtend($last_start),\n HexExtend($start_val)];\n }\n $last_start = $start_val;\n $routine = $this_routine;\n } elsif (m/^Loaded image name: (.+)/) {\n # The win32 nm workalike emits information about the binary it is using.\n if ($main::opt_debug) { print STDERR \"Using Image $1\\n\"; }\n } elsif (m/^PDB file name: (.+)/) {\n # The win32 nm workalike emits information about the pdb it is using.\n if ($main::opt_debug) { print STDERR \"Using PDB $1\\n\"; }\n }\n }\n close(NM);\n # Handle the last line in the nm output. Unfortunately, we don't know\n # how big this last symbol is, because we don't know how big the file\n # is. For now, we just give it a size of 0.\n # TODO(csilvers): do better here.\n if (defined($routine) && $routine =~ m/$regexp/) {\n $symbol_table->{$routine} = [HexExtend($last_start),\n HexExtend($last_start)];\n }\n return $symbol_table;\n}\n\n# Gets the procedure boundaries for all routines in \"$image\" whose names\n# match \"$regexp\" and returns them in a hashtable mapping from procedure\n# name to a two-element vector of [start address, end address].\n# Will return an empty map if nm is not installed or not working properly.\nsub GetProcedureBoundaries {\n my $image = shift;\n my $regexp = shift;\n\n # If $image doesn't start with /, then put ./ in front of it. This works\n # around an obnoxious bug in our probing of nm -f behavior.\n # \"nm -f $image\" is supposed to fail on GNU nm, but if:\n #\n # a. $image starts with [BbSsPp] (for example, bin/foo/bar), AND\n # b. you have a.out in your current directory (a not uncommon occurrence)\n #\n # then \"nm -f $image\" succeeds because -f only looks at the first letter of\n # the argument, which looks valid because it's [BbSsPp], and then since\n # there's no image provided, it looks for a.out and finds it.\n #\n # This regex makes sure that $image starts with . or /, forcing the -f\n # parsing to fail since . and / are not valid formats.\n $image =~ s#^[^/]#./$&#;\n\n # For libc libraries, the copy in /usr/lib/debug contains debugging symbols\n my $debugging = DebuggingLibrary($image);\n if ($debugging) {\n $image = $debugging;\n }\n\n my $nm = $obj_tool_map{\"nm\"};\n my $cppfilt = $obj_tool_map{\"c++filt\"};\n\n # nm can fail for two reasons: 1) $image isn't a debug library; 2) nm\n # binary doesn't support --demangle. In addition, for OS X we need\n # to use the -f flag to get 'flat' nm output (otherwise we don't sort\n # properly and get incorrect results). Unfortunately, GNU nm uses -f\n # in an incompatible way. So first we test whether our nm supports\n # --demangle and -f.\n my $demangle_flag = \"\";\n my $cppfilt_flag = \"\";\n my $to_devnull = \">$dev_null 2>&1\";\n if (system(ShellEscape($nm, \"--demangle\", $image) . $to_devnull) == 0) {\n # In this mode, we do \"nm --demangle \"\n $demangle_flag = \"--demangle\";\n $cppfilt_flag = \"\";\n } elsif (system(ShellEscape($cppfilt, $image) . $to_devnull) == 0) {\n # In this mode, we do \"nm | c++filt\"\n $cppfilt_flag = \" | \" . ShellEscape($cppfilt);\n };\n my $flatten_flag = \"\";\n if (system(ShellEscape($nm, \"-f\", $image) . $to_devnull) == 0) {\n $flatten_flag = \"-f\";\n }\n\n # Finally, in the case $imagie isn't a debug library, we try again with\n # -D to at least get *exported* symbols. If we can't use --demangle,\n # we use c++filt instead, if it exists on this system.\n my @nm_commands = (ShellEscape($nm, \"-n\", $flatten_flag, $demangle_flag,\n $image) . \" 2>$dev_null $cppfilt_flag\",\n ShellEscape($nm, \"-D\", \"-n\", $flatten_flag, $demangle_flag,\n $image) . \" 2>$dev_null $cppfilt_flag\",\n # 6nm is for Go binaries\n ShellEscape(\"6nm\", \"$image\") . \" 2>$dev_null | sort\",\n );\n\n # If the executable is an MS Windows PDB-format executable, we'll\n # have set up obj_tool_map(\"nm_pdb\"). In this case, we actually\n # want to use both unix nm and windows-specific nm_pdb, since\n # PDB-format executables can apparently include dwarf .o files.\n if (exists $obj_tool_map{\"nm_pdb\"}) {\n push(@nm_commands,\n ShellEscape($obj_tool_map{\"nm_pdb\"}, \"--demangle\", $image)\n . \" 2>$dev_null\");\n }\n\n foreach my $nm_command (@nm_commands) {\n my $symbol_table = GetProcedureBoundariesViaNm($nm_command, $regexp);\n return $symbol_table if (%{$symbol_table});\n }\n my $symbol_table = {};\n return $symbol_table;\n}\n\n\n# The test vectors for AddressAdd/Sub/Inc are 8-16-nibble hex strings.\n# To make them more readable, we add underscores at interesting places.\n# This routine removes the underscores, producing the canonical representation\n# used by jeprof to represent addresses, particularly in the tested routines.\nsub CanonicalHex {\n my $arg = shift;\n return join '', (split '_',$arg);\n}\n\n\n# Unit test for AddressAdd:\nsub AddressAddUnitTest {\n my $test_data_8 = shift;\n my $test_data_16 = shift;\n my $error_count = 0;\n my $fail_count = 0;\n my $pass_count = 0;\n # print STDERR \"AddressAddUnitTest: \", 1+$#{$test_data_8}, \" tests\\n\";\n\n # First a few 8-nibble addresses. Note that this implementation uses\n # plain old arithmetic, so a quick sanity check along with verifying what\n # happens to overflow (we want it to wrap):\n $address_length = 8;\n foreach my $row (@{$test_data_8}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressAdd ($row->[0], $row->[1]);\n if ($sum ne $row->[2]) {\n printf STDERR \"ERROR: %s != %s + %s = %s\\n\", $sum,\n $row->[0], $row->[1], $row->[2];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressAdd 32-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count = $fail_count;\n $fail_count = 0;\n $pass_count = 0;\n\n # Now 16-nibble addresses.\n $address_length = 16;\n foreach my $row (@{$test_data_16}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressAdd (CanonicalHex($row->[0]), CanonicalHex($row->[1]));\n my $expected = join '', (split '_',$row->[2]);\n if ($sum ne CanonicalHex($row->[2])) {\n printf STDERR \"ERROR: %s != %s + %s = %s\\n\", $sum,\n $row->[0], $row->[1], $row->[2];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressAdd 64-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count += $fail_count;\n\n return $error_count;\n}\n\n\n# Unit test for AddressSub:\nsub AddressSubUnitTest {\n my $test_data_8 = shift;\n my $test_data_16 = shift;\n my $error_count = 0;\n my $fail_count = 0;\n my $pass_count = 0;\n # print STDERR \"AddressSubUnitTest: \", 1+$#{$test_data_8}, \" tests\\n\";\n\n # First a few 8-nibble addresses. Note that this implementation uses\n # plain old arithmetic, so a quick sanity check along with verifying what\n # happens to overflow (we want it to wrap):\n $address_length = 8;\n foreach my $row (@{$test_data_8}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressSub ($row->[0], $row->[1]);\n if ($sum ne $row->[3]) {\n printf STDERR \"ERROR: %s != %s - %s = %s\\n\", $sum,\n $row->[0], $row->[1], $row->[3];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressSub 32-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count = $fail_count;\n $fail_count = 0;\n $pass_count = 0;\n\n # Now 16-nibble addresses.\n $address_length = 16;\n foreach my $row (@{$test_data_16}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressSub (CanonicalHex($row->[0]), CanonicalHex($row->[1]));\n if ($sum ne CanonicalHex($row->[3])) {\n printf STDERR \"ERROR: %s != %s - %s = %s\\n\", $sum,\n $row->[0], $row->[1], $row->[3];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressSub 64-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count += $fail_count;\n\n return $error_count;\n}\n\n\n# Unit test for AddressInc:\nsub AddressIncUnitTest {\n my $test_data_8 = shift;\n my $test_data_16 = shift;\n my $error_count = 0;\n my $fail_count = 0;\n my $pass_count = 0;\n # print STDERR \"AddressIncUnitTest: \", 1+$#{$test_data_8}, \" tests\\n\";\n\n # First a few 8-nibble addresses. Note that this implementation uses\n # plain old arithmetic, so a quick sanity check along with verifying what\n # happens to overflow (we want it to wrap):\n $address_length = 8;\n foreach my $row (@{$test_data_8}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressInc ($row->[0]);\n if ($sum ne $row->[4]) {\n printf STDERR \"ERROR: %s != %s + 1 = %s\\n\", $sum,\n $row->[0], $row->[4];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressInc 32-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count = $fail_count;\n $fail_count = 0;\n $pass_count = 0;\n\n # Now 16-nibble addresses.\n $address_length = 16;\n foreach my $row (@{$test_data_16}) {\n if ($main::opt_debug and $main::opt_test) { print STDERR \"@{$row}\\n\"; }\n my $sum = AddressInc (CanonicalHex($row->[0]));\n if ($sum ne CanonicalHex($row->[4])) {\n printf STDERR \"ERROR: %s != %s + 1 = %s\\n\", $sum,\n $row->[0], $row->[4];\n ++$fail_count;\n } else {\n ++$pass_count;\n }\n }\n printf STDERR \"AddressInc 64-bit tests: %d passes, %d failures\\n\",\n $pass_count, $fail_count;\n $error_count += $fail_count;\n\n return $error_count;\n}\n\n\n# Driver for unit tests.\n# Currently just the address add/subtract/increment routines for 64-bit.\nsub RunUnitTests {\n my $error_count = 0;\n\n # This is a list of tuples [a, b, a+b, a-b, a+1]\n my $unit_test_data_8 = [\n [qw(aaaaaaaa 50505050 fafafafa 5a5a5a5a aaaaaaab)],\n [qw(50505050 aaaaaaaa fafafafa a5a5a5a6 50505051)],\n [qw(ffffffff aaaaaaaa aaaaaaa9 55555555 00000000)],\n [qw(00000001 ffffffff 00000000 00000002 00000002)],\n [qw(00000001 fffffff0 fffffff1 00000011 00000002)],\n ];\n my $unit_test_data_16 = [\n # The implementation handles data in 7-nibble chunks, so those are the\n # interesting boundaries.\n [qw(aaaaaaaa 50505050\n 00_000000f_afafafa 00_0000005_a5a5a5a 00_000000a_aaaaaab)],\n [qw(50505050 aaaaaaaa\n 00_000000f_afafafa ff_ffffffa_5a5a5a6 00_0000005_0505051)],\n [qw(ffffffff aaaaaaaa\n 00_000001a_aaaaaa9 00_0000005_5555555 00_0000010_0000000)],\n [qw(00000001 ffffffff\n 00_0000010_0000000 ff_ffffff0_0000002 00_0000000_0000002)],\n [qw(00000001 fffffff0\n 00_000000f_ffffff1 ff_ffffff0_0000011 00_0000000_0000002)],\n\n [qw(00_a00000a_aaaaaaa 50505050\n 00_a00000f_afafafa 00_a000005_a5a5a5a 00_a00000a_aaaaaab)],\n [qw(0f_fff0005_0505050 aaaaaaaa\n 0f_fff000f_afafafa 0f_ffefffa_5a5a5a6 0f_fff0005_0505051)],\n [qw(00_000000f_fffffff 01_800000a_aaaaaaa\n 01_800001a_aaaaaa9 fe_8000005_5555555 00_0000010_0000000)],\n [qw(00_0000000_0000001 ff_fffffff_fffffff\n 00_0000000_0000000 00_0000000_0000002 00_0000000_0000002)],\n [qw(00_0000000_0000001 ff_fffffff_ffffff0\n ff_fffffff_ffffff1 00_0000000_0000011 00_0000000_0000002)],\n ];\n\n $error_count += AddressAddUnitTest($unit_test_data_8, $unit_test_data_16);\n $error_count += AddressSubUnitTest($unit_test_data_8, $unit_test_data_16);\n $error_count += AddressIncUnitTest($unit_test_data_8, $unit_test_data_16);\n if ($error_count > 0) {\n print STDERR $error_count, \" errors: FAILED\\n\";\n } else {\n print STDERR \"PASS\\n\";\n }\n exit ($error_count);\n}\n" }, { "path": "deps/jemalloc/build-aux/config.guess", "content": "#! /bin/sh\n# Attempt to guess a canonical system name.\n# Copyright 1992-2021 Free Software Foundation, Inc.\n\ntimestamp='2021-01-01'\n\n# This file is free software; you can redistribute it and/or modify it\n# under the terms of the GNU General Public License as published by\n# the Free Software Foundation; either version 3 of the License, or\n# (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful, but\n# WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n# General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with this program; if not, see .\n#\n# As a special exception to the GNU General Public License, if you\n# distribute this file as part of a program that contains a\n# configuration script generated by Autoconf, you may include it under\n# the same distribution terms that you use for the rest of that\n# program. This Exception is an additional permission under section 7\n# of the GNU General Public License, version 3 (\"GPLv3\").\n#\n# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.\n#\n# You can get the latest version of this script from:\n# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess\n#\n# Please send patches to .\n\n\nme=$(echo \"$0\" | sed -e 's,.*/,,')\n\nusage=\"\\\nUsage: $0 [OPTION]\n\nOutput the configuration name of the system \\`$me' is run on.\n\nOptions:\n -h, --help print this help, then exit\n -t, --time-stamp print date of last modification, then exit\n -v, --version print version number, then exit\n\nReport bugs and patches to .\"\n\nversion=\"\\\nGNU config.guess ($timestamp)\n\nOriginally written by Per Bothner.\nCopyright 1992-2021 Free Software Foundation, Inc.\n\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\"\n\nhelp=\"\nTry \\`$me --help' for more information.\"\n\n# Parse command line\nwhile test $# -gt 0 ; do\n case $1 in\n --time-stamp | --time* | -t )\n echo \"$timestamp\" ; exit ;;\n --version | -v )\n echo \"$version\" ; exit ;;\n --help | --h* | -h )\n echo \"$usage\"; exit ;;\n -- ) # Stop option processing\n shift; break ;;\n - )\t# Use stdin as input.\n break ;;\n -* )\n echo \"$me: invalid option $1$help\" >&2\n exit 1 ;;\n * )\n break ;;\n esac\ndone\n\nif test $# != 0; then\n echo \"$me: too many arguments$help\" >&2\n exit 1\nfi\n\n# CC_FOR_BUILD -- compiler used by this script. Note that the use of a\n# compiler to aid in system detection is discouraged as it requires\n# temporary files to be created and, as you can see below, it is a\n# headache to deal with in a portable fashion.\n\n# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still\n# use `HOST_CC' if defined, but it is deprecated.\n\n# Portable tmp directory creation inspired by the Autoconf team.\n\ntmp=\n# shellcheck disable=SC2172\ntrap 'test -z \"$tmp\" || rm -fr \"$tmp\"' 0 1 2 13 15\n\nset_cc_for_build() {\n # prevent multiple calls if $tmp is already set\n test \"$tmp\" && return 0\n : \"${TMPDIR=/tmp}\"\n # shellcheck disable=SC2039\n { tmp=$( (umask 077 && mktemp -d \"$TMPDIR/cgXXXXXX\") 2>/dev/null) && test -n \"$tmp\" && test -d \"$tmp\" ; } ||\n\t{ test -n \"$RANDOM\" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir \"$tmp\" 2>/dev/null) ; } ||\n\t{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir \"$tmp\" 2>/dev/null) && echo \"Warning: creating insecure temp directory\" >&2 ; } ||\n\t{ echo \"$me: cannot create a temporary directory in $TMPDIR\" >&2 ; exit 1 ; }\n dummy=$tmp/dummy\n case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in\n\t,,) echo \"int x;\" > \"$dummy.c\"\n\t for driver in cc gcc c89 c99 ; do\n\t\t if ($driver -c -o \"$dummy.o\" \"$dummy.c\") >/dev/null 2>&1 ; then\n\t\t CC_FOR_BUILD=\"$driver\"\n\t\t break\n\t\t fi\n\t done\n\t if test x\"$CC_FOR_BUILD\" = x ; then\n\t\t CC_FOR_BUILD=no_compiler_found\n\t fi\n\t ;;\n\t,,*) CC_FOR_BUILD=$CC ;;\n\t,*,*) CC_FOR_BUILD=$HOST_CC ;;\n esac\n}\n\n# This is needed to find uname on a Pyramid OSx when run in the BSD universe.\n# (ghazi@noc.rutgers.edu 1994-08-24)\nif test -f /.attbin/uname ; then\n\tPATH=$PATH:/.attbin ; export PATH\nfi\n\nUNAME_MACHINE=$( (uname -m) 2>/dev/null) || UNAME_MACHINE=unknown\nUNAME_RELEASE=$( (uname -r) 2>/dev/null) || UNAME_RELEASE=unknown\nUNAME_SYSTEM=$( (uname -s) 2>/dev/null) || UNAME_SYSTEM=unknown\nUNAME_VERSION=$( (uname -v) 2>/dev/null) || UNAME_VERSION=unknown\n\ncase \"$UNAME_SYSTEM\" in\nLinux|GNU|GNU/*)\n\tLIBC=unknown\n\n\tset_cc_for_build\n\tcat <<-EOF > \"$dummy.c\"\n\t#include \n\t#if defined(__UCLIBC__)\n\tLIBC=uclibc\n\t#elif defined(__dietlibc__)\n\tLIBC=dietlibc\n\t#elif defined(__GLIBC__)\n\tLIBC=gnu\n\t#else\n\t#include \n\t/* First heuristic to detect musl libc. */\n\t#ifdef __DEFINED_va_list\n\tLIBC=musl\n\t#endif\n\t#endif\n\tEOF\n\teval \"$($CC_FOR_BUILD -E \"$dummy.c\" 2>/dev/null | grep '^LIBC' | sed 's, ,,g')\"\n\n\t# Second heuristic to detect musl libc.\n\tif [ \"$LIBC\" = unknown ] &&\n\t command -v ldd >/dev/null &&\n\t ldd --version 2>&1 | grep -q ^musl; then\n\t\tLIBC=musl\n\tfi\n\n\t# If the system lacks a compiler, then just pick glibc.\n\t# We could probably try harder.\n\tif [ \"$LIBC\" = unknown ]; then\n\t\tLIBC=gnu\n\tfi\n\t;;\nesac\n\n# Note: order is significant - the case branches are not exclusive.\n\ncase \"$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION\" in\n *:NetBSD:*:*)\n\t# NetBSD (nbsd) targets should (where applicable) match one or\n\t# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,\n\t# *-*-netbsdecoff* and *-*-netbsd*. For targets that recently\n\t# switched to ELF, *-*-netbsd* would select the old\n\t# object file format. This provides both forward\n\t# compatibility and a consistent mechanism for selecting the\n\t# object file format.\n\t#\n\t# Note: NetBSD doesn't particularly care about the vendor\n\t# portion of the name. We always set it to \"unknown\".\n\tsysctl=\"sysctl -n hw.machine_arch\"\n\tUNAME_MACHINE_ARCH=$( (uname -p 2>/dev/null || \\\n\t \"/sbin/$sysctl\" 2>/dev/null || \\\n\t \"/usr/sbin/$sysctl\" 2>/dev/null || \\\n\t echo unknown))\n\tcase \"$UNAME_MACHINE_ARCH\" in\n\t aarch64eb) machine=aarch64_be-unknown ;;\n\t armeb) machine=armeb-unknown ;;\n\t arm*) machine=arm-unknown ;;\n\t sh3el) machine=shl-unknown ;;\n\t sh3eb) machine=sh-unknown ;;\n\t sh5el) machine=sh5le-unknown ;;\n\t earmv*)\n\t\tarch=$(echo \"$UNAME_MACHINE_ARCH\" | sed -e 's,^e\\(armv[0-9]\\).*$,\\1,')\n\t\tendian=$(echo \"$UNAME_MACHINE_ARCH\" | sed -ne 's,^.*\\(eb\\)$,\\1,p')\n\t\tmachine=\"${arch}${endian}\"-unknown\n\t\t;;\n\t *) machine=\"$UNAME_MACHINE_ARCH\"-unknown ;;\n\tesac\n\t# The Operating System including object format, if it has switched\n\t# to ELF recently (or will in the future) and ABI.\n\tcase \"$UNAME_MACHINE_ARCH\" in\n\t earm*)\n\t\tos=netbsdelf\n\t\t;;\n\t arm*|i386|m68k|ns32k|sh3*|sparc|vax)\n\t\tset_cc_for_build\n\t\tif echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \\\n\t\t\t| grep -q __ELF__\n\t\tthen\n\t\t # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).\n\t\t # Return netbsd for either. FIX?\n\t\t os=netbsd\n\t\telse\n\t\t os=netbsdelf\n\t\tfi\n\t\t;;\n\t *)\n\t\tos=netbsd\n\t\t;;\n\tesac\n\t# Determine ABI tags.\n\tcase \"$UNAME_MACHINE_ARCH\" in\n\t earm*)\n\t\texpr='s/^earmv[0-9]/-eabi/;s/eb$//'\n\t\tabi=$(echo \"$UNAME_MACHINE_ARCH\" | sed -e \"$expr\")\n\t\t;;\n\tesac\n\t# The OS release\n\t# Debian GNU/NetBSD machines have a different userland, and\n\t# thus, need a distinct triplet. However, they do not need\n\t# kernel version information, so it can be replaced with a\n\t# suitable tag, in the style of linux-gnu.\n\tcase \"$UNAME_VERSION\" in\n\t Debian*)\n\t\trelease='-gnu'\n\t\t;;\n\t *)\n\t\trelease=$(echo \"$UNAME_RELEASE\" | sed -e 's/[-_].*//' | cut -d. -f1,2)\n\t\t;;\n\tesac\n\t# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:\n\t# contains redundant information, the shorter form:\n\t# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.\n\techo \"$machine-${os}${release}${abi-}\"\n\texit ;;\n *:Bitrig:*:*)\n\tUNAME_MACHINE_ARCH=$(arch | sed 's/Bitrig.//')\n\techo \"$UNAME_MACHINE_ARCH\"-unknown-bitrig\"$UNAME_RELEASE\"\n\texit ;;\n *:OpenBSD:*:*)\n\tUNAME_MACHINE_ARCH=$(arch | sed 's/OpenBSD.//')\n\techo \"$UNAME_MACHINE_ARCH\"-unknown-openbsd\"$UNAME_RELEASE\"\n\texit ;;\n *:LibertyBSD:*:*)\n\tUNAME_MACHINE_ARCH=$(arch | sed 's/^.*BSD\\.//')\n\techo \"$UNAME_MACHINE_ARCH\"-unknown-libertybsd\"$UNAME_RELEASE\"\n\texit ;;\n *:MidnightBSD:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-midnightbsd\"$UNAME_RELEASE\"\n\texit ;;\n *:ekkoBSD:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-ekkobsd\"$UNAME_RELEASE\"\n\texit ;;\n *:SolidBSD:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-solidbsd\"$UNAME_RELEASE\"\n\texit ;;\n *:OS108:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-os108_\"$UNAME_RELEASE\"\n\texit ;;\n macppc:MirBSD:*:*)\n\techo powerpc-unknown-mirbsd\"$UNAME_RELEASE\"\n\texit ;;\n *:MirBSD:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-mirbsd\"$UNAME_RELEASE\"\n\texit ;;\n *:Sortix:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-sortix\n\texit ;;\n *:Twizzler:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-twizzler\n\texit ;;\n *:Redox:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-redox\n\texit ;;\n mips:OSF1:*.*)\n\techo mips-dec-osf1\n\texit ;;\n alpha:OSF1:*:*)\n\tcase $UNAME_RELEASE in\n\t*4.0)\n\t\tUNAME_RELEASE=$(/usr/sbin/sizer -v | awk '{print $3}')\n\t\t;;\n\t*5.*)\n\t\tUNAME_RELEASE=$(/usr/sbin/sizer -v | awk '{print $4}')\n\t\t;;\n\tesac\n\t# According to Compaq, /usr/sbin/psrinfo has been available on\n\t# OSF/1 and Tru64 systems produced since 1995. I hope that\n\t# covers most systems running today. This code pipes the CPU\n\t# types through head -n 1, so we only detect the type of CPU 0.\n\tALPHA_CPU_TYPE=$(/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \\(.*\\) processor.*$/\\1/p' | head -n 1)\n\tcase \"$ALPHA_CPU_TYPE\" in\n\t \"EV4 (21064)\")\n\t\tUNAME_MACHINE=alpha ;;\n\t \"EV4.5 (21064)\")\n\t\tUNAME_MACHINE=alpha ;;\n\t \"LCA4 (21066/21068)\")\n\t\tUNAME_MACHINE=alpha ;;\n\t \"EV5 (21164)\")\n\t\tUNAME_MACHINE=alphaev5 ;;\n\t \"EV5.6 (21164A)\")\n\t\tUNAME_MACHINE=alphaev56 ;;\n\t \"EV5.6 (21164PC)\")\n\t\tUNAME_MACHINE=alphapca56 ;;\n\t \"EV5.7 (21164PC)\")\n\t\tUNAME_MACHINE=alphapca57 ;;\n\t \"EV6 (21264)\")\n\t\tUNAME_MACHINE=alphaev6 ;;\n\t \"EV6.7 (21264A)\")\n\t\tUNAME_MACHINE=alphaev67 ;;\n\t \"EV6.8CB (21264C)\")\n\t\tUNAME_MACHINE=alphaev68 ;;\n\t \"EV6.8AL (21264B)\")\n\t\tUNAME_MACHINE=alphaev68 ;;\n\t \"EV6.8CX (21264D)\")\n\t\tUNAME_MACHINE=alphaev68 ;;\n\t \"EV6.9A (21264/EV69A)\")\n\t\tUNAME_MACHINE=alphaev69 ;;\n\t \"EV7 (21364)\")\n\t\tUNAME_MACHINE=alphaev7 ;;\n\t \"EV7.9 (21364A)\")\n\t\tUNAME_MACHINE=alphaev79 ;;\n\tesac\n\t# A Pn.n version is a patched version.\n\t# A Vn.n version is a released version.\n\t# A Tn.n version is a released field test version.\n\t# A Xn.n version is an unreleased experimental baselevel.\n\t# 1.2 uses \"1.2\" for uname -r.\n\techo \"$UNAME_MACHINE\"-dec-osf\"$(echo \"$UNAME_RELEASE\" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz)\"\n\t# Reset EXIT trap before exiting to avoid spurious non-zero exit code.\n\texitcode=$?\n\ttrap '' 0\n\texit $exitcode ;;\n Amiga*:UNIX_System_V:4.0:*)\n\techo m68k-unknown-sysv4\n\texit ;;\n *:[Aa]miga[Oo][Ss]:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-amigaos\n\texit ;;\n *:[Mm]orph[Oo][Ss]:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-morphos\n\texit ;;\n *:OS/390:*:*)\n\techo i370-ibm-openedition\n\texit ;;\n *:z/VM:*:*)\n\techo s390-ibm-zvmoe\n\texit ;;\n *:OS400:*:*)\n\techo powerpc-ibm-os400\n\texit ;;\n arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)\n\techo arm-acorn-riscix\"$UNAME_RELEASE\"\n\texit ;;\n arm*:riscos:*:*|arm*:RISCOS:*:*)\n\techo arm-unknown-riscos\n\texit ;;\n SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)\n\techo hppa1.1-hitachi-hiuxmpp\n\texit ;;\n Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)\n\t# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.\n\tif test \"$( (/bin/universe) 2>/dev/null)\" = att ; then\n\t\techo pyramid-pyramid-sysv3\n\telse\n\t\techo pyramid-pyramid-bsd\n\tfi\n\texit ;;\n NILE*:*:*:dcosx)\n\techo pyramid-pyramid-svr4\n\texit ;;\n DRS?6000:unix:4.0:6*)\n\techo sparc-icl-nx6\n\texit ;;\n DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)\n\tcase $(/usr/bin/uname -p) in\n\t sparc) echo sparc-icl-nx7; exit ;;\n\tesac ;;\n s390x:SunOS:*:*)\n\techo \"$UNAME_MACHINE\"-ibm-solaris2\"$(echo \"$UNAME_RELEASE\" | sed -e 's/[^.]*//')\"\n\texit ;;\n sun4H:SunOS:5.*:*)\n\techo sparc-hal-solaris2\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*//')\"\n\texit ;;\n sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)\n\techo sparc-sun-solaris2\"$(echo \"$UNAME_RELEASE\" | sed -e 's/[^.]*//')\"\n\texit ;;\n i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)\n\techo i386-pc-auroraux\"$UNAME_RELEASE\"\n\texit ;;\n i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)\n\tset_cc_for_build\n\tSUN_ARCH=i386\n\t# If there is a compiler, see if it is configured for 64-bit objects.\n\t# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.\n\t# This test works for both compilers.\n\tif test \"$CC_FOR_BUILD\" != no_compiler_found; then\n\t if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \\\n\t\t(CCOPTS=\"\" $CC_FOR_BUILD -E - 2>/dev/null) | \\\n\t\tgrep IS_64BIT_ARCH >/dev/null\n\t then\n\t\tSUN_ARCH=x86_64\n\t fi\n\tfi\n\techo \"$SUN_ARCH\"-pc-solaris2\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*//')\"\n\texit ;;\n sun4*:SunOS:6*:*)\n\t# According to config.sub, this is the proper way to canonicalize\n\t# SunOS6. Hard to guess exactly what SunOS6 will be like, but\n\t# it's likely to be more like Solaris than SunOS4.\n\techo sparc-sun-solaris3\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*//')\"\n\texit ;;\n sun4*:SunOS:*:*)\n\tcase \"$(/usr/bin/arch -k)\" in\n\t Series*|S4*)\n\t\tUNAME_RELEASE=$(uname -v)\n\t\t;;\n\tesac\n\t# Japanese Language versions have a version number like `4.1.3-JL'.\n\techo sparc-sun-sunos\"$(echo \"$UNAME_RELEASE\"|sed -e 's/-/_/')\"\n\texit ;;\n sun3*:SunOS:*:*)\n\techo m68k-sun-sunos\"$UNAME_RELEASE\"\n\texit ;;\n sun*:*:4.2BSD:*)\n\tUNAME_RELEASE=$( (sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null)\n\ttest \"x$UNAME_RELEASE\" = x && UNAME_RELEASE=3\n\tcase \"$(/bin/arch)\" in\n\t sun3)\n\t\techo m68k-sun-sunos\"$UNAME_RELEASE\"\n\t\t;;\n\t sun4)\n\t\techo sparc-sun-sunos\"$UNAME_RELEASE\"\n\t\t;;\n\tesac\n\texit ;;\n aushp:SunOS:*:*)\n\techo sparc-auspex-sunos\"$UNAME_RELEASE\"\n\texit ;;\n # The situation for MiNT is a little confusing. The machine name\n # can be virtually everything (everything which is not\n # \"atarist\" or \"atariste\" at least should have a processor\n # > m68000). The system name ranges from \"MiNT\" over \"FreeMiNT\"\n # to the lowercase version \"mint\" (or \"freemint\"). Finally\n # the system name \"TOS\" denotes a system which is actually not\n # MiNT. But MiNT is downward compatible to TOS, so this should\n # be no problem.\n atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)\n\techo m68k-atari-mint\"$UNAME_RELEASE\"\n\texit ;;\n atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)\n\techo m68k-atari-mint\"$UNAME_RELEASE\"\n\texit ;;\n *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)\n\techo m68k-atari-mint\"$UNAME_RELEASE\"\n\texit ;;\n milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)\n\techo m68k-milan-mint\"$UNAME_RELEASE\"\n\texit ;;\n hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)\n\techo m68k-hades-mint\"$UNAME_RELEASE\"\n\texit ;;\n *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)\n\techo m68k-unknown-mint\"$UNAME_RELEASE\"\n\texit ;;\n m68k:machten:*:*)\n\techo m68k-apple-machten\"$UNAME_RELEASE\"\n\texit ;;\n powerpc:machten:*:*)\n\techo powerpc-apple-machten\"$UNAME_RELEASE\"\n\texit ;;\n RISC*:Mach:*:*)\n\techo mips-dec-mach_bsd4.3\n\texit ;;\n RISC*:ULTRIX:*:*)\n\techo mips-dec-ultrix\"$UNAME_RELEASE\"\n\texit ;;\n VAX*:ULTRIX*:*:*)\n\techo vax-dec-ultrix\"$UNAME_RELEASE\"\n\texit ;;\n 2020:CLIX:*:* | 2430:CLIX:*:*)\n\techo clipper-intergraph-clix\"$UNAME_RELEASE\"\n\texit ;;\n mips:*:*:UMIPS | mips:*:*:RISCos)\n\tset_cc_for_build\n\tsed 's/^\t//' << EOF > \"$dummy.c\"\n#ifdef __cplusplus\n#include /* for printf() prototype */\n\tint main (int argc, char *argv[]) {\n#else\n\tint main (argc, argv) int argc; char *argv[]; {\n#endif\n\t#if defined (host_mips) && defined (MIPSEB)\n\t#if defined (SYSTYPE_SYSV)\n\t printf (\"mips-mips-riscos%ssysv\\\\n\", argv[1]); exit (0);\n\t#endif\n\t#if defined (SYSTYPE_SVR4)\n\t printf (\"mips-mips-riscos%ssvr4\\\\n\", argv[1]); exit (0);\n\t#endif\n\t#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)\n\t printf (\"mips-mips-riscos%sbsd\\\\n\", argv[1]); exit (0);\n\t#endif\n\t#endif\n\t exit (-1);\n\t}\nEOF\n\t$CC_FOR_BUILD -o \"$dummy\" \"$dummy.c\" &&\n\t dummyarg=$(echo \"$UNAME_RELEASE\" | sed -n 's/\\([0-9]*\\).*/\\1/p') &&\n\t SYSTEM_NAME=$(\"$dummy\" \"$dummyarg\") &&\n\t { echo \"$SYSTEM_NAME\"; exit; }\n\techo mips-mips-riscos\"$UNAME_RELEASE\"\n\texit ;;\n Motorola:PowerMAX_OS:*:*)\n\techo powerpc-motorola-powermax\n\texit ;;\n Motorola:*:4.3:PL8-*)\n\techo powerpc-harris-powermax\n\texit ;;\n Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)\n\techo powerpc-harris-powermax\n\texit ;;\n Night_Hawk:Power_UNIX:*:*)\n\techo powerpc-harris-powerunix\n\texit ;;\n m88k:CX/UX:7*:*)\n\techo m88k-harris-cxux7\n\texit ;;\n m88k:*:4*:R4*)\n\techo m88k-motorola-sysv4\n\texit ;;\n m88k:*:3*:R3*)\n\techo m88k-motorola-sysv3\n\texit ;;\n AViiON:dgux:*:*)\n\t# DG/UX returns AViiON for all architectures\n\tUNAME_PROCESSOR=$(/usr/bin/uname -p)\n\tif test \"$UNAME_PROCESSOR\" = mc88100 || test \"$UNAME_PROCESSOR\" = mc88110\n\tthen\n\t if test \"$TARGET_BINARY_INTERFACE\"x = m88kdguxelfx || \\\n\t test \"$TARGET_BINARY_INTERFACE\"x = x\n\t then\n\t\techo m88k-dg-dgux\"$UNAME_RELEASE\"\n\t else\n\t\techo m88k-dg-dguxbcs\"$UNAME_RELEASE\"\n\t fi\n\telse\n\t echo i586-dg-dgux\"$UNAME_RELEASE\"\n\tfi\n\texit ;;\n M88*:DolphinOS:*:*)\t# DolphinOS (SVR3)\n\techo m88k-dolphin-sysv3\n\texit ;;\n M88*:*:R3*:*)\n\t# Delta 88k system running SVR3\n\techo m88k-motorola-sysv3\n\texit ;;\n XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)\n\techo m88k-tektronix-sysv3\n\texit ;;\n Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)\n\techo m68k-tektronix-bsd\n\texit ;;\n *:IRIX*:*:*)\n\techo mips-sgi-irix\"$(echo \"$UNAME_RELEASE\"|sed -e 's/-/_/g')\"\n\texit ;;\n ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.\n\techo romp-ibm-aix # uname -m gives an 8 hex-code CPU id\n\texit ;; # Note that: echo \"'$(uname -s)'\" gives 'AIX '\n i*86:AIX:*:*)\n\techo i386-ibm-aix\n\texit ;;\n ia64:AIX:*:*)\n\tif test -x /usr/bin/oslevel ; then\n\t\tIBM_REV=$(/usr/bin/oslevel)\n\telse\n\t\tIBM_REV=\"$UNAME_VERSION.$UNAME_RELEASE\"\n\tfi\n\techo \"$UNAME_MACHINE\"-ibm-aix\"$IBM_REV\"\n\texit ;;\n *:AIX:2:3)\n\tif grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then\n\t\tset_cc_for_build\n\t\tsed 's/^\t\t//' << EOF > \"$dummy.c\"\n\t\t#include \n\n\t\tmain()\n\t\t\t{\n\t\t\tif (!__power_pc())\n\t\t\t\texit(1);\n\t\t\tputs(\"powerpc-ibm-aix3.2.5\");\n\t\t\texit(0);\n\t\t\t}\nEOF\n\t\tif $CC_FOR_BUILD -o \"$dummy\" \"$dummy.c\" && SYSTEM_NAME=$(\"$dummy\")\n\t\tthen\n\t\t\techo \"$SYSTEM_NAME\"\n\t\telse\n\t\t\techo rs6000-ibm-aix3.2.5\n\t\tfi\n\telif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then\n\t\techo rs6000-ibm-aix3.2.4\n\telse\n\t\techo rs6000-ibm-aix3.2\n\tfi\n\texit ;;\n *:AIX:*:[4567])\n\tIBM_CPU_ID=$(/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }')\n\tif /usr/sbin/lsattr -El \"$IBM_CPU_ID\" | grep ' POWER' >/dev/null 2>&1; then\n\t\tIBM_ARCH=rs6000\n\telse\n\t\tIBM_ARCH=powerpc\n\tfi\n\tif test -x /usr/bin/lslpp ; then\n\t\tIBM_REV=$(/usr/bin/lslpp -Lqc bos.rte.libc |\n\t\t\t awk -F: '{ print $3 }' | sed s/[0-9]*$/0/)\n\telse\n\t\tIBM_REV=\"$UNAME_VERSION.$UNAME_RELEASE\"\n\tfi\n\techo \"$IBM_ARCH\"-ibm-aix\"$IBM_REV\"\n\texit ;;\n *:AIX:*:*)\n\techo rs6000-ibm-aix\n\texit ;;\n ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)\n\techo romp-ibm-bsd4.4\n\texit ;;\n ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and\n\techo romp-ibm-bsd\"$UNAME_RELEASE\" # 4.3 with uname added to\n\texit ;; # report: romp-ibm BSD 4.3\n *:BOSX:*:*)\n\techo rs6000-bull-bosx\n\texit ;;\n DPX/2?00:B.O.S.:*:*)\n\techo m68k-bull-sysv3\n\texit ;;\n 9000/[34]??:4.3bsd:1.*:*)\n\techo m68k-hp-bsd\n\texit ;;\n hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)\n\techo m68k-hp-bsd4.4\n\texit ;;\n 9000/[34678]??:HP-UX:*:*)\n\tHPUX_REV=$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*.[0B]*//')\n\tcase \"$UNAME_MACHINE\" in\n\t 9000/31?) HP_ARCH=m68000 ;;\n\t 9000/[34]??) HP_ARCH=m68k ;;\n\t 9000/[678][0-9][0-9])\n\t\tif test -x /usr/bin/getconf; then\n\t\t sc_cpu_version=$(/usr/bin/getconf SC_CPU_VERSION 2>/dev/null)\n\t\t sc_kernel_bits=$(/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null)\n\t\t case \"$sc_cpu_version\" in\n\t\t 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0\n\t\t 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1\n\t\t 532) # CPU_PA_RISC2_0\n\t\t\tcase \"$sc_kernel_bits\" in\n\t\t\t 32) HP_ARCH=hppa2.0n ;;\n\t\t\t 64) HP_ARCH=hppa2.0w ;;\n\t\t\t '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20\n\t\t\tesac ;;\n\t\t esac\n\t\tfi\n\t\tif test \"$HP_ARCH\" = \"\"; then\n\t\t set_cc_for_build\n\t\t sed 's/^\t\t//' << EOF > \"$dummy.c\"\n\n\t\t#define _HPUX_SOURCE\n\t\t#include \n\t\t#include \n\n\t\tint main ()\n\t\t{\n\t\t#if defined(_SC_KERNEL_BITS)\n\t\t long bits = sysconf(_SC_KERNEL_BITS);\n\t\t#endif\n\t\t long cpu = sysconf (_SC_CPU_VERSION);\n\n\t\t switch (cpu)\n\t\t\t{\n\t\t\tcase CPU_PA_RISC1_0: puts (\"hppa1.0\"); break;\n\t\t\tcase CPU_PA_RISC1_1: puts (\"hppa1.1\"); break;\n\t\t\tcase CPU_PA_RISC2_0:\n\t\t#if defined(_SC_KERNEL_BITS)\n\t\t\t switch (bits)\n\t\t\t\t{\n\t\t\t\tcase 64: puts (\"hppa2.0w\"); break;\n\t\t\t\tcase 32: puts (\"hppa2.0n\"); break;\n\t\t\t\tdefault: puts (\"hppa2.0\"); break;\n\t\t\t\t} break;\n\t\t#else /* !defined(_SC_KERNEL_BITS) */\n\t\t\t puts (\"hppa2.0\"); break;\n\t\t#endif\n\t\t\tdefault: puts (\"hppa1.0\"); break;\n\t\t\t}\n\t\t exit (0);\n\t\t}\nEOF\n\t\t (CCOPTS=\"\" $CC_FOR_BUILD -o \"$dummy\" \"$dummy.c\" 2>/dev/null) && HP_ARCH=$(\"$dummy\")\n\t\t test -z \"$HP_ARCH\" && HP_ARCH=hppa\n\t\tfi ;;\n\tesac\n\tif test \"$HP_ARCH\" = hppa2.0w\n\tthen\n\t set_cc_for_build\n\n\t # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating\n\t # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler\n\t # generating 64-bit code. GNU and HP use different nomenclature:\n\t #\n\t # $ CC_FOR_BUILD=cc ./config.guess\n\t # => hppa2.0w-hp-hpux11.23\n\t # $ CC_FOR_BUILD=\"cc +DA2.0w\" ./config.guess\n\t # => hppa64-hp-hpux11.23\n\n\t if echo __LP64__ | (CCOPTS=\"\" $CC_FOR_BUILD -E - 2>/dev/null) |\n\t\tgrep -q __LP64__\n\t then\n\t\tHP_ARCH=hppa2.0w\n\t else\n\t\tHP_ARCH=hppa64\n\t fi\n\tfi\n\techo \"$HP_ARCH\"-hp-hpux\"$HPUX_REV\"\n\texit ;;\n ia64:HP-UX:*:*)\n\tHPUX_REV=$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*.[0B]*//')\n\techo ia64-hp-hpux\"$HPUX_REV\"\n\texit ;;\n 3050*:HI-UX:*:*)\n\tset_cc_for_build\n\tsed 's/^\t//' << EOF > \"$dummy.c\"\n\t#include \n\tint\n\tmain ()\n\t{\n\t long cpu = sysconf (_SC_CPU_VERSION);\n\t /* The order matters, because CPU_IS_HP_MC68K erroneously returns\n\t true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct\n\t results, however. */\n\t if (CPU_IS_PA_RISC (cpu))\n\t {\n\t switch (cpu)\n\t\t{\n\t\t case CPU_PA_RISC1_0: puts (\"hppa1.0-hitachi-hiuxwe2\"); break;\n\t\t case CPU_PA_RISC1_1: puts (\"hppa1.1-hitachi-hiuxwe2\"); break;\n\t\t case CPU_PA_RISC2_0: puts (\"hppa2.0-hitachi-hiuxwe2\"); break;\n\t\t default: puts (\"hppa-hitachi-hiuxwe2\"); break;\n\t\t}\n\t }\n\t else if (CPU_IS_HP_MC68K (cpu))\n\t puts (\"m68k-hitachi-hiuxwe2\");\n\t else puts (\"unknown-hitachi-hiuxwe2\");\n\t exit (0);\n\t}\nEOF\n\t$CC_FOR_BUILD -o \"$dummy\" \"$dummy.c\" && SYSTEM_NAME=$(\"$dummy\") &&\n\t\t{ echo \"$SYSTEM_NAME\"; exit; }\n\techo unknown-hitachi-hiuxwe2\n\texit ;;\n 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)\n\techo hppa1.1-hp-bsd\n\texit ;;\n 9000/8??:4.3bsd:*:*)\n\techo hppa1.0-hp-bsd\n\texit ;;\n *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)\n\techo hppa1.0-hp-mpeix\n\texit ;;\n hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)\n\techo hppa1.1-hp-osf\n\texit ;;\n hp8??:OSF1:*:*)\n\techo hppa1.0-hp-osf\n\texit ;;\n i*86:OSF1:*:*)\n\tif test -x /usr/sbin/sysversion ; then\n\t echo \"$UNAME_MACHINE\"-unknown-osf1mk\n\telse\n\t echo \"$UNAME_MACHINE\"-unknown-osf1\n\tfi\n\texit ;;\n parisc*:Lites*:*:*)\n\techo hppa1.1-hp-lites\n\texit ;;\n C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)\n\techo c1-convex-bsd\n\texit ;;\n C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)\n\tif getsysinfo -f scalar_acc\n\tthen echo c32-convex-bsd\n\telse echo c2-convex-bsd\n\tfi\n\texit ;;\n C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)\n\techo c34-convex-bsd\n\texit ;;\n C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)\n\techo c38-convex-bsd\n\texit ;;\n C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)\n\techo c4-convex-bsd\n\texit ;;\n CRAY*Y-MP:*:*:*)\n\techo ymp-cray-unicos\"$UNAME_RELEASE\" | sed -e 's/\\.[^.]*$/.X/'\n\texit ;;\n CRAY*[A-Z]90:*:*:*)\n\techo \"$UNAME_MACHINE\"-cray-unicos\"$UNAME_RELEASE\" \\\n\t| sed -e 's/CRAY.*\\([A-Z]90\\)/\\1/' \\\n\t -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \\\n\t -e 's/\\.[^.]*$/.X/'\n\texit ;;\n CRAY*TS:*:*:*)\n\techo t90-cray-unicos\"$UNAME_RELEASE\" | sed -e 's/\\.[^.]*$/.X/'\n\texit ;;\n CRAY*T3E:*:*:*)\n\techo alphaev5-cray-unicosmk\"$UNAME_RELEASE\" | sed -e 's/\\.[^.]*$/.X/'\n\texit ;;\n CRAY*SV1:*:*:*)\n\techo sv1-cray-unicos\"$UNAME_RELEASE\" | sed -e 's/\\.[^.]*$/.X/'\n\texit ;;\n *:UNICOS/mp:*:*)\n\techo craynv-cray-unicosmp\"$UNAME_RELEASE\" | sed -e 's/\\.[^.]*$/.X/'\n\texit ;;\n F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)\n\tFUJITSU_PROC=$(uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz)\n\tFUJITSU_SYS=$(uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\\///')\n\tFUJITSU_REL=$(echo \"$UNAME_RELEASE\" | sed -e 's/ /_/')\n\techo \"${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}\"\n\texit ;;\n 5000:UNIX_System_V:4.*:*)\n\tFUJITSU_SYS=$(uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\\///')\n\tFUJITSU_REL=$(echo \"$UNAME_RELEASE\" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/')\n\techo \"sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}\"\n\texit ;;\n i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\\ Embedded/OS:*:*)\n\techo \"$UNAME_MACHINE\"-pc-bsdi\"$UNAME_RELEASE\"\n\texit ;;\n sparc*:BSD/OS:*:*)\n\techo sparc-unknown-bsdi\"$UNAME_RELEASE\"\n\texit ;;\n *:BSD/OS:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-bsdi\"$UNAME_RELEASE\"\n\texit ;;\n arm:FreeBSD:*:*)\n\tUNAME_PROCESSOR=$(uname -p)\n\tset_cc_for_build\n\tif echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \\\n\t | grep -q __ARM_PCS_VFP\n\tthen\n\t echo \"${UNAME_PROCESSOR}\"-unknown-freebsd\"$(echo ${UNAME_RELEASE}|sed -e 's/[-(].*//')\"-gnueabi\n\telse\n\t echo \"${UNAME_PROCESSOR}\"-unknown-freebsd\"$(echo ${UNAME_RELEASE}|sed -e 's/[-(].*//')\"-gnueabihf\n\tfi\n\texit ;;\n *:FreeBSD:*:*)\n\tUNAME_PROCESSOR=$(/usr/bin/uname -p)\n\tcase \"$UNAME_PROCESSOR\" in\n\t amd64)\n\t\tUNAME_PROCESSOR=x86_64 ;;\n\t i386)\n\t\tUNAME_PROCESSOR=i586 ;;\n\tesac\n\techo \"$UNAME_PROCESSOR\"-unknown-freebsd\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[-(].*//')\"\n\texit ;;\n i*:CYGWIN*:*)\n\techo \"$UNAME_MACHINE\"-pc-cygwin\n\texit ;;\n *:MINGW64*:*)\n\techo \"$UNAME_MACHINE\"-pc-mingw64\n\texit ;;\n *:MINGW*:*)\n\techo \"$UNAME_MACHINE\"-pc-mingw32\n\texit ;;\n *:MSYS*:*)\n\techo \"$UNAME_MACHINE\"-pc-msys\n\texit ;;\n i*:PW*:*)\n\techo \"$UNAME_MACHINE\"-pc-pw32\n\texit ;;\n *:Interix*:*)\n\tcase \"$UNAME_MACHINE\" in\n\t x86)\n\t\techo i586-pc-interix\"$UNAME_RELEASE\"\n\t\texit ;;\n\t authenticamd | genuineintel | EM64T)\n\t\techo x86_64-unknown-interix\"$UNAME_RELEASE\"\n\t\texit ;;\n\t IA64)\n\t\techo ia64-unknown-interix\"$UNAME_RELEASE\"\n\t\texit ;;\n\tesac ;;\n i*:UWIN*:*)\n\techo \"$UNAME_MACHINE\"-pc-uwin\n\texit ;;\n amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)\n\techo x86_64-pc-cygwin\n\texit ;;\n prep*:SunOS:5.*:*)\n\techo powerpcle-unknown-solaris2\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[^.]*//')\"\n\texit ;;\n *:GNU:*:*)\n\t# the GNU system\n\techo \"$(echo \"$UNAME_MACHINE\"|sed -e 's,[-/].*$,,')-unknown-$LIBC$(echo \"$UNAME_RELEASE\"|sed -e 's,/.*$,,')\"\n\texit ;;\n *:GNU/*:*:*)\n\t# other systems with GNU libc and userland\n\techo \"$UNAME_MACHINE-unknown-$(echo \"$UNAME_SYSTEM\" | sed 's,^[^/]*/,,' | tr \"[:upper:]\" \"[:lower:]\")$(echo \"$UNAME_RELEASE\"|sed -e 's/[-(].*//')-$LIBC\"\n\texit ;;\n *:Minix:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-minix\n\texit ;;\n aarch64:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n aarch64_be:Linux:*:*)\n\tUNAME_MACHINE=aarch64_be\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n alpha:Linux:*:*)\n\tcase $(sed -n '/^cpu model/s/^.*: \\(.*\\)/\\1/p' /proc/cpuinfo 2>/dev/null) in\n\t EV5) UNAME_MACHINE=alphaev5 ;;\n\t EV56) UNAME_MACHINE=alphaev56 ;;\n\t PCA56) UNAME_MACHINE=alphapca56 ;;\n\t PCA57) UNAME_MACHINE=alphapca56 ;;\n\t EV6) UNAME_MACHINE=alphaev6 ;;\n\t EV67) UNAME_MACHINE=alphaev67 ;;\n\t EV68*) UNAME_MACHINE=alphaev68 ;;\n\tesac\n\tobjdump --private-headers /bin/sh | grep -q ld.so.1\n\tif test \"$?\" = 0 ; then LIBC=gnulibc1 ; fi\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n arc:Linux:*:* | arceb:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n arm*:Linux:*:*)\n\tset_cc_for_build\n\tif echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \\\n\t | grep -q __ARM_EABI__\n\tthen\n\t echo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\telse\n\t if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \\\n\t\t| grep -q __ARM_PCS_VFP\n\t then\n\t\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"eabi\n\t else\n\t\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"eabihf\n\t fi\n\tfi\n\texit ;;\n avr32*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n cris:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-axis-linux-\"$LIBC\"\n\texit ;;\n crisv32:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-axis-linux-\"$LIBC\"\n\texit ;;\n e2k:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n frv:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n hexagon:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n i*86:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-pc-linux-\"$LIBC\"\n\texit ;;\n ia64:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n k1om:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n m32r*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n m68*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n mips:Linux:*:* | mips64:Linux:*:*)\n\tset_cc_for_build\n\tIS_GLIBC=0\n\ttest x\"${LIBC}\" = xgnu && IS_GLIBC=1\n\tsed 's/^\t//' << EOF > \"$dummy.c\"\n\t#undef CPU\n\t#undef mips\n\t#undef mipsel\n\t#undef mips64\n\t#undef mips64el\n\t#if ${IS_GLIBC} && defined(_ABI64)\n\tLIBCABI=gnuabi64\n\t#else\n\t#if ${IS_GLIBC} && defined(_ABIN32)\n\tLIBCABI=gnuabin32\n\t#else\n\tLIBCABI=${LIBC}\n\t#endif\n\t#endif\n\n\t#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6\n\tCPU=mipsisa64r6\n\t#else\n\t#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6\n\tCPU=mipsisa32r6\n\t#else\n\t#if defined(__mips64)\n\tCPU=mips64\n\t#else\n\tCPU=mips\n\t#endif\n\t#endif\n\t#endif\n\n\t#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)\n\tMIPS_ENDIAN=el\n\t#else\n\t#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)\n\tMIPS_ENDIAN=\n\t#else\n\tMIPS_ENDIAN=\n\t#endif\n\t#endif\nEOF\n\teval \"$($CC_FOR_BUILD -E \"$dummy.c\" 2>/dev/null | grep '^CPU\\|^MIPS_ENDIAN\\|^LIBCABI')\"\n\ttest \"x$CPU\" != x && { echo \"$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI\"; exit; }\n\t;;\n mips64el:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n openrisc*:Linux:*:*)\n\techo or1k-unknown-linux-\"$LIBC\"\n\texit ;;\n or32:Linux:*:* | or1k*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n padre:Linux:*:*)\n\techo sparc-unknown-linux-\"$LIBC\"\n\texit ;;\n parisc64:Linux:*:* | hppa64:Linux:*:*)\n\techo hppa64-unknown-linux-\"$LIBC\"\n\texit ;;\n parisc:Linux:*:* | hppa:Linux:*:*)\n\t# Look for CPU level\n\tcase $(grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2) in\n\t PA7*) echo hppa1.1-unknown-linux-\"$LIBC\" ;;\n\t PA8*) echo hppa2.0-unknown-linux-\"$LIBC\" ;;\n\t *) echo hppa-unknown-linux-\"$LIBC\" ;;\n\tesac\n\texit ;;\n ppc64:Linux:*:*)\n\techo powerpc64-unknown-linux-\"$LIBC\"\n\texit ;;\n ppc:Linux:*:*)\n\techo powerpc-unknown-linux-\"$LIBC\"\n\texit ;;\n ppc64le:Linux:*:*)\n\techo powerpc64le-unknown-linux-\"$LIBC\"\n\texit ;;\n ppcle:Linux:*:*)\n\techo powerpcle-unknown-linux-\"$LIBC\"\n\texit ;;\n riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n s390:Linux:*:* | s390x:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-ibm-linux-\"$LIBC\"\n\texit ;;\n sh64*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n sh*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n sparc:Linux:*:* | sparc64:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n tile*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n vax:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-dec-linux-\"$LIBC\"\n\texit ;;\n x86_64:Linux:*:*)\n\tset_cc_for_build\n\tLIBCABI=$LIBC\n\tif test \"$CC_FOR_BUILD\" != no_compiler_found; then\n\t if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \\\n\t\t(CCOPTS=\"\" $CC_FOR_BUILD -E - 2>/dev/null) | \\\n\t\tgrep IS_X32 >/dev/null\n\t then\n\t\tLIBCABI=\"$LIBC\"x32\n\t fi\n\tfi\n\techo \"$UNAME_MACHINE\"-pc-linux-\"$LIBCABI\"\n\texit ;;\n xtensa*:Linux:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-linux-\"$LIBC\"\n\texit ;;\n i*86:DYNIX/ptx:4*:*)\n\t# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.\n\t# earlier versions are messed up and put the nodename in both\n\t# sysname and nodename.\n\techo i386-sequent-sysv4\n\texit ;;\n i*86:UNIX_SV:4.2MP:2.*)\n\t# Unixware is an offshoot of SVR4, but it has its own version\n\t# number series starting with 2...\n\t# I am not positive that other SVR4 systems won't match this,\n\t# I just have to hope. -- rms.\n\t# Use sysv4.2uw... so that sysv4* matches it.\n\techo \"$UNAME_MACHINE\"-pc-sysv4.2uw\"$UNAME_VERSION\"\n\texit ;;\n i*86:OS/2:*:*)\n\t# If we were able to find `uname', then EMX Unix compatibility\n\t# is probably installed.\n\techo \"$UNAME_MACHINE\"-pc-os2-emx\n\texit ;;\n i*86:XTS-300:*:STOP)\n\techo \"$UNAME_MACHINE\"-unknown-stop\n\texit ;;\n i*86:atheos:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-atheos\n\texit ;;\n i*86:syllable:*:*)\n\techo \"$UNAME_MACHINE\"-pc-syllable\n\texit ;;\n i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)\n\techo i386-unknown-lynxos\"$UNAME_RELEASE\"\n\texit ;;\n i*86:*DOS:*:*)\n\techo \"$UNAME_MACHINE\"-pc-msdosdjgpp\n\texit ;;\n i*86:*:4.*:*)\n\tUNAME_REL=$(echo \"$UNAME_RELEASE\" | sed 's/\\/MP$//')\n\tif grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then\n\t\techo \"$UNAME_MACHINE\"-univel-sysv\"$UNAME_REL\"\n\telse\n\t\techo \"$UNAME_MACHINE\"-pc-sysv\"$UNAME_REL\"\n\tfi\n\texit ;;\n i*86:*:5:[678]*)\n\t# UnixWare 7.x, OpenUNIX and OpenServer 6.\n\tcase $(/bin/uname -X | grep \"^Machine\") in\n\t *486*)\t UNAME_MACHINE=i486 ;;\n\t *Pentium)\t UNAME_MACHINE=i586 ;;\n\t *Pent*|*Celeron) UNAME_MACHINE=i686 ;;\n\tesac\n\techo \"$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}\"\n\texit ;;\n i*86:*:3.2:*)\n\tif test -f /usr/options/cb.name; then\n\t\tUNAME_REL=$(sed -n 's/.*Version //p' /dev/null >/dev/null ; then\n\t\tUNAME_REL=$( (/bin/uname -X|grep Release|sed -e 's/.*= //'))\n\t\t(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486\n\t\t(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \\\n\t\t\t&& UNAME_MACHINE=i586\n\t\t(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \\\n\t\t\t&& UNAME_MACHINE=i686\n\t\t(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \\\n\t\t\t&& UNAME_MACHINE=i686\n\t\techo \"$UNAME_MACHINE\"-pc-sco\"$UNAME_REL\"\n\telse\n\t\techo \"$UNAME_MACHINE\"-pc-sysv32\n\tfi\n\texit ;;\n pc:*:*:*)\n\t# Left here for compatibility:\n\t# uname -m prints for DJGPP always 'pc', but it prints nothing about\n\t# the processor, so we play safe by assuming i586.\n\t# Note: whatever this is, it MUST be the same as what config.sub\n\t# prints for the \"djgpp\" host, or else GDB configure will decide that\n\t# this is a cross-build.\n\techo i586-pc-msdosdjgpp\n\texit ;;\n Intel:Mach:3*:*)\n\techo i386-pc-mach3\n\texit ;;\n paragon:*:*:*)\n\techo i860-intel-osf1\n\texit ;;\n i860:*:4.*:*) # i860-SVR4\n\tif grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then\n\t echo i860-stardent-sysv\"$UNAME_RELEASE\" # Stardent Vistra i860-SVR4\n\telse # Add other i860-SVR4 vendors below as they are discovered.\n\t echo i860-unknown-sysv\"$UNAME_RELEASE\" # Unknown i860-SVR4\n\tfi\n\texit ;;\n mini*:CTIX:SYS*5:*)\n\t# \"miniframe\"\n\techo m68010-convergent-sysv\n\texit ;;\n mc68k:UNIX:SYSTEM5:3.51m)\n\techo m68k-convergent-sysv\n\texit ;;\n M680?0:D-NIX:5.3:*)\n\techo m68k-diab-dnix\n\texit ;;\n M68*:*:R3V[5678]*:*)\n\ttest -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;\n 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)\n\tOS_REL=''\n\ttest -r /etc/.relid \\\n\t&& OS_REL=.$(sed -n 's/[^ ]* [^ ]* \\([0-9][0-9]\\).*/\\1/p' < /etc/.relid)\n\t/bin/uname -p 2>/dev/null | grep 86 >/dev/null \\\n\t && { echo i486-ncr-sysv4.3\"$OS_REL\"; exit; }\n\t/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \\\n\t && { echo i586-ncr-sysv4.3\"$OS_REL\"; exit; } ;;\n 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)\n\t/bin/uname -p 2>/dev/null | grep 86 >/dev/null \\\n\t && { echo i486-ncr-sysv4; exit; } ;;\n NCR*:*:4.2:* | MPRAS*:*:4.2:*)\n\tOS_REL='.3'\n\ttest -r /etc/.relid \\\n\t && OS_REL=.$(sed -n 's/[^ ]* [^ ]* \\([0-9][0-9]\\).*/\\1/p' < /etc/.relid)\n\t/bin/uname -p 2>/dev/null | grep 86 >/dev/null \\\n\t && { echo i486-ncr-sysv4.3\"$OS_REL\"; exit; }\n\t/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \\\n\t && { echo i586-ncr-sysv4.3\"$OS_REL\"; exit; }\n\t/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \\\n\t && { echo i586-ncr-sysv4.3\"$OS_REL\"; exit; } ;;\n m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)\n\techo m68k-unknown-lynxos\"$UNAME_RELEASE\"\n\texit ;;\n mc68030:UNIX_System_V:4.*:*)\n\techo m68k-atari-sysv4\n\texit ;;\n TSUNAMI:LynxOS:2.*:*)\n\techo sparc-unknown-lynxos\"$UNAME_RELEASE\"\n\texit ;;\n rs6000:LynxOS:2.*:*)\n\techo rs6000-unknown-lynxos\"$UNAME_RELEASE\"\n\texit ;;\n PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)\n\techo powerpc-unknown-lynxos\"$UNAME_RELEASE\"\n\texit ;;\n SM[BE]S:UNIX_SV:*:*)\n\techo mips-dde-sysv\"$UNAME_RELEASE\"\n\texit ;;\n RM*:ReliantUNIX-*:*:*)\n\techo mips-sni-sysv4\n\texit ;;\n RM*:SINIX-*:*:*)\n\techo mips-sni-sysv4\n\texit ;;\n *:SINIX-*:*:*)\n\tif uname -p 2>/dev/null >/dev/null ; then\n\t\tUNAME_MACHINE=$( (uname -p) 2>/dev/null)\n\t\techo \"$UNAME_MACHINE\"-sni-sysv4\n\telse\n\t\techo ns32k-sni-sysv\n\tfi\n\texit ;;\n PENTIUM:*:4.0*:*)\t# Unisys `ClearPath HMP IX 4000' SVR4/MP effort\n\t\t\t# says \n\techo i586-unisys-sysv4\n\texit ;;\n *:UNIX_System_V:4*:FTX*)\n\t# From Gerald Hewes .\n\t# How about differentiating between stratus architectures? -djm\n\techo hppa1.1-stratus-sysv4\n\texit ;;\n *:*:*:FTX*)\n\t# From seanf@swdc.stratus.com.\n\techo i860-stratus-sysv4\n\texit ;;\n i*86:VOS:*:*)\n\t# From Paul.Green@stratus.com.\n\techo \"$UNAME_MACHINE\"-stratus-vos\n\texit ;;\n *:VOS:*:*)\n\t# From Paul.Green@stratus.com.\n\techo hppa1.1-stratus-vos\n\texit ;;\n mc68*:A/UX:*:*)\n\techo m68k-apple-aux\"$UNAME_RELEASE\"\n\texit ;;\n news*:NEWS-OS:6*:*)\n\techo mips-sony-newsos6\n\texit ;;\n R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)\n\tif test -d /usr/nec; then\n\t\techo mips-nec-sysv\"$UNAME_RELEASE\"\n\telse\n\t\techo mips-unknown-sysv\"$UNAME_RELEASE\"\n\tfi\n\texit ;;\n BeBox:BeOS:*:*)\t# BeOS running on hardware made by Be, PPC only.\n\techo powerpc-be-beos\n\texit ;;\n BeMac:BeOS:*:*)\t# BeOS running on Mac or Mac clone, PPC only.\n\techo powerpc-apple-beos\n\texit ;;\n BePC:BeOS:*:*)\t# BeOS running on Intel PC compatible.\n\techo i586-pc-beos\n\texit ;;\n BePC:Haiku:*:*)\t# Haiku running on Intel PC compatible.\n\techo i586-pc-haiku\n\texit ;;\n x86_64:Haiku:*:*)\n\techo x86_64-unknown-haiku\n\texit ;;\n SX-4:SUPER-UX:*:*)\n\techo sx4-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-5:SUPER-UX:*:*)\n\techo sx5-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-6:SUPER-UX:*:*)\n\techo sx6-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-7:SUPER-UX:*:*)\n\techo sx7-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-8:SUPER-UX:*:*)\n\techo sx8-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-8R:SUPER-UX:*:*)\n\techo sx8r-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n SX-ACE:SUPER-UX:*:*)\n\techo sxace-nec-superux\"$UNAME_RELEASE\"\n\texit ;;\n Power*:Rhapsody:*:*)\n\techo powerpc-apple-rhapsody\"$UNAME_RELEASE\"\n\texit ;;\n *:Rhapsody:*:*)\n\techo \"$UNAME_MACHINE\"-apple-rhapsody\"$UNAME_RELEASE\"\n\texit ;;\n arm64:Darwin:*:*)\n\techo aarch64-apple-darwin\"$UNAME_RELEASE\"\n\texit ;;\n *:Darwin:*:*)\n\tUNAME_PROCESSOR=$(uname -p)\n\tcase $UNAME_PROCESSOR in\n\t unknown) UNAME_PROCESSOR=powerpc ;;\n\tesac\n\tif command -v xcode-select > /dev/null 2> /dev/null && \\\n\t\t! xcode-select --print-path > /dev/null 2> /dev/null ; then\n\t # Avoid executing cc if there is no toolchain installed as\n\t # cc will be a stub that puts up a graphical alert\n\t # prompting the user to install developer tools.\n\t CC_FOR_BUILD=no_compiler_found\n\telse\n\t set_cc_for_build\n\tfi\n\tif test \"$CC_FOR_BUILD\" != no_compiler_found; then\n\t if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \\\n\t\t (CCOPTS=\"\" $CC_FOR_BUILD -E - 2>/dev/null) | \\\n\t\t grep IS_64BIT_ARCH >/dev/null\n\t then\n\t\tcase $UNAME_PROCESSOR in\n\t\t i386) UNAME_PROCESSOR=x86_64 ;;\n\t\t powerpc) UNAME_PROCESSOR=powerpc64 ;;\n\t\tesac\n\t fi\n\t # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc\n\t if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \\\n\t\t (CCOPTS=\"\" $CC_FOR_BUILD -E - 2>/dev/null) | \\\n\t\t grep IS_PPC >/dev/null\n\t then\n\t\tUNAME_PROCESSOR=powerpc\n\t fi\n\telif test \"$UNAME_PROCESSOR\" = i386 ; then\n\t # uname -m returns i386 or x86_64\n\t UNAME_PROCESSOR=$UNAME_MACHINE\n\tfi\n\techo \"$UNAME_PROCESSOR\"-apple-darwin\"$UNAME_RELEASE\"\n\texit ;;\n *:procnto*:*:* | *:QNX:[0123456789]*:*)\n\tUNAME_PROCESSOR=$(uname -p)\n\tif test \"$UNAME_PROCESSOR\" = x86; then\n\t\tUNAME_PROCESSOR=i386\n\t\tUNAME_MACHINE=pc\n\tfi\n\techo \"$UNAME_PROCESSOR\"-\"$UNAME_MACHINE\"-nto-qnx\"$UNAME_RELEASE\"\n\texit ;;\n *:QNX:*:4*)\n\techo i386-pc-qnx\n\texit ;;\n NEO-*:NONSTOP_KERNEL:*:*)\n\techo neo-tandem-nsk\"$UNAME_RELEASE\"\n\texit ;;\n NSE-*:NONSTOP_KERNEL:*:*)\n\techo nse-tandem-nsk\"$UNAME_RELEASE\"\n\texit ;;\n NSR-*:NONSTOP_KERNEL:*:*)\n\techo nsr-tandem-nsk\"$UNAME_RELEASE\"\n\texit ;;\n NSV-*:NONSTOP_KERNEL:*:*)\n\techo nsv-tandem-nsk\"$UNAME_RELEASE\"\n\texit ;;\n NSX-*:NONSTOP_KERNEL:*:*)\n\techo nsx-tandem-nsk\"$UNAME_RELEASE\"\n\texit ;;\n *:NonStop-UX:*:*)\n\techo mips-compaq-nonstopux\n\texit ;;\n BS2000:POSIX*:*:*)\n\techo bs2000-siemens-sysv\n\texit ;;\n DS/*:UNIX_System_V:*:*)\n\techo \"$UNAME_MACHINE\"-\"$UNAME_SYSTEM\"-\"$UNAME_RELEASE\"\n\texit ;;\n *:Plan9:*:*)\n\t# \"uname -m\" is not consistent, so use $cputype instead. 386\n\t# is converted to i386 for consistency with other x86\n\t# operating systems.\n\t# shellcheck disable=SC2154\n\tif test \"$cputype\" = 386; then\n\t UNAME_MACHINE=i386\n\telse\n\t UNAME_MACHINE=\"$cputype\"\n\tfi\n\techo \"$UNAME_MACHINE\"-unknown-plan9\n\texit ;;\n *:TOPS-10:*:*)\n\techo pdp10-unknown-tops10\n\texit ;;\n *:TENEX:*:*)\n\techo pdp10-unknown-tenex\n\texit ;;\n KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)\n\techo pdp10-dec-tops20\n\texit ;;\n XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)\n\techo pdp10-xkl-tops20\n\texit ;;\n *:TOPS-20:*:*)\n\techo pdp10-unknown-tops20\n\texit ;;\n *:ITS:*:*)\n\techo pdp10-unknown-its\n\texit ;;\n SEI:*:*:SEIUX)\n\techo mips-sei-seiux\"$UNAME_RELEASE\"\n\texit ;;\n *:DragonFly:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-dragonfly\"$(echo \"$UNAME_RELEASE\"|sed -e 's/[-(].*//')\"\n\texit ;;\n *:*VMS:*:*)\n\tUNAME_MACHINE=$( (uname -p) 2>/dev/null)\n\tcase \"$UNAME_MACHINE\" in\n\t A*) echo alpha-dec-vms ; exit ;;\n\t I*) echo ia64-dec-vms ; exit ;;\n\t V*) echo vax-dec-vms ; exit ;;\n\tesac ;;\n *:XENIX:*:SysV)\n\techo i386-pc-xenix\n\texit ;;\n i*86:skyos:*:*)\n\techo \"$UNAME_MACHINE\"-pc-skyos\"$(echo \"$UNAME_RELEASE\" | sed -e 's/ .*$//')\"\n\texit ;;\n i*86:rdos:*:*)\n\techo \"$UNAME_MACHINE\"-pc-rdos\n\texit ;;\n i*86:AROS:*:*)\n\techo \"$UNAME_MACHINE\"-pc-aros\n\texit ;;\n x86_64:VMkernel:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-esx\n\texit ;;\n amd64:Isilon\\ OneFS:*:*)\n\techo x86_64-unknown-onefs\n\texit ;;\n *:Unleashed:*:*)\n\techo \"$UNAME_MACHINE\"-unknown-unleashed\"$UNAME_RELEASE\"\n\texit ;;\nesac\n\n# No uname command or uname output not recognized.\nset_cc_for_build\ncat > \"$dummy.c\" <\n#include \n#endif\n#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)\n#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)\n#include \n#if defined(_SIZE_T_) || defined(SIGLOST)\n#include \n#endif\n#endif\n#endif\nmain ()\n{\n#if defined (sony)\n#if defined (MIPSEB)\n /* BFD wants \"bsd\" instead of \"newsos\". Perhaps BFD should be changed,\n I don't know.... */\n printf (\"mips-sony-bsd\\n\"); exit (0);\n#else\n#include \n printf (\"m68k-sony-newsos%s\\n\",\n#ifdef NEWSOS4\n \"4\"\n#else\n \"\"\n#endif\n ); exit (0);\n#endif\n#endif\n\n#if defined (NeXT)\n#if !defined (__ARCHITECTURE__)\n#define __ARCHITECTURE__ \"m68k\"\n#endif\n int version;\n version=$( (hostinfo | sed -n 's/.*NeXT Mach \\([0-9]*\\).*/\\1/p') 2>/dev/null);\n if (version < 4)\n printf (\"%s-next-nextstep%d\\n\", __ARCHITECTURE__, version);\n else\n printf (\"%s-next-openstep%d\\n\", __ARCHITECTURE__, version);\n exit (0);\n#endif\n\n#if defined (MULTIMAX) || defined (n16)\n#if defined (UMAXV)\n printf (\"ns32k-encore-sysv\\n\"); exit (0);\n#else\n#if defined (CMU)\n printf (\"ns32k-encore-mach\\n\"); exit (0);\n#else\n printf (\"ns32k-encore-bsd\\n\"); exit (0);\n#endif\n#endif\n#endif\n\n#if defined (__386BSD__)\n printf (\"i386-pc-bsd\\n\"); exit (0);\n#endif\n\n#if defined (sequent)\n#if defined (i386)\n printf (\"i386-sequent-dynix\\n\"); exit (0);\n#endif\n#if defined (ns32000)\n printf (\"ns32k-sequent-dynix\\n\"); exit (0);\n#endif\n#endif\n\n#if defined (_SEQUENT_)\n struct utsname un;\n\n uname(&un);\n if (strncmp(un.version, \"V2\", 2) == 0) {\n printf (\"i386-sequent-ptx2\\n\"); exit (0);\n }\n if (strncmp(un.version, \"V1\", 2) == 0) { /* XXX is V1 correct? */\n printf (\"i386-sequent-ptx1\\n\"); exit (0);\n }\n printf (\"i386-sequent-ptx\\n\"); exit (0);\n#endif\n\n#if defined (vax)\n#if !defined (ultrix)\n#include \n#if defined (BSD)\n#if BSD == 43\n printf (\"vax-dec-bsd4.3\\n\"); exit (0);\n#else\n#if BSD == 199006\n printf (\"vax-dec-bsd4.3reno\\n\"); exit (0);\n#else\n printf (\"vax-dec-bsd\\n\"); exit (0);\n#endif\n#endif\n#else\n printf (\"vax-dec-bsd\\n\"); exit (0);\n#endif\n#else\n#if defined(_SIZE_T_) || defined(SIGLOST)\n struct utsname un;\n uname (&un);\n printf (\"vax-dec-ultrix%s\\n\", un.release); exit (0);\n#else\n printf (\"vax-dec-ultrix\\n\"); exit (0);\n#endif\n#endif\n#endif\n#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)\n#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)\n#if defined(_SIZE_T_) || defined(SIGLOST)\n struct utsname *un;\n uname (&un);\n printf (\"mips-dec-ultrix%s\\n\", un.release); exit (0);\n#else\n printf (\"mips-dec-ultrix\\n\"); exit (0);\n#endif\n#endif\n#endif\n\n#if defined (alliant) && defined (i860)\n printf (\"i860-alliant-bsd\\n\"); exit (0);\n#endif\n\n exit (1);\n}\nEOF\n\n$CC_FOR_BUILD -o \"$dummy\" \"$dummy.c\" 2>/dev/null && SYSTEM_NAME=$($dummy) &&\n\t{ echo \"$SYSTEM_NAME\"; exit; }\n\n# Apollos put the system type in the environment.\ntest -d /usr/apollo && { echo \"$ISP-apollo-$SYSTYPE\"; exit; }\n\necho \"$0: unable to guess system type\" >&2\n\ncase \"$UNAME_MACHINE:$UNAME_SYSTEM\" in\n mips:Linux | mips64:Linux)\n\t# If we got here on MIPS GNU/Linux, output extra information.\n\tcat >&2 <&2 <&2 </dev/null || echo unknown)\nuname -r = $( (uname -r) 2>/dev/null || echo unknown)\nuname -s = $( (uname -s) 2>/dev/null || echo unknown)\nuname -v = $( (uname -v) 2>/dev/null || echo unknown)\n\n/usr/bin/uname -p = $( (/usr/bin/uname -p) 2>/dev/null)\n/bin/uname -X = $( (/bin/uname -X) 2>/dev/null)\n\nhostinfo = $( (hostinfo) 2>/dev/null)\n/bin/universe = $( (/bin/universe) 2>/dev/null)\n/usr/bin/arch -k = $( (/usr/bin/arch -k) 2>/dev/null)\n/bin/arch = $( (/bin/arch) 2>/dev/null)\n/usr/bin/oslevel = $( (/usr/bin/oslevel) 2>/dev/null)\n/usr/convex/getsysinfo = $( (/usr/convex/getsysinfo) 2>/dev/null)\n\nUNAME_MACHINE = \"$UNAME_MACHINE\"\nUNAME_RELEASE = \"$UNAME_RELEASE\"\nUNAME_SYSTEM = \"$UNAME_SYSTEM\"\nUNAME_VERSION = \"$UNAME_VERSION\"\nEOF\nfi\n\nexit 1\n\n# Local variables:\n# eval: (add-hook 'before-save-hook 'time-stamp)\n# time-stamp-start: \"timestamp='\"\n# time-stamp-format: \"%:y-%02m-%02d\"\n# time-stamp-end: \"'\"\n# End:\n" }, { "path": "deps/jemalloc/build-aux/config.sub", "content": "#! /bin/sh\n# Configuration validation subroutine script.\n# Copyright 1992-2021 Free Software Foundation, Inc.\n\ntimestamp='2021-01-07'\n\n# This file is free software; you can redistribute it and/or modify it\n# under the terms of the GNU General Public License as published by\n# the Free Software Foundation; either version 3 of the License, or\n# (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful, but\n# WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n# General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with this program; if not, see .\n#\n# As a special exception to the GNU General Public License, if you\n# distribute this file as part of a program that contains a\n# configuration script generated by Autoconf, you may include it under\n# the same distribution terms that you use for the rest of that\n# program. This Exception is an additional permission under section 7\n# of the GNU General Public License, version 3 (\"GPLv3\").\n\n\n# Please send patches to .\n#\n# Configuration subroutine to validate and canonicalize a configuration type.\n# Supply the specified configuration type as an argument.\n# If it is invalid, we print an error message on stderr and exit with code 1.\n# Otherwise, we print the canonical config type on stdout and succeed.\n\n# You can get the latest version of this script from:\n# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub\n\n# This file is supposed to be the same for all GNU packages\n# and recognize all the CPU types, system types and aliases\n# that are meaningful with *any* GNU software.\n# Each package is responsible for reporting which valid configurations\n# it does not support. The user should be able to distinguish\n# a failure to support a valid configuration from a meaningless\n# configuration.\n\n# The goal of this file is to map all the various variations of a given\n# machine specification into a single specification in the form:\n#\tCPU_TYPE-MANUFACTURER-OPERATING_SYSTEM\n# or in some cases, the newer four-part form:\n#\tCPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM\n# It is wrong to echo any other type of specification.\n\nme=$(echo \"$0\" | sed -e 's,.*/,,')\n\nusage=\"\\\nUsage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS\n\nCanonicalize a configuration name.\n\nOptions:\n -h, --help print this help, then exit\n -t, --time-stamp print date of last modification, then exit\n -v, --version print version number, then exit\n\nReport bugs and patches to .\"\n\nversion=\"\\\nGNU config.sub ($timestamp)\n\nCopyright 1992-2021 Free Software Foundation, Inc.\n\nThis is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\"\n\nhelp=\"\nTry \\`$me --help' for more information.\"\n\n# Parse command line\nwhile test $# -gt 0 ; do\n case $1 in\n --time-stamp | --time* | -t )\n echo \"$timestamp\" ; exit ;;\n --version | -v )\n echo \"$version\" ; exit ;;\n --help | --h* | -h )\n echo \"$usage\"; exit ;;\n -- ) # Stop option processing\n shift; break ;;\n - )\t# Use stdin as input.\n break ;;\n -* )\n echo \"$me: invalid option $1$help\" >&2\n exit 1 ;;\n\n *local*)\n # First pass through any local machine types.\n echo \"$1\"\n exit ;;\n\n * )\n break ;;\n esac\ndone\n\ncase $# in\n 0) echo \"$me: missing argument$help\" >&2\n exit 1;;\n 1) ;;\n *) echo \"$me: too many arguments$help\" >&2\n exit 1;;\nesac\n\n# Split fields of configuration type\n# shellcheck disable=SC2162\nIFS=\"-\" read field1 field2 field3 field4 <&2\n\t\texit 1\n\t\t;;\n\t*-*-*-*)\n\t\tbasic_machine=$field1-$field2\n\t\tbasic_os=$field3-$field4\n\t\t;;\n\t*-*-*)\n\t\t# Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two\n\t\t# parts\n\t\tmaybe_os=$field2-$field3\n\t\tcase $maybe_os in\n\t\t\tnto-qnx* | linux-* | uclinux-uclibc* \\\n\t\t\t| uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \\\n\t\t\t| netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \\\n\t\t\t| storm-chaos* | os2-emx* | rtmk-nova*)\n\t\t\t\tbasic_machine=$field1\n\t\t\t\tbasic_os=$maybe_os\n\t\t\t\t;;\n\t\t\tandroid-linux)\n\t\t\t\tbasic_machine=$field1-unknown\n\t\t\t\tbasic_os=linux-android\n\t\t\t\t;;\n\t\t\t*)\n\t\t\t\tbasic_machine=$field1-$field2\n\t\t\t\tbasic_os=$field3\n\t\t\t\t;;\n\t\tesac\n\t\t;;\n\t*-*)\n\t\t# A lone config we happen to match not fitting any pattern\n\t\tcase $field1-$field2 in\n\t\t\tdecstation-3100)\n\t\t\t\tbasic_machine=mips-dec\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\t*-*)\n\t\t\t\t# Second component is usually, but not always the OS\n\t\t\t\tcase $field2 in\n\t\t\t\t\t# Prevent following clause from handling this valid os\n\t\t\t\t\tsun*os*)\n\t\t\t\t\t\tbasic_machine=$field1\n\t\t\t\t\t\tbasic_os=$field2\n\t\t\t\t\t\t;;\n\t\t\t\t\t# Manufacturers\n\t\t\t\t\tdec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \\\n\t\t\t\t\t| att* | 7300* | 3300* | delta* | motorola* | sun[234]* \\\n\t\t\t\t\t| unicom* | ibm* | next | hp | isi* | apollo | altos* \\\n\t\t\t\t\t| convergent* | ncr* | news | 32* | 3600* | 3100* \\\n\t\t\t\t\t| hitachi* | c[123]* | convex* | sun | crds | omron* | dg \\\n\t\t\t\t\t| ultra | tti* | harris | dolphin | highlevel | gould \\\n\t\t\t\t\t| cbm | ns | masscomp | apple | axis | knuth | cray \\\n\t\t\t\t\t| microblaze* | sim | cisco \\\n\t\t\t\t\t| oki | wec | wrs | winbond)\n\t\t\t\t\t\tbasic_machine=$field1-$field2\n\t\t\t\t\t\tbasic_os=\n\t\t\t\t\t\t;;\n\t\t\t\t\t*)\n\t\t\t\t\t\tbasic_machine=$field1\n\t\t\t\t\t\tbasic_os=$field2\n\t\t\t\t\t\t;;\n\t\t\t\tesac\n\t\t\t;;\n\t\tesac\n\t\t;;\n\t*)\n\t\t# Convert single-component short-hands not valid as part of\n\t\t# multi-component configurations.\n\t\tcase $field1 in\n\t\t\t386bsd)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\ta29khif)\n\t\t\t\tbasic_machine=a29k-amd\n\t\t\t\tbasic_os=udi\n\t\t\t\t;;\n\t\t\tadobe68k)\n\t\t\t\tbasic_machine=m68010-adobe\n\t\t\t\tbasic_os=scout\n\t\t\t\t;;\n\t\t\talliant)\n\t\t\t\tbasic_machine=fx80-alliant\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\taltos | altos3068)\n\t\t\t\tbasic_machine=m68k-altos\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tam29k)\n\t\t\t\tbasic_machine=a29k-none\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tamdahl)\n\t\t\t\tbasic_machine=580-amdahl\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tamiga)\n\t\t\t\tbasic_machine=m68k-unknown\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tamigaos | amigados)\n\t\t\t\tbasic_machine=m68k-unknown\n\t\t\t\tbasic_os=amigaos\n\t\t\t\t;;\n\t\t\tamigaunix | amix)\n\t\t\t\tbasic_machine=m68k-unknown\n\t\t\t\tbasic_os=sysv4\n\t\t\t\t;;\n\t\t\tapollo68)\n\t\t\t\tbasic_machine=m68k-apollo\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tapollo68bsd)\n\t\t\t\tbasic_machine=m68k-apollo\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\taros)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=aros\n\t\t\t\t;;\n\t\t\taux)\n\t\t\t\tbasic_machine=m68k-apple\n\t\t\t\tbasic_os=aux\n\t\t\t\t;;\n\t\t\tbalance)\n\t\t\t\tbasic_machine=ns32k-sequent\n\t\t\t\tbasic_os=dynix\n\t\t\t\t;;\n\t\t\tblackfin)\n\t\t\t\tbasic_machine=bfin-unknown\n\t\t\t\tbasic_os=linux\n\t\t\t\t;;\n\t\t\tcegcc)\n\t\t\t\tbasic_machine=arm-unknown\n\t\t\t\tbasic_os=cegcc\n\t\t\t\t;;\n\t\t\tconvex-c1)\n\t\t\t\tbasic_machine=c1-convex\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tconvex-c2)\n\t\t\t\tbasic_machine=c2-convex\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tconvex-c32)\n\t\t\t\tbasic_machine=c32-convex\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tconvex-c34)\n\t\t\t\tbasic_machine=c34-convex\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tconvex-c38)\n\t\t\t\tbasic_machine=c38-convex\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\tcray)\n\t\t\t\tbasic_machine=j90-cray\n\t\t\t\tbasic_os=unicos\n\t\t\t\t;;\n\t\t\tcrds | unos)\n\t\t\t\tbasic_machine=m68k-crds\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tda30)\n\t\t\t\tbasic_machine=m68k-da30\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tdecstation | pmax | pmin | dec3100 | decstatn)\n\t\t\t\tbasic_machine=mips-dec\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tdelta88)\n\t\t\t\tbasic_machine=m88k-motorola\n\t\t\t\tbasic_os=sysv3\n\t\t\t\t;;\n\t\t\tdicos)\n\t\t\t\tbasic_machine=i686-pc\n\t\t\t\tbasic_os=dicos\n\t\t\t\t;;\n\t\t\tdjgpp)\n\t\t\t\tbasic_machine=i586-pc\n\t\t\t\tbasic_os=msdosdjgpp\n\t\t\t\t;;\n\t\t\tebmon29k)\n\t\t\t\tbasic_machine=a29k-amd\n\t\t\t\tbasic_os=ebmon\n\t\t\t\t;;\n\t\t\tes1800 | OSE68k | ose68k | ose | OSE)\n\t\t\t\tbasic_machine=m68k-ericsson\n\t\t\t\tbasic_os=ose\n\t\t\t\t;;\n\t\t\tgmicro)\n\t\t\t\tbasic_machine=tron-gmicro\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tgo32)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=go32\n\t\t\t\t;;\n\t\t\th8300hms)\n\t\t\t\tbasic_machine=h8300-hitachi\n\t\t\t\tbasic_os=hms\n\t\t\t\t;;\n\t\t\th8300xray)\n\t\t\t\tbasic_machine=h8300-hitachi\n\t\t\t\tbasic_os=xray\n\t\t\t\t;;\n\t\t\th8500hms)\n\t\t\t\tbasic_machine=h8500-hitachi\n\t\t\t\tbasic_os=hms\n\t\t\t\t;;\n\t\t\tharris)\n\t\t\t\tbasic_machine=m88k-harris\n\t\t\t\tbasic_os=sysv3\n\t\t\t\t;;\n\t\t\thp300 | hp300hpux)\n\t\t\t\tbasic_machine=m68k-hp\n\t\t\t\tbasic_os=hpux\n\t\t\t\t;;\n\t\t\thp300bsd)\n\t\t\t\tbasic_machine=m68k-hp\n\t\t\t\tbasic_os=bsd\n\t\t\t\t;;\n\t\t\thppaosf)\n\t\t\t\tbasic_machine=hppa1.1-hp\n\t\t\t\tbasic_os=osf\n\t\t\t\t;;\n\t\t\thppro)\n\t\t\t\tbasic_machine=hppa1.1-hp\n\t\t\t\tbasic_os=proelf\n\t\t\t\t;;\n\t\t\ti386mach)\n\t\t\t\tbasic_machine=i386-mach\n\t\t\t\tbasic_os=mach\n\t\t\t\t;;\n\t\t\tisi68 | isi)\n\t\t\t\tbasic_machine=m68k-isi\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tm68knommu)\n\t\t\t\tbasic_machine=m68k-unknown\n\t\t\t\tbasic_os=linux\n\t\t\t\t;;\n\t\t\tmagnum | m3230)\n\t\t\t\tbasic_machine=mips-mips\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tmerlin)\n\t\t\t\tbasic_machine=ns32k-utek\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tmingw64)\n\t\t\t\tbasic_machine=x86_64-pc\n\t\t\t\tbasic_os=mingw64\n\t\t\t\t;;\n\t\t\tmingw32)\n\t\t\t\tbasic_machine=i686-pc\n\t\t\t\tbasic_os=mingw32\n\t\t\t\t;;\n\t\t\tmingw32ce)\n\t\t\t\tbasic_machine=arm-unknown\n\t\t\t\tbasic_os=mingw32ce\n\t\t\t\t;;\n\t\t\tmonitor)\n\t\t\t\tbasic_machine=m68k-rom68k\n\t\t\t\tbasic_os=coff\n\t\t\t\t;;\n\t\t\tmorphos)\n\t\t\t\tbasic_machine=powerpc-unknown\n\t\t\t\tbasic_os=morphos\n\t\t\t\t;;\n\t\t\tmoxiebox)\n\t\t\t\tbasic_machine=moxie-unknown\n\t\t\t\tbasic_os=moxiebox\n\t\t\t\t;;\n\t\t\tmsdos)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=msdos\n\t\t\t\t;;\n\t\t\tmsys)\n\t\t\t\tbasic_machine=i686-pc\n\t\t\t\tbasic_os=msys\n\t\t\t\t;;\n\t\t\tmvs)\n\t\t\t\tbasic_machine=i370-ibm\n\t\t\t\tbasic_os=mvs\n\t\t\t\t;;\n\t\t\tnacl)\n\t\t\t\tbasic_machine=le32-unknown\n\t\t\t\tbasic_os=nacl\n\t\t\t\t;;\n\t\t\tncr3000)\n\t\t\t\tbasic_machine=i486-ncr\n\t\t\t\tbasic_os=sysv4\n\t\t\t\t;;\n\t\t\tnetbsd386)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=netbsd\n\t\t\t\t;;\n\t\t\tnetwinder)\n\t\t\t\tbasic_machine=armv4l-rebel\n\t\t\t\tbasic_os=linux\n\t\t\t\t;;\n\t\t\tnews | news700 | news800 | news900)\n\t\t\t\tbasic_machine=m68k-sony\n\t\t\t\tbasic_os=newsos\n\t\t\t\t;;\n\t\t\tnews1000)\n\t\t\t\tbasic_machine=m68030-sony\n\t\t\t\tbasic_os=newsos\n\t\t\t\t;;\n\t\t\tnecv70)\n\t\t\t\tbasic_machine=v70-nec\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tnh3000)\n\t\t\t\tbasic_machine=m68k-harris\n\t\t\t\tbasic_os=cxux\n\t\t\t\t;;\n\t\t\tnh[45]000)\n\t\t\t\tbasic_machine=m88k-harris\n\t\t\t\tbasic_os=cxux\n\t\t\t\t;;\n\t\t\tnindy960)\n\t\t\t\tbasic_machine=i960-intel\n\t\t\t\tbasic_os=nindy\n\t\t\t\t;;\n\t\t\tmon960)\n\t\t\t\tbasic_machine=i960-intel\n\t\t\t\tbasic_os=mon960\n\t\t\t\t;;\n\t\t\tnonstopux)\n\t\t\t\tbasic_machine=mips-compaq\n\t\t\t\tbasic_os=nonstopux\n\t\t\t\t;;\n\t\t\tos400)\n\t\t\t\tbasic_machine=powerpc-ibm\n\t\t\t\tbasic_os=os400\n\t\t\t\t;;\n\t\t\tOSE68000 | ose68000)\n\t\t\t\tbasic_machine=m68000-ericsson\n\t\t\t\tbasic_os=ose\n\t\t\t\t;;\n\t\t\tos68k)\n\t\t\t\tbasic_machine=m68k-none\n\t\t\t\tbasic_os=os68k\n\t\t\t\t;;\n\t\t\tparagon)\n\t\t\t\tbasic_machine=i860-intel\n\t\t\t\tbasic_os=osf\n\t\t\t\t;;\n\t\t\tparisc)\n\t\t\t\tbasic_machine=hppa-unknown\n\t\t\t\tbasic_os=linux\n\t\t\t\t;;\n\t\t\tpsp)\n\t\t\t\tbasic_machine=mipsallegrexel-sony\n\t\t\t\tbasic_os=psp\n\t\t\t\t;;\n\t\t\tpw32)\n\t\t\t\tbasic_machine=i586-unknown\n\t\t\t\tbasic_os=pw32\n\t\t\t\t;;\n\t\t\trdos | rdos64)\n\t\t\t\tbasic_machine=x86_64-pc\n\t\t\t\tbasic_os=rdos\n\t\t\t\t;;\n\t\t\trdos32)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=rdos\n\t\t\t\t;;\n\t\t\trom68k)\n\t\t\t\tbasic_machine=m68k-rom68k\n\t\t\t\tbasic_os=coff\n\t\t\t\t;;\n\t\t\tsa29200)\n\t\t\t\tbasic_machine=a29k-amd\n\t\t\t\tbasic_os=udi\n\t\t\t\t;;\n\t\t\tsei)\n\t\t\t\tbasic_machine=mips-sei\n\t\t\t\tbasic_os=seiux\n\t\t\t\t;;\n\t\t\tsequent)\n\t\t\t\tbasic_machine=i386-sequent\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tsps7)\n\t\t\t\tbasic_machine=m68k-bull\n\t\t\t\tbasic_os=sysv2\n\t\t\t\t;;\n\t\t\tst2000)\n\t\t\t\tbasic_machine=m68k-tandem\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tstratus)\n\t\t\t\tbasic_machine=i860-stratus\n\t\t\t\tbasic_os=sysv4\n\t\t\t\t;;\n\t\t\tsun2)\n\t\t\t\tbasic_machine=m68000-sun\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tsun2os3)\n\t\t\t\tbasic_machine=m68000-sun\n\t\t\t\tbasic_os=sunos3\n\t\t\t\t;;\n\t\t\tsun2os4)\n\t\t\t\tbasic_machine=m68000-sun\n\t\t\t\tbasic_os=sunos4\n\t\t\t\t;;\n\t\t\tsun3)\n\t\t\t\tbasic_machine=m68k-sun\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tsun3os3)\n\t\t\t\tbasic_machine=m68k-sun\n\t\t\t\tbasic_os=sunos3\n\t\t\t\t;;\n\t\t\tsun3os4)\n\t\t\t\tbasic_machine=m68k-sun\n\t\t\t\tbasic_os=sunos4\n\t\t\t\t;;\n\t\t\tsun4)\n\t\t\t\tbasic_machine=sparc-sun\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tsun4os3)\n\t\t\t\tbasic_machine=sparc-sun\n\t\t\t\tbasic_os=sunos3\n\t\t\t\t;;\n\t\t\tsun4os4)\n\t\t\t\tbasic_machine=sparc-sun\n\t\t\t\tbasic_os=sunos4\n\t\t\t\t;;\n\t\t\tsun4sol2)\n\t\t\t\tbasic_machine=sparc-sun\n\t\t\t\tbasic_os=solaris2\n\t\t\t\t;;\n\t\t\tsun386 | sun386i | roadrunner)\n\t\t\t\tbasic_machine=i386-sun\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\t\tsv1)\n\t\t\t\tbasic_machine=sv1-cray\n\t\t\t\tbasic_os=unicos\n\t\t\t\t;;\n\t\t\tsymmetry)\n\t\t\t\tbasic_machine=i386-sequent\n\t\t\t\tbasic_os=dynix\n\t\t\t\t;;\n\t\t\tt3e)\n\t\t\t\tbasic_machine=alphaev5-cray\n\t\t\t\tbasic_os=unicos\n\t\t\t\t;;\n\t\t\tt90)\n\t\t\t\tbasic_machine=t90-cray\n\t\t\t\tbasic_os=unicos\n\t\t\t\t;;\n\t\t\ttoad1)\n\t\t\t\tbasic_machine=pdp10-xkl\n\t\t\t\tbasic_os=tops20\n\t\t\t\t;;\n\t\t\ttpf)\n\t\t\t\tbasic_machine=s390x-ibm\n\t\t\t\tbasic_os=tpf\n\t\t\t\t;;\n\t\t\tudi29k)\n\t\t\t\tbasic_machine=a29k-amd\n\t\t\t\tbasic_os=udi\n\t\t\t\t;;\n\t\t\tultra3)\n\t\t\t\tbasic_machine=a29k-nyu\n\t\t\t\tbasic_os=sym1\n\t\t\t\t;;\n\t\t\tv810 | necv810)\n\t\t\t\tbasic_machine=v810-nec\n\t\t\t\tbasic_os=none\n\t\t\t\t;;\n\t\t\tvaxv)\n\t\t\t\tbasic_machine=vax-dec\n\t\t\t\tbasic_os=sysv\n\t\t\t\t;;\n\t\t\tvms)\n\t\t\t\tbasic_machine=vax-dec\n\t\t\t\tbasic_os=vms\n\t\t\t\t;;\n\t\t\tvsta)\n\t\t\t\tbasic_machine=i386-pc\n\t\t\t\tbasic_os=vsta\n\t\t\t\t;;\n\t\t\tvxworks960)\n\t\t\t\tbasic_machine=i960-wrs\n\t\t\t\tbasic_os=vxworks\n\t\t\t\t;;\n\t\t\tvxworks68)\n\t\t\t\tbasic_machine=m68k-wrs\n\t\t\t\tbasic_os=vxworks\n\t\t\t\t;;\n\t\t\tvxworks29k)\n\t\t\t\tbasic_machine=a29k-wrs\n\t\t\t\tbasic_os=vxworks\n\t\t\t\t;;\n\t\t\txbox)\n\t\t\t\tbasic_machine=i686-pc\n\t\t\t\tbasic_os=mingw32\n\t\t\t\t;;\n\t\t\tymp)\n\t\t\t\tbasic_machine=ymp-cray\n\t\t\t\tbasic_os=unicos\n\t\t\t\t;;\n\t\t\t*)\n\t\t\t\tbasic_machine=$1\n\t\t\t\tbasic_os=\n\t\t\t\t;;\n\t\tesac\n\t\t;;\nesac\n\n# Decode 1-component or ad-hoc basic machines\ncase $basic_machine in\n\t# Here we handle the default manufacturer of certain CPU types. It is in\n\t# some cases the only manufacturer, in others, it is the most popular.\n\tw89k)\n\t\tcpu=hppa1.1\n\t\tvendor=winbond\n\t\t;;\n\top50n)\n\t\tcpu=hppa1.1\n\t\tvendor=oki\n\t\t;;\n\top60c)\n\t\tcpu=hppa1.1\n\t\tvendor=oki\n\t\t;;\n\tibm*)\n\t\tcpu=i370\n\t\tvendor=ibm\n\t\t;;\n\torion105)\n\t\tcpu=clipper\n\t\tvendor=highlevel\n\t\t;;\n\tmac | mpw | mac-mpw)\n\t\tcpu=m68k\n\t\tvendor=apple\n\t\t;;\n\tpmac | pmac-mpw)\n\t\tcpu=powerpc\n\t\tvendor=apple\n\t\t;;\n\n\t# Recognize the various machine names and aliases which stand\n\t# for a CPU type and a company and sometimes even an OS.\n\t3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)\n\t\tcpu=m68000\n\t\tvendor=att\n\t\t;;\n\t3b*)\n\t\tcpu=we32k\n\t\tvendor=att\n\t\t;;\n\tbluegene*)\n\t\tcpu=powerpc\n\t\tvendor=ibm\n\t\tbasic_os=cnk\n\t\t;;\n\tdecsystem10* | dec10*)\n\t\tcpu=pdp10\n\t\tvendor=dec\n\t\tbasic_os=tops10\n\t\t;;\n\tdecsystem20* | dec20*)\n\t\tcpu=pdp10\n\t\tvendor=dec\n\t\tbasic_os=tops20\n\t\t;;\n\tdelta | 3300 | motorola-3300 | motorola-delta \\\n\t | 3300-motorola | delta-motorola)\n\t\tcpu=m68k\n\t\tvendor=motorola\n\t\t;;\n\tdpx2*)\n\t\tcpu=m68k\n\t\tvendor=bull\n\t\tbasic_os=sysv3\n\t\t;;\n\tencore | umax | mmax)\n\t\tcpu=ns32k\n\t\tvendor=encore\n\t\t;;\n\telxsi)\n\t\tcpu=elxsi\n\t\tvendor=elxsi\n\t\tbasic_os=${basic_os:-bsd}\n\t\t;;\n\tfx2800)\n\t\tcpu=i860\n\t\tvendor=alliant\n\t\t;;\n\tgenix)\n\t\tcpu=ns32k\n\t\tvendor=ns\n\t\t;;\n\th3050r* | hiux*)\n\t\tcpu=hppa1.1\n\t\tvendor=hitachi\n\t\tbasic_os=hiuxwe2\n\t\t;;\n\thp3k9[0-9][0-9] | hp9[0-9][0-9])\n\t\tcpu=hppa1.0\n\t\tvendor=hp\n\t\t;;\n\thp9k2[0-9][0-9] | hp9k31[0-9])\n\t\tcpu=m68000\n\t\tvendor=hp\n\t\t;;\n\thp9k3[2-9][0-9])\n\t\tcpu=m68k\n\t\tvendor=hp\n\t\t;;\n\thp9k6[0-9][0-9] | hp6[0-9][0-9])\n\t\tcpu=hppa1.0\n\t\tvendor=hp\n\t\t;;\n\thp9k7[0-79][0-9] | hp7[0-79][0-9])\n\t\tcpu=hppa1.1\n\t\tvendor=hp\n\t\t;;\n\thp9k78[0-9] | hp78[0-9])\n\t\t# FIXME: really hppa2.0-hp\n\t\tcpu=hppa1.1\n\t\tvendor=hp\n\t\t;;\n\thp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)\n\t\t# FIXME: really hppa2.0-hp\n\t\tcpu=hppa1.1\n\t\tvendor=hp\n\t\t;;\n\thp9k8[0-9][13679] | hp8[0-9][13679])\n\t\tcpu=hppa1.1\n\t\tvendor=hp\n\t\t;;\n\thp9k8[0-9][0-9] | hp8[0-9][0-9])\n\t\tcpu=hppa1.0\n\t\tvendor=hp\n\t\t;;\n\ti*86v32)\n\t\tcpu=$(echo \"$1\" | sed -e 's/86.*/86/')\n\t\tvendor=pc\n\t\tbasic_os=sysv32\n\t\t;;\n\ti*86v4*)\n\t\tcpu=$(echo \"$1\" | sed -e 's/86.*/86/')\n\t\tvendor=pc\n\t\tbasic_os=sysv4\n\t\t;;\n\ti*86v)\n\t\tcpu=$(echo \"$1\" | sed -e 's/86.*/86/')\n\t\tvendor=pc\n\t\tbasic_os=sysv\n\t\t;;\n\ti*86sol2)\n\t\tcpu=$(echo \"$1\" | sed -e 's/86.*/86/')\n\t\tvendor=pc\n\t\tbasic_os=solaris2\n\t\t;;\n\tj90 | j90-cray)\n\t\tcpu=j90\n\t\tvendor=cray\n\t\tbasic_os=${basic_os:-unicos}\n\t\t;;\n\tiris | iris4d)\n\t\tcpu=mips\n\t\tvendor=sgi\n\t\tcase $basic_os in\n\t\t irix*)\n\t\t\t;;\n\t\t *)\n\t\t\tbasic_os=irix4\n\t\t\t;;\n\t\tesac\n\t\t;;\n\tminiframe)\n\t\tcpu=m68000\n\t\tvendor=convergent\n\t\t;;\n\t*mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)\n\t\tcpu=m68k\n\t\tvendor=atari\n\t\tbasic_os=mint\n\t\t;;\n\tnews-3600 | risc-news)\n\t\tcpu=mips\n\t\tvendor=sony\n\t\tbasic_os=newsos\n\t\t;;\n\tnext | m*-next)\n\t\tcpu=m68k\n\t\tvendor=next\n\t\tcase $basic_os in\n\t\t openstep*)\n\t\t ;;\n\t\t nextstep*)\n\t\t\t;;\n\t\t ns2*)\n\t\t basic_os=nextstep2\n\t\t\t;;\n\t\t *)\n\t\t basic_os=nextstep3\n\t\t\t;;\n\t\tesac\n\t\t;;\n\tnp1)\n\t\tcpu=np1\n\t\tvendor=gould\n\t\t;;\n\top50n-* | op60c-*)\n\t\tcpu=hppa1.1\n\t\tvendor=oki\n\t\tbasic_os=proelf\n\t\t;;\n\tpa-hitachi)\n\t\tcpu=hppa1.1\n\t\tvendor=hitachi\n\t\tbasic_os=hiuxwe2\n\t\t;;\n\tpbd)\n\t\tcpu=sparc\n\t\tvendor=tti\n\t\t;;\n\tpbb)\n\t\tcpu=m68k\n\t\tvendor=tti\n\t\t;;\n\tpc532)\n\t\tcpu=ns32k\n\t\tvendor=pc532\n\t\t;;\n\tpn)\n\t\tcpu=pn\n\t\tvendor=gould\n\t\t;;\n\tpower)\n\t\tcpu=power\n\t\tvendor=ibm\n\t\t;;\n\tps2)\n\t\tcpu=i386\n\t\tvendor=ibm\n\t\t;;\n\trm[46]00)\n\t\tcpu=mips\n\t\tvendor=siemens\n\t\t;;\n\trtpc | rtpc-*)\n\t\tcpu=romp\n\t\tvendor=ibm\n\t\t;;\n\tsde)\n\t\tcpu=mipsisa32\n\t\tvendor=sde\n\t\tbasic_os=${basic_os:-elf}\n\t\t;;\n\tsimso-wrs)\n\t\tcpu=sparclite\n\t\tvendor=wrs\n\t\tbasic_os=vxworks\n\t\t;;\n\ttower | tower-32)\n\t\tcpu=m68k\n\t\tvendor=ncr\n\t\t;;\n\tvpp*|vx|vx-*)\n\t\tcpu=f301\n\t\tvendor=fujitsu\n\t\t;;\n\tw65)\n\t\tcpu=w65\n\t\tvendor=wdc\n\t\t;;\n\tw89k-*)\n\t\tcpu=hppa1.1\n\t\tvendor=winbond\n\t\tbasic_os=proelf\n\t\t;;\n\tnone)\n\t\tcpu=none\n\t\tvendor=none\n\t\t;;\n\tleon|leon[3-9])\n\t\tcpu=sparc\n\t\tvendor=$basic_machine\n\t\t;;\n\tleon-*|leon[3-9]-*)\n\t\tcpu=sparc\n\t\tvendor=$(echo \"$basic_machine\" | sed 's/-.*//')\n\t\t;;\n\n\t*-*)\n\t\t# shellcheck disable=SC2162\n\t\tIFS=\"-\" read cpu vendor <&2\n\t\t\t\texit 1\n\t\t\t\t;;\n\t\tesac\n\t\t;;\nesac\n\n# Here we canonicalize certain aliases for manufacturers.\ncase $vendor in\n\tdigital*)\n\t\tvendor=dec\n\t\t;;\n\tcommodore*)\n\t\tvendor=cbm\n\t\t;;\n\t*)\n\t\t;;\nesac\n\n# Decode manufacturer-specific aliases for certain operating systems.\n\nif test x$basic_os != x\nthen\n\n# First recognize some ad-hoc caes, or perhaps split kernel-os, or else just\n# set os.\ncase $basic_os in\n\tgnu/linux*)\n\t\tkernel=linux\n\t\tos=$(echo $basic_os | sed -e 's|gnu/linux|gnu|')\n\t\t;;\n\tos2-emx)\n\t\tkernel=os2\n\t\tos=$(echo $basic_os | sed -e 's|os2-emx|emx|')\n\t\t;;\n\tnto-qnx*)\n\t\tkernel=nto\n\t\tos=$(echo $basic_os | sed -e 's|nto-qnx|qnx|')\n\t\t;;\n\t*-*)\n\t\t# shellcheck disable=SC2162\n\t\tIFS=\"-\" read kernel os <&2\n\t\texit 1\n\t\t;;\nesac\n\n# As a final step for OS-related things, validate the OS-kernel combination\n# (given a valid OS), if there is a kernel.\ncase $kernel-$os in\n\tlinux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* | linux-musl* | linux-uclibc* )\n\t\t;;\n\tuclinux-uclibc* )\n\t\t;;\n\t-dietlibc* | -newlib* | -musl* | -uclibc* )\n\t\t# These are just libc implementations, not actual OSes, and thus\n\t\t# require a kernel.\n\t\techo \"Invalid configuration \\`$1': libc \\`$os' needs explicit kernel.\" 1>&2\n\t\texit 1\n\t\t;;\n\tkfreebsd*-gnu* | kopensolaris*-gnu*)\n\t\t;;\n\tnto-qnx*)\n\t\t;;\n\tos2-emx)\n\t\t;;\n\t*-eabi* | *-gnueabi*)\n\t\t;;\n\t-*)\n\t\t# Blank kernel with real OS is always fine.\n\t\t;;\n\t*-*)\n\t\techo \"Invalid configuration \\`$1': Kernel \\`$kernel' not known to work with OS \\`$os'.\" 1>&2\n\t\texit 1\n\t\t;;\nesac\n\n# Here we handle the case where we know the os, and the CPU type, but not the\n# manufacturer. We pick the logical manufacturer.\ncase $vendor in\n\tunknown)\n\t\tcase $cpu-$os in\n\t\t\t*-riscix*)\n\t\t\t\tvendor=acorn\n\t\t\t\t;;\n\t\t\t*-sunos*)\n\t\t\t\tvendor=sun\n\t\t\t\t;;\n\t\t\t*-cnk* | *-aix*)\n\t\t\t\tvendor=ibm\n\t\t\t\t;;\n\t\t\t*-beos*)\n\t\t\t\tvendor=be\n\t\t\t\t;;\n\t\t\t*-hpux*)\n\t\t\t\tvendor=hp\n\t\t\t\t;;\n\t\t\t*-mpeix*)\n\t\t\t\tvendor=hp\n\t\t\t\t;;\n\t\t\t*-hiux*)\n\t\t\t\tvendor=hitachi\n\t\t\t\t;;\n\t\t\t*-unos*)\n\t\t\t\tvendor=crds\n\t\t\t\t;;\n\t\t\t*-dgux*)\n\t\t\t\tvendor=dg\n\t\t\t\t;;\n\t\t\t*-luna*)\n\t\t\t\tvendor=omron\n\t\t\t\t;;\n\t\t\t*-genix*)\n\t\t\t\tvendor=ns\n\t\t\t\t;;\n\t\t\t*-clix*)\n\t\t\t\tvendor=intergraph\n\t\t\t\t;;\n\t\t\t*-mvs* | *-opened*)\n\t\t\t\tvendor=ibm\n\t\t\t\t;;\n\t\t\t*-os400*)\n\t\t\t\tvendor=ibm\n\t\t\t\t;;\n\t\t\ts390-* | s390x-*)\n\t\t\t\tvendor=ibm\n\t\t\t\t;;\n\t\t\t*-ptx*)\n\t\t\t\tvendor=sequent\n\t\t\t\t;;\n\t\t\t*-tpf*)\n\t\t\t\tvendor=ibm\n\t\t\t\t;;\n\t\t\t*-vxsim* | *-vxworks* | *-windiss*)\n\t\t\t\tvendor=wrs\n\t\t\t\t;;\n\t\t\t*-aux*)\n\t\t\t\tvendor=apple\n\t\t\t\t;;\n\t\t\t*-hms*)\n\t\t\t\tvendor=hitachi\n\t\t\t\t;;\n\t\t\t*-mpw* | *-macos*)\n\t\t\t\tvendor=apple\n\t\t\t\t;;\n\t\t\t*-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)\n\t\t\t\tvendor=atari\n\t\t\t\t;;\n\t\t\t*-vos*)\n\t\t\t\tvendor=stratus\n\t\t\t\t;;\n\t\tesac\n\t\t;;\nesac\n\necho \"$cpu-$vendor-${kernel:+$kernel-}$os\"\nexit\n\n# Local variables:\n# eval: (add-hook 'before-save-hook 'time-stamp)\n# time-stamp-start: \"timestamp='\"\n# time-stamp-format: \"%:y-%02m-%02d\"\n# time-stamp-end: \"'\"\n# End:\n" }, { "path": "deps/jemalloc/build-aux/install-sh", "content": "#! /bin/sh\n#\n# install - install a program, script, or datafile\n# This comes from X11R5 (mit/util/scripts/install.sh).\n#\n# Copyright 1991 by the Massachusetts Institute of Technology\n#\n# Permission to use, copy, modify, distribute, and sell this software and its\n# documentation for any purpose is hereby granted without fee, provided that\n# the above copyright notice appear in all copies and that both that\n# copyright notice and this permission notice appear in supporting\n# documentation, and that the name of M.I.T. not be used in advertising or\n# publicity pertaining to distribution of the software without specific,\n# written prior permission. M.I.T. makes no representations about the\n# suitability of this software for any purpose. It is provided \"as is\"\n# without express or implied warranty.\n#\n# Calling this script install-sh is preferred over install.sh, to prevent\n# `make' implicit rules from creating a file called install from it\n# when there is no Makefile.\n#\n# This script is compatible with the BSD install script, but was written\n# from scratch. It can only install one file at a time, a restriction\n# shared with many OS's install programs.\n\n\n# set DOITPROG to echo to test this script\n\n# Don't use :- since 4.3BSD and earlier shells don't like it.\ndoit=\"${DOITPROG-}\"\n\n\n# put in absolute paths if you don't have them in your path; or use env. vars.\n\nmvprog=\"${MVPROG-mv}\"\ncpprog=\"${CPPROG-cp}\"\nchmodprog=\"${CHMODPROG-chmod}\"\nchownprog=\"${CHOWNPROG-chown}\"\nchgrpprog=\"${CHGRPPROG-chgrp}\"\nstripprog=\"${STRIPPROG-strip}\"\nrmprog=\"${RMPROG-rm}\"\nmkdirprog=\"${MKDIRPROG-mkdir}\"\n\ntransformbasename=\"\"\ntransform_arg=\"\"\ninstcmd=\"$mvprog\"\nchmodcmd=\"$chmodprog 0755\"\nchowncmd=\"\"\nchgrpcmd=\"\"\nstripcmd=\"\"\nrmcmd=\"$rmprog -f\"\nmvcmd=\"$mvprog\"\nsrc=\"\"\ndst=\"\"\ndir_arg=\"\"\n\nwhile [ x\"$1\" != x ]; do\n case $1 in\n\t-c) instcmd=\"$cpprog\"\n\t shift\n\t continue;;\n\n\t-d) dir_arg=true\n\t shift\n\t continue;;\n\n\t-m) chmodcmd=\"$chmodprog $2\"\n\t shift\n\t shift\n\t continue;;\n\n\t-o) chowncmd=\"$chownprog $2\"\n\t shift\n\t shift\n\t continue;;\n\n\t-g) chgrpcmd=\"$chgrpprog $2\"\n\t shift\n\t shift\n\t continue;;\n\n\t-s) stripcmd=\"$stripprog\"\n\t shift\n\t continue;;\n\n\t-t=*) transformarg=`echo $1 | sed 's/-t=//'`\n\t shift\n\t continue;;\n\n\t-b=*) transformbasename=`echo $1 | sed 's/-b=//'`\n\t shift\n\t continue;;\n\n\t*) if [ x\"$src\" = x ]\n\t then\n\t\tsrc=$1\n\t else\n\t\t# this colon is to work around a 386BSD /bin/sh bug\n\t\t:\n\t\tdst=$1\n\t fi\n\t shift\n\t continue;;\n esac\ndone\n\nif [ x\"$src\" = x ]\nthen\n\techo \"install:\tno input file specified\"\n\texit 1\nelse\n\ttrue\nfi\n\nif [ x\"$dir_arg\" != x ]; then\n\tdst=$src\n\tsrc=\"\"\n\t\n\tif [ -d $dst ]; then\n\t\tinstcmd=:\n\telse\n\t\tinstcmd=mkdir\n\tfi\nelse\n\n# Waiting for this to be detected by the \"$instcmd $src $dsttmp\" command\n# might cause directories to be created, which would be especially bad \n# if $src (and thus $dsttmp) contains '*'.\n\n\tif [ -f $src -o -d $src ]\n\tthen\n\t\ttrue\n\telse\n\t\techo \"install: $src does not exist\"\n\t\texit 1\n\tfi\n\t\n\tif [ x\"$dst\" = x ]\n\tthen\n\t\techo \"install:\tno destination specified\"\n\t\texit 1\n\telse\n\t\ttrue\n\tfi\n\n# If destination is a directory, append the input filename; if your system\n# does not like double slashes in filenames, you may need to add some logic\n\n\tif [ -d $dst ]\n\tthen\n\t\tdst=\"$dst\"/`basename $src`\n\telse\n\t\ttrue\n\tfi\nfi\n\n## this sed command emulates the dirname command\ndstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`\n\n# Make sure that the destination directory exists.\n# this part is taken from Noah Friedman's mkinstalldirs script\n\n# Skip lots of stat calls in the usual case.\nif [ ! -d \"$dstdir\" ]; then\ndefaultIFS='\t\n'\nIFS=\"${IFS-${defaultIFS}}\"\n\noIFS=\"${IFS}\"\n# Some sh's can't handle IFS=/ for some reason.\nIFS='%'\nset - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`\nIFS=\"${oIFS}\"\n\npathcomp=''\n\nwhile [ $# -ne 0 ] ; do\n\tpathcomp=\"${pathcomp}${1}\"\n\tshift\n\n\tif [ ! -d \"${pathcomp}\" ] ;\n then\n\t\t$mkdirprog \"${pathcomp}\"\n\telse\n\t\ttrue\n\tfi\n\n\tpathcomp=\"${pathcomp}/\"\ndone\nfi\n\nif [ x\"$dir_arg\" != x ]\nthen\n\t$doit $instcmd $dst &&\n\n\tif [ x\"$chowncmd\" != x ]; then $doit $chowncmd $dst; else true ; fi &&\n\tif [ x\"$chgrpcmd\" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&\n\tif [ x\"$stripcmd\" != x ]; then $doit $stripcmd $dst; else true ; fi &&\n\tif [ x\"$chmodcmd\" != x ]; then $doit $chmodcmd $dst; else true ; fi\nelse\n\n# If we're going to rename the final executable, determine the name now.\n\n\tif [ x\"$transformarg\" = x ] \n\tthen\n\t\tdstfile=`basename $dst`\n\telse\n\t\tdstfile=`basename $dst $transformbasename | \n\t\t\tsed $transformarg`$transformbasename\n\tfi\n\n# don't allow the sed command to completely eliminate the filename\n\n\tif [ x\"$dstfile\" = x ] \n\tthen\n\t\tdstfile=`basename $dst`\n\telse\n\t\ttrue\n\tfi\n\n# Make a temp file name in the proper directory.\n\n\tdsttmp=$dstdir/#inst.$$#\n\n# Move or copy the file name to the temp name\n\n\t$doit $instcmd $src $dsttmp &&\n\n\ttrap \"rm -f ${dsttmp}\" 0 &&\n\n# and set any options; do chmod last to preserve setuid bits\n\n# If any of these fail, we abort the whole thing. If we want to\n# ignore errors from any of these, just make sure not to ignore\n# errors from the above \"$doit $instcmd $src $dsttmp\" command.\n\n\tif [ x\"$chowncmd\" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&\n\tif [ x\"$chgrpcmd\" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&\n\tif [ x\"$stripcmd\" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&\n\tif [ x\"$chmodcmd\" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&\n\n# Now rename the file to the real destination.\n\n\t$doit $rmcmd -f $dstdir/$dstfile &&\n\t$doit $mvcmd $dsttmp $dstdir/$dstfile \n\nfi &&\n\n\nexit 0\n" }, { "path": "deps/jemalloc/config.stamp.in", "content": "" }, { "path": "deps/jemalloc/configure", "content": "#! /bin/sh\n# Guess values for system-dependent variables and create Makefiles.\n# Generated by GNU Autoconf 2.71.\n#\n#\n# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,\n# Inc.\n#\n#\n# This configure script is free software; the Free Software Foundation\n# gives unlimited permission to copy, distribute and modify it.\n## -------------------- ##\n## M4sh Initialization. ##\n## -------------------- ##\n\n# Be more Bourne compatible\nDUALCASE=1; export DUALCASE # for MKS sh\nas_nop=:\nif test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1\nthen :\n emulate sh\n NULLCMD=:\n # Pre-4.2 versions of Zsh do word splitting on ${1+\"$@\"}, which\n # is contrary to our usage. Disable this feature.\n alias -g '${1+\"$@\"}'='\"$@\"'\n setopt NO_GLOB_SUBST\nelse $as_nop\n case `(set -o) 2>/dev/null` in #(\n *posix*) :\n set -o posix ;; #(\n *) :\n ;;\nesac\nfi\n\n\n\n# Reset variables that may have inherited troublesome values from\n# the environment.\n\n# IFS needs to be set, to space, tab, and newline, in precisely that order.\n# (If _AS_PATH_WALK were called with IFS unset, it would have the\n# side effect of setting IFS to empty, thus disabling word splitting.)\n# Quoting is to prevent editors from complaining about space-tab.\nas_nl='\n'\nexport as_nl\nIFS=\" \"\"\t$as_nl\"\n\nPS1='$ '\nPS2='> '\nPS4='+ '\n\n# Ensure predictable behavior from utilities with locale-dependent output.\nLC_ALL=C\nexport LC_ALL\nLANGUAGE=C\nexport LANGUAGE\n\n# We cannot yet rely on \"unset\" to work, but we need these variables\n# to be unset--not just set to an empty or harmless value--now, to\n# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct\n# also avoids known problems related to \"unset\" and subshell syntax\n# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).\nfor as_var in BASH_ENV ENV MAIL MAILPATH CDPATH\ndo eval test \\${$as_var+y} \\\n && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :\ndone\n\n# Ensure that fds 0, 1, and 2 are open.\nif (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi\nif (exec 3>&2) ; then :; else exec 2>/dev/null; fi\n\n# The user is always right.\nif ${PATH_SEPARATOR+false} :; then\n PATH_SEPARATOR=:\n (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {\n (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||\n PATH_SEPARATOR=';'\n }\nfi\n\n\n# Find who we are. Look in the path if we contain no directory separator.\nas_myself=\ncase $0 in #((\n *[\\\\/]* ) as_myself=$0 ;;\n *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n test -r \"$as_dir$0\" && as_myself=$as_dir$0 && break\n done\nIFS=$as_save_IFS\n\n ;;\nesac\n# We did not find ourselves, most probably we were run as `sh COMMAND'\n# in which case we are not to be found in the path.\nif test \"x$as_myself\" = x; then\n as_myself=$0\nfi\nif test ! -f \"$as_myself\"; then\n printf \"%s\\n\" \"$as_myself: error: cannot find myself; rerun with an absolute file name\" >&2\n exit 1\nfi\n\n\n# Use a proper internal environment variable to ensure we don't fall\n # into an infinite loop, continuously re-executing ourselves.\n if test x\"${_as_can_reexec}\" != xno && test \"x$CONFIG_SHELL\" != x; then\n _as_can_reexec=no; export _as_can_reexec;\n # We cannot yet assume a decent shell, so we have to provide a\n# neutralization value for shells without unset; and this also\n# works around shells that cannot unset nonexistent variables.\n# Preserve -v and -x to the replacement shell.\nBASH_ENV=/dev/null\nENV=/dev/null\n(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV\ncase $- in # ((((\n *v*x* | *x*v* ) as_opts=-vx ;;\n *v* ) as_opts=-v ;;\n *x* ) as_opts=-x ;;\n * ) as_opts= ;;\nesac\nexec $CONFIG_SHELL $as_opts \"$as_myself\" ${1+\"$@\"}\n# Admittedly, this is quite paranoid, since all the known shells bail\n# out after a failed `exec'.\nprintf \"%s\\n\" \"$0: could not re-execute with $CONFIG_SHELL\" >&2\nexit 255\n fi\n # We don't want this to propagate to other subprocesses.\n { _as_can_reexec=; unset _as_can_reexec;}\nif test \"x$CONFIG_SHELL\" = x; then\n as_bourne_compatible=\"as_nop=:\nif test \\${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1\nthen :\n emulate sh\n NULLCMD=:\n # Pre-4.2 versions of Zsh do word splitting on \\${1+\\\"\\$@\\\"}, which\n # is contrary to our usage. Disable this feature.\n alias -g '\\${1+\\\"\\$@\\\"}'='\\\"\\$@\\\"'\n setopt NO_GLOB_SUBST\nelse \\$as_nop\n case \\`(set -o) 2>/dev/null\\` in #(\n *posix*) :\n set -o posix ;; #(\n *) :\n ;;\nesac\nfi\n\"\n as_required=\"as_fn_return () { (exit \\$1); }\nas_fn_success () { as_fn_return 0; }\nas_fn_failure () { as_fn_return 1; }\nas_fn_ret_success () { return 0; }\nas_fn_ret_failure () { return 1; }\n\nexitcode=0\nas_fn_success || { exitcode=1; echo as_fn_success failed.; }\nas_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }\nas_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }\nas_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }\nif ( set x; as_fn_ret_success y && test x = \\\"\\$1\\\" )\nthen :\n\nelse \\$as_nop\n exitcode=1; echo positional parameters were not saved.\nfi\ntest x\\$exitcode = x0 || exit 1\nblah=\\$(echo \\$(echo blah))\ntest x\\\"\\$blah\\\" = xblah || exit 1\ntest -x / || exit 1\"\n as_suggested=\" as_lineno_1=\";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested\" as_lineno_1a=\\$LINENO\n as_lineno_2=\";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested\" as_lineno_2a=\\$LINENO\n eval 'test \\\"x\\$as_lineno_1'\\$as_run'\\\" != \\\"x\\$as_lineno_2'\\$as_run'\\\" &&\n test \\\"x\\`expr \\$as_lineno_1'\\$as_run' + 1\\`\\\" = \\\"x\\$as_lineno_2'\\$as_run'\\\"' || exit 1\ntest \\$(( 1 + 1 )) = 2 || exit 1\"\n if (eval \"$as_required\") 2>/dev/null\nthen :\n as_have_required=yes\nelse $as_nop\n as_have_required=no\nfi\n if test x$as_have_required = xyes && (eval \"$as_suggested\") 2>/dev/null\nthen :\n\nelse $as_nop\n as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nas_found=false\nfor as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n as_found=:\n case $as_dir in #(\n\t /*)\n\t for as_base in sh bash ksh sh5; do\n\t # Try only shells that exist, to save several forks.\n\t as_shell=$as_dir$as_base\n\t if { test -f \"$as_shell\" || test -f \"$as_shell.exe\"; } &&\n\t\t as_run=a \"$as_shell\" -c \"$as_bourne_compatible\"\"$as_required\" 2>/dev/null\nthen :\n CONFIG_SHELL=$as_shell as_have_required=yes\n\t\t if as_run=a \"$as_shell\" -c \"$as_bourne_compatible\"\"$as_suggested\" 2>/dev/null\nthen :\n break 2\nfi\nfi\n\t done;;\n esac\n as_found=false\ndone\nIFS=$as_save_IFS\nif $as_found\nthen :\n\nelse $as_nop\n if { test -f \"$SHELL\" || test -f \"$SHELL.exe\"; } &&\n\t as_run=a \"$SHELL\" -c \"$as_bourne_compatible\"\"$as_required\" 2>/dev/null\nthen :\n CONFIG_SHELL=$SHELL as_have_required=yes\nfi\nfi\n\n\n if test \"x$CONFIG_SHELL\" != x\nthen :\n export CONFIG_SHELL\n # We cannot yet assume a decent shell, so we have to provide a\n# neutralization value for shells without unset; and this also\n# works around shells that cannot unset nonexistent variables.\n# Preserve -v and -x to the replacement shell.\nBASH_ENV=/dev/null\nENV=/dev/null\n(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV\ncase $- in # ((((\n *v*x* | *x*v* ) as_opts=-vx ;;\n *v* ) as_opts=-v ;;\n *x* ) as_opts=-x ;;\n * ) as_opts= ;;\nesac\nexec $CONFIG_SHELL $as_opts \"$as_myself\" ${1+\"$@\"}\n# Admittedly, this is quite paranoid, since all the known shells bail\n# out after a failed `exec'.\nprintf \"%s\\n\" \"$0: could not re-execute with $CONFIG_SHELL\" >&2\nexit 255\nfi\n\n if test x$as_have_required = xno\nthen :\n printf \"%s\\n\" \"$0: This script requires a shell more modern than all\"\n printf \"%s\\n\" \"$0: the shells that I found on your system.\"\n if test ${ZSH_VERSION+y} ; then\n printf \"%s\\n\" \"$0: In particular, zsh $ZSH_VERSION has bugs and should\"\n printf \"%s\\n\" \"$0: be upgraded to zsh 4.3.4 or later.\"\n else\n printf \"%s\\n\" \"$0: Please tell bug-autoconf@gnu.org about your system,\n$0: including any error possibly output before this\n$0: message. Then install a modern shell, or manually run\n$0: the script under such a shell if you do have one.\"\n fi\n exit 1\nfi\nfi\nfi\nSHELL=${CONFIG_SHELL-/bin/sh}\nexport SHELL\n# Unset more variables known to interfere with behavior of common tools.\nCLICOLOR_FORCE= GREP_OPTIONS=\nunset CLICOLOR_FORCE GREP_OPTIONS\n\n## --------------------- ##\n## M4sh Shell Functions. ##\n## --------------------- ##\n# as_fn_unset VAR\n# ---------------\n# Portably unset VAR.\nas_fn_unset ()\n{\n { eval $1=; unset $1;}\n}\nas_unset=as_fn_unset\n\n\n# as_fn_set_status STATUS\n# -----------------------\n# Set $? to STATUS, without forking.\nas_fn_set_status ()\n{\n return $1\n} # as_fn_set_status\n\n# as_fn_exit STATUS\n# -----------------\n# Exit the shell with STATUS, even in a \"trap 0\" or \"set -e\" context.\nas_fn_exit ()\n{\n set +e\n as_fn_set_status $1\n exit $1\n} # as_fn_exit\n# as_fn_nop\n# ---------\n# Do nothing but, unlike \":\", preserve the value of $?.\nas_fn_nop ()\n{\n return $?\n}\nas_nop=as_fn_nop\n\n# as_fn_mkdir_p\n# -------------\n# Create \"$as_dir\" as a directory, including parents if necessary.\nas_fn_mkdir_p ()\n{\n\n case $as_dir in #(\n -*) as_dir=./$as_dir;;\n esac\n test -d \"$as_dir\" || eval $as_mkdir_p || {\n as_dirs=\n while :; do\n case $as_dir in #(\n *\\'*) as_qdir=`printf \"%s\\n\" \"$as_dir\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"`;; #'(\n *) as_qdir=$as_dir;;\n esac\n as_dirs=\"'$as_qdir' $as_dirs\"\n as_dir=`$as_dirname -- \"$as_dir\" ||\n$as_expr X\"$as_dir\" : 'X\\(.*[^/]\\)//*[^/][^/]*/*$' \\| \\\n\t X\"$as_dir\" : 'X\\(//\\)[^/]' \\| \\\n\t X\"$as_dir\" : 'X\\(//\\)$' \\| \\\n\t X\"$as_dir\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X\"$as_dir\" |\n sed '/^X\\(.*[^/]\\)\\/\\/*[^/][^/]*\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)[^/].*/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n test -d \"$as_dir\" && break\n done\n test -z \"$as_dirs\" || eval \"mkdir $as_dirs\"\n } || test -d \"$as_dir\" || as_fn_error $? \"cannot create directory $as_dir\"\n\n\n} # as_fn_mkdir_p\n\n# as_fn_executable_p FILE\n# -----------------------\n# Test if FILE is an executable regular file.\nas_fn_executable_p ()\n{\n test -f \"$1\" && test -x \"$1\"\n} # as_fn_executable_p\n# as_fn_append VAR VALUE\n# ----------------------\n# Append the text in VALUE to the end of the definition contained in VAR. Take\n# advantage of any shell optimizations that allow amortized linear growth over\n# repeated appends, instead of the typical quadratic growth present in naive\n# implementations.\nif (eval \"as_var=1; as_var+=2; test x\\$as_var = x12\") 2>/dev/null\nthen :\n eval 'as_fn_append ()\n {\n eval $1+=\\$2\n }'\nelse $as_nop\n as_fn_append ()\n {\n eval $1=\\$$1\\$2\n }\nfi # as_fn_append\n\n# as_fn_arith ARG...\n# ------------------\n# Perform arithmetic evaluation on the ARGs, and store the result in the\n# global $as_val. Take advantage of shells that can avoid forks. The arguments\n# must be portable across $(()) and expr.\nif (eval \"test \\$(( 1 + 1 )) = 2\") 2>/dev/null\nthen :\n eval 'as_fn_arith ()\n {\n as_val=$(( $* ))\n }'\nelse $as_nop\n as_fn_arith ()\n {\n as_val=`expr \"$@\" || test $? -eq 1`\n }\nfi # as_fn_arith\n\n# as_fn_nop\n# ---------\n# Do nothing but, unlike \":\", preserve the value of $?.\nas_fn_nop ()\n{\n return $?\n}\nas_nop=as_fn_nop\n\n# as_fn_error STATUS ERROR [LINENO LOG_FD]\n# ----------------------------------------\n# Output \"`basename $0`: error: ERROR\" to stderr. If LINENO and LOG_FD are\n# provided, also output the error to LOG_FD, referencing LINENO. Then exit the\n# script with STATUS, using 1 if that was 0.\nas_fn_error ()\n{\n as_status=$1; test $as_status -eq 0 && as_status=1\n if test \"$4\"; then\n as_lineno=${as_lineno-\"$3\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: $2\" >&$4\n fi\n printf \"%s\\n\" \"$as_me: error: $2\" >&2\n as_fn_exit $as_status\n} # as_fn_error\n\nif expr a : '\\(a\\)' >/dev/null 2>&1 &&\n test \"X`expr 00001 : '.*\\(...\\)'`\" = X001; then\n as_expr=expr\nelse\n as_expr=false\nfi\n\nif (basename -- /) >/dev/null 2>&1 && test \"X`basename -- / 2>&1`\" = \"X/\"; then\n as_basename=basename\nelse\n as_basename=false\nfi\n\nif (as_dir=`dirname -- /` && test \"X$as_dir\" = X/) >/dev/null 2>&1; then\n as_dirname=dirname\nelse\n as_dirname=false\nfi\n\nas_me=`$as_basename -- \"$0\" ||\n$as_expr X/\"$0\" : '.*/\\([^/][^/]*\\)/*$' \\| \\\n\t X\"$0\" : 'X\\(//\\)$' \\| \\\n\t X\"$0\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X/\"$0\" |\n sed '/^.*\\/\\([^/][^/]*\\)\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\/\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\/\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n\n# Avoid depending upon Character Ranges.\nas_cr_letters='abcdefghijklmnopqrstuvwxyz'\nas_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'\nas_cr_Letters=$as_cr_letters$as_cr_LETTERS\nas_cr_digits='0123456789'\nas_cr_alnum=$as_cr_Letters$as_cr_digits\n\n\n as_lineno_1=$LINENO as_lineno_1a=$LINENO\n as_lineno_2=$LINENO as_lineno_2a=$LINENO\n eval 'test \"x$as_lineno_1'$as_run'\" != \"x$as_lineno_2'$as_run'\" &&\n test \"x`expr $as_lineno_1'$as_run' + 1`\" = \"x$as_lineno_2'$as_run'\"' || {\n # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)\n sed -n '\n p\n /[$]LINENO/=\n ' <$as_myself |\n sed '\n s/[$]LINENO.*/&-/\n t lineno\n b\n :lineno\n N\n :loop\n s/[$]LINENO\\([^'$as_cr_alnum'_].*\\n\\)\\(.*\\)/\\2\\1\\2/\n t loop\n s/-\\n.*//\n ' >$as_me.lineno &&\n chmod +x \"$as_me.lineno\" ||\n { printf \"%s\\n\" \"$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell\" >&2; as_fn_exit 1; }\n\n # If we had to re-execute with $CONFIG_SHELL, we're ensured to have\n # already done that, so ensure we don't try to do so again and fall\n # in an infinite loop. This has already happened in practice.\n _as_can_reexec=no; export _as_can_reexec\n # Don't try to exec as it changes $[0], causing all sort of problems\n # (the dirname of $[0] is not the place where we might find the\n # original and so on. Autoconf is especially sensitive to this).\n . \"./$as_me.lineno\"\n # Exit status is that of the last command.\n exit\n}\n\n\n# Determine whether it's possible to make 'echo' print without a newline.\n# These variables are no longer used directly by Autoconf, but are AC_SUBSTed\n# for compatibility with existing Makefiles.\nECHO_C= ECHO_N= ECHO_T=\ncase `echo -n x` in #(((((\n-n*)\n case `echo 'xy\\c'` in\n *c*) ECHO_T='\t';;\t# ECHO_T is single tab character.\n xy) ECHO_C='\\c';;\n *) echo `echo ksh88 bug on AIX 6.1` > /dev/null\n ECHO_T='\t';;\n esac;;\n*)\n ECHO_N='-n';;\nesac\n\n# For backward compatibility with old third-party macros, we provide\n# the shell variables $as_echo and $as_echo_n. New code should use\n# AS_ECHO([\"message\"]) and AS_ECHO_N([\"message\"]), respectively.\nas_echo='printf %s\\n'\nas_echo_n='printf %s'\n\n\nrm -f conf$$ conf$$.exe conf$$.file\nif test -d conf$$.dir; then\n rm -f conf$$.dir/conf$$.file\nelse\n rm -f conf$$.dir\n mkdir conf$$.dir 2>/dev/null\nfi\nif (echo >conf$$.file) 2>/dev/null; then\n if ln -s conf$$.file conf$$ 2>/dev/null; then\n as_ln_s='ln -s'\n # ... but there are two gotchas:\n # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.\n # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.\n # In both cases, we have to default to `cp -pR'.\n ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||\n as_ln_s='cp -pR'\n elif ln conf$$.file conf$$ 2>/dev/null; then\n as_ln_s=ln\n else\n as_ln_s='cp -pR'\n fi\nelse\n as_ln_s='cp -pR'\nfi\nrm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file\nrmdir conf$$.dir 2>/dev/null\n\nif mkdir -p . 2>/dev/null; then\n as_mkdir_p='mkdir -p \"$as_dir\"'\nelse\n test -d ./-p && rmdir ./-p\n as_mkdir_p=false\nfi\n\nas_test_x='test -x'\nas_executable_p=as_fn_executable_p\n\n# Sed expression to map a string onto a valid CPP name.\nas_tr_cpp=\"eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'\"\n\n# Sed expression to map a string onto a valid variable name.\nas_tr_sh=\"eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'\"\n\n\ntest -n \"$DJDIR\" || exec 7<&0 &1\n\n# Name of the host.\n# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,\n# so uname gets run too.\nac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`\n\n#\n# Initializations.\n#\nac_default_prefix=/usr/local\nac_clean_files=\nac_config_libobj_dir=.\nLIBOBJS=\ncross_compiling=no\nsubdirs=\nMFLAGS=\nMAKEFLAGS=\n\n# Identity of this package.\nPACKAGE_NAME=''\nPACKAGE_TARNAME=''\nPACKAGE_VERSION=''\nPACKAGE_STRING=''\nPACKAGE_BUGREPORT=''\nPACKAGE_URL=''\n\nac_unique_file=\"Makefile.in\"\n# Factoring default headers for most tests.\nac_includes_default=\"\\\n#include \n#ifdef HAVE_STDIO_H\n# include \n#endif\n#ifdef HAVE_STDLIB_H\n# include \n#endif\n#ifdef HAVE_STRING_H\n# include \n#endif\n#ifdef HAVE_INTTYPES_H\n# include \n#endif\n#ifdef HAVE_STDINT_H\n# include \n#endif\n#ifdef HAVE_STRINGS_H\n# include \n#endif\n#ifdef HAVE_SYS_TYPES_H\n# include \n#endif\n#ifdef HAVE_SYS_STAT_H\n# include \n#endif\n#ifdef HAVE_UNISTD_H\n# include \n#endif\"\n\nac_header_c_list=\nac_subst_vars='LTLIBOBJS\nLIBOBJS\ncfgoutputs_out\ncfgoutputs_in\ncfghdrs_out\ncfghdrs_in\nenable_initial_exec_tls\nenable_zone_allocator\nenable_tls\nenable_lazy_lock\nlibdl\nenable_uaf_detection\nenable_opt_size_checks\nenable_opt_safety_checks\nenable_readlinkat\nenable_log\nenable_cache_oblivious\nenable_xmalloc\nenable_utrace\nenable_fill\nenable_prof\nenable_experimental_smallocx\nenable_stats\nenable_debug\nje_\ninstall_suffix\nprivate_namespace\nJEMALLOC_CPREFIX\nJEMALLOC_PREFIX\nenable_static\nenable_shared\nenable_doc\nAUTOCONF\nLD\nRANLIB\nINSTALL_DATA\nINSTALL_SCRIPT\nINSTALL_PROGRAM\nenable_autogen\nRPATH_EXTRA\nLM\nCC_MM\nDUMP_SYMS\nAROUT\nARFLAGS\nMKLIB\nTEST_LD_MODE\nLDTARGET\nCTARGET\nPIC_CFLAGS\nSOREV\nEXTRA_LDFLAGS\nDSO_LDFLAGS\nlink_whole_archive\nlibprefix\nexe\na\no\nimportlib\nso\nLD_PRELOAD_VAR\nRPATH\nabi\njemalloc_version_gid\njemalloc_version_nrev\njemalloc_version_bugfix\njemalloc_version_minor\njemalloc_version_major\njemalloc_version\nAWK\nNM\nAR\nhost_os\nhost_vendor\nhost_cpu\nhost\nbuild_os\nbuild_vendor\nbuild_cpu\nbuild\nEXTRA_CXXFLAGS\nSPECIFIED_CXXFLAGS\nCONFIGURE_CXXFLAGS\nenable_cxx\nHAVE_CXX14\nHAVE_CXX17\nac_ct_CXX\nCXXFLAGS\nCXX\nCPP\nEXTRA_CFLAGS\nSPECIFIED_CFLAGS\nCONFIGURE_CFLAGS\nOBJEXT\nEXEEXT\nac_ct_CC\nCPPFLAGS\nLDFLAGS\nCFLAGS\nCC\nXSLROOT\nXSLTPROC\nMANDIR\nDATADIR\nLIBDIR\nINCLUDEDIR\nBINDIR\nPREFIX\nabs_objroot\nobjroot\nabs_srcroot\nsrcroot\nrev\nCONFIG\ntarget_alias\nhost_alias\nbuild_alias\nLIBS\nECHO_T\nECHO_N\nECHO_C\nDEFS\nmandir\nlocaledir\nlibdir\npsdir\npdfdir\ndvidir\nhtmldir\ninfodir\ndocdir\noldincludedir\nincludedir\nrunstatedir\nlocalstatedir\nsharedstatedir\nsysconfdir\ndatadir\ndatarootdir\nlibexecdir\nsbindir\nbindir\nprogram_transform_name\nprefix\nexec_prefix\nPACKAGE_URL\nPACKAGE_BUGREPORT\nPACKAGE_STRING\nPACKAGE_VERSION\nPACKAGE_TARNAME\nPACKAGE_NAME\nPATH_SEPARATOR\nSHELL'\nac_subst_files=''\nac_user_opts='\nenable_option_checking\nwith_xslroot\nenable_cxx\nwith_lg_vaddr\nwith_version\nwith_rpath\nenable_autogen\nenable_doc\nenable_shared\nenable_static\nwith_mangling\nwith_jemalloc_prefix\nwith_export\nwith_private_namespace\nwith_install_suffix\nwith_malloc_conf\nenable_debug\nenable_stats\nenable_experimental_smallocx\nenable_prof\nenable_prof_libunwind\nwith_static_libunwind\nenable_prof_libgcc\nenable_prof_gcc\nenable_fill\nenable_utrace\nenable_xmalloc\nenable_cache_oblivious\nenable_log\nenable_readlinkat\nenable_opt_safety_checks\nenable_opt_size_checks\nenable_uaf_detection\nwith_lg_quantum\nwith_lg_slab_maxregs\nwith_lg_page\nwith_lg_hugepage\nenable_libdl\nenable_syscall\nenable_lazy_lock\nenable_zone_allocator\nenable_initial_exec_tls\n'\n ac_precious_vars='build_alias\nhost_alias\ntarget_alias\nCC\nCFLAGS\nLDFLAGS\nLIBS\nCPPFLAGS\nCPP\nCXX\nCXXFLAGS\nCCC'\n\n\n# Initialize some variables set by options.\nac_init_help=\nac_init_version=false\nac_unrecognized_opts=\nac_unrecognized_sep=\n# The variables have the same names as the options, with\n# dashes changed to underlines.\ncache_file=/dev/null\nexec_prefix=NONE\nno_create=\nno_recursion=\nprefix=NONE\nprogram_prefix=NONE\nprogram_suffix=NONE\nprogram_transform_name=s,x,x,\nsilent=\nsite=\nsrcdir=\nverbose=\nx_includes=NONE\nx_libraries=NONE\n\n# Installation directory options.\n# These are left unexpanded so users can \"make install exec_prefix=/foo\"\n# and all the variables that are supposed to be based on exec_prefix\n# by default will actually change.\n# Use braces instead of parens because sh, perl, etc. also accept them.\n# (The list follows the same order as the GNU Coding Standards.)\nbindir='${exec_prefix}/bin'\nsbindir='${exec_prefix}/sbin'\nlibexecdir='${exec_prefix}/libexec'\ndatarootdir='${prefix}/share'\ndatadir='${datarootdir}'\nsysconfdir='${prefix}/etc'\nsharedstatedir='${prefix}/com'\nlocalstatedir='${prefix}/var'\nrunstatedir='${localstatedir}/run'\nincludedir='${prefix}/include'\noldincludedir='/usr/include'\ndocdir='${datarootdir}/doc/${PACKAGE}'\ninfodir='${datarootdir}/info'\nhtmldir='${docdir}'\ndvidir='${docdir}'\npdfdir='${docdir}'\npsdir='${docdir}'\nlibdir='${exec_prefix}/lib'\nlocaledir='${datarootdir}/locale'\nmandir='${datarootdir}/man'\n\nac_prev=\nac_dashdash=\nfor ac_option\ndo\n # If the previous option needs an argument, assign it.\n if test -n \"$ac_prev\"; then\n eval $ac_prev=\\$ac_option\n ac_prev=\n continue\n fi\n\n case $ac_option in\n *=?*) ac_optarg=`expr \"X$ac_option\" : '[^=]*=\\(.*\\)'` ;;\n *=) ac_optarg= ;;\n *) ac_optarg=yes ;;\n esac\n\n case $ac_dashdash$ac_option in\n --)\n ac_dashdash=yes ;;\n\n -bindir | --bindir | --bindi | --bind | --bin | --bi)\n ac_prev=bindir ;;\n -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)\n bindir=$ac_optarg ;;\n\n -build | --build | --buil | --bui | --bu)\n ac_prev=build_alias ;;\n -build=* | --build=* | --buil=* | --bui=* | --bu=*)\n build_alias=$ac_optarg ;;\n\n -cache-file | --cache-file | --cache-fil | --cache-fi \\\n | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)\n ac_prev=cache_file ;;\n -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \\\n | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)\n cache_file=$ac_optarg ;;\n\n --config-cache | -C)\n cache_file=config.cache ;;\n\n -datadir | --datadir | --datadi | --datad)\n ac_prev=datadir ;;\n -datadir=* | --datadir=* | --datadi=* | --datad=*)\n datadir=$ac_optarg ;;\n\n -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \\\n | --dataroo | --dataro | --datar)\n ac_prev=datarootdir ;;\n -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \\\n | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)\n datarootdir=$ac_optarg ;;\n\n -disable-* | --disable-*)\n ac_useropt=`expr \"x$ac_option\" : 'x-*disable-\\(.*\\)'`\n # Reject names that are not valid shell variable names.\n expr \"x$ac_useropt\" : \".*[^-+._$as_cr_alnum]\" >/dev/null &&\n as_fn_error $? \"invalid feature name: \\`$ac_useropt'\"\n ac_useropt_orig=$ac_useropt\n ac_useropt=`printf \"%s\\n\" \"$ac_useropt\" | sed 's/[-+.]/_/g'`\n case $ac_user_opts in\n *\"\n\"enable_$ac_useropt\"\n\"*) ;;\n *) ac_unrecognized_opts=\"$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig\"\n\t ac_unrecognized_sep=', ';;\n esac\n eval enable_$ac_useropt=no ;;\n\n -docdir | --docdir | --docdi | --doc | --do)\n ac_prev=docdir ;;\n -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)\n docdir=$ac_optarg ;;\n\n -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)\n ac_prev=dvidir ;;\n -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)\n dvidir=$ac_optarg ;;\n\n -enable-* | --enable-*)\n ac_useropt=`expr \"x$ac_option\" : 'x-*enable-\\([^=]*\\)'`\n # Reject names that are not valid shell variable names.\n expr \"x$ac_useropt\" : \".*[^-+._$as_cr_alnum]\" >/dev/null &&\n as_fn_error $? \"invalid feature name: \\`$ac_useropt'\"\n ac_useropt_orig=$ac_useropt\n ac_useropt=`printf \"%s\\n\" \"$ac_useropt\" | sed 's/[-+.]/_/g'`\n case $ac_user_opts in\n *\"\n\"enable_$ac_useropt\"\n\"*) ;;\n *) ac_unrecognized_opts=\"$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig\"\n\t ac_unrecognized_sep=', ';;\n esac\n eval enable_$ac_useropt=\\$ac_optarg ;;\n\n -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \\\n | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \\\n | --exec | --exe | --ex)\n ac_prev=exec_prefix ;;\n -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \\\n | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \\\n | --exec=* | --exe=* | --ex=*)\n exec_prefix=$ac_optarg ;;\n\n -gas | --gas | --ga | --g)\n # Obsolete; use --with-gas.\n with_gas=yes ;;\n\n -help | --help | --hel | --he | -h)\n ac_init_help=long ;;\n -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)\n ac_init_help=recursive ;;\n -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)\n ac_init_help=short ;;\n\n -host | --host | --hos | --ho)\n ac_prev=host_alias ;;\n -host=* | --host=* | --hos=* | --ho=*)\n host_alias=$ac_optarg ;;\n\n -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)\n ac_prev=htmldir ;;\n -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \\\n | --ht=*)\n htmldir=$ac_optarg ;;\n\n -includedir | --includedir | --includedi | --included | --include \\\n | --includ | --inclu | --incl | --inc)\n ac_prev=includedir ;;\n -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \\\n | --includ=* | --inclu=* | --incl=* | --inc=*)\n includedir=$ac_optarg ;;\n\n -infodir | --infodir | --infodi | --infod | --info | --inf)\n ac_prev=infodir ;;\n -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)\n infodir=$ac_optarg ;;\n\n -libdir | --libdir | --libdi | --libd)\n ac_prev=libdir ;;\n -libdir=* | --libdir=* | --libdi=* | --libd=*)\n libdir=$ac_optarg ;;\n\n -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \\\n | --libexe | --libex | --libe)\n ac_prev=libexecdir ;;\n -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \\\n | --libexe=* | --libex=* | --libe=*)\n libexecdir=$ac_optarg ;;\n\n -localedir | --localedir | --localedi | --localed | --locale)\n ac_prev=localedir ;;\n -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)\n localedir=$ac_optarg ;;\n\n -localstatedir | --localstatedir | --localstatedi | --localstated \\\n | --localstate | --localstat | --localsta | --localst | --locals)\n ac_prev=localstatedir ;;\n -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \\\n | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)\n localstatedir=$ac_optarg ;;\n\n -mandir | --mandir | --mandi | --mand | --man | --ma | --m)\n ac_prev=mandir ;;\n -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)\n mandir=$ac_optarg ;;\n\n -nfp | --nfp | --nf)\n # Obsolete; use --without-fp.\n with_fp=no ;;\n\n -no-create | --no-create | --no-creat | --no-crea | --no-cre \\\n | --no-cr | --no-c | -n)\n no_create=yes ;;\n\n -no-recursion | --no-recursion | --no-recursio | --no-recursi \\\n | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)\n no_recursion=yes ;;\n\n -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \\\n | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \\\n | --oldin | --oldi | --old | --ol | --o)\n ac_prev=oldincludedir ;;\n -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \\\n | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \\\n | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)\n oldincludedir=$ac_optarg ;;\n\n -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)\n ac_prev=prefix ;;\n -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)\n prefix=$ac_optarg ;;\n\n -program-prefix | --program-prefix | --program-prefi | --program-pref \\\n | --program-pre | --program-pr | --program-p)\n ac_prev=program_prefix ;;\n -program-prefix=* | --program-prefix=* | --program-prefi=* \\\n | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)\n program_prefix=$ac_optarg ;;\n\n -program-suffix | --program-suffix | --program-suffi | --program-suff \\\n | --program-suf | --program-su | --program-s)\n ac_prev=program_suffix ;;\n -program-suffix=* | --program-suffix=* | --program-suffi=* \\\n | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)\n program_suffix=$ac_optarg ;;\n\n -program-transform-name | --program-transform-name \\\n | --program-transform-nam | --program-transform-na \\\n | --program-transform-n | --program-transform- \\\n | --program-transform | --program-transfor \\\n | --program-transfo | --program-transf \\\n | --program-trans | --program-tran \\\n | --progr-tra | --program-tr | --program-t)\n ac_prev=program_transform_name ;;\n -program-transform-name=* | --program-transform-name=* \\\n | --program-transform-nam=* | --program-transform-na=* \\\n | --program-transform-n=* | --program-transform-=* \\\n | --program-transform=* | --program-transfor=* \\\n | --program-transfo=* | --program-transf=* \\\n | --program-trans=* | --program-tran=* \\\n | --progr-tra=* | --program-tr=* | --program-t=*)\n program_transform_name=$ac_optarg ;;\n\n -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)\n ac_prev=pdfdir ;;\n -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)\n pdfdir=$ac_optarg ;;\n\n -psdir | --psdir | --psdi | --psd | --ps)\n ac_prev=psdir ;;\n -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)\n psdir=$ac_optarg ;;\n\n -q | -quiet | --quiet | --quie | --qui | --qu | --q \\\n | -silent | --silent | --silen | --sile | --sil)\n silent=yes ;;\n\n -runstatedir | --runstatedir | --runstatedi | --runstated \\\n | --runstate | --runstat | --runsta | --runst | --runs \\\n | --run | --ru | --r)\n ac_prev=runstatedir ;;\n -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \\\n | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \\\n | --run=* | --ru=* | --r=*)\n runstatedir=$ac_optarg ;;\n\n -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)\n ac_prev=sbindir ;;\n -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \\\n | --sbi=* | --sb=*)\n sbindir=$ac_optarg ;;\n\n -sharedstatedir | --sharedstatedir | --sharedstatedi \\\n | --sharedstated | --sharedstate | --sharedstat | --sharedsta \\\n | --sharedst | --shareds | --shared | --share | --shar \\\n | --sha | --sh)\n ac_prev=sharedstatedir ;;\n -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \\\n | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \\\n | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \\\n | --sha=* | --sh=*)\n sharedstatedir=$ac_optarg ;;\n\n -site | --site | --sit)\n ac_prev=site ;;\n -site=* | --site=* | --sit=*)\n site=$ac_optarg ;;\n\n -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)\n ac_prev=srcdir ;;\n -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)\n srcdir=$ac_optarg ;;\n\n -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \\\n | --syscon | --sysco | --sysc | --sys | --sy)\n ac_prev=sysconfdir ;;\n -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \\\n | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)\n sysconfdir=$ac_optarg ;;\n\n -target | --target | --targe | --targ | --tar | --ta | --t)\n ac_prev=target_alias ;;\n -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)\n target_alias=$ac_optarg ;;\n\n -v | -verbose | --verbose | --verbos | --verbo | --verb)\n verbose=yes ;;\n\n -version | --version | --versio | --versi | --vers | -V)\n ac_init_version=: ;;\n\n -with-* | --with-*)\n ac_useropt=`expr \"x$ac_option\" : 'x-*with-\\([^=]*\\)'`\n # Reject names that are not valid shell variable names.\n expr \"x$ac_useropt\" : \".*[^-+._$as_cr_alnum]\" >/dev/null &&\n as_fn_error $? \"invalid package name: \\`$ac_useropt'\"\n ac_useropt_orig=$ac_useropt\n ac_useropt=`printf \"%s\\n\" \"$ac_useropt\" | sed 's/[-+.]/_/g'`\n case $ac_user_opts in\n *\"\n\"with_$ac_useropt\"\n\"*) ;;\n *) ac_unrecognized_opts=\"$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig\"\n\t ac_unrecognized_sep=', ';;\n esac\n eval with_$ac_useropt=\\$ac_optarg ;;\n\n -without-* | --without-*)\n ac_useropt=`expr \"x$ac_option\" : 'x-*without-\\(.*\\)'`\n # Reject names that are not valid shell variable names.\n expr \"x$ac_useropt\" : \".*[^-+._$as_cr_alnum]\" >/dev/null &&\n as_fn_error $? \"invalid package name: \\`$ac_useropt'\"\n ac_useropt_orig=$ac_useropt\n ac_useropt=`printf \"%s\\n\" \"$ac_useropt\" | sed 's/[-+.]/_/g'`\n case $ac_user_opts in\n *\"\n\"with_$ac_useropt\"\n\"*) ;;\n *) ac_unrecognized_opts=\"$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig\"\n\t ac_unrecognized_sep=', ';;\n esac\n eval with_$ac_useropt=no ;;\n\n --x)\n # Obsolete; use --with-x.\n with_x=yes ;;\n\n -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \\\n | --x-incl | --x-inc | --x-in | --x-i)\n ac_prev=x_includes ;;\n -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \\\n | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)\n x_includes=$ac_optarg ;;\n\n -x-libraries | --x-libraries | --x-librarie | --x-librari \\\n | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)\n ac_prev=x_libraries ;;\n -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \\\n | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)\n x_libraries=$ac_optarg ;;\n\n -*) as_fn_error $? \"unrecognized option: \\`$ac_option'\nTry \\`$0 --help' for more information\"\n ;;\n\n *=*)\n ac_envvar=`expr \"x$ac_option\" : 'x\\([^=]*\\)='`\n # Reject names that are not valid shell variable names.\n case $ac_envvar in #(\n '' | [0-9]* | *[!_$as_cr_alnum]* )\n as_fn_error $? \"invalid variable name: \\`$ac_envvar'\" ;;\n esac\n eval $ac_envvar=\\$ac_optarg\n export $ac_envvar ;;\n\n *)\n # FIXME: should be removed in autoconf 3.0.\n printf \"%s\\n\" \"$as_me: WARNING: you should use --build, --host, --target\" >&2\n expr \"x$ac_option\" : \".*[^-._$as_cr_alnum]\" >/dev/null &&\n printf \"%s\\n\" \"$as_me: WARNING: invalid host type: $ac_option\" >&2\n : \"${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}\"\n ;;\n\n esac\ndone\n\nif test -n \"$ac_prev\"; then\n ac_option=--`echo $ac_prev | sed 's/_/-/g'`\n as_fn_error $? \"missing argument to $ac_option\"\nfi\n\nif test -n \"$ac_unrecognized_opts\"; then\n case $enable_option_checking in\n no) ;;\n fatal) as_fn_error $? \"unrecognized options: $ac_unrecognized_opts\" ;;\n *) printf \"%s\\n\" \"$as_me: WARNING: unrecognized options: $ac_unrecognized_opts\" >&2 ;;\n esac\nfi\n\n# Check all directory arguments for consistency.\nfor ac_var in\texec_prefix prefix bindir sbindir libexecdir datarootdir \\\n\t\tdatadir sysconfdir sharedstatedir localstatedir includedir \\\n\t\toldincludedir docdir infodir htmldir dvidir pdfdir psdir \\\n\t\tlibdir localedir mandir runstatedir\ndo\n eval ac_val=\\$$ac_var\n # Remove trailing slashes.\n case $ac_val in\n */ )\n ac_val=`expr \"X$ac_val\" : 'X\\(.*[^/]\\)' \\| \"X$ac_val\" : 'X\\(.*\\)'`\n eval $ac_var=\\$ac_val;;\n esac\n # Be sure to have absolute directory names.\n case $ac_val in\n [\\\\/$]* | ?:[\\\\/]* ) continue;;\n NONE | '' ) case $ac_var in *prefix ) continue;; esac;;\n esac\n as_fn_error $? \"expected an absolute directory name for --$ac_var: $ac_val\"\ndone\n\n# There might be people who depend on the old broken behavior: `$host'\n# used to hold the argument of --host etc.\n# FIXME: To remove some day.\nbuild=$build_alias\nhost=$host_alias\ntarget=$target_alias\n\n# FIXME: To remove some day.\nif test \"x$host_alias\" != x; then\n if test \"x$build_alias\" = x; then\n cross_compiling=maybe\n elif test \"x$build_alias\" != \"x$host_alias\"; then\n cross_compiling=yes\n fi\nfi\n\nac_tool_prefix=\ntest -n \"$host_alias\" && ac_tool_prefix=$host_alias-\n\ntest \"$silent\" = yes && exec 6>/dev/null\n\n\nac_pwd=`pwd` && test -n \"$ac_pwd\" &&\nac_ls_di=`ls -di .` &&\nac_pwd_ls_di=`cd \"$ac_pwd\" && ls -di .` ||\n as_fn_error $? \"working directory cannot be determined\"\ntest \"X$ac_ls_di\" = \"X$ac_pwd_ls_di\" ||\n as_fn_error $? \"pwd does not report name of working directory\"\n\n\n# Find the source files, if location was not specified.\nif test -z \"$srcdir\"; then\n ac_srcdir_defaulted=yes\n # Try the directory containing this script, then the parent directory.\n ac_confdir=`$as_dirname -- \"$as_myself\" ||\n$as_expr X\"$as_myself\" : 'X\\(.*[^/]\\)//*[^/][^/]*/*$' \\| \\\n\t X\"$as_myself\" : 'X\\(//\\)[^/]' \\| \\\n\t X\"$as_myself\" : 'X\\(//\\)$' \\| \\\n\t X\"$as_myself\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X\"$as_myself\" |\n sed '/^X\\(.*[^/]\\)\\/\\/*[^/][^/]*\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)[^/].*/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n srcdir=$ac_confdir\n if test ! -r \"$srcdir/$ac_unique_file\"; then\n srcdir=..\n fi\nelse\n ac_srcdir_defaulted=no\nfi\nif test ! -r \"$srcdir/$ac_unique_file\"; then\n test \"$ac_srcdir_defaulted\" = yes && srcdir=\"$ac_confdir or ..\"\n as_fn_error $? \"cannot find sources ($ac_unique_file) in $srcdir\"\nfi\nac_msg=\"sources are in $srcdir, but \\`cd $srcdir' does not work\"\nac_abs_confdir=`(\n\tcd \"$srcdir\" && test -r \"./$ac_unique_file\" || as_fn_error $? \"$ac_msg\"\n\tpwd)`\n# When building in place, set srcdir=.\nif test \"$ac_abs_confdir\" = \"$ac_pwd\"; then\n srcdir=.\nfi\n# Remove unnecessary trailing slashes from srcdir.\n# Double slashes in file names in object file debugging info\n# mess up M-x gdb in Emacs.\ncase $srcdir in\n*/) srcdir=`expr \"X$srcdir\" : 'X\\(.*[^/]\\)' \\| \"X$srcdir\" : 'X\\(.*\\)'`;;\nesac\nfor ac_var in $ac_precious_vars; do\n eval ac_env_${ac_var}_set=\\${${ac_var}+set}\n eval ac_env_${ac_var}_value=\\$${ac_var}\n eval ac_cv_env_${ac_var}_set=\\${${ac_var}+set}\n eval ac_cv_env_${ac_var}_value=\\$${ac_var}\ndone\n\n#\n# Report the --help message.\n#\nif test \"$ac_init_help\" = \"long\"; then\n # Omit some internal or obsolete options to make the list less imposing.\n # This message is too long to be a string in the A/UX 3.1 sh.\n cat <<_ACEOF\n\\`configure' configures this package to adapt to many kinds of systems.\n\nUsage: $0 [OPTION]... [VAR=VALUE]...\n\nTo assign environment variables (e.g., CC, CFLAGS...), specify them as\nVAR=VALUE. See below for descriptions of some of the useful variables.\n\nDefaults for the options are specified in brackets.\n\nConfiguration:\n -h, --help display this help and exit\n --help=short display options specific to this package\n --help=recursive display the short help of all the included packages\n -V, --version display version information and exit\n -q, --quiet, --silent do not print \\`checking ...' messages\n --cache-file=FILE cache test results in FILE [disabled]\n -C, --config-cache alias for \\`--cache-file=config.cache'\n -n, --no-create do not create output files\n --srcdir=DIR find the sources in DIR [configure dir or \\`..']\n\nInstallation directories:\n --prefix=PREFIX install architecture-independent files in PREFIX\n [$ac_default_prefix]\n --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX\n [PREFIX]\n\nBy default, \\`make install' will install all the files in\n\\`$ac_default_prefix/bin', \\`$ac_default_prefix/lib' etc. You can specify\nan installation prefix other than \\`$ac_default_prefix' using \\`--prefix',\nfor instance \\`--prefix=\\$HOME'.\n\nFor better control, use the options below.\n\nFine tuning of the installation directories:\n --bindir=DIR user executables [EPREFIX/bin]\n --sbindir=DIR system admin executables [EPREFIX/sbin]\n --libexecdir=DIR program executables [EPREFIX/libexec]\n --sysconfdir=DIR read-only single-machine data [PREFIX/etc]\n --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]\n --localstatedir=DIR modifiable single-machine data [PREFIX/var]\n --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]\n --libdir=DIR object code libraries [EPREFIX/lib]\n --includedir=DIR C header files [PREFIX/include]\n --oldincludedir=DIR C header files for non-gcc [/usr/include]\n --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]\n --datadir=DIR read-only architecture-independent data [DATAROOTDIR]\n --infodir=DIR info documentation [DATAROOTDIR/info]\n --localedir=DIR locale-dependent data [DATAROOTDIR/locale]\n --mandir=DIR man documentation [DATAROOTDIR/man]\n --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE]\n --htmldir=DIR html documentation [DOCDIR]\n --dvidir=DIR dvi documentation [DOCDIR]\n --pdfdir=DIR pdf documentation [DOCDIR]\n --psdir=DIR ps documentation [DOCDIR]\n_ACEOF\n\n cat <<\\_ACEOF\n\nSystem types:\n --build=BUILD configure for building on BUILD [guessed]\n --host=HOST cross-compile to build programs to run on HOST [BUILD]\n_ACEOF\nfi\n\nif test -n \"$ac_init_help\"; then\n\n cat <<\\_ACEOF\n\nOptional Features:\n --disable-option-checking ignore unrecognized --enable/--with options\n --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)\n --enable-FEATURE[=ARG] include FEATURE [ARG=yes]\n --disable-cxx Disable C++ integration\n --enable-autogen Automatically regenerate configure output\n --enable-doc Build documentation\n --enable-shared Build shared libaries\n --enable-static Build static libaries\n --enable-debug Build debugging code\n --disable-stats Disable statistics calculation/reporting\n --enable-experimental-smallocx\n Enable experimental smallocx API\n --enable-prof Enable allocation profiling\n --enable-prof-libunwind Use libunwind for backtracing\n --disable-prof-libgcc Do not use libgcc for backtracing\n --disable-prof-gcc Do not use gcc intrinsics for backtracing\n --disable-fill Disable support for junk/zero filling\n --enable-utrace Enable utrace(2)-based tracing\n --enable-xmalloc Support xmalloc option\n --disable-cache-oblivious\n Disable support for cache-oblivious allocation\n alignment\n --enable-log Support debug logging\n --enable-readlinkat Use readlinkat over readlink\n --enable-opt-safety-checks\n Perform certain low-overhead checks, even in opt\n mode\n --enable-opt-size-checks\n Perform sized-deallocation argument checks, even in\n opt mode\n --enable-uaf-detection Allow sampled junk-filling on deallocation to detect\n use-after-free\n --disable-libdl Do not use libdl\n --disable-syscall Disable use of syscall(2)\n --enable-lazy-lock Enable lazy locking (only lock when multi-threaded)\n --disable-zone-allocator\n Disable zone allocator for Darwin\n --disable-initial-exec-tls\n Disable the initial-exec tls model\n\nOptional Packages:\n --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]\n --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)\n --with-xslroot= XSL stylesheet root path\n --with-lg-vaddr=\n Number of significant virtual address bits\n --with-version=..--g\n Version string\n --with-rpath= Colon-separated rpath (ELF systems only)\n --with-mangling= Mangle symbols in \n --with-jemalloc-prefix=\n Prefix to prepend to all public APIs\n --without-export disable exporting jemalloc public APIs\n --with-private-namespace=\n Prefix to prepend to all library-private APIs\n --with-install-suffix=\n Suffix to append to all installed files\n --with-malloc-conf=\n config.malloc_conf options string\n --with-static-libunwind=\n Path to static libunwind library; use rather than\n dynamically linking\n --with-lg-quantum=\n Base 2 log of minimum allocation alignment\n --with-lg-slab-maxregs=\n Base 2 log of maximum number of regions in a slab\n (used with malloc_conf slab_sizes)\n --with-lg-page=\n Base 2 log of system page size\n --with-lg-hugepage=\n Base 2 log of system huge page size\n\nSome influential environment variables:\n CC C compiler command\n CFLAGS C compiler flags\n LDFLAGS linker flags, e.g. -L if you have libraries in a\n nonstandard directory \n LIBS libraries to pass to the linker, e.g. -l\n CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if\n you have headers in a nonstandard directory \n CPP C preprocessor\n CXX C++ compiler command\n CXXFLAGS C++ compiler flags\n\nUse these variables to override the choices made by `configure' or to help\nit to find libraries and programs with nonstandard names/locations.\n\nReport bugs to the package provider.\n_ACEOF\nac_status=$?\nfi\n\nif test \"$ac_init_help\" = \"recursive\"; then\n # If there are subdirs, report their specific --help.\n for ac_dir in : $ac_subdirs_all; do test \"x$ac_dir\" = x: && continue\n test -d \"$ac_dir\" ||\n { cd \"$srcdir\" && ac_pwd=`pwd` && srcdir=. && test -d \"$ac_dir\"; } ||\n continue\n ac_builddir=.\n\ncase \"$ac_dir\" in\n.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;\n*)\n ac_dir_suffix=/`printf \"%s\\n\" \"$ac_dir\" | sed 's|^\\.[\\\\/]||'`\n # A \"..\" for each directory in $ac_dir_suffix.\n ac_top_builddir_sub=`printf \"%s\\n\" \"$ac_dir_suffix\" | sed 's|/[^\\\\/]*|/..|g;s|/||'`\n case $ac_top_builddir_sub in\n \"\") ac_top_builddir_sub=. ac_top_build_prefix= ;;\n *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;\n esac ;;\nesac\nac_abs_top_builddir=$ac_pwd\nac_abs_builddir=$ac_pwd$ac_dir_suffix\n# for backward compatibility:\nac_top_builddir=$ac_top_build_prefix\n\ncase $srcdir in\n .) # We are building in place.\n ac_srcdir=.\n ac_top_srcdir=$ac_top_builddir_sub\n ac_abs_top_srcdir=$ac_pwd ;;\n [\\\\/]* | ?:[\\\\/]* ) # Absolute name.\n ac_srcdir=$srcdir$ac_dir_suffix;\n ac_top_srcdir=$srcdir\n ac_abs_top_srcdir=$srcdir ;;\n *) # Relative name.\n ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix\n ac_top_srcdir=$ac_top_build_prefix$srcdir\n ac_abs_top_srcdir=$ac_pwd/$srcdir ;;\nesac\nac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix\n\n cd \"$ac_dir\" || { ac_status=$?; continue; }\n # Check for configure.gnu first; this name is used for a wrapper for\n # Metaconfig's \"Configure\" on case-insensitive file systems.\n if test -f \"$ac_srcdir/configure.gnu\"; then\n echo &&\n $SHELL \"$ac_srcdir/configure.gnu\" --help=recursive\n elif test -f \"$ac_srcdir/configure\"; then\n echo &&\n $SHELL \"$ac_srcdir/configure\" --help=recursive\n else\n printf \"%s\\n\" \"$as_me: WARNING: no configuration information is in $ac_dir\" >&2\n fi || ac_status=$?\n cd \"$ac_pwd\" || { ac_status=$?; break; }\n done\nfi\n\ntest -n \"$ac_init_help\" && exit $ac_status\nif $ac_init_version; then\n cat <<\\_ACEOF\nconfigure\ngenerated by GNU Autoconf 2.71\n\nCopyright (C) 2021 Free Software Foundation, Inc.\nThis configure script is free software; the Free Software Foundation\ngives unlimited permission to copy, distribute and modify it.\n_ACEOF\n exit\nfi\n\n## ------------------------ ##\n## Autoconf initialization. ##\n## ------------------------ ##\n\n# ac_fn_c_try_compile LINENO\n# --------------------------\n# Try to compile conftest.$ac_ext, and return whether this succeeded.\nac_fn_c_try_compile ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n rm -f conftest.$ac_objext conftest.beam\n if { { ac_try=\"$ac_compile\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_compile\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n grep -v '^ *+' conftest.err >conftest.er1\n cat conftest.er1 >&5\n mv -f conftest.er1 conftest.err\n fi\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; } && {\n\t test -z \"$ac_c_werror_flag\" ||\n\t test ! -s conftest.err\n } && test -s conftest.$ac_objext\nthen :\n ac_retval=0\nelse $as_nop\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n\tac_retval=1\nfi\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n as_fn_set_status $ac_retval\n\n} # ac_fn_c_try_compile\n\n# ac_fn_c_try_cpp LINENO\n# ----------------------\n# Try to preprocess conftest.$ac_ext, and return whether this succeeded.\nac_fn_c_try_cpp ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n if { { ac_try=\"$ac_cpp conftest.$ac_ext\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_cpp conftest.$ac_ext\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n grep -v '^ *+' conftest.err >conftest.er1\n cat conftest.er1 >&5\n mv -f conftest.er1 conftest.err\n fi\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; } > conftest.i && {\n\t test -z \"$ac_c_preproc_warn_flag$ac_c_werror_flag\" ||\n\t test ! -s conftest.err\n }\nthen :\n ac_retval=0\nelse $as_nop\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n ac_retval=1\nfi\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n as_fn_set_status $ac_retval\n\n} # ac_fn_c_try_cpp\n\n# ac_fn_cxx_try_compile LINENO\n# ----------------------------\n# Try to compile conftest.$ac_ext, and return whether this succeeded.\nac_fn_cxx_try_compile ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n rm -f conftest.$ac_objext conftest.beam\n if { { ac_try=\"$ac_compile\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_compile\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n grep -v '^ *+' conftest.err >conftest.er1\n cat conftest.er1 >&5\n mv -f conftest.er1 conftest.err\n fi\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; } && {\n\t test -z \"$ac_cxx_werror_flag\" ||\n\t test ! -s conftest.err\n } && test -s conftest.$ac_objext\nthen :\n ac_retval=0\nelse $as_nop\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n\tac_retval=1\nfi\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n as_fn_set_status $ac_retval\n\n} # ac_fn_cxx_try_compile\n\n# ac_fn_c_try_link LINENO\n# -----------------------\n# Try to link conftest.$ac_ext, and return whether this succeeded.\nac_fn_c_try_link ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext\n if { { ac_try=\"$ac_link\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_link\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n grep -v '^ *+' conftest.err >conftest.er1\n cat conftest.er1 >&5\n mv -f conftest.er1 conftest.err\n fi\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; } && {\n\t test -z \"$ac_c_werror_flag\" ||\n\t test ! -s conftest.err\n } && test -s conftest$ac_exeext && {\n\t test \"$cross_compiling\" = yes ||\n\t test -x conftest$ac_exeext\n }\nthen :\n ac_retval=0\nelse $as_nop\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n\tac_retval=1\nfi\n # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information\n # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would\n # interfere with the next link command; also delete a directory that is\n # left behind by Apple's compiler. We do this before executing the actions.\n rm -rf conftest.dSYM conftest_ipa8_conftest.oo\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n as_fn_set_status $ac_retval\n\n} # ac_fn_c_try_link\n\n# ac_fn_c_try_run LINENO\n# ----------------------\n# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that\n# executables *can* be run.\nac_fn_c_try_run ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n if { { ac_try=\"$ac_link\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_link\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'\n { { case \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_try\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }; }\nthen :\n ac_retval=0\nelse $as_nop\n printf \"%s\\n\" \"$as_me: program exited with status $ac_status\" >&5\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n ac_retval=$ac_status\nfi\n rm -rf conftest.dSYM conftest_ipa8_conftest.oo\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n as_fn_set_status $ac_retval\n\n} # ac_fn_c_try_run\n\n# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES\n# -------------------------------------------------------\n# Tests whether HEADER exists and can be compiled using the include files in\n# INCLUDES, setting the cache variable VAR accordingly.\nac_fn_c_check_header_compile ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $2\" >&5\nprintf %s \"checking for $2... \" >&6; }\nif eval test \\${$3+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\n#include <$2>\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n eval \"$3=yes\"\nelse $as_nop\n eval \"$3=no\"\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\neval ac_res=\\$$3\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_res\" >&5\nprintf \"%s\\n\" \"$ac_res\" >&6; }\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n\n} # ac_fn_c_check_header_compile\n\n# ac_fn_c_compute_int LINENO EXPR VAR INCLUDES\n# --------------------------------------------\n# Tries to find the compile-time value of EXPR in a program that includes\n# INCLUDES, setting VAR accordingly. Returns whether the value could be\n# computed\nac_fn_c_compute_int ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n if test \"$cross_compiling\" = yes; then\n # Depending upon the size, compute the lo and hi bounds.\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nstatic int test_array [1 - 2 * !(($2) >= 0)];\ntest_array [0] = 0;\nreturn test_array [0];\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_lo=0 ac_mid=0\n while :; do\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nstatic int test_array [1 - 2 * !(($2) <= $ac_mid)];\ntest_array [0] = 0;\nreturn test_array [0];\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_hi=$ac_mid; break\nelse $as_nop\n as_fn_arith $ac_mid + 1 && ac_lo=$as_val\n\t\t\tif test $ac_lo -le $ac_mid; then\n\t\t\t ac_lo= ac_hi=\n\t\t\t break\n\t\t\tfi\n\t\t\tas_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n done\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nstatic int test_array [1 - 2 * !(($2) < 0)];\ntest_array [0] = 0;\nreturn test_array [0];\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_hi=-1 ac_mid=-1\n while :; do\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nstatic int test_array [1 - 2 * !(($2) >= $ac_mid)];\ntest_array [0] = 0;\nreturn test_array [0];\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_lo=$ac_mid; break\nelse $as_nop\n as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val\n\t\t\tif test $ac_mid -le $ac_hi; then\n\t\t\t ac_lo= ac_hi=\n\t\t\t break\n\t\t\tfi\n\t\t\tas_fn_arith 2 '*' $ac_mid && ac_mid=$as_val\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n done\nelse $as_nop\n ac_lo= ac_hi=\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n# Binary search between lo and hi bounds.\nwhile test \"x$ac_lo\" != \"x$ac_hi\"; do\n as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nstatic int test_array [1 - 2 * !(($2) <= $ac_mid)];\ntest_array [0] = 0;\nreturn test_array [0];\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_hi=$ac_mid\nelse $as_nop\n as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\ndone\ncase $ac_lo in #((\n?*) eval \"$3=\\$ac_lo\"; ac_retval=0 ;;\n'') ac_retval=1 ;;\nesac\n else\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nstatic long int longval (void) { return $2; }\nstatic unsigned long int ulongval (void) { return $2; }\n#include \n#include \nint\nmain (void)\n{\n\n FILE *f = fopen (\"conftest.val\", \"w\");\n if (! f)\n return 1;\n if (($2) < 0)\n {\n long int i = longval ();\n if (i != ($2))\n\treturn 1;\n fprintf (f, \"%ld\", i);\n }\n else\n {\n unsigned long int i = ulongval ();\n if (i != ($2))\n\treturn 1;\n fprintf (f, \"%lu\", i);\n }\n /* Do not output a trailing newline, as this causes \\r\\n confusion\n on some platforms. */\n return ferror (f) || fclose (f) != 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_run \"$LINENO\"\nthen :\n echo >>conftest.val; read $3 &5\nprintf %s \"checking for $2... \" >&6; }\nif eval test \\${$3+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n/* Define $2 to an innocuous variant, in case declares $2.\n For example, HP-UX 11i declares gettimeofday. */\n#define $2 innocuous_$2\n\n/* System header to define __stub macros and hopefully few prototypes,\n which can conflict with char $2 (); below. */\n\n#include \n#undef $2\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\n#ifdef __cplusplus\nextern \"C\"\n#endif\nchar $2 ();\n/* The GNU C library defines this for functions which it implements\n to always fail with ENOSYS. Some functions are actually named\n something starting with __ and the normal name is an alias. */\n#if defined __stub_$2 || defined __stub___$2\nchoke me\n#endif\n\nint\nmain (void)\n{\nreturn $2 ();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n eval \"$3=yes\"\nelse $as_nop\n eval \"$3=no\"\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\neval ac_res=\\$$3\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_res\" >&5\nprintf \"%s\\n\" \"$ac_res\" >&6; }\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n\n} # ac_fn_c_check_func\n\n# ac_fn_c_check_type LINENO TYPE VAR INCLUDES\n# -------------------------------------------\n# Tests whether TYPE exists after having included INCLUDES, setting cache\n# variable VAR accordingly.\nac_fn_c_check_type ()\n{\n as_lineno=${as_lineno-\"$1\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $2\" >&5\nprintf %s \"checking for $2... \" >&6; }\nif eval test \\${$3+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n eval \"$3=no\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nif (sizeof ($2))\n\t return 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$4\nint\nmain (void)\n{\nif (sizeof (($2)))\n\t return 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n\nelse $as_nop\n eval \"$3=yes\"\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\neval ac_res=\\$$3\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_res\" >&5\nprintf \"%s\\n\" \"$ac_res\" >&6; }\n eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno\n\n} # ac_fn_c_check_type\nac_configure_args_raw=\nfor ac_arg\ndo\n case $ac_arg in\n *\\'*)\n ac_arg=`printf \"%s\\n\" \"$ac_arg\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"` ;;\n esac\n as_fn_append ac_configure_args_raw \" '$ac_arg'\"\ndone\n\ncase $ac_configure_args_raw in\n *$as_nl*)\n ac_safe_unquote= ;;\n *)\n ac_unsafe_z='|&;<>()$`\\\\\"*?[ ''\t' # This string ends in space, tab.\n ac_unsafe_a=\"$ac_unsafe_z#~\"\n ac_safe_unquote=\"s/ '\\\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\\\)'/ \\\\1/g\"\n ac_configure_args_raw=` printf \"%s\\n\" \"$ac_configure_args_raw\" | sed \"$ac_safe_unquote\"`;;\nesac\n\ncat >config.log <<_ACEOF\nThis file contains any messages produced by compilers while\nrunning configure, to aid debugging if configure makes a mistake.\n\nIt was created by $as_me, which was\ngenerated by GNU Autoconf 2.71. Invocation command line was\n\n $ $0$ac_configure_args_raw\n\n_ACEOF\nexec 5>>config.log\n{\ncat <<_ASUNAME\n## --------- ##\n## Platform. ##\n## --------- ##\n\nhostname = `(hostname || uname -n) 2>/dev/null | sed 1q`\nuname -m = `(uname -m) 2>/dev/null || echo unknown`\nuname -r = `(uname -r) 2>/dev/null || echo unknown`\nuname -s = `(uname -s) 2>/dev/null || echo unknown`\nuname -v = `(uname -v) 2>/dev/null || echo unknown`\n\n/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`\n/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`\n\n/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`\n/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`\n/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`\n/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`\n/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`\n/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`\n/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`\n\n_ASUNAME\n\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n printf \"%s\\n\" \"PATH: $as_dir\"\n done\nIFS=$as_save_IFS\n\n} >&5\n\ncat >&5 <<_ACEOF\n\n\n## ----------- ##\n## Core tests. ##\n## ----------- ##\n\n_ACEOF\n\n\n# Keep a trace of the command line.\n# Strip out --no-create and --no-recursion so they do not pile up.\n# Strip out --silent because we don't want to record it for future runs.\n# Also quote any args containing shell meta-characters.\n# Make two passes to allow for proper duplicate-argument suppression.\nac_configure_args=\nac_configure_args0=\nac_configure_args1=\nac_must_keep_next=false\nfor ac_pass in 1 2\ndo\n for ac_arg\n do\n case $ac_arg in\n -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;\n -q | -quiet | --quiet | --quie | --qui | --qu | --q \\\n | -silent | --silent | --silen | --sile | --sil)\n continue ;;\n *\\'*)\n ac_arg=`printf \"%s\\n\" \"$ac_arg\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"` ;;\n esac\n case $ac_pass in\n 1) as_fn_append ac_configure_args0 \" '$ac_arg'\" ;;\n 2)\n as_fn_append ac_configure_args1 \" '$ac_arg'\"\n if test $ac_must_keep_next = true; then\n\tac_must_keep_next=false # Got value, back to normal.\n else\n\tcase $ac_arg in\n\t *=* | --config-cache | -C | -disable-* | --disable-* \\\n\t | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \\\n\t | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \\\n\t | -with-* | --with-* | -without-* | --without-* | --x)\n\t case \"$ac_configure_args0 \" in\n\t \"$ac_configure_args1\"*\" '$ac_arg' \"* ) continue ;;\n\t esac\n\t ;;\n\t -* ) ac_must_keep_next=true ;;\n\tesac\n fi\n as_fn_append ac_configure_args \" '$ac_arg'\"\n ;;\n esac\n done\ndone\n{ ac_configure_args0=; unset ac_configure_args0;}\n{ ac_configure_args1=; unset ac_configure_args1;}\n\n# When interrupted or exit'd, cleanup temporary files, and complete\n# config.log. We remove comments because anyway the quotes in there\n# would cause problems or look ugly.\n# WARNING: Use '\\'' to represent an apostrophe within the trap.\n# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.\ntrap 'exit_status=$?\n # Sanitize IFS.\n IFS=\" \"\"\t$as_nl\"\n # Save into config.log some information that might help in debugging.\n {\n echo\n\n printf \"%s\\n\" \"## ---------------- ##\n## Cache variables. ##\n## ---------------- ##\"\n echo\n # The following way of writing the cache mishandles newlines in values,\n(\n for ac_var in `(set) 2>&1 | sed -n '\\''s/^\\([a-zA-Z_][a-zA-Z0-9_]*\\)=.*/\\1/p'\\''`; do\n eval ac_val=\\$$ac_var\n case $ac_val in #(\n *${as_nl}*)\n case $ac_var in #(\n *_cv_*) { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: cache variable $ac_var contains a newline\" >&2;} ;;\n esac\n case $ac_var in #(\n _ | IFS | as_nl) ;; #(\n BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(\n *) { eval $ac_var=; unset $ac_var;} ;;\n esac ;;\n esac\n done\n (set) 2>&1 |\n case $as_nl`(ac_space='\\'' '\\''; set) 2>&1` in #(\n *${as_nl}ac_space=\\ *)\n sed -n \\\n\t\"s/'\\''/'\\''\\\\\\\\'\\'''\\''/g;\n\t s/^\\\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\\\)=\\\\(.*\\\\)/\\\\1='\\''\\\\2'\\''/p\"\n ;; #(\n *)\n sed -n \"/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p\"\n ;;\n esac |\n sort\n)\n echo\n\n printf \"%s\\n\" \"## ----------------- ##\n## Output variables. ##\n## ----------------- ##\"\n echo\n for ac_var in $ac_subst_vars\n do\n eval ac_val=\\$$ac_var\n case $ac_val in\n *\\'\\''*) ac_val=`printf \"%s\\n\" \"$ac_val\" | sed \"s/'\\''/'\\''\\\\\\\\\\\\\\\\'\\'''\\''/g\"`;;\n esac\n printf \"%s\\n\" \"$ac_var='\\''$ac_val'\\''\"\n done | sort\n echo\n\n if test -n \"$ac_subst_files\"; then\n printf \"%s\\n\" \"## ------------------- ##\n## File substitutions. ##\n## ------------------- ##\"\n echo\n for ac_var in $ac_subst_files\n do\n\teval ac_val=\\$$ac_var\n\tcase $ac_val in\n\t*\\'\\''*) ac_val=`printf \"%s\\n\" \"$ac_val\" | sed \"s/'\\''/'\\''\\\\\\\\\\\\\\\\'\\'''\\''/g\"`;;\n\tesac\n\tprintf \"%s\\n\" \"$ac_var='\\''$ac_val'\\''\"\n done | sort\n echo\n fi\n\n if test -s confdefs.h; then\n printf \"%s\\n\" \"## ----------- ##\n## confdefs.h. ##\n## ----------- ##\"\n echo\n cat confdefs.h\n echo\n fi\n test \"$ac_signal\" != 0 &&\n printf \"%s\\n\" \"$as_me: caught signal $ac_signal\"\n printf \"%s\\n\" \"$as_me: exit $exit_status\"\n } >&5\n rm -f core *.core core.conftest.* &&\n rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&\n exit $exit_status\n' 0\nfor ac_signal in 1 2 13 15; do\n trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal\ndone\nac_signal=0\n\n# confdefs.h avoids OS command line length limits that DEFS can exceed.\nrm -f -r conftest* confdefs.h\n\nprintf \"%s\\n\" \"/* confdefs.h */\" > confdefs.h\n\n# Predefined preprocessor variables.\n\nprintf \"%s\\n\" \"#define PACKAGE_NAME \\\"$PACKAGE_NAME\\\"\" >>confdefs.h\n\nprintf \"%s\\n\" \"#define PACKAGE_TARNAME \\\"$PACKAGE_TARNAME\\\"\" >>confdefs.h\n\nprintf \"%s\\n\" \"#define PACKAGE_VERSION \\\"$PACKAGE_VERSION\\\"\" >>confdefs.h\n\nprintf \"%s\\n\" \"#define PACKAGE_STRING \\\"$PACKAGE_STRING\\\"\" >>confdefs.h\n\nprintf \"%s\\n\" \"#define PACKAGE_BUGREPORT \\\"$PACKAGE_BUGREPORT\\\"\" >>confdefs.h\n\nprintf \"%s\\n\" \"#define PACKAGE_URL \\\"$PACKAGE_URL\\\"\" >>confdefs.h\n\n\n# Let the site file select an alternate cache file if it wants to.\n# Prefer an explicitly selected file to automatically selected ones.\nif test -n \"$CONFIG_SITE\"; then\n ac_site_files=\"$CONFIG_SITE\"\nelif test \"x$prefix\" != xNONE; then\n ac_site_files=\"$prefix/share/config.site $prefix/etc/config.site\"\nelse\n ac_site_files=\"$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site\"\nfi\n\nfor ac_site_file in $ac_site_files\ndo\n case $ac_site_file in #(\n */*) :\n ;; #(\n *) :\n ac_site_file=./$ac_site_file ;;\nesac\n if test -f \"$ac_site_file\" && test -r \"$ac_site_file\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file\" >&5\nprintf \"%s\\n\" \"$as_me: loading site script $ac_site_file\" >&6;}\n sed 's/^/| /' \"$ac_site_file\" >&5\n . \"$ac_site_file\" \\\n || { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error $? \"failed to load site script $ac_site_file\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n fi\ndone\n\nif test -r \"$cache_file\"; then\n # Some versions of bash will fail to source /dev/null (special files\n # actually), so we avoid doing that. DJGPP emulates it as a regular file.\n if test /dev/null != \"$cache_file\" && test -f \"$cache_file\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: loading cache $cache_file\" >&5\nprintf \"%s\\n\" \"$as_me: loading cache $cache_file\" >&6;}\n case $cache_file in\n [\\\\/]* | ?:[\\\\/]* ) . \"$cache_file\";;\n *) . \"./$cache_file\";;\n esac\n fi\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: creating cache $cache_file\" >&5\nprintf \"%s\\n\" \"$as_me: creating cache $cache_file\" >&6;}\n >$cache_file\nfi\n\n# Test code for whether the C compiler supports C89 (global declarations)\nac_c_conftest_c89_globals='\n/* Does the compiler advertise C89 conformance?\n Do not test the value of __STDC__, because some compilers set it to 0\n while being otherwise adequately conformant. */\n#if !defined __STDC__\n# error \"Compiler does not advertise C89 conformance\"\n#endif\n\n#include \n#include \nstruct stat;\n/* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */\nstruct buf { int x; };\nstruct buf * (*rcsopen) (struct buf *, struct stat *, int);\nstatic char *e (p, i)\n char **p;\n int i;\n{\n return p[i];\n}\nstatic char *f (char * (*g) (char **, int), char **p, ...)\n{\n char *s;\n va_list v;\n va_start (v,p);\n s = g (p, va_arg (v,int));\n va_end (v);\n return s;\n}\n\n/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has\n function prototypes and stuff, but not \\xHH hex character constants.\n These do not provoke an error unfortunately, instead are silently treated\n as an \"x\". The following induces an error, until -std is added to get\n proper ANSI mode. Curiously \\x00 != x always comes out true, for an\n array size at least. It is necessary to write \\x00 == 0 to get something\n that is true only with -std. */\nint osf4_cc_array ['\\''\\x00'\\'' == 0 ? 1 : -1];\n\n/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters\n inside strings and character constants. */\n#define FOO(x) '\\''x'\\''\nint xlc6_cc_array[FOO(a) == '\\''x'\\'' ? 1 : -1];\n\nint test (int i, double x);\nstruct s1 {int (*f) (int a);};\nstruct s2 {int (*f) (double a);};\nint pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),\n int, int);'\n\n# Test code for whether the C compiler supports C89 (body of main).\nac_c_conftest_c89_main='\nok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);\n'\n\n# Test code for whether the C compiler supports C99 (global declarations)\nac_c_conftest_c99_globals='\n// Does the compiler advertise C99 conformance?\n#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L\n# error \"Compiler does not advertise C99 conformance\"\n#endif\n\n#include \nextern int puts (const char *);\nextern int printf (const char *, ...);\nextern int dprintf (int, const char *, ...);\nextern void *malloc (size_t);\n\n// Check varargs macros. These examples are taken from C99 6.10.3.5.\n// dprintf is used instead of fprintf to avoid needing to declare\n// FILE and stderr.\n#define debug(...) dprintf (2, __VA_ARGS__)\n#define showlist(...) puts (#__VA_ARGS__)\n#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))\nstatic void\ntest_varargs_macros (void)\n{\n int x = 1234;\n int y = 5678;\n debug (\"Flag\");\n debug (\"X = %d\\n\", x);\n showlist (The first, second, and third items.);\n report (x>y, \"x is %d but y is %d\", x, y);\n}\n\n// Check long long types.\n#define BIG64 18446744073709551615ull\n#define BIG32 4294967295ul\n#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)\n#if !BIG_OK\n #error \"your preprocessor is broken\"\n#endif\n#if BIG_OK\n#else\n #error \"your preprocessor is broken\"\n#endif\nstatic long long int bignum = -9223372036854775807LL;\nstatic unsigned long long int ubignum = BIG64;\n\nstruct incomplete_array\n{\n int datasize;\n double data[];\n};\n\nstruct named_init {\n int number;\n const wchar_t *name;\n double average;\n};\n\ntypedef const char *ccp;\n\nstatic inline int\ntest_restrict (ccp restrict text)\n{\n // See if C++-style comments work.\n // Iterate through items via the restricted pointer.\n // Also check for declarations in for loops.\n for (unsigned int i = 0; *(text+i) != '\\''\\0'\\''; ++i)\n continue;\n return 0;\n}\n\n// Check varargs and va_copy.\nstatic bool\ntest_varargs (const char *format, ...)\n{\n va_list args;\n va_start (args, format);\n va_list args_copy;\n va_copy (args_copy, args);\n\n const char *str = \"\";\n int number = 0;\n float fnumber = 0;\n\n while (*format)\n {\n switch (*format++)\n\t{\n\tcase '\\''s'\\'': // string\n\t str = va_arg (args_copy, const char *);\n\t break;\n\tcase '\\''d'\\'': // int\n\t number = va_arg (args_copy, int);\n\t break;\n\tcase '\\''f'\\'': // float\n\t fnumber = va_arg (args_copy, double);\n\t break;\n\tdefault:\n\t break;\n\t}\n }\n va_end (args_copy);\n va_end (args);\n\n return *str && number && fnumber;\n}\n'\n\n# Test code for whether the C compiler supports C99 (body of main).\nac_c_conftest_c99_main='\n // Check bool.\n _Bool success = false;\n success |= (argc != 0);\n\n // Check restrict.\n if (test_restrict (\"String literal\") == 0)\n success = true;\n char *restrict newvar = \"Another string\";\n\n // Check varargs.\n success &= test_varargs (\"s, d'\\'' f .\", \"string\", 65, 34.234);\n test_varargs_macros ();\n\n // Check flexible array members.\n struct incomplete_array *ia =\n malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));\n ia->datasize = 10;\n for (int i = 0; i < ia->datasize; ++i)\n ia->data[i] = i * 1.234;\n\n // Check named initializers.\n struct named_init ni = {\n .number = 34,\n .name = L\"Test wide string\",\n .average = 543.34343,\n };\n\n ni.number = 58;\n\n int dynamic_array[ni.number];\n dynamic_array[0] = argv[0][0];\n dynamic_array[ni.number - 1] = 543;\n\n // work around unused variable warnings\n ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\\''x'\\''\n\t || dynamic_array[ni.number - 1] != 543);\n'\n\n# Test code for whether the C compiler supports C11 (global declarations)\nac_c_conftest_c11_globals='\n// Does the compiler advertise C11 conformance?\n#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L\n# error \"Compiler does not advertise C11 conformance\"\n#endif\n\n// Check _Alignas.\nchar _Alignas (double) aligned_as_double;\nchar _Alignas (0) no_special_alignment;\nextern char aligned_as_int;\nchar _Alignas (0) _Alignas (int) aligned_as_int;\n\n// Check _Alignof.\nenum\n{\n int_alignment = _Alignof (int),\n int_array_alignment = _Alignof (int[100]),\n char_alignment = _Alignof (char)\n};\n_Static_assert (0 < -_Alignof (int), \"_Alignof is signed\");\n\n// Check _Noreturn.\nint _Noreturn does_not_return (void) { for (;;) continue; }\n\n// Check _Static_assert.\nstruct test_static_assert\n{\n int x;\n _Static_assert (sizeof (int) <= sizeof (long int),\n \"_Static_assert does not work in struct\");\n long int y;\n};\n\n// Check UTF-8 literals.\n#define u8 syntax error!\nchar const utf8_literal[] = u8\"happens to be ASCII\" \"another string\";\n\n// Check duplicate typedefs.\ntypedef long *long_ptr;\ntypedef long int *long_ptr;\ntypedef long_ptr long_ptr;\n\n// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.\nstruct anonymous\n{\n union {\n struct { int i; int j; };\n struct { int k; long int l; } w;\n };\n int m;\n} v1;\n'\n\n# Test code for whether the C compiler supports C11 (body of main).\nac_c_conftest_c11_main='\n _Static_assert ((offsetof (struct anonymous, i)\n\t\t == offsetof (struct anonymous, w.k)),\n\t\t \"Anonymous union alignment botch\");\n v1.i = 2;\n v1.w.k = 5;\n ok |= v1.i != 5;\n'\n\n# Test code for whether the C compiler supports C11 (complete).\nac_c_conftest_c11_program=\"${ac_c_conftest_c89_globals}\n${ac_c_conftest_c99_globals}\n${ac_c_conftest_c11_globals}\n\nint\nmain (int argc, char **argv)\n{\n int ok = 0;\n ${ac_c_conftest_c89_main}\n ${ac_c_conftest_c99_main}\n ${ac_c_conftest_c11_main}\n return ok;\n}\n\"\n\n# Test code for whether the C compiler supports C99 (complete).\nac_c_conftest_c99_program=\"${ac_c_conftest_c89_globals}\n${ac_c_conftest_c99_globals}\n\nint\nmain (int argc, char **argv)\n{\n int ok = 0;\n ${ac_c_conftest_c89_main}\n ${ac_c_conftest_c99_main}\n return ok;\n}\n\"\n\n# Test code for whether the C compiler supports C89 (complete).\nac_c_conftest_c89_program=\"${ac_c_conftest_c89_globals}\n\nint\nmain (int argc, char **argv)\n{\n int ok = 0;\n ${ac_c_conftest_c89_main}\n return ok;\n}\n\"\n\n# Test code for whether the C++ compiler supports C++98 (global declarations)\nac_cxx_conftest_cxx98_globals='\n// Does the compiler advertise C++98 conformance?\n#if !defined __cplusplus || __cplusplus < 199711L\n# error \"Compiler does not advertise C++98 conformance\"\n#endif\n\n// These inclusions are to reject old compilers that\n// lack the unsuffixed header files.\n#include \n#include \n\n// and are *not* freestanding headers in C++98.\nextern void assert (int);\nnamespace std {\n extern int strcmp (const char *, const char *);\n}\n\n// Namespaces, exceptions, and templates were all added after \"C++ 2.0\".\nusing std::exception;\nusing std::strcmp;\n\nnamespace {\n\nvoid test_exception_syntax()\n{\n try {\n throw \"test\";\n } catch (const char *s) {\n // Extra parentheses suppress a warning when building autoconf itself,\n // due to lint rules shared with more typical C programs.\n assert (!(strcmp) (s, \"test\"));\n }\n}\n\ntemplate struct test_template\n{\n T const val;\n explicit test_template(T t) : val(t) {}\n template T add(U u) { return static_cast(u) + val; }\n};\n\n} // anonymous namespace\n'\n\n# Test code for whether the C++ compiler supports C++98 (body of main)\nac_cxx_conftest_cxx98_main='\n assert (argc);\n assert (! argv[0]);\n{\n test_exception_syntax ();\n test_template tt (2.0);\n assert (tt.add (4) == 6.0);\n assert (true && !false);\n}\n'\n\n# Test code for whether the C++ compiler supports C++11 (global declarations)\nac_cxx_conftest_cxx11_globals='\n// Does the compiler advertise C++ 2011 conformance?\n#if !defined __cplusplus || __cplusplus < 201103L\n# error \"Compiler does not advertise C++11 conformance\"\n#endif\n\nnamespace cxx11test\n{\n constexpr int get_val() { return 20; }\n\n struct testinit\n {\n int i;\n double d;\n };\n\n class delegate\n {\n public:\n delegate(int n) : n(n) {}\n delegate(): delegate(2354) {}\n\n virtual int getval() { return this->n; };\n protected:\n int n;\n };\n\n class overridden : public delegate\n {\n public:\n overridden(int n): delegate(n) {}\n virtual int getval() override final { return this->n * 2; }\n };\n\n class nocopy\n {\n public:\n nocopy(int i): i(i) {}\n nocopy() = default;\n nocopy(const nocopy&) = delete;\n nocopy & operator=(const nocopy&) = delete;\n private:\n int i;\n };\n\n // for testing lambda expressions\n template Ret eval(Fn f, Ret v)\n {\n return f(v);\n }\n\n // for testing variadic templates and trailing return types\n template auto sum(V first) -> V\n {\n return first;\n }\n template auto sum(V first, Args... rest) -> V\n {\n return first + sum(rest...);\n }\n}\n'\n\n# Test code for whether the C++ compiler supports C++11 (body of main)\nac_cxx_conftest_cxx11_main='\n{\n // Test auto and decltype\n auto a1 = 6538;\n auto a2 = 48573953.4;\n auto a3 = \"String literal\";\n\n int total = 0;\n for (auto i = a3; *i; ++i) { total += *i; }\n\n decltype(a2) a4 = 34895.034;\n}\n{\n // Test constexpr\n short sa[cxx11test::get_val()] = { 0 };\n}\n{\n // Test initializer lists\n cxx11test::testinit il = { 4323, 435234.23544 };\n}\n{\n // Test range-based for\n int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3,\n 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};\n for (auto &x : array) { x += 23; }\n}\n{\n // Test lambda expressions\n using cxx11test::eval;\n assert (eval ([](int x) { return x*2; }, 21) == 42);\n double d = 2.0;\n assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0);\n assert (d == 5.0);\n assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0);\n assert (d == 5.0);\n}\n{\n // Test use of variadic templates\n using cxx11test::sum;\n auto a = sum(1);\n auto b = sum(1, 2);\n auto c = sum(1.0, 2.0, 3.0);\n}\n{\n // Test constructor delegation\n cxx11test::delegate d1;\n cxx11test::delegate d2();\n cxx11test::delegate d3(45);\n}\n{\n // Test override and final\n cxx11test::overridden o1(55464);\n}\n{\n // Test nullptr\n char *c = nullptr;\n}\n{\n // Test template brackets\n test_template<::test_template> v(test_template(12));\n}\n{\n // Unicode literals\n char const *utf8 = u8\"UTF-8 string \\u2500\";\n char16_t const *utf16 = u\"UTF-8 string \\u2500\";\n char32_t const *utf32 = U\"UTF-32 string \\u2500\";\n}\n'\n\n# Test code for whether the C compiler supports C++11 (complete).\nac_cxx_conftest_cxx11_program=\"${ac_cxx_conftest_cxx98_globals}\n${ac_cxx_conftest_cxx11_globals}\n\nint\nmain (int argc, char **argv)\n{\n int ok = 0;\n ${ac_cxx_conftest_cxx98_main}\n ${ac_cxx_conftest_cxx11_main}\n return ok;\n}\n\"\n\n# Test code for whether the C compiler supports C++98 (complete).\nac_cxx_conftest_cxx98_program=\"${ac_cxx_conftest_cxx98_globals}\nint\nmain (int argc, char **argv)\n{\n int ok = 0;\n ${ac_cxx_conftest_cxx98_main}\n return ok;\n}\n\"\n\nas_fn_append ac_header_c_list \" stdio.h stdio_h HAVE_STDIO_H\"\nas_fn_append ac_header_c_list \" stdlib.h stdlib_h HAVE_STDLIB_H\"\nas_fn_append ac_header_c_list \" string.h string_h HAVE_STRING_H\"\nas_fn_append ac_header_c_list \" inttypes.h inttypes_h HAVE_INTTYPES_H\"\nas_fn_append ac_header_c_list \" stdint.h stdint_h HAVE_STDINT_H\"\nas_fn_append ac_header_c_list \" strings.h strings_h HAVE_STRINGS_H\"\nas_fn_append ac_header_c_list \" sys/stat.h sys_stat_h HAVE_SYS_STAT_H\"\nas_fn_append ac_header_c_list \" sys/types.h sys_types_h HAVE_SYS_TYPES_H\"\nas_fn_append ac_header_c_list \" unistd.h unistd_h HAVE_UNISTD_H\"\n\n# Auxiliary files required by this configure script.\nac_aux_files=\"install-sh config.guess config.sub\"\n\n# Locations in which to look for auxiliary files.\nac_aux_dir_candidates=\"${srcdir}/build-aux\"\n\n# Search for a directory containing all of the required auxiliary files,\n# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.\n# If we don't find one directory that contains all the files we need,\n# we report the set of missing files from the *first* directory in\n# $ac_aux_dir_candidates and give up.\nac_missing_aux_files=\"\"\nac_first_candidate=:\nprintf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files\" >&5\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nas_found=false\nfor as_dir in $ac_aux_dir_candidates\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n as_found=:\n\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: trying $as_dir\" >&5\n ac_aux_dir_found=yes\n ac_install_sh=\n for ac_aux in $ac_aux_files\n do\n # As a special case, if \"install-sh\" is required, that requirement\n # can be satisfied by any of \"install-sh\", \"install.sh\", or \"shtool\",\n # and $ac_install_sh is set appropriately for whichever one is found.\n if test x\"$ac_aux\" = x\"install-sh\"\n then\n if test -f \"${as_dir}install-sh\"; then\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found\" >&5\n ac_install_sh=\"${as_dir}install-sh -c\"\n elif test -f \"${as_dir}install.sh\"; then\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found\" >&5\n ac_install_sh=\"${as_dir}install.sh -c\"\n elif test -f \"${as_dir}shtool\"; then\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found\" >&5\n ac_install_sh=\"${as_dir}shtool install -c\"\n else\n ac_aux_dir_found=no\n if $ac_first_candidate; then\n ac_missing_aux_files=\"${ac_missing_aux_files} install-sh\"\n else\n break\n fi\n fi\n else\n if test -f \"${as_dir}${ac_aux}\"; then\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found\" >&5\n else\n ac_aux_dir_found=no\n if $ac_first_candidate; then\n ac_missing_aux_files=\"${ac_missing_aux_files} ${ac_aux}\"\n else\n break\n fi\n fi\n fi\n done\n if test \"$ac_aux_dir_found\" = yes; then\n ac_aux_dir=\"$as_dir\"\n break\n fi\n ac_first_candidate=false\n\n as_found=false\ndone\nIFS=$as_save_IFS\nif $as_found\nthen :\n\nelse $as_nop\n as_fn_error $? \"cannot find required auxiliary files:$ac_missing_aux_files\" \"$LINENO\" 5\nfi\n\n\n# These three variables are undocumented and unsupported,\n# and are intended to be withdrawn in a future Autoconf release.\n# They can cause serious problems if a builder's source tree is in a directory\n# whose full name contains unusual characters.\nif test -f \"${ac_aux_dir}config.guess\"; then\n ac_config_guess=\"$SHELL ${ac_aux_dir}config.guess\"\nfi\nif test -f \"${ac_aux_dir}config.sub\"; then\n ac_config_sub=\"$SHELL ${ac_aux_dir}config.sub\"\nfi\nif test -f \"$ac_aux_dir/configure\"; then\n ac_configure=\"$SHELL ${ac_aux_dir}configure\"\nfi\n\n# Check that the precious variables saved in the cache have kept the same\n# value.\nac_cache_corrupted=false\nfor ac_var in $ac_precious_vars; do\n eval ac_old_set=\\$ac_cv_env_${ac_var}_set\n eval ac_new_set=\\$ac_env_${ac_var}_set\n eval ac_old_val=\\$ac_cv_env_${ac_var}_value\n eval ac_new_val=\\$ac_env_${ac_var}_value\n case $ac_old_set,$ac_new_set in\n set,)\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: \\`$ac_var' was set to \\`$ac_old_val' in the previous run\" >&5\nprintf \"%s\\n\" \"$as_me: error: \\`$ac_var' was set to \\`$ac_old_val' in the previous run\" >&2;}\n ac_cache_corrupted=: ;;\n ,set)\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: \\`$ac_var' was not set in the previous run\" >&5\nprintf \"%s\\n\" \"$as_me: error: \\`$ac_var' was not set in the previous run\" >&2;}\n ac_cache_corrupted=: ;;\n ,);;\n *)\n if test \"x$ac_old_val\" != \"x$ac_new_val\"; then\n\t# differences in whitespace do not lead to failure.\n\tac_old_val_w=`echo x $ac_old_val`\n\tac_new_val_w=`echo x $ac_new_val`\n\tif test \"$ac_old_val_w\" != \"$ac_new_val_w\"; then\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: \\`$ac_var' has changed since the previous run:\" >&5\nprintf \"%s\\n\" \"$as_me: error: \\`$ac_var' has changed since the previous run:\" >&2;}\n\t ac_cache_corrupted=:\n\telse\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \\`$ac_var' since the previous run:\" >&5\nprintf \"%s\\n\" \"$as_me: warning: ignoring whitespace changes in \\`$ac_var' since the previous run:\" >&2;}\n\t eval $ac_var=\\$ac_old_val\n\tfi\n\t{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: former value: \\`$ac_old_val'\" >&5\nprintf \"%s\\n\" \"$as_me: former value: \\`$ac_old_val'\" >&2;}\n\t{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: current value: \\`$ac_new_val'\" >&5\nprintf \"%s\\n\" \"$as_me: current value: \\`$ac_new_val'\" >&2;}\n fi;;\n esac\n # Pass precious variables to config.status.\n if test \"$ac_new_set\" = set; then\n case $ac_new_val in\n *\\'*) ac_arg=$ac_var=`printf \"%s\\n\" \"$ac_new_val\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"` ;;\n *) ac_arg=$ac_var=$ac_new_val ;;\n esac\n case \" $ac_configure_args \" in\n *\" '$ac_arg' \"*) ;; # Avoid dups. Use of quotes ensures accuracy.\n *) as_fn_append ac_configure_args \" '$ac_arg'\" ;;\n esac\n fi\ndone\nif $ac_cache_corrupted; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build\" >&5\nprintf \"%s\\n\" \"$as_me: error: changes in the environment can compromise the build\" >&2;}\n as_fn_error $? \"run \\`${MAKE-make} distclean' and/or \\`rm $cache_file'\n\t and start over\" \"$LINENO\" 5\nfi\n## -------------------- ##\n## Main body of script. ##\n## -------------------- ##\n\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\n\n\n\n\n\n\n\n\n\nCONFIGURE_CFLAGS=\nSPECIFIED_CFLAGS=\"${CFLAGS}\"\n\n\n\n\n\nCONFIGURE_CXXFLAGS=\nSPECIFIED_CXXFLAGS=\"${CXXFLAGS}\"\n\n\n\n\n\nCONFIG=`echo ${ac_configure_args} | sed -e 's#'\"'\"'\\([^ ]*\\)'\"'\"'#\\1#g'`\n\n\nrev=2\n\n\nsrcroot=$srcdir\nif test \"x${srcroot}\" = \"x.\" ; then\n srcroot=\"\"\nelse\n srcroot=\"${srcroot}/\"\nfi\n\nabs_srcroot=\"`cd \\\"${srcdir}\\\"; pwd`/\"\n\n\nobjroot=\"\"\n\nabs_objroot=\"`pwd`/\"\n\n\ncase \"$prefix\" in\n *\\ * ) as_fn_error $? \"Prefix should not contain spaces\" \"$LINENO\" 5 ;;\n \"NONE\" ) prefix=\"/usr/local\" ;;\nesac\ncase \"$exec_prefix\" in\n *\\ * ) as_fn_error $? \"Exec prefix should not contain spaces\" \"$LINENO\" 5 ;;\n \"NONE\" ) exec_prefix=$prefix ;;\nesac\nPREFIX=$prefix\n\nBINDIR=`eval echo $bindir`\nBINDIR=`eval echo $BINDIR`\n\nINCLUDEDIR=`eval echo $includedir`\nINCLUDEDIR=`eval echo $INCLUDEDIR`\n\nLIBDIR=`eval echo $libdir`\nLIBDIR=`eval echo $LIBDIR`\n\nDATADIR=`eval echo $datadir`\nDATADIR=`eval echo $DATADIR`\n\nMANDIR=`eval echo $mandir`\nMANDIR=`eval echo $MANDIR`\n\n\n# Extract the first word of \"xsltproc\", so it can be a program name with args.\nset dummy xsltproc; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_path_XSLTPROC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n case $XSLTPROC in\n [\\\\/]* | ?:[\\\\/]*)\n ac_cv_path_XSLTPROC=\"$XSLTPROC\" # Let the user override the test with a path.\n ;;\n *)\n as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_path_XSLTPROC=\"$as_dir$ac_word$ac_exec_ext\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\n test -z \"$ac_cv_path_XSLTPROC\" && ac_cv_path_XSLTPROC=\"false\"\n ;;\nesac\nfi\nXSLTPROC=$ac_cv_path_XSLTPROC\nif test -n \"$XSLTPROC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $XSLTPROC\" >&5\nprintf \"%s\\n\" \"$XSLTPROC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nif test -d \"/usr/share/xml/docbook/stylesheet/docbook-xsl\" ; then\n DEFAULT_XSLROOT=\"/usr/share/xml/docbook/stylesheet/docbook-xsl\"\nelif test -d \"/usr/share/sgml/docbook/xsl-stylesheets\" ; then\n DEFAULT_XSLROOT=\"/usr/share/sgml/docbook/xsl-stylesheets\"\nelse\n DEFAULT_XSLROOT=\"\"\nfi\n\n# Check whether --with-xslroot was given.\nif test ${with_xslroot+y}\nthen :\n withval=$with_xslroot;\nif test \"x$with_xslroot\" = \"xno\" ; then\n XSLROOT=\"${DEFAULT_XSLROOT}\"\nelse\n XSLROOT=\"${with_xslroot}\"\nfi\n\nelse $as_nop\n XSLROOT=\"${DEFAULT_XSLROOT}\"\n\nfi\n\nif test \"x$XSLTPROC\" = \"xfalse\" ; then\n XSLROOT=\"\"\nfi\n\n\nCFLAGS=$CFLAGS\n\n\n\n\n\n\n\n\n\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\nif test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}gcc\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}gcc; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CC\"; then\n ac_cv_prog_CC=\"$CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_CC=\"${ac_tool_prefix}gcc\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nCC=$ac_cv_prog_CC\nif test -n \"$CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CC\" >&5\nprintf \"%s\\n\" \"$CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$ac_cv_prog_CC\"; then\n ac_ct_CC=$CC\n # Extract the first word of \"gcc\", so it can be a program name with args.\nset dummy gcc; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_CC\"; then\n ac_cv_prog_ac_ct_CC=\"$ac_ct_CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_CC=\"gcc\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_CC=$ac_cv_prog_ac_ct_CC\nif test -n \"$ac_ct_CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC\" >&5\nprintf \"%s\\n\" \"$ac_ct_CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n if test \"x$ac_ct_CC\" = x; then\n CC=\"\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n CC=$ac_ct_CC\n fi\nelse\n CC=\"$ac_cv_prog_CC\"\nfi\n\nif test -z \"$CC\"; then\n if test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}cc\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}cc; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CC\"; then\n ac_cv_prog_CC=\"$CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_CC=\"${ac_tool_prefix}cc\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nCC=$ac_cv_prog_CC\nif test -n \"$CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CC\" >&5\nprintf \"%s\\n\" \"$CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n fi\nfi\nif test -z \"$CC\"; then\n # Extract the first word of \"cc\", so it can be a program name with args.\nset dummy cc; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CC\"; then\n ac_cv_prog_CC=\"$CC\" # Let the user override the test.\nelse\n ac_prog_rejected=no\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n if test \"$as_dir$ac_word$ac_exec_ext\" = \"/usr/ucb/cc\"; then\n ac_prog_rejected=yes\n continue\n fi\n ac_cv_prog_CC=\"cc\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nif test $ac_prog_rejected = yes; then\n # We found a bogon in the path, so make sure we never use it.\n set dummy $ac_cv_prog_CC\n shift\n if test $# != 0; then\n # We chose a different compiler from the bogus one.\n # However, it has the same basename, so the bogon will be chosen\n # first if we set CC to just the basename; use the full file name.\n shift\n ac_cv_prog_CC=\"$as_dir$ac_word${1+' '}$@\"\n fi\nfi\nfi\nfi\nCC=$ac_cv_prog_CC\nif test -n \"$CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CC\" >&5\nprintf \"%s\\n\" \"$CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$CC\"; then\n if test -n \"$ac_tool_prefix\"; then\n for ac_prog in cl.exe\n do\n # Extract the first word of \"$ac_tool_prefix$ac_prog\", so it can be a program name with args.\nset dummy $ac_tool_prefix$ac_prog; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CC\"; then\n ac_cv_prog_CC=\"$CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_CC=\"$ac_tool_prefix$ac_prog\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nCC=$ac_cv_prog_CC\nif test -n \"$CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CC\" >&5\nprintf \"%s\\n\" \"$CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n test -n \"$CC\" && break\n done\nfi\nif test -z \"$CC\"; then\n ac_ct_CC=$CC\n for ac_prog in cl.exe\ndo\n # Extract the first word of \"$ac_prog\", so it can be a program name with args.\nset dummy $ac_prog; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_CC\"; then\n ac_cv_prog_ac_ct_CC=\"$ac_ct_CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_CC=\"$ac_prog\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_CC=$ac_cv_prog_ac_ct_CC\nif test -n \"$ac_ct_CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC\" >&5\nprintf \"%s\\n\" \"$ac_ct_CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n test -n \"$ac_ct_CC\" && break\ndone\n\n if test \"x$ac_ct_CC\" = x; then\n CC=\"\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n CC=$ac_ct_CC\n fi\nfi\n\nfi\nif test -z \"$CC\"; then\n if test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}clang\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}clang; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CC\"; then\n ac_cv_prog_CC=\"$CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_CC=\"${ac_tool_prefix}clang\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nCC=$ac_cv_prog_CC\nif test -n \"$CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CC\" >&5\nprintf \"%s\\n\" \"$CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$ac_cv_prog_CC\"; then\n ac_ct_CC=$CC\n # Extract the first word of \"clang\", so it can be a program name with args.\nset dummy clang; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_CC+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_CC\"; then\n ac_cv_prog_ac_ct_CC=\"$ac_ct_CC\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_CC=\"clang\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_CC=$ac_cv_prog_ac_ct_CC\nif test -n \"$ac_ct_CC\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC\" >&5\nprintf \"%s\\n\" \"$ac_ct_CC\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n if test \"x$ac_ct_CC\" = x; then\n CC=\"\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n CC=$ac_ct_CC\n fi\nelse\n CC=\"$ac_cv_prog_CC\"\nfi\n\nfi\n\n\ntest -z \"$CC\" && { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error $? \"no acceptable C compiler found in \\$PATH\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n\n# Provide some information about the compiler.\nprintf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for C compiler version\" >&5\nset X $ac_compile\nac_compiler=$2\nfor ac_option in --version -v -V -qversion -version; do\n { { ac_try=\"$ac_compiler $ac_option >&5\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_compiler $ac_option >&5\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n sed '10a\\\n... rest of stderr output deleted ...\n 10q' conftest.err >conftest.er1\n cat conftest.er1 >&5\n fi\n rm -f conftest.er1 conftest.err\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\ndone\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nac_clean_files_save=$ac_clean_files\nac_clean_files=\"$ac_clean_files a.out a.out.dSYM a.exe b.out\"\n# Try to create an executable without -o first, disregard a.out.\n# It will help us diagnose broken compilers, and finding out an intuition\n# of exeext.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether the C compiler works\" >&5\nprintf %s \"checking whether the C compiler works... \" >&6; }\nac_link_default=`printf \"%s\\n\" \"$ac_link\" | sed 's/ -o *conftest[^ ]*//'`\n\n# The possible output files:\nac_files=\"a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*\"\n\nac_rmfiles=\nfor ac_file in $ac_files\ndo\n case $ac_file in\n *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;\n * ) ac_rmfiles=\"$ac_rmfiles $ac_file\";;\n esac\ndone\nrm -f $ac_rmfiles\n\nif { { ac_try=\"$ac_link_default\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_link_default\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\nthen :\n # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.\n# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'\n# in a Makefile. We should not override ac_cv_exeext if it was cached,\n# so that the user can short-circuit this test for compilers unknown to\n# Autoconf.\nfor ac_file in $ac_files ''\ndo\n test -f \"$ac_file\" || continue\n case $ac_file in\n *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )\n\t;;\n [ab].out )\n\t# We found the default executable, but exeext='' is most\n\t# certainly right.\n\tbreak;;\n *.* )\n\tif test ${ac_cv_exeext+y} && test \"$ac_cv_exeext\" != no;\n\tthen :; else\n\t ac_cv_exeext=`expr \"$ac_file\" : '[^.]*\\(\\..*\\)'`\n\tfi\n\t# We set ac_cv_exeext here because the later test for it is not\n\t# safe: cross compilers may not add the suffix if given an `-o'\n\t# argument, so we may need to know it at that point already.\n\t# Even if this section looks crufty: it has the advantage of\n\t# actually working.\n\tbreak;;\n * )\n\tbreak;;\n esac\ndone\ntest \"$ac_cv_exeext\" = no && ac_cv_exeext=\n\nelse $as_nop\n ac_file=''\nfi\nif test -z \"$ac_file\"\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nprintf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n{ { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"C compiler cannot create executables\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name\" >&5\nprintf %s \"checking for C compiler default output file name... \" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_file\" >&5\nprintf \"%s\\n\" \"$ac_file\" >&6; }\nac_exeext=$ac_cv_exeext\n\nrm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out\nac_clean_files=$ac_clean_files_save\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for suffix of executables\" >&5\nprintf %s \"checking for suffix of executables... \" >&6; }\nif { { ac_try=\"$ac_link\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_link\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\nthen :\n # If both `conftest.exe' and `conftest' are `present' (well, observable)\n# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will\n# work properly (i.e., refer to `conftest.exe'), while it won't with\n# `rm'.\nfor ac_file in conftest.exe conftest conftest.*; do\n test -f \"$ac_file\" || continue\n case $ac_file in\n *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;\n *.* ) ac_cv_exeext=`expr \"$ac_file\" : '[^.]*\\(\\..*\\)'`\n\t break;;\n * ) break;;\n esac\ndone\nelse $as_nop\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error $? \"cannot compute suffix of executables: cannot compile and link\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\nfi\nrm -f conftest conftest$ac_cv_exeext\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext\" >&5\nprintf \"%s\\n\" \"$ac_cv_exeext\" >&6; }\n\nrm -f conftest.$ac_ext\nEXEEXT=$ac_cv_exeext\nac_exeext=$EXEEXT\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \nint\nmain (void)\n{\nFILE *f = fopen (\"conftest.out\", \"w\");\n return ferror (f) || fclose (f) != 0;\n\n ;\n return 0;\n}\n_ACEOF\nac_clean_files=\"$ac_clean_files conftest.out\"\n# Check that the compiler produces executables we can run. If not, either\n# the compiler is broken, or we cross compile.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling\" >&5\nprintf %s \"checking whether we are cross compiling... \" >&6; }\nif test \"$cross_compiling\" != yes; then\n { { ac_try=\"$ac_link\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_link\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\n if { ac_try='./conftest$ac_cv_exeext'\n { { case \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_try\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }; }; then\n cross_compiling=no\n else\n if test \"$cross_compiling\" = maybe; then\n\tcross_compiling=yes\n else\n\t{ { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot run C compiled programs.\nIf you meant to cross compile, use \\`--host'.\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n fi\n fi\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $cross_compiling\" >&5\nprintf \"%s\\n\" \"$cross_compiling\" >&6; }\n\nrm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out\nac_clean_files=$ac_clean_files_save\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for suffix of object files\" >&5\nprintf %s \"checking for suffix of object files... \" >&6; }\nif test ${ac_cv_objext+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nrm -f conftest.o conftest.obj\nif { { ac_try=\"$ac_compile\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_compile\") 2>&5\n ac_status=$?\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\nthen :\n for ac_file in conftest.o conftest.obj conftest.*; do\n test -f \"$ac_file\" || continue;\n case $ac_file in\n *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;\n *) ac_cv_objext=`expr \"$ac_file\" : '.*\\.\\(.*\\)'`\n break;;\n esac\ndone\nelse $as_nop\n printf \"%s\\n\" \"$as_me: failed program was:\" >&5\nsed 's/^/| /' conftest.$ac_ext >&5\n\n{ { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error $? \"cannot compute suffix of object files: cannot compile\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\nfi\nrm -f conftest.$ac_cv_objext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext\" >&5\nprintf \"%s\\n\" \"$ac_cv_objext\" >&6; }\nOBJEXT=$ac_cv_objext\nac_objext=$OBJEXT\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C\" >&5\nprintf %s \"checking whether the compiler supports GNU C... \" >&6; }\nif test ${ac_cv_c_compiler_gnu+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n#ifndef __GNUC__\n choke me\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_compiler_gnu=yes\nelse $as_nop\n ac_compiler_gnu=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_cv_c_compiler_gnu=$ac_compiler_gnu\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu\" >&5\nprintf \"%s\\n\" \"$ac_cv_c_compiler_gnu\" >&6; }\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test $ac_compiler_gnu = yes; then\n GCC=yes\nelse\n GCC=\nfi\nac_test_CFLAGS=${CFLAGS+y}\nac_save_CFLAGS=$CFLAGS\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g\" >&5\nprintf %s \"checking whether $CC accepts -g... \" >&6; }\nif test ${ac_cv_prog_cc_g+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_save_c_werror_flag=$ac_c_werror_flag\n ac_c_werror_flag=yes\n ac_cv_prog_cc_g=no\n CFLAGS=\"-g\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cc_g=yes\nelse $as_nop\n CFLAGS=\"\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n\nelse $as_nop\n ac_c_werror_flag=$ac_save_c_werror_flag\n\t CFLAGS=\"-g\"\n\t cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cc_g=yes\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n ac_c_werror_flag=$ac_save_c_werror_flag\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cc_g\" >&6; }\nif test $ac_test_CFLAGS; then\n CFLAGS=$ac_save_CFLAGS\nelif test $ac_cv_prog_cc_g = yes; then\n if test \"$GCC\" = yes; then\n CFLAGS=\"-g -O2\"\n else\n CFLAGS=\"-g\"\n fi\nelse\n if test \"$GCC\" = yes; then\n CFLAGS=\"-O2\"\n else\n CFLAGS=\n fi\nfi\nac_prog_cc_stdc=no\nif test x$ac_prog_cc_stdc = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features\" >&5\nprintf %s \"checking for $CC option to enable C11 features... \" >&6; }\nif test ${ac_cv_prog_cc_c11+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_prog_cc_c11=no\nac_save_CC=$CC\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_c_conftest_c11_program\n_ACEOF\nfor ac_arg in '' -std=gnu11\ndo\n CC=\"$ac_save_CC $ac_arg\"\n if ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cc_c11=$ac_arg\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam\n test \"x$ac_cv_prog_cc_c11\" != \"xno\" && break\ndone\nrm -f conftest.$ac_ext\nCC=$ac_save_CC\nfi\n\nif test \"x$ac_cv_prog_cc_c11\" = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: unsupported\" >&5\nprintf \"%s\\n\" \"unsupported\" >&6; }\nelse $as_nop\n if test \"x$ac_cv_prog_cc_c11\" = x\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: none needed\" >&5\nprintf \"%s\\n\" \"none needed\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cc_c11\" >&6; }\n CC=\"$CC $ac_cv_prog_cc_c11\"\nfi\n ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11\n ac_prog_cc_stdc=c11\nfi\nfi\nif test x$ac_prog_cc_stdc = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features\" >&5\nprintf %s \"checking for $CC option to enable C99 features... \" >&6; }\nif test ${ac_cv_prog_cc_c99+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_prog_cc_c99=no\nac_save_CC=$CC\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_c_conftest_c99_program\n_ACEOF\nfor ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=\ndo\n CC=\"$ac_save_CC $ac_arg\"\n if ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cc_c99=$ac_arg\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam\n test \"x$ac_cv_prog_cc_c99\" != \"xno\" && break\ndone\nrm -f conftest.$ac_ext\nCC=$ac_save_CC\nfi\n\nif test \"x$ac_cv_prog_cc_c99\" = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: unsupported\" >&5\nprintf \"%s\\n\" \"unsupported\" >&6; }\nelse $as_nop\n if test \"x$ac_cv_prog_cc_c99\" = x\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: none needed\" >&5\nprintf \"%s\\n\" \"none needed\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cc_c99\" >&6; }\n CC=\"$CC $ac_cv_prog_cc_c99\"\nfi\n ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99\n ac_prog_cc_stdc=c99\nfi\nfi\nif test x$ac_prog_cc_stdc = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features\" >&5\nprintf %s \"checking for $CC option to enable C89 features... \" >&6; }\nif test ${ac_cv_prog_cc_c89+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_prog_cc_c89=no\nac_save_CC=$CC\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_c_conftest_c89_program\n_ACEOF\nfor ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae \"-Aa -D_HPUX_SOURCE\" \"-Xc -D__EXTENSIONS__\"\ndo\n CC=\"$ac_save_CC $ac_arg\"\n if ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cc_c89=$ac_arg\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam\n test \"x$ac_cv_prog_cc_c89\" != \"xno\" && break\ndone\nrm -f conftest.$ac_ext\nCC=$ac_save_CC\nfi\n\nif test \"x$ac_cv_prog_cc_c89\" = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: unsupported\" >&5\nprintf \"%s\\n\" \"unsupported\" >&6; }\nelse $as_nop\n if test \"x$ac_cv_prog_cc_c89\" = x\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: none needed\" >&5\nprintf \"%s\\n\" \"none needed\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cc_c89\" >&6; }\n CC=\"$CC $ac_cv_prog_cc_c89\"\nfi\n ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89\n ac_prog_cc_stdc=c89\nfi\nfi\n\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\n\nif test \"x$GCC\" != \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler is MSVC\" >&5\nprintf %s \"checking whether compiler is MSVC... \" >&6; }\nif test ${je_cv_msvc+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n#ifndef _MSC_VER\n int fail-1;\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_msvc=yes\nelse $as_nop\n je_cv_msvc=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_msvc\" >&5\nprintf \"%s\\n\" \"$je_cv_msvc\" >&6; }\nfi\n\nje_cv_cray_prgenv_wrapper=\"\"\nif test \"x${PE_ENV}\" != \"x\" ; then\n case \"${CC}\" in\n CC|cc)\n\tje_cv_cray_prgenv_wrapper=\"yes\"\n\t;;\n *)\n ;;\n esac\nfi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler is cray\" >&5\nprintf %s \"checking whether compiler is cray... \" >&6; }\nif test ${je_cv_cray+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n#ifndef _CRAYC\n int fail-1;\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cray=yes\nelse $as_nop\n je_cv_cray=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_cray\" >&5\nprintf \"%s\\n\" \"$je_cv_cray\" >&6; }\n\nif test \"x${je_cv_cray}\" = \"xyes\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether cray compiler version is 8.4\" >&5\nprintf %s \"checking whether cray compiler version is 8.4... \" >&6; }\nif test ${je_cv_cray_84+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n#if !(_RELEASE_MAJOR == 8 && _RELEASE_MINOR == 4)\n int fail-1;\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cray_84=yes\nelse $as_nop\n je_cv_cray_84=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_cray_84\" >&5\nprintf \"%s\\n\" \"$je_cv_cray_84\" >&6; }\nfi\n\nif test \"x$GCC\" = \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -std=gnu11\" >&5\nprintf %s \"checking whether compiler supports -std=gnu11... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-std=gnu11\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-std=gnu11\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n if test \"x$je_cv_cflags_added\" = \"x-std=gnu11\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_RESTRICT \" >>confdefs.h\n\n else\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -std=gnu99\" >&5\nprintf %s \"checking whether compiler supports -std=gnu99... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-std=gnu99\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-std=gnu99\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n if test \"x$je_cv_cflags_added\" = \"x-std=gnu99\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_RESTRICT \" >>confdefs.h\n\n fi\n fi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror=unknown-warning-option\" >&5\nprintf %s \"checking whether compiler supports -Werror=unknown-warning-option... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror=unknown-warning-option\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror=unknown-warning-option\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wall\" >&5\nprintf %s \"checking whether compiler supports -Wall... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wall\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wall\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wextra\" >&5\nprintf %s \"checking whether compiler supports -Wextra... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wextra\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wextra\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wshorten-64-to-32\" >&5\nprintf %s \"checking whether compiler supports -Wshorten-64-to-32... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wshorten-64-to-32\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wshorten-64-to-32\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wsign-compare\" >&5\nprintf %s \"checking whether compiler supports -Wsign-compare... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wsign-compare\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wsign-compare\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wundef\" >&5\nprintf %s \"checking whether compiler supports -Wundef... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wundef\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wundef\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-format-zero-length\" >&5\nprintf %s \"checking whether compiler supports -Wno-format-zero-length... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wno-format-zero-length\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wno-format-zero-length\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wpointer-arith\" >&5\nprintf %s \"checking whether compiler supports -Wpointer-arith... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wpointer-arith\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wpointer-arith\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-missing-braces\" >&5\nprintf %s \"checking whether compiler supports -Wno-missing-braces... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wno-missing-braces\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wno-missing-braces\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-missing-field-initializers\" >&5\nprintf %s \"checking whether compiler supports -Wno-missing-field-initializers... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wno-missing-field-initializers\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wno-missing-field-initializers\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-missing-attributes\" >&5\nprintf %s \"checking whether compiler supports -Wno-missing-attributes... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wno-missing-attributes\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wno-missing-attributes\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -pipe\" >&5\nprintf %s \"checking whether compiler supports -pipe... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-pipe\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-pipe\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -g3\" >&5\nprintf %s \"checking whether compiler supports -g3... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-g3\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-g3\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nelif test \"x$je_cv_msvc\" = \"xyes\" ; then\n CC=\"$CC -nologo\"\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Zi\" >&5\nprintf %s \"checking whether compiler supports -Zi... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Zi\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Zi\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -MT\" >&5\nprintf %s \"checking whether compiler supports -MT... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-MT\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-MT\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -W3\" >&5\nprintf %s \"checking whether compiler supports -W3... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-W3\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-W3\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -FS\" >&5\nprintf %s \"checking whether compiler supports -FS... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-FS\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-FS\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n T_APPEND_V=-I${srcdir}/include/msvc_compat\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\nfi\nif test \"x$je_cv_cray\" = \"xyes\" ; then\n if test \"x$je_cv_cray_84\" = \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hipa2\" >&5\nprintf %s \"checking whether compiler supports -hipa2... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-hipa2\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-hipa2\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnognu\" >&5\nprintf %s \"checking whether compiler supports -hnognu... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-hnognu\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-hnognu\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n fi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnomessage=128\" >&5\nprintf %s \"checking whether compiler supports -hnomessage=128... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-hnomessage=128\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-hnomessage=128\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnomessage=1357\" >&5\nprintf %s \"checking whether compiler supports -hnomessage=1357... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-hnomessage=1357\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-hnomessage=1357\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nfi\n\n\n\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor\" >&5\nprintf %s \"checking how to run the C preprocessor... \" >&6; }\n# On Suns, sometimes $CPP names a directory.\nif test -n \"$CPP\" && test -d \"$CPP\"; then\n CPP=\nfi\nif test -z \"$CPP\"; then\n if test ${ac_cv_prog_CPP+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n # Double quotes because $CC needs to be expanded\n for CPP in \"$CC -E\" \"$CC -E -traditional-cpp\" cpp /lib/cpp\n do\n ac_preproc_ok=false\nfor ac_c_preproc_warn_flag in '' yes\ndo\n # Use a header file that comes with gcc, so configuring glibc\n # with a fresh cross-compiler works.\n # On the NeXT, cc -E runs the code through the compiler's parser,\n # not just through cpp. \"Syntax error\" is here to catch this case.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\t\t Syntax error\n_ACEOF\nif ac_fn_c_try_cpp \"$LINENO\"\nthen :\n\nelse $as_nop\n # Broken: fails on valid input.\ncontinue\nfi\nrm -f conftest.err conftest.i conftest.$ac_ext\n\n # OK, works on sane cases. Now check whether nonexistent headers\n # can be detected and how.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n_ACEOF\nif ac_fn_c_try_cpp \"$LINENO\"\nthen :\n # Broken: success on invalid input.\ncontinue\nelse $as_nop\n # Passes both tests.\nac_preproc_ok=:\nbreak\nfi\nrm -f conftest.err conftest.i conftest.$ac_ext\n\ndone\n# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.\nrm -f conftest.i conftest.err conftest.$ac_ext\nif $ac_preproc_ok\nthen :\n break\nfi\n\n done\n ac_cv_prog_CPP=$CPP\n\nfi\n CPP=$ac_cv_prog_CPP\nelse\n ac_cv_prog_CPP=$CPP\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CPP\" >&5\nprintf \"%s\\n\" \"$CPP\" >&6; }\nac_preproc_ok=false\nfor ac_c_preproc_warn_flag in '' yes\ndo\n # Use a header file that comes with gcc, so configuring glibc\n # with a fresh cross-compiler works.\n # On the NeXT, cc -E runs the code through the compiler's parser,\n # not just through cpp. \"Syntax error\" is here to catch this case.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\t\t Syntax error\n_ACEOF\nif ac_fn_c_try_cpp \"$LINENO\"\nthen :\n\nelse $as_nop\n # Broken: fails on valid input.\ncontinue\nfi\nrm -f conftest.err conftest.i conftest.$ac_ext\n\n # OK, works on sane cases. Now check whether nonexistent headers\n # can be detected and how.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n_ACEOF\nif ac_fn_c_try_cpp \"$LINENO\"\nthen :\n # Broken: success on invalid input.\ncontinue\nelse $as_nop\n # Passes both tests.\nac_preproc_ok=:\nbreak\nfi\nrm -f conftest.err conftest.i conftest.$ac_ext\n\ndone\n# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.\nrm -f conftest.i conftest.err conftest.$ac_ext\nif $ac_preproc_ok\nthen :\n\nelse $as_nop\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error $? \"C preprocessor \\\"$CPP\\\" fails sanity check\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\nfi\n\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\n\n# Check whether --enable-cxx was given.\nif test ${enable_cxx+y}\nthen :\n enableval=$enable_cxx; if test \"x$enable_cxx\" = \"xno\" ; then\n enable_cxx=\"0\"\nelse\n enable_cxx=\"1\"\nfi\n\nelse $as_nop\n enable_cxx=\"1\"\n\nfi\n\nif test \"x$enable_cxx\" = \"x1\" ; then\n # ===========================================================================\n# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html\n# ===========================================================================\n#\n# SYNOPSIS\n#\n# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])\n#\n# DESCRIPTION\n#\n# Check for baseline language coverage in the compiler for the specified\n# version of the C++ standard. If necessary, add switches to CXX and\n# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard)\n# or '14' (for the C++14 standard).\n#\n# The second argument, if specified, indicates whether you insist on an\n# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.\n# -std=c++11). If neither is specified, you get whatever works, with\n# preference for an extended mode.\n#\n# The third argument, if specified 'mandatory' or if left unspecified,\n# indicates that baseline support for the specified C++ standard is\n# required and that the macro should error out if no mode with that\n# support is found. If specified 'optional', then configuration proceeds\n# regardless, after defining HAVE_CXX${VERSION} if and only if a\n# supporting mode is found.\n#\n# LICENSE\n#\n# Copyright (c) 2008 Benjamin Kosnik \n# Copyright (c) 2012 Zack Weinberg \n# Copyright (c) 2013 Roy Stogner \n# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov \n# Copyright (c) 2015 Paul Norman \n# Copyright (c) 2015 Moritz Klammler \n# Copyright (c) 2016, 2018 Krzesimir Nowak \n# Copyright (c) 2019 Enji Cooper \n#\n# Copying and distribution of this file, with or without modification, are\n# permitted in any medium without royalty provided the copyright notice\n# and this notice are preserved. This file is offered as-is, without any\n# warranty.\n\n#serial 11\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\nif test -z \"$CXX\"; then\n if test -n \"$CCC\"; then\n CXX=$CCC\n else\n if test -n \"$ac_tool_prefix\"; then\n for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++\n do\n # Extract the first word of \"$ac_tool_prefix$ac_prog\", so it can be a program name with args.\nset dummy $ac_tool_prefix$ac_prog; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_CXX+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$CXX\"; then\n ac_cv_prog_CXX=\"$CXX\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_CXX=\"$ac_tool_prefix$ac_prog\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nCXX=$ac_cv_prog_CXX\nif test -n \"$CXX\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $CXX\" >&5\nprintf \"%s\\n\" \"$CXX\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n test -n \"$CXX\" && break\n done\nfi\nif test -z \"$CXX\"; then\n ac_ct_CXX=$CXX\n for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++\ndo\n # Extract the first word of \"$ac_prog\", so it can be a program name with args.\nset dummy $ac_prog; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_CXX+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_CXX\"; then\n ac_cv_prog_ac_ct_CXX=\"$ac_ct_CXX\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_CXX=\"$ac_prog\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_CXX=$ac_cv_prog_ac_ct_CXX\nif test -n \"$ac_ct_CXX\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX\" >&5\nprintf \"%s\\n\" \"$ac_ct_CXX\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n test -n \"$ac_ct_CXX\" && break\ndone\n\n if test \"x$ac_ct_CXX\" = x; then\n CXX=\"g++\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n CXX=$ac_ct_CXX\n fi\nfi\n\n fi\nfi\n# Provide some information about the compiler.\nprintf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for C++ compiler version\" >&5\nset X $ac_compile\nac_compiler=$2\nfor ac_option in --version -v -V -qversion; do\n { { ac_try=\"$ac_compiler $ac_option >&5\"\ncase \"(($ac_try\" in\n *\\\"* | *\\`* | *\\\\*) ac_try_echo=\\$ac_try;;\n *) ac_try_echo=$ac_try;;\nesac\neval ac_try_echo=\"\\\"\\$as_me:${as_lineno-$LINENO}: $ac_try_echo\\\"\"\nprintf \"%s\\n\" \"$ac_try_echo\"; } >&5\n (eval \"$ac_compiler $ac_option >&5\") 2>conftest.err\n ac_status=$?\n if test -s conftest.err; then\n sed '10a\\\n... rest of stderr output deleted ...\n 10q' conftest.err >conftest.er1\n cat conftest.er1 >&5\n fi\n rm -f conftest.er1 conftest.err\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: \\$? = $ac_status\" >&5\n test $ac_status = 0; }\ndone\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++\" >&5\nprintf %s \"checking whether the compiler supports GNU C++... \" >&6; }\nif test ${ac_cv_cxx_compiler_gnu+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n#ifndef __GNUC__\n choke me\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n ac_compiler_gnu=yes\nelse $as_nop\n ac_compiler_gnu=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_cv_cxx_compiler_gnu=$ac_compiler_gnu\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu\" >&5\nprintf \"%s\\n\" \"$ac_cv_cxx_compiler_gnu\" >&6; }\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\nif test $ac_compiler_gnu = yes; then\n GXX=yes\nelse\n GXX=\nfi\nac_test_CXXFLAGS=${CXXFLAGS+y}\nac_save_CXXFLAGS=$CXXFLAGS\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g\" >&5\nprintf %s \"checking whether $CXX accepts -g... \" >&6; }\nif test ${ac_cv_prog_cxx_g+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_save_cxx_werror_flag=$ac_cxx_werror_flag\n ac_cxx_werror_flag=yes\n ac_cv_prog_cxx_g=no\n CXXFLAGS=\"-g\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cxx_g=yes\nelse $as_nop\n CXXFLAGS=\"\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n\nelse $as_nop\n ac_cxx_werror_flag=$ac_save_cxx_werror_flag\n\t CXXFLAGS=\"-g\"\n\t cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cxx_g=yes\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n ac_cxx_werror_flag=$ac_save_cxx_werror_flag\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cxx_g\" >&6; }\nif test $ac_test_CXXFLAGS; then\n CXXFLAGS=$ac_save_CXXFLAGS\nelif test $ac_cv_prog_cxx_g = yes; then\n if test \"$GXX\" = yes; then\n CXXFLAGS=\"-g -O2\"\n else\n CXXFLAGS=\"-g\"\n fi\nelse\n if test \"$GXX\" = yes; then\n CXXFLAGS=\"-O2\"\n else\n CXXFLAGS=\n fi\nfi\nac_prog_cxx_stdcxx=no\nif test x$ac_prog_cxx_stdcxx = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features\" >&5\nprintf %s \"checking for $CXX option to enable C++11 features... \" >&6; }\nif test ${ac_cv_prog_cxx_11+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_prog_cxx_11=no\nac_save_CXX=$CXX\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_cxx_conftest_cxx11_program\n_ACEOF\nfor ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA\ndo\n CXX=\"$ac_save_CXX $ac_arg\"\n if ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cxx_cxx11=$ac_arg\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam\n test \"x$ac_cv_prog_cxx_cxx11\" != \"xno\" && break\ndone\nrm -f conftest.$ac_ext\nCXX=$ac_save_CXX\nfi\n\nif test \"x$ac_cv_prog_cxx_cxx11\" = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: unsupported\" >&5\nprintf \"%s\\n\" \"unsupported\" >&6; }\nelse $as_nop\n if test \"x$ac_cv_prog_cxx_cxx11\" = x\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: none needed\" >&5\nprintf \"%s\\n\" \"none needed\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cxx_cxx11\" >&6; }\n CXX=\"$CXX $ac_cv_prog_cxx_cxx11\"\nfi\n ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11\n ac_prog_cxx_stdcxx=cxx11\nfi\nfi\nif test x$ac_prog_cxx_stdcxx = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features\" >&5\nprintf %s \"checking for $CXX option to enable C++98 features... \" >&6; }\nif test ${ac_cv_prog_cxx_98+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_prog_cxx_98=no\nac_save_CXX=$CXX\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_cxx_conftest_cxx98_program\n_ACEOF\nfor ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA\ndo\n CXX=\"$ac_save_CXX $ac_arg\"\n if ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n ac_cv_prog_cxx_cxx98=$ac_arg\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam\n test \"x$ac_cv_prog_cxx_cxx98\" != \"xno\" && break\ndone\nrm -f conftest.$ac_ext\nCXX=$ac_save_CXX\nfi\n\nif test \"x$ac_cv_prog_cxx_cxx98\" = xno\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: unsupported\" >&5\nprintf \"%s\\n\" \"unsupported\" >&6; }\nelse $as_nop\n if test \"x$ac_cv_prog_cxx_cxx98\" = x\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: none needed\" >&5\nprintf \"%s\\n\" \"none needed\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98\" >&5\nprintf \"%s\\n\" \"$ac_cv_prog_cxx_cxx98\" >&6; }\n CXX=\"$CXX $ac_cv_prog_cxx_cxx98\"\nfi\n ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98\n ac_prog_cxx_stdcxx=cxx98\nfi\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\n\n ax_cxx_compile_alternatives=\"17 1z\" ax_cxx_compile_cxx17_required=false\n ac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n ac_success=no\n\n\n\n if test x$ac_success = xno; then\n for alternative in ${ax_cxx_compile_alternatives}; do\n for switch in -std=c++${alternative} +std=c++${alternative} \"-h std=c++${alternative}\"; do\n cachevar=`printf \"%s\\n\" \"ax_cv_cxx_compile_cxx17_$switch\" | $as_tr_sh`\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++17 features with $switch\" >&5\nprintf %s \"checking whether $CXX supports C++17 features with $switch... \" >&6; }\nif eval test \\${$cachevar+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_save_CXX=\"$CXX\"\n CXX=\"$CXX $switch\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\n// If the compiler admits that it is not ready for C++11, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201103L\n\n#error \"This is not a C++11 compiler\"\n\n#else\n\nnamespace cxx11\n{\n\n namespace test_static_assert\n {\n\n template \n struct check\n {\n static_assert(sizeof(int) <= sizeof(T), \"not big enough\");\n };\n\n }\n\n namespace test_final_override\n {\n\n struct Base\n {\n virtual ~Base() {}\n virtual void f() {}\n };\n\n struct Derived : public Base\n {\n virtual ~Derived() override {}\n virtual void f() override {}\n };\n\n }\n\n namespace test_double_right_angle_brackets\n {\n\n template < typename T >\n struct check {};\n\n typedef check single_type;\n typedef check> double_type;\n typedef check>> triple_type;\n typedef check>>> quadruple_type;\n\n }\n\n namespace test_decltype\n {\n\n int\n f()\n {\n int a = 1;\n decltype(a) b = 2;\n return a + b;\n }\n\n }\n\n namespace test_type_deduction\n {\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static const bool value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static const bool value = true;\n };\n\n template < typename T1, typename T2 >\n auto\n add(T1 a1, T2 a2) -> decltype(a1 + a2)\n {\n return a1 + a2;\n }\n\n int\n test(const int c, volatile int v)\n {\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == false, \"\");\n auto ac = c;\n auto av = v;\n auto sumi = ac + av + 'x';\n auto sumf = ac + av + 1.0;\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == true, \"\");\n return (sumf > 0.0) ? sumi : add(c, v);\n }\n\n }\n\n namespace test_noexcept\n {\n\n int f() { return 0; }\n int g() noexcept { return 0; }\n\n static_assert(noexcept(f()) == false, \"\");\n static_assert(noexcept(g()) == true, \"\");\n\n }\n\n namespace test_constexpr\n {\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c_r(const CharT *const s, const unsigned long acc) noexcept\n {\n return *s ? strlen_c_r(s + 1, acc + 1) : acc;\n }\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c(const CharT *const s) noexcept\n {\n return strlen_c_r(s, 0UL);\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"1\") == 1UL, \"\");\n static_assert(strlen_c(\"example\") == 7UL, \"\");\n static_assert(strlen_c(\"another\\0example\") == 7UL, \"\");\n\n }\n\n namespace test_rvalue_references\n {\n\n template < int N >\n struct answer\n {\n static constexpr int value = N;\n };\n\n answer<1> f(int&) { return answer<1>(); }\n answer<2> f(const int&) { return answer<2>(); }\n answer<3> f(int&&) { return answer<3>(); }\n\n void\n test()\n {\n int i = 0;\n const int c = 0;\n static_assert(decltype(f(i))::value == 1, \"\");\n static_assert(decltype(f(c))::value == 2, \"\");\n static_assert(decltype(f(0))::value == 3, \"\");\n }\n\n }\n\n namespace test_uniform_initialization\n {\n\n struct test\n {\n static const int zero {};\n static const int one {1};\n };\n\n static_assert(test::zero == 0, \"\");\n static_assert(test::one == 1, \"\");\n\n }\n\n namespace test_lambdas\n {\n\n void\n test1()\n {\n auto lambda1 = [](){};\n auto lambda2 = lambda1;\n lambda1();\n lambda2();\n }\n\n int\n test2()\n {\n auto a = [](int i, int j){ return i + j; }(1, 2);\n auto b = []() -> int { return '0'; }();\n auto c = [=](){ return a + b; }();\n auto d = [&](){ return c; }();\n auto e = [a, &b](int x) mutable {\n const auto identity = [](int y){ return y; };\n for (auto i = 0; i < a; ++i)\n a += b--;\n return x + identity(a + b);\n }(0);\n return a + b + c + d + e;\n }\n\n int\n test3()\n {\n const auto nullary = [](){ return 0; };\n const auto unary = [](int x){ return x; };\n using nullary_t = decltype(nullary);\n using unary_t = decltype(unary);\n const auto higher1st = [](nullary_t f){ return f(); };\n const auto higher2nd = [unary](nullary_t f1){\n return [unary, f1](unary_t f2){ return f2(unary(f1())); };\n };\n return higher1st(nullary) + higher2nd(nullary)(unary);\n }\n\n }\n\n namespace test_variadic_templates\n {\n\n template \n struct sum;\n\n template \n struct sum\n {\n static constexpr auto value = N0 + sum::value;\n };\n\n template <>\n struct sum<>\n {\n static constexpr auto value = 0;\n };\n\n static_assert(sum<>::value == 0, \"\");\n static_assert(sum<1>::value == 1, \"\");\n static_assert(sum<23>::value == 23, \"\");\n static_assert(sum<1, 2>::value == 3, \"\");\n static_assert(sum<5, 5, 11>::value == 21, \"\");\n static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, \"\");\n\n }\n\n // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae\n // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function\n // because of this.\n namespace test_template_alias_sfinae\n {\n\n struct foo {};\n\n template\n using member = typename T::member_type;\n\n template\n void func(...) {}\n\n template\n void func(member*) {}\n\n void test();\n\n void test() { func(0); }\n\n }\n\n} // namespace cxx11\n\n#endif // __cplusplus >= 201103L\n\n\n\n\n// If the compiler admits that it is not ready for C++14, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201402L\n\n#error \"This is not a C++14 compiler\"\n\n#else\n\nnamespace cxx14\n{\n\n namespace test_polymorphic_lambdas\n {\n\n int\n test()\n {\n const auto lambda = [](auto&&... args){\n const auto istiny = [](auto x){\n return (sizeof(x) == 1UL) ? 1 : 0;\n };\n const int aretiny[] = { istiny(args)... };\n return aretiny[0];\n };\n return lambda(1, 1L, 1.0f, '1');\n }\n\n }\n\n namespace test_binary_literals\n {\n\n constexpr auto ivii = 0b0000000000101010;\n static_assert(ivii == 42, \"wrong value\");\n\n }\n\n namespace test_generalized_constexpr\n {\n\n template < typename CharT >\n constexpr unsigned long\n strlen_c(const CharT *const s) noexcept\n {\n auto length = 0UL;\n for (auto p = s; *p; ++p)\n ++length;\n return length;\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"x\") == 1UL, \"\");\n static_assert(strlen_c(\"test\") == 4UL, \"\");\n static_assert(strlen_c(\"another\\0test\") == 7UL, \"\");\n\n }\n\n namespace test_lambda_init_capture\n {\n\n int\n test()\n {\n auto x = 0;\n const auto lambda1 = [a = x](int b){ return a + b; };\n const auto lambda2 = [a = lambda1(x)](){ return a; };\n return lambda2();\n }\n\n }\n\n namespace test_digit_separators\n {\n\n constexpr auto ten_million = 100'000'000;\n static_assert(ten_million == 100000000, \"\");\n\n }\n\n namespace test_return_type_deduction\n {\n\n auto f(int& x) { return x; }\n decltype(auto) g(int& x) { return x; }\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static constexpr auto value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static constexpr auto value = true;\n };\n\n int\n test()\n {\n auto x = 0;\n static_assert(is_same::value, \"\");\n static_assert(is_same::value, \"\");\n return x;\n }\n\n }\n\n} // namespace cxx14\n\n#endif // __cplusplus >= 201402L\n\n\n\n\n// If the compiler admits that it is not ready for C++17, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201703L\n\n#error \"This is not a C++17 compiler\"\n\n#else\n\n#include \n#include \n#include \n\nnamespace cxx17\n{\n\n namespace test_constexpr_lambdas\n {\n\n constexpr int foo = [](){return 42;}();\n\n }\n\n namespace test::nested_namespace::definitions\n {\n\n }\n\n namespace test_fold_expression\n {\n\n template\n int multiply(Args... args)\n {\n return (args * ... * 1);\n }\n\n template\n bool all(Args... args)\n {\n return (args && ...);\n }\n\n }\n\n namespace test_extended_static_assert\n {\n\n static_assert (true);\n\n }\n\n namespace test_auto_brace_init_list\n {\n\n auto foo = {5};\n auto bar {5};\n\n static_assert(std::is_same, decltype(foo)>::value);\n static_assert(std::is_same::value);\n }\n\n namespace test_typename_in_template_template_parameter\n {\n\n template typename X> struct D;\n\n }\n\n namespace test_fallthrough_nodiscard_maybe_unused_attributes\n {\n\n int f1()\n {\n return 42;\n }\n\n [[nodiscard]] int f2()\n {\n [[maybe_unused]] auto unused = f1();\n\n switch (f1())\n {\n case 17:\n f1();\n [[fallthrough]];\n case 42:\n f1();\n }\n return f1();\n }\n\n }\n\n namespace test_extended_aggregate_initialization\n {\n\n struct base1\n {\n int b1, b2 = 42;\n };\n\n struct base2\n {\n base2() {\n b3 = 42;\n }\n int b3;\n };\n\n struct derived : base1, base2\n {\n int d;\n };\n\n derived d1 {{1, 2}, {}, 4}; // full initialization\n derived d2 {{}, {}, 4}; // value-initialized bases\n\n }\n\n namespace test_general_range_based_for_loop\n {\n\n struct iter\n {\n int i;\n\n int& operator* ()\n {\n return i;\n }\n\n const int& operator* () const\n {\n return i;\n }\n\n iter& operator++()\n {\n ++i;\n return *this;\n }\n };\n\n struct sentinel\n {\n int i;\n };\n\n bool operator== (const iter& i, const sentinel& s)\n {\n return i.i == s.i;\n }\n\n bool operator!= (const iter& i, const sentinel& s)\n {\n return !(i == s);\n }\n\n struct range\n {\n iter begin() const\n {\n return {0};\n }\n\n sentinel end() const\n {\n return {5};\n }\n };\n\n void f()\n {\n range r {};\n\n for (auto i : r)\n {\n [[maybe_unused]] auto v = i;\n }\n }\n\n }\n\n namespace test_lambda_capture_asterisk_this_by_value\n {\n\n struct t\n {\n int i;\n int foo()\n {\n return [*this]()\n {\n return i;\n }();\n }\n };\n\n }\n\n namespace test_enum_class_construction\n {\n\n enum class byte : unsigned char\n {};\n\n byte foo {42};\n\n }\n\n namespace test_constexpr_if\n {\n\n template \n int f ()\n {\n if constexpr(cond)\n {\n return 13;\n }\n else\n {\n return 42;\n }\n }\n\n }\n\n namespace test_selection_statement_with_initializer\n {\n\n int f()\n {\n return 13;\n }\n\n int f2()\n {\n if (auto i = f(); i > 0)\n {\n return 3;\n }\n\n switch (auto i = f(); i + 4)\n {\n case 17:\n return 2;\n\n default:\n return 1;\n }\n }\n\n }\n\n namespace test_template_argument_deduction_for_class_templates\n {\n\n template \n struct pair\n {\n pair (T1 p1, T2 p2)\n : m1 {p1},\n m2 {p2}\n {}\n\n T1 m1;\n T2 m2;\n };\n\n void f()\n {\n [[maybe_unused]] auto p = pair{13, 42u};\n }\n\n }\n\n namespace test_non_type_auto_template_parameters\n {\n\n template \n struct B\n {};\n\n B<5> b1;\n B<'a'> b2;\n\n }\n\n namespace test_structured_bindings\n {\n\n int arr[2] = { 1, 2 };\n std::pair pr = { 1, 2 };\n\n auto f1() -> int(&)[2]\n {\n return arr;\n }\n\n auto f2() -> std::pair&\n {\n return pr;\n }\n\n struct S\n {\n int x1 : 2;\n volatile double y1;\n };\n\n S f3()\n {\n return {};\n }\n\n auto [ x1, y1 ] = f1();\n auto& [ xr1, yr1 ] = f1();\n auto [ x2, y2 ] = f2();\n auto& [ xr2, yr2 ] = f2();\n const auto [ x3, y3 ] = f3();\n\n }\n\n namespace test_exception_spec_type_system\n {\n\n struct Good {};\n struct Bad {};\n\n void g1() noexcept;\n void g2();\n\n template\n Bad\n f(T*, T*);\n\n template\n Good\n f(T1*, T2*);\n\n static_assert (std::is_same_v);\n\n }\n\n namespace test_inline_variables\n {\n\n template void f(T)\n {}\n\n template inline T g(T)\n {\n return T{};\n }\n\n template<> inline void f<>(int)\n {}\n\n template<> int g<>(int)\n {\n return 5;\n }\n\n }\n\n} // namespace cxx17\n\n#endif // __cplusplus < 201703L\n\n\n\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n eval $cachevar=yes\nelse $as_nop\n eval $cachevar=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n CXX=\"$ac_save_CXX\"\nfi\neval ac_res=\\$$cachevar\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_res\" >&5\nprintf \"%s\\n\" \"$ac_res\" >&6; }\n if eval test x\\$$cachevar = xyes; then\n CXX=\"$CXX $switch\"\n if test -n \"$CXXCPP\" ; then\n CXXCPP=\"$CXXCPP $switch\"\n fi\n ac_success=yes\n break\n fi\n done\n if test x$ac_success = xyes; then\n break\n fi\n done\n fi\n ac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\n if test x$ax_cxx_compile_cxx17_required = xtrue; then\n if test x$ac_success = xno; then\n as_fn_error $? \"*** A compiler with support for C++17 language features is required.\" \"$LINENO\" 5\n fi\n fi\n if test x$ac_success = xno; then\n HAVE_CXX17=0\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: No compiler with C++17 support was found\" >&5\nprintf \"%s\\n\" \"$as_me: No compiler with C++17 support was found\" >&6;}\n else\n HAVE_CXX17=1\n\nprintf \"%s\\n\" \"#define HAVE_CXX17 1\" >>confdefs.h\n\n fi\n\n\n if test \"x${HAVE_CXX17}\" != \"x1\"; then\n ax_cxx_compile_alternatives=\"14 1y\" ax_cxx_compile_cxx14_required=false\n ac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n ac_success=no\n\n\n\n if test x$ac_success = xno; then\n for alternative in ${ax_cxx_compile_alternatives}; do\n for switch in -std=c++${alternative} +std=c++${alternative} \"-h std=c++${alternative}\"; do\n cachevar=`printf \"%s\\n\" \"ax_cv_cxx_compile_cxx14_$switch\" | $as_tr_sh`\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features with $switch\" >&5\nprintf %s \"checking whether $CXX supports C++14 features with $switch... \" >&6; }\nif eval test \\${$cachevar+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_save_CXX=\"$CXX\"\n CXX=\"$CXX $switch\"\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\n// If the compiler admits that it is not ready for C++11, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201103L\n\n#error \"This is not a C++11 compiler\"\n\n#else\n\nnamespace cxx11\n{\n\n namespace test_static_assert\n {\n\n template \n struct check\n {\n static_assert(sizeof(int) <= sizeof(T), \"not big enough\");\n };\n\n }\n\n namespace test_final_override\n {\n\n struct Base\n {\n virtual ~Base() {}\n virtual void f() {}\n };\n\n struct Derived : public Base\n {\n virtual ~Derived() override {}\n virtual void f() override {}\n };\n\n }\n\n namespace test_double_right_angle_brackets\n {\n\n template < typename T >\n struct check {};\n\n typedef check single_type;\n typedef check> double_type;\n typedef check>> triple_type;\n typedef check>>> quadruple_type;\n\n }\n\n namespace test_decltype\n {\n\n int\n f()\n {\n int a = 1;\n decltype(a) b = 2;\n return a + b;\n }\n\n }\n\n namespace test_type_deduction\n {\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static const bool value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static const bool value = true;\n };\n\n template < typename T1, typename T2 >\n auto\n add(T1 a1, T2 a2) -> decltype(a1 + a2)\n {\n return a1 + a2;\n }\n\n int\n test(const int c, volatile int v)\n {\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == false, \"\");\n auto ac = c;\n auto av = v;\n auto sumi = ac + av + 'x';\n auto sumf = ac + av + 1.0;\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == true, \"\");\n return (sumf > 0.0) ? sumi : add(c, v);\n }\n\n }\n\n namespace test_noexcept\n {\n\n int f() { return 0; }\n int g() noexcept { return 0; }\n\n static_assert(noexcept(f()) == false, \"\");\n static_assert(noexcept(g()) == true, \"\");\n\n }\n\n namespace test_constexpr\n {\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c_r(const CharT *const s, const unsigned long acc) noexcept\n {\n return *s ? strlen_c_r(s + 1, acc + 1) : acc;\n }\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c(const CharT *const s) noexcept\n {\n return strlen_c_r(s, 0UL);\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"1\") == 1UL, \"\");\n static_assert(strlen_c(\"example\") == 7UL, \"\");\n static_assert(strlen_c(\"another\\0example\") == 7UL, \"\");\n\n }\n\n namespace test_rvalue_references\n {\n\n template < int N >\n struct answer\n {\n static constexpr int value = N;\n };\n\n answer<1> f(int&) { return answer<1>(); }\n answer<2> f(const int&) { return answer<2>(); }\n answer<3> f(int&&) { return answer<3>(); }\n\n void\n test()\n {\n int i = 0;\n const int c = 0;\n static_assert(decltype(f(i))::value == 1, \"\");\n static_assert(decltype(f(c))::value == 2, \"\");\n static_assert(decltype(f(0))::value == 3, \"\");\n }\n\n }\n\n namespace test_uniform_initialization\n {\n\n struct test\n {\n static const int zero {};\n static const int one {1};\n };\n\n static_assert(test::zero == 0, \"\");\n static_assert(test::one == 1, \"\");\n\n }\n\n namespace test_lambdas\n {\n\n void\n test1()\n {\n auto lambda1 = [](){};\n auto lambda2 = lambda1;\n lambda1();\n lambda2();\n }\n\n int\n test2()\n {\n auto a = [](int i, int j){ return i + j; }(1, 2);\n auto b = []() -> int { return '0'; }();\n auto c = [=](){ return a + b; }();\n auto d = [&](){ return c; }();\n auto e = [a, &b](int x) mutable {\n const auto identity = [](int y){ return y; };\n for (auto i = 0; i < a; ++i)\n a += b--;\n return x + identity(a + b);\n }(0);\n return a + b + c + d + e;\n }\n\n int\n test3()\n {\n const auto nullary = [](){ return 0; };\n const auto unary = [](int x){ return x; };\n using nullary_t = decltype(nullary);\n using unary_t = decltype(unary);\n const auto higher1st = [](nullary_t f){ return f(); };\n const auto higher2nd = [unary](nullary_t f1){\n return [unary, f1](unary_t f2){ return f2(unary(f1())); };\n };\n return higher1st(nullary) + higher2nd(nullary)(unary);\n }\n\n }\n\n namespace test_variadic_templates\n {\n\n template \n struct sum;\n\n template \n struct sum\n {\n static constexpr auto value = N0 + sum::value;\n };\n\n template <>\n struct sum<>\n {\n static constexpr auto value = 0;\n };\n\n static_assert(sum<>::value == 0, \"\");\n static_assert(sum<1>::value == 1, \"\");\n static_assert(sum<23>::value == 23, \"\");\n static_assert(sum<1, 2>::value == 3, \"\");\n static_assert(sum<5, 5, 11>::value == 21, \"\");\n static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, \"\");\n\n }\n\n // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae\n // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function\n // because of this.\n namespace test_template_alias_sfinae\n {\n\n struct foo {};\n\n template\n using member = typename T::member_type;\n\n template\n void func(...) {}\n\n template\n void func(member*) {}\n\n void test();\n\n void test() { func(0); }\n\n }\n\n} // namespace cxx11\n\n#endif // __cplusplus >= 201103L\n\n\n\n\n// If the compiler admits that it is not ready for C++14, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201402L\n\n#error \"This is not a C++14 compiler\"\n\n#else\n\nnamespace cxx14\n{\n\n namespace test_polymorphic_lambdas\n {\n\n int\n test()\n {\n const auto lambda = [](auto&&... args){\n const auto istiny = [](auto x){\n return (sizeof(x) == 1UL) ? 1 : 0;\n };\n const int aretiny[] = { istiny(args)... };\n return aretiny[0];\n };\n return lambda(1, 1L, 1.0f, '1');\n }\n\n }\n\n namespace test_binary_literals\n {\n\n constexpr auto ivii = 0b0000000000101010;\n static_assert(ivii == 42, \"wrong value\");\n\n }\n\n namespace test_generalized_constexpr\n {\n\n template < typename CharT >\n constexpr unsigned long\n strlen_c(const CharT *const s) noexcept\n {\n auto length = 0UL;\n for (auto p = s; *p; ++p)\n ++length;\n return length;\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"x\") == 1UL, \"\");\n static_assert(strlen_c(\"test\") == 4UL, \"\");\n static_assert(strlen_c(\"another\\0test\") == 7UL, \"\");\n\n }\n\n namespace test_lambda_init_capture\n {\n\n int\n test()\n {\n auto x = 0;\n const auto lambda1 = [a = x](int b){ return a + b; };\n const auto lambda2 = [a = lambda1(x)](){ return a; };\n return lambda2();\n }\n\n }\n\n namespace test_digit_separators\n {\n\n constexpr auto ten_million = 100'000'000;\n static_assert(ten_million == 100000000, \"\");\n\n }\n\n namespace test_return_type_deduction\n {\n\n auto f(int& x) { return x; }\n decltype(auto) g(int& x) { return x; }\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static constexpr auto value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static constexpr auto value = true;\n };\n\n int\n test()\n {\n auto x = 0;\n static_assert(is_same::value, \"\");\n static_assert(is_same::value, \"\");\n return x;\n }\n\n }\n\n} // namespace cxx14\n\n#endif // __cplusplus >= 201402L\n\n\n\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n eval $cachevar=yes\nelse $as_nop\n eval $cachevar=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n CXX=\"$ac_save_CXX\"\nfi\neval ac_res=\\$$cachevar\n\t { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_res\" >&5\nprintf \"%s\\n\" \"$ac_res\" >&6; }\n if eval test x\\$$cachevar = xyes; then\n CXX=\"$CXX $switch\"\n if test -n \"$CXXCPP\" ; then\n CXXCPP=\"$CXXCPP $switch\"\n fi\n ac_success=yes\n break\n fi\n done\n if test x$ac_success = xyes; then\n break\n fi\n done\n fi\n ac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\n if test x$ax_cxx_compile_cxx14_required = xtrue; then\n if test x$ac_success = xno; then\n as_fn_error $? \"*** A compiler with support for C++14 language features is required.\" \"$LINENO\" 5\n fi\n fi\n if test x$ac_success = xno; then\n HAVE_CXX14=0\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: No compiler with C++14 support was found\" >&5\nprintf \"%s\\n\" \"$as_me: No compiler with C++14 support was found\" >&6;}\n else\n HAVE_CXX14=1\n\nprintf \"%s\\n\" \"#define HAVE_CXX14 1\" >>confdefs.h\n\n fi\n\n\n fi\n if test \"x${HAVE_CXX14}\" = \"x1\" -o \"x${HAVE_CXX17}\" = \"x1\"; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wall\" >&5\nprintf %s \"checking whether compiler supports -Wall... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-Wall\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-Wall\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wextra\" >&5\nprintf %s \"checking whether compiler supports -Wextra... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-Wextra\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-Wextra\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -g3\" >&5\nprintf %s \"checking whether compiler supports -g3... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-g3\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-g3\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n\n SAVED_LIBS=\"${LIBS}\"\n T_APPEND_V=-lstdc++\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether libstdc++ linkage is compilable\" >&5\nprintf %s \"checking whether libstdc++ linkage is compilable... \" >&6; }\nif test ${je_cv_libstdcxx+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tint *arr = (int *)malloc(sizeof(int) * 42);\n\tif (arr == NULL)\n\t\treturn 1;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_libstdcxx=yes\nelse $as_nop\n je_cv_libstdcxx=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_libstdcxx\" >&5\nprintf \"%s\\n\" \"$je_cv_libstdcxx\" >&6; }\n\n if test \"x${je_cv_libstdcxx}\" = \"xno\" ; then\n LIBS=\"${SAVED_LIBS}\"\n fi\n else\n enable_cxx=\"0\"\n fi\nfi\nif test \"x$enable_cxx\" = \"x1\"; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_ENABLE_CXX \" >>confdefs.h\n\nfi\n\n\n\n\n\nac_header= ac_cache=\nfor ac_item in $ac_header_c_list\ndo\n if test $ac_cache; then\n ac_fn_c_check_header_compile \"$LINENO\" $ac_header ac_cv_header_$ac_cache \"$ac_includes_default\"\n if eval test \\\"x\\$ac_cv_header_$ac_cache\\\" = xyes; then\n printf \"%s\\n\" \"#define $ac_item 1\" >> confdefs.h\n fi\n ac_header= ac_cache=\n elif test $ac_header; then\n ac_cache=$ac_item\n else\n ac_header=$ac_item\n fi\ndone\n\n\n\n\n\n\n\n\nif test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes\nthen :\n\nprintf \"%s\\n\" \"#define STDC_HEADERS 1\" >>confdefs.h\n\nfi\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian\" >&5\nprintf %s \"checking whether byte ordering is bigendian... \" >&6; }\nif test ${ac_cv_c_bigendian+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_cv_c_bigendian=unknown\n # See if we're dealing with a universal compiler.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#ifndef __APPLE_CC__\n\t not a universal capable compiler\n\t #endif\n\t typedef int dummy;\n\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n\n\t# Check for potential -arch flags. It is not universal unless\n\t# there are at least two -arch flags with different values.\n\tac_arch=\n\tac_prev=\n\tfor ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do\n\t if test -n \"$ac_prev\"; then\n\t case $ac_word in\n\t i?86 | x86_64 | ppc | ppc64)\n\t if test -z \"$ac_arch\" || test \"$ac_arch\" = \"$ac_word\"; then\n\t\t ac_arch=$ac_word\n\t else\n\t\t ac_cv_c_bigendian=universal\n\t\t break\n\t fi\n\t ;;\n\t esac\n\t ac_prev=\n\t elif test \"x$ac_word\" = \"x-arch\"; then\n\t ac_prev=arch\n\t fi\n done\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n if test $ac_cv_c_bigendian = unknown; then\n # See if sys/param.h defines the BYTE_ORDER macro.\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\t #include \n\nint\nmain (void)\n{\n#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \\\n\t\t && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \\\n\t\t && LITTLE_ENDIAN)\n\t bogus endian macros\n\t #endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n # It does; now see whether it defined to BIG_ENDIAN or not.\n\t cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\t\t#include \n\nint\nmain (void)\n{\n#if BYTE_ORDER != BIG_ENDIAN\n\t\t not big endian\n\t\t#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_c_bigendian=yes\nelse $as_nop\n ac_cv_c_bigendian=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n fi\n if test $ac_cv_c_bigendian = unknown; then\n # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\nint\nmain (void)\n{\n#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)\n\t bogus endian macros\n\t #endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n # It does; now see whether it defined to _BIG_ENDIAN or not.\n\t cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\nint\nmain (void)\n{\n#ifndef _BIG_ENDIAN\n\t\t not big endian\n\t\t#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_c_bigendian=yes\nelse $as_nop\n ac_cv_c_bigendian=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n fi\n if test $ac_cv_c_bigendian = unknown; then\n # Compile a test program.\n if test \"$cross_compiling\" = yes\nthen :\n # Try to guess by grepping values from an object file.\n\t cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\nunsigned short int ascii_mm[] =\n\t\t { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };\n\t\tunsigned short int ascii_ii[] =\n\t\t { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };\n\t\tint use_ascii (int i) {\n\t\t return ascii_mm[i] + ascii_ii[i];\n\t\t}\n\t\tunsigned short int ebcdic_ii[] =\n\t\t { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };\n\t\tunsigned short int ebcdic_mm[] =\n\t\t { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };\n\t\tint use_ebcdic (int i) {\n\t\t return ebcdic_mm[i] + ebcdic_ii[i];\n\t\t}\n\t\textern int foo;\n\nint\nmain (void)\n{\nreturn use_ascii (foo) == use_ebcdic (foo);\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then\n\t ac_cv_c_bigendian=yes\n\t fi\n\t if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then\n\t if test \"$ac_cv_c_bigendian\" = unknown; then\n\t\tac_cv_c_bigendian=no\n\t else\n\t\t# finding both strings is unlikely to happen, but who knows?\n\t\tac_cv_c_bigendian=unknown\n\t fi\n\t fi\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n$ac_includes_default\nint\nmain (void)\n{\n\n\t /* Are we little or big endian? From Harbison&Steele. */\n\t union\n\t {\n\t long int l;\n\t char c[sizeof (long int)];\n\t } u;\n\t u.l = 1;\n\t return u.c[sizeof (long int) - 1] == 1;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_run \"$LINENO\"\nthen :\n ac_cv_c_bigendian=no\nelse $as_nop\n ac_cv_c_bigendian=yes\nfi\nrm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \\\n conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n\n fi\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian\" >&5\nprintf \"%s\\n\" \"$ac_cv_c_bigendian\" >&6; }\n case $ac_cv_c_bigendian in #(\n yes)\n ac_cv_big_endian=1;; #(\n no)\n ac_cv_big_endian=0 ;; #(\n universal)\n\nprintf \"%s\\n\" \"#define AC_APPLE_UNIVERSAL_BUILD 1\" >>confdefs.h\n\n ;; #(\n *)\n as_fn_error $? \"unknown endianness\n presetting ac_cv_c_bigendian=no (or yes) will help\" \"$LINENO\" 5 ;;\n esac\n\nif test \"x${ac_cv_big_endian}\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_BIG_ENDIAN \" >>confdefs.h\n\nfi\n\nif test \"x${je_cv_msvc}\" = \"xyes\" -a \"x${ac_cv_header_inttypes_h}\" = \"xno\"; then\n T_APPEND_V=-I${srcdir}/include/msvc_compat/C99\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\nfi\n\nif test \"x${je_cv_msvc}\" = \"xyes\" ; then\n LG_SIZEOF_PTR=LG_SIZEOF_PTR_WIN\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit\" >&5\nprintf \"%s\\n\" \"Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit\" >&6; }\nelse\n # The cast to long int works around a bug in the HP C Compiler\n# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects\n# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.\n# This bug is HP SR number 8606223364.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking size of void *\" >&5\nprintf %s \"checking size of void *... \" >&6; }\nif test ${ac_cv_sizeof_void_p+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if ac_fn_c_compute_int \"$LINENO\" \"(long int) (sizeof (void *))\" \"ac_cv_sizeof_void_p\" \"$ac_includes_default\"\nthen :\n\nelse $as_nop\n if test \"$ac_cv_type_void_p\" = yes; then\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot compute sizeof (void *)\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n else\n ac_cv_sizeof_void_p=0\n fi\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_void_p\" >&5\nprintf \"%s\\n\" \"$ac_cv_sizeof_void_p\" >&6; }\n\n\n\nprintf \"%s\\n\" \"#define SIZEOF_VOID_P $ac_cv_sizeof_void_p\" >>confdefs.h\n\n\n if test \"x${ac_cv_sizeof_void_p}\" = \"x8\" ; then\n LG_SIZEOF_PTR=3\n elif test \"x${ac_cv_sizeof_void_p}\" = \"x4\" ; then\n LG_SIZEOF_PTR=2\n else\n as_fn_error $? \"Unsupported pointer size: ${ac_cv_sizeof_void_p}\" \"$LINENO\" 5\n fi\nfi\n\nprintf \"%s\\n\" \"#define LG_SIZEOF_PTR $LG_SIZEOF_PTR\" >>confdefs.h\n\n\n# The cast to long int works around a bug in the HP C Compiler\n# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects\n# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.\n# This bug is HP SR number 8606223364.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking size of int\" >&5\nprintf %s \"checking size of int... \" >&6; }\nif test ${ac_cv_sizeof_int+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if ac_fn_c_compute_int \"$LINENO\" \"(long int) (sizeof (int))\" \"ac_cv_sizeof_int\" \"$ac_includes_default\"\nthen :\n\nelse $as_nop\n if test \"$ac_cv_type_int\" = yes; then\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot compute sizeof (int)\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n else\n ac_cv_sizeof_int=0\n fi\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int\" >&5\nprintf \"%s\\n\" \"$ac_cv_sizeof_int\" >&6; }\n\n\n\nprintf \"%s\\n\" \"#define SIZEOF_INT $ac_cv_sizeof_int\" >>confdefs.h\n\n\nif test \"x${ac_cv_sizeof_int}\" = \"x8\" ; then\n LG_SIZEOF_INT=3\nelif test \"x${ac_cv_sizeof_int}\" = \"x4\" ; then\n LG_SIZEOF_INT=2\nelse\n as_fn_error $? \"Unsupported int size: ${ac_cv_sizeof_int}\" \"$LINENO\" 5\nfi\n\nprintf \"%s\\n\" \"#define LG_SIZEOF_INT $LG_SIZEOF_INT\" >>confdefs.h\n\n\n# The cast to long int works around a bug in the HP C Compiler\n# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects\n# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.\n# This bug is HP SR number 8606223364.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking size of long\" >&5\nprintf %s \"checking size of long... \" >&6; }\nif test ${ac_cv_sizeof_long+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if ac_fn_c_compute_int \"$LINENO\" \"(long int) (sizeof (long))\" \"ac_cv_sizeof_long\" \"$ac_includes_default\"\nthen :\n\nelse $as_nop\n if test \"$ac_cv_type_long\" = yes; then\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot compute sizeof (long)\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n else\n ac_cv_sizeof_long=0\n fi\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long\" >&5\nprintf \"%s\\n\" \"$ac_cv_sizeof_long\" >&6; }\n\n\n\nprintf \"%s\\n\" \"#define SIZEOF_LONG $ac_cv_sizeof_long\" >>confdefs.h\n\n\nif test \"x${ac_cv_sizeof_long}\" = \"x8\" ; then\n LG_SIZEOF_LONG=3\nelif test \"x${ac_cv_sizeof_long}\" = \"x4\" ; then\n LG_SIZEOF_LONG=2\nelse\n as_fn_error $? \"Unsupported long size: ${ac_cv_sizeof_long}\" \"$LINENO\" 5\nfi\n\nprintf \"%s\\n\" \"#define LG_SIZEOF_LONG $LG_SIZEOF_LONG\" >>confdefs.h\n\n\n# The cast to long int works around a bug in the HP C Compiler\n# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects\n# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.\n# This bug is HP SR number 8606223364.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking size of long long\" >&5\nprintf %s \"checking size of long long... \" >&6; }\nif test ${ac_cv_sizeof_long_long+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if ac_fn_c_compute_int \"$LINENO\" \"(long int) (sizeof (long long))\" \"ac_cv_sizeof_long_long\" \"$ac_includes_default\"\nthen :\n\nelse $as_nop\n if test \"$ac_cv_type_long_long\" = yes; then\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot compute sizeof (long long)\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n else\n ac_cv_sizeof_long_long=0\n fi\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long\" >&5\nprintf \"%s\\n\" \"$ac_cv_sizeof_long_long\" >&6; }\n\n\n\nprintf \"%s\\n\" \"#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long\" >>confdefs.h\n\n\nif test \"x${ac_cv_sizeof_long_long}\" = \"x8\" ; then\n LG_SIZEOF_LONG_LONG=3\nelif test \"x${ac_cv_sizeof_long_long}\" = \"x4\" ; then\n LG_SIZEOF_LONG_LONG=2\nelse\n as_fn_error $? \"Unsupported long long size: ${ac_cv_sizeof_long_long}\" \"$LINENO\" 5\nfi\n\nprintf \"%s\\n\" \"#define LG_SIZEOF_LONG_LONG $LG_SIZEOF_LONG_LONG\" >>confdefs.h\n\n\n# The cast to long int works around a bug in the HP C Compiler\n# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects\n# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.\n# This bug is HP SR number 8606223364.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking size of intmax_t\" >&5\nprintf %s \"checking size of intmax_t... \" >&6; }\nif test ${ac_cv_sizeof_intmax_t+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if ac_fn_c_compute_int \"$LINENO\" \"(long int) (sizeof (intmax_t))\" \"ac_cv_sizeof_intmax_t\" \"$ac_includes_default\"\nthen :\n\nelse $as_nop\n if test \"$ac_cv_type_intmax_t\" = yes; then\n { { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: in \\`$ac_pwd':\" >&5\nprintf \"%s\\n\" \"$as_me: error: in \\`$ac_pwd':\" >&2;}\nas_fn_error 77 \"cannot compute sizeof (intmax_t)\nSee \\`config.log' for more details\" \"$LINENO\" 5; }\n else\n ac_cv_sizeof_intmax_t=0\n fi\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_intmax_t\" >&5\nprintf \"%s\\n\" \"$ac_cv_sizeof_intmax_t\" >&6; }\n\n\n\nprintf \"%s\\n\" \"#define SIZEOF_INTMAX_T $ac_cv_sizeof_intmax_t\" >>confdefs.h\n\n\nif test \"x${ac_cv_sizeof_intmax_t}\" = \"x16\" ; then\n LG_SIZEOF_INTMAX_T=4\nelif test \"x${ac_cv_sizeof_intmax_t}\" = \"x8\" ; then\n LG_SIZEOF_INTMAX_T=3\nelif test \"x${ac_cv_sizeof_intmax_t}\" = \"x4\" ; then\n LG_SIZEOF_INTMAX_T=2\nelse\n as_fn_error $? \"Unsupported intmax_t size: ${ac_cv_sizeof_intmax_t}\" \"$LINENO\" 5\nfi\n\nprintf \"%s\\n\" \"#define LG_SIZEOF_INTMAX_T $LG_SIZEOF_INTMAX_T\" >>confdefs.h\n\n\n\n\n\n # Make sure we can run config.sub.\n$SHELL \"${ac_aux_dir}config.sub\" sun4 >/dev/null 2>&1 ||\n as_fn_error $? \"cannot run $SHELL ${ac_aux_dir}config.sub\" \"$LINENO\" 5\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking build system type\" >&5\nprintf %s \"checking build system type... \" >&6; }\nif test ${ac_cv_build+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_build_alias=$build_alias\ntest \"x$ac_build_alias\" = x &&\n ac_build_alias=`$SHELL \"${ac_aux_dir}config.guess\"`\ntest \"x$ac_build_alias\" = x &&\n as_fn_error $? \"cannot guess build type; you must specify one\" \"$LINENO\" 5\nac_cv_build=`$SHELL \"${ac_aux_dir}config.sub\" $ac_build_alias` ||\n as_fn_error $? \"$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed\" \"$LINENO\" 5\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_build\" >&5\nprintf \"%s\\n\" \"$ac_cv_build\" >&6; }\ncase $ac_cv_build in\n*-*-*) ;;\n*) as_fn_error $? \"invalid value of canonical build\" \"$LINENO\" 5;;\nesac\nbuild=$ac_cv_build\nac_save_IFS=$IFS; IFS='-'\nset x $ac_cv_build\nshift\nbuild_cpu=$1\nbuild_vendor=$2\nshift; shift\n# Remember, the first character of IFS is used to create $*,\n# except with old shells:\nbuild_os=$*\nIFS=$ac_save_IFS\ncase $build_os in *\\ *) build_os=`echo \"$build_os\" | sed 's/ /-/g'`;; esac\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking host system type\" >&5\nprintf %s \"checking host system type... \" >&6; }\nif test ${ac_cv_host+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test \"x$host_alias\" = x; then\n ac_cv_host=$ac_cv_build\nelse\n ac_cv_host=`$SHELL \"${ac_aux_dir}config.sub\" $host_alias` ||\n as_fn_error $? \"$SHELL ${ac_aux_dir}config.sub $host_alias failed\" \"$LINENO\" 5\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_host\" >&5\nprintf \"%s\\n\" \"$ac_cv_host\" >&6; }\ncase $ac_cv_host in\n*-*-*) ;;\n*) as_fn_error $? \"invalid value of canonical host\" \"$LINENO\" 5;;\nesac\nhost=$ac_cv_host\nac_save_IFS=$IFS; IFS='-'\nset x $ac_cv_host\nshift\nhost_cpu=$1\nhost_vendor=$2\nshift; shift\n# Remember, the first character of IFS is used to create $*,\n# except with old shells:\nhost_os=$*\nIFS=$ac_save_IFS\ncase $host_os in *\\ *) host_os=`echo \"$host_os\" | sed 's/ /-/g'`;; esac\n\n\nCPU_SPINWAIT=\"\"\ncase \"${host_cpu}\" in\n i686|x86_64)\n\tHAVE_CPU_SPINWAIT=1\n\tif test \"x${je_cv_msvc}\" = \"xyes\" ; then\n\t if test ${je_cv_pause_msvc+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pause instruction MSVC is compilable\" >&5\nprintf %s \"checking whether pause instruction MSVC is compilable... \" >&6; }\nif test ${je_cv_pause_msvc+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n_mm_pause(); return 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pause_msvc=yes\nelse $as_nop\n je_cv_pause_msvc=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pause_msvc\" >&5\nprintf \"%s\\n\" \"$je_cv_pause_msvc\" >&6; }\n\nfi\n\n\t if test \"x${je_cv_pause_msvc}\" = \"xyes\" ; then\n\t\tCPU_SPINWAIT='_mm_pause()'\n\t fi\n\telse\n\t if test ${je_cv_pause+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pause instruction is compilable\" >&5\nprintf %s \"checking whether pause instruction is compilable... \" >&6; }\nif test ${je_cv_pause+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n__asm__ volatile(\"pause\"); return 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pause=yes\nelse $as_nop\n je_cv_pause=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pause\" >&5\nprintf \"%s\\n\" \"$je_cv_pause\" >&6; }\n\nfi\n\n\t if test \"x${je_cv_pause}\" = \"xyes\" ; then\n\t\tCPU_SPINWAIT='__asm__ volatile(\"pause\")'\n\t fi\n\tfi\n\t;;\n aarch64|arm*)\n\tHAVE_CPU_SPINWAIT=1\n\t\tif test ${je_cv_isb+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether isb instruction is compilable\" >&5\nprintf %s \"checking whether isb instruction is compilable... \" >&6; }\nif test ${je_cv_isb+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n__asm__ volatile(\"isb\"); return 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_isb=yes\nelse $as_nop\n je_cv_isb=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_isb\" >&5\nprintf \"%s\\n\" \"$je_cv_isb\" >&6; }\n\nfi\n\n\tif test \"x${je_cv_isb}\" = \"xyes\" ; then\n\t CPU_SPINWAIT='__asm__ volatile(\"isb\")'\n\tfi\n\t;;\n *)\n\tHAVE_CPU_SPINWAIT=0\n\t;;\nesac\n\nprintf \"%s\\n\" \"#define HAVE_CPU_SPINWAIT $HAVE_CPU_SPINWAIT\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define CPU_SPINWAIT $CPU_SPINWAIT\" >>confdefs.h\n\n\n\n# Check whether --with-lg_vaddr was given.\nif test ${with_lg_vaddr+y}\nthen :\n withval=$with_lg_vaddr; LG_VADDR=\"$with_lg_vaddr\"\nelse $as_nop\n LG_VADDR=\"detect\"\nfi\n\n\ncase \"${host_cpu}\" in\n aarch64)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking number of significant virtual address bits\" >&5\nprintf %s \"checking number of significant virtual address bits... \" >&6; }\n if test \"x${LG_SIZEOF_PTR}\" = \"x2\" ; then\n #aarch64 ILP32\n LG_VADDR=32\n else\n #aarch64 LP64\n LG_VADDR=48\n fi\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $LG_VADDR\" >&5\nprintf \"%s\\n\" \"$LG_VADDR\" >&6; }\n fi\n ;;\n x86_64)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking number of significant virtual address bits\" >&5\nprintf %s \"checking number of significant virtual address bits... \" >&6; }\nif test ${je_cv_lg_vaddr+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test \"$cross_compiling\" = yes\nthen :\n je_cv_lg_vaddr=57\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#ifdef _WIN32\n#include \n#include \ntypedef unsigned __int32 uint32_t;\n#else\n#include \n#endif\n\nint\nmain (void)\n{\n\n\tuint32_t r[4];\n\tuint32_t eax_in = 0x80000008U;\n#ifdef _WIN32\n\t__cpuid((int *)r, (int)eax_in);\n#else\n\tasm volatile (\"cpuid\"\n\t : \"=a\" (r[0]), \"=b\" (r[1]), \"=c\" (r[2]), \"=d\" (r[3])\n\t : \"a\" (eax_in), \"c\" (0)\n\t);\n#endif\n\tuint32_t eax_out = r[0];\n\tuint32_t vaddr = ((eax_out & 0x0000ff00U) >> 8);\n\tFILE *f = fopen(\"conftest.out\", \"w\");\n\tif (f == NULL) {\n\t\treturn 1;\n\t}\n\tif (vaddr > (sizeof(void *) << 3)) {\n\t\tvaddr = sizeof(void *) << 3;\n\t}\n\tfprintf(f, \"%u\", vaddr);\n\tfclose(f);\n\treturn 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_run \"$LINENO\"\nthen :\n je_cv_lg_vaddr=`cat conftest.out`\nelse $as_nop\n je_cv_lg_vaddr=error\nfi\nrm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \\\n conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_lg_vaddr\" >&5\nprintf \"%s\\n\" \"$je_cv_lg_vaddr\" >&6; }\n if test \"x${je_cv_lg_vaddr}\" != \"x\" ; then\n LG_VADDR=\"${je_cv_lg_vaddr}\"\n fi\n if test \"x${LG_VADDR}\" != \"xerror\" ; then\n\nprintf \"%s\\n\" \"#define LG_VADDR $LG_VADDR\" >>confdefs.h\n\n else\n as_fn_error $? \"cannot determine number of significant virtual address bits\" \"$LINENO\" 5\n fi\n fi\n ;;\n *)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking number of significant virtual address bits\" >&5\nprintf %s \"checking number of significant virtual address bits... \" >&6; }\n if test \"x${LG_SIZEOF_PTR}\" = \"x3\" ; then\n LG_VADDR=64\n elif test \"x${LG_SIZEOF_PTR}\" = \"x2\" ; then\n LG_VADDR=32\n elif test \"x${LG_SIZEOF_PTR}\" = \"xLG_SIZEOF_PTR_WIN\" ; then\n LG_VADDR=\"(1U << (LG_SIZEOF_PTR_WIN+3))\"\n else\n as_fn_error $? \"Unsupported lg(pointer size): ${LG_SIZEOF_PTR}\" \"$LINENO\" 5\n fi\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $LG_VADDR\" >&5\nprintf \"%s\\n\" \"$LG_VADDR\" >&6; }\n fi\n ;;\nesac\n\nprintf \"%s\\n\" \"#define LG_VADDR $LG_VADDR\" >>confdefs.h\n\n\nLD_PRELOAD_VAR=\"LD_PRELOAD\"\nso=\"so\"\nimportlib=\"${so}\"\no=\"$ac_objext\"\na=\"a\"\nexe=\"$ac_exeext\"\nlibprefix=\"lib\"\nlink_whole_archive=\"0\"\nDSO_LDFLAGS='-shared -Wl,-soname,$(@F)'\nRPATH='-Wl,-rpath,$(1)'\nSOREV=\"${so}.${rev}\"\nPIC_CFLAGS='-fPIC -DPIC'\nCTARGET='-o $@'\nLDTARGET='-o $@'\nTEST_LD_MODE=\nEXTRA_LDFLAGS=\nARFLAGS='crs'\nAROUT=' $@'\nCC_MM=1\n\nif test \"x$je_cv_cray_prgenv_wrapper\" = \"xyes\" ; then\n TEST_LD_MODE='-dynamic'\nfi\n\nif test \"x${je_cv_cray}\" = \"xyes\" ; then\n CC_MM=\nfi\n\n\n\n\nif test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}ar\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}ar; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_AR+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$AR\"; then\n ac_cv_prog_AR=\"$AR\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_AR=\"${ac_tool_prefix}ar\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nAR=$ac_cv_prog_AR\nif test -n \"$AR\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $AR\" >&5\nprintf \"%s\\n\" \"$AR\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$ac_cv_prog_AR\"; then\n ac_ct_AR=$AR\n # Extract the first word of \"ar\", so it can be a program name with args.\nset dummy ar; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_AR+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_AR\"; then\n ac_cv_prog_ac_ct_AR=\"$ac_ct_AR\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_AR=\"ar\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_AR=$ac_cv_prog_ac_ct_AR\nif test -n \"$ac_ct_AR\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR\" >&5\nprintf \"%s\\n\" \"$ac_ct_AR\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n if test \"x$ac_ct_AR\" = x; then\n AR=\":\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n AR=$ac_ct_AR\n fi\nelse\n AR=\"$ac_cv_prog_AR\"\nfi\n\n\n\n\n\nif test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}nm\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}nm; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_NM+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$NM\"; then\n ac_cv_prog_NM=\"$NM\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_NM=\"${ac_tool_prefix}nm\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nNM=$ac_cv_prog_NM\nif test -n \"$NM\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $NM\" >&5\nprintf \"%s\\n\" \"$NM\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$ac_cv_prog_NM\"; then\n ac_ct_NM=$NM\n # Extract the first word of \"nm\", so it can be a program name with args.\nset dummy nm; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_NM+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_NM\"; then\n ac_cv_prog_ac_ct_NM=\"$ac_ct_NM\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_NM=\"nm\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_NM=$ac_cv_prog_ac_ct_NM\nif test -n \"$ac_ct_NM\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM\" >&5\nprintf \"%s\\n\" \"$ac_ct_NM\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n if test \"x$ac_ct_NM\" = x; then\n NM=\":\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n NM=$ac_ct_NM\n fi\nelse\n NM=\"$ac_cv_prog_NM\"\nfi\n\n\nfor ac_prog in gawk mawk nawk awk\ndo\n # Extract the first word of \"$ac_prog\", so it can be a program name with args.\nset dummy $ac_prog; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_AWK+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$AWK\"; then\n ac_cv_prog_AWK=\"$AWK\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_AWK=\"$ac_prog\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nAWK=$ac_cv_prog_AWK\nif test -n \"$AWK\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $AWK\" >&5\nprintf \"%s\\n\" \"$AWK\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n test -n \"$AWK\" && break\ndone\n\n\n\n\n# Check whether --with-version was given.\nif test ${with_version+y}\nthen :\n withval=$with_version;\n echo \"${with_version}\" | grep '^[0-9]\\+\\.[0-9]\\+\\.[0-9]\\+-[0-9]\\+-g[0-9a-f]\\+$' 2>&1 1>/dev/null\n if test $? -eq 0 ; then\n echo \"$with_version\" > \"${objroot}VERSION\"\n else\n echo \"${with_version}\" | grep '^VERSION$' 2>&1 1>/dev/null\n if test $? -ne 0 ; then\n as_fn_error $? \"${with_version} does not match ..--g or VERSION\" \"$LINENO\" 5\n fi\n fi\n\nelse $as_nop\n\n if test \"x`test ! \\\"${srcroot}\\\" && cd \\\"${srcroot}\\\"; git rev-parse --is-inside-work-tree 2>/dev/null`\" = \"xtrue\" ; then\n for pattern in '[0-9].[0-9].[0-9]' '[0-9].[0-9].[0-9][0-9]' \\\n '[0-9].[0-9][0-9].[0-9]' '[0-9].[0-9][0-9].[0-9][0-9]' \\\n '[0-9][0-9].[0-9].[0-9]' '[0-9][0-9].[0-9].[0-9][0-9]' \\\n '[0-9][0-9].[0-9][0-9].[0-9]' \\\n '[0-9][0-9].[0-9][0-9].[0-9][0-9]'; do\n (test ! \"${srcroot}\" && cd \"${srcroot}\"; git describe --long --abbrev=40 --match=\"${pattern}\") > \"${objroot}VERSION.tmp\" 2>/dev/null\n if test $? -eq 0 ; then\n mv \"${objroot}VERSION.tmp\" \"${objroot}VERSION\"\n break\n fi\n done\n fi\n rm -f \"${objroot}VERSION.tmp\"\n\nfi\n\n\nif test ! -e \"${objroot}VERSION\" ; then\n if test ! -e \"${srcroot}VERSION\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Missing VERSION file, and unable to generate it; creating bogus VERSION\" >&5\nprintf \"%s\\n\" \"Missing VERSION file, and unable to generate it; creating bogus VERSION\" >&6; }\n echo \"0.0.0-0-g000000missing_version_try_git_fetch_tags\" > \"${objroot}VERSION\"\n else\n cp ${srcroot}VERSION ${objroot}VERSION\n fi\nfi\njemalloc_version=`cat \"${objroot}VERSION\"`\njemalloc_version_major=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print $1}'`\njemalloc_version_minor=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print $2}'`\njemalloc_version_bugfix=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print $3}'`\njemalloc_version_nrev=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print $4}'`\njemalloc_version_gid=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print $5}'`\n\n\n\n\n\n\n\ndefault_retain=\"0\"\nzero_realloc_default_free=\"0\"\nmaps_coalesce=\"1\"\nDUMP_SYMS=\"${NM} -a\"\nSYM_PREFIX=\"\"\ncase \"${host}\" in\n *-*-darwin* | *-*-ios*)\n\tabi=\"macho\"\n\tRPATH=\"\"\n\tLD_PRELOAD_VAR=\"DYLD_INSERT_LIBRARIES\"\n\tso=\"dylib\"\n\timportlib=\"${so}\"\n\tforce_tls=\"0\"\n\tDSO_LDFLAGS='-shared -Wl,-install_name,$(LIBDIR)/$(@F)'\n\tSOREV=\"${rev}.${so}\"\n\tsbrk_deprecated=\"1\"\n\tSYM_PREFIX=\"_\"\n\t;;\n *-*-freebsd*)\n\tT_APPEND_V=-D_BSD_SOURCE\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\tabi=\"elf\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_SYSCTL_VM_OVERCOMMIT \" >>confdefs.h\n\n\tforce_lazy_lock=\"1\"\n\t;;\n *-*-dragonfly*)\n\tabi=\"elf\"\n\t;;\n *-*-openbsd*)\n\tabi=\"elf\"\n\tforce_tls=\"0\"\n\t;;\n *-*-bitrig*)\n\tabi=\"elf\"\n\t;;\n *-*-linux-android*)\n\t\tT_APPEND_V=-D_GNU_SOURCE\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\tabi=\"elf\"\n\tglibc=\"0\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_ALLOCA_H \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_THREADED_INIT \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_C11_ATOMICS \" >>confdefs.h\n\n\tforce_tls=\"0\"\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-linux*)\n\t\tT_APPEND_V=-D_GNU_SOURCE\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\tabi=\"elf\"\n\tglibc=\"1\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_ALLOCA_H \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_THREADED_INIT \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_USE_CXX_THROW \" >>confdefs.h\n\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-kfreebsd*)\n\t\tT_APPEND_V=-D_GNU_SOURCE\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\tabi=\"elf\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_ALLOCA_H \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_SYSCTL_VM_OVERCOMMIT \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_THREADED_INIT \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_USE_CXX_THROW \" >>confdefs.h\n\n\t;;\n *-*-netbsd*)\n\t{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking ABI\" >&5\nprintf %s \"checking ABI... \" >&6; }\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#ifdef __ELF__\n/* ELF */\n#else\n#error aout\n#endif\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n abi=\"elf\"\nelse $as_nop\n abi=\"aout\"\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n\t{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $abi\" >&5\nprintf \"%s\\n\" \"$abi\" >&6; }\n\t;;\n *-*-solaris2*)\n\tabi=\"elf\"\n\tRPATH='-Wl,-R,$(1)'\n\t\tT_APPEND_V=-D_POSIX_PTHREAD_SEMANTICS\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\tT_APPEND_V=-lposix4 -lsocket -lnsl\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\n\t;;\n *-ibm-aix*)\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t \t LD_PRELOAD_VAR=\"LDR_PRELOAD64\"\n\telse\n\t \t LD_PRELOAD_VAR=\"LDR_PRELOAD\"\n\tfi\n\tabi=\"xcoff\"\n\t;;\n *-*-mingw* | *-*-cygwin*)\n\tabi=\"pecoff\"\n\tforce_tls=\"0\"\n\tmaps_coalesce=\"0\"\n\tRPATH=\"\"\n\tso=\"dll\"\n\tif test \"x$je_cv_msvc\" = \"xyes\" ; then\n\t importlib=\"lib\"\n\t DSO_LDFLAGS=\"-LD\"\n\t EXTRA_LDFLAGS=\"-link -DEBUG\"\n\t CTARGET='-Fo$@'\n\t LDTARGET='-Fe$@'\n\t AR='lib'\n\t ARFLAGS='-nologo -out:'\n\t AROUT='$@'\n\t CC_MM=\n else\n\t importlib=\"${so}\"\n\t DSO_LDFLAGS=\"-shared\"\n\t link_whole_archive=\"1\"\n\tfi\n\tcase \"${host}\" in\n\t *-*-cygwin*)\n\t DUMP_SYMS=\"dumpbin /SYMBOLS\"\n\t ;;\n\t *)\n\t ;;\n\tesac\n\ta=\"lib\"\n\tlibprefix=\"\"\n\tSOREV=\"${so}\"\n\tPIC_CFLAGS=\"\"\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-nto-qnx)\n\tabi=\"elf\"\n force_tls=\"0\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAS_ALLOCA_H \" >>confdefs.h\n\n\t;;\n *)\n\t{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Unsupported operating system: ${host}\" >&5\nprintf \"%s\\n\" \"Unsupported operating system: ${host}\" >&6; }\n\tabi=\"elf\"\n\t;;\nesac\n\nJEMALLOC_USABLE_SIZE_CONST=const\n for ac_header in malloc.h\ndo :\n ac_fn_c_check_header_compile \"$LINENO\" \"malloc.h\" \"ac_cv_header_malloc_h\" \"$ac_includes_default\"\nif test \"x$ac_cv_header_malloc_h\" = xyes\nthen :\n printf \"%s\\n\" \"#define HAVE_MALLOC_H 1\" >>confdefs.h\n\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether malloc_usable_size definition can use const argument\" >&5\nprintf %s \"checking whether malloc_usable_size definition can use const argument... \" >&6; }\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n #include \n size_t malloc_usable_size(const void *ptr);\n\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\n\nelse $as_nop\n\n JEMALLOC_USABLE_SIZE_CONST=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\n\nfi\n\ndone\n\nprintf \"%s\\n\" \"#define JEMALLOC_USABLE_SIZE_CONST $JEMALLOC_USABLE_SIZE_CONST\" >>confdefs.h\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for library containing log\" >&5\nprintf %s \"checking for library containing log... \" >&6; }\nif test ${ac_cv_search_log+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_func_search_save_LIBS=$LIBS\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar log ();\nint\nmain (void)\n{\nreturn log ();\n ;\n return 0;\n}\n_ACEOF\nfor ac_lib in '' m\ndo\n if test -z \"$ac_lib\"; then\n ac_res=\"none required\"\n else\n ac_res=-l$ac_lib\n LIBS=\"-l$ac_lib $ac_func_search_save_LIBS\"\n fi\n if ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_search_log=$ac_res\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext\n if test ${ac_cv_search_log+y}\nthen :\n break\nfi\ndone\nif test ${ac_cv_search_log+y}\nthen :\n\nelse $as_nop\n ac_cv_search_log=no\nfi\nrm conftest.$ac_ext\nLIBS=$ac_func_search_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_log\" >&5\nprintf \"%s\\n\" \"$ac_cv_search_log\" >&6; }\nac_res=$ac_cv_search_log\nif test \"$ac_res\" != no\nthen :\n test \"$ac_res\" = \"none required\" || LIBS=\"$ac_res $LIBS\"\n\nelse $as_nop\n as_fn_error $? \"Missing math functions\" \"$LINENO\" 5\nfi\n\nif test \"x$ac_cv_search_log\" != \"xnone required\" ; then\n LM=\"$ac_cv_search_log\"\nelse\n LM=\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether __attribute__ syntax is compilable\" >&5\nprintf %s \"checking whether __attribute__ syntax is compilable... \" >&6; }\nif test ${je_cv_attribute+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\nstatic __attribute__((unused)) void foo(void){}\nint\nmain (void)\n{\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_attribute=yes\nelse $as_nop\n je_cv_attribute=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_attribute\" >&5\nprintf \"%s\\n\" \"$je_cv_attribute\" >&6; }\n\nif test \"x${je_cv_attribute}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR \" >>confdefs.h\n\n if test \"x${GCC}\" = \"xyes\" -a \"x${abi}\" = \"xelf\"; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fvisibility=hidden\" >&5\nprintf %s \"checking whether compiler supports -fvisibility=hidden... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-fvisibility=hidden\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-fvisibility=hidden\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fvisibility=hidden\" >&5\nprintf %s \"checking whether compiler supports -fvisibility=hidden... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-fvisibility=hidden\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-fvisibility=hidden\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n fi\nfi\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether tls_model attribute is compilable\" >&5\nprintf %s \"checking whether tls_model attribute is compilable... \" >&6; }\nif test ${je_cv_tls_model+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\nstatic __thread int\n __attribute__((tls_model(\"initial-exec\"), unused)) foo;\n foo = 0;\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_tls_model=yes\nelse $as_nop\n je_cv_tls_model=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_tls_model\" >&5\nprintf \"%s\\n\" \"$je_cv_tls_model\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether alloc_size attribute is compilable\" >&5\nprintf %s \"checking whether alloc_size attribute is compilable... \" >&6; }\nif test ${je_cv_alloc_size+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \nint\nmain (void)\n{\nvoid *foo(size_t size) __attribute__((alloc_size(1)));\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_alloc_size=yes\nelse $as_nop\n je_cv_alloc_size=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_alloc_size\" >&5\nprintf \"%s\\n\" \"$je_cv_alloc_size\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_alloc_size}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_ALLOC_SIZE \" >>confdefs.h\n\nfi\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether format(gnu_printf, ...) attribute is compilable\" >&5\nprintf %s \"checking whether format(gnu_printf, ...) attribute is compilable... \" >&6; }\nif test ${je_cv_format_gnu_printf+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \nint\nmain (void)\n{\nvoid *foo(const char *format, ...) __attribute__((format(gnu_printf, 1, 2)));\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_format_gnu_printf=yes\nelse $as_nop\n je_cv_format_gnu_printf=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_format_gnu_printf\" >&5\nprintf \"%s\\n\" \"$je_cv_format_gnu_printf\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_format_gnu_printf}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_FORMAT_GNU_PRINTF \" >>confdefs.h\n\nfi\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether format(printf, ...) attribute is compilable\" >&5\nprintf %s \"checking whether format(printf, ...) attribute is compilable... \" >&6; }\nif test ${je_cv_format_printf+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \nint\nmain (void)\n{\nvoid *foo(const char *format, ...) __attribute__((format(printf, 1, 2)));\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_format_printf=yes\nelse $as_nop\n je_cv_format_printf=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_format_printf\" >&5\nprintf \"%s\\n\" \"$je_cv_format_printf\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_format_printf}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_FORMAT_PRINTF \" >>confdefs.h\n\nfi\n\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether format(printf, ...) attribute is compilable\" >&5\nprintf %s \"checking whether format(printf, ...) attribute is compilable... \" >&6; }\nif test ${je_cv_format_arg+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \nint\nmain (void)\n{\nconst char * __attribute__((__format_arg__(1))) foo(const char *format);\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_format_arg=yes\nelse $as_nop\n je_cv_format_arg=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_format_arg\" >&5\nprintf \"%s\\n\" \"$je_cv_format_arg\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_format_arg}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_FORMAT_ARG \" >>confdefs.h\n\nfi\n\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wimplicit-fallthrough\" >&5\nprintf %s \"checking whether compiler supports -Wimplicit-fallthrough... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wimplicit-fallthrough\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wimplicit-fallthrough\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether fallthrough attribute is compilable\" >&5\nprintf %s \"checking whether fallthrough attribute is compilable... \" >&6; }\nif test ${je_cv_fallthrough+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#if !__has_attribute(fallthrough)\n #error \"foo\"\n #endif\nint\nmain (void)\n{\nint x = 0;\n switch (x) {\n case 0: __attribute__((__fallthrough__));\n case 1: return 1;\n }\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_fallthrough=yes\nelse $as_nop\n je_cv_fallthrough=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_fallthrough\" >&5\nprintf \"%s\\n\" \"$je_cv_fallthrough\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_fallthrough}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_FALLTHROUGH \" >>confdefs.h\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wimplicit-fallthrough\" >&5\nprintf %s \"checking whether compiler supports -Wimplicit-fallthrough... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Wimplicit-fallthrough\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Wimplicit-fallthrough\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wimplicit-fallthrough\" >&5\nprintf %s \"checking whether compiler supports -Wimplicit-fallthrough... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-Wimplicit-fallthrough\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-Wimplicit-fallthrough\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\nfi\n\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether cold attribute is compilable\" >&5\nprintf %s \"checking whether cold attribute is compilable... \" >&6; }\nif test ${je_cv_cold+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n__attribute__((__cold__)) void foo();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_cold=yes\nelse $as_nop\n je_cv_cold=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_cold\" >&5\nprintf \"%s\\n\" \"$je_cv_cold\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_cold}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ATTR_COLD \" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether vm_make_tag is compilable\" >&5\nprintf %s \"checking whether vm_make_tag is compilable... \" >&6; }\nif test ${je_cv_vm_make_tag+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\t #include \nint\nmain (void)\n{\nvoid *p;\n\t p = mmap(0, 16, PROT_READ, MAP_ANON|MAP_PRIVATE, VM_MAKE_TAG(1), 0);\n\t munmap(p, 16);\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_vm_make_tag=yes\nelse $as_nop\n je_cv_vm_make_tag=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_vm_make_tag\" >&5\nprintf \"%s\\n\" \"$je_cv_vm_make_tag\" >&6; }\n\nif test \"x${je_cv_vm_make_tag}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_VM_MAKE_TAG \" >>confdefs.h\n\nfi\n\n\n# Check whether --with-rpath was given.\nif test ${with_rpath+y}\nthen :\n withval=$with_rpath; if test \"x$with_rpath\" = \"xno\" ; then\n RPATH_EXTRA=\nelse\n RPATH_EXTRA=\"`echo $with_rpath | tr \\\":\\\" \\\" \\\"`\"\nfi\nelse $as_nop\n RPATH_EXTRA=\n\nfi\n\n\n\n# Check whether --enable-autogen was given.\nif test ${enable_autogen+y}\nthen :\n enableval=$enable_autogen; if test \"x$enable_autogen\" = \"xno\" ; then\n enable_autogen=\"0\"\nelse\n enable_autogen=\"1\"\nfi\n\nelse $as_nop\n enable_autogen=\"0\"\n\nfi\n\n\n\n\n # Find a good install program. We prefer a C program (faster),\n# so one script is as good as another. But avoid the broken or\n# incompatible versions:\n# SysV /etc/install, /usr/sbin/install\n# SunOS /usr/etc/install\n# IRIX /sbin/install\n# AIX /bin/install\n# AmigaOS /C/install, which installs bootblocks on floppy discs\n# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag\n# AFS /usr/afsws/bin/install, which mishandles nonexistent args\n# SVR4 /usr/ucb/install, which tries to use the nonexistent group \"staff\"\n# OS/2's system install, which has a completely different semantic\n# ./install, which can be erroneously created by make from ./install.sh.\n# Reject install programs that cannot install multiple files.\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install\" >&5\nprintf %s \"checking for a BSD-compatible install... \" >&6; }\nif test -z \"$INSTALL\"; then\nif test ${ac_cv_path_install+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n # Account for fact that we put trailing slashes in our PATH walk.\ncase $as_dir in #((\n ./ | /[cC]/* | \\\n /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \\\n ?:[\\\\/]os2[\\\\/]install[\\\\/]* | ?:[\\\\/]OS2[\\\\/]INSTALL[\\\\/]* | \\\n /usr/ucb/* ) ;;\n *)\n # OSF1 and SCO ODT 3.0 have their own names for install.\n # Don't use installbsd from OSF since it installs stuff as root\n # by default.\n for ac_prog in ginstall scoinst install; do\n for ac_exec_ext in '' $ac_executable_extensions; do\n\tif as_fn_executable_p \"$as_dir$ac_prog$ac_exec_ext\"; then\n\t if test $ac_prog = install &&\n\t grep dspmsg \"$as_dir$ac_prog$ac_exec_ext\" >/dev/null 2>&1; then\n\t # AIX install. It has an incompatible calling convention.\n\t :\n\t elif test $ac_prog = install &&\n\t grep pwplus \"$as_dir$ac_prog$ac_exec_ext\" >/dev/null 2>&1; then\n\t # program-specific install script used by HP pwplus--don't use.\n\t :\n\t else\n\t rm -rf conftest.one conftest.two conftest.dir\n\t echo one > conftest.one\n\t echo two > conftest.two\n\t mkdir conftest.dir\n\t if \"$as_dir$ac_prog$ac_exec_ext\" -c conftest.one conftest.two \"`pwd`/conftest.dir/\" &&\n\t test -s conftest.one && test -s conftest.two &&\n\t test -s conftest.dir/conftest.one &&\n\t test -s conftest.dir/conftest.two\n\t then\n\t ac_cv_path_install=\"$as_dir$ac_prog$ac_exec_ext -c\"\n\t break 3\n\t fi\n\t fi\n\tfi\n done\n done\n ;;\nesac\n\n done\nIFS=$as_save_IFS\n\nrm -rf conftest.one conftest.two conftest.dir\n\nfi\n if test ${ac_cv_path_install+y}; then\n INSTALL=$ac_cv_path_install\n else\n # As a last resort, use the slow shell script. Don't cache a\n # value for INSTALL within a source directory, because that will\n # break other packages using the cache if that directory is\n # removed, or if the value is a relative name.\n INSTALL=$ac_install_sh\n fi\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $INSTALL\" >&5\nprintf \"%s\\n\" \"$INSTALL\" >&6; }\n\n# Use test -z because SunOS4 sh mishandles braces in ${var-val}.\n# It thinks the first close brace ends the variable substitution.\ntest -z \"$INSTALL_PROGRAM\" && INSTALL_PROGRAM='${INSTALL}'\n\ntest -z \"$INSTALL_SCRIPT\" && INSTALL_SCRIPT='${INSTALL}'\n\ntest -z \"$INSTALL_DATA\" && INSTALL_DATA='${INSTALL} -m 644'\n\nif test -n \"$ac_tool_prefix\"; then\n # Extract the first word of \"${ac_tool_prefix}ranlib\", so it can be a program name with args.\nset dummy ${ac_tool_prefix}ranlib; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_RANLIB+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$RANLIB\"; then\n ac_cv_prog_RANLIB=\"$RANLIB\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_RANLIB=\"${ac_tool_prefix}ranlib\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nRANLIB=$ac_cv_prog_RANLIB\nif test -n \"$RANLIB\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $RANLIB\" >&5\nprintf \"%s\\n\" \"$RANLIB\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\nfi\nif test -z \"$ac_cv_prog_RANLIB\"; then\n ac_ct_RANLIB=$RANLIB\n # Extract the first word of \"ranlib\", so it can be a program name with args.\nset dummy ranlib; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_prog_ac_ct_RANLIB+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test -n \"$ac_ct_RANLIB\"; then\n ac_cv_prog_ac_ct_RANLIB=\"$ac_ct_RANLIB\" # Let the user override the test.\nelse\nas_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_prog_ac_ct_RANLIB=\"ranlib\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\nfi\nfi\nac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB\nif test -n \"$ac_ct_RANLIB\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB\" >&5\nprintf \"%s\\n\" \"$ac_ct_RANLIB\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n if test \"x$ac_ct_RANLIB\" = x; then\n RANLIB=\":\"\n else\n case $cross_compiling:$ac_tool_warned in\nyes:)\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: using cross tools not prefixed with host triplet\" >&2;}\nac_tool_warned=yes ;;\nesac\n RANLIB=$ac_ct_RANLIB\n fi\nelse\n RANLIB=\"$ac_cv_prog_RANLIB\"\nfi\n\n# Extract the first word of \"ld\", so it can be a program name with args.\nset dummy ld; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_path_LD+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n case $LD in\n [\\\\/]* | ?:[\\\\/]*)\n ac_cv_path_LD=\"$LD\" # Let the user override the test with a path.\n ;;\n *)\n as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_path_LD=\"$as_dir$ac_word$ac_exec_ext\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\n test -z \"$ac_cv_path_LD\" && ac_cv_path_LD=\"false\"\n ;;\nesac\nfi\nLD=$ac_cv_path_LD\nif test -n \"$LD\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $LD\" >&5\nprintf \"%s\\n\" \"$LD\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n# Extract the first word of \"autoconf\", so it can be a program name with args.\nset dummy autoconf; ac_word=$2\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for $ac_word\" >&5\nprintf %s \"checking for $ac_word... \" >&6; }\nif test ${ac_cv_path_AUTOCONF+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n case $AUTOCONF in\n [\\\\/]* | ?:[\\\\/]*)\n ac_cv_path_AUTOCONF=\"$AUTOCONF\" # Let the user override the test with a path.\n ;;\n *)\n as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n for ac_exec_ext in '' $ac_executable_extensions; do\n if as_fn_executable_p \"$as_dir$ac_word$ac_exec_ext\"; then\n ac_cv_path_AUTOCONF=\"$as_dir$ac_word$ac_exec_ext\"\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext\" >&5\n break 2\n fi\ndone\n done\nIFS=$as_save_IFS\n\n test -z \"$ac_cv_path_AUTOCONF\" && ac_cv_path_AUTOCONF=\"false\"\n ;;\nesac\nfi\nAUTOCONF=$ac_cv_path_AUTOCONF\nif test -n \"$AUTOCONF\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $AUTOCONF\" >&5\nprintf \"%s\\n\" \"$AUTOCONF\" >&6; }\nelse\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\nfi\n\n\n\n# Check whether --enable-doc was given.\nif test ${enable_doc+y}\nthen :\n enableval=$enable_doc; if test \"x$enable_doc\" = \"xno\" ; then\n enable_doc=\"0\"\nelse\n enable_doc=\"1\"\nfi\n\nelse $as_nop\n enable_doc=\"1\"\n\nfi\n\n\n\n# Check whether --enable-shared was given.\nif test ${enable_shared+y}\nthen :\n enableval=$enable_shared; if test \"x$enable_shared\" = \"xno\" ; then\n enable_shared=\"0\"\nelse\n enable_shared=\"1\"\nfi\n\nelse $as_nop\n enable_shared=\"1\"\n\nfi\n\n\n\n# Check whether --enable-static was given.\nif test ${enable_static+y}\nthen :\n enableval=$enable_static; if test \"x$enable_static\" = \"xno\" ; then\n enable_static=\"0\"\nelse\n enable_static=\"1\"\nfi\n\nelse $as_nop\n enable_static=\"1\"\n\nfi\n\n\n\nif test \"$enable_shared$enable_static\" = \"00\" ; then\n as_fn_error $? \"Please enable one of shared or static builds\" \"$LINENO\" 5\nfi\n\n\n# Check whether --with-mangling was given.\nif test ${with_mangling+y}\nthen :\n withval=$with_mangling; mangling_map=\"$with_mangling\"\nelse $as_nop\n mangling_map=\"\"\nfi\n\n\n\n# Check whether --with-jemalloc_prefix was given.\nif test ${with_jemalloc_prefix+y}\nthen :\n withval=$with_jemalloc_prefix; JEMALLOC_PREFIX=\"$with_jemalloc_prefix\"\nelse $as_nop\n if test \"x$abi\" != \"xmacho\" -a \"x$abi\" != \"xpecoff\"; then\n JEMALLOC_PREFIX=\"\"\nelse\n JEMALLOC_PREFIX=\"je_\"\nfi\n\nfi\n\nif test \"x$JEMALLOC_PREFIX\" = \"x\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_IS_MALLOC \" >>confdefs.h\n\nelse\n JEMALLOC_CPREFIX=`echo ${JEMALLOC_PREFIX} | tr \"a-z\" \"A-Z\"`\n\nprintf \"%s\\n\" \"#define JEMALLOC_PREFIX \\\"$JEMALLOC_PREFIX\\\"\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_CPREFIX \\\"$JEMALLOC_CPREFIX\\\"\" >>confdefs.h\n\nfi\n\n\n\n\n# Check whether --with-export was given.\nif test ${with_export+y}\nthen :\n withval=$with_export; if test \"x$with_export\" = \"xno\"; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_EXPORT /**/\" >>confdefs.h\n\nfi\n\nfi\n\n\npublic_syms=\"aligned_alloc calloc dallocx free mallctl mallctlbymib mallctlnametomib malloc malloc_conf malloc_conf_2_conf_harder malloc_message malloc_stats_print malloc_usable_size mallocx smallocx_${jemalloc_version_gid} nallocx posix_memalign rallocx realloc sallocx sdallocx xallocx\"\nac_fn_c_check_func \"$LINENO\" \"memalign\" \"ac_cv_func_memalign\"\nif test \"x$ac_cv_func_memalign\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE_MEMALIGN \" >>confdefs.h\n\n\t public_syms=\"${public_syms} memalign\"\nfi\n\nac_fn_c_check_func \"$LINENO\" \"valloc\" \"ac_cv_func_valloc\"\nif test \"x$ac_cv_func_valloc\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE_VALLOC \" >>confdefs.h\n\n\t public_syms=\"${public_syms} valloc\"\nfi\n\nac_fn_c_check_func \"$LINENO\" \"malloc_size\" \"ac_cv_func_malloc_size\"\nif test \"x$ac_cv_func_malloc_size\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MALLOC_SIZE \" >>confdefs.h\n\n\t public_syms=\"${public_syms} malloc_size\"\nfi\n\n\nwrap_syms=\nif test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n ac_fn_c_check_func \"$LINENO\" \"__libc_calloc\" \"ac_cv_func___libc_calloc\"\nif test \"x$ac_cv_func___libc_calloc\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_CALLOC \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_calloc\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__libc_free\" \"ac_cv_func___libc_free\"\nif test \"x$ac_cv_func___libc_free\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_FREE \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_free\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__libc_malloc\" \"ac_cv_func___libc_malloc\"\nif test \"x$ac_cv_func___libc_malloc\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_MALLOC \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_malloc\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__libc_memalign\" \"ac_cv_func___libc_memalign\"\nif test \"x$ac_cv_func___libc_memalign\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_MEMALIGN \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_memalign\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__libc_realloc\" \"ac_cv_func___libc_realloc\"\nif test \"x$ac_cv_func___libc_realloc\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_REALLOC \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_realloc\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__libc_valloc\" \"ac_cv_func___libc_valloc\"\nif test \"x$ac_cv_func___libc_valloc\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___LIBC_VALLOC \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __libc_valloc\"\nfi\n\n ac_fn_c_check_func \"$LINENO\" \"__posix_memalign\" \"ac_cv_func___posix_memalign\"\nif test \"x$ac_cv_func___posix_memalign\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define JEMALLOC_OVERRIDE___POSIX_MEMALIGN \" >>confdefs.h\n\n\t\t wrap_syms=\"${wrap_syms} __posix_memalign\"\nfi\n\nfi\n\ncase \"${host}\" in\n *-*-mingw* | *-*-cygwin*)\n wrap_syms=\"${wrap_syms} tls_callback\"\n ;;\n *)\n ;;\nesac\n\n\n# Check whether --with-private_namespace was given.\nif test ${with_private_namespace+y}\nthen :\n withval=$with_private_namespace; JEMALLOC_PRIVATE_NAMESPACE=\"${with_private_namespace}je_\"\nelse $as_nop\n JEMALLOC_PRIVATE_NAMESPACE=\"je_\"\n\nfi\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_PRIVATE_NAMESPACE $JEMALLOC_PRIVATE_NAMESPACE\" >>confdefs.h\n\nprivate_namespace=\"$JEMALLOC_PRIVATE_NAMESPACE\"\n\n\n\n# Check whether --with-install_suffix was given.\nif test ${with_install_suffix+y}\nthen :\n withval=$with_install_suffix; case \"$with_install_suffix\" in\n *\\ * ) as_fn_error $? \"Install suffix should not contain spaces\" \"$LINENO\" 5 ;;\n * ) INSTALL_SUFFIX=\"$with_install_suffix\" ;;\nesac\nelse $as_nop\n INSTALL_SUFFIX=\n\nfi\n\ninstall_suffix=\"$INSTALL_SUFFIX\"\n\n\n\n# Check whether --with-malloc_conf was given.\nif test ${with_malloc_conf+y}\nthen :\n withval=$with_malloc_conf; JEMALLOC_CONFIG_MALLOC_CONF=\"$with_malloc_conf\"\nelse $as_nop\n JEMALLOC_CONFIG_MALLOC_CONF=\"\"\n\nfi\n\nconfig_malloc_conf=\"$JEMALLOC_CONFIG_MALLOC_CONF\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_CONFIG_MALLOC_CONF \\\"$config_malloc_conf\\\"\" >>confdefs.h\n\n\nje_=\"je_\"\n\n\ncfgoutputs_in=\"Makefile.in\"\ncfgoutputs_in=\"${cfgoutputs_in} jemalloc.pc.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/html.xsl.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/manpages.xsl.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/jemalloc.xml.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_macros.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_protos.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_typedefs.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/internal/jemalloc_preamble.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} test/test.sh.in\"\ncfgoutputs_in=\"${cfgoutputs_in} test/include/test/jemalloc_test.h.in\"\n\ncfgoutputs_out=\"Makefile\"\ncfgoutputs_out=\"${cfgoutputs_out} jemalloc.pc\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/html.xsl\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/manpages.xsl\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/jemalloc.xml\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_macros.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_protos.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_typedefs.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/internal/jemalloc_preamble.h\"\ncfgoutputs_out=\"${cfgoutputs_out} test/test.sh\"\ncfgoutputs_out=\"${cfgoutputs_out} test/include/test/jemalloc_test.h\"\n\ncfgoutputs_tup=\"Makefile\"\ncfgoutputs_tup=\"${cfgoutputs_tup} jemalloc.pc:jemalloc.pc.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/html.xsl:doc/html.xsl.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/manpages.xsl:doc/manpages.xsl.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/jemalloc.xml:doc/jemalloc.xml.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_macros.h:include/jemalloc/jemalloc_macros.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_protos.h:include/jemalloc/jemalloc_protos.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_typedefs.h:include/jemalloc/jemalloc_typedefs.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/internal/jemalloc_preamble.h\"\ncfgoutputs_tup=\"${cfgoutputs_tup} test/test.sh:test/test.sh.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} test/include/test/jemalloc_test.h:test/include/test/jemalloc_test.h.in\"\n\ncfghdrs_in=\"include/jemalloc/jemalloc_defs.h.in\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/jemalloc_internal_defs.h.in\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/private_symbols.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/private_namespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/public_namespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/public_unnamespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc_rename.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc_mangle.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc.sh\"\ncfghdrs_in=\"${cfghdrs_in} test/include/test/jemalloc_test_defs.h.in\"\n\ncfghdrs_out=\"include/jemalloc/jemalloc_defs.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc${install_suffix}.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/private_symbols.awk\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/private_symbols_jet.awk\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_symbols.txt\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_namespace.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_unnamespace.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_protos_jet.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_rename.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_mangle.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_mangle_jet.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/jemalloc_internal_defs.h\"\ncfghdrs_out=\"${cfghdrs_out} test/include/test/jemalloc_test_defs.h\"\n\ncfghdrs_tup=\"include/jemalloc/jemalloc_defs.h:include/jemalloc/jemalloc_defs.h.in\"\ncfghdrs_tup=\"${cfghdrs_tup} include/jemalloc/internal/jemalloc_internal_defs.h:include/jemalloc/internal/jemalloc_internal_defs.h.in\"\ncfghdrs_tup=\"${cfghdrs_tup} test/include/test/jemalloc_test_defs.h:test/include/test/jemalloc_test_defs.h.in\"\n\n\n# Check whether --enable-debug was given.\nif test ${enable_debug+y}\nthen :\n enableval=$enable_debug; if test \"x$enable_debug\" = \"xno\" ; then\n enable_debug=\"0\"\nelse\n enable_debug=\"1\"\nfi\n\nelse $as_nop\n enable_debug=\"0\"\n\nfi\n\nif test \"x$enable_debug\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_DEBUG \" >>confdefs.h\n\nfi\n\n\nif test \"x$enable_debug\" = \"x0\" ; then\n if test \"x$GCC\" = \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O3\" >&5\nprintf %s \"checking whether compiler supports -O3... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-O3\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-O3\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O3\" >&5\nprintf %s \"checking whether compiler supports -O3... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-O3\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-O3\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -funroll-loops\" >&5\nprintf %s \"checking whether compiler supports -funroll-loops... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-funroll-loops\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-funroll-loops\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n elif test \"x$je_cv_msvc\" = \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O2\" >&5\nprintf %s \"checking whether compiler supports -O2... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-O2\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-O2\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O2\" >&5\nprintf %s \"checking whether compiler supports -O2... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-O2\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-O2\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n else\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O\" >&5\nprintf %s \"checking whether compiler supports -O... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-O\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-O\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O\" >&5\nprintf %s \"checking whether compiler supports -O... \" >&6; }\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nT_APPEND_V=-O\n if test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\nac_ext=cpp\nac_cpp='$CXXCPP $CPPFLAGS'\nac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_cxx_compiler_gnu\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_cxx_try_compile \"$LINENO\"\nthen :\n je_cv_cxxflags_added=-O\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cxxflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nac_ext=c\nac_cpp='$CPP $CPPFLAGS'\nac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'\nac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'\nac_compiler_gnu=$ac_cv_c_compiler_gnu\n\nif test \"x${CONFIGURE_CXXFLAGS}\" = \"x\" -o \"x${SPECIFIED_CXXFLAGS}\" = \"x\" ; then\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS}${SPECIFIED_CXXFLAGS}\"\nelse\n CXXFLAGS=\"${CONFIGURE_CXXFLAGS} ${SPECIFIED_CXXFLAGS}\"\nfi\n\n\n fi\nfi\n\n# Check whether --enable-stats was given.\nif test ${enable_stats+y}\nthen :\n enableval=$enable_stats; if test \"x$enable_stats\" = \"xno\" ; then\n enable_stats=\"0\"\nelse\n enable_stats=\"1\"\nfi\n\nelse $as_nop\n enable_stats=\"1\"\n\nfi\n\nif test \"x$enable_stats\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_STATS \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-experimental_smallocx was given.\nif test ${enable_experimental_smallocx+y}\nthen :\n enableval=$enable_experimental_smallocx; if test \"x$enable_experimental_smallocx\" = \"xno\" ; then\nenable_experimental_smallocx=\"0\"\nelse\nenable_experimental_smallocx=\"1\"\nfi\n\nelse $as_nop\n enable_experimental_smallocx=\"0\"\n\nfi\n\nif test \"x$enable_experimental_smallocx\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_EXPERIMENTAL_SMALLOCX_API \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-prof was given.\nif test ${enable_prof+y}\nthen :\n enableval=$enable_prof; if test \"x$enable_prof\" = \"xno\" ; then\n enable_prof=\"0\"\nelse\n enable_prof=\"1\"\nfi\n\nelse $as_nop\n enable_prof=\"0\"\n\nfi\n\nif test \"x$enable_prof\" = \"x1\" ; then\n backtrace_method=\"\"\nelse\n backtrace_method=\"N/A\"\nfi\n\n# Check whether --enable-prof-libunwind was given.\nif test ${enable_prof_libunwind+y}\nthen :\n enableval=$enable_prof_libunwind; if test \"x$enable_prof_libunwind\" = \"xno\" ; then\n enable_prof_libunwind=\"0\"\nelse\n enable_prof_libunwind=\"1\"\n if test \"x$enable_prof\" = \"x0\" ; then\n as_fn_error $? \"--enable-prof-libunwind should only be used with --enable-prof\" \"$LINENO\" 5\n fi\nfi\n\nelse $as_nop\n enable_prof_libunwind=\"0\"\n\nfi\n\n\n# Check whether --with-static_libunwind was given.\nif test ${with_static_libunwind+y}\nthen :\n withval=$with_static_libunwind; if test \"x$with_static_libunwind\" = \"xno\" ; then\n LUNWIND=\"-lunwind\"\nelse\n if test ! -f \"$with_static_libunwind\" ; then\n as_fn_error $? \"Static libunwind not found: $with_static_libunwind\" \"$LINENO\" 5\n fi\n LUNWIND=\"$with_static_libunwind\"\nfi\nelse $as_nop\n LUNWIND=\"-lunwind\"\n\nfi\n\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_libunwind\" = \"x1\" ; then\n for ac_header in libunwind.h\ndo :\n ac_fn_c_check_header_compile \"$LINENO\" \"libunwind.h\" \"ac_cv_header_libunwind_h\" \"$ac_includes_default\"\nif test \"x$ac_cv_header_libunwind_h\" = xyes\nthen :\n printf \"%s\\n\" \"#define HAVE_LIBUNWIND_H 1\" >>confdefs.h\n\nelse $as_nop\n enable_prof_libunwind=\"0\"\nfi\n\ndone\n if test \"x$LUNWIND\" = \"x-lunwind\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for unw_backtrace in -lunwind\" >&5\nprintf %s \"checking for unw_backtrace in -lunwind... \" >&6; }\nif test ${ac_cv_lib_unwind_unw_backtrace+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_check_lib_save_LIBS=$LIBS\nLIBS=\"-lunwind $LIBS\"\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar unw_backtrace ();\nint\nmain (void)\n{\nreturn unw_backtrace ();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_lib_unwind_unw_backtrace=yes\nelse $as_nop\n ac_cv_lib_unwind_unw_backtrace=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nLIBS=$ac_check_lib_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_unwind_unw_backtrace\" >&5\nprintf \"%s\\n\" \"$ac_cv_lib_unwind_unw_backtrace\" >&6; }\nif test \"x$ac_cv_lib_unwind_unw_backtrace\" = xyes\nthen :\n T_APPEND_V=$LUNWIND\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\nelse $as_nop\n enable_prof_libunwind=\"0\"\nfi\n\n else\n T_APPEND_V=$LUNWIND\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\n fi\n if test \"x${enable_prof_libunwind}\" = \"x1\" ; then\n backtrace_method=\"libunwind\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROF_LIBUNWIND \" >>confdefs.h\n\n fi\nfi\n\n# Check whether --enable-prof-libgcc was given.\nif test ${enable_prof_libgcc+y}\nthen :\n enableval=$enable_prof_libgcc; if test \"x$enable_prof_libgcc\" = \"xno\" ; then\n enable_prof_libgcc=\"0\"\nelse\n enable_prof_libgcc=\"1\"\nfi\n\nelse $as_nop\n enable_prof_libgcc=\"1\"\n\nfi\n\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_libgcc\" = \"x1\" \\\n -a \"x$GCC\" = \"xyes\" ; then\n for ac_header in unwind.h\ndo :\n ac_fn_c_check_header_compile \"$LINENO\" \"unwind.h\" \"ac_cv_header_unwind_h\" \"$ac_includes_default\"\nif test \"x$ac_cv_header_unwind_h\" = xyes\nthen :\n printf \"%s\\n\" \"#define HAVE_UNWIND_H 1\" >>confdefs.h\n\nelse $as_nop\n enable_prof_libgcc=\"0\"\nfi\n\ndone\n if test \"x${enable_prof_libgcc}\" = \"x1\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for _Unwind_Backtrace in -lgcc\" >&5\nprintf %s \"checking for _Unwind_Backtrace in -lgcc... \" >&6; }\nif test ${ac_cv_lib_gcc__Unwind_Backtrace+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_check_lib_save_LIBS=$LIBS\nLIBS=\"-lgcc $LIBS\"\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar _Unwind_Backtrace ();\nint\nmain (void)\n{\nreturn _Unwind_Backtrace ();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_lib_gcc__Unwind_Backtrace=yes\nelse $as_nop\n ac_cv_lib_gcc__Unwind_Backtrace=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nLIBS=$ac_check_lib_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcc__Unwind_Backtrace\" >&5\nprintf \"%s\\n\" \"$ac_cv_lib_gcc__Unwind_Backtrace\" >&6; }\nif test \"x$ac_cv_lib_gcc__Unwind_Backtrace\" = xyes\nthen :\n T_APPEND_V=-lgcc\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\nelse $as_nop\n enable_prof_libgcc=\"0\"\nfi\n\n fi\n if test \"x${enable_prof_libgcc}\" = \"x1\" ; then\n backtrace_method=\"libgcc\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROF_LIBGCC \" >>confdefs.h\n\n fi\nelse\n enable_prof_libgcc=\"0\"\nfi\n\n# Check whether --enable-prof-gcc was given.\nif test ${enable_prof_gcc+y}\nthen :\n enableval=$enable_prof_gcc; if test \"x$enable_prof_gcc\" = \"xno\" ; then\n enable_prof_gcc=\"0\"\nelse\n enable_prof_gcc=\"1\"\nfi\n\nelse $as_nop\n enable_prof_gcc=\"1\"\n\nfi\n\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_gcc\" = \"x1\" \\\n -a \"x$GCC\" = \"xyes\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fno-omit-frame-pointer\" >&5\nprintf %s \"checking whether compiler supports -fno-omit-frame-pointer... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-fno-omit-frame-pointer\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-fno-omit-frame-pointer\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n backtrace_method=\"gcc intrinsics\"\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROF_GCC \" >>confdefs.h\n\nelse\n enable_prof_gcc=\"0\"\nfi\n\nif test \"x$backtrace_method\" = \"x\" ; then\n backtrace_method=\"none (disabling profiling)\"\n enable_prof=\"0\"\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking configured backtracing method\" >&5\nprintf %s \"checking configured backtracing method... \" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $backtrace_method\" >&5\nprintf \"%s\\n\" \"$backtrace_method\" >&6; }\nif test \"x$enable_prof\" = \"x1\" ; then\n T_APPEND_V=$LM\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_PROF \" >>confdefs.h\n\nfi\n\n\nif test \"x${maps_coalesce}\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_MAPS_COALESCE \" >>confdefs.h\n\nfi\n\nif test \"x$default_retain\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_RETAIN \" >>confdefs.h\n\nfi\n\nif test \"x$zero_realloc_default_free\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_ZERO_REALLOC_DEFAULT_FREE \" >>confdefs.h\n\nfi\n\nhave_dss=\"1\"\nac_fn_c_check_func \"$LINENO\" \"sbrk\" \"ac_cv_func_sbrk\"\nif test \"x$ac_cv_func_sbrk\" = xyes\nthen :\n have_sbrk=\"1\"\nelse $as_nop\n have_sbrk=\"0\"\nfi\n\nif test \"x$have_sbrk\" = \"x1\" ; then\n if test \"x$sbrk_deprecated\" = \"x1\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Disabling dss allocation because sbrk is deprecated\" >&5\nprintf \"%s\\n\" \"Disabling dss allocation because sbrk is deprecated\" >&6; }\n have_dss=\"0\"\n fi\nelse\n have_dss=\"0\"\nfi\n\nif test \"x$have_dss\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_DSS \" >>confdefs.h\n\nfi\n\n# Check whether --enable-fill was given.\nif test ${enable_fill+y}\nthen :\n enableval=$enable_fill; if test \"x$enable_fill\" = \"xno\" ; then\n enable_fill=\"0\"\nelse\n enable_fill=\"1\"\nfi\n\nelse $as_nop\n enable_fill=\"1\"\n\nfi\n\nif test \"x$enable_fill\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_FILL \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-utrace was given.\nif test ${enable_utrace+y}\nthen :\n enableval=$enable_utrace; if test \"x$enable_utrace\" = \"xno\" ; then\n enable_utrace=\"0\"\nelse\n enable_utrace=\"1\"\nfi\n\nelse $as_nop\n enable_utrace=\"0\"\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether utrace(2) is compilable\" >&5\nprintf %s \"checking whether utrace(2) is compilable... \" >&6; }\nif test ${je_cv_utrace+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n#include \n#include \n#include \n\nint\nmain (void)\n{\n\n\tutrace((void *)0, 0);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_utrace=yes\nelse $as_nop\n je_cv_utrace=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_utrace\" >&5\nprintf \"%s\\n\" \"$je_cv_utrace\" >&6; }\n\nif test \"x${je_cv_utrace}\" = \"xno\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether utrace(2) with label is compilable\" >&5\nprintf %s \"checking whether utrace(2) with label is compilable... \" >&6; }\nif test ${je_cv_utrace_label+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n #include \n #include \n #include \n #include \n\nint\nmain (void)\n{\n\n\t utrace((void *)0, (void *)0, 0);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_utrace_label=yes\nelse $as_nop\n je_cv_utrace_label=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_utrace_label\" >&5\nprintf \"%s\\n\" \"$je_cv_utrace_label\" >&6; }\n\n if test \"x${je_cv_utrace_label}\" = \"xno\"; then\n enable_utrace=\"0\"\n fi\n if test \"x$enable_utrace\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_UTRACE_LABEL \" >>confdefs.h\n\n fi\nelse\n if test \"x$enable_utrace\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_UTRACE \" >>confdefs.h\n\n fi\nfi\n\n\n# Check whether --enable-xmalloc was given.\nif test ${enable_xmalloc+y}\nthen :\n enableval=$enable_xmalloc; if test \"x$enable_xmalloc\" = \"xno\" ; then\n enable_xmalloc=\"0\"\nelse\n enable_xmalloc=\"1\"\nfi\n\nelse $as_nop\n enable_xmalloc=\"0\"\n\nfi\n\nif test \"x$enable_xmalloc\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_XMALLOC \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-cache-oblivious was given.\nif test ${enable_cache_oblivious+y}\nthen :\n enableval=$enable_cache_oblivious; if test \"x$enable_cache_oblivious\" = \"xno\" ; then\n enable_cache_oblivious=\"0\"\nelse\n enable_cache_oblivious=\"1\"\nfi\n\nelse $as_nop\n enable_cache_oblivious=\"1\"\n\nfi\n\nif test \"x$enable_cache_oblivious\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_CACHE_OBLIVIOUS \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-log was given.\nif test ${enable_log+y}\nthen :\n enableval=$enable_log; if test \"x$enable_log\" = \"xno\" ; then\n enable_log=\"0\"\nelse\n enable_log=\"1\"\nfi\n\nelse $as_nop\n enable_log=\"0\"\n\nfi\n\nif test \"x$enable_log\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_LOG \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-readlinkat was given.\nif test ${enable_readlinkat+y}\nthen :\n enableval=$enable_readlinkat; if test \"x$enable_readlinkat\" = \"xno\" ; then\n enable_readlinkat=\"0\"\nelse\n enable_readlinkat=\"1\"\nfi\n\nelse $as_nop\n enable_readlinkat=\"0\"\n\nfi\n\nif test \"x$enable_readlinkat\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_READLINKAT \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-opt-safety-checks was given.\nif test ${enable_opt_safety_checks+y}\nthen :\n enableval=$enable_opt_safety_checks; if test \"x$enable_opt_safety_checks\" = \"xno\" ; then\n enable_opt_safety_checks=\"0\"\nelse\n enable_opt_safety_checks=\"1\"\nfi\n\nelse $as_nop\n enable_opt_safety_checks=\"0\"\n\nfi\n\nif test \"x$enable_opt_safety_checks\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_OPT_SAFETY_CHECKS \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-opt-size-checks was given.\nif test ${enable_opt_size_checks+y}\nthen :\n enableval=$enable_opt_size_checks; if test \"x$enable_opt_size_checks\" = \"xno\" ; then\n enable_opt_size_checks=\"0\"\nelse\n enable_opt_size_checks=\"1\"\nfi\n\nelse $as_nop\n enable_opt_size_checks=\"0\"\n\nfi\n\nif test \"x$enable_opt_size_checks\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_OPT_SIZE_CHECKS \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-uaf-detection was given.\nif test ${enable_uaf_detection+y}\nthen :\n enableval=$enable_uaf_detection; if test \"x$enable_uaf_detection\" = \"xno\" ; then\n enable_uaf_detection=\"0\"\nelse\n enable_uaf_detection=\"1\"\nfi\n\nelse $as_nop\n enable_uaf_detection=\"0\"\n\nfi\n\nif test \"x$enable_uaf_detection\" = \"x1\" ; then\n printf \"%s\\n\" \"#define JEMALLOC_UAF_DETECTION \" >>confdefs.h\n\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether a program using __builtin_unreachable is compilable\" >&5\nprintf %s \"checking whether a program using __builtin_unreachable is compilable... \" >&6; }\nif test ${je_cv_gcc_builtin_unreachable+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nvoid foo (void) {\n __builtin_unreachable();\n}\n\nint\nmain (void)\n{\n\n\t{\n\t\tfoo();\n\t}\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_builtin_unreachable=yes\nelse $as_nop\n je_cv_gcc_builtin_unreachable=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_builtin_unreachable\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_builtin_unreachable\" >&6; }\n\nif test \"x${je_cv_gcc_builtin_unreachable}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_UNREACHABLE __builtin_unreachable\" >>confdefs.h\n\nelse\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_UNREACHABLE abort\" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether a program using __builtin_ffsl is compilable\" >&5\nprintf %s \"checking whether a program using __builtin_ffsl is compilable... \" >&6; }\nif test ${je_cv_gcc_builtin_ffsl+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n#include \n\nint\nmain (void)\n{\n\n\t{\n\t\tint rv = __builtin_ffsl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_builtin_ffsl=yes\nelse $as_nop\n je_cv_gcc_builtin_ffsl=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_builtin_ffsl\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_builtin_ffsl\" >&6; }\n\nif test \"x${je_cv_gcc_builtin_ffsl}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFSLL __builtin_ffsll\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFSL __builtin_ffsl\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFS __builtin_ffs\" >>confdefs.h\n\nelse\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether a program using ffsl is compilable\" >&5\nprintf %s \"checking whether a program using ffsl is compilable... \" >&6; }\nif test ${je_cv_function_ffsl+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n #include \n #include \n\nint\nmain (void)\n{\n\n\t{\n\t\tint rv = ffsl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_function_ffsl=yes\nelse $as_nop\n je_cv_function_ffsl=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_function_ffsl\" >&5\nprintf \"%s\\n\" \"$je_cv_function_ffsl\" >&6; }\n\n if test \"x${je_cv_function_ffsl}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFSLL ffsll\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFSL ffsl\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_FFS ffs\" >>confdefs.h\n\n else\n as_fn_error $? \"Cannot build without ffsl(3) or __builtin_ffsl()\" \"$LINENO\" 5\n fi\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether a program using __builtin_popcountl is compilable\" >&5\nprintf %s \"checking whether a program using __builtin_popcountl is compilable... \" >&6; }\nif test ${je_cv_gcc_builtin_popcountl+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n#include \n\nint\nmain (void)\n{\n\n\t{\n\t\tint rv = __builtin_popcountl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_builtin_popcountl=yes\nelse $as_nop\n je_cv_gcc_builtin_popcountl=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_builtin_popcountl\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_builtin_popcountl\" >&6; }\n\nif test \"x${je_cv_gcc_builtin_popcountl}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_POPCOUNT __builtin_popcount\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_POPCOUNTL __builtin_popcountl\" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_INTERNAL_POPCOUNTLL __builtin_popcountll\" >>confdefs.h\n\nfi\n\n\n# Check whether --with-lg_quantum was given.\nif test ${with_lg_quantum+y}\nthen :\n withval=$with_lg_quantum;\nfi\n\nif test \"x$with_lg_quantum\" != \"x\" ; then\n\nprintf \"%s\\n\" \"#define LG_QUANTUM $with_lg_quantum\" >>confdefs.h\n\nfi\n\n\n# Check whether --with-lg_slab_maxregs was given.\nif test ${with_lg_slab_maxregs+y}\nthen :\n withval=$with_lg_slab_maxregs; CONFIG_LG_SLAB_MAXREGS=\"with_lg_slab_maxregs\"\nelse $as_nop\n CONFIG_LG_SLAB_MAXREGS=\"\"\nfi\n\nif test \"x$with_lg_slab_maxregs\" != \"x\" ; then\n\nprintf \"%s\\n\" \"#define CONFIG_LG_SLAB_MAXREGS $with_lg_slab_maxregs\" >>confdefs.h\n\nfi\n\n\n# Check whether --with-lg_page was given.\nif test ${with_lg_page+y}\nthen :\n withval=$with_lg_page; LG_PAGE=\"$with_lg_page\"\nelse $as_nop\n LG_PAGE=\"detect\"\nfi\n\ncase \"${host}\" in\n aarch64-apple-darwin*)\n if test \"x${host}\" != \"x${build}\" -a \"x$LG_PAGE\" = \"xdetect\"; then\n LG_PAGE=14\n fi\n ;;\nesac\nif test \"x$LG_PAGE\" = \"xdetect\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking LG_PAGE\" >&5\nprintf %s \"checking LG_PAGE... \" >&6; }\nif test ${je_cv_lg_page+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n if test \"$cross_compiling\" = yes\nthen :\n je_cv_lg_page=12\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n#include \n\nint\nmain (void)\n{\n\n int result;\n FILE *f;\n\n#ifdef _WIN32\n SYSTEM_INFO si;\n GetSystemInfo(&si);\n result = si.dwPageSize;\n#else\n result = sysconf(_SC_PAGESIZE);\n#endif\n if (result == -1) {\n\treturn 1;\n }\n result = JEMALLOC_INTERNAL_FFSL(result) - 1;\n\n f = fopen(\"conftest.out\", \"w\");\n if (f == NULL) {\n\treturn 1;\n }\n fprintf(f, \"%d\", result);\n fclose(f);\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_run \"$LINENO\"\nthen :\n je_cv_lg_page=`cat conftest.out`\nelse $as_nop\n je_cv_lg_page=undefined\nfi\nrm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \\\n conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_lg_page\" >&5\nprintf \"%s\\n\" \"$je_cv_lg_page\" >&6; }\nfi\nif test \"x${je_cv_lg_page}\" != \"x\" ; then\n LG_PAGE=\"${je_cv_lg_page}\"\nfi\nif test \"x${LG_PAGE}\" != \"xundefined\" ; then\n\nprintf \"%s\\n\" \"#define LG_PAGE $LG_PAGE\" >>confdefs.h\n\nelse\n as_fn_error $? \"cannot determine value for LG_PAGE\" \"$LINENO\" 5\nfi\n\n\n# Check whether --with-lg_hugepage was given.\nif test ${with_lg_hugepage+y}\nthen :\n withval=$with_lg_hugepage; je_cv_lg_hugepage=\"${with_lg_hugepage}\"\nelse $as_nop\n je_cv_lg_hugepage=\"\"\nfi\n\nif test \"x${je_cv_lg_hugepage}\" = \"x\" ; then\n if test -e \"/proc/meminfo\" ; then\n hpsk=`cat /proc/meminfo 2>/dev/null | \\\n grep -e '^Hugepagesize:[[:space:]]\\+[0-9]\\+[[:space:]]kB$' | \\\n awk '{print $2}'`\n if test \"x${hpsk}\" != \"x\" ; then\n je_cv_lg_hugepage=10\n while test \"${hpsk}\" -gt 1 ; do\n hpsk=\"$((hpsk / 2))\"\n je_cv_lg_hugepage=\"$((je_cv_lg_hugepage + 1))\"\n done\n fi\n fi\n\n if test \"x${je_cv_lg_hugepage}\" = \"x\" ; then\n je_cv_lg_hugepage=21\n fi\nfi\nif test \"x${LG_PAGE}\" != \"xundefined\" -a \\\n \"${je_cv_lg_hugepage}\" -lt \"${LG_PAGE}\" ; then\n as_fn_error $? \"Huge page size (2^${je_cv_lg_hugepage}) must be at least page size (2^${LG_PAGE})\" \"$LINENO\" 5\nfi\n\nprintf \"%s\\n\" \"#define LG_HUGEPAGE ${je_cv_lg_hugepage}\" >>confdefs.h\n\n\n# Check whether --enable-libdl was given.\nif test ${enable_libdl+y}\nthen :\n enableval=$enable_libdl; if test \"x$enable_libdl\" = \"xno\" ; then\n enable_libdl=\"0\"\nelse\n enable_libdl=\"1\"\nfi\n\nelse $as_nop\n enable_libdl=\"1\"\n\nfi\n\n\n\n\nif test \"x$abi\" != \"xpecoff\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD \" >>confdefs.h\n\n for ac_header in pthread.h\ndo :\n ac_fn_c_check_header_compile \"$LINENO\" \"pthread.h\" \"ac_cv_header_pthread_h\" \"$ac_includes_default\"\nif test \"x$ac_cv_header_pthread_h\" = xyes\nthen :\n printf \"%s\\n\" \"#define HAVE_PTHREAD_H 1\" >>confdefs.h\n\nelse $as_nop\n as_fn_error $? \"pthread.h is missing\" \"$LINENO\" 5\nfi\n\ndone\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for pthread_create in -lpthread\" >&5\nprintf %s \"checking for pthread_create in -lpthread... \" >&6; }\nif test ${ac_cv_lib_pthread_pthread_create+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_check_lib_save_LIBS=$LIBS\nLIBS=\"-lpthread $LIBS\"\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar pthread_create ();\nint\nmain (void)\n{\nreturn pthread_create ();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_lib_pthread_pthread_create=yes\nelse $as_nop\n ac_cv_lib_pthread_pthread_create=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nLIBS=$ac_check_lib_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create\" >&5\nprintf \"%s\\n\" \"$ac_cv_lib_pthread_pthread_create\" >&6; }\nif test \"x$ac_cv_lib_pthread_pthread_create\" = xyes\nthen :\n T_APPEND_V=-pthread\n if test \"x${LIBS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n LIBS=\"${LIBS}${T_APPEND_V}\"\nelse\n LIBS=\"${LIBS} ${T_APPEND_V}\"\nfi\n\n\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for library containing pthread_create\" >&5\nprintf %s \"checking for library containing pthread_create... \" >&6; }\nif test ${ac_cv_search_pthread_create+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_func_search_save_LIBS=$LIBS\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar pthread_create ();\nint\nmain (void)\n{\nreturn pthread_create ();\n ;\n return 0;\n}\n_ACEOF\nfor ac_lib in ''\ndo\n if test -z \"$ac_lib\"; then\n ac_res=\"none required\"\n else\n ac_res=-l$ac_lib\n LIBS=\"-l$ac_lib $ac_func_search_save_LIBS\"\n fi\n if ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_search_pthread_create=$ac_res\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext\n if test ${ac_cv_search_pthread_create+y}\nthen :\n break\nfi\ndone\nif test ${ac_cv_search_pthread_create+y}\nthen :\n\nelse $as_nop\n ac_cv_search_pthread_create=no\nfi\nrm conftest.$ac_ext\nLIBS=$ac_func_search_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_pthread_create\" >&5\nprintf \"%s\\n\" \"$ac_cv_search_pthread_create\" >&6; }\nac_res=$ac_cv_search_pthread_create\nif test \"$ac_res\" != no\nthen :\n test \"$ac_res\" = \"none required\" || LIBS=\"$ac_res $LIBS\"\n\nelse $as_nop\n as_fn_error $? \"libpthread is missing\" \"$LINENO\" 5\nfi\n\nfi\n\n wrap_syms=\"${wrap_syms} pthread_create\"\n have_pthread=\"1\"\n\n if test \"x$enable_libdl\" = \"x1\" ; then\n have_dlsym=\"1\"\n for ac_header in dlfcn.h\ndo :\n ac_fn_c_check_header_compile \"$LINENO\" \"dlfcn.h\" \"ac_cv_header_dlfcn_h\" \"$ac_includes_default\"\nif test \"x$ac_cv_header_dlfcn_h\" = xyes\nthen :\n printf \"%s\\n\" \"#define HAVE_DLFCN_H 1\" >>confdefs.h\n ac_fn_c_check_func \"$LINENO\" \"dlsym\" \"ac_cv_func_dlsym\"\nif test \"x$ac_cv_func_dlsym\" = xyes\nthen :\n\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for dlsym in -ldl\" >&5\nprintf %s \"checking for dlsym in -ldl... \" >&6; }\nif test ${ac_cv_lib_dl_dlsym+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_check_lib_save_LIBS=$LIBS\nLIBS=\"-ldl $LIBS\"\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar dlsym ();\nint\nmain (void)\n{\nreturn dlsym ();\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_lib_dl_dlsym=yes\nelse $as_nop\n ac_cv_lib_dl_dlsym=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nLIBS=$ac_check_lib_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlsym\" >&5\nprintf \"%s\\n\" \"$ac_cv_lib_dl_dlsym\" >&6; }\nif test \"x$ac_cv_lib_dl_dlsym\" = xyes\nthen :\n LIBS=\"$LIBS -ldl\"\nelse $as_nop\n have_dlsym=\"0\"\nfi\n\nfi\n\nelse $as_nop\n have_dlsym=\"0\"\nfi\n\ndone\n if test \"x$have_dlsym\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_DLSYM \" >>confdefs.h\n\n fi\n else\n have_dlsym=\"0\"\n fi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pthread_atfork(3) is compilable\" >&5\nprintf %s \"checking whether pthread_atfork(3) is compilable... \" >&6; }\nif test ${je_cv_pthread_atfork+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n pthread_atfork((void *)0, (void *)0, (void *)0);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pthread_atfork=yes\nelse $as_nop\n je_cv_pthread_atfork=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_atfork\" >&5\nprintf \"%s\\n\" \"$je_cv_pthread_atfork\" >&6; }\n\n if test \"x${je_cv_pthread_atfork}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD_ATFORK \" >>confdefs.h\n\n fi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pthread_setname_np(3) is compilable\" >&5\nprintf %s \"checking whether pthread_setname_np(3) is compilable... \" >&6; }\nif test ${je_cv_pthread_setname_np+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n pthread_setname_np(pthread_self(), \"setname_test\");\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pthread_setname_np=yes\nelse $as_nop\n je_cv_pthread_setname_np=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_setname_np\" >&5\nprintf \"%s\\n\" \"$je_cv_pthread_setname_np\" >&6; }\n\n if test \"x${je_cv_pthread_setname_np}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD_SETNAME_NP \" >>confdefs.h\n\n fi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pthread_getname_np(3) is compilable\" >&5\nprintf %s \"checking whether pthread_getname_np(3) is compilable... \" >&6; }\nif test ${je_cv_pthread_getname_np+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n\nint\nmain (void)\n{\n\n {\n \tchar *name = malloc(16);\n \tpthread_getname_np(pthread_self(), name, 16);\n\tfree(name);\n }\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pthread_getname_np=yes\nelse $as_nop\n je_cv_pthread_getname_np=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_getname_np\" >&5\nprintf \"%s\\n\" \"$je_cv_pthread_getname_np\" >&6; }\n\n if test \"x${je_cv_pthread_getname_np}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD_GETNAME_NP \" >>confdefs.h\n\n fi\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pthread_get_name_np(3) is compilable\" >&5\nprintf %s \"checking whether pthread_get_name_np(3) is compilable... \" >&6; }\nif test ${je_cv_pthread_get_name_np+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n#include \n\nint\nmain (void)\n{\n\n {\n \tchar *name = malloc(16);\n \tpthread_get_name_np(pthread_self(), name, 16);\n\tfree(name);\n }\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pthread_get_name_np=yes\nelse $as_nop\n je_cv_pthread_get_name_np=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_get_name_np\" >&5\nprintf \"%s\\n\" \"$je_cv_pthread_get_name_np\" >&6; }\n\n if test \"x${je_cv_pthread_get_name_np}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD_GET_NAME_NP \" >>confdefs.h\n\n fi\nfi\n\nT_APPEND_V=-D_REENTRANT\n if test \"x${CPPFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CPPFLAGS=\"${CPPFLAGS}${T_APPEND_V}\"\nelse\n CPPFLAGS=\"${CPPFLAGS} ${T_APPEND_V}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime\" >&5\nprintf %s \"checking for library containing clock_gettime... \" >&6; }\nif test ${ac_cv_search_clock_gettime+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_func_search_save_LIBS=$LIBS\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar clock_gettime ();\nint\nmain (void)\n{\nreturn clock_gettime ();\n ;\n return 0;\n}\n_ACEOF\nfor ac_lib in '' rt\ndo\n if test -z \"$ac_lib\"; then\n ac_res=\"none required\"\n else\n ac_res=-l$ac_lib\n LIBS=\"-l$ac_lib $ac_func_search_save_LIBS\"\n fi\n if ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_search_clock_gettime=$ac_res\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext\n if test ${ac_cv_search_clock_gettime+y}\nthen :\n break\nfi\ndone\nif test ${ac_cv_search_clock_gettime+y}\nthen :\n\nelse $as_nop\n ac_cv_search_clock_gettime=no\nfi\nrm conftest.$ac_ext\nLIBS=$ac_func_search_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime\" >&5\nprintf \"%s\\n\" \"$ac_cv_search_clock_gettime\" >&6; }\nac_res=$ac_cv_search_clock_gettime\nif test \"$ac_res\" != no\nthen :\n test \"$ac_res\" = \"none required\" || LIBS=\"$ac_res $LIBS\"\n\nfi\n\n\nif test \"x$je_cv_cray_prgenv_wrapper\" = \"xyes\" ; then\n if test \"$ac_cv_search_clock_gettime\" != \"-lrt\"; then\n SAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n unset ac_cv_search_clock_gettime\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -dynamic\" >&5\nprintf %s \"checking whether compiler supports -dynamic... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-dynamic\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-dynamic\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime\" >&5\nprintf %s \"checking for library containing clock_gettime... \" >&6; }\nif test ${ac_cv_search_clock_gettime+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n ac_func_search_save_LIBS=$LIBS\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n/* Override any GCC internal prototype to avoid an error.\n Use char because int might match the return type of a GCC\n builtin and then its argument prototype would still apply. */\nchar clock_gettime ();\nint\nmain (void)\n{\nreturn clock_gettime ();\n ;\n return 0;\n}\n_ACEOF\nfor ac_lib in '' rt\ndo\n if test -z \"$ac_lib\"; then\n ac_res=\"none required\"\n else\n ac_res=-l$ac_lib\n LIBS=\"-l$ac_lib $ac_func_search_save_LIBS\"\n fi\n if ac_fn_c_try_link \"$LINENO\"\nthen :\n ac_cv_search_clock_gettime=$ac_res\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext\n if test ${ac_cv_search_clock_gettime+y}\nthen :\n break\nfi\ndone\nif test ${ac_cv_search_clock_gettime+y}\nthen :\n\nelse $as_nop\n ac_cv_search_clock_gettime=no\nfi\nrm conftest.$ac_ext\nLIBS=$ac_func_search_save_LIBS\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime\" >&5\nprintf \"%s\\n\" \"$ac_cv_search_clock_gettime\" >&6; }\nac_res=$ac_cv_search_clock_gettime\nif test \"$ac_res\" != no\nthen :\n test \"$ac_res\" = \"none required\" || LIBS=\"$ac_res $LIBS\"\n\nfi\n\n\n CONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n fi\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is compilable\" >&5\nprintf %s \"checking whether clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is compilable... \" >&6; }\nif test ${je_cv_clock_monotonic_coarse+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC_COARSE, &ts);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_clock_monotonic_coarse=yes\nelse $as_nop\n je_cv_clock_monotonic_coarse=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_clock_monotonic_coarse\" >&5\nprintf \"%s\\n\" \"$je_cv_clock_monotonic_coarse\" >&6; }\n\nif test \"x${je_cv_clock_monotonic_coarse}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE \" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether clock_gettime(CLOCK_MONOTONIC, ...) is compilable\" >&5\nprintf %s \"checking whether clock_gettime(CLOCK_MONOTONIC, ...) is compilable... \" >&6; }\nif test ${je_cv_clock_monotonic+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n\nint\nmain (void)\n{\n\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC, &ts);\n#if !defined(_POSIX_MONOTONIC_CLOCK) || _POSIX_MONOTONIC_CLOCK < 0\n# error _POSIX_MONOTONIC_CLOCK missing/invalid\n#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_clock_monotonic=yes\nelse $as_nop\n je_cv_clock_monotonic=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_clock_monotonic\" >&5\nprintf \"%s\\n\" \"$je_cv_clock_monotonic\" >&6; }\n\nif test \"x${je_cv_clock_monotonic}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_CLOCK_MONOTONIC \" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether mach_absolute_time() is compilable\" >&5\nprintf %s \"checking whether mach_absolute_time() is compilable... \" >&6; }\nif test ${je_cv_mach_absolute_time+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmach_absolute_time();\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_mach_absolute_time=yes\nelse $as_nop\n je_cv_mach_absolute_time=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_mach_absolute_time\" >&5\nprintf \"%s\\n\" \"$je_cv_mach_absolute_time\" >&6; }\n\nif test \"x${je_cv_mach_absolute_time}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MACH_ABSOLUTE_TIME \" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether clock_gettime(CLOCK_REALTIME, ...) is compilable\" >&5\nprintf %s \"checking whether clock_gettime(CLOCK_REALTIME, ...) is compilable... \" >&6; }\nif test ${je_cv_clock_realtime+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_REALTIME, &ts);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_clock_realtime=yes\nelse $as_nop\n je_cv_clock_realtime=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_clock_realtime\" >&5\nprintf \"%s\\n\" \"$je_cv_clock_realtime\" >&6; }\n\nif test \"x${je_cv_clock_realtime}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_CLOCK_REALTIME \" >>confdefs.h\n\nfi\n\n# Check whether --enable-syscall was given.\nif test ${enable_syscall+y}\nthen :\n enableval=$enable_syscall; if test \"x$enable_syscall\" = \"xno\" ; then\n enable_syscall=\"0\"\nelse\n enable_syscall=\"1\"\nfi\n\nelse $as_nop\n enable_syscall=\"1\"\n\nfi\n\nif test \"x$enable_syscall\" = \"x1\" ; then\n SAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether syscall(2) is compilable\" >&5\nprintf %s \"checking whether syscall(2) is compilable... \" >&6; }\nif test ${je_cv_syscall+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n\nint\nmain (void)\n{\n\n\tsyscall(SYS_write, 2, \"hello\", 5);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_syscall=yes\nelse $as_nop\n je_cv_syscall=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_syscall\" >&5\nprintf \"%s\\n\" \"$je_cv_syscall\" >&6; }\n\n CONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n if test \"x$je_cv_syscall\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_USE_SYSCALL \" >>confdefs.h\n\n fi\nfi\n\nac_fn_c_check_func \"$LINENO\" \"secure_getenv\" \"ac_cv_func_secure_getenv\"\nif test \"x$ac_cv_func_secure_getenv\" = xyes\nthen :\n have_secure_getenv=\"1\"\nelse $as_nop\n have_secure_getenv=\"0\"\n\nfi\n\nif test \"x$have_secure_getenv\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_SECURE_GETENV \" >>confdefs.h\n\nfi\n\nac_fn_c_check_func \"$LINENO\" \"sched_getcpu\" \"ac_cv_func_sched_getcpu\"\nif test \"x$ac_cv_func_sched_getcpu\" = xyes\nthen :\n have_sched_getcpu=\"1\"\nelse $as_nop\n have_sched_getcpu=\"0\"\n\nfi\n\nif test \"x$have_sched_getcpu\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_SCHED_GETCPU \" >>confdefs.h\n\nfi\n\nac_fn_c_check_func \"$LINENO\" \"sched_setaffinity\" \"ac_cv_func_sched_setaffinity\"\nif test \"x$ac_cv_func_sched_setaffinity\" = xyes\nthen :\n have_sched_setaffinity=\"1\"\nelse $as_nop\n have_sched_setaffinity=\"0\"\n\nfi\n\nif test \"x$have_sched_setaffinity\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_SCHED_SETAFFINITY \" >>confdefs.h\n\nfi\n\nac_fn_c_check_func \"$LINENO\" \"issetugid\" \"ac_cv_func_issetugid\"\nif test \"x$ac_cv_func_issetugid\" = xyes\nthen :\n have_issetugid=\"1\"\nelse $as_nop\n have_issetugid=\"0\"\n\nfi\n\nif test \"x$have_issetugid\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_ISSETUGID \" >>confdefs.h\n\nfi\n\nac_fn_c_check_func \"$LINENO\" \"_malloc_thread_cleanup\" \"ac_cv_func__malloc_thread_cleanup\"\nif test \"x$ac_cv_func__malloc_thread_cleanup\" = xyes\nthen :\n have__malloc_thread_cleanup=\"1\"\nelse $as_nop\n have__malloc_thread_cleanup=\"0\"\n\nfi\n\nif test \"x$have__malloc_thread_cleanup\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_MALLOC_THREAD_CLEANUP \" >>confdefs.h\n\n wrap_syms=\"${wrap_syms} _malloc_thread_cleanup _malloc_tsd_cleanup_register\"\n force_tls=\"1\"\nfi\n\nac_fn_c_check_func \"$LINENO\" \"_pthread_mutex_init_calloc_cb\" \"ac_cv_func__pthread_mutex_init_calloc_cb\"\nif test \"x$ac_cv_func__pthread_mutex_init_calloc_cb\" = xyes\nthen :\n have__pthread_mutex_init_calloc_cb=\"1\"\nelse $as_nop\n have__pthread_mutex_init_calloc_cb=\"0\"\n\nfi\n\nif test \"x$have__pthread_mutex_init_calloc_cb\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_MUTEX_INIT_CB \" >>confdefs.h\n\n wrap_syms=\"${wrap_syms} _malloc_prefork _malloc_postfork\"\nfi\n\nac_fn_c_check_func \"$LINENO\" \"memcntl\" \"ac_cv_func_memcntl\"\nif test \"x$ac_cv_func_memcntl\" = xyes\nthen :\n have_memcntl=\"1\"\nelse $as_nop\n have_memcntl=\"0\"\nfi\n\nif test \"x$have_memcntl\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MEMCNTL \" >>confdefs.h\n\nfi\n\n# Check whether --enable-lazy_lock was given.\nif test ${enable_lazy_lock+y}\nthen :\n enableval=$enable_lazy_lock; if test \"x$enable_lazy_lock\" = \"xno\" ; then\n enable_lazy_lock=\"0\"\nelse\n enable_lazy_lock=\"1\"\nfi\n\nelse $as_nop\n enable_lazy_lock=\"\"\n\nfi\n\nif test \"x${enable_lazy_lock}\" = \"x\" ; then\n if test \"x${force_lazy_lock}\" = \"x1\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Forcing lazy-lock to avoid allocator/threading bootstrap issues\" >&5\nprintf \"%s\\n\" \"Forcing lazy-lock to avoid allocator/threading bootstrap issues\" >&6; }\n enable_lazy_lock=\"1\"\n else\n enable_lazy_lock=\"0\"\n fi\nfi\nif test \"x${enable_lazy_lock}\" = \"x1\" -a \"x${abi}\" = \"xpecoff\" ; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: Forcing no lazy-lock because thread creation monitoring is unimplemented\" >&5\nprintf \"%s\\n\" \"Forcing no lazy-lock because thread creation monitoring is unimplemented\" >&6; }\n enable_lazy_lock=\"0\"\nfi\nif test \"x$enable_lazy_lock\" = \"x1\" ; then\n if test \"x$have_dlsym\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_LAZY_LOCK \" >>confdefs.h\n\n else\n as_fn_error $? \"Missing dlsym support: lazy-lock cannot be enabled.\" \"$LINENO\" 5\n fi\nfi\n\n\nif test \"x${force_tls}\" = \"x1\" ; then\n enable_tls=\"1\"\nelif test \"x${force_tls}\" = \"x0\" ; then\n enable_tls=\"0\"\nelse\n enable_tls=\"1\"\nfi\nif test \"x${enable_tls}\" = \"x1\" ; then\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for TLS\" >&5\nprintf %s \"checking for TLS... \" >&6; }\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n __thread int x;\n\nint\nmain (void)\n{\n\n x = 42;\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n enable_tls=\"0\"\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nelse\n enable_tls=\"0\"\nfi\n\nif test \"x${enable_tls}\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_TLS \" >>confdefs.h\n\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether C11 atomics is compilable\" >&5\nprintf %s \"checking whether C11 atomics is compilable... \" >&6; }\nif test ${je_cv_c11_atomics+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#if (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)\n#include \n#else\n#error Atomics not available\n#endif\n\nint\nmain (void)\n{\n\n uint64_t *p = (uint64_t *)0;\n uint64_t x = 1;\n volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p;\n uint64_t r = atomic_fetch_add(a, x) + x;\n return r == 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_c11_atomics=yes\nelse $as_nop\n je_cv_c11_atomics=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_c11_atomics\" >&5\nprintf \"%s\\n\" \"$je_cv_c11_atomics\" >&6; }\n\nif test \"x${je_cv_c11_atomics}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_C11_ATOMICS \" >>confdefs.h\n\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether GCC __atomic atomics is compilable\" >&5\nprintf %s \"checking whether GCC __atomic atomics is compilable... \" >&6; }\nif test ${je_cv_gcc_atomic_atomics+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n int x = 0;\n int val = 1;\n int y = __atomic_fetch_add(&x, val, __ATOMIC_RELAXED);\n int after_add = x;\n return after_add == 1;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_atomic_atomics=yes\nelse $as_nop\n je_cv_gcc_atomic_atomics=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_atomic_atomics\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_atomic_atomics\" >&6; }\n\nif test \"x${je_cv_gcc_atomic_atomics}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GCC_ATOMIC_ATOMICS \" >>confdefs.h\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether GCC 8-bit __atomic atomics is compilable\" >&5\nprintf %s \"checking whether GCC 8-bit __atomic atomics is compilable... \" >&6; }\nif test ${je_cv_gcc_u8_atomic_atomics+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n unsigned char x = 0;\n int val = 1;\n int y = __atomic_fetch_add(&x, val, __ATOMIC_RELAXED);\n int after_add = (int)x;\n return after_add == 1;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_u8_atomic_atomics=yes\nelse $as_nop\n je_cv_gcc_u8_atomic_atomics=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_u8_atomic_atomics\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_u8_atomic_atomics\" >&6; }\n\n if test \"x${je_cv_gcc_u8_atomic_atomics}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GCC_U8_ATOMIC_ATOMICS \" >>confdefs.h\n\n fi\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether GCC __sync atomics is compilable\" >&5\nprintf %s \"checking whether GCC __sync atomics is compilable... \" >&6; }\nif test ${je_cv_gcc_sync_atomics+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n int x = 0;\n int before_add = __sync_fetch_and_add(&x, 1);\n int after_add = x;\n return (before_add == 0) && (after_add == 1);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_sync_atomics=yes\nelse $as_nop\n je_cv_gcc_sync_atomics=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_sync_atomics\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_sync_atomics\" >&6; }\n\nif test \"x${je_cv_gcc_sync_atomics}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GCC_SYNC_ATOMICS \" >>confdefs.h\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether GCC 8-bit __sync atomics is compilable\" >&5\nprintf %s \"checking whether GCC 8-bit __sync atomics is compilable... \" >&6; }\nif test ${je_cv_gcc_u8_sync_atomics+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n unsigned char x = 0;\n int before_add = __sync_fetch_and_add(&x, 1);\n int after_add = (int)x;\n return (before_add == 0) && (after_add == 1);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_gcc_u8_sync_atomics=yes\nelse $as_nop\n je_cv_gcc_u8_sync_atomics=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_u8_sync_atomics\" >&5\nprintf \"%s\\n\" \"$je_cv_gcc_u8_sync_atomics\" >&6; }\n\n if test \"x${je_cv_gcc_u8_sync_atomics}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GCC_U8_SYNC_ATOMICS \" >>confdefs.h\n\n fi\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether Darwin OSAtomic*() is compilable\" >&5\nprintf %s \"checking whether Darwin OSAtomic*() is compilable... \" >&6; }\nif test ${je_cv_osatomic+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n\nint\nmain (void)\n{\n\n\t{\n\t\tint32_t x32 = 0;\n\t\tvolatile int32_t *x32p = &x32;\n\t\tOSAtomicAdd32(1, x32p);\n\t}\n\t{\n\t\tint64_t x64 = 0;\n\t\tvolatile int64_t *x64p = &x64;\n\t\tOSAtomicAdd64(1, x64p);\n\t}\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_osatomic=yes\nelse $as_nop\n je_cv_osatomic=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_osatomic\" >&5\nprintf \"%s\\n\" \"$je_cv_osatomic\" >&6; }\n\nif test \"x${je_cv_osatomic}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_OSATOMIC \" >>confdefs.h\n\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(2) is compilable\" >&5\nprintf %s \"checking whether madvise(2) is compilable... \" >&6; }\nif test ${je_cv_madvise+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, 0);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_madvise=yes\nelse $as_nop\n je_cv_madvise=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_madvise\" >&5\nprintf \"%s\\n\" \"$je_cv_madvise\" >&6; }\n\nif test \"x${je_cv_madvise}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MADVISE \" >>confdefs.h\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_FREE) is compilable\" >&5\nprintf %s \"checking whether madvise(..., MADV_FREE) is compilable... \" >&6; }\nif test ${je_cv_madv_free+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, MADV_FREE);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_madv_free=yes\nelse $as_nop\n je_cv_madv_free=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_free\" >&5\nprintf \"%s\\n\" \"$je_cv_madv_free\" >&6; }\n\n if test \"x${je_cv_madv_free}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_MADVISE_FREE \" >>confdefs.h\n\n elif test \"x${je_cv_madvise}\" = \"xyes\" ; then\n case \"${host_cpu}\" in i686|x86_64)\n case \"${host}\" in *-*-linux*)\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_MADVISE_FREE \" >>confdefs.h\n\n\nprintf \"%s\\n\" \"#define JEMALLOC_DEFINE_MADVISE_FREE \" >>confdefs.h\n\n\t ;;\n esac\n ;;\n esac\n fi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_DONTNEED) is compilable\" >&5\nprintf %s \"checking whether madvise(..., MADV_DONTNEED) is compilable... \" >&6; }\nif test ${je_cv_madv_dontneed+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, MADV_DONTNEED);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_madv_dontneed=yes\nelse $as_nop\n je_cv_madv_dontneed=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_dontneed\" >&5\nprintf \"%s\\n\" \"$je_cv_madv_dontneed\" >&6; }\n\n if test \"x${je_cv_madv_dontneed}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_MADVISE_DONTNEED \" >>confdefs.h\n\n fi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_DO[NT]DUMP) is compilable\" >&5\nprintf %s \"checking whether madvise(..., MADV_DO[NT]DUMP) is compilable... \" >&6; }\nif test ${je_cv_madv_dontdump+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, MADV_DONTDUMP);\n\tmadvise((void *)0, 0, MADV_DODUMP);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_madv_dontdump=yes\nelse $as_nop\n je_cv_madv_dontdump=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_dontdump\" >&5\nprintf \"%s\\n\" \"$je_cv_madv_dontdump\" >&6; }\n\n if test \"x${je_cv_madv_dontdump}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_MADVISE_DONTDUMP \" >>confdefs.h\n\n fi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_[NO]HUGEPAGE) is compilable\" >&5\nprintf %s \"checking whether madvise(..., MADV_[NO]HUGEPAGE) is compilable... \" >&6; }\nif test ${je_cv_thp+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, MADV_HUGEPAGE);\n\tmadvise((void *)0, 0, MADV_NOHUGEPAGE);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_thp=yes\nelse $as_nop\n je_cv_thp=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_thp\" >&5\nprintf \"%s\\n\" \"$je_cv_thp\" >&6; }\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_[NO]CORE) is compilable\" >&5\nprintf %s \"checking whether madvise(..., MADV_[NO]CORE) is compilable... \" >&6; }\nif test ${je_cv_madv_nocore+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmadvise((void *)0, 0, MADV_NOCORE);\n\tmadvise((void *)0, 0, MADV_CORE);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_madv_nocore=yes\nelse $as_nop\n je_cv_madv_nocore=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_nocore\" >&5\nprintf \"%s\\n\" \"$je_cv_madv_nocore\" >&6; }\n\n if test \"x${je_cv_madv_nocore}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_MADVISE_NOCORE \" >>confdefs.h\n\n fi\ncase \"${host_cpu}\" in\n arm*)\n ;;\n *)\n if test \"x${je_cv_thp}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MADVISE_HUGE \" >>confdefs.h\n\n fi\n ;;\nesac\nelse\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether posix_madvise is compilable\" >&5\nprintf %s \"checking whether posix_madvise is compilable... \" >&6; }\nif test ${je_cv_posix_madvise+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n\nint\nmain (void)\n{\n\n posix_madvise((void *)0, 0, 0);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_posix_madvise=yes\nelse $as_nop\n je_cv_posix_madvise=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_posix_madvise\" >&5\nprintf \"%s\\n\" \"$je_cv_posix_madvise\" >&6; }\n\n if test \"x${je_cv_posix_madvise}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_POSIX_MADVISE \" >>confdefs.h\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether posix_madvise(..., POSIX_MADV_DONTNEED) is compilable\" >&5\nprintf %s \"checking whether posix_madvise(..., POSIX_MADV_DONTNEED) is compilable... \" >&6; }\nif test ${je_cv_posix_madv_dontneed+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n\nint\nmain (void)\n{\n\n posix_madvise((void *)0, 0, POSIX_MADV_DONTNEED);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_posix_madv_dontneed=yes\nelse $as_nop\n je_cv_posix_madv_dontneed=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_posix_madv_dontneed\" >&5\nprintf \"%s\\n\" \"$je_cv_posix_madv_dontneed\" >&6; }\n\n if test \"x${je_cv_posix_madv_dontneed}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED \" >>confdefs.h\n\n fi\n fi\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether mprotect(2) is compilable\" >&5\nprintf %s \"checking whether mprotect(2) is compilable... \" >&6; }\nif test ${je_cv_mprotect+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n\tmprotect((void *)0, 0, PROT_NONE);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_mprotect=yes\nelse $as_nop\n je_cv_mprotect=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_mprotect\" >&5\nprintf \"%s\\n\" \"$je_cv_mprotect\" >&6; }\n\nif test \"x${je_cv_mprotect}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_MPROTECT \" >>confdefs.h\n\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for __builtin_clz\" >&5\nprintf %s \"checking for __builtin_clz... \" >&6; }\nif test ${je_cv_builtin_clz+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\nint\nmain (void)\n{\n\n {\n unsigned x = 0;\n int y = __builtin_clz(x);\n }\n {\n unsigned long x = 0;\n int y = __builtin_clzl(x);\n }\n {\n unsigned long long x = 0;\n int y = __builtin_clzll(x);\n }\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_builtin_clz=yes\nelse $as_nop\n je_cv_builtin_clz=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_builtin_clz\" >&5\nprintf \"%s\\n\" \"$je_cv_builtin_clz\" >&6; }\n\nif test \"x${je_cv_builtin_clz}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_BUILTIN_CLZ \" >>confdefs.h\n\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether Darwin os_unfair_lock_*() is compilable\" >&5\nprintf %s \"checking whether Darwin os_unfair_lock_*() is compilable... \" >&6; }\nif test ${je_cv_os_unfair_lock+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n\nint\nmain (void)\n{\n\n\t#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200\n\t#error \"os_unfair_lock is not supported\"\n\t#else\n\tos_unfair_lock lock = OS_UNFAIR_LOCK_INIT;\n\tos_unfair_lock_lock(&lock);\n\tos_unfair_lock_unlock(&lock);\n\t#endif\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_os_unfair_lock=yes\nelse $as_nop\n je_cv_os_unfair_lock=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_os_unfair_lock\" >&5\nprintf \"%s\\n\" \"$je_cv_os_unfair_lock\" >&6; }\n\nif test \"x${je_cv_os_unfair_lock}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_OS_UNFAIR_LOCK \" >>confdefs.h\n\nfi\n\n\n# Check whether --enable-zone-allocator was given.\nif test ${enable_zone_allocator+y}\nthen :\n enableval=$enable_zone_allocator; if test \"x$enable_zone_allocator\" = \"xno\" ; then\n enable_zone_allocator=\"0\"\nelse\n enable_zone_allocator=\"1\"\nfi\n\nelse $as_nop\n if test \"x${abi}\" = \"xmacho\"; then\n enable_zone_allocator=\"1\"\nfi\n\n\nfi\n\n\n\nif test \"x${enable_zone_allocator}\" = \"x1\" ; then\n if test \"x${abi}\" != \"xmacho\"; then\n as_fn_error $? \"--enable-zone-allocator is only supported on Darwin\" \"$LINENO\" 5\n fi\n\nprintf \"%s\\n\" \"#define JEMALLOC_ZONE \" >>confdefs.h\n\nfi\n\n# Check whether --enable-initial-exec-tls was given.\nif test ${enable_initial_exec_tls+y}\nthen :\n enableval=$enable_initial_exec_tls; if test \"x$enable_initial_exec_tls\" = \"xno\" ; then\n enable_initial_exec_tls=\"0\"\nelse\n enable_initial_exec_tls=\"1\"\nfi\n\nelse $as_nop\n enable_initial_exec_tls=\"1\"\n\nfi\n\n\n\nif test \"x${je_cv_tls_model}\" = \"xyes\" -a \\\n \"x${enable_initial_exec_tls}\" = \"x1\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_TLS_MODEL __attribute__((tls_model(\\\"initial-exec\\\")))\" >>confdefs.h\n\nelse\n\nprintf \"%s\\n\" \"#define JEMALLOC_TLS_MODEL \" >>confdefs.h\n\nfi\n\n\nif test \"x${have_pthread}\" = \"x1\" -a \"x${je_cv_os_unfair_lock}\" != \"xyes\" -a \\\n \"x${abi}\" != \"xmacho\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_BACKGROUND_THREAD \" >>confdefs.h\n\nfi\n\n\nif test \"x$glibc\" = \"x1\" ; then\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether glibc malloc hook is compilable\" >&5\nprintf %s \"checking whether glibc malloc hook is compilable... \" >&6; }\nif test ${je_cv_glibc_malloc_hook+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n\n extern void (* __free_hook)(void *ptr);\n extern void *(* __malloc_hook)(size_t size);\n extern void *(* __realloc_hook)(void *ptr, size_t size);\n\nint\nmain (void)\n{\n\n void *ptr = 0L;\n if (__malloc_hook) ptr = __malloc_hook(1);\n if (__realloc_hook) ptr = __realloc_hook(ptr, 2);\n if (__free_hook && ptr) __free_hook(ptr);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_glibc_malloc_hook=yes\nelse $as_nop\n je_cv_glibc_malloc_hook=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_glibc_malloc_hook\" >&5\nprintf \"%s\\n\" \"$je_cv_glibc_malloc_hook\" >&6; }\n\n if test \"x${je_cv_glibc_malloc_hook}\" = \"xyes\" ; then\n if test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GLIBC_MALLOC_HOOK \" >>confdefs.h\n\n wrap_syms=\"${wrap_syms} __free_hook __malloc_hook __realloc_hook\"\n fi\n fi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether glibc memalign hook is compilable\" >&5\nprintf %s \"checking whether glibc memalign hook is compilable... \" >&6; }\nif test ${je_cv_glibc_memalign_hook+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n #include \n\n extern void *(* __memalign_hook)(size_t alignment, size_t size);\n\nint\nmain (void)\n{\n\n void *ptr = 0L;\n if (__memalign_hook) ptr = __memalign_hook(16, 7);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_glibc_memalign_hook=yes\nelse $as_nop\n je_cv_glibc_memalign_hook=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_glibc_memalign_hook\" >&5\nprintf \"%s\\n\" \"$je_cv_glibc_memalign_hook\" >&6; }\n\n if test \"x${je_cv_glibc_memalign_hook}\" = \"xyes\" ; then\n if test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_GLIBC_MEMALIGN_HOOK \" >>confdefs.h\n\n wrap_syms=\"${wrap_syms} __memalign_hook\"\n fi\n fi\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether pthreads adaptive mutexes is compilable\" >&5\nprintf %s \"checking whether pthreads adaptive mutexes is compilable... \" >&6; }\nif test ${je_cv_pthread_mutex_adaptive_np+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n\nint\nmain (void)\n{\n\n pthread_mutexattr_t attr;\n pthread_mutexattr_init(&attr);\n pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);\n pthread_mutexattr_destroy(&attr);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_pthread_mutex_adaptive_np=yes\nelse $as_nop\n je_cv_pthread_mutex_adaptive_np=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_mutex_adaptive_np\" >&5\nprintf \"%s\\n\" \"$je_cv_pthread_mutex_adaptive_np\" >&6; }\n\nif test \"x${je_cv_pthread_mutex_adaptive_np}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP \" >>confdefs.h\n\nfi\n\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -D_GNU_SOURCE\" >&5\nprintf %s \"checking whether compiler supports -D_GNU_SOURCE... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-D_GNU_SOURCE\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-D_GNU_SOURCE\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror\" >&5\nprintf %s \"checking whether compiler supports -Werror... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-Werror\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-Werror\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning\" >&5\nprintf %s \"checking whether compiler supports -herror_on_warning... \" >&6; }\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nT_APPEND_V=-herror_on_warning\n if test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${T_APPEND_V}\" = \"x\" ; then\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}${T_APPEND_V}\"\nelse\n CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS} ${T_APPEND_V}\"\nfi\n\n\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\ncat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n\nint\nmain (void)\n{\n\n return 0;\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n je_cv_cflags_added=-herror_on_warning\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: yes\" >&5\nprintf \"%s\\n\" \"yes\" >&6; }\nelse $as_nop\n je_cv_cflags_added=\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: no\" >&5\nprintf \"%s\\n\" \"no\" >&6; }\n CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"\n\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking whether strerror_r returns char with gnu source is compilable\" >&5\nprintf %s \"checking whether strerror_r returns char with gnu source is compilable... \" >&6; }\nif test ${je_cv_strerror_r_returns_char_with_gnu_source+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n\n#include \n#include \n#include \n#include \n\nint\nmain (void)\n{\n\n char *buffer = (char *) malloc(100);\n char *error = strerror_r(EINVAL, buffer, 100);\n printf(\"%s\\n\", error);\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_link \"$LINENO\"\nthen :\n je_cv_strerror_r_returns_char_with_gnu_source=yes\nelse $as_nop\n je_cv_strerror_r_returns_char_with_gnu_source=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam \\\n conftest$ac_exeext conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $je_cv_strerror_r_returns_char_with_gnu_source\" >&5\nprintf \"%s\\n\" \"$je_cv_strerror_r_returns_char_with_gnu_source\" >&6; }\n\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nif test \"x${CONFIGURE_CFLAGS}\" = \"x\" -o \"x${SPECIFIED_CFLAGS}\" = \"x\" ; then\n CFLAGS=\"${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}\"\nelse\n CFLAGS=\"${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}\"\nfi\n\n\nif test \"x${je_cv_strerror_r_returns_char_with_gnu_source}\" = \"xyes\" ; then\n\nprintf \"%s\\n\" \"#define JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE \" >>confdefs.h\n\nfi\n\nac_fn_c_check_type \"$LINENO\" \"_Bool\" \"ac_cv_type__Bool\" \"$ac_includes_default\"\nif test \"x$ac_cv_type__Bool\" = xyes\nthen :\n\nprintf \"%s\\n\" \"#define HAVE__BOOL 1\" >>confdefs.h\n\n\nfi\n\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99\" >&5\nprintf %s \"checking for stdbool.h that conforms to C99... \" >&6; }\nif test ${ac_cv_header_stdbool_h+y}\nthen :\n printf %s \"(cached) \" >&6\nelse $as_nop\n cat confdefs.h - <<_ACEOF >conftest.$ac_ext\n/* end confdefs.h. */\n#include \n\n #ifndef __bool_true_false_are_defined\n #error \"__bool_true_false_are_defined is not defined\"\n #endif\n char a[__bool_true_false_are_defined == 1 ? 1 : -1];\n\n /* Regardless of whether this is C++ or \"_Bool\" is a\n valid type name, \"true\" and \"false\" should be usable\n in #if expressions and integer constant expressions,\n and \"bool\" should be a valid type name. */\n\n #if !true\n #error \"'true' is not true\"\n #endif\n #if true != 1\n #error \"'true' is not equal to 1\"\n #endif\n char b[true == 1 ? 1 : -1];\n char c[true];\n\n #if false\n #error \"'false' is not false\"\n #endif\n #if false != 0\n #error \"'false' is not equal to 0\"\n #endif\n char d[false == 0 ? 1 : -1];\n\n enum { e = false, f = true, g = false * true, h = true * 256 };\n\n char i[(bool) 0.5 == true ? 1 : -1];\n char j[(bool) 0.0 == false ? 1 : -1];\n char k[sizeof (bool) > 0 ? 1 : -1];\n\n struct sb { bool s: 1; bool t; } s;\n char l[sizeof s.t > 0 ? 1 : -1];\n\n /* The following fails for\n HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */\n bool m[h];\n char n[sizeof m == h * sizeof m[0] ? 1 : -1];\n char o[-1 - (bool) 0 < 0 ? 1 : -1];\n /* Catch a bug in an HP-UX C compiler. See\n https://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html\n https://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html\n */\n bool p = true;\n bool *pp = &p;\n\n /* C 1999 specifies that bool, true, and false are to be\n macros, but C++ 2011 and later overrule this. */\n #if __cplusplus < 201103\n #ifndef bool\n #error \"bool is not defined\"\n #endif\n #ifndef false\n #error \"false is not defined\"\n #endif\n #ifndef true\n #error \"true is not defined\"\n #endif\n #endif\n\n /* If _Bool is available, repeat with it all the tests\n above that used bool. */\n #ifdef HAVE__BOOL\n struct sB { _Bool s: 1; _Bool t; } t;\n\n char q[(_Bool) 0.5 == true ? 1 : -1];\n char r[(_Bool) 0.0 == false ? 1 : -1];\n char u[sizeof (_Bool) > 0 ? 1 : -1];\n char v[sizeof t.t > 0 ? 1 : -1];\n\n _Bool w[h];\n char x[sizeof m == h * sizeof m[0] ? 1 : -1];\n char y[-1 - (_Bool) 0 < 0 ? 1 : -1];\n _Bool z = true;\n _Bool *pz = &p;\n #endif\n\nint\nmain (void)\n{\n\n bool ps = &s;\n *pp |= p;\n *pp |= ! p;\n\n #ifdef HAVE__BOOL\n _Bool pt = &t;\n *pz |= z;\n *pz |= ! z;\n #endif\n\n /* Refer to every declared value, so they cannot be\n discarded as unused. */\n return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !j + !k\n + !l + !m + !n + !o + !p + !pp + !ps\n #ifdef HAVE__BOOL\n + !q + !r + !u + !v + !w + !x + !y + !z + !pt\n #endif\n );\n\n ;\n return 0;\n}\n_ACEOF\nif ac_fn_c_try_compile \"$LINENO\"\nthen :\n ac_cv_header_stdbool_h=yes\nelse $as_nop\n ac_cv_header_stdbool_h=no\nfi\nrm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext\nfi\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h\" >&5\nprintf \"%s\\n\" \"$ac_cv_header_stdbool_h\" >&6; }\n\nif test $ac_cv_header_stdbool_h = yes; then\n\nprintf \"%s\\n\" \"#define HAVE_STDBOOL_H 1\" >>confdefs.h\n\nfi\n\n\n\nac_config_commands=\"$ac_config_commands include/jemalloc/internal/public_symbols.txt\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/internal/private_symbols.awk\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/internal/private_symbols_jet.awk\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/internal/public_namespace.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/internal/public_unnamespace.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/jemalloc_protos_jet.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/jemalloc_rename.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/jemalloc_mangle.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/jemalloc_mangle_jet.h\"\n\nac_config_commands=\"$ac_config_commands include/jemalloc/jemalloc.h\"\n\n\n\n\nac_config_headers=\"$ac_config_headers $cfghdrs_tup\"\n\n\n\nac_config_files=\"$ac_config_files $cfgoutputs_tup config.stamp bin/jemalloc-config bin/jemalloc.sh bin/jeprof\"\n\n\n\ncat >confcache <<\\_ACEOF\n# This file is a shell script that caches the results of configure\n# tests run on this system so they can be shared between configure\n# scripts and configure runs, see configure's option --config-cache.\n# It is not useful on other systems. If it contains results you don't\n# want to keep, you may remove or edit it.\n#\n# config.status only pays attention to the cache file if you give it\n# the --recheck option to rerun configure.\n#\n# `ac_cv_env_foo' variables (set or unset) will be overridden when\n# loading this file, other *unset* `ac_cv_foo' will be assigned the\n# following values.\n\n_ACEOF\n\n# The following way of writing the cache mishandles newlines in values,\n# but we know of no workaround that is simple, portable, and efficient.\n# So, we kill variables containing newlines.\n# Ultrix sh set writes to stderr and can't be redirected directly,\n# and sets the high bit in the cache file unless we assign to the vars.\n(\n for ac_var in `(set) 2>&1 | sed -n 's/^\\([a-zA-Z_][a-zA-Z0-9_]*\\)=.*/\\1/p'`; do\n eval ac_val=\\$$ac_var\n case $ac_val in #(\n *${as_nl}*)\n case $ac_var in #(\n *_cv_*) { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: cache variable $ac_var contains a newline\" >&2;} ;;\n esac\n case $ac_var in #(\n _ | IFS | as_nl) ;; #(\n BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(\n *) { eval $ac_var=; unset $ac_var;} ;;\n esac ;;\n esac\n done\n\n (set) 2>&1 |\n case $as_nl`(ac_space=' '; set) 2>&1` in #(\n *${as_nl}ac_space=\\ *)\n # `set' does not quote correctly, so add quotes: double-quote\n # substitution turns \\\\\\\\ into \\\\, and sed turns \\\\ into \\.\n sed -n \\\n\t\"s/'/'\\\\\\\\''/g;\n\t s/^\\\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\\\)=\\\\(.*\\\\)/\\\\1='\\\\2'/p\"\n ;; #(\n *)\n # `set' quotes correctly as required by POSIX, so do not add quotes.\n sed -n \"/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p\"\n ;;\n esac |\n sort\n) |\n sed '\n /^ac_cv_env_/b end\n t clear\n :clear\n s/^\\([^=]*\\)=\\(.*[{}].*\\)$/test ${\\1+y} || &/\n t end\n s/^\\([^=]*\\)=\\(.*\\)$/\\1=${\\1=\\2}/\n :end' >>confcache\nif diff \"$cache_file\" confcache >/dev/null 2>&1; then :; else\n if test -w \"$cache_file\"; then\n if test \"x$cache_file\" != \"x/dev/null\"; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: updating cache $cache_file\" >&5\nprintf \"%s\\n\" \"$as_me: updating cache $cache_file\" >&6;}\n if test ! -f \"$cache_file\" || test -h \"$cache_file\"; then\n\tcat confcache >\"$cache_file\"\n else\n case $cache_file in #(\n */* | ?:*)\n\t mv -f confcache \"$cache_file\"$$ &&\n\t mv -f \"$cache_file\"$$ \"$cache_file\" ;; #(\n *)\n\t mv -f confcache \"$cache_file\" ;;\n\tesac\n fi\n fi\n else\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file\" >&5\nprintf \"%s\\n\" \"$as_me: not updating unwritable cache $cache_file\" >&6;}\n fi\nfi\nrm -f confcache\n\ntest \"x$prefix\" = xNONE && prefix=$ac_default_prefix\n# Let make expand exec_prefix.\ntest \"x$exec_prefix\" = xNONE && exec_prefix='${prefix}'\n\nDEFS=-DHAVE_CONFIG_H\n\nac_libobjs=\nac_ltlibobjs=\nU=\nfor ac_i in : $LIBOBJS; do test \"x$ac_i\" = x: && continue\n # 1. Remove the extension, and $U if already installed.\n ac_script='s/\\$U\\././;s/\\.o$//;s/\\.obj$//'\n ac_i=`printf \"%s\\n\" \"$ac_i\" | sed \"$ac_script\"`\n # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR\n # will be set to the directory where LIBOBJS objects are built.\n as_fn_append ac_libobjs \" \\${LIBOBJDIR}$ac_i\\$U.$ac_objext\"\n as_fn_append ac_ltlibobjs \" \\${LIBOBJDIR}$ac_i\"'$U.lo'\ndone\nLIBOBJS=$ac_libobjs\n\nLTLIBOBJS=$ac_ltlibobjs\n\n\n\n\n: \"${CONFIG_STATUS=./config.status}\"\nac_write_fail=0\nac_clean_files_save=$ac_clean_files\nac_clean_files=\"$ac_clean_files $CONFIG_STATUS\"\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS\" >&5\nprintf \"%s\\n\" \"$as_me: creating $CONFIG_STATUS\" >&6;}\nas_write_fail=0\ncat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1\n#! $SHELL\n# Generated by $as_me.\n# Run this file to recreate the current configuration.\n# Compiler output produced by configure, useful for debugging\n# configure, is in config.log if it exists.\n\ndebug=false\nac_cs_recheck=false\nac_cs_silent=false\n\nSHELL=\\${CONFIG_SHELL-$SHELL}\nexport SHELL\n_ASEOF\ncat >>$CONFIG_STATUS <<\\_ASEOF || as_write_fail=1\n## -------------------- ##\n## M4sh Initialization. ##\n## -------------------- ##\n\n# Be more Bourne compatible\nDUALCASE=1; export DUALCASE # for MKS sh\nas_nop=:\nif test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1\nthen :\n emulate sh\n NULLCMD=:\n # Pre-4.2 versions of Zsh do word splitting on ${1+\"$@\"}, which\n # is contrary to our usage. Disable this feature.\n alias -g '${1+\"$@\"}'='\"$@\"'\n setopt NO_GLOB_SUBST\nelse $as_nop\n case `(set -o) 2>/dev/null` in #(\n *posix*) :\n set -o posix ;; #(\n *) :\n ;;\nesac\nfi\n\n\n\n# Reset variables that may have inherited troublesome values from\n# the environment.\n\n# IFS needs to be set, to space, tab, and newline, in precisely that order.\n# (If _AS_PATH_WALK were called with IFS unset, it would have the\n# side effect of setting IFS to empty, thus disabling word splitting.)\n# Quoting is to prevent editors from complaining about space-tab.\nas_nl='\n'\nexport as_nl\nIFS=\" \"\"\t$as_nl\"\n\nPS1='$ '\nPS2='> '\nPS4='+ '\n\n# Ensure predictable behavior from utilities with locale-dependent output.\nLC_ALL=C\nexport LC_ALL\nLANGUAGE=C\nexport LANGUAGE\n\n# We cannot yet rely on \"unset\" to work, but we need these variables\n# to be unset--not just set to an empty or harmless value--now, to\n# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct\n# also avoids known problems related to \"unset\" and subshell syntax\n# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).\nfor as_var in BASH_ENV ENV MAIL MAILPATH CDPATH\ndo eval test \\${$as_var+y} \\\n && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :\ndone\n\n# Ensure that fds 0, 1, and 2 are open.\nif (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi\nif (exec 3>&2) ; then :; else exec 2>/dev/null; fi\n\n# The user is always right.\nif ${PATH_SEPARATOR+false} :; then\n PATH_SEPARATOR=:\n (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {\n (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||\n PATH_SEPARATOR=';'\n }\nfi\n\n\n# Find who we are. Look in the path if we contain no directory separator.\nas_myself=\ncase $0 in #((\n *[\\\\/]* ) as_myself=$0 ;;\n *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR\nfor as_dir in $PATH\ndo\n IFS=$as_save_IFS\n case $as_dir in #(((\n '') as_dir=./ ;;\n */) ;;\n *) as_dir=$as_dir/ ;;\n esac\n test -r \"$as_dir$0\" && as_myself=$as_dir$0 && break\n done\nIFS=$as_save_IFS\n\n ;;\nesac\n# We did not find ourselves, most probably we were run as `sh COMMAND'\n# in which case we are not to be found in the path.\nif test \"x$as_myself\" = x; then\n as_myself=$0\nfi\nif test ! -f \"$as_myself\"; then\n printf \"%s\\n\" \"$as_myself: error: cannot find myself; rerun with an absolute file name\" >&2\n exit 1\nfi\n\n\n\n# as_fn_error STATUS ERROR [LINENO LOG_FD]\n# ----------------------------------------\n# Output \"`basename $0`: error: ERROR\" to stderr. If LINENO and LOG_FD are\n# provided, also output the error to LOG_FD, referencing LINENO. Then exit the\n# script with STATUS, using 1 if that was 0.\nas_fn_error ()\n{\n as_status=$1; test $as_status -eq 0 && as_status=1\n if test \"$4\"; then\n as_lineno=${as_lineno-\"$3\"} as_lineno_stack=as_lineno_stack=$as_lineno_stack\n printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: error: $2\" >&$4\n fi\n printf \"%s\\n\" \"$as_me: error: $2\" >&2\n as_fn_exit $as_status\n} # as_fn_error\n\n\n\n# as_fn_set_status STATUS\n# -----------------------\n# Set $? to STATUS, without forking.\nas_fn_set_status ()\n{\n return $1\n} # as_fn_set_status\n\n# as_fn_exit STATUS\n# -----------------\n# Exit the shell with STATUS, even in a \"trap 0\" or \"set -e\" context.\nas_fn_exit ()\n{\n set +e\n as_fn_set_status $1\n exit $1\n} # as_fn_exit\n\n# as_fn_unset VAR\n# ---------------\n# Portably unset VAR.\nas_fn_unset ()\n{\n { eval $1=; unset $1;}\n}\nas_unset=as_fn_unset\n\n# as_fn_append VAR VALUE\n# ----------------------\n# Append the text in VALUE to the end of the definition contained in VAR. Take\n# advantage of any shell optimizations that allow amortized linear growth over\n# repeated appends, instead of the typical quadratic growth present in naive\n# implementations.\nif (eval \"as_var=1; as_var+=2; test x\\$as_var = x12\") 2>/dev/null\nthen :\n eval 'as_fn_append ()\n {\n eval $1+=\\$2\n }'\nelse $as_nop\n as_fn_append ()\n {\n eval $1=\\$$1\\$2\n }\nfi # as_fn_append\n\n# as_fn_arith ARG...\n# ------------------\n# Perform arithmetic evaluation on the ARGs, and store the result in the\n# global $as_val. Take advantage of shells that can avoid forks. The arguments\n# must be portable across $(()) and expr.\nif (eval \"test \\$(( 1 + 1 )) = 2\") 2>/dev/null\nthen :\n eval 'as_fn_arith ()\n {\n as_val=$(( $* ))\n }'\nelse $as_nop\n as_fn_arith ()\n {\n as_val=`expr \"$@\" || test $? -eq 1`\n }\nfi # as_fn_arith\n\n\nif expr a : '\\(a\\)' >/dev/null 2>&1 &&\n test \"X`expr 00001 : '.*\\(...\\)'`\" = X001; then\n as_expr=expr\nelse\n as_expr=false\nfi\n\nif (basename -- /) >/dev/null 2>&1 && test \"X`basename -- / 2>&1`\" = \"X/\"; then\n as_basename=basename\nelse\n as_basename=false\nfi\n\nif (as_dir=`dirname -- /` && test \"X$as_dir\" = X/) >/dev/null 2>&1; then\n as_dirname=dirname\nelse\n as_dirname=false\nfi\n\nas_me=`$as_basename -- \"$0\" ||\n$as_expr X/\"$0\" : '.*/\\([^/][^/]*\\)/*$' \\| \\\n\t X\"$0\" : 'X\\(//\\)$' \\| \\\n\t X\"$0\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X/\"$0\" |\n sed '/^.*\\/\\([^/][^/]*\\)\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\/\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\/\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n\n# Avoid depending upon Character Ranges.\nas_cr_letters='abcdefghijklmnopqrstuvwxyz'\nas_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'\nas_cr_Letters=$as_cr_letters$as_cr_LETTERS\nas_cr_digits='0123456789'\nas_cr_alnum=$as_cr_Letters$as_cr_digits\n\n\n# Determine whether it's possible to make 'echo' print without a newline.\n# These variables are no longer used directly by Autoconf, but are AC_SUBSTed\n# for compatibility with existing Makefiles.\nECHO_C= ECHO_N= ECHO_T=\ncase `echo -n x` in #(((((\n-n*)\n case `echo 'xy\\c'` in\n *c*) ECHO_T='\t';;\t# ECHO_T is single tab character.\n xy) ECHO_C='\\c';;\n *) echo `echo ksh88 bug on AIX 6.1` > /dev/null\n ECHO_T='\t';;\n esac;;\n*)\n ECHO_N='-n';;\nesac\n\n# For backward compatibility with old third-party macros, we provide\n# the shell variables $as_echo and $as_echo_n. New code should use\n# AS_ECHO([\"message\"]) and AS_ECHO_N([\"message\"]), respectively.\nas_echo='printf %s\\n'\nas_echo_n='printf %s'\n\nrm -f conf$$ conf$$.exe conf$$.file\nif test -d conf$$.dir; then\n rm -f conf$$.dir/conf$$.file\nelse\n rm -f conf$$.dir\n mkdir conf$$.dir 2>/dev/null\nfi\nif (echo >conf$$.file) 2>/dev/null; then\n if ln -s conf$$.file conf$$ 2>/dev/null; then\n as_ln_s='ln -s'\n # ... but there are two gotchas:\n # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.\n # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.\n # In both cases, we have to default to `cp -pR'.\n ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||\n as_ln_s='cp -pR'\n elif ln conf$$.file conf$$ 2>/dev/null; then\n as_ln_s=ln\n else\n as_ln_s='cp -pR'\n fi\nelse\n as_ln_s='cp -pR'\nfi\nrm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file\nrmdir conf$$.dir 2>/dev/null\n\n\n# as_fn_mkdir_p\n# -------------\n# Create \"$as_dir\" as a directory, including parents if necessary.\nas_fn_mkdir_p ()\n{\n\n case $as_dir in #(\n -*) as_dir=./$as_dir;;\n esac\n test -d \"$as_dir\" || eval $as_mkdir_p || {\n as_dirs=\n while :; do\n case $as_dir in #(\n *\\'*) as_qdir=`printf \"%s\\n\" \"$as_dir\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"`;; #'(\n *) as_qdir=$as_dir;;\n esac\n as_dirs=\"'$as_qdir' $as_dirs\"\n as_dir=`$as_dirname -- \"$as_dir\" ||\n$as_expr X\"$as_dir\" : 'X\\(.*[^/]\\)//*[^/][^/]*/*$' \\| \\\n\t X\"$as_dir\" : 'X\\(//\\)[^/]' \\| \\\n\t X\"$as_dir\" : 'X\\(//\\)$' \\| \\\n\t X\"$as_dir\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X\"$as_dir\" |\n sed '/^X\\(.*[^/]\\)\\/\\/*[^/][^/]*\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)[^/].*/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n test -d \"$as_dir\" && break\n done\n test -z \"$as_dirs\" || eval \"mkdir $as_dirs\"\n } || test -d \"$as_dir\" || as_fn_error $? \"cannot create directory $as_dir\"\n\n\n} # as_fn_mkdir_p\nif mkdir -p . 2>/dev/null; then\n as_mkdir_p='mkdir -p \"$as_dir\"'\nelse\n test -d ./-p && rmdir ./-p\n as_mkdir_p=false\nfi\n\n\n# as_fn_executable_p FILE\n# -----------------------\n# Test if FILE is an executable regular file.\nas_fn_executable_p ()\n{\n test -f \"$1\" && test -x \"$1\"\n} # as_fn_executable_p\nas_test_x='test -x'\nas_executable_p=as_fn_executable_p\n\n# Sed expression to map a string onto a valid CPP name.\nas_tr_cpp=\"eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'\"\n\n# Sed expression to map a string onto a valid variable name.\nas_tr_sh=\"eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'\"\n\n\nexec 6>&1\n## ----------------------------------- ##\n## Main body of $CONFIG_STATUS script. ##\n## ----------------------------------- ##\n_ASEOF\ntest $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n# Save the log message, to keep $0 and so on meaningful, and to\n# report actual input values of CONFIG_FILES etc. instead of their\n# values after options handling.\nac_log=\"\nThis file was extended by $as_me, which was\ngenerated by GNU Autoconf 2.71. Invocation command line was\n\n CONFIG_FILES = $CONFIG_FILES\n CONFIG_HEADERS = $CONFIG_HEADERS\n CONFIG_LINKS = $CONFIG_LINKS\n CONFIG_COMMANDS = $CONFIG_COMMANDS\n $ $0 $@\n\non `(hostname || uname -n) 2>/dev/null | sed 1q`\n\"\n\n_ACEOF\n\ncase $ac_config_files in *\"\n\"*) set x $ac_config_files; shift; ac_config_files=$*;;\nesac\n\ncase $ac_config_headers in *\"\n\"*) set x $ac_config_headers; shift; ac_config_headers=$*;;\nesac\n\n\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\n# Files that config.status was made for.\nconfig_files=\"$ac_config_files\"\nconfig_headers=\"$ac_config_headers\"\nconfig_commands=\"$ac_config_commands\"\n\n_ACEOF\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\nac_cs_usage=\"\\\n\\`$as_me' instantiates files and other configuration actions\nfrom templates according to the current configuration. Unless the files\nand actions are specified as TAGs, all are instantiated by default.\n\nUsage: $0 [OPTION]... [TAG]...\n\n -h, --help print this help, then exit\n -V, --version print version number and configuration settings, then exit\n --config print configuration, then exit\n -q, --quiet, --silent\n do not print progress messages\n -d, --debug don't remove temporary files\n --recheck update $as_me by reconfiguring in the same conditions\n --file=FILE[:TEMPLATE]\n instantiate the configuration file FILE\n --header=FILE[:TEMPLATE]\n instantiate the configuration header FILE\n\nConfiguration files:\n$config_files\n\nConfiguration headers:\n$config_headers\n\nConfiguration commands:\n$config_commands\n\nReport bugs to the package provider.\"\n\n_ACEOF\nac_cs_config=`printf \"%s\\n\" \"$ac_configure_args\" | sed \"$ac_safe_unquote\"`\nac_cs_config_escaped=`printf \"%s\\n\" \"$ac_cs_config\" | sed \"s/^ //; s/'/'\\\\\\\\\\\\\\\\''/g\"`\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\nac_cs_config='$ac_cs_config_escaped'\nac_cs_version=\"\\\\\nconfig.status\nconfigured by $0, generated by GNU Autoconf 2.71,\n with options \\\\\"\\$ac_cs_config\\\\\"\n\nCopyright (C) 2021 Free Software Foundation, Inc.\nThis config.status script is free software; the Free Software Foundation\ngives unlimited permission to copy, distribute and modify it.\"\n\nac_pwd='$ac_pwd'\nsrcdir='$srcdir'\nINSTALL='$INSTALL'\nAWK='$AWK'\ntest -n \"\\$AWK\" || AWK=awk\n_ACEOF\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n# The default lists apply if the user does not specify any file.\nac_need_defaults=:\nwhile test $# != 0\ndo\n case $1 in\n --*=?*)\n ac_option=`expr \"X$1\" : 'X\\([^=]*\\)='`\n ac_optarg=`expr \"X$1\" : 'X[^=]*=\\(.*\\)'`\n ac_shift=:\n ;;\n --*=)\n ac_option=`expr \"X$1\" : 'X\\([^=]*\\)='`\n ac_optarg=\n ac_shift=:\n ;;\n *)\n ac_option=$1\n ac_optarg=$2\n ac_shift=shift\n ;;\n esac\n\n case $ac_option in\n # Handling of the options.\n -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)\n ac_cs_recheck=: ;;\n --version | --versio | --versi | --vers | --ver | --ve | --v | -V )\n printf \"%s\\n\" \"$ac_cs_version\"; exit ;;\n --config | --confi | --conf | --con | --co | --c )\n printf \"%s\\n\" \"$ac_cs_config\"; exit ;;\n --debug | --debu | --deb | --de | --d | -d )\n debug=: ;;\n --file | --fil | --fi | --f )\n $ac_shift\n case $ac_optarg in\n *\\'*) ac_optarg=`printf \"%s\\n\" \"$ac_optarg\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"` ;;\n '') as_fn_error $? \"missing file argument\" ;;\n esac\n as_fn_append CONFIG_FILES \" '$ac_optarg'\"\n ac_need_defaults=false;;\n --header | --heade | --head | --hea )\n $ac_shift\n case $ac_optarg in\n *\\'*) ac_optarg=`printf \"%s\\n\" \"$ac_optarg\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"` ;;\n esac\n as_fn_append CONFIG_HEADERS \" '$ac_optarg'\"\n ac_need_defaults=false;;\n --he | --h)\n # Conflict between --help and --header\n as_fn_error $? \"ambiguous option: \\`$1'\nTry \\`$0 --help' for more information.\";;\n --help | --hel | -h )\n printf \"%s\\n\" \"$ac_cs_usage\"; exit ;;\n -q | -quiet | --quiet | --quie | --qui | --qu | --q \\\n | -silent | --silent | --silen | --sile | --sil | --si | --s)\n ac_cs_silent=: ;;\n\n # This is an error.\n -*) as_fn_error $? \"unrecognized option: \\`$1'\nTry \\`$0 --help' for more information.\" ;;\n\n *) as_fn_append ac_config_targets \" $1\"\n ac_need_defaults=false ;;\n\n esac\n shift\ndone\n\nac_configure_extra_args=\n\nif $ac_cs_silent; then\n exec 6>/dev/null\n ac_configure_extra_args=\"$ac_configure_extra_args --silent\"\nfi\n\n_ACEOF\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\nif \\$ac_cs_recheck; then\n set X $SHELL '$0' $ac_configure_args \\$ac_configure_extra_args --no-create --no-recursion\n shift\n \\printf \"%s\\n\" \"running CONFIG_SHELL=$SHELL \\$*\" >&6\n CONFIG_SHELL='$SHELL'\n export CONFIG_SHELL\n exec \"\\$@\"\nfi\n\n_ACEOF\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\nexec 5>>config.log\n{\n echo\n sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX\n## Running $as_me. ##\n_ASBOX\n printf \"%s\\n\" \"$ac_log\"\n} >&5\n\n_ACEOF\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\n#\n# INIT-COMMANDS\n#\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n mangling_map=\"${mangling_map}\"\n public_syms=\"${public_syms}\"\n JEMALLOC_PREFIX=\"${JEMALLOC_PREFIX}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n public_syms=\"${public_syms}\"\n wrap_syms=\"${wrap_syms}\"\n SYM_PREFIX=\"${SYM_PREFIX}\"\n JEMALLOC_PREFIX=\"${JEMALLOC_PREFIX}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n public_syms=\"${public_syms}\"\n wrap_syms=\"${wrap_syms}\"\n SYM_PREFIX=\"${SYM_PREFIX}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n\n\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n install_suffix=\"${install_suffix}\"\n\n\n_ACEOF\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n\n# Handling of arguments.\nfor ac_config_target in $ac_config_targets\ndo\n case $ac_config_target in\n \"include/jemalloc/internal/public_symbols.txt\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/internal/public_symbols.txt\" ;;\n \"include/jemalloc/internal/private_symbols.awk\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/internal/private_symbols.awk\" ;;\n \"include/jemalloc/internal/private_symbols_jet.awk\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/internal/private_symbols_jet.awk\" ;;\n \"include/jemalloc/internal/public_namespace.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/internal/public_namespace.h\" ;;\n \"include/jemalloc/internal/public_unnamespace.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/internal/public_unnamespace.h\" ;;\n \"include/jemalloc/jemalloc_protos_jet.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/jemalloc_protos_jet.h\" ;;\n \"include/jemalloc/jemalloc_rename.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/jemalloc_rename.h\" ;;\n \"include/jemalloc/jemalloc_mangle.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/jemalloc_mangle.h\" ;;\n \"include/jemalloc/jemalloc_mangle_jet.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/jemalloc_mangle_jet.h\" ;;\n \"include/jemalloc/jemalloc.h\") CONFIG_COMMANDS=\"$CONFIG_COMMANDS include/jemalloc/jemalloc.h\" ;;\n \"$cfghdrs_tup\") CONFIG_HEADERS=\"$CONFIG_HEADERS $cfghdrs_tup\" ;;\n \"$cfgoutputs_tup\") CONFIG_FILES=\"$CONFIG_FILES $cfgoutputs_tup\" ;;\n \"config.stamp\") CONFIG_FILES=\"$CONFIG_FILES config.stamp\" ;;\n \"bin/jemalloc-config\") CONFIG_FILES=\"$CONFIG_FILES bin/jemalloc-config\" ;;\n \"bin/jemalloc.sh\") CONFIG_FILES=\"$CONFIG_FILES bin/jemalloc.sh\" ;;\n \"bin/jeprof\") CONFIG_FILES=\"$CONFIG_FILES bin/jeprof\" ;;\n\n *) as_fn_error $? \"invalid argument: \\`$ac_config_target'\" \"$LINENO\" 5;;\n esac\ndone\n\n\n# If the user did not use the arguments to specify the items to instantiate,\n# then the envvar interface is used. Set only those that are not.\n# We use the long form for the default assignment because of an extremely\n# bizarre bug on SunOS 4.1.3.\nif $ac_need_defaults; then\n test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files\n test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers\n test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands\nfi\n\n# Have a temporary directory for convenience. Make it in the build tree\n# simply because there is no reason against having it here, and in addition,\n# creating and moving files from /tmp can sometimes cause problems.\n# Hook for its removal unless debugging.\n# Note that there is a small window in which the directory will not be cleaned:\n# after its creation but before its name has been assigned to `$tmp'.\n$debug ||\n{\n tmp= ac_tmp=\n trap 'exit_status=$?\n : \"${ac_tmp:=$tmp}\"\n { test ! -d \"$ac_tmp\" || rm -fr \"$ac_tmp\"; } && exit $exit_status\n' 0\n trap 'as_fn_exit 1' 1 2 13 15\n}\n# Create a (secure) tmp directory for tmp files.\n\n{\n tmp=`(umask 077 && mktemp -d \"./confXXXXXX\") 2>/dev/null` &&\n test -d \"$tmp\"\n} ||\n{\n tmp=./conf$$-$RANDOM\n (umask 077 && mkdir \"$tmp\")\n} || as_fn_error $? \"cannot create a temporary directory in .\" \"$LINENO\" 5\nac_tmp=$tmp\n\n# Set up the scripts for CONFIG_FILES section.\n# No need to generate them if there are no CONFIG_FILES.\n# This happens for instance with `./config.status config.h'.\nif test -n \"$CONFIG_FILES\"; then\n\n\nac_cr=`echo X | tr X '\\015'`\n# On cygwin, bash can eat \\r inside `` if the user requested igncr.\n# But we know of no other shell where ac_cr would be empty at this\n# point, so we can use a bashism as a fallback.\nif test \"x$ac_cr\" = x; then\n eval ac_cr=\\$\\'\\\\r\\'\nfi\nac_cs_awk_cr=`$AWK 'BEGIN { print \"a\\rb\" }' /dev/null`\nif test \"$ac_cs_awk_cr\" = \"a${ac_cr}b\"; then\n ac_cs_awk_cr='\\\\r'\nelse\n ac_cs_awk_cr=$ac_cr\nfi\n\necho 'BEGIN {' >\"$ac_tmp/subs1.awk\" &&\n_ACEOF\n\n\n{\n echo \"cat >conf$$subs.awk <<_ACEOF\" &&\n echo \"$ac_subst_vars\" | sed 's/.*/&!$&$ac_delim/' &&\n echo \"_ACEOF\"\n} >conf$$subs.sh ||\n as_fn_error $? \"could not make $CONFIG_STATUS\" \"$LINENO\" 5\nac_delim_num=`echo \"$ac_subst_vars\" | grep -c '^'`\nac_delim='%!_!# '\nfor ac_last_try in false false false false false :; do\n . ./conf$$subs.sh ||\n as_fn_error $? \"could not make $CONFIG_STATUS\" \"$LINENO\" 5\n\n ac_delim_n=`sed -n \"s/.*$ac_delim\\$/X/p\" conf$$subs.awk | grep -c X`\n if test $ac_delim_n = $ac_delim_num; then\n break\n elif $ac_last_try; then\n as_fn_error $? \"could not make $CONFIG_STATUS\" \"$LINENO\" 5\n else\n ac_delim=\"$ac_delim!$ac_delim _$ac_delim!! \"\n fi\ndone\nrm -f conf$$subs.sh\n\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\ncat >>\"\\$ac_tmp/subs1.awk\" <<\\\\_ACAWK &&\n_ACEOF\nsed -n '\nh\ns/^/S[\"/; s/!.*/\"]=/\np\ng\ns/^[^!]*!//\n:repl\nt repl\ns/'\"$ac_delim\"'$//\nt delim\n:nl\nh\ns/\\(.\\{148\\}\\)..*/\\1/\nt more1\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\\\\n\"\\\\/\np\nn\nb repl\n:more1\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\"\\\\/\np\ng\ns/.\\{148\\}//\nt nl\n:delim\nh\ns/\\(.\\{148\\}\\)..*/\\1/\nt more2\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\"/\np\nb\n:more2\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\"\\\\/\np\ng\ns/.\\{148\\}//\nt delim\n' >$CONFIG_STATUS || ac_write_fail=1\nrm -f conf$$subs.awk\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\n_ACAWK\ncat >>\"\\$ac_tmp/subs1.awk\" <<_ACAWK &&\n for (key in S) S_is_set[key] = 1\n FS = \"\u0007\"\n\n}\n{\n line = $ 0\n nfields = split(line, field, \"@\")\n substed = 0\n len = length(field[1])\n for (i = 2; i < nfields; i++) {\n key = field[i]\n keylen = length(key)\n if (S_is_set[key]) {\n value = S[key]\n line = substr(line, 1, len) \"\" value \"\" substr(line, len + keylen + 3)\n len += length(value) + length(field[++i])\n substed = 1\n } else\n len += 1 + keylen\n }\n\n print line\n}\n\n_ACAWK\n_ACEOF\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\nif sed \"s/$ac_cr//\" < /dev/null > /dev/null 2>&1; then\n sed \"s/$ac_cr\\$//; s/$ac_cr/$ac_cs_awk_cr/g\"\nelse\n cat\nfi < \"$ac_tmp/subs1.awk\" > \"$ac_tmp/subs.awk\" \\\n || as_fn_error $? \"could not setup config files machinery\" \"$LINENO\" 5\n_ACEOF\n\n# VPATH may cause trouble with some makes, so we remove sole $(srcdir),\n# ${srcdir} and @srcdir@ entries from VPATH if srcdir is \".\", strip leading and\n# trailing colons and then remove the whole line if VPATH becomes empty\n# (actually we leave an empty line to preserve line numbers).\nif test \"x$srcdir\" = x.; then\n ac_vpsub='/^[\t ]*VPATH[\t ]*=[\t ]*/{\nh\ns///\ns/^/:/\ns/[\t ]*$/:/\ns/:\\$(srcdir):/:/g\ns/:\\${srcdir}:/:/g\ns/:@srcdir@:/:/g\ns/^:*//\ns/:*$//\nx\ns/\\(=[\t ]*\\).*/\\1/\nG\ns/\\n//\ns/^[^=]*=[\t ]*$//\n}'\nfi\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\nfi # test -n \"$CONFIG_FILES\"\n\n# Set up the scripts for CONFIG_HEADERS section.\n# No need to generate them if there are no CONFIG_HEADERS.\n# This happens for instance with `./config.status Makefile'.\nif test -n \"$CONFIG_HEADERS\"; then\ncat >\"$ac_tmp/defines.awk\" <<\\_ACAWK ||\nBEGIN {\n_ACEOF\n\n# Transform confdefs.h into an awk script `defines.awk', embedded as\n# here-document in config.status, that substitutes the proper values into\n# config.h.in to produce config.h.\n\n# Create a delimiter string that does not exist in confdefs.h, to ease\n# handling of long lines.\nac_delim='%!_!# '\nfor ac_last_try in false false :; do\n ac_tt=`sed -n \"/$ac_delim/p\" confdefs.h`\n if test -z \"$ac_tt\"; then\n break\n elif $ac_last_try; then\n as_fn_error $? \"could not make $CONFIG_HEADERS\" \"$LINENO\" 5\n else\n ac_delim=\"$ac_delim!$ac_delim _$ac_delim!! \"\n fi\ndone\n\n# For the awk script, D is an array of macro values keyed by name,\n# likewise P contains macro parameters if any. Preserve backslash\n# newline sequences.\n\nac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*\nsed -n '\ns/.\\{148\\}/&'\"$ac_delim\"'/g\nt rset\n:rset\ns/^[\t ]*#[\t ]*define[\t ][\t ]*/ /\nt def\nd\n:def\ns/\\\\$//\nt bsnl\ns/[\"\\\\]/\\\\&/g\ns/^ \\('\"$ac_word_re\"'\\)\\(([^()]*)\\)[\t ]*\\(.*\\)/P[\"\\1\"]=\"\\2\"\\\nD[\"\\1\"]=\" \\3\"/p\ns/^ \\('\"$ac_word_re\"'\\)[\t ]*\\(.*\\)/D[\"\\1\"]=\" \\2\"/p\nd\n:bsnl\ns/[\"\\\\]/\\\\&/g\ns/^ \\('\"$ac_word_re\"'\\)\\(([^()]*)\\)[\t ]*\\(.*\\)/P[\"\\1\"]=\"\\2\"\\\nD[\"\\1\"]=\" \\3\\\\\\\\\\\\n\"\\\\/p\nt cont\ns/^ \\('\"$ac_word_re\"'\\)[\t ]*\\(.*\\)/D[\"\\1\"]=\" \\2\\\\\\\\\\\\n\"\\\\/p\nt cont\nd\n:cont\nn\ns/.\\{148\\}/&'\"$ac_delim\"'/g\nt clear\n:clear\ns/\\\\$//\nt bsnlc\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\"/p\nd\n:bsnlc\ns/[\"\\\\]/\\\\&/g; s/^/\"/; s/$/\\\\\\\\\\\\n\"\\\\/p\nb cont\n' >$CONFIG_STATUS || ac_write_fail=1\n\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\n for (key in D) D_is_set[key] = 1\n FS = \"\u0007\"\n}\n/^[\\t ]*#[\\t ]*(define|undef)[\\t ]+$ac_word_re([\\t (]|\\$)/ {\n line = \\$ 0\n split(line, arg, \" \")\n if (arg[1] == \"#\") {\n defundef = arg[2]\n mac1 = arg[3]\n } else {\n defundef = substr(arg[1], 2)\n mac1 = arg[2]\n }\n split(mac1, mac2, \"(\") #)\n macro = mac2[1]\n prefix = substr(line, 1, index(line, defundef) - 1)\n if (D_is_set[macro]) {\n # Preserve the white space surrounding the \"#\".\n print prefix \"define\", macro P[macro] D[macro]\n next\n } else {\n # Replace #undef with comments. This is necessary, for example,\n # in the case of _POSIX_SOURCE, which is predefined and required\n # on some systems where configure will not decide to define it.\n if (defundef == \"undef\") {\n print \"/*\", prefix defundef, macro, \"*/\"\n next\n }\n }\n}\n{ print }\n_ACAWK\n_ACEOF\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n as_fn_error $? \"could not setup config headers machinery\" \"$LINENO\" 5\nfi # test -n \"$CONFIG_HEADERS\"\n\n\neval set X \" :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS\"\nshift\nfor ac_tag\ndo\n case $ac_tag in\n :[FHLC]) ac_mode=$ac_tag; continue;;\n esac\n case $ac_mode$ac_tag in\n :[FHL]*:*);;\n :L* | :C*:*) as_fn_error $? \"invalid tag \\`$ac_tag'\" \"$LINENO\" 5;;\n :[FH]-) ac_tag=-:-;;\n :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;\n esac\n ac_save_IFS=$IFS\n IFS=:\n set x $ac_tag\n IFS=$ac_save_IFS\n shift\n ac_file=$1\n shift\n\n case $ac_mode in\n :L) ac_source=$1;;\n :[FH])\n ac_file_inputs=\n for ac_f\n do\n case $ac_f in\n -) ac_f=\"$ac_tmp/stdin\";;\n *) # Look for the file first in the build tree, then in the source tree\n\t # (if the path is not absolute). The absolute path cannot be DOS-style,\n\t # because $ac_f cannot contain `:'.\n\t test -f \"$ac_f\" ||\n\t case $ac_f in\n\t [\\\\/$]*) false;;\n\t *) test -f \"$srcdir/$ac_f\" && ac_f=\"$srcdir/$ac_f\";;\n\t esac ||\n\t as_fn_error 1 \"cannot find input file: \\`$ac_f'\" \"$LINENO\" 5;;\n esac\n case $ac_f in *\\'*) ac_f=`printf \"%s\\n\" \"$ac_f\" | sed \"s/'/'\\\\\\\\\\\\\\\\''/g\"`;; esac\n as_fn_append ac_file_inputs \" '$ac_f'\"\n done\n\n # Let's still pretend it is `configure' which instantiates (i.e., don't\n # use $as_me), people would be surprised to read:\n # /* config.h. Generated by config.status. */\n configure_input='Generated from '`\n\t printf \"%s\\n\" \"$*\" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'\n\t`' by configure.'\n if test x\"$ac_file\" != x-; then\n configure_input=\"$ac_file. $configure_input\"\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: creating $ac_file\" >&5\nprintf \"%s\\n\" \"$as_me: creating $ac_file\" >&6;}\n fi\n # Neutralize special characters interpreted by sed in replacement strings.\n case $configure_input in #(\n *\\&* | *\\|* | *\\\\* )\n ac_sed_conf_input=`printf \"%s\\n\" \"$configure_input\" |\n sed 's/[\\\\\\\\&|]/\\\\\\\\&/g'`;; #(\n *) ac_sed_conf_input=$configure_input;;\n esac\n\n case $ac_tag in\n *:-:* | *:-) cat >\"$ac_tmp/stdin\" \\\n || as_fn_error $? \"could not create $ac_file\" \"$LINENO\" 5 ;;\n esac\n ;;\n esac\n\n ac_dir=`$as_dirname -- \"$ac_file\" ||\n$as_expr X\"$ac_file\" : 'X\\(.*[^/]\\)//*[^/][^/]*/*$' \\| \\\n\t X\"$ac_file\" : 'X\\(//\\)[^/]' \\| \\\n\t X\"$ac_file\" : 'X\\(//\\)$' \\| \\\n\t X\"$ac_file\" : 'X\\(/\\)' \\| . 2>/dev/null ||\nprintf \"%s\\n\" X\"$ac_file\" |\n sed '/^X\\(.*[^/]\\)\\/\\/*[^/][^/]*\\/*$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)[^/].*/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\/\\)$/{\n\t s//\\1/\n\t q\n\t }\n\t /^X\\(\\/\\).*/{\n\t s//\\1/\n\t q\n\t }\n\t s/.*/./; q'`\n as_dir=\"$ac_dir\"; as_fn_mkdir_p\n ac_builddir=.\n\ncase \"$ac_dir\" in\n.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;\n*)\n ac_dir_suffix=/`printf \"%s\\n\" \"$ac_dir\" | sed 's|^\\.[\\\\/]||'`\n # A \"..\" for each directory in $ac_dir_suffix.\n ac_top_builddir_sub=`printf \"%s\\n\" \"$ac_dir_suffix\" | sed 's|/[^\\\\/]*|/..|g;s|/||'`\n case $ac_top_builddir_sub in\n \"\") ac_top_builddir_sub=. ac_top_build_prefix= ;;\n *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;\n esac ;;\nesac\nac_abs_top_builddir=$ac_pwd\nac_abs_builddir=$ac_pwd$ac_dir_suffix\n# for backward compatibility:\nac_top_builddir=$ac_top_build_prefix\n\ncase $srcdir in\n .) # We are building in place.\n ac_srcdir=.\n ac_top_srcdir=$ac_top_builddir_sub\n ac_abs_top_srcdir=$ac_pwd ;;\n [\\\\/]* | ?:[\\\\/]* ) # Absolute name.\n ac_srcdir=$srcdir$ac_dir_suffix;\n ac_top_srcdir=$srcdir\n ac_abs_top_srcdir=$srcdir ;;\n *) # Relative name.\n ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix\n ac_top_srcdir=$ac_top_build_prefix$srcdir\n ac_abs_top_srcdir=$ac_pwd/$srcdir ;;\nesac\nac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix\n\n\n case $ac_mode in\n :F)\n #\n # CONFIG_FILE\n #\n\n case $INSTALL in\n [\\\\/$]* | ?:[\\\\/]* ) ac_INSTALL=$INSTALL ;;\n *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;\n esac\n_ACEOF\n\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n# If the template does not know about datarootdir, expand it.\n# FIXME: This hack should be removed a few years after 2.60.\nac_datarootdir_hack=; ac_datarootdir_seen=\nac_sed_dataroot='\n/datarootdir/ {\n p\n q\n}\n/@datadir@/p\n/@docdir@/p\n/@infodir@/p\n/@localedir@/p\n/@mandir@/p'\ncase `eval \"sed -n \\\"\\$ac_sed_dataroot\\\" $ac_file_inputs\"` in\n*datarootdir*) ac_datarootdir_seen=yes;;\n*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting\" >&2;}\n_ACEOF\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\n ac_datarootdir_hack='\n s&@datadir@&$datadir&g\n s&@docdir@&$docdir&g\n s&@infodir@&$infodir&g\n s&@localedir@&$localedir&g\n s&@mandir@&$mandir&g\n s&\\\\\\${datarootdir}&$datarootdir&g' ;;\nesac\n_ACEOF\n\n# Neutralize VPATH when `$srcdir' = `.'.\n# Shell code in configure.ac might set extrasub.\n# FIXME: do we really want to maintain this feature?\ncat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1\nac_sed_extra=\"$ac_vpsub\n$extrasub\n_ACEOF\ncat >>$CONFIG_STATUS <<\\_ACEOF || ac_write_fail=1\n:t\n/@[a-zA-Z_][a-zA-Z_0-9]*@/!b\ns|@configure_input@|$ac_sed_conf_input|;t t\ns&@top_builddir@&$ac_top_builddir_sub&;t t\ns&@top_build_prefix@&$ac_top_build_prefix&;t t\ns&@srcdir@&$ac_srcdir&;t t\ns&@abs_srcdir@&$ac_abs_srcdir&;t t\ns&@top_srcdir@&$ac_top_srcdir&;t t\ns&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t\ns&@builddir@&$ac_builddir&;t t\ns&@abs_builddir@&$ac_abs_builddir&;t t\ns&@abs_top_builddir@&$ac_abs_top_builddir&;t t\ns&@INSTALL@&$ac_INSTALL&;t t\n$ac_datarootdir_hack\n\"\neval sed \\\"\\$ac_sed_extra\\\" \"$ac_file_inputs\" | $AWK -f \"$ac_tmp/subs.awk\" \\\n >$ac_tmp/out || as_fn_error $? \"could not create $ac_file\" \"$LINENO\" 5\n\ntest -z \"$ac_datarootdir_hack$ac_datarootdir_seen\" &&\n { ac_out=`sed -n '/\\${datarootdir}/p' \"$ac_tmp/out\"`; test -n \"$ac_out\"; } &&\n { ac_out=`sed -n '/^[\t ]*datarootdir[\t ]*:*=/p' \\\n \"$ac_tmp/out\"`; test -z \"$ac_out\"; } &&\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \\`datarootdir'\nwhich seems to be undefined. Please make sure it is defined\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: $ac_file contains a reference to the variable \\`datarootdir'\nwhich seems to be undefined. Please make sure it is defined\" >&2;}\n\n rm -f \"$ac_tmp/stdin\"\n case $ac_file in\n -) cat \"$ac_tmp/out\" && rm -f \"$ac_tmp/out\";;\n *) rm -f \"$ac_file\" && mv \"$ac_tmp/out\" \"$ac_file\";;\n esac \\\n || as_fn_error $? \"could not create $ac_file\" \"$LINENO\" 5\n ;;\n :H)\n #\n # CONFIG_HEADER\n #\n if test x\"$ac_file\" != x-; then\n {\n printf \"%s\\n\" \"/* $configure_input */\" >&1 \\\n && eval '$AWK -f \"$ac_tmp/defines.awk\"' \"$ac_file_inputs\"\n } >\"$ac_tmp/config.h\" \\\n || as_fn_error $? \"could not create $ac_file\" \"$LINENO\" 5\n if diff \"$ac_file\" \"$ac_tmp/config.h\" >/dev/null 2>&1; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: $ac_file is unchanged\" >&5\nprintf \"%s\\n\" \"$as_me: $ac_file is unchanged\" >&6;}\n else\n rm -f \"$ac_file\"\n mv \"$ac_tmp/config.h\" \"$ac_file\" \\\n\t|| as_fn_error $? \"could not create $ac_file\" \"$LINENO\" 5\n fi\n else\n printf \"%s\\n\" \"/* $configure_input */\" >&1 \\\n && eval '$AWK -f \"$ac_tmp/defines.awk\"' \"$ac_file_inputs\" \\\n || as_fn_error $? \"could not create -\" \"$LINENO\" 5\n fi\n ;;\n\n :C) { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: executing $ac_file commands\" >&5\nprintf \"%s\\n\" \"$as_me: executing $ac_file commands\" >&6;}\n ;;\n esac\n\n\n case $ac_file$ac_mode in\n \"include/jemalloc/internal/public_symbols.txt\":C)\n f=\"${objroot}include/jemalloc/internal/public_symbols.txt\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n cp /dev/null \"${f}\"\n for nm in `echo ${mangling_map} |tr ',' ' '` ; do\n n=`echo ${nm} |tr ':' ' ' |awk '{print $1}'`\n m=`echo ${nm} |tr ':' ' ' |awk '{print $2}'`\n echo \"${n}:${m}\" >> \"${f}\"\n public_syms=`for sym in ${public_syms}; do echo \"${sym}\"; done |grep -v \"^${n}\\$\" |tr '\\n' ' '`\n done\n for sym in ${public_syms} ; do\n n=\"${sym}\"\n m=\"${JEMALLOC_PREFIX}${sym}\"\n echo \"${n}:${m}\" >> \"${f}\"\n done\n ;;\n \"include/jemalloc/internal/private_symbols.awk\":C)\n f=\"${objroot}include/jemalloc/internal/private_symbols.awk\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n export_syms=`for sym in ${public_syms}; do echo \"${JEMALLOC_PREFIX}${sym}\"; done; for sym in ${wrap_syms}; do echo \"${sym}\"; done;`\n \"${srcdir}/include/jemalloc/internal/private_symbols.sh\" \"${SYM_PREFIX}\" ${export_syms} > \"${objroot}include/jemalloc/internal/private_symbols.awk\"\n ;;\n \"include/jemalloc/internal/private_symbols_jet.awk\":C)\n f=\"${objroot}include/jemalloc/internal/private_symbols_jet.awk\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n export_syms=`for sym in ${public_syms}; do echo \"jet_${sym}\"; done; for sym in ${wrap_syms}; do echo \"${sym}\"; done;`\n \"${srcdir}/include/jemalloc/internal/private_symbols.sh\" \"${SYM_PREFIX}\" ${export_syms} > \"${objroot}include/jemalloc/internal/private_symbols_jet.awk\"\n ;;\n \"include/jemalloc/internal/public_namespace.h\":C)\n mkdir -p \"${objroot}include/jemalloc/internal\"\n \"${srcdir}/include/jemalloc/internal/public_namespace.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/internal/public_namespace.h\"\n ;;\n \"include/jemalloc/internal/public_unnamespace.h\":C)\n mkdir -p \"${objroot}include/jemalloc/internal\"\n \"${srcdir}/include/jemalloc/internal/public_unnamespace.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/internal/public_unnamespace.h\"\n ;;\n \"include/jemalloc/jemalloc_protos_jet.h\":C)\n mkdir -p \"${objroot}include/jemalloc\"\n cat \"${srcdir}/include/jemalloc/jemalloc_protos.h.in\" | sed -e 's/@je_@/jet_/g' > \"${objroot}include/jemalloc/jemalloc_protos_jet.h\"\n ;;\n \"include/jemalloc/jemalloc_rename.h\":C)\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_rename.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/jemalloc_rename.h\"\n ;;\n \"include/jemalloc/jemalloc_mangle.h\":C)\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_mangle.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" je_ > \"${objroot}include/jemalloc/jemalloc_mangle.h\"\n ;;\n \"include/jemalloc/jemalloc_mangle_jet.h\":C)\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_mangle.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" jet_ > \"${objroot}include/jemalloc/jemalloc_mangle_jet.h\"\n ;;\n \"include/jemalloc/jemalloc.h\":C)\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc.sh\" \"${objroot}\" > \"${objroot}include/jemalloc/jemalloc${install_suffix}.h\"\n ;;\n\n esac\ndone # for ac_tag\n\n\nas_fn_exit 0\n_ACEOF\nac_clean_files=$ac_clean_files_save\n\ntest $ac_write_fail = 0 ||\n as_fn_error $? \"write failure creating $CONFIG_STATUS\" \"$LINENO\" 5\n\n\n# configure is writing to config.log, and then calls config.status.\n# config.status does its own redirection, appending to config.log.\n# Unfortunately, on DOS this fails, as config.log is still kept open\n# by configure, so config.status won't be able to write to it; its\n# output is simply discarded. So we exec the FD to /dev/null,\n# effectively closing config.log, so it can be properly (re)opened and\n# appended to by config.status. When coming back to configure, we\n# need to make the FD available again.\nif test \"$no_create\" != yes; then\n ac_cs_success=:\n ac_config_status_args=\n test \"$silent\" = yes &&\n ac_config_status_args=\"$ac_config_status_args --quiet\"\n exec 5>/dev/null\n $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false\n exec 5>>config.log\n # Use ||, not &&, to avoid exiting from the if with $? = 1, which\n # would make configure fail if this is the last instruction.\n $ac_cs_success || as_fn_exit 1\nfi\nif test -n \"$ac_unrecognized_opts\" && test \"$enable_option_checking\" != no; then\n { printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts\" >&5\nprintf \"%s\\n\" \"$as_me: WARNING: unrecognized options: $ac_unrecognized_opts\" >&2;}\nfi\n\n\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: ===============================================================================\" >&5\nprintf \"%s\\n\" \"===============================================================================\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: jemalloc version : ${jemalloc_version}\" >&5\nprintf \"%s\\n\" \"jemalloc version : ${jemalloc_version}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: library revision : ${rev}\" >&5\nprintf \"%s\\n\" \"library revision : ${rev}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: \" >&5\nprintf \"%s\\n\" \"\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CONFIG : ${CONFIG}\" >&5\nprintf \"%s\\n\" \"CONFIG : ${CONFIG}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CC : ${CC}\" >&5\nprintf \"%s\\n\" \"CC : ${CC}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CONFIGURE_CFLAGS : ${CONFIGURE_CFLAGS}\" >&5\nprintf \"%s\\n\" \"CONFIGURE_CFLAGS : ${CONFIGURE_CFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: SPECIFIED_CFLAGS : ${SPECIFIED_CFLAGS}\" >&5\nprintf \"%s\\n\" \"SPECIFIED_CFLAGS : ${SPECIFIED_CFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: EXTRA_CFLAGS : ${EXTRA_CFLAGS}\" >&5\nprintf \"%s\\n\" \"EXTRA_CFLAGS : ${EXTRA_CFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CPPFLAGS : ${CPPFLAGS}\" >&5\nprintf \"%s\\n\" \"CPPFLAGS : ${CPPFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CXX : ${CXX}\" >&5\nprintf \"%s\\n\" \"CXX : ${CXX}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: CONFIGURE_CXXFLAGS : ${CONFIGURE_CXXFLAGS}\" >&5\nprintf \"%s\\n\" \"CONFIGURE_CXXFLAGS : ${CONFIGURE_CXXFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: SPECIFIED_CXXFLAGS : ${SPECIFIED_CXXFLAGS}\" >&5\nprintf \"%s\\n\" \"SPECIFIED_CXXFLAGS : ${SPECIFIED_CXXFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: EXTRA_CXXFLAGS : ${EXTRA_CXXFLAGS}\" >&5\nprintf \"%s\\n\" \"EXTRA_CXXFLAGS : ${EXTRA_CXXFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: LDFLAGS : ${LDFLAGS}\" >&5\nprintf \"%s\\n\" \"LDFLAGS : ${LDFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: EXTRA_LDFLAGS : ${EXTRA_LDFLAGS}\" >&5\nprintf \"%s\\n\" \"EXTRA_LDFLAGS : ${EXTRA_LDFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: DSO_LDFLAGS : ${DSO_LDFLAGS}\" >&5\nprintf \"%s\\n\" \"DSO_LDFLAGS : ${DSO_LDFLAGS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: LIBS : ${LIBS}\" >&5\nprintf \"%s\\n\" \"LIBS : ${LIBS}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: RPATH_EXTRA : ${RPATH_EXTRA}\" >&5\nprintf \"%s\\n\" \"RPATH_EXTRA : ${RPATH_EXTRA}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: \" >&5\nprintf \"%s\\n\" \"\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: XSLTPROC : ${XSLTPROC}\" >&5\nprintf \"%s\\n\" \"XSLTPROC : ${XSLTPROC}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: XSLROOT : ${XSLROOT}\" >&5\nprintf \"%s\\n\" \"XSLROOT : ${XSLROOT}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: \" >&5\nprintf \"%s\\n\" \"\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: PREFIX : ${PREFIX}\" >&5\nprintf \"%s\\n\" \"PREFIX : ${PREFIX}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: BINDIR : ${BINDIR}\" >&5\nprintf \"%s\\n\" \"BINDIR : ${BINDIR}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: DATADIR : ${DATADIR}\" >&5\nprintf \"%s\\n\" \"DATADIR : ${DATADIR}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: INCLUDEDIR : ${INCLUDEDIR}\" >&5\nprintf \"%s\\n\" \"INCLUDEDIR : ${INCLUDEDIR}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: LIBDIR : ${LIBDIR}\" >&5\nprintf \"%s\\n\" \"LIBDIR : ${LIBDIR}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: MANDIR : ${MANDIR}\" >&5\nprintf \"%s\\n\" \"MANDIR : ${MANDIR}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: \" >&5\nprintf \"%s\\n\" \"\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: srcroot : ${srcroot}\" >&5\nprintf \"%s\\n\" \"srcroot : ${srcroot}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: abs_srcroot : ${abs_srcroot}\" >&5\nprintf \"%s\\n\" \"abs_srcroot : ${abs_srcroot}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: objroot : ${objroot}\" >&5\nprintf \"%s\\n\" \"objroot : ${objroot}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: abs_objroot : ${abs_objroot}\" >&5\nprintf \"%s\\n\" \"abs_objroot : ${abs_objroot}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: \" >&5\nprintf \"%s\\n\" \"\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: JEMALLOC_PREFIX : ${JEMALLOC_PREFIX}\" >&5\nprintf \"%s\\n\" \"JEMALLOC_PREFIX : ${JEMALLOC_PREFIX}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: JEMALLOC_PRIVATE_NAMESPACE\" >&5\nprintf \"%s\\n\" \"JEMALLOC_PRIVATE_NAMESPACE\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: : ${JEMALLOC_PRIVATE_NAMESPACE}\" >&5\nprintf \"%s\\n\" \" : ${JEMALLOC_PRIVATE_NAMESPACE}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: install_suffix : ${install_suffix}\" >&5\nprintf \"%s\\n\" \"install_suffix : ${install_suffix}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: malloc_conf : ${config_malloc_conf}\" >&5\nprintf \"%s\\n\" \"malloc_conf : ${config_malloc_conf}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: documentation : ${enable_doc}\" >&5\nprintf \"%s\\n\" \"documentation : ${enable_doc}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: shared libs : ${enable_shared}\" >&5\nprintf \"%s\\n\" \"shared libs : ${enable_shared}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: static libs : ${enable_static}\" >&5\nprintf \"%s\\n\" \"static libs : ${enable_static}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: autogen : ${enable_autogen}\" >&5\nprintf \"%s\\n\" \"autogen : ${enable_autogen}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: debug : ${enable_debug}\" >&5\nprintf \"%s\\n\" \"debug : ${enable_debug}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: stats : ${enable_stats}\" >&5\nprintf \"%s\\n\" \"stats : ${enable_stats}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: experimental_smallocx : ${enable_experimental_smallocx}\" >&5\nprintf \"%s\\n\" \"experimental_smallocx : ${enable_experimental_smallocx}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: prof : ${enable_prof}\" >&5\nprintf \"%s\\n\" \"prof : ${enable_prof}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: prof-libunwind : ${enable_prof_libunwind}\" >&5\nprintf \"%s\\n\" \"prof-libunwind : ${enable_prof_libunwind}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: prof-libgcc : ${enable_prof_libgcc}\" >&5\nprintf \"%s\\n\" \"prof-libgcc : ${enable_prof_libgcc}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: prof-gcc : ${enable_prof_gcc}\" >&5\nprintf \"%s\\n\" \"prof-gcc : ${enable_prof_gcc}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: fill : ${enable_fill}\" >&5\nprintf \"%s\\n\" \"fill : ${enable_fill}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: utrace : ${enable_utrace}\" >&5\nprintf \"%s\\n\" \"utrace : ${enable_utrace}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: xmalloc : ${enable_xmalloc}\" >&5\nprintf \"%s\\n\" \"xmalloc : ${enable_xmalloc}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: log : ${enable_log}\" >&5\nprintf \"%s\\n\" \"log : ${enable_log}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: lazy_lock : ${enable_lazy_lock}\" >&5\nprintf \"%s\\n\" \"lazy_lock : ${enable_lazy_lock}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: cache-oblivious : ${enable_cache_oblivious}\" >&5\nprintf \"%s\\n\" \"cache-oblivious : ${enable_cache_oblivious}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: cxx : ${enable_cxx}\" >&5\nprintf \"%s\\n\" \"cxx : ${enable_cxx}\" >&6; }\n{ printf \"%s\\n\" \"$as_me:${as_lineno-$LINENO}: result: ===============================================================================\" >&5\nprintf \"%s\\n\" \"===============================================================================\" >&6; }\n\n" }, { "path": "deps/jemalloc/configure.ac", "content": "dnl Process this file with autoconf to produce a configure script.\nAC_PREREQ(2.68)\nAC_INIT([Makefile.in])\n\nAC_CONFIG_AUX_DIR([build-aux])\n\ndnl ============================================================================\ndnl Custom macro definitions.\n\ndnl JE_CONCAT_VVV(r, a, b)\ndnl\ndnl Set $r to the concatenation of $a and $b, with a space separating them iff\ndnl both $a and $b are non-empty.\nAC_DEFUN([JE_CONCAT_VVV],\nif test \"x[$]{$2}\" = \"x\" -o \"x[$]{$3}\" = \"x\" ; then\n $1=\"[$]{$2}[$]{$3}\"\nelse\n $1=\"[$]{$2} [$]{$3}\"\nfi\n)\n\ndnl JE_APPEND_VS(a, b)\ndnl\ndnl Set $a to the concatenation of $a and b, with a space separating them iff\ndnl both $a and b are non-empty.\nAC_DEFUN([JE_APPEND_VS],\n T_APPEND_V=$2\n JE_CONCAT_VVV($1, $1, T_APPEND_V)\n)\n\nCONFIGURE_CFLAGS=\nSPECIFIED_CFLAGS=\"${CFLAGS}\"\ndnl JE_CFLAGS_ADD(cflag)\ndnl\ndnl CFLAGS is the concatenation of CONFIGURE_CFLAGS and SPECIFIED_CFLAGS\ndnl (ignoring EXTRA_CFLAGS, which does not impact configure tests. This macro\ndnl appends to CONFIGURE_CFLAGS and regenerates CFLAGS.\nAC_DEFUN([JE_CFLAGS_ADD],\n[\nAC_MSG_CHECKING([whether compiler supports $1])\nT_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\nJE_APPEND_VS(CONFIGURE_CFLAGS, $1)\nJE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)\nAC_COMPILE_IFELSE([AC_LANG_PROGRAM(\n[[\n]], [[\n return 0;\n]])],\n [je_cv_cflags_added=$1]\n AC_MSG_RESULT([yes]),\n [je_cv_cflags_added=]\n AC_MSG_RESULT([no])\n [CONFIGURE_CFLAGS=\"${T_CONFIGURE_CFLAGS}\"]\n)\nJE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)\n])\n\ndnl JE_CFLAGS_SAVE()\ndnl JE_CFLAGS_RESTORE()\ndnl\ndnl Save/restore CFLAGS. Nesting is not supported.\nAC_DEFUN([JE_CFLAGS_SAVE],\nSAVED_CONFIGURE_CFLAGS=\"${CONFIGURE_CFLAGS}\"\n)\nAC_DEFUN([JE_CFLAGS_RESTORE],\nCONFIGURE_CFLAGS=\"${SAVED_CONFIGURE_CFLAGS}\"\nJE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)\n)\n\nCONFIGURE_CXXFLAGS=\nSPECIFIED_CXXFLAGS=\"${CXXFLAGS}\"\ndnl JE_CXXFLAGS_ADD(cxxflag)\nAC_DEFUN([JE_CXXFLAGS_ADD],\n[\nAC_MSG_CHECKING([whether compiler supports $1])\nT_CONFIGURE_CXXFLAGS=\"${CONFIGURE_CXXFLAGS}\"\nJE_APPEND_VS(CONFIGURE_CXXFLAGS, $1)\nJE_CONCAT_VVV(CXXFLAGS, CONFIGURE_CXXFLAGS, SPECIFIED_CXXFLAGS)\nAC_LANG_PUSH([C++])\nAC_COMPILE_IFELSE([AC_LANG_PROGRAM(\n[[\n]], [[\n return 0;\n]])],\n [je_cv_cxxflags_added=$1]\n AC_MSG_RESULT([yes]),\n [je_cv_cxxflags_added=]\n AC_MSG_RESULT([no])\n [CONFIGURE_CXXFLAGS=\"${T_CONFIGURE_CXXFLAGS}\"]\n)\nAC_LANG_POP([C++])\nJE_CONCAT_VVV(CXXFLAGS, CONFIGURE_CXXFLAGS, SPECIFIED_CXXFLAGS)\n])\n\ndnl JE_COMPILABLE(label, hcode, mcode, rvar)\ndnl\ndnl Use AC_LINK_IFELSE() rather than AC_COMPILE_IFELSE() so that linker errors\ndnl cause failure.\nAC_DEFUN([JE_COMPILABLE],\n[\nAC_CACHE_CHECK([whether $1 is compilable],\n [$4],\n [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2],\n [$3])],\n [$4=yes],\n [$4=no])])\n])\n\ndnl ============================================================================\n\nCONFIG=`echo ${ac_configure_args} | sed -e 's#'\"'\"'\\([^ ]*\\)'\"'\"'#\\1#g'`\nAC_SUBST([CONFIG])\n\ndnl Library revision.\nrev=2\nAC_SUBST([rev])\n\nsrcroot=$srcdir\nif test \"x${srcroot}\" = \"x.\" ; then\n srcroot=\"\"\nelse\n srcroot=\"${srcroot}/\"\nfi\nAC_SUBST([srcroot])\nabs_srcroot=\"`cd \\\"${srcdir}\\\"; pwd`/\"\nAC_SUBST([abs_srcroot])\n\nobjroot=\"\"\nAC_SUBST([objroot])\nabs_objroot=\"`pwd`/\"\nAC_SUBST([abs_objroot])\n\ndnl Munge install path variables.\ncase \"$prefix\" in\n *\\ * ) AC_MSG_ERROR([Prefix should not contain spaces]) ;;\n \"NONE\" ) prefix=\"/usr/local\" ;;\nesac\ncase \"$exec_prefix\" in\n *\\ * ) AC_MSG_ERROR([Exec prefix should not contain spaces]) ;;\n \"NONE\" ) exec_prefix=$prefix ;;\nesac\nPREFIX=$prefix\nAC_SUBST([PREFIX])\nBINDIR=`eval echo $bindir`\nBINDIR=`eval echo $BINDIR`\nAC_SUBST([BINDIR])\nINCLUDEDIR=`eval echo $includedir`\nINCLUDEDIR=`eval echo $INCLUDEDIR`\nAC_SUBST([INCLUDEDIR])\nLIBDIR=`eval echo $libdir`\nLIBDIR=`eval echo $LIBDIR`\nAC_SUBST([LIBDIR])\nDATADIR=`eval echo $datadir`\nDATADIR=`eval echo $DATADIR`\nAC_SUBST([DATADIR])\nMANDIR=`eval echo $mandir`\nMANDIR=`eval echo $MANDIR`\nAC_SUBST([MANDIR])\n\ndnl Support for building documentation.\nAC_PATH_PROG([XSLTPROC], [xsltproc], [false], [$PATH])\nif test -d \"/usr/share/xml/docbook/stylesheet/docbook-xsl\" ; then\n DEFAULT_XSLROOT=\"/usr/share/xml/docbook/stylesheet/docbook-xsl\"\nelif test -d \"/usr/share/sgml/docbook/xsl-stylesheets\" ; then\n DEFAULT_XSLROOT=\"/usr/share/sgml/docbook/xsl-stylesheets\"\nelse\n dnl Documentation building will fail if this default gets used.\n DEFAULT_XSLROOT=\"\"\nfi\nAC_ARG_WITH([xslroot],\n [AS_HELP_STRING([--with-xslroot=], [XSL stylesheet root path])], [\nif test \"x$with_xslroot\" = \"xno\" ; then\n XSLROOT=\"${DEFAULT_XSLROOT}\"\nelse\n XSLROOT=\"${with_xslroot}\"\nfi\n],\n XSLROOT=\"${DEFAULT_XSLROOT}\"\n)\nif test \"x$XSLTPROC\" = \"xfalse\" ; then\n XSLROOT=\"\"\nfi\nAC_SUBST([XSLROOT])\n\ndnl If CFLAGS isn't defined, set CFLAGS to something reasonable. Otherwise,\ndnl just prevent autoconf from molesting CFLAGS.\nCFLAGS=$CFLAGS\nAC_PROG_CC\n\nif test \"x$GCC\" != \"xyes\" ; then\n AC_CACHE_CHECK([whether compiler is MSVC],\n [je_cv_msvc],\n [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],\n [\n#ifndef _MSC_VER\n int fail[-1];\n#endif\n])],\n [je_cv_msvc=yes],\n [je_cv_msvc=no])])\nfi\n\ndnl check if a cray prgenv wrapper compiler is being used\nje_cv_cray_prgenv_wrapper=\"\"\nif test \"x${PE_ENV}\" != \"x\" ; then\n case \"${CC}\" in\n CC|cc)\n\tje_cv_cray_prgenv_wrapper=\"yes\"\n\t;;\n *)\n ;;\n esac\nfi\n\nAC_CACHE_CHECK([whether compiler is cray],\n [je_cv_cray],\n [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],\n [\n#ifndef _CRAYC\n int fail[-1];\n#endif\n])],\n [je_cv_cray=yes],\n [je_cv_cray=no])])\n\nif test \"x${je_cv_cray}\" = \"xyes\" ; then\n AC_CACHE_CHECK([whether cray compiler version is 8.4],\n [je_cv_cray_84],\n [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],\n [\n#if !(_RELEASE_MAJOR == 8 && _RELEASE_MINOR == 4)\n int fail[-1];\n#endif\n])],\n [je_cv_cray_84=yes],\n [je_cv_cray_84=no])])\nfi\n\nif test \"x$GCC\" = \"xyes\" ; then\n JE_CFLAGS_ADD([-std=gnu11])\n if test \"x$je_cv_cflags_added\" = \"x-std=gnu11\" ; then\n AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT], [ ], [ ])\n else\n JE_CFLAGS_ADD([-std=gnu99])\n if test \"x$je_cv_cflags_added\" = \"x-std=gnu99\" ; then\n AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT], [ ], [ ])\n fi\n fi\n JE_CFLAGS_ADD([-Werror=unknown-warning-option])\n JE_CFLAGS_ADD([-Wall])\n JE_CFLAGS_ADD([-Wextra])\n JE_CFLAGS_ADD([-Wshorten-64-to-32])\n JE_CFLAGS_ADD([-Wsign-compare])\n JE_CFLAGS_ADD([-Wundef])\n JE_CFLAGS_ADD([-Wno-format-zero-length])\n JE_CFLAGS_ADD([-Wpointer-arith])\n dnl This warning triggers on the use of the universal zero initializer, which\n dnl is a very handy idiom for things like the tcache static initializer (which\n dnl has lots of nested structs). See the discussion at.\n dnl https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119\n JE_CFLAGS_ADD([-Wno-missing-braces])\n dnl This one too.\n JE_CFLAGS_ADD([-Wno-missing-field-initializers])\n JE_CFLAGS_ADD([-Wno-missing-attributes])\n JE_CFLAGS_ADD([-pipe])\n JE_CFLAGS_ADD([-g3])\nelif test \"x$je_cv_msvc\" = \"xyes\" ; then\n CC=\"$CC -nologo\"\n JE_CFLAGS_ADD([-Zi])\n JE_CFLAGS_ADD([-MT])\n JE_CFLAGS_ADD([-W3])\n JE_CFLAGS_ADD([-FS])\n JE_APPEND_VS(CPPFLAGS, -I${srcdir}/include/msvc_compat)\nfi\nif test \"x$je_cv_cray\" = \"xyes\" ; then\n dnl cray compiler 8.4 has an inlining bug\n if test \"x$je_cv_cray_84\" = \"xyes\" ; then\n JE_CFLAGS_ADD([-hipa2])\n JE_CFLAGS_ADD([-hnognu])\n fi\n dnl ignore unreachable code warning\n JE_CFLAGS_ADD([-hnomessage=128])\n dnl ignore redefinition of \"malloc\", \"free\", etc warning\n JE_CFLAGS_ADD([-hnomessage=1357])\nfi\nAC_SUBST([CONFIGURE_CFLAGS])\nAC_SUBST([SPECIFIED_CFLAGS])\nAC_SUBST([EXTRA_CFLAGS])\nAC_PROG_CPP\n\nAC_ARG_ENABLE([cxx],\n [AS_HELP_STRING([--disable-cxx], [Disable C++ integration])],\nif test \"x$enable_cxx\" = \"xno\" ; then\n enable_cxx=\"0\"\nelse\n enable_cxx=\"1\"\nfi\n,\nenable_cxx=\"1\"\n)\nif test \"x$enable_cxx\" = \"x1\" ; then\n dnl Require at least c++14, which is the first version to support sized\n dnl deallocation. C++ support is not compiled otherwise.\n m4_include([m4/ax_cxx_compile_stdcxx.m4])\n AX_CXX_COMPILE_STDCXX([17], [noext], [optional])\n if test \"x${HAVE_CXX17}\" != \"x1\"; then\n AX_CXX_COMPILE_STDCXX([14], [noext], [optional])\n fi\n if test \"x${HAVE_CXX14}\" = \"x1\" -o \"x${HAVE_CXX17}\" = \"x1\"; then\n JE_CXXFLAGS_ADD([-Wall])\n JE_CXXFLAGS_ADD([-Wextra])\n JE_CXXFLAGS_ADD([-g3])\n\n SAVED_LIBS=\"${LIBS}\"\n JE_APPEND_VS(LIBS, -lstdc++)\n JE_COMPILABLE([libstdc++ linkage], [\n#include \n], [[\n\tint *arr = (int *)malloc(sizeof(int) * 42);\n\tif (arr == NULL)\n\t\treturn 1;\n]], [je_cv_libstdcxx])\n if test \"x${je_cv_libstdcxx}\" = \"xno\" ; then\n LIBS=\"${SAVED_LIBS}\"\n fi\n else\n enable_cxx=\"0\"\n fi\nfi\nif test \"x$enable_cxx\" = \"x1\"; then\n AC_DEFINE([JEMALLOC_ENABLE_CXX], [ ], [ ])\nfi\nAC_SUBST([enable_cxx])\nAC_SUBST([CONFIGURE_CXXFLAGS])\nAC_SUBST([SPECIFIED_CXXFLAGS])\nAC_SUBST([EXTRA_CXXFLAGS])\n\nAC_C_BIGENDIAN([ac_cv_big_endian=1], [ac_cv_big_endian=0])\nif test \"x${ac_cv_big_endian}\" = \"x1\" ; then\n AC_DEFINE_UNQUOTED([JEMALLOC_BIG_ENDIAN], [ ], [ ])\nfi\n\nif test \"x${je_cv_msvc}\" = \"xyes\" -a \"x${ac_cv_header_inttypes_h}\" = \"xno\"; then\n JE_APPEND_VS(CPPFLAGS, -I${srcdir}/include/msvc_compat/C99)\nfi\n\nif test \"x${je_cv_msvc}\" = \"xyes\" ; then\n LG_SIZEOF_PTR=LG_SIZEOF_PTR_WIN\n AC_MSG_RESULT([Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit])\nelse\n AC_CHECK_SIZEOF([void *])\n if test \"x${ac_cv_sizeof_void_p}\" = \"x8\" ; then\n LG_SIZEOF_PTR=3\n elif test \"x${ac_cv_sizeof_void_p}\" = \"x4\" ; then\n LG_SIZEOF_PTR=2\n else\n AC_MSG_ERROR([Unsupported pointer size: ${ac_cv_sizeof_void_p}])\n fi\nfi\nAC_DEFINE_UNQUOTED([LG_SIZEOF_PTR], [$LG_SIZEOF_PTR], [ ])\n\nAC_CHECK_SIZEOF([int])\nif test \"x${ac_cv_sizeof_int}\" = \"x8\" ; then\n LG_SIZEOF_INT=3\nelif test \"x${ac_cv_sizeof_int}\" = \"x4\" ; then\n LG_SIZEOF_INT=2\nelse\n AC_MSG_ERROR([Unsupported int size: ${ac_cv_sizeof_int}])\nfi\nAC_DEFINE_UNQUOTED([LG_SIZEOF_INT], [$LG_SIZEOF_INT], [ ])\n\nAC_CHECK_SIZEOF([long])\nif test \"x${ac_cv_sizeof_long}\" = \"x8\" ; then\n LG_SIZEOF_LONG=3\nelif test \"x${ac_cv_sizeof_long}\" = \"x4\" ; then\n LG_SIZEOF_LONG=2\nelse\n AC_MSG_ERROR([Unsupported long size: ${ac_cv_sizeof_long}])\nfi\nAC_DEFINE_UNQUOTED([LG_SIZEOF_LONG], [$LG_SIZEOF_LONG], [ ])\n\nAC_CHECK_SIZEOF([long long])\nif test \"x${ac_cv_sizeof_long_long}\" = \"x8\" ; then\n LG_SIZEOF_LONG_LONG=3\nelif test \"x${ac_cv_sizeof_long_long}\" = \"x4\" ; then\n LG_SIZEOF_LONG_LONG=2\nelse\n AC_MSG_ERROR([Unsupported long long size: ${ac_cv_sizeof_long_long}])\nfi\nAC_DEFINE_UNQUOTED([LG_SIZEOF_LONG_LONG], [$LG_SIZEOF_LONG_LONG], [ ])\n\nAC_CHECK_SIZEOF([intmax_t])\nif test \"x${ac_cv_sizeof_intmax_t}\" = \"x16\" ; then\n LG_SIZEOF_INTMAX_T=4\nelif test \"x${ac_cv_sizeof_intmax_t}\" = \"x8\" ; then\n LG_SIZEOF_INTMAX_T=3\nelif test \"x${ac_cv_sizeof_intmax_t}\" = \"x4\" ; then\n LG_SIZEOF_INTMAX_T=2\nelse\n AC_MSG_ERROR([Unsupported intmax_t size: ${ac_cv_sizeof_intmax_t}])\nfi\nAC_DEFINE_UNQUOTED([LG_SIZEOF_INTMAX_T], [$LG_SIZEOF_INTMAX_T], [ ])\n\nAC_CANONICAL_HOST\ndnl CPU-specific settings.\nCPU_SPINWAIT=\"\"\ncase \"${host_cpu}\" in\n i686|x86_64)\n\tHAVE_CPU_SPINWAIT=1\n\tif test \"x${je_cv_msvc}\" = \"xyes\" ; then\n\t AC_CACHE_VAL([je_cv_pause_msvc],\n\t [JE_COMPILABLE([pause instruction MSVC], [],\n\t\t\t\t\t[[_mm_pause(); return 0;]],\n\t\t\t\t\t[je_cv_pause_msvc])])\n\t if test \"x${je_cv_pause_msvc}\" = \"xyes\" ; then\n\t\tCPU_SPINWAIT='_mm_pause()'\n\t fi\n\telse\n\t AC_CACHE_VAL([je_cv_pause],\n\t [JE_COMPILABLE([pause instruction], [],\n\t\t\t\t\t[[__asm__ volatile(\"pause\"); return 0;]],\n\t\t\t\t\t[je_cv_pause])])\n\t if test \"x${je_cv_pause}\" = \"xyes\" ; then\n\t\tCPU_SPINWAIT='__asm__ volatile(\"pause\")'\n\t fi\n\tfi\n\t;;\n aarch64|arm*)\n\tHAVE_CPU_SPINWAIT=1\n\tdnl isb is a better equivalent to the pause instruction on x86.\n\tAC_CACHE_VAL([je_cv_isb],\n\t [JE_COMPILABLE([isb instruction], [],\n\t\t\t[[__asm__ volatile(\"isb\"); return 0;]],\n\t\t\t[je_cv_isb])])\n\tif test \"x${je_cv_isb}\" = \"xyes\" ; then\n\t CPU_SPINWAIT='__asm__ volatile(\"isb\")'\n\tfi\n\t;;\n *)\n\tHAVE_CPU_SPINWAIT=0\n\t;;\nesac\nAC_DEFINE_UNQUOTED([HAVE_CPU_SPINWAIT], [$HAVE_CPU_SPINWAIT], [ ])\nAC_DEFINE_UNQUOTED([CPU_SPINWAIT], [$CPU_SPINWAIT], [ ])\n\nAC_ARG_WITH([lg_vaddr],\n [AS_HELP_STRING([--with-lg-vaddr=], [Number of significant virtual address bits])],\n [LG_VADDR=\"$with_lg_vaddr\"], [LG_VADDR=\"detect\"])\n\ncase \"${host_cpu}\" in\n aarch64)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n AC_MSG_CHECKING([number of significant virtual address bits])\n if test \"x${LG_SIZEOF_PTR}\" = \"x2\" ; then\n #aarch64 ILP32\n LG_VADDR=32\n else\n #aarch64 LP64\n LG_VADDR=48\n fi\n AC_MSG_RESULT([$LG_VADDR])\n fi\n ;;\n x86_64)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n AC_CACHE_CHECK([number of significant virtual address bits],\n [je_cv_lg_vaddr],\n AC_RUN_IFELSE([AC_LANG_PROGRAM(\n[[\n#include \n#ifdef _WIN32\n#include \n#include \ntypedef unsigned __int32 uint32_t;\n#else\n#include \n#endif\n]], [[\n\tuint32_t r[[4]];\n\tuint32_t eax_in = 0x80000008U;\n#ifdef _WIN32\n\t__cpuid((int *)r, (int)eax_in);\n#else\n\tasm volatile (\"cpuid\"\n\t : \"=a\" (r[[0]]), \"=b\" (r[[1]]), \"=c\" (r[[2]]), \"=d\" (r[[3]])\n\t : \"a\" (eax_in), \"c\" (0)\n\t);\n#endif\n\tuint32_t eax_out = r[[0]];\n\tuint32_t vaddr = ((eax_out & 0x0000ff00U) >> 8);\n\tFILE *f = fopen(\"conftest.out\", \"w\");\n\tif (f == NULL) {\n\t\treturn 1;\n\t}\n\tif (vaddr > (sizeof(void *) << 3)) {\n\t\tvaddr = sizeof(void *) << 3;\n\t}\n\tfprintf(f, \"%u\", vaddr);\n\tfclose(f);\n\treturn 0;\n]])],\n [je_cv_lg_vaddr=`cat conftest.out`],\n [je_cv_lg_vaddr=error],\n [je_cv_lg_vaddr=57]))\n if test \"x${je_cv_lg_vaddr}\" != \"x\" ; then\n LG_VADDR=\"${je_cv_lg_vaddr}\"\n fi\n if test \"x${LG_VADDR}\" != \"xerror\" ; then\n AC_DEFINE_UNQUOTED([LG_VADDR], [$LG_VADDR], [ ])\n else\n AC_MSG_ERROR([cannot determine number of significant virtual address bits])\n fi\n fi\n ;;\n *)\n if test \"x$LG_VADDR\" = \"xdetect\"; then\n AC_MSG_CHECKING([number of significant virtual address bits])\n if test \"x${LG_SIZEOF_PTR}\" = \"x3\" ; then\n LG_VADDR=64\n elif test \"x${LG_SIZEOF_PTR}\" = \"x2\" ; then\n LG_VADDR=32\n elif test \"x${LG_SIZEOF_PTR}\" = \"xLG_SIZEOF_PTR_WIN\" ; then\n LG_VADDR=\"(1U << (LG_SIZEOF_PTR_WIN+3))\"\n else\n AC_MSG_ERROR([Unsupported lg(pointer size): ${LG_SIZEOF_PTR}])\n fi\n AC_MSG_RESULT([$LG_VADDR])\n fi\n ;;\nesac\nAC_DEFINE_UNQUOTED([LG_VADDR], [$LG_VADDR], [ ])\n\nLD_PRELOAD_VAR=\"LD_PRELOAD\"\nso=\"so\"\nimportlib=\"${so}\"\no=\"$ac_objext\"\na=\"a\"\nexe=\"$ac_exeext\"\nlibprefix=\"lib\"\nlink_whole_archive=\"0\"\nDSO_LDFLAGS='-shared -Wl,-soname,$(@F)'\nRPATH='-Wl,-rpath,$(1)'\nSOREV=\"${so}.${rev}\"\nPIC_CFLAGS='-fPIC -DPIC'\nCTARGET='-o $@'\nLDTARGET='-o $@'\nTEST_LD_MODE=\nEXTRA_LDFLAGS=\nARFLAGS='crs'\nAROUT=' $@'\nCC_MM=1\n\nif test \"x$je_cv_cray_prgenv_wrapper\" = \"xyes\" ; then\n TEST_LD_MODE='-dynamic'\nfi\n\nif test \"x${je_cv_cray}\" = \"xyes\" ; then\n CC_MM=\nfi\n\nAN_MAKEVAR([AR], [AC_PROG_AR])\nAN_PROGRAM([ar], [AC_PROG_AR])\nAC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL(AR, ar, :)])\nAC_PROG_AR\n\nAN_MAKEVAR([NM], [AC_PROG_NM])\nAN_PROGRAM([nm], [AC_PROG_NM])\nAC_DEFUN([AC_PROG_NM], [AC_CHECK_TOOL(NM, nm, :)])\nAC_PROG_NM\n\nAC_PROG_AWK\n\ndnl ============================================================================\ndnl jemalloc version.\ndnl\n\nAC_ARG_WITH([version],\n [AS_HELP_STRING([--with-version=..--g],\n [Version string])],\n [\n echo \"${with_version}\" | grep ['^[0-9]\\+\\.[0-9]\\+\\.[0-9]\\+-[0-9]\\+-g[0-9a-f]\\+$'] 2>&1 1>/dev/null\n if test $? -eq 0 ; then\n echo \"$with_version\" > \"${objroot}VERSION\"\n else\n echo \"${with_version}\" | grep ['^VERSION$'] 2>&1 1>/dev/null\n if test $? -ne 0 ; then\n AC_MSG_ERROR([${with_version} does not match ..--g or VERSION])\n fi\n fi\n ], [\n dnl Set VERSION if source directory is inside a git repository.\n if test \"x`test ! \\\"${srcroot}\\\" && cd \\\"${srcroot}\\\"; git rev-parse --is-inside-work-tree 2>/dev/null`\" = \"xtrue\" ; then\n dnl Pattern globs aren't powerful enough to match both single- and\n dnl double-digit version numbers, so iterate over patterns to support up\n dnl to version 99.99.99 without any accidental matches.\n for pattern in ['[0-9].[0-9].[0-9]' '[0-9].[0-9].[0-9][0-9]' \\\n '[0-9].[0-9][0-9].[0-9]' '[0-9].[0-9][0-9].[0-9][0-9]' \\\n '[0-9][0-9].[0-9].[0-9]' '[0-9][0-9].[0-9].[0-9][0-9]' \\\n '[0-9][0-9].[0-9][0-9].[0-9]' \\\n '[0-9][0-9].[0-9][0-9].[0-9][0-9]']; do\n (test ! \"${srcroot}\" && cd \"${srcroot}\"; git describe --long --abbrev=40 --match=\"${pattern}\") > \"${objroot}VERSION.tmp\" 2>/dev/null\n if test $? -eq 0 ; then\n mv \"${objroot}VERSION.tmp\" \"${objroot}VERSION\"\n break\n fi\n done\n fi\n rm -f \"${objroot}VERSION.tmp\"\n ])\n\nif test ! -e \"${objroot}VERSION\" ; then\n if test ! -e \"${srcroot}VERSION\" ; then\n AC_MSG_RESULT(\n [Missing VERSION file, and unable to generate it; creating bogus VERSION])\n echo \"0.0.0-0-g000000missing_version_try_git_fetch_tags\" > \"${objroot}VERSION\"\n else\n cp ${srcroot}VERSION ${objroot}VERSION\n fi\nfi\njemalloc_version=`cat \"${objroot}VERSION\"`\njemalloc_version_major=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print [$]1}'`\njemalloc_version_minor=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print [$]2}'`\njemalloc_version_bugfix=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print [$]3}'`\njemalloc_version_nrev=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print [$]4}'`\njemalloc_version_gid=`echo ${jemalloc_version} | tr \".g-\" \" \" | awk '{print [$]5}'`\nAC_SUBST([jemalloc_version])\nAC_SUBST([jemalloc_version_major])\nAC_SUBST([jemalloc_version_minor])\nAC_SUBST([jemalloc_version_bugfix])\nAC_SUBST([jemalloc_version_nrev])\nAC_SUBST([jemalloc_version_gid])\n\ndnl Platform-specific settings. abi and RPATH can probably be determined\ndnl programmatically, but doing so is error-prone, which makes it generally\ndnl not worth the trouble.\ndnl\ndnl Define cpp macros in CPPFLAGS, rather than doing AC_DEFINE(macro), since the\ndnl definitions need to be seen before any headers are included, which is a pain\ndnl to make happen otherwise.\ndefault_retain=\"0\"\nzero_realloc_default_free=\"0\"\nmaps_coalesce=\"1\"\nDUMP_SYMS=\"${NM} -a\"\nSYM_PREFIX=\"\"\ncase \"${host}\" in\n *-*-darwin* | *-*-ios*)\n\tabi=\"macho\"\n\tRPATH=\"\"\n\tLD_PRELOAD_VAR=\"DYLD_INSERT_LIBRARIES\"\n\tso=\"dylib\"\n\timportlib=\"${so}\"\n\tforce_tls=\"0\"\n\tDSO_LDFLAGS='-shared -Wl,-install_name,$(LIBDIR)/$(@F)'\n\tSOREV=\"${rev}.${so}\"\n\tsbrk_deprecated=\"1\"\n\tSYM_PREFIX=\"_\"\n\t;;\n *-*-freebsd*)\n\tJE_APPEND_VS(CPPFLAGS, -D_BSD_SOURCE)\n\tabi=\"elf\"\n\tAC_DEFINE([JEMALLOC_SYSCTL_VM_OVERCOMMIT], [ ], [ ])\n\tforce_lazy_lock=\"1\"\n\t;;\n *-*-dragonfly*)\n\tabi=\"elf\"\n\t;;\n *-*-openbsd*)\n\tabi=\"elf\"\n\tforce_tls=\"0\"\n\t;;\n *-*-bitrig*)\n\tabi=\"elf\"\n\t;;\n *-*-linux-android*)\n\tdnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.\n\tJE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)\n\tabi=\"elf\"\n\tglibc=\"0\"\n\tAC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_HAS_ALLOCA_H], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_THREADED_INIT], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_C11_ATOMICS], [ ], [ ])\n\tforce_tls=\"0\"\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-linux*)\n\tdnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.\n\tJE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)\n\tabi=\"elf\"\n\tglibc=\"1\"\n\tAC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_HAS_ALLOCA_H], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_THREADED_INIT], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_USE_CXX_THROW], [ ], [ ])\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-kfreebsd*)\n\tdnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.\n\tJE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)\n\tabi=\"elf\"\n\tAC_DEFINE([JEMALLOC_HAS_ALLOCA_H], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_SYSCTL_VM_OVERCOMMIT], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_THREADED_INIT], [ ], [ ])\n\tAC_DEFINE([JEMALLOC_USE_CXX_THROW], [ ], [ ])\n\t;;\n *-*-netbsd*)\n\tAC_MSG_CHECKING([ABI])\n AC_COMPILE_IFELSE([AC_LANG_PROGRAM(\n[[#ifdef __ELF__\n/* ELF */\n#else\n#error aout\n#endif\n]])],\n [abi=\"elf\"],\n [abi=\"aout\"])\n\tAC_MSG_RESULT([$abi])\n\t;;\n *-*-solaris2*)\n\tabi=\"elf\"\n\tRPATH='-Wl,-R,$(1)'\n\tdnl Solaris needs this for sigwait().\n\tJE_APPEND_VS(CPPFLAGS, -D_POSIX_PTHREAD_SEMANTICS)\n\tJE_APPEND_VS(LIBS, -lposix4 -lsocket -lnsl)\n\t;;\n *-ibm-aix*)\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t dnl 64bit AIX\n\t LD_PRELOAD_VAR=\"LDR_PRELOAD64\"\n\telse\n\t dnl 32bit AIX\n\t LD_PRELOAD_VAR=\"LDR_PRELOAD\"\n\tfi\n\tabi=\"xcoff\"\n\t;;\n *-*-mingw* | *-*-cygwin*)\n\tabi=\"pecoff\"\n\tforce_tls=\"0\"\n\tmaps_coalesce=\"0\"\n\tRPATH=\"\"\n\tso=\"dll\"\n\tif test \"x$je_cv_msvc\" = \"xyes\" ; then\n\t importlib=\"lib\"\n\t DSO_LDFLAGS=\"-LD\"\n\t EXTRA_LDFLAGS=\"-link -DEBUG\"\n\t CTARGET='-Fo$@'\n\t LDTARGET='-Fe$@'\n\t AR='lib'\n\t ARFLAGS='-nologo -out:'\n\t AROUT='$@'\n\t CC_MM=\n else\n\t importlib=\"${so}\"\n\t DSO_LDFLAGS=\"-shared\"\n\t link_whole_archive=\"1\"\n\tfi\n\tcase \"${host}\" in\n\t *-*-cygwin*)\n\t DUMP_SYMS=\"dumpbin /SYMBOLS\"\n\t ;;\n\t *)\n\t ;;\n\tesac\n\ta=\"lib\"\n\tlibprefix=\"\"\n\tSOREV=\"${so}\"\n\tPIC_CFLAGS=\"\"\n\tif test \"${LG_SIZEOF_PTR}\" = \"3\"; then\n\t default_retain=\"1\"\n\tfi\n\tzero_realloc_default_free=\"1\"\n\t;;\n *-*-nto-qnx)\n\tabi=\"elf\"\n force_tls=\"0\"\n AC_DEFINE([JEMALLOC_HAS_ALLOCA_H], [ ], [ ])\n\t;;\n *)\n\tAC_MSG_RESULT([Unsupported operating system: ${host}])\n\tabi=\"elf\"\n\t;;\nesac\n\nJEMALLOC_USABLE_SIZE_CONST=const\nAC_CHECK_HEADERS([malloc.h], [\n AC_MSG_CHECKING([whether malloc_usable_size definition can use const argument])\n AC_COMPILE_IFELSE([AC_LANG_PROGRAM(\n [#include \n #include \n size_t malloc_usable_size(const void *ptr);\n ],\n [])],[\n AC_MSG_RESULT([yes])\n ],[\n JEMALLOC_USABLE_SIZE_CONST=\n AC_MSG_RESULT([no])\n ])\n])\nAC_DEFINE_UNQUOTED([JEMALLOC_USABLE_SIZE_CONST], [$JEMALLOC_USABLE_SIZE_CONST], [ ])\nAC_SUBST([abi])\nAC_SUBST([RPATH])\nAC_SUBST([LD_PRELOAD_VAR])\nAC_SUBST([so])\nAC_SUBST([importlib])\nAC_SUBST([o])\nAC_SUBST([a])\nAC_SUBST([exe])\nAC_SUBST([libprefix])\nAC_SUBST([link_whole_archive])\nAC_SUBST([DSO_LDFLAGS])\nAC_SUBST([EXTRA_LDFLAGS])\nAC_SUBST([SOREV])\nAC_SUBST([PIC_CFLAGS])\nAC_SUBST([CTARGET])\nAC_SUBST([LDTARGET])\nAC_SUBST([TEST_LD_MODE])\nAC_SUBST([MKLIB])\nAC_SUBST([ARFLAGS])\nAC_SUBST([AROUT])\nAC_SUBST([DUMP_SYMS])\nAC_SUBST([CC_MM])\n\ndnl Determine whether libm must be linked to use e.g. log(3).\nAC_SEARCH_LIBS([log], [m], , [AC_MSG_ERROR([Missing math functions])])\nif test \"x$ac_cv_search_log\" != \"xnone required\" ; then\n LM=\"$ac_cv_search_log\"\nelse\n LM=\nfi\nAC_SUBST(LM)\n\nJE_COMPILABLE([__attribute__ syntax],\n [static __attribute__((unused)) void foo(void){}],\n [],\n [je_cv_attribute])\nif test \"x${je_cv_attribute}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR], [ ], [ ])\n if test \"x${GCC}\" = \"xyes\" -a \"x${abi}\" = \"xelf\"; then\n JE_CFLAGS_ADD([-fvisibility=hidden])\n JE_CXXFLAGS_ADD([-fvisibility=hidden])\n fi\nfi\ndnl Check for tls_model attribute support (clang 3.0 still lacks support).\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([tls_model attribute], [],\n [static __thread int\n __attribute__((tls_model(\"initial-exec\"), unused)) foo;\n foo = 0;],\n [je_cv_tls_model])\nJE_CFLAGS_RESTORE()\ndnl (Setting of JEMALLOC_TLS_MODEL is done later, after we've checked for\ndnl --disable-initial-exec-tls)\n\ndnl Check for alloc_size attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([alloc_size attribute], [#include ],\n [void *foo(size_t size) __attribute__((alloc_size(1)));],\n [je_cv_alloc_size])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_alloc_size}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_ALLOC_SIZE], [ ], [ ])\nfi\ndnl Check for format(gnu_printf, ...) attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([format(gnu_printf, ...) attribute], [#include ],\n [void *foo(const char *format, ...) __attribute__((format(gnu_printf, 1, 2)));],\n [je_cv_format_gnu_printf])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_format_gnu_printf}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_GNU_PRINTF], [ ], [ ])\nfi\ndnl Check for format(printf, ...) attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([format(printf, ...) attribute], [#include ],\n [void *foo(const char *format, ...) __attribute__((format(printf, 1, 2)));],\n [je_cv_format_printf])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_format_printf}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_PRINTF], [ ], [ ])\nfi\n\ndnl Check for format_arg(...) attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([format(printf, ...) attribute], [#include ],\n [const char * __attribute__((__format_arg__(1))) foo(const char *format);],\n [je_cv_format_arg])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_format_arg}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_ARG], [ ], [ ])\nfi\n\ndnl Check for fallthrough attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Wimplicit-fallthrough])\nJE_COMPILABLE([fallthrough attribute],\n [#if !__has_attribute(fallthrough)\n #error \"foo\"\n #endif],\n [int x = 0;\n switch (x) {\n case 0: __attribute__((__fallthrough__));\n case 1: return 1;\n }],\n [je_cv_fallthrough])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_fallthrough}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_FALLTHROUGH], [ ], [ ])\n JE_CFLAGS_ADD([-Wimplicit-fallthrough])\n JE_CXXFLAGS_ADD([-Wimplicit-fallthrough])\nfi\n\ndnl Check for cold attribute support.\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([cold attribute], [],\n [__attribute__((__cold__)) void foo();],\n [je_cv_cold])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_cold}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ATTR_COLD], [ ], [ ])\nfi\n\ndnl Check for VM_MAKE_TAG for mmap support.\nJE_COMPILABLE([vm_make_tag],\n\t [#include \n\t #include ],\n\t [void *p;\n\t p = mmap(0, 16, PROT_READ, MAP_ANON|MAP_PRIVATE, VM_MAKE_TAG(1), 0);\n\t munmap(p, 16);],\n\t [je_cv_vm_make_tag])\nif test \"x${je_cv_vm_make_tag}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_VM_MAKE_TAG], [ ], [ ])\nfi\n\ndnl Support optional additions to rpath.\nAC_ARG_WITH([rpath],\n [AS_HELP_STRING([--with-rpath=], [Colon-separated rpath (ELF systems only)])],\nif test \"x$with_rpath\" = \"xno\" ; then\n RPATH_EXTRA=\nelse\n RPATH_EXTRA=\"`echo $with_rpath | tr \\\":\\\" \\\" \\\"`\"\nfi,\n RPATH_EXTRA=\n)\nAC_SUBST([RPATH_EXTRA])\n\ndnl Disable rules that do automatic regeneration of configure output by default.\nAC_ARG_ENABLE([autogen],\n [AS_HELP_STRING([--enable-autogen], [Automatically regenerate configure output])],\nif test \"x$enable_autogen\" = \"xno\" ; then\n enable_autogen=\"0\"\nelse\n enable_autogen=\"1\"\nfi\n,\nenable_autogen=\"0\"\n)\nAC_SUBST([enable_autogen])\n\nAC_PROG_INSTALL\nAC_PROG_RANLIB\nAC_PATH_PROG([LD], [ld], [false], [$PATH])\nAC_PATH_PROG([AUTOCONF], [autoconf], [false], [$PATH])\n\ndnl Enable documentation\nAC_ARG_ENABLE([doc],\n\t [AS_HELP_STRING([--enable-doc], [Build documentation])],\nif test \"x$enable_doc\" = \"xno\" ; then\n enable_doc=\"0\"\nelse\n enable_doc=\"1\"\nfi\n,\nenable_doc=\"1\"\n)\nAC_SUBST([enable_doc])\n\ndnl Enable shared libs\nAC_ARG_ENABLE([shared],\n [AS_HELP_STRING([--enable-shared], [Build shared libaries])],\nif test \"x$enable_shared\" = \"xno\" ; then\n enable_shared=\"0\"\nelse\n enable_shared=\"1\"\nfi\n,\nenable_shared=\"1\"\n)\nAC_SUBST([enable_shared])\n\ndnl Enable static libs\nAC_ARG_ENABLE([static],\n [AS_HELP_STRING([--enable-static], [Build static libaries])],\nif test \"x$enable_static\" = \"xno\" ; then\n enable_static=\"0\"\nelse\n enable_static=\"1\"\nfi\n,\nenable_static=\"1\"\n)\nAC_SUBST([enable_static])\n\nif test \"$enable_shared$enable_static\" = \"00\" ; then\n AC_MSG_ERROR([Please enable one of shared or static builds])\nfi\n\ndnl Perform no name mangling by default.\nAC_ARG_WITH([mangling],\n [AS_HELP_STRING([--with-mangling=], [Mangle symbols in ])],\n [mangling_map=\"$with_mangling\"], [mangling_map=\"\"])\n\ndnl Do not prefix public APIs by default.\nAC_ARG_WITH([jemalloc_prefix],\n [AS_HELP_STRING([--with-jemalloc-prefix=], [Prefix to prepend to all public APIs])],\n [JEMALLOC_PREFIX=\"$with_jemalloc_prefix\"],\n [if test \"x$abi\" != \"xmacho\" -a \"x$abi\" != \"xpecoff\"; then\n JEMALLOC_PREFIX=\"\"\nelse\n JEMALLOC_PREFIX=\"je_\"\nfi]\n)\nif test \"x$JEMALLOC_PREFIX\" = \"x\" ; then\n AC_DEFINE([JEMALLOC_IS_MALLOC], [ ], [ ])\nelse\n JEMALLOC_CPREFIX=`echo ${JEMALLOC_PREFIX} | tr \"a-z\" \"A-Z\"`\n AC_DEFINE_UNQUOTED([JEMALLOC_PREFIX], [\"$JEMALLOC_PREFIX\"], [ ])\n AC_DEFINE_UNQUOTED([JEMALLOC_CPREFIX], [\"$JEMALLOC_CPREFIX\"], [ ])\nfi\nAC_SUBST([JEMALLOC_PREFIX])\nAC_SUBST([JEMALLOC_CPREFIX])\n\nAC_ARG_WITH([export],\n [AS_HELP_STRING([--without-export], [disable exporting jemalloc public APIs])],\n [if test \"x$with_export\" = \"xno\"; then\n AC_DEFINE([JEMALLOC_EXPORT],[], [ ])\nfi]\n)\n\npublic_syms=\"aligned_alloc calloc dallocx free mallctl mallctlbymib mallctlnametomib malloc malloc_conf malloc_conf_2_conf_harder malloc_message malloc_stats_print malloc_usable_size mallocx smallocx_${jemalloc_version_gid} nallocx posix_memalign rallocx realloc sallocx sdallocx xallocx\"\ndnl Check for additional platform-specific public API functions.\nAC_CHECK_FUNC([memalign],\n\t [AC_DEFINE([JEMALLOC_OVERRIDE_MEMALIGN], [ ], [ ])\n\t public_syms=\"${public_syms} memalign\"])\nAC_CHECK_FUNC([valloc],\n\t [AC_DEFINE([JEMALLOC_OVERRIDE_VALLOC], [ ], [ ])\n\t public_syms=\"${public_syms} valloc\"])\nAC_CHECK_FUNC([malloc_size],\n\t [AC_DEFINE([JEMALLOC_HAVE_MALLOC_SIZE], [ ], [ ])\n\t public_syms=\"${public_syms} malloc_size\"])\n\ndnl Check for allocator-related functions that should be wrapped.\nwrap_syms=\nif test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n AC_CHECK_FUNC([__libc_calloc],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_CALLOC], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_calloc\"])\n AC_CHECK_FUNC([__libc_free],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_FREE], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_free\"])\n AC_CHECK_FUNC([__libc_malloc],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_MALLOC], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_malloc\"])\n AC_CHECK_FUNC([__libc_memalign],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_MEMALIGN], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_memalign\"])\n AC_CHECK_FUNC([__libc_realloc],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_REALLOC], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_realloc\"])\n AC_CHECK_FUNC([__libc_valloc],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___LIBC_VALLOC], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __libc_valloc\"])\n AC_CHECK_FUNC([__posix_memalign],\n\t\t[AC_DEFINE([JEMALLOC_OVERRIDE___POSIX_MEMALIGN], [ ], [ ])\n\t\t wrap_syms=\"${wrap_syms} __posix_memalign\"])\nfi\n\ncase \"${host}\" in\n *-*-mingw* | *-*-cygwin*)\n wrap_syms=\"${wrap_syms} tls_callback\"\n ;;\n *)\n ;;\nesac\n\ndnl Mangle library-private APIs.\nAC_ARG_WITH([private_namespace],\n [AS_HELP_STRING([--with-private-namespace=], [Prefix to prepend to all library-private APIs])],\n [JEMALLOC_PRIVATE_NAMESPACE=\"${with_private_namespace}je_\"],\n [JEMALLOC_PRIVATE_NAMESPACE=\"je_\"]\n)\nAC_DEFINE_UNQUOTED([JEMALLOC_PRIVATE_NAMESPACE], [$JEMALLOC_PRIVATE_NAMESPACE], [ ])\nprivate_namespace=\"$JEMALLOC_PRIVATE_NAMESPACE\"\nAC_SUBST([private_namespace])\n\ndnl Do not add suffix to installed files by default.\nAC_ARG_WITH([install_suffix],\n [AS_HELP_STRING([--with-install-suffix=], [Suffix to append to all installed files])],\n [case \"$with_install_suffix\" in\n *\\ * ) AC_MSG_ERROR([Install suffix should not contain spaces]) ;;\n * ) INSTALL_SUFFIX=\"$with_install_suffix\" ;;\nesac],\n [INSTALL_SUFFIX=]\n)\ninstall_suffix=\"$INSTALL_SUFFIX\"\nAC_SUBST([install_suffix])\n\ndnl Specify default malloc_conf.\nAC_ARG_WITH([malloc_conf],\n [AS_HELP_STRING([--with-malloc-conf=], [config.malloc_conf options string])],\n [JEMALLOC_CONFIG_MALLOC_CONF=\"$with_malloc_conf\"],\n [JEMALLOC_CONFIG_MALLOC_CONF=\"\"]\n)\nconfig_malloc_conf=\"$JEMALLOC_CONFIG_MALLOC_CONF\"\nAC_DEFINE_UNQUOTED([JEMALLOC_CONFIG_MALLOC_CONF], [\"$config_malloc_conf\"], [ ])\n\ndnl Substitute @je_@ in jemalloc_protos.h.in, primarily to make generation of\ndnl jemalloc_protos_jet.h easy.\nje_=\"je_\"\nAC_SUBST([je_])\n\ncfgoutputs_in=\"Makefile.in\"\ncfgoutputs_in=\"${cfgoutputs_in} jemalloc.pc.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/html.xsl.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/manpages.xsl.in\"\ncfgoutputs_in=\"${cfgoutputs_in} doc/jemalloc.xml.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_macros.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_protos.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/jemalloc_typedefs.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} include/jemalloc/internal/jemalloc_preamble.h.in\"\ncfgoutputs_in=\"${cfgoutputs_in} test/test.sh.in\"\ncfgoutputs_in=\"${cfgoutputs_in} test/include/test/jemalloc_test.h.in\"\n\ncfgoutputs_out=\"Makefile\"\ncfgoutputs_out=\"${cfgoutputs_out} jemalloc.pc\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/html.xsl\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/manpages.xsl\"\ncfgoutputs_out=\"${cfgoutputs_out} doc/jemalloc.xml\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_macros.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_protos.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/jemalloc_typedefs.h\"\ncfgoutputs_out=\"${cfgoutputs_out} include/jemalloc/internal/jemalloc_preamble.h\"\ncfgoutputs_out=\"${cfgoutputs_out} test/test.sh\"\ncfgoutputs_out=\"${cfgoutputs_out} test/include/test/jemalloc_test.h\"\n\ncfgoutputs_tup=\"Makefile\"\ncfgoutputs_tup=\"${cfgoutputs_tup} jemalloc.pc:jemalloc.pc.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/html.xsl:doc/html.xsl.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/manpages.xsl:doc/manpages.xsl.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} doc/jemalloc.xml:doc/jemalloc.xml.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_macros.h:include/jemalloc/jemalloc_macros.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_protos.h:include/jemalloc/jemalloc_protos.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/jemalloc_typedefs.h:include/jemalloc/jemalloc_typedefs.h.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} include/jemalloc/internal/jemalloc_preamble.h\"\ncfgoutputs_tup=\"${cfgoutputs_tup} test/test.sh:test/test.sh.in\"\ncfgoutputs_tup=\"${cfgoutputs_tup} test/include/test/jemalloc_test.h:test/include/test/jemalloc_test.h.in\"\n\ncfghdrs_in=\"include/jemalloc/jemalloc_defs.h.in\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/jemalloc_internal_defs.h.in\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/private_symbols.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/private_namespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/public_namespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/internal/public_unnamespace.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc_rename.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc_mangle.sh\"\ncfghdrs_in=\"${cfghdrs_in} include/jemalloc/jemalloc.sh\"\ncfghdrs_in=\"${cfghdrs_in} test/include/test/jemalloc_test_defs.h.in\"\n\ncfghdrs_out=\"include/jemalloc/jemalloc_defs.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc${install_suffix}.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/private_symbols.awk\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/private_symbols_jet.awk\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_symbols.txt\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_namespace.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/public_unnamespace.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_protos_jet.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_rename.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_mangle.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/jemalloc_mangle_jet.h\"\ncfghdrs_out=\"${cfghdrs_out} include/jemalloc/internal/jemalloc_internal_defs.h\"\ncfghdrs_out=\"${cfghdrs_out} test/include/test/jemalloc_test_defs.h\"\n\ncfghdrs_tup=\"include/jemalloc/jemalloc_defs.h:include/jemalloc/jemalloc_defs.h.in\"\ncfghdrs_tup=\"${cfghdrs_tup} include/jemalloc/internal/jemalloc_internal_defs.h:include/jemalloc/internal/jemalloc_internal_defs.h.in\"\ncfghdrs_tup=\"${cfghdrs_tup} test/include/test/jemalloc_test_defs.h:test/include/test/jemalloc_test_defs.h.in\"\n\ndnl ============================================================================\ndnl jemalloc build options.\ndnl\n\ndnl Do not compile with debugging by default.\nAC_ARG_ENABLE([debug],\n [AS_HELP_STRING([--enable-debug],\n [Build debugging code])],\n[if test \"x$enable_debug\" = \"xno\" ; then\n enable_debug=\"0\"\nelse\n enable_debug=\"1\"\nfi\n],\n[enable_debug=\"0\"]\n)\nif test \"x$enable_debug\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_DEBUG], [ ], [ ])\nfi\nAC_SUBST([enable_debug])\n\ndnl Only optimize if not debugging.\nif test \"x$enable_debug\" = \"x0\" ; then\n if test \"x$GCC\" = \"xyes\" ; then\n JE_CFLAGS_ADD([-O3])\n JE_CXXFLAGS_ADD([-O3])\n JE_CFLAGS_ADD([-funroll-loops])\n elif test \"x$je_cv_msvc\" = \"xyes\" ; then\n JE_CFLAGS_ADD([-O2])\n JE_CXXFLAGS_ADD([-O2])\n else\n JE_CFLAGS_ADD([-O])\n JE_CXXFLAGS_ADD([-O])\n fi\nfi\n\ndnl Enable statistics calculation by default.\nAC_ARG_ENABLE([stats],\n [AS_HELP_STRING([--disable-stats],\n [Disable statistics calculation/reporting])],\n[if test \"x$enable_stats\" = \"xno\" ; then\n enable_stats=\"0\"\nelse\n enable_stats=\"1\"\nfi\n],\n[enable_stats=\"1\"]\n)\nif test \"x$enable_stats\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_STATS], [ ], [ ])\nfi\nAC_SUBST([enable_stats])\n\ndnl Do not enable smallocx by default.\nAC_ARG_ENABLE([experimental_smallocx],\n [AS_HELP_STRING([--enable-experimental-smallocx], [Enable experimental smallocx API])],\n[if test \"x$enable_experimental_smallocx\" = \"xno\" ; then\nenable_experimental_smallocx=\"0\"\nelse\nenable_experimental_smallocx=\"1\"\nfi\n],\n[enable_experimental_smallocx=\"0\"]\n)\nif test \"x$enable_experimental_smallocx\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_EXPERIMENTAL_SMALLOCX_API], [ ], [ ])\nfi\nAC_SUBST([enable_experimental_smallocx])\n\ndnl Do not enable profiling by default.\nAC_ARG_ENABLE([prof],\n [AS_HELP_STRING([--enable-prof], [Enable allocation profiling])],\n[if test \"x$enable_prof\" = \"xno\" ; then\n enable_prof=\"0\"\nelse\n enable_prof=\"1\"\nfi\n],\n[enable_prof=\"0\"]\n)\nif test \"x$enable_prof\" = \"x1\" ; then\n backtrace_method=\"\"\nelse\n backtrace_method=\"N/A\"\nfi\n\nAC_ARG_ENABLE([prof-libunwind],\n [AS_HELP_STRING([--enable-prof-libunwind], [Use libunwind for backtracing])],\n[if test \"x$enable_prof_libunwind\" = \"xno\" ; then\n enable_prof_libunwind=\"0\"\nelse\n enable_prof_libunwind=\"1\"\n if test \"x$enable_prof\" = \"x0\" ; then\n AC_MSG_ERROR([--enable-prof-libunwind should only be used with --enable-prof])\n fi\nfi\n],\n[enable_prof_libunwind=\"0\"]\n)\nAC_ARG_WITH([static_libunwind],\n [AS_HELP_STRING([--with-static-libunwind=],\n [Path to static libunwind library; use rather than dynamically linking])],\nif test \"x$with_static_libunwind\" = \"xno\" ; then\n LUNWIND=\"-lunwind\"\nelse\n if test ! -f \"$with_static_libunwind\" ; then\n AC_MSG_ERROR([Static libunwind not found: $with_static_libunwind])\n fi\n LUNWIND=\"$with_static_libunwind\"\nfi,\n LUNWIND=\"-lunwind\"\n)\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_libunwind\" = \"x1\" ; then\n AC_CHECK_HEADERS([libunwind.h], , [enable_prof_libunwind=\"0\"])\n if test \"x$LUNWIND\" = \"x-lunwind\" ; then\n AC_CHECK_LIB([unwind], [unw_backtrace], [JE_APPEND_VS(LIBS, $LUNWIND)],\n [enable_prof_libunwind=\"0\"])\n else\n JE_APPEND_VS(LIBS, $LUNWIND)\n fi\n if test \"x${enable_prof_libunwind}\" = \"x1\" ; then\n backtrace_method=\"libunwind\"\n AC_DEFINE([JEMALLOC_PROF_LIBUNWIND], [ ], [ ])\n fi\nfi\n\nAC_ARG_ENABLE([prof-libgcc],\n [AS_HELP_STRING([--disable-prof-libgcc],\n [Do not use libgcc for backtracing])],\n[if test \"x$enable_prof_libgcc\" = \"xno\" ; then\n enable_prof_libgcc=\"0\"\nelse\n enable_prof_libgcc=\"1\"\nfi\n],\n[enable_prof_libgcc=\"1\"]\n)\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_libgcc\" = \"x1\" \\\n -a \"x$GCC\" = \"xyes\" ; then\n AC_CHECK_HEADERS([unwind.h], , [enable_prof_libgcc=\"0\"])\n if test \"x${enable_prof_libgcc}\" = \"x1\" ; then\n AC_CHECK_LIB([gcc], [_Unwind_Backtrace], [JE_APPEND_VS(LIBS, -lgcc)], [enable_prof_libgcc=\"0\"])\n fi\n if test \"x${enable_prof_libgcc}\" = \"x1\" ; then\n backtrace_method=\"libgcc\"\n AC_DEFINE([JEMALLOC_PROF_LIBGCC], [ ], [ ])\n fi\nelse\n enable_prof_libgcc=\"0\"\nfi\n\nAC_ARG_ENABLE([prof-gcc],\n [AS_HELP_STRING([--disable-prof-gcc],\n [Do not use gcc intrinsics for backtracing])],\n[if test \"x$enable_prof_gcc\" = \"xno\" ; then\n enable_prof_gcc=\"0\"\nelse\n enable_prof_gcc=\"1\"\nfi\n],\n[enable_prof_gcc=\"1\"]\n)\nif test \"x$backtrace_method\" = \"x\" -a \"x$enable_prof_gcc\" = \"x1\" \\\n -a \"x$GCC\" = \"xyes\" ; then\n JE_CFLAGS_ADD([-fno-omit-frame-pointer])\n backtrace_method=\"gcc intrinsics\"\n AC_DEFINE([JEMALLOC_PROF_GCC], [ ], [ ])\nelse\n enable_prof_gcc=\"0\"\nfi\n\nif test \"x$backtrace_method\" = \"x\" ; then\n backtrace_method=\"none (disabling profiling)\"\n enable_prof=\"0\"\nfi\nAC_MSG_CHECKING([configured backtracing method])\nAC_MSG_RESULT([$backtrace_method])\nif test \"x$enable_prof\" = \"x1\" ; then\n dnl Heap profiling uses the log(3) function.\n JE_APPEND_VS(LIBS, $LM)\n\n AC_DEFINE([JEMALLOC_PROF], [ ], [ ])\nfi\nAC_SUBST([enable_prof])\n\ndnl Indicate whether adjacent virtual memory mappings automatically coalesce\ndnl (and fragment on demand).\nif test \"x${maps_coalesce}\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_MAPS_COALESCE], [ ], [ ])\nfi\n\ndnl Indicate whether to retain memory (rather than using munmap()) by default.\nif test \"x$default_retain\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_RETAIN], [ ], [ ])\nfi\n\ndnl Indicate whether realloc(ptr, 0) defaults to the \"alloc\" behavior.\nif test \"x$zero_realloc_default_free\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_ZERO_REALLOC_DEFAULT_FREE], [ ], [ ])\nfi\n\ndnl Enable allocation from DSS if supported by the OS.\nhave_dss=\"1\"\ndnl Check whether the BSD/SUSv1 sbrk() exists. If not, disable DSS support.\nAC_CHECK_FUNC([sbrk], [have_sbrk=\"1\"], [have_sbrk=\"0\"])\nif test \"x$have_sbrk\" = \"x1\" ; then\n if test \"x$sbrk_deprecated\" = \"x1\" ; then\n AC_MSG_RESULT([Disabling dss allocation because sbrk is deprecated])\n have_dss=\"0\"\n fi\nelse\n have_dss=\"0\"\nfi\n\nif test \"x$have_dss\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_DSS], [ ], [ ])\nfi\n\ndnl Support the junk/zero filling option by default.\nAC_ARG_ENABLE([fill],\n [AS_HELP_STRING([--disable-fill], [Disable support for junk/zero filling])],\n[if test \"x$enable_fill\" = \"xno\" ; then\n enable_fill=\"0\"\nelse\n enable_fill=\"1\"\nfi\n],\n[enable_fill=\"1\"]\n)\nif test \"x$enable_fill\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_FILL], [ ], [ ])\nfi\nAC_SUBST([enable_fill])\n\ndnl Disable utrace(2)-based tracing by default.\nAC_ARG_ENABLE([utrace],\n [AS_HELP_STRING([--enable-utrace], [Enable utrace(2)-based tracing])],\n[if test \"x$enable_utrace\" = \"xno\" ; then\n enable_utrace=\"0\"\nelse\n enable_utrace=\"1\"\nfi\n],\n[enable_utrace=\"0\"]\n)\nJE_COMPILABLE([utrace(2)], [\n#include \n#include \n#include \n#include \n#include \n], [\n\tutrace((void *)0, 0);\n], [je_cv_utrace])\nif test \"x${je_cv_utrace}\" = \"xno\" ; then\n JE_COMPILABLE([utrace(2) with label], [\n #include \n #include \n #include \n #include \n #include \n ], [\n\t utrace((void *)0, (void *)0, 0);\n ], [je_cv_utrace_label])\n if test \"x${je_cv_utrace_label}\" = \"xno\"; then\n enable_utrace=\"0\"\n fi\n if test \"x$enable_utrace\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_UTRACE_LABEL], [ ], [ ])\n fi\nelse\n if test \"x$enable_utrace\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_UTRACE], [ ], [ ])\n fi\nfi\nAC_SUBST([enable_utrace])\n\ndnl Do not support the xmalloc option by default.\nAC_ARG_ENABLE([xmalloc],\n [AS_HELP_STRING([--enable-xmalloc], [Support xmalloc option])],\n[if test \"x$enable_xmalloc\" = \"xno\" ; then\n enable_xmalloc=\"0\"\nelse\n enable_xmalloc=\"1\"\nfi\n],\n[enable_xmalloc=\"0\"]\n)\nif test \"x$enable_xmalloc\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_XMALLOC], [ ], [ ])\nfi\nAC_SUBST([enable_xmalloc])\n\ndnl Support cache-oblivious allocation alignment by default.\nAC_ARG_ENABLE([cache-oblivious],\n [AS_HELP_STRING([--disable-cache-oblivious],\n [Disable support for cache-oblivious allocation alignment])],\n[if test \"x$enable_cache_oblivious\" = \"xno\" ; then\n enable_cache_oblivious=\"0\"\nelse\n enable_cache_oblivious=\"1\"\nfi\n],\n[enable_cache_oblivious=\"1\"]\n)\nif test \"x$enable_cache_oblivious\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_CACHE_OBLIVIOUS], [ ], [ ])\nfi\nAC_SUBST([enable_cache_oblivious])\n\ndnl Do not log by default.\nAC_ARG_ENABLE([log],\n [AS_HELP_STRING([--enable-log], [Support debug logging])],\n[if test \"x$enable_log\" = \"xno\" ; then\n enable_log=\"0\"\nelse\n enable_log=\"1\"\nfi\n],\n[enable_log=\"0\"]\n)\nif test \"x$enable_log\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_LOG], [ ], [ ])\nfi\nAC_SUBST([enable_log])\n\ndnl Do not use readlinkat by default\nAC_ARG_ENABLE([readlinkat],\n [AS_HELP_STRING([--enable-readlinkat], [Use readlinkat over readlink])],\n[if test \"x$enable_readlinkat\" = \"xno\" ; then\n enable_readlinkat=\"0\"\nelse\n enable_readlinkat=\"1\"\nfi\n],\n[enable_readlinkat=\"0\"]\n)\nif test \"x$enable_readlinkat\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_READLINKAT], [ ], [ ])\nfi\nAC_SUBST([enable_readlinkat])\n\ndnl Avoid extra safety checks by default\nAC_ARG_ENABLE([opt-safety-checks],\n [AS_HELP_STRING([--enable-opt-safety-checks],\n [Perform certain low-overhead checks, even in opt mode])],\n[if test \"x$enable_opt_safety_checks\" = \"xno\" ; then\n enable_opt_safety_checks=\"0\"\nelse\n enable_opt_safety_checks=\"1\"\nfi\n],\n[enable_opt_safety_checks=\"0\"]\n)\nif test \"x$enable_opt_safety_checks\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_OPT_SAFETY_CHECKS], [ ], [ ])\nfi\nAC_SUBST([enable_opt_safety_checks])\n\ndnl Look for sized-deallocation bugs while otherwise being in opt mode.\nAC_ARG_ENABLE([opt-size-checks],\n [AS_HELP_STRING([--enable-opt-size-checks],\n [Perform sized-deallocation argument checks, even in opt mode])],\n[if test \"x$enable_opt_size_checks\" = \"xno\" ; then\n enable_opt_size_checks=\"0\"\nelse\n enable_opt_size_checks=\"1\"\nfi\n],\n[enable_opt_size_checks=\"0\"]\n)\nif test \"x$enable_opt_size_checks\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_OPT_SIZE_CHECKS], [ ], [ ])\nfi\nAC_SUBST([enable_opt_size_checks])\n\ndnl Do not check for use-after-free by default.\nAC_ARG_ENABLE([uaf-detection],\n [AS_HELP_STRING([--enable-uaf-detection],\n [Allow sampled junk-filling on deallocation to detect use-after-free])],\n[if test \"x$enable_uaf_detection\" = \"xno\" ; then\n enable_uaf_detection=\"0\"\nelse\n enable_uaf_detection=\"1\"\nfi\n],\n[enable_uaf_detection=\"0\"]\n)\nif test \"x$enable_uaf_detection\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_UAF_DETECTION], [ ])\nfi\nAC_SUBST([enable_uaf_detection])\n\nJE_COMPILABLE([a program using __builtin_unreachable], [\nvoid foo (void) {\n __builtin_unreachable();\n}\n], [\n\t{\n\t\tfoo();\n\t}\n], [je_cv_gcc_builtin_unreachable])\nif test \"x${je_cv_gcc_builtin_unreachable}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_INTERNAL_UNREACHABLE], [__builtin_unreachable], [ ])\nelse\n AC_DEFINE([JEMALLOC_INTERNAL_UNREACHABLE], [abort], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for __builtin_ffsl(), then ffsl(3), and fail if neither are found.\ndnl One of those two functions should (theoretically) exist on all platforms\ndnl that jemalloc currently has a chance of functioning on without modification.\ndnl We additionally assume ffs[ll]() or __builtin_ffs[ll]() are defined if\ndnl ffsl() or __builtin_ffsl() are defined, respectively.\nJE_COMPILABLE([a program using __builtin_ffsl], [\n#include \n#include \n#include \n], [\n\t{\n\t\tint rv = __builtin_ffsl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n], [je_cv_gcc_builtin_ffsl])\nif test \"x${je_cv_gcc_builtin_ffsl}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_INTERNAL_FFSLL], [__builtin_ffsll], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_FFSL], [__builtin_ffsl], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_FFS], [__builtin_ffs], [ ])\nelse\n JE_COMPILABLE([a program using ffsl], [\n #include \n #include \n #include \n ], [\n\t{\n\t\tint rv = ffsl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n ], [je_cv_function_ffsl])\n if test \"x${je_cv_function_ffsl}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_INTERNAL_FFSLL], [ffsll], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_FFSL], [ffsl], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_FFS], [ffs], [ ])\n else\n AC_MSG_ERROR([Cannot build without ffsl(3) or __builtin_ffsl()])\n fi\nfi\n\nJE_COMPILABLE([a program using __builtin_popcountl], [\n#include \n#include \n#include \n], [\n\t{\n\t\tint rv = __builtin_popcountl(0x08);\n\t\tprintf(\"%d\\n\", rv);\n\t}\n], [je_cv_gcc_builtin_popcountl])\nif test \"x${je_cv_gcc_builtin_popcountl}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_INTERNAL_POPCOUNT], [__builtin_popcount], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_POPCOUNTL], [__builtin_popcountl], [ ])\n AC_DEFINE([JEMALLOC_INTERNAL_POPCOUNTLL], [__builtin_popcountll], [ ])\nfi\n\nAC_ARG_WITH([lg_quantum],\n [AS_HELP_STRING([--with-lg-quantum=],\n [Base 2 log of minimum allocation alignment])])\nif test \"x$with_lg_quantum\" != \"x\" ; then\n AC_DEFINE_UNQUOTED([LG_QUANTUM], [$with_lg_quantum], [ ])\nfi\n\nAC_ARG_WITH([lg_slab_maxregs],\n [AS_HELP_STRING([--with-lg-slab-maxregs=],\n [Base 2 log of maximum number of regions in a slab (used with malloc_conf slab_sizes)])],\n [CONFIG_LG_SLAB_MAXREGS=\"with_lg_slab_maxregs\"],\n [CONFIG_LG_SLAB_MAXREGS=\"\"])\nif test \"x$with_lg_slab_maxregs\" != \"x\" ; then\n AC_DEFINE_UNQUOTED([CONFIG_LG_SLAB_MAXREGS], [$with_lg_slab_maxregs], [ ])\nfi\n\nAC_ARG_WITH([lg_page],\n [AS_HELP_STRING([--with-lg-page=], [Base 2 log of system page size])],\n [LG_PAGE=\"$with_lg_page\"], [LG_PAGE=\"detect\"])\ncase \"${host}\" in\n aarch64-apple-darwin*)\n dnl When cross-compile for Apple M1 and no page size specified, use the\n dnl default and skip detecting the page size (which is likely incorrect).\n if test \"x${host}\" != \"x${build}\" -a \"x$LG_PAGE\" = \"xdetect\"; then\n LG_PAGE=14\n fi\n ;;\nesac\nif test \"x$LG_PAGE\" = \"xdetect\"; then\n AC_CACHE_CHECK([LG_PAGE],\n [je_cv_lg_page],\n AC_RUN_IFELSE([AC_LANG_PROGRAM(\n[[\n#include \n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n#include \n]],\n[[\n int result;\n FILE *f;\n\n#ifdef _WIN32\n SYSTEM_INFO si;\n GetSystemInfo(&si);\n result = si.dwPageSize;\n#else\n result = sysconf(_SC_PAGESIZE);\n#endif\n if (result == -1) {\n\treturn 1;\n }\n result = JEMALLOC_INTERNAL_FFSL(result) - 1;\n\n f = fopen(\"conftest.out\", \"w\");\n if (f == NULL) {\n\treturn 1;\n }\n fprintf(f, \"%d\", result);\n fclose(f);\n\n return 0;\n]])],\n [je_cv_lg_page=`cat conftest.out`],\n [je_cv_lg_page=undefined],\n [je_cv_lg_page=12]))\nfi\nif test \"x${je_cv_lg_page}\" != \"x\" ; then\n LG_PAGE=\"${je_cv_lg_page}\"\nfi\nif test \"x${LG_PAGE}\" != \"xundefined\" ; then\n AC_DEFINE_UNQUOTED([LG_PAGE], [$LG_PAGE], [ ])\nelse\n AC_MSG_ERROR([cannot determine value for LG_PAGE])\nfi\n\nAC_ARG_WITH([lg_hugepage],\n [AS_HELP_STRING([--with-lg-hugepage=],\n [Base 2 log of system huge page size])],\n [je_cv_lg_hugepage=\"${with_lg_hugepage}\"],\n [je_cv_lg_hugepage=\"\"])\nif test \"x${je_cv_lg_hugepage}\" = \"x\" ; then\n dnl Look in /proc/meminfo (Linux-specific) for information on the default huge\n dnl page size, if any. The relevant line looks like:\n dnl\n dnl Hugepagesize: 2048 kB\n if test -e \"/proc/meminfo\" ; then\n hpsk=[`cat /proc/meminfo 2>/dev/null | \\\n grep -e '^Hugepagesize:[[:space:]]\\+[0-9]\\+[[:space:]]kB$' | \\\n awk '{print $2}'`]\n if test \"x${hpsk}\" != \"x\" ; then\n je_cv_lg_hugepage=10\n while test \"${hpsk}\" -gt 1 ; do\n hpsk=\"$((hpsk / 2))\"\n je_cv_lg_hugepage=\"$((je_cv_lg_hugepage + 1))\"\n done\n fi\n fi\n\n dnl Set default if unable to automatically configure.\n if test \"x${je_cv_lg_hugepage}\" = \"x\" ; then\n je_cv_lg_hugepage=21\n fi\nfi\nif test \"x${LG_PAGE}\" != \"xundefined\" -a \\\n \"${je_cv_lg_hugepage}\" -lt \"${LG_PAGE}\" ; then\n AC_MSG_ERROR([Huge page size (2^${je_cv_lg_hugepage}) must be at least page size (2^${LG_PAGE})])\nfi\nAC_DEFINE_UNQUOTED([LG_HUGEPAGE], [${je_cv_lg_hugepage}], [ ])\n\ndnl ============================================================================\ndnl Enable libdl by default.\nAC_ARG_ENABLE([libdl],\n [AS_HELP_STRING([--disable-libdl],\n [Do not use libdl])],\n[if test \"x$enable_libdl\" = \"xno\" ; then\n enable_libdl=\"0\"\nelse\n enable_libdl=\"1\"\nfi\n],\n[enable_libdl=\"1\"]\n)\nAC_SUBST([libdl])\n\ndnl ============================================================================\ndnl Configure pthreads.\n\nif test \"x$abi\" != \"xpecoff\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD], [ ], [ ])\n AC_CHECK_HEADERS([pthread.h], , [AC_MSG_ERROR([pthread.h is missing])])\n dnl Some systems may embed pthreads functionality in libc; check for libpthread\n dnl first, but try libc too before failing.\n AC_CHECK_LIB([pthread], [pthread_create], [JE_APPEND_VS(LIBS, -pthread)],\n [AC_SEARCH_LIBS([pthread_create], , ,\n AC_MSG_ERROR([libpthread is missing]))])\n wrap_syms=\"${wrap_syms} pthread_create\"\n have_pthread=\"1\"\n\ndnl Check if we have dlsym support.\n if test \"x$enable_libdl\" = \"x1\" ; then\n have_dlsym=\"1\"\n AC_CHECK_HEADERS([dlfcn.h],\n AC_CHECK_FUNC([dlsym], [],\n [AC_CHECK_LIB([dl], [dlsym], [LIBS=\"$LIBS -ldl\"], [have_dlsym=\"0\"])]),\n [have_dlsym=\"0\"])\n if test \"x$have_dlsym\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_DLSYM], [ ], [ ])\n fi\n else\n have_dlsym=\"0\"\n fi\n\n JE_COMPILABLE([pthread_atfork(3)], [\n#include \n], [\n pthread_atfork((void *)0, (void *)0, (void *)0);\n], [je_cv_pthread_atfork])\n if test \"x${je_cv_pthread_atfork}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD_ATFORK], [ ], [ ])\n fi\n dnl Check if pthread_setname_np is available with the expected API.\n JE_COMPILABLE([pthread_setname_np(3)], [\n#include \n], [\n pthread_setname_np(pthread_self(), \"setname_test\");\n], [je_cv_pthread_setname_np])\n if test \"x${je_cv_pthread_setname_np}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD_SETNAME_NP], [ ], [ ])\n fi\n dnl Check if pthread_getname_np is not necessarily present despite\n dnl the pthread_setname_np counterpart\n JE_COMPILABLE([pthread_getname_np(3)], [\n#include \n#include \n], [\n {\n \tchar *name = malloc(16);\n \tpthread_getname_np(pthread_self(), name, 16);\n\tfree(name);\n }\n], [je_cv_pthread_getname_np])\n if test \"x${je_cv_pthread_getname_np}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD_GETNAME_NP], [ ], [ ])\n fi\n dnl Check if pthread_get_name_np is not necessarily present despite\n dnl the pthread_set_name_np counterpart\n JE_COMPILABLE([pthread_get_name_np(3)], [\n#include \n#include \n#include \n], [\n {\n \tchar *name = malloc(16);\n \tpthread_get_name_np(pthread_self(), name, 16);\n\tfree(name);\n }\n], [je_cv_pthread_get_name_np])\n if test \"x${je_cv_pthread_get_name_np}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD_GET_NAME_NP], [ ], [ ])\n fi\nfi\n\nJE_APPEND_VS(CPPFLAGS, -D_REENTRANT)\n\ndnl Check whether clock_gettime(2) is in libc or librt.\nAC_SEARCH_LIBS([clock_gettime], [rt])\n\ndnl Cray wrapper compiler often adds `-lrt` when using `-static`. Check with\ndnl `-dynamic` as well in case a user tries to dynamically link in jemalloc\nif test \"x$je_cv_cray_prgenv_wrapper\" = \"xyes\" ; then\n if test \"$ac_cv_search_clock_gettime\" != \"-lrt\"; then\n JE_CFLAGS_SAVE()\n\n unset ac_cv_search_clock_gettime\n JE_CFLAGS_ADD([-dynamic])\n AC_SEARCH_LIBS([clock_gettime], [rt])\n\n JE_CFLAGS_RESTORE()\n fi\nfi\n\ndnl check for CLOCK_MONOTONIC_COARSE (Linux-specific).\nJE_COMPILABLE([clock_gettime(CLOCK_MONOTONIC_COARSE, ...)], [\n#include \n], [\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC_COARSE, &ts);\n], [je_cv_clock_monotonic_coarse])\nif test \"x${je_cv_clock_monotonic_coarse}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE], [ ], [ ])\nfi\n\ndnl check for CLOCK_MONOTONIC.\nJE_COMPILABLE([clock_gettime(CLOCK_MONOTONIC, ...)], [\n#include \n#include \n], [\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC, &ts);\n#if !defined(_POSIX_MONOTONIC_CLOCK) || _POSIX_MONOTONIC_CLOCK < 0\n# error _POSIX_MONOTONIC_CLOCK missing/invalid\n#endif\n], [je_cv_clock_monotonic])\nif test \"x${je_cv_clock_monotonic}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_CLOCK_MONOTONIC], [ ], [ ])\nfi\n\ndnl Check for mach_absolute_time().\nJE_COMPILABLE([mach_absolute_time()], [\n#include \n], [\n\tmach_absolute_time();\n], [je_cv_mach_absolute_time])\nif test \"x${je_cv_mach_absolute_time}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_MACH_ABSOLUTE_TIME], [ ], [ ])\nfi\n\ndnl check for CLOCK_REALTIME (always should be available on Linux)\nJE_COMPILABLE([clock_gettime(CLOCK_REALTIME, ...)], [\n#include \n], [\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_REALTIME, &ts);\n], [je_cv_clock_realtime])\nif test \"x${je_cv_clock_realtime}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_CLOCK_REALTIME], [ ], [ ])\nfi\n\ndnl Use syscall(2) (if available) by default.\nAC_ARG_ENABLE([syscall],\n [AS_HELP_STRING([--disable-syscall], [Disable use of syscall(2)])],\n[if test \"x$enable_syscall\" = \"xno\" ; then\n enable_syscall=\"0\"\nelse\n enable_syscall=\"1\"\nfi\n],\n[enable_syscall=\"1\"]\n)\nif test \"x$enable_syscall\" = \"x1\" ; then\n dnl Check if syscall(2) is usable. Treat warnings as errors, so that e.g. OS\n dnl X 10.12's deprecation warning prevents use.\n JE_CFLAGS_SAVE()\n JE_CFLAGS_ADD([-Werror])\n JE_COMPILABLE([syscall(2)], [\n#include \n#include \n], [\n\tsyscall(SYS_write, 2, \"hello\", 5);\n],\n [je_cv_syscall])\n JE_CFLAGS_RESTORE()\n if test \"x$je_cv_syscall\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_USE_SYSCALL], [ ], [ ])\n fi\nfi\n\ndnl Check if the GNU-specific secure_getenv function exists.\nAC_CHECK_FUNC([secure_getenv],\n [have_secure_getenv=\"1\"],\n [have_secure_getenv=\"0\"]\n )\nif test \"x$have_secure_getenv\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_SECURE_GETENV], [ ], [ ])\nfi\n\ndnl Check if the GNU-specific sched_getcpu function exists.\nAC_CHECK_FUNC([sched_getcpu],\n [have_sched_getcpu=\"1\"],\n [have_sched_getcpu=\"0\"]\n )\nif test \"x$have_sched_getcpu\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_SCHED_GETCPU], [ ], [ ])\nfi\n\ndnl Check if the GNU-specific sched_setaffinity function exists.\nAC_CHECK_FUNC([sched_setaffinity],\n [have_sched_setaffinity=\"1\"],\n [have_sched_setaffinity=\"0\"]\n )\nif test \"x$have_sched_setaffinity\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_SCHED_SETAFFINITY], [ ], [ ])\nfi\n\ndnl Check if the Solaris/BSD issetugid function exists.\nAC_CHECK_FUNC([issetugid],\n [have_issetugid=\"1\"],\n [have_issetugid=\"0\"]\n )\nif test \"x$have_issetugid\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_ISSETUGID], [ ], [ ])\nfi\n\ndnl Check whether the BSD-specific _malloc_thread_cleanup() exists. If so, use\ndnl it rather than pthreads TSD cleanup functions to support cleanup during\ndnl thread exit, in order to avoid pthreads library recursion during\ndnl bootstrapping.\nAC_CHECK_FUNC([_malloc_thread_cleanup],\n [have__malloc_thread_cleanup=\"1\"],\n [have__malloc_thread_cleanup=\"0\"]\n )\nif test \"x$have__malloc_thread_cleanup\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_MALLOC_THREAD_CLEANUP], [ ], [ ])\n wrap_syms=\"${wrap_syms} _malloc_thread_cleanup _malloc_tsd_cleanup_register\"\n force_tls=\"1\"\nfi\n\ndnl Check whether the BSD-specific _pthread_mutex_init_calloc_cb() exists. If\ndnl so, mutex initialization causes allocation, and we need to implement this\ndnl callback function in order to prevent recursive allocation.\nAC_CHECK_FUNC([_pthread_mutex_init_calloc_cb],\n [have__pthread_mutex_init_calloc_cb=\"1\"],\n [have__pthread_mutex_init_calloc_cb=\"0\"]\n )\nif test \"x$have__pthread_mutex_init_calloc_cb\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_MUTEX_INIT_CB], [ ], [ ])\n wrap_syms=\"${wrap_syms} _malloc_prefork _malloc_postfork\"\nfi\n\nAC_CHECK_FUNC([memcntl],\n\t [have_memcntl=\"1\"],\n\t [have_memcntl=\"0\"],\n\t )\nif test \"x$have_memcntl\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_HAVE_MEMCNTL], [ ], [ ])\nfi\n\ndnl Disable lazy locking by default.\nAC_ARG_ENABLE([lazy_lock],\n [AS_HELP_STRING([--enable-lazy-lock],\n [Enable lazy locking (only lock when multi-threaded)])],\n[if test \"x$enable_lazy_lock\" = \"xno\" ; then\n enable_lazy_lock=\"0\"\nelse\n enable_lazy_lock=\"1\"\nfi\n],\n[enable_lazy_lock=\"\"]\n)\nif test \"x${enable_lazy_lock}\" = \"x\" ; then\n if test \"x${force_lazy_lock}\" = \"x1\" ; then\n AC_MSG_RESULT([Forcing lazy-lock to avoid allocator/threading bootstrap issues])\n enable_lazy_lock=\"1\"\n else\n enable_lazy_lock=\"0\"\n fi\nfi\nif test \"x${enable_lazy_lock}\" = \"x1\" -a \"x${abi}\" = \"xpecoff\" ; then\n AC_MSG_RESULT([Forcing no lazy-lock because thread creation monitoring is unimplemented])\n enable_lazy_lock=\"0\"\nfi\nif test \"x$enable_lazy_lock\" = \"x1\" ; then\n if test \"x$have_dlsym\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_LAZY_LOCK], [ ], [ ])\n else\n AC_MSG_ERROR([Missing dlsym support: lazy-lock cannot be enabled.])\n fi\nfi\nAC_SUBST([enable_lazy_lock])\n\ndnl Automatically configure TLS.\nif test \"x${force_tls}\" = \"x1\" ; then\n enable_tls=\"1\"\nelif test \"x${force_tls}\" = \"x0\" ; then\n enable_tls=\"0\"\nelse\n enable_tls=\"1\"\nfi\nif test \"x${enable_tls}\" = \"x1\" ; then\nAC_MSG_CHECKING([for TLS])\nAC_COMPILE_IFELSE([AC_LANG_PROGRAM(\n[[\n __thread int x;\n]], [[\n x = 42;\n\n return 0;\n]])],\n AC_MSG_RESULT([yes]),\n AC_MSG_RESULT([no])\n enable_tls=\"0\")\nelse\n enable_tls=\"0\"\nfi\nAC_SUBST([enable_tls])\nif test \"x${enable_tls}\" = \"x1\" ; then\n AC_DEFINE_UNQUOTED([JEMALLOC_TLS], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for C11 atomics.\n\nJE_COMPILABLE([C11 atomics], [\n#include \n#if (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)\n#include \n#else\n#error Atomics not available\n#endif\n], [\n uint64_t *p = (uint64_t *)0;\n uint64_t x = 1;\n volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p;\n uint64_t r = atomic_fetch_add(a, x) + x;\n return r == 0;\n], [je_cv_c11_atomics])\nif test \"x${je_cv_c11_atomics}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_C11_ATOMICS], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for GCC-style __atomic atomics.\n\nJE_COMPILABLE([GCC __atomic atomics], [\n], [\n int x = 0;\n int val = 1;\n int y = __atomic_fetch_add(&x, val, __ATOMIC_RELAXED);\n int after_add = x;\n return after_add == 1;\n], [je_cv_gcc_atomic_atomics])\nif test \"x${je_cv_gcc_atomic_atomics}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_GCC_ATOMIC_ATOMICS], [ ], [ ])\n\n dnl check for 8-bit atomic support\n JE_COMPILABLE([GCC 8-bit __atomic atomics], [\n ], [\n unsigned char x = 0;\n int val = 1;\n int y = __atomic_fetch_add(&x, val, __ATOMIC_RELAXED);\n int after_add = (int)x;\n return after_add == 1;\n ], [je_cv_gcc_u8_atomic_atomics])\n if test \"x${je_cv_gcc_u8_atomic_atomics}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_GCC_U8_ATOMIC_ATOMICS], [ ], [ ])\n fi\nfi\n\ndnl ============================================================================\ndnl Check for GCC-style __sync atomics.\n\nJE_COMPILABLE([GCC __sync atomics], [\n], [\n int x = 0;\n int before_add = __sync_fetch_and_add(&x, 1);\n int after_add = x;\n return (before_add == 0) && (after_add == 1);\n], [je_cv_gcc_sync_atomics])\nif test \"x${je_cv_gcc_sync_atomics}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_GCC_SYNC_ATOMICS], [ ], [ ])\n\n dnl check for 8-bit atomic support\n JE_COMPILABLE([GCC 8-bit __sync atomics], [\n ], [\n unsigned char x = 0;\n int before_add = __sync_fetch_and_add(&x, 1);\n int after_add = (int)x;\n return (before_add == 0) && (after_add == 1);\n ], [je_cv_gcc_u8_sync_atomics])\n if test \"x${je_cv_gcc_u8_sync_atomics}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_GCC_U8_SYNC_ATOMICS], [ ], [ ])\n fi\nfi\n\ndnl ============================================================================\ndnl Check for atomic(3) operations as provided on Darwin.\ndnl We need this not for the atomic operations (which are provided above), but\ndnl rather for the OS_unfair_lock type it exposes.\n\nJE_COMPILABLE([Darwin OSAtomic*()], [\n#include \n#include \n], [\n\t{\n\t\tint32_t x32 = 0;\n\t\tvolatile int32_t *x32p = &x32;\n\t\tOSAtomicAdd32(1, x32p);\n\t}\n\t{\n\t\tint64_t x64 = 0;\n\t\tvolatile int64_t *x64p = &x64;\n\t\tOSAtomicAdd64(1, x64p);\n\t}\n], [je_cv_osatomic])\nif test \"x${je_cv_osatomic}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_OSATOMIC], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for madvise(2).\n\nJE_COMPILABLE([madvise(2)], [\n#include \n], [\n\tmadvise((void *)0, 0, 0);\n], [je_cv_madvise])\nif test \"x${je_cv_madvise}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_MADVISE], [ ], [ ])\n\n dnl Check for madvise(..., MADV_FREE).\n JE_COMPILABLE([madvise(..., MADV_FREE)], [\n#include \n], [\n\tmadvise((void *)0, 0, MADV_FREE);\n], [je_cv_madv_free])\n if test \"x${je_cv_madv_free}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ], [ ])\n elif test \"x${je_cv_madvise}\" = \"xyes\" ; then\n case \"${host_cpu}\" in i686|x86_64)\n case \"${host}\" in *-*-linux*)\n AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ], [ ])\n AC_DEFINE([JEMALLOC_DEFINE_MADVISE_FREE], [ ], [ ])\n\t ;;\n esac\n ;;\n esac\n fi\n\n dnl Check for madvise(..., MADV_DONTNEED).\n JE_COMPILABLE([madvise(..., MADV_DONTNEED)], [\n#include \n], [\n\tmadvise((void *)0, 0, MADV_DONTNEED);\n], [je_cv_madv_dontneed])\n if test \"x${je_cv_madv_dontneed}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED], [ ], [ ])\n fi\n\n dnl Check for madvise(..., MADV_DO[NT]DUMP).\n JE_COMPILABLE([madvise(..., MADV_DO[[NT]]DUMP)], [\n#include \n], [\n\tmadvise((void *)0, 0, MADV_DONTDUMP);\n\tmadvise((void *)0, 0, MADV_DODUMP);\n], [je_cv_madv_dontdump])\n if test \"x${je_cv_madv_dontdump}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_MADVISE_DONTDUMP], [ ], [ ])\n fi\n\n dnl Check for madvise(..., MADV_[NO]HUGEPAGE).\n JE_COMPILABLE([madvise(..., MADV_[[NO]]HUGEPAGE)], [\n#include \n], [\n\tmadvise((void *)0, 0, MADV_HUGEPAGE);\n\tmadvise((void *)0, 0, MADV_NOHUGEPAGE);\n], [je_cv_thp])\n dnl Check for madvise(..., MADV_[NO]CORE).\n JE_COMPILABLE([madvise(..., MADV_[[NO]]CORE)], [\n#include \n], [\n\tmadvise((void *)0, 0, MADV_NOCORE);\n\tmadvise((void *)0, 0, MADV_CORE);\n], [je_cv_madv_nocore])\n if test \"x${je_cv_madv_nocore}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_MADVISE_NOCORE], [ ], [ ])\n fi\ncase \"${host_cpu}\" in\n arm*)\n ;;\n *)\n if test \"x${je_cv_thp}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_MADVISE_HUGE], [ ], [ ])\n fi\n ;;\nesac\nelse\n dnl Check for posix_madvise.\n JE_COMPILABLE([posix_madvise], [\n #include \n ], [\n posix_madvise((void *)0, 0, 0);\n ], [je_cv_posix_madvise])\n if test \"x${je_cv_posix_madvise}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_POSIX_MADVISE], [ ], [ ])\n\n dnl Check for posix_madvise(..., POSIX_MADV_DONTNEED).\n JE_COMPILABLE([posix_madvise(..., POSIX_MADV_DONTNEED)], [\n #include \n ], [\n posix_madvise((void *)0, 0, POSIX_MADV_DONTNEED);\n ], [je_cv_posix_madv_dontneed])\n if test \"x${je_cv_posix_madv_dontneed}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED], [ ], [ ])\n fi\n fi\nfi\n\ndnl ============================================================================\ndnl Check for mprotect(2).\n\nJE_COMPILABLE([mprotect(2)], [\n#include \n], [\n\tmprotect((void *)0, 0, PROT_NONE);\n], [je_cv_mprotect])\nif test \"x${je_cv_mprotect}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_MPROTECT], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for __builtin_clz(), __builtin_clzl(), and __builtin_clzll().\n\nAC_CACHE_CHECK([for __builtin_clz],\n [je_cv_builtin_clz],\n [AC_LINK_IFELSE([AC_LANG_PROGRAM([],\n [\n {\n unsigned x = 0;\n int y = __builtin_clz(x);\n }\n {\n unsigned long x = 0;\n int y = __builtin_clzl(x);\n }\n {\n unsigned long long x = 0;\n int y = __builtin_clzll(x);\n }\n ])],\n [je_cv_builtin_clz=yes],\n [je_cv_builtin_clz=no])])\n\nif test \"x${je_cv_builtin_clz}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_BUILTIN_CLZ], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for os_unfair_lock operations as provided on Darwin.\n\nJE_COMPILABLE([Darwin os_unfair_lock_*()], [\n#include \n#include \n], [\n\t#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200\n\t#error \"os_unfair_lock is not supported\"\n\t#else\n\tos_unfair_lock lock = OS_UNFAIR_LOCK_INIT;\n\tos_unfair_lock_lock(&lock);\n\tos_unfair_lock_unlock(&lock);\n\t#endif\n], [je_cv_os_unfair_lock])\nif test \"x${je_cv_os_unfair_lock}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_OS_UNFAIR_LOCK], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Darwin-related configuration.\n\nAC_ARG_ENABLE([zone-allocator],\n [AS_HELP_STRING([--disable-zone-allocator],\n [Disable zone allocator for Darwin])],\n[if test \"x$enable_zone_allocator\" = \"xno\" ; then\n enable_zone_allocator=\"0\"\nelse\n enable_zone_allocator=\"1\"\nfi\n],\n[if test \"x${abi}\" = \"xmacho\"; then\n enable_zone_allocator=\"1\"\nfi\n]\n)\nAC_SUBST([enable_zone_allocator])\n\nif test \"x${enable_zone_allocator}\" = \"x1\" ; then\n if test \"x${abi}\" != \"xmacho\"; then\n AC_MSG_ERROR([--enable-zone-allocator is only supported on Darwin])\n fi\n AC_DEFINE([JEMALLOC_ZONE], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Use initial-exec TLS by default.\nAC_ARG_ENABLE([initial-exec-tls],\n [AS_HELP_STRING([--disable-initial-exec-tls],\n [Disable the initial-exec tls model])],\n[if test \"x$enable_initial_exec_tls\" = \"xno\" ; then\n enable_initial_exec_tls=\"0\"\nelse\n enable_initial_exec_tls=\"1\"\nfi\n],\n[enable_initial_exec_tls=\"1\"]\n)\nAC_SUBST([enable_initial_exec_tls])\n\nif test \"x${je_cv_tls_model}\" = \"xyes\" -a \\\n \"x${enable_initial_exec_tls}\" = \"x1\" ; then\n AC_DEFINE([JEMALLOC_TLS_MODEL],\n [__attribute__((tls_model(\"initial-exec\")))], \n [ ])\nelse\n AC_DEFINE([JEMALLOC_TLS_MODEL], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Enable background threads if possible.\n\nif test \"x${have_pthread}\" = \"x1\" -a \"x${je_cv_os_unfair_lock}\" != \"xyes\" -a \\\n \"x${abi}\" != \"xmacho\" ; then\n AC_DEFINE([JEMALLOC_BACKGROUND_THREAD], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for glibc malloc hooks\n\nif test \"x$glibc\" = \"x1\" ; then\n JE_COMPILABLE([glibc malloc hook], [\n #include \n\n extern void (* __free_hook)(void *ptr);\n extern void *(* __malloc_hook)(size_t size);\n extern void *(* __realloc_hook)(void *ptr, size_t size);\n], [\n void *ptr = 0L;\n if (__malloc_hook) ptr = __malloc_hook(1);\n if (__realloc_hook) ptr = __realloc_hook(ptr, 2);\n if (__free_hook && ptr) __free_hook(ptr);\n], [je_cv_glibc_malloc_hook])\n if test \"x${je_cv_glibc_malloc_hook}\" = \"xyes\" ; then\n if test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n AC_DEFINE([JEMALLOC_GLIBC_MALLOC_HOOK], [ ], [ ])\n wrap_syms=\"${wrap_syms} __free_hook __malloc_hook __realloc_hook\"\n fi\n fi\n\n JE_COMPILABLE([glibc memalign hook], [\n #include \n\n extern void *(* __memalign_hook)(size_t alignment, size_t size);\n], [\n void *ptr = 0L;\n if (__memalign_hook) ptr = __memalign_hook(16, 7);\n], [je_cv_glibc_memalign_hook])\n if test \"x${je_cv_glibc_memalign_hook}\" = \"xyes\" ; then\n if test \"x${JEMALLOC_PREFIX}\" = \"x\" ; then\n AC_DEFINE([JEMALLOC_GLIBC_MEMALIGN_HOOK], [ ], [ ])\n wrap_syms=\"${wrap_syms} __memalign_hook\"\n fi\n fi\nfi\n\nJE_COMPILABLE([pthreads adaptive mutexes], [\n#include \n], [\n pthread_mutexattr_t attr;\n pthread_mutexattr_init(&attr);\n pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);\n pthread_mutexattr_destroy(&attr);\n], [je_cv_pthread_mutex_adaptive_np])\nif test \"x${je_cv_pthread_mutex_adaptive_np}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], [ ], [ ])\nfi\n\nJE_CFLAGS_SAVE()\nJE_CFLAGS_ADD([-D_GNU_SOURCE])\nJE_CFLAGS_ADD([-Werror])\nJE_CFLAGS_ADD([-herror_on_warning])\nJE_COMPILABLE([strerror_r returns char with gnu source], [\n#include \n#include \n#include \n#include \n], [\n char *buffer = (char *) malloc(100);\n char *error = strerror_r(EINVAL, buffer, 100);\n printf(\"%s\\n\", error);\n], [je_cv_strerror_r_returns_char_with_gnu_source])\nJE_CFLAGS_RESTORE()\nif test \"x${je_cv_strerror_r_returns_char_with_gnu_source}\" = \"xyes\" ; then\n AC_DEFINE([JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE], [ ], [ ])\nfi\n\ndnl ============================================================================\ndnl Check for typedefs, structures, and compiler characteristics.\nAC_HEADER_STDBOOL\n\ndnl ============================================================================\ndnl Define commands that generate output files.\n\nAC_CONFIG_COMMANDS([include/jemalloc/internal/public_symbols.txt], [\n f=\"${objroot}include/jemalloc/internal/public_symbols.txt\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n cp /dev/null \"${f}\"\n for nm in `echo ${mangling_map} |tr ',' ' '` ; do\n n=`echo ${nm} |tr ':' ' ' |awk '{print $[]1}'`\n m=`echo ${nm} |tr ':' ' ' |awk '{print $[]2}'`\n echo \"${n}:${m}\" >> \"${f}\"\n dnl Remove name from public_syms so that it isn't redefined later.\n public_syms=`for sym in ${public_syms}; do echo \"${sym}\"; done |grep -v \"^${n}\\$\" |tr '\\n' ' '`\n done\n for sym in ${public_syms} ; do\n n=\"${sym}\"\n m=\"${JEMALLOC_PREFIX}${sym}\"\n echo \"${n}:${m}\" >> \"${f}\"\n done\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n mangling_map=\"${mangling_map}\"\n public_syms=\"${public_syms}\"\n JEMALLOC_PREFIX=\"${JEMALLOC_PREFIX}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/internal/private_symbols.awk], [\n f=\"${objroot}include/jemalloc/internal/private_symbols.awk\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n export_syms=`for sym in ${public_syms}; do echo \"${JEMALLOC_PREFIX}${sym}\"; done; for sym in ${wrap_syms}; do echo \"${sym}\"; done;`\n \"${srcdir}/include/jemalloc/internal/private_symbols.sh\" \"${SYM_PREFIX}\" ${export_syms} > \"${objroot}include/jemalloc/internal/private_symbols.awk\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n public_syms=\"${public_syms}\"\n wrap_syms=\"${wrap_syms}\"\n SYM_PREFIX=\"${SYM_PREFIX}\"\n JEMALLOC_PREFIX=\"${JEMALLOC_PREFIX}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/internal/private_symbols_jet.awk], [\n f=\"${objroot}include/jemalloc/internal/private_symbols_jet.awk\"\n mkdir -p \"${objroot}include/jemalloc/internal\"\n export_syms=`for sym in ${public_syms}; do echo \"jet_${sym}\"; done; for sym in ${wrap_syms}; do echo \"${sym}\"; done;`\n \"${srcdir}/include/jemalloc/internal/private_symbols.sh\" \"${SYM_PREFIX}\" ${export_syms} > \"${objroot}include/jemalloc/internal/private_symbols_jet.awk\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n public_syms=\"${public_syms}\"\n wrap_syms=\"${wrap_syms}\"\n SYM_PREFIX=\"${SYM_PREFIX}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/internal/public_namespace.h], [\n mkdir -p \"${objroot}include/jemalloc/internal\"\n \"${srcdir}/include/jemalloc/internal/public_namespace.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/internal/public_namespace.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/internal/public_unnamespace.h], [\n mkdir -p \"${objroot}include/jemalloc/internal\"\n \"${srcdir}/include/jemalloc/internal/public_unnamespace.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/internal/public_unnamespace.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/jemalloc_protos_jet.h], [\n mkdir -p \"${objroot}include/jemalloc\"\n cat \"${srcdir}/include/jemalloc/jemalloc_protos.h.in\" | sed -e 's/@je_@/jet_/g' > \"${objroot}include/jemalloc/jemalloc_protos_jet.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/jemalloc_rename.h], [\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_rename.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" > \"${objroot}include/jemalloc/jemalloc_rename.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle.h], [\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_mangle.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" je_ > \"${objroot}include/jemalloc/jemalloc_mangle.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle_jet.h], [\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc_mangle.sh\" \"${objroot}include/jemalloc/internal/public_symbols.txt\" jet_ > \"${objroot}include/jemalloc/jemalloc_mangle_jet.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n])\nAC_CONFIG_COMMANDS([include/jemalloc/jemalloc.h], [\n mkdir -p \"${objroot}include/jemalloc\"\n \"${srcdir}/include/jemalloc/jemalloc.sh\" \"${objroot}\" > \"${objroot}include/jemalloc/jemalloc${install_suffix}.h\"\n], [\n srcdir=\"${srcdir}\"\n objroot=\"${objroot}\"\n install_suffix=\"${install_suffix}\"\n])\n\ndnl Process .in files.\nAC_SUBST([cfghdrs_in])\nAC_SUBST([cfghdrs_out])\nAC_CONFIG_HEADERS([$cfghdrs_tup])\n\ndnl ============================================================================\ndnl Generate outputs.\n\nAC_CONFIG_FILES([$cfgoutputs_tup config.stamp bin/jemalloc-config bin/jemalloc.sh bin/jeprof])\nAC_SUBST([cfgoutputs_in])\nAC_SUBST([cfgoutputs_out])\nAC_OUTPUT\n\ndnl ============================================================================\ndnl Print out the results of configuration.\nAC_MSG_RESULT([===============================================================================])\nAC_MSG_RESULT([jemalloc version : ${jemalloc_version}])\nAC_MSG_RESULT([library revision : ${rev}])\nAC_MSG_RESULT([])\nAC_MSG_RESULT([CONFIG : ${CONFIG}])\nAC_MSG_RESULT([CC : ${CC}])\nAC_MSG_RESULT([CONFIGURE_CFLAGS : ${CONFIGURE_CFLAGS}])\nAC_MSG_RESULT([SPECIFIED_CFLAGS : ${SPECIFIED_CFLAGS}])\nAC_MSG_RESULT([EXTRA_CFLAGS : ${EXTRA_CFLAGS}])\nAC_MSG_RESULT([CPPFLAGS : ${CPPFLAGS}])\nAC_MSG_RESULT([CXX : ${CXX}])\nAC_MSG_RESULT([CONFIGURE_CXXFLAGS : ${CONFIGURE_CXXFLAGS}])\nAC_MSG_RESULT([SPECIFIED_CXXFLAGS : ${SPECIFIED_CXXFLAGS}])\nAC_MSG_RESULT([EXTRA_CXXFLAGS : ${EXTRA_CXXFLAGS}])\nAC_MSG_RESULT([LDFLAGS : ${LDFLAGS}])\nAC_MSG_RESULT([EXTRA_LDFLAGS : ${EXTRA_LDFLAGS}])\nAC_MSG_RESULT([DSO_LDFLAGS : ${DSO_LDFLAGS}])\nAC_MSG_RESULT([LIBS : ${LIBS}])\nAC_MSG_RESULT([RPATH_EXTRA : ${RPATH_EXTRA}])\nAC_MSG_RESULT([])\nAC_MSG_RESULT([XSLTPROC : ${XSLTPROC}])\nAC_MSG_RESULT([XSLROOT : ${XSLROOT}])\nAC_MSG_RESULT([])\nAC_MSG_RESULT([PREFIX : ${PREFIX}])\nAC_MSG_RESULT([BINDIR : ${BINDIR}])\nAC_MSG_RESULT([DATADIR : ${DATADIR}])\nAC_MSG_RESULT([INCLUDEDIR : ${INCLUDEDIR}])\nAC_MSG_RESULT([LIBDIR : ${LIBDIR}])\nAC_MSG_RESULT([MANDIR : ${MANDIR}])\nAC_MSG_RESULT([])\nAC_MSG_RESULT([srcroot : ${srcroot}])\nAC_MSG_RESULT([abs_srcroot : ${abs_srcroot}])\nAC_MSG_RESULT([objroot : ${objroot}])\nAC_MSG_RESULT([abs_objroot : ${abs_objroot}])\nAC_MSG_RESULT([])\nAC_MSG_RESULT([JEMALLOC_PREFIX : ${JEMALLOC_PREFIX}])\nAC_MSG_RESULT([JEMALLOC_PRIVATE_NAMESPACE])\nAC_MSG_RESULT([ : ${JEMALLOC_PRIVATE_NAMESPACE}])\nAC_MSG_RESULT([install_suffix : ${install_suffix}])\nAC_MSG_RESULT([malloc_conf : ${config_malloc_conf}])\nAC_MSG_RESULT([documentation : ${enable_doc}])\nAC_MSG_RESULT([shared libs : ${enable_shared}])\nAC_MSG_RESULT([static libs : ${enable_static}])\nAC_MSG_RESULT([autogen : ${enable_autogen}])\nAC_MSG_RESULT([debug : ${enable_debug}])\nAC_MSG_RESULT([stats : ${enable_stats}])\nAC_MSG_RESULT([experimental_smallocx : ${enable_experimental_smallocx}])\nAC_MSG_RESULT([prof : ${enable_prof}])\nAC_MSG_RESULT([prof-libunwind : ${enable_prof_libunwind}])\nAC_MSG_RESULT([prof-libgcc : ${enable_prof_libgcc}])\nAC_MSG_RESULT([prof-gcc : ${enable_prof_gcc}])\nAC_MSG_RESULT([fill : ${enable_fill}])\nAC_MSG_RESULT([utrace : ${enable_utrace}])\nAC_MSG_RESULT([xmalloc : ${enable_xmalloc}])\nAC_MSG_RESULT([log : ${enable_log}])\nAC_MSG_RESULT([lazy_lock : ${enable_lazy_lock}])\nAC_MSG_RESULT([cache-oblivious : ${enable_cache_oblivious}])\nAC_MSG_RESULT([cxx : ${enable_cxx}])\nAC_MSG_RESULT([===============================================================================])\n" }, { "path": "deps/jemalloc/doc/html.xsl.in", "content": "\n \n \n \n\n" }, { "path": "deps/jemalloc/doc/jemalloc.xml.in", "content": "\n\n\n\n\n \n User Manual\n jemalloc\n @jemalloc_version@\n \n \n Jason\n Evans\n Author\n \n \n \n \n JEMALLOC\n 3\n \n \n jemalloc\n jemalloc\n \n general purpose memory allocation functions\n \n \n LIBRARY\n This manual describes jemalloc @jemalloc_version@. More information\n can be found at the jemalloc website.\n \n \n SYNOPSIS\n \n #include <jemalloc/jemalloc.h>\n \n Standard API\n \n void *malloc\n size_t size\n \n \n void *calloc\n size_t number\n size_t size\n \n \n int posix_memalign\n void **ptr\n size_t alignment\n size_t size\n \n \n void *aligned_alloc\n size_t alignment\n size_t size\n \n \n void *realloc\n void *ptr\n size_t size\n \n \n void free\n void *ptr\n \n \n \n Non-standard API\n \n void *mallocx\n size_t size\n int flags\n \n \n void *rallocx\n void *ptr\n size_t size\n int flags\n \n \n size_t xallocx\n void *ptr\n size_t size\n size_t extra\n int flags\n \n \n size_t sallocx\n void *ptr\n int flags\n \n \n void dallocx\n void *ptr\n int flags\n \n \n void sdallocx\n void *ptr\n size_t size\n int flags\n \n \n size_t nallocx\n size_t size\n int flags\n \n \n int mallctl\n const char *name\n void *oldp\n size_t *oldlenp\n void *newp\n size_t newlen\n \n \n int mallctlnametomib\n const char *name\n size_t *mibp\n size_t *miblenp\n \n \n int mallctlbymib\n const size_t *mib\n size_t miblen\n void *oldp\n size_t *oldlenp\n void *newp\n size_t newlen\n \n \n void malloc_stats_print\n void (*write_cb)\n void *, const char *\n \n void *cbopaque\n const char *opts\n \n \n size_t malloc_usable_size\n const void *ptr\n \n \n void (*malloc_message)\n void *cbopaque\n const char *s\n \n const char *malloc_conf;\n \n \n \n \n DESCRIPTION\n \n Standard API\n\n The malloc() function allocates\n size bytes of uninitialized memory. The allocated\n space is suitably aligned (after possible pointer coercion) for storage\n of any type of object.\n\n The calloc() function allocates\n space for number objects, each\n size bytes in length. The result is identical to\n calling malloc() with an argument of\n number * size, with the\n exception that the allocated memory is explicitly initialized to zero\n bytes.\n\n The posix_memalign() function\n allocates size bytes of memory such that the\n allocation's base address is a multiple of\n alignment, and returns the allocation in the value\n pointed to by ptr. The requested\n alignment must be a power of 2 at least as large as\n sizeof(void *).\n\n The aligned_alloc() function\n allocates size bytes of memory such that the\n allocation's base address is a multiple of\n alignment. The requested\n alignment must be a power of 2. Behavior is\n undefined if size is not an integral multiple of\n alignment.\n\n The realloc() function changes the\n size of the previously allocated memory referenced by\n ptr to size bytes. The\n contents of the memory are unchanged up to the lesser of the new and old\n sizes. If the new size is larger, the contents of the newly allocated\n portion of the memory are undefined. Upon success, the memory referenced\n by ptr is freed and a pointer to the newly\n allocated memory is returned. Note that\n realloc() may move the memory allocation,\n resulting in a different return value than ptr.\n If ptr is NULL, the\n realloc() function behaves identically to\n malloc() for the specified size.\n\n The free() function causes the\n allocated memory referenced by ptr to be made\n available for future allocations. If ptr is\n NULL, no action occurs.\n \n \n Non-standard API\n The mallocx(),\n rallocx(),\n xallocx(),\n sallocx(),\n dallocx(),\n sdallocx(), and\n nallocx() functions all have a\n flags argument that can be used to specify\n options. The functions only check the options that are contextually\n relevant. Use bitwise or (|) operations to\n specify one or more of the following:\n \n \n MALLOCX_LG_ALIGN(la)\n \n\n Align the memory allocation to start at an address\n that is a multiple of (1 <<\n la). This macro does not validate\n that la is within the valid\n range.\n \n \n MALLOCX_ALIGN(a)\n \n\n Align the memory allocation to start at an address\n that is a multiple of a, where\n a is a power of two. This macro does not\n validate that a is a power of 2.\n \n \n \n MALLOCX_ZERO\n\n Initialize newly allocated memory to contain zero\n bytes. In the growing reallocation case, the real size prior to\n reallocation defines the boundary between untouched bytes and those\n that are initialized to contain zero bytes. If this macro is\n absent, newly allocated memory is uninitialized.\n \n \n MALLOCX_TCACHE(tc)\n \n\n Use the thread-specific cache (tcache) specified by\n the identifier tc, which must have been\n acquired via the tcache.create\n mallctl. This macro does not validate that\n tc specifies a valid\n identifier.\n \n \n MALLOCX_TCACHE_NONE\n\n Do not use a thread-specific cache (tcache). Unless\n MALLOCX_TCACHE(tc) or\n MALLOCX_TCACHE_NONE is specified, an\n automatically managed tcache will be used under many circumstances.\n This macro cannot be used in the same flags\n argument as\n MALLOCX_TCACHE(tc).\n \n \n MALLOCX_ARENA(a)\n \n\n Use the arena specified by the index\n a. This macro has no effect for regions that\n were allocated via an arena other than the one specified. This\n macro does not validate that a specifies an\n arena index in the valid range.\n \n \n \n\n The mallocx() function allocates at\n least size bytes of memory, and returns a pointer\n to the base address of the allocation. Behavior is undefined if\n size is 0.\n\n The rallocx() function resizes the\n allocation at ptr to be at least\n size bytes, and returns a pointer to the base\n address of the resulting allocation, which may or may not have moved from\n its original location. Behavior is undefined if\n size is 0.\n\n The xallocx() function resizes the\n allocation at ptr in place to be at least\n size bytes, and returns the real size of the\n allocation. If extra is non-zero, an attempt is\n made to resize the allocation to be at least (size +\n extra) bytes, though inability to allocate\n the extra byte(s) will not by itself result in failure to resize.\n Behavior is undefined if size is\n 0, or if (size + extra\n > SIZE_T_MAX).\n\n The sallocx() function returns the\n real size of the allocation at ptr.\n\n The dallocx() function causes the\n memory referenced by ptr to be made available for\n future allocations.\n\n The sdallocx() function is an\n extension of dallocx() with a\n size parameter to allow the caller to pass in the\n allocation size as an optimization. The minimum valid input size is the\n original requested size of the allocation, and the maximum valid input\n size is the corresponding value returned by\n nallocx() or\n sallocx().\n\n The nallocx() function allocates no\n memory, but it performs the same size computation as the\n mallocx() function, and returns the real\n size of the allocation that would result from the equivalent\n mallocx() function call, or\n 0 if the inputs exceed the maximum supported size\n class and/or alignment. Behavior is undefined if\n size is 0.\n\n The mallctl() function provides a\n general interface for introspecting the memory allocator, as well as\n setting modifiable parameters and triggering actions. The\n period-separated name argument specifies a\n location in a tree-structured namespace; see the section for\n documentation on the tree contents. To read a value, pass a pointer via\n oldp to adequate space to contain the value, and a\n pointer to its length via oldlenp; otherwise pass\n NULL and NULL. Similarly, to\n write a value, pass a pointer to the value via\n newp, and its length via\n newlen; otherwise pass NULL\n and 0.\n\n The mallctlnametomib() function\n provides a way to avoid repeated name lookups for applications that\n repeatedly query the same portion of the namespace, by translating a name\n to a Management Information Base (MIB) that can be passed\n repeatedly to mallctlbymib(). Upon\n successful return from mallctlnametomib(),\n mibp contains an array of\n *miblenp integers, where\n *miblenp is the lesser of the number of components\n in name and the input value of\n *miblenp. Thus it is possible to pass a\n *miblenp that is smaller than the number of\n period-separated name components, which results in a partial MIB that can\n be used as the basis for constructing a complete MIB. For name\n components that are integers (e.g. the 2 in\n arenas.bin.2.size),\n the corresponding MIB component will always be that integer. Therefore,\n it is legitimate to construct code like the following: \n\n \n \n The malloc_stats_print() function writes\n summary statistics via the write_cb callback\n function pointer and cbopaque data passed to\n write_cb, or malloc_message()\n if write_cb is NULL. The\n statistics are presented in human-readable form unless J is\n specified as a character within the opts string, in\n which case the statistics are presented in JSON format. This function can be\n called repeatedly. General information that never changes during\n execution can be omitted by specifying g as a character\n within the opts string. Note that\n malloc_stats_print() uses the\n mallctl*() functions internally, so inconsistent\n statistics can be reported if multiple threads use these functions\n simultaneously. If is specified during\n configuration, m, d, and a\n can be specified to omit merged arena, destroyed merged arena, and per\n arena statistics, respectively; b and l can\n be specified to omit per size class statistics for bins and large objects,\n respectively; x can be specified to omit all mutex\n statistics; e can be used to omit extent statistics.\n Unrecognized characters are silently ignored. Note that thread caching\n may prevent some statistics from being completely up to date, since extra\n locking would be required to merge counters that track thread cache\n operations.\n\n The malloc_usable_size() function\n returns the usable size of the allocation pointed to by\n ptr. The return value may be larger than the size\n that was requested during allocation. The\n malloc_usable_size() function is not a\n mechanism for in-place realloc(); rather\n it is provided solely as a tool for introspection purposes. Any\n discrepancy between the requested allocation size and the size reported\n by malloc_usable_size() should not be\n depended on, since such behavior is entirely implementation-dependent.\n \n \n \n \n TUNING\n Once, when the first call is made to one of the memory allocation\n routines, the allocator initializes its internals based in part on various\n options that can be specified at compile- or run-time.\n\n The string specified via , the\n string pointed to by the global variable malloc_conf, the\n name of the file referenced by the symbolic link named\n /etc/malloc.conf, and the value of the\n environment variable MALLOC_CONF, will be interpreted, in\n that order, from left to right as options. Note that\n malloc_conf may be read before\n main() is entered, so the declaration of\n malloc_conf should specify an initializer that contains\n the final value to be read by jemalloc. \n and malloc_conf are compile-time mechanisms, whereas\n /etc/malloc.conf and\n MALLOC_CONF can be safely set any time prior to program\n invocation.\n\n An options string is a comma-separated list of option:value pairs.\n There is one key corresponding to each opt.* mallctl (see the section for options\n documentation). For example, abort:true,narenas:1 sets\n the opt.abort and opt.narenas options. Some\n options have boolean values (true/false), others have integer values (base\n 8, 10, or 16, depending on prefix), and yet others have raw string\n values.\n \n \n IMPLEMENTATION NOTES\n Traditionally, allocators have used\n sbrk\n 2 to obtain memory, which is\n suboptimal for several reasons, including race conditions, increased\n fragmentation, and artificial limitations on maximum usable memory. If\n sbrk\n 2 is supported by the operating\n system, this allocator uses both\n mmap\n 2 and\n sbrk\n 2, in that order of preference;\n otherwise only mmap\n 2 is used.\n\n This allocator uses multiple arenas in order to reduce lock\n contention for threaded programs on multi-processor systems. This works\n well with regard to threading scalability, but incurs some costs. There is\n a small fixed per-arena overhead, and additionally, arenas manage memory\n completely independently of each other, which means a small fixed increase\n in overall memory fragmentation. These overheads are not generally an\n issue, given the number of arenas normally used. Note that using\n substantially more arenas than the default is not likely to improve\n performance, mainly due to reduced cache performance. However, it may make\n sense to reduce the number of arenas if an application does not make much\n use of the allocation functions.\n\n In addition to multiple arenas, this allocator supports\n thread-specific caching, in order to make it possible to completely avoid\n synchronization for most allocation requests. Such caching allows very fast\n allocation in the common case, but it increases memory usage and\n fragmentation, since a bounded number of objects can remain allocated in\n each thread cache.\n\n Memory is conceptually broken into extents. Extents are always\n aligned to multiples of the page size. This alignment makes it possible to\n find metadata for user objects quickly. User objects are broken into two\n categories according to size: small and large. Contiguous small objects\n comprise a slab, which resides within a single extent, whereas large objects\n each have their own extents backing them.\n\n Small objects are managed in groups by slabs. Each slab maintains\n a bitmap to track which regions are in use. Allocation requests that are no\n more than half the quantum (8 or 16, depending on architecture) are rounded\n up to the nearest power of two that is at least sizeof(double). All other object size\n classes are multiples of the quantum, spaced such that there are four size\n classes for each doubling in size, which limits internal fragmentation to\n approximately 20% for all but the smallest size classes. Small size classes\n are smaller than four times the page size, and large size classes extend\n from four times the page size up to the largest size class that does not\n exceed PTRDIFF_MAX.\n\n Allocations are packed tightly together, which can be an issue for\n multi-threaded applications. If you need to assure that allocations do not\n suffer from cacheline sharing, round your allocation requests up to the\n nearest multiple of the cacheline size, or specify cacheline alignment when\n allocating.\n\n The realloc(),\n rallocx(), and\n xallocx() functions may resize allocations\n without moving them under limited circumstances. Unlike the\n *allocx() API, the standard API does not\n officially round up the usable size of an allocation to the nearest size\n class, so technically it is necessary to call\n realloc() to grow e.g. a 9-byte allocation to\n 16 bytes, or shrink a 16-byte allocation to 9 bytes. Growth and shrinkage\n trivially succeeds in place as long as the pre-size and post-size both round\n up to the same size class. No other API guarantees are made regarding\n in-place resizing, but the current implementation also tries to resize large\n allocations in place, as long as the pre-size and post-size are both large.\n For shrinkage to succeed, the extent allocator must support splitting (see\n arena.<i>.extent_hooks).\n Growth only succeeds if the trailing memory is currently available, and the\n extent allocator supports merging.\n\n Assuming 4 KiB pages and a 16-byte quantum on a 64-bit system, the\n size classes in each category are as shown in .\n\n \n Size classes\n \n \n \n \n \n \n Category\n Spacing\n Size\n \n \n \n \n Small\n lg\n [8]\n \n \n 16\n [16, 32, 48, 64, 80, 96, 112, 128]\n \n \n 32\n [160, 192, 224, 256]\n \n \n 64\n [320, 384, 448, 512]\n \n \n 128\n [640, 768, 896, 1024]\n \n \n 256\n [1280, 1536, 1792, 2048]\n \n \n 512\n [2560, 3072, 3584, 4096]\n \n \n 1 KiB\n [5 KiB, 6 KiB, 7 KiB, 8 KiB]\n \n \n 2 KiB\n [10 KiB, 12 KiB, 14 KiB]\n \n \n Large\n 2 KiB\n [16 KiB]\n \n \n 4 KiB\n [20 KiB, 24 KiB, 28 KiB, 32 KiB]\n \n \n 8 KiB\n [40 KiB, 48 KiB, 56 KiB, 64 KiB]\n \n \n 16 KiB\n [80 KiB, 96 KiB, 112 KiB, 128 KiB]\n \n \n 32 KiB\n [160 KiB, 192 KiB, 224 KiB, 256 KiB]\n \n \n 64 KiB\n [320 KiB, 384 KiB, 448 KiB, 512 KiB]\n \n \n 128 KiB\n [640 KiB, 768 KiB, 896 KiB, 1 MiB]\n \n \n 256 KiB\n [1280 KiB, 1536 KiB, 1792 KiB, 2 MiB]\n \n \n 512 KiB\n [2560 KiB, 3 MiB, 3584 KiB, 4 MiB]\n \n \n 1 MiB\n [5 MiB, 6 MiB, 7 MiB, 8 MiB]\n \n \n 2 MiB\n [10 MiB, 12 MiB, 14 MiB, 16 MiB]\n \n \n 4 MiB\n [20 MiB, 24 MiB, 28 MiB, 32 MiB]\n \n \n 8 MiB\n [40 MiB, 48 MiB, 56 MiB, 64 MiB]\n \n \n ...\n ...\n \n \n 512 PiB\n [2560 PiB, 3 EiB, 3584 PiB, 4 EiB]\n \n \n 1 EiB\n [5 EiB, 6 EiB, 7 EiB]\n \n \n \n
\n \n \n MALLCTL NAMESPACE\n The following names are defined in the namespace accessible via the\n mallctl*() functions. Value types are specified in\n parentheses, their readable/writable statuses are encoded as\n rw, r-, -w, or\n --, and required build configuration flags follow, if\n any. A name element encoded as <i> or\n <j> indicates an integer component, where the\n integer varies from 0 to some upper value that must be determined via\n introspection. In the case of stats.arenas.<i>.*\n and arena.<i>.{initialized,purge,decay,dss},\n <i> equal to\n MALLCTL_ARENAS_ALL can be used to operate on all arenas\n or access the summation of statistics from all arenas; similarly\n <i> equal to\n MALLCTL_ARENAS_DESTROYED can be used to access the\n summation of statistics from all destroyed arenas. These constants can be\n utilized either via mallctlnametomib() followed by\n mallctlbymib(), or via code such as the following:\n \n Take special note of the epoch mallctl, which controls\n refreshing of cached dynamic statistics.\n\n \n \n \n version\n (const char *)\n r-\n \n Return the jemalloc version string.\n \n\n \n \n epoch\n (uint64_t)\n rw\n \n If a value is passed in, refresh the data from which\n the mallctl*() functions report values,\n and increment the epoch. Return the current epoch. This is useful for\n detecting whether another thread caused a refresh.\n \n\n \n \n background_thread\n (bool)\n rw\n \n Enable/disable internal background worker threads. When\n set to true, background threads are created on demand (the number of\n background threads will be no more than the number of CPUs or active\n arenas). Threads run periodically, and handle purging asynchronously. When switching\n off, background threads are terminated synchronously. Note that after\n fork2\n function, the state in the child process will be disabled regardless\n the state in parent process. See stats.background_thread\n for related stats. opt.background_thread\n can be used to set the default option. This option is only available on\n selected pthread-based platforms.\n \n\n \n \n max_background_threads\n (size_t)\n rw\n \n Maximum number of background worker threads that will\n be created. This value is capped at opt.max_background_threads at\n startup.\n \n\n \n \n config.cache_oblivious\n (bool)\n r-\n \n was specified\n during build configuration.\n \n\n \n \n config.debug\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n \n \n config.fill\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n \n \n config.lazy_lock\n (bool)\n r-\n \n was specified\n during build configuration.\n \n\n \n \n config.malloc_conf\n (const char *)\n r-\n \n Embedded configure-time-specified run-time options\n string, empty unless was specified\n during build configuration.\n \n\n \n \n config.prof\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n \n \n config.prof_libgcc\n (bool)\n r-\n \n was not\n specified during build configuration.\n \n\n \n \n config.prof_libunwind\n (bool)\n r-\n \n was specified\n during build configuration.\n \n\n \n \n config.stats\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n\n \n \n config.utrace\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n \n \n config.xmalloc\n (bool)\n r-\n \n was specified during\n build configuration.\n \n\n \n \n opt.abort\n (bool)\n r-\n \n Abort-on-warning enabled/disabled. If true, most\n warnings are fatal. Note that runtime option warnings are not included\n (see opt.abort_conf for\n that). The process will call\n abort\n 3 in these cases. This option is\n disabled by default unless is\n specified during configuration, in which case it is enabled by default.\n \n \n\n \n \n opt.confirm_conf\n (bool)\n r-\n \n\tConfirm-runtime-options-when-program-starts\n\tenabled/disabled. If true, the string specified via\n\t, the string pointed to by the\n\tglobal variable malloc_conf, the name\n\tof the file referenced by the symbolic link named\n\t/etc/malloc.conf, and the value of\n\tthe environment variable MALLOC_CONF, will be printed in\n\torder. Then, each option being set will be individually printed. This\n\toption is disabled by default.\n \n\n \n \n opt.abort_conf\n (bool)\n r-\n \n Abort-on-invalid-configuration enabled/disabled. If\n true, invalid runtime options are fatal. The process will call\n abort\n 3 in these cases. This option is\n disabled by default unless is\n specified during configuration, in which case it is enabled by default.\n \n \n\n \n \n opt.cache_oblivious\n (bool)\n r-\n \n Enable / Disable cache-oblivious large allocation\n alignment, for large requests with no alignment constraints. If this\n feature is disabled, all large allocations are page-aligned as an\n implementation artifact, which can severely harm CPU cache utilization.\n However, the cache-oblivious layout comes at the cost of one extra page\n per large allocation, which in the most extreme case increases physical\n memory usage for the 16 KiB size class to 20 KiB. This option is enabled\n by default.\n \n\n \n \n opt.metadata_thp\n (const char *)\n r-\n \n Controls whether to allow jemalloc to use transparent\n huge page (THP) for internal metadata (see stats.metadata). always\n allows such usage. auto uses no THP initially, but may\n begin to do so when metadata usage reaches certain level. The default\n is disabled.\n \n\n \n \n opt.trust_madvise\n (bool)\n r-\n \n If true, do not perform runtime check for MADV_DONTNEED,\n to check that it actually zeros pages. The default is disabled on Linux\n and enabled elsewhere.\n \n\n \n \n opt.retain\n (bool)\n r-\n \n If true, retain unused virtual memory for later reuse\n rather than discarding it by calling\n munmap\n 2 or equivalent (see stats.retained for related details).\n It also makes jemalloc use \n mmap2\n or equivalent in a more greedy way, mapping larger\n chunks in one go. This option is disabled by default unless discarding\n virtual memory is known to trigger platform-specific performance\n problems, namely 1) for [64-bit] Linux, which has a quirk in its virtual\n memory allocation algorithm that causes semi-permanent VM map holes\n under normal jemalloc operation; and 2) for [64-bit] Windows, which\n disallows split / merged regions with\n MEM_RELEASE. Although the\n same issues may present on 32-bit platforms as well, retaining virtual\n memory for 32-bit Linux and Windows is disabled by default due to the\n practical possibility of address space exhaustion. \n \n\n \n \n opt.dss\n (const char *)\n r-\n \n dss (sbrk\n 2) allocation precedence as\n related to mmap\n 2 allocation. The following\n settings are supported if\n sbrk\n 2 is supported by the operating\n system: disabled, primary, and\n secondary; otherwise only disabled is\n supported. The default is secondary if\n sbrk\n 2 is supported by the operating\n system; disabled otherwise.\n \n \n\n \n \n opt.narenas\n (unsigned)\n r-\n \n Maximum number of arenas to use for automatic\n multiplexing of threads and arenas. The default is four times the\n number of CPUs, or one if there is a single CPU.\n \n\n \n \n opt.oversize_threshold\n (size_t)\n r-\n \n The threshold in bytes of which requests are considered\n oversize. Allocation requests with greater sizes are fulfilled from a\n dedicated arena (automatically managed, however not within\n narenas), in order to reduce fragmentation by not\n mixing huge allocations with small ones. In addition, the decay API\n guarantees on the extents greater than the specified threshold may be\n overridden. Note that requests with arena index specified via\n MALLOCX_ARENA, or threads associated with explicit\n arenas will not be considered. The default threshold is 8MiB. Values\n not within large size classes disables this feature.\n \n\n \n \n opt.percpu_arena\n (const char *)\n r-\n \n Per CPU arena mode. Use the percpu\n setting to enable this feature, which uses number of CPUs to determine\n number of arenas, and bind threads to arenas dynamically based on the\n CPU the thread runs on currently. phycpu setting uses\n one arena per physical CPU, which means the two hyper threads on the\n same CPU share one arena. Note that no runtime checking regarding the\n availability of hyper threading is done at the moment. When set to\n disabled, narenas and thread to arena association will\n not be impacted by this option. The default is disabled.\n \n \n\n \n \n opt.background_thread\n (bool)\n r-\n \n Internal background worker threads enabled/disabled.\n Because of potential circular dependencies, enabling background thread\n using this option may cause crash or deadlock during initialization. For\n a reliable way to use this feature, see background_thread for dynamic control\n options and details. This option is disabled by\n default.\n \n\n \n \n opt.max_background_threads\n (size_t)\n r-\n \n Maximum number of background threads that will be created\n if background_thread is set.\n Defaults to number of cpus.\n \n\n \n \n opt.dirty_decay_ms\n (ssize_t)\n r-\n \n Approximate time in milliseconds from the creation of a\n set of unused dirty pages until an equivalent set of unused dirty pages\n is purged (i.e. converted to muzzy via e.g.\n madvise(...MADV_FREE)\n if supported by the operating system, or converted to clean otherwise)\n and/or reused. Dirty pages are defined as previously having been\n potentially written to by the application, and therefore consuming\n physical memory, yet having no current use. The pages are incrementally\n purged according to a sigmoidal decay curve that starts and ends with\n zero purge rate. A decay time of 0 causes all unused dirty pages to be\n purged immediately upon creation. A decay time of -1 disables purging.\n The default decay time is 10 seconds. See arenas.dirty_decay_ms\n and arena.<i>.dirty_decay_ms\n for related dynamic control options. See opt.muzzy_decay_ms\n for a description of muzzy pages.for a description of muzzy pages. Note\n that when the oversize_threshold\n feature is enabled, the arenas reserved for oversize requests may have\n its own default decay settings.\n \n\n \n \n opt.muzzy_decay_ms\n (ssize_t)\n r-\n \n Approximate time in milliseconds from the creation of a\n set of unused muzzy pages until an equivalent set of unused muzzy pages\n is purged (i.e. converted to clean) and/or reused. Muzzy pages are\n defined as previously having been unused dirty pages that were\n subsequently purged in a manner that left them subject to the\n reclamation whims of the operating system (e.g.\n madvise(...MADV_FREE)),\n and therefore in an indeterminate state. The pages are incrementally\n purged according to a sigmoidal decay curve that starts and ends with\n zero purge rate. A decay time of 0 causes all unused muzzy pages to be\n purged immediately upon creation. A decay time of -1 disables purging.\n The default decay time is 10 seconds. See arenas.muzzy_decay_ms\n and arena.<i>.muzzy_decay_ms\n for related dynamic control options.\n \n\n \n \n opt.lg_extent_max_active_fit\n (size_t)\n r-\n \n When reusing dirty extents, this determines the (log\n base 2 of the) maximum ratio between the size of the active extent\n selected (to split off from) and the size of the requested allocation.\n This prevents the splitting of large active extents for smaller\n allocations, which can reduce fragmentation over the long run\n (especially for non-active extents). Lower value may reduce\n fragmentation, at the cost of extra active extents. The default value\n is 6, which gives a maximum ratio of 64 (2^6).\n \n\n \n \n opt.stats_print\n (bool)\n r-\n \n Enable/disable statistics printing at exit. If\n enabled, the malloc_stats_print()\n function is called at program exit via an\n atexit\n 3 function. opt.stats_print_opts\n can be combined to specify output options. If\n is specified during configuration, this\n has the potential to cause deadlock for a multi-threaded process that\n exits while one or more threads are executing in the memory allocation\n functions. Furthermore, atexit() may\n allocate memory during application initialization and then deadlock\n internally when jemalloc in turn calls\n atexit(), so this option is not\n universally usable (though the application can register its own\n atexit() function with equivalent\n functionality). Therefore, this option should only be used with care;\n it is primarily intended as a performance tuning aid during application\n development. This option is disabled by default.\n \n\n \n \n opt.stats_print_opts\n (const char *)\n r-\n \n Options (the opts string) to pass\n to the malloc_stats_print() at exit (enabled\n through opt.stats_print). See\n available options in malloc_stats_print().\n Has no effect unless opt.stats_print is\n enabled. The default is .\n \n\n \n \n opt.stats_interval\n (int64_t)\n r-\n \n Average interval between statistics outputs, as measured\n in bytes of allocation activity. The actual interval may be sporadic\n because decentralized event counters are used to avoid synchronization\n bottlenecks. The output may be triggered on any thread, which then\n calls malloc_stats_print(). opt.stats_interval_opts\n can be combined to specify output options. By default,\n interval-triggered stats output is disabled (encoded as\n -1).\n \n\n \n \n opt.stats_interval_opts\n (const char *)\n r-\n \n Options (the opts string) to pass\n to the malloc_stats_print() for interval based\n\tstatistics printing (enabled\n through opt.stats_interval). See\n available options in malloc_stats_print().\n Has no effect unless opt.stats_interval is\n enabled. The default is .\n \n\n \n \n opt.junk\n (const char *)\n r-\n []\n \n Junk filling. If set to alloc, each byte\n of uninitialized allocated memory will be initialized to\n 0xa5. If set to free, all deallocated\n memory will be initialized to 0x5a. If set to\n true, both allocated and deallocated memory will be\n initialized, and if set to false, junk filling be\n disabled entirely. This is intended for debugging and will impact\n performance negatively. This option is false by default\n unless is specified during\n configuration, in which case it is true by\n default.\n \n\n \n \n opt.zero\n (bool)\n r-\n []\n \n Zero filling enabled/disabled. If enabled, each byte\n of uninitialized allocated memory will be initialized to 0. Note that\n this initialization only happens once for each byte, so\n realloc() and\n rallocx() calls do not zero memory that\n was previously allocated. This is intended for debugging and will\n impact performance negatively. This option is disabled by default.\n \n \n\n \n \n opt.utrace\n (bool)\n r-\n []\n \n Allocation tracing based on\n utrace\n 2 enabled/disabled. This option\n is disabled by default.\n \n\n \n \n opt.xmalloc\n (bool)\n r-\n []\n \n Abort-on-out-of-memory enabled/disabled. If enabled,\n rather than returning failure for any allocation function, display a\n diagnostic message on STDERR_FILENO and cause the\n program to drop core (using\n abort\n 3). If an application is\n designed to depend on this behavior, set the option at compile time by\n including the following in the source code:\n \n This option is disabled by default.\n \n\n \n \n opt.tcache\n (bool)\n r-\n \n Thread-specific caching (tcache) enabled/disabled. When\n there are multiple threads, each thread uses a tcache for objects up to\n a certain size. Thread-specific caching allows many allocations to be\n satisfied without performing any thread synchronization, at the cost of\n increased memory use. See the opt.tcache_max\n option for related tuning information. This option is enabled by\n default.\n \n\n \n \n opt.tcache_max\n (size_t)\n r-\n \n Maximum size class to cache in the thread-specific cache\n (tcache). At a minimum, the first size class is cached; and at a\n maximum, size classes up to 8 MiB can be cached. The default maximum is\n 32 KiB (2^15). As a convenience, this may also be set by specifying\n lg_tcache_max, which will be taken to be the base-2 logarithm of the\n setting of tcache_max.\n \n\n \n \n opt.thp\n (const char *)\n r-\n \n Transparent hugepage (THP) mode. Settings \"always\",\n \"never\" and \"default\" are available if THP is supported by the operating\n system. The \"always\" setting enables transparent hugepage for all user\n memory mappings with\n MADV_HUGEPAGE; \"never\"\n ensures no transparent hugepage with\n MADV_NOHUGEPAGE; the default\n setting \"default\" makes no changes. Note that: this option does not\n affect THP for jemalloc internal metadata (see opt.metadata_thp);\n in addition, for arenas with customized extent_hooks,\n this option is bypassed as it is implemented as part of the default\n extent hooks.\n \n\n \n \n opt.prof\n (bool)\n r-\n []\n \n Memory profiling enabled/disabled. If enabled, profile\n memory allocation activity. See the opt.prof_active\n option for on-the-fly activation/deactivation. See the opt.lg_prof_sample\n option for probabilistic sampling control. See the opt.prof_accum\n option for control of cumulative sample reporting. See the opt.lg_prof_interval\n option for information on interval-triggered profile dumping, the opt.prof_gdump\n option for information on high-water-triggered profile dumping, and the\n opt.prof_final\n option for final profile dumping. Profile output is compatible with\n the jeprof command, which is based on the\n pprof that is developed as part of the gperftools\n package. See HEAP PROFILE\n FORMAT for heap profile format documentation.\n \n\n \n \n opt.prof_prefix\n (const char *)\n r-\n []\n \n Filename prefix for profile dumps. If the prefix is\n set to the empty string, no automatic dumps will occur; this is\n primarily useful for disabling the automatic final heap dump (which\n also disables leak reporting, if enabled). The default prefix is\n jeprof. This prefix value can be overridden by\n prof.prefix.\n \n \n\n \n \n opt.prof_active\n (bool)\n r-\n []\n \n Profiling activated/deactivated. This is a secondary\n control mechanism that makes it possible to start the application with\n profiling enabled (see the opt.prof option) but\n inactive, then toggle profiling at any time during program execution\n with the prof.active mallctl.\n This option is enabled by default.\n \n\n \n \n opt.prof_thread_active_init\n (bool)\n r-\n []\n \n Initial setting for thread.prof.active\n in newly created threads. The initial setting for newly created threads\n can also be changed during execution via the prof.thread_active_init\n mallctl. This option is enabled by default.\n \n\n \n \n opt.lg_prof_sample\n (size_t)\n r-\n []\n \n Average interval (log base 2) between allocation\n samples, as measured in bytes of allocation activity. Increasing the\n sampling interval decreases profile fidelity, but also decreases the\n computational overhead. The default sample interval is 512 KiB (2^19\n B).\n \n\n \n \n opt.prof_accum\n (bool)\n r-\n []\n \n Reporting of cumulative object/byte counts in profile\n dumps enabled/disabled. If this option is enabled, every unique\n backtrace must be stored for the duration of execution. Depending on\n the application, this can impose a large memory overhead, and the\n cumulative counts are not always of interest. This option is disabled\n by default.\n \n\n \n \n opt.lg_prof_interval\n (ssize_t)\n r-\n []\n \n Average interval (log base 2) between memory profile\n dumps, as measured in bytes of allocation activity. The actual\n interval between dumps may be sporadic because decentralized allocation\n counters are used to avoid synchronization bottlenecks. Profiles are\n dumped to files named according to the pattern\n <prefix>.<pid>.<seq>.i<iseq>.heap,\n where <prefix> is controlled by the\n opt.prof_prefix and\n prof.prefix\n options. By default, interval-triggered profile dumping is disabled\n (encoded as -1).\n \n \n\n \n \n opt.prof_gdump\n (bool)\n r-\n []\n \n Set the initial state of prof.gdump, which when\n enabled triggers a memory profile dump every time the total virtual\n memory exceeds the previous maximum. This option is disabled by\n default.\n \n\n \n \n opt.prof_final\n (bool)\n r-\n []\n \n Use an\n atexit\n 3 function to dump final memory\n usage to a file named according to the pattern\n <prefix>.<pid>.<seq>.f.heap,\n where <prefix> is controlled by the opt.prof_prefix and\n prof.prefix\n options. Note that atexit() may allocate\n memory during application initialization and then deadlock internally\n when jemalloc in turn calls atexit(), so\n this option is not universally usable (though the application can\n register its own atexit() function with\n equivalent functionality). This option is disabled by\n default.\n \n\n \n \n opt.prof_leak\n (bool)\n r-\n []\n \n Leak reporting enabled/disabled. If enabled, use an\n atexit\n 3 function to report memory leaks\n detected by allocation sampling. See the\n opt.prof option for\n information on analyzing heap profile output. Works only when combined\n with opt.prof_final\n , otherwise does nothing. This option is disabled by default.\n \n \n\n \n \n opt.prof_leak_error\n (bool)\n r-\n []\n \n Similar to \n opt.prof_leak, but makes the process exit with error\n code 1 if a memory leak is detected. This option supersedes\n opt.prof_leak,\n meaning that if both are specified, this option takes precedence. When\n enabled, also enables \n opt.prof_leak. Works only when combined with\n opt.prof_final,\n otherwise does nothing. This option is disabled by default.\n \n \n\n \n \n opt.zero_realloc\n (const char *)\n r-\n \n Determines the behavior of\n realloc() when passed a value of zero for the new\n size. alloc treats this as an allocation of size zero\n (and returns a non-null result except in case of resource exhaustion).\n free treats this as a deallocation of the pointer, and\n returns NULL without setting\n errno. abort aborts the process if\n zero is passed. The default is free on Linux and\n Windows, and alloc elsewhere.\n\n\tThere is considerable divergence of behaviors across\n\timplementations in handling this case. Many have the behavior of\n\tfree. This can introduce security vulnerabilities, since\n\ta NULL return value indicates failure, and the\n\tcontinued validity of the passed-in pointer (per POSIX and C11).\n\talloc is safe, but can cause leaks in programs that\n\texpect the common behavior. Programs intended to be portable and\n\tleak-free cannot assume either behavior, and must therefore never call\n\trealloc with a size of 0. The abort option enables these\n\ttesting this behavior.\n \n\n \n \n thread.arena\n (unsigned)\n rw\n \n Get or set the arena associated with the calling\n thread. If the specified arena was not initialized beforehand (see the\n arena.i.initialized\n mallctl), it will be automatically initialized as a side effect of\n calling this interface.\n \n\n \n \n thread.allocated\n (uint64_t)\n r-\n []\n \n Get the total number of bytes ever allocated by the\n calling thread. This counter has the potential to wrap around; it is\n up to the application to appropriately interpret the counter in such\n cases.\n \n\n \n \n thread.allocatedp\n (uint64_t *)\n r-\n []\n \n Get a pointer to the the value that is returned by the\n thread.allocated\n mallctl. This is useful for avoiding the overhead of repeated\n mallctl*() calls. Note that the underlying counter\n should not be modified by the application.\n \n\n \n \n thread.deallocated\n (uint64_t)\n r-\n []\n \n Get the total number of bytes ever deallocated by the\n calling thread. This counter has the potential to wrap around; it is\n up to the application to appropriately interpret the counter in such\n cases.\n \n\n \n \n thread.deallocatedp\n (uint64_t *)\n r-\n []\n \n Get a pointer to the the value that is returned by the\n thread.deallocated\n mallctl. This is useful for avoiding the overhead of repeated\n mallctl*() calls. Note that the underlying counter\n should not be modified by the application.\n \n\n \n \n thread.peak.read\n (uint64_t)\n r-\n []\n \n Get an approximation of the maximum value of the\n difference between the number of bytes allocated and the number of bytes\n deallocated by the calling thread since the last call to thread.peak.reset,\n or since the thread's creation if it has not called thread.peak.reset.\n No guarantees are made about the quality of the approximation, but\n jemalloc currently endeavors to maintain accuracy to within one hundred\n kilobytes.\n \n \n\n \n \n thread.peak.reset\n (void)\n --\n []\n \n Resets the counter for net bytes allocated in the calling\n thread to zero. This affects subsequent calls to thread.peak.read,\n but not the values returned by thread.allocated\n or thread.deallocated.\n \n \n\n \n \n thread.tcache.enabled\n (bool)\n rw\n \n Enable/disable calling thread's tcache. The tcache is\n implicitly flushed as a side effect of becoming\n disabled (see thread.tcache.flush).\n \n \n\n \n \n thread.tcache.flush\n (void)\n --\n \n Flush calling thread's thread-specific cache (tcache).\n This interface releases all cached objects and internal data structures\n associated with the calling thread's tcache. Ordinarily, this interface\n need not be called, since automatic periodic incremental garbage\n collection occurs, and the thread cache is automatically discarded when\n a thread exits. However, garbage collection is triggered by allocation\n activity, so it is possible for a thread that stops\n allocating/deallocating to retain its cache indefinitely, in which case\n the developer may find manual flushing useful.\n \n\n \n \n thread.prof.name\n (const char *)\n r- or\n -w\n []\n \n Get/set the descriptive name associated with the calling\n thread in memory profile dumps. An internal copy of the name string is\n created, so the input string need not be maintained after this interface\n completes execution. The output string of this interface should be\n copied for non-ephemeral uses, because multiple implementation details\n can cause asynchronous string deallocation. Furthermore, each\n invocation of this interface can only read or write; simultaneous\n read/write is not supported due to string lifetime limitations. The\n name string must be nil-terminated and comprised only of characters in\n the sets recognized\n by isgraph\n 3 and\n isblank\n 3.\n \n\n \n \n thread.prof.active\n (bool)\n rw\n []\n \n Control whether sampling is currently active for the\n calling thread. This is an activation mechanism in addition to prof.active; both must\n be active for the calling thread to sample. This flag is enabled by\n default.\n \n\n \n \n thread.idle\n (void)\n --\n \n Hints to jemalloc that the calling thread will be idle\n\tfor some nontrivial period of time (say, on the order of seconds), and\n\tthat doing some cleanup operations may be beneficial. There are no\n\tguarantees as to what specific operations will be performed; currently\n\tthis flushes the caller's tcache and may (according to some heuristic)\n\tpurge its associated arena.\n\tThis is not intended to be a general-purpose background activity\n\tmechanism, and threads should not wake up multiple times solely to call\n\tit. Rather, a thread waiting for a task should do a timed wait first,\n\tcall thread.idle\n\tif no task appears in the timeout interval, and then do an untimed wait.\n\tFor such a background activity mechanism, see\n\tbackground_thread.\n\t\n \n\n \n \n tcache.create\n (unsigned)\n r-\n \n Create an explicit thread-specific cache (tcache) and\n return an identifier that can be passed to the MALLOCX_TCACHE(tc)\n macro to explicitly use the specified cache rather than the\n automatically managed one that is used by default. Each explicit cache\n can be used by only one thread at a time; the application must assure\n that this constraint holds.\n \n\n If the amount of space supplied for storing the thread-specific\n cache identifier does not equal\n sizeof(unsigned), no\n thread-specific cache will be created, no data will be written to the\n space pointed by oldp, and\n *oldlenp will be set to 0.\n \n\n \n\n \n \n tcache.flush\n (unsigned)\n -w\n \n Flush the specified thread-specific cache (tcache). The\n same considerations apply to this interface as to thread.tcache.flush,\n except that the tcache will never be automatically discarded.\n \n \n\n \n \n tcache.destroy\n (unsigned)\n -w\n \n Flush the specified thread-specific cache (tcache) and\n make the identifier available for use during a future tcache creation.\n \n \n\n \n \n arena.<i>.initialized\n (bool)\n r-\n \n Get whether the specified arena's statistics are\n initialized (i.e. the arena was initialized prior to the current epoch).\n This interface can also be nominally used to query whether the merged\n statistics corresponding to MALLCTL_ARENAS_ALL are\n initialized (always true).\n \n\n \n \n arena.<i>.decay\n (void)\n --\n \n Trigger decay-based purging of unused dirty/muzzy pages\n for arena <i>, or for all arenas if <i> equals\n MALLCTL_ARENAS_ALL. The proportion of unused\n dirty/muzzy pages to be purged depends on the current time; see opt.dirty_decay_ms\n and opt.muzy_decay_ms\n for details.\n \n\n \n \n arena.<i>.purge\n (void)\n --\n \n Purge all unused dirty pages for arena <i>, or for\n all arenas if <i> equals MALLCTL_ARENAS_ALL.\n \n \n\n \n \n arena.<i>.reset\n (void)\n --\n \n Discard all of the arena's extant allocations. This\n interface can only be used with arenas explicitly created via arenas.create. None\n of the arena's discarded/cached allocations may accessed afterward. As\n part of this requirement, all thread caches which were used to\n allocate/deallocate in conjunction with the arena must be flushed\n beforehand.\n \n\n \n \n arena.<i>.destroy\n (void)\n --\n \n Destroy the arena. Discard all of the arena's extant\n allocations using the same mechanism as for arena.<i>.reset\n (with all the same constraints and side effects), merge the arena stats\n into those accessible at arena index\n MALLCTL_ARENAS_DESTROYED, and then completely\n discard all metadata associated with the arena. Future calls to arenas.create may\n recycle the arena index. Destruction will fail if any threads are\n currently associated with the arena as a result of calls to thread.arena.\n \n\n \n \n arena.<i>.dss\n (const char *)\n rw\n \n Set the precedence of dss allocation as related to mmap\n allocation for arena <i>, or for all arenas if <i> equals\n MALLCTL_ARENAS_ALL. See opt.dss for supported\n settings.\n \n\n \n \n arena.<i>.dirty_decay_ms\n (ssize_t)\n rw\n \n Current per-arena approximate time in milliseconds from\n the creation of a set of unused dirty pages until an equivalent set of\n unused dirty pages is purged and/or reused. Each time this interface is\n set, all currently unused dirty pages are considered to have fully\n decayed, which causes immediate purging of all unused dirty pages unless\n the decay time is set to -1 (i.e. purging disabled). See opt.dirty_decay_ms\n for additional information.\n \n\n \n \n arena.<i>.muzzy_decay_ms\n (ssize_t)\n rw\n \n Current per-arena approximate time in milliseconds from\n the creation of a set of unused muzzy pages until an equivalent set of\n unused muzzy pages is purged and/or reused. Each time this interface is\n set, all currently unused muzzy pages are considered to have fully\n decayed, which causes immediate purging of all unused muzzy pages unless\n the decay time is set to -1 (i.e. purging disabled). See opt.muzzy_decay_ms\n for additional information.\n \n\n \n \n arena.<i>.retain_grow_limit\n (size_t)\n rw\n \n Maximum size to grow retained region (only relevant when\n opt.retain is\n enabled). This controls the maximum increment to expand virtual memory,\n or allocation through arena.<i>extent_hooks.\n In particular, if customized extent hooks reserve physical memory\n (e.g. 1G huge pages), this is useful to control the allocation hook's\n input size. The default is no limit.\n \n\n \n \n arena.<i>.extent_hooks\n (extent_hooks_t *)\n rw\n \n Get or set the extent management hook functions for\n arena <i>. The functions must be capable of operating on all\n extant extents associated with arena <i>, usually by passing\n unknown extents to the replaced functions. In practice, it is feasible\n to control allocation for arenas explicitly created via arenas.create such\n that all extents originate from an application-supplied extent allocator\n (by specifying the custom extent hook functions during arena creation).\n However, the API guarantees for the automatically created arenas may be\n relaxed -- hooks set there may be called in a \"best effort\" fashion; in\n addition there may be extents created prior to the application having an\n opportunity to take over extent allocation.\n\n \n The extent_hooks_t structure comprises function\n pointers which are described individually below. jemalloc uses these\n functions to manage extent lifetime, which starts off with allocation of\n mapped committed memory, in the simplest case followed by deallocation.\n However, there are performance and platform reasons to retain extents\n for later reuse. Cleanup attempts cascade from deallocation to decommit\n to forced purging to lazy purging, which gives the extent management\n functions opportunities to reject the most permanent cleanup operations\n in favor of less permanent (and often less costly) operations. All\n operations except allocation can be universally opted out of by setting\n the hook pointers to NULL, or selectively opted out\n of by returning failure. Note that once the extent hook is set, the\n structure is accessed directly by the associated arenas, so it must\n remain valid for the entire lifetime of the arenas.\n\n \n typedef void *(extent_alloc_t)\n extent_hooks_t *extent_hooks\n void *new_addr\n size_t size\n size_t alignment\n bool *zero\n bool *commit\n unsigned arena_ind\n \n \n An extent allocation function conforms to the\n extent_alloc_t type and upon success returns a pointer to\n size bytes of mapped memory on behalf of arena\n arena_ind such that the extent's base address is\n a multiple of alignment, as well as setting\n *zero to indicate whether the extent is zeroed\n and *commit to indicate whether the extent is\n committed. Upon error the function returns NULL\n and leaves *zero and\n *commit unmodified. The\n size parameter is always a multiple of the page\n size. The alignment parameter is always a power\n of two at least as large as the page size. Zeroing is mandatory if\n *zero is true upon function entry. Committing is\n mandatory if *commit is true upon function entry.\n If new_addr is not NULL, the\n returned pointer must be new_addr on success or\n NULL on error. Committed memory may be committed\n in absolute terms as on a system that does not overcommit, or in\n implicit terms as on a system that overcommits and satisfies physical\n memory needs on demand via soft page faults. Note that replacing the\n default extent allocation function makes the arena's arena.<i>.dss\n setting irrelevant.\n\n \n typedef bool (extent_dalloc_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n bool committed\n unsigned arena_ind\n \n \n \n An extent deallocation function conforms to the\n extent_dalloc_t type and deallocates an extent at given\n addr and size with\n committed/decommited memory as indicated, on\n behalf of arena arena_ind, returning false upon\n success. If the function returns true, this indicates opt-out from\n deallocation; the virtual memory mapping associated with the extent\n remains mapped, in the same commit state, and available for future use,\n in which case it will be automatically retained for later reuse.\n\n \n typedef void (extent_destroy_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n bool committed\n unsigned arena_ind\n \n \n \n An extent destruction function conforms to the\n extent_destroy_t type and unconditionally destroys an\n extent at given addr and\n size with\n committed/decommited memory as indicated, on\n behalf of arena arena_ind. This function may be\n called to destroy retained extents during arena destruction (see arena.<i>.destroy).\n\n \n typedef bool (extent_commit_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n size_t offset\n size_t length\n unsigned arena_ind\n \n \n An extent commit function conforms to the\n extent_commit_t type and commits zeroed physical memory to\n back pages within an extent at given addr and\n size at offset bytes,\n extending for length on behalf of arena\n arena_ind, returning false upon success.\n Committed memory may be committed in absolute terms as on a system that\n does not overcommit, or in implicit terms as on a system that\n overcommits and satisfies physical memory needs on demand via soft page\n faults. If the function returns true, this indicates insufficient\n physical memory to satisfy the request.\n\n \n typedef bool (extent_decommit_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n size_t offset\n size_t length\n unsigned arena_ind\n \n \n An extent decommit function conforms to the\n extent_decommit_t type and decommits any physical memory\n that is backing pages within an extent at given\n addr and size at\n offset bytes, extending for\n length on behalf of arena\n arena_ind, returning false upon success, in which\n case the pages will be committed via the extent commit function before\n being reused. If the function returns true, this indicates opt-out from\n decommit; the memory remains committed and available for future use, in\n which case it will be automatically retained for later reuse.\n\n \n typedef bool (extent_purge_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n size_t offset\n size_t length\n unsigned arena_ind\n \n \n An extent purge function conforms to the\n extent_purge_t type and discards physical pages\n within the virtual memory mapping associated with an extent at given\n addr and size at\n offset bytes, extending for\n length on behalf of arena\n arena_ind. A lazy extent purge function (e.g.\n implemented via\n madvise(...MADV_FREE))\n can delay purging indefinitely and leave the pages within the purged\n virtual memory range in an indeterminite state, whereas a forced extent\n purge function immediately purges, and the pages within the virtual\n memory range will be zero-filled the next time they are accessed. If\n the function returns true, this indicates failure to purge.\n\n \n typedef bool (extent_split_t)\n extent_hooks_t *extent_hooks\n void *addr\n size_t size\n size_t size_a\n size_t size_b\n bool committed\n unsigned arena_ind\n \n \n An extent split function conforms to the\n extent_split_t type and optionally splits an extent at\n given addr and size into\n two adjacent extents, the first of size_a bytes,\n and the second of size_b bytes, operating on\n committed/decommitted memory as indicated, on\n behalf of arena arena_ind, returning false upon\n success. If the function returns true, this indicates that the extent\n remains unsplit and therefore should continue to be operated on as a\n whole.\n\n \n typedef bool (extent_merge_t)\n extent_hooks_t *extent_hooks\n void *addr_a\n size_t size_a\n void *addr_b\n size_t size_b\n bool committed\n unsigned arena_ind\n \n \n An extent merge function conforms to the\n extent_merge_t type and optionally merges adjacent extents,\n at given addr_a and size_a\n with given addr_b and\n size_b into one contiguous extent, operating on\n committed/decommitted memory as indicated, on\n behalf of arena arena_ind, returning false upon\n success. If the function returns true, this indicates that the extents\n remain distinct mappings and therefore should continue to be operated on\n independently.\n \n \n\n \n \n arenas.narenas\n (unsigned)\n r-\n \n Current limit on number of arenas.\n \n\n \n \n arenas.dirty_decay_ms\n (ssize_t)\n rw\n \n Current default per-arena approximate time in\n milliseconds from the creation of a set of unused dirty pages until an\n equivalent set of unused dirty pages is purged and/or reused, used to\n initialize arena.<i>.dirty_decay_ms\n during arena creation. See opt.dirty_decay_ms\n for additional information.\n \n\n \n \n arenas.muzzy_decay_ms\n (ssize_t)\n rw\n \n Current default per-arena approximate time in\n milliseconds from the creation of a set of unused muzzy pages until an\n equivalent set of unused muzzy pages is purged and/or reused, used to\n initialize arena.<i>.muzzy_decay_ms\n during arena creation. See opt.muzzy_decay_ms\n for additional information.\n \n\n \n \n arenas.quantum\n (size_t)\n r-\n \n Quantum size.\n \n\n \n \n arenas.page\n (size_t)\n r-\n \n Page size.\n \n\n \n \n arenas.tcache_max\n (size_t)\n r-\n \n Maximum thread-cached size class.\n \n\n \n \n arenas.nbins\n (unsigned)\n r-\n \n Number of bin size classes.\n \n\n \n \n arenas.nhbins\n (unsigned)\n r-\n \n Total number of thread cache bin size\n classes.\n \n\n \n \n arenas.bin.<i>.size\n (size_t)\n r-\n \n Maximum size supported by size class.\n \n\n \n \n arenas.bin.<i>.nregs\n (uint32_t)\n r-\n \n Number of regions per slab.\n \n\n \n \n arenas.bin.<i>.slab_size\n (size_t)\n r-\n \n Number of bytes per slab.\n \n\n \n \n arenas.nlextents\n (unsigned)\n r-\n \n Total number of large size classes.\n \n\n \n \n arenas.lextent.<i>.size\n (size_t)\n r-\n \n Maximum size supported by this large size\n class.\n \n\n \n \n arenas.create\n (unsigned, extent_hooks_t *)\n rw\n \n Explicitly create a new arena outside the range of\n automatically managed arenas, with optionally specified extent hooks,\n and return the new arena index.\n\n If the amount of space supplied for storing the arena index does\n not equal sizeof(unsigned), no\n arena will be created, no data will be written to the space pointed by\n oldp, and *oldlenp will\n be set to 0.\n \n \n\n \n \n arenas.lookup\n (unsigned, void*)\n rw\n \n Index of the arena to which an allocation belongs to.\n \n\n \n \n prof.thread_active_init\n (bool)\n rw\n []\n \n Control the initial setting for thread.prof.active\n in newly created threads. See the opt.prof_thread_active_init\n option for additional information.\n \n\n \n \n prof.active\n (bool)\n rw\n []\n \n Control whether sampling is currently active. See the\n opt.prof_active\n option for additional information, as well as the interrelated thread.prof.active\n mallctl.\n \n\n \n \n prof.dump\n (const char *)\n -w\n []\n \n Dump a memory profile to the specified file, or if NULL\n is specified, to a file according to the pattern\n <prefix>.<pid>.<seq>.m<mseq>.heap,\n where <prefix> is controlled by the\n opt.prof_prefix\n and prof.prefix\n options.\n \n\n \n \n prof.prefix\n (const char *)\n -w\n []\n \n Set the filename prefix for profile dumps. See\n opt.prof_prefix\n for the default setting. This can be useful to differentiate profile\n dumps such as from forked processes.\n \n \n\n \n \n prof.gdump\n (bool)\n rw\n []\n \n When enabled, trigger a memory profile dump every time\n the total virtual memory exceeds the previous maximum. Profiles are\n dumped to files named according to the pattern\n <prefix>.<pid>.<seq>.u<useq>.heap,\n where <prefix> is controlled by the opt.prof_prefix and\n prof.prefix\n options.\n \n\n \n \n prof.reset\n (size_t)\n -w\n []\n \n Reset all memory profile statistics, and optionally\n update the sample rate (see opt.lg_prof_sample\n and prof.lg_sample).\n \n \n\n \n \n prof.lg_sample\n (size_t)\n r-\n []\n \n Get the current sample rate (see opt.lg_prof_sample).\n \n \n\n \n \n prof.interval\n (uint64_t)\n r-\n []\n \n Average number of bytes allocated between\n interval-based profile dumps. See the\n opt.lg_prof_interval\n option for additional information.\n \n\n \n \n stats.allocated\n (size_t)\n r-\n []\n \n Total number of bytes allocated by the\n application.\n \n\n \n \n stats.active\n (size_t)\n r-\n []\n \n Total number of bytes in active pages allocated by the\n application. This is a multiple of the page size, and greater than or\n equal to stats.allocated.\n This does not include \n stats.arenas.<i>.pdirty,\n \n stats.arenas.<i>.pmuzzy, nor pages\n entirely devoted to allocator metadata.\n \n\n \n \n stats.metadata\n (size_t)\n r-\n []\n \n Total number of bytes dedicated to metadata, which\n comprise base allocations used for bootstrap-sensitive allocator\n metadata structures (see stats.arenas.<i>.base)\n and internal allocations (see stats.arenas.<i>.internal).\n Transparent huge page (enabled with opt.metadata_thp) usage is not\n considered.\n \n\n \n \n stats.metadata_thp\n (size_t)\n r-\n []\n \n Number of transparent huge pages (THP) used for\n metadata. See stats.metadata and\n opt.metadata_thp) for\n details.\n \n\n \n \n stats.resident\n (size_t)\n r-\n []\n \n Maximum number of bytes in physically resident data\n pages mapped by the allocator, comprising all pages dedicated to\n allocator metadata, pages backing active allocations, and unused dirty\n pages. This is a maximum rather than precise because pages may not\n actually be physically resident if they correspond to demand-zeroed\n virtual memory that has not yet been touched. This is a multiple of the\n page size, and is larger than stats.active.\n \n\n \n \n stats.mapped\n (size_t)\n r-\n []\n \n Total number of bytes in active extents mapped by the\n allocator. This is larger than stats.active. This\n does not include inactive extents, even those that contain unused dirty\n pages, which means that there is no strict ordering between this and\n stats.resident.\n \n\n \n \n stats.retained\n (size_t)\n r-\n []\n \n Total number of bytes in virtual memory mappings that\n were retained rather than being returned to the operating system via\n e.g. munmap\n 2 or similar. Retained virtual\n memory is typically untouched, decommitted, or purged, so it has no\n strongly associated physical memory (see extent hooks for details).\n Retained memory is excluded from mapped memory statistics, e.g. stats.mapped.\n \n \n\n \n \n stats.zero_reallocs\n (size_t)\n r-\n []\n \n Number of times that the realloc()\n was called with a non-NULL pointer argument and a\n 0 size argument. This is a fundamentally unsafe\n pattern in portable programs; see \n opt.zero_realloc for details.\n \n \n\n \n \n stats.background_thread.num_threads\n (size_t)\n r-\n []\n \n Number of background\n threads running currently.\n \n\n \n \n stats.background_thread.num_runs\n (uint64_t)\n r-\n []\n \n Total number of runs from all background threads.\n \n\n \n \n stats.background_thread.run_interval\n (uint64_t)\n r-\n []\n \n Average run interval in nanoseconds of background threads.\n \n\n \n \n stats.mutexes.ctl.{counter};\n (counter specific type)\n r-\n []\n \n Statistics on ctl mutex (global\n scope; mallctl related). {counter} is one of the\n counters below:\n \n num_ops (uint64_t):\n Total number of lock acquisition operations on this mutex.\n\n\t num_spin_acq (uint64_t): Number\n\t of times the mutex was spin-acquired. When the mutex is currently\n\t locked and cannot be acquired immediately, a short period of\n\t spin-retry within jemalloc will be performed. Acquired through spin\n\t generally means the contention was lightweight and not causing context\n\t switches.\n\n\t num_wait (uint64_t): Number of\n\t times the mutex was wait-acquired, which means the mutex contention\n\t was not solved by spin-retry, and blocking operation was likely\n\t involved in order to acquire the mutex. This event generally implies\n\t higher cost / longer delay, and should be investigated if it happens\n\t often.\n\n\t max_wait_time (uint64_t):\n\t Maximum length of time in nanoseconds spent on a single wait-acquired\n\t lock operation. Note that to avoid profiling overhead on the common\n\t path, this does not consider spin-acquired cases.\n\n\t total_wait_time (uint64_t):\n\t Cumulative time in nanoseconds spent on wait-acquired lock operations.\n\t Similarly, spin-acquired cases are not considered.\n\n\t max_num_thds (uint32_t): Maximum\n\t number of threads waiting on this mutex simultaneously. Similarly,\n\t spin-acquired cases are not considered.\n\n\t num_owner_switch (uint64_t):\n\t Number of times the current mutex owner is different from the previous\n\t one. This event does not generally imply an issue; rather it is an\n\t indicator of how often the protected data are accessed by different\n\t threads.\n\t \n\t \n\t\n\t\n \n\n \n \n stats.mutexes.background_thread.{counter}\n\t (counter specific type) r-\n []\n \n Statistics on background_thread mutex\n (global scope; background_thread\n related). {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.mutexes.prof.{counter}\n\t (counter specific type) r-\n []\n \n Statistics on prof mutex (global\n scope; profiling related). {counter} is one of the\n counters in mutex profiling\n counters.\n \n\n \n \n stats.mutexes.prof_thds_data.{counter}\n\t (counter specific type) r-\n []\n \n\tStatistics on prof threads data mutex\n\t(global scope; profiling related). {counter} is one\n\tof the counters in mutex profiling\n counters.\n \n\n \n \n stats.mutexes.prof_dump.{counter}\n\t (counter specific type) r-\n []\n \n\tStatistics on prof dumping mutex\n\t(global scope; profiling related). {counter} is one\n\tof the counters in mutex profiling\n counters.\n \n\n \n \n stats.mutexes.reset\n\t (void) --\n []\n \n Reset all mutex profile statistics, including global\n mutexes, arena mutexes and bin mutexes.\n \n\n \n \n stats.arenas.<i>.dss\n (const char *)\n r-\n \n dss (sbrk\n 2) allocation precedence as\n related to mmap\n 2 allocation. See opt.dss for details.\n \n \n\n \n \n stats.arenas.<i>.dirty_decay_ms\n (ssize_t)\n r-\n \n Approximate time in milliseconds from the creation of a\n set of unused dirty pages until an equivalent set of unused dirty pages\n is purged and/or reused. See opt.dirty_decay_ms\n for details.\n \n\n \n \n stats.arenas.<i>.muzzy_decay_ms\n (ssize_t)\n r-\n \n Approximate time in milliseconds from the creation of a\n set of unused muzzy pages until an equivalent set of unused muzzy pages\n is purged and/or reused. See opt.muzzy_decay_ms\n for details.\n \n\n \n \n stats.arenas.<i>.nthreads\n (unsigned)\n r-\n \n Number of threads currently assigned to\n arena.\n \n\n \n \n stats.arenas.<i>.uptime\n (uint64_t)\n r-\n \n Time elapsed (in nanoseconds) since the arena was\n created. If <i> equals 0 or\n MALLCTL_ARENAS_ALL, this is the uptime since malloc\n initialization.\n \n\n \n \n stats.arenas.<i>.pactive\n (size_t)\n r-\n \n Number of pages in active extents.\n \n\n \n \n stats.arenas.<i>.pdirty\n (size_t)\n r-\n \n Number of pages within unused extents that are\n potentially dirty, and for which madvise() or\n similar has not been called. See opt.dirty_decay_ms\n for a description of dirty pages.\n \n\n \n \n stats.arenas.<i>.pmuzzy\n (size_t)\n r-\n \n Number of pages within unused extents that are muzzy.\n See opt.muzzy_decay_ms\n for a description of muzzy pages.\n \n\n \n \n stats.arenas.<i>.mapped\n (size_t)\n r-\n []\n \n Number of mapped bytes.\n \n\n \n \n stats.arenas.<i>.retained\n (size_t)\n r-\n []\n \n Number of retained bytes. See stats.retained for\n details.\n \n\n \n \n stats.arenas.<i>.extent_avail\n (size_t)\n r-\n []\n \n Number of allocated (but unused) extent structs in this\n\tarena.\n \n\n \n \n stats.arenas.<i>.base\n (size_t)\n r-\n []\n \n \n Number of bytes dedicated to bootstrap-sensitive allocator metadata\n structures.\n \n\n \n \n stats.arenas.<i>.internal\n (size_t)\n r-\n []\n \n Number of bytes dedicated to internal allocations.\n Internal allocations differ from application-originated allocations in\n that they are for internal use, and that they are omitted from heap\n profiles.\n \n\n \n \n stats.arenas.<i>.metadata_thp\n (size_t)\n r-\n []\n \n Number of transparent huge pages (THP) used for\n metadata. See opt.metadata_thp\n for details.\n \n\n \n \n stats.arenas.<i>.resident\n (size_t)\n r-\n []\n \n Maximum number of bytes in physically resident data\n pages mapped by the arena, comprising all pages dedicated to allocator\n metadata, pages backing active allocations, and unused dirty pages.\n This is a maximum rather than precise because pages may not actually be\n physically resident if they correspond to demand-zeroed virtual memory\n that has not yet been touched. This is a multiple of the page\n size.\n \n\n \n \n stats.arenas.<i>.dirty_npurge\n (uint64_t)\n r-\n []\n \n Number of dirty page purge sweeps performed.\n \n \n\n \n \n stats.arenas.<i>.dirty_nmadvise\n (uint64_t)\n r-\n []\n \n Number of madvise() or similar\n calls made to purge dirty pages.\n \n\n \n \n stats.arenas.<i>.dirty_purged\n (uint64_t)\n r-\n []\n \n Number of dirty pages purged.\n \n\n \n \n stats.arenas.<i>.muzzy_npurge\n (uint64_t)\n r-\n []\n \n Number of muzzy page purge sweeps performed.\n \n \n\n \n \n stats.arenas.<i>.muzzy_nmadvise\n (uint64_t)\n r-\n []\n \n Number of madvise() or similar\n calls made to purge muzzy pages.\n \n\n \n \n stats.arenas.<i>.muzzy_purged\n (uint64_t)\n r-\n []\n \n Number of muzzy pages purged.\n \n\n \n \n stats.arenas.<i>.small.allocated\n (size_t)\n r-\n []\n \n Number of bytes currently allocated by small objects.\n \n \n\n \n \n stats.arenas.<i>.small.nmalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a small allocation was\n requested from the arena's bins, whether to fill the relevant tcache if\n opt.tcache is\n enabled, or to directly satisfy an allocation request\n otherwise.\n \n\n \n \n stats.arenas.<i>.small.ndalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a small allocation was\n returned to the arena's bins, whether to flush the relevant tcache if\n opt.tcache is\n enabled, or to directly deallocate an allocation\n otherwise.\n \n\n \n \n stats.arenas.<i>.small.nrequests\n (uint64_t)\n r-\n []\n \n Cumulative number of allocation requests satisfied by\n all bin size classes.\n \n\n \n \n stats.arenas.<i>.small.nfills\n (uint64_t)\n r-\n []\n \n Cumulative number of tcache fills by all small size\n\tclasses.\n \n\n \n \n stats.arenas.<i>.small.nflushes\n (uint64_t)\n r-\n []\n \n Cumulative number of tcache flushes by all small size\n classes.\n \n\n \n \n stats.arenas.<i>.large.allocated\n (size_t)\n r-\n []\n \n Number of bytes currently allocated by large objects.\n \n \n\n \n \n stats.arenas.<i>.large.nmalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a large extent was allocated\n from the arena, whether to fill the relevant tcache if opt.tcache is enabled and\n the size class is within the range being cached, or to directly satisfy\n an allocation request otherwise.\n \n\n \n \n stats.arenas.<i>.large.ndalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a large extent was returned\n to the arena, whether to flush the relevant tcache if opt.tcache is enabled and\n the size class is within the range being cached, or to directly\n deallocate an allocation otherwise.\n \n\n \n \n stats.arenas.<i>.large.nrequests\n (uint64_t)\n r-\n []\n \n Cumulative number of allocation requests satisfied by\n all large size classes.\n \n\n \n \n stats.arenas.<i>.large.nfills\n (uint64_t)\n r-\n []\n \n Cumulative number of tcache fills by all large size\n\tclasses.\n \n\n \n \n stats.arenas.<i>.large.nflushes\n (uint64_t)\n r-\n []\n \n Cumulative number of tcache flushes by all large size\n classes.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nmalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a bin region of the\n corresponding size class was allocated from the arena, whether to fill\n the relevant tcache if opt.tcache is enabled, or\n to directly satisfy an allocation request otherwise.\n \n\n \n \n stats.arenas.<i>.bins.<j>.ndalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a bin region of the\n corresponding size class was returned to the arena, whether to flush the\n relevant tcache if opt.tcache is enabled, or\n to directly deallocate an allocation otherwise.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nrequests\n (uint64_t)\n r-\n []\n \n Cumulative number of allocation requests satisfied by\n bin regions of the corresponding size class.\n \n\n \n \n stats.arenas.<i>.bins.<j>.curregs\n (size_t)\n r-\n []\n \n Current number of regions for this size\n class.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nfills\n (uint64_t)\n r-\n \n Cumulative number of tcache fills.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nflushes\n (uint64_t)\n r-\n \n Cumulative number of tcache flushes.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nslabs\n (uint64_t)\n r-\n []\n \n Cumulative number of slabs created.\n \n\n \n \n stats.arenas.<i>.bins.<j>.nreslabs\n (uint64_t)\n r-\n []\n \n Cumulative number of times the current slab from which\n to allocate changed.\n \n\n \n \n stats.arenas.<i>.bins.<j>.curslabs\n (size_t)\n r-\n []\n \n Current number of slabs.\n \n\n\n \n \n stats.arenas.<i>.bins.<j>.nonfull_slabs\n (size_t)\n r-\n []\n \n Current number of nonfull slabs.\n \n\n \n \n stats.arenas.<i>.bins.<j>.mutex.{counter}\n (counter specific type) r-\n []\n \n Statistics on\n arena.<i>.bins.<j> mutex (arena bin\n scope; bin operation related). {counter} is one of\n the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.extents.<j>.n{extent_type}\n (size_t)\n r-\n []\n \n Number of extents of the given type in this arena in\n\tthe bucket corresponding to page size index <j>. The extent type\n\tis one of dirty, muzzy, or retained.\n \n\n \n \n stats.arenas.<i>.extents.<j>.{extent_type}_bytes\n (size_t)\n r-\n []\n \n\t Sum of the bytes managed by extents of the given type\n\tin this arena in the bucket corresponding to page size index <j>.\n\tThe extent type is one of dirty, muzzy, or retained.\n \n\n \n \n stats.arenas.<i>.lextents.<j>.nmalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a large extent of the\n corresponding size class was allocated from the arena, whether to fill\n the relevant tcache if opt.tcache is enabled and\n the size class is within the range being cached, or to directly satisfy\n an allocation request otherwise.\n \n\n \n \n stats.arenas.<i>.lextents.<j>.ndalloc\n (uint64_t)\n r-\n []\n \n Cumulative number of times a large extent of the\n corresponding size class was returned to the arena, whether to flush the\n relevant tcache if opt.tcache is enabled and\n the size class is within the range being cached, or to directly\n deallocate an allocation otherwise.\n \n\n \n \n stats.arenas.<i>.lextents.<j>.nrequests\n (uint64_t)\n r-\n []\n \n Cumulative number of allocation requests satisfied by\n large extents of the corresponding size class.\n \n\n \n \n stats.arenas.<i>.lextents.<j>.curlextents\n (size_t)\n r-\n []\n \n Current number of large allocations for this size class.\n \n \n\n \n \n stats.arenas.<i>.mutexes.large.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.large\n mutex (arena scope; large allocation related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.extent_avail.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.extent_avail\n mutex (arena scope; extent avail related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.extents_dirty.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.extents_dirty\n mutex (arena scope; dirty extents related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.extents_muzzy.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.extents_muzzy\n mutex (arena scope; muzzy extents related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.extents_retained.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.extents_retained\n mutex (arena scope; retained extents related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.decay_dirty.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.decay_dirty\n mutex (arena scope; decay for dirty pages related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.decay_muzzy.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.decay_muzzy\n mutex (arena scope; decay for muzzy pages related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.base.{counter}\n (counter specific type) r-\n []\n \n Statistics on arena.<i>.base\n mutex (arena scope; base allocator related).\n {counter} is one of the counters in mutex profiling\n counters.\n \n\n \n \n stats.arenas.<i>.mutexes.tcache_list.{counter}\n (counter specific type) r-\n []\n \n Statistics on\n arena.<i>.tcache_list mutex (arena scope;\n tcache to arena association related). This mutex is expected to be\n accessed less often. {counter} is one of the\n counters in mutex profiling\n counters.\n \n\n \n \n \n HEAP PROFILE FORMAT\n Although the heap profiling functionality was originally designed to\n be compatible with the\n pprof command that is developed as part of the gperftools\n package, the addition of per thread heap profiling functionality\n required a different heap profile format. The jeprof\n command is derived from pprof, with enhancements to\n support the heap profile format described here.\n\n In the following hypothetical heap profile, [...]\n indicates elision for the sake of compactness. The following matches the above heap profile, but most\ntokens are replaced with <description> to indicate\ndescriptions of the corresponding fields. /\n : : [: ]\n [...]\n : : [: ]\n [...]\n : : [: ]\n [...]\n@ [...] [...]\n : : [: ]\n : : [: ]\n : : [: ]\n[...]\n\nMAPPED_LIBRARIES:\n/maps>]]>\n \n\n \n DEBUGGING MALLOC PROBLEMS\n When debugging, it is a good idea to configure/build jemalloc with\n the and \n options, and recompile the program with suitable options and symbols for\n debugger support. When so configured, jemalloc incorporates a wide variety\n of run-time assertions that catch application errors such as double-free,\n write-after-free, etc.\n\n Programs often accidentally depend on uninitialized\n memory actually being filled with zero bytes. Junk filling\n (see the opt.junk\n option) tends to expose such bugs in the form of obviously incorrect\n results and/or coredumps. Conversely, zero\n filling (see the opt.zero option) eliminates\n the symptoms of such bugs. Between these two options, it is usually\n possible to quickly detect, diagnose, and eliminate such bugs.\n\n This implementation does not provide much detail about the problems\n it detects, because the performance impact for storing such information\n would be prohibitive.\n \n \n DIAGNOSTIC MESSAGES\n If any of the memory allocation/deallocation functions detect an\n error or warning condition, a message will be printed to file descriptor\n STDERR_FILENO. Errors will result in the process\n dumping core. If the opt.abort option is set, most\n warnings are treated as errors.\n\n The malloc_message variable allows the programmer\n to override the function which emits the text strings forming the errors\n and warnings if for some reason the STDERR_FILENO file\n descriptor is not suitable for this.\n malloc_message() takes the\n cbopaque pointer argument that is\n NULL unless overridden by the arguments in a call to\n malloc_stats_print(), followed by a string\n pointer. Please note that doing anything which tries to allocate memory in\n this function is likely to result in a crash or deadlock.\n\n All messages are prefixed by\n <jemalloc>: .\n \n \n RETURN VALUES\n \n Standard API\n The malloc() and\n calloc() functions return a pointer to the\n allocated memory if successful; otherwise a NULL\n pointer is returned and errno is set to\n ENOMEM.\n\n The posix_memalign() function\n returns the value 0 if successful; otherwise it returns an error value.\n The posix_memalign() function will fail\n if:\n \n \n EINVAL\n\n The alignment parameter is\n not a power of 2 at least as large as\n sizeof(void *).\n \n \n \n ENOMEM\n\n Memory allocation error.\n \n \n \n\n The aligned_alloc() function returns\n a pointer to the allocated memory if successful; otherwise a\n NULL pointer is returned and\n errno is set. The\n aligned_alloc() function will fail if:\n \n \n EINVAL\n\n The alignment parameter is\n not a power of 2.\n \n \n \n ENOMEM\n\n Memory allocation error.\n \n \n \n\n The realloc() function returns a\n pointer, possibly identical to ptr, to the\n allocated memory if successful; otherwise a NULL\n pointer is returned, and errno is set to\n ENOMEM if the error was the result of an\n allocation failure. The realloc()\n function always leaves the original buffer intact when an error occurs.\n \n\n The free() function returns no\n value.\n \n \n Non-standard API\n The mallocx() and\n rallocx() functions return a pointer to\n the allocated memory if successful; otherwise a NULL\n pointer is returned to indicate insufficient contiguous memory was\n available to service the allocation request. \n\n The xallocx() function returns the\n real size of the resulting resized allocation pointed to by\n ptr, which is a value less than\n size if the allocation could not be adequately\n grown in place. \n\n The sallocx() function returns the\n real size of the allocation pointed to by ptr.\n \n\n The nallocx() returns the real size\n that would result from a successful equivalent\n mallocx() function call, or zero if\n insufficient memory is available to perform the size computation. \n\n The mallctl(),\n mallctlnametomib(), and\n mallctlbymib() functions return 0 on\n success; otherwise they return an error value. The functions will fail\n if:\n \n \n EINVAL\n\n newp is not\n NULL, and newlen is too\n large or too small. Alternatively, *oldlenp\n is too large or too small; when it happens, except for a very few\n cases explicitly documented otherwise, as much data as possible\n are read despite the error, with the amount of data read being\n recorded in *oldlenp.\n \n \n ENOENT\n\n name or\n mib specifies an unknown/invalid\n value.\n \n \n EPERM\n\n Attempt to read or write void value, or attempt to\n write read-only value.\n \n \n EAGAIN\n\n A memory allocation failure\n occurred.\n \n \n EFAULT\n\n An interface with side effects failed in some way\n not directly related to mallctl*()\n read/write processing.\n \n \n \n\n The malloc_usable_size() function\n returns the usable size of the allocation pointed to by\n ptr. \n \n \n \n ENVIRONMENT\n The following environment variable affects the execution of the\n allocation functions:\n \n \n MALLOC_CONF\n\n If the environment variable\n MALLOC_CONF is set, the characters it contains\n will be interpreted as options.\n \n \n \n \n \n EXAMPLES\n To dump core whenever a problem occurs:\n ln -s 'abort:true' /etc/malloc.conf\n \n To specify in the source that only one arena should be automatically\n created:\n \n \n \n SEE ALSO\n madvise\n 2,\n mmap\n 2,\n sbrk\n 2,\n utrace\n 2,\n alloca\n 3,\n atexit\n 3,\n getpagesize\n 3\n \n \n STANDARDS\n The malloc(),\n calloc(),\n realloc(), and\n free() functions conform to ISO/IEC\n 9899:1990 (ISO C90).\n\n The posix_memalign() function conforms\n to IEEE Std 1003.1-2001 (POSIX.1).\n \n\n" }, { "path": "deps/jemalloc/doc/manpages.xsl.in", "content": "\n \n \n\n" }, { "path": "deps/jemalloc/doc/stylesheet.xsl", "content": "\n ansi\n \n \n \n \n \n \n \n\n" }, { "path": "deps/jemalloc/doc_internal/PROFILING_INTERNALS.md", "content": "# jemalloc profiling\nThis describes the mathematical basis behind jemalloc's profiling implementation, as well as the implementation tricks that make it effective. Historically, the jemalloc profiling design simply copied tcmalloc's. The implementation has since diverged, due to both the desire to record additional information, and to correct some biasing bugs.\n\nNote: this document is markdown with embedded LaTeX; different markdown renderers may not produce the expected output. Viewing with `pandoc -s PROFILING_INTERNALS.md -o PROFILING_INTERNALS.pdf` is recommended.\n\n## Some tricks in our implementation toolbag\n\n### Sampling\nRecording our metadata is quite expensive; we need to walk up the stack to get a stack trace. On top of that, we need to allocate storage to record that stack trace, and stick it somewhere where a profile-dumping call can find it. That call might happen on another thread, so we'll probably need to take a lock to do so. These costs are quite large compared to the average cost of an allocation. To manage this, we'll only sample some fraction of allocations. This will miss some of them, so our data will be incomplete, but we'll try to make up for it. We can tune our sampling rate to balance accuracy and performance.\n\n### Fast Bernoulli sampling\nCompared to our fast paths, even a `coinflip(p)` function can be quite expensive. Having to do a random-number generation and some floating point operations would be a sizeable relative cost. However (as pointed out in [[Vitter, 1987](https://dl.acm.org/doi/10.1145/23002.23003)]), if we can orchestrate our algorithm so that many of our `coinflip` calls share their parameter value, we can do better. We can sample from the geometric distribution, and initialize a counter with the result. When the counter hits 0, the `coinflip` function returns true (and reinitializes its internal counter).\nThis can let us do a random-number generation once per (logical) coinflip that comes up heads, rather than once per (logical) coinflip. Since we expect to sample relatively rarely, this can be a large win.\n\n### Fast-path / slow-path thinking\nMost programs have a skewed distribution of allocations. Smaller allocations are much more frequent than large ones, but shorter lived and less common as a fraction of program memory. \"Small\" and \"large\" are necessarily sort of fuzzy terms, but if we define \"small\" as \"allocations jemalloc puts into slabs\" and \"large\" as the others, then it's not uncommon for small allocations to be hundreds of times more frequent than large ones, but take up around half the amount of heap space as large ones. Moreover, small allocations tend to be much cheaper than large ones (often by a factor of 20-30): they're more likely to hit in thread caches, less likely to have to do an mmap, and cheaper to fill (by the user) once the allocation has been returned.\n\n## An unbiased estimator of space consumption from (almost) arbitrary sampling strategies\nSuppose we have a sampling strategy that meets the following criteria:\n\n - One allocation being sampled is independent of other allocations being sampled.\n - Each allocation has a non-zero probability of being sampled.\n\nWe can then estimate the bytes in live allocations through some particular stack trace as:\n\n$$ \\sum_i S_i I_i \\frac{1}{\\mathrm{E}[I_i]} $$\n\nwhere the sum ranges over some index variable of live allocations from that stack, $S_i$ is the size of the $i$'th allocation, and $I_i$ is an indicator random variable for whether or not the $i'th$ allocation is sampled. $S_i$ and $\\mathrm{E}[I_i]$ are constants (the program allocations are fixed; the random variables are the sampling decisions), so taking the expectation we get\n\n$$ \\sum_i S_i \\mathrm{E}[I_i] \\frac{1}{\\mathrm{E}[I_i]}.$$\n\nThis is of course $\\sum_i S_i$, as we want (and, a similar calculation could be done for allocation counts as well).\nThis is a fairly general strategy; note that while we require that sampling decisions be independent of one another's outcomes, they don't have to be independent of previous allocations, total bytes allocated, etc. You can imagine strategies that:\n\n - Sample allocations at program startup at a higher rate than subsequent allocations\n - Sample even-indexed allocations more frequently than odd-indexed ones (so long as no allocation has zero sampling probability)\n - Let threads declare themselves as high-sampling-priority, and sample their allocations at an increased rate.\n\nThese can all be fit into this framework to give an unbiased estimator.\n\n## Evaluating sampling strategies\nNot all strategies for picking allocations to sample are equally good, of course. Among unbiased estimators, the lower the variance, the lower the mean squared error. Using the estimator above, the variance is:\n\n$$\n\\begin{aligned}\n& \\mathrm{Var}[\\sum_i S_i I_i \\frac{1}{\\mathrm{E}[I_i]}] \\\\\n=& \\sum_i \\mathrm{Var}[S_i I_i \\frac{1}{\\mathrm{E}[I_i]}] \\\\\n=& \\sum_i \\frac{S_i^2}{\\mathrm{E}[I_i]^2} \\mathrm{Var}[I_i] \\\\\n=& \\sum_i \\frac{S_i^2}{\\mathrm{E}[I_i]^2} \\mathrm{Var}[I_i] \\\\\n=& \\sum_i \\frac{S_i^2}{\\mathrm{E}[I_i]^2} \\mathrm{E}[I_i](1 - \\mathrm{E}[I_i]) \\\\\n=& \\sum_i S_i^2 \\frac{1 - \\mathrm{E}[I_i]}{\\mathrm{E}[I_i]}.\n\\end{aligned}\n$$\n\nWe can use this formula to compare various strategy choices. All else being equal, lower-variance strategies are better.\n\n## Possible sampling strategies\nBecause of the desire to avoid the fast-path costs, we'd like to use our Bernoulli trick if possible. There are two obvious counters to use: a coinflip per allocation, and a coinflip per byte allocated.\n\n### Bernoulli sampling per-allocation\nAn obvious strategy is to pick some large $N$, and give each allocation a $1/N$ chance of being sampled. This would let us use our Bernoulli-via-Geometric trick. Using the formula from above, we can compute the variance as:\n\n$$ \\sum_i S_i^2 \\frac{1 - \\frac{1}{N}}{\\frac{1}{N}} = (N-1) \\sum_i S_i^2.$$\n\nThat is, an allocation of size $Z$ contributes a term of $(N-1)Z^2$ to the variance.\n\n### Bernoulli sampling per-byte\nAnother option we have is to pick some rate $R$, and give each byte a $1/R$ chance of being picked for sampling (at which point we would sample its contained allocation). The chance of an allocation of size $Z$ being sampled, then, is\n\n$$1-(1-\\frac{1}{R})^{Z}$$\n\nand an allocation of size $Z$ contributes a term of\n\n$$Z^2 \\frac{(1-\\frac{1}{R})^{Z}}{1-(1-\\frac{1}{R})^{Z}}.$$\n\nIn practical settings, $R$ is large, and so this is well-approximated by\n\n$$Z^2 \\frac{e^{-Z/R}}{1 - e^{-Z/R}} .$$\n\nJust to get a sense of the dynamics here, let's look at the behavior for various values of $Z$. When $Z$ is small relative to $R$, we can use $e^z \\approx 1 + x$, and conclude that the variance contributed by a small-$Z$ allocation is around\n\n$$Z^2 \\frac{1-Z/R}{Z/R} \\approx RZ.$$\n\nWhen $Z$ is comparable to $R$, the variance term is near $Z^2$ (we have $\\frac{e^{-Z/R}}{1 - e^{-Z/R}} = 1$ when $Z/R = \\ln 2 \\approx 0.693$). When $Z$ is large relative to $R$, the variance term goes to zero.\n\n## Picking a sampling strategy\nThe fast-path/slow-path dynamics of allocation patterns point us towards the per-byte sampling approach:\n\n - The quadratic increase in variance per allocation in the first approach is quite costly when heaps have a non-negligible portion of their bytes in those allocations, which is practically often the case.\n - The Bernoulli-per-byte approach shifts more of its samples towards large allocations, which are already a slow-path.\n - We drive several tickers (e.g. tcache gc) by bytes allocated, and report bytes-allocated as a user-visible statistic, so we have to do all the necessary bookkeeping anyways.\n\nIndeed, this is the approach we use in jemalloc. Our heap dumps record the size of the allocation and the sampling rate $R$, and jeprof unbiases by dividing by $1 - e^{-Z/R}$. The framework above would suggest dividing by $1-(1-1/R)^Z$; instead, we use the fact that $R$ is large in practical situations, and so $e^{-Z/R}$ is a good approximation (and faster to compute). (Equivalently, we may also see this as the factor that falls out from viewing sampling as a Poisson process directly).\n\n## Consequences for heap dump consumers\nUsing this approach means that there are a few things users need to be aware of.\n\n### Stack counts are not proportional to allocation frequencies\nIf one stack appears twice as often as another, this by itself does not imply that it allocates twice as often. Consider the case in which there are only two types of allocating call stacks in a program. Stack A allocates 8 bytes, and occurs a million times in a program. Stack B allocates 8 MB, and occurs just once in a program. If our sampling rate $R$ is about 1MB, we expect stack A to show up about 8 times, and stack B to show up once. Stack A isn't 8 times more frequent than stack B, though; it's a million times more frequent.\n\n### Aggregation must be done after unbiasing samples\nSome tools manually parse heap dump output, and aggregate across stacks (or across program runs) to provide wider-scale data analyses. When doing this aggregation, though, it's important to unbias-and-then-sum, rather than sum-and-then-unbias. Reusing our example from the previous section: suppose we collect heap dumps of the program from a million machines. We then have 8 million occurs of stack A (each of 8 bytes), and a million occurrences of stack B (each of 8 MB). If we sum first, we'll attribute 64 MB to stack A, and 8 TB to stack B. Unbiasing changes these numbers by an infinitesimal amount, so that sum-then-unbias dramatically underreports the amount of memory allocated by stack A.\n\n## An avenue for future exploration\nWhile the framework we laid out above is pretty general, as an engineering decision we're only interested in fairly simple approaches (i.e. ones for which the chance of an allocation being sampled depends only on its size). Our job is then: for each size class $Z$, pick a probability $p_Z$ that an allocation of that size will be sampled. We made some handwave-y references to statistical distributions to justify our choices, but there's no reason we need to pick them that way. Any set of non-zero probabilities is a valid choice.\nThe real limiting factor in our ability to reduce estimator variance is that fact that sampling is expensive; we want to make sure we only do it on a small fraction of allocations. Our goal, then, is to pick the $p_Z$ to minimize variance given some maximum sampling rate $P$. If we define $a_Z$ to be the fraction of allocations of size $Z$, and $l_Z$ to be the fraction of allocations of size $Z$ still alive at the time of a heap dump, then we can phrase this as an optimization problem over the choices of $p_Z$:\n\nMinimize\n\n$$ \\sum_Z Z^2 l_Z \\frac{1-p_Z}{p_Z} $$\n\nsubject to\n\n$$ \\sum_Z a_Z p_Z \\leq P $$\n\nIgnoring a term that doesn't depend on $p_Z$, the objective is minimized whenever\n\n$$ \\sum_Z Z^2 l_Z \\frac{1}{p_Z} $$\n\nis. For a particular program, $l_Z$ and $a_Z$ are just numbers that can be obtained (exactly) from existing stats introspection facilities, and we have a fairly tractable convex optimization problem (it can be framed as a second-order cone program). It would be interesting to evaluate, for various common allocation patterns, how well our current strategy adapts. Do our actual choices for $p_Z$ closely correspond to the optimal ones? How close is the variance of our choices to the variance of the optimal strategy?\nYou can imagine an implementation that actually goes all the way, and makes $p_Z$ selections a tuning parameter. I don't think this is a good use of development time for the foreseeable future; but I do wonder about the answers to some of these questions.\n\n## Implementation realities\n\nThe nice story above is at least partially a lie. Initially, jeprof (copying its logic from pprof) had the sum-then-unbias error described above. The current version of jemalloc does the unbiasing step on a per-allocation basis internally, so that we're always tracking what the unbiased numbers \"should\" be. The problem is, actually surfacing those unbiased numbers would require a breaking change to jeprof (and the various already-deployed tools that have copied its logic). Instead, we use a little bit more trickery. Since we know at dump time the numbers we want jeprof to report, we simply choose the values we'll output so that the jeprof numbers will match the true numbers. The math is described in `src/prof_data.c` (where the only cleverness is a change of variables that lets the exponentials fall out).\n\nThis has the effect of making the output of jeprof (and related tools) correct, while making its inputs incorrect. This can be annoying to human readers of raw profiling dump output.\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/activity_callback.h", "content": "#ifndef JEMALLOC_INTERNAL_ACTIVITY_CALLBACK_H\n#define JEMALLOC_INTERNAL_ACTIVITY_CALLBACK_H\n\n/*\n * The callback to be executed \"periodically\", in response to some amount of\n * allocator activity.\n *\n * This callback need not be computing any sort of peak (although that's the\n * intended first use case), but we drive it from the peak counter, so it's\n * keeps things tidy to keep it here.\n *\n * The calls to this thunk get driven by the peak_event module.\n */\n#define ACTIVITY_CALLBACK_THUNK_INITIALIZER {NULL, NULL}\ntypedef void (*activity_callback_t)(void *uctx, uint64_t allocated,\n uint64_t deallocated);\ntypedef struct activity_callback_thunk_s activity_callback_thunk_t;\nstruct activity_callback_thunk_s {\n\tactivity_callback_t callback;\n\tvoid *uctx;\n};\n\n#endif /* JEMALLOC_INTERNAL_ACTIVITY_CALLBACK_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n#define JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n\n#include \"jemalloc/internal/bin.h\"\n#include \"jemalloc/internal/div.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/hook.h\"\n#include \"jemalloc/internal/pages.h\"\n#include \"jemalloc/internal/stats.h\"\n\n/*\n * When the amount of pages to be purged exceeds this amount, deferred purge\n * should happen.\n */\n#define ARENA_DEFERRED_PURGE_NPAGES_THRESHOLD UINT64_C(1024)\n\nextern ssize_t opt_dirty_decay_ms;\nextern ssize_t opt_muzzy_decay_ms;\n\nextern percpu_arena_mode_t opt_percpu_arena;\nextern const char *percpu_arena_mode_names[];\n\nextern div_info_t arena_binind_div_info[SC_NBINS];\n\nextern malloc_mutex_t arenas_lock;\nextern emap_t arena_emap_global;\n\nextern size_t opt_oversize_threshold;\nextern size_t oversize_threshold;\n\n/*\n * arena_bin_offsets[binind] is the offset of the first bin shard for size class\n * binind.\n */\nextern uint32_t arena_bin_offsets[SC_NBINS];\n\nvoid arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena,\n unsigned *nthreads, const char **dss, ssize_t *dirty_decay_ms,\n ssize_t *muzzy_decay_ms, size_t *nactive, size_t *ndirty, size_t *nmuzzy);\nvoid arena_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,\n const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms,\n size_t *nactive, size_t *ndirty, size_t *nmuzzy, arena_stats_t *astats,\n bin_stats_data_t *bstats, arena_stats_large_t *lstats,\n pac_estats_t *estats, hpa_shard_stats_t *hpastats, sec_stats_t *secstats);\nvoid arena_handle_deferred_work(tsdn_t *tsdn, arena_t *arena);\nedata_t *arena_extent_alloc_large(tsdn_t *tsdn, arena_t *arena,\n size_t usize, size_t alignment, bool zero);\nvoid arena_extent_dalloc_large_prep(tsdn_t *tsdn, arena_t *arena,\n edata_t *edata);\nvoid arena_extent_ralloc_large_shrink(tsdn_t *tsdn, arena_t *arena,\n edata_t *edata, size_t oldsize);\nvoid arena_extent_ralloc_large_expand(tsdn_t *tsdn, arena_t *arena,\n edata_t *edata, size_t oldsize);\nbool arena_decay_ms_set(tsdn_t *tsdn, arena_t *arena, extent_state_t state,\n ssize_t decay_ms);\nssize_t arena_decay_ms_get(arena_t *arena, extent_state_t state);\nvoid arena_decay(tsdn_t *tsdn, arena_t *arena, bool is_background_thread,\n bool all);\nuint64_t arena_time_until_deferred(tsdn_t *tsdn, arena_t *arena);\nvoid arena_do_deferred_work(tsdn_t *tsdn, arena_t *arena);\nvoid arena_reset(tsd_t *tsd, arena_t *arena);\nvoid arena_destroy(tsd_t *tsd, arena_t *arena);\nvoid arena_cache_bin_fill_small(tsdn_t *tsdn, arena_t *arena,\n cache_bin_t *cache_bin, cache_bin_info_t *cache_bin_info, szind_t binind,\n const unsigned nfill);\n\nvoid *arena_malloc_hard(tsdn_t *tsdn, arena_t *arena, size_t size,\n szind_t ind, bool zero);\nvoid *arena_palloc(tsdn_t *tsdn, arena_t *arena, size_t usize,\n size_t alignment, bool zero, tcache_t *tcache);\nvoid arena_prof_promote(tsdn_t *tsdn, void *ptr, size_t usize);\nvoid arena_dalloc_promoted(tsdn_t *tsdn, void *ptr, tcache_t *tcache,\n bool slow_path);\nvoid arena_slab_dalloc(tsdn_t *tsdn, arena_t *arena, edata_t *slab);\n\nvoid arena_dalloc_bin_locked_handle_newly_empty(tsdn_t *tsdn, arena_t *arena,\n edata_t *slab, bin_t *bin);\nvoid arena_dalloc_bin_locked_handle_newly_nonempty(tsdn_t *tsdn, arena_t *arena,\n edata_t *slab, bin_t *bin);\nvoid arena_dalloc_small(tsdn_t *tsdn, void *ptr);\nbool arena_ralloc_no_move(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,\n size_t extra, bool zero, size_t *newsize);\nvoid *arena_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,\n size_t size, size_t alignment, bool zero, tcache_t *tcache,\n hook_ralloc_args_t *hook_args);\ndss_prec_t arena_dss_prec_get(arena_t *arena);\nehooks_t *arena_get_ehooks(arena_t *arena);\nextent_hooks_t *arena_set_extent_hooks(tsd_t *tsd, arena_t *arena,\n extent_hooks_t *extent_hooks);\nbool arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec);\nssize_t arena_dirty_decay_ms_default_get(void);\nbool arena_dirty_decay_ms_default_set(ssize_t decay_ms);\nssize_t arena_muzzy_decay_ms_default_get(void);\nbool arena_muzzy_decay_ms_default_set(ssize_t decay_ms);\nbool arena_retain_grow_limit_get_set(tsd_t *tsd, arena_t *arena,\n size_t *old_limit, size_t *new_limit);\nunsigned arena_nthreads_get(arena_t *arena, bool internal);\nvoid arena_nthreads_inc(arena_t *arena, bool internal);\nvoid arena_nthreads_dec(arena_t *arena, bool internal);\narena_t *arena_new(tsdn_t *tsdn, unsigned ind, const arena_config_t *config);\nbool arena_init_huge(void);\nbool arena_is_huge(unsigned arena_ind);\narena_t *arena_choose_huge(tsd_t *tsd);\nbin_t *arena_bin_choose(tsdn_t *tsdn, arena_t *arena, szind_t binind,\n unsigned *binshard);\nsize_t arena_fill_small_fresh(tsdn_t *tsdn, arena_t *arena, szind_t binind,\n void **ptrs, size_t nfill, bool zero);\nbool arena_boot(sc_data_t *sc_data, base_t *base, bool hpa);\nvoid arena_prefork0(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork1(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork2(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork3(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork4(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork5(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork6(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork7(tsdn_t *tsdn, arena_t *arena);\nvoid arena_prefork8(tsdn_t *tsdn, arena_t *arena);\nvoid arena_postfork_parent(tsdn_t *tsdn, arena_t *arena);\nvoid arena_postfork_child(tsdn_t *tsdn, arena_t *arena);\n\n#endif /* JEMALLOC_INTERNAL_ARENA_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_a.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n\nstatic inline unsigned\narena_ind_get(const arena_t *arena) {\n\treturn arena->ind;\n}\n\nstatic inline void\narena_internal_add(arena_t *arena, size_t size) {\n\tatomic_fetch_add_zu(&arena->stats.internal, size, ATOMIC_RELAXED);\n}\n\nstatic inline void\narena_internal_sub(arena_t *arena, size_t size) {\n\tatomic_fetch_sub_zu(&arena->stats.internal, size, ATOMIC_RELAXED);\n}\n\nstatic inline size_t\narena_internal_get(arena_t *arena) {\n\treturn atomic_load_zu(&arena->stats.internal, ATOMIC_RELAXED);\n}\n\n#endif /* JEMALLOC_INTERNAL_ARENA_INLINES_A_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_b.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n\n#include \"jemalloc/internal/div.h\"\n#include \"jemalloc/internal/emap.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/rtree.h\"\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/ticker.h\"\n\nstatic inline arena_t *\narena_get_from_edata(edata_t *edata) {\n\treturn (arena_t *)atomic_load_p(&arenas[edata_arena_ind_get(edata)],\n\t ATOMIC_RELAXED);\n}\n\nJEMALLOC_ALWAYS_INLINE arena_t *\narena_choose_maybe_huge(tsd_t *tsd, arena_t *arena, size_t size) {\n\tif (arena != NULL) {\n\t\treturn arena;\n\t}\n\n\t/*\n\t * For huge allocations, use the dedicated huge arena if both are true:\n\t * 1) is using auto arena selection (i.e. arena == NULL), and 2) the\n\t * thread is not assigned to a manual arena.\n\t */\n\tif (unlikely(size >= oversize_threshold)) {\n\t\tarena_t *tsd_arena = tsd_arena_get(tsd);\n\t\tif (tsd_arena == NULL || arena_is_auto(tsd_arena)) {\n\t\t\treturn arena_choose_huge(tsd);\n\t\t}\n\t}\n\n\treturn arena_choose(tsd, NULL);\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_prof_info_get(tsd_t *tsd, const void *ptr, emap_alloc_ctx_t *alloc_ctx,\n prof_info_t *prof_info, bool reset_recent) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\tassert(prof_info != NULL);\n\n\tedata_t *edata = NULL;\n\tbool is_slab;\n\n\t/* Static check. */\n\tif (alloc_ctx == NULL) {\n\t\tedata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global,\n\t\t ptr);\n\t\tis_slab = edata_slab_get(edata);\n\t} else if (unlikely(!(is_slab = alloc_ctx->slab))) {\n\t\tedata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global,\n\t\t ptr);\n\t}\n\n\tif (unlikely(!is_slab)) {\n\t\t/* edata must have been initialized at this point. */\n\t\tassert(edata != NULL);\n\t\tlarge_prof_info_get(tsd, edata, prof_info, reset_recent);\n\t} else {\n\t\tprof_info->alloc_tctx = (prof_tctx_t *)(uintptr_t)1U;\n\t\t/*\n\t\t * No need to set other fields in prof_info; they will never be\n\t\t * accessed if (uintptr_t)alloc_tctx == (uintptr_t)1U.\n\t\t */\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_prof_tctx_reset(tsd_t *tsd, const void *ptr,\n emap_alloc_ctx_t *alloc_ctx) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\n\t/* Static check. */\n\tif (alloc_ctx == NULL) {\n\t\tedata_t *edata = emap_edata_lookup(tsd_tsdn(tsd),\n\t\t &arena_emap_global, ptr);\n\t\tif (unlikely(!edata_slab_get(edata))) {\n\t\t\tlarge_prof_tctx_reset(edata);\n\t\t}\n\t} else {\n\t\tif (unlikely(!alloc_ctx->slab)) {\n\t\t\tedata_t *edata = emap_edata_lookup(tsd_tsdn(tsd),\n\t\t\t &arena_emap_global, ptr);\n\t\t\tlarge_prof_tctx_reset(edata);\n\t\t}\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_prof_tctx_reset_sampled(tsd_t *tsd, const void *ptr) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\n\tedata_t *edata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global,\n\t ptr);\n\tassert(!edata_slab_get(edata));\n\n\tlarge_prof_tctx_reset(edata);\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_prof_info_set(tsd_t *tsd, edata_t *edata, prof_tctx_t *tctx,\n size_t size) {\n\tcassert(config_prof);\n\n\tassert(!edata_slab_get(edata));\n\tlarge_prof_info_set(edata, tctx, size);\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_decay_ticks(tsdn_t *tsdn, arena_t *arena, unsigned nticks) {\n\tif (unlikely(tsdn_null(tsdn))) {\n\t\treturn;\n\t}\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\t/*\n\t * We use the ticker_geom_t to avoid having per-arena state in the tsd.\n\t * Instead of having a countdown-until-decay timer running for every\n\t * arena in every thread, we flip a coin once per tick, whose\n\t * probability of coming up heads is 1/nticks; this is effectively the\n\t * operation of the ticker_geom_t. Each arena has the same chance of a\n\t * coinflip coming up heads (1/ARENA_DECAY_NTICKS_PER_UPDATE), so we can\n\t * use a single ticker for all of them.\n\t */\n\tticker_geom_t *decay_ticker = tsd_arena_decay_tickerp_get(tsd);\n\tuint64_t *prng_state = tsd_prng_statep_get(tsd);\n\tif (unlikely(ticker_geom_ticks(decay_ticker, prng_state, nticks))) {\n\t\tarena_decay(tsdn, arena, false, false);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_decay_tick(tsdn_t *tsdn, arena_t *arena) {\n\tarena_decay_ticks(tsdn, arena, 1);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\narena_malloc(tsdn_t *tsdn, arena_t *arena, size_t size, szind_t ind, bool zero,\n tcache_t *tcache, bool slow_path) {\n\tassert(!tsdn_null(tsdn) || tcache == NULL);\n\n\tif (likely(tcache != NULL)) {\n\t\tif (likely(size <= SC_SMALL_MAXCLASS)) {\n\t\t\treturn tcache_alloc_small(tsdn_tsd(tsdn), arena,\n\t\t\t tcache, size, ind, zero, slow_path);\n\t\t}\n\t\tif (likely(size <= tcache_maxclass)) {\n\t\t\treturn tcache_alloc_large(tsdn_tsd(tsdn), arena,\n\t\t\t tcache, size, ind, zero, slow_path);\n\t\t}\n\t\t/* (size > tcache_maxclass) case falls through. */\n\t\tassert(size > tcache_maxclass);\n\t}\n\n\treturn arena_malloc_hard(tsdn, arena, size, ind, zero);\n}\n\nJEMALLOC_ALWAYS_INLINE arena_t *\narena_aalloc(tsdn_t *tsdn, const void *ptr) {\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tunsigned arena_ind = edata_arena_ind_get(edata);\n\treturn (arena_t *)atomic_load_p(&arenas[arena_ind], ATOMIC_RELAXED);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\narena_salloc(tsdn_t *tsdn, const void *ptr) {\n\tassert(ptr != NULL);\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr, &alloc_ctx);\n\tassert(alloc_ctx.szind != SC_NSIZES);\n\n\treturn sz_index2size(alloc_ctx.szind);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\narena_vsalloc(tsdn_t *tsdn, const void *ptr) {\n\t/*\n\t * Return 0 if ptr is not within an extent managed by jemalloc. This\n\t * function has two extra costs relative to isalloc():\n\t * - The rtree calls cannot claim to be dependent lookups, which induces\n\t * rtree lookup load dependencies.\n\t * - The lookup may fail, so there is an extra branch to check for\n\t * failure.\n\t */\n\n\temap_full_alloc_ctx_t full_alloc_ctx;\n\tbool missing = emap_full_alloc_ctx_try_lookup(tsdn, &arena_emap_global,\n\t ptr, &full_alloc_ctx);\n\tif (missing) {\n\t\treturn 0;\n\t}\n\n\tif (full_alloc_ctx.edata == NULL) {\n\t\treturn 0;\n\t}\n\tassert(edata_state_get(full_alloc_ctx.edata) == extent_state_active);\n\t/* Only slab members should be looked up via interior pointers. */\n\tassert(edata_addr_get(full_alloc_ctx.edata) == ptr\n\t || edata_slab_get(full_alloc_ctx.edata));\n\n\tassert(full_alloc_ctx.szind != SC_NSIZES);\n\n\treturn sz_index2size(full_alloc_ctx.szind);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nlarge_dalloc_safety_checks(edata_t *edata, void *ptr, szind_t szind) {\n\tif (!config_opt_safety_checks) {\n\t\treturn false;\n\t}\n\n\t/*\n\t * Eagerly detect double free and sized dealloc bugs for large sizes.\n\t * The cost is low enough (as edata will be accessed anyway) to be\n\t * enabled all the time.\n\t */\n\tif (unlikely(edata == NULL ||\n\t edata_state_get(edata) != extent_state_active)) {\n\t\tsafety_check_fail(\"Invalid deallocation detected: \"\n\t\t \"pages being freed (%p) not currently active, \"\n\t\t \"possibly caused by double free bugs.\",\n\t\t (uintptr_t)edata_addr_get(edata));\n\t\treturn true;\n\t}\n\tsize_t input_size = sz_index2size(szind);\n\tif (unlikely(input_size != edata_usize_get(edata))) {\n\t\tsafety_check_fail_sized_dealloc(/* current_dealloc */ true, ptr,\n\t\t /* true_size */ edata_usize_get(edata), input_size);\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic inline void\narena_dalloc_large_no_tcache(tsdn_t *tsdn, void *ptr, szind_t szind) {\n\tif (config_prof && unlikely(szind < SC_NBINS)) {\n\t\tarena_dalloc_promoted(tsdn, ptr, NULL, true);\n\t} else {\n\t\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t ptr);\n\t\tif (large_dalloc_safety_checks(edata, ptr, szind)) {\n\t\t\t/* See the comment in isfree. */\n\t\t\treturn;\n\t\t}\n\t\tlarge_dalloc(tsdn, edata);\n\t}\n}\n\nstatic inline void\narena_dalloc_no_tcache(tsdn_t *tsdn, void *ptr) {\n\tassert(ptr != NULL);\n\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr, &alloc_ctx);\n\n\tif (config_debug) {\n\t\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t ptr);\n\t\tassert(alloc_ctx.szind == edata_szind_get(edata));\n\t\tassert(alloc_ctx.szind < SC_NSIZES);\n\t\tassert(alloc_ctx.slab == edata_slab_get(edata));\n\t}\n\n\tif (likely(alloc_ctx.slab)) {\n\t\t/* Small allocation. */\n\t\tarena_dalloc_small(tsdn, ptr);\n\t} else {\n\t\tarena_dalloc_large_no_tcache(tsdn, ptr, alloc_ctx.szind);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_dalloc_large(tsdn_t *tsdn, void *ptr, tcache_t *tcache, szind_t szind,\n bool slow_path) {\n\tif (szind < nhbins) {\n\t\tif (config_prof && unlikely(szind < SC_NBINS)) {\n\t\t\tarena_dalloc_promoted(tsdn, ptr, tcache, slow_path);\n\t\t} else {\n\t\t\ttcache_dalloc_large(tsdn_tsd(tsdn), tcache, ptr, szind,\n\t\t\t slow_path);\n\t\t}\n\t} else {\n\t\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t ptr);\n\t\tif (large_dalloc_safety_checks(edata, ptr, szind)) {\n\t\t\t/* See the comment in isfree. */\n\t\t\treturn;\n\t\t}\n\t\tlarge_dalloc(tsdn, edata);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_dalloc(tsdn_t *tsdn, void *ptr, tcache_t *tcache,\n emap_alloc_ctx_t *caller_alloc_ctx, bool slow_path) {\n\tassert(!tsdn_null(tsdn) || tcache == NULL);\n\tassert(ptr != NULL);\n\n\tif (unlikely(tcache == NULL)) {\n\t\tarena_dalloc_no_tcache(tsdn, ptr);\n\t\treturn;\n\t}\n\n\temap_alloc_ctx_t alloc_ctx;\n\tif (caller_alloc_ctx != NULL) {\n\t\talloc_ctx = *caller_alloc_ctx;\n\t} else {\n\t\tutil_assume(!tsdn_null(tsdn));\n\t\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr,\n\t\t &alloc_ctx);\n\t}\n\n\tif (config_debug) {\n\t\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t ptr);\n\t\tassert(alloc_ctx.szind == edata_szind_get(edata));\n\t\tassert(alloc_ctx.szind < SC_NSIZES);\n\t\tassert(alloc_ctx.slab == edata_slab_get(edata));\n\t}\n\n\tif (likely(alloc_ctx.slab)) {\n\t\t/* Small allocation. */\n\t\ttcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr,\n\t\t alloc_ctx.szind, slow_path);\n\t} else {\n\t\tarena_dalloc_large(tsdn, ptr, tcache, alloc_ctx.szind,\n\t\t slow_path);\n\t}\n}\n\nstatic inline void\narena_sdalloc_no_tcache(tsdn_t *tsdn, void *ptr, size_t size) {\n\tassert(ptr != NULL);\n\tassert(size <= SC_LARGE_MAXCLASS);\n\n\temap_alloc_ctx_t alloc_ctx;\n\tif (!config_prof || !opt_prof) {\n\t\t/*\n\t\t * There is no risk of being confused by a promoted sampled\n\t\t * object, so base szind and slab on the given size.\n\t\t */\n\t\talloc_ctx.szind = sz_size2index(size);\n\t\talloc_ctx.slab = (alloc_ctx.szind < SC_NBINS);\n\t}\n\n\tif ((config_prof && opt_prof) || config_debug) {\n\t\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr,\n\t\t &alloc_ctx);\n\n\t\tassert(alloc_ctx.szind == sz_size2index(size));\n\t\tassert((config_prof && opt_prof)\n\t\t || alloc_ctx.slab == (alloc_ctx.szind < SC_NBINS));\n\n\t\tif (config_debug) {\n\t\t\tedata_t *edata = emap_edata_lookup(tsdn,\n\t\t\t &arena_emap_global, ptr);\n\t\t\tassert(alloc_ctx.szind == edata_szind_get(edata));\n\t\t\tassert(alloc_ctx.slab == edata_slab_get(edata));\n\t\t}\n\t}\n\n\tif (likely(alloc_ctx.slab)) {\n\t\t/* Small allocation. */\n\t\tarena_dalloc_small(tsdn, ptr);\n\t} else {\n\t\tarena_dalloc_large_no_tcache(tsdn, ptr, alloc_ctx.szind);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_sdalloc(tsdn_t *tsdn, void *ptr, size_t size, tcache_t *tcache,\n emap_alloc_ctx_t *caller_alloc_ctx, bool slow_path) {\n\tassert(!tsdn_null(tsdn) || tcache == NULL);\n\tassert(ptr != NULL);\n\tassert(size <= SC_LARGE_MAXCLASS);\n\n\tif (unlikely(tcache == NULL)) {\n\t\tarena_sdalloc_no_tcache(tsdn, ptr, size);\n\t\treturn;\n\t}\n\n\temap_alloc_ctx_t alloc_ctx;\n\tif (config_prof && opt_prof) {\n\t\tif (caller_alloc_ctx == NULL) {\n\t\t\t/* Uncommon case and should be a static check. */\n\t\t\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr,\n\t\t\t &alloc_ctx);\n\t\t\tassert(alloc_ctx.szind == sz_size2index(size));\n\t\t} else {\n\t\t\talloc_ctx = *caller_alloc_ctx;\n\t\t}\n\t} else {\n\t\t/*\n\t\t * There is no risk of being confused by a promoted sampled\n\t\t * object, so base szind and slab on the given size.\n\t\t */\n\t\talloc_ctx.szind = sz_size2index(size);\n\t\talloc_ctx.slab = (alloc_ctx.szind < SC_NBINS);\n\t}\n\n\tif (config_debug) {\n\t\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t ptr);\n\t\tassert(alloc_ctx.szind == edata_szind_get(edata));\n\t\tassert(alloc_ctx.slab == edata_slab_get(edata));\n\t}\n\n\tif (likely(alloc_ctx.slab)) {\n\t\t/* Small allocation. */\n\t\ttcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr,\n\t\t alloc_ctx.szind, slow_path);\n\t} else {\n\t\tarena_dalloc_large(tsdn, ptr, tcache, alloc_ctx.szind,\n\t\t slow_path);\n\t}\n}\n\nstatic inline void\narena_cache_oblivious_randomize(tsdn_t *tsdn, arena_t *arena, edata_t *edata,\n size_t alignment) {\n\tassert(edata_base_get(edata) == edata_addr_get(edata));\n\n\tif (alignment < PAGE) {\n\t\tunsigned lg_range = LG_PAGE -\n\t\t lg_floor(CACHELINE_CEILING(alignment));\n\t\tsize_t r;\n\t\tif (!tsdn_null(tsdn)) {\n\t\t\ttsd_t *tsd = tsdn_tsd(tsdn);\n\t\t\tr = (size_t)prng_lg_range_u64(\n\t\t\t tsd_prng_statep_get(tsd), lg_range);\n\t\t} else {\n\t\t\tuint64_t stack_value = (uint64_t)(uintptr_t)&r;\n\t\t\tr = (size_t)prng_lg_range_u64(&stack_value, lg_range);\n\t\t}\n\t\tuintptr_t random_offset = ((uintptr_t)r) << (LG_PAGE -\n\t\t lg_range);\n\t\tedata->e_addr = (void *)((uintptr_t)edata->e_addr +\n\t\t random_offset);\n\t\tassert(ALIGNMENT_ADDR2BASE(edata->e_addr, alignment) ==\n\t\t edata->e_addr);\n\t}\n}\n\n/*\n * The dalloc bin info contains just the information that the common paths need\n * during tcache flushes. By force-inlining these paths, and using local copies\n * of data (so that the compiler knows it's constant), we avoid a whole bunch of\n * redundant loads and stores by leaving this information in registers.\n */\ntypedef struct arena_dalloc_bin_locked_info_s arena_dalloc_bin_locked_info_t;\nstruct arena_dalloc_bin_locked_info_s {\n\tdiv_info_t div_info;\n\tuint32_t nregs;\n\tuint64_t ndalloc;\n};\n\nJEMALLOC_ALWAYS_INLINE size_t\narena_slab_regind(arena_dalloc_bin_locked_info_t *info, szind_t binind,\n edata_t *slab, const void *ptr) {\n\tsize_t diff, regind;\n\n\t/* Freeing a pointer outside the slab can cause assertion failure. */\n\tassert((uintptr_t)ptr >= (uintptr_t)edata_addr_get(slab));\n\tassert((uintptr_t)ptr < (uintptr_t)edata_past_get(slab));\n\t/* Freeing an interior pointer can cause assertion failure. */\n\tassert(((uintptr_t)ptr - (uintptr_t)edata_addr_get(slab)) %\n\t (uintptr_t)bin_infos[binind].reg_size == 0);\n\n\tdiff = (size_t)((uintptr_t)ptr - (uintptr_t)edata_addr_get(slab));\n\n\t/* Avoid doing division with a variable divisor. */\n\tregind = div_compute(&info->div_info, diff);\n\n\tassert(regind < bin_infos[binind].nregs);\n\n\treturn regind;\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_dalloc_bin_locked_begin(arena_dalloc_bin_locked_info_t *info,\n szind_t binind) {\n\tinfo->div_info = arena_binind_div_info[binind];\n\tinfo->nregs = bin_infos[binind].nregs;\n\tinfo->ndalloc = 0;\n}\n\n/*\n * Does the deallocation work associated with freeing a single pointer (a\n * \"step\") in between a arena_dalloc_bin_locked begin and end call.\n *\n * Returns true if arena_slab_dalloc must be called on slab. Doesn't do\n * stats updates, which happen during finish (this lets running counts get left\n * in a register).\n */\nJEMALLOC_ALWAYS_INLINE bool\narena_dalloc_bin_locked_step(tsdn_t *tsdn, arena_t *arena, bin_t *bin,\n arena_dalloc_bin_locked_info_t *info, szind_t binind, edata_t *slab,\n void *ptr) {\n\tconst bin_info_t *bin_info = &bin_infos[binind];\n\tsize_t regind = arena_slab_regind(info, binind, slab, ptr);\n\tslab_data_t *slab_data = edata_slab_data_get(slab);\n\n\tassert(edata_nfree_get(slab) < bin_info->nregs);\n\t/* Freeing an unallocated pointer can cause assertion failure. */\n\tassert(bitmap_get(slab_data->bitmap, &bin_info->bitmap_info, regind));\n\n\tbitmap_unset(slab_data->bitmap, &bin_info->bitmap_info, regind);\n\tedata_nfree_inc(slab);\n\n\tif (config_stats) {\n\t\tinfo->ndalloc++;\n\t}\n\n\tunsigned nfree = edata_nfree_get(slab);\n\tif (nfree == bin_info->nregs) {\n\t\tarena_dalloc_bin_locked_handle_newly_empty(tsdn, arena, slab,\n\t\t bin);\n\t\treturn true;\n\t} else if (nfree == 1 && slab != bin->slabcur) {\n\t\tarena_dalloc_bin_locked_handle_newly_nonempty(tsdn, arena, slab,\n\t\t bin);\n\t}\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\narena_dalloc_bin_locked_finish(tsdn_t *tsdn, arena_t *arena, bin_t *bin,\n arena_dalloc_bin_locked_info_t *info) {\n\tif (config_stats) {\n\t\tbin->stats.ndalloc += info->ndalloc;\n\t\tassert(bin->stats.curregs >= (size_t)info->ndalloc);\n\t\tbin->stats.curregs -= (size_t)info->ndalloc;\n\t}\n}\n\nstatic inline bin_t *\narena_get_bin(arena_t *arena, szind_t binind, unsigned binshard) {\n\tbin_t *shard0 = (bin_t *)((uintptr_t)arena + arena_bin_offsets[binind]);\n\treturn shard0 + binshard;\n}\n\n#endif /* JEMALLOC_INTERNAL_ARENA_INLINES_B_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_stats.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_STATS_H\n#define JEMALLOC_INTERNAL_ARENA_STATS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/lockedint.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/mutex_prof.h\"\n#include \"jemalloc/internal/pa.h\"\n#include \"jemalloc/internal/sc.h\"\n\nJEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n\ntypedef struct arena_stats_large_s arena_stats_large_t;\nstruct arena_stats_large_s {\n\t/*\n\t * Total number of allocation/deallocation requests served directly by\n\t * the arena.\n\t */\n\tlocked_u64_t\tnmalloc;\n\tlocked_u64_t\tndalloc;\n\n\t/*\n\t * Number of allocation requests that correspond to this size class.\n\t * This includes requests served by tcache, though tcache only\n\t * periodically merges into this counter.\n\t */\n\tlocked_u64_t\tnrequests; /* Partially derived. */\n\t/*\n\t * Number of tcache fills / flushes for large (similarly, periodically\n\t * merged). Note that there is no large tcache batch-fill currently\n\t * (i.e. only fill 1 at a time); however flush may be batched.\n\t */\n\tlocked_u64_t\tnfills; /* Partially derived. */\n\tlocked_u64_t\tnflushes; /* Partially derived. */\n\n\t/* Current number of allocations of this size class. */\n\tsize_t\t\tcurlextents; /* Derived. */\n};\n\n/*\n * Arena stats. Note that fields marked \"derived\" are not directly maintained\n * within the arena code; rather their values are derived during stats merge\n * requests.\n */\ntypedef struct arena_stats_s arena_stats_t;\nstruct arena_stats_s {\n\tLOCKEDINT_MTX_DECLARE(mtx)\n\n\t/*\n\t * resident includes the base stats -- that's why it lives here and not\n\t * in pa_shard_stats_t.\n\t */\n\tsize_t\t\t\tbase; /* Derived. */\n\tsize_t\t\t\tresident; /* Derived. */\n\tsize_t\t\t\tmetadata_thp; /* Derived. */\n\tsize_t\t\t\tmapped; /* Derived. */\n\n\tatomic_zu_t\t\tinternal;\n\n\tsize_t\t\t\tallocated_large; /* Derived. */\n\tuint64_t\t\tnmalloc_large; /* Derived. */\n\tuint64_t\t\tndalloc_large; /* Derived. */\n\tuint64_t\t\tnfills_large; /* Derived. */\n\tuint64_t\t\tnflushes_large; /* Derived. */\n\tuint64_t\t\tnrequests_large; /* Derived. */\n\n\t/*\n\t * The stats logically owned by the pa_shard in the same arena. This\n\t * lives here only because it's convenient for the purposes of the ctl\n\t * module -- it only knows about the single arena_stats.\n\t */\n\tpa_shard_stats_t\tpa_shard_stats;\n\n\t/* Number of bytes cached in tcache associated with this arena. */\n\tsize_t\t\t\ttcache_bytes; /* Derived. */\n\tsize_t\t\t\ttcache_stashed_bytes; /* Derived. */\n\n\tmutex_prof_data_t mutex_prof_data[mutex_prof_num_arena_mutexes];\n\n\t/* One element for each large size class. */\n\tarena_stats_large_t\tlstats[SC_NSIZES - SC_NBINS];\n\n\t/* Arena uptime. */\n\tnstime_t\t\tuptime;\n};\n\nstatic inline bool\narena_stats_init(tsdn_t *tsdn, arena_stats_t *arena_stats) {\n\tif (config_debug) {\n\t\tfor (size_t i = 0; i < sizeof(arena_stats_t); i++) {\n\t\t\tassert(((char *)arena_stats)[i] == 0);\n\t\t}\n\t}\n\tif (LOCKEDINT_MTX_INIT(arena_stats->mtx, \"arena_stats\",\n\t WITNESS_RANK_ARENA_STATS, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\t/* Memory is zeroed, so there is no need to clear stats. */\n\treturn false;\n}\n\nstatic inline void\narena_stats_large_flush_nrequests_add(tsdn_t *tsdn, arena_stats_t *arena_stats,\n szind_t szind, uint64_t nrequests) {\n\tLOCKEDINT_MTX_LOCK(tsdn, arena_stats->mtx);\n\tarena_stats_large_t *lstats = &arena_stats->lstats[szind - SC_NBINS];\n\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(arena_stats->mtx),\n\t &lstats->nrequests, nrequests);\n\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(arena_stats->mtx),\n\t &lstats->nflushes, 1);\n\tLOCKEDINT_MTX_UNLOCK(tsdn, arena_stats->mtx);\n}\n\n#endif /* JEMALLOC_INTERNAL_ARENA_STATS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_structs.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_STRUCTS_H\n#define JEMALLOC_INTERNAL_ARENA_STRUCTS_H\n\n#include \"jemalloc/internal/arena_stats.h\"\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/bin.h\"\n#include \"jemalloc/internal/bitmap.h\"\n#include \"jemalloc/internal/counter.h\"\n#include \"jemalloc/internal/ecache.h\"\n#include \"jemalloc/internal/edata_cache.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/nstime.h\"\n#include \"jemalloc/internal/pa.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/ticker.h\"\n\nstruct arena_s {\n\t/*\n\t * Number of threads currently assigned to this arena. Each thread has\n\t * two distinct assignments, one for application-serving allocation, and\n\t * the other for internal metadata allocation. Internal metadata must\n\t * not be allocated from arenas explicitly created via the arenas.create\n\t * mallctl, because the arena..reset mallctl indiscriminately\n\t * discards all allocations for the affected arena.\n\t *\n\t * 0: Application allocation.\n\t * 1: Internal metadata allocation.\n\t *\n\t * Synchronization: atomic.\n\t */\n\tatomic_u_t\t\tnthreads[2];\n\n\t/* Next bin shard for binding new threads. Synchronization: atomic. */\n\tatomic_u_t\t\tbinshard_next;\n\n\t/*\n\t * When percpu_arena is enabled, to amortize the cost of reading /\n\t * updating the current CPU id, track the most recent thread accessing\n\t * this arena, and only read CPU if there is a mismatch.\n\t */\n\ttsdn_t\t\t*last_thd;\n\n\t/* Synchronization: internal. */\n\tarena_stats_t\t\tstats;\n\n\t/*\n\t * Lists of tcaches and cache_bin_array_descriptors for extant threads\n\t * associated with this arena. Stats from these are merged\n\t * incrementally, and at exit if opt_stats_print is enabled.\n\t *\n\t * Synchronization: tcache_ql_mtx.\n\t */\n\tql_head(tcache_slow_t)\t\t\ttcache_ql;\n\tql_head(cache_bin_array_descriptor_t)\tcache_bin_array_descriptor_ql;\n\tmalloc_mutex_t\t\t\t\ttcache_ql_mtx;\n\n\t/*\n\t * Represents a dss_prec_t, but atomically.\n\t *\n\t * Synchronization: atomic.\n\t */\n\tatomic_u_t\t\tdss_prec;\n\n\t/*\n\t * Extant large allocations.\n\t *\n\t * Synchronization: large_mtx.\n\t */\n\tedata_list_active_t\tlarge;\n\t/* Synchronizes all large allocation/update/deallocation. */\n\tmalloc_mutex_t\t\tlarge_mtx;\n\n\t/* The page-level allocator shard this arena uses. */\n\tpa_shard_t\t\tpa_shard;\n\n\t/*\n\t * A cached copy of base->ind. This can get accessed on hot paths;\n\t * looking it up in base requires an extra pointer hop / cache miss.\n\t */\n\tunsigned ind;\n\n\t/*\n\t * Base allocator, from which arena metadata are allocated.\n\t *\n\t * Synchronization: internal.\n\t */\n\tbase_t\t\t\t*base;\n\t/* Used to determine uptime. Read-only after initialization. */\n\tnstime_t\t\tcreate_time;\n\n\t/*\n\t * The arena is allocated alongside its bins; really this is a\n\t * dynamically sized array determined by the binshard settings.\n\t */\n\tbin_t\t\t\tbins[0];\n};\n\n#endif /* JEMALLOC_INTERNAL_ARENA_STRUCTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/arena_types.h", "content": "#ifndef JEMALLOC_INTERNAL_ARENA_TYPES_H\n#define JEMALLOC_INTERNAL_ARENA_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n/* Default decay times in milliseconds. */\n#define DIRTY_DECAY_MS_DEFAULT\tZD(10 * 1000)\n#define MUZZY_DECAY_MS_DEFAULT\t(0)\n/* Number of event ticks between time checks. */\n#define ARENA_DECAY_NTICKS_PER_UPDATE\t1000\n\ntypedef struct arena_decay_s arena_decay_t;\ntypedef struct arena_s arena_t;\n\ntypedef enum {\n\tpercpu_arena_mode_names_base = 0, /* Used for options processing. */\n\n\t/*\n\t * *_uninit are used only during bootstrapping, and must correspond\n\t * to initialized variant plus percpu_arena_mode_enabled_base.\n\t */\n\tpercpu_arena_uninit = 0,\n\tper_phycpu_arena_uninit = 1,\n\n\t/* All non-disabled modes must come after percpu_arena_disabled. */\n\tpercpu_arena_disabled = 2,\n\n\tpercpu_arena_mode_names_limit = 3, /* Used for options processing. */\n\tpercpu_arena_mode_enabled_base = 3,\n\n\tpercpu_arena = 3,\n\tper_phycpu_arena = 4 /* Hyper threads share arena. */\n} percpu_arena_mode_t;\n\n#define PERCPU_ARENA_ENABLED(m)\t((m) >= percpu_arena_mode_enabled_base)\n#define PERCPU_ARENA_DEFAULT\tpercpu_arena_disabled\n\n/*\n * When allocation_size >= oversize_threshold, use the dedicated huge arena\n * (unless have explicitly spicified arena index). 0 disables the feature.\n */\n#define OVERSIZE_THRESHOLD_DEFAULT (8 << 20)\n\nstruct arena_config_s {\n\t/* extent hooks to be used for the arena */\n\textent_hooks_t *extent_hooks;\n\n\t/*\n\t * Use extent hooks for metadata (base) allocations when true.\n\t */\n\tbool metadata_use_hooks;\n};\n\ntypedef struct arena_config_s arena_config_t;\n\nextern const arena_config_t arena_config_default;\n\n#endif /* JEMALLOC_INTERNAL_ARENA_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/assert.h", "content": "#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/util.h\"\n\n/*\n * Define a custom assert() in order to reduce the chances of deadlock during\n * assertion failure.\n */\n#ifndef assert\n#define assert(e) do {\t\t\t\t\t\t\t\\\n\tif (unlikely(config_debug && !(e))) {\t\t\t\t\\\n\t\tmalloc_printf(\t\t\t\t\t\t\\\n\t\t \": %s:%d: Failed assertion: \\\"%s\\\"\\n\",\t\\\n\t\t __FILE__, __LINE__, #e);\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#endif\n\n#ifndef not_reached\n#define not_reached() do {\t\t\t\t\t\t\\\n\tif (config_debug) {\t\t\t\t\t\t\\\n\t\tmalloc_printf(\t\t\t\t\t\t\\\n\t\t \": %s:%d: Unreachable code reached\\n\",\t\\\n\t\t __FILE__, __LINE__);\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tunreachable();\t\t\t\t\t\t\t\\\n} while (0)\n#endif\n\n#ifndef not_implemented\n#define not_implemented() do {\t\t\t\t\t\t\\\n\tif (config_debug) {\t\t\t\t\t\t\\\n\t\tmalloc_printf(\": %s:%d: Not implemented\\n\",\t\\\n\t\t __FILE__, __LINE__);\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#endif\n\n#ifndef assert_not_implemented\n#define assert_not_implemented(e) do {\t\t\t\t\t\\\n\tif (unlikely(config_debug && !(e))) {\t\t\t\t\\\n\t\tnot_implemented();\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#endif\n\n/* Use to assert a particular configuration, e.g., cassert(config_debug). */\n#ifndef cassert\n#define cassert(c) do {\t\t\t\t\t\t\t\\\n\tif (unlikely(!(c))) {\t\t\t\t\t\t\\\n\t\tnot_reached();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#endif\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/atomic.h", "content": "#ifndef JEMALLOC_INTERNAL_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_H\n\n#define ATOMIC_INLINE JEMALLOC_ALWAYS_INLINE\n\n#define JEMALLOC_U8_ATOMICS\n#if defined(JEMALLOC_GCC_ATOMIC_ATOMICS)\n# include \"jemalloc/internal/atomic_gcc_atomic.h\"\n# if !defined(JEMALLOC_GCC_U8_ATOMIC_ATOMICS)\n# undef JEMALLOC_U8_ATOMICS\n# endif\n#elif defined(JEMALLOC_GCC_SYNC_ATOMICS)\n# include \"jemalloc/internal/atomic_gcc_sync.h\"\n# if !defined(JEMALLOC_GCC_U8_SYNC_ATOMICS)\n# undef JEMALLOC_U8_ATOMICS\n# endif\n#elif defined(_MSC_VER)\n# include \"jemalloc/internal/atomic_msvc.h\"\n#elif defined(JEMALLOC_C11_ATOMICS)\n# include \"jemalloc/internal/atomic_c11.h\"\n#else\n# error \"Don't have atomics implemented on this platform.\"\n#endif\n\n/*\n * This header gives more or less a backport of C11 atomics. The user can write\n * JEMALLOC_GENERATE_ATOMICS(type, short_type, lg_sizeof_type); to generate\n * counterparts of the C11 atomic functions for type, as so:\n * JEMALLOC_GENERATE_ATOMICS(int *, pi, 3);\n * and then write things like:\n * int *some_ptr;\n * atomic_pi_t atomic_ptr_to_int;\n * atomic_store_pi(&atomic_ptr_to_int, some_ptr, ATOMIC_RELAXED);\n * int *prev_value = atomic_exchange_pi(&ptr_to_int, NULL, ATOMIC_ACQ_REL);\n * assert(some_ptr == prev_value);\n * and expect things to work in the obvious way.\n *\n * Also included (with naming differences to avoid conflicts with the standard\n * library):\n * atomic_fence(atomic_memory_order_t) (mimics C11's atomic_thread_fence).\n * ATOMIC_INIT (mimics C11's ATOMIC_VAR_INIT).\n */\n\n/*\n * Pure convenience, so that we don't have to type \"atomic_memory_order_\"\n * quite so often.\n */\n#define ATOMIC_RELAXED atomic_memory_order_relaxed\n#define ATOMIC_ACQUIRE atomic_memory_order_acquire\n#define ATOMIC_RELEASE atomic_memory_order_release\n#define ATOMIC_ACQ_REL atomic_memory_order_acq_rel\n#define ATOMIC_SEQ_CST atomic_memory_order_seq_cst\n\n/*\n * Another convenience -- simple atomic helper functions.\n */\n#define JEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(type, short_type,\t\\\n lg_size)\t\t\t\t\t\t\t\t\\\n JEMALLOC_GENERATE_INT_ATOMICS(type, short_type, lg_size)\t\t\\\n ATOMIC_INLINE void\t\t\t\t\t\t\t\\\n atomic_load_add_store_##short_type(atomic_##short_type##_t *a,\t\\\n\ttype inc) {\t\t\t\t\t\t\t\\\n\t type oldval = atomic_load_##short_type(a, ATOMIC_RELAXED);\t\\\n\t type newval = oldval + inc;\t\t\t\t\t\\\n\t atomic_store_##short_type(a, newval, ATOMIC_RELAXED);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n ATOMIC_INLINE void\t\t\t\t\t\t\t\\\n atomic_load_sub_store_##short_type(atomic_##short_type##_t *a,\t\\\n\ttype inc) {\t\t\t\t\t\t\t\\\n\t type oldval = atomic_load_##short_type(a, ATOMIC_RELAXED);\t\\\n\t type newval = oldval - inc;\t\t\t\t\t\\\n\t atomic_store_##short_type(a, newval, ATOMIC_RELAXED);\t\\\n\t}\n\n/*\n * Not all platforms have 64-bit atomics. If we do, this #define exposes that\n * fact.\n */\n#if (LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3)\n# define JEMALLOC_ATOMIC_U64\n#endif\n\nJEMALLOC_GENERATE_ATOMICS(void *, p, LG_SIZEOF_PTR)\n\n/*\n * There's no actual guarantee that sizeof(bool) == 1, but it's true on the only\n * platform that actually needs to know the size, MSVC.\n */\nJEMALLOC_GENERATE_ATOMICS(bool, b, 0)\n\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(unsigned, u, LG_SIZEOF_INT)\n\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(size_t, zu, LG_SIZEOF_PTR)\n\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(ssize_t, zd, LG_SIZEOF_PTR)\n\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(uint8_t, u8, 0)\n\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(uint32_t, u32, 2)\n\n#ifdef JEMALLOC_ATOMIC_U64\nJEMALLOC_GENERATE_EXPANDED_INT_ATOMICS(uint64_t, u64, 3)\n#endif\n\n#undef ATOMIC_INLINE\n\n#endif /* JEMALLOC_INTERNAL_ATOMIC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/atomic_c11.h", "content": "#ifndef JEMALLOC_INTERNAL_ATOMIC_C11_H\n#define JEMALLOC_INTERNAL_ATOMIC_C11_H\n\n#include \n\n#define ATOMIC_INIT(...) ATOMIC_VAR_INIT(__VA_ARGS__)\n\n#define atomic_memory_order_t memory_order\n#define atomic_memory_order_relaxed memory_order_relaxed\n#define atomic_memory_order_acquire memory_order_acquire\n#define atomic_memory_order_release memory_order_release\n#define atomic_memory_order_acq_rel memory_order_acq_rel\n#define atomic_memory_order_seq_cst memory_order_seq_cst\n\n#define atomic_fence atomic_thread_fence\n\n#define JEMALLOC_GENERATE_ATOMICS(type, short_type,\t\t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\ntypedef _Atomic(type) atomic_##short_type##_t;\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_load_##short_type(const atomic_##short_type##_t *a,\t\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * A strict interpretation of the C standard prevents\t\t\\\n\t * atomic_load from taking a const argument, but it's\t\t\\\n\t * convenient for our purposes. This cast is a workaround.\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tatomic_##short_type##_t* a_nonconst =\t\t\t\t\\\n\t (atomic_##short_type##_t*)a;\t\t\t\t\\\n\treturn atomic_load_explicit(a_nonconst, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE void\t\t\t\t\t\t\t\\\natomic_store_##short_type(atomic_##short_type##_t *a,\t\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\tatomic_store_explicit(a, val, mo);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_exchange_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn atomic_exchange_explicit(a, val, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_weak_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, atomic_memory_order_t success_mo,\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\treturn atomic_compare_exchange_weak_explicit(a, expected,\t\\\n\t desired, success_mo, failure_mo);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_strong_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, atomic_memory_order_t success_mo,\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\treturn atomic_compare_exchange_strong_explicit(a, expected,\t\\\n\t desired, success_mo, failure_mo);\t\t\t\t\\\n}\n\n/*\n * Integral types have some special operations available that non-integral ones\n * lack.\n */\n#define JEMALLOC_GENERATE_INT_ATOMICS(type, short_type, \t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\nJEMALLOC_GENERATE_ATOMICS(type, short_type, /* unused */ lg_size)\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_add_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn atomic_fetch_add_explicit(a, val, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_sub_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn atomic_fetch_sub_explicit(a, val, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_and_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn atomic_fetch_and_explicit(a, val, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_or_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn atomic_fetch_or_explicit(a, val, mo);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_xor_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn atomic_fetch_xor_explicit(a, val, mo);\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_ATOMIC_C11_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_atomic.h", "content": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n\n#include \"jemalloc/internal/assert.h\"\n\n#define ATOMIC_INIT(...) {__VA_ARGS__}\n\ntypedef enum {\n\tatomic_memory_order_relaxed,\n\tatomic_memory_order_acquire,\n\tatomic_memory_order_release,\n\tatomic_memory_order_acq_rel,\n\tatomic_memory_order_seq_cst\n} atomic_memory_order_t;\n\nATOMIC_INLINE int\natomic_enum_to_builtin(atomic_memory_order_t mo) {\n\tswitch (mo) {\n\tcase atomic_memory_order_relaxed:\n\t\treturn __ATOMIC_RELAXED;\n\tcase atomic_memory_order_acquire:\n\t\treturn __ATOMIC_ACQUIRE;\n\tcase atomic_memory_order_release:\n\t\treturn __ATOMIC_RELEASE;\n\tcase atomic_memory_order_acq_rel:\n\t\treturn __ATOMIC_ACQ_REL;\n\tcase atomic_memory_order_seq_cst:\n\t\treturn __ATOMIC_SEQ_CST;\n\t}\n\t/* Can't happen; the switch is exhaustive. */\n\tnot_reached();\n}\n\nATOMIC_INLINE void\natomic_fence(atomic_memory_order_t mo) {\n\t__atomic_thread_fence(atomic_enum_to_builtin(mo));\n}\n\n#define JEMALLOC_GENERATE_ATOMICS(type, short_type,\t\t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\ttype repr;\t\t\t\t\t\t\t\\\n} atomic_##short_type##_t;\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_load_##short_type(const atomic_##short_type##_t *a,\t\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\ttype result;\t\t\t\t\t\t\t\\\n\t__atomic_load(&a->repr, &result, atomic_enum_to_builtin(mo));\t\\\n\treturn result;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE void\t\t\t\t\t\t\t\\\natomic_store_##short_type(atomic_##short_type##_t *a, type val,\t\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\t__atomic_store(&a->repr, &val, atomic_enum_to_builtin(mo));\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_exchange_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\ttype result;\t\t\t\t\t\t\t\\\n\t__atomic_exchange(&a->repr, &val, &result,\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n\treturn result;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_weak_##short_type(atomic_##short_type##_t *a,\t\\\n UNUSED type *expected, type desired,\t\t\t\t\\\n atomic_memory_order_t success_mo,\t\t\t\t\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\treturn __atomic_compare_exchange(&a->repr, expected, &desired,\t\\\n\t true, atomic_enum_to_builtin(success_mo),\t\t\t\\\n\t atomic_enum_to_builtin(failure_mo));\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_strong_##short_type(atomic_##short_type##_t *a,\t\\\n UNUSED type *expected, type desired,\t\t\t\t\\\n atomic_memory_order_t success_mo,\t\t\t\t\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\treturn __atomic_compare_exchange(&a->repr, expected, &desired,\t\\\n\t false,\t\t\t\t\t\t\t\\\n\t atomic_enum_to_builtin(success_mo),\t\t\t\t\\\n\t atomic_enum_to_builtin(failure_mo));\t\t\t\\\n}\n\n\n#define JEMALLOC_GENERATE_INT_ATOMICS(type, short_type,\t\t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\nJEMALLOC_GENERATE_ATOMICS(type, short_type, /* unused */ lg_size)\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_add_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __atomic_fetch_add(&a->repr, val,\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_sub_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __atomic_fetch_sub(&a->repr, val,\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_and_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __atomic_fetch_and(&a->repr, val,\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_or_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __atomic_fetch_or(&a->repr, val,\t\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_xor_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __atomic_fetch_xor(&a->repr, val,\t\t\t\\\n\t atomic_enum_to_builtin(mo));\t\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_sync.h", "content": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n\n#define ATOMIC_INIT(...) {__VA_ARGS__}\n\ntypedef enum {\n\tatomic_memory_order_relaxed,\n\tatomic_memory_order_acquire,\n\tatomic_memory_order_release,\n\tatomic_memory_order_acq_rel,\n\tatomic_memory_order_seq_cst\n} atomic_memory_order_t;\n\nATOMIC_INLINE void\natomic_fence(atomic_memory_order_t mo) {\n\t/* Easy cases first: no barrier, and full barrier. */\n\tif (mo == atomic_memory_order_relaxed) {\n\t\tasm volatile(\"\" ::: \"memory\");\n\t\treturn;\n\t}\n\tif (mo == atomic_memory_order_seq_cst) {\n\t\tasm volatile(\"\" ::: \"memory\");\n\t\t__sync_synchronize();\n\t\tasm volatile(\"\" ::: \"memory\");\n\t\treturn;\n\t}\n\tasm volatile(\"\" ::: \"memory\");\n# if defined(__i386__) || defined(__x86_64__)\n\t/* This is implicit on x86. */\n# elif defined(__ppc64__)\n\tasm volatile(\"lwsync\");\n# elif defined(__ppc__)\n\tasm volatile(\"sync\");\n# elif defined(__sparc__) && defined(__arch64__)\n\tif (mo == atomic_memory_order_acquire) {\n\t\tasm volatile(\"membar #LoadLoad | #LoadStore\");\n\t} else if (mo == atomic_memory_order_release) {\n\t\tasm volatile(\"membar #LoadStore | #StoreStore\");\n\t} else {\n\t\tasm volatile(\"membar #LoadLoad | #LoadStore | #StoreStore\");\n\t}\n# else\n\t__sync_synchronize();\n# endif\n\tasm volatile(\"\" ::: \"memory\");\n}\n\n/*\n * A correct implementation of seq_cst loads and stores on weakly ordered\n * architectures could do either of the following:\n * 1. store() is weak-fence -> store -> strong fence, load() is load ->\n * strong-fence.\n * 2. store() is strong-fence -> store, load() is strong-fence -> load ->\n * weak-fence.\n * The tricky thing is, load() and store() above can be the load or store\n * portions of a gcc __sync builtin, so we have to follow GCC's lead, which\n * means going with strategy 2.\n * On strongly ordered architectures, the natural strategy is to stick a strong\n * fence after seq_cst stores, and have naked loads. So we want the strong\n * fences in different places on different architectures.\n * atomic_pre_sc_load_fence and atomic_post_sc_store_fence allow us to\n * accomplish this.\n */\n\nATOMIC_INLINE void\natomic_pre_sc_load_fence() {\n# if defined(__i386__) || defined(__x86_64__) ||\t\t\t\\\n (defined(__sparc__) && defined(__arch64__))\n\tatomic_fence(atomic_memory_order_relaxed);\n# else\n\tatomic_fence(atomic_memory_order_seq_cst);\n# endif\n}\n\nATOMIC_INLINE void\natomic_post_sc_store_fence() {\n# if defined(__i386__) || defined(__x86_64__) ||\t\t\t\\\n (defined(__sparc__) && defined(__arch64__))\n\tatomic_fence(atomic_memory_order_seq_cst);\n# else\n\tatomic_fence(atomic_memory_order_relaxed);\n# endif\n\n}\n\n#define JEMALLOC_GENERATE_ATOMICS(type, short_type,\t\t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\ttype volatile repr;\t\t\t\t\t\t\\\n} atomic_##short_type##_t;\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_load_##short_type(const atomic_##short_type##_t *a,\t\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\tif (mo == atomic_memory_order_seq_cst) {\t\t\t\\\n\t\tatomic_pre_sc_load_fence();\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ttype result = a->repr;\t\t\t\t\t\t\\\n\tif (mo != atomic_memory_order_relaxed) {\t\t\t\\\n\t\tatomic_fence(atomic_memory_order_acquire);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn result;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE void\t\t\t\t\t\t\t\\\natomic_store_##short_type(atomic_##short_type##_t *a,\t\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\tif (mo != atomic_memory_order_relaxed) {\t\t\t\\\n\t\tatomic_fence(atomic_memory_order_release);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ta->repr = val;\t\t\t\t\t\t\t\\\n\tif (mo == atomic_memory_order_seq_cst) {\t\t\t\\\n\t\tatomic_post_sc_store_fence();\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_exchange_##short_type(atomic_##short_type##_t *a, type val, \\\n atomic_memory_order_t mo) { \t\t\t\t\t \\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Because of FreeBSD, we care about gcc 4.2, which doesn't have\\\n\t * an atomic exchange builtin. We fake it with a CAS loop.\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\twhile (true) {\t\t\t\t\t\t\t\\\n\t\ttype old = a->repr;\t\t\t\t\t\\\n\t\tif (__sync_bool_compare_and_swap(&a->repr, old, val)) {\t\\\n\t\t\treturn old;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_weak_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, \\\n atomic_memory_order_t success_mo, \\\n atomic_memory_order_t failure_mo) {\t\t\t\t \\\n\ttype prev = __sync_val_compare_and_swap(&a->repr, *expected,\t\\\n\t desired);\t\t\t\t\t\t\t\\\n\tif (prev == *expected) {\t\t\t\t\t\\\n\t\treturn true;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\t*expected = prev;\t\t\t\t\t\\\n\t\treturn false;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_strong_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, \\\n atomic_memory_order_t success_mo, \\\n atomic_memory_order_t failure_mo) { \\\n\ttype prev = __sync_val_compare_and_swap(&a->repr, *expected,\t\\\n\t desired);\t\t\t\t\t\t\t\\\n\tif (prev == *expected) {\t\t\t\t\t\\\n\t\treturn true;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\t*expected = prev;\t\t\t\t\t\\\n\t\treturn false;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\n\n#define JEMALLOC_GENERATE_INT_ATOMICS(type, short_type,\t\t\t\\\n /* unused */ lg_size)\t\t\t\t\t\t\\\nJEMALLOC_GENERATE_ATOMICS(type, short_type, /* unused */ lg_size)\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_add_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __sync_fetch_and_add(&a->repr, val);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_sub_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __sync_fetch_and_sub(&a->repr, val);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_and_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __sync_fetch_and_and(&a->repr, val);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_or_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __sync_fetch_and_or(&a->repr, val);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_xor_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn __sync_fetch_and_xor(&a->repr, val);\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/atomic_msvc.h", "content": "#ifndef JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n#define JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n\n#define ATOMIC_INIT(...) {__VA_ARGS__}\n\ntypedef enum {\n\tatomic_memory_order_relaxed,\n\tatomic_memory_order_acquire,\n\tatomic_memory_order_release,\n\tatomic_memory_order_acq_rel,\n\tatomic_memory_order_seq_cst\n} atomic_memory_order_t;\n\ntypedef char atomic_repr_0_t;\ntypedef short atomic_repr_1_t;\ntypedef long atomic_repr_2_t;\ntypedef __int64 atomic_repr_3_t;\n\nATOMIC_INLINE void\natomic_fence(atomic_memory_order_t mo) {\n\t_ReadWriteBarrier();\n# if defined(_M_ARM) || defined(_M_ARM64)\n\t/* ARM needs a barrier for everything but relaxed. */\n\tif (mo != atomic_memory_order_relaxed) {\n\t\tMemoryBarrier();\n\t}\n# elif defined(_M_IX86) || defined (_M_X64)\n\t/* x86 needs a barrier only for seq_cst. */\n\tif (mo == atomic_memory_order_seq_cst) {\n\t\tMemoryBarrier();\n\t}\n# else\n# error \"Don't know how to create atomics for this platform for MSVC.\"\n# endif\n\t_ReadWriteBarrier();\n}\n\n#define ATOMIC_INTERLOCKED_REPR(lg_size) atomic_repr_ ## lg_size ## _t\n\n#define ATOMIC_CONCAT(a, b) ATOMIC_RAW_CONCAT(a, b)\n#define ATOMIC_RAW_CONCAT(a, b) a ## b\n\n#define ATOMIC_INTERLOCKED_NAME(base_name, lg_size) ATOMIC_CONCAT(\t\\\n base_name, ATOMIC_INTERLOCKED_SUFFIX(lg_size))\n\n#define ATOMIC_INTERLOCKED_SUFFIX(lg_size)\t\t\t\t\\\n ATOMIC_CONCAT(ATOMIC_INTERLOCKED_SUFFIX_, lg_size)\n\n#define ATOMIC_INTERLOCKED_SUFFIX_0 8\n#define ATOMIC_INTERLOCKED_SUFFIX_1 16\n#define ATOMIC_INTERLOCKED_SUFFIX_2\n#define ATOMIC_INTERLOCKED_SUFFIX_3 64\n\n#define JEMALLOC_GENERATE_ATOMICS(type, short_type, lg_size)\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tATOMIC_INTERLOCKED_REPR(lg_size) repr;\t\t\t\t\\\n} atomic_##short_type##_t;\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_load_##short_type(const atomic_##short_type##_t *a,\t\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\tATOMIC_INTERLOCKED_REPR(lg_size) ret = a->repr;\t\t\t\\\n\tif (mo != atomic_memory_order_relaxed) {\t\t\t\\\n\t\tatomic_fence(atomic_memory_order_acquire);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn (type) ret;\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE void\t\t\t\t\t\t\t\\\natomic_store_##short_type(atomic_##short_type##_t *a,\t\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\tif (mo != atomic_memory_order_relaxed) {\t\t\t\\\n\t\tatomic_fence(atomic_memory_order_release);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ta->repr = (ATOMIC_INTERLOCKED_REPR(lg_size)) val;\t\t\\\n\tif (mo == atomic_memory_order_seq_cst) {\t\t\t\\\n\t\tatomic_fence(atomic_memory_order_seq_cst);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_exchange_##short_type(atomic_##short_type##_t *a, type val,\t\\\n atomic_memory_order_t mo) {\t\t\t\t\t\t\\\n\treturn (type)ATOMIC_INTERLOCKED_NAME(_InterlockedExchange,\t\\\n\t lg_size)(&a->repr, (ATOMIC_INTERLOCKED_REPR(lg_size))val);\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_weak_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, atomic_memory_order_t success_mo,\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\tATOMIC_INTERLOCKED_REPR(lg_size) e =\t\t\t\t\\\n\t (ATOMIC_INTERLOCKED_REPR(lg_size))*expected;\t\t\\\n\tATOMIC_INTERLOCKED_REPR(lg_size) d =\t\t\t\t\\\n\t (ATOMIC_INTERLOCKED_REPR(lg_size))desired;\t\t\t\\\n\tATOMIC_INTERLOCKED_REPR(lg_size) old =\t\t\t\t\\\n\t ATOMIC_INTERLOCKED_NAME(_InterlockedCompareExchange, \t\\\n\t\tlg_size)(&a->repr, d, e);\t\t\t\t\\\n\tif (old == e) {\t\t\t\t\t\t\t\\\n\t\treturn true;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\t*expected = (type)old;\t\t\t\t\t\\\n\t\treturn false;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE bool\t\t\t\t\t\t\t\\\natomic_compare_exchange_strong_##short_type(atomic_##short_type##_t *a,\t\\\n type *expected, type desired, atomic_memory_order_t success_mo,\t\\\n atomic_memory_order_t failure_mo) {\t\t\t\t\t\\\n\t/* We implement the weak version with strong semantics. */\t\\\n\treturn atomic_compare_exchange_weak_##short_type(a, expected,\t\\\n\t desired, success_mo, failure_mo);\t\t\t\t\\\n}\n\n\n#define JEMALLOC_GENERATE_INT_ATOMICS(type, short_type, lg_size)\t\\\nJEMALLOC_GENERATE_ATOMICS(type, short_type, lg_size)\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_add_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn (type)ATOMIC_INTERLOCKED_NAME(_InterlockedExchangeAdd,\t\\\n\t lg_size)(&a->repr, (ATOMIC_INTERLOCKED_REPR(lg_size))val);\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_sub_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * MSVC warns on negation of unsigned operands, but for us it\t\\\n\t * gives exactly the right semantics (MAX_TYPE + 1 - operand).\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\t__pragma(warning(push))\t\t\t\t\t\t\\\n\t__pragma(warning(disable: 4146))\t\t\t\t\\\n\treturn atomic_fetch_add_##short_type(a, -val, mo);\t\t\\\n\t__pragma(warning(pop))\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_and_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn (type)ATOMIC_INTERLOCKED_NAME(_InterlockedAnd, lg_size)(\t\\\n\t &a->repr, (ATOMIC_INTERLOCKED_REPR(lg_size))val);\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_or_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn (type)ATOMIC_INTERLOCKED_NAME(_InterlockedOr, lg_size)(\t\\\n\t &a->repr, (ATOMIC_INTERLOCKED_REPR(lg_size))val);\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nATOMIC_INLINE type\t\t\t\t\t\t\t\\\natomic_fetch_xor_##short_type(atomic_##short_type##_t *a,\t\t\\\n type val, atomic_memory_order_t mo) {\t\t\t\t\\\n\treturn (type)ATOMIC_INTERLOCKED_NAME(_InterlockedXor, lg_size)(\t\\\n\t &a->repr, (ATOMIC_INTERLOCKED_REPR(lg_size))val);\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_ATOMIC_MSVC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/background_thread_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n\nextern bool opt_background_thread;\nextern size_t opt_max_background_threads;\nextern malloc_mutex_t background_thread_lock;\nextern atomic_b_t background_thread_enabled_state;\nextern size_t n_background_threads;\nextern size_t max_background_threads;\nextern background_thread_info_t *background_thread_info;\n\nbool background_thread_create(tsd_t *tsd, unsigned arena_ind);\nbool background_threads_enable(tsd_t *tsd);\nbool background_threads_disable(tsd_t *tsd);\nbool background_thread_is_started(background_thread_info_t* info);\nvoid background_thread_wakeup_early(background_thread_info_t *info,\n nstime_t *remaining_sleep);\nvoid background_thread_prefork0(tsdn_t *tsdn);\nvoid background_thread_prefork1(tsdn_t *tsdn);\nvoid background_thread_postfork_parent(tsdn_t *tsdn);\nvoid background_thread_postfork_child(tsdn_t *tsdn);\nbool background_thread_stats_read(tsdn_t *tsdn,\n background_thread_stats_t *stats);\nvoid background_thread_ctl_init(tsdn_t *tsdn);\n\n#ifdef JEMALLOC_PTHREAD_CREATE_WRAPPER\nextern int pthread_create_wrapper(pthread_t *__restrict, const pthread_attr_t *,\n void *(*)(void *), void *__restrict);\n#endif\nbool background_thread_boot0(void);\nbool background_thread_boot1(tsdn_t *tsdn, base_t *base);\n\n#endif /* JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/background_thread_inlines.h", "content": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n\nJEMALLOC_ALWAYS_INLINE bool\nbackground_thread_enabled(void) {\n\treturn atomic_load_b(&background_thread_enabled_state, ATOMIC_RELAXED);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nbackground_thread_enabled_set(tsdn_t *tsdn, bool state) {\n\tmalloc_mutex_assert_owner(tsdn, &background_thread_lock);\n\tatomic_store_b(&background_thread_enabled_state, state, ATOMIC_RELAXED);\n}\n\nJEMALLOC_ALWAYS_INLINE background_thread_info_t *\narena_background_thread_info_get(arena_t *arena) {\n\tunsigned arena_ind = arena_ind_get(arena);\n\treturn &background_thread_info[arena_ind % max_background_threads];\n}\n\nJEMALLOC_ALWAYS_INLINE background_thread_info_t *\nbackground_thread_info_get(size_t ind) {\n\treturn &background_thread_info[ind % max_background_threads];\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nbackground_thread_wakeup_time_get(background_thread_info_t *info) {\n\tuint64_t next_wakeup = nstime_ns(&info->next_wakeup);\n\tassert(atomic_load_b(&info->indefinite_sleep, ATOMIC_ACQUIRE) ==\n\t (next_wakeup == BACKGROUND_THREAD_INDEFINITE_SLEEP));\n\treturn next_wakeup;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nbackground_thread_wakeup_time_set(tsdn_t *tsdn, background_thread_info_t *info,\n uint64_t wakeup_time) {\n\tmalloc_mutex_assert_owner(tsdn, &info->mtx);\n\tatomic_store_b(&info->indefinite_sleep,\n\t wakeup_time == BACKGROUND_THREAD_INDEFINITE_SLEEP, ATOMIC_RELEASE);\n\tnstime_init(&info->next_wakeup, wakeup_time);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nbackground_thread_indefinite_sleep(background_thread_info_t *info) {\n\treturn atomic_load_b(&info->indefinite_sleep, ATOMIC_ACQUIRE);\n}\n\n#endif /* JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/background_thread_structs.h", "content": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n\n/* This file really combines \"structs\" and \"types\", but only transitionally. */\n\n#if defined(JEMALLOC_BACKGROUND_THREAD) || defined(JEMALLOC_LAZY_LOCK)\n# define JEMALLOC_PTHREAD_CREATE_WRAPPER\n#endif\n\n#define BACKGROUND_THREAD_INDEFINITE_SLEEP UINT64_MAX\n#define MAX_BACKGROUND_THREAD_LIMIT MALLOCX_ARENA_LIMIT\n#define DEFAULT_NUM_BACKGROUND_THREAD 4\n\n/*\n * These exist only as a transitional state. Eventually, deferral should be\n * part of the PAI, and each implementation can indicate wait times with more\n * specificity.\n */\n#define BACKGROUND_THREAD_HPA_INTERVAL_MAX_UNINITIALIZED (-2)\n#define BACKGROUND_THREAD_HPA_INTERVAL_MAX_DEFAULT_WHEN_ENABLED 5000\n\n#define BACKGROUND_THREAD_DEFERRED_MIN UINT64_C(0)\n#define BACKGROUND_THREAD_DEFERRED_MAX UINT64_MAX\n\ntypedef enum {\n\tbackground_thread_stopped,\n\tbackground_thread_started,\n\t/* Thread waits on the global lock when paused (for arena_reset). */\n\tbackground_thread_paused,\n} background_thread_state_t;\n\nstruct background_thread_info_s {\n#ifdef JEMALLOC_BACKGROUND_THREAD\n\t/* Background thread is pthread specific. */\n\tpthread_t\t\tthread;\n\tpthread_cond_t\t\tcond;\n#endif\n\tmalloc_mutex_t\t\tmtx;\n\tbackground_thread_state_t\tstate;\n\t/* When true, it means no wakeup scheduled. */\n\tatomic_b_t\t\tindefinite_sleep;\n\t/* Next scheduled wakeup time (absolute time in ns). */\n\tnstime_t\t\tnext_wakeup;\n\t/*\n\t * Since the last background thread run, newly added number of pages\n\t * that need to be purged by the next wakeup. This is adjusted on\n\t * epoch advance, and is used to determine whether we should signal the\n\t * background thread to wake up earlier.\n\t */\n\tsize_t\t\t\tnpages_to_purge_new;\n\t/* Stats: total number of runs since started. */\n\tuint64_t\t\ttot_n_runs;\n\t/* Stats: total sleep time since started. */\n\tnstime_t\t\ttot_sleep_time;\n};\ntypedef struct background_thread_info_s background_thread_info_t;\n\nstruct background_thread_stats_s {\n\tsize_t num_threads;\n\tuint64_t num_runs;\n\tnstime_t run_interval;\n\tmutex_prof_data_t max_counter_per_bg_thd;\n};\ntypedef struct background_thread_stats_s background_thread_stats_t;\n\n#endif /* JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/base.h", "content": "#ifndef JEMALLOC_INTERNAL_BASE_H\n#define JEMALLOC_INTERNAL_BASE_H\n\n#include \"jemalloc/internal/edata.h\"\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/mutex.h\"\n\nenum metadata_thp_mode_e {\n\tmetadata_thp_disabled = 0,\n\t/*\n\t * Lazily enable hugepage for metadata. To avoid high RSS caused by THP\n\t * + low usage arena (i.e. THP becomes a significant percentage), the\n\t * \"auto\" option only starts using THP after a base allocator used up\n\t * the first THP region. Starting from the second hugepage (in a single\n\t * arena), \"auto\" behaves the same as \"always\", i.e. madvise hugepage\n\t * right away.\n\t */\n\tmetadata_thp_auto = 1,\n\tmetadata_thp_always = 2,\n\tmetadata_thp_mode_limit = 3\n};\ntypedef enum metadata_thp_mode_e metadata_thp_mode_t;\n\n#define METADATA_THP_DEFAULT metadata_thp_disabled\nextern metadata_thp_mode_t opt_metadata_thp;\nextern const char *metadata_thp_mode_names[];\n\n\n/* Embedded at the beginning of every block of base-managed virtual memory. */\ntypedef struct base_block_s base_block_t;\nstruct base_block_s {\n\t/* Total size of block's virtual memory mapping. */\n\tsize_t size;\n\n\t/* Next block in list of base's blocks. */\n\tbase_block_t *next;\n\n\t/* Tracks unused trailing space. */\n\tedata_t edata;\n};\n\ntypedef struct base_s base_t;\nstruct base_s {\n\t/*\n\t * User-configurable extent hook functions.\n\t */\n\tehooks_t ehooks;\n\n\t/*\n\t * User-configurable extent hook functions for metadata allocations.\n\t */\n\tehooks_t ehooks_base;\n\n\t/* Protects base_alloc() and base_stats_get() operations. */\n\tmalloc_mutex_t mtx;\n\n\t/* Using THP when true (metadata_thp auto mode). */\n\tbool auto_thp_switched;\n\t/*\n\t * Most recent size class in the series of increasingly large base\n\t * extents. Logarithmic spacing between subsequent allocations ensures\n\t * that the total number of distinct mappings remains small.\n\t */\n\tpszind_t pind_last;\n\n\t/* Serial number generation state. */\n\tsize_t extent_sn_next;\n\n\t/* Chain of all blocks associated with base. */\n\tbase_block_t *blocks;\n\n\t/* Heap of extents that track unused trailing space within blocks. */\n\tedata_heap_t avail[SC_NSIZES];\n\n\t/* Stats, only maintained if config_stats. */\n\tsize_t allocated;\n\tsize_t resident;\n\tsize_t mapped;\n\t/* Number of THP regions touched. */\n\tsize_t n_thp;\n};\n\nstatic inline unsigned\nbase_ind_get(const base_t *base) {\n\treturn ehooks_ind_get(&base->ehooks);\n}\n\nstatic inline bool\nmetadata_thp_enabled(void) {\n\treturn (opt_metadata_thp != metadata_thp_disabled);\n}\n\nbase_t *b0get(void);\nbase_t *base_new(tsdn_t *tsdn, unsigned ind,\n const extent_hooks_t *extent_hooks, bool metadata_use_hooks);\nvoid base_delete(tsdn_t *tsdn, base_t *base);\nehooks_t *base_ehooks_get(base_t *base);\nehooks_t *base_ehooks_get_for_metadata(base_t *base);\nextent_hooks_t *base_extent_hooks_set(base_t *base,\n extent_hooks_t *extent_hooks);\nvoid *base_alloc(tsdn_t *tsdn, base_t *base, size_t size, size_t alignment);\nedata_t *base_alloc_edata(tsdn_t *tsdn, base_t *base);\nvoid base_stats_get(tsdn_t *tsdn, base_t *base, size_t *allocated,\n size_t *resident, size_t *mapped, size_t *n_thp);\nvoid base_prefork(tsdn_t *tsdn, base_t *base);\nvoid base_postfork_parent(tsdn_t *tsdn, base_t *base);\nvoid base_postfork_child(tsdn_t *tsdn, base_t *base);\nbool base_boot(tsdn_t *tsdn);\n\n#endif /* JEMALLOC_INTERNAL_BASE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bin.h", "content": "#ifndef JEMALLOC_INTERNAL_BIN_H\n#define JEMALLOC_INTERNAL_BIN_H\n\n#include \"jemalloc/internal/bin_stats.h\"\n#include \"jemalloc/internal/bin_types.h\"\n#include \"jemalloc/internal/edata.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/sc.h\"\n\n/*\n * A bin contains a set of extents that are currently being used for slab\n * allocations.\n */\ntypedef struct bin_s bin_t;\nstruct bin_s {\n\t/* All operations on bin_t fields require lock ownership. */\n\tmalloc_mutex_t\t\tlock;\n\n\t/*\n\t * Bin statistics. These get touched every time the lock is acquired,\n\t * so put them close by in the hopes of getting some cache locality.\n\t */\n\tbin_stats_t\tstats;\n\n\t/*\n\t * Current slab being used to service allocations of this bin's size\n\t * class. slabcur is independent of slabs_{nonfull,full}; whenever\n\t * slabcur is reassigned, the previous slab must be deallocated or\n\t * inserted into slabs_{nonfull,full}.\n\t */\n\tedata_t\t\t\t*slabcur;\n\n\t/*\n\t * Heap of non-full slabs. This heap is used to assure that new\n\t * allocations come from the non-full slab that is oldest/lowest in\n\t * memory.\n\t */\n\tedata_heap_t\t\tslabs_nonfull;\n\n\t/* List used to track full slabs. */\n\tedata_list_active_t\tslabs_full;\n};\n\n/* A set of sharded bins of the same size class. */\ntypedef struct bins_s bins_t;\nstruct bins_s {\n\t/* Sharded bins. Dynamically sized. */\n\tbin_t *bin_shards;\n};\n\nvoid bin_shard_sizes_boot(unsigned bin_shards[SC_NBINS]);\nbool bin_update_shard_size(unsigned bin_shards[SC_NBINS], size_t start_size,\n size_t end_size, size_t nshards);\n\n/* Initializes a bin to empty. Returns true on error. */\nbool bin_init(bin_t *bin);\n\n/* Forking. */\nvoid bin_prefork(tsdn_t *tsdn, bin_t *bin);\nvoid bin_postfork_parent(tsdn_t *tsdn, bin_t *bin);\nvoid bin_postfork_child(tsdn_t *tsdn, bin_t *bin);\n\n/* Stats. */\nstatic inline void\nbin_stats_merge(tsdn_t *tsdn, bin_stats_data_t *dst_bin_stats, bin_t *bin) {\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\tmalloc_mutex_prof_accum(tsdn, &dst_bin_stats->mutex_data, &bin->lock);\n\tbin_stats_t *stats = &dst_bin_stats->stats_data;\n\tstats->nmalloc += bin->stats.nmalloc;\n\tstats->ndalloc += bin->stats.ndalloc;\n\tstats->nrequests += bin->stats.nrequests;\n\tstats->curregs += bin->stats.curregs;\n\tstats->nfills += bin->stats.nfills;\n\tstats->nflushes += bin->stats.nflushes;\n\tstats->nslabs += bin->stats.nslabs;\n\tstats->reslabs += bin->stats.reslabs;\n\tstats->curslabs += bin->stats.curslabs;\n\tstats->nonfull_slabs += bin->stats.nonfull_slabs;\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n}\n\n#endif /* JEMALLOC_INTERNAL_BIN_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bin_info.h", "content": "#ifndef JEMALLOC_INTERNAL_BIN_INFO_H\n#define JEMALLOC_INTERNAL_BIN_INFO_H\n\n#include \"jemalloc/internal/bitmap.h\"\n\n/*\n * Read-only information associated with each element of arena_t's bins array\n * is stored separately, partly to reduce memory usage (only one copy, rather\n * than one per arena), but mainly to avoid false cacheline sharing.\n *\n * Each slab has the following layout:\n *\n * /--------------------\\\n * | region 0 |\n * |--------------------|\n * | region 1 |\n * |--------------------|\n * | ... |\n * | ... |\n * | ... |\n * |--------------------|\n * | region nregs-1 |\n * \\--------------------/\n */\ntypedef struct bin_info_s bin_info_t;\nstruct bin_info_s {\n\t/* Size of regions in a slab for this bin's size class. */\n\tsize_t\t\t\treg_size;\n\n\t/* Total size of a slab for this bin's size class. */\n\tsize_t\t\t\tslab_size;\n\n\t/* Total number of regions in a slab for this bin's size class. */\n\tuint32_t\t\tnregs;\n\n\t/* Number of sharded bins in each arena for this size class. */\n\tuint32_t\t\tn_shards;\n\n\t/*\n\t * Metadata used to manipulate bitmaps for slabs associated with this\n\t * bin.\n\t */\n\tbitmap_info_t\t\tbitmap_info;\n};\n\nextern bin_info_t bin_infos[SC_NBINS];\n\nvoid bin_info_boot(sc_data_t *sc_data, unsigned bin_shard_sizes[SC_NBINS]);\n\n#endif /* JEMALLOC_INTERNAL_BIN_INFO_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bin_stats.h", "content": "#ifndef JEMALLOC_INTERNAL_BIN_STATS_H\n#define JEMALLOC_INTERNAL_BIN_STATS_H\n\n#include \"jemalloc/internal/mutex_prof.h\"\n\ntypedef struct bin_stats_s bin_stats_t;\nstruct bin_stats_s {\n\t/*\n\t * Total number of allocation/deallocation requests served directly by\n\t * the bin. Note that tcache may allocate an object, then recycle it\n\t * many times, resulting many increments to nrequests, but only one\n\t * each to nmalloc and ndalloc.\n\t */\n\tuint64_t\tnmalloc;\n\tuint64_t\tndalloc;\n\n\t/*\n\t * Number of allocation requests that correspond to the size of this\n\t * bin. This includes requests served by tcache, though tcache only\n\t * periodically merges into this counter.\n\t */\n\tuint64_t\tnrequests;\n\n\t/*\n\t * Current number of regions of this size class, including regions\n\t * currently cached by tcache.\n\t */\n\tsize_t\t\tcurregs;\n\n\t/* Number of tcache fills from this bin. */\n\tuint64_t\tnfills;\n\n\t/* Number of tcache flushes to this bin. */\n\tuint64_t\tnflushes;\n\n\t/* Total number of slabs created for this bin's size class. */\n\tuint64_t\tnslabs;\n\n\t/*\n\t * Total number of slabs reused by extracting them from the slabs heap\n\t * for this bin's size class.\n\t */\n\tuint64_t\treslabs;\n\n\t/* Current number of slabs in this bin. */\n\tsize_t\t\tcurslabs;\n\n\t/* Current size of nonfull slabs heap in this bin. */\n\tsize_t\t\tnonfull_slabs;\n};\n\ntypedef struct bin_stats_data_s bin_stats_data_t;\nstruct bin_stats_data_s {\n\tbin_stats_t stats_data;\n\tmutex_prof_data_t mutex_data;\n};\n#endif /* JEMALLOC_INTERNAL_BIN_STATS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bin_types.h", "content": "#ifndef JEMALLOC_INTERNAL_BIN_TYPES_H\n#define JEMALLOC_INTERNAL_BIN_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n#define BIN_SHARDS_MAX (1 << EDATA_BITS_BINSHARD_WIDTH)\n#define N_BIN_SHARDS_DEFAULT 1\n\n/* Used in TSD static initializer only. Real init in arena_bind(). */\n#define TSD_BINSHARDS_ZERO_INITIALIZER {{UINT8_MAX}}\n\ntypedef struct tsd_binshards_s tsd_binshards_t;\nstruct tsd_binshards_s {\n\tuint8_t binshard[SC_NBINS];\n};\n\n#endif /* JEMALLOC_INTERNAL_BIN_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bit_util.h", "content": "#ifndef JEMALLOC_INTERNAL_BIT_UTIL_H\n#define JEMALLOC_INTERNAL_BIT_UTIL_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/* Sanity check. */\n#if !defined(JEMALLOC_INTERNAL_FFSLL) || !defined(JEMALLOC_INTERNAL_FFSL) \\\n || !defined(JEMALLOC_INTERNAL_FFS)\n# error JEMALLOC_INTERNAL_FFS{,L,LL} should have been defined by configure\n#endif\n\n/*\n * Unlike the builtins and posix ffs functions, our ffs requires a non-zero\n * input, and returns the position of the lowest bit set (as opposed to the\n * posix versions, which return 1 larger than that position and use a return\n * value of zero as a sentinel. This tends to simplify logic in callers, and\n * allows for consistency with the builtins we build fls on top of.\n */\nstatic inline unsigned\nffs_llu(unsigned long long x) {\n\tutil_assume(x != 0);\n\treturn JEMALLOC_INTERNAL_FFSLL(x) - 1;\n}\n\nstatic inline unsigned\nffs_lu(unsigned long x) {\n\tutil_assume(x != 0);\n\treturn JEMALLOC_INTERNAL_FFSL(x) - 1;\n}\n\nstatic inline unsigned\nffs_u(unsigned x) {\n\tutil_assume(x != 0);\n\treturn JEMALLOC_INTERNAL_FFS(x) - 1;\n}\n\n#define DO_FLS_SLOW(x, suffix) do {\t\t\t\t\t\\\n\tutil_assume(x != 0);\t\t\t\t\t\t\\\n\tx |= (x >> 1);\t\t\t\t\t\t\t\\\n\tx |= (x >> 2);\t\t\t\t\t\t\t\\\n\tx |= (x >> 4);\t\t\t\t\t\t\t\\\n\tx |= (x >> 8);\t\t\t\t\t\t\t\\\n\tx |= (x >> 16);\t\t\t\t\t\t\t\\\n\tif (sizeof(x) > 4) {\t\t\t\t\t\t\\\n\t\t/*\t\t\t\t\t\t\t\\\n\t\t * If sizeof(x) is 4, then the expression \"x >> 32\"\t\\\n\t\t * will generate compiler warnings even if the code\t\\\n\t\t * never executes. This circumvents the warning, and\t\\\n\t\t * gets compiled out in optimized builds.\t\t\\\n\t\t */\t\t\t\t\t\t\t\\\n\t\tint constant_32 = sizeof(x) * 4;\t\t\t\\\n\t\tx |= (x >> constant_32);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tx++;\t\t\t\t\t\t\t\t\\\n\tif (x == 0) {\t\t\t\t\t\t\t\\\n\t\treturn 8 * sizeof(x) - 1;\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn ffs_##suffix(x) - 1;\t\t\t\t\t\\\n} while(0)\n\nstatic inline unsigned\nfls_llu_slow(unsigned long long x) {\n\tDO_FLS_SLOW(x, llu);\n}\n\nstatic inline unsigned\nfls_lu_slow(unsigned long x) {\n\tDO_FLS_SLOW(x, lu);\n}\n\nstatic inline unsigned\nfls_u_slow(unsigned x) {\n\tDO_FLS_SLOW(x, u);\n}\n\n#undef DO_FLS_SLOW\n\n#ifdef JEMALLOC_HAVE_BUILTIN_CLZ\nstatic inline unsigned\nfls_llu(unsigned long long x) {\n\tutil_assume(x != 0);\n\t/*\n\t * Note that the xor here is more naturally written as subtraction; the\n\t * last bit set is the number of bits in the type minus the number of\n\t * leading zero bits. But GCC implements that as:\n\t * bsr edi, edi\n\t * mov eax, 31\n\t * xor edi, 31\n\t * sub eax, edi\n\t * If we write it as xor instead, then we get\n\t * bsr eax, edi\n\t * as desired.\n\t */\n\treturn (8 * sizeof(x) - 1) ^ __builtin_clzll(x);\n}\n\nstatic inline unsigned\nfls_lu(unsigned long x) {\n\tutil_assume(x != 0);\n\treturn (8 * sizeof(x) - 1) ^ __builtin_clzl(x);\n}\n\nstatic inline unsigned\nfls_u(unsigned x) {\n\tutil_assume(x != 0);\n\treturn (8 * sizeof(x) - 1) ^ __builtin_clz(x);\n}\n#elif defined(_MSC_VER)\n\n#if LG_SIZEOF_PTR == 3\n#define DO_BSR64(bit, x) _BitScanReverse64(&bit, x)\n#else\n/*\n * This never actually runs; we're just dodging a compiler error for the\n * never-taken branch where sizeof(void *) == 8.\n */\n#define DO_BSR64(bit, x) bit = 0; unreachable()\n#endif\n\n#define DO_FLS(x) do {\t\t\t\t\t\t\t\\\n\tif (x == 0) {\t\t\t\t\t\t\t\\\n\t\treturn 8 * sizeof(x);\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tunsigned long bit;\t\t\t\t\t\t\\\n\tif (sizeof(x) == 4) {\t\t\t\t\t\t\\\n\t\t_BitScanReverse(&bit, (unsigned)x);\t\t\t\\\n\t\treturn (unsigned)bit;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (sizeof(x) == 8 && sizeof(void *) == 8) {\t\t\t\\\n\t\tDO_BSR64(bit, x);\t\t\t\t\t\\\n\t\treturn (unsigned)bit;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (sizeof(x) == 8 && sizeof(void *) == 4) {\t\t\t\\\n\t\t/* Dodge a compiler warning, as above. */\t\t\\\n\t\tint constant_32 = sizeof(x) * 4;\t\t\t\\\n\t\tif (_BitScanReverse(&bit,\t\t\t\t\\\n\t\t (unsigned)(x >> constant_32))) {\t\t\t\\\n\t\t\treturn 32 + (unsigned)bit;\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\t_BitScanReverse(&bit, (unsigned)x);\t\t\\\n\t\t\treturn (unsigned)bit;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tunreachable();\t\t\t\t\t\t\t\\\n} while (0)\n\nstatic inline unsigned\nfls_llu(unsigned long long x) {\n\tDO_FLS(x);\n}\n\nstatic inline unsigned\nfls_lu(unsigned long x) {\n\tDO_FLS(x);\n}\n\nstatic inline unsigned\nfls_u(unsigned x) {\n\tDO_FLS(x);\n}\n\n#undef DO_FLS\n#undef DO_BSR64\n#else\n\nstatic inline unsigned\nfls_llu(unsigned long long x) {\n\treturn fls_llu_slow(x);\n}\n\nstatic inline unsigned\nfls_lu(unsigned long x) {\n\treturn fls_lu_slow(x);\n}\n\nstatic inline unsigned\nfls_u(unsigned x) {\n\treturn fls_u_slow(x);\n}\n#endif\n\n#if LG_SIZEOF_LONG_LONG > 3\n# error \"Haven't implemented popcount for 16-byte ints.\"\n#endif\n\n#define DO_POPCOUNT(x, type) do {\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Algorithm from an old AMD optimization reference manual.\t\\\n\t * We're putting a little bit more work than you might expect\t\\\n\t * into the no-instrinsic case, since we only support the\t\\\n\t * GCC intrinsics spelling of popcount (for now). Detecting\t\\\n\t * whether or not the popcount builtin is actually useable in\t\\\n\t * MSVC is nontrivial.\t\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\ttype bmul = (type)0x0101010101010101ULL;\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Replace each 2 bits with the sideways sum of the original\t\\\n\t * values. 0x5 = 0b0101.\t\t\t\t\t\\\n\t *\t\t\t\t\t\t\t\t\\\n\t * You might expect this to be:\t\t\t\t\t\\\n\t * x = (x & 0x55...) + ((x >> 1) & 0x55...).\t\t\t\\\n\t * That costs an extra mask relative to this, though.\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tx = x - ((x >> 1) & (0x55U * bmul));\t\t\t\t\\\n\t/* Replace each 4 bits with their sideays sum. 0x3 = 0b0011. */\\\n\tx = (x & (bmul * 0x33U)) + ((x >> 2) & (bmul * 0x33U));\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Replace each 8 bits with their sideways sum. Note that we\t\\\n\t * can't overflow within each 4-bit sum here, so we can skip\t\\\n\t * the initial mask.\t\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tx = (x + (x >> 4)) & (bmul * 0x0FU);\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * None of the partial sums in this multiplication (viewed in\t\\\n\t * base-256) can overflow into the next digit. So the least\t\\\n\t * significant byte of the product will be the least\t\t\\\n\t * significant byte of the original value, the second least\t\\\n\t * significant byte will be the sum of the two least\t\t\\\n\t * significant bytes of the original value, and so on.\t\t\\\n\t * Importantly, the high byte will be the byte-wise sum of all\t\\\n\t * the bytes of the original value.\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tx = x * bmul;\t\t\t\t\t\t\t\\\n\tx >>= ((sizeof(x) - 1) * 8);\t\t\t\t\t\\\n\treturn (unsigned)x;\t\t\t\t\t\t\\\n} while(0)\n\nstatic inline unsigned\npopcount_u_slow(unsigned bitmap) {\n\tDO_POPCOUNT(bitmap, unsigned);\n}\n\nstatic inline unsigned\npopcount_lu_slow(unsigned long bitmap) {\n\tDO_POPCOUNT(bitmap, unsigned long);\n}\n\nstatic inline unsigned\npopcount_llu_slow(unsigned long long bitmap) {\n\tDO_POPCOUNT(bitmap, unsigned long long);\n}\n\n#undef DO_POPCOUNT\n\nstatic inline unsigned\npopcount_u(unsigned bitmap) {\n#ifdef JEMALLOC_INTERNAL_POPCOUNT\n\treturn JEMALLOC_INTERNAL_POPCOUNT(bitmap);\n#else\n\treturn popcount_u_slow(bitmap);\n#endif\n}\n\nstatic inline unsigned\npopcount_lu(unsigned long bitmap) {\n#ifdef JEMALLOC_INTERNAL_POPCOUNTL\n\treturn JEMALLOC_INTERNAL_POPCOUNTL(bitmap);\n#else\n\treturn popcount_lu_slow(bitmap);\n#endif\n}\n\nstatic inline unsigned\npopcount_llu(unsigned long long bitmap) {\n#ifdef JEMALLOC_INTERNAL_POPCOUNTLL\n\treturn JEMALLOC_INTERNAL_POPCOUNTLL(bitmap);\n#else\n\treturn popcount_llu_slow(bitmap);\n#endif\n}\n\n/*\n * Clears first unset bit in bitmap, and returns\n * place of bit. bitmap *must not* be 0.\n */\n\nstatic inline size_t\ncfs_lu(unsigned long* bitmap) {\n\tutil_assume(*bitmap != 0);\n\tsize_t bit = ffs_lu(*bitmap);\n\t*bitmap ^= ZU(1) << bit;\n\treturn bit;\n}\n\nstatic inline unsigned\nffs_zu(size_t x) {\n#if LG_SIZEOF_PTR == LG_SIZEOF_INT\n\treturn ffs_u(x);\n#elif LG_SIZEOF_PTR == LG_SIZEOF_LONG\n\treturn ffs_lu(x);\n#elif LG_SIZEOF_PTR == LG_SIZEOF_LONG_LONG\n\treturn ffs_llu(x);\n#else\n#error No implementation for size_t ffs()\n#endif\n}\n\nstatic inline unsigned\nfls_zu(size_t x) {\n#if LG_SIZEOF_PTR == LG_SIZEOF_INT\n\treturn fls_u(x);\n#elif LG_SIZEOF_PTR == LG_SIZEOF_LONG\n\treturn fls_lu(x);\n#elif LG_SIZEOF_PTR == LG_SIZEOF_LONG_LONG\n\treturn fls_llu(x);\n#else\n#error No implementation for size_t fls()\n#endif\n}\n\n\nstatic inline unsigned\nffs_u64(uint64_t x) {\n#if LG_SIZEOF_LONG == 3\n\treturn ffs_lu(x);\n#elif LG_SIZEOF_LONG_LONG == 3\n\treturn ffs_llu(x);\n#else\n#error No implementation for 64-bit ffs()\n#endif\n}\n\nstatic inline unsigned\nfls_u64(uint64_t x) {\n#if LG_SIZEOF_LONG == 3\n\treturn fls_lu(x);\n#elif LG_SIZEOF_LONG_LONG == 3\n\treturn fls_llu(x);\n#else\n#error No implementation for 64-bit fls()\n#endif\n}\n\nstatic inline unsigned\nffs_u32(uint32_t x) {\n#if LG_SIZEOF_INT == 2\n\treturn ffs_u(x);\n#else\n#error No implementation for 32-bit ffs()\n#endif\n\treturn ffs_u(x);\n}\n\nstatic inline unsigned\nfls_u32(uint32_t x) {\n#if LG_SIZEOF_INT == 2\n\treturn fls_u(x);\n#else\n#error No implementation for 32-bit fls()\n#endif\n\treturn fls_u(x);\n}\n\nstatic inline uint64_t\npow2_ceil_u64(uint64_t x) {\n\tif (unlikely(x <= 1)) {\n\t\treturn x;\n\t}\n\tsize_t msb_on_index = fls_u64(x - 1);\n\t/*\n\t * Range-check; it's on the callers to ensure that the result of this\n\t * call won't overflow.\n\t */\n\tassert(msb_on_index < 63);\n\treturn 1ULL << (msb_on_index + 1);\n}\n\nstatic inline uint32_t\npow2_ceil_u32(uint32_t x) {\n\tif (unlikely(x <= 1)) {\n\t return x;\n\t}\n\tsize_t msb_on_index = fls_u32(x - 1);\n\t/* As above. */\n\tassert(msb_on_index < 31);\n\treturn 1U << (msb_on_index + 1);\n}\n\n/* Compute the smallest power of 2 that is >= x. */\nstatic inline size_t\npow2_ceil_zu(size_t x) {\n#if (LG_SIZEOF_PTR == 3)\n\treturn pow2_ceil_u64(x);\n#else\n\treturn pow2_ceil_u32(x);\n#endif\n}\n\nstatic inline unsigned\nlg_floor(size_t x) {\n\tutil_assume(x != 0);\n#if (LG_SIZEOF_PTR == 3)\n\treturn fls_u64(x);\n#else\n\treturn fls_u32(x);\n#endif\n}\n\nstatic inline unsigned\nlg_ceil(size_t x) {\n\treturn lg_floor(x) + ((x & (x - 1)) == 0 ? 0 : 1);\n}\n\n/* A compile-time version of lg_floor and lg_ceil. */\n#define LG_FLOOR_1(x) 0\n#define LG_FLOOR_2(x) (x < (1ULL << 1) ? LG_FLOOR_1(x) : 1 + LG_FLOOR_1(x >> 1))\n#define LG_FLOOR_4(x) (x < (1ULL << 2) ? LG_FLOOR_2(x) : 2 + LG_FLOOR_2(x >> 2))\n#define LG_FLOOR_8(x) (x < (1ULL << 4) ? LG_FLOOR_4(x) : 4 + LG_FLOOR_4(x >> 4))\n#define LG_FLOOR_16(x) (x < (1ULL << 8) ? LG_FLOOR_8(x) : 8 + LG_FLOOR_8(x >> 8))\n#define LG_FLOOR_32(x) (x < (1ULL << 16) ? LG_FLOOR_16(x) : 16 + LG_FLOOR_16(x >> 16))\n#define LG_FLOOR_64(x) (x < (1ULL << 32) ? LG_FLOOR_32(x) : 32 + LG_FLOOR_32(x >> 32))\n#if LG_SIZEOF_PTR == 2\n# define LG_FLOOR(x) LG_FLOOR_32((x))\n#else\n# define LG_FLOOR(x) LG_FLOOR_64((x))\n#endif\n\n#define LG_CEIL(x) (LG_FLOOR(x) + (((x) & ((x) - 1)) == 0 ? 0 : 1))\n\n#endif /* JEMALLOC_INTERNAL_BIT_UTIL_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/bitmap.h", "content": "#ifndef JEMALLOC_INTERNAL_BITMAP_H\n#define JEMALLOC_INTERNAL_BITMAP_H\n\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/sc.h\"\n\ntypedef unsigned long bitmap_t;\n#define LG_SIZEOF_BITMAP\tLG_SIZEOF_LONG\n\n/* Maximum bitmap bit count is 2^LG_BITMAP_MAXBITS. */\n#if SC_LG_SLAB_MAXREGS > LG_CEIL(SC_NSIZES)\n/* Maximum bitmap bit count is determined by maximum regions per slab. */\n# define LG_BITMAP_MAXBITS\tSC_LG_SLAB_MAXREGS\n#else\n/* Maximum bitmap bit count is determined by number of extent size classes. */\n# define LG_BITMAP_MAXBITS\tLG_CEIL(SC_NSIZES)\n#endif\n#define BITMAP_MAXBITS\t\t(ZU(1) << LG_BITMAP_MAXBITS)\n\n/* Number of bits per group. */\n#define LG_BITMAP_GROUP_NBITS\t\t(LG_SIZEOF_BITMAP + 3)\n#define BITMAP_GROUP_NBITS\t\t(1U << LG_BITMAP_GROUP_NBITS)\n#define BITMAP_GROUP_NBITS_MASK\t\t(BITMAP_GROUP_NBITS-1)\n\n/*\n * Do some analysis on how big the bitmap is before we use a tree. For a brute\n * force linear search, if we would have to call ffs_lu() more than 2^3 times,\n * use a tree instead.\n */\n#if LG_BITMAP_MAXBITS - LG_BITMAP_GROUP_NBITS > 3\n# define BITMAP_USE_TREE\n#endif\n\n/* Number of groups required to store a given number of bits. */\n#define BITMAP_BITS2GROUPS(nbits)\t\t\t\t\t\\\n (((nbits) + BITMAP_GROUP_NBITS_MASK) >> LG_BITMAP_GROUP_NBITS)\n\n/*\n * Number of groups required at a particular level for a given number of bits.\n */\n#define BITMAP_GROUPS_L0(nbits)\t\t\t\t\t\t\\\n BITMAP_BITS2GROUPS(nbits)\n#define BITMAP_GROUPS_L1(nbits)\t\t\t\t\t\t\\\n BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(nbits))\n#define BITMAP_GROUPS_L2(nbits)\t\t\t\t\t\t\\\n BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS((nbits))))\n#define BITMAP_GROUPS_L3(nbits)\t\t\t\t\t\t\\\n BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(\t\t\\\n\tBITMAP_BITS2GROUPS((nbits)))))\n#define BITMAP_GROUPS_L4(nbits)\t\t\t\t\t\t\\\n BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS(\t\t\\\n\tBITMAP_BITS2GROUPS(BITMAP_BITS2GROUPS((nbits))))))\n\n/*\n * Assuming the number of levels, number of groups required for a given number\n * of bits.\n */\n#define BITMAP_GROUPS_1_LEVEL(nbits)\t\t\t\t\t\\\n BITMAP_GROUPS_L0(nbits)\n#define BITMAP_GROUPS_2_LEVEL(nbits)\t\t\t\t\t\\\n (BITMAP_GROUPS_1_LEVEL(nbits) + BITMAP_GROUPS_L1(nbits))\n#define BITMAP_GROUPS_3_LEVEL(nbits)\t\t\t\t\t\\\n (BITMAP_GROUPS_2_LEVEL(nbits) + BITMAP_GROUPS_L2(nbits))\n#define BITMAP_GROUPS_4_LEVEL(nbits)\t\t\t\t\t\\\n (BITMAP_GROUPS_3_LEVEL(nbits) + BITMAP_GROUPS_L3(nbits))\n#define BITMAP_GROUPS_5_LEVEL(nbits)\t\t\t\t\t\\\n (BITMAP_GROUPS_4_LEVEL(nbits) + BITMAP_GROUPS_L4(nbits))\n\n/*\n * Maximum number of groups required to support LG_BITMAP_MAXBITS.\n */\n#ifdef BITMAP_USE_TREE\n\n#if LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS\n# define BITMAP_GROUPS(nbits)\tBITMAP_GROUPS_1_LEVEL(nbits)\n# define BITMAP_GROUPS_MAX\tBITMAP_GROUPS_1_LEVEL(BITMAP_MAXBITS)\n#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 2\n# define BITMAP_GROUPS(nbits)\tBITMAP_GROUPS_2_LEVEL(nbits)\n# define BITMAP_GROUPS_MAX\tBITMAP_GROUPS_2_LEVEL(BITMAP_MAXBITS)\n#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 3\n# define BITMAP_GROUPS(nbits)\tBITMAP_GROUPS_3_LEVEL(nbits)\n# define BITMAP_GROUPS_MAX\tBITMAP_GROUPS_3_LEVEL(BITMAP_MAXBITS)\n#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 4\n# define BITMAP_GROUPS(nbits)\tBITMAP_GROUPS_4_LEVEL(nbits)\n# define BITMAP_GROUPS_MAX\tBITMAP_GROUPS_4_LEVEL(BITMAP_MAXBITS)\n#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 5\n# define BITMAP_GROUPS(nbits)\tBITMAP_GROUPS_5_LEVEL(nbits)\n# define BITMAP_GROUPS_MAX\tBITMAP_GROUPS_5_LEVEL(BITMAP_MAXBITS)\n#else\n# error \"Unsupported bitmap size\"\n#endif\n\n/*\n * Maximum number of levels possible. This could be statically computed based\n * on LG_BITMAP_MAXBITS:\n *\n * #define BITMAP_MAX_LEVELS \\\n * (LG_BITMAP_MAXBITS / LG_SIZEOF_BITMAP) \\\n * + !!(LG_BITMAP_MAXBITS % LG_SIZEOF_BITMAP)\n *\n * However, that would not allow the generic BITMAP_INFO_INITIALIZER() macro, so\n * instead hardcode BITMAP_MAX_LEVELS to the largest number supported by the\n * various cascading macros. The only additional cost this incurs is some\n * unused trailing entries in bitmap_info_t structures; the bitmaps themselves\n * are not impacted.\n */\n#define BITMAP_MAX_LEVELS\t5\n\n#define BITMAP_INFO_INITIALIZER(nbits) {\t\t\t\t\\\n\t/* nbits. */\t\t\t\t\t\t\t\\\n\tnbits,\t\t\t\t\t\t\t\t\\\n\t/* nlevels. */\t\t\t\t\t\t\t\\\n\t(BITMAP_GROUPS_L0(nbits) > BITMAP_GROUPS_L1(nbits)) +\t\t\\\n\t (BITMAP_GROUPS_L1(nbits) > BITMAP_GROUPS_L2(nbits)) +\t\\\n\t (BITMAP_GROUPS_L2(nbits) > BITMAP_GROUPS_L3(nbits)) +\t\\\n\t (BITMAP_GROUPS_L3(nbits) > BITMAP_GROUPS_L4(nbits)) + 1,\t\\\n\t/* levels. */\t\t\t\t\t\t\t\\\n\t{\t\t\t\t\t\t\t\t\\\n\t\t{0},\t\t\t\t\t\t\t\\\n\t\t{BITMAP_GROUPS_L0(nbits)},\t\t\t\t\\\n\t\t{BITMAP_GROUPS_L1(nbits) + BITMAP_GROUPS_L0(nbits)},\t\\\n\t\t{BITMAP_GROUPS_L2(nbits) + BITMAP_GROUPS_L1(nbits) +\t\\\n\t\t BITMAP_GROUPS_L0(nbits)},\t\t\t\t\\\n\t\t{BITMAP_GROUPS_L3(nbits) + BITMAP_GROUPS_L2(nbits) +\t\\\n\t\t BITMAP_GROUPS_L1(nbits) + BITMAP_GROUPS_L0(nbits)},\t\\\n\t\t{BITMAP_GROUPS_L4(nbits) + BITMAP_GROUPS_L3(nbits) +\t\\\n\t\t BITMAP_GROUPS_L2(nbits) + BITMAP_GROUPS_L1(nbits)\t\\\n\t\t + BITMAP_GROUPS_L0(nbits)}\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\n\n#else /* BITMAP_USE_TREE */\n\n#define BITMAP_GROUPS(nbits)\tBITMAP_BITS2GROUPS(nbits)\n#define BITMAP_GROUPS_MAX\tBITMAP_BITS2GROUPS(BITMAP_MAXBITS)\n\n#define BITMAP_INFO_INITIALIZER(nbits) {\t\t\t\t\\\n\t/* nbits. */\t\t\t\t\t\t\t\\\n\tnbits,\t\t\t\t\t\t\t\t\\\n\t/* ngroups. */\t\t\t\t\t\t\t\\\n\tBITMAP_BITS2GROUPS(nbits)\t\t\t\t\t\\\n}\n\n#endif /* BITMAP_USE_TREE */\n\ntypedef struct bitmap_level_s {\n\t/* Offset of this level's groups within the array of groups. */\n\tsize_t group_offset;\n} bitmap_level_t;\n\ntypedef struct bitmap_info_s {\n\t/* Logical number of bits in bitmap (stored at bottom level). */\n\tsize_t nbits;\n\n#ifdef BITMAP_USE_TREE\n\t/* Number of levels necessary for nbits. */\n\tunsigned nlevels;\n\n\t/*\n\t * Only the first (nlevels+1) elements are used, and levels are ordered\n\t * bottom to top (e.g. the bottom level is stored in levels[0]).\n\t */\n\tbitmap_level_t levels[BITMAP_MAX_LEVELS+1];\n#else /* BITMAP_USE_TREE */\n\t/* Number of groups necessary for nbits. */\n\tsize_t ngroups;\n#endif /* BITMAP_USE_TREE */\n} bitmap_info_t;\n\nvoid bitmap_info_init(bitmap_info_t *binfo, size_t nbits);\nvoid bitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo, bool fill);\nsize_t bitmap_size(const bitmap_info_t *binfo);\n\nstatic inline bool\nbitmap_full(bitmap_t *bitmap, const bitmap_info_t *binfo) {\n#ifdef BITMAP_USE_TREE\n\tsize_t rgoff = binfo->levels[binfo->nlevels].group_offset - 1;\n\tbitmap_t rg = bitmap[rgoff];\n\t/* The bitmap is full iff the root group is 0. */\n\treturn (rg == 0);\n#else\n\tsize_t i;\n\n\tfor (i = 0; i < binfo->ngroups; i++) {\n\t\tif (bitmap[i] != 0) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n#endif\n}\n\nstatic inline bool\nbitmap_get(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit) {\n\tsize_t goff;\n\tbitmap_t g;\n\n\tassert(bit < binfo->nbits);\n\tgoff = bit >> LG_BITMAP_GROUP_NBITS;\n\tg = bitmap[goff];\n\treturn !(g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK)));\n}\n\nstatic inline void\nbitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit) {\n\tsize_t goff;\n\tbitmap_t *gp;\n\tbitmap_t g;\n\n\tassert(bit < binfo->nbits);\n\tassert(!bitmap_get(bitmap, binfo, bit));\n\tgoff = bit >> LG_BITMAP_GROUP_NBITS;\n\tgp = &bitmap[goff];\n\tg = *gp;\n\tassert(g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK)));\n\tg ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);\n\t*gp = g;\n\tassert(bitmap_get(bitmap, binfo, bit));\n#ifdef BITMAP_USE_TREE\n\t/* Propagate group state transitions up the tree. */\n\tif (g == 0) {\n\t\tunsigned i;\n\t\tfor (i = 1; i < binfo->nlevels; i++) {\n\t\t\tbit = goff;\n\t\t\tgoff = bit >> LG_BITMAP_GROUP_NBITS;\n\t\t\tgp = &bitmap[binfo->levels[i].group_offset + goff];\n\t\t\tg = *gp;\n\t\t\tassert(g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK)));\n\t\t\tg ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);\n\t\t\t*gp = g;\n\t\t\tif (g != 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n#endif\n}\n\n/* ffu: find first unset >= bit. */\nstatic inline size_t\nbitmap_ffu(const bitmap_t *bitmap, const bitmap_info_t *binfo, size_t min_bit) {\n\tassert(min_bit < binfo->nbits);\n\n#ifdef BITMAP_USE_TREE\n\tsize_t bit = 0;\n\tfor (unsigned level = binfo->nlevels; level--;) {\n\t\tsize_t lg_bits_per_group = (LG_BITMAP_GROUP_NBITS * (level +\n\t\t 1));\n\t\tbitmap_t group = bitmap[binfo->levels[level].group_offset + (bit\n\t\t >> lg_bits_per_group)];\n\t\tunsigned group_nmask = (unsigned)(((min_bit > bit) ? (min_bit -\n\t\t bit) : 0) >> (lg_bits_per_group - LG_BITMAP_GROUP_NBITS));\n\t\tassert(group_nmask <= BITMAP_GROUP_NBITS);\n\t\tbitmap_t group_mask = ~((1LU << group_nmask) - 1);\n\t\tbitmap_t group_masked = group & group_mask;\n\t\tif (group_masked == 0LU) {\n\t\t\tif (group == 0LU) {\n\t\t\t\treturn binfo->nbits;\n\t\t\t}\n\t\t\t/*\n\t\t\t * min_bit was preceded by one or more unset bits in\n\t\t\t * this group, but there are no other unset bits in this\n\t\t\t * group. Try again starting at the first bit of the\n\t\t\t * next sibling. This will recurse at most once per\n\t\t\t * non-root level.\n\t\t\t */\n\t\t\tsize_t sib_base = bit + (ZU(1) << lg_bits_per_group);\n\t\t\tassert(sib_base > min_bit);\n\t\t\tassert(sib_base > bit);\n\t\t\tif (sib_base >= binfo->nbits) {\n\t\t\t\treturn binfo->nbits;\n\t\t\t}\n\t\t\treturn bitmap_ffu(bitmap, binfo, sib_base);\n\t\t}\n\t\tbit += ((size_t)ffs_lu(group_masked)) <<\n\t\t (lg_bits_per_group - LG_BITMAP_GROUP_NBITS);\n\t}\n\tassert(bit >= min_bit);\n\tassert(bit < binfo->nbits);\n\treturn bit;\n#else\n\tsize_t i = min_bit >> LG_BITMAP_GROUP_NBITS;\n\tbitmap_t g = bitmap[i] & ~((1LU << (min_bit & BITMAP_GROUP_NBITS_MASK))\n\t - 1);\n\tsize_t bit;\n\tdo {\n\t\tif (g != 0) {\n\t\t\tbit = ffs_lu(g);\n\t\t\treturn (i << LG_BITMAP_GROUP_NBITS) + bit;\n\t\t}\n\t\ti++;\n\t\tg = bitmap[i];\n\t} while (i < binfo->ngroups);\n\treturn binfo->nbits;\n#endif\n}\n\n/* sfu: set first unset. */\nstatic inline size_t\nbitmap_sfu(bitmap_t *bitmap, const bitmap_info_t *binfo) {\n\tsize_t bit;\n\tbitmap_t g;\n\tunsigned i;\n\n\tassert(!bitmap_full(bitmap, binfo));\n\n#ifdef BITMAP_USE_TREE\n\ti = binfo->nlevels - 1;\n\tg = bitmap[binfo->levels[i].group_offset];\n\tbit = ffs_lu(g);\n\twhile (i > 0) {\n\t\ti--;\n\t\tg = bitmap[binfo->levels[i].group_offset + bit];\n\t\tbit = (bit << LG_BITMAP_GROUP_NBITS) + ffs_lu(g);\n\t}\n#else\n\ti = 0;\n\tg = bitmap[0];\n\twhile (g == 0) {\n\t\ti++;\n\t\tg = bitmap[i];\n\t}\n\tbit = (i << LG_BITMAP_GROUP_NBITS) + ffs_lu(g);\n#endif\n\tbitmap_set(bitmap, binfo, bit);\n\treturn bit;\n}\n\nstatic inline void\nbitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit) {\n\tsize_t goff;\n\tbitmap_t *gp;\n\tbitmap_t g;\n\tUNUSED bool propagate;\n\n\tassert(bit < binfo->nbits);\n\tassert(bitmap_get(bitmap, binfo, bit));\n\tgoff = bit >> LG_BITMAP_GROUP_NBITS;\n\tgp = &bitmap[goff];\n\tg = *gp;\n\tpropagate = (g == 0);\n\tassert((g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK))) == 0);\n\tg ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);\n\t*gp = g;\n\tassert(!bitmap_get(bitmap, binfo, bit));\n#ifdef BITMAP_USE_TREE\n\t/* Propagate group state transitions up the tree. */\n\tif (propagate) {\n\t\tunsigned i;\n\t\tfor (i = 1; i < binfo->nlevels; i++) {\n\t\t\tbit = goff;\n\t\t\tgoff = bit >> LG_BITMAP_GROUP_NBITS;\n\t\t\tgp = &bitmap[binfo->levels[i].group_offset + goff];\n\t\t\tg = *gp;\n\t\t\tpropagate = (g == 0);\n\t\t\tassert((g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK)))\n\t\t\t == 0);\n\t\t\tg ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);\n\t\t\t*gp = g;\n\t\t\tif (!propagate) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n#endif /* BITMAP_USE_TREE */\n}\n\n#endif /* JEMALLOC_INTERNAL_BITMAP_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/buf_writer.h", "content": "#ifndef JEMALLOC_INTERNAL_BUF_WRITER_H\n#define JEMALLOC_INTERNAL_BUF_WRITER_H\n\n/*\n * Note: when using the buffered writer, cbopaque is passed to write_cb only\n * when the buffer is flushed. It would make a difference if cbopaque points\n * to something that's changing for each write_cb call, or something that\n * affects write_cb in a way dependent on the content of the output string.\n * However, the most typical usage case in practice is that cbopaque points to\n * some \"option like\" content for the write_cb, so it doesn't matter.\n */\n\ntypedef struct {\n\twrite_cb_t *write_cb;\n\tvoid *cbopaque;\n\tchar *buf;\n\tsize_t buf_size;\n\tsize_t buf_end;\n\tbool internal_buf;\n} buf_writer_t;\n\nbool buf_writer_init(tsdn_t *tsdn, buf_writer_t *buf_writer,\n write_cb_t *write_cb, void *cbopaque, char *buf, size_t buf_len);\nvoid buf_writer_flush(buf_writer_t *buf_writer);\nwrite_cb_t buf_writer_cb;\nvoid buf_writer_terminate(tsdn_t *tsdn, buf_writer_t *buf_writer);\n\ntypedef ssize_t (read_cb_t)(void *read_cbopaque, void *buf, size_t limit);\nvoid buf_writer_pipe(buf_writer_t *buf_writer, read_cb_t *read_cb,\n void *read_cbopaque);\n\n#endif /* JEMALLOC_INTERNAL_BUF_WRITER_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/cache_bin.h", "content": "#ifndef JEMALLOC_INTERNAL_CACHE_BIN_H\n#define JEMALLOC_INTERNAL_CACHE_BIN_H\n\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/sz.h\"\n\n/*\n * The cache_bins are the mechanism that the tcache and the arena use to\n * communicate. The tcache fills from and flushes to the arena by passing a\n * cache_bin_t to fill/flush. When the arena needs to pull stats from the\n * tcaches associated with it, it does so by iterating over its\n * cache_bin_array_descriptor_t objects and reading out per-bin stats it\n * contains. This makes it so that the arena need not know about the existence\n * of the tcache at all.\n */\n\n/*\n * The size in bytes of each cache bin stack. We also use this to indicate\n * *counts* of individual objects.\n */\ntypedef uint16_t cache_bin_sz_t;\n\n/*\n * Leave a noticeable mark pattern on the cache bin stack boundaries, in case a\n * bug starts leaking those. Make it look like the junk pattern but be distinct\n * from it.\n */\nstatic const uintptr_t cache_bin_preceding_junk =\n (uintptr_t)0x7a7a7a7a7a7a7a7aULL;\n/* Note: a7 vs. 7a above -- this tells you which pointer leaked. */\nstatic const uintptr_t cache_bin_trailing_junk =\n (uintptr_t)0xa7a7a7a7a7a7a7a7ULL;\n\n/*\n * That implies the following value, for the maximum number of items in any\n * individual bin. The cache bins track their bounds looking just at the low\n * bits of a pointer, compared against a cache_bin_sz_t. So that's\n * 1 << (sizeof(cache_bin_sz_t) * 8)\n * bytes spread across pointer sized objects to get the maximum.\n */\n#define CACHE_BIN_NCACHED_MAX (((size_t)1 << sizeof(cache_bin_sz_t) * 8) \\\n / sizeof(void *) - 1)\n\n/*\n * This lives inside the cache_bin (for locality reasons), and is initialized\n * alongside it, but is otherwise not modified by any cache bin operations.\n * It's logically public and maintained by its callers.\n */\ntypedef struct cache_bin_stats_s cache_bin_stats_t;\nstruct cache_bin_stats_s {\n\t/*\n\t * Number of allocation requests that corresponded to the size of this\n\t * bin.\n\t */\n\tuint64_t nrequests;\n};\n\n/*\n * Read-only information associated with each element of tcache_t's tbins array\n * is stored separately, mainly to reduce memory usage.\n */\ntypedef struct cache_bin_info_s cache_bin_info_t;\nstruct cache_bin_info_s {\n\tcache_bin_sz_t ncached_max;\n};\n\n/*\n * Responsible for caching allocations associated with a single size.\n *\n * Several pointers are used to track the stack. To save on metadata bytes,\n * only the stack_head is a full sized pointer (which is dereferenced on the\n * fastpath), while the others store only the low 16 bits -- this is correct\n * because a single stack never takes more space than 2^16 bytes, and at the\n * same time only equality checks are performed on the low bits.\n *\n * (low addr) (high addr)\n * |------stashed------|------available------|------cached-----|\n * ^ ^ ^ ^\n * low_bound(derived) low_bits_full stack_head low_bits_empty\n */\ntypedef struct cache_bin_s cache_bin_t;\nstruct cache_bin_s {\n\t/*\n\t * The stack grows down. Whenever the bin is nonempty, the head points\n\t * to an array entry containing a valid allocation. When it is empty,\n\t * the head points to one element past the owned array.\n\t */\n\tvoid **stack_head;\n\t/*\n\t * cur_ptr and stats are both modified frequently. Let's keep them\n\t * close so that they have a higher chance of being on the same\n\t * cacheline, thus less write-backs.\n\t */\n\tcache_bin_stats_t tstats;\n\n\t/*\n\t * The low bits of the address of the first item in the stack that\n\t * hasn't been used since the last GC, to track the low water mark (min\n\t * # of cached items).\n\t *\n\t * Since the stack grows down, this is a higher address than\n\t * low_bits_full.\n\t */\n\tuint16_t low_bits_low_water;\n\n\t/*\n\t * The low bits of the value that stack_head will take on when the array\n\t * is full (of cached & stashed items). But remember that stack_head\n\t * always points to a valid item when the array is nonempty -- this is\n\t * in the array.\n\t *\n\t * Recall that since the stack grows down, this is the lowest available\n\t * address in the array for caching. Only adjusted when stashing items.\n\t */\n\tuint16_t low_bits_full;\n\n\t/*\n\t * The low bits of the value that stack_head will take on when the array\n\t * is empty.\n\t *\n\t * The stack grows down -- this is one past the highest address in the\n\t * array. Immutable after initialization.\n\t */\n\tuint16_t low_bits_empty;\n};\n\n/*\n * The cache_bins live inside the tcache, but the arena (by design) isn't\n * supposed to know much about tcache internals. To let the arena iterate over\n * associated bins, we keep (with the tcache) a linked list of\n * cache_bin_array_descriptor_ts that tell the arena how to find the bins.\n */\ntypedef struct cache_bin_array_descriptor_s cache_bin_array_descriptor_t;\nstruct cache_bin_array_descriptor_s {\n\t/*\n\t * The arena keeps a list of the cache bins associated with it, for\n\t * stats collection.\n\t */\n\tql_elm(cache_bin_array_descriptor_t) link;\n\t/* Pointers to the tcache bins. */\n\tcache_bin_t *bins;\n};\n\nstatic inline void\ncache_bin_array_descriptor_init(cache_bin_array_descriptor_t *descriptor,\n cache_bin_t *bins) {\n\tql_elm_new(descriptor, link);\n\tdescriptor->bins = bins;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ncache_bin_nonfast_aligned(const void *ptr) {\n\tif (!config_uaf_detection) {\n\t\treturn false;\n\t}\n\t/*\n\t * Currently we use alignment to decide which pointer to junk & stash on\n\t * dealloc (for catching use-after-free). In some common cases a\n\t * page-aligned check is needed already (sdalloc w/ config_prof), so we\n\t * are getting it more or less for free -- no added instructions on\n\t * free_fastpath.\n\t *\n\t * Another way of deciding which pointer to sample, is adding another\n\t * thread_event to pick one every N bytes. That also adds no cost on\n\t * the fastpath, however it will tend to pick large allocations which is\n\t * not the desired behavior.\n\t */\n\treturn ((uintptr_t)ptr & san_cache_bin_nonfast_mask) == 0;\n}\n\n/* Returns ncached_max: Upper limit on ncached. */\nstatic inline cache_bin_sz_t\ncache_bin_info_ncached_max(cache_bin_info_t *info) {\n\treturn info->ncached_max;\n}\n\n/*\n * Internal.\n *\n * Asserts that the pointer associated with earlier is <= the one associated\n * with later.\n */\nstatic inline void\ncache_bin_assert_earlier(cache_bin_t *bin, uint16_t earlier, uint16_t later) {\n\tif (earlier > later) {\n\t\tassert(bin->low_bits_full > bin->low_bits_empty);\n\t}\n}\n\n/*\n * Internal.\n *\n * Does difference calculations that handle wraparound correctly. Earlier must\n * be associated with the position earlier in memory.\n */\nstatic inline uint16_t\ncache_bin_diff(cache_bin_t *bin, uint16_t earlier, uint16_t later, bool racy) {\n\t/*\n\t * When it's racy, bin->low_bits_full can be modified concurrently. It\n\t * can cross the uint16_t max value and become less than\n\t * bin->low_bits_empty at the time of the check.\n\t */\n\tif (!racy) {\n\t\tcache_bin_assert_earlier(bin, earlier, later);\n\t}\n\treturn later - earlier;\n}\n\n/*\n * Number of items currently cached in the bin, without checking ncached_max.\n * We require specifying whether or not the request is racy or not (i.e. whether\n * or not concurrent modifications are possible).\n */\nstatic inline cache_bin_sz_t\ncache_bin_ncached_get_internal(cache_bin_t *bin, bool racy) {\n\tcache_bin_sz_t diff = cache_bin_diff(bin,\n\t (uint16_t)(uintptr_t)bin->stack_head, bin->low_bits_empty, racy);\n\tcache_bin_sz_t n = diff / sizeof(void *);\n\t/*\n\t * We have undefined behavior here; if this function is called from the\n\t * arena stats updating code, then stack_head could change from the\n\t * first line to the next one. Morally, these loads should be atomic,\n\t * but compilers won't currently generate comparisons with in-memory\n\t * operands against atomics, and these variables get accessed on the\n\t * fast paths. This should still be \"safe\" in the sense of generating\n\t * the correct assembly for the foreseeable future, though.\n\t */\n\tassert(n == 0 || *(bin->stack_head) != NULL || racy);\n\treturn n;\n}\n\n/*\n * Number of items currently cached in the bin, with checking ncached_max. The\n * caller must know that no concurrent modification of the cache_bin is\n * possible.\n */\nstatic inline cache_bin_sz_t\ncache_bin_ncached_get_local(cache_bin_t *bin, cache_bin_info_t *info) {\n\tcache_bin_sz_t n = cache_bin_ncached_get_internal(bin,\n\t /* racy */ false);\n\tassert(n <= cache_bin_info_ncached_max(info));\n\treturn n;\n}\n\n/*\n * Internal.\n *\n * A pointer to the position one past the end of the backing array.\n *\n * Do not call if racy, because both 'bin->stack_head' and 'bin->low_bits_full'\n * are subject to concurrent modifications.\n */\nstatic inline void **\ncache_bin_empty_position_get(cache_bin_t *bin) {\n\tcache_bin_sz_t diff = cache_bin_diff(bin,\n\t (uint16_t)(uintptr_t)bin->stack_head, bin->low_bits_empty,\n\t /* racy */ false);\n\tuintptr_t empty_bits = (uintptr_t)bin->stack_head + diff;\n\tvoid **ret = (void **)empty_bits;\n\n\tassert(ret >= bin->stack_head);\n\n\treturn ret;\n}\n\n/*\n * Internal.\n *\n * Calculates low bits of the lower bound of the usable cache bin's range (see\n * cache_bin_t visual representation above).\n *\n * No values are concurrently modified, so should be safe to read in a\n * multithreaded environment. Currently concurrent access happens only during\n * arena statistics collection.\n */\nstatic inline uint16_t\ncache_bin_low_bits_low_bound_get(cache_bin_t *bin, cache_bin_info_t *info) {\n\treturn (uint16_t)bin->low_bits_empty -\n\t info->ncached_max * sizeof(void *);\n}\n\n/*\n * Internal.\n *\n * A pointer to the position with the lowest address of the backing array.\n */\nstatic inline void **\ncache_bin_low_bound_get(cache_bin_t *bin, cache_bin_info_t *info) {\n\tcache_bin_sz_t ncached_max = cache_bin_info_ncached_max(info);\n\tvoid **ret = cache_bin_empty_position_get(bin) - ncached_max;\n\tassert(ret <= bin->stack_head);\n\n\treturn ret;\n}\n\n/*\n * As the name implies. This is important since it's not correct to try to\n * batch fill a nonempty cache bin.\n */\nstatic inline void\ncache_bin_assert_empty(cache_bin_t *bin, cache_bin_info_t *info) {\n\tassert(cache_bin_ncached_get_local(bin, info) == 0);\n\tassert(cache_bin_empty_position_get(bin) == bin->stack_head);\n}\n\n/*\n * Get low water, but without any of the correctness checking we do for the\n * caller-usable version, if we are temporarily breaking invariants (like\n * ncached >= low_water during flush).\n */\nstatic inline cache_bin_sz_t\ncache_bin_low_water_get_internal(cache_bin_t *bin) {\n\treturn cache_bin_diff(bin, bin->low_bits_low_water,\n\t bin->low_bits_empty, /* racy */ false) / sizeof(void *);\n}\n\n/* Returns the numeric value of low water in [0, ncached]. */\nstatic inline cache_bin_sz_t\ncache_bin_low_water_get(cache_bin_t *bin, cache_bin_info_t *info) {\n\tcache_bin_sz_t low_water = cache_bin_low_water_get_internal(bin);\n\tassert(low_water <= cache_bin_info_ncached_max(info));\n\tassert(low_water <= cache_bin_ncached_get_local(bin, info));\n\n\tcache_bin_assert_earlier(bin, (uint16_t)(uintptr_t)bin->stack_head,\n\t bin->low_bits_low_water);\n\n\treturn low_water;\n}\n\n/*\n * Indicates that the current cache bin position should be the low water mark\n * going forward.\n */\nstatic inline void\ncache_bin_low_water_set(cache_bin_t *bin) {\n\tbin->low_bits_low_water = (uint16_t)(uintptr_t)bin->stack_head;\n}\n\nstatic inline void\ncache_bin_low_water_adjust(cache_bin_t *bin) {\n\tif (cache_bin_ncached_get_internal(bin, /* racy */ false)\n\t < cache_bin_low_water_get_internal(bin)) {\n\t\tcache_bin_low_water_set(bin);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void *\ncache_bin_alloc_impl(cache_bin_t *bin, bool *success, bool adjust_low_water) {\n\t/*\n\t * success (instead of ret) should be checked upon the return of this\n\t * function. We avoid checking (ret == NULL) because there is never a\n\t * null stored on the avail stack (which is unknown to the compiler),\n\t * and eagerly checking ret would cause pipeline stall (waiting for the\n\t * cacheline).\n\t */\n\n\t/*\n\t * This may read from the empty position; however the loaded value won't\n\t * be used. It's safe because the stack has one more slot reserved.\n\t */\n\tvoid *ret = *bin->stack_head;\n\tuint16_t low_bits = (uint16_t)(uintptr_t)bin->stack_head;\n\tvoid **new_head = bin->stack_head + 1;\n\n\t/*\n\t * Note that the low water mark is at most empty; if we pass this check,\n\t * we know we're non-empty.\n\t */\n\tif (likely(low_bits != bin->low_bits_low_water)) {\n\t\tbin->stack_head = new_head;\n\t\t*success = true;\n\t\treturn ret;\n\t}\n\tif (!adjust_low_water) {\n\t\t*success = false;\n\t\treturn NULL;\n\t}\n\t/*\n\t * In the fast-path case where we call alloc_easy and then alloc, the\n\t * previous checking and computation is optimized away -- we didn't\n\t * actually commit any of our operations.\n\t */\n\tif (likely(low_bits != bin->low_bits_empty)) {\n\t\tbin->stack_head = new_head;\n\t\tbin->low_bits_low_water = (uint16_t)(uintptr_t)new_head;\n\t\t*success = true;\n\t\treturn ret;\n\t}\n\t*success = false;\n\treturn NULL;\n}\n\n/*\n * Allocate an item out of the bin, failing if we're at the low-water mark.\n */\nJEMALLOC_ALWAYS_INLINE void *\ncache_bin_alloc_easy(cache_bin_t *bin, bool *success) {\n\t/* We don't look at info if we're not adjusting low-water. */\n\treturn cache_bin_alloc_impl(bin, success, false);\n}\n\n/*\n * Allocate an item out of the bin, even if we're currently at the low-water\n * mark (and failing only if the bin is empty).\n */\nJEMALLOC_ALWAYS_INLINE void *\ncache_bin_alloc(cache_bin_t *bin, bool *success) {\n\treturn cache_bin_alloc_impl(bin, success, true);\n}\n\nJEMALLOC_ALWAYS_INLINE cache_bin_sz_t\ncache_bin_alloc_batch(cache_bin_t *bin, size_t num, void **out) {\n\tcache_bin_sz_t n = cache_bin_ncached_get_internal(bin,\n\t /* racy */ false);\n\tif (n > num) {\n\t\tn = (cache_bin_sz_t)num;\n\t}\n\tmemcpy(out, bin->stack_head, n * sizeof(void *));\n\tbin->stack_head += n;\n\tcache_bin_low_water_adjust(bin);\n\n\treturn n;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ncache_bin_full(cache_bin_t *bin) {\n\treturn ((uint16_t)(uintptr_t)bin->stack_head == bin->low_bits_full);\n}\n\n/*\n * Free an object into the given bin. Fails only if the bin is full.\n */\nJEMALLOC_ALWAYS_INLINE bool\ncache_bin_dalloc_easy(cache_bin_t *bin, void *ptr) {\n\tif (unlikely(cache_bin_full(bin))) {\n\t\treturn false;\n\t}\n\n\tbin->stack_head--;\n\t*bin->stack_head = ptr;\n\tcache_bin_assert_earlier(bin, bin->low_bits_full,\n\t (uint16_t)(uintptr_t)bin->stack_head);\n\n\treturn true;\n}\n\n/* Returns false if failed to stash (i.e. bin is full). */\nJEMALLOC_ALWAYS_INLINE bool\ncache_bin_stash(cache_bin_t *bin, void *ptr) {\n\tif (cache_bin_full(bin)) {\n\t\treturn false;\n\t}\n\n\t/* Stash at the full position, in the [full, head) range. */\n\tuint16_t low_bits_head = (uint16_t)(uintptr_t)bin->stack_head;\n\t/* Wraparound handled as well. */\n\tuint16_t diff = cache_bin_diff(bin, bin->low_bits_full, low_bits_head,\n\t /* racy */ false);\n\t*(void **)((uintptr_t)bin->stack_head - diff) = ptr;\n\n\tassert(!cache_bin_full(bin));\n\tbin->low_bits_full += sizeof(void *);\n\tcache_bin_assert_earlier(bin, bin->low_bits_full, low_bits_head);\n\n\treturn true;\n}\n\n/*\n * Get the number of stashed pointers.\n *\n * When called from a thread not owning the TLS (i.e. racy = true), it's\n * important to keep in mind that 'bin->stack_head' and 'bin->low_bits_full' can\n * be modified concurrently and almost none assertions about their values can be\n * made.\n */\nJEMALLOC_ALWAYS_INLINE cache_bin_sz_t\ncache_bin_nstashed_get_internal(cache_bin_t *bin, cache_bin_info_t *info,\n bool racy) {\n\tcache_bin_sz_t ncached_max = cache_bin_info_ncached_max(info);\n\tuint16_t low_bits_low_bound = cache_bin_low_bits_low_bound_get(bin,\n\t info);\n\n\tcache_bin_sz_t n = cache_bin_diff(bin, low_bits_low_bound,\n\t bin->low_bits_full, racy) / sizeof(void *);\n\tassert(n <= ncached_max);\n\n\tif (!racy) {\n\t\t/* Below are for assertions only. */\n\t\tvoid **low_bound = cache_bin_low_bound_get(bin, info);\n\n\t\tassert((uint16_t)(uintptr_t)low_bound == low_bits_low_bound);\n\t\tvoid *stashed = *(low_bound + n - 1);\n\t\tbool aligned = cache_bin_nonfast_aligned(stashed);\n#ifdef JEMALLOC_JET\n\t\t/* Allow arbitrary pointers to be stashed in tests. */\n\t\taligned = true;\n#endif\n\t\tassert(n == 0 || (stashed != NULL && aligned));\n\t}\n\n\treturn n;\n}\n\nJEMALLOC_ALWAYS_INLINE cache_bin_sz_t\ncache_bin_nstashed_get_local(cache_bin_t *bin, cache_bin_info_t *info) {\n\tcache_bin_sz_t n = cache_bin_nstashed_get_internal(bin, info,\n\t /* racy */ false);\n\tassert(n <= cache_bin_info_ncached_max(info));\n\treturn n;\n}\n\n/*\n * Obtain a racy view of the number of items currently in the cache bin, in the\n * presence of possible concurrent modifications.\n */\nstatic inline void\ncache_bin_nitems_get_remote(cache_bin_t *bin, cache_bin_info_t *info,\n cache_bin_sz_t *ncached, cache_bin_sz_t *nstashed) {\n\tcache_bin_sz_t n = cache_bin_ncached_get_internal(bin, /* racy */ true);\n\tassert(n <= cache_bin_info_ncached_max(info));\n\t*ncached = n;\n\n\tn = cache_bin_nstashed_get_internal(bin, info, /* racy */ true);\n\tassert(n <= cache_bin_info_ncached_max(info));\n\t*nstashed = n;\n\t/* Note that cannot assert ncached + nstashed <= ncached_max (racy). */\n}\n\n/*\n * Filling and flushing are done in batch, on arrays of void *s. For filling,\n * the arrays go forward, and can be accessed with ordinary array arithmetic.\n * For flushing, we work from the end backwards, and so need to use special\n * accessors that invert the usual ordering.\n *\n * This is important for maintaining first-fit; the arena code fills with\n * earliest objects first, and so those are the ones we should return first for\n * cache_bin_alloc calls. When flushing, we should flush the objects that we\n * wish to return later; those at the end of the array. This is better for the\n * first-fit heuristic as well as for cache locality; the most recently freed\n * objects are the ones most likely to still be in cache.\n *\n * This all sounds very hand-wavey and theoretical, but reverting the ordering\n * on one or the other pathway leads to measurable slowdowns.\n */\n\ntypedef struct cache_bin_ptr_array_s cache_bin_ptr_array_t;\nstruct cache_bin_ptr_array_s {\n\tcache_bin_sz_t n;\n\tvoid **ptr;\n};\n\n/*\n * Declare a cache_bin_ptr_array_t sufficient for nval items.\n *\n * In the current implementation, this could be just part of a\n * cache_bin_ptr_array_init_... call, since we reuse the cache bin stack memory.\n * Indirecting behind a macro, though, means experimenting with linked-list\n * representations is easy (since they'll require an alloca in the calling\n * frame).\n */\n#define CACHE_BIN_PTR_ARRAY_DECLARE(name, nval)\t\t\t\t\\\n cache_bin_ptr_array_t name;\t\t\t\t\t\t\\\n name.n = (nval)\n\n/*\n * Start a fill. The bin must be empty, and This must be followed by a\n * finish_fill call before doing any alloc/dalloc operations on the bin.\n */\nstatic inline void\ncache_bin_init_ptr_array_for_fill(cache_bin_t *bin, cache_bin_info_t *info,\n cache_bin_ptr_array_t *arr, cache_bin_sz_t nfill) {\n\tcache_bin_assert_empty(bin, info);\n\tarr->ptr = cache_bin_empty_position_get(bin) - nfill;\n}\n\n/*\n * While nfill in cache_bin_init_ptr_array_for_fill is the number we *intend* to\n * fill, nfilled here is the number we actually filled (which may be less, in\n * case of OOM.\n */\nstatic inline void\ncache_bin_finish_fill(cache_bin_t *bin, cache_bin_info_t *info,\n cache_bin_ptr_array_t *arr, cache_bin_sz_t nfilled) {\n\tcache_bin_assert_empty(bin, info);\n\tvoid **empty_position = cache_bin_empty_position_get(bin);\n\tif (nfilled < arr->n) {\n\t\tmemmove(empty_position - nfilled, empty_position - arr->n,\n\t\t nfilled * sizeof(void *));\n\t}\n\tbin->stack_head = empty_position - nfilled;\n}\n\n/*\n * Same deal, but with flush. Unlike fill (which can fail), the user must flush\n * everything we give them.\n */\nstatic inline void\ncache_bin_init_ptr_array_for_flush(cache_bin_t *bin, cache_bin_info_t *info,\n cache_bin_ptr_array_t *arr, cache_bin_sz_t nflush) {\n\tarr->ptr = cache_bin_empty_position_get(bin) - nflush;\n\tassert(cache_bin_ncached_get_local(bin, info) == 0\n\t || *arr->ptr != NULL);\n}\n\nstatic inline void\ncache_bin_finish_flush(cache_bin_t *bin, cache_bin_info_t *info,\n cache_bin_ptr_array_t *arr, cache_bin_sz_t nflushed) {\n\tunsigned rem = cache_bin_ncached_get_local(bin, info) - nflushed;\n\tmemmove(bin->stack_head + nflushed, bin->stack_head,\n\t rem * sizeof(void *));\n\tbin->stack_head = bin->stack_head + nflushed;\n\tcache_bin_low_water_adjust(bin);\n}\n\nstatic inline void\ncache_bin_init_ptr_array_for_stashed(cache_bin_t *bin, szind_t binind,\n cache_bin_info_t *info, cache_bin_ptr_array_t *arr,\n cache_bin_sz_t nstashed) {\n\tassert(nstashed > 0);\n\tassert(cache_bin_nstashed_get_local(bin, info) == nstashed);\n\n\tvoid **low_bound = cache_bin_low_bound_get(bin, info);\n\tarr->ptr = low_bound;\n\tassert(*arr->ptr != NULL);\n}\n\nstatic inline void\ncache_bin_finish_flush_stashed(cache_bin_t *bin, cache_bin_info_t *info) {\n\tvoid **low_bound = cache_bin_low_bound_get(bin, info);\n\n\t/* Reset the bin local full position. */\n\tbin->low_bits_full = (uint16_t)(uintptr_t)low_bound;\n\tassert(cache_bin_nstashed_get_local(bin, info) == 0);\n}\n\n/*\n * Initialize a cache_bin_info to represent up to the given number of items in\n * the cache_bins it is associated with.\n */\nvoid cache_bin_info_init(cache_bin_info_t *bin_info,\n cache_bin_sz_t ncached_max);\n/*\n * Given an array of initialized cache_bin_info_ts, determine how big an\n * allocation is required to initialize a full set of cache_bin_ts.\n */\nvoid cache_bin_info_compute_alloc(cache_bin_info_t *infos, szind_t ninfos,\n size_t *size, size_t *alignment);\n\n/*\n * Actually initialize some cache bins. Callers should allocate the backing\n * memory indicated by a call to cache_bin_compute_alloc. They should then\n * preincrement, call init once for each bin and info, and then call\n * cache_bin_postincrement. *alloc_cur will then point immediately past the end\n * of the allocation.\n */\nvoid cache_bin_preincrement(cache_bin_info_t *infos, szind_t ninfos,\n void *alloc, size_t *cur_offset);\nvoid cache_bin_postincrement(cache_bin_info_t *infos, szind_t ninfos,\n void *alloc, size_t *cur_offset);\nvoid cache_bin_init(cache_bin_t *bin, cache_bin_info_t *info, void *alloc,\n size_t *cur_offset);\n\n/*\n * If a cache bin was zero initialized (either because it lives in static or\n * thread-local storage, or was memset to 0), this function indicates whether or\n * not cache_bin_init was called on it.\n */\nbool cache_bin_still_zero_initialized(cache_bin_t *bin);\n\n#endif /* JEMALLOC_INTERNAL_CACHE_BIN_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ckh.h", "content": "#ifndef JEMALLOC_INTERNAL_CKH_H\n#define JEMALLOC_INTERNAL_CKH_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/* Cuckoo hashing implementation. Skip to the end for the interface. */\n\n/******************************************************************************/\n/* INTERNAL DEFINITIONS -- IGNORE */\n/******************************************************************************/\n\n/* Maintain counters used to get an idea of performance. */\n/* #define CKH_COUNT */\n/* Print counter values in ckh_delete() (requires CKH_COUNT). */\n/* #define CKH_VERBOSE */\n\n/*\n * There are 2^LG_CKH_BUCKET_CELLS cells in each hash table bucket. Try to fit\n * one bucket per L1 cache line.\n */\n#define LG_CKH_BUCKET_CELLS (LG_CACHELINE - LG_SIZEOF_PTR - 1)\n\n/* Typedefs to allow easy function pointer passing. */\ntypedef void ckh_hash_t (const void *, size_t[2]);\ntypedef bool ckh_keycomp_t (const void *, const void *);\n\n/* Hash table cell. */\ntypedef struct {\n\tconst void *key;\n\tconst void *data;\n} ckhc_t;\n\n/* The hash table itself. */\ntypedef struct {\n#ifdef CKH_COUNT\n\t/* Counters used to get an idea of performance. */\n\tuint64_t ngrows;\n\tuint64_t nshrinks;\n\tuint64_t nshrinkfails;\n\tuint64_t ninserts;\n\tuint64_t nrelocs;\n#endif\n\n\t/* Used for pseudo-random number generation. */\n\tuint64_t prng_state;\n\n\t/* Total number of items. */\n\tsize_t count;\n\n\t/*\n\t * Minimum and current number of hash table buckets. There are\n\t * 2^LG_CKH_BUCKET_CELLS cells per bucket.\n\t */\n\tunsigned lg_minbuckets;\n\tunsigned lg_curbuckets;\n\n\t/* Hash and comparison functions. */\n\tckh_hash_t *hash;\n\tckh_keycomp_t *keycomp;\n\n\t/* Hash table with 2^lg_curbuckets buckets. */\n\tckhc_t *tab;\n} ckh_t;\n\n/******************************************************************************/\n/* BEGIN PUBLIC API */\n/******************************************************************************/\n\n/* Lifetime management. Minitems is the initial capacity. */\nbool ckh_new(tsd_t *tsd, ckh_t *ckh, size_t minitems, ckh_hash_t *hash,\n ckh_keycomp_t *keycomp);\nvoid ckh_delete(tsd_t *tsd, ckh_t *ckh);\n\n/* Get the number of elements in the set. */\nsize_t ckh_count(ckh_t *ckh);\n\n/*\n * To iterate over the elements in the table, initialize *tabind to 0 and call\n * this function until it returns true. Each call that returns false will\n * update *key and *data to the next element in the table, assuming the pointers\n * are non-NULL.\n */\nbool ckh_iter(ckh_t *ckh, size_t *tabind, void **key, void **data);\n\n/*\n * Basic hash table operations -- insert, removal, lookup. For ckh_remove and\n * ckh_search, key or data can be NULL. The hash-table only stores pointers to\n * the key and value, and doesn't do any lifetime management.\n */\nbool ckh_insert(tsd_t *tsd, ckh_t *ckh, const void *key, const void *data);\nbool ckh_remove(tsd_t *tsd, ckh_t *ckh, const void *searchkey, void **key,\n void **data);\nbool ckh_search(ckh_t *ckh, const void *searchkey, void **key, void **data);\n\n/* Some useful hash and comparison functions for strings and pointers. */\nvoid ckh_string_hash(const void *key, size_t r_hash[2]);\nbool ckh_string_keycomp(const void *k1, const void *k2);\nvoid ckh_pointer_hash(const void *key, size_t r_hash[2]);\nbool ckh_pointer_keycomp(const void *k1, const void *k2);\n\n#endif /* JEMALLOC_INTERNAL_CKH_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/counter.h", "content": "#ifndef JEMALLOC_INTERNAL_COUNTER_H\n#define JEMALLOC_INTERNAL_COUNTER_H\n\n#include \"jemalloc/internal/mutex.h\"\n\ntypedef struct counter_accum_s {\n\tLOCKEDINT_MTX_DECLARE(mtx)\n\tlocked_u64_t accumbytes;\n\tuint64_t interval;\n} counter_accum_t;\n\nJEMALLOC_ALWAYS_INLINE bool\ncounter_accum(tsdn_t *tsdn, counter_accum_t *counter, uint64_t bytes) {\n\tuint64_t interval = counter->interval;\n\tassert(interval > 0);\n\tLOCKEDINT_MTX_LOCK(tsdn, counter->mtx);\n\t/*\n\t * If the event moves fast enough (and/or if the event handling is slow\n\t * enough), extreme overflow can cause counter trigger coalescing.\n\t * This is an intentional mechanism that avoids rate-limiting\n\t * allocation.\n\t */\n\tbool overflow = locked_inc_mod_u64(tsdn, LOCKEDINT_MTX(counter->mtx),\n\t &counter->accumbytes, bytes, interval);\n\tLOCKEDINT_MTX_UNLOCK(tsdn, counter->mtx);\n\treturn overflow;\n}\n\nbool counter_accum_init(counter_accum_t *counter, uint64_t interval);\nvoid counter_prefork(tsdn_t *tsdn, counter_accum_t *counter);\nvoid counter_postfork_parent(tsdn_t *tsdn, counter_accum_t *counter);\nvoid counter_postfork_child(tsdn_t *tsdn, counter_accum_t *counter);\n\n#endif /* JEMALLOC_INTERNAL_COUNTER_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ctl.h", "content": "#ifndef JEMALLOC_INTERNAL_CTL_H\n#define JEMALLOC_INTERNAL_CTL_H\n\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/mutex_prof.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/stats.h\"\n\n/* Maximum ctl tree depth. */\n#define CTL_MAX_DEPTH\t7\n\ntypedef struct ctl_node_s {\n\tbool named;\n} ctl_node_t;\n\ntypedef struct ctl_named_node_s {\n\tctl_node_t node;\n\tconst char *name;\n\t/* If (nchildren == 0), this is a terminal node. */\n\tsize_t nchildren;\n\tconst ctl_node_t *children;\n\tint (*ctl)(tsd_t *, const size_t *, size_t, void *, size_t *, void *,\n\t size_t);\n} ctl_named_node_t;\n\ntypedef struct ctl_indexed_node_s {\n\tstruct ctl_node_s node;\n\tconst ctl_named_node_t *(*index)(tsdn_t *, const size_t *, size_t,\n\t size_t);\n} ctl_indexed_node_t;\n\ntypedef struct ctl_arena_stats_s {\n\tarena_stats_t astats;\n\n\t/* Aggregate stats for small size classes, based on bin stats. */\n\tsize_t allocated_small;\n\tuint64_t nmalloc_small;\n\tuint64_t ndalloc_small;\n\tuint64_t nrequests_small;\n\tuint64_t nfills_small;\n\tuint64_t nflushes_small;\n\n\tbin_stats_data_t bstats[SC_NBINS];\n\tarena_stats_large_t lstats[SC_NSIZES - SC_NBINS];\n\tpac_estats_t estats[SC_NPSIZES];\n\thpa_shard_stats_t hpastats;\n\tsec_stats_t secstats;\n} ctl_arena_stats_t;\n\ntypedef struct ctl_stats_s {\n\tsize_t allocated;\n\tsize_t active;\n\tsize_t metadata;\n\tsize_t metadata_thp;\n\tsize_t resident;\n\tsize_t mapped;\n\tsize_t retained;\n\n\tbackground_thread_stats_t background_thread;\n\tmutex_prof_data_t mutex_prof_data[mutex_prof_num_global_mutexes];\n} ctl_stats_t;\n\ntypedef struct ctl_arena_s ctl_arena_t;\nstruct ctl_arena_s {\n\tunsigned arena_ind;\n\tbool initialized;\n\tql_elm(ctl_arena_t) destroyed_link;\n\n\t/* Basic stats, supported even if !config_stats. */\n\tunsigned nthreads;\n\tconst char *dss;\n\tssize_t dirty_decay_ms;\n\tssize_t muzzy_decay_ms;\n\tsize_t pactive;\n\tsize_t pdirty;\n\tsize_t pmuzzy;\n\n\t/* NULL if !config_stats. */\n\tctl_arena_stats_t *astats;\n};\n\ntypedef struct ctl_arenas_s {\n\tuint64_t epoch;\n\tunsigned narenas;\n\tql_head(ctl_arena_t) destroyed;\n\n\t/*\n\t * Element 0 corresponds to merged stats for extant arenas (accessed via\n\t * MALLCTL_ARENAS_ALL), element 1 corresponds to merged stats for\n\t * destroyed arenas (accessed via MALLCTL_ARENAS_DESTROYED), and the\n\t * remaining MALLOCX_ARENA_LIMIT elements correspond to arenas.\n\t */\n\tctl_arena_t *arenas[2 + MALLOCX_ARENA_LIMIT];\n} ctl_arenas_t;\n\nint ctl_byname(tsd_t *tsd, const char *name, void *oldp, size_t *oldlenp,\n void *newp, size_t newlen);\nint ctl_nametomib(tsd_t *tsd, const char *name, size_t *mibp, size_t *miblenp);\nint ctl_bymib(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen);\nint ctl_mibnametomib(tsd_t *tsd, size_t *mib, size_t miblen, const char *name,\n size_t *miblenp);\nint ctl_bymibname(tsd_t *tsd, size_t *mib, size_t miblen, const char *name,\n size_t *miblenp, void *oldp, size_t *oldlenp, void *newp, size_t newlen);\nbool ctl_boot(void);\nvoid ctl_prefork(tsdn_t *tsdn);\nvoid ctl_postfork_parent(tsdn_t *tsdn);\nvoid ctl_postfork_child(tsdn_t *tsdn);\nvoid ctl_mtx_assert_held(tsdn_t *tsdn);\n\n#define xmallctl(name, oldp, oldlenp, newp, newlen) do {\t\t\\\n\tif (je_mallctl(name, oldp, oldlenp, newp, newlen)\t\t\\\n\t != 0) {\t\t\t\t\t\t\t\\\n\t\tmalloc_printf(\t\t\t\t\t\t\\\n\t\t \": Failure in xmallctl(\\\"%s\\\", ...)\\n\",\t\\\n\t\t name);\t\t\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define xmallctlnametomib(name, mibp, miblenp) do {\t\t\t\\\n\tif (je_mallctlnametomib(name, mibp, miblenp) != 0) {\t\t\\\n\t\tmalloc_printf(\": Failure in \"\t\t\t\\\n\t\t \"xmallctlnametomib(\\\"%s\\\", ...)\\n\", name);\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define xmallctlbymib(mib, miblen, oldp, oldlenp, newp, newlen) do {\t\\\n\tif (je_mallctlbymib(mib, miblen, oldp, oldlenp, newp,\t\t\\\n\t newlen) != 0) {\t\t\t\t\t\t\\\n\t\tmalloc_write(\t\t\t\t\t\t\\\n\t\t \": Failure in xmallctlbymib()\\n\");\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define xmallctlmibnametomib(mib, miblen, name, miblenp) do {\t\t\\\n\tif (ctl_mibnametomib(tsd_fetch(), mib, miblen, name, miblenp)\t\\\n\t != 0) {\t\t\t\t\t\t\t\\\n\t\tmalloc_write(\t\t\t\t\t\t\\\n\t\t \": Failure in ctl_mibnametomib()\\n\");\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define xmallctlbymibname(mib, miblen, name, miblenp, oldp, oldlenp,\t\\\n newp, newlen) do {\t\t\t\t\t\t\t\\\n\tif (ctl_bymibname(tsd_fetch(), mib, miblen, name, miblenp,\t\\\n\t oldp, oldlenp, newp, newlen) != 0) {\t\t\t\\\n\t\tmalloc_write(\t\t\t\t\t\t\\\n\t\t \": Failure in ctl_bymibname()\\n\");\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#endif /* JEMALLOC_INTERNAL_CTL_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/decay.h", "content": "#ifndef JEMALLOC_INTERNAL_DECAY_H\n#define JEMALLOC_INTERNAL_DECAY_H\n\n#include \"jemalloc/internal/smoothstep.h\"\n\n#define DECAY_UNBOUNDED_TIME_TO_PURGE ((uint64_t)-1)\n\n/*\n * The decay_t computes the number of pages we should purge at any given time.\n * Page allocators inform a decay object when pages enter a decay-able state\n * (i.e. dirty or muzzy), and query it to determine how many pages should be\n * purged at any given time.\n *\n * This is mostly a single-threaded data structure and doesn't care about\n * synchronization at all; it's the caller's responsibility to manage their\n * synchronization on their own. There are two exceptions:\n * 1) It's OK to racily call decay_ms_read (i.e. just the simplest state query).\n * 2) The mtx and purging fields live (and are initialized) here, but are\n * logically owned by the page allocator. This is just a convenience (since\n * those fields would be duplicated for both the dirty and muzzy states\n * otherwise).\n */\ntypedef struct decay_s decay_t;\nstruct decay_s {\n\t/* Synchronizes all non-atomic fields. */\n\tmalloc_mutex_t mtx;\n\t/*\n\t * True if a thread is currently purging the extents associated with\n\t * this decay structure.\n\t */\n\tbool purging;\n\t/*\n\t * Approximate time in milliseconds from the creation of a set of unused\n\t * dirty pages until an equivalent set of unused dirty pages is purged\n\t * and/or reused.\n\t */\n\tatomic_zd_t time_ms;\n\t/* time / SMOOTHSTEP_NSTEPS. */\n\tnstime_t interval;\n\t/*\n\t * Time at which the current decay interval logically started. We do\n\t * not actually advance to a new epoch until sometime after it starts\n\t * because of scheduling and computation delays, and it is even possible\n\t * to completely skip epochs. In all cases, during epoch advancement we\n\t * merge all relevant activity into the most recently recorded epoch.\n\t */\n\tnstime_t epoch;\n\t/* Deadline randomness generator. */\n\tuint64_t jitter_state;\n\t/*\n\t * Deadline for current epoch. This is the sum of interval and per\n\t * epoch jitter which is a uniform random variable in [0..interval).\n\t * Epochs always advance by precise multiples of interval, but we\n\t * randomize the deadline to reduce the likelihood of arenas purging in\n\t * lockstep.\n\t */\n\tnstime_t deadline;\n\t/*\n\t * The number of pages we cap ourselves at in the current epoch, per\n\t * decay policies. Updated on an epoch change. After an epoch change,\n\t * the caller should take steps to try to purge down to this amount.\n\t */\n\tsize_t npages_limit;\n\t/*\n\t * Number of unpurged pages at beginning of current epoch. During epoch\n\t * advancement we use the delta between arena->decay_*.nunpurged and\n\t * ecache_npages_get(&arena->ecache_*) to determine how many dirty pages,\n\t * if any, were generated.\n\t */\n\tsize_t nunpurged;\n\t/*\n\t * Trailing log of how many unused dirty pages were generated during\n\t * each of the past SMOOTHSTEP_NSTEPS decay epochs, where the last\n\t * element is the most recent epoch. Corresponding epoch times are\n\t * relative to epoch.\n\t *\n\t * Updated only on epoch advance, triggered by\n\t * decay_maybe_advance_epoch, below.\n\t */\n\tsize_t backlog[SMOOTHSTEP_NSTEPS];\n\n\t/* Peak number of pages in associated extents. Used for debug only. */\n\tuint64_t ceil_npages;\n};\n\n/*\n * The current decay time setting. This is the only public access to a decay_t\n * that's allowed without holding mtx.\n */\nstatic inline ssize_t\ndecay_ms_read(const decay_t *decay) {\n\treturn atomic_load_zd(&decay->time_ms, ATOMIC_RELAXED);\n}\n\n/*\n * See the comment on the struct field -- the limit on pages we should allow in\n * this decay state this epoch.\n */\nstatic inline size_t\ndecay_npages_limit_get(const decay_t *decay) {\n\treturn decay->npages_limit;\n}\n\n/* How many unused dirty pages were generated during the last epoch. */\nstatic inline size_t\ndecay_epoch_npages_delta(const decay_t *decay) {\n\treturn decay->backlog[SMOOTHSTEP_NSTEPS - 1];\n}\n\n/*\n * Current epoch duration, in nanoseconds. Given that new epochs are started\n * somewhat haphazardly, this is not necessarily exactly the time between any\n * two calls to decay_maybe_advance_epoch; see the comments on fields in the\n * decay_t.\n */\nstatic inline uint64_t\ndecay_epoch_duration_ns(const decay_t *decay) {\n\treturn nstime_ns(&decay->interval);\n}\n\nstatic inline bool\ndecay_immediately(const decay_t *decay) {\n\tssize_t decay_ms = decay_ms_read(decay);\n\treturn decay_ms == 0;\n}\n\nstatic inline bool\ndecay_disabled(const decay_t *decay) {\n\tssize_t decay_ms = decay_ms_read(decay);\n\treturn decay_ms < 0;\n}\n\n/* Returns true if decay is enabled and done gradually. */\nstatic inline bool\ndecay_gradually(const decay_t *decay) {\n\tssize_t decay_ms = decay_ms_read(decay);\n\treturn decay_ms > 0;\n}\n\n/*\n * Returns true if the passed in decay time setting is valid.\n * < -1 : invalid\n * -1 : never decay\n * 0 : decay immediately\n * > 0 : some positive decay time, up to a maximum allowed value of\n * NSTIME_SEC_MAX * 1000, which corresponds to decaying somewhere in the early\n * 27th century. By that time, we expect to have implemented alternate purging\n * strategies.\n */\nbool decay_ms_valid(ssize_t decay_ms);\n\n/*\n * As a precondition, the decay_t must be zeroed out (as if with memset).\n *\n * Returns true on error.\n */\nbool decay_init(decay_t *decay, nstime_t *cur_time, ssize_t decay_ms);\n\n/*\n * Given an already-initialized decay_t, reinitialize it with the given decay\n * time. The decay_t must have previously been initialized (and should not then\n * be zeroed).\n */\nvoid decay_reinit(decay_t *decay, nstime_t *cur_time, ssize_t decay_ms);\n\n/*\n * Compute how many of 'npages_new' pages we would need to purge in 'time'.\n */\nuint64_t decay_npages_purge_in(decay_t *decay, nstime_t *time,\n size_t npages_new);\n\n/* Returns true if the epoch advanced and there are pages to purge. */\nbool decay_maybe_advance_epoch(decay_t *decay, nstime_t *new_time,\n size_t current_npages);\n\n/*\n * Calculates wait time until a number of pages in the interval\n * [0.5 * npages_threshold .. 1.5 * npages_threshold] should be purged.\n *\n * Returns number of nanoseconds or DECAY_UNBOUNDED_TIME_TO_PURGE in case of\n * indefinite wait.\n */\nuint64_t decay_ns_until_purge(decay_t *decay, size_t npages_current,\n uint64_t npages_threshold);\n\n#endif /* JEMALLOC_INTERNAL_DECAY_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/div.h", "content": "#ifndef JEMALLOC_INTERNAL_DIV_H\n#define JEMALLOC_INTERNAL_DIV_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * This module does the division that computes the index of a region in a slab,\n * given its offset relative to the base.\n * That is, given a divisor d, an n = i * d (all integers), we'll return i.\n * We do some pre-computation to do this more quickly than a CPU division\n * instruction.\n * We bound n < 2^32, and don't support dividing by one.\n */\n\ntypedef struct div_info_s div_info_t;\nstruct div_info_s {\n\tuint32_t magic;\n#ifdef JEMALLOC_DEBUG\n\tsize_t d;\n#endif\n};\n\nvoid div_init(div_info_t *div_info, size_t divisor);\n\nstatic inline size_t\ndiv_compute(div_info_t *div_info, size_t n) {\n\tassert(n <= (uint32_t)-1);\n\t/*\n\t * This generates, e.g. mov; imul; shr on x86-64. On a 32-bit machine,\n\t * the compilers I tried were all smart enough to turn this into the\n\t * appropriate \"get the high 32 bits of the result of a multiply\" (e.g.\n\t * mul; mov edx eax; on x86, umull on arm, etc.).\n\t */\n\tsize_t i = ((uint64_t)n * (uint64_t)div_info->magic) >> 32;\n#ifdef JEMALLOC_DEBUG\n\tassert(i * div_info->d == n);\n#endif\n\treturn i;\n}\n\n#endif /* JEMALLOC_INTERNAL_DIV_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ecache.h", "content": "#ifndef JEMALLOC_INTERNAL_ECACHE_H\n#define JEMALLOC_INTERNAL_ECACHE_H\n\n#include \"jemalloc/internal/eset.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/mutex.h\"\n\ntypedef struct ecache_s ecache_t;\nstruct ecache_s {\n\tmalloc_mutex_t mtx;\n\teset_t eset;\n\teset_t guarded_eset;\n\t/* All stored extents must be in the same state. */\n\textent_state_t state;\n\t/* The index of the ehooks the ecache is associated with. */\n\tunsigned ind;\n\t/*\n\t * If true, delay coalescing until eviction; otherwise coalesce during\n\t * deallocation.\n\t */\n\tbool delay_coalesce;\n};\n\nstatic inline size_t\necache_npages_get(ecache_t *ecache) {\n\treturn eset_npages_get(&ecache->eset) +\n\t eset_npages_get(&ecache->guarded_eset);\n}\n\n/* Get the number of extents in the given page size index. */\nstatic inline size_t\necache_nextents_get(ecache_t *ecache, pszind_t ind) {\n\treturn eset_nextents_get(&ecache->eset, ind) +\n\t eset_nextents_get(&ecache->guarded_eset, ind);\n}\n\n/* Get the sum total bytes of the extents in the given page size index. */\nstatic inline size_t\necache_nbytes_get(ecache_t *ecache, pszind_t ind) {\n\treturn eset_nbytes_get(&ecache->eset, ind) +\n\t eset_nbytes_get(&ecache->guarded_eset, ind);\n}\n\nstatic inline unsigned\necache_ind_get(ecache_t *ecache) {\n\treturn ecache->ind;\n}\n\nbool ecache_init(tsdn_t *tsdn, ecache_t *ecache, extent_state_t state,\n unsigned ind, bool delay_coalesce);\nvoid ecache_prefork(tsdn_t *tsdn, ecache_t *ecache);\nvoid ecache_postfork_parent(tsdn_t *tsdn, ecache_t *ecache);\nvoid ecache_postfork_child(tsdn_t *tsdn, ecache_t *ecache);\n\n#endif /* JEMALLOC_INTERNAL_ECACHE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/edata.h", "content": "#ifndef JEMALLOC_INTERNAL_EDATA_H\n#define JEMALLOC_INTERNAL_EDATA_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/bin_info.h\"\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/hpdata.h\"\n#include \"jemalloc/internal/nstime.h\"\n#include \"jemalloc/internal/ph.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/slab_data.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/typed_list.h\"\n\n/*\n * sizeof(edata_t) is 128 bytes on 64-bit architectures. Ensure the alignment\n * to free up the low bits in the rtree leaf.\n */\n#define EDATA_ALIGNMENT 128\n\nenum extent_state_e {\n\textent_state_active = 0,\n\textent_state_dirty = 1,\n\textent_state_muzzy = 2,\n\textent_state_retained = 3,\n\textent_state_transition = 4, /* States below are intermediate. */\n\textent_state_merging = 5,\n\textent_state_max = 5 /* Sanity checking only. */\n};\ntypedef enum extent_state_e extent_state_t;\n\nenum extent_head_state_e {\n\tEXTENT_NOT_HEAD,\n\tEXTENT_IS_HEAD /* See comments in ehooks_default_merge_impl(). */\n};\ntypedef enum extent_head_state_e extent_head_state_t;\n\n/*\n * Which implementation of the page allocator interface, (PAI, defined in\n * pai.h) owns the given extent?\n */\nenum extent_pai_e {\n\tEXTENT_PAI_PAC = 0,\n\tEXTENT_PAI_HPA = 1\n};\ntypedef enum extent_pai_e extent_pai_t;\n\nstruct e_prof_info_s {\n\t/* Time when this was allocated. */\n\tnstime_t\te_prof_alloc_time;\n\t/* Allocation request size. */\n\tsize_t\t\te_prof_alloc_size;\n\t/* Points to a prof_tctx_t. */\n\tatomic_p_t\te_prof_tctx;\n\t/*\n\t * Points to a prof_recent_t for the allocation; NULL\n\t * means the recent allocation record no longer exists.\n\t * Protected by prof_recent_alloc_mtx.\n\t */\n\tatomic_p_t\te_prof_recent_alloc;\n};\ntypedef struct e_prof_info_s e_prof_info_t;\n\n/*\n * The information about a particular edata that lives in an emap. Space is\n * more precious there (the information, plus the edata pointer, has to live in\n * a 64-bit word if we want to enable a packed representation.\n *\n * There are two things that are special about the information here:\n * - It's quicker to access. You have one fewer pointer hop, since finding the\n * edata_t associated with an item always requires accessing the rtree leaf in\n * which this data is stored.\n * - It can be read unsynchronized, and without worrying about lifetime issues.\n */\ntypedef struct edata_map_info_s edata_map_info_t;\nstruct edata_map_info_s {\n\tbool slab;\n\tszind_t szind;\n};\n\ntypedef struct edata_cmp_summary_s edata_cmp_summary_t;\nstruct edata_cmp_summary_s {\n\tuint64_t sn;\n\tuintptr_t addr;\n};\n\n/* Extent (span of pages). Use accessor functions for e_* fields. */\ntypedef struct edata_s edata_t;\nph_structs(edata_avail, edata_t);\nph_structs(edata_heap, edata_t);\nstruct edata_s {\n\t/*\n\t * Bitfield containing several fields:\n\t *\n\t * a: arena_ind\n\t * b: slab\n\t * c: committed\n\t * p: pai\n\t * z: zeroed\n\t * g: guarded\n\t * t: state\n\t * i: szind\n\t * f: nfree\n\t * s: bin_shard\n\t *\n\t * 00000000 ... 0000ssss ssffffff ffffiiii iiiitttg zpcbaaaa aaaaaaaa\n\t *\n\t * arena_ind: Arena from which this extent came, or all 1 bits if\n\t * unassociated.\n\t *\n\t * slab: The slab flag indicates whether the extent is used for a slab\n\t * of small regions. This helps differentiate small size classes,\n\t * and it indicates whether interior pointers can be looked up via\n\t * iealloc().\n\t *\n\t * committed: The committed flag indicates whether physical memory is\n\t * committed to the extent, whether explicitly or implicitly\n\t * as on a system that overcommits and satisfies physical\n\t * memory needs on demand via soft page faults.\n\t *\n\t * pai: The pai flag is an extent_pai_t.\n\t *\n\t * zeroed: The zeroed flag is used by extent recycling code to track\n\t * whether memory is zero-filled.\n\t *\n\t * guarded: The guarded flag is use by the sanitizer to track whether\n\t * the extent has page guards around it.\n\t *\n\t * state: The state flag is an extent_state_t.\n\t *\n\t * szind: The szind flag indicates usable size class index for\n\t * allocations residing in this extent, regardless of whether the\n\t * extent is a slab. Extent size and usable size often differ\n\t * even for non-slabs, either due to sz_large_pad or promotion of\n\t * sampled small regions.\n\t *\n\t * nfree: Number of free regions in slab.\n\t *\n\t * bin_shard: the shard of the bin from which this extent came.\n\t */\n\tuint64_t\t\te_bits;\n#define MASK(CURRENT_FIELD_WIDTH, CURRENT_FIELD_SHIFT) ((((((uint64_t)0x1U) << (CURRENT_FIELD_WIDTH)) - 1)) << (CURRENT_FIELD_SHIFT))\n\n#define EDATA_BITS_ARENA_WIDTH MALLOCX_ARENA_BITS\n#define EDATA_BITS_ARENA_SHIFT 0\n#define EDATA_BITS_ARENA_MASK MASK(EDATA_BITS_ARENA_WIDTH, EDATA_BITS_ARENA_SHIFT)\n\n#define EDATA_BITS_SLAB_WIDTH 1\n#define EDATA_BITS_SLAB_SHIFT (EDATA_BITS_ARENA_WIDTH + EDATA_BITS_ARENA_SHIFT)\n#define EDATA_BITS_SLAB_MASK MASK(EDATA_BITS_SLAB_WIDTH, EDATA_BITS_SLAB_SHIFT)\n\n#define EDATA_BITS_COMMITTED_WIDTH 1\n#define EDATA_BITS_COMMITTED_SHIFT (EDATA_BITS_SLAB_WIDTH + EDATA_BITS_SLAB_SHIFT)\n#define EDATA_BITS_COMMITTED_MASK MASK(EDATA_BITS_COMMITTED_WIDTH, EDATA_BITS_COMMITTED_SHIFT)\n\n#define EDATA_BITS_PAI_WIDTH 1\n#define EDATA_BITS_PAI_SHIFT (EDATA_BITS_COMMITTED_WIDTH + EDATA_BITS_COMMITTED_SHIFT)\n#define EDATA_BITS_PAI_MASK MASK(EDATA_BITS_PAI_WIDTH, EDATA_BITS_PAI_SHIFT)\n\n#define EDATA_BITS_ZEROED_WIDTH 1\n#define EDATA_BITS_ZEROED_SHIFT (EDATA_BITS_PAI_WIDTH + EDATA_BITS_PAI_SHIFT)\n#define EDATA_BITS_ZEROED_MASK MASK(EDATA_BITS_ZEROED_WIDTH, EDATA_BITS_ZEROED_SHIFT)\n\n#define EDATA_BITS_GUARDED_WIDTH 1\n#define EDATA_BITS_GUARDED_SHIFT (EDATA_BITS_ZEROED_WIDTH + EDATA_BITS_ZEROED_SHIFT)\n#define EDATA_BITS_GUARDED_MASK MASK(EDATA_BITS_GUARDED_WIDTH, EDATA_BITS_GUARDED_SHIFT)\n\n#define EDATA_BITS_STATE_WIDTH 3\n#define EDATA_BITS_STATE_SHIFT (EDATA_BITS_GUARDED_WIDTH + EDATA_BITS_GUARDED_SHIFT)\n#define EDATA_BITS_STATE_MASK MASK(EDATA_BITS_STATE_WIDTH, EDATA_BITS_STATE_SHIFT)\n\n#define EDATA_BITS_SZIND_WIDTH LG_CEIL(SC_NSIZES)\n#define EDATA_BITS_SZIND_SHIFT (EDATA_BITS_STATE_WIDTH + EDATA_BITS_STATE_SHIFT)\n#define EDATA_BITS_SZIND_MASK MASK(EDATA_BITS_SZIND_WIDTH, EDATA_BITS_SZIND_SHIFT)\n\n#define EDATA_BITS_NFREE_WIDTH (SC_LG_SLAB_MAXREGS + 1)\n#define EDATA_BITS_NFREE_SHIFT (EDATA_BITS_SZIND_WIDTH + EDATA_BITS_SZIND_SHIFT)\n#define EDATA_BITS_NFREE_MASK MASK(EDATA_BITS_NFREE_WIDTH, EDATA_BITS_NFREE_SHIFT)\n\n#define EDATA_BITS_BINSHARD_WIDTH 6\n#define EDATA_BITS_BINSHARD_SHIFT (EDATA_BITS_NFREE_WIDTH + EDATA_BITS_NFREE_SHIFT)\n#define EDATA_BITS_BINSHARD_MASK MASK(EDATA_BITS_BINSHARD_WIDTH, EDATA_BITS_BINSHARD_SHIFT)\n\n#define EDATA_BITS_IS_HEAD_WIDTH 1\n#define EDATA_BITS_IS_HEAD_SHIFT (EDATA_BITS_BINSHARD_WIDTH + EDATA_BITS_BINSHARD_SHIFT)\n#define EDATA_BITS_IS_HEAD_MASK MASK(EDATA_BITS_IS_HEAD_WIDTH, EDATA_BITS_IS_HEAD_SHIFT)\n\n\t/* Pointer to the extent that this structure is responsible for. */\n\tvoid\t\t\t*e_addr;\n\n\tunion {\n\t\t/*\n\t\t * Extent size and serial number associated with the extent\n\t\t * structure (different than the serial number for the extent at\n\t\t * e_addr).\n\t\t *\n\t\t * ssssssss [...] ssssssss ssssnnnn nnnnnnnn\n\t\t */\n\t\tsize_t\t\t\te_size_esn;\n\t#define EDATA_SIZE_MASK\t((size_t)~(PAGE-1))\n\t#define EDATA_ESN_MASK\t\t((size_t)PAGE-1)\n\t\t/* Base extent size, which may not be a multiple of PAGE. */\n\t\tsize_t\t\t\te_bsize;\n\t};\n\n\t/*\n\t * If this edata is a user allocation from an HPA, it comes out of some\n\t * pageslab (we don't yet support huegpage allocations that don't fit\n\t * into pageslabs). This tracks it.\n\t */\n\thpdata_t *e_ps;\n\n\t/*\n\t * Serial number. These are not necessarily unique; splitting an extent\n\t * results in two extents with the same serial number.\n\t */\n\tuint64_t e_sn;\n\n\tunion {\n\t\t/*\n\t\t * List linkage used when the edata_t is active; either in\n\t\t * arena's large allocations or bin_t's slabs_full.\n\t\t */\n\t\tql_elm(edata_t)\tql_link_active;\n\t\t/*\n\t\t * Pairing heap linkage. Used whenever the extent is inactive\n\t\t * (in the page allocators), or when it is active and in\n\t\t * slabs_nonfull, or when the edata_t is unassociated with an\n\t\t * extent and sitting in an edata_cache.\n\t\t */\n\t\tunion {\n\t\t\tedata_heap_link_t heap_link;\n\t\t\tedata_avail_link_t avail_link;\n\t\t};\n\t};\n\n\tunion {\n\t\t/*\n\t\t * List linkage used when the extent is inactive:\n\t\t * - Stashed dirty extents\n\t\t * - Ecache LRU functionality.\n\t\t */\n\t\tql_elm(edata_t) ql_link_inactive;\n\t\t/* Small region slab metadata. */\n\t\tslab_data_t\te_slab_data;\n\n\t\t/* Profiling data, used for large objects. */\n\t\te_prof_info_t\te_prof_info;\n\t};\n};\n\nTYPED_LIST(edata_list_active, edata_t, ql_link_active)\nTYPED_LIST(edata_list_inactive, edata_t, ql_link_inactive)\n\nstatic inline unsigned\nedata_arena_ind_get(const edata_t *edata) {\n\tunsigned arena_ind = (unsigned)((edata->e_bits &\n\t EDATA_BITS_ARENA_MASK) >> EDATA_BITS_ARENA_SHIFT);\n\tassert(arena_ind < MALLOCX_ARENA_LIMIT);\n\n\treturn arena_ind;\n}\n\nstatic inline szind_t\nedata_szind_get_maybe_invalid(const edata_t *edata) {\n\tszind_t szind = (szind_t)((edata->e_bits & EDATA_BITS_SZIND_MASK) >>\n\t EDATA_BITS_SZIND_SHIFT);\n\tassert(szind <= SC_NSIZES);\n\treturn szind;\n}\n\nstatic inline szind_t\nedata_szind_get(const edata_t *edata) {\n\tszind_t szind = edata_szind_get_maybe_invalid(edata);\n\tassert(szind < SC_NSIZES); /* Never call when \"invalid\". */\n\treturn szind;\n}\n\nstatic inline size_t\nedata_usize_get(const edata_t *edata) {\n\treturn sz_index2size(edata_szind_get(edata));\n}\n\nstatic inline unsigned\nedata_binshard_get(const edata_t *edata) {\n\tunsigned binshard = (unsigned)((edata->e_bits &\n\t EDATA_BITS_BINSHARD_MASK) >> EDATA_BITS_BINSHARD_SHIFT);\n\tassert(binshard < bin_infos[edata_szind_get(edata)].n_shards);\n\treturn binshard;\n}\n\nstatic inline uint64_t\nedata_sn_get(const edata_t *edata) {\n\treturn edata->e_sn;\n}\n\nstatic inline extent_state_t\nedata_state_get(const edata_t *edata) {\n\treturn (extent_state_t)((edata->e_bits & EDATA_BITS_STATE_MASK) >>\n\t EDATA_BITS_STATE_SHIFT);\n}\n\nstatic inline bool\nedata_guarded_get(const edata_t *edata) {\n\treturn (bool)((edata->e_bits & EDATA_BITS_GUARDED_MASK) >>\n\t EDATA_BITS_GUARDED_SHIFT);\n}\n\nstatic inline bool\nedata_zeroed_get(const edata_t *edata) {\n\treturn (bool)((edata->e_bits & EDATA_BITS_ZEROED_MASK) >>\n\t EDATA_BITS_ZEROED_SHIFT);\n}\n\nstatic inline bool\nedata_committed_get(const edata_t *edata) {\n\treturn (bool)((edata->e_bits & EDATA_BITS_COMMITTED_MASK) >>\n\t EDATA_BITS_COMMITTED_SHIFT);\n}\n\nstatic inline extent_pai_t\nedata_pai_get(const edata_t *edata) {\n\treturn (extent_pai_t)((edata->e_bits & EDATA_BITS_PAI_MASK) >>\n\t EDATA_BITS_PAI_SHIFT);\n}\n\nstatic inline bool\nedata_slab_get(const edata_t *edata) {\n\treturn (bool)((edata->e_bits & EDATA_BITS_SLAB_MASK) >>\n\t EDATA_BITS_SLAB_SHIFT);\n}\n\nstatic inline unsigned\nedata_nfree_get(const edata_t *edata) {\n\tassert(edata_slab_get(edata));\n\treturn (unsigned)((edata->e_bits & EDATA_BITS_NFREE_MASK) >>\n\t EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void *\nedata_base_get(const edata_t *edata) {\n\tassert(edata->e_addr == PAGE_ADDR2BASE(edata->e_addr) ||\n\t !edata_slab_get(edata));\n\treturn PAGE_ADDR2BASE(edata->e_addr);\n}\n\nstatic inline void *\nedata_addr_get(const edata_t *edata) {\n\tassert(edata->e_addr == PAGE_ADDR2BASE(edata->e_addr) ||\n\t !edata_slab_get(edata));\n\treturn edata->e_addr;\n}\n\nstatic inline size_t\nedata_size_get(const edata_t *edata) {\n\treturn (edata->e_size_esn & EDATA_SIZE_MASK);\n}\n\nstatic inline size_t\nedata_esn_get(const edata_t *edata) {\n\treturn (edata->e_size_esn & EDATA_ESN_MASK);\n}\n\nstatic inline size_t\nedata_bsize_get(const edata_t *edata) {\n\treturn edata->e_bsize;\n}\n\nstatic inline hpdata_t *\nedata_ps_get(const edata_t *edata) {\n\tassert(edata_pai_get(edata) == EXTENT_PAI_HPA);\n\treturn edata->e_ps;\n}\n\nstatic inline void *\nedata_before_get(const edata_t *edata) {\n\treturn (void *)((uintptr_t)edata_base_get(edata) - PAGE);\n}\n\nstatic inline void *\nedata_last_get(const edata_t *edata) {\n\treturn (void *)((uintptr_t)edata_base_get(edata) +\n\t edata_size_get(edata) - PAGE);\n}\n\nstatic inline void *\nedata_past_get(const edata_t *edata) {\n\treturn (void *)((uintptr_t)edata_base_get(edata) +\n\t edata_size_get(edata));\n}\n\nstatic inline slab_data_t *\nedata_slab_data_get(edata_t *edata) {\n\tassert(edata_slab_get(edata));\n\treturn &edata->e_slab_data;\n}\n\nstatic inline const slab_data_t *\nedata_slab_data_get_const(const edata_t *edata) {\n\tassert(edata_slab_get(edata));\n\treturn &edata->e_slab_data;\n}\n\nstatic inline prof_tctx_t *\nedata_prof_tctx_get(const edata_t *edata) {\n\treturn (prof_tctx_t *)atomic_load_p(&edata->e_prof_info.e_prof_tctx,\n\t ATOMIC_ACQUIRE);\n}\n\nstatic inline const nstime_t *\nedata_prof_alloc_time_get(const edata_t *edata) {\n\treturn &edata->e_prof_info.e_prof_alloc_time;\n}\n\nstatic inline size_t\nedata_prof_alloc_size_get(const edata_t *edata) {\n\treturn edata->e_prof_info.e_prof_alloc_size;\n}\n\nstatic inline prof_recent_t *\nedata_prof_recent_alloc_get_dont_call_directly(const edata_t *edata) {\n\treturn (prof_recent_t *)atomic_load_p(\n\t &edata->e_prof_info.e_prof_recent_alloc, ATOMIC_RELAXED);\n}\n\nstatic inline void\nedata_arena_ind_set(edata_t *edata, unsigned arena_ind) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_ARENA_MASK) |\n\t ((uint64_t)arena_ind << EDATA_BITS_ARENA_SHIFT);\n}\n\nstatic inline void\nedata_binshard_set(edata_t *edata, unsigned binshard) {\n\t/* The assertion assumes szind is set already. */\n\tassert(binshard < bin_infos[edata_szind_get(edata)].n_shards);\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_BINSHARD_MASK) |\n\t ((uint64_t)binshard << EDATA_BITS_BINSHARD_SHIFT);\n}\n\nstatic inline void\nedata_addr_set(edata_t *edata, void *addr) {\n\tedata->e_addr = addr;\n}\n\nstatic inline void\nedata_size_set(edata_t *edata, size_t size) {\n\tassert((size & ~EDATA_SIZE_MASK) == 0);\n\tedata->e_size_esn = size | (edata->e_size_esn & ~EDATA_SIZE_MASK);\n}\n\nstatic inline void\nedata_esn_set(edata_t *edata, size_t esn) {\n\tedata->e_size_esn = (edata->e_size_esn & ~EDATA_ESN_MASK) | (esn &\n\t EDATA_ESN_MASK);\n}\n\nstatic inline void\nedata_bsize_set(edata_t *edata, size_t bsize) {\n\tedata->e_bsize = bsize;\n}\n\nstatic inline void\nedata_ps_set(edata_t *edata, hpdata_t *ps) {\n\tassert(edata_pai_get(edata) == EXTENT_PAI_HPA);\n\tedata->e_ps = ps;\n}\n\nstatic inline void\nedata_szind_set(edata_t *edata, szind_t szind) {\n\tassert(szind <= SC_NSIZES); /* SC_NSIZES means \"invalid\". */\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_SZIND_MASK) |\n\t ((uint64_t)szind << EDATA_BITS_SZIND_SHIFT);\n}\n\nstatic inline void\nedata_nfree_set(edata_t *edata, unsigned nfree) {\n\tassert(edata_slab_get(edata));\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_NFREE_MASK) |\n\t ((uint64_t)nfree << EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void\nedata_nfree_binshard_set(edata_t *edata, unsigned nfree, unsigned binshard) {\n\t/* The assertion assumes szind is set already. */\n\tassert(binshard < bin_infos[edata_szind_get(edata)].n_shards);\n\tedata->e_bits = (edata->e_bits &\n\t (~EDATA_BITS_NFREE_MASK & ~EDATA_BITS_BINSHARD_MASK)) |\n\t ((uint64_t)binshard << EDATA_BITS_BINSHARD_SHIFT) |\n\t ((uint64_t)nfree << EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void\nedata_nfree_inc(edata_t *edata) {\n\tassert(edata_slab_get(edata));\n\tedata->e_bits += ((uint64_t)1U << EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void\nedata_nfree_dec(edata_t *edata) {\n\tassert(edata_slab_get(edata));\n\tedata->e_bits -= ((uint64_t)1U << EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void\nedata_nfree_sub(edata_t *edata, uint64_t n) {\n\tassert(edata_slab_get(edata));\n\tedata->e_bits -= (n << EDATA_BITS_NFREE_SHIFT);\n}\n\nstatic inline void\nedata_sn_set(edata_t *edata, uint64_t sn) {\n\tedata->e_sn = sn;\n}\n\nstatic inline void\nedata_state_set(edata_t *edata, extent_state_t state) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_STATE_MASK) |\n\t ((uint64_t)state << EDATA_BITS_STATE_SHIFT);\n}\n\nstatic inline void\nedata_guarded_set(edata_t *edata, bool guarded) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_GUARDED_MASK) |\n\t ((uint64_t)guarded << EDATA_BITS_GUARDED_SHIFT);\n}\n\nstatic inline void\nedata_zeroed_set(edata_t *edata, bool zeroed) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_ZEROED_MASK) |\n\t ((uint64_t)zeroed << EDATA_BITS_ZEROED_SHIFT);\n}\n\nstatic inline void\nedata_committed_set(edata_t *edata, bool committed) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_COMMITTED_MASK) |\n\t ((uint64_t)committed << EDATA_BITS_COMMITTED_SHIFT);\n}\n\nstatic inline void\nedata_pai_set(edata_t *edata, extent_pai_t pai) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_PAI_MASK) |\n\t ((uint64_t)pai << EDATA_BITS_PAI_SHIFT);\n}\n\nstatic inline void\nedata_slab_set(edata_t *edata, bool slab) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_SLAB_MASK) |\n\t ((uint64_t)slab << EDATA_BITS_SLAB_SHIFT);\n}\n\nstatic inline void\nedata_prof_tctx_set(edata_t *edata, prof_tctx_t *tctx) {\n\tatomic_store_p(&edata->e_prof_info.e_prof_tctx, tctx, ATOMIC_RELEASE);\n}\n\nstatic inline void\nedata_prof_alloc_time_set(edata_t *edata, nstime_t *t) {\n\tnstime_copy(&edata->e_prof_info.e_prof_alloc_time, t);\n}\n\nstatic inline void\nedata_prof_alloc_size_set(edata_t *edata, size_t size) {\n\tedata->e_prof_info.e_prof_alloc_size = size;\n}\n\nstatic inline void\nedata_prof_recent_alloc_set_dont_call_directly(edata_t *edata,\n prof_recent_t *recent_alloc) {\n\tatomic_store_p(&edata->e_prof_info.e_prof_recent_alloc, recent_alloc,\n\t ATOMIC_RELAXED);\n}\n\nstatic inline bool\nedata_is_head_get(edata_t *edata) {\n\treturn (bool)((edata->e_bits & EDATA_BITS_IS_HEAD_MASK) >>\n\t EDATA_BITS_IS_HEAD_SHIFT);\n}\n\nstatic inline void\nedata_is_head_set(edata_t *edata, bool is_head) {\n\tedata->e_bits = (edata->e_bits & ~EDATA_BITS_IS_HEAD_MASK) |\n\t ((uint64_t)is_head << EDATA_BITS_IS_HEAD_SHIFT);\n}\n\nstatic inline bool\nedata_state_in_transition(extent_state_t state) {\n\treturn state >= extent_state_transition;\n}\n\n/*\n * Because this function is implemented as a sequence of bitfield modifications,\n * even though each individual bit is properly initialized, we technically read\n * uninitialized data within it. This is mostly fine, since most callers get\n * their edatas from zeroing sources, but callers who make stack edata_ts need\n * to manually zero them.\n */\nstatic inline void\nedata_init(edata_t *edata, unsigned arena_ind, void *addr, size_t size,\n bool slab, szind_t szind, uint64_t sn, extent_state_t state, bool zeroed,\n bool committed, extent_pai_t pai, extent_head_state_t is_head) {\n\tassert(addr == PAGE_ADDR2BASE(addr) || !slab);\n\n\tedata_arena_ind_set(edata, arena_ind);\n\tedata_addr_set(edata, addr);\n\tedata_size_set(edata, size);\n\tedata_slab_set(edata, slab);\n\tedata_szind_set(edata, szind);\n\tedata_sn_set(edata, sn);\n\tedata_state_set(edata, state);\n\tedata_guarded_set(edata, false);\n\tedata_zeroed_set(edata, zeroed);\n\tedata_committed_set(edata, committed);\n\tedata_pai_set(edata, pai);\n\tedata_is_head_set(edata, is_head == EXTENT_IS_HEAD);\n\tif (config_prof) {\n\t\tedata_prof_tctx_set(edata, NULL);\n\t}\n}\n\nstatic inline void\nedata_binit(edata_t *edata, void *addr, size_t bsize, uint64_t sn) {\n\tedata_arena_ind_set(edata, (1U << MALLOCX_ARENA_BITS) - 1);\n\tedata_addr_set(edata, addr);\n\tedata_bsize_set(edata, bsize);\n\tedata_slab_set(edata, false);\n\tedata_szind_set(edata, SC_NSIZES);\n\tedata_sn_set(edata, sn);\n\tedata_state_set(edata, extent_state_active);\n\tedata_guarded_set(edata, false);\n\tedata_zeroed_set(edata, true);\n\tedata_committed_set(edata, true);\n\t/*\n\t * This isn't strictly true, but base allocated extents never get\n\t * deallocated and can't be looked up in the emap, but no sense in\n\t * wasting a state bit to encode this fact.\n\t */\n\tedata_pai_set(edata, EXTENT_PAI_PAC);\n}\n\nstatic inline int\nedata_esn_comp(const edata_t *a, const edata_t *b) {\n\tsize_t a_esn = edata_esn_get(a);\n\tsize_t b_esn = edata_esn_get(b);\n\n\treturn (a_esn > b_esn) - (a_esn < b_esn);\n}\n\nstatic inline int\nedata_ead_comp(const edata_t *a, const edata_t *b) {\n\tuintptr_t a_eaddr = (uintptr_t)a;\n\tuintptr_t b_eaddr = (uintptr_t)b;\n\n\treturn (a_eaddr > b_eaddr) - (a_eaddr < b_eaddr);\n}\n\nstatic inline edata_cmp_summary_t\nedata_cmp_summary_get(const edata_t *edata) {\n\treturn (edata_cmp_summary_t){edata_sn_get(edata),\n\t\t(uintptr_t)edata_addr_get(edata)};\n}\n\nstatic inline int\nedata_cmp_summary_comp(edata_cmp_summary_t a, edata_cmp_summary_t b) {\n\tint ret;\n\tret = (a.sn > b.sn) - (a.sn < b.sn);\n\tif (ret != 0) {\n\t\treturn ret;\n\t}\n\tret = (a.addr > b.addr) - (a.addr < b.addr);\n\treturn ret;\n}\n\nstatic inline int\nedata_snad_comp(const edata_t *a, const edata_t *b) {\n\tedata_cmp_summary_t a_cmp = edata_cmp_summary_get(a);\n\tedata_cmp_summary_t b_cmp = edata_cmp_summary_get(b);\n\n\treturn edata_cmp_summary_comp(a_cmp, b_cmp);\n}\n\nstatic inline int\nedata_esnead_comp(const edata_t *a, const edata_t *b) {\n\tint ret;\n\n\tret = edata_esn_comp(a, b);\n\tif (ret != 0) {\n\t\treturn ret;\n\t}\n\n\tret = edata_ead_comp(a, b);\n\treturn ret;\n}\n\nph_proto(, edata_avail, edata_t)\nph_proto(, edata_heap, edata_t)\n\n#endif /* JEMALLOC_INTERNAL_EDATA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/edata_cache.h", "content": "#ifndef JEMALLOC_INTERNAL_EDATA_CACHE_H\n#define JEMALLOC_INTERNAL_EDATA_CACHE_H\n\n#include \"jemalloc/internal/base.h\"\n\n/* For tests only. */\n#define EDATA_CACHE_FAST_FILL 4\n\n/*\n * A cache of edata_t structures allocated via base_alloc_edata (as opposed to\n * the underlying extents they describe). The contents of returned edata_t\n * objects are garbage and cannot be relied upon.\n */\n\ntypedef struct edata_cache_s edata_cache_t;\nstruct edata_cache_s {\n\tedata_avail_t avail;\n\tatomic_zu_t count;\n\tmalloc_mutex_t mtx;\n\tbase_t *base;\n};\n\nbool edata_cache_init(edata_cache_t *edata_cache, base_t *base);\nedata_t *edata_cache_get(tsdn_t *tsdn, edata_cache_t *edata_cache);\nvoid edata_cache_put(tsdn_t *tsdn, edata_cache_t *edata_cache, edata_t *edata);\n\nvoid edata_cache_prefork(tsdn_t *tsdn, edata_cache_t *edata_cache);\nvoid edata_cache_postfork_parent(tsdn_t *tsdn, edata_cache_t *edata_cache);\nvoid edata_cache_postfork_child(tsdn_t *tsdn, edata_cache_t *edata_cache);\n\n/*\n * An edata_cache_small is like an edata_cache, but it relies on external\n * synchronization and avoids first-fit strategies.\n */\n\ntypedef struct edata_cache_fast_s edata_cache_fast_t;\nstruct edata_cache_fast_s {\n\tedata_list_inactive_t list;\n\tedata_cache_t *fallback;\n\tbool disabled;\n};\n\nvoid edata_cache_fast_init(edata_cache_fast_t *ecs, edata_cache_t *fallback);\nedata_t *edata_cache_fast_get(tsdn_t *tsdn, edata_cache_fast_t *ecs);\nvoid edata_cache_fast_put(tsdn_t *tsdn, edata_cache_fast_t *ecs,\n edata_t *edata);\nvoid edata_cache_fast_disable(tsdn_t *tsdn, edata_cache_fast_t *ecs);\n\n#endif /* JEMALLOC_INTERNAL_EDATA_CACHE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ehooks.h", "content": "#ifndef JEMALLOC_INTERNAL_EHOOKS_H\n#define JEMALLOC_INTERNAL_EHOOKS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n\n/*\n * This module is the internal interface to the extent hooks (both\n * user-specified and external). Eventually, this will give us the flexibility\n * to use multiple different versions of user-visible extent-hook APIs under a\n * single user interface.\n *\n * Current API expansions (not available to anyone but the default hooks yet):\n * - Head state tracking. Hooks can decide whether or not to merge two\n * extents based on whether or not one of them is the head (i.e. was\n * allocated on its own). The later extent loses its \"head\" status.\n */\n\nextern const extent_hooks_t ehooks_default_extent_hooks;\n\ntypedef struct ehooks_s ehooks_t;\nstruct ehooks_s {\n\t/*\n\t * The user-visible id that goes with the ehooks (i.e. that of the base\n\t * they're a part of, the associated arena's index within the arenas\n\t * array).\n\t */\n\tunsigned ind;\n\t/* Logically an extent_hooks_t *. */\n\tatomic_p_t ptr;\n};\n\nextern const extent_hooks_t ehooks_default_extent_hooks;\n\n/*\n * These are not really part of the public API. Each hook has a fast-path for\n * the default-hooks case that can avoid various small inefficiencies:\n * - Forgetting tsd and then calling tsd_get within the hook.\n * - Getting more state than necessary out of the extent_t.\n * - Doing arena_ind -> arena -> arena_ind lookups.\n * By making the calls to these functions visible to the compiler, it can move\n * those extra bits of computation down below the fast-paths where they get ignored.\n */\nvoid *ehooks_default_alloc_impl(tsdn_t *tsdn, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, unsigned arena_ind);\nbool ehooks_default_dalloc_impl(void *addr, size_t size);\nvoid ehooks_default_destroy_impl(void *addr, size_t size);\nbool ehooks_default_commit_impl(void *addr, size_t offset, size_t length);\nbool ehooks_default_decommit_impl(void *addr, size_t offset, size_t length);\n#ifdef PAGES_CAN_PURGE_LAZY\nbool ehooks_default_purge_lazy_impl(void *addr, size_t offset, size_t length);\n#endif\n#ifdef PAGES_CAN_PURGE_FORCED\nbool ehooks_default_purge_forced_impl(void *addr, size_t offset, size_t length);\n#endif\nbool ehooks_default_split_impl();\n/*\n * Merge is the only default extent hook we declare -- see the comment in\n * ehooks_merge.\n */\nbool ehooks_default_merge(extent_hooks_t *extent_hooks, void *addr_a,\n size_t size_a, void *addr_b, size_t size_b, bool committed,\n unsigned arena_ind);\nbool ehooks_default_merge_impl(tsdn_t *tsdn, void *addr_a, void *addr_b);\nvoid ehooks_default_zero_impl(void *addr, size_t size);\nvoid ehooks_default_guard_impl(void *guard1, void *guard2);\nvoid ehooks_default_unguard_impl(void *guard1, void *guard2);\n\n/*\n * We don't officially support reentrancy from wtihin the extent hooks. But\n * various people who sit within throwing distance of the jemalloc team want\n * that functionality in certain limited cases. The default reentrancy guards\n * assert that we're not reentrant from a0 (since it's the bootstrap arena,\n * where reentrant allocations would be redirected), which we would incorrectly\n * trigger in cases where a0 has extent hooks (those hooks themselves can't be\n * reentrant, then, but there are reasonable uses for such functionality, like\n * putting internal metadata on hugepages). Therefore, we use the raw\n * reentrancy guards.\n *\n * Eventually, we need to think more carefully about whether and where we\n * support allocating from within extent hooks (and what that means for things\n * like profiling, stats collection, etc.), and document what the guarantee is.\n */\nstatic inline void\nehooks_pre_reentrancy(tsdn_t *tsdn) {\n\ttsd_t *tsd = tsdn_null(tsdn) ? tsd_fetch() : tsdn_tsd(tsdn);\n\ttsd_pre_reentrancy_raw(tsd);\n}\n\nstatic inline void\nehooks_post_reentrancy(tsdn_t *tsdn) {\n\ttsd_t *tsd = tsdn_null(tsdn) ? tsd_fetch() : tsdn_tsd(tsdn);\n\ttsd_post_reentrancy_raw(tsd);\n}\n\n/* Beginning of the public API. */\nvoid ehooks_init(ehooks_t *ehooks, extent_hooks_t *extent_hooks, unsigned ind);\n\nstatic inline unsigned\nehooks_ind_get(const ehooks_t *ehooks) {\n\treturn ehooks->ind;\n}\n\nstatic inline void\nehooks_set_extent_hooks_ptr(ehooks_t *ehooks, extent_hooks_t *extent_hooks) {\n\tatomic_store_p(&ehooks->ptr, extent_hooks, ATOMIC_RELEASE);\n}\n\nstatic inline extent_hooks_t *\nehooks_get_extent_hooks_ptr(ehooks_t *ehooks) {\n\treturn (extent_hooks_t *)atomic_load_p(&ehooks->ptr, ATOMIC_ACQUIRE);\n}\n\nstatic inline bool\nehooks_are_default(ehooks_t *ehooks) {\n\treturn ehooks_get_extent_hooks_ptr(ehooks) ==\n\t &ehooks_default_extent_hooks;\n}\n\n/*\n * In some cases, a caller needs to allocate resources before attempting to call\n * a hook. If that hook is doomed to fail, this is wasteful. We therefore\n * include some checks for such cases.\n */\nstatic inline bool\nehooks_dalloc_will_fail(ehooks_t *ehooks) {\n\tif (ehooks_are_default(ehooks)) {\n\t\treturn opt_retain;\n\t} else {\n\t\treturn ehooks_get_extent_hooks_ptr(ehooks)->dalloc == NULL;\n\t}\n}\n\nstatic inline bool\nehooks_split_will_fail(ehooks_t *ehooks) {\n\treturn ehooks_get_extent_hooks_ptr(ehooks)->split == NULL;\n}\n\nstatic inline bool\nehooks_merge_will_fail(ehooks_t *ehooks) {\n\treturn ehooks_get_extent_hooks_ptr(ehooks)->merge == NULL;\n}\n\nstatic inline bool\nehooks_guard_will_fail(ehooks_t *ehooks) {\n\t/*\n\t * Before the guard hooks are officially introduced, limit the use to\n\t * the default hooks only.\n\t */\n\treturn !ehooks_are_default(ehooks);\n}\n\n/*\n * Some hooks are required to return zeroed memory in certain situations. In\n * debug mode, we do some heuristic checks that they did what they were supposed\n * to.\n *\n * This isn't really ehooks-specific (i.e. anyone can check for zeroed memory).\n * But incorrect zero information indicates an ehook bug.\n */\nstatic inline void\nehooks_debug_zero_check(void *addr, size_t size) {\n\tassert(((uintptr_t)addr & PAGE_MASK) == 0);\n\tassert((size & PAGE_MASK) == 0);\n\tassert(size > 0);\n\tif (config_debug) {\n\t\t/* Check the whole first page. */\n\t\tsize_t *p = (size_t *)addr;\n\t\tfor (size_t i = 0; i < PAGE / sizeof(size_t); i++) {\n\t\t\tassert(p[i] == 0);\n\t\t}\n\t\t/*\n\t\t * And 4 spots within. There's a tradeoff here; the larger\n\t\t * this number, the more likely it is that we'll catch a bug\n\t\t * where ehooks return a sparsely non-zero range. But\n\t\t * increasing the number of checks also increases the number of\n\t\t * page faults in debug mode. FreeBSD does much of their\n\t\t * day-to-day development work in debug mode, so we don't want\n\t\t * even the debug builds to be too slow.\n\t\t */\n\t\tconst size_t nchecks = 4;\n\t\tassert(PAGE >= sizeof(size_t) * nchecks);\n\t\tfor (size_t i = 0; i < nchecks; ++i) {\n\t\t\tassert(p[i * (size / sizeof(size_t) / nchecks)] == 0);\n\t\t}\n\t}\n}\n\n\nstatic inline void *\nehooks_alloc(tsdn_t *tsdn, ehooks_t *ehooks, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit) {\n\tbool orig_zero = *zero;\n\tvoid *ret;\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\tret = ehooks_default_alloc_impl(tsdn, new_addr, size,\n\t\t alignment, zero, commit, ehooks_ind_get(ehooks));\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tret = extent_hooks->alloc(extent_hooks, new_addr, size,\n\t\t alignment, zero, commit, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t}\n\tassert(new_addr == NULL || ret == NULL || new_addr == ret);\n\tassert(!orig_zero || *zero);\n\tif (*zero && ret != NULL) {\n\t\tehooks_debug_zero_check(ret, size);\n\t}\n\treturn ret;\n}\n\nstatic inline bool\nehooks_dalloc(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n bool committed) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\treturn ehooks_default_dalloc_impl(addr, size);\n\t} else if (extent_hooks->dalloc == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->dalloc(extent_hooks, addr, size,\n\t\t committed, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline void\nehooks_destroy(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n bool committed) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\tehooks_default_destroy_impl(addr, size);\n\t} else if (extent_hooks->destroy == NULL) {\n\t\t/* Do nothing. */\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\textent_hooks->destroy(extent_hooks, addr, size, committed,\n\t\t ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t}\n}\n\nstatic inline bool\nehooks_commit(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n size_t offset, size_t length) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tbool err;\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\terr = ehooks_default_commit_impl(addr, offset, length);\n\t} else if (extent_hooks->commit == NULL) {\n\t\terr = true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\terr = extent_hooks->commit(extent_hooks, addr, size,\n\t\t offset, length, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t}\n\tif (!err) {\n\t\tehooks_debug_zero_check(addr, size);\n\t}\n\treturn err;\n}\n\nstatic inline bool\nehooks_decommit(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n size_t offset, size_t length) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\treturn ehooks_default_decommit_impl(addr, offset, length);\n\t} else if (extent_hooks->decommit == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->decommit(extent_hooks, addr, size,\n\t\t offset, length, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline bool\nehooks_purge_lazy(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n size_t offset, size_t length) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n#ifdef PAGES_CAN_PURGE_LAZY\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\treturn ehooks_default_purge_lazy_impl(addr, offset, length);\n\t}\n#endif\n\tif (extent_hooks->purge_lazy == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->purge_lazy(extent_hooks, addr, size,\n\t\t offset, length, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline bool\nehooks_purge_forced(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n size_t offset, size_t length) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\t/*\n\t * It would be correct to have a ehooks_debug_zero_check call at the end\n\t * of this function; purge_forced is required to zero. But checking\n\t * would touch the page in question, which may have performance\n\t * consequences (imagine the hooks are using hugepages, with a global\n\t * zero page off). Even in debug mode, it's usually a good idea to\n\t * avoid cases that can dramatically increase memory consumption.\n\t */\n#ifdef PAGES_CAN_PURGE_FORCED\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\treturn ehooks_default_purge_forced_impl(addr, offset, length);\n\t}\n#endif\n\tif (extent_hooks->purge_forced == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->purge_forced(extent_hooks, addr, size,\n\t\t offset, length, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline bool\nehooks_split(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size,\n size_t size_a, size_t size_b, bool committed) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (ehooks_are_default(ehooks)) {\n\t\treturn ehooks_default_split_impl();\n\t} else if (extent_hooks->split == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->split(extent_hooks, addr, size, size_a,\n\t\t size_b, committed, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline bool\nehooks_merge(tsdn_t *tsdn, ehooks_t *ehooks, void *addr_a, size_t size_a,\n void *addr_b, size_t size_b, bool committed) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\treturn ehooks_default_merge_impl(tsdn, addr_a, addr_b);\n\t} else if (extent_hooks->merge == NULL) {\n\t\treturn true;\n\t} else {\n\t\tehooks_pre_reentrancy(tsdn);\n\t\tbool err = extent_hooks->merge(extent_hooks, addr_a, size_a,\n\t\t addr_b, size_b, committed, ehooks_ind_get(ehooks));\n\t\tehooks_post_reentrancy(tsdn);\n\t\treturn err;\n\t}\n}\n\nstatic inline void\nehooks_zero(tsdn_t *tsdn, ehooks_t *ehooks, void *addr, size_t size) {\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\tehooks_default_zero_impl(addr, size);\n\t} else {\n\t\t/*\n\t\t * It would be correct to try using the user-provided purge\n\t\t * hooks (since they are required to have zeroed the extent if\n\t\t * they indicate success), but we don't necessarily know their\n\t\t * cost. We'll be conservative and use memset.\n\t\t */\n\t\tmemset(addr, 0, size);\n\t}\n}\n\nstatic inline bool\nehooks_guard(tsdn_t *tsdn, ehooks_t *ehooks, void *guard1, void *guard2) {\n\tbool err;\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\tehooks_default_guard_impl(guard1, guard2);\n\t\terr = false;\n\t} else {\n\t\terr = true;\n\t}\n\n\treturn err;\n}\n\nstatic inline bool\nehooks_unguard(tsdn_t *tsdn, ehooks_t *ehooks, void *guard1, void *guard2) {\n\tbool err;\n\textent_hooks_t *extent_hooks = ehooks_get_extent_hooks_ptr(ehooks);\n\n\tif (extent_hooks == &ehooks_default_extent_hooks) {\n\t\tehooks_default_unguard_impl(guard1, guard2);\n\t\terr = false;\n\t} else {\n\t\terr = true;\n\t}\n\n\treturn err;\n}\n\n#endif /* JEMALLOC_INTERNAL_EHOOKS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/emap.h", "content": "#ifndef JEMALLOC_INTERNAL_EMAP_H\n#define JEMALLOC_INTERNAL_EMAP_H\n\n#include \"jemalloc/internal/base.h\"\n#include \"jemalloc/internal/rtree.h\"\n\n/*\n * Note: Ends without at semicolon, so that\n * EMAP_DECLARE_RTREE_CTX;\n * in uses will avoid empty-statement warnings.\n */\n#define EMAP_DECLARE_RTREE_CTX\t\t\t\t\t\t\\\n rtree_ctx_t rtree_ctx_fallback;\t\t\t\t\t\\\n rtree_ctx_t *rtree_ctx = tsdn_rtree_ctx(tsdn, &rtree_ctx_fallback)\n\ntypedef struct emap_s emap_t;\nstruct emap_s {\n\trtree_t rtree;\n};\n\n/* Used to pass rtree lookup context down the path. */\ntypedef struct emap_alloc_ctx_t emap_alloc_ctx_t;\nstruct emap_alloc_ctx_t {\n\tszind_t szind;\n\tbool slab;\n};\n\ntypedef struct emap_full_alloc_ctx_s emap_full_alloc_ctx_t;\nstruct emap_full_alloc_ctx_s {\n\tszind_t szind;\n\tbool slab;\n\tedata_t *edata;\n};\n\nbool emap_init(emap_t *emap, base_t *base, bool zeroed);\n\nvoid emap_remap(tsdn_t *tsdn, emap_t *emap, edata_t *edata, szind_t szind,\n bool slab);\n\nvoid emap_update_edata_state(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_state_t state);\n\n/*\n * The two acquire functions below allow accessing neighbor edatas, if it's safe\n * and valid to do so (i.e. from the same arena, of the same state, etc.). This\n * is necessary because the ecache locks are state based, and only protect\n * edatas with the same state. Therefore the neighbor edata's state needs to be\n * verified first, before chasing the edata pointer. The returned edata will be\n * in an acquired state, meaning other threads will be prevented from accessing\n * it, even if technically the edata can still be discovered from the rtree.\n *\n * This means, at any moment when holding pointers to edata, either one of the\n * state based locks is held (and the edatas are all of the protected state), or\n * the edatas are in an acquired state (e.g. in active or merging state). The\n * acquire operation itself (changing the edata to an acquired state) is done\n * under the state locks.\n */\nedata_t *emap_try_acquire_edata_neighbor(tsdn_t *tsdn, emap_t *emap,\n edata_t *edata, extent_pai_t pai, extent_state_t expected_state,\n bool forward);\nedata_t *emap_try_acquire_edata_neighbor_expand(tsdn_t *tsdn, emap_t *emap,\n edata_t *edata, extent_pai_t pai, extent_state_t expected_state);\nvoid emap_release_edata(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_state_t new_state);\n\n/*\n * Associate the given edata with its beginning and end address, setting the\n * szind and slab info appropriately.\n * Returns true on error (i.e. resource exhaustion).\n */\nbool emap_register_boundary(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n szind_t szind, bool slab);\n\n/*\n * Does the same thing, but with the interior of the range, for slab\n * allocations.\n *\n * You might wonder why we don't just have a single emap_register function that\n * does both depending on the value of 'slab'. The answer is twofold:\n * - As a practical matter, in places like the extract->split->commit pathway,\n * we defer the interior operation until we're sure that the commit won't fail\n * (but we have to register the split boundaries there).\n * - In general, we're trying to move to a world where the page-specific\n * allocator doesn't know as much about how the pages it allocates will be\n * used, and passing a 'slab' parameter everywhere makes that more\n * complicated.\n *\n * Unlike the boundary version, this function can't fail; this is because slabs\n * can't get big enough to touch a new page that neither of the boundaries\n * touched, so no allocation is necessary to fill the interior once the boundary\n * has been touched.\n */\nvoid emap_register_interior(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n szind_t szind);\n\nvoid emap_deregister_boundary(tsdn_t *tsdn, emap_t *emap, edata_t *edata);\nvoid emap_deregister_interior(tsdn_t *tsdn, emap_t *emap, edata_t *edata);\n\ntypedef struct emap_prepare_s emap_prepare_t;\nstruct emap_prepare_s {\n\trtree_leaf_elm_t *lead_elm_a;\n\trtree_leaf_elm_t *lead_elm_b;\n\trtree_leaf_elm_t *trail_elm_a;\n\trtree_leaf_elm_t *trail_elm_b;\n};\n\n/**\n * These functions the emap metadata management for merging, splitting, and\n * reusing extents. In particular, they set the boundary mappings from\n * addresses to edatas. If the result is going to be used as a slab, you\n * still need to call emap_register_interior on it, though.\n *\n * Remap simply changes the szind and slab status of an extent's boundary\n * mappings. If the extent is not a slab, it doesn't bother with updating the\n * end mapping (since lookups only occur in the interior of an extent for\n * slabs). Since the szind and slab status only make sense for active extents,\n * this should only be called while activating or deactivating an extent.\n *\n * Split and merge have a \"prepare\" and a \"commit\" portion. The prepare portion\n * does the operations that can be done without exclusive access to the extent\n * in question, while the commit variant requires exclusive access to maintain\n * the emap invariants. The only function that can fail is emap_split_prepare,\n * and it returns true on failure (at which point the caller shouldn't commit).\n *\n * In all cases, \"lead\" refers to the lower-addressed extent, and trail to the\n * higher-addressed one. It's the caller's responsibility to set the edata\n * state appropriately.\n */\nbool emap_split_prepare(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *edata, size_t size_a, edata_t *trail, size_t size_b);\nvoid emap_split_commit(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, size_t size_a, edata_t *trail, size_t size_b);\nvoid emap_merge_prepare(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, edata_t *trail);\nvoid emap_merge_commit(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, edata_t *trail);\n\n/* Assert that the emap's view of the given edata matches the edata's view. */\nvoid emap_do_assert_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata);\nstatic inline void\nemap_assert_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tif (config_debug) {\n\t\temap_do_assert_mapped(tsdn, emap, edata);\n\t}\n}\n\n/* Assert that the given edata isn't in the map. */\nvoid emap_do_assert_not_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata);\nstatic inline void\nemap_assert_not_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tif (config_debug) {\n\t\temap_do_assert_not_mapped(tsdn, emap, edata);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nemap_edata_in_transition(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tassert(config_debug);\n\temap_assert_mapped(tsdn, emap, edata);\n\n\tEMAP_DECLARE_RTREE_CTX;\n\trtree_contents_t contents = rtree_read(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_base_get(edata));\n\n\treturn edata_state_in_transition(contents.metadata.state);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nemap_edata_is_acquired(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tif (!config_debug) {\n\t\t/* For assertions only. */\n\t\treturn false;\n\t}\n\n\t/*\n\t * The edata is considered acquired if no other threads will attempt to\n\t * read / write any fields from it. This includes a few cases:\n\t *\n\t * 1) edata not hooked into emap yet -- This implies the edata just got\n\t * allocated or initialized.\n\t *\n\t * 2) in an active or transition state -- In both cases, the edata can\n\t * be discovered from the emap, however the state tracked in the rtree\n\t * will prevent other threads from accessing the actual edata.\n\t */\n\tEMAP_DECLARE_RTREE_CTX;\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, &emap->rtree,\n\t rtree_ctx, (uintptr_t)edata_base_get(edata), /* dependent */ true,\n\t /* init_missing */ false);\n\tif (elm == NULL) {\n\t\treturn true;\n\t}\n\trtree_contents_t contents = rtree_leaf_elm_read(tsdn, &emap->rtree, elm,\n\t /* dependent */ true);\n\tif (contents.edata == NULL ||\n\t contents.metadata.state == extent_state_active ||\n\t edata_state_in_transition(contents.metadata.state)) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nextent_assert_can_coalesce(const edata_t *inner, const edata_t *outer) {\n\tassert(edata_arena_ind_get(inner) == edata_arena_ind_get(outer));\n\tassert(edata_pai_get(inner) == edata_pai_get(outer));\n\tassert(edata_committed_get(inner) == edata_committed_get(outer));\n\tassert(edata_state_get(inner) == extent_state_active);\n\tassert(edata_state_get(outer) == extent_state_merging);\n\tassert(!edata_guarded_get(inner) && !edata_guarded_get(outer));\n\tassert(edata_base_get(inner) == edata_past_get(outer) ||\n\t edata_base_get(outer) == edata_past_get(inner));\n}\n\nJEMALLOC_ALWAYS_INLINE void\nextent_assert_can_expand(const edata_t *original, const edata_t *expand) {\n\tassert(edata_arena_ind_get(original) == edata_arena_ind_get(expand));\n\tassert(edata_pai_get(original) == edata_pai_get(expand));\n\tassert(edata_state_get(original) == extent_state_active);\n\tassert(edata_state_get(expand) == extent_state_merging);\n\tassert(edata_past_get(original) == edata_base_get(expand));\n}\n\nJEMALLOC_ALWAYS_INLINE edata_t *\nemap_edata_lookup(tsdn_t *tsdn, emap_t *emap, const void *ptr) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\treturn rtree_read(tsdn, &emap->rtree, rtree_ctx, (uintptr_t)ptr).edata;\n}\n\n/* Fills in alloc_ctx with the info in the map. */\nJEMALLOC_ALWAYS_INLINE void\nemap_alloc_ctx_lookup(tsdn_t *tsdn, emap_t *emap, const void *ptr,\n emap_alloc_ctx_t *alloc_ctx) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\trtree_metadata_t metadata = rtree_metadata_read(tsdn, &emap->rtree,\n\t rtree_ctx, (uintptr_t)ptr);\n\talloc_ctx->szind = metadata.szind;\n\talloc_ctx->slab = metadata.slab;\n}\n\n/* The pointer must be mapped. */\nJEMALLOC_ALWAYS_INLINE void\nemap_full_alloc_ctx_lookup(tsdn_t *tsdn, emap_t *emap, const void *ptr,\n emap_full_alloc_ctx_t *full_alloc_ctx) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\trtree_contents_t contents = rtree_read(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)ptr);\n\tfull_alloc_ctx->edata = contents.edata;\n\tfull_alloc_ctx->szind = contents.metadata.szind;\n\tfull_alloc_ctx->slab = contents.metadata.slab;\n}\n\n/*\n * The pointer is allowed to not be mapped.\n *\n * Returns true when the pointer is not present.\n */\nJEMALLOC_ALWAYS_INLINE bool\nemap_full_alloc_ctx_try_lookup(tsdn_t *tsdn, emap_t *emap, const void *ptr,\n emap_full_alloc_ctx_t *full_alloc_ctx) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\trtree_contents_t contents;\n\tbool err = rtree_read_independent(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)ptr, &contents);\n\tif (err) {\n\t\treturn true;\n\t}\n\tfull_alloc_ctx->edata = contents.edata;\n\tfull_alloc_ctx->szind = contents.metadata.szind;\n\tfull_alloc_ctx->slab = contents.metadata.slab;\n\treturn false;\n}\n\n/*\n * Only used on the fastpath of free. Returns true when cannot be fulfilled by\n * fast path, e.g. when the metadata key is not cached.\n */\nJEMALLOC_ALWAYS_INLINE bool\nemap_alloc_ctx_try_lookup_fast(tsd_t *tsd, emap_t *emap, const void *ptr,\n emap_alloc_ctx_t *alloc_ctx) {\n\t/* Use the unsafe getter since this may gets called during exit. */\n\trtree_ctx_t *rtree_ctx = tsd_rtree_ctxp_get_unsafe(tsd);\n\n\trtree_metadata_t metadata;\n\tbool err = rtree_metadata_try_read_fast(tsd_tsdn(tsd), &emap->rtree,\n\t rtree_ctx, (uintptr_t)ptr, &metadata);\n\tif (err) {\n\t\treturn true;\n\t}\n\talloc_ctx->szind = metadata.szind;\n\talloc_ctx->slab = metadata.slab;\n\treturn false;\n}\n\n/*\n * We want to do batch lookups out of the cache bins, which use\n * cache_bin_ptr_array_get to access the i'th element of the bin (since they\n * invert usual ordering in deciding what to flush). This lets the emap avoid\n * caring about its caller's ordering.\n */\ntypedef const void *(*emap_ptr_getter)(void *ctx, size_t ind);\n/*\n * This allows size-checking assertions, which we can only do while we're in the\n * process of edata lookups.\n */\ntypedef void (*emap_metadata_visitor)(void *ctx, emap_full_alloc_ctx_t *alloc_ctx);\n\ntypedef union emap_batch_lookup_result_u emap_batch_lookup_result_t;\nunion emap_batch_lookup_result_u {\n\tedata_t *edata;\n\trtree_leaf_elm_t *rtree_leaf;\n};\n\nJEMALLOC_ALWAYS_INLINE void\nemap_edata_lookup_batch(tsd_t *tsd, emap_t *emap, size_t nptrs,\n emap_ptr_getter ptr_getter, void *ptr_getter_ctx,\n emap_metadata_visitor metadata_visitor, void *metadata_visitor_ctx,\n emap_batch_lookup_result_t *result) {\n\t/* Avoids null-checking tsdn in the loop below. */\n\tutil_assume(tsd != NULL);\n\trtree_ctx_t *rtree_ctx = tsd_rtree_ctxp_get(tsd);\n\n\tfor (size_t i = 0; i < nptrs; i++) {\n\t\tconst void *ptr = ptr_getter(ptr_getter_ctx, i);\n\t\t/*\n\t\t * Reuse the edatas array as a temp buffer, lying a little about\n\t\t * the types.\n\t\t */\n\t\tresult[i].rtree_leaf = rtree_leaf_elm_lookup(tsd_tsdn(tsd),\n\t\t &emap->rtree, rtree_ctx, (uintptr_t)ptr,\n\t\t /* dependent */ true, /* init_missing */ false);\n\t}\n\n\tfor (size_t i = 0; i < nptrs; i++) {\n\t\trtree_leaf_elm_t *elm = result[i].rtree_leaf;\n\t\trtree_contents_t contents = rtree_leaf_elm_read(tsd_tsdn(tsd),\n\t\t &emap->rtree, elm, /* dependent */ true);\n\t\tresult[i].edata = contents.edata;\n\t\temap_full_alloc_ctx_t alloc_ctx;\n\t\t/*\n\t\t * Not all these fields are read in practice by the metadata\n\t\t * visitor. But the compiler can easily optimize away the ones\n\t\t * that aren't, so no sense in being incomplete.\n\t\t */\n\t\talloc_ctx.szind = contents.metadata.szind;\n\t\talloc_ctx.slab = contents.metadata.slab;\n\t\talloc_ctx.edata = contents.edata;\n\t\tmetadata_visitor(metadata_visitor_ctx, &alloc_ctx);\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_EMAP_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/emitter.h", "content": "#ifndef JEMALLOC_INTERNAL_EMITTER_H\n#define JEMALLOC_INTERNAL_EMITTER_H\n\n#include \"jemalloc/internal/ql.h\"\n\ntypedef enum emitter_output_e emitter_output_t;\nenum emitter_output_e {\n\temitter_output_json,\n\temitter_output_json_compact,\n\temitter_output_table\n};\n\ntypedef enum emitter_justify_e emitter_justify_t;\nenum emitter_justify_e {\n\temitter_justify_left,\n\temitter_justify_right,\n\t/* Not for users; just to pass to internal functions. */\n\temitter_justify_none\n};\n\ntypedef enum emitter_type_e emitter_type_t;\nenum emitter_type_e {\n\temitter_type_bool,\n\temitter_type_int,\n\temitter_type_int64,\n\temitter_type_unsigned,\n\temitter_type_uint32,\n\temitter_type_uint64,\n\temitter_type_size,\n\temitter_type_ssize,\n\temitter_type_string,\n\t/*\n\t * A title is a column title in a table; it's just a string, but it's\n\t * not quoted.\n\t */\n\temitter_type_title,\n};\n\ntypedef struct emitter_col_s emitter_col_t;\nstruct emitter_col_s {\n\t/* Filled in by the user. */\n\temitter_justify_t justify;\n\tint width;\n\temitter_type_t type;\n\tunion {\n\t\tbool bool_val;\n\t\tint int_val;\n\t\tunsigned unsigned_val;\n\t\tuint32_t uint32_val;\n\t\tuint32_t uint32_t_val;\n\t\tuint64_t uint64_val;\n\t\tuint64_t uint64_t_val;\n\t\tsize_t size_val;\n\t\tssize_t ssize_val;\n\t\tconst char *str_val;\n\t};\n\n\t/* Filled in by initialization. */\n\tql_elm(emitter_col_t) link;\n};\n\ntypedef struct emitter_row_s emitter_row_t;\nstruct emitter_row_s {\n\tql_head(emitter_col_t) cols;\n};\n\ntypedef struct emitter_s emitter_t;\nstruct emitter_s {\n\temitter_output_t output;\n\t/* The output information. */\n\twrite_cb_t *write_cb;\n\tvoid *cbopaque;\n\tint nesting_depth;\n\t/* True if we've already emitted a value at the given depth. */\n\tbool item_at_depth;\n\t/* True if we emitted a key and will emit corresponding value next. */\n\tbool emitted_key;\n};\n\nstatic inline bool\nemitter_outputs_json(emitter_t *emitter) {\n\treturn emitter->output == emitter_output_json ||\n\t emitter->output == emitter_output_json_compact;\n}\n\n/* Internal convenience function. Write to the emitter the given string. */\nJEMALLOC_FORMAT_PRINTF(2, 3)\nstatic inline void\nemitter_printf(emitter_t *emitter, const char *format, ...) {\n\tva_list ap;\n\n\tva_start(ap, format);\n\tmalloc_vcprintf(emitter->write_cb, emitter->cbopaque, format, ap);\n\tva_end(ap);\n}\n\nstatic inline const char * JEMALLOC_FORMAT_ARG(3)\nemitter_gen_fmt(char *out_fmt, size_t out_size, const char *fmt_specifier,\n emitter_justify_t justify, int width) {\n\tsize_t written;\n\tfmt_specifier++;\n\tif (justify == emitter_justify_none) {\n\t\twritten = malloc_snprintf(out_fmt, out_size,\n\t\t \"%%%s\", fmt_specifier);\n\t} else if (justify == emitter_justify_left) {\n\t\twritten = malloc_snprintf(out_fmt, out_size,\n\t\t \"%%-%d%s\", width, fmt_specifier);\n\t} else {\n\t\twritten = malloc_snprintf(out_fmt, out_size,\n\t\t \"%%%d%s\", width, fmt_specifier);\n\t}\n\t/* Only happens in case of bad format string, which *we* choose. */\n\tassert(written < out_size);\n\treturn out_fmt;\n}\n\n/*\n * Internal. Emit the given value type in the relevant encoding (so that the\n * bool true gets mapped to json \"true\", but the string \"true\" gets mapped to\n * json \"\\\"true\\\"\", for instance.\n *\n * Width is ignored if justify is emitter_justify_none.\n */\nstatic inline void\nemitter_print_value(emitter_t *emitter, emitter_justify_t justify, int width,\n emitter_type_t value_type, const void *value) {\n\tsize_t str_written;\n#define BUF_SIZE 256\n#define FMT_SIZE 10\n\t/*\n\t * We dynamically generate a format string to emit, to let us use the\n\t * snprintf machinery. This is kinda hacky, but gets the job done\n\t * quickly without having to think about the various snprintf edge\n\t * cases.\n\t */\n\tchar fmt[FMT_SIZE];\n\tchar buf[BUF_SIZE];\n\n#define EMIT_SIMPLE(type, format)\t\t\t\t\t\\\n\temitter_printf(emitter,\t\t\t\t\t\t\\\n\t emitter_gen_fmt(fmt, FMT_SIZE, format, justify, width),\t\\\n\t *(const type *)value);\n\n\tswitch (value_type) {\n\tcase emitter_type_bool:\n\t\temitter_printf(emitter,\n\t\t emitter_gen_fmt(fmt, FMT_SIZE, \"%s\", justify, width),\n\t\t *(const bool *)value ? \"true\" : \"false\");\n\t\tbreak;\n\tcase emitter_type_int:\n\t\tEMIT_SIMPLE(int, \"%d\")\n\t\tbreak;\n\tcase emitter_type_int64:\n\t\tEMIT_SIMPLE(int64_t, \"%\" FMTd64)\n\t\tbreak;\n\tcase emitter_type_unsigned:\n\t\tEMIT_SIMPLE(unsigned, \"%u\")\n\t\tbreak;\n\tcase emitter_type_ssize:\n\t\tEMIT_SIMPLE(ssize_t, \"%zd\")\n\t\tbreak;\n\tcase emitter_type_size:\n\t\tEMIT_SIMPLE(size_t, \"%zu\")\n\t\tbreak;\n\tcase emitter_type_string:\n\t\tstr_written = malloc_snprintf(buf, BUF_SIZE, \"\\\"%s\\\"\",\n\t\t *(const char *const *)value);\n\t\t/*\n\t\t * We control the strings we output; we shouldn't get anything\n\t\t * anywhere near the fmt size.\n\t\t */\n\t\tassert(str_written < BUF_SIZE);\n\t\temitter_printf(emitter,\n\t\t emitter_gen_fmt(fmt, FMT_SIZE, \"%s\", justify, width), buf);\n\t\tbreak;\n\tcase emitter_type_uint32:\n\t\tEMIT_SIMPLE(uint32_t, \"%\" FMTu32)\n\t\tbreak;\n\tcase emitter_type_uint64:\n\t\tEMIT_SIMPLE(uint64_t, \"%\" FMTu64)\n\t\tbreak;\n\tcase emitter_type_title:\n\t\tEMIT_SIMPLE(char *const, \"%s\");\n\t\tbreak;\n\tdefault:\n\t\tunreachable();\n\t}\n#undef BUF_SIZE\n#undef FMT_SIZE\n}\n\n\n/* Internal functions. In json mode, tracks nesting state. */\nstatic inline void\nemitter_nest_inc(emitter_t *emitter) {\n\temitter->nesting_depth++;\n\temitter->item_at_depth = false;\n}\n\nstatic inline void\nemitter_nest_dec(emitter_t *emitter) {\n\temitter->nesting_depth--;\n\temitter->item_at_depth = true;\n}\n\nstatic inline void\nemitter_indent(emitter_t *emitter) {\n\tint amount = emitter->nesting_depth;\n\tconst char *indent_str;\n\tassert(emitter->output != emitter_output_json_compact);\n\tif (emitter->output == emitter_output_json) {\n\t\tindent_str = \"\\t\";\n\t} else {\n\t\tamount *= 2;\n\t\tindent_str = \" \";\n\t}\n\tfor (int i = 0; i < amount; i++) {\n\t\temitter_printf(emitter, \"%s\", indent_str);\n\t}\n}\n\nstatic inline void\nemitter_json_key_prefix(emitter_t *emitter) {\n\tassert(emitter_outputs_json(emitter));\n\tif (emitter->emitted_key) {\n\t\temitter->emitted_key = false;\n\t\treturn;\n\t}\n\tif (emitter->item_at_depth) {\n\t\temitter_printf(emitter, \",\");\n\t}\n\tif (emitter->output != emitter_output_json_compact) {\n\t\temitter_printf(emitter, \"\\n\");\n\t\temitter_indent(emitter);\n\t}\n}\n\n/******************************************************************************/\n/* Public functions for emitter_t. */\n\nstatic inline void\nemitter_init(emitter_t *emitter, emitter_output_t emitter_output,\n write_cb_t *write_cb, void *cbopaque) {\n\temitter->output = emitter_output;\n\temitter->write_cb = write_cb;\n\temitter->cbopaque = cbopaque;\n\temitter->item_at_depth = false;\n\temitter->emitted_key = false;\n\temitter->nesting_depth = 0;\n}\n\n/******************************************************************************/\n/* JSON public API. */\n\n/*\n * Emits a key (e.g. as appears in an object). The next json entity emitted will\n * be the corresponding value.\n */\nstatic inline void\nemitter_json_key(emitter_t *emitter, const char *json_key) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key_prefix(emitter);\n\t\temitter_printf(emitter, \"\\\"%s\\\":%s\", json_key,\n\t\t emitter->output == emitter_output_json_compact ? \"\" : \" \");\n\t\temitter->emitted_key = true;\n\t}\n}\n\nstatic inline void\nemitter_json_value(emitter_t *emitter, emitter_type_t value_type,\n const void *value) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key_prefix(emitter);\n\t\temitter_print_value(emitter, emitter_justify_none, -1,\n\t\t value_type, value);\n\t\temitter->item_at_depth = true;\n\t}\n}\n\n/* Shorthand for calling emitter_json_key and then emitter_json_value. */\nstatic inline void\nemitter_json_kv(emitter_t *emitter, const char *json_key,\n emitter_type_t value_type, const void *value) {\n\temitter_json_key(emitter, json_key);\n\temitter_json_value(emitter, value_type, value);\n}\n\nstatic inline void\nemitter_json_array_begin(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key_prefix(emitter);\n\t\temitter_printf(emitter, \"[\");\n\t\temitter_nest_inc(emitter);\n\t}\n}\n\n/* Shorthand for calling emitter_json_key and then emitter_json_array_begin. */\nstatic inline void\nemitter_json_array_kv_begin(emitter_t *emitter, const char *json_key) {\n\temitter_json_key(emitter, json_key);\n\temitter_json_array_begin(emitter);\n}\n\nstatic inline void\nemitter_json_array_end(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\tassert(emitter->nesting_depth > 0);\n\t\temitter_nest_dec(emitter);\n\t\tif (emitter->output != emitter_output_json_compact) {\n\t\t\temitter_printf(emitter, \"\\n\");\n\t\t\temitter_indent(emitter);\n\t\t}\n\t\temitter_printf(emitter, \"]\");\n\t}\n}\n\nstatic inline void\nemitter_json_object_begin(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key_prefix(emitter);\n\t\temitter_printf(emitter, \"{\");\n\t\temitter_nest_inc(emitter);\n\t}\n}\n\n/* Shorthand for calling emitter_json_key and then emitter_json_object_begin. */\nstatic inline void\nemitter_json_object_kv_begin(emitter_t *emitter, const char *json_key) {\n\temitter_json_key(emitter, json_key);\n\temitter_json_object_begin(emitter);\n}\n\nstatic inline void\nemitter_json_object_end(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\tassert(emitter->nesting_depth > 0);\n\t\temitter_nest_dec(emitter);\n\t\tif (emitter->output != emitter_output_json_compact) {\n\t\t\temitter_printf(emitter, \"\\n\");\n\t\t\temitter_indent(emitter);\n\t\t}\n\t\temitter_printf(emitter, \"}\");\n\t}\n}\n\n\n/******************************************************************************/\n/* Table public API. */\n\nstatic inline void\nemitter_table_dict_begin(emitter_t *emitter, const char *table_key) {\n\tif (emitter->output == emitter_output_table) {\n\t\temitter_indent(emitter);\n\t\temitter_printf(emitter, \"%s\\n\", table_key);\n\t\temitter_nest_inc(emitter);\n\t}\n}\n\nstatic inline void\nemitter_table_dict_end(emitter_t *emitter) {\n\tif (emitter->output == emitter_output_table) {\n\t\temitter_nest_dec(emitter);\n\t}\n}\n\nstatic inline void\nemitter_table_kv_note(emitter_t *emitter, const char *table_key,\n emitter_type_t value_type, const void *value,\n const char *table_note_key, emitter_type_t table_note_value_type,\n const void *table_note_value) {\n\tif (emitter->output == emitter_output_table) {\n\t\temitter_indent(emitter);\n\t\temitter_printf(emitter, \"%s: \", table_key);\n\t\temitter_print_value(emitter, emitter_justify_none, -1,\n\t\t value_type, value);\n\t\tif (table_note_key != NULL) {\n\t\t\temitter_printf(emitter, \" (%s: \", table_note_key);\n\t\t\temitter_print_value(emitter, emitter_justify_none, -1,\n\t\t\t table_note_value_type, table_note_value);\n\t\t\temitter_printf(emitter, \")\");\n\t\t}\n\t\temitter_printf(emitter, \"\\n\");\n\t}\n\temitter->item_at_depth = true;\n}\n\nstatic inline void\nemitter_table_kv(emitter_t *emitter, const char *table_key,\n emitter_type_t value_type, const void *value) {\n\temitter_table_kv_note(emitter, table_key, value_type, value, NULL,\n\t emitter_type_bool, NULL);\n}\n\n\n/* Write to the emitter the given string, but only in table mode. */\nJEMALLOC_FORMAT_PRINTF(2, 3)\nstatic inline void\nemitter_table_printf(emitter_t *emitter, const char *format, ...) {\n\tif (emitter->output == emitter_output_table) {\n\t\tva_list ap;\n\t\tva_start(ap, format);\n\t\tmalloc_vcprintf(emitter->write_cb, emitter->cbopaque, format, ap);\n\t\tva_end(ap);\n\t}\n}\n\nstatic inline void\nemitter_table_row(emitter_t *emitter, emitter_row_t *row) {\n\tif (emitter->output != emitter_output_table) {\n\t\treturn;\n\t}\n\temitter_col_t *col;\n\tql_foreach(col, &row->cols, link) {\n\t\temitter_print_value(emitter, col->justify, col->width,\n\t\t col->type, (const void *)&col->bool_val);\n\t}\n\temitter_table_printf(emitter, \"\\n\");\n}\n\nstatic inline void\nemitter_row_init(emitter_row_t *row) {\n\tql_new(&row->cols);\n}\n\nstatic inline void\nemitter_col_init(emitter_col_t *col, emitter_row_t *row) {\n\tql_elm_new(col, link);\n\tql_tail_insert(&row->cols, col, link);\n}\n\n\n/******************************************************************************/\n/*\n * Generalized public API. Emits using either JSON or table, according to\n * settings in the emitter_t. */\n\n/*\n * Note emits a different kv pair as well, but only in table mode. Omits the\n * note if table_note_key is NULL.\n */\nstatic inline void\nemitter_kv_note(emitter_t *emitter, const char *json_key, const char *table_key,\n emitter_type_t value_type, const void *value,\n const char *table_note_key, emitter_type_t table_note_value_type,\n const void *table_note_value) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key(emitter, json_key);\n\t\temitter_json_value(emitter, value_type, value);\n\t} else {\n\t\temitter_table_kv_note(emitter, table_key, value_type, value,\n\t\t table_note_key, table_note_value_type, table_note_value);\n\t}\n\temitter->item_at_depth = true;\n}\n\nstatic inline void\nemitter_kv(emitter_t *emitter, const char *json_key, const char *table_key,\n emitter_type_t value_type, const void *value) {\n\temitter_kv_note(emitter, json_key, table_key, value_type, value, NULL,\n\t emitter_type_bool, NULL);\n}\n\nstatic inline void\nemitter_dict_begin(emitter_t *emitter, const char *json_key,\n const char *table_header) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_key(emitter, json_key);\n\t\temitter_json_object_begin(emitter);\n\t} else {\n\t\temitter_table_dict_begin(emitter, table_header);\n\t}\n}\n\nstatic inline void\nemitter_dict_end(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_object_end(emitter);\n\t} else {\n\t\temitter_table_dict_end(emitter);\n\t}\n}\n\nstatic inline void\nemitter_begin(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\tassert(emitter->nesting_depth == 0);\n\t\temitter_printf(emitter, \"{\");\n\t\temitter_nest_inc(emitter);\n\t} else {\n\t\t/*\n\t\t * This guarantees that we always call write_cb at least once.\n\t\t * This is useful if some invariant is established by each call\n\t\t * to write_cb, but doesn't hold initially: e.g., some buffer\n\t\t * holds a null-terminated string.\n\t\t */\n\t\temitter_printf(emitter, \"%s\", \"\");\n\t}\n}\n\nstatic inline void\nemitter_end(emitter_t *emitter) {\n\tif (emitter_outputs_json(emitter)) {\n\t\tassert(emitter->nesting_depth == 1);\n\t\temitter_nest_dec(emitter);\n\t\temitter_printf(emitter, \"%s\", emitter->output ==\n\t\t emitter_output_json_compact ? \"}\" : \"\\n}\\n\");\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_EMITTER_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/eset.h", "content": "#ifndef JEMALLOC_INTERNAL_ESET_H\n#define JEMALLOC_INTERNAL_ESET_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/fb.h\"\n#include \"jemalloc/internal/edata.h\"\n#include \"jemalloc/internal/mutex.h\"\n\n/*\n * An eset (\"extent set\") is a quantized collection of extents, with built-in\n * LRU queue.\n *\n * This class is not thread-safe; synchronization must be done externally if\n * there are mutating operations. One exception is the stats counters, which\n * may be read without any locking.\n */\n\ntypedef struct eset_bin_s eset_bin_t;\nstruct eset_bin_s {\n\tedata_heap_t heap;\n\t/*\n\t * We do first-fit across multiple size classes. If we compared against\n\t * the min element in each heap directly, we'd take a cache miss per\n\t * extent we looked at. If we co-locate the edata summaries, we only\n\t * take a miss on the edata we're actually going to return (which is\n\t * inevitable anyways).\n\t */\n\tedata_cmp_summary_t heap_min;\n};\n\ntypedef struct eset_bin_stats_s eset_bin_stats_t;\nstruct eset_bin_stats_s {\n\tatomic_zu_t nextents;\n\tatomic_zu_t nbytes;\n};\n\ntypedef struct eset_s eset_t;\nstruct eset_s {\n\t/* Bitmap for which set bits correspond to non-empty heaps. */\n\tfb_group_t bitmap[FB_NGROUPS(SC_NPSIZES + 1)];\n\n\t/* Quantized per size class heaps of extents. */\n\teset_bin_t bins[SC_NPSIZES + 1];\n\n\teset_bin_stats_t bin_stats[SC_NPSIZES + 1];\n\n\t/* LRU of all extents in heaps. */\n\tedata_list_inactive_t lru;\n\n\t/* Page sum for all extents in heaps. */\n\tatomic_zu_t npages;\n\n\t/*\n\t * A duplication of the data in the containing ecache. We use this only\n\t * for assertions on the states of the passed-in extents.\n\t */\n\textent_state_t state;\n};\n\nvoid eset_init(eset_t *eset, extent_state_t state);\n\nsize_t eset_npages_get(eset_t *eset);\n/* Get the number of extents in the given page size index. */\nsize_t eset_nextents_get(eset_t *eset, pszind_t ind);\n/* Get the sum total bytes of the extents in the given page size index. */\nsize_t eset_nbytes_get(eset_t *eset, pszind_t ind);\n\nvoid eset_insert(eset_t *eset, edata_t *edata);\nvoid eset_remove(eset_t *eset, edata_t *edata);\n/*\n * Select an extent from this eset of the given size and alignment. Returns\n * null if no such item could be found.\n */\nedata_t *eset_fit(eset_t *eset, size_t esize, size_t alignment, bool exact_only,\n unsigned lg_max_fit);\n\n#endif /* JEMALLOC_INTERNAL_ESET_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/exp_grow.h", "content": "#ifndef JEMALLOC_INTERNAL_EXP_GROW_H\n#define JEMALLOC_INTERNAL_EXP_GROW_H\n\ntypedef struct exp_grow_s exp_grow_t;\nstruct exp_grow_s {\n\t/*\n\t * Next extent size class in a growing series to use when satisfying a\n\t * request via the extent hooks (only if opt_retain). This limits the\n\t * number of disjoint virtual memory ranges so that extent merging can\n\t * be effective even if multiple arenas' extent allocation requests are\n\t * highly interleaved.\n\t *\n\t * retain_grow_limit is the max allowed size ind to expand (unless the\n\t * required size is greater). Default is no limit, and controlled\n\t * through mallctl only.\n\t */\n\tpszind_t next;\n\tpszind_t limit;\n};\n\nstatic inline bool\nexp_grow_size_prepare(exp_grow_t *exp_grow, size_t alloc_size_min,\n size_t *r_alloc_size, pszind_t *r_skip) {\n\t*r_skip = 0;\n\t*r_alloc_size = sz_pind2sz(exp_grow->next + *r_skip);\n\twhile (*r_alloc_size < alloc_size_min) {\n\t\t(*r_skip)++;\n\t\tif (exp_grow->next + *r_skip >=\n\t\t sz_psz2ind(SC_LARGE_MAXCLASS)) {\n\t\t\t/* Outside legal range. */\n\t\t\treturn true;\n\t\t}\n\t\t*r_alloc_size = sz_pind2sz(exp_grow->next + *r_skip);\n\t}\n\treturn false;\n}\n\nstatic inline void\nexp_grow_size_commit(exp_grow_t *exp_grow, pszind_t skip) {\n\tif (exp_grow->next + skip + 1 <= exp_grow->limit) {\n\t\texp_grow->next += skip + 1;\n\t} else {\n\t\texp_grow->next = exp_grow->limit;\n\t}\n\n}\n\nvoid exp_grow_init(exp_grow_t *exp_grow);\n\n#endif /* JEMALLOC_INTERNAL_EXP_GROW_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/extent.h", "content": "#ifndef JEMALLOC_INTERNAL_EXTENT_H\n#define JEMALLOC_INTERNAL_EXTENT_H\n\n#include \"jemalloc/internal/ecache.h\"\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/ph.h\"\n#include \"jemalloc/internal/rtree.h\"\n\n/*\n * This module contains the page-level allocator. It chooses the addresses that\n * allocations requested by other modules will inhabit, and updates the global\n * metadata to reflect allocation/deallocation/purging decisions.\n */\n\n/*\n * When reuse (and split) an active extent, (1U << opt_lg_extent_max_active_fit)\n * is the max ratio between the size of the active extent and the new extent.\n */\n#define LG_EXTENT_MAX_ACTIVE_FIT_DEFAULT 6\nextern size_t opt_lg_extent_max_active_fit;\n\nedata_t *ecache_alloc(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *expand_edata, size_t size, size_t alignment,\n bool zero, bool guarded);\nedata_t *ecache_alloc_grow(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *expand_edata, size_t size, size_t alignment,\n bool zero, bool guarded);\nvoid ecache_dalloc(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata);\nedata_t *ecache_evict(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, size_t npages_min);\n\nvoid extent_gdump_add(tsdn_t *tsdn, const edata_t *edata);\nvoid extent_record(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *edata);\nvoid extent_dalloc_gap(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata);\nedata_t *extent_alloc_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n void *new_addr, size_t size, size_t alignment, bool zero, bool *commit,\n bool growing_retained);\nvoid extent_dalloc_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata);\nvoid extent_destroy_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata);\nbool extent_commit_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length);\nbool extent_decommit_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length);\nbool extent_purge_lazy_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length);\nbool extent_purge_forced_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length);\nedata_t *extent_split_wrapper(tsdn_t *tsdn, pac_t *pac,\n ehooks_t *ehooks, edata_t *edata, size_t size_a, size_t size_b,\n bool holding_core_locks);\nbool extent_merge_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *a, edata_t *b);\nbool extent_commit_zero(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n bool commit, bool zero, bool growing_retained);\nsize_t extent_sn_next(pac_t *pac);\nbool extent_boot(void);\n\nJEMALLOC_ALWAYS_INLINE bool\nextent_neighbor_head_state_mergeable(bool edata_is_head,\n bool neighbor_is_head, bool forward) {\n\t/*\n\t * Head states checking: disallow merging if the higher addr extent is a\n\t * head extent. This helps preserve first-fit, and more importantly\n\t * makes sure no merge across arenas.\n\t */\n\tif (forward) {\n\t\tif (neighbor_is_head) {\n\t\t\treturn false;\n\t\t}\n\t} else {\n\t\tif (edata_is_head) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nextent_can_acquire_neighbor(edata_t *edata, rtree_contents_t contents,\n extent_pai_t pai, extent_state_t expected_state, bool forward,\n bool expanding) {\n\tedata_t *neighbor = contents.edata;\n\tif (neighbor == NULL) {\n\t\treturn false;\n\t}\n\t/* It's not safe to access *neighbor yet; must verify states first. */\n\tbool neighbor_is_head = contents.metadata.is_head;\n\tif (!extent_neighbor_head_state_mergeable(edata_is_head_get(edata),\n\t neighbor_is_head, forward)) {\n\t\treturn false;\n\t}\n\textent_state_t neighbor_state = contents.metadata.state;\n\tif (pai == EXTENT_PAI_PAC) {\n\t\tif (neighbor_state != expected_state) {\n\t\t\treturn false;\n\t\t}\n\t\t/* From this point, it's safe to access *neighbor. */\n\t\tif (!expanding && (edata_committed_get(edata) !=\n\t\t edata_committed_get(neighbor))) {\n\t\t\t/*\n\t\t\t * Some platforms (e.g. Windows) require an explicit\n\t\t\t * commit step (and writing to uncommitted memory is not\n\t\t\t * allowed).\n\t\t\t */\n\t\t\treturn false;\n\t\t}\n\t} else {\n\t\tif (neighbor_state == extent_state_active) {\n\t\t\treturn false;\n\t\t}\n\t\t/* From this point, it's safe to access *neighbor. */\n\t}\n\n\tassert(edata_pai_get(edata) == pai);\n\tif (edata_pai_get(neighbor) != pai) {\n\t\treturn false;\n\t}\n\tif (opt_retain) {\n\t\tassert(edata_arena_ind_get(edata) ==\n\t\t edata_arena_ind_get(neighbor));\n\t} else {\n\t\tif (edata_arena_ind_get(edata) !=\n\t\t edata_arena_ind_get(neighbor)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\tassert(!edata_guarded_get(edata) && !edata_guarded_get(neighbor));\n\n\treturn true;\n}\n\n#endif /* JEMALLOC_INTERNAL_EXTENT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/extent_dss.h", "content": "#ifndef JEMALLOC_INTERNAL_EXTENT_DSS_H\n#define JEMALLOC_INTERNAL_EXTENT_DSS_H\n\ntypedef enum {\n\tdss_prec_disabled = 0,\n\tdss_prec_primary = 1,\n\tdss_prec_secondary = 2,\n\n\tdss_prec_limit = 3\n} dss_prec_t;\n#define DSS_PREC_DEFAULT dss_prec_secondary\n#define DSS_DEFAULT \"secondary\"\n\nextern const char *dss_prec_names[];\n\nextern const char *opt_dss;\n\ndss_prec_t extent_dss_prec_get(void);\nbool extent_dss_prec_set(dss_prec_t dss_prec);\nvoid *extent_alloc_dss(tsdn_t *tsdn, arena_t *arena, void *new_addr,\n size_t size, size_t alignment, bool *zero, bool *commit);\nbool extent_in_dss(void *addr);\nbool extent_dss_mergeable(void *addr_a, void *addr_b);\nvoid extent_dss_boot(void);\n\n#endif /* JEMALLOC_INTERNAL_EXTENT_DSS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/extent_mmap.h", "content": "#ifndef JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n\nextern bool opt_retain;\n\nvoid *extent_alloc_mmap(void *new_addr, size_t size, size_t alignment,\n bool *zero, bool *commit);\nbool extent_dalloc_mmap(void *addr, size_t size);\n\n#endif /* JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/fb.h", "content": "#ifndef JEMALLOC_INTERNAL_FB_H\n#define JEMALLOC_INTERNAL_FB_H\n\n/*\n * The flat bitmap module. This has a larger API relative to the bitmap module\n * (supporting things like backwards searches, and searching for both set and\n * unset bits), at the cost of slower operations for very large bitmaps.\n *\n * Initialized flat bitmaps start at all-zeros (all bits unset).\n */\n\ntypedef unsigned long fb_group_t;\n#define FB_GROUP_BITS (ZU(1) << (LG_SIZEOF_LONG + 3))\n#define FB_NGROUPS(nbits) ((nbits) / FB_GROUP_BITS \\\n + ((nbits) % FB_GROUP_BITS == 0 ? 0 : 1))\n\nstatic inline void\nfb_init(fb_group_t *fb, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tmemset(fb, 0, ngroups * sizeof(fb_group_t));\n}\n\nstatic inline bool\nfb_empty(fb_group_t *fb, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tfor (size_t i = 0; i < ngroups; i++) {\n\t\tif (fb[i] != 0) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\nstatic inline bool\nfb_full(fb_group_t *fb, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tsize_t trailing_bits = nbits % FB_GROUP_BITS;\n\tsize_t limit = (trailing_bits == 0 ? ngroups : ngroups - 1);\n\tfor (size_t i = 0; i < limit; i++) {\n\t\tif (fb[i] != ~(fb_group_t)0) {\n\t\t\treturn false;\n\t\t}\n\t}\n\tif (trailing_bits == 0) {\n\t\treturn true;\n\t}\n\treturn fb[ngroups - 1] == ((fb_group_t)1 << trailing_bits) - 1;\n}\n\nstatic inline bool\nfb_get(fb_group_t *fb, size_t nbits, size_t bit) {\n\tassert(bit < nbits);\n\tsize_t group_ind = bit / FB_GROUP_BITS;\n\tsize_t bit_ind = bit % FB_GROUP_BITS;\n\treturn (bool)(fb[group_ind] & ((fb_group_t)1 << bit_ind));\n}\n\nstatic inline void\nfb_set(fb_group_t *fb, size_t nbits, size_t bit) {\n\tassert(bit < nbits);\n\tsize_t group_ind = bit / FB_GROUP_BITS;\n\tsize_t bit_ind = bit % FB_GROUP_BITS;\n\tfb[group_ind] |= ((fb_group_t)1 << bit_ind);\n}\n\nstatic inline void\nfb_unset(fb_group_t *fb, size_t nbits, size_t bit) {\n\tassert(bit < nbits);\n\tsize_t group_ind = bit / FB_GROUP_BITS;\n\tsize_t bit_ind = bit % FB_GROUP_BITS;\n\tfb[group_ind] &= ~((fb_group_t)1 << bit_ind);\n}\n\n\n/*\n * Some implementation details. This visitation function lets us apply a group\n * visitor to each group in the bitmap (potentially modifying it). The mask\n * indicates which bits are logically part of the visitation.\n */\ntypedef void (*fb_group_visitor_t)(void *ctx, fb_group_t *fb, fb_group_t mask);\nJEMALLOC_ALWAYS_INLINE void\nfb_visit_impl(fb_group_t *fb, size_t nbits, fb_group_visitor_t visit, void *ctx,\n size_t start, size_t cnt) {\n\tassert(cnt > 0);\n\tassert(start + cnt <= nbits);\n\tsize_t group_ind = start / FB_GROUP_BITS;\n\tsize_t start_bit_ind = start % FB_GROUP_BITS;\n\t/*\n\t * The first group is special; it's the only one we don't start writing\n\t * to from bit 0.\n\t */\n\tsize_t first_group_cnt = (start_bit_ind + cnt > FB_GROUP_BITS\n\t\t? FB_GROUP_BITS - start_bit_ind : cnt);\n\t/*\n\t * We can basically split affected words into:\n\t * - The first group, where we touch only the high bits\n\t * - The last group, where we touch only the low bits\n\t * - The middle, where we set all the bits to the same thing.\n\t * We treat each case individually. The last two could be merged, but\n\t * this can lead to bad codegen for those middle words.\n\t */\n\t/* First group */\n\tfb_group_t mask = ((~(fb_group_t)0)\n\t >> (FB_GROUP_BITS - first_group_cnt))\n\t << start_bit_ind;\n\tvisit(ctx, &fb[group_ind], mask);\n\n\tcnt -= first_group_cnt;\n\tgroup_ind++;\n\t/* Middle groups */\n\twhile (cnt > FB_GROUP_BITS) {\n\t\tvisit(ctx, &fb[group_ind], ~(fb_group_t)0);\n\t\tcnt -= FB_GROUP_BITS;\n\t\tgroup_ind++;\n\t}\n\t/* Last group */\n\tif (cnt != 0) {\n\t\tmask = (~(fb_group_t)0) >> (FB_GROUP_BITS - cnt);\n\t\tvisit(ctx, &fb[group_ind], mask);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nfb_assign_visitor(void *ctx, fb_group_t *fb, fb_group_t mask) {\n\tbool val = *(bool *)ctx;\n\tif (val) {\n\t\t*fb |= mask;\n\t} else {\n\t\t*fb &= ~mask;\n\t}\n}\n\n/* Sets the cnt bits starting at position start. Must not have a 0 count. */\nstatic inline void\nfb_set_range(fb_group_t *fb, size_t nbits, size_t start, size_t cnt) {\n\tbool val = true;\n\tfb_visit_impl(fb, nbits, &fb_assign_visitor, &val, start, cnt);\n}\n\n/* Unsets the cnt bits starting at position start. Must not have a 0 count. */\nstatic inline void\nfb_unset_range(fb_group_t *fb, size_t nbits, size_t start, size_t cnt) {\n\tbool val = false;\n\tfb_visit_impl(fb, nbits, &fb_assign_visitor, &val, start, cnt);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nfb_scount_visitor(void *ctx, fb_group_t *fb, fb_group_t mask) {\n\tsize_t *scount = (size_t *)ctx;\n\t*scount += popcount_lu(*fb & mask);\n}\n\n/* Finds the number of set bit in the of length cnt starting at start. */\nJEMALLOC_ALWAYS_INLINE size_t\nfb_scount(fb_group_t *fb, size_t nbits, size_t start, size_t cnt) {\n\tsize_t scount = 0;\n\tfb_visit_impl(fb, nbits, &fb_scount_visitor, &scount, start, cnt);\n\treturn scount;\n}\n\n/* Finds the number of unset bit in the of length cnt starting at start. */\nJEMALLOC_ALWAYS_INLINE size_t\nfb_ucount(fb_group_t *fb, size_t nbits, size_t start, size_t cnt) {\n\tsize_t scount = fb_scount(fb, nbits, start, cnt);\n\treturn cnt - scount;\n}\n\n/*\n * An implementation detail; find the first bit at position >= min_bit with the\n * value val.\n *\n * Returns the number of bits in the bitmap if no such bit exists.\n */\nJEMALLOC_ALWAYS_INLINE ssize_t\nfb_find_impl(fb_group_t *fb, size_t nbits, size_t start, bool val,\n bool forward) {\n\tassert(start < nbits);\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tssize_t group_ind = start / FB_GROUP_BITS;\n\tsize_t bit_ind = start % FB_GROUP_BITS;\n\n\tfb_group_t maybe_invert = (val ? 0 : (fb_group_t)-1);\n\n\tfb_group_t group = fb[group_ind];\n\tgroup ^= maybe_invert;\n\tif (forward) {\n\t\t/* Only keep ones in bits bit_ind and above. */\n\t\tgroup &= ~((1LU << bit_ind) - 1);\n\t} else {\n\t\t/*\n\t\t * Only keep ones in bits bit_ind and below. You might more\n\t\t * naturally express this as (1 << (bit_ind + 1)) - 1, but\n\t\t * that shifts by an invalid amount if bit_ind is one less than\n\t\t * FB_GROUP_BITS.\n\t\t */\n\t\tgroup &= ((2LU << bit_ind) - 1);\n\t}\n\tssize_t group_ind_bound = forward ? (ssize_t)ngroups : -1;\n\twhile (group == 0) {\n\t\tgroup_ind += forward ? 1 : -1;\n\t\tif (group_ind == group_ind_bound) {\n\t\t\treturn forward ? (ssize_t)nbits : (ssize_t)-1;\n\t\t}\n\t\tgroup = fb[group_ind];\n\t\tgroup ^= maybe_invert;\n\t}\n\tassert(group != 0);\n\tsize_t bit = forward ? ffs_lu(group) : fls_lu(group);\n\tsize_t pos = group_ind * FB_GROUP_BITS + bit;\n\t/*\n\t * The high bits of a partially filled last group are zeros, so if we're\n\t * looking for zeros we don't want to report an invalid result.\n\t */\n\tif (forward && !val && pos > nbits) {\n\t\treturn nbits;\n\t}\n\treturn pos;\n}\n\n/*\n * Find the first set bit in the bitmap with an index >= min_bit. Returns the\n * number of bits in the bitmap if no such bit exists.\n */\nstatic inline size_t\nfb_ffu(fb_group_t *fb, size_t nbits, size_t min_bit) {\n\treturn (size_t)fb_find_impl(fb, nbits, min_bit, /* val */ false,\n\t /* forward */ true);\n}\n\n/* The same, but looks for an unset bit. */\nstatic inline size_t\nfb_ffs(fb_group_t *fb, size_t nbits, size_t min_bit) {\n\treturn (size_t)fb_find_impl(fb, nbits, min_bit, /* val */ true,\n\t /* forward */ true);\n}\n\n/*\n * Find the last set bit in the bitmap with an index <= max_bit. Returns -1 if\n * no such bit exists.\n */\nstatic inline ssize_t\nfb_flu(fb_group_t *fb, size_t nbits, size_t max_bit) {\n\treturn fb_find_impl(fb, nbits, max_bit, /* val */ false,\n\t /* forward */ false);\n}\n\nstatic inline ssize_t\nfb_fls(fb_group_t *fb, size_t nbits, size_t max_bit) {\n\treturn fb_find_impl(fb, nbits, max_bit, /* val */ true,\n\t /* forward */ false);\n}\n\n/* Returns whether or not we found a range. */\nJEMALLOC_ALWAYS_INLINE bool\nfb_iter_range_impl(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len, bool val, bool forward) {\n\tassert(start < nbits);\n\tssize_t next_range_begin = fb_find_impl(fb, nbits, start, val, forward);\n\tif ((forward && next_range_begin == (ssize_t)nbits)\n\t || (!forward && next_range_begin == (ssize_t)-1)) {\n\t\treturn false;\n\t}\n\t/* Half open range; the set bits are [begin, end). */\n\tssize_t next_range_end = fb_find_impl(fb, nbits, next_range_begin, !val,\n\t forward);\n\tif (forward) {\n\t\t*r_begin = next_range_begin;\n\t\t*r_len = next_range_end - next_range_begin;\n\t} else {\n\t\t*r_begin = next_range_end + 1;\n\t\t*r_len = next_range_begin - next_range_end;\n\t}\n\treturn true;\n}\n\n/*\n * Used to iterate through ranges of set bits.\n *\n * Tries to find the next contiguous sequence of set bits with a first index >=\n * start. If one exists, puts the earliest bit of the range in *r_begin, its\n * length in *r_len, and returns true. Otherwise, returns false (without\n * touching *r_begin or *r_end).\n */\nstatic inline bool\nfb_srange_iter(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len) {\n\treturn fb_iter_range_impl(fb, nbits, start, r_begin, r_len,\n\t /* val */ true, /* forward */ true);\n}\n\n/*\n * The same as fb_srange_iter, but searches backwards from start rather than\n * forwards. (The position returned is still the earliest bit in the range).\n */\nstatic inline bool\nfb_srange_riter(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len) {\n\treturn fb_iter_range_impl(fb, nbits, start, r_begin, r_len,\n\t /* val */ true, /* forward */ false);\n}\n\n/* Similar to fb_srange_iter, but searches for unset bits. */\nstatic inline bool\nfb_urange_iter(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len) {\n\treturn fb_iter_range_impl(fb, nbits, start, r_begin, r_len,\n\t /* val */ false, /* forward */ true);\n}\n\n/* Similar to fb_srange_riter, but searches for unset bits. */\nstatic inline bool\nfb_urange_riter(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len) {\n\treturn fb_iter_range_impl(fb, nbits, start, r_begin, r_len,\n\t /* val */ false, /* forward */ false);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nfb_range_longest_impl(fb_group_t *fb, size_t nbits, bool val) {\n\tsize_t begin = 0;\n\tsize_t longest_len = 0;\n\tsize_t len = 0;\n\twhile (begin < nbits && fb_iter_range_impl(fb, nbits, begin, &begin,\n\t &len, val, /* forward */ true)) {\n\t\tif (len > longest_len) {\n\t\t\tlongest_len = len;\n\t\t}\n\t\tbegin += len;\n\t}\n\treturn longest_len;\n}\n\nstatic inline size_t\nfb_srange_longest(fb_group_t *fb, size_t nbits) {\n\treturn fb_range_longest_impl(fb, nbits, /* val */ true);\n}\n\nstatic inline size_t\nfb_urange_longest(fb_group_t *fb, size_t nbits) {\n\treturn fb_range_longest_impl(fb, nbits, /* val */ false);\n}\n\n/*\n * Initializes each bit of dst with the bitwise-AND of the corresponding bits of\n * src1 and src2. All bitmaps must be the same size.\n */\nstatic inline void\nfb_bit_and(fb_group_t *dst, fb_group_t *src1, fb_group_t *src2, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tfor (size_t i = 0; i < ngroups; i++) {\n\t\tdst[i] = src1[i] & src2[i];\n\t}\n}\n\n/* Like fb_bit_and, but with bitwise-OR. */\nstatic inline void\nfb_bit_or(fb_group_t *dst, fb_group_t *src1, fb_group_t *src2, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tfor (size_t i = 0; i < ngroups; i++) {\n\t\tdst[i] = src1[i] | src2[i];\n\t}\n}\n\n/* Initializes dst bit i to the negation of source bit i. */\nstatic inline void\nfb_bit_not(fb_group_t *dst, fb_group_t *src, size_t nbits) {\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tfor (size_t i = 0; i < ngroups; i++) {\n\t\tdst[i] = ~src[i];\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_FB_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/fxp.h", "content": "#ifndef JEMALLOC_INTERNAL_FXP_H\n#define JEMALLOC_INTERNAL_FXP_H\n\n/*\n * A simple fixed-point math implementation, supporting only unsigned values\n * (with overflow being an error).\n *\n * It's not in general safe to use floating point in core code, because various\n * libc implementations we get linked against can assume that malloc won't touch\n * floating point state and call it with an unusual calling convention.\n */\n\n/*\n * High 16 bits are the integer part, low 16 are the fractional part. Or\n * equivalently, repr == 2**16 * val, where we use \"val\" to refer to the\n * (imaginary) fractional representation of the true value.\n *\n * We pick a uint32_t here since it's convenient in some places to\n * double the representation size (i.e. multiplication and division use\n * 64-bit integer types), and a uint64_t is the largest type we're\n * certain is available.\n */\ntypedef uint32_t fxp_t;\n#define FXP_INIT_INT(x) ((x) << 16)\n#define FXP_INIT_PERCENT(pct) (((pct) << 16) / 100)\n\n/*\n * Amount of precision used in parsing and printing numbers. The integer bound\n * is simply because the integer part of the number gets 16 bits, and so is\n * bounded by 65536.\n *\n * We use a lot of precision for the fractional part, even though most of it\n * gets rounded off; this lets us get exact values for the important special\n * case where the denominator is a small power of 2 (for instance,\n * 1/512 == 0.001953125 is exactly representable even with only 16 bits of\n * fractional precision). We need to left-shift by 16 before dividing by\n * 10**precision, so we pick precision to be floor(log(2**48)) = 14.\n */\n#define FXP_INTEGER_PART_DIGITS 5\n#define FXP_FRACTIONAL_PART_DIGITS 14\n\n/*\n * In addition to the integer and fractional parts of the number, we need to\n * include a null character and (possibly) a decimal point.\n */\n#define FXP_BUF_SIZE (FXP_INTEGER_PART_DIGITS + FXP_FRACTIONAL_PART_DIGITS + 2)\n\nstatic inline fxp_t\nfxp_add(fxp_t a, fxp_t b) {\n\treturn a + b;\n}\n\nstatic inline fxp_t\nfxp_sub(fxp_t a, fxp_t b) {\n\tassert(a >= b);\n\treturn a - b;\n}\n\nstatic inline fxp_t\nfxp_mul(fxp_t a, fxp_t b) {\n\tuint64_t unshifted = (uint64_t)a * (uint64_t)b;\n\t/*\n\t * Unshifted is (a.val * 2**16) * (b.val * 2**16)\n\t * == (a.val * b.val) * 2**32, but we want\n\t * (a.val * b.val) * 2 ** 16.\n\t */\n\treturn (uint32_t)(unshifted >> 16);\n}\n\nstatic inline fxp_t\nfxp_div(fxp_t a, fxp_t b) {\n\tassert(b != 0);\n\tuint64_t unshifted = ((uint64_t)a << 32) / (uint64_t)b;\n\t/*\n\t * Unshifted is (a.val * 2**16) * (2**32) / (b.val * 2**16)\n\t * == (a.val / b.val) * (2 ** 32), which again corresponds to a right\n\t * shift of 16.\n\t */\n\treturn (uint32_t)(unshifted >> 16);\n}\n\nstatic inline uint32_t\nfxp_round_down(fxp_t a) {\n\treturn a >> 16;\n}\n\nstatic inline uint32_t\nfxp_round_nearest(fxp_t a) {\n\tuint32_t fractional_part = (a & ((1U << 16) - 1));\n\tuint32_t increment = (uint32_t)(fractional_part >= (1U << 15));\n\treturn (a >> 16) + increment;\n}\n\n/*\n * Approximately computes x * frac, without the size limitations that would be\n * imposed by converting u to an fxp_t.\n */\nstatic inline size_t\nfxp_mul_frac(size_t x_orig, fxp_t frac) {\n\tassert(frac <= (1U << 16));\n\t/*\n\t * Work around an over-enthusiastic warning about type limits below (on\n\t * 32-bit platforms, a size_t is always less than 1ULL << 48).\n\t */\n\tuint64_t x = (uint64_t)x_orig;\n\t/*\n\t * If we can guarantee no overflow, multiply first before shifting, to\n\t * preserve some precision. Otherwise, shift first and then multiply.\n\t * In the latter case, we only lose the low 16 bits of a 48-bit number,\n\t * so we're still accurate to within 1/2**32.\n\t */\n\tif (x < (1ULL << 48)) {\n\t\treturn (size_t)((x * frac) >> 16);\n\t} else {\n\t\treturn (size_t)((x >> 16) * (uint64_t)frac);\n\t}\n}\n\n/*\n * Returns true on error. Otherwise, returns false and updates *ptr to point to\n * the first character not parsed (because it wasn't a digit).\n */\nbool fxp_parse(fxp_t *a, const char *ptr, char **end);\nvoid fxp_print(fxp_t a, char buf[FXP_BUF_SIZE]);\n\n#endif /* JEMALLOC_INTERNAL_FXP_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hash.h", "content": "#ifndef JEMALLOC_INTERNAL_HASH_H\n#define JEMALLOC_INTERNAL_HASH_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * The following hash function is based on MurmurHash3, placed into the public\n * domain by Austin Appleby. See https://github.com/aappleby/smhasher for\n * details.\n */\n\n/******************************************************************************/\n/* Internal implementation. */\nstatic inline uint32_t\nhash_rotl_32(uint32_t x, int8_t r) {\n\treturn ((x << r) | (x >> (32 - r)));\n}\n\nstatic inline uint64_t\nhash_rotl_64(uint64_t x, int8_t r) {\n\treturn ((x << r) | (x >> (64 - r)));\n}\n\nstatic inline uint32_t\nhash_get_block_32(const uint32_t *p, int i) {\n\t/* Handle unaligned read. */\n\tif (unlikely((uintptr_t)p & (sizeof(uint32_t)-1)) != 0) {\n\t\tuint32_t ret;\n\n\t\tmemcpy(&ret, (uint8_t *)(p + i), sizeof(uint32_t));\n\t\treturn ret;\n\t}\n\n\treturn p[i];\n}\n\nstatic inline uint64_t\nhash_get_block_64(const uint64_t *p, int i) {\n\t/* Handle unaligned read. */\n\tif (unlikely((uintptr_t)p & (sizeof(uint64_t)-1)) != 0) {\n\t\tuint64_t ret;\n\n\t\tmemcpy(&ret, (uint8_t *)(p + i), sizeof(uint64_t));\n\t\treturn ret;\n\t}\n\n\treturn p[i];\n}\n\nstatic inline uint32_t\nhash_fmix_32(uint32_t h) {\n\th ^= h >> 16;\n\th *= 0x85ebca6b;\n\th ^= h >> 13;\n\th *= 0xc2b2ae35;\n\th ^= h >> 16;\n\n\treturn h;\n}\n\nstatic inline uint64_t\nhash_fmix_64(uint64_t k) {\n\tk ^= k >> 33;\n\tk *= KQU(0xff51afd7ed558ccd);\n\tk ^= k >> 33;\n\tk *= KQU(0xc4ceb9fe1a85ec53);\n\tk ^= k >> 33;\n\n\treturn k;\n}\n\nstatic inline uint32_t\nhash_x86_32(const void *key, int len, uint32_t seed) {\n\tconst uint8_t *data = (const uint8_t *) key;\n\tconst int nblocks = len / 4;\n\n\tuint32_t h1 = seed;\n\n\tconst uint32_t c1 = 0xcc9e2d51;\n\tconst uint32_t c2 = 0x1b873593;\n\n\t/* body */\n\t{\n\t\tconst uint32_t *blocks = (const uint32_t *) (data + nblocks*4);\n\t\tint i;\n\n\t\tfor (i = -nblocks; i; i++) {\n\t\t\tuint32_t k1 = hash_get_block_32(blocks, i);\n\n\t\t\tk1 *= c1;\n\t\t\tk1 = hash_rotl_32(k1, 15);\n\t\t\tk1 *= c2;\n\n\t\t\th1 ^= k1;\n\t\t\th1 = hash_rotl_32(h1, 13);\n\t\t\th1 = h1*5 + 0xe6546b64;\n\t\t}\n\t}\n\n\t/* tail */\n\t{\n\t\tconst uint8_t *tail = (const uint8_t *) (data + nblocks*4);\n\n\t\tuint32_t k1 = 0;\n\n\t\tswitch (len & 3) {\n\t\tcase 3: k1 ^= tail[2] << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 2: k1 ^= tail[1] << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 1: k1 ^= tail[0]; k1 *= c1; k1 = hash_rotl_32(k1, 15);\n\t\t\tk1 *= c2; h1 ^= k1;\n\t\t}\n\t}\n\n\t/* finalization */\n\th1 ^= len;\n\n\th1 = hash_fmix_32(h1);\n\n\treturn h1;\n}\n\nstatic inline void\nhash_x86_128(const void *key, const int len, uint32_t seed,\n uint64_t r_out[2]) {\n\tconst uint8_t * data = (const uint8_t *) key;\n\tconst int nblocks = len / 16;\n\n\tuint32_t h1 = seed;\n\tuint32_t h2 = seed;\n\tuint32_t h3 = seed;\n\tuint32_t h4 = seed;\n\n\tconst uint32_t c1 = 0x239b961b;\n\tconst uint32_t c2 = 0xab0e9789;\n\tconst uint32_t c3 = 0x38b34ae5;\n\tconst uint32_t c4 = 0xa1e38b93;\n\n\t/* body */\n\t{\n\t\tconst uint32_t *blocks = (const uint32_t *) (data + nblocks*16);\n\t\tint i;\n\n\t\tfor (i = -nblocks; i; i++) {\n\t\t\tuint32_t k1 = hash_get_block_32(blocks, i*4 + 0);\n\t\t\tuint32_t k2 = hash_get_block_32(blocks, i*4 + 1);\n\t\t\tuint32_t k3 = hash_get_block_32(blocks, i*4 + 2);\n\t\t\tuint32_t k4 = hash_get_block_32(blocks, i*4 + 3);\n\n\t\t\tk1 *= c1; k1 = hash_rotl_32(k1, 15); k1 *= c2; h1 ^= k1;\n\n\t\t\th1 = hash_rotl_32(h1, 19); h1 += h2;\n\t\t\th1 = h1*5 + 0x561ccd1b;\n\n\t\t\tk2 *= c2; k2 = hash_rotl_32(k2, 16); k2 *= c3; h2 ^= k2;\n\n\t\t\th2 = hash_rotl_32(h2, 17); h2 += h3;\n\t\t\th2 = h2*5 + 0x0bcaa747;\n\n\t\t\tk3 *= c3; k3 = hash_rotl_32(k3, 17); k3 *= c4; h3 ^= k3;\n\n\t\t\th3 = hash_rotl_32(h3, 15); h3 += h4;\n\t\t\th3 = h3*5 + 0x96cd1c35;\n\n\t\t\tk4 *= c4; k4 = hash_rotl_32(k4, 18); k4 *= c1; h4 ^= k4;\n\n\t\t\th4 = hash_rotl_32(h4, 13); h4 += h1;\n\t\t\th4 = h4*5 + 0x32ac3b17;\n\t\t}\n\t}\n\n\t/* tail */\n\t{\n\t\tconst uint8_t *tail = (const uint8_t *) (data + nblocks*16);\n\t\tuint32_t k1 = 0;\n\t\tuint32_t k2 = 0;\n\t\tuint32_t k3 = 0;\n\t\tuint32_t k4 = 0;\n\n\t\tswitch (len & 15) {\n\t\tcase 15: k4 ^= tail[14] << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 14: k4 ^= tail[13] << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 13: k4 ^= tail[12] << 0;\n\t\t\tk4 *= c4; k4 = hash_rotl_32(k4, 18); k4 *= c1; h4 ^= k4;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase 12: k3 ^= (uint32_t) tail[11] << 24; JEMALLOC_FALLTHROUGH;\n\t\tcase 11: k3 ^= tail[10] << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 10: k3 ^= tail[ 9] << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 9: k3 ^= tail[ 8] << 0;\n\t\t\tk3 *= c3; k3 = hash_rotl_32(k3, 17); k3 *= c4; h3 ^= k3;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase 8: k2 ^= (uint32_t) tail[ 7] << 24; JEMALLOC_FALLTHROUGH;\n\t\tcase 7: k2 ^= tail[ 6] << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 6: k2 ^= tail[ 5] << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 5: k2 ^= tail[ 4] << 0;\n\t\t\tk2 *= c2; k2 = hash_rotl_32(k2, 16); k2 *= c3; h2 ^= k2;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase 4: k1 ^= (uint32_t) tail[ 3] << 24; JEMALLOC_FALLTHROUGH;\n\t\tcase 3: k1 ^= tail[ 2] << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 2: k1 ^= tail[ 1] << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 1: k1 ^= tail[ 0] << 0;\n\t\t\tk1 *= c1; k1 = hash_rotl_32(k1, 15); k1 *= c2; h1 ^= k1;\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t/* finalization */\n\th1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;\n\n\th1 += h2; h1 += h3; h1 += h4;\n\th2 += h1; h3 += h1; h4 += h1;\n\n\th1 = hash_fmix_32(h1);\n\th2 = hash_fmix_32(h2);\n\th3 = hash_fmix_32(h3);\n\th4 = hash_fmix_32(h4);\n\n\th1 += h2; h1 += h3; h1 += h4;\n\th2 += h1; h3 += h1; h4 += h1;\n\n\tr_out[0] = (((uint64_t) h2) << 32) | h1;\n\tr_out[1] = (((uint64_t) h4) << 32) | h3;\n}\n\nstatic inline void\nhash_x64_128(const void *key, const int len, const uint32_t seed,\n uint64_t r_out[2]) {\n\tconst uint8_t *data = (const uint8_t *) key;\n\tconst int nblocks = len / 16;\n\n\tuint64_t h1 = seed;\n\tuint64_t h2 = seed;\n\n\tconst uint64_t c1 = KQU(0x87c37b91114253d5);\n\tconst uint64_t c2 = KQU(0x4cf5ad432745937f);\n\n\t/* body */\n\t{\n\t\tconst uint64_t *blocks = (const uint64_t *) (data);\n\t\tint i;\n\n\t\tfor (i = 0; i < nblocks; i++) {\n\t\t\tuint64_t k1 = hash_get_block_64(blocks, i*2 + 0);\n\t\t\tuint64_t k2 = hash_get_block_64(blocks, i*2 + 1);\n\n\t\t\tk1 *= c1; k1 = hash_rotl_64(k1, 31); k1 *= c2; h1 ^= k1;\n\n\t\t\th1 = hash_rotl_64(h1, 27); h1 += h2;\n\t\t\th1 = h1*5 + 0x52dce729;\n\n\t\t\tk2 *= c2; k2 = hash_rotl_64(k2, 33); k2 *= c1; h2 ^= k2;\n\n\t\t\th2 = hash_rotl_64(h2, 31); h2 += h1;\n\t\t\th2 = h2*5 + 0x38495ab5;\n\t\t}\n\t}\n\n\t/* tail */\n\t{\n\t\tconst uint8_t *tail = (const uint8_t*)(data + nblocks*16);\n\t\tuint64_t k1 = 0;\n\t\tuint64_t k2 = 0;\n\n\t\tswitch (len & 15) {\n\t\tcase 15: k2 ^= ((uint64_t)(tail[14])) << 48; JEMALLOC_FALLTHROUGH;\n\t\tcase 14: k2 ^= ((uint64_t)(tail[13])) << 40; JEMALLOC_FALLTHROUGH;\n\t\tcase 13: k2 ^= ((uint64_t)(tail[12])) << 32; JEMALLOC_FALLTHROUGH;\n\t\tcase 12: k2 ^= ((uint64_t)(tail[11])) << 24; JEMALLOC_FALLTHROUGH;\n\t\tcase 11: k2 ^= ((uint64_t)(tail[10])) << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 10: k2 ^= ((uint64_t)(tail[ 9])) << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 9: k2 ^= ((uint64_t)(tail[ 8])) << 0;\n\t\t\tk2 *= c2; k2 = hash_rotl_64(k2, 33); k2 *= c1; h2 ^= k2;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase 8: k1 ^= ((uint64_t)(tail[ 7])) << 56; JEMALLOC_FALLTHROUGH;\n\t\tcase 7: k1 ^= ((uint64_t)(tail[ 6])) << 48; JEMALLOC_FALLTHROUGH;\n\t\tcase 6: k1 ^= ((uint64_t)(tail[ 5])) << 40; JEMALLOC_FALLTHROUGH;\n\t\tcase 5: k1 ^= ((uint64_t)(tail[ 4])) << 32; JEMALLOC_FALLTHROUGH;\n\t\tcase 4: k1 ^= ((uint64_t)(tail[ 3])) << 24; JEMALLOC_FALLTHROUGH;\n\t\tcase 3: k1 ^= ((uint64_t)(tail[ 2])) << 16; JEMALLOC_FALLTHROUGH;\n\t\tcase 2: k1 ^= ((uint64_t)(tail[ 1])) << 8; JEMALLOC_FALLTHROUGH;\n\t\tcase 1: k1 ^= ((uint64_t)(tail[ 0])) << 0;\n\t\t\tk1 *= c1; k1 = hash_rotl_64(k1, 31); k1 *= c2; h1 ^= k1;\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t/* finalization */\n\th1 ^= len; h2 ^= len;\n\n\th1 += h2;\n\th2 += h1;\n\n\th1 = hash_fmix_64(h1);\n\th2 = hash_fmix_64(h2);\n\n\th1 += h2;\n\th2 += h1;\n\n\tr_out[0] = h1;\n\tr_out[1] = h2;\n}\n\n/******************************************************************************/\n/* API. */\nstatic inline void\nhash(const void *key, size_t len, const uint32_t seed, size_t r_hash[2]) {\n\tassert(len <= INT_MAX); /* Unfortunate implementation limitation. */\n\n#if (LG_SIZEOF_PTR == 3 && !defined(JEMALLOC_BIG_ENDIAN))\n\thash_x64_128(key, (int)len, seed, (uint64_t *)r_hash);\n#else\n\t{\n\t\tuint64_t hashes[2];\n\t\thash_x86_128(key, (int)len, seed, hashes);\n\t\tr_hash[0] = (size_t)hashes[0];\n\t\tr_hash[1] = (size_t)hashes[1];\n\t}\n#endif\n}\n\n#endif /* JEMALLOC_INTERNAL_HASH_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hook.h", "content": "#ifndef JEMALLOC_INTERNAL_HOOK_H\n#define JEMALLOC_INTERNAL_HOOK_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/*\n * This API is *extremely* experimental, and may get ripped out, changed in API-\n * and ABI-incompatible ways, be insufficiently or incorrectly documented, etc.\n *\n * It allows hooking the stateful parts of the API to see changes as they\n * happen.\n *\n * Allocation hooks are called after the allocation is done, free hooks are\n * called before the free is done, and expand hooks are called after the\n * allocation is expanded.\n *\n * For realloc and rallocx, if the expansion happens in place, the expansion\n * hook is called. If it is moved, then the alloc hook is called on the new\n * location, and then the free hook is called on the old location (i.e. both\n * hooks are invoked in between the alloc and the dalloc).\n *\n * If we return NULL from OOM, then usize might not be trustworthy. Calling\n * realloc(NULL, size) only calls the alloc hook, and calling realloc(ptr, 0)\n * only calls the free hook. (Calling realloc(NULL, 0) is treated as malloc(0),\n * and only calls the alloc hook).\n *\n * Reentrancy:\n * Reentrancy is guarded against from within the hook implementation. If you\n * call allocator functions from within a hook, the hooks will not be invoked\n * again.\n * Threading:\n * The installation of a hook synchronizes with all its uses. If you can\n * prove the installation of a hook happens-before a jemalloc entry point,\n * then the hook will get invoked (unless there's a racing removal).\n *\n * Hook insertion appears to be atomic at a per-thread level (i.e. if a thread\n * allocates and has the alloc hook invoked, then a subsequent free on the\n * same thread will also have the free hook invoked).\n *\n * The *removal* of a hook does *not* block until all threads are done with\n * the hook. Hook authors have to be resilient to this, and need some\n * out-of-band mechanism for cleaning up any dynamically allocated memory\n * associated with their hook.\n * Ordering:\n * Order of hook execution is unspecified, and may be different than insertion\n * order.\n */\n\n#define HOOK_MAX 4\n\nenum hook_alloc_e {\n\thook_alloc_malloc,\n\thook_alloc_posix_memalign,\n\thook_alloc_aligned_alloc,\n\thook_alloc_calloc,\n\thook_alloc_memalign,\n\thook_alloc_valloc,\n\thook_alloc_mallocx,\n\n\t/* The reallocating functions have both alloc and dalloc variants */\n\thook_alloc_realloc,\n\thook_alloc_rallocx,\n};\n/*\n * We put the enum typedef after the enum, since this file may get included by\n * jemalloc_cpp.cpp, and C++ disallows enum forward declarations.\n */\ntypedef enum hook_alloc_e hook_alloc_t;\n\nenum hook_dalloc_e {\n\thook_dalloc_free,\n\thook_dalloc_dallocx,\n\thook_dalloc_sdallocx,\n\n\t/*\n\t * The dalloc halves of reallocation (not called if in-place expansion\n\t * happens).\n\t */\n\thook_dalloc_realloc,\n\thook_dalloc_rallocx,\n};\ntypedef enum hook_dalloc_e hook_dalloc_t;\n\n\nenum hook_expand_e {\n\thook_expand_realloc,\n\thook_expand_rallocx,\n\thook_expand_xallocx,\n};\ntypedef enum hook_expand_e hook_expand_t;\n\ntypedef void (*hook_alloc)(\n void *extra, hook_alloc_t type, void *result, uintptr_t result_raw,\n uintptr_t args_raw[3]);\n\ntypedef void (*hook_dalloc)(\n void *extra, hook_dalloc_t type, void *address, uintptr_t args_raw[3]);\n\ntypedef void (*hook_expand)(\n void *extra, hook_expand_t type, void *address, size_t old_usize,\n size_t new_usize, uintptr_t result_raw, uintptr_t args_raw[4]);\n\ntypedef struct hooks_s hooks_t;\nstruct hooks_s {\n\thook_alloc alloc_hook;\n\thook_dalloc dalloc_hook;\n\thook_expand expand_hook;\n\tvoid *extra;\n};\n\n/*\n * Begin implementation details; everything above this point might one day live\n * in a public API. Everything below this point never will.\n */\n\n/*\n * The realloc pathways haven't gotten any refactoring love in a while, and it's\n * fairly difficult to pass information from the entry point to the hooks. We\n * put the informaiton the hooks will need into a struct to encapsulate\n * everything.\n *\n * Much of these pathways are force-inlined, so that the compiler can avoid\n * materializing this struct until we hit an extern arena function. For fairly\n * goofy reasons, *many* of the realloc paths hit an extern arena function.\n * These paths are cold enough that it doesn't matter; eventually, we should\n * rewrite the realloc code to make the expand-in-place and the\n * free-then-realloc paths more orthogonal, at which point we don't need to\n * spread the hook logic all over the place.\n */\ntypedef struct hook_ralloc_args_s hook_ralloc_args_t;\nstruct hook_ralloc_args_s {\n\t/* I.e. as opposed to rallocx. */\n\tbool is_realloc;\n\t/*\n\t * The expand hook takes 4 arguments, even if only 3 are actually used;\n\t * we add an extra one in case the user decides to memcpy without\n\t * looking too closely at the hooked function.\n\t */\n\tuintptr_t args[4];\n};\n\n/*\n * Returns an opaque handle to be used when removing the hook. NULL means that\n * we couldn't install the hook.\n */\nbool hook_boot();\n\nvoid *hook_install(tsdn_t *tsdn, hooks_t *hooks);\n/* Uninstalls the hook with the handle previously returned from hook_install. */\nvoid hook_remove(tsdn_t *tsdn, void *opaque);\n\n/* Hooks */\n\nvoid hook_invoke_alloc(hook_alloc_t type, void *result, uintptr_t result_raw,\n uintptr_t args_raw[3]);\n\nvoid hook_invoke_dalloc(hook_dalloc_t type, void *address,\n uintptr_t args_raw[3]);\n\nvoid hook_invoke_expand(hook_expand_t type, void *address, size_t old_usize,\n size_t new_usize, uintptr_t result_raw, uintptr_t args_raw[4]);\n\n#endif /* JEMALLOC_INTERNAL_HOOK_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hpa.h", "content": "#ifndef JEMALLOC_INTERNAL_HPA_H\n#define JEMALLOC_INTERNAL_HPA_H\n\n#include \"jemalloc/internal/exp_grow.h\"\n#include \"jemalloc/internal/hpa_hooks.h\"\n#include \"jemalloc/internal/hpa_opts.h\"\n#include \"jemalloc/internal/pai.h\"\n#include \"jemalloc/internal/psset.h\"\n\ntypedef struct hpa_central_s hpa_central_t;\nstruct hpa_central_s {\n\t/*\n\t * The mutex guarding most of the operations on the central data\n\t * structure.\n\t */\n\tmalloc_mutex_t mtx;\n\t/*\n\t * Guards expansion of eden. We separate this from the regular mutex so\n\t * that cheaper operations can still continue while we're doing the OS\n\t * call.\n\t */\n\tmalloc_mutex_t grow_mtx;\n\t/*\n\t * Either NULL (if empty), or some integer multiple of a\n\t * hugepage-aligned number of hugepages. We carve them off one at a\n\t * time to satisfy new pageslab requests.\n\t *\n\t * Guarded by grow_mtx.\n\t */\n\tvoid *eden;\n\tsize_t eden_len;\n\t/* Source for metadata. */\n\tbase_t *base;\n\t/* Number of grow operations done on this hpa_central_t. */\n\tuint64_t age_counter;\n\n\t/* The HPA hooks. */\n\thpa_hooks_t hooks;\n};\n\ntypedef struct hpa_shard_nonderived_stats_s hpa_shard_nonderived_stats_t;\nstruct hpa_shard_nonderived_stats_s {\n\t/*\n\t * The number of times we've purged within a hugepage.\n\t *\n\t * Guarded by mtx.\n\t */\n\tuint64_t npurge_passes;\n\t/*\n\t * The number of individual purge calls we perform (which should always\n\t * be bigger than npurge_passes, since each pass purges at least one\n\t * extent within a hugepage.\n\t *\n\t * Guarded by mtx.\n\t */\n\tuint64_t npurges;\n\n\t/*\n\t * The number of times we've hugified a pageslab.\n\t *\n\t * Guarded by mtx.\n\t */\n\tuint64_t nhugifies;\n\t/*\n\t * The number of times we've dehugified a pageslab.\n\t *\n\t * Guarded by mtx.\n\t */\n\tuint64_t ndehugifies;\n};\n\n/* Completely derived; only used by CTL. */\ntypedef struct hpa_shard_stats_s hpa_shard_stats_t;\nstruct hpa_shard_stats_s {\n\tpsset_stats_t psset_stats;\n\thpa_shard_nonderived_stats_t nonderived_stats;\n};\n\ntypedef struct hpa_shard_s hpa_shard_t;\nstruct hpa_shard_s {\n\t/*\n\t * pai must be the first member; we cast from a pointer to it to a\n\t * pointer to the hpa_shard_t.\n\t */\n\tpai_t pai;\n\n\t/* The central allocator we get our hugepages from. */\n\thpa_central_t *central;\n\t/* Protects most of this shard's state. */\n\tmalloc_mutex_t mtx;\n\t/*\n\t * Guards the shard's access to the central allocator (preventing\n\t * multiple threads operating on this shard from accessing the central\n\t * allocator).\n\t */\n\tmalloc_mutex_t grow_mtx;\n\t/* The base metadata allocator. */\n\tbase_t *base;\n\n\t/*\n\t * This edata cache is the one we use when allocating a small extent\n\t * from a pageslab. The pageslab itself comes from the centralized\n\t * allocator, and so will use its edata_cache.\n\t */\n\tedata_cache_fast_t ecf;\n\n\tpsset_t psset;\n\n\t/*\n\t * How many grow operations have occurred.\n\t *\n\t * Guarded by grow_mtx.\n\t */\n\tuint64_t age_counter;\n\n\t/* The arena ind we're associated with. */\n\tunsigned ind;\n\n\t/*\n\t * Our emap. This is just a cache of the emap pointer in the associated\n\t * hpa_central.\n\t */\n\temap_t *emap;\n\n\t/* The configuration choices for this hpa shard. */\n\thpa_shard_opts_t opts;\n\n\t/*\n\t * How many pages have we started but not yet finished purging in this\n\t * hpa shard.\n\t */\n\tsize_t npending_purge;\n\n\t/*\n\t * Those stats which are copied directly into the CTL-centric hpa shard\n\t * stats.\n\t */\n\thpa_shard_nonderived_stats_t stats;\n\n\t/*\n\t * Last time we performed purge on this shard.\n\t */\n\tnstime_t last_purge;\n};\n\n/*\n * Whether or not the HPA can be used given the current configuration. This is\n * is not necessarily a guarantee that it backs its allocations by hugepages,\n * just that it can function properly given the system it's running on.\n */\nbool hpa_supported();\nbool hpa_central_init(hpa_central_t *central, base_t *base, const hpa_hooks_t *hooks);\nbool hpa_shard_init(hpa_shard_t *shard, hpa_central_t *central, emap_t *emap,\n base_t *base, edata_cache_t *edata_cache, unsigned ind,\n const hpa_shard_opts_t *opts);\n\nvoid hpa_shard_stats_accum(hpa_shard_stats_t *dst, hpa_shard_stats_t *src);\nvoid hpa_shard_stats_merge(tsdn_t *tsdn, hpa_shard_t *shard,\n hpa_shard_stats_t *dst);\n\n/*\n * Notify the shard that we won't use it for allocations much longer. Due to\n * the possibility of races, we don't actually prevent allocations; just flush\n * and disable the embedded edata_cache_small.\n */\nvoid hpa_shard_disable(tsdn_t *tsdn, hpa_shard_t *shard);\nvoid hpa_shard_destroy(tsdn_t *tsdn, hpa_shard_t *shard);\n\nvoid hpa_shard_set_deferral_allowed(tsdn_t *tsdn, hpa_shard_t *shard,\n bool deferral_allowed);\nvoid hpa_shard_do_deferred_work(tsdn_t *tsdn, hpa_shard_t *shard);\n\n/*\n * We share the fork ordering with the PA and arena prefork handling; that's why\n * these are 3 and 4 rather than 0 and 1.\n */\nvoid hpa_shard_prefork3(tsdn_t *tsdn, hpa_shard_t *shard);\nvoid hpa_shard_prefork4(tsdn_t *tsdn, hpa_shard_t *shard);\nvoid hpa_shard_postfork_parent(tsdn_t *tsdn, hpa_shard_t *shard);\nvoid hpa_shard_postfork_child(tsdn_t *tsdn, hpa_shard_t *shard);\n\n#endif /* JEMALLOC_INTERNAL_HPA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hpa_hooks.h", "content": "#ifndef JEMALLOC_INTERNAL_HPA_HOOKS_H\n#define JEMALLOC_INTERNAL_HPA_HOOKS_H\n\ntypedef struct hpa_hooks_s hpa_hooks_t;\nstruct hpa_hooks_s {\n\tvoid *(*map)(size_t size);\n\tvoid (*unmap)(void *ptr, size_t size);\n\tvoid (*purge)(void *ptr, size_t size);\n\tvoid (*hugify)(void *ptr, size_t size);\n\tvoid (*dehugify)(void *ptr, size_t size);\n\tvoid (*curtime)(nstime_t *r_time, bool first_reading);\n\tuint64_t (*ms_since)(nstime_t *r_time);\n};\n\nextern hpa_hooks_t hpa_hooks_default;\n\n#endif /* JEMALLOC_INTERNAL_HPA_HOOKS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hpa_opts.h", "content": "#ifndef JEMALLOC_INTERNAL_HPA_OPTS_H\n#define JEMALLOC_INTERNAL_HPA_OPTS_H\n\n#include \"jemalloc/internal/fxp.h\"\n\n/*\n * This file is morally part of hpa.h, but is split out for header-ordering\n * reasons.\n */\n\ntypedef struct hpa_shard_opts_s hpa_shard_opts_t;\nstruct hpa_shard_opts_s {\n\t/*\n\t * The largest size we'll allocate out of the shard. For those\n\t * allocations refused, the caller (in practice, the PA module) will\n\t * fall back to the more general (for now) PAC, which can always handle\n\t * any allocation request.\n\t */\n\tsize_t slab_max_alloc;\n\n\t/*\n\t * When the number of active bytes in a hugepage is >=\n\t * hugification_threshold, we force hugify it.\n\t */\n\tsize_t hugification_threshold;\n\n\t/*\n\t * The HPA purges whenever the number of pages exceeds dirty_mult *\n\t * active_pages. This may be set to (fxp_t)-1 to disable purging.\n\t */\n\tfxp_t dirty_mult;\n\n\t/*\n\t * Whether or not the PAI methods are allowed to defer work to a\n\t * subsequent hpa_shard_do_deferred_work() call. Practically, this\n\t * corresponds to background threads being enabled. We track this\n\t * ourselves for encapsulation purposes.\n\t */\n\tbool deferral_allowed;\n\n\t/*\n\t * How long a hugepage has to be a hugification candidate before it will\n\t * actually get hugified.\n\t */\n\tuint64_t hugify_delay_ms;\n\n\t/*\n\t * Minimum amount of time between purges.\n\t */\n\tuint64_t min_purge_interval_ms;\n};\n\n#define HPA_SHARD_OPTS_DEFAULT {\t\t\t\t\t\\\n\t/* slab_max_alloc */\t\t\t\t\t\t\\\n\t64 * 1024,\t\t\t\t\t\t\t\\\n\t/* hugification_threshold */\t\t\t\t\t\\\n\tHUGEPAGE * 95 / 100,\t\t\t\t\t\t\\\n\t/* dirty_mult */\t\t\t\t\t\t\\\n\tFXP_INIT_PERCENT(25),\t\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * deferral_allowed\t\t\t\t\t\t\\\n\t * \t\t\t\t\t\t\t\t\\\n\t * Really, this is always set by the arena during creation\t\\\n\t * or by an hpa_shard_set_deferral_allowed call, so the value\t\\\n\t * we put here doesn't matter.\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tfalse,\t\t\t\t\t\t\t\t\\\n\t/* hugify_delay_ms */\t\t\t\t\t\t\\\n\t10 * 1000,\t\t\t\t\t\t\t\\\n\t/* min_purge_interval_ms */\t\t\t\t\t\\\n\t5 * 1000\t\t\t\t\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_HPA_OPTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/hpdata.h", "content": "#ifndef JEMALLOC_INTERNAL_HPDATA_H\n#define JEMALLOC_INTERNAL_HPDATA_H\n\n#include \"jemalloc/internal/fb.h\"\n#include \"jemalloc/internal/ph.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/typed_list.h\"\n\n/*\n * The metadata representation we use for extents in hugepages. While the PAC\n * uses the edata_t to represent both active and inactive extents, the HP only\n * uses the edata_t for active ones; instead, inactive extent state is tracked\n * within hpdata associated with the enclosing hugepage-sized, hugepage-aligned\n * region of virtual address space.\n *\n * An hpdata need not be \"truly\" backed by a hugepage (which is not necessarily\n * an observable property of any given region of address space). It's just\n * hugepage-sized and hugepage-aligned; it's *potentially* huge.\n */\ntypedef struct hpdata_s hpdata_t;\nph_structs(hpdata_age_heap, hpdata_t);\nstruct hpdata_s {\n\t/*\n\t * We likewise follow the edata convention of mangling names and forcing\n\t * the use of accessors -- this lets us add some consistency checks on\n\t * access.\n\t */\n\n\t/*\n\t * The address of the hugepage in question. This can't be named h_addr,\n\t * since that conflicts with a macro defined in Windows headers.\n\t */\n\tvoid *h_address;\n\t/* Its age (measured in psset operations). */\n\tuint64_t h_age;\n\t/* Whether or not we think the hugepage is mapped that way by the OS. */\n\tbool h_huge;\n\n\t/*\n\t * For some properties, we keep parallel sets of bools; h_foo_allowed\n\t * and h_in_psset_foo_container. This is a decoupling mechanism to\n\t * avoid bothering the hpa (which manages policies) from the psset\n\t * (which is the mechanism used to enforce those policies). This allows\n\t * all the container management logic to live in one place, without the\n\t * HPA needing to know or care how that happens.\n\t */\n\n\t/*\n\t * Whether or not the hpdata is allowed to be used to serve allocations,\n\t * and whether or not the psset is currently tracking it as such.\n\t */\n\tbool h_alloc_allowed;\n\tbool h_in_psset_alloc_container;\n\n\t/*\n\t * The same, but with purging. There's no corresponding\n\t * h_in_psset_purge_container, because the psset (currently) always\n\t * removes hpdatas from their containers during updates (to implement\n\t * LRU for purging).\n\t */\n\tbool h_purge_allowed;\n\n\t/* And with hugifying. */\n\tbool h_hugify_allowed;\n\t/* When we became a hugification candidate. */\n\tnstime_t h_time_hugify_allowed;\n\tbool h_in_psset_hugify_container;\n\n\t/* Whether or not a purge or hugify is currently happening. */\n\tbool h_mid_purge;\n\tbool h_mid_hugify;\n\n\t/*\n\t * Whether or not the hpdata is being updated in the psset (i.e. if\n\t * there has been a psset_update_begin call issued without a matching\n\t * psset_update_end call). Eventually this will expand to other types\n\t * of updates.\n\t */\n\tbool h_updating;\n\n\t/* Whether or not the hpdata is in a psset. */\n\tbool h_in_psset;\n\n\tunion {\n\t\t/* When nonempty (and also nonfull), used by the psset bins. */\n\t\thpdata_age_heap_link_t age_link;\n\t\t/*\n\t\t * When empty (or not corresponding to any hugepage), list\n\t\t * linkage.\n\t\t */\n\t\tql_elm(hpdata_t) ql_link_empty;\n\t};\n\n\t/*\n\t * Linkage for the psset to track candidates for purging and hugifying.\n\t */\n\tql_elm(hpdata_t) ql_link_purge;\n\tql_elm(hpdata_t) ql_link_hugify;\n\n\t/* The length of the largest contiguous sequence of inactive pages. */\n\tsize_t h_longest_free_range;\n\n\t/* Number of active pages. */\n\tsize_t h_nactive;\n\n\t/* A bitmap with bits set in the active pages. */\n\tfb_group_t active_pages[FB_NGROUPS(HUGEPAGE_PAGES)];\n\n\t/*\n\t * Number of dirty or active pages, and a bitmap tracking them. One\n\t * way to think of this is as which pages are dirty from the OS's\n\t * perspective.\n\t */\n\tsize_t h_ntouched;\n\n\t/* The touched pages (using the same definition as above). */\n\tfb_group_t touched_pages[FB_NGROUPS(HUGEPAGE_PAGES)];\n};\n\nTYPED_LIST(hpdata_empty_list, hpdata_t, ql_link_empty)\nTYPED_LIST(hpdata_purge_list, hpdata_t, ql_link_purge)\nTYPED_LIST(hpdata_hugify_list, hpdata_t, ql_link_hugify)\n\nph_proto(, hpdata_age_heap, hpdata_t);\n\nstatic inline void *\nhpdata_addr_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_address;\n}\n\nstatic inline void\nhpdata_addr_set(hpdata_t *hpdata, void *addr) {\n\tassert(HUGEPAGE_ADDR2BASE(addr) == addr);\n\thpdata->h_address = addr;\n}\n\nstatic inline uint64_t\nhpdata_age_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_age;\n}\n\nstatic inline void\nhpdata_age_set(hpdata_t *hpdata, uint64_t age) {\n\thpdata->h_age = age;\n}\n\nstatic inline bool\nhpdata_huge_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_huge;\n}\n\nstatic inline bool\nhpdata_alloc_allowed_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_alloc_allowed;\n}\n\nstatic inline void\nhpdata_alloc_allowed_set(hpdata_t *hpdata, bool alloc_allowed) {\n\thpdata->h_alloc_allowed = alloc_allowed;\n}\n\nstatic inline bool\nhpdata_in_psset_alloc_container_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_in_psset_alloc_container;\n}\n\nstatic inline void\nhpdata_in_psset_alloc_container_set(hpdata_t *hpdata, bool in_container) {\n\tassert(in_container != hpdata->h_in_psset_alloc_container);\n\thpdata->h_in_psset_alloc_container = in_container;\n}\n\nstatic inline bool\nhpdata_purge_allowed_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_purge_allowed;\n}\n\nstatic inline void\nhpdata_purge_allowed_set(hpdata_t *hpdata, bool purge_allowed) {\n assert(purge_allowed == false || !hpdata->h_mid_purge);\n hpdata->h_purge_allowed = purge_allowed;\n}\n\nstatic inline bool\nhpdata_hugify_allowed_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_hugify_allowed;\n}\n\nstatic inline void\nhpdata_allow_hugify(hpdata_t *hpdata, nstime_t now) {\n\tassert(!hpdata->h_mid_hugify);\n\thpdata->h_hugify_allowed = true;\n\thpdata->h_time_hugify_allowed = now;\n}\n\nstatic inline nstime_t\nhpdata_time_hugify_allowed(hpdata_t *hpdata) {\n\treturn hpdata->h_time_hugify_allowed;\n}\n\nstatic inline void\nhpdata_disallow_hugify(hpdata_t *hpdata) {\n\thpdata->h_hugify_allowed = false;\n}\n\nstatic inline bool\nhpdata_in_psset_hugify_container_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_in_psset_hugify_container;\n}\n\nstatic inline void\nhpdata_in_psset_hugify_container_set(hpdata_t *hpdata, bool in_container) {\n\tassert(in_container != hpdata->h_in_psset_hugify_container);\n\thpdata->h_in_psset_hugify_container = in_container;\n}\n\nstatic inline bool\nhpdata_mid_purge_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_mid_purge;\n}\n\nstatic inline void\nhpdata_mid_purge_set(hpdata_t *hpdata, bool mid_purge) {\n\tassert(mid_purge != hpdata->h_mid_purge);\n\thpdata->h_mid_purge = mid_purge;\n}\n\nstatic inline bool\nhpdata_mid_hugify_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_mid_hugify;\n}\n\nstatic inline void\nhpdata_mid_hugify_set(hpdata_t *hpdata, bool mid_hugify) {\n\tassert(mid_hugify != hpdata->h_mid_hugify);\n\thpdata->h_mid_hugify = mid_hugify;\n}\n\nstatic inline bool\nhpdata_changing_state_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_mid_purge || hpdata->h_mid_hugify;\n}\n\n\nstatic inline bool\nhpdata_updating_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_updating;\n}\n\nstatic inline void\nhpdata_updating_set(hpdata_t *hpdata, bool updating) {\n\tassert(updating != hpdata->h_updating);\n\thpdata->h_updating = updating;\n}\n\nstatic inline bool\nhpdata_in_psset_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_in_psset;\n}\n\nstatic inline void\nhpdata_in_psset_set(hpdata_t *hpdata, bool in_psset) {\n\tassert(in_psset != hpdata->h_in_psset);\n\thpdata->h_in_psset = in_psset;\n}\n\nstatic inline size_t\nhpdata_longest_free_range_get(const hpdata_t *hpdata) {\n\treturn hpdata->h_longest_free_range;\n}\n\nstatic inline void\nhpdata_longest_free_range_set(hpdata_t *hpdata, size_t longest_free_range) {\n\tassert(longest_free_range <= HUGEPAGE_PAGES);\n\thpdata->h_longest_free_range = longest_free_range;\n}\n\nstatic inline size_t\nhpdata_nactive_get(hpdata_t *hpdata) {\n\treturn hpdata->h_nactive;\n}\n\nstatic inline size_t\nhpdata_ntouched_get(hpdata_t *hpdata) {\n\treturn hpdata->h_ntouched;\n}\n\nstatic inline size_t\nhpdata_ndirty_get(hpdata_t *hpdata) {\n\treturn hpdata->h_ntouched - hpdata->h_nactive;\n}\n\nstatic inline size_t\nhpdata_nretained_get(hpdata_t *hpdata) {\n\treturn HUGEPAGE_PAGES - hpdata->h_ntouched;\n}\n\nstatic inline void\nhpdata_assert_empty(hpdata_t *hpdata) {\n\tassert(fb_empty(hpdata->active_pages, HUGEPAGE_PAGES));\n\tassert(hpdata->h_nactive == 0);\n}\n\n/*\n * Only used in tests, and in hpdata_assert_consistent, below. Verifies some\n * consistency properties of the hpdata (e.g. that cached counts of page stats\n * match computed ones).\n */\nstatic inline bool\nhpdata_consistent(hpdata_t *hpdata) {\n\tif(fb_urange_longest(hpdata->active_pages, HUGEPAGE_PAGES)\n\t != hpdata_longest_free_range_get(hpdata)) {\n\t\treturn false;\n\t}\n\tif (fb_scount(hpdata->active_pages, HUGEPAGE_PAGES, 0, HUGEPAGE_PAGES)\n\t != hpdata->h_nactive) {\n\t\treturn false;\n\t}\n\tif (fb_scount(hpdata->touched_pages, HUGEPAGE_PAGES, 0, HUGEPAGE_PAGES)\n\t != hpdata->h_ntouched) {\n\t\treturn false;\n\t}\n\tif (hpdata->h_ntouched < hpdata->h_nactive) {\n\t\treturn false;\n\t}\n\tif (hpdata->h_huge && hpdata->h_ntouched != HUGEPAGE_PAGES) {\n\t\treturn false;\n\t}\n\tif (hpdata_changing_state_get(hpdata)\n\t && ((hpdata->h_purge_allowed) || hpdata->h_hugify_allowed)) {\n\t\treturn false;\n\t}\n\tif (hpdata_hugify_allowed_get(hpdata)\n\t != hpdata_in_psset_hugify_container_get(hpdata)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nstatic inline void\nhpdata_assert_consistent(hpdata_t *hpdata) {\n\tassert(hpdata_consistent(hpdata));\n}\n\nstatic inline bool\nhpdata_empty(hpdata_t *hpdata) {\n\treturn hpdata->h_nactive == 0;\n}\n\nstatic inline bool\nhpdata_full(hpdata_t *hpdata) {\n\treturn hpdata->h_nactive == HUGEPAGE_PAGES;\n}\n\nvoid hpdata_init(hpdata_t *hpdata, void *addr, uint64_t age);\n\n/*\n * Given an hpdata which can serve an allocation request, pick and reserve an\n * offset within that allocation.\n */\nvoid *hpdata_reserve_alloc(hpdata_t *hpdata, size_t sz);\nvoid hpdata_unreserve(hpdata_t *hpdata, void *begin, size_t sz);\n\n/*\n * The hpdata_purge_prepare_t allows grabbing the metadata required to purge\n * subranges of a hugepage while holding a lock, drop the lock during the actual\n * purging of them, and reacquire it to update the metadata again.\n */\ntypedef struct hpdata_purge_state_s hpdata_purge_state_t;\nstruct hpdata_purge_state_s {\n\tsize_t npurged;\n\tsize_t ndirty_to_purge;\n\tfb_group_t to_purge[FB_NGROUPS(HUGEPAGE_PAGES)];\n\tsize_t next_purge_search_begin;\n};\n\n/*\n * Initializes purge state. The access to hpdata must be externally\n * synchronized with other hpdata_* calls.\n *\n * You can tell whether or not a thread is purging or hugifying a given hpdata\n * via hpdata_changing_state_get(hpdata). Racing hugification or purging\n * operations aren't allowed.\n *\n * Once you begin purging, you have to follow through and call hpdata_purge_next\n * until you're done, and then end. Allocating out of an hpdata undergoing\n * purging is not allowed.\n *\n * Returns the number of dirty pages that will be purged.\n */\nsize_t hpdata_purge_begin(hpdata_t *hpdata, hpdata_purge_state_t *purge_state);\n\n/*\n * If there are more extents to purge, sets *r_purge_addr and *r_purge_size to\n * true, and returns true. Otherwise, returns false to indicate that we're\n * done.\n *\n * This requires exclusive access to the purge state, but *not* to the hpdata.\n * In particular, unreserve calls are allowed while purging (i.e. you can dalloc\n * into one part of the hpdata while purging a different part).\n */\nbool hpdata_purge_next(hpdata_t *hpdata, hpdata_purge_state_t *purge_state,\n void **r_purge_addr, size_t *r_purge_size);\n/*\n * Updates the hpdata metadata after all purging is done. Needs external\n * synchronization.\n */\nvoid hpdata_purge_end(hpdata_t *hpdata, hpdata_purge_state_t *purge_state);\n\nvoid hpdata_hugify(hpdata_t *hpdata);\nvoid hpdata_dehugify(hpdata_t *hpdata);\n\n#endif /* JEMALLOC_INTERNAL_HPDATA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/inspect.h", "content": "#ifndef JEMALLOC_INTERNAL_INSPECT_H\n#define JEMALLOC_INTERNAL_INSPECT_H\n\n/*\n * This module contains the heap introspection capabilities. For now they are\n * exposed purely through mallctl APIs in the experimental namespace, but this\n * may change over time.\n */\n\n/*\n * The following two structs are for experimental purposes. See\n * experimental_utilization_query_ctl and\n * experimental_utilization_batch_query_ctl in src/ctl.c.\n */\ntypedef struct inspect_extent_util_stats_s inspect_extent_util_stats_t;\nstruct inspect_extent_util_stats_s {\n\tsize_t nfree;\n\tsize_t nregs;\n\tsize_t size;\n};\n\ntypedef struct inspect_extent_util_stats_verbose_s\n inspect_extent_util_stats_verbose_t;\n\nstruct inspect_extent_util_stats_verbose_s {\n\tvoid *slabcur_addr;\n\tsize_t nfree;\n\tsize_t nregs;\n\tsize_t size;\n\tsize_t bin_nfree;\n\tsize_t bin_nregs;\n};\n\nvoid inspect_extent_util_stats_get(tsdn_t *tsdn, const void *ptr,\n size_t *nfree, size_t *nregs, size_t *size);\nvoid inspect_extent_util_stats_verbose_get(tsdn_t *tsdn, const void *ptr,\n size_t *nfree, size_t *nregs, size_t *size,\n size_t *bin_nfree, size_t *bin_nregs, void **slabcur_addr);\n\n#endif /* JEMALLOC_INTERNAL_INSPECT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_decls.h", "content": "#ifndef JEMALLOC_INTERNAL_DECLS_H\n#define JEMALLOC_INTERNAL_DECLS_H\n\n#include \n#ifdef _WIN32\n# include \n# include \"msvc_compat/windows_extra.h\"\n# include \"msvc_compat/strings.h\"\n# ifdef _WIN64\n# if LG_VADDR <= 32\n# error Generate the headers using x64 vcargs\n# endif\n# else\n# if LG_VADDR > 32\n# undef LG_VADDR\n# define LG_VADDR 32\n# endif\n# endif\n#else\n# include \n# include \n# if !defined(__pnacl__) && !defined(__native_client__)\n# include \n# if !defined(SYS_write) && defined(__NR_write)\n# define SYS_write __NR_write\n# endif\n# if defined(SYS_open) && defined(__aarch64__)\n /* Android headers may define SYS_open to __NR_open even though\n * __NR_open may not exist on AArch64 (superseded by __NR_openat). */\n# undef SYS_open\n# endif\n# include \n# endif\n# include \n# if defined(__FreeBSD__) || defined(__DragonFly__)\n# include \n# include \n# if defined(__FreeBSD__)\n# define cpu_set_t cpuset_t\n# endif\n# endif\n# include \n# ifdef JEMALLOC_OS_UNFAIR_LOCK\n# include \n# endif\n# ifdef JEMALLOC_GLIBC_MALLOC_HOOK\n# include \n# endif\n# include \n# include \n# include \n# ifdef JEMALLOC_HAVE_MACH_ABSOLUTE_TIME\n# include \n# endif\n#endif\n#include \n\n#include \n#ifndef SIZE_T_MAX\n# define SIZE_T_MAX\tSIZE_MAX\n#endif\n#ifndef SSIZE_MAX\n# define SSIZE_MAX\t((ssize_t)(SIZE_T_MAX >> 1))\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#ifndef offsetof\n# define offsetof(type, member)\t((size_t)&(((type *)NULL)->member))\n#endif\n#include \n#include \n#include \n#ifdef _MSC_VER\n# include \ntypedef intptr_t ssize_t;\n# define PATH_MAX 1024\n# define STDERR_FILENO 2\n# define __func__ __FUNCTION__\n# ifdef JEMALLOC_HAS_RESTRICT\n# define restrict __restrict\n# endif\n/* Disable warnings about deprecated system functions. */\n# pragma warning(disable: 4996)\n#if _MSC_VER < 1800\nstatic int\nisblank(int c) {\n\treturn (c == '\\t' || c == ' ');\n}\n#endif\n#else\n# include \n#endif\n#include \n\n/*\n * The Win32 midl compiler has #define small char; we don't use midl, but\n * \"small\" is a nice identifier to have available when talking about size\n * classes.\n */\n#ifdef small\n# undef small\n#endif\n\n#endif /* JEMALLOC_INTERNAL_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h.in", "content": "#ifndef JEMALLOC_INTERNAL_DEFS_H_\n#define JEMALLOC_INTERNAL_DEFS_H_\n/*\n * If JEMALLOC_PREFIX is defined via --with-jemalloc-prefix, it will cause all\n * public APIs to be prefixed. This makes it possible, with some care, to use\n * multiple allocators simultaneously.\n */\n#undef JEMALLOC_PREFIX\n#undef JEMALLOC_CPREFIX\n\n/*\n * Define overrides for non-standard allocator-related functions if they are\n * present on the system.\n */\n#undef JEMALLOC_OVERRIDE___LIBC_CALLOC\n#undef JEMALLOC_OVERRIDE___LIBC_FREE\n#undef JEMALLOC_OVERRIDE___LIBC_MALLOC\n#undef JEMALLOC_OVERRIDE___LIBC_MEMALIGN\n#undef JEMALLOC_OVERRIDE___LIBC_REALLOC\n#undef JEMALLOC_OVERRIDE___LIBC_VALLOC\n#undef JEMALLOC_OVERRIDE___POSIX_MEMALIGN\n\n/*\n * JEMALLOC_PRIVATE_NAMESPACE is used as a prefix for all library-private APIs.\n * For shared libraries, symbol visibility mechanisms prevent these symbols\n * from being exported, but for static libraries, naming collisions are a real\n * possibility.\n */\n#undef JEMALLOC_PRIVATE_NAMESPACE\n\n/*\n * Hyper-threaded CPUs may need a special instruction inside spin loops in\n * order to yield to another virtual CPU.\n */\n#undef CPU_SPINWAIT\n/* 1 if CPU_SPINWAIT is defined, 0 otherwise. */\n#undef HAVE_CPU_SPINWAIT\n\n/*\n * Number of significant bits in virtual addresses. This may be less than the\n * total number of bits in a pointer, e.g. on x64, for which the uppermost 16\n * bits are the same as bit 47.\n */\n#undef LG_VADDR\n\n/* Defined if C11 atomics are available. */\n#undef JEMALLOC_C11_ATOMICS\n\n/* Defined if GCC __atomic atomics are available. */\n#undef JEMALLOC_GCC_ATOMIC_ATOMICS\n/* and the 8-bit variant support. */\n#undef JEMALLOC_GCC_U8_ATOMIC_ATOMICS\n\n/* Defined if GCC __sync atomics are available. */\n#undef JEMALLOC_GCC_SYNC_ATOMICS\n/* and the 8-bit variant support. */\n#undef JEMALLOC_GCC_U8_SYNC_ATOMICS\n\n/*\n * Defined if __builtin_clz() and __builtin_clzl() are available.\n */\n#undef JEMALLOC_HAVE_BUILTIN_CLZ\n\n/*\n * Defined if os_unfair_lock_*() functions are available, as provided by Darwin.\n */\n#undef JEMALLOC_OS_UNFAIR_LOCK\n\n/* Defined if syscall(2) is usable. */\n#undef JEMALLOC_USE_SYSCALL\n\n/*\n * Defined if secure_getenv(3) is available.\n */\n#undef JEMALLOC_HAVE_SECURE_GETENV\n\n/*\n * Defined if issetugid(2) is available.\n */\n#undef JEMALLOC_HAVE_ISSETUGID\n\n/* Defined if pthread_atfork(3) is available. */\n#undef JEMALLOC_HAVE_PTHREAD_ATFORK\n\n/* Defined if pthread_setname_np(3) is available. */\n#undef JEMALLOC_HAVE_PTHREAD_SETNAME_NP\n\n/* Defined if pthread_getname_np(3) is available. */\n#undef JEMALLOC_HAVE_PTHREAD_GETNAME_NP\n\n/* Defined if pthread_get_name_np(3) is available. */\n#undef JEMALLOC_HAVE_PTHREAD_GET_NAME_NP\n\n/*\n * Defined if clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is available.\n */\n#undef JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE\n\n/*\n * Defined if clock_gettime(CLOCK_MONOTONIC, ...) is available.\n */\n#undef JEMALLOC_HAVE_CLOCK_MONOTONIC\n\n/*\n * Defined if mach_absolute_time() is available.\n */\n#undef JEMALLOC_HAVE_MACH_ABSOLUTE_TIME\n\n/*\n * Defined if clock_gettime(CLOCK_REALTIME, ...) is available.\n */\n#undef JEMALLOC_HAVE_CLOCK_REALTIME\n\n/*\n * Defined if _malloc_thread_cleanup() exists. At least in the case of\n * FreeBSD, pthread_key_create() allocates, which if used during malloc\n * bootstrapping will cause recursion into the pthreads library. Therefore, if\n * _malloc_thread_cleanup() exists, use it as the basis for thread cleanup in\n * malloc_tsd.\n */\n#undef JEMALLOC_MALLOC_THREAD_CLEANUP\n\n/*\n * Defined if threaded initialization is known to be safe on this platform.\n * Among other things, it must be possible to initialize a mutex without\n * triggering allocation in order for threaded allocation to be safe.\n */\n#undef JEMALLOC_THREADED_INIT\n\n/*\n * Defined if the pthreads implementation defines\n * _pthread_mutex_init_calloc_cb(), in which case the function is used in order\n * to avoid recursive allocation during mutex initialization.\n */\n#undef JEMALLOC_MUTEX_INIT_CB\n\n/* Non-empty if the tls_model attribute is supported. */\n#undef JEMALLOC_TLS_MODEL\n\n/*\n * JEMALLOC_DEBUG enables assertions and other sanity checks, and disables\n * inline functions.\n */\n#undef JEMALLOC_DEBUG\n\n/* JEMALLOC_STATS enables statistics calculation. */\n#undef JEMALLOC_STATS\n\n/* JEMALLOC_EXPERIMENTAL_SMALLOCX_API enables experimental smallocx API. */\n#undef JEMALLOC_EXPERIMENTAL_SMALLOCX_API\n\n/* JEMALLOC_PROF enables allocation profiling. */\n#undef JEMALLOC_PROF\n\n/* Use libunwind for profile backtracing if defined. */\n#undef JEMALLOC_PROF_LIBUNWIND\n\n/* Use libgcc for profile backtracing if defined. */\n#undef JEMALLOC_PROF_LIBGCC\n\n/* Use gcc intrinsics for profile backtracing if defined. */\n#undef JEMALLOC_PROF_GCC\n\n/*\n * JEMALLOC_DSS enables use of sbrk(2) to allocate extents from the data storage\n * segment (DSS).\n */\n#undef JEMALLOC_DSS\n\n/* Support memory filling (junk/zero). */\n#undef JEMALLOC_FILL\n\n/* Support utrace(2)-based tracing. */\n#undef JEMALLOC_UTRACE\n\n/* Support utrace(2)-based tracing (label based signature). */\n#undef JEMALLOC_UTRACE_LABEL\n\n/* Support optional abort() on OOM. */\n#undef JEMALLOC_XMALLOC\n\n/* Support lazy locking (avoid locking unless a second thread is launched). */\n#undef JEMALLOC_LAZY_LOCK\n\n/*\n * Minimum allocation alignment is 2^LG_QUANTUM bytes (ignoring tiny size\n * classes).\n */\n#undef LG_QUANTUM\n\n/* One page is 2^LG_PAGE bytes. */\n#undef LG_PAGE\n\n/* Maximum number of regions in a slab. */\n#undef CONFIG_LG_SLAB_MAXREGS\n\n/*\n * One huge page is 2^LG_HUGEPAGE bytes. Note that this is defined even if the\n * system does not explicitly support huge pages; system calls that require\n * explicit huge page support are separately configured.\n */\n#undef LG_HUGEPAGE\n\n/*\n * If defined, adjacent virtual memory mappings with identical attributes\n * automatically coalesce, and they fragment when changes are made to subranges.\n * This is the normal order of things for mmap()/munmap(), but on Windows\n * VirtualAlloc()/VirtualFree() operations must be precisely matched, i.e.\n * mappings do *not* coalesce/fragment.\n */\n#undef JEMALLOC_MAPS_COALESCE\n\n/*\n * If defined, retain memory for later reuse by default rather than using e.g.\n * munmap() to unmap freed extents. This is enabled on 64-bit Linux because\n * common sequences of mmap()/munmap() calls will cause virtual memory map\n * holes.\n */\n#undef JEMALLOC_RETAIN\n\n/* TLS is used to map arenas and magazine caches to threads. */\n#undef JEMALLOC_TLS\n\n/*\n * Used to mark unreachable code to quiet \"end of non-void\" compiler warnings.\n * Don't use this directly; instead use unreachable() from util.h\n */\n#undef JEMALLOC_INTERNAL_UNREACHABLE\n\n/*\n * ffs*() functions to use for bitmapping. Don't use these directly; instead,\n * use ffs_*() from util.h.\n */\n#undef JEMALLOC_INTERNAL_FFSLL\n#undef JEMALLOC_INTERNAL_FFSL\n#undef JEMALLOC_INTERNAL_FFS\n\n/*\n * popcount*() functions to use for bitmapping.\n */\n#undef JEMALLOC_INTERNAL_POPCOUNTL\n#undef JEMALLOC_INTERNAL_POPCOUNT\n\n/*\n * If defined, explicitly attempt to more uniformly distribute large allocation\n * pointer alignments across all cache indices.\n */\n#undef JEMALLOC_CACHE_OBLIVIOUS\n\n/*\n * If defined, enable logging facilities. We make this a configure option to\n * avoid taking extra branches everywhere.\n */\n#undef JEMALLOC_LOG\n\n/*\n * If defined, use readlinkat() (instead of readlink()) to follow\n * /etc/malloc_conf.\n */\n#undef JEMALLOC_READLINKAT\n\n/*\n * Darwin (OS X) uses zones to work around Mach-O symbol override shortcomings.\n */\n#undef JEMALLOC_ZONE\n\n/*\n * Methods for determining whether the OS overcommits.\n * JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY: Linux's\n * /proc/sys/vm.overcommit_memory file.\n * JEMALLOC_SYSCTL_VM_OVERCOMMIT: FreeBSD's vm.overcommit sysctl.\n */\n#undef JEMALLOC_SYSCTL_VM_OVERCOMMIT\n#undef JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY\n\n/* Defined if madvise(2) is available. */\n#undef JEMALLOC_HAVE_MADVISE\n\n/*\n * Defined if transparent huge pages are supported via the MADV_[NO]HUGEPAGE\n * arguments to madvise(2).\n */\n#undef JEMALLOC_HAVE_MADVISE_HUGE\n\n/*\n * Methods for purging unused pages differ between operating systems.\n *\n * madvise(..., MADV_FREE) : This marks pages as being unused, such that they\n * will be discarded rather than swapped out.\n * madvise(..., MADV_DONTNEED) : If JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS is\n * defined, this immediately discards pages,\n * such that new pages will be demand-zeroed if\n * the address region is later touched;\n * otherwise this behaves similarly to\n * MADV_FREE, though typically with higher\n * system overhead.\n */\n#undef JEMALLOC_PURGE_MADVISE_FREE\n#undef JEMALLOC_PURGE_MADVISE_DONTNEED\n#undef JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS\n\n/* Defined if madvise(2) is available but MADV_FREE is not (x86 Linux only). */\n#undef JEMALLOC_DEFINE_MADVISE_FREE\n\n/*\n * Defined if MADV_DO[NT]DUMP is supported as an argument to madvise.\n */\n#undef JEMALLOC_MADVISE_DONTDUMP\n\n/*\n * Defined if MADV_[NO]CORE is supported as an argument to madvise.\n */\n#undef JEMALLOC_MADVISE_NOCORE\n\n/* Defined if mprotect(2) is available. */\n#undef JEMALLOC_HAVE_MPROTECT\n\n/*\n * Defined if transparent huge pages (THPs) are supported via the\n * MADV_[NO]HUGEPAGE arguments to madvise(2), and THP support is enabled.\n */\n#undef JEMALLOC_THP\n\n/* Defined if posix_madvise is available. */\n#undef JEMALLOC_HAVE_POSIX_MADVISE\n\n/*\n * Method for purging unused pages using posix_madvise.\n *\n * posix_madvise(..., POSIX_MADV_DONTNEED)\n */\n#undef JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED\n#undef JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED_ZEROS\n\n/*\n * Defined if memcntl page admin call is supported\n */\n#undef JEMALLOC_HAVE_MEMCNTL\n\n/*\n * Defined if malloc_size is supported\n */\n#undef JEMALLOC_HAVE_MALLOC_SIZE\n\n/* Define if operating system has alloca.h header. */\n#undef JEMALLOC_HAS_ALLOCA_H\n\n/* C99 restrict keyword supported. */\n#undef JEMALLOC_HAS_RESTRICT\n\n/* For use by hash code. */\n#undef JEMALLOC_BIG_ENDIAN\n\n/* sizeof(int) == 2^LG_SIZEOF_INT. */\n#undef LG_SIZEOF_INT\n\n/* sizeof(long) == 2^LG_SIZEOF_LONG. */\n#undef LG_SIZEOF_LONG\n\n/* sizeof(long long) == 2^LG_SIZEOF_LONG_LONG. */\n#undef LG_SIZEOF_LONG_LONG\n\n/* sizeof(intmax_t) == 2^LG_SIZEOF_INTMAX_T. */\n#undef LG_SIZEOF_INTMAX_T\n\n/* glibc malloc hooks (__malloc_hook, __realloc_hook, __free_hook). */\n#undef JEMALLOC_GLIBC_MALLOC_HOOK\n\n/* glibc memalign hook. */\n#undef JEMALLOC_GLIBC_MEMALIGN_HOOK\n\n/* pthread support */\n#undef JEMALLOC_HAVE_PTHREAD\n\n/* dlsym() support */\n#undef JEMALLOC_HAVE_DLSYM\n\n/* Adaptive mutex support in pthreads. */\n#undef JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP\n\n/* GNU specific sched_getcpu support */\n#undef JEMALLOC_HAVE_SCHED_GETCPU\n\n/* GNU specific sched_setaffinity support */\n#undef JEMALLOC_HAVE_SCHED_SETAFFINITY\n\n/*\n * If defined, all the features necessary for background threads are present.\n */\n#undef JEMALLOC_BACKGROUND_THREAD\n\n/*\n * If defined, jemalloc symbols are not exported (doesn't work when\n * JEMALLOC_PREFIX is not defined).\n */\n#undef JEMALLOC_EXPORT\n\n/* config.malloc_conf options string. */\n#undef JEMALLOC_CONFIG_MALLOC_CONF\n\n/* If defined, jemalloc takes the malloc/free/etc. symbol names. */\n#undef JEMALLOC_IS_MALLOC\n\n/*\n * Defined if strerror_r returns char * if _GNU_SOURCE is defined.\n */\n#undef JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE\n\n/* Performs additional safety checks when defined. */\n#undef JEMALLOC_OPT_SAFETY_CHECKS\n\n/* Is C++ support being built? */\n#undef JEMALLOC_ENABLE_CXX\n\n/* Performs additional size checks when defined. */\n#undef JEMALLOC_OPT_SIZE_CHECKS\n\n/* Allows sampled junk and stash for checking use-after-free when defined. */\n#undef JEMALLOC_UAF_DETECTION\n\n/* Darwin VM_MAKE_TAG support */\n#undef JEMALLOC_HAVE_VM_MAKE_TAG\n\n/* If defined, realloc(ptr, 0) defaults to \"free\" instead of \"alloc\". */\n#undef JEMALLOC_ZERO_REALLOC_DEFAULT_FREE\n\n#endif /* JEMALLOC_INTERNAL_DEFS_H_ */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTERNS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/hpa_opts.h\"\n#include \"jemalloc/internal/sec_opts.h\"\n#include \"jemalloc/internal/tsd_types.h\"\n#include \"jemalloc/internal/nstime.h\"\n\n/* TSD checks this to set thread local slow state accordingly. */\nextern bool malloc_slow;\n\n/* Run-time options. */\nextern bool opt_abort;\nextern bool opt_abort_conf;\nextern bool opt_trust_madvise;\nextern bool opt_confirm_conf;\nextern bool opt_hpa;\nextern hpa_shard_opts_t opt_hpa_opts;\nextern sec_opts_t opt_hpa_sec_opts;\n\nextern const char *opt_junk;\nextern bool opt_junk_alloc;\nextern bool opt_junk_free;\nextern void (*junk_free_callback)(void *ptr, size_t size);\nextern void (*junk_alloc_callback)(void *ptr, size_t size);\nextern bool opt_utrace;\nextern bool opt_xmalloc;\nextern bool opt_experimental_infallible_new;\nextern bool opt_zero;\nextern unsigned opt_narenas;\nextern zero_realloc_action_t opt_zero_realloc_action;\nextern malloc_init_t malloc_init_state;\nextern const char *zero_realloc_mode_names[];\nextern atomic_zu_t zero_realloc_count;\nextern bool opt_cache_oblivious;\n\n/* Escape free-fastpath when ptr & mask == 0 (for sanitization purpose). */\nextern uintptr_t san_cache_bin_nonfast_mask;\n\n/* Number of CPUs. */\nextern unsigned ncpus;\n\n/* Number of arenas used for automatic multiplexing of threads and arenas. */\nextern unsigned narenas_auto;\n\n/* Base index for manual arenas. */\nextern unsigned manual_arena_base;\n\n/*\n * Arenas that are used to service external requests. Not all elements of the\n * arenas array are necessarily used; arenas are created lazily as needed.\n */\nextern atomic_p_t arenas[];\n\nvoid *a0malloc(size_t size);\nvoid a0dalloc(void *ptr);\nvoid *bootstrap_malloc(size_t size);\nvoid *bootstrap_calloc(size_t num, size_t size);\nvoid bootstrap_free(void *ptr);\nvoid arena_set(unsigned ind, arena_t *arena);\nunsigned narenas_total_get(void);\narena_t *arena_init(tsdn_t *tsdn, unsigned ind, const arena_config_t *config);\narena_t *arena_choose_hard(tsd_t *tsd, bool internal);\nvoid arena_migrate(tsd_t *tsd, arena_t *oldarena, arena_t *newarena);\nvoid iarena_cleanup(tsd_t *tsd);\nvoid arena_cleanup(tsd_t *tsd);\nsize_t batch_alloc(void **ptrs, size_t num, size_t size, int flags);\nvoid jemalloc_prefork(void);\nvoid jemalloc_postfork_parent(void);\nvoid jemalloc_postfork_child(void);\nvoid je_sdallocx_noflags(void *ptr, size_t size);\nvoid *malloc_default(size_t size, size_t *usize);\n\n#endif /* JEMALLOC_INTERNAL_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_includes.h", "content": "#ifndef JEMALLOC_INTERNAL_INCLUDES_H\n#define JEMALLOC_INTERNAL_INCLUDES_H\n\n/*\n * jemalloc can conceptually be broken into components (arena, tcache, etc.),\n * but there are circular dependencies that cannot be broken without\n * substantial performance degradation.\n *\n * Historically, we dealt with this by each header into four sections (types,\n * structs, externs, and inlines), and included each header file multiple times\n * in this file, picking out the portion we want on each pass using the\n * following #defines:\n * JEMALLOC_H_TYPES : Preprocessor-defined constants and pseudo-opaque data\n * types.\n * JEMALLOC_H_STRUCTS : Data structures.\n * JEMALLOC_H_EXTERNS : Extern data declarations and function prototypes.\n * JEMALLOC_H_INLINES : Inline functions.\n *\n * We're moving toward a world in which the dependencies are explicit; each file\n * will #include the headers it depends on (rather than relying on them being\n * implicitly available via this file including every header file in the\n * project).\n *\n * We're now in an intermediate state: we've broken up the header files to avoid\n * having to include each one multiple times, but have not yet moved the\n * dependency information into the header files (i.e. we still rely on the\n * ordering in this file to ensure all a header's dependencies are available in\n * its translation unit). Each component is now broken up into multiple header\n * files, corresponding to the sections above (e.g. instead of \"foo.h\", we now\n * have \"foo_types.h\", \"foo_structs.h\", \"foo_externs.h\", \"foo_inlines.h\").\n *\n * Those files which have been converted to explicitly include their\n * inter-component dependencies are now in the initial HERMETIC HEADERS\n * section. All headers may still rely on jemalloc_preamble.h (which, by fiat,\n * must be included first in every translation unit) for system headers and\n * global jemalloc definitions, however.\n */\n\n/******************************************************************************/\n/* TYPES */\n/******************************************************************************/\n\n#include \"jemalloc/internal/arena_types.h\"\n#include \"jemalloc/internal/tcache_types.h\"\n#include \"jemalloc/internal/prof_types.h\"\n\n/******************************************************************************/\n/* STRUCTS */\n/******************************************************************************/\n\n#include \"jemalloc/internal/prof_structs.h\"\n#include \"jemalloc/internal/arena_structs.h\"\n#include \"jemalloc/internal/tcache_structs.h\"\n#include \"jemalloc/internal/background_thread_structs.h\"\n\n/******************************************************************************/\n/* EXTERNS */\n/******************************************************************************/\n\n#include \"jemalloc/internal/jemalloc_internal_externs.h\"\n#include \"jemalloc/internal/arena_externs.h\"\n#include \"jemalloc/internal/large_externs.h\"\n#include \"jemalloc/internal/tcache_externs.h\"\n#include \"jemalloc/internal/prof_externs.h\"\n#include \"jemalloc/internal/background_thread_externs.h\"\n\n/******************************************************************************/\n/* INLINES */\n/******************************************************************************/\n\n#include \"jemalloc/internal/jemalloc_internal_inlines_a.h\"\n/*\n * Include portions of arena code interleaved with tcache code in order to\n * resolve circular dependencies.\n */\n#include \"jemalloc/internal/arena_inlines_a.h\"\n#include \"jemalloc/internal/jemalloc_internal_inlines_b.h\"\n#include \"jemalloc/internal/tcache_inlines.h\"\n#include \"jemalloc/internal/arena_inlines_b.h\"\n#include \"jemalloc/internal/jemalloc_internal_inlines_c.h\"\n#include \"jemalloc/internal/prof_inlines.h\"\n#include \"jemalloc/internal/background_thread_inlines.h\"\n\n#endif /* JEMALLOC_INTERNAL_INCLUDES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_a.h", "content": "#ifndef JEMALLOC_INTERNAL_INLINES_A_H\n#define JEMALLOC_INTERNAL_INLINES_A_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/ticker.h\"\n\nJEMALLOC_ALWAYS_INLINE malloc_cpuid_t\nmalloc_getcpu(void) {\n\tassert(have_percpu_arena);\n#if defined(_WIN32)\n\treturn GetCurrentProcessorNumber();\n#elif defined(JEMALLOC_HAVE_SCHED_GETCPU)\n\treturn (malloc_cpuid_t)sched_getcpu();\n#else\n\tnot_reached();\n\treturn -1;\n#endif\n}\n\n/* Return the chosen arena index based on current cpu. */\nJEMALLOC_ALWAYS_INLINE unsigned\npercpu_arena_choose(void) {\n\tassert(have_percpu_arena && PERCPU_ARENA_ENABLED(opt_percpu_arena));\n\n\tmalloc_cpuid_t cpuid = malloc_getcpu();\n\tassert(cpuid >= 0);\n\n\tunsigned arena_ind;\n\tif ((opt_percpu_arena == percpu_arena) || ((unsigned)cpuid < ncpus /\n\t 2)) {\n\t\tarena_ind = cpuid;\n\t} else {\n\t\tassert(opt_percpu_arena == per_phycpu_arena);\n\t\t/* Hyper threads on the same physical CPU share arena. */\n\t\tarena_ind = cpuid - ncpus / 2;\n\t}\n\n\treturn arena_ind;\n}\n\n/* Return the limit of percpu auto arena range, i.e. arenas[0...ind_limit). */\nJEMALLOC_ALWAYS_INLINE unsigned\npercpu_arena_ind_limit(percpu_arena_mode_t mode) {\n\tassert(have_percpu_arena && PERCPU_ARENA_ENABLED(mode));\n\tif (mode == per_phycpu_arena && ncpus > 1) {\n\t\tif (ncpus % 2) {\n\t\t\t/* This likely means a misconfig. */\n\t\t\treturn ncpus / 2 + 1;\n\t\t}\n\t\treturn ncpus / 2;\n\t} else {\n\t\treturn ncpus;\n\t}\n}\n\nstatic inline arena_t *\narena_get(tsdn_t *tsdn, unsigned ind, bool init_if_missing) {\n\tarena_t *ret;\n\n\tassert(ind < MALLOCX_ARENA_LIMIT);\n\n\tret = (arena_t *)atomic_load_p(&arenas[ind], ATOMIC_ACQUIRE);\n\tif (unlikely(ret == NULL)) {\n\t\tif (init_if_missing) {\n\t\t\tret = arena_init(tsdn, ind, &arena_config_default);\n\t\t}\n\t}\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntcache_available(tsd_t *tsd) {\n\t/*\n\t * Thread specific auto tcache might be unavailable if: 1) during tcache\n\t * initialization, or 2) disabled through thread.tcache.enabled mallctl\n\t * or config options. This check covers all cases.\n\t */\n\tif (likely(tsd_tcache_enabled_get(tsd))) {\n\t\t/* Associated arena == NULL implies tcache init in progress. */\n\t\tif (config_debug && tsd_tcache_slowp_get(tsd)->arena != NULL) {\n\t\t\ttcache_assert_initialized(tsd_tcachep_get(tsd));\n\t\t}\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE tcache_t *\ntcache_get(tsd_t *tsd) {\n\tif (!tcache_available(tsd)) {\n\t\treturn NULL;\n\t}\n\n\treturn tsd_tcachep_get(tsd);\n}\n\nJEMALLOC_ALWAYS_INLINE tcache_slow_t *\ntcache_slow_get(tsd_t *tsd) {\n\tif (!tcache_available(tsd)) {\n\t\treturn NULL;\n\t}\n\n\treturn tsd_tcache_slowp_get(tsd);\n}\n\nstatic inline void\npre_reentrancy(tsd_t *tsd, arena_t *arena) {\n\t/* arena is the current context. Reentry from a0 is not allowed. */\n\tassert(arena != arena_get(tsd_tsdn(tsd), 0, false));\n\ttsd_pre_reentrancy_raw(tsd);\n}\n\nstatic inline void\npost_reentrancy(tsd_t *tsd) {\n\ttsd_post_reentrancy_raw(tsd);\n}\n\n#endif /* JEMALLOC_INTERNAL_INLINES_A_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_b.h", "content": "#ifndef JEMALLOC_INTERNAL_INLINES_B_H\n#define JEMALLOC_INTERNAL_INLINES_B_H\n\n#include \"jemalloc/internal/extent.h\"\n\nstatic inline void\npercpu_arena_update(tsd_t *tsd, unsigned cpu) {\n\tassert(have_percpu_arena);\n\tarena_t *oldarena = tsd_arena_get(tsd);\n\tassert(oldarena != NULL);\n\tunsigned oldind = arena_ind_get(oldarena);\n\n\tif (oldind != cpu) {\n\t\tunsigned newind = cpu;\n\t\tarena_t *newarena = arena_get(tsd_tsdn(tsd), newind, true);\n\t\tassert(newarena != NULL);\n\n\t\t/* Set new arena/tcache associations. */\n\t\tarena_migrate(tsd, oldarena, newarena);\n\t\ttcache_t *tcache = tcache_get(tsd);\n\t\tif (tcache != NULL) {\n\t\t\ttcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);\n\t\t\ttcache_arena_reassociate(tsd_tsdn(tsd), tcache_slow,\n\t\t\t tcache, newarena);\n\t\t}\n\t}\n}\n\n\n/* Choose an arena based on a per-thread value. */\nstatic inline arena_t *\narena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal) {\n\tarena_t *ret;\n\n\tif (arena != NULL) {\n\t\treturn arena;\n\t}\n\n\t/* During reentrancy, arena 0 is the safest bet. */\n\tif (unlikely(tsd_reentrancy_level_get(tsd) > 0)) {\n\t\treturn arena_get(tsd_tsdn(tsd), 0, true);\n\t}\n\n\tret = internal ? tsd_iarena_get(tsd) : tsd_arena_get(tsd);\n\tif (unlikely(ret == NULL)) {\n\t\tret = arena_choose_hard(tsd, internal);\n\t\tassert(ret);\n\t\tif (tcache_available(tsd)) {\n\t\t\ttcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);\n\t\t\ttcache_t *tcache = tsd_tcachep_get(tsd);\n\t\t\tif (tcache_slow->arena != NULL) {\n\t\t\t\t/* See comments in tsd_tcache_data_init().*/\n\t\t\t\tassert(tcache_slow->arena ==\n\t\t\t\t arena_get(tsd_tsdn(tsd), 0, false));\n\t\t\t\tif (tcache_slow->arena != ret) {\n\t\t\t\t\ttcache_arena_reassociate(tsd_tsdn(tsd),\n\t\t\t\t\t tcache_slow, tcache, ret);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttcache_arena_associate(tsd_tsdn(tsd),\n\t\t\t\t tcache_slow, tcache, ret);\n\t\t\t}\n\t\t}\n\t}\n\n\t/*\n\t * Note that for percpu arena, if the current arena is outside of the\n\t * auto percpu arena range, (i.e. thread is assigned to a manually\n\t * managed arena), then percpu arena is skipped.\n\t */\n\tif (have_percpu_arena && PERCPU_ARENA_ENABLED(opt_percpu_arena) &&\n\t !internal && (arena_ind_get(ret) <\n\t percpu_arena_ind_limit(opt_percpu_arena)) && (ret->last_thd !=\n\t tsd_tsdn(tsd))) {\n\t\tunsigned ind = percpu_arena_choose();\n\t\tif (arena_ind_get(ret) != ind) {\n\t\t\tpercpu_arena_update(tsd, ind);\n\t\t\tret = tsd_arena_get(tsd);\n\t\t}\n\t\tret->last_thd = tsd_tsdn(tsd);\n\t}\n\n\treturn ret;\n}\n\nstatic inline arena_t *\narena_choose(tsd_t *tsd, arena_t *arena) {\n\treturn arena_choose_impl(tsd, arena, false);\n}\n\nstatic inline arena_t *\narena_ichoose(tsd_t *tsd, arena_t *arena) {\n\treturn arena_choose_impl(tsd, arena, true);\n}\n\nstatic inline bool\narena_is_auto(arena_t *arena) {\n\tassert(narenas_auto > 0);\n\n\treturn (arena_ind_get(arena) < manual_arena_base);\n}\n\n#endif /* JEMALLOC_INTERNAL_INLINES_B_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h", "content": "#ifndef JEMALLOC_INTERNAL_INLINES_C_H\n#define JEMALLOC_INTERNAL_INLINES_C_H\n\n#include \"jemalloc/internal/hook.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/log.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/thread_event.h\"\n#include \"jemalloc/internal/witness.h\"\n\n/*\n * Translating the names of the 'i' functions:\n * Abbreviations used in the first part of the function name (before\n * alloc/dalloc) describe what that function accomplishes:\n * a: arena (query)\n * s: size (query, or sized deallocation)\n * e: extent (query)\n * p: aligned (allocates)\n * vs: size (query, without knowing that the pointer is into the heap)\n * r: rallocx implementation\n * x: xallocx implementation\n * Abbreviations used in the second part of the function name (after\n * alloc/dalloc) describe the arguments it takes\n * z: whether to return zeroed memory\n * t: accepts a tcache_t * parameter\n * m: accepts an arena_t * parameter\n */\n\nJEMALLOC_ALWAYS_INLINE arena_t *\niaalloc(tsdn_t *tsdn, const void *ptr) {\n\tassert(ptr != NULL);\n\n\treturn arena_aalloc(tsdn, ptr);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nisalloc(tsdn_t *tsdn, const void *ptr) {\n\tassert(ptr != NULL);\n\n\treturn arena_salloc(tsdn, ptr);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\niallocztm(tsdn_t *tsdn, size_t size, szind_t ind, bool zero, tcache_t *tcache,\n bool is_internal, arena_t *arena, bool slow_path) {\n\tvoid *ret;\n\n\tassert(!is_internal || tcache == NULL);\n\tassert(!is_internal || arena == NULL || arena_is_auto(arena));\n\tif (!tsdn_null(tsdn) && tsd_reentrancy_level_get(tsdn_tsd(tsdn)) == 0) {\n\t\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t\t WITNESS_RANK_CORE, 0);\n\t}\n\n\tret = arena_malloc(tsdn, arena, size, ind, zero, tcache, slow_path);\n\tif (config_stats && is_internal && likely(ret != NULL)) {\n\t\tarena_internal_add(iaalloc(tsdn, ret), isalloc(tsdn, ret));\n\t}\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nialloc(tsd_t *tsd, size_t size, szind_t ind, bool zero, bool slow_path) {\n\treturn iallocztm(tsd_tsdn(tsd), size, ind, zero, tcache_get(tsd), false,\n\t NULL, slow_path);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nipallocztm(tsdn_t *tsdn, size_t usize, size_t alignment, bool zero,\n tcache_t *tcache, bool is_internal, arena_t *arena) {\n\tvoid *ret;\n\n\tassert(usize != 0);\n\tassert(usize == sz_sa2u(usize, alignment));\n\tassert(!is_internal || tcache == NULL);\n\tassert(!is_internal || arena == NULL || arena_is_auto(arena));\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tret = arena_palloc(tsdn, arena, usize, alignment, zero, tcache);\n\tassert(ALIGNMENT_ADDR2BASE(ret, alignment) == ret);\n\tif (config_stats && is_internal && likely(ret != NULL)) {\n\t\tarena_internal_add(iaalloc(tsdn, ret), isalloc(tsdn, ret));\n\t}\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nipalloct(tsdn_t *tsdn, size_t usize, size_t alignment, bool zero,\n tcache_t *tcache, arena_t *arena) {\n\treturn ipallocztm(tsdn, usize, alignment, zero, tcache, false, arena);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nipalloc(tsd_t *tsd, size_t usize, size_t alignment, bool zero) {\n\treturn ipallocztm(tsd_tsdn(tsd), usize, alignment, zero,\n\t tcache_get(tsd), false, NULL);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nivsalloc(tsdn_t *tsdn, const void *ptr) {\n\treturn arena_vsalloc(tsdn, ptr);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nidalloctm(tsdn_t *tsdn, void *ptr, tcache_t *tcache,\n emap_alloc_ctx_t *alloc_ctx, bool is_internal, bool slow_path) {\n\tassert(ptr != NULL);\n\tassert(!is_internal || tcache == NULL);\n\tassert(!is_internal || arena_is_auto(iaalloc(tsdn, ptr)));\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tif (config_stats && is_internal) {\n\t\tarena_internal_sub(iaalloc(tsdn, ptr), isalloc(tsdn, ptr));\n\t}\n\tif (!is_internal && !tsdn_null(tsdn) &&\n\t tsd_reentrancy_level_get(tsdn_tsd(tsdn)) != 0) {\n\t\tassert(tcache == NULL);\n\t}\n\tarena_dalloc(tsdn, ptr, tcache, alloc_ctx, slow_path);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nidalloc(tsd_t *tsd, void *ptr) {\n\tidalloctm(tsd_tsdn(tsd), ptr, tcache_get(tsd), NULL, false, true);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nisdalloct(tsdn_t *tsdn, void *ptr, size_t size, tcache_t *tcache,\n emap_alloc_ctx_t *alloc_ctx, bool slow_path) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tarena_sdalloc(tsdn, ptr, size, tcache, alloc_ctx, slow_path);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\niralloct_realign(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,\n size_t alignment, bool zero, tcache_t *tcache, arena_t *arena,\n hook_ralloc_args_t *hook_args) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tvoid *p;\n\tsize_t usize, copysize;\n\n\tusize = sz_sa2u(size, alignment);\n\tif (unlikely(usize == 0 || usize > SC_LARGE_MAXCLASS)) {\n\t\treturn NULL;\n\t}\n\tp = ipalloct(tsdn, usize, alignment, zero, tcache, arena);\n\tif (p == NULL) {\n\t\treturn NULL;\n\t}\n\t/*\n\t * Copy at most size bytes (not size+extra), since the caller has no\n\t * expectation that the extra bytes will be reliably preserved.\n\t */\n\tcopysize = (size < oldsize) ? size : oldsize;\n\tmemcpy(p, ptr, copysize);\n\thook_invoke_alloc(hook_args->is_realloc\n\t ? hook_alloc_realloc : hook_alloc_rallocx, p, (uintptr_t)p,\n\t hook_args->args);\n\thook_invoke_dalloc(hook_args->is_realloc\n\t ? hook_dalloc_realloc : hook_dalloc_rallocx, ptr, hook_args->args);\n\tisdalloct(tsdn, ptr, oldsize, tcache, NULL, true);\n\treturn p;\n}\n\n/*\n * is_realloc threads through the knowledge of whether or not this call comes\n * from je_realloc (as opposed to je_rallocx); this ensures that we pass the\n * correct entry point into any hooks.\n * Note that these functions are all force-inlined, so no actual bool gets\n * passed-around anywhere.\n */\nJEMALLOC_ALWAYS_INLINE void *\niralloct(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size, size_t alignment,\n bool zero, tcache_t *tcache, arena_t *arena, hook_ralloc_args_t *hook_args)\n{\n\tassert(ptr != NULL);\n\tassert(size != 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (alignment != 0 && ((uintptr_t)ptr & ((uintptr_t)alignment-1))\n\t != 0) {\n\t\t/*\n\t\t * Existing object alignment is inadequate; allocate new space\n\t\t * and copy.\n\t\t */\n\t\treturn iralloct_realign(tsdn, ptr, oldsize, size, alignment,\n\t\t zero, tcache, arena, hook_args);\n\t}\n\n\treturn arena_ralloc(tsdn, arena, ptr, oldsize, size, alignment, zero,\n\t tcache, hook_args);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\niralloc(tsd_t *tsd, void *ptr, size_t oldsize, size_t size, size_t alignment,\n bool zero, hook_ralloc_args_t *hook_args) {\n\treturn iralloct(tsd_tsdn(tsd), ptr, oldsize, size, alignment, zero,\n\t tcache_get(tsd), NULL, hook_args);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nixalloc(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size, size_t extra,\n size_t alignment, bool zero, size_t *newsize) {\n\tassert(ptr != NULL);\n\tassert(size != 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (alignment != 0 && ((uintptr_t)ptr & ((uintptr_t)alignment-1))\n\t != 0) {\n\t\t/* Existing object alignment is inadequate. */\n\t\t*newsize = oldsize;\n\t\treturn true;\n\t}\n\n\treturn arena_ralloc_no_move(tsdn, ptr, oldsize, size, extra, zero,\n\t newsize);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nfastpath_success_finish(tsd_t *tsd, uint64_t allocated_after,\n cache_bin_t *bin, void *ret) {\n\tthread_allocated_set(tsd, allocated_after);\n\tif (config_stats) {\n\t\tbin->tstats.nrequests++;\n\t}\n\n\tLOG(\"core.malloc.exit\", \"result: %p\", ret);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nmalloc_initialized(void) {\n\treturn (malloc_init_state == malloc_init_initialized);\n}\n\n/*\n * malloc() fastpath. Included here so that we can inline it into operator new;\n * function call overhead there is non-negligible as a fraction of total CPU in\n * allocation-heavy C++ programs. We take the fallback alloc to allow malloc\n * (which can return NULL) to differ in its behavior from operator new (which\n * can't). It matches the signature of malloc / operator new so that we can\n * tail-call the fallback allocator, allowing us to avoid setting up the call\n * frame in the common case.\n *\n * Fastpath assumes size <= SC_LOOKUP_MAXCLASS, and that we hit\n * tcache. If either of these is false, we tail-call to the slowpath,\n * malloc_default(). Tail-calling is used to avoid any caller-saved\n * registers.\n *\n * fastpath supports ticker and profiling, both of which will also\n * tail-call to the slowpath if they fire.\n */\nJEMALLOC_ALWAYS_INLINE void *\nimalloc_fastpath(size_t size, void *(fallback_alloc)(size_t, size_t *), size_t *usable_size) {\n\tLOG(\"core.malloc.entry\", \"size: %zu\", size);\n\tif (tsd_get_allocates() && unlikely(!malloc_initialized())) {\n\t\treturn fallback_alloc(size, usable_size);\n\t}\n\n\ttsd_t *tsd = tsd_get(false);\n\tif (unlikely((size > SC_LOOKUP_MAXCLASS) || tsd == NULL)) {\n\t\treturn fallback_alloc(size, usable_size);\n\t}\n\t/*\n\t * The code below till the branch checking the next_event threshold may\n\t * execute before malloc_init(), in which case the threshold is 0 to\n\t * trigger slow path and initialization.\n\t *\n\t * Note that when uninitialized, only the fast-path variants of the sz /\n\t * tsd facilities may be called.\n\t */\n\tszind_t ind;\n\t/*\n\t * The thread_allocated counter in tsd serves as a general purpose\n\t * accumulator for bytes of allocation to trigger different types of\n\t * events. usize is always needed to advance thread_allocated, though\n\t * it's not always needed in the core allocation logic.\n\t */\n\tsize_t usize;\n\tsz_size2index_usize_fastpath(size, &ind, &usize);\n\t/* Fast path relies on size being a bin. */\n\tassert(ind < SC_NBINS);\n\tassert((SC_LOOKUP_MAXCLASS < SC_SMALL_MAXCLASS) &&\n\t (size <= SC_SMALL_MAXCLASS));\n\n\tuint64_t allocated, threshold;\n\tte_malloc_fastpath_ctx(tsd, &allocated, &threshold);\n\tuint64_t allocated_after = allocated + usize;\n\t/*\n\t * The ind and usize might be uninitialized (or partially) before\n\t * malloc_init(). The assertions check for: 1) full correctness (usize\n\t * & ind) when initialized; and 2) guaranteed slow-path (threshold == 0)\n\t * when !initialized.\n\t */\n\tif (!malloc_initialized()) {\n\t\tassert(threshold == 0);\n\t} else {\n\t\tassert(ind == sz_size2index(size));\n\t\tassert(usize > 0 && usize == sz_index2size(ind));\n\t}\n\t/*\n\t * Check for events and tsd non-nominal (fast_threshold will be set to\n\t * 0) in a single branch.\n\t */\n\tif (unlikely(allocated_after >= threshold)) {\n\t\treturn fallback_alloc(size, usable_size);\n\t}\n\tassert(tsd_fast(tsd));\n\n\ttcache_t *tcache = tsd_tcachep_get(tsd);\n\tassert(tcache == tcache_get(tsd));\n\tcache_bin_t *bin = &tcache->bins[ind];\n\tbool tcache_success;\n\tvoid *ret;\n\n\t/*\n\t * We split up the code this way so that redundant low-water\n\t * computation doesn't happen on the (more common) case in which we\n\t * don't touch the low water mark. The compiler won't do this\n\t * duplication on its own.\n\t */\n\tret = cache_bin_alloc_easy(bin, &tcache_success);\n\tif (tcache_success) {\n\t\tfastpath_success_finish(tsd, allocated_after, bin, ret);\n\t\tif (usable_size) *usable_size = usize;\n\t\treturn ret;\n\t}\n\tret = cache_bin_alloc(bin, &tcache_success);\n\tif (tcache_success) {\n\t\tfastpath_success_finish(tsd, allocated_after, bin, ret);\n\t\tif (usable_size) *usable_size = usize;\n\t\treturn ret;\n\t}\n\n\treturn fallback_alloc(size, usable_size);\n}\n\nJEMALLOC_ALWAYS_INLINE int\niget_defrag_hint(tsdn_t *tsdn, void* ptr) {\n\tint defrag = 0;\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsdn, &arena_emap_global, ptr, &alloc_ctx);\n\tif (likely(alloc_ctx.slab)) {\n\t\t/* Small allocation. */\n\t\tedata_t *slab = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\t\tarena_t *arena = arena_get_from_edata(slab);\n\t\tszind_t binind = edata_szind_get(slab);\n\t\tunsigned binshard = edata_binshard_get(slab);\n\t\tbin_t *bin = arena_get_bin(arena, binind, binshard);\n\t\tmalloc_mutex_lock(tsdn, &bin->lock);\n\t\tarena_dalloc_bin_locked_info_t info;\n\t\tarena_dalloc_bin_locked_begin(&info, binind);\n\t\t/* Don't bother moving allocations from the slab currently used for new allocations */\n\t\tif (slab != bin->slabcur) {\n\t\t\tint free_in_slab = edata_nfree_get(slab);\n\t\t\tif (free_in_slab) {\n\t\t\t\tconst bin_info_t *bin_info = &bin_infos[binind];\n\t\t\t\t/* Find number of non-full slabs and the number of regs in them */\n\t\t\t\tunsigned long curslabs = 0;\n\t\t\t\tsize_t curregs = 0;\n\t\t\t\t/* Run on all bin shards (usually just one) */\n\t\t\t\tfor (uint32_t i=0; i< bin_info->n_shards; i++) {\n\t\t\t\t\tbin_t *bb = arena_get_bin(arena, binind, i);\n\t\t\t\t\tcurslabs += bb->stats.nonfull_slabs;\n\t\t\t\t\t/* Deduct the regs in full slabs (they're not part of the game) */\n\t\t\t\t\tunsigned long full_slabs = bb->stats.curslabs - bb->stats.nonfull_slabs;\n\t\t\t\t\tcurregs += bb->stats.curregs - full_slabs * bin_info->nregs;\n\t\t\t\t\tif (bb->slabcur) {\n\t\t\t\t\t\t/* Remove slabcur from the overall utilization (not a candidate to nove from) */\n\t\t\t\t\t\tcurregs -= bin_info->nregs - edata_nfree_get(bb->slabcur);\n\t\t\t\t\t\tcurslabs -= 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t/* Compare the utilization ratio of the slab in question to the total average\n\t\t\t\t * among non-full slabs. To avoid precision loss in division, we do that by\n\t\t\t\t * extrapolating the usage of the slab as if all slabs have the same usage.\n\t\t\t\t * If this slab is less used than the average, we'll prefer to move the data\n\t\t\t\t * to hopefully more used ones. To avoid stagnation when all slabs have the same\n\t\t\t\t * utilization, we give additional 12.5% weight to the decision to defrag. */\n\t\t\t\tdefrag = (bin_info->nregs - free_in_slab) * curslabs <= curregs + curregs / 8;\n\t\t\t}\n\t\t}\n\t\tarena_dalloc_bin_locked_finish(tsdn, arena, bin, &info);\n\t\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\t}\n\treturn defrag;\n}\n\n#endif /* JEMALLOC_INTERNAL_INLINES_C_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_macros.h", "content": "#ifndef JEMALLOC_INTERNAL_MACROS_H\n#define JEMALLOC_INTERNAL_MACROS_H\n\n#ifdef JEMALLOC_DEBUG\n# define JEMALLOC_ALWAYS_INLINE static inline\n#else\n# ifdef _MSC_VER\n# define JEMALLOC_ALWAYS_INLINE static __forceinline\n# else\n# define JEMALLOC_ALWAYS_INLINE JEMALLOC_ATTR(always_inline) static inline\n# endif\n#endif\n#ifdef _MSC_VER\n# define inline _inline\n#endif\n\n#define UNUSED JEMALLOC_ATTR(unused)\n\n#define ZU(z)\t((size_t)z)\n#define ZD(z)\t((ssize_t)z)\n#define QU(q)\t((uint64_t)q)\n#define QD(q)\t((int64_t)q)\n\n#define KZU(z)\tZU(z##ULL)\n#define KZD(z)\tZD(z##LL)\n#define KQU(q)\tQU(q##ULL)\n#define KQD(q)\tQI(q##LL)\n\n#ifndef __DECONST\n# define\t__DECONST(type, var)\t((type)(uintptr_t)(const void *)(var))\n#endif\n\n#if !defined(JEMALLOC_HAS_RESTRICT) || defined(__cplusplus)\n# define restrict\n#endif\n\n/* Various function pointers are static and immutable except during testing. */\n#ifdef JEMALLOC_JET\n# define JET_MUTABLE\n#else\n# define JET_MUTABLE const\n#endif\n\n#define JEMALLOC_VA_ARGS_HEAD(head, ...) head\n#define JEMALLOC_VA_ARGS_TAIL(head, ...) __VA_ARGS__\n\n/* Diagnostic suppression macros */\n#if defined(_MSC_VER) && !defined(__clang__)\n# define JEMALLOC_DIAGNOSTIC_PUSH __pragma(warning(push))\n# define JEMALLOC_DIAGNOSTIC_POP __pragma(warning(pop))\n# define JEMALLOC_DIAGNOSTIC_IGNORE(W) __pragma(warning(disable:W))\n# define JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n# define JEMALLOC_DIAGNOSTIC_IGNORE_TYPE_LIMITS\n# define JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n# define JEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n/* #pragma GCC diagnostic first appeared in gcc 4.6. */\n#elif (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && \\\n (__GNUC_MINOR__ > 5)))) || defined(__clang__)\n/*\n * The JEMALLOC_PRAGMA__ macro is an implementation detail of the GCC and Clang\n * diagnostic suppression macros and should not be used anywhere else.\n */\n# define JEMALLOC_PRAGMA__(X) _Pragma(#X)\n# define JEMALLOC_DIAGNOSTIC_PUSH JEMALLOC_PRAGMA__(GCC diagnostic push)\n# define JEMALLOC_DIAGNOSTIC_POP JEMALLOC_PRAGMA__(GCC diagnostic pop)\n# define JEMALLOC_DIAGNOSTIC_IGNORE(W) \\\n JEMALLOC_PRAGMA__(GCC diagnostic ignored W)\n\n/*\n * The -Wmissing-field-initializers warning is buggy in GCC versions < 5.1 and\n * all clang versions up to version 7 (currently trunk, unreleased). This macro\n * suppresses the warning for the affected compiler versions only.\n */\n# if ((defined(__GNUC__) && !defined(__clang__)) && (__GNUC__ < 5)) || \\\n defined(__clang__)\n# define JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS \\\n JEMALLOC_DIAGNOSTIC_IGNORE(\"-Wmissing-field-initializers\")\n# else\n# define JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n# endif\n\n# define JEMALLOC_DIAGNOSTIC_IGNORE_TYPE_LIMITS \\\n JEMALLOC_DIAGNOSTIC_IGNORE(\"-Wtype-limits\")\n# define JEMALLOC_DIAGNOSTIC_IGNORE_UNUSED_PARAMETER \\\n JEMALLOC_DIAGNOSTIC_IGNORE(\"-Wunused-parameter\")\n# if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ >= 7)\n# define JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN \\\n JEMALLOC_DIAGNOSTIC_IGNORE(\"-Walloc-size-larger-than=\")\n# else\n# define JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n# endif\n# define JEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS \\\n JEMALLOC_DIAGNOSTIC_PUSH \\\n JEMALLOC_DIAGNOSTIC_IGNORE_UNUSED_PARAMETER\n#else\n# define JEMALLOC_DIAGNOSTIC_PUSH\n# define JEMALLOC_DIAGNOSTIC_POP\n# define JEMALLOC_DIAGNOSTIC_IGNORE(W)\n# define JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n# define JEMALLOC_DIAGNOSTIC_IGNORE_TYPE_LIMITS\n# define JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n# define JEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n#endif\n\n/*\n * Disables spurious diagnostics for all headers. Since these headers are not\n * included by users directly, it does not affect their diagnostic settings.\n */\nJEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n\n#endif /* JEMALLOC_INTERNAL_MACROS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_types.h", "content": "#ifndef JEMALLOC_INTERNAL_TYPES_H\n#define JEMALLOC_INTERNAL_TYPES_H\n\n#include \"jemalloc/internal/quantum.h\"\n\n/* Processor / core id type. */\ntypedef int malloc_cpuid_t;\n\n/* When realloc(non-null-ptr, 0) is called, what happens? */\nenum zero_realloc_action_e {\n\t/* Realloc(ptr, 0) is free(ptr); return malloc(0); */\n\tzero_realloc_action_alloc = 0,\n\t/* Realloc(ptr, 0) is free(ptr); */\n\tzero_realloc_action_free = 1,\n\t/* Realloc(ptr, 0) aborts. */\n\tzero_realloc_action_abort = 2\n};\ntypedef enum zero_realloc_action_e zero_realloc_action_t;\n\n/* Signature of write callback. */\ntypedef void (write_cb_t)(void *, const char *);\n\nenum malloc_init_e {\n\tmalloc_init_uninitialized\t= 3,\n\tmalloc_init_a0_initialized\t= 2,\n\tmalloc_init_recursible\t\t= 1,\n\tmalloc_init_initialized\t\t= 0 /* Common case --> jnz. */\n};\ntypedef enum malloc_init_e malloc_init_t;\n\n/*\n * Flags bits:\n *\n * a: arena\n * t: tcache\n * 0: unused\n * z: zero\n * n: alignment\n *\n * aaaaaaaa aaaatttt tttttttt 0znnnnnn\n */\n#define MALLOCX_ARENA_BITS\t12\n#define MALLOCX_TCACHE_BITS\t12\n#define MALLOCX_LG_ALIGN_BITS\t6\n#define MALLOCX_ARENA_SHIFT\t20\n#define MALLOCX_TCACHE_SHIFT\t8\n#define MALLOCX_ARENA_MASK \\\n (((1 << MALLOCX_ARENA_BITS) - 1) << MALLOCX_ARENA_SHIFT)\n/* NB: Arena index bias decreases the maximum number of arenas by 1. */\n#define MALLOCX_ARENA_LIMIT\t((1 << MALLOCX_ARENA_BITS) - 1)\n#define MALLOCX_TCACHE_MASK \\\n (((1 << MALLOCX_TCACHE_BITS) - 1) << MALLOCX_TCACHE_SHIFT)\n#define MALLOCX_TCACHE_MAX\t((1 << MALLOCX_TCACHE_BITS) - 3)\n#define MALLOCX_LG_ALIGN_MASK\t((1 << MALLOCX_LG_ALIGN_BITS) - 1)\n/* Use MALLOCX_ALIGN_GET() if alignment may not be specified in flags. */\n#define MALLOCX_ALIGN_GET_SPECIFIED(flags)\t\t\t\t\\\n (ZU(1) << (flags & MALLOCX_LG_ALIGN_MASK))\n#define MALLOCX_ALIGN_GET(flags)\t\t\t\t\t\\\n (MALLOCX_ALIGN_GET_SPECIFIED(flags) & (SIZE_T_MAX-1))\n#define MALLOCX_ZERO_GET(flags)\t\t\t\t\t\t\\\n ((bool)(flags & MALLOCX_ZERO))\n\n#define MALLOCX_TCACHE_GET(flags)\t\t\t\t\t\\\n (((unsigned)((flags & MALLOCX_TCACHE_MASK) >> MALLOCX_TCACHE_SHIFT)) - 2)\n#define MALLOCX_ARENA_GET(flags)\t\t\t\t\t\\\n (((unsigned)(((unsigned)flags) >> MALLOCX_ARENA_SHIFT)) - 1)\n\n/* Smallest size class to support. */\n#define TINY_MIN\t\t(1U << LG_TINY_MIN)\n\n#define LONG\t\t\t((size_t)(1U << LG_SIZEOF_LONG))\n#define LONG_MASK\t\t(LONG - 1)\n\n/* Return the smallest long multiple that is >= a. */\n#define LONG_CEILING(a)\t\t\t\t\t\t\t\\\n\t(((a) + LONG_MASK) & ~LONG_MASK)\n\n#define SIZEOF_PTR\t\t(1U << LG_SIZEOF_PTR)\n#define PTR_MASK\t\t(SIZEOF_PTR - 1)\n\n/* Return the smallest (void *) multiple that is >= a. */\n#define PTR_CEILING(a)\t\t\t\t\t\t\t\\\n\t(((a) + PTR_MASK) & ~PTR_MASK)\n\n/*\n * Maximum size of L1 cache line. This is used to avoid cache line aliasing.\n * In addition, this controls the spacing of cacheline-spaced size classes.\n *\n * CACHELINE cannot be based on LG_CACHELINE because __declspec(align()) can\n * only handle raw constants.\n */\n#define LG_CACHELINE\t\t6\n#define CACHELINE\t\t64\n#define CACHELINE_MASK\t\t(CACHELINE - 1)\n\n/* Return the smallest cacheline multiple that is >= s. */\n#define CACHELINE_CEILING(s)\t\t\t\t\t\t\\\n\t(((s) + CACHELINE_MASK) & ~CACHELINE_MASK)\n\n/* Return the nearest aligned address at or below a. */\n#define ALIGNMENT_ADDR2BASE(a, alignment)\t\t\t\t\\\n\t((void *)((uintptr_t)(a) & ((~(alignment)) + 1)))\n\n/* Return the offset between a and the nearest aligned address at or below a. */\n#define ALIGNMENT_ADDR2OFFSET(a, alignment)\t\t\t\t\\\n\t((size_t)((uintptr_t)(a) & (alignment - 1)))\n\n/* Return the smallest alignment multiple that is >= s. */\n#define ALIGNMENT_CEILING(s, alignment)\t\t\t\t\t\\\n\t(((s) + (alignment - 1)) & ((~(alignment)) + 1))\n\n/* Declare a variable-length array. */\n#if __STDC_VERSION__ < 199901L\n# ifdef _MSC_VER\n# include \n# define alloca _alloca\n# else\n# ifdef JEMALLOC_HAS_ALLOCA_H\n# include \n# else\n# include \n# endif\n# endif\n# define VARIABLE_ARRAY(type, name, count) \\\n\ttype *name = alloca(sizeof(type) * (count))\n#else\n# define VARIABLE_ARRAY(type, name, count) type name[(count)]\n#endif\n\n#endif /* JEMALLOC_INTERNAL_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/jemalloc_preamble.h.in", "content": "#ifndef JEMALLOC_PREAMBLE_H\n#define JEMALLOC_PREAMBLE_H\n\n#include \"jemalloc_internal_defs.h\"\n#include \"jemalloc/internal/jemalloc_internal_decls.h\"\n\n#if defined(JEMALLOC_UTRACE) || defined(JEMALLOC_UTRACE_LABEL)\n#include \n# if defined(JEMALLOC_UTRACE)\n# define UTRACE_CALL(p, l) utrace(p, l)\n# else\n# define UTRACE_CALL(p, l) utrace(\"jemalloc_process\", p, l)\n# define JEMALLOC_UTRACE\n# endif\n#endif\n\n#define JEMALLOC_NO_DEMANGLE\n#ifdef JEMALLOC_JET\n# undef JEMALLOC_IS_MALLOC\n# define JEMALLOC_N(n) jet_##n\n# include \"jemalloc/internal/public_namespace.h\"\n# define JEMALLOC_NO_RENAME\n# include \"../jemalloc@install_suffix@.h\"\n# undef JEMALLOC_NO_RENAME\n#else\n# define JEMALLOC_N(n) @private_namespace@##n\n# include \"../jemalloc@install_suffix@.h\"\n#endif\n\n#if defined(JEMALLOC_OSATOMIC)\n#include \n#endif\n\n#ifdef JEMALLOC_ZONE\n#include \n#include \n#include \n#endif\n\n#include \"jemalloc/internal/jemalloc_internal_macros.h\"\n\n/*\n * Note that the ordering matters here; the hook itself is name-mangled. We\n * want the inclusion of hooks to happen early, so that we hook as much as\n * possible.\n */\n#ifndef JEMALLOC_NO_PRIVATE_NAMESPACE\n# ifndef JEMALLOC_JET\n# include \"jemalloc/internal/private_namespace.h\"\n# else\n# include \"jemalloc/internal/private_namespace_jet.h\"\n# endif\n#endif\n#include \"jemalloc/internal/test_hooks.h\"\n\n#ifdef JEMALLOC_DEFINE_MADVISE_FREE\n# define JEMALLOC_MADV_FREE 8\n#endif\n\nstatic const bool config_debug =\n#ifdef JEMALLOC_DEBUG\n true\n#else\n false\n#endif\n ;\nstatic const bool have_dss =\n#ifdef JEMALLOC_DSS\n true\n#else\n false\n#endif\n ;\nstatic const bool have_madvise_huge =\n#ifdef JEMALLOC_HAVE_MADVISE_HUGE\n true\n#else\n false\n#endif\n ;\nstatic const bool config_fill =\n#ifdef JEMALLOC_FILL\n true\n#else\n false\n#endif\n ;\nstatic const bool config_lazy_lock =\n#ifdef JEMALLOC_LAZY_LOCK\n true\n#else\n false\n#endif\n ;\nstatic const char * const config_malloc_conf = JEMALLOC_CONFIG_MALLOC_CONF;\nstatic const bool config_prof =\n#ifdef JEMALLOC_PROF\n true\n#else\n false\n#endif\n ;\nstatic const bool config_prof_libgcc =\n#ifdef JEMALLOC_PROF_LIBGCC\n true\n#else\n false\n#endif\n ;\nstatic const bool config_prof_libunwind =\n#ifdef JEMALLOC_PROF_LIBUNWIND\n true\n#else\n false\n#endif\n ;\nstatic const bool maps_coalesce =\n#ifdef JEMALLOC_MAPS_COALESCE\n true\n#else\n false\n#endif\n ;\nstatic const bool config_stats =\n#ifdef JEMALLOC_STATS\n true\n#else\n false\n#endif\n ;\nstatic const bool config_tls =\n#ifdef JEMALLOC_TLS\n true\n#else\n false\n#endif\n ;\nstatic const bool config_utrace =\n#ifdef JEMALLOC_UTRACE\n true\n#else\n false\n#endif\n ;\nstatic const bool config_xmalloc =\n#ifdef JEMALLOC_XMALLOC\n true\n#else\n false\n#endif\n ;\nstatic const bool config_cache_oblivious =\n#ifdef JEMALLOC_CACHE_OBLIVIOUS\n true\n#else\n false\n#endif\n ;\n/*\n * Undocumented, for jemalloc development use only at the moment. See the note\n * in jemalloc/internal/log.h.\n */\nstatic const bool config_log =\n#ifdef JEMALLOC_LOG\n true\n#else\n false\n#endif\n ;\n/*\n * Are extra safety checks enabled; things like checking the size of sized\n * deallocations, double-frees, etc.\n */\nstatic const bool config_opt_safety_checks =\n#ifdef JEMALLOC_OPT_SAFETY_CHECKS\n true\n#elif defined(JEMALLOC_DEBUG)\n /*\n * This lets us only guard safety checks by one flag instead of two; fast\n * checks can guard solely by config_opt_safety_checks and run in debug mode\n * too.\n */\n true\n#else\n false\n#endif\n ;\n\n/*\n * Extra debugging of sized deallocations too onerous to be included in the\n * general safety checks.\n */\nstatic const bool config_opt_size_checks =\n#if defined(JEMALLOC_OPT_SIZE_CHECKS) || defined(JEMALLOC_DEBUG)\n true\n#else\n false\n#endif\n ;\n\nstatic const bool config_uaf_detection =\n#if defined(JEMALLOC_UAF_DETECTION) || defined(JEMALLOC_DEBUG)\n true\n#else\n false\n#endif\n ;\n\n/* Whether or not the C++ extensions are enabled. */\nstatic const bool config_enable_cxx =\n#ifdef JEMALLOC_ENABLE_CXX\n true\n#else\n false\n#endif\n;\n\n#if defined(_WIN32) || defined(JEMALLOC_HAVE_SCHED_GETCPU)\n/* Currently percpu_arena depends on sched_getcpu. */\n#define JEMALLOC_PERCPU_ARENA\n#endif\nstatic const bool have_percpu_arena =\n#ifdef JEMALLOC_PERCPU_ARENA\n true\n#else\n false\n#endif\n ;\n/*\n * Undocumented, and not recommended; the application should take full\n * responsibility for tracking provenance.\n */\nstatic const bool force_ivsalloc =\n#ifdef JEMALLOC_FORCE_IVSALLOC\n true\n#else\n false\n#endif\n ;\nstatic const bool have_background_thread =\n#ifdef JEMALLOC_BACKGROUND_THREAD\n true\n#else\n false\n#endif\n ;\nstatic const bool config_high_res_timer =\n#ifdef JEMALLOC_HAVE_CLOCK_REALTIME\n true\n#else\n false\n#endif\n ;\n\nstatic const bool have_memcntl =\n#ifdef JEMALLOC_HAVE_MEMCNTL\n true\n#else\n false\n#endif\n ;\n\n#endif /* JEMALLOC_PREAMBLE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/large_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_LARGE_EXTERNS_H\n#define JEMALLOC_INTERNAL_LARGE_EXTERNS_H\n\n#include \"jemalloc/internal/hook.h\"\n\nvoid *large_malloc(tsdn_t *tsdn, arena_t *arena, size_t usize, bool zero);\nvoid *large_palloc(tsdn_t *tsdn, arena_t *arena, size_t usize, size_t alignment,\n bool zero);\nbool large_ralloc_no_move(tsdn_t *tsdn, edata_t *edata, size_t usize_min,\n size_t usize_max, bool zero);\nvoid *large_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t usize,\n size_t alignment, bool zero, tcache_t *tcache,\n hook_ralloc_args_t *hook_args);\n\nvoid large_dalloc_prep_locked(tsdn_t *tsdn, edata_t *edata);\nvoid large_dalloc_finish(tsdn_t *tsdn, edata_t *edata);\nvoid large_dalloc(tsdn_t *tsdn, edata_t *edata);\nsize_t large_salloc(tsdn_t *tsdn, const edata_t *edata);\nvoid large_prof_info_get(tsd_t *tsd, edata_t *edata, prof_info_t *prof_info,\n bool reset_recent);\nvoid large_prof_tctx_reset(edata_t *edata);\nvoid large_prof_info_set(edata_t *edata, prof_tctx_t *tctx, size_t size);\n\n#endif /* JEMALLOC_INTERNAL_LARGE_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/lockedint.h", "content": "#ifndef JEMALLOC_INTERNAL_LOCKEDINT_H\n#define JEMALLOC_INTERNAL_LOCKEDINT_H\n\n/*\n * In those architectures that support 64-bit atomics, we use atomic updates for\n * our 64-bit values. Otherwise, we use a plain uint64_t and synchronize\n * externally.\n */\n\ntypedef struct locked_u64_s locked_u64_t;\n#ifdef JEMALLOC_ATOMIC_U64\nstruct locked_u64_s {\n\tatomic_u64_t val;\n};\n#else\n/* Must hold the associated mutex. */\nstruct locked_u64_s {\n\tuint64_t val;\n};\n#endif\n\ntypedef struct locked_zu_s locked_zu_t;\nstruct locked_zu_s {\n\tatomic_zu_t val;\n};\n\n#ifndef JEMALLOC_ATOMIC_U64\n# define LOCKEDINT_MTX_DECLARE(name) malloc_mutex_t name;\n# define LOCKEDINT_MTX_INIT(mu, name, rank, rank_mode)\t\t\t\\\n malloc_mutex_init(&(mu), name, rank, rank_mode)\n# define LOCKEDINT_MTX(mtx) (&(mtx))\n# define LOCKEDINT_MTX_LOCK(tsdn, mu) malloc_mutex_lock(tsdn, &(mu))\n# define LOCKEDINT_MTX_UNLOCK(tsdn, mu) malloc_mutex_unlock(tsdn, &(mu))\n# define LOCKEDINT_MTX_PREFORK(tsdn, mu) malloc_mutex_prefork(tsdn, &(mu))\n# define LOCKEDINT_MTX_POSTFORK_PARENT(tsdn, mu)\t\t\t\\\n malloc_mutex_postfork_parent(tsdn, &(mu))\n# define LOCKEDINT_MTX_POSTFORK_CHILD(tsdn, mu)\t\t\t\\\n malloc_mutex_postfork_child(tsdn, &(mu))\n#else\n# define LOCKEDINT_MTX_DECLARE(name)\n# define LOCKEDINT_MTX(mtx) NULL\n# define LOCKEDINT_MTX_INIT(mu, name, rank, rank_mode) false\n# define LOCKEDINT_MTX_LOCK(tsdn, mu)\n# define LOCKEDINT_MTX_UNLOCK(tsdn, mu)\n# define LOCKEDINT_MTX_PREFORK(tsdn, mu)\n# define LOCKEDINT_MTX_POSTFORK_PARENT(tsdn, mu)\n# define LOCKEDINT_MTX_POSTFORK_CHILD(tsdn, mu)\n#endif\n\n#ifdef JEMALLOC_ATOMIC_U64\n# define LOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx) assert((mtx) == NULL)\n#else\n# define LOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx)\t\t\t\\\n malloc_mutex_assert_owner(tsdn, (mtx))\n#endif\n\nstatic inline uint64_t\nlocked_read_u64(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_u64_t *p) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\treturn atomic_load_u64(&p->val, ATOMIC_RELAXED);\n#else\n\treturn p->val;\n#endif\n}\n\nstatic inline void\nlocked_inc_u64(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_u64_t *p,\n uint64_t x) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\tatomic_fetch_add_u64(&p->val, x, ATOMIC_RELAXED);\n#else\n\tp->val += x;\n#endif\n}\n\nstatic inline void\nlocked_dec_u64(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_u64_t *p,\n uint64_t x) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\tuint64_t r = atomic_fetch_sub_u64(&p->val, x, ATOMIC_RELAXED);\n\tassert(r - x <= r);\n#else\n\tp->val -= x;\n\tassert(p->val + x >= p->val);\n#endif\n}\n\n/* Increment and take modulus. Returns whether the modulo made any change. */\nstatic inline bool\nlocked_inc_mod_u64(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_u64_t *p,\n const uint64_t x, const uint64_t modulus) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n\tuint64_t before, after;\n\tbool overflow;\n#ifdef JEMALLOC_ATOMIC_U64\n\tbefore = atomic_load_u64(&p->val, ATOMIC_RELAXED);\n\tdo {\n\t\tafter = before + x;\n\t\tassert(after >= before);\n\t\toverflow = (after >= modulus);\n\t\tif (overflow) {\n\t\t\tafter %= modulus;\n\t\t}\n\t} while (!atomic_compare_exchange_weak_u64(&p->val, &before, after,\n\t ATOMIC_RELAXED, ATOMIC_RELAXED));\n#else\n\tbefore = p->val;\n\tafter = before + x;\n\toverflow = (after >= modulus);\n\tif (overflow) {\n\t\tafter %= modulus;\n\t}\n\tp->val = after;\n#endif\n\treturn overflow;\n}\n\n/*\n * Non-atomically sets *dst += src. *dst needs external synchronization.\n * This lets us avoid the cost of a fetch_add when its unnecessary (note that\n * the types here are atomic).\n */\nstatic inline void\nlocked_inc_u64_unsynchronized(locked_u64_t *dst, uint64_t src) {\n#ifdef JEMALLOC_ATOMIC_U64\n\tuint64_t cur_dst = atomic_load_u64(&dst->val, ATOMIC_RELAXED);\n\tatomic_store_u64(&dst->val, src + cur_dst, ATOMIC_RELAXED);\n#else\n\tdst->val += src;\n#endif\n}\n\nstatic inline uint64_t\nlocked_read_u64_unsynchronized(locked_u64_t *p) {\n#ifdef JEMALLOC_ATOMIC_U64\n\treturn atomic_load_u64(&p->val, ATOMIC_RELAXED);\n#else\n\treturn p->val;\n#endif\n}\n\nstatic inline void\nlocked_init_u64_unsynchronized(locked_u64_t *p, uint64_t x) {\n#ifdef JEMALLOC_ATOMIC_U64\n\tatomic_store_u64(&p->val, x, ATOMIC_RELAXED);\n#else\n\tp->val = x;\n#endif\n}\n\nstatic inline size_t\nlocked_read_zu(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_zu_t *p) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\treturn atomic_load_zu(&p->val, ATOMIC_RELAXED);\n#else\n\treturn atomic_load_zu(&p->val, ATOMIC_RELAXED);\n#endif\n}\n\nstatic inline void\nlocked_inc_zu(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_zu_t *p,\n size_t x) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\tatomic_fetch_add_zu(&p->val, x, ATOMIC_RELAXED);\n#else\n\tsize_t cur = atomic_load_zu(&p->val, ATOMIC_RELAXED);\n\tatomic_store_zu(&p->val, cur + x, ATOMIC_RELAXED);\n#endif\n}\n\nstatic inline void\nlocked_dec_zu(tsdn_t *tsdn, malloc_mutex_t *mtx, locked_zu_t *p,\n size_t x) {\n\tLOCKEDINT_MTX_ASSERT_INTERNAL(tsdn, mtx);\n#ifdef JEMALLOC_ATOMIC_U64\n\tsize_t r = atomic_fetch_sub_zu(&p->val, x, ATOMIC_RELAXED);\n\tassert(r - x <= r);\n#else\n\tsize_t cur = atomic_load_zu(&p->val, ATOMIC_RELAXED);\n\tatomic_store_zu(&p->val, cur - x, ATOMIC_RELAXED);\n#endif\n}\n\n/* Like the _u64 variant, needs an externally synchronized *dst. */\nstatic inline void\nlocked_inc_zu_unsynchronized(locked_zu_t *dst, size_t src) {\n\tsize_t cur_dst = atomic_load_zu(&dst->val, ATOMIC_RELAXED);\n\tatomic_store_zu(&dst->val, src + cur_dst, ATOMIC_RELAXED);\n}\n\n/*\n * Unlike the _u64 variant, this is safe to call unconditionally.\n */\nstatic inline size_t\nlocked_read_atomic_zu(locked_zu_t *p) {\n\treturn atomic_load_zu(&p->val, ATOMIC_RELAXED);\n}\n\n#endif /* JEMALLOC_INTERNAL_LOCKEDINT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/log.h", "content": "#ifndef JEMALLOC_INTERNAL_LOG_H\n#define JEMALLOC_INTERNAL_LOG_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/mutex.h\"\n\n#ifdef JEMALLOC_LOG\n# define JEMALLOC_LOG_VAR_BUFSIZE 1000\n#else\n# define JEMALLOC_LOG_VAR_BUFSIZE 1\n#endif\n\n#define JEMALLOC_LOG_BUFSIZE 4096\n\n/*\n * The log malloc_conf option is a '|'-delimited list of log_var name segments\n * which should be logged. The names are themselves hierarchical, with '.' as\n * the delimiter (a \"segment\" is just a prefix in the log namespace). So, if\n * you have:\n *\n * log(\"arena\", \"log msg for arena\"); // 1\n * log(\"arena.a\", \"log msg for arena.a\"); // 2\n * log(\"arena.b\", \"log msg for arena.b\"); // 3\n * log(\"arena.a.a\", \"log msg for arena.a.a\"); // 4\n * log(\"extent.a\", \"log msg for extent.a\"); // 5\n * log(\"extent.b\", \"log msg for extent.b\"); // 6\n *\n * And your malloc_conf option is \"log=arena.a|extent\", then lines 2, 4, 5, and\n * 6 will print at runtime. You can enable logging from all log vars by\n * writing \"log=.\".\n *\n * None of this should be regarded as a stable API for right now. It's intended\n * as a debugging interface, to let us keep around some of our printf-debugging\n * statements.\n */\n\nextern char log_var_names[JEMALLOC_LOG_VAR_BUFSIZE];\nextern atomic_b_t log_init_done;\n\ntypedef struct log_var_s log_var_t;\nstruct log_var_s {\n\t/*\n\t * Lowest bit is \"inited\", second lowest is \"enabled\". Putting them in\n\t * a single word lets us avoid any fences on weak architectures.\n\t */\n\tatomic_u_t state;\n\tconst char *name;\n};\n\n#define LOG_NOT_INITIALIZED 0U\n#define LOG_INITIALIZED_NOT_ENABLED 1U\n#define LOG_ENABLED 2U\n\n#define LOG_VAR_INIT(name_str) {ATOMIC_INIT(LOG_NOT_INITIALIZED), name_str}\n\n/*\n * Returns the value we should assume for state (which is not necessarily\n * accurate; if logging is done before logging has finished initializing, then\n * we default to doing the safe thing by logging everything).\n */\nunsigned log_var_update_state(log_var_t *log_var);\n\n/* We factor out the metadata management to allow us to test more easily. */\n#define log_do_begin(log_var)\t\t\t\t\t\t\\\nif (config_log) {\t\t\t\t\t\t\t\\\n\tunsigned log_state = atomic_load_u(&(log_var).state,\t\t\\\n\t ATOMIC_RELAXED);\t\t\t\t\t\t\\\n\tif (unlikely(log_state == LOG_NOT_INITIALIZED)) {\t\t\\\n\t\tlog_state = log_var_update_state(&(log_var));\t\t\\\n\t\tassert(log_state != LOG_NOT_INITIALIZED);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (log_state == LOG_ENABLED) {\t\t\t\t\t\\\n\t\t{\n\t\t\t/* User code executes here. */\n#define log_do_end(log_var)\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\n\n/*\n * MSVC has some preprocessor bugs in its expansion of __VA_ARGS__ during\n * preprocessing. To work around this, we take all potential extra arguments in\n * a var-args functions. Since a varargs macro needs at least one argument in\n * the \"...\", we accept the format string there, and require that the first\n * argument in this \"...\" is a const char *.\n */\nstatic inline void\nlog_impl_varargs(const char *name, ...) {\n\tchar buf[JEMALLOC_LOG_BUFSIZE];\n\tva_list ap;\n\n\tva_start(ap, name);\n\tconst char *format = va_arg(ap, const char *);\n\tsize_t dst_offset = 0;\n\tdst_offset += malloc_snprintf(buf, JEMALLOC_LOG_BUFSIZE, \"%s: \", name);\n\tdst_offset += malloc_vsnprintf(buf + dst_offset,\n\t JEMALLOC_LOG_BUFSIZE - dst_offset, format, ap);\n\tdst_offset += malloc_snprintf(buf + dst_offset,\n\t JEMALLOC_LOG_BUFSIZE - dst_offset, \"\\n\");\n\tva_end(ap);\n\n\tmalloc_write(buf);\n}\n\n/* Call as log(\"log.var.str\", \"format_string %d\", arg_for_format_string); */\n#define LOG(log_var_str, ...)\t\t\t\t\t\t\\\ndo {\t\t\t\t\t\t\t\t\t\\\n\tstatic log_var_t log_var = LOG_VAR_INIT(log_var_str);\t\t\\\n\tlog_do_begin(log_var)\t\t\t\t\t\t\\\n\t\tlog_impl_varargs((log_var).name, __VA_ARGS__);\t\t\\\n\tlog_do_end(log_var)\t\t\t\t\t\t\\\n} while (0)\n\n#endif /* JEMALLOC_INTERNAL_LOG_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/malloc_io.h", "content": "#ifndef JEMALLOC_INTERNAL_MALLOC_IO_H\n#define JEMALLOC_INTERNAL_MALLOC_IO_H\n\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n\n#ifdef _WIN32\n# ifdef _WIN64\n# define FMT64_PREFIX \"ll\"\n# define FMTPTR_PREFIX \"ll\"\n# else\n# define FMT64_PREFIX \"ll\"\n# define FMTPTR_PREFIX \"\"\n# endif\n# define FMTd32 \"d\"\n# define FMTu32 \"u\"\n# define FMTx32 \"x\"\n# define FMTd64 FMT64_PREFIX \"d\"\n# define FMTu64 FMT64_PREFIX \"u\"\n# define FMTx64 FMT64_PREFIX \"x\"\n# define FMTdPTR FMTPTR_PREFIX \"d\"\n# define FMTuPTR FMTPTR_PREFIX \"u\"\n# define FMTxPTR FMTPTR_PREFIX \"x\"\n#else\n# include \n# define FMTd32 PRId32\n# define FMTu32 PRIu32\n# define FMTx32 PRIx32\n# define FMTd64 PRId64\n# define FMTu64 PRIu64\n# define FMTx64 PRIx64\n# define FMTdPTR PRIdPTR\n# define FMTuPTR PRIuPTR\n# define FMTxPTR PRIxPTR\n#endif\n\n/* Size of stack-allocated buffer passed to buferror(). */\n#define BUFERROR_BUF\t\t64\n\n/*\n * Size of stack-allocated buffer used by malloc_{,v,vc}printf(). This must be\n * large enough for all possible uses within jemalloc.\n */\n#define MALLOC_PRINTF_BUFSIZE\t4096\n\nwrite_cb_t wrtmessage;\nint buferror(int err, char *buf, size_t buflen);\nuintmax_t malloc_strtoumax(const char *restrict nptr, char **restrict endptr,\n int base);\nvoid malloc_write(const char *s);\n\n/*\n * malloc_vsnprintf() supports a subset of snprintf(3) that avoids floating\n * point math.\n */\nsize_t malloc_vsnprintf(char *str, size_t size, const char *format,\n va_list ap);\nsize_t malloc_snprintf(char *str, size_t size, const char *format, ...)\n JEMALLOC_FORMAT_PRINTF(3, 4);\n/*\n * The caller can set write_cb to null to choose to print with the\n * je_malloc_message hook.\n */\nvoid malloc_vcprintf(write_cb_t *write_cb, void *cbopaque, const char *format,\n va_list ap);\nvoid malloc_cprintf(write_cb_t *write_cb, void *cbopaque, const char *format,\n ...) JEMALLOC_FORMAT_PRINTF(3, 4);\nvoid malloc_printf(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);\n\nstatic inline ssize_t\nmalloc_write_fd(int fd, const void *buf, size_t count) {\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_write)\n\t/*\n\t * Use syscall(2) rather than write(2) when possible in order to avoid\n\t * the possibility of memory allocation within libc. This is necessary\n\t * on FreeBSD; most operating systems do not have this problem though.\n\t *\n\t * syscall() returns long or int, depending on platform, so capture the\n\t * result in the widest plausible type to avoid compiler warnings.\n\t */\n\tlong result = syscall(SYS_write, fd, buf, count);\n#else\n\tssize_t result = (ssize_t)write(fd, buf,\n#ifdef _WIN32\n\t (unsigned int)\n#endif\n\t count);\n#endif\n\treturn (ssize_t)result;\n}\n\nstatic inline ssize_t\nmalloc_read_fd(int fd, void *buf, size_t count) {\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_read)\n\tlong result = syscall(SYS_read, fd, buf, count);\n#else\n\tssize_t result = read(fd, buf,\n#ifdef _WIN32\n\t (unsigned int)\n#endif\n\t count);\n#endif\n\treturn (ssize_t)result;\n}\n\n#endif /* JEMALLOC_INTERNAL_MALLOC_IO_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/mpsc_queue.h", "content": "#ifndef JEMALLOC_INTERNAL_MPSC_QUEUE_H\n#define JEMALLOC_INTERNAL_MPSC_QUEUE_H\n\n#include \"jemalloc/internal/atomic.h\"\n\n/*\n * A concurrent implementation of a multi-producer, single-consumer queue. It\n * supports three concurrent operations:\n * - Push\n * - Push batch\n * - Pop batch\n *\n * These operations are all lock-free.\n *\n * The implementation is the simple two-stack queue built on a Treiber stack.\n * It's not terribly efficient, but this isn't expected to go into anywhere with\n * hot code. In fact, we don't really even need queue semantics in any\n * anticipated use cases; we could get away with just the stack. But this way\n * lets us frame the API in terms of the existing list types, which is a nice\n * convenience. We can save on cache misses by introducing our own (parallel)\n * single-linked list type here, and dropping FIFO semantics, if we need this to\n * get faster. Since we're currently providing queue semantics though, we use\n * the prev field in the link rather than the next field for Treiber-stack\n * linkage, so that we can preserve order for bash-pushed lists (recall that the\n * two-stack tricks reverses orders in the lock-free first stack).\n */\n\n#define mpsc_queue(a_type)\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n\tatomic_p_t tail;\t\t\t\t\t\t\\\n}\n\n#define mpsc_queue_proto(a_attr, a_prefix, a_queue_type, a_type,\t\\\n a_list_type)\t\t\t\t\t\t\t\\\n/* Initialize a queue. */\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##new(a_queue_type *queue);\t\t\t\t\t\\\n/* Insert all items in src into the queue, clearing src. */\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##push_batch(a_queue_type *queue, a_list_type *src);\t\t\\\n/* Insert node into the queue. */\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##push(a_queue_type *queue, a_type *node);\t\t\t\\\n/*\t\t\t\t\t\t\t\t\t\\\n * Pop all items in the queue into the list at dst. dst should already\t\\\n * be initialized (and may contain existing items, which then remain\t\\\n * in dst).\t\t\t\t\t\t\t\t\\\n */\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##pop_batch(a_queue_type *queue, a_list_type *dst);\n\n#define mpsc_queue_gen(a_attr, a_prefix, a_queue_type, a_type,\t\t\\\n a_list_type, a_link)\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##new(a_queue_type *queue) {\t\t\t\t\t\\\n\tatomic_store_p(&queue->tail, NULL, ATOMIC_RELAXED);\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##push_batch(a_queue_type *queue, a_list_type *src) {\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Reuse the ql list next field as the Treiber stack next\t\\\n\t * field.\t\t\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\ta_type *first = ql_first(src);\t\t\t\t\t\\\n\ta_type *last = ql_last(src, a_link);\t\t\t\t\\\n\tvoid* cur_tail = atomic_load_p(&queue->tail, ATOMIC_RELAXED);\t\\\n\tdo {\t\t\t\t\t\t\t\t\\\n\t\t/*\t\t\t\t\t\t\t\\\n\t\t * Note that this breaks the queue ring structure;\t\\\n\t\t * it's not a ring any more!\t\t\t\t\\\n\t\t */\t\t\t\t\t\t\t\\\n\t\tfirst->a_link.qre_prev = cur_tail;\t\t\t\\\n\t\t/*\t\t\t\t\t\t\t\\\n\t\t * Note: the upcoming CAS doesn't need an atomic; every\t\\\n\t\t * push only needs to synchronize with the next pop,\t\\\n\t\t * which we get from the release sequence rules.\t\\\n\t\t */\t\t\t\t\t\t\t\\\n\t} while (!atomic_compare_exchange_weak_p(&queue->tail,\t\t\\\n\t &cur_tail, last, ATOMIC_RELEASE, ATOMIC_RELAXED));\t\t\\\n\tql_new(src);\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##push(a_queue_type *queue, a_type *node) {\t\t\t\\\n\tql_elm_new(node, a_link);\t\t\t\t\t\\\n\ta_list_type list;\t\t\t\t\t\t\\\n\tql_new(&list);\t\t\t\t\t\t\t\\\n\tql_head_insert(&list, node, a_link);\t\t\t\t\\\n\ta_prefix##push_batch(queue, &list);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##pop_batch(a_queue_type *queue, a_list_type *dst) {\t\t\\\n\ta_type *tail = atomic_load_p(&queue->tail, ATOMIC_RELAXED);\t\\\n\tif (tail == NULL) {\t\t\t\t\t\t\\\n\t\t/*\t\t\t\t\t\t\t\\\n\t\t * In the common special case where there are no\t\\\n\t\t * pending elements, bail early without a costly RMW.\t\\\n\t\t */\t\t\t\t\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ttail = atomic_exchange_p(&queue->tail, NULL, ATOMIC_ACQUIRE);\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * It's a single-consumer queue, so if cur started non-NULL,\t\\\n\t * it'd better stay non-NULL.\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tassert(tail != NULL);\t\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * We iterate through the stack and both fix up the link\t\\\n\t * structure (stack insertion broke the list requirement that\t\\\n\t * the list be circularly linked). It's just as efficient at\t\\\n\t * this point to make the queue a \"real\" queue, so do that as\t\\\n\t * well.\t\t\t\t\t\t\t\\\n\t * If this ever gets to be a hot spot, we can omit this fixup\t\\\n\t * and make the queue a bag (i.e. not necessarily ordered), but\t\\\n\t * that would mean jettisoning the existing list API as the \t\\\n\t * batch pushing/popping interface.\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\ta_list_type reversed;\t\t\t\t\t\t\\\n\tql_new(&reversed);\t\t\t\t\t\t\\\n\twhile (tail != NULL) {\t\t\t\t\t\t\\\n\t\t/*\t\t\t\t\t\t\t\\\n\t\t * Pop an item off the stack, prepend it onto the list\t\\\n\t\t * (reversing the order). Recall that we use the\t\\\n\t\t * list prev field as the Treiber stack next field to\t\\\n\t\t * preserve order of batch-pushed items when reversed.\t\\\n\t\t */\t\t\t\t\t\t\t\\\n\t\ta_type *next = tail->a_link.qre_prev;\t\t\t\\\n\t\tql_elm_new(tail, a_link);\t\t\t\t\\\n\t\tql_head_insert(&reversed, tail, a_link);\t\t\\\n\t\ttail = next;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tql_concat(dst, &reversed, a_link);\t\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_MPSC_QUEUE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/mutex.h", "content": "#ifndef JEMALLOC_INTERNAL_MUTEX_H\n#define JEMALLOC_INTERNAL_MUTEX_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/mutex_prof.h\"\n#include \"jemalloc/internal/tsd.h\"\n#include \"jemalloc/internal/witness.h\"\n\nextern int64_t opt_mutex_max_spin;\n\ntypedef enum {\n\t/* Can only acquire one mutex of a given witness rank at a time. */\n\tmalloc_mutex_rank_exclusive,\n\t/*\n\t * Can acquire multiple mutexes of the same witness rank, but in\n\t * address-ascending order only.\n\t */\n\tmalloc_mutex_address_ordered\n} malloc_mutex_lock_order_t;\n\ntypedef struct malloc_mutex_s malloc_mutex_t;\nstruct malloc_mutex_s {\n\tunion {\n\t\tstruct {\n\t\t\t/*\n\t\t\t * prof_data is defined first to reduce cacheline\n\t\t\t * bouncing: the data is not touched by the mutex holder\n\t\t\t * during unlocking, while might be modified by\n\t\t\t * contenders. Having it before the mutex itself could\n\t\t\t * avoid prefetching a modified cacheline (for the\n\t\t\t * unlocking thread).\n\t\t\t */\n\t\t\tmutex_prof_data_t\tprof_data;\n#ifdef _WIN32\n# if _WIN32_WINNT >= 0x0600\n\t\t\tSRWLOCK \tlock;\n# else\n\t\t\tCRITICAL_SECTION\tlock;\n# endif\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n\t\t\tos_unfair_lock\t\tlock;\n#elif (defined(JEMALLOC_MUTEX_INIT_CB))\n\t\t\tpthread_mutex_t\t\tlock;\n\t\t\tmalloc_mutex_t\t\t*postponed_next;\n#else\n\t\t\tpthread_mutex_t\t\tlock;\n#endif\n\t\t\t/*\n\t\t\t * Hint flag to avoid exclusive cache line contention\n\t\t\t * during spin waiting\n\t\t\t */\n\t\t\tatomic_b_t\t\tlocked;\n\t\t};\n\t\t/*\n\t\t * We only touch witness when configured w/ debug. However we\n\t\t * keep the field in a union when !debug so that we don't have\n\t\t * to pollute the code base with #ifdefs, while avoid paying the\n\t\t * memory cost.\n\t\t */\n#if !defined(JEMALLOC_DEBUG)\n\t\twitness_t\t\t\twitness;\n\t\tmalloc_mutex_lock_order_t\tlock_order;\n#endif\n\t};\n\n#if defined(JEMALLOC_DEBUG)\n\twitness_t\t\t\twitness;\n\tmalloc_mutex_lock_order_t\tlock_order;\n#endif\n};\n\n#ifdef _WIN32\n# if _WIN32_WINNT >= 0x0600\n# define MALLOC_MUTEX_LOCK(m) AcquireSRWLockExclusive(&(m)->lock)\n# define MALLOC_MUTEX_UNLOCK(m) ReleaseSRWLockExclusive(&(m)->lock)\n# define MALLOC_MUTEX_TRYLOCK(m) (!TryAcquireSRWLockExclusive(&(m)->lock))\n# else\n# define MALLOC_MUTEX_LOCK(m) EnterCriticalSection(&(m)->lock)\n# define MALLOC_MUTEX_UNLOCK(m) LeaveCriticalSection(&(m)->lock)\n# define MALLOC_MUTEX_TRYLOCK(m) (!TryEnterCriticalSection(&(m)->lock))\n# endif\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n# define MALLOC_MUTEX_LOCK(m) os_unfair_lock_lock(&(m)->lock)\n# define MALLOC_MUTEX_UNLOCK(m) os_unfair_lock_unlock(&(m)->lock)\n# define MALLOC_MUTEX_TRYLOCK(m) (!os_unfair_lock_trylock(&(m)->lock))\n#else\n# define MALLOC_MUTEX_LOCK(m) pthread_mutex_lock(&(m)->lock)\n# define MALLOC_MUTEX_UNLOCK(m) pthread_mutex_unlock(&(m)->lock)\n# define MALLOC_MUTEX_TRYLOCK(m) (pthread_mutex_trylock(&(m)->lock) != 0)\n#endif\n\n#define LOCK_PROF_DATA_INITIALIZER\t\t\t\t\t\\\n {NSTIME_ZERO_INITIALIZER, NSTIME_ZERO_INITIALIZER, 0, 0, 0,\t\t\\\n\t ATOMIC_INIT(0), 0, NULL, 0}\n\n#ifdef _WIN32\n# define MALLOC_MUTEX_INITIALIZER\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n# if defined(JEMALLOC_DEBUG)\n# define MALLOC_MUTEX_INITIALIZER\t\t\t\t\t\\\n {{{LOCK_PROF_DATA_INITIALIZER, OS_UNFAIR_LOCK_INIT, ATOMIC_INIT(false)}}, \\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT), 0}\n# else\n# define MALLOC_MUTEX_INITIALIZER \\\n {{{LOCK_PROF_DATA_INITIALIZER, OS_UNFAIR_LOCK_INIT, ATOMIC_INIT(false)}}, \\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT)}\n# endif\n#elif (defined(JEMALLOC_MUTEX_INIT_CB))\n# if (defined(JEMALLOC_DEBUG))\n# define MALLOC_MUTEX_INITIALIZER\t\t\t\t\t\\\n {{{LOCK_PROF_DATA_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, NULL, ATOMIC_INIT(false)}},\t\\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT), 0}\n# else\n# define MALLOC_MUTEX_INITIALIZER\t\t\t\t\t\\\n {{{LOCK_PROF_DATA_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, NULL, ATOMIC_INIT(false)}},\t\\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT)}\n# endif\n\n#else\n# define MALLOC_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT\n# if defined(JEMALLOC_DEBUG)\n# define MALLOC_MUTEX_INITIALIZER\t\t\t\t\t\\\n {{{LOCK_PROF_DATA_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, ATOMIC_INIT(false)}}, \\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT), 0}\n# else\n# define MALLOC_MUTEX_INITIALIZER \\\n {{{LOCK_PROF_DATA_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, ATOMIC_INIT(false)}},\t\\\n WITNESS_INITIALIZER(\"mutex\", WITNESS_RANK_OMIT)}\n# endif\n#endif\n\n#ifdef JEMALLOC_LAZY_LOCK\nextern bool isthreaded;\n#else\n# undef isthreaded /* Undo private_namespace.h definition. */\n# define isthreaded true\n#endif\n\nbool malloc_mutex_init(malloc_mutex_t *mutex, const char *name,\n witness_rank_t rank, malloc_mutex_lock_order_t lock_order);\nvoid malloc_mutex_prefork(tsdn_t *tsdn, malloc_mutex_t *mutex);\nvoid malloc_mutex_postfork_parent(tsdn_t *tsdn, malloc_mutex_t *mutex);\nvoid malloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex);\nbool malloc_mutex_boot(void);\nvoid malloc_mutex_prof_data_reset(tsdn_t *tsdn, malloc_mutex_t *mutex);\n\nvoid malloc_mutex_lock_slow(malloc_mutex_t *mutex);\n\nstatic inline void\nmalloc_mutex_lock_final(malloc_mutex_t *mutex) {\n\tMALLOC_MUTEX_LOCK(mutex);\n\tatomic_store_b(&mutex->locked, true, ATOMIC_RELAXED);\n}\n\nstatic inline bool\nmalloc_mutex_trylock_final(malloc_mutex_t *mutex) {\n\treturn MALLOC_MUTEX_TRYLOCK(mutex);\n}\n\nstatic inline void\nmutex_owner_stats_update(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\tif (config_stats) {\n\t\tmutex_prof_data_t *data = &mutex->prof_data;\n\t\tdata->n_lock_ops++;\n\t\tif (data->prev_owner != tsdn) {\n\t\t\tdata->prev_owner = tsdn;\n\t\t\tdata->n_owner_switches++;\n\t\t}\n\t}\n}\n\n/* Trylock: return false if the lock is successfully acquired. */\nstatic inline bool\nmalloc_mutex_trylock(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\twitness_assert_not_owner(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n\tif (isthreaded) {\n\t\tif (malloc_mutex_trylock_final(mutex)) {\n\t\t\tatomic_store_b(&mutex->locked, true, ATOMIC_RELAXED);\n\t\t\treturn true;\n\t\t}\n\t\tmutex_owner_stats_update(tsdn, mutex);\n\t}\n\twitness_lock(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n\n\treturn false;\n}\n\n/* Aggregate lock prof data. */\nstatic inline void\nmalloc_mutex_prof_merge(mutex_prof_data_t *sum, mutex_prof_data_t *data) {\n\tnstime_add(&sum->tot_wait_time, &data->tot_wait_time);\n\tif (nstime_compare(&sum->max_wait_time, &data->max_wait_time) < 0) {\n\t\tnstime_copy(&sum->max_wait_time, &data->max_wait_time);\n\t}\n\n\tsum->n_wait_times += data->n_wait_times;\n\tsum->n_spin_acquired += data->n_spin_acquired;\n\n\tif (sum->max_n_thds < data->max_n_thds) {\n\t\tsum->max_n_thds = data->max_n_thds;\n\t}\n\tuint32_t cur_n_waiting_thds = atomic_load_u32(&sum->n_waiting_thds,\n\t ATOMIC_RELAXED);\n\tuint32_t new_n_waiting_thds = cur_n_waiting_thds + atomic_load_u32(\n\t &data->n_waiting_thds, ATOMIC_RELAXED);\n\tatomic_store_u32(&sum->n_waiting_thds, new_n_waiting_thds,\n\t ATOMIC_RELAXED);\n\tsum->n_owner_switches += data->n_owner_switches;\n\tsum->n_lock_ops += data->n_lock_ops;\n}\n\nstatic inline void\nmalloc_mutex_lock(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\twitness_assert_not_owner(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n\tif (isthreaded) {\n\t\tif (malloc_mutex_trylock_final(mutex)) {\n\t\t\tmalloc_mutex_lock_slow(mutex);\n\t\t\tatomic_store_b(&mutex->locked, true, ATOMIC_RELAXED);\n\t\t}\n\t\tmutex_owner_stats_update(tsdn, mutex);\n\t}\n\twitness_lock(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n}\n\nstatic inline void\nmalloc_mutex_unlock(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\tatomic_store_b(&mutex->locked, false, ATOMIC_RELAXED);\n\twitness_unlock(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n\tif (isthreaded) {\n\t\tMALLOC_MUTEX_UNLOCK(mutex);\n\t}\n}\n\nstatic inline void\nmalloc_mutex_assert_owner(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\twitness_assert_owner(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n}\n\nstatic inline void\nmalloc_mutex_assert_not_owner(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\twitness_assert_not_owner(tsdn_witness_tsdp_get(tsdn), &mutex->witness);\n}\n\nstatic inline void\nmalloc_mutex_prof_copy(mutex_prof_data_t *dst, mutex_prof_data_t *source) {\n\t/*\n\t * Not *really* allowed (we shouldn't be doing non-atomic loads of\n\t * atomic data), but the mutex protection makes this safe, and writing\n\t * a member-for-member copy is tedious for this situation.\n\t */\n\t*dst = *source;\n\t/* n_wait_thds is not reported (modified w/o locking). */\n\tatomic_store_u32(&dst->n_waiting_thds, 0, ATOMIC_RELAXED);\n}\n\n/* Copy the prof data from mutex for processing. */\nstatic inline void\nmalloc_mutex_prof_read(tsdn_t *tsdn, mutex_prof_data_t *data,\n malloc_mutex_t *mutex) {\n\t/* Can only read holding the mutex. */\n\tmalloc_mutex_assert_owner(tsdn, mutex);\n\tmalloc_mutex_prof_copy(data, &mutex->prof_data);\n}\n\nstatic inline void\nmalloc_mutex_prof_accum(tsdn_t *tsdn, mutex_prof_data_t *data,\n malloc_mutex_t *mutex) {\n\tmutex_prof_data_t *source = &mutex->prof_data;\n\t/* Can only read holding the mutex. */\n\tmalloc_mutex_assert_owner(tsdn, mutex);\n\n\tnstime_add(&data->tot_wait_time, &source->tot_wait_time);\n\tif (nstime_compare(&source->max_wait_time, &data->max_wait_time) > 0) {\n\t\tnstime_copy(&data->max_wait_time, &source->max_wait_time);\n\t}\n\tdata->n_wait_times += source->n_wait_times;\n\tdata->n_spin_acquired += source->n_spin_acquired;\n\tif (data->max_n_thds < source->max_n_thds) {\n\t\tdata->max_n_thds = source->max_n_thds;\n\t}\n\t/* n_wait_thds is not reported. */\n\tatomic_store_u32(&data->n_waiting_thds, 0, ATOMIC_RELAXED);\n\tdata->n_owner_switches += source->n_owner_switches;\n\tdata->n_lock_ops += source->n_lock_ops;\n}\n\n/* Compare the prof data and update to the maximum. */\nstatic inline void\nmalloc_mutex_prof_max_update(tsdn_t *tsdn, mutex_prof_data_t *data,\n malloc_mutex_t *mutex) {\n\tmutex_prof_data_t *source = &mutex->prof_data;\n\t/* Can only read holding the mutex. */\n\tmalloc_mutex_assert_owner(tsdn, mutex);\n\n\tif (nstime_compare(&source->tot_wait_time, &data->tot_wait_time) > 0) {\n\t\tnstime_copy(&data->tot_wait_time, &source->tot_wait_time);\n\t}\n\tif (nstime_compare(&source->max_wait_time, &data->max_wait_time) > 0) {\n\t\tnstime_copy(&data->max_wait_time, &source->max_wait_time);\n\t}\n\tif (source->n_wait_times > data->n_wait_times) {\n\t\tdata->n_wait_times = source->n_wait_times;\n\t}\n\tif (source->n_spin_acquired > data->n_spin_acquired) {\n\t\tdata->n_spin_acquired = source->n_spin_acquired;\n\t}\n\tif (source->max_n_thds > data->max_n_thds) {\n\t\tdata->max_n_thds = source->max_n_thds;\n\t}\n\tif (source->n_owner_switches > data->n_owner_switches) {\n\t\tdata->n_owner_switches = source->n_owner_switches;\n\t}\n\tif (source->n_lock_ops > data->n_lock_ops) {\n\t\tdata->n_lock_ops = source->n_lock_ops;\n\t}\n\t/* n_wait_thds is not reported. */\n}\n\n#endif /* JEMALLOC_INTERNAL_MUTEX_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/mutex_prof.h", "content": "#ifndef JEMALLOC_INTERNAL_MUTEX_PROF_H\n#define JEMALLOC_INTERNAL_MUTEX_PROF_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/nstime.h\"\n#include \"jemalloc/internal/tsd_types.h\"\n\n#define MUTEX_PROF_GLOBAL_MUTEXES\t\t\t\t\t\\\n OP(background_thread)\t\t\t\t\t\t\\\n OP(max_per_bg_thd)\t\t\t\t\t\t\t\\\n OP(ctl)\t\t\t\t\t\t\t\t\\\n OP(prof)\t\t\t\t\t\t\t\t\\\n OP(prof_thds_data)\t\t\t\t\t\t\t\\\n OP(prof_dump)\t\t\t\t\t\t\t\\\n OP(prof_recent_alloc)\t\t\t\t\t\t\\\n OP(prof_recent_dump)\t\t\t\t\t\t\\\n OP(prof_stats)\n\ntypedef enum {\n#define OP(mtx) global_prof_mutex_##mtx,\n\tMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n\tmutex_prof_num_global_mutexes\n} mutex_prof_global_ind_t;\n\n#define MUTEX_PROF_ARENA_MUTEXES\t\t\t\t\t\\\n OP(large)\t\t\t\t\t\t\t\t\\\n OP(extent_avail)\t\t\t\t\t\t\t\\\n OP(extents_dirty)\t\t\t\t\t\t\t\\\n OP(extents_muzzy)\t\t\t\t\t\t\t\\\n OP(extents_retained)\t\t\t\t\t\t\\\n OP(decay_dirty)\t\t\t\t\t\t\t\\\n OP(decay_muzzy)\t\t\t\t\t\t\t\\\n OP(base)\t\t\t\t\t\t\t\t\\\n OP(tcache_list)\t\t\t\t\t\t\t\\\n OP(hpa_shard)\t\t\t\t\t\t\t\\\n OP(hpa_shard_grow)\t\t\t\t\t\t\t\\\n OP(hpa_sec)\n\ntypedef enum {\n#define OP(mtx) arena_prof_mutex_##mtx,\n\tMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n\tmutex_prof_num_arena_mutexes\n} mutex_prof_arena_ind_t;\n\n/*\n * The forth parameter is a boolean value that is true for derived rate counters\n * and false for real ones.\n */\n#define MUTEX_PROF_UINT64_COUNTERS\t\t\t\t\t\\\n OP(num_ops, uint64_t, \"n_lock_ops\", false, num_ops)\t\t\t\t\t\\\n OP(num_ops_ps, uint64_t, \"(#/sec)\", true, num_ops)\t\t\t\t\\\n OP(num_wait, uint64_t, \"n_waiting\", false, num_wait)\t\t\t\t\\\n OP(num_wait_ps, uint64_t, \"(#/sec)\", true, num_wait)\t\t\t\t\\\n OP(num_spin_acq, uint64_t, \"n_spin_acq\", false, num_spin_acq)\t\t\t\\\n OP(num_spin_acq_ps, uint64_t, \"(#/sec)\", true, num_spin_acq)\t\t\t\\\n OP(num_owner_switch, uint64_t, \"n_owner_switch\", false, num_owner_switch)\t\t\\\n OP(num_owner_switch_ps, uint64_t, \"(#/sec)\", true, num_owner_switch)\t\\\n OP(total_wait_time, uint64_t, \"total_wait_ns\", false, total_wait_time)\t\t\\\n OP(total_wait_time_ps, uint64_t, \"(#/sec)\", true, total_wait_time)\t\t\\\n OP(max_wait_time, uint64_t, \"max_wait_ns\", false, max_wait_time)\n\n#define MUTEX_PROF_UINT32_COUNTERS\t\t\t\t\t\\\n OP(max_num_thds, uint32_t, \"max_n_thds\", false, max_num_thds)\n\n#define MUTEX_PROF_COUNTERS\t\t\t\t\t\t\\\n\t\tMUTEX_PROF_UINT64_COUNTERS\t\t\t\t\\\n\t\tMUTEX_PROF_UINT32_COUNTERS\n\n#define OP(counter, type, human, derived, base_counter) mutex_counter_##counter,\n\n#define COUNTER_ENUM(counter_list, t)\t\t\t\t\t\\\n\t\ttypedef enum {\t\t\t\t\t\t\\\n\t\t\tcounter_list\t\t\t\t\t\\\n\t\t\tmutex_prof_num_##t##_counters\t\t\t\\\n\t\t} mutex_prof_##t##_counter_ind_t;\n\nCOUNTER_ENUM(MUTEX_PROF_UINT64_COUNTERS, uint64_t)\nCOUNTER_ENUM(MUTEX_PROF_UINT32_COUNTERS, uint32_t)\n\n#undef COUNTER_ENUM\n#undef OP\n\ntypedef struct {\n\t/*\n\t * Counters touched on the slow path, i.e. when there is lock\n\t * contention. We update them once we have the lock.\n\t */\n\t/* Total time (in nano seconds) spent waiting on this mutex. */\n\tnstime_t\t\ttot_wait_time;\n\t/* Max time (in nano seconds) spent on a single lock operation. */\n\tnstime_t\t\tmax_wait_time;\n\t/* # of times have to wait for this mutex (after spinning). */\n\tuint64_t\t\tn_wait_times;\n\t/* # of times acquired the mutex through local spinning. */\n\tuint64_t\t\tn_spin_acquired;\n\t/* Max # of threads waiting for the mutex at the same time. */\n\tuint32_t\t\tmax_n_thds;\n\t/* Current # of threads waiting on the lock. Atomic synced. */\n\tatomic_u32_t\t\tn_waiting_thds;\n\n\t/*\n\t * Data touched on the fast path. These are modified right after we\n\t * grab the lock, so it's placed closest to the end (i.e. right before\n\t * the lock) so that we have a higher chance of them being on the same\n\t * cacheline.\n\t */\n\t/* # of times the mutex holder is different than the previous one. */\n\tuint64_t\t\tn_owner_switches;\n\t/* Previous mutex holder, to facilitate n_owner_switches. */\n\ttsdn_t\t\t\t*prev_owner;\n\t/* # of lock() operations in total. */\n\tuint64_t\t\tn_lock_ops;\n} mutex_prof_data_t;\n\n#endif /* JEMALLOC_INTERNAL_MUTEX_PROF_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/nstime.h", "content": "#ifndef JEMALLOC_INTERNAL_NSTIME_H\n#define JEMALLOC_INTERNAL_NSTIME_H\n\n/* Maximum supported number of seconds (~584 years). */\n#define NSTIME_SEC_MAX KQU(18446744072)\n\n#define NSTIME_MAGIC ((uint32_t)0xb8a9ce37)\n#ifdef JEMALLOC_DEBUG\n# define NSTIME_ZERO_INITIALIZER {0, NSTIME_MAGIC}\n#else\n# define NSTIME_ZERO_INITIALIZER {0}\n#endif\n\ntypedef struct {\n\tuint64_t ns;\n#ifdef JEMALLOC_DEBUG\n\tuint32_t magic; /* Tracks if initialized. */\n#endif\n} nstime_t;\n\nstatic const nstime_t nstime_zero = NSTIME_ZERO_INITIALIZER;\n\nvoid nstime_init(nstime_t *time, uint64_t ns);\nvoid nstime_init2(nstime_t *time, uint64_t sec, uint64_t nsec);\nuint64_t nstime_ns(const nstime_t *time);\nuint64_t nstime_sec(const nstime_t *time);\nuint64_t nstime_msec(const nstime_t *time);\nuint64_t nstime_nsec(const nstime_t *time);\nvoid nstime_copy(nstime_t *time, const nstime_t *source);\nint nstime_compare(const nstime_t *a, const nstime_t *b);\nvoid nstime_add(nstime_t *time, const nstime_t *addend);\nvoid nstime_iadd(nstime_t *time, uint64_t addend);\nvoid nstime_subtract(nstime_t *time, const nstime_t *subtrahend);\nvoid nstime_isubtract(nstime_t *time, uint64_t subtrahend);\nvoid nstime_imultiply(nstime_t *time, uint64_t multiplier);\nvoid nstime_idivide(nstime_t *time, uint64_t divisor);\nuint64_t nstime_divide(const nstime_t *time, const nstime_t *divisor);\nuint64_t nstime_ns_since(const nstime_t *past);\n\ntypedef bool (nstime_monotonic_t)(void);\nextern nstime_monotonic_t *JET_MUTABLE nstime_monotonic;\n\ntypedef void (nstime_update_t)(nstime_t *);\nextern nstime_update_t *JET_MUTABLE nstime_update;\n\ntypedef void (nstime_prof_update_t)(nstime_t *);\nextern nstime_prof_update_t *JET_MUTABLE nstime_prof_update;\n\nvoid nstime_init_update(nstime_t *time);\nvoid nstime_prof_init_update(nstime_t *time);\n\nenum prof_time_res_e {\n\tprof_time_res_default = 0,\n\tprof_time_res_high = 1\n};\ntypedef enum prof_time_res_e prof_time_res_t;\n\nextern prof_time_res_t opt_prof_time_res;\nextern const char *prof_time_res_mode_names[];\n\nJEMALLOC_ALWAYS_INLINE void\nnstime_init_zero(nstime_t *time) {\n\tnstime_copy(time, &nstime_zero);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nnstime_equals_zero(nstime_t *time) {\n\tint diff = nstime_compare(time, &nstime_zero);\n\tassert(diff >= 0);\n\treturn diff == 0;\n}\n\n#endif /* JEMALLOC_INTERNAL_NSTIME_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/pa.h", "content": "#ifndef JEMALLOC_INTERNAL_PA_H\n#define JEMALLOC_INTERNAL_PA_H\n\n#include \"jemalloc/internal/base.h\"\n#include \"jemalloc/internal/decay.h\"\n#include \"jemalloc/internal/ecache.h\"\n#include \"jemalloc/internal/edata_cache.h\"\n#include \"jemalloc/internal/emap.h\"\n#include \"jemalloc/internal/hpa.h\"\n#include \"jemalloc/internal/lockedint.h\"\n#include \"jemalloc/internal/pac.h\"\n#include \"jemalloc/internal/pai.h\"\n#include \"jemalloc/internal/sec.h\"\n\n/*\n * The page allocator; responsible for acquiring pages of memory for\n * allocations. It picks the implementation of the page allocator interface\n * (i.e. a pai_t) to handle a given page-level allocation request. For now, the\n * only such implementation is the PAC code (\"page allocator classic\"), but\n * others will be coming soon.\n */\n\ntypedef struct pa_central_s pa_central_t;\nstruct pa_central_s {\n\thpa_central_t hpa;\n};\n\n/*\n * The stats for a particular pa_shard. Because of the way the ctl module\n * handles stats epoch data collection (it has its own arena_stats, and merges\n * the stats from each arena into it), this needs to live in the arena_stats_t;\n * hence we define it here and let the pa_shard have a pointer (rather than the\n * more natural approach of just embedding it in the pa_shard itself).\n *\n * We follow the arena_stats_t approach of marking the derived fields. These\n * are the ones that are not maintained on their own; instead, their values are\n * derived during those stats merges.\n */\ntypedef struct pa_shard_stats_s pa_shard_stats_t;\nstruct pa_shard_stats_s {\n\t/* Number of edata_t structs allocated by base, but not being used. */\n\tsize_t edata_avail; /* Derived. */\n\t/*\n\t * Stats specific to the PAC. For now, these are the only stats that\n\t * exist, but there will eventually be other page allocators. Things\n\t * like edata_avail make sense in a cross-PA sense, but things like\n\t * npurges don't.\n\t */\n\tpac_stats_t pac_stats;\n};\n\n/*\n * The local allocator handle. Keeps the state necessary to satisfy page-sized\n * allocations.\n *\n * The contents are mostly internal to the PA module. The key exception is that\n * arena decay code is allowed to grab pointers to the dirty and muzzy ecaches\n * decay_ts, for a couple of queries, passing them back to a PA function, or\n * acquiring decay.mtx and looking at decay.purging. The reasoning is that,\n * while PA decides what and how to purge, the arena code decides when and where\n * (e.g. on what thread). It's allowed to use the presence of another purger to\n * decide.\n * (The background thread code also touches some other decay internals, but\n * that's not fundamental; its' just an artifact of a partial refactoring, and\n * its accesses could be straightforwardly moved inside the decay module).\n */\ntypedef struct pa_shard_s pa_shard_t;\nstruct pa_shard_s {\n\t/* The central PA this shard is associated with. */\n\tpa_central_t *central;\n\n\t/*\n\t * Number of pages in active extents.\n\t *\n\t * Synchronization: atomic.\n\t */\n\tatomic_zu_t nactive;\n\n\t/*\n\t * Whether or not we should prefer the hugepage allocator. Atomic since\n\t * it may be concurrently modified by a thread setting extent hooks.\n\t * Note that we still may do HPA operations in this arena; if use_hpa is\n\t * changed from true to false, we'll free back to the hugepage allocator\n\t * for those allocations.\n\t */\n\tatomic_b_t use_hpa;\n\n\t/*\n\t * If we never used the HPA to begin with, it wasn't initialized, and so\n\t * we shouldn't try to e.g. acquire its mutexes during fork. This\n\t * tracks that knowledge.\n\t */\n\tbool ever_used_hpa;\n\n\t/* Allocates from a PAC. */\n\tpac_t pac;\n\n\t/*\n\t * We place a small extent cache in front of the HPA, since we intend\n\t * these configurations to use many fewer arenas, and therefore have a\n\t * higher risk of hot locks.\n\t */\n\tsec_t hpa_sec;\n\thpa_shard_t hpa_shard;\n\n\t/* The source of edata_t objects. */\n\tedata_cache_t edata_cache;\n\n\tunsigned ind;\n\n\tmalloc_mutex_t *stats_mtx;\n\tpa_shard_stats_t *stats;\n\n\t/* The emap this shard is tied to. */\n\temap_t *emap;\n\n\t/* The base from which we get the ehooks and allocate metadat. */\n\tbase_t *base;\n};\n\nstatic inline bool\npa_shard_dont_decay_muzzy(pa_shard_t *shard) {\n\treturn ecache_npages_get(&shard->pac.ecache_muzzy) == 0 &&\n\t pac_decay_ms_get(&shard->pac, extent_state_muzzy) <= 0;\n}\n\nstatic inline ehooks_t *\npa_shard_ehooks_get(pa_shard_t *shard) {\n\treturn base_ehooks_get(shard->base);\n}\n\n/* Returns true on error. */\nbool pa_central_init(pa_central_t *central, base_t *base, bool hpa,\n hpa_hooks_t *hpa_hooks);\n\n/* Returns true on error. */\nbool pa_shard_init(tsdn_t *tsdn, pa_shard_t *shard, pa_central_t *central,\n emap_t *emap, base_t *base, unsigned ind, pa_shard_stats_t *stats,\n malloc_mutex_t *stats_mtx, nstime_t *cur_time, size_t oversize_threshold,\n ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms);\n\n/*\n * This isn't exposed to users; we allow late enablement of the HPA shard so\n * that we can boot without worrying about the HPA, then turn it on in a0.\n */\nbool pa_shard_enable_hpa(tsdn_t *tsdn, pa_shard_t *shard,\n const hpa_shard_opts_t *hpa_opts, const sec_opts_t *hpa_sec_opts);\n\n/*\n * We stop using the HPA when custom extent hooks are installed, but still\n * redirect deallocations to it.\n */\nvoid pa_shard_disable_hpa(tsdn_t *tsdn, pa_shard_t *shard);\n\n/*\n * This does the PA-specific parts of arena reset (i.e. freeing all active\n * allocations).\n */\nvoid pa_shard_reset(tsdn_t *tsdn, pa_shard_t *shard);\n\n/*\n * Destroy all the remaining retained extents. Should only be called after\n * decaying all active, dirty, and muzzy extents to the retained state, as the\n * last step in destroying the shard.\n */\nvoid pa_shard_destroy(tsdn_t *tsdn, pa_shard_t *shard);\n\n/* Gets an edata for the given allocation. */\nedata_t *pa_alloc(tsdn_t *tsdn, pa_shard_t *shard, size_t size,\n size_t alignment, bool slab, szind_t szind, bool zero, bool guarded,\n bool *deferred_work_generated);\n/* Returns true on error, in which case nothing changed. */\nbool pa_expand(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata, size_t old_size,\n size_t new_size, szind_t szind, bool zero, bool *deferred_work_generated);\n/*\n * The same. Sets *generated_dirty to true if we produced new dirty pages, and\n * false otherwise.\n */\nbool pa_shrink(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata, size_t old_size,\n size_t new_size, szind_t szind, bool *deferred_work_generated);\n/*\n * Frees the given edata back to the pa. Sets *generated_dirty if we produced\n * new dirty pages (well, we always set it for now; but this need not be the\n * case).\n * (We could make generated_dirty the return value of course, but this is more\n * consistent with the shrink pathway and our error codes here).\n */\nvoid pa_dalloc(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata,\n bool *deferred_work_generated);\nbool pa_decay_ms_set(tsdn_t *tsdn, pa_shard_t *shard, extent_state_t state,\n ssize_t decay_ms, pac_purge_eagerness_t eagerness);\nssize_t pa_decay_ms_get(pa_shard_t *shard, extent_state_t state);\n\n/*\n * Do deferred work on this PA shard.\n *\n * Morally, this should do both PAC decay and the HPA deferred work. For now,\n * though, the arena, background thread, and PAC modules are tightly interwoven\n * in a way that's tricky to extricate, so we only do the HPA-specific parts.\n */\nvoid pa_shard_set_deferral_allowed(tsdn_t *tsdn, pa_shard_t *shard,\n bool deferral_allowed);\nvoid pa_shard_do_deferred_work(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_try_deferred_work(tsdn_t *tsdn, pa_shard_t *shard);\nuint64_t pa_shard_time_until_deferred_work(tsdn_t *tsdn, pa_shard_t *shard);\n\n/******************************************************************************/\n/*\n * Various bits of \"boring\" functionality that are still part of this module,\n * but that we relegate to pa_extra.c, to keep the core logic in pa.c as\n * readable as possible.\n */\n\n/*\n * These fork phases are synchronized with the arena fork phase numbering to\n * make it easy to keep straight. That's why there's no prefork1.\n */\nvoid pa_shard_prefork0(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_prefork2(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_prefork3(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_prefork4(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_prefork5(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_postfork_parent(tsdn_t *tsdn, pa_shard_t *shard);\nvoid pa_shard_postfork_child(tsdn_t *tsdn, pa_shard_t *shard);\n\nvoid pa_shard_basic_stats_merge(pa_shard_t *shard, size_t *nactive,\n size_t *ndirty, size_t *nmuzzy);\n\nvoid pa_shard_stats_merge(tsdn_t *tsdn, pa_shard_t *shard,\n pa_shard_stats_t *pa_shard_stats_out, pac_estats_t *estats_out,\n hpa_shard_stats_t *hpa_stats_out, sec_stats_t *sec_stats_out,\n size_t *resident);\n\n/*\n * Reads the PA-owned mutex stats into the output stats array, at the\n * appropriate positions. Morally, these stats should really live in\n * pa_shard_stats_t, but the indices are sort of baked into the various mutex\n * prof macros. This would be a good thing to do at some point.\n */\nvoid pa_shard_mtx_stats_read(tsdn_t *tsdn, pa_shard_t *shard,\n mutex_prof_data_t mutex_prof_data[mutex_prof_num_arena_mutexes]);\n\n#endif /* JEMALLOC_INTERNAL_PA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/pac.h", "content": "#ifndef JEMALLOC_INTERNAL_PAC_H\n#define JEMALLOC_INTERNAL_PAC_H\n\n#include \"jemalloc/internal/exp_grow.h\"\n#include \"jemalloc/internal/pai.h\"\n#include \"san_bump.h\"\n\n\n/*\n * Page allocator classic; an implementation of the PAI interface that:\n * - Can be used for arenas with custom extent hooks.\n * - Can always satisfy any allocation request (including highly-fragmentary\n * ones).\n * - Can use efficient OS-level zeroing primitives for demand-filled pages.\n */\n\n/* How \"eager\" decay/purging should be. */\nenum pac_purge_eagerness_e {\n\tPAC_PURGE_ALWAYS,\n\tPAC_PURGE_NEVER,\n\tPAC_PURGE_ON_EPOCH_ADVANCE\n};\ntypedef enum pac_purge_eagerness_e pac_purge_eagerness_t;\n\ntypedef struct pac_decay_stats_s pac_decay_stats_t;\nstruct pac_decay_stats_s {\n\t/* Total number of purge sweeps. */\n\tlocked_u64_t npurge;\n\t/* Total number of madvise calls made. */\n\tlocked_u64_t nmadvise;\n\t/* Total number of pages purged. */\n\tlocked_u64_t purged;\n};\n\ntypedef struct pac_estats_s pac_estats_t;\nstruct pac_estats_s {\n\t/*\n\t * Stats for a given index in the range [0, SC_NPSIZES] in the various\n\t * ecache_ts.\n\t * We track both bytes and # of extents: two extents in the same bucket\n\t * may have different sizes if adjacent size classes differ by more than\n\t * a page, so bytes cannot always be derived from # of extents.\n\t */\n\tsize_t ndirty;\n\tsize_t dirty_bytes;\n\tsize_t nmuzzy;\n\tsize_t muzzy_bytes;\n\tsize_t nretained;\n\tsize_t retained_bytes;\n};\n\ntypedef struct pac_stats_s pac_stats_t;\nstruct pac_stats_s {\n\tpac_decay_stats_t decay_dirty;\n\tpac_decay_stats_t decay_muzzy;\n\n\t/*\n\t * Number of unused virtual memory bytes currently retained. Retained\n\t * bytes are technically mapped (though always decommitted or purged),\n\t * but they are excluded from the mapped statistic (above).\n\t */\n\tsize_t retained; /* Derived. */\n\n\t/*\n\t * Number of bytes currently mapped, excluding retained memory (and any\n\t * base-allocated memory, which is tracked by the arena stats).\n\t *\n\t * We name this \"pac_mapped\" to avoid confusion with the arena_stats\n\t * \"mapped\".\n\t */\n\tatomic_zu_t pac_mapped;\n\n\t/* VM space had to be leaked (undocumented). Normally 0. */\n\tatomic_zu_t abandoned_vm;\n};\n\ntypedef struct pac_s pac_t;\nstruct pac_s {\n\t/*\n\t * Must be the first member (we convert it to a PAC given only a\n\t * pointer). The handle to the allocation interface.\n\t */\n\tpai_t pai;\n\t/*\n\t * Collections of extents that were previously allocated. These are\n\t * used when allocating extents, in an attempt to re-use address space.\n\t *\n\t * Synchronization: internal.\n\t */\n\tecache_t ecache_dirty;\n\tecache_t ecache_muzzy;\n\tecache_t ecache_retained;\n\n\tbase_t *base;\n\temap_t *emap;\n\tedata_cache_t *edata_cache;\n\n\t/* The grow info for the retained ecache. */\n\texp_grow_t exp_grow;\n\tmalloc_mutex_t grow_mtx;\n\n\t/* Special allocator for guarded frequently reused extents. */\n\tsan_bump_alloc_t sba;\n\n\t/* How large extents should be before getting auto-purged. */\n\tatomic_zu_t oversize_threshold;\n\n\t/*\n\t * Decay-based purging state, responsible for scheduling extent state\n\t * transitions.\n\t *\n\t * Synchronization: via the internal mutex.\n\t */\n\tdecay_t decay_dirty; /* dirty --> muzzy */\n\tdecay_t decay_muzzy; /* muzzy --> retained */\n\n\tmalloc_mutex_t *stats_mtx;\n\tpac_stats_t *stats;\n\n\t/* Extent serial number generator state. */\n\tatomic_zu_t extent_sn_next;\n};\n\nbool pac_init(tsdn_t *tsdn, pac_t *pac, base_t *base, emap_t *emap,\n edata_cache_t *edata_cache, nstime_t *cur_time, size_t oversize_threshold,\n ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms, pac_stats_t *pac_stats,\n malloc_mutex_t *stats_mtx);\n\nstatic inline size_t\npac_mapped(pac_t *pac) {\n\treturn atomic_load_zu(&pac->stats->pac_mapped, ATOMIC_RELAXED);\n}\n\nstatic inline ehooks_t *\npac_ehooks_get(pac_t *pac) {\n\treturn base_ehooks_get(pac->base);\n}\n\n/*\n * All purging functions require holding decay->mtx. This is one of the few\n * places external modules are allowed to peek inside pa_shard_t internals.\n */\n\n/*\n * Decays the number of pages currently in the ecache. This might not leave the\n * ecache empty if other threads are inserting dirty objects into it\n * concurrently with the call.\n */\nvoid pac_decay_all(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache, bool fully_decay);\n/*\n * Updates decay settings for the current time, and conditionally purges in\n * response (depending on decay_purge_setting). Returns whether or not the\n * epoch advanced.\n */\nbool pac_maybe_decay_purge(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache,\n pac_purge_eagerness_t eagerness);\n\n/*\n * Gets / sets the maximum amount that we'll grow an arena down the\n * grow-retained pathways (unless forced to by an allocaction request).\n *\n * Set new_limit to NULL if it's just a query, or old_limit to NULL if you don't\n * care about the previous value.\n *\n * Returns true on error (if the new limit is not valid).\n */\nbool pac_retain_grow_limit_get_set(tsdn_t *tsdn, pac_t *pac, size_t *old_limit,\n size_t *new_limit);\n\nbool pac_decay_ms_set(tsdn_t *tsdn, pac_t *pac, extent_state_t state,\n ssize_t decay_ms, pac_purge_eagerness_t eagerness);\nssize_t pac_decay_ms_get(pac_t *pac, extent_state_t state);\n\nvoid pac_reset(tsdn_t *tsdn, pac_t *pac);\nvoid pac_destroy(tsdn_t *tsdn, pac_t *pac);\n\n#endif /* JEMALLOC_INTERNAL_PAC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/pages.h", "content": "#ifndef JEMALLOC_INTERNAL_PAGES_EXTERNS_H\n#define JEMALLOC_INTERNAL_PAGES_EXTERNS_H\n\n/* Page size. LG_PAGE is determined by the configure script. */\n#ifdef PAGE_MASK\n# undef PAGE_MASK\n#endif\n#define PAGE\t\t((size_t)(1U << LG_PAGE))\n#define PAGE_MASK\t((size_t)(PAGE - 1))\n/* Return the page base address for the page containing address a. */\n#define PAGE_ADDR2BASE(a)\t\t\t\t\t\t\\\n\t((void *)((uintptr_t)(a) & ~PAGE_MASK))\n/* Return the smallest pagesize multiple that is >= s. */\n#define PAGE_CEILING(s)\t\t\t\t\t\t\t\\\n\t(((s) + PAGE_MASK) & ~PAGE_MASK)\n/* Return the largest pagesize multiple that is <=s. */\n#define PAGE_FLOOR(s) \t\t\t\t\t\t\t\\\n\t((s) & ~PAGE_MASK)\n\n/* Huge page size. LG_HUGEPAGE is determined by the configure script. */\n#define HUGEPAGE\t((size_t)(1U << LG_HUGEPAGE))\n#define HUGEPAGE_MASK\t((size_t)(HUGEPAGE - 1))\n\n#if LG_HUGEPAGE != 0\n# define HUGEPAGE_PAGES (HUGEPAGE / PAGE)\n#else\n/*\n * It's convenient to define arrays (or bitmaps) of HUGEPAGE_PAGES lengths. If\n * we can't autodetect the hugepage size, it gets treated as 0, in which case\n * we'll trigger a compiler error in those arrays. Avoid this case by ensuring\n * that this value is at least 1. (We won't ever run in this degraded state;\n * hpa_supported() returns false in this case.\n */\n# define HUGEPAGE_PAGES 1\n#endif\n\n/* Return the huge page base address for the huge page containing address a. */\n#define HUGEPAGE_ADDR2BASE(a)\t\t\t\t\t\t\\\n\t((void *)((uintptr_t)(a) & ~HUGEPAGE_MASK))\n/* Return the smallest pagesize multiple that is >= s. */\n#define HUGEPAGE_CEILING(s)\t\t\t\t\t\t\\\n\t(((s) + HUGEPAGE_MASK) & ~HUGEPAGE_MASK)\n\n/* PAGES_CAN_PURGE_LAZY is defined if lazy purging is supported. */\n#if defined(_WIN32) || defined(JEMALLOC_PURGE_MADVISE_FREE)\n# define PAGES_CAN_PURGE_LAZY\n#endif\n/*\n * PAGES_CAN_PURGE_FORCED is defined if forced purging is supported.\n *\n * The only supported way to hard-purge on Windows is to decommit and then\n * re-commit, but doing so is racy, and if re-commit fails it's a pain to\n * propagate the \"poisoned\" memory state. Since we typically decommit as the\n * next step after purging on Windows anyway, there's no point in adding such\n * complexity.\n */\n#if !defined(_WIN32) && ((defined(JEMALLOC_PURGE_MADVISE_DONTNEED) && \\\n defined(JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS)) || \\\n defined(JEMALLOC_MAPS_COALESCE))\n# define PAGES_CAN_PURGE_FORCED\n#endif\n\nstatic const bool pages_can_purge_lazy =\n#ifdef PAGES_CAN_PURGE_LAZY\n true\n#else\n false\n#endif\n ;\nstatic const bool pages_can_purge_forced =\n#ifdef PAGES_CAN_PURGE_FORCED\n true\n#else\n false\n#endif\n ;\n\n#if defined(JEMALLOC_HAVE_MADVISE_HUGE) || defined(JEMALLOC_HAVE_MEMCNTL)\n# define PAGES_CAN_HUGIFY\n#endif\n\nstatic const bool pages_can_hugify =\n#ifdef PAGES_CAN_HUGIFY\n true\n#else\n false\n#endif\n ;\n\ntypedef enum {\n\tthp_mode_default = 0, /* Do not change hugepage settings. */\n\tthp_mode_always = 1, /* Always set MADV_HUGEPAGE. */\n\tthp_mode_never = 2, /* Always set MADV_NOHUGEPAGE. */\n\n\tthp_mode_names_limit = 3, /* Used for option processing. */\n\tthp_mode_not_supported = 3 /* No THP support detected. */\n} thp_mode_t;\n\n#define THP_MODE_DEFAULT thp_mode_default\nextern thp_mode_t opt_thp;\nextern thp_mode_t init_system_thp_mode; /* Initial system wide state. */\nextern const char *thp_mode_names[];\n\nvoid *pages_map(void *addr, size_t size, size_t alignment, bool *commit);\nvoid pages_unmap(void *addr, size_t size);\nbool pages_commit(void *addr, size_t size);\nbool pages_decommit(void *addr, size_t size);\nbool pages_purge_lazy(void *addr, size_t size);\nbool pages_purge_forced(void *addr, size_t size);\nbool pages_huge(void *addr, size_t size);\nbool pages_nohuge(void *addr, size_t size);\nbool pages_dontdump(void *addr, size_t size);\nbool pages_dodump(void *addr, size_t size);\nbool pages_boot(void);\nvoid pages_set_thp_state (void *ptr, size_t size);\nvoid pages_mark_guards(void *head, void *tail);\nvoid pages_unmark_guards(void *head, void *tail);\n\n#endif /* JEMALLOC_INTERNAL_PAGES_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/pai.h", "content": "#ifndef JEMALLOC_INTERNAL_PAI_H\n#define JEMALLOC_INTERNAL_PAI_H\n\n/* An interface for page allocation. */\n\ntypedef struct pai_s pai_t;\nstruct pai_s {\n\t/* Returns NULL on failure. */\n\tedata_t *(*alloc)(tsdn_t *tsdn, pai_t *self, size_t size,\n\t size_t alignment, bool zero, bool guarded, bool frequent_reuse,\n\t bool *deferred_work_generated);\n\t/*\n\t * Returns the number of extents added to the list (which may be fewer\n\t * than requested, in case of OOM). The list should already be\n\t * initialized. The only alignment guarantee is page-alignment, and\n\t * the results are not necessarily zeroed.\n\t */\n\tsize_t (*alloc_batch)(tsdn_t *tsdn, pai_t *self, size_t size,\n\t size_t nallocs, edata_list_active_t *results,\n\t bool *deferred_work_generated);\n\tbool (*expand)(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n\t size_t old_size, size_t new_size, bool zero,\n\t bool *deferred_work_generated);\n\tbool (*shrink)(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n\t size_t old_size, size_t new_size, bool *deferred_work_generated);\n\tvoid (*dalloc)(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n\t bool *deferred_work_generated);\n\t/* This function empties out list as a side-effect of being called. */\n\tvoid (*dalloc_batch)(tsdn_t *tsdn, pai_t *self,\n\t edata_list_active_t *list, bool *deferred_work_generated);\n\tuint64_t (*time_until_deferred_work)(tsdn_t *tsdn, pai_t *self);\n};\n\n/*\n * These are just simple convenience functions to avoid having to reference the\n * same pai_t twice on every invocation.\n */\n\nstatic inline edata_t *\npai_alloc(tsdn_t *tsdn, pai_t *self, size_t size, size_t alignment,\n bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated) {\n\treturn self->alloc(tsdn, self, size, alignment, zero, guarded,\n\t frequent_reuse, deferred_work_generated);\n}\n\nstatic inline size_t\npai_alloc_batch(tsdn_t *tsdn, pai_t *self, size_t size, size_t nallocs,\n edata_list_active_t *results, bool *deferred_work_generated) {\n\treturn self->alloc_batch(tsdn, self, size, nallocs, results,\n\t deferred_work_generated);\n}\n\nstatic inline bool\npai_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool zero, bool *deferred_work_generated) {\n\treturn self->expand(tsdn, self, edata, old_size, new_size, zero,\n\t deferred_work_generated);\n}\n\nstatic inline bool\npai_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool *deferred_work_generated) {\n\treturn self->shrink(tsdn, self, edata, old_size, new_size,\n\t deferred_work_generated);\n}\n\nstatic inline void\npai_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated) {\n\tself->dalloc(tsdn, self, edata, deferred_work_generated);\n}\n\nstatic inline void\npai_dalloc_batch(tsdn_t *tsdn, pai_t *self, edata_list_active_t *list,\n bool *deferred_work_generated) {\n\tself->dalloc_batch(tsdn, self, list, deferred_work_generated);\n}\n\nstatic inline uint64_t\npai_time_until_deferred_work(tsdn_t *tsdn, pai_t *self) {\n\treturn self->time_until_deferred_work(tsdn, self);\n}\n\n/*\n * An implementation of batch allocation that simply calls alloc once for\n * each item in the list.\n */\nsize_t pai_alloc_batch_default(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t nallocs, edata_list_active_t *results, bool *deferred_work_generated);\n/* Ditto, for dalloc. */\nvoid pai_dalloc_batch_default(tsdn_t *tsdn, pai_t *self,\n edata_list_active_t *list, bool *deferred_work_generated);\n\n#endif /* JEMALLOC_INTERNAL_PAI_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/peak.h", "content": "#ifndef JEMALLOC_INTERNAL_PEAK_H\n#define JEMALLOC_INTERNAL_PEAK_H\n\ntypedef struct peak_s peak_t;\nstruct peak_s {\n\t/* The highest recorded peak value, after adjustment (see below). */\n\tuint64_t cur_max;\n\t/*\n\t * The difference between alloc and dalloc at the last set_zero call;\n\t * this lets us cancel out the appropriate amount of excess.\n\t */\n\tuint64_t adjustment;\n};\n\n#define PEAK_INITIALIZER {0, 0}\n\nstatic inline uint64_t\npeak_max(peak_t *peak) {\n\treturn peak->cur_max;\n}\n\nstatic inline void\npeak_update(peak_t *peak, uint64_t alloc, uint64_t dalloc) {\n\tint64_t candidate_max = (int64_t)(alloc - dalloc - peak->adjustment);\n\tif (candidate_max > (int64_t)peak->cur_max) {\n\t\tpeak->cur_max = candidate_max;\n\t}\n}\n\n/* Resets the counter to zero; all peaks are now relative to this point. */\nstatic inline void\npeak_set_zero(peak_t *peak, uint64_t alloc, uint64_t dalloc) {\n\tpeak->cur_max = 0;\n\tpeak->adjustment = alloc - dalloc;\n}\n\n#endif /* JEMALLOC_INTERNAL_PEAK_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/peak_event.h", "content": "#ifndef JEMALLOC_INTERNAL_PEAK_EVENT_H\n#define JEMALLOC_INTERNAL_PEAK_EVENT_H\n\n/*\n * While peak.h contains the simple helper struct that tracks state, this\n * contains the allocator tie-ins (and knows about tsd, the event module, etc.).\n */\n\n/* Update the peak with current tsd state. */\nvoid peak_event_update(tsd_t *tsd);\n/* Set current state to zero. */\nvoid peak_event_zero(tsd_t *tsd);\nuint64_t peak_event_max(tsd_t *tsd);\n\n/* Manual hooks. */\n/* The activity-triggered hooks. */\nuint64_t peak_alloc_new_event_wait(tsd_t *tsd);\nuint64_t peak_alloc_postponed_event_wait(tsd_t *tsd);\nvoid peak_alloc_event_handler(tsd_t *tsd, uint64_t elapsed);\nuint64_t peak_dalloc_new_event_wait(tsd_t *tsd);\nuint64_t peak_dalloc_postponed_event_wait(tsd_t *tsd);\nvoid peak_dalloc_event_handler(tsd_t *tsd, uint64_t elapsed);\n\n#endif /* JEMALLOC_INTERNAL_PEAK_EVENT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ph.h", "content": "#ifndef JEMALLOC_INTERNAL_PH_H\n#define JEMALLOC_INTERNAL_PH_H\n\n/*\n * A Pairing Heap implementation.\n *\n * \"The Pairing Heap: A New Form of Self-Adjusting Heap\"\n * https://www.cs.cmu.edu/~sleator/papers/pairing-heaps.pdf\n *\n * With auxiliary twopass list, described in a follow on paper.\n *\n * \"Pairing Heaps: Experiments and Analysis\"\n * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.106.2988&rep=rep1&type=pdf\n *\n *******************************************************************************\n *\n * We include a non-obvious optimization:\n * - First, we introduce a new pop-and-link operation; pop the two most\n * recently-inserted items off the aux-list, link them, and push the resulting\n * heap.\n * - We maintain a count of the number of insertions since the last time we\n * merged the aux-list (i.e. via first() or remove_first()). After N inserts,\n * we do ffs(N) pop-and-link operations.\n *\n * One way to think of this is that we're progressively building up a tree in\n * the aux-list, rather than a linked-list (think of the series of merges that\n * will be performed as the aux-count grows).\n *\n * There's a couple reasons we benefit from this:\n * - Ordinarily, after N insertions, the aux-list is of size N. With our\n * strategy, it's of size O(log(N)). So we decrease the worst-case time of\n * first() calls, and reduce the average cost of remove_min calls. Since\n * these almost always occur while holding a lock, we practically reduce the\n * frequency of unusually long hold times.\n * - This moves the bulk of the work of merging the aux-list onto the threads\n * that are inserting into the heap. In some common scenarios, insertions\n * happen in bulk, from a single thread (think tcache flushing; we potentially\n * move many slabs from slabs_full to slabs_nonfull). All the nodes in this\n * case are in the inserting threads cache, and linking them is very cheap\n * (cache misses dominate linking cost). Without this optimization, linking\n * happens on the next call to remove_first. Since that remove_first call\n * likely happens on a different thread (or at least, after the cache has\n * gotten cold if done on the same thread), deferring linking trades cheap\n * link operations now for expensive ones later.\n *\n * The ffs trick keeps amortized insert cost at constant time. Similar\n * strategies based on periodically sorting the list after a batch of operations\n * perform worse than this in practice, even with various fancy tricks; they\n * all took amortized complexity of an insert from O(1) to O(log(n)).\n */\n\ntypedef int (*ph_cmp_t)(void *, void *);\n\n/* Node structure. */\ntypedef struct phn_link_s phn_link_t;\nstruct phn_link_s {\n\tvoid *prev;\n\tvoid *next;\n\tvoid *lchild;\n};\n\ntypedef struct ph_s ph_t;\nstruct ph_s {\n\tvoid *root;\n\t/*\n\t * Inserts done since the last aux-list merge. This is not necessarily\n\t * the size of the aux-list, since it's possible that removals have\n\t * happened since, and we don't track whether or not those removals are\n\t * from the aux list.\n\t */\n\tsize_t auxcount;\n};\n\nJEMALLOC_ALWAYS_INLINE phn_link_t *\nphn_link_get(void *phn, size_t offset) {\n\treturn (phn_link_t *)(((uintptr_t)phn) + offset);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nphn_link_init(void *phn, size_t offset) {\n\tphn_link_get(phn, offset)->prev = NULL;\n\tphn_link_get(phn, offset)->next = NULL;\n\tphn_link_get(phn, offset)->lchild = NULL;\n}\n\n/* Internal utility helpers. */\nJEMALLOC_ALWAYS_INLINE void *\nphn_lchild_get(void *phn, size_t offset) {\n\treturn phn_link_get(phn, offset)->lchild;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nphn_lchild_set(void *phn, void *lchild, size_t offset) {\n\tphn_link_get(phn, offset)->lchild = lchild;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nphn_next_get(void *phn, size_t offset) {\n\treturn phn_link_get(phn, offset)->next;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nphn_next_set(void *phn, void *next, size_t offset) {\n\tphn_link_get(phn, offset)->next = next;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nphn_prev_get(void *phn, size_t offset) {\n\treturn phn_link_get(phn, offset)->prev;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nphn_prev_set(void *phn, void *prev, size_t offset) {\n\tphn_link_get(phn, offset)->prev = prev;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nphn_merge_ordered(void *phn0, void *phn1, size_t offset,\n ph_cmp_t cmp) {\n\tvoid *phn0child;\n\n\tassert(phn0 != NULL);\n\tassert(phn1 != NULL);\n\tassert(cmp(phn0, phn1) <= 0);\n\n\tphn_prev_set(phn1, phn0, offset);\n\tphn0child = phn_lchild_get(phn0, offset);\n\tphn_next_set(phn1, phn0child, offset);\n\tif (phn0child != NULL) {\n\t\tphn_prev_set(phn0child, phn1, offset);\n\t}\n\tphn_lchild_set(phn0, phn1, offset);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nphn_merge(void *phn0, void *phn1, size_t offset, ph_cmp_t cmp) {\n\tvoid *result;\n\tif (phn0 == NULL) {\n\t\tresult = phn1;\n\t} else if (phn1 == NULL) {\n\t\tresult = phn0;\n\t} else if (cmp(phn0, phn1) < 0) {\n\t\tphn_merge_ordered(phn0, phn1, offset, cmp);\n\t\tresult = phn0;\n\t} else {\n\t\tphn_merge_ordered(phn1, phn0, offset, cmp);\n\t\tresult = phn1;\n\t}\n\treturn result;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nphn_merge_siblings(void *phn, size_t offset, ph_cmp_t cmp) {\n\tvoid *head = NULL;\n\tvoid *tail = NULL;\n\tvoid *phn0 = phn;\n\tvoid *phn1 = phn_next_get(phn0, offset);\n\n\t/*\n\t * Multipass merge, wherein the first two elements of a FIFO\n\t * are repeatedly merged, and each result is appended to the\n\t * singly linked FIFO, until the FIFO contains only a single\n\t * element. We start with a sibling list but no reference to\n\t * its tail, so we do a single pass over the sibling list to\n\t * populate the FIFO.\n\t */\n\tif (phn1 != NULL) {\n\t\tvoid *phnrest = phn_next_get(phn1, offset);\n\t\tif (phnrest != NULL) {\n\t\t\tphn_prev_set(phnrest, NULL, offset);\n\t\t}\n\t\tphn_prev_set(phn0, NULL, offset);\n\t\tphn_next_set(phn0, NULL, offset);\n\t\tphn_prev_set(phn1, NULL, offset);\n\t\tphn_next_set(phn1, NULL, offset);\n\t\tphn0 = phn_merge(phn0, phn1, offset, cmp);\n\t\thead = tail = phn0;\n\t\tphn0 = phnrest;\n\t\twhile (phn0 != NULL) {\n\t\t\tphn1 = phn_next_get(phn0, offset);\n\t\t\tif (phn1 != NULL) {\n\t\t\t\tphnrest = phn_next_get(phn1, offset);\n\t\t\t\tif (phnrest != NULL) {\n\t\t\t\t\tphn_prev_set(phnrest, NULL, offset);\n\t\t\t\t}\n\t\t\t\tphn_prev_set(phn0, NULL, offset);\n\t\t\t\tphn_next_set(phn0, NULL, offset);\n\t\t\t\tphn_prev_set(phn1, NULL, offset);\n\t\t\t\tphn_next_set(phn1, NULL, offset);\n\t\t\t\tphn0 = phn_merge(phn0, phn1, offset, cmp);\n\t\t\t\tphn_next_set(tail, phn0, offset);\n\t\t\t\ttail = phn0;\n\t\t\t\tphn0 = phnrest;\n\t\t\t} else {\n\t\t\t\tphn_next_set(tail, phn0, offset);\n\t\t\t\ttail = phn0;\n\t\t\t\tphn0 = NULL;\n\t\t\t}\n\t\t}\n\t\tphn0 = head;\n\t\tphn1 = phn_next_get(phn0, offset);\n\t\tif (phn1 != NULL) {\n\t\t\twhile (true) {\n\t\t\t\thead = phn_next_get(phn1, offset);\n\t\t\t\tassert(phn_prev_get(phn0, offset) == NULL);\n\t\t\t\tphn_next_set(phn0, NULL, offset);\n\t\t\t\tassert(phn_prev_get(phn1, offset) == NULL);\n\t\t\t\tphn_next_set(phn1, NULL, offset);\n\t\t\t\tphn0 = phn_merge(phn0, phn1, offset, cmp);\n\t\t\t\tif (head == NULL) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tphn_next_set(tail, phn0, offset);\n\t\t\t\ttail = phn0;\n\t\t\t\tphn0 = head;\n\t\t\t\tphn1 = phn_next_get(phn0, offset);\n\t\t\t}\n\t\t}\n\t}\n\treturn phn0;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nph_merge_aux(ph_t *ph, size_t offset, ph_cmp_t cmp) {\n\tph->auxcount = 0;\n\tvoid *phn = phn_next_get(ph->root, offset);\n\tif (phn != NULL) {\n\t\tphn_prev_set(ph->root, NULL, offset);\n\t\tphn_next_set(ph->root, NULL, offset);\n\t\tphn_prev_set(phn, NULL, offset);\n\t\tphn = phn_merge_siblings(phn, offset, cmp);\n\t\tassert(phn_next_get(phn, offset) == NULL);\n\t\tph->root = phn_merge(ph->root, phn, offset, cmp);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nph_merge_children(void *phn, size_t offset, ph_cmp_t cmp) {\n\tvoid *result;\n\tvoid *lchild = phn_lchild_get(phn, offset);\n\tif (lchild == NULL) {\n\t\tresult = NULL;\n\t} else {\n\t\tresult = phn_merge_siblings(lchild, offset, cmp);\n\t}\n\treturn result;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nph_new(ph_t *ph) {\n\tph->root = NULL;\n\tph->auxcount = 0;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nph_empty(ph_t *ph) {\n\treturn ph->root == NULL;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nph_first(ph_t *ph, size_t offset, ph_cmp_t cmp) {\n\tif (ph->root == NULL) {\n\t\treturn NULL;\n\t}\n\tph_merge_aux(ph, offset, cmp);\n\treturn ph->root;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nph_any(ph_t *ph, size_t offset) {\n\tif (ph->root == NULL) {\n\t\treturn NULL;\n\t}\n\tvoid *aux = phn_next_get(ph->root, offset);\n\tif (aux != NULL) {\n\t\treturn aux;\n\t}\n\treturn ph->root;\n}\n\n/* Returns true if we should stop trying to merge. */\nJEMALLOC_ALWAYS_INLINE bool\nph_try_aux_merge_pair(ph_t *ph, size_t offset, ph_cmp_t cmp) {\n\tassert(ph->root != NULL);\n\tvoid *phn0 = phn_next_get(ph->root, offset);\n\tif (phn0 == NULL) {\n\t\treturn true;\n\t}\n\tvoid *phn1 = phn_next_get(phn0, offset);\n\tif (phn1 == NULL) {\n\t\treturn true;\n\t}\n\tvoid *next_phn1 = phn_next_get(phn1, offset);\n\tphn_next_set(phn0, NULL, offset);\n\tphn_prev_set(phn0, NULL, offset);\n\tphn_next_set(phn1, NULL, offset);\n\tphn_prev_set(phn1, NULL, offset);\n\tphn0 = phn_merge(phn0, phn1, offset, cmp);\n\tphn_next_set(phn0, next_phn1, offset);\n\tif (next_phn1 != NULL) {\n\t\tphn_prev_set(next_phn1, phn0, offset);\n\t}\n\tphn_next_set(ph->root, phn0, offset);\n\tphn_prev_set(phn0, ph->root, offset);\n\treturn next_phn1 == NULL;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nph_insert(ph_t *ph, void *phn, size_t offset, ph_cmp_t cmp) {\n\tphn_link_init(phn, offset);\n\n\t/*\n\t * Treat the root as an aux list during insertion, and lazily merge\n\t * during a_prefix##remove_first(). For elements that are inserted,\n\t * then removed via a_prefix##remove() before the aux list is ever\n\t * processed, this makes insert/remove constant-time, whereas eager\n\t * merging would make insert O(log n).\n\t */\n\tif (ph->root == NULL) {\n\t\tph->root = phn;\n\t} else {\n\t\t/*\n\t\t * As a special case, check to see if we can replace the root.\n\t\t * This is practically common in some important cases, and lets\n\t\t * us defer some insertions (hopefully, until the point where\n\t\t * some of the items in the aux list have been removed, savings\n\t\t * us from linking them at all).\n\t\t */\n\t\tif (cmp(phn, ph->root) < 0) {\n\t\t\tphn_lchild_set(phn, ph->root, offset);\n\t\t\tphn_prev_set(ph->root, phn, offset);\n\t\t\tph->root = phn;\n\t\t\tph->auxcount = 0;\n\t\t\treturn;\n\t\t}\n\t\tph->auxcount++;\n\t\tphn_next_set(phn, phn_next_get(ph->root, offset), offset);\n\t\tif (phn_next_get(ph->root, offset) != NULL) {\n\t\t\tphn_prev_set(phn_next_get(ph->root, offset), phn,\n\t\t\t offset);\n\t\t}\n\t\tphn_prev_set(phn, ph->root, offset);\n\t\tphn_next_set(ph->root, phn, offset);\n\t}\n\tif (ph->auxcount > 1) {\n\t\tunsigned nmerges = ffs_zu(ph->auxcount - 1);\n\t\tbool done = false;\n\t\tfor (unsigned i = 0; i < nmerges && !done; i++) {\n\t\t\tdone = ph_try_aux_merge_pair(ph, offset, cmp);\n\t\t}\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nph_remove_first(ph_t *ph, size_t offset, ph_cmp_t cmp) {\n\tvoid *ret;\n\n\tif (ph->root == NULL) {\n\t\treturn NULL;\n\t}\n\tph_merge_aux(ph, offset, cmp);\n\tret = ph->root;\n\tph->root = ph_merge_children(ph->root, offset, cmp);\n\n\treturn ret;\n\n}\n\nJEMALLOC_ALWAYS_INLINE void\nph_remove(ph_t *ph, void *phn, size_t offset, ph_cmp_t cmp) {\n\tvoid *replace;\n\tvoid *parent;\n\n\tif (ph->root == phn) {\n\t\t/*\n\t\t * We can delete from aux list without merging it, but we need\n\t\t * to merge if we are dealing with the root node and it has\n\t\t * children.\n\t\t */\n\t\tif (phn_lchild_get(phn, offset) == NULL) {\n\t\t\tph->root = phn_next_get(phn, offset);\n\t\t\tif (ph->root != NULL) {\n\t\t\t\tphn_prev_set(ph->root, NULL, offset);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\tph_merge_aux(ph, offset, cmp);\n\t\tif (ph->root == phn) {\n\t\t\tph->root = ph_merge_children(ph->root, offset, cmp);\n\t\t\treturn;\n\t\t}\n\t}\n\n\t/* Get parent (if phn is leftmost child) before mutating. */\n\tif ((parent = phn_prev_get(phn, offset)) != NULL) {\n\t\tif (phn_lchild_get(parent, offset) != phn) {\n\t\t\tparent = NULL;\n\t\t}\n\t}\n\t/* Find a possible replacement node, and link to parent. */\n\treplace = ph_merge_children(phn, offset, cmp);\n\t/* Set next/prev for sibling linked list. */\n\tif (replace != NULL) {\n\t\tif (parent != NULL) {\n\t\t\tphn_prev_set(replace, parent, offset);\n\t\t\tphn_lchild_set(parent, replace, offset);\n\t\t} else {\n\t\t\tphn_prev_set(replace, phn_prev_get(phn, offset),\n\t\t\t offset);\n\t\t\tif (phn_prev_get(phn, offset) != NULL) {\n\t\t\t\tphn_next_set(phn_prev_get(phn, offset), replace,\n\t\t\t\t offset);\n\t\t\t}\n\t\t}\n\t\tphn_next_set(replace, phn_next_get(phn, offset), offset);\n\t\tif (phn_next_get(phn, offset) != NULL) {\n\t\t\tphn_prev_set(phn_next_get(phn, offset), replace,\n\t\t\t offset);\n\t\t}\n\t} else {\n\t\tif (parent != NULL) {\n\t\t\tvoid *next = phn_next_get(phn, offset);\n\t\t\tphn_lchild_set(parent, next, offset);\n\t\t\tif (next != NULL) {\n\t\t\t\tphn_prev_set(next, parent, offset);\n\t\t\t}\n\t\t} else {\n\t\t\tassert(phn_prev_get(phn, offset) != NULL);\n\t\t\tphn_next_set(\n\t\t\t phn_prev_get(phn, offset),\n\t\t\t phn_next_get(phn, offset), offset);\n\t\t}\n\t\tif (phn_next_get(phn, offset) != NULL) {\n\t\t\tphn_prev_set(\n\t\t\t phn_next_get(phn, offset),\n\t\t\t phn_prev_get(phn, offset), offset);\n\t\t}\n\t}\n}\n\n#define ph_structs(a_prefix, a_type)\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tphn_link_t link;\t\t\t\t\t\t\\\n} a_prefix##_link_t;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tph_t ph;\t\t\t\t\t\t\t\\\n} a_prefix##_t;\n\n/*\n * The ph_proto() macro generates function prototypes that correspond to the\n * functions generated by an equivalently parameterized call to ph_gen().\n */\n#define ph_proto(a_attr, a_prefix, a_type)\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr void a_prefix##_new(a_prefix##_t *ph);\t\t\t\t\\\na_attr bool a_prefix##_empty(a_prefix##_t *ph);\t\t\t\t\\\na_attr a_type *a_prefix##_first(a_prefix##_t *ph);\t\t\t\\\na_attr a_type *a_prefix##_any(a_prefix##_t *ph);\t\t\t\\\na_attr void a_prefix##_insert(a_prefix##_t *ph, a_type *phn);\t\t\\\na_attr a_type *a_prefix##_remove_first(a_prefix##_t *ph);\t\t\\\na_attr void a_prefix##_remove(a_prefix##_t *ph, a_type *phn);\t\t\\\na_attr a_type *a_prefix##_remove_any(a_prefix##_t *ph);\n\n/* The ph_gen() macro generates a type-specific pairing heap implementation. */\n#define ph_gen(a_attr, a_prefix, a_type, a_field, a_cmp)\t\t\\\nJEMALLOC_ALWAYS_INLINE int\t\t\t\t\t\t\\\na_prefix##_ph_cmp(void *a, void *b) {\t\t\t\t\t\\\n\treturn a_cmp((a_type *)a, (a_type *)b);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##_new(a_prefix##_t *ph) {\t\t\t\t\t\\\n\tph_new(&ph->ph);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##_empty(a_prefix##_t *ph) {\t\t\t\t\t\\\n\treturn ph_empty(&ph->ph);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##_first(a_prefix##_t *ph) {\t\t\t\t\t\\\n\treturn ph_first(&ph->ph, offsetof(a_type, a_field),\t\t\\\n\t &a_prefix##_ph_cmp);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##_any(a_prefix##_t *ph) {\t\t\t\t\t\\\n\treturn ph_any(&ph->ph, offsetof(a_type, a_field));\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##_insert(a_prefix##_t *ph, a_type *phn) {\t\t\t\\\n\tph_insert(&ph->ph, phn, offsetof(a_type, a_field),\t\t\\\n\t a_prefix##_ph_cmp);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##_remove_first(a_prefix##_t *ph) {\t\t\t\t\\\n\treturn ph_remove_first(&ph->ph, offsetof(a_type, a_field),\t\\\n\t a_prefix##_ph_cmp);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##_remove(a_prefix##_t *ph, a_type *phn) {\t\t\t\\\n\tph_remove(&ph->ph, phn, offsetof(a_type, a_field),\t\t\\\n\t a_prefix##_ph_cmp);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##_remove_any(a_prefix##_t *ph) {\t\t\t\t\\\n\ta_type *ret = a_prefix##_any(ph);\t\t\t\t\\\n\tif (ret != NULL) {\t\t\t\t\t\t\\\n\t\ta_prefix##_remove(ph, ret);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_PH_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/private_namespace.sh", "content": "#!/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", "content": "#!/bin/sh\n#\n# Generate private_symbols[_jet].awk.\n#\n# Usage: private_symbols.sh *\n#\n# is typically \"\" or \"_\".\n\nsym_prefix=$1\nshift\n\ncat <' output.\n#\n# Handle lines like:\n# 0000000000000008 D opt_junk\n# 0000000000007574 T malloc_initialized\n(NF == 3 && $2 ~ /^[ABCDGRSTVW]$/ && !($3 in exported_symbols) && $3 ~ /^[A-Za-z0-9_]+$/) {\n print substr($3, 1+length(sym_prefix), length($3)-length(sym_prefix))\n}\n\n# Process 'dumpbin /SYMBOLS ' output.\n#\n# Handle lines like:\n# 353 00008098 SECT4 notype External | opt_junk\n# 3F1 00000000 SECT7 notype () External | malloc_initialized\n($3 ~ /^SECT[0-9]+/ && $(NF-2) == \"External\" && !($NF in exported_symbols)) {\n print $NF\n}\nEOF\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prng.h", "content": "#ifndef JEMALLOC_INTERNAL_PRNG_H\n#define JEMALLOC_INTERNAL_PRNG_H\n\n#include \"jemalloc/internal/bit_util.h\"\n\n/*\n * Simple linear congruential pseudo-random number generator:\n *\n * prng(y) = (a*x + c) % m\n *\n * where the following constants ensure maximal period:\n *\n * a == Odd number (relatively prime to 2^n), and (a-1) is a multiple of 4.\n * c == Odd number (relatively prime to 2^n).\n * m == 2^32\n *\n * See Knuth's TAOCP 3rd Ed., Vol. 2, pg. 17 for details on these constraints.\n *\n * This choice of m has the disadvantage that the quality of the bits is\n * proportional to bit position. For example, the lowest bit has a cycle of 2,\n * the next has a cycle of 4, etc. For this reason, we prefer to use the upper\n * bits.\n */\n\n/******************************************************************************/\n/* INTERNAL DEFINITIONS -- IGNORE */\n/******************************************************************************/\n#define PRNG_A_32\tUINT32_C(1103515241)\n#define PRNG_C_32\tUINT32_C(12347)\n\n#define PRNG_A_64\tUINT64_C(6364136223846793005)\n#define PRNG_C_64\tUINT64_C(1442695040888963407)\n\nJEMALLOC_ALWAYS_INLINE uint32_t\nprng_state_next_u32(uint32_t state) {\n\treturn (state * PRNG_A_32) + PRNG_C_32;\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nprng_state_next_u64(uint64_t state) {\n\treturn (state * PRNG_A_64) + PRNG_C_64;\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nprng_state_next_zu(size_t state) {\n#if LG_SIZEOF_PTR == 2\n\treturn (state * PRNG_A_32) + PRNG_C_32;\n#elif LG_SIZEOF_PTR == 3\n\treturn (state * PRNG_A_64) + PRNG_C_64;\n#else\n#error Unsupported pointer size\n#endif\n}\n\n/******************************************************************************/\n/* BEGIN PUBLIC API */\n/******************************************************************************/\n\n/*\n * The prng_lg_range functions give a uniform int in the half-open range [0,\n * 2**lg_range).\n */\n\nJEMALLOC_ALWAYS_INLINE uint32_t\nprng_lg_range_u32(uint32_t *state, unsigned lg_range) {\n\tassert(lg_range > 0);\n\tassert(lg_range <= 32);\n\n\t*state = prng_state_next_u32(*state);\n\tuint32_t ret = *state >> (32 - lg_range);\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nprng_lg_range_u64(uint64_t *state, unsigned lg_range) {\n\tassert(lg_range > 0);\n\tassert(lg_range <= 64);\n\n\t*state = prng_state_next_u64(*state);\n\tuint64_t ret = *state >> (64 - lg_range);\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nprng_lg_range_zu(size_t *state, unsigned lg_range) {\n\tassert(lg_range > 0);\n\tassert(lg_range <= ZU(1) << (3 + LG_SIZEOF_PTR));\n\n\t*state = prng_state_next_zu(*state);\n\tsize_t ret = *state >> ((ZU(1) << (3 + LG_SIZEOF_PTR)) - lg_range);\n\n\treturn ret;\n}\n\n/*\n * The prng_range functions behave like the prng_lg_range, but return a result\n * in [0, range) instead of [0, 2**lg_range).\n */\n\nJEMALLOC_ALWAYS_INLINE uint32_t\nprng_range_u32(uint32_t *state, uint32_t range) {\n\tassert(range != 0);\n\t/*\n\t * If range were 1, lg_range would be 0, so the shift in\n\t * prng_lg_range_u32 would be a shift of a 32-bit variable by 32 bits,\n\t * which is UB. Just handle this case as a one-off.\n\t */\n\tif (range == 1) {\n\t\treturn 0;\n\t}\n\n\t/* Compute the ceiling of lg(range). */\n\tunsigned lg_range = ffs_u32(pow2_ceil_u32(range));\n\n\t/* Generate a result in [0..range) via repeated trial. */\n\tuint32_t ret;\n\tdo {\n\t\tret = prng_lg_range_u32(state, lg_range);\n\t} while (ret >= range);\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nprng_range_u64(uint64_t *state, uint64_t range) {\n\tassert(range != 0);\n\n\t/* See the note in prng_range_u32. */\n\tif (range == 1) {\n\t\treturn 0;\n\t}\n\n\t/* Compute the ceiling of lg(range). */\n\tunsigned lg_range = ffs_u64(pow2_ceil_u64(range));\n\n\t/* Generate a result in [0..range) via repeated trial. */\n\tuint64_t ret;\n\tdo {\n\t\tret = prng_lg_range_u64(state, lg_range);\n\t} while (ret >= range);\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nprng_range_zu(size_t *state, size_t range) {\n\tassert(range != 0);\n\n\t/* See the note in prng_range_u32. */\n\tif (range == 1) {\n\t\treturn 0;\n\t}\n\n\t/* Compute the ceiling of lg(range). */\n\tunsigned lg_range = ffs_u64(pow2_ceil_u64(range));\n\n\t/* Generate a result in [0..range) via repeated trial. */\n\tsize_t ret;\n\tdo {\n\t\tret = prng_lg_range_zu(state, lg_range);\n\t} while (ret >= range);\n\n\treturn ret;\n}\n\n#endif /* JEMALLOC_INTERNAL_PRNG_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_data.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_DATA_H\n#define JEMALLOC_INTERNAL_PROF_DATA_H\n\n#include \"jemalloc/internal/mutex.h\"\n\nextern malloc_mutex_t bt2gctx_mtx;\nextern malloc_mutex_t tdatas_mtx;\nextern malloc_mutex_t prof_dump_mtx;\n\nextern malloc_mutex_t *gctx_locks;\nextern malloc_mutex_t *tdata_locks;\n\nextern size_t prof_unbiased_sz[PROF_SC_NSIZES];\nextern size_t prof_shifted_unbiased_cnt[PROF_SC_NSIZES];\n\nvoid prof_bt_hash(const void *key, size_t r_hash[2]);\nbool prof_bt_keycomp(const void *k1, const void *k2);\n\nbool prof_data_init(tsd_t *tsd);\nprof_tctx_t *prof_lookup(tsd_t *tsd, prof_bt_t *bt);\nchar *prof_thread_name_alloc(tsd_t *tsd, const char *thread_name);\nint prof_thread_name_set_impl(tsd_t *tsd, const char *thread_name);\nvoid prof_unbias_map_init();\nvoid prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,\n prof_tdata_t *tdata, bool leakcheck);\nprof_tdata_t * prof_tdata_init_impl(tsd_t *tsd, uint64_t thr_uid,\n uint64_t thr_discrim, char *thread_name, bool active);\nvoid prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata);\nvoid prof_reset(tsd_t *tsd, size_t lg_sample);\nvoid prof_tctx_try_destroy(tsd_t *tsd, prof_tctx_t *tctx);\n\n/* Used in unit tests. */\nsize_t prof_tdata_count(void);\nsize_t prof_bt_count(void);\nvoid prof_cnt_all(prof_cnt_t *cnt_all);\n\n#endif /* JEMALLOC_INTERNAL_PROF_DATA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_EXTERNS_H\n#define JEMALLOC_INTERNAL_PROF_EXTERNS_H\n\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/prof_hook.h\"\n\nextern bool opt_prof;\nextern bool opt_prof_active;\nextern bool opt_prof_thread_active_init;\nextern size_t opt_lg_prof_sample; /* Mean bytes between samples. */\nextern ssize_t opt_lg_prof_interval; /* lg(prof_interval). */\nextern bool opt_prof_gdump; /* High-water memory dumping. */\nextern bool opt_prof_final; /* Final profile dumping. */\nextern bool opt_prof_leak; /* Dump leak summary at exit. */\nextern bool opt_prof_leak_error; /* Exit with error code if memory leaked */\nextern bool opt_prof_accum; /* Report cumulative bytes. */\nextern bool opt_prof_log; /* Turn logging on at boot. */\nextern char opt_prof_prefix[\n /* Minimize memory bloat for non-prof builds. */\n#ifdef JEMALLOC_PROF\n PATH_MAX +\n#endif\n 1];\nextern bool opt_prof_unbias;\n\n/* For recording recent allocations */\nextern ssize_t opt_prof_recent_alloc_max;\n\n/* Whether to use thread name provided by the system or by mallctl. */\nextern bool opt_prof_sys_thread_name;\n\n/* Whether to record per size class counts and request size totals. */\nextern bool opt_prof_stats;\n\n/* Accessed via prof_active_[gs]et{_unlocked,}(). */\nextern bool prof_active_state;\n\n/* Accessed via prof_gdump_[gs]et{_unlocked,}(). */\nextern bool prof_gdump_val;\n\n/* Profile dump interval, measured in bytes allocated. */\nextern uint64_t prof_interval;\n\n/*\n * Initialized as opt_lg_prof_sample, and potentially modified during profiling\n * resets.\n */\nextern size_t lg_prof_sample;\n\nextern bool prof_booted;\n\nvoid prof_backtrace_hook_set(prof_backtrace_hook_t hook);\nprof_backtrace_hook_t prof_backtrace_hook_get();\n\nvoid prof_dump_hook_set(prof_dump_hook_t hook);\nprof_dump_hook_t prof_dump_hook_get();\n\n/* Functions only accessed in prof_inlines.h */\nprof_tdata_t *prof_tdata_init(tsd_t *tsd);\nprof_tdata_t *prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata);\n\nvoid prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx);\nvoid prof_malloc_sample_object(tsd_t *tsd, const void *ptr, size_t size,\n size_t usize, prof_tctx_t *tctx);\nvoid prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_info_t *prof_info);\nprof_tctx_t *prof_tctx_create(tsd_t *tsd);\nvoid prof_idump(tsdn_t *tsdn);\nbool prof_mdump(tsd_t *tsd, const char *filename);\nvoid prof_gdump(tsdn_t *tsdn);\n\nvoid prof_tdata_cleanup(tsd_t *tsd);\nbool prof_active_get(tsdn_t *tsdn);\nbool prof_active_set(tsdn_t *tsdn, bool active);\nconst char *prof_thread_name_get(tsd_t *tsd);\nint prof_thread_name_set(tsd_t *tsd, const char *thread_name);\nbool prof_thread_active_get(tsd_t *tsd);\nbool prof_thread_active_set(tsd_t *tsd, bool active);\nbool prof_thread_active_init_get(tsdn_t *tsdn);\nbool prof_thread_active_init_set(tsdn_t *tsdn, bool active_init);\nbool prof_gdump_get(tsdn_t *tsdn);\nbool prof_gdump_set(tsdn_t *tsdn, bool active);\nvoid prof_boot0(void);\nvoid prof_boot1(void);\nbool prof_boot2(tsd_t *tsd, base_t *base);\nvoid prof_prefork0(tsdn_t *tsdn);\nvoid prof_prefork1(tsdn_t *tsdn);\nvoid prof_postfork_parent(tsdn_t *tsdn);\nvoid prof_postfork_child(tsdn_t *tsdn);\n\n/* Only accessed by thread event. */\nuint64_t prof_sample_new_event_wait(tsd_t *tsd);\nuint64_t prof_sample_postponed_event_wait(tsd_t *tsd);\nvoid prof_sample_event_handler(tsd_t *tsd, uint64_t elapsed);\n\n#endif /* JEMALLOC_INTERNAL_PROF_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_hook.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_HOOK_H\n#define JEMALLOC_INTERNAL_PROF_HOOK_H\n\n/*\n * The hooks types of which are declared in this file are experimental and\n * undocumented, thus the typedefs are located in an 'internal' header.\n */\n\n/*\n * A hook to mock out backtrace functionality. This can be handy, since it's\n * otherwise difficult to guarantee that two allocations are reported as coming\n * from the exact same stack trace in the presence of an optimizing compiler.\n */\ntypedef void (*prof_backtrace_hook_t)(void **, unsigned *, unsigned);\n\n/*\n * A callback hook that notifies about recently dumped heap profile.\n */\ntypedef void (*prof_dump_hook_t)(const char *filename);\n\n#endif /* JEMALLOC_INTERNAL_PROF_HOOK_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_inlines.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_INLINES_H\n#define JEMALLOC_INTERNAL_PROF_INLINES_H\n\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/thread_event.h\"\n\nJEMALLOC_ALWAYS_INLINE void\nprof_active_assert() {\n\tcassert(config_prof);\n\t/*\n\t * If opt_prof is off, then prof_active must always be off, regardless\n\t * of whether prof_active_mtx is in effect or not.\n\t */\n\tassert(opt_prof || !prof_active_state);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nprof_active_get_unlocked(void) {\n\tprof_active_assert();\n\t/*\n\t * Even if opt_prof is true, sampling can be temporarily disabled by\n\t * setting prof_active to false. No locking is used when reading\n\t * prof_active in the fast path, so there are no guarantees regarding\n\t * how long it will take for all threads to notice state changes.\n\t */\n\treturn prof_active_state;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nprof_gdump_get_unlocked(void) {\n\t/*\n\t * No locking is used when reading prof_gdump_val in the fast path, so\n\t * there are no guarantees regarding how long it will take for all\n\t * threads to notice state changes.\n\t */\n\treturn prof_gdump_val;\n}\n\nJEMALLOC_ALWAYS_INLINE prof_tdata_t *\nprof_tdata_get(tsd_t *tsd, bool create) {\n\tprof_tdata_t *tdata;\n\n\tcassert(config_prof);\n\n\ttdata = tsd_prof_tdata_get(tsd);\n\tif (create) {\n\t\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\t\tif (unlikely(tdata == NULL)) {\n\t\t\tif (tsd_nominal(tsd)) {\n\t\t\t\ttdata = prof_tdata_init(tsd);\n\t\t\t\ttsd_prof_tdata_set(tsd, tdata);\n\t\t\t}\n\t\t} else if (unlikely(tdata->expired)) {\n\t\t\ttdata = prof_tdata_reinit(tsd, tdata);\n\t\t\ttsd_prof_tdata_set(tsd, tdata);\n\t\t}\n\t\tassert(tdata == NULL || tdata->attached);\n\t}\n\n\treturn tdata;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_info_get(tsd_t *tsd, const void *ptr, emap_alloc_ctx_t *alloc_ctx,\n prof_info_t *prof_info) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\tassert(prof_info != NULL);\n\n\tarena_prof_info_get(tsd, ptr, alloc_ctx, prof_info, false);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_info_get_and_reset_recent(tsd_t *tsd, const void *ptr,\n emap_alloc_ctx_t *alloc_ctx, prof_info_t *prof_info) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\tassert(prof_info != NULL);\n\n\tarena_prof_info_get(tsd, ptr, alloc_ctx, prof_info, true);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_tctx_reset(tsd_t *tsd, const void *ptr, emap_alloc_ctx_t *alloc_ctx) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\n\tarena_prof_tctx_reset(tsd, ptr, alloc_ctx);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_tctx_reset_sampled(tsd_t *tsd, const void *ptr) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\n\tarena_prof_tctx_reset_sampled(tsd, ptr);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_info_set(tsd_t *tsd, edata_t *edata, prof_tctx_t *tctx, size_t size) {\n\tcassert(config_prof);\n\tassert(edata != NULL);\n\tassert((uintptr_t)tctx > (uintptr_t)1U);\n\n\tarena_prof_info_set(tsd, edata, tctx, size);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nprof_sample_should_skip(tsd_t *tsd, bool sample_event) {\n\tcassert(config_prof);\n\n\t/* Fastpath: no need to load tdata */\n\tif (likely(!sample_event)) {\n\t\treturn true;\n\t}\n\n\t/*\n\t * sample_event is always obtained from the thread event module, and\n\t * whenever it's true, it means that the thread event module has\n\t * already checked the reentrancy level.\n\t */\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata = prof_tdata_get(tsd, true);\n\tif (unlikely(tdata == NULL)) {\n\t\treturn true;\n\t}\n\n\treturn !tdata->active;\n}\n\nJEMALLOC_ALWAYS_INLINE prof_tctx_t *\nprof_alloc_prep(tsd_t *tsd, bool prof_active, bool sample_event) {\n\tprof_tctx_t *ret;\n\n\tif (!prof_active ||\n\t likely(prof_sample_should_skip(tsd, sample_event))) {\n\t\tret = (prof_tctx_t *)(uintptr_t)1U;\n\t} else {\n\t\tret = prof_tctx_create(tsd);\n\t}\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_malloc(tsd_t *tsd, const void *ptr, size_t size, size_t usize,\n emap_alloc_ctx_t *alloc_ctx, prof_tctx_t *tctx) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\tassert(usize == isalloc(tsd_tsdn(tsd), ptr));\n\n\tif (unlikely((uintptr_t)tctx > (uintptr_t)1U)) {\n\t\tprof_malloc_sample_object(tsd, ptr, size, usize, tctx);\n\t} else {\n\t\tprof_tctx_reset(tsd, ptr, alloc_ctx);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_realloc(tsd_t *tsd, const void *ptr, size_t size, size_t usize,\n prof_tctx_t *tctx, bool prof_active, const void *old_ptr, size_t old_usize,\n prof_info_t *old_prof_info, bool sample_event) {\n\tbool sampled, old_sampled, moved;\n\n\tcassert(config_prof);\n\tassert(ptr != NULL || (uintptr_t)tctx <= (uintptr_t)1U);\n\n\tif (prof_active && ptr != NULL) {\n\t\tassert(usize == isalloc(tsd_tsdn(tsd), ptr));\n\t\tif (prof_sample_should_skip(tsd, sample_event)) {\n\t\t\t/*\n\t\t\t * Don't sample. The usize passed to prof_alloc_prep()\n\t\t\t * was larger than what actually got allocated, so a\n\t\t\t * backtrace was captured for this allocation, even\n\t\t\t * though its actual usize was insufficient to cross the\n\t\t\t * sample threshold.\n\t\t\t */\n\t\t\tprof_alloc_rollback(tsd, tctx);\n\t\t\ttctx = (prof_tctx_t *)(uintptr_t)1U;\n\t\t}\n\t}\n\n\tsampled = ((uintptr_t)tctx > (uintptr_t)1U);\n\told_sampled = ((uintptr_t)old_prof_info->alloc_tctx > (uintptr_t)1U);\n\tmoved = (ptr != old_ptr);\n\n\tif (unlikely(sampled)) {\n\t\tprof_malloc_sample_object(tsd, ptr, size, usize, tctx);\n\t} else if (moved) {\n\t\tprof_tctx_reset(tsd, ptr, NULL);\n\t} else if (unlikely(old_sampled)) {\n\t\t/*\n\t\t * prof_tctx_reset() would work for the !moved case as well,\n\t\t * but prof_tctx_reset_sampled() is slightly cheaper, and the\n\t\t * proper thing to do here in the presence of explicit\n\t\t * knowledge re: moved state.\n\t\t */\n\t\tprof_tctx_reset_sampled(tsd, ptr);\n\t} else {\n\t\tprof_info_t prof_info;\n\t\tprof_info_get(tsd, ptr, NULL, &prof_info);\n\t\tassert((uintptr_t)prof_info.alloc_tctx == (uintptr_t)1U);\n\t}\n\n\t/*\n\t * The prof_free_sampled_object() call must come after the\n\t * prof_malloc_sample_object() call, because tctx and old_tctx may be\n\t * the same, in which case reversing the call order could cause the tctx\n\t * to be prematurely destroyed as a side effect of momentarily zeroed\n\t * counters.\n\t */\n\tif (unlikely(old_sampled)) {\n\t\tprof_free_sampled_object(tsd, old_usize, old_prof_info);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nprof_sample_align(size_t orig_align) {\n\t/*\n\t * Enforce page alignment, so that sampled allocations can be identified\n\t * w/o metadata lookup.\n\t */\n\tassert(opt_prof);\n\treturn (opt_cache_oblivious && orig_align < PAGE) ? PAGE :\n\t orig_align;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nprof_sample_aligned(const void *ptr) {\n\treturn ((uintptr_t)ptr & PAGE_MASK) == 0;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nprof_sampled(tsd_t *tsd, const void *ptr) {\n\tprof_info_t prof_info;\n\tprof_info_get(tsd, ptr, NULL, &prof_info);\n\tbool sampled = (uintptr_t)prof_info.alloc_tctx > (uintptr_t)1U;\n\tif (sampled) {\n\t\tassert(prof_sample_aligned(ptr));\n\t}\n\treturn sampled;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nprof_free(tsd_t *tsd, const void *ptr, size_t usize,\n emap_alloc_ctx_t *alloc_ctx) {\n\tprof_info_t prof_info;\n\tprof_info_get_and_reset_recent(tsd, ptr, alloc_ctx, &prof_info);\n\n\tcassert(config_prof);\n\tassert(usize == isalloc(tsd_tsdn(tsd), ptr));\n\n\tif (unlikely((uintptr_t)prof_info.alloc_tctx > (uintptr_t)1U)) {\n\t\tassert(prof_sample_aligned(ptr));\n\t\tprof_free_sampled_object(tsd, usize, &prof_info);\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_PROF_INLINES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_log.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_LOG_H\n#define JEMALLOC_INTERNAL_PROF_LOG_H\n\n#include \"jemalloc/internal/mutex.h\"\n\nextern malloc_mutex_t log_mtx;\n\nvoid prof_try_log(tsd_t *tsd, size_t usize, prof_info_t *prof_info);\nbool prof_log_init(tsd_t *tsdn);\n\n/* Used in unit tests. */\nsize_t prof_log_bt_count(void);\nsize_t prof_log_alloc_count(void);\nsize_t prof_log_thr_count(void);\nbool prof_log_is_logging(void);\nbool prof_log_rep_check(void);\nvoid prof_log_dummy_set(bool new_value);\n\nbool prof_log_start(tsdn_t *tsdn, const char *filename);\nbool prof_log_stop(tsdn_t *tsdn);\n\n#endif /* JEMALLOC_INTERNAL_PROF_LOG_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_recent.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_RECENT_H\n#define JEMALLOC_INTERNAL_PROF_RECENT_H\n\nextern malloc_mutex_t prof_recent_alloc_mtx;\nextern malloc_mutex_t prof_recent_dump_mtx;\n\nbool prof_recent_alloc_prepare(tsd_t *tsd, prof_tctx_t *tctx);\nvoid prof_recent_alloc(tsd_t *tsd, edata_t *edata, size_t size, size_t usize);\nvoid prof_recent_alloc_reset(tsd_t *tsd, edata_t *edata);\nbool prof_recent_init();\nvoid edata_prof_recent_alloc_init(edata_t *edata);\n\n/* Used in unit tests. */\ntypedef ql_head(prof_recent_t) prof_recent_list_t;\nextern prof_recent_list_t prof_recent_alloc_list;\nedata_t *prof_recent_alloc_edata_get_no_lock_test(const prof_recent_t *node);\nprof_recent_t *edata_prof_recent_alloc_get_no_lock_test(const edata_t *edata);\n\nssize_t prof_recent_alloc_max_ctl_read();\nssize_t prof_recent_alloc_max_ctl_write(tsd_t *tsd, ssize_t max);\nvoid prof_recent_alloc_dump(tsd_t *tsd, write_cb_t *write_cb, void *cbopaque);\n\n#endif /* JEMALLOC_INTERNAL_PROF_RECENT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_stats.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_STATS_H\n#define JEMALLOC_INTERNAL_PROF_STATS_H\n\ntypedef struct prof_stats_s prof_stats_t;\nstruct prof_stats_s {\n\tuint64_t req_sum;\n\tuint64_t count;\n};\n\nextern malloc_mutex_t prof_stats_mtx;\n\nvoid prof_stats_inc(tsd_t *tsd, szind_t ind, size_t size);\nvoid prof_stats_dec(tsd_t *tsd, szind_t ind, size_t size);\nvoid prof_stats_get_live(tsd_t *tsd, szind_t ind, prof_stats_t *stats);\nvoid prof_stats_get_accum(tsd_t *tsd, szind_t ind, prof_stats_t *stats);\n\n#endif /* JEMALLOC_INTERNAL_PROF_STATS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_structs.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_STRUCTS_H\n#define JEMALLOC_INTERNAL_PROF_STRUCTS_H\n\n#include \"jemalloc/internal/ckh.h\"\n#include \"jemalloc/internal/edata.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/prng.h\"\n#include \"jemalloc/internal/rb.h\"\n\nstruct prof_bt_s {\n\t/* Backtrace, stored as len program counters. */\n\tvoid\t\t**vec;\n\tunsigned\tlen;\n};\n\n#ifdef JEMALLOC_PROF_LIBGCC\n/* Data structure passed to libgcc _Unwind_Backtrace() callback functions. */\ntypedef struct {\n\tvoid \t\t**vec;\n\tunsigned\t*len;\n\tunsigned\tmax;\n} prof_unwind_data_t;\n#endif\n\nstruct prof_cnt_s {\n\t/* Profiling counters. */\n\tuint64_t\tcurobjs;\n\tuint64_t\tcurobjs_shifted_unbiased;\n\tuint64_t\tcurbytes;\n\tuint64_t\tcurbytes_unbiased;\n\tuint64_t\taccumobjs;\n\tuint64_t\taccumobjs_shifted_unbiased;\n\tuint64_t\taccumbytes;\n\tuint64_t\taccumbytes_unbiased;\n};\n\ntypedef enum {\n\tprof_tctx_state_initializing,\n\tprof_tctx_state_nominal,\n\tprof_tctx_state_dumping,\n\tprof_tctx_state_purgatory /* Dumper must finish destroying. */\n} prof_tctx_state_t;\n\nstruct prof_tctx_s {\n\t/* Thread data for thread that performed the allocation. */\n\tprof_tdata_t\t\t*tdata;\n\n\t/*\n\t * Copy of tdata->thr_{uid,discrim}, necessary because tdata may be\n\t * defunct during teardown.\n\t */\n\tuint64_t\t\tthr_uid;\n\tuint64_t\t\tthr_discrim;\n\n\t/*\n\t * Reference count of how many times this tctx object is referenced in\n\t * recent allocation / deallocation records, protected by tdata->lock.\n\t */\n\tuint64_t\t\trecent_count;\n\n\t/* Profiling counters, protected by tdata->lock. */\n\tprof_cnt_t\t\tcnts;\n\n\t/* Associated global context. */\n\tprof_gctx_t\t\t*gctx;\n\n\t/*\n\t * UID that distinguishes multiple tctx's created by the same thread,\n\t * but coexisting in gctx->tctxs. There are two ways that such\n\t * coexistence can occur:\n\t * - A dumper thread can cause a tctx to be retained in the purgatory\n\t * state.\n\t * - Although a single \"producer\" thread must create all tctx's which\n\t * share the same thr_uid, multiple \"consumers\" can each concurrently\n\t * execute portions of prof_tctx_destroy(). prof_tctx_destroy() only\n\t * gets called once each time cnts.cur{objs,bytes} drop to 0, but this\n\t * threshold can be hit again before the first consumer finishes\n\t * executing prof_tctx_destroy().\n\t */\n\tuint64_t\t\ttctx_uid;\n\n\t/* Linkage into gctx's tctxs. */\n\trb_node(prof_tctx_t)\ttctx_link;\n\n\t/*\n\t * True during prof_alloc_prep()..prof_malloc_sample_object(), prevents\n\t * sample vs destroy race.\n\t */\n\tbool\t\t\tprepared;\n\n\t/* Current dump-related state, protected by gctx->lock. */\n\tprof_tctx_state_t\tstate;\n\n\t/*\n\t * Copy of cnts snapshotted during early dump phase, protected by\n\t * dump_mtx.\n\t */\n\tprof_cnt_t\t\tdump_cnts;\n};\ntypedef rb_tree(prof_tctx_t) prof_tctx_tree_t;\n\nstruct prof_info_s {\n\t/* Time when the allocation was made. */\n\tnstime_t\t\talloc_time;\n\t/* Points to the prof_tctx_t corresponding to the allocation. */\n\tprof_tctx_t\t\t*alloc_tctx;\n\t/* Allocation request size. */\n\tsize_t\t\t\talloc_size;\n};\n\nstruct prof_gctx_s {\n\t/* Protects nlimbo, cnt_summed, and tctxs. */\n\tmalloc_mutex_t\t\t*lock;\n\n\t/*\n\t * Number of threads that currently cause this gctx to be in a state of\n\t * limbo due to one of:\n\t * - Initializing this gctx.\n\t * - Initializing per thread counters associated with this gctx.\n\t * - Preparing to destroy this gctx.\n\t * - Dumping a heap profile that includes this gctx.\n\t * nlimbo must be 1 (single destroyer) in order to safely destroy the\n\t * gctx.\n\t */\n\tunsigned\t\tnlimbo;\n\n\t/*\n\t * Tree of profile counters, one for each thread that has allocated in\n\t * this context.\n\t */\n\tprof_tctx_tree_t\ttctxs;\n\n\t/* Linkage for tree of contexts to be dumped. */\n\trb_node(prof_gctx_t)\tdump_link;\n\n\t/* Temporary storage for summation during dump. */\n\tprof_cnt_t\t\tcnt_summed;\n\n\t/* Associated backtrace. */\n\tprof_bt_t\t\tbt;\n\n\t/* Backtrace vector, variable size, referred to by bt. */\n\tvoid\t\t\t*vec[1];\n};\ntypedef rb_tree(prof_gctx_t) prof_gctx_tree_t;\n\nstruct prof_tdata_s {\n\tmalloc_mutex_t\t\t*lock;\n\n\t/* Monotonically increasing unique thread identifier. */\n\tuint64_t\t\tthr_uid;\n\n\t/*\n\t * Monotonically increasing discriminator among tdata structures\n\t * associated with the same thr_uid.\n\t */\n\tuint64_t\t\tthr_discrim;\n\n\t/* Included in heap profile dumps if non-NULL. */\n\tchar\t\t\t*thread_name;\n\n\tbool\t\t\tattached;\n\tbool\t\t\texpired;\n\n\trb_node(prof_tdata_t)\ttdata_link;\n\n\t/*\n\t * Counter used to initialize prof_tctx_t's tctx_uid. No locking is\n\t * necessary when incrementing this field, because only one thread ever\n\t * does so.\n\t */\n\tuint64_t\t\ttctx_uid_next;\n\n\t/*\n\t * Hash of (prof_bt_t *)-->(prof_tctx_t *). Each thread tracks\n\t * backtraces for which it has non-zero allocation/deallocation counters\n\t * associated with thread-specific prof_tctx_t objects. Other threads\n\t * may write to prof_tctx_t contents when freeing associated objects.\n\t */\n\tckh_t\t\t\tbt2tctx;\n\n\t/* State used to avoid dumping while operating on prof internals. */\n\tbool\t\t\tenq;\n\tbool\t\t\tenq_idump;\n\tbool\t\t\tenq_gdump;\n\n\t/*\n\t * Set to true during an early dump phase for tdata's which are\n\t * currently being dumped. New threads' tdata's have this initialized\n\t * to false so that they aren't accidentally included in later dump\n\t * phases.\n\t */\n\tbool\t\t\tdumping;\n\n\t/*\n\t * True if profiling is active for this tdata's thread\n\t * (thread.prof.active mallctl).\n\t */\n\tbool\t\t\tactive;\n\n\t/* Temporary storage for summation during dump. */\n\tprof_cnt_t\t\tcnt_summed;\n\n\t/* Backtrace vector, used for calls to prof_backtrace(). */\n\tvoid\t\t\t*vec[PROF_BT_MAX];\n};\ntypedef rb_tree(prof_tdata_t) prof_tdata_tree_t;\n\nstruct prof_recent_s {\n\tnstime_t alloc_time;\n\tnstime_t dalloc_time;\n\n\tql_elm(prof_recent_t) link;\n\tsize_t size;\n\tsize_t usize;\n\tatomic_p_t alloc_edata; /* NULL means allocation has been freed. */\n\tprof_tctx_t *alloc_tctx;\n\tprof_tctx_t *dalloc_tctx;\n};\n\n#endif /* JEMALLOC_INTERNAL_PROF_STRUCTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_sys.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_SYS_H\n#define JEMALLOC_INTERNAL_PROF_SYS_H\n\nextern malloc_mutex_t prof_dump_filename_mtx;\nextern base_t *prof_base;\n\nvoid bt_init(prof_bt_t *bt, void **vec);\nvoid prof_backtrace(tsd_t *tsd, prof_bt_t *bt);\nvoid prof_hooks_init();\nvoid prof_unwind_init();\nvoid prof_sys_thread_name_fetch(tsd_t *tsd);\nint prof_getpid(void);\nvoid prof_get_default_filename(tsdn_t *tsdn, char *filename, uint64_t ind);\nbool prof_prefix_set(tsdn_t *tsdn, const char *prefix);\nvoid prof_fdump_impl(tsd_t *tsd);\nvoid prof_idump_impl(tsd_t *tsd);\nbool prof_mdump_impl(tsd_t *tsd, const char *filename);\nvoid prof_gdump_impl(tsd_t *tsd);\n\n/* Used in unit tests. */\ntypedef int (prof_sys_thread_name_read_t)(char *buf, size_t limit);\nextern prof_sys_thread_name_read_t *JET_MUTABLE prof_sys_thread_name_read;\ntypedef int (prof_dump_open_file_t)(const char *, int);\nextern prof_dump_open_file_t *JET_MUTABLE prof_dump_open_file;\ntypedef ssize_t (prof_dump_write_file_t)(int, const void *, size_t);\nextern prof_dump_write_file_t *JET_MUTABLE prof_dump_write_file;\ntypedef int (prof_dump_open_maps_t)();\nextern prof_dump_open_maps_t *JET_MUTABLE prof_dump_open_maps;\n\n#endif /* JEMALLOC_INTERNAL_PROF_SYS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/prof_types.h", "content": "#ifndef JEMALLOC_INTERNAL_PROF_TYPES_H\n#define JEMALLOC_INTERNAL_PROF_TYPES_H\n\ntypedef struct prof_bt_s prof_bt_t;\ntypedef struct prof_cnt_s prof_cnt_t;\ntypedef struct prof_tctx_s prof_tctx_t;\ntypedef struct prof_info_s prof_info_t;\ntypedef struct prof_gctx_s prof_gctx_t;\ntypedef struct prof_tdata_s prof_tdata_t;\ntypedef struct prof_recent_s prof_recent_t;\n\n/* Option defaults. */\n#ifdef JEMALLOC_PROF\n# define PROF_PREFIX_DEFAULT\t\t\"jeprof\"\n#else\n# define PROF_PREFIX_DEFAULT\t\t\"\"\n#endif\n#define LG_PROF_SAMPLE_DEFAULT\t\t19\n#define LG_PROF_INTERVAL_DEFAULT\t-1\n\n/*\n * Hard limit on stack backtrace depth. The version of prof_backtrace() that\n * is based on __builtin_return_address() necessarily has a hard-coded number\n * of backtrace frame handlers, and should be kept in sync with this setting.\n */\n#define PROF_BT_MAX\t\t\t128\n\n/* Initial hash table size. */\n#define PROF_CKH_MINITEMS\t\t64\n\n/* Size of memory buffer to use when writing dump files. */\n#ifndef JEMALLOC_PROF\n/* Minimize memory bloat for non-prof builds. */\n# define PROF_DUMP_BUFSIZE\t\t1\n#elif defined(JEMALLOC_DEBUG)\n/* Use a small buffer size in debug build, mainly to facilitate testing. */\n# define PROF_DUMP_BUFSIZE\t\t16\n#else\n# define PROF_DUMP_BUFSIZE\t\t65536\n#endif\n\n/* Size of size class related tables */\n#ifdef JEMALLOC_PROF\n# define PROF_SC_NSIZES\t\tSC_NSIZES\n#else\n/* Minimize memory bloat for non-prof builds. */\n# define PROF_SC_NSIZES\t\t1\n#endif\n\n/* Size of stack-allocated buffer used by prof_printf(). */\n#define PROF_PRINTF_BUFSIZE\t\t128\n\n/*\n * Number of mutexes shared among all gctx's. No space is allocated for these\n * unless profiling is enabled, so it's okay to over-provision.\n */\n#define PROF_NCTX_LOCKS\t\t\t1024\n\n/*\n * Number of mutexes shared among all tdata's. No space is allocated for these\n * unless profiling is enabled, so it's okay to over-provision.\n */\n#define PROF_NTDATA_LOCKS\t\t256\n\n/* Minimize memory bloat for non-prof builds. */\n#ifdef JEMALLOC_PROF\n#define PROF_DUMP_FILENAME_LEN (PATH_MAX + 1)\n#else\n#define PROF_DUMP_FILENAME_LEN 1\n#endif\n\n/* Default number of recent allocations to record. */\n#define PROF_RECENT_ALLOC_MAX_DEFAULT 0\n\n#endif /* JEMALLOC_INTERNAL_PROF_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/psset.h", "content": "#ifndef JEMALLOC_INTERNAL_PSSET_H\n#define JEMALLOC_INTERNAL_PSSET_H\n\n#include \"jemalloc/internal/hpdata.h\"\n\n/*\n * A page-slab set. What the eset is to PAC, the psset is to HPA. It maintains\n * a collection of page-slabs (the intent being that they are backed by\n * hugepages, or at least could be), and handles allocation and deallocation\n * requests.\n */\n\n/*\n * One more than the maximum pszind_t we will serve out of the HPA.\n * Practically, we expect only the first few to be actually used. This\n * corresponds to a maximum size of of 512MB on systems with 4k pages and\n * SC_NGROUP == 4, which is already an unreasonably large maximum. Morally, you\n * can think of this as being SC_NPSIZES, but there's no sense in wasting that\n * much space in the arena, making bitmaps that much larger, etc.\n */\n#define PSSET_NPSIZES 64\n\n/*\n * We keep two purge lists per page size class; one for hugified hpdatas (at\n * index 2*pszind), and one for the non-hugified hpdatas (at index 2*pszind +\n * 1). This lets us implement a preference for purging non-hugified hpdatas\n * among similarly-dirty ones.\n * We reserve the last two indices for empty slabs, in that case purging\n * hugified ones (which are definitionally all waste) before non-hugified ones\n * (i.e. reversing the order).\n */\n#define PSSET_NPURGE_LISTS (2 * PSSET_NPSIZES)\n\ntypedef struct psset_bin_stats_s psset_bin_stats_t;\nstruct psset_bin_stats_s {\n\t/* How many pageslabs are in this bin? */\n\tsize_t npageslabs;\n\t/* Of them, how many pages are active? */\n\tsize_t nactive;\n\t/* And how many are dirty? */\n\tsize_t ndirty;\n};\n\ntypedef struct psset_stats_s psset_stats_t;\nstruct psset_stats_s {\n\t/*\n\t * The second index is huge stats; nonfull_slabs[pszind][0] contains\n\t * stats for the non-huge slabs in bucket pszind, while\n\t * nonfull_slabs[pszind][1] contains stats for the huge slabs.\n\t */\n\tpsset_bin_stats_t nonfull_slabs[PSSET_NPSIZES][2];\n\n\t/*\n\t * Full slabs don't live in any edata heap, but we still track their\n\t * stats.\n\t */\n\tpsset_bin_stats_t full_slabs[2];\n\n\t/* Empty slabs are similar. */\n\tpsset_bin_stats_t empty_slabs[2];\n};\n\ntypedef struct psset_s psset_t;\nstruct psset_s {\n\t/*\n\t * The pageslabs, quantized by the size class of the largest contiguous\n\t * free run of pages in a pageslab.\n\t */\n\thpdata_age_heap_t pageslabs[PSSET_NPSIZES];\n\t/* Bitmap for which set bits correspond to non-empty heaps. */\n\tfb_group_t pageslab_bitmap[FB_NGROUPS(PSSET_NPSIZES)];\n\t/*\n\t * The sum of all bin stats in stats. This lets us quickly answer\n\t * queries for the number of dirty, active, and retained pages in the\n\t * entire set.\n\t */\n\tpsset_bin_stats_t merged_stats;\n\tpsset_stats_t stats;\n\t/*\n\t * Slabs with no active allocations, but which are allowed to serve new\n\t * allocations.\n\t */\n\thpdata_empty_list_t empty;\n\t/*\n\t * Slabs which are available to be purged, ordered by how much we want\n\t * to purge them (with later indices indicating slabs we want to purge\n\t * more).\n\t */\n\thpdata_purge_list_t to_purge[PSSET_NPURGE_LISTS];\n\t/* Bitmap for which set bits correspond to non-empty purge lists. */\n\tfb_group_t purge_bitmap[FB_NGROUPS(PSSET_NPURGE_LISTS)];\n\t/* Slabs which are available to be hugified. */\n\thpdata_hugify_list_t to_hugify;\n};\n\nvoid psset_init(psset_t *psset);\nvoid psset_stats_accum(psset_stats_t *dst, psset_stats_t *src);\n\n/*\n * Begin or end updating the given pageslab's metadata. While the pageslab is\n * being updated, it won't be returned from psset_fit calls.\n */\nvoid psset_update_begin(psset_t *psset, hpdata_t *ps);\nvoid psset_update_end(psset_t *psset, hpdata_t *ps);\n\n/* Analogous to the eset_fit; pick a hpdata to serve the request. */\nhpdata_t *psset_pick_alloc(psset_t *psset, size_t size);\n/* Pick one to purge. */\nhpdata_t *psset_pick_purge(psset_t *psset);\n/* Pick one to hugify. */\nhpdata_t *psset_pick_hugify(psset_t *psset);\n\nvoid psset_insert(psset_t *psset, hpdata_t *ps);\nvoid psset_remove(psset_t *psset, hpdata_t *ps);\n\nstatic inline size_t\npsset_npageslabs(psset_t *psset) {\n\treturn psset->merged_stats.npageslabs;\n}\n\nstatic inline size_t\npsset_nactive(psset_t *psset) {\n\treturn psset->merged_stats.nactive;\n}\n\nstatic inline size_t\npsset_ndirty(psset_t *psset) {\n\treturn psset->merged_stats.ndirty;\n}\n\n#endif /* JEMALLOC_INTERNAL_PSSET_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/public_namespace.sh", "content": "#!/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})\"\ndone\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/public_unnamespace.sh", "content": "#!/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", "content": "#ifndef JEMALLOC_INTERNAL_QL_H\n#define JEMALLOC_INTERNAL_QL_H\n\n#include \"jemalloc/internal/qr.h\"\n\n/*\n * A linked-list implementation.\n *\n * This is built on top of the ring implementation, but that can be viewed as an\n * implementation detail (i.e. trying to advance past the tail of the list\n * doesn't wrap around).\n *\n * You define a struct like so:\n * typedef strucy my_s my_t;\n * struct my_s {\n * int data;\n * ql_elm(my_t) my_link;\n * };\n *\n * // We wobble between \"list\" and \"head\" for this type; we're now mostly\n * // heading towards \"list\".\n * typedef ql_head(my_t) my_list_t;\n *\n * You then pass a my_list_t * for a_head arguments, a my_t * for a_elm\n * arguments, the token \"my_link\" for a_field arguments, and the token \"my_t\"\n * for a_type arguments.\n */\n\n/* List definitions. */\n#define ql_head(a_type)\t\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n\ta_type *qlh_first;\t\t\t\t\t\t\\\n}\n\n/* Static initializer for an empty list. */\n#define ql_head_initializer(a_head) {NULL}\n\n/* The field definition. */\n#define ql_elm(a_type)\tqr(a_type)\n\n/* A pointer to the first element in the list, or NULL if the list is empty. */\n#define ql_first(a_head) ((a_head)->qlh_first)\n\n/* Dynamically initializes a list. */\n#define ql_new(a_head) do {\t\t\t\t\t\t\\\n\tql_first(a_head) = NULL;\t\t\t\t\t\\\n} while (0)\n\n/*\n * Sets dest to be the contents of src (overwriting any elements there), leaving\n * src empty.\n */\n#define ql_move(a_head_dest, a_head_src) do {\t\t\t\t\\\n\tql_first(a_head_dest) = ql_first(a_head_src);\t\t\t\\\n\tql_new(a_head_src);\t\t\t\t\t\t\\\n} while (0)\n\n/* True if the list is empty, otherwise false. */\n#define ql_empty(a_head) (ql_first(a_head) == NULL)\n\n/*\n * Initializes a ql_elm. Must be called even if the field is about to be\n * overwritten.\n */\n#define ql_elm_new(a_elm, a_field) qr_new((a_elm), a_field)\n\n/*\n * Obtains the last item in the list.\n */\n#define ql_last(a_head, a_field)\t\t\t\t\t\\\n\t(ql_empty(a_head) ? NULL : qr_prev(ql_first(a_head), a_field))\n\n/*\n * Gets a pointer to the next/prev element in the list. Trying to advance past\n * the end or retreat before the beginning of the list returns NULL.\n */\n#define ql_next(a_head, a_elm, a_field)\t\t\t\t\t\\\n\t((ql_last(a_head, a_field) != (a_elm))\t\t\t\t\\\n\t ? qr_next((a_elm), a_field)\t: NULL)\n#define ql_prev(a_head, a_elm, a_field)\t\t\t\t\t\\\n\t((ql_first(a_head) != (a_elm)) ? qr_prev((a_elm), a_field)\t\\\n\t\t\t\t : NULL)\n\n/* Inserts a_elm before a_qlelm in the list. */\n#define ql_before_insert(a_head, a_qlelm, a_elm, a_field) do {\t\t\\\n\tqr_before_insert((a_qlelm), (a_elm), a_field);\t\t\t\\\n\tif (ql_first(a_head) == (a_qlelm)) {\t\t\t\t\\\n\t\tql_first(a_head) = (a_elm);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Inserts a_elm after a_qlelm in the list. */\n#define ql_after_insert(a_qlelm, a_elm, a_field)\t\t\t\\\n\tqr_after_insert((a_qlelm), (a_elm), a_field)\n\n/* Inserts a_elm as the first item in the list. */\n#define ql_head_insert(a_head, a_elm, a_field) do {\t\t\t\\\n\tif (!ql_empty(a_head)) {\t\t\t\t\t\\\n\t\tqr_before_insert(ql_first(a_head), (a_elm), a_field);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tql_first(a_head) = (a_elm);\t\t\t\t\t\\\n} while (0)\n\n/* Inserts a_elm as the last item in the list. */\n#define ql_tail_insert(a_head, a_elm, a_field) do {\t\t\t\\\n\tif (!ql_empty(a_head)) {\t\t\t\t\t\\\n\t\tqr_before_insert(ql_first(a_head), (a_elm), a_field);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tql_first(a_head) = qr_next((a_elm), a_field);\t\t\t\\\n} while (0)\n\n/*\n * Given lists a = [a_1, ..., a_n] and [b_1, ..., b_n], results in:\n * a = [a1, ..., a_n, b_1, ..., b_n] and b = [].\n */\n#define ql_concat(a_head_a, a_head_b, a_field) do {\t\t\t\\\n\tif (ql_empty(a_head_a)) {\t\t\t\t\t\\\n\t\tql_move(a_head_a, a_head_b);\t\t\t\t\\\n\t} else if (!ql_empty(a_head_b)) {\t\t\t\t\\\n\t\tqr_meld(ql_first(a_head_a), ql_first(a_head_b),\t\t\\\n\t\t a_field);\t\t\t\t\t\t\\\n\t\tql_new(a_head_b);\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Removes a_elm from the list. */\n#define ql_remove(a_head, a_elm, a_field) do {\t\t\t\t\\\n\tif (ql_first(a_head) == (a_elm)) {\t\t\t\t\\\n\t\tql_first(a_head) = qr_next(ql_first(a_head), a_field);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (ql_first(a_head) != (a_elm)) {\t\t\t\t\\\n\t\tqr_remove((a_elm), a_field);\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tql_new(a_head);\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Removes the first item in the list. */\n#define ql_head_remove(a_head, a_type, a_field) do {\t\t\t\\\n\ta_type *t = ql_first(a_head);\t\t\t\t\t\\\n\tql_remove((a_head), t, a_field);\t\t\t\t\\\n} while (0)\n\n/* Removes the last item in the list. */\n#define ql_tail_remove(a_head, a_type, a_field) do {\t\t\t\\\n\ta_type *t = ql_last(a_head, a_field);\t\t\t\t\\\n\tql_remove((a_head), t, a_field);\t\t\t\t\\\n} while (0)\n\n/*\n * Given a = [a_1, a_2, ..., a_n-1, a_n, a_n+1, ...],\n * ql_split(a, a_n, b, some_field) results in\n * a = [a_1, a_2, ..., a_n-1]\n * and replaces b's contents with:\n * b = [a_n, a_n+1, ...]\n */\n#define ql_split(a_head_a, a_elm, a_head_b, a_field) do {\t\t\\\n\tif (ql_first(a_head_a) == (a_elm)) {\t\t\t\t\\\n\t\tql_move(a_head_b, a_head_a);\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tqr_split(ql_first(a_head_a), (a_elm), a_field);\t\t\\\n\t\tql_first(a_head_b) = (a_elm);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/*\n * An optimized version of:\n *\ta_type *t = ql_first(a_head);\n *\tql_remove((a_head), t, a_field);\n *\tql_tail_insert((a_head), t, a_field);\n */\n#define ql_rotate(a_head, a_field) do {\t\t\t\t\t\\\n\tql_first(a_head) = qr_next(ql_first(a_head), a_field);\t\t\\\n} while (0)\n\n/*\n * Helper macro to iterate over each element in a list in order, starting from\n * the head (or in reverse order, starting from the tail). The usage is\n * (assuming my_t and my_list_t defined as above).\n *\n * int sum(my_list_t *list) {\n * int sum = 0;\n * my_t *iter;\n * ql_foreach(iter, list, link) {\n * sum += iter->data;\n * }\n * return sum;\n * }\n */\n\n#define ql_foreach(a_var, a_head, a_field)\t\t\t\t\\\n\tqr_foreach((a_var), ql_first(a_head), a_field)\n\n#define ql_reverse_foreach(a_var, a_head, a_field)\t\t\t\\\n\tqr_reverse_foreach((a_var), ql_first(a_head), a_field)\n\n#endif /* JEMALLOC_INTERNAL_QL_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/qr.h", "content": "#ifndef JEMALLOC_INTERNAL_QR_H\n#define JEMALLOC_INTERNAL_QR_H\n\n/*\n * A ring implementation based on an embedded circular doubly-linked list.\n *\n * You define your struct like so:\n *\n * typedef struct my_s my_t;\n * struct my_s {\n * int data;\n * qr(my_t) my_link;\n * };\n *\n * And then pass a my_t * into macros for a_qr arguments, and the token\n * \"my_link\" into a_field fields.\n */\n\n/* Ring definitions. */\n#define qr(a_type)\t\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n\ta_type\t*qre_next;\t\t\t\t\t\t\\\n\ta_type\t*qre_prev;\t\t\t\t\t\t\\\n}\n\n/*\n * Initialize a qr link. Every link must be initialized before being used, even\n * if that initialization is going to be immediately overwritten (say, by being\n * passed into an insertion macro).\n */\n#define qr_new(a_qr, a_field) do {\t\t\t\t\t\\\n\t(a_qr)->a_field.qre_next = (a_qr);\t\t\t\t\\\n\t(a_qr)->a_field.qre_prev = (a_qr);\t\t\t\t\\\n} while (0)\n\n/*\n * Go forwards or backwards in the ring. Note that (the ring being circular), this\n * always succeeds -- you just keep looping around and around the ring if you\n * chase pointers without end.\n */\n#define qr_next(a_qr, a_field) ((a_qr)->a_field.qre_next)\n#define qr_prev(a_qr, a_field) ((a_qr)->a_field.qre_prev)\n\n/*\n * Given two rings:\n * a -> a_1 -> ... -> a_n --\n * ^ |\n * |------------------------\n *\n * b -> b_1 -> ... -> b_n --\n * ^ |\n * |------------------------\n *\n * Results in the ring:\n * a -> a_1 -> ... -> a_n -> b -> b_1 -> ... -> b_n --\n * ^ |\n * |-------------------------------------------------|\n *\n * a_qr_a can directly be a qr_next() macro, but a_qr_b cannot.\n */\n#define qr_meld(a_qr_a, a_qr_b, a_field) do {\t\t\t\t\\\n\t(a_qr_b)->a_field.qre_prev->a_field.qre_next =\t\t\t\\\n\t (a_qr_a)->a_field.qre_prev;\t\t\t\t\t\\\n\t(a_qr_a)->a_field.qre_prev = (a_qr_b)->a_field.qre_prev;\t\\\n\t(a_qr_b)->a_field.qre_prev =\t\t\t\t\t\\\n\t (a_qr_b)->a_field.qre_prev->a_field.qre_next;\t\t\\\n\t(a_qr_a)->a_field.qre_prev->a_field.qre_next = (a_qr_a);\t\\\n\t(a_qr_b)->a_field.qre_prev->a_field.qre_next = (a_qr_b);\t\\\n} while (0)\n\n/*\n * Logically, this is just a meld. The intent, though, is that a_qrelm is a\n * single-element ring, so that \"before\" has a more obvious interpretation than\n * meld.\n */\n#define qr_before_insert(a_qrelm, a_qr, a_field)\t\t\t\\\n\tqr_meld((a_qrelm), (a_qr), a_field)\n\n/* Ditto, but inserting after rather than before. */\n#define qr_after_insert(a_qrelm, a_qr, a_field)\t\t\t\t\\\n\tqr_before_insert(qr_next(a_qrelm, a_field), (a_qr), a_field)\n\n/*\n * Inverts meld; given the ring:\n * a -> a_1 -> ... -> a_n -> b -> b_1 -> ... -> b_n --\n * ^ |\n * |-------------------------------------------------|\n *\n * Results in two rings:\n * a -> a_1 -> ... -> a_n --\n * ^ |\n * |------------------------\n *\n * b -> b_1 -> ... -> b_n --\n * ^ |\n * |------------------------\n *\n * qr_meld() and qr_split() are functionally equivalent, so there's no need to\n * have two copies of the code.\n */\n#define qr_split(a_qr_a, a_qr_b, a_field)\t\t\t\t\\\n\tqr_meld((a_qr_a), (a_qr_b), a_field)\n\n/*\n * Splits off a_qr from the rest of its ring, so that it becomes a\n * single-element ring.\n */\n#define qr_remove(a_qr, a_field)\t\t\t\t\t\\\n\tqr_split(qr_next(a_qr, a_field), (a_qr), a_field)\n\n/*\n * Helper macro to iterate over each element in a ring exactly once, starting\n * with a_qr. The usage is (assuming my_t defined as above):\n *\n * int sum(my_t *item) {\n * int sum = 0;\n * my_t *iter;\n * qr_foreach(iter, item, link) {\n * sum += iter->data;\n * }\n * return sum;\n * }\n */\n#define qr_foreach(var, a_qr, a_field)\t\t\t\t\t\\\n\tfor ((var) = (a_qr);\t\t\t\t\t\t\\\n\t (var) != NULL;\t\t\t\t\t\t\\\n\t (var) = (((var)->a_field.qre_next != (a_qr))\t\t\\\n\t ? (var)->a_field.qre_next : NULL))\n\n/*\n * The same (and with the same usage) as qr_foreach, but in the opposite order,\n * ending with a_qr.\n */\n#define qr_reverse_foreach(var, a_qr, a_field)\t\t\t\t\\\n\tfor ((var) = ((a_qr) != NULL) ? qr_prev(a_qr, a_field) : NULL;\t\\\n\t (var) != NULL;\t\t\t\t\t\t\\\n\t (var) = (((var) != (a_qr))\t\t\t\t\t\\\n\t ? (var)->a_field.qre_prev : NULL))\n\n#endif /* JEMALLOC_INTERNAL_QR_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/quantum.h", "content": "#ifndef JEMALLOC_INTERNAL_QUANTUM_H\n#define JEMALLOC_INTERNAL_QUANTUM_H\n\n/*\n * Minimum allocation alignment is 2^LG_QUANTUM bytes (ignoring tiny size\n * classes).\n */\n#ifndef LG_QUANTUM\n# if (defined(__i386__) || defined(_M_IX86))\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __ia64__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __alpha__\n# define LG_QUANTUM\t\t4\n# endif\n# if (defined(__sparc64__) || defined(__sparcv9) || defined(__sparc_v9__))\n# define LG_QUANTUM\t\t4\n# endif\n# if (defined(__amd64__) || defined(__x86_64__) || defined(_M_X64))\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __arm__\n# define LG_QUANTUM\t\t3\n# endif\n# ifdef __aarch64__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __hppa__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __loongarch__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __m68k__\n# define LG_QUANTUM\t\t3\n# endif\n# ifdef __mips__\n# if defined(__mips_n32) || defined(__mips_n64)\n# define LG_QUANTUM\t\t4\n# else\n# define LG_QUANTUM\t\t3\n# endif\n# endif\n# ifdef __nios2__\n# define LG_QUANTUM\t\t3\n# endif\n# ifdef __or1k__\n# define LG_QUANTUM\t\t3\n# endif\n# ifdef __powerpc__\n# define LG_QUANTUM\t\t4\n# endif\n# if defined(__riscv) || defined(__riscv__)\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __s390__\n# define LG_QUANTUM\t\t4\n# endif\n# if (defined (__SH3E__) || defined(__SH4_SINGLE__) || defined(__SH4__) || \\\n\tdefined(__SH4_SINGLE_ONLY__))\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __tile__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __le32__\n# define LG_QUANTUM\t\t4\n# endif\n# ifdef __arc__\n# define LG_QUANTUM\t\t3\n# endif\n# ifndef LG_QUANTUM\n# error \"Unknown minimum alignment for architecture; specify via \"\n\t \"--with-lg-quantum\"\n# endif\n#endif\n\n#define QUANTUM\t\t\t((size_t)(1U << LG_QUANTUM))\n#define QUANTUM_MASK\t\t(QUANTUM - 1)\n\n/* Return the smallest quantum multiple that is >= a. */\n#define QUANTUM_CEILING(a)\t\t\t\t\t\t\\\n\t(((a) + QUANTUM_MASK) & ~QUANTUM_MASK)\n\n#endif /* JEMALLOC_INTERNAL_QUANTUM_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/rb.h", "content": "#ifndef JEMALLOC_INTERNAL_RB_H\n#define JEMALLOC_INTERNAL_RB_H\n\n/*-\n *******************************************************************************\n *\n * cpp macro implementation of left-leaning 2-3 red-black trees. Parent\n * pointers are not used, and color bits are stored in the least significant\n * bit of right-child pointers (if RB_COMPACT is defined), thus making node\n * linkage as compact as is possible for red-black trees.\n *\n * Usage:\n *\n * #include \n * #include \n * #define NDEBUG // (Optional, see assert(3).)\n * #include \n * #define RB_COMPACT // (Optional, embed color bits in right-child pointers.)\n * #include \n * ...\n *\n *******************************************************************************\n */\n\n#ifndef __PGI\n#define RB_COMPACT\n#endif\n\n/*\n * Each node in the RB tree consumes at least 1 byte of space (for the linkage\n * if nothing else, so there are a maximum of sizeof(void *) << 3 rb tree nodes\n * in any process (and thus, at most sizeof(void *) << 3 nodes in any rb tree).\n * The choice of algorithm bounds the depth of a tree to twice the binary log of\n * the number of elements in the tree; the following bound follows.\n */\n#define RB_MAX_DEPTH (sizeof(void *) << 4)\n\n#ifdef RB_COMPACT\n/* Node structure. */\n#define rb_node(a_type)\t\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n a_type *rbn_left;\t\t\t\t\t\t\t\\\n a_type *rbn_right_red;\t\t\t\t\t\t\\\n}\n#else\n#define rb_node(a_type)\t\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n a_type *rbn_left;\t\t\t\t\t\t\t\\\n a_type *rbn_right;\t\t\t\t\t\t\t\\\n bool rbn_red;\t\t\t\t\t\t\t\\\n}\n#endif\n\n/* Root structure. */\n#define rb_tree(a_type)\t\t\t\t\t\t\t\\\nstruct {\t\t\t\t\t\t\t\t\\\n a_type *rbt_root;\t\t\t\t\t\t\t\\\n}\n\n/* Left accessors. */\n#define rbtn_left_get(a_type, a_field, a_node)\t\t\t\t\\\n ((a_node)->a_field.rbn_left)\n#define rbtn_left_set(a_type, a_field, a_node, a_left) do {\t\t\\\n (a_node)->a_field.rbn_left = a_left;\t\t\t\t\\\n} while (0)\n\n#ifdef RB_COMPACT\n/* Right accessors. */\n#define rbtn_right_get(a_type, a_field, a_node)\t\t\t\t\\\n ((a_type *) (((intptr_t) (a_node)->a_field.rbn_right_red)\t\t\\\n & ((ssize_t)-2)))\n#define rbtn_right_set(a_type, a_field, a_node, a_right) do {\t\t\\\n (a_node)->a_field.rbn_right_red = (a_type *) (((uintptr_t) a_right)\t\\\n | (((uintptr_t) (a_node)->a_field.rbn_right_red) & ((size_t)1)));\t\\\n} while (0)\n\n/* Color accessors. */\n#define rbtn_red_get(a_type, a_field, a_node)\t\t\t\t\\\n ((bool) (((uintptr_t) (a_node)->a_field.rbn_right_red)\t\t\\\n & ((size_t)1)))\n#define rbtn_color_set(a_type, a_field, a_node, a_red) do {\t\t\\\n (a_node)->a_field.rbn_right_red = (a_type *) ((((intptr_t)\t\t\\\n (a_node)->a_field.rbn_right_red) & ((ssize_t)-2))\t\t\t\\\n | ((ssize_t)a_red));\t\t\t\t\t\t\\\n} while (0)\n#define rbtn_red_set(a_type, a_field, a_node) do {\t\t\t\\\n (a_node)->a_field.rbn_right_red = (a_type *) (((uintptr_t)\t\t\\\n (a_node)->a_field.rbn_right_red) | ((size_t)1));\t\t\t\\\n} while (0)\n#define rbtn_black_set(a_type, a_field, a_node) do {\t\t\t\\\n (a_node)->a_field.rbn_right_red = (a_type *) (((intptr_t)\t\t\\\n (a_node)->a_field.rbn_right_red) & ((ssize_t)-2));\t\t\\\n} while (0)\n\n/* Node initializer. */\n#define rbt_node_new(a_type, a_field, a_rbt, a_node) do {\t\t\\\n /* Bookkeeping bit cannot be used by node pointer. */\t\t\\\n assert(((uintptr_t)(a_node) & 0x1) == 0);\t\t\t\t\\\n rbtn_left_set(a_type, a_field, (a_node), NULL);\t\\\n rbtn_right_set(a_type, a_field, (a_node), NULL);\t\\\n rbtn_red_set(a_type, a_field, (a_node));\t\t\t\t\\\n} while (0)\n#else\n/* Right accessors. */\n#define rbtn_right_get(a_type, a_field, a_node)\t\t\t\t\\\n ((a_node)->a_field.rbn_right)\n#define rbtn_right_set(a_type, a_field, a_node, a_right) do {\t\t\\\n (a_node)->a_field.rbn_right = a_right;\t\t\t\t\\\n} while (0)\n\n/* Color accessors. */\n#define rbtn_red_get(a_type, a_field, a_node)\t\t\t\t\\\n ((a_node)->a_field.rbn_red)\n#define rbtn_color_set(a_type, a_field, a_node, a_red) do {\t\t\\\n (a_node)->a_field.rbn_red = (a_red);\t\t\t\t\\\n} while (0)\n#define rbtn_red_set(a_type, a_field, a_node) do {\t\t\t\\\n (a_node)->a_field.rbn_red = true;\t\t\t\t\t\\\n} while (0)\n#define rbtn_black_set(a_type, a_field, a_node) do {\t\t\t\\\n (a_node)->a_field.rbn_red = false;\t\t\t\t\t\\\n} while (0)\n\n/* Node initializer. */\n#define rbt_node_new(a_type, a_field, a_rbt, a_node) do {\t\t\\\n rbtn_left_set(a_type, a_field, (a_node), NULL);\t\\\n rbtn_right_set(a_type, a_field, (a_node), NULL);\t\\\n rbtn_red_set(a_type, a_field, (a_node));\t\t\t\t\\\n} while (0)\n#endif\n\n/* Tree initializer. */\n#define rb_new(a_type, a_field, a_rbt) do {\t\t\t\t\\\n (a_rbt)->rbt_root = NULL;\t\t\t\t\t\t\\\n} while (0)\n\n/* Internal utility macros. */\n#define rbtn_first(a_type, a_field, a_rbt, a_root, r_node) do {\t\t\\\n (r_node) = (a_root);\t\t\t\t\t\t\\\n if ((r_node) != NULL) {\t\t\t\t\t\t\\\n\tfor (;\t\t\t\t\t\t\t\t\\\n\t rbtn_left_get(a_type, a_field, (r_node)) != NULL;\t\t\\\n\t (r_node) = rbtn_left_get(a_type, a_field, (r_node))) {\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define rbtn_last(a_type, a_field, a_rbt, a_root, r_node) do {\t\t\\\n (r_node) = (a_root);\t\t\t\t\t\t\\\n if ((r_node) != NULL) {\t\t\t\t\t\t\\\n\tfor (; rbtn_right_get(a_type, a_field, (r_node)) != NULL;\t\\\n\t (r_node) = rbtn_right_get(a_type, a_field, (r_node))) {\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define rbtn_rotate_left(a_type, a_field, a_node, r_node) do {\t\t\\\n (r_node) = rbtn_right_get(a_type, a_field, (a_node));\t\t\\\n rbtn_right_set(a_type, a_field, (a_node),\t\t\t\t\\\n rbtn_left_get(a_type, a_field, (r_node)));\t\t\t\\\n rbtn_left_set(a_type, a_field, (r_node), (a_node));\t\t\t\\\n} while (0)\n\n#define rbtn_rotate_right(a_type, a_field, a_node, r_node) do {\t\t\\\n (r_node) = rbtn_left_get(a_type, a_field, (a_node));\t\t\\\n rbtn_left_set(a_type, a_field, (a_node),\t\t\t\t\\\n rbtn_right_get(a_type, a_field, (r_node)));\t\t\t\\\n rbtn_right_set(a_type, a_field, (r_node), (a_node));\t\t\\\n} while (0)\n\n#define rb_summarized_only_false(...)\n#define rb_summarized_only_true(...) __VA_ARGS__\n#define rb_empty_summarize(a_node, a_lchild, a_rchild) false\n\n/*\n * The rb_proto() and rb_summarized_proto() macros generate function prototypes\n * that correspond to the functions generated by an equivalently parameterized\n * call to rb_gen() or rb_summarized_gen(), respectively.\n */\n\n#define rb_proto(a_attr, a_prefix, a_rbt_type, a_type)\t\t\t\\\n rb_proto_impl(a_attr, a_prefix, a_rbt_type, a_type, false)\n#define rb_summarized_proto(a_attr, a_prefix, a_rbt_type, a_type)\t\\\n rb_proto_impl(a_attr, a_prefix, a_rbt_type, a_type, true)\n#define rb_proto_impl(a_attr, a_prefix, a_rbt_type, a_type,\t\t\\\n a_is_summarized)\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##new(a_rbt_type *rbtree);\t\t\t\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##empty(a_rbt_type *rbtree);\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##first(a_rbt_type *rbtree);\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##last(a_rbt_type *rbtree);\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##next(a_rbt_type *rbtree, a_type *node);\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##prev(a_rbt_type *rbtree, a_type *node);\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##search(a_rbt_type *rbtree, const a_type *key);\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##nsearch(a_rbt_type *rbtree, const a_type *key);\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##psearch(a_rbt_type *rbtree, const a_type *key);\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##insert(a_rbt_type *rbtree, a_type *node);\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##remove(a_rbt_type *rbtree, a_type *node);\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter(a_rbt_type *rbtree, a_type *start, a_type *(*cb)(\t\\\n a_rbt_type *, a_type *, void *), void *arg);\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter(a_rbt_type *rbtree, a_type *start,\t\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg);\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##destroy(a_rbt_type *rbtree, void (*cb)(a_type *, void *),\t\\\n void *arg);\t\t\t\t\t\t\t\t\\\n/* Extended API */\t\t\t\t\t\t\t\\\nrb_summarized_only_##a_is_summarized(\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##update_summaries(a_rbt_type *rbtree, a_type *node);\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##empty_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##first_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##last_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##next_filtered(a_rbt_type *rbtree, a_type *node,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##prev_filtered(a_rbt_type *rbtree, a_type *node,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##search_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##nsearch_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##psearch_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_filtered(a_rbt_type *rbtree, a_type *start,\t\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_filtered(a_rbt_type *rbtree, a_type *start,\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx);\t\t\t\t\t\t\t\\\n)\n\n/*\n * The rb_gen() macro generates a type-specific red-black tree implementation,\n * based on the above cpp macros.\n * Arguments:\n *\n * a_attr:\n * Function attribute for generated functions (ex: static).\n * a_prefix:\n * Prefix for generated functions (ex: ex_).\n * a_rb_type:\n * Type for red-black tree data structure (ex: ex_t).\n * a_type:\n * Type for red-black tree node data structure (ex: ex_node_t).\n * a_field:\n * Name of red-black tree node linkage (ex: ex_link).\n * a_cmp:\n * Node comparison function name, with the following prototype:\n *\n * int a_cmp(a_type *a_node, a_type *a_other);\n * ^^^^^^\n * or a_key\n * Interpretation of comparison function return values:\n * -1 : a_node < a_other\n * 0 : a_node == a_other\n * 1 : a_node > a_other\n * In all cases, the a_node or a_key macro argument is the first argument to\n * the comparison function, which makes it possible to write comparison\n * functions that treat the first argument specially. a_cmp must be a total\n * order on values inserted into the tree -- duplicates are not allowed.\n *\n * Assuming the following setup:\n *\n * typedef struct ex_node_s ex_node_t;\n * struct ex_node_s {\n * rb_node(ex_node_t) ex_link;\n * };\n * typedef rb_tree(ex_node_t) ex_t;\n * rb_gen(static, ex_, ex_t, ex_node_t, ex_link, ex_cmp)\n *\n * The following API is generated:\n *\n * static void\n * ex_new(ex_t *tree);\n * Description: Initialize a red-black tree structure.\n * Args:\n * tree: Pointer to an uninitialized red-black tree object.\n *\n * static bool\n * ex_empty(ex_t *tree);\n * Description: Determine whether tree is empty.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * Ret: True if tree is empty, false otherwise.\n *\n * static ex_node_t *\n * ex_first(ex_t *tree);\n * static ex_node_t *\n * ex_last(ex_t *tree);\n * Description: Get the first/last node in tree.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * Ret: First/last node in tree, or NULL if tree is empty.\n *\n * static ex_node_t *\n * ex_next(ex_t *tree, ex_node_t *node);\n * static ex_node_t *\n * ex_prev(ex_t *tree, ex_node_t *node);\n * Description: Get node's successor/predecessor.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * node: A node in tree.\n * Ret: node's successor/predecessor in tree, or NULL if node is\n * last/first.\n *\n * static ex_node_t *\n * ex_search(ex_t *tree, const ex_node_t *key);\n * Description: Search for node that matches key.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * key : Search key.\n * Ret: Node in tree that matches key, or NULL if no match.\n *\n * static ex_node_t *\n * ex_nsearch(ex_t *tree, const ex_node_t *key);\n * static ex_node_t *\n * ex_psearch(ex_t *tree, const ex_node_t *key);\n * Description: Search for node that matches key. If no match is found,\n * return what would be key's successor/predecessor, were\n * key in tree.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * key : Search key.\n * Ret: Node in tree that matches key, or if no match, hypothetical node's\n * successor/predecessor (NULL if no successor/predecessor).\n *\n * static void\n * ex_insert(ex_t *tree, ex_node_t *node);\n * Description: Insert node into tree.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * node: Node to be inserted into tree.\n *\n * static void\n * ex_remove(ex_t *tree, ex_node_t *node);\n * Description: Remove node from tree.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * node: Node in tree to be removed.\n *\n * static ex_node_t *\n * ex_iter(ex_t *tree, ex_node_t *start, ex_node_t *(*cb)(ex_t *,\n * ex_node_t *, void *), void *arg);\n * static ex_node_t *\n * ex_reverse_iter(ex_t *tree, ex_node_t *start, ex_node *(*cb)(ex_t *,\n * ex_node_t *, void *), void *arg);\n * Description: Iterate forward/backward over tree, starting at node. If\n * tree is modified, iteration must be immediately\n * terminated by the callback function that causes the\n * modification.\n * Args:\n * tree : Pointer to an initialized red-black tree object.\n * start: Node at which to start iteration, or NULL to start at\n * first/last node.\n * cb : Callback function, which is called for each node during\n * iteration. Under normal circumstances the callback function\n * should return NULL, which causes iteration to continue. If a\n * callback function returns non-NULL, iteration is immediately\n * terminated and the non-NULL return value is returned by the\n * iterator. This is useful for re-starting iteration after\n * modifying tree.\n * arg : Opaque pointer passed to cb().\n * Ret: NULL if iteration completed, or the non-NULL callback return value\n * that caused termination of the iteration.\n *\n * static void\n * ex_destroy(ex_t *tree, void (*cb)(ex_node_t *, void *), void *arg);\n * Description: Iterate over the tree with post-order traversal, remove\n * each node, and run the callback if non-null. This is\n * used for destroying a tree without paying the cost to\n * rebalance it. The tree must not be otherwise altered\n * during traversal.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * cb : Callback function, which, if non-null, is called for each node\n * during iteration. There is no way to stop iteration once it\n * has begun.\n * arg : Opaque pointer passed to cb().\n *\n * The rb_summarized_gen() macro generates all the functions above, but has an\n * expanded interface. In introduces the notion of summarizing subtrees, and of\n * filtering searches in the tree according to the information contained in\n * those summaries.\n * The extra macro argument is:\n * a_summarize:\n * Tree summarization function name, with the following prototype:\n *\n * bool a_summarize(a_type *a_node, const a_type *a_left_child,\n * const a_type *a_right_child);\n *\n * This function should update a_node with the summary of the subtree rooted\n * there, using the data contained in it and the summaries in a_left_child\n * and a_right_child. One or both of them may be NULL. When the tree\n * changes due to an insertion or removal, it updates the summaries of all\n * nodes whose subtrees have changed (always updating the summaries of\n * children before their parents). If the user alters a node in the tree in\n * a way that may change its summary, they can call the generated\n * update_summaries function to bubble up the summary changes to the root.\n * It should return true if the summary changed (or may have changed), and\n * false if it didn't (which will allow the implementation to terminate\n * \"bubbling up\" the summaries early).\n * As the parameter names indicate, the children are ordered as they are in\n * the tree, a_left_child, if it is not NULL, compares less than a_node,\n * which in turn compares less than a_right_child (if a_right_child is not\n * NULL).\n *\n * Using the same setup as above but replacing the macro with\n * rb_summarized_gen(static, ex_, ex_t, ex_node_t, ex_link, ex_cmp,\n * ex_summarize)\n *\n * Generates all the previous functions, but adds some more:\n *\n * static void\n * ex_update_summaries(ex_t *tree, ex_node_t *node);\n * Description: Recompute all summaries of ancestors of node.\n * Args:\n * tree: Pointer to an initialized red-black tree object.\n * node: The element of the tree whose summary may have changed.\n *\n * For each of ex_empty, ex_first, ex_last, ex_next, ex_prev, ex_search,\n * ex_nsearch, ex_psearch, ex_iter, and ex_reverse_iter, an additional function\n * is generated as well, with the suffix _filtered (e.g. ex_empty_filtered,\n * ex_first_filtered, etc.). These use the concept of a \"filter\"; a binary\n * property some node either satisfies or does not satisfy. Clever use of the\n * a_summary argument to rb_summarized_gen can allow efficient computation of\n * these predicates across whole subtrees of the tree.\n * The extended API functions accept three additional arguments after the\n * arguments to the corresponding non-extended equivalent.\n *\n * ex_fn(..., bool (*filter_node)(void *, ex_node_t *),\n * bool (*filter_subtree)(void *, ex_node_t *), void *filter_ctx);\n * filter_node : Returns true if the node passes the filter.\n * filter_subtree : Returns true if some node in the subtree rooted at\n * node passes the filter.\n * filter_ctx : A context argument passed to the filters.\n *\n * For a more concrete example of summarizing and filtering, suppose we're using\n * the red-black tree to track a set of integers:\n *\n * struct ex_node_s {\n * rb_node(ex_node_t) ex_link;\n * unsigned data;\n * };\n *\n * Suppose, for some application-specific reason, we want to be able to quickly\n * find numbers in the set which are divisible by large powers of 2 (say, for\n * aligned allocation purposes). We augment the node with a summary field:\n *\n * struct ex_node_s {\n * rb_node(ex_node_t) ex_link;\n * unsigned data;\n * unsigned max_subtree_ffs;\n * }\n *\n * and define our summarization function as follows:\n *\n * bool\n * ex_summarize(ex_node_t *node, const ex_node_t *lchild,\n * const ex_node_t *rchild) {\n * unsigned new_max_subtree_ffs = ffs(node->data);\n * if (lchild != NULL && lchild->max_subtree_ffs > new_max_subtree_ffs) {\n * new_max_subtree_ffs = lchild->max_subtree_ffs;\n * }\n * if (rchild != NULL && rchild->max_subtree_ffs > new_max_subtree_ffs) {\n * new_max_subtree_ffs = rchild->max_subtree_ffs;\n * }\n * bool changed = (node->max_subtree_ffs != new_max_subtree_ffs)\n * node->max_subtree_ffs = new_max_subtree_ffs;\n * // This could be \"return true\" without any correctness or big-O\n * // performance changes; but practically, precisely reporting summary\n * // changes reduces the amount of work that has to be done when \"bubbling\n * // up\" summary changes.\n * return changed;\n * }\n *\n * We can now implement our filter functions as follows:\n * bool\n * ex_filter_node(void *filter_ctx, ex_node_t *node) {\n * unsigned required_ffs = *(unsigned *)filter_ctx;\n * return ffs(node->data) >= required_ffs;\n * }\n * bool\n * ex_filter_subtree(void *filter_ctx, ex_node_t *node) {\n * unsigned required_ffs = *(unsigned *)filter_ctx;\n * return node->max_subtree_ffs >= required_ffs;\n * }\n *\n * We can now easily search for, e.g., the smallest integer in the set that's\n * divisible by 128:\n * ex_node_t *\n * find_div_128(ex_tree_t *tree) {\n * unsigned min_ffs = 7;\n * return ex_first_filtered(tree, &ex_filter_node, &ex_filter_subtree,\n * &min_ffs);\n * }\n *\n * We could with similar ease:\n * - Fnd the next multiple of 128 in the set that's larger than 12345 (with\n * ex_nsearch_filtered)\n * - Iterate over just those multiples of 64 that are in the set (with\n * ex_iter_filtered)\n * - Determine if the set contains any multiples of 1024 (with\n * ex_empty_filtered).\n *\n * Some possibly subtle API notes:\n * - The node argument to ex_next_filtered and ex_prev_filtered need not pass\n * the filter; it will find the next/prev node that passes the filter.\n * - ex_search_filtered will fail even for a node in the tree, if that node does\n * not pass the filter. ex_psearch_filtered and ex_nsearch_filtered behave\n * similarly; they may return a node larger/smaller than the key, even if a\n * node equivalent to the key is in the tree (but does not pass the filter).\n * - Similarly, if the start argument to a filtered iteration function does not\n * pass the filter, the callback won't be invoked on it.\n *\n * These should make sense after a moment's reflection; each post-condition is\n * the same as with the unfiltered version, with the added constraint that the\n * returned node must pass the filter.\n */\n#define rb_gen(a_attr, a_prefix, a_rbt_type, a_type, a_field, a_cmp)\t\\\n rb_gen_impl(a_attr, a_prefix, a_rbt_type, a_type, a_field, a_cmp,\t\\\n\trb_empty_summarize, false)\n#define rb_summarized_gen(a_attr, a_prefix, a_rbt_type, a_type,\t\t\\\n a_field, a_cmp, a_summarize)\t\t\t\t\t\\\n rb_gen_impl(a_attr, a_prefix, a_rbt_type, a_type, a_field, a_cmp,\t\\\n\ta_summarize, true)\n\n#define rb_gen_impl(a_attr, a_prefix, a_rbt_type, a_type,\t\t\\\n a_field, a_cmp, a_summarize, a_is_summarized)\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n a_type *node;\t\t\t\t\t\t\t\\\n int cmp;\t\t\t\t\t\t\t\t\\\n} a_prefix##path_entry_t;\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\na_prefix##summarize_range(a_prefix##path_entry_t *rfirst,\t\t\\\n a_prefix##path_entry_t *rlast) {\t\t\t\t\t\\\n while ((uintptr_t)rlast >= (uintptr_t)rfirst) {\t\t\t\\\n\ta_type *node = rlast->node;\t\t\t\t\t\\\n\t/* Avoid a warning when a_summarize is rb_empty_summarize. */\t\\\n\t(void)node;\t\t\t\t\t\t\t\\\n\tbool changed = a_summarize(node, rbtn_left_get(a_type, a_field,\t\\\n\t node), rbtn_right_get(a_type, a_field, node));\t\t\\\n\tif (!changed) {\t\t\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\trlast--;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n/* On the remove pathways, we sometimes swap the node being removed */\\\n/* and its first successor; in such cases we need to do two range */\\\n/* updates; one from the node to its (former) swapped successor, the */\\\n/* next from that successor to the root (with either allowed to */\\\n/* bail out early if appropriate. */\\\nstatic inline void\t\t\t\t\t\t\t\\\na_prefix##summarize_swapped_range(a_prefix##path_entry_t *rfirst,\t\\\n a_prefix##path_entry_t *rlast, a_prefix##path_entry_t *swap_loc) {\t\\\n\tif (swap_loc == NULL || rlast <= swap_loc) {\t\t\t\\\n\t\ta_prefix##summarize_range(rfirst, rlast);\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\ta_prefix##summarize_range(swap_loc + 1, rlast);\t\t\\\n\t\t(void)a_summarize(swap_loc->node,\t\t\t\\\n\t\t rbtn_left_get(a_type, a_field, swap_loc->node),\t\\\n\t\t rbtn_right_get(a_type, a_field, swap_loc->node));\t\\\n\t\ta_prefix##summarize_range(rfirst, swap_loc - 1);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##new(a_rbt_type *rbtree) {\t\t\t\t\t\\\n rb_new(a_type, a_field, rbtree);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##empty(a_rbt_type *rbtree) {\t\t\t\t\t\\\n return (rbtree->rbt_root == NULL);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##first(a_rbt_type *rbtree) {\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n rbtn_first(a_type, a_field, rbtree, rbtree->rbt_root, ret);\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##last(a_rbt_type *rbtree) {\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n rbtn_last(a_type, a_field, rbtree, rbtree->rbt_root, ret);\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##next(a_rbt_type *rbtree, a_type *node) {\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (rbtn_right_get(a_type, a_field, node) != NULL) {\t\t\\\n\trbtn_first(a_type, a_field, rbtree, rbtn_right_get(a_type,\t\\\n\t a_field, node), ret);\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *tnode = rbtree->rbt_root;\t\t\t\t\\\n\tassert(tnode != NULL);\t\t\t\t\t\t\\\n\tret = NULL;\t\t\t\t\t\t\t\\\n\twhile (true) {\t\t\t\t\t\t\t\\\n\t int cmp = (a_cmp)(node, tnode);\t\t\t\t\\\n\t if (cmp < 0) {\t\t\t\t\t\t\\\n\t\tret = tnode;\t\t\t\t\t\t\\\n\t\ttnode = rbtn_left_get(a_type, a_field, tnode);\t\t\\\n\t } else if (cmp > 0) {\t\t\t\t\t\\\n\t\ttnode = rbtn_right_get(a_type, a_field, tnode);\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t assert(tnode != NULL);\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##prev(a_rbt_type *rbtree, a_type *node) {\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (rbtn_left_get(a_type, a_field, node) != NULL) {\t\t\t\\\n\trbtn_last(a_type, a_field, rbtree, rbtn_left_get(a_type,\t\\\n\t a_field, node), ret);\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *tnode = rbtree->rbt_root;\t\t\t\t\\\n\tassert(tnode != NULL);\t\t\t\t\t\t\\\n\tret = NULL;\t\t\t\t\t\t\t\\\n\twhile (true) {\t\t\t\t\t\t\t\\\n\t int cmp = (a_cmp)(node, tnode);\t\t\t\t\\\n\t if (cmp < 0) {\t\t\t\t\t\t\\\n\t\ttnode = rbtn_left_get(a_type, a_field, tnode);\t\t\\\n\t } else if (cmp > 0) {\t\t\t\t\t\\\n\t\tret = tnode;\t\t\t\t\t\t\\\n\t\ttnode = rbtn_right_get(a_type, a_field, tnode);\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t assert(tnode != NULL);\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##search(a_rbt_type *rbtree, const a_type *key) {\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n int cmp;\t\t\t\t\t\t\t\t\\\n ret = rbtree->rbt_root;\t\t\t\t\t\t\\\n while (ret != NULL\t\t\t\t\t\t\t\\\n && (cmp = (a_cmp)(key, ret)) != 0) {\t\t\t\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t ret = rbtn_left_get(a_type, a_field, ret);\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t ret = rbtn_right_get(a_type, a_field, ret);\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##nsearch(a_rbt_type *rbtree, const a_type *key) {\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *tnode = rbtree->rbt_root;\t\t\t\t\t\\\n ret = NULL;\t\t\t\t\t\t\t\t\\\n while (tnode != NULL) {\t\t\t\t\t\t\\\n\tint cmp = (a_cmp)(key, tnode);\t\t\t\t\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t ret = tnode;\t\t\t\t\t\t\\\n\t tnode = rbtn_left_get(a_type, a_field, tnode);\t\t\\\n\t} else if (cmp > 0) {\t\t\t\t\t\t\\\n\t tnode = rbtn_right_get(a_type, a_field, tnode);\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t ret = tnode;\t\t\t\t\t\t\\\n\t break;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##psearch(a_rbt_type *rbtree, const a_type *key) {\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *tnode = rbtree->rbt_root;\t\t\t\t\t\\\n ret = NULL;\t\t\t\t\t\t\t\t\\\n while (tnode != NULL) {\t\t\t\t\t\t\\\n\tint cmp = (a_cmp)(key, tnode);\t\t\t\t\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t tnode = rbtn_left_get(a_type, a_field, tnode);\t\t\\\n\t} else if (cmp > 0) {\t\t\t\t\t\t\\\n\t ret = tnode;\t\t\t\t\t\t\\\n\t tnode = rbtn_right_get(a_type, a_field, tnode);\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t ret = tnode;\t\t\t\t\t\t\\\n\t break;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##insert(a_rbt_type *rbtree, a_type *node) {\t\t\t\\\n a_prefix##path_entry_t path[RB_MAX_DEPTH];\t\t\t\\\n a_prefix##path_entry_t *pathp;\t\t\t\t\t\\\n rbt_node_new(a_type, a_field, rbtree, node);\t\t\t\\\n /* Wind. */\t\t\t\t\t\t\t\t\\\n path->node = rbtree->rbt_root;\t\t\t\t\t\\\n for (pathp = path; pathp->node != NULL; pathp++) {\t\t\t\\\n\tint cmp = pathp->cmp = a_cmp(node, pathp->node);\t\t\\\n\tassert(cmp != 0);\t\t\t\t\t\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_left_get(a_type, a_field,\t\t\\\n\t pathp->node);\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_right_get(a_type, a_field,\t\t\\\n\t pathp->node);\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n pathp->node = node;\t\t\t\t\t\t\t\\\n /* A loop invariant we maintain is that all nodes with */\\\n /* out-of-date summaries live in path[0], path[1], ..., *pathp. */\\\n /* To maintain this, we have to summarize node, since we */\\\n /* decrement pathp before the first iteration. */\\\n assert(rbtn_left_get(a_type, a_field, node) == NULL);\t\t\\\n assert(rbtn_right_get(a_type, a_field, node) == NULL);\t\t\\\n (void)a_summarize(node, NULL, NULL);\t\t\t\t\\\n /* Unwind. */\t\t\t\t\t\t\t\\\n for (pathp--; (uintptr_t)pathp >= (uintptr_t)path; pathp--) {\t\\\n\ta_type *cnode = pathp->node;\t\t\t\t\t\\\n\tif (pathp->cmp < 0) {\t\t\t\t\t\t\\\n\t a_type *left = pathp[1].node;\t\t\t\t\\\n\t rbtn_left_set(a_type, a_field, cnode, left);\t\t\\\n\t if (rbtn_red_get(a_type, a_field, left)) {\t\t\t\\\n\t\ta_type *leftleft = rbtn_left_get(a_type, a_field, left);\\\n\t\tif (leftleft != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t leftleft)) {\t\t\t\t\t\t\\\n\t\t /* Fix up 4-node. */\t\t\t\t\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, leftleft);\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, cnode, tnode);\t\\\n\t\t (void)a_summarize(cnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, cnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, cnode));\t\\\n\t\t cnode = tnode;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\ta_prefix##summarize_range(path, pathp);\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t a_type *right = pathp[1].node;\t\t\t\t\\\n\t rbtn_right_set(a_type, a_field, cnode, right);\t\t\\\n\t if (rbtn_red_get(a_type, a_field, right)) {\t\t\t\\\n\t\ta_type *left = rbtn_left_get(a_type, a_field, cnode);\t\\\n\t\tif (left != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t left)) {\t\t\t\t\t\t\\\n\t\t /* Split 4-node. */\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, left);\t\t\\\n\t\t rbtn_black_set(a_type, a_field, right);\t\t\\\n\t\t rbtn_red_set(a_type, a_field, cnode);\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* Lean left. */\t\t\t\t\t\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t bool tred = rbtn_red_get(a_type, a_field, cnode);\t\\\n\t\t rbtn_rotate_left(a_type, a_field, cnode, tnode);\t\\\n\t\t rbtn_color_set(a_type, a_field, tnode, tred);\t\\\n\t\t rbtn_red_set(a_type, a_field, cnode);\t\t\\\n\t\t (void)a_summarize(cnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, cnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, cnode));\t\\\n\t\t cnode = tnode;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\ta_prefix##summarize_range(path, pathp);\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tpathp->node = cnode;\t\t\t\t\t\t\\\n\t(void)a_summarize(cnode,\t\t\t\t\t\\\n\t rbtn_left_get(a_type, a_field, cnode),\t\t\t\\\n\t rbtn_right_get(a_type, a_field, cnode));\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n /* Set root, and make it black. */\t\t\t\t\t\\\n rbtree->rbt_root = path->node;\t\t\t\t\t\\\n rbtn_black_set(a_type, a_field, rbtree->rbt_root);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##remove(a_rbt_type *rbtree, a_type *node) {\t\t\t\\\n a_prefix##path_entry_t path[RB_MAX_DEPTH];\t\t\t\t\\\n a_prefix##path_entry_t *pathp;\t\t\t\t\t\\\n a_prefix##path_entry_t *nodep;\t\t\t\t\t\\\n a_prefix##path_entry_t *swap_loc;\t\t\t\t\t\\\n /* This is a \"real\" sentinel -- NULL means we didn't swap the */\\\n /* node to be pruned with one of its successors, and so */\\\n /* summarization can terminate early whenever some summary */\\\n /* doesn't change. */\\\n swap_loc = NULL;\t\t\t\t\t\t\t\\\n /* This is just to silence a compiler warning. */\t\t\t\\\n nodep = NULL;\t\t\t\t\t\t\t\\\n /* Wind. */\t\t\t\t\t\t\t\t\\\n path->node = rbtree->rbt_root;\t\t\t\t\t\\\n for (pathp = path; pathp->node != NULL; pathp++) {\t\t\t\\\n\tint cmp = pathp->cmp = a_cmp(node, pathp->node);\t\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_left_get(a_type, a_field,\t\t\\\n\t pathp->node);\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_right_get(a_type, a_field,\t\t\\\n\t pathp->node);\t\t\t\t\t\t\\\n\t if (cmp == 0) {\t\t\t\t\t\t\\\n\t /* Find node's successor, in preparation for swap. */\t\\\n\t\tpathp->cmp = 1;\t\t\t\t\t\t\\\n\t\tnodep = pathp;\t\t\t\t\t\t\\\n\t\tfor (pathp++; pathp->node != NULL; pathp++) {\t\t\\\n\t\t pathp->cmp = -1;\t\t\t\t\t\\\n\t\t pathp[1].node = rbtn_left_get(a_type, a_field,\t\\\n\t\t pathp->node);\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n assert(nodep->node == node);\t\t\t\t\t\\\n pathp--;\t\t\t\t\t\t\t\t\\\n if (pathp->node != node) {\t\t\t\t\t\t\\\n\t/* Swap node with its successor. */\t\t\t\t\\\n\tswap_loc = nodep;\t\t\t\t\t\t\\\n\tbool tred = rbtn_red_get(a_type, a_field, pathp->node);\t\t\\\n\trbtn_color_set(a_type, a_field, pathp->node,\t\t\t\\\n\t rbtn_red_get(a_type, a_field, node));\t\t\t\t\\\n\trbtn_left_set(a_type, a_field, pathp->node,\t\t\t\\\n\t rbtn_left_get(a_type, a_field, node));\t\t\t\\\n\t/* If node's successor is its right child, the following code */\\\n\t/* will do the wrong thing for the right child pointer. */\\\n\t/* However, it doesn't matter, because the pointer will be */\\\n\t/* properly set when the successor is pruned. */\\\n\trbtn_right_set(a_type, a_field, pathp->node,\t\t\t\\\n\t rbtn_right_get(a_type, a_field, node));\t\t\t\\\n\trbtn_color_set(a_type, a_field, node, tred);\t\t\t\\\n\t/* The pruned leaf node's child pointers are never accessed */\\\n\t/* again, so don't bother setting them to nil. */\\\n\tnodep->node = pathp->node;\t\t\t\t\t\\\n\tpathp->node = node;\t\t\t\t\t\t\\\n\tif (nodep == path) {\t\t\t\t\t\t\\\n\t rbtree->rbt_root = nodep->node;\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t if (nodep[-1].cmp < 0) {\t\t\t\t\t\\\n\t\trbtn_left_set(a_type, a_field, nodep[-1].node,\t\t\\\n\t\t nodep->node);\t\t\t\t\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\trbtn_right_set(a_type, a_field, nodep[-1].node,\t\t\\\n\t\t nodep->node);\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n\tif (left != NULL) {\t\t\t\t\t\t\\\n\t /* node has no successor, but it has a left child. */\\\n\t /* Splice node out, without losing the left child. */\\\n\t assert(!rbtn_red_get(a_type, a_field, node));\t\t\\\n\t assert(rbtn_red_get(a_type, a_field, left));\t\t\\\n\t rbtn_black_set(a_type, a_field, left);\t\t\t\\\n\t if (pathp == path) {\t\t\t\t\t\\\n\t\trbtree->rbt_root = left;\t\t\t\t\\\n\t\t/* Nothing to summarize -- the subtree rooted at the */\\\n\t\t/* node's left child hasn't changed, and it's now the */\\\n\t\t/* root.\t\t\t\t\t */\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\tif (pathp[-1].cmp < 0) {\t\t\t\t\\\n\t\t rbtn_left_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t left);\t\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t rbtn_right_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t left);\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\ta_prefix##summarize_swapped_range(path, &pathp[-1],\t\\\n\t\t swap_loc);\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t return;\t\t\t\t\t\t\t\\\n\t} else if (pathp == path) {\t\t\t\t\t\\\n\t /* The tree only contained one node. */\t\t\t\\\n\t rbtree->rbt_root = NULL;\t\t\t\t\t\\\n\t return;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n /* We've now established the invariant that the node has no right */\\\n /* child (well, morally; we didn't bother nulling it out if we */\\\n /* swapped it with its successor), and that the only nodes with */\\\n /* out-of-date summaries live in path[0], path[1], ..., pathp[-1].*/\\\n if (rbtn_red_get(a_type, a_field, pathp->node)) {\t\t\t\\\n\t/* Prune red node, which requires no fixup. */\t\t\t\\\n\tassert(pathp[-1].cmp < 0);\t\t\t\t\t\\\n\trbtn_left_set(a_type, a_field, pathp[-1].node, NULL);\t\t\\\n\ta_prefix##summarize_swapped_range(path, &pathp[-1], swap_loc);\t\\\n\treturn;\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n /* The node to be pruned is black, so unwind until balance is */\\\n /* restored. */\\\n pathp->node = NULL;\t\t\t\t\t\t\t\\\n for (pathp--; (uintptr_t)pathp >= (uintptr_t)path; pathp--) {\t\\\n\tassert(pathp->cmp != 0);\t\t\t\t\t\\\n\tif (pathp->cmp < 0) {\t\t\t\t\t\t\\\n\t rbtn_left_set(a_type, a_field, pathp->node,\t\t\t\\\n\t pathp[1].node);\t\t\t\t\t\t\\\n\t if (rbtn_red_get(a_type, a_field, pathp->node)) {\t\t\\\n\t\ta_type *right = rbtn_right_get(a_type, a_field,\t\t\\\n\t\t pathp->node);\t\t\t\t\t\t\\\n\t\ta_type *rightleft = rbtn_left_get(a_type, a_field,\t\\\n\t\t right);\t\t\t\t\t\t\\\n\t\ta_type *tnode;\t\t\t\t\t\t\\\n\t\tif (rightleft != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t rightleft)) {\t\t\t\t\t\t\\\n\t\t /* In the following diagrams, ||, //, and \\\\ */\\\n\t\t /* indicate the path to the removed node. */\\\n\t\t /* */\\\n\t\t /* || */\\\n\t\t /* pathp(r) */\\\n\t\t /* // \\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (r) */\\\n\t\t /* */\\\n\t\t rbtn_black_set(a_type, a_field, pathp->node);\t\\\n\t\t rbtn_rotate_right(a_type, a_field, right, tnode);\t\\\n\t\t rbtn_right_set(a_type, a_field, pathp->node, tnode);\\\n\t\t rbtn_rotate_left(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(right,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, right),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, right));\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(r) */\\\n\t\t /* // \\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (b) */\\\n\t\t /* */\\\n\t\t rbtn_rotate_left(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\t(void)a_summarize(tnode, rbtn_left_get(a_type, a_field,\t\\\n\t\t tnode), rbtn_right_get(a_type, a_field, tnode));\t\\\n\t\t/* Balance restored, but rotation modified subtree */\\\n\t\t/* root. */\\\n\t\tassert((uintptr_t)pathp > (uintptr_t)path);\t\t\\\n\t\tif (pathp[-1].cmp < 0) {\t\t\t\t\\\n\t\t rbtn_left_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t rbtn_right_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\ta_prefix##summarize_swapped_range(path, &pathp[-1],\t\\\n\t\t swap_loc);\t\t\t\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\ta_type *right = rbtn_right_get(a_type, a_field,\t\t\\\n\t\t pathp->node);\t\t\t\t\t\t\\\n\t\ta_type *rightleft = rbtn_left_get(a_type, a_field,\t\\\n\t\t right);\t\t\t\t\t\t\\\n\t\tif (rightleft != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t rightleft)) {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* // \\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (r) */\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, rightleft);\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, right, tnode);\t\\\n\t\t rbtn_right_set(a_type, a_field, pathp->node, tnode);\\\n\t\t rbtn_rotate_left(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(right,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, right),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, right));\t\\\n\t\t (void)a_summarize(tnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, tnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, tnode));\t\\\n\t\t /* Balance restored, but rotation modified */\\\n\t\t /* subtree root, which may actually be the tree */\\\n\t\t /* root. */\\\n\t\t if (pathp == path) {\t\t\t\t\\\n\t\t\t/* Set root. */\t\t\t\t\t\\\n\t\t\trbtree->rbt_root = tnode;\t\t\t\\\n\t\t } else {\t\t\t\t\t\t\\\n\t\t\tif (pathp[-1].cmp < 0) {\t\t\t\\\n\t\t\t rbtn_left_set(a_type, a_field,\t\t\\\n\t\t\t pathp[-1].node, tnode);\t\t\t\\\n\t\t\t} else {\t\t\t\t\t\\\n\t\t\t rbtn_right_set(a_type, a_field,\t\t\\\n\t\t\t pathp[-1].node, tnode);\t\t\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t\ta_prefix##summarize_swapped_range(path,\t\t\\\n\t\t\t &pathp[-1], swap_loc);\t\t\t\\\n\t\t }\t\t\t\t\t\t\t\\\n\t\t return;\t\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* // \\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (b) */\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t rbtn_red_set(a_type, a_field, pathp->node);\t\t\\\n\t\t rbtn_rotate_left(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(tnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, tnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, tnode));\t\\\n\t\t pathp->node = tnode;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t a_type *left;\t\t\t\t\t\t\\\n\t rbtn_right_set(a_type, a_field, pathp->node,\t\t\\\n\t pathp[1].node);\t\t\t\t\t\t\\\n\t left = rbtn_left_get(a_type, a_field, pathp->node);\t\t\\\n\t if (rbtn_red_get(a_type, a_field, left)) {\t\t\t\\\n\t\ta_type *tnode;\t\t\t\t\t\t\\\n\t\ta_type *leftright = rbtn_right_get(a_type, a_field,\t\\\n\t\t left);\t\t\t\t\t\t\\\n\t\ta_type *leftrightleft = rbtn_left_get(a_type, a_field,\t\\\n\t\t leftright);\t\t\t\t\t\t\\\n\t\tif (leftrightleft != NULL && rbtn_red_get(a_type,\t\\\n\t\t a_field, leftrightleft)) {\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (r) (b) */\\\n\t\t /* \\ */\\\n\t\t /* (b) */\\\n\t\t /* / */\\\n\t\t /* (r) */\\\n\t\t a_type *unode;\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, leftrightleft);\t\\\n\t\t rbtn_rotate_right(a_type, a_field, pathp->node,\t\\\n\t\t unode);\t\t\t\t\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t rbtn_right_set(a_type, a_field, unode, tnode);\t\\\n\t\t rbtn_rotate_left(a_type, a_field, unode, tnode);\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(unode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, unode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, unode));\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (r) (b) */\\\n\t\t /* \\ */\\\n\t\t /* (b) */\\\n\t\t /* / */\\\n\t\t /* (b) */\\\n\t\t assert(leftright != NULL);\t\t\t\t\\\n\t\t rbtn_red_set(a_type, a_field, leftright);\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, tnode);\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\t(void)a_summarize(tnode,\t\t\t\t\\\n\t\t rbtn_left_get(a_type, a_field, tnode),\t\t\\\n\t\t rbtn_right_get(a_type, a_field, tnode));\t\t\\\n\t\t/* Balance restored, but rotation modified subtree */\\\n\t\t/* root, which may actually be the tree root. */\\\n\t\tif (pathp == path) {\t\t\t\t\t\\\n\t\t /* Set root. */\t\t\t\t\t\\\n\t\t rbtree->rbt_root = tnode;\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t if (pathp[-1].cmp < 0) {\t\t\t\t\\\n\t\t\trbtn_left_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t\t tnode);\t\t\t\t\t\\\n\t\t } else {\t\t\t\t\t\t\\\n\t\t\trbtn_right_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t\t tnode);\t\t\t\t\t\\\n\t\t }\t\t\t\t\t\t\t\\\n\t\t a_prefix##summarize_swapped_range(path, &pathp[-1],\t\\\n\t\t\tswap_loc);\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t } else if (rbtn_red_get(a_type, a_field, pathp->node)) {\t\\\n\t\ta_type *leftleft = rbtn_left_get(a_type, a_field, left);\\\n\t\tif (leftleft != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t leftleft)) {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(r) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (r) */\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, pathp->node);\t\\\n\t\t rbtn_red_set(a_type, a_field, left);\t\t\\\n\t\t rbtn_black_set(a_type, a_field, leftleft);\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(tnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, tnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, tnode));\t\\\n\t\t /* Balance restored, but rotation modified */\\\n\t\t /* subtree root. */\\\n\t\t assert((uintptr_t)pathp > (uintptr_t)path);\t\t\\\n\t\t if (pathp[-1].cmp < 0) {\t\t\t\t\\\n\t\t\trbtn_left_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t\t tnode);\t\t\t\t\t\\\n\t\t } else {\t\t\t\t\t\t\\\n\t\t\trbtn_right_set(a_type, a_field, pathp[-1].node,\t\\\n\t\t\t tnode);\t\t\t\t\t\\\n\t\t }\t\t\t\t\t\t\t\\\n\t\t a_prefix##summarize_swapped_range(path, &pathp[-1],\t\\\n\t\t\tswap_loc);\t\t\t\t\t\\\n\t\t return;\t\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(r) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (b) */\\\n\t\t rbtn_red_set(a_type, a_field, left);\t\t\\\n\t\t rbtn_black_set(a_type, a_field, pathp->node);\t\\\n\t\t /* Balance restored. */\t\t\t\t\\\n\t\t a_prefix##summarize_swapped_range(path, pathp,\t\\\n\t\t\tswap_loc);\t\t\t\t\t\\\n\t\t return;\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t } else {\t\t\t\t\t\t\t\\\n\t\ta_type *leftleft = rbtn_left_get(a_type, a_field, left);\\\n\t\tif (leftleft != NULL && rbtn_red_get(a_type, a_field,\t\\\n\t\t leftleft)) {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (r) */\\\n\t\t a_type *tnode;\t\t\t\t\t\\\n\t\t rbtn_black_set(a_type, a_field, leftleft);\t\t\\\n\t\t rbtn_rotate_right(a_type, a_field, pathp->node,\t\\\n\t\t tnode);\t\t\t\t\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t (void)a_summarize(tnode,\t\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, tnode),\t\t\\\n\t\t\trbtn_right_get(a_type, a_field, tnode));\t\\\n\t\t /* Balance restored, but rotation modified */\\\n\t\t /* subtree root, which may actually be the tree */\\\n\t\t /* root. */\\\n\t\t if (pathp == path) {\t\t\t\t\\\n\t\t\t/* Set root. */\t\t\t\t\t\\\n\t\t\trbtree->rbt_root = tnode;\t\t\t\\\n\t\t } else {\t\t\t\t\t\t\\\n\t\t\tif (pathp[-1].cmp < 0) {\t\t\t\\\n\t\t\t rbtn_left_set(a_type, a_field,\t\t\\\n\t\t\t pathp[-1].node, tnode);\t\t\t\\\n\t\t\t} else {\t\t\t\t\t\\\n\t\t\t rbtn_right_set(a_type, a_field,\t\t\\\n\t\t\t pathp[-1].node, tnode);\t\t\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t a_prefix##summarize_swapped_range(path,\t\t\\\n\t\t\t &pathp[-1], swap_loc);\t\t\t\\\n\t\t }\t\t\t\t\t\t\t\\\n\t\t return;\t\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t /* || */\\\n\t\t /* pathp(b) */\\\n\t\t /* / \\\\ */\\\n\t\t /* (b) (b) */\\\n\t\t /* / */\\\n\t\t /* (b) */\\\n\t\t rbtn_red_set(a_type, a_field, left);\t\t\\\n\t\t (void)a_summarize(pathp->node,\t\t\t\\\n\t\t\trbtn_left_get(a_type, a_field, pathp->node),\t\\\n\t\t\trbtn_right_get(a_type, a_field, pathp->node));\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n /* Set root. */\t\t\t\t\t\t\t\\\n rbtree->rbt_root = path->node;\t\t\t\t\t\\\n assert(!rbtn_red_get(a_type, a_field, rbtree->rbt_root));\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_recurse(a_rbt_type *rbtree, a_type *node,\t\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg) {\t\t\\\n if (node == NULL) {\t\t\t\t\t\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = a_prefix##iter_recurse(rbtree, rbtn_left_get(a_type,\t\\\n\t a_field, node), cb, arg)) != NULL || (ret = cb(rbtree, node,\t\\\n\t arg)) != NULL) {\t\t\t\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##iter_recurse(rbtree, rbtn_right_get(a_type,\t\\\n\t a_field, node), cb, arg);\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_start(a_rbt_type *rbtree, a_type *start, a_type *node,\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg) {\t\t\\\n int cmp = a_cmp(start, node);\t\t\t\t\t\\\n if (cmp < 0) {\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = a_prefix##iter_start(rbtree, start,\t\t\t\\\n\t rbtn_left_get(a_type, a_field, node), cb, arg)) != NULL ||\t\\\n\t (ret = cb(rbtree, node, arg)) != NULL) {\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##iter_recurse(rbtree, rbtn_right_get(a_type,\t\\\n\t a_field, node), cb, arg);\t\t\t\t\t\\\n } else if (cmp > 0) {\t\t\t\t\t\t\\\n\treturn a_prefix##iter_start(rbtree, start,\t\t\t\\\n\t rbtn_right_get(a_type, a_field, node), cb, arg);\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = cb(rbtree, node, arg)) != NULL) {\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##iter_recurse(rbtree, rbtn_right_get(a_type,\t\\\n\t a_field, node), cb, arg);\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter(a_rbt_type *rbtree, a_type *start, a_type *(*cb)(\t\\\n a_rbt_type *, a_type *, void *), void *arg) {\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (start != NULL) {\t\t\t\t\t\t\\\n\tret = a_prefix##iter_start(rbtree, start, rbtree->rbt_root,\t\\\n\t cb, arg);\t\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tret = a_prefix##iter_recurse(rbtree, rbtree->rbt_root, cb, arg);\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_recurse(a_rbt_type *rbtree, a_type *node,\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg) {\t\t\\\n if (node == NULL) {\t\t\t\t\t\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = a_prefix##reverse_iter_recurse(rbtree,\t\t\\\n\t rbtn_right_get(a_type, a_field, node), cb, arg)) != NULL ||\t\\\n\t (ret = cb(rbtree, node, arg)) != NULL) {\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_recurse(rbtree,\t\t\t\\\n\t rbtn_left_get(a_type, a_field, node), cb, arg);\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_start(a_rbt_type *rbtree, a_type *start,\t\t\\\n a_type *node, a_type *(*cb)(a_rbt_type *, a_type *, void *),\t\t\\\n void *arg) {\t\t\t\t\t\t\t\t\\\n int cmp = a_cmp(start, node);\t\t\t\t\t\\\n if (cmp > 0) {\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = a_prefix##reverse_iter_start(rbtree, start,\t\t\\\n\t rbtn_right_get(a_type, a_field, node), cb, arg)) != NULL ||\t\\\n\t (ret = cb(rbtree, node, arg)) != NULL) {\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_recurse(rbtree,\t\t\t\\\n\t rbtn_left_get(a_type, a_field, node), cb, arg);\t\t\\\n } else if (cmp < 0) {\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_start(rbtree, start,\t\t\\\n\t rbtn_left_get(a_type, a_field, node), cb, arg);\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\ta_type *ret;\t\t\t\t\t\t\t\\\n\tif ((ret = cb(rbtree, node, arg)) != NULL) {\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_recurse(rbtree,\t\t\t\\\n\t rbtn_left_get(a_type, a_field, node), cb, arg);\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter(a_rbt_type *rbtree, a_type *start,\t\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg) {\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (start != NULL) {\t\t\t\t\t\t\\\n\tret = a_prefix##reverse_iter_start(rbtree, start,\t\t\\\n\t rbtree->rbt_root, cb, arg);\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tret = a_prefix##reverse_iter_recurse(rbtree, rbtree->rbt_root,\t\\\n\t cb, arg);\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##destroy_recurse(a_rbt_type *rbtree, a_type *node, void (*cb)(\t\\\n a_type *, void *), void *arg) {\t\t\t\t\t\\\n if (node == NULL) {\t\t\t\t\t\t\t\\\n\treturn;\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_prefix##destroy_recurse(rbtree, rbtn_left_get(a_type, a_field,\t\\\n node), cb, arg);\t\t\t\t\t\t\t\\\n rbtn_left_set(a_type, a_field, (node), NULL);\t\t\t\\\n a_prefix##destroy_recurse(rbtree, rbtn_right_get(a_type, a_field,\t\\\n node), cb, arg);\t\t\t\t\t\t\t\\\n rbtn_right_set(a_type, a_field, (node), NULL);\t\t\t\\\n if (cb) {\t\t\t\t\t\t\t\t\\\n\tcb(node, arg);\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##destroy(a_rbt_type *rbtree, void (*cb)(a_type *, void *),\t\\\n void *arg) {\t\t\t\t\t\t\t\t\\\n a_prefix##destroy_recurse(rbtree, rbtree->rbt_root, cb, arg);\t\\\n rbtree->rbt_root = NULL;\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n/* BEGIN SUMMARIZED-ONLY IMPLEMENTATION */\t\t\t\t\\\nrb_summarized_only_##a_is_summarized(\t\t\t\t\t\\\nstatic inline a_prefix##path_entry_t *\t\t\t\t\t\\\na_prefix##wind(a_rbt_type *rbtree,\t\t\t\t\t\\\n a_prefix##path_entry_t path[RB_MAX_DEPTH], a_type *node) {\t\t\\\n a_prefix##path_entry_t *pathp;\t\t\t\t\t\\\n path->node = rbtree->rbt_root;\t\t\t\t\t\\\n for (pathp = path; ; pathp++) {\t\t\t\t\t\\\n\tassert((size_t)(pathp - path) < RB_MAX_DEPTH);\t\t\t\\\n\tpathp->cmp = a_cmp(node, pathp->node);\t\t\t\t\\\n\tif (pathp->cmp < 0) {\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_left_get(a_type, a_field,\t\t\\\n\t\tpathp->node);\t\t\t\t\t\t\\\n\t} else if (pathp->cmp == 0) {\t\t\t\t\t\\\n\t return pathp;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t pathp[1].node = rbtn_right_get(a_type, a_field,\t\t\\\n\t\tpathp->node);\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n unreachable();\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##update_summaries(a_rbt_type *rbtree, a_type *node) {\t\t\\\n a_prefix##path_entry_t path[RB_MAX_DEPTH];\t\t\t\t\\\n a_prefix##path_entry_t *pathp = a_prefix##wind(rbtree, path, node);\t\\\n a_prefix##summarize_range(path, pathp);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##empty_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *node = rbtree->rbt_root;\t\t\t\t\t\\\n return node == NULL || !filter_subtree(filter_ctx, node);\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline a_type *\t\t\t\t\t\t\t\\\na_prefix##first_filtered_from_node(a_type *node,\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n assert(node != NULL && filter_subtree(filter_ctx, node));\t\t\\\n while (true) {\t\t\t\t\t\t\t\\\n\ta_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n\ta_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n\tif (left != NULL && filter_subtree(filter_ctx, left)) {\t\t\\\n\t node = left;\t\t\t\t\t\t\\\n\t} else if (filter_node(filter_ctx, node)) {\t\t\t\\\n\t return node;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tassert(right != NULL\t\t\t\t\t\\\n\t\t && filter_subtree(filter_ctx, right));\t\t\\\n\t\tnode = right;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n unreachable();\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##first_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *node = rbtree->rbt_root;\t\t\t\t\t\\\n if (node == NULL || !filter_subtree(filter_ctx, node)) {\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return a_prefix##first_filtered_from_node(node, filter_node,\t\\\n\tfilter_subtree, filter_ctx);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline a_type *\t\t\t\t\t\t\t\\\na_prefix##last_filtered_from_node(a_type *node,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n assert(node != NULL && filter_subtree(filter_ctx, node));\t\t\\\n while (true) {\t\t\t\t\t\t\t\\\n\ta_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n\ta_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n\tif (right != NULL && filter_subtree(filter_ctx, right)) {\t\\\n\t node = right;\t\t\t\t\t\t\\\n\t} else if (filter_node(filter_ctx, node)) {\t\t\t\\\n\t return node;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tassert(left != NULL\t\t\t\t\t\\\n\t\t && filter_subtree(filter_ctx, left));\t\t\\\n\t\tnode = left;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n unreachable();\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##last_filtered(a_rbt_type *rbtree,\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *node = rbtree->rbt_root;\t\t\t\t\t\\\n if (node == NULL || !filter_subtree(filter_ctx, node)) {\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return a_prefix##last_filtered_from_node(node, filter_node,\t\t\\\n\tfilter_subtree, filter_ctx);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n/* Internal implementation function. Search for a node comparing */\\\n/* equal to key matching the filter. If such a node is in the tree, */\\\n/* return it. Additionally, the caller has the option to ask for */\\\n/* bounds on the next / prev node in the tree passing the filter. */\\\n/* If nextbound is true, then this function will do one of the */\\\n/* following: */\\\n/* - Fill in *nextbound_node with the smallest node in the tree */\\\n/* greater than key passing the filter, and NULL-out */\\\n/* *nextbound_subtree. */\\\n/* - Fill in *nextbound_subtree with a parent of that node which is */\\\n/* not a parent of the searched-for node, and NULL-out */\\\n/* *nextbound_node. */\\\n/* - NULL-out both *nextbound_node and *nextbound_subtree, in which */\\\n/* case no node greater than key but passing the filter is in the */\\\n/* tree. */\\\n/* The prevbound case is similar. If the caller knows that key is in */\\\n/* the tree and that the subtree rooted at key does not contain a */\\\n/* node satisfying the bound being searched for, then they can pass */\\\n/* false for include_subtree, in which case we won't bother searching */\\\n/* there (risking a cache miss). */\\\n/* */\\\n/* This API is unfortunately complex; but the logic for filtered */\\\n/* searches is very subtle, and otherwise we would have to repeat it */\\\n/* multiple times for filtered search, nsearch, psearch, next, and */\\\n/* prev. */\\\nstatic inline a_type *\t\t\t\t\t\t\t\\\na_prefix##search_with_filter_bounds(a_rbt_type *rbtree,\t\t\t\\\n const a_type *key,\t\t\t\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx,\t\t\t\t\t\t\t\\\n bool include_subtree,\t\t\t\t\t\t\t\\\n bool nextbound, a_type **nextbound_node, a_type **nextbound_subtree,\t\\\n bool prevbound, a_type **prevbound_node, a_type **prevbound_subtree) {\\\n if (nextbound) {\t\t\t\t\t\t\t\\\n\t *nextbound_node = NULL;\t\t\t\t\t\\\n\t *nextbound_subtree = NULL;\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (prevbound) {\t\t\t\t\t\t\t\\\n\t *prevbound_node = NULL;\t\t\t\t\t\\\n\t *prevbound_subtree = NULL;\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_type *tnode = rbtree->rbt_root;\t\t\t\t\t\\\n while (tnode != NULL && filter_subtree(filter_ctx, tnode)) {\t\\\n\tint cmp = a_cmp(key, tnode);\t\t\t\t\t\\\n\ta_type *tleft = rbtn_left_get(a_type, a_field, tnode);\t\t\\\n\ta_type *tright = rbtn_right_get(a_type, a_field, tnode);\t\\\n\tif (cmp < 0) {\t\t\t\t\t\t\t\\\n\t if (nextbound) {\t\t\t\t\t\t\\\n\t\tif (filter_node(filter_ctx, tnode)) {\t\t\t\\\n\t\t *nextbound_node = tnode;\t\t\t\t\\\n\t\t *nextbound_subtree = NULL;\t\t\t\t\\\n\t\t} else if (tright != NULL && filter_subtree(\t\t\\\n\t\t filter_ctx, tright)) {\t\t\t\t\\\n\t\t *nextbound_node = NULL;\t\t\t\t\\\n\t\t *nextbound_subtree = tright;\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t tnode = tleft;\t\t\t\t\t\t\\\n\t} else if (cmp > 0) {\t\t\t\t\t\t\\\n\t if (prevbound) {\t\t\t\t\t\t\\\n\t\tif (filter_node(filter_ctx, tnode)) {\t\t\t\\\n\t\t *prevbound_node = tnode;\t\t\t\t\\\n\t\t *prevbound_subtree = NULL;\t\t\t\t\\\n\t\t} else if (tleft != NULL && filter_subtree(\t\t\\\n\t\t filter_ctx, tleft)) {\t\t\t\t\\\n\t\t *prevbound_node = NULL;\t\t\t\t\\\n\t\t *prevbound_subtree = tleft;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t tnode = tright;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t if (filter_node(filter_ctx, tnode)) {\t\t\t\\\n\t\treturn tnode;\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t if (include_subtree) {\t\t\t\t\t\\\n\t\tif (prevbound && tleft != NULL && filter_subtree(\t\\\n\t\t filter_ctx, tleft)) {\t\t\t\t\\\n\t\t *prevbound_node = NULL;\t\t\t\t\\\n\t\t *prevbound_subtree = tleft;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tif (nextbound && tright != NULL && filter_subtree(\t\\\n\t\t filter_ctx, tright)) {\t\t\t\t\\\n\t\t *nextbound_node = NULL;\t\t\t\t\\\n\t\t *nextbound_subtree = tright;\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t return NULL;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return NULL;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##next_filtered(a_rbt_type *rbtree, a_type *node,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *nright = rbtn_right_get(a_type, a_field, node);\t\t\\\n if (nright != NULL && filter_subtree(filter_ctx, nright)) {\t\t\\\n\treturn a_prefix##first_filtered_from_node(nright, filter_node,\t\\\n\t filter_subtree, filter_ctx);\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_type *node_candidate;\t\t\t\t\t\t\\\n a_type *subtree_candidate;\t\t\t\t\t\t\\\n a_type *search_result = a_prefix##search_with_filter_bounds(\t\\\n\trbtree, node, filter_node, filter_subtree, filter_ctx,\t\t\\\n\t/* include_subtree */ false,\t\t\t\t\t\\\n\t/* nextbound */ true, &node_candidate, &subtree_candidate,\t\\\n\t/* prevbound */ false, NULL, NULL);\t\t\t\t\\\n assert(node == search_result\t\t\t\t\t\\\n\t|| !filter_node(filter_ctx, node));\t\t\t\t\\\n if (node_candidate != NULL) {\t\t\t\t\t\\\n\treturn node_candidate;\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (subtree_candidate != NULL) {\t\t\t\t\t\\\n\treturn a_prefix##first_filtered_from_node(\t\t\t\\\n\t subtree_candidate, filter_node, filter_subtree,\t\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return NULL;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##prev_filtered(a_rbt_type *rbtree, a_type *node,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *nleft = rbtn_left_get(a_type, a_field, node);\t\t\\\n if (nleft != NULL && filter_subtree(filter_ctx, nleft)) {\t\t\\\n\treturn a_prefix##last_filtered_from_node(nleft, filter_node,\t\\\n\t filter_subtree, filter_ctx);\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_type *node_candidate;\t\t\t\t\t\t\\\n a_type *subtree_candidate;\t\t\t\t\t\t\\\n a_type *search_result = a_prefix##search_with_filter_bounds(\t\\\n\trbtree, node, filter_node, filter_subtree, filter_ctx,\t\t\\\n\t/* include_subtree */ false,\t\t\t\t\t\\\n\t/* nextbound */ false, NULL, NULL,\t\t\t\t\\\n\t/* prevbound */ true, &node_candidate, &subtree_candidate);\t\\\n assert(node == search_result\t\t\t\t\t\\\n\t|| !filter_node(filter_ctx, node));\t\t\t\t\\\n if (node_candidate != NULL) {\t\t\t\t\t\\\n\treturn node_candidate;\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (subtree_candidate != NULL) {\t\t\t\t\t\\\n\treturn a_prefix##last_filtered_from_node(\t\t\t\\\n\t subtree_candidate, filter_node, filter_subtree,\t\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return NULL;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##search_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *result = a_prefix##search_with_filter_bounds(rbtree, key,\t\\\n\tfilter_node, filter_subtree, filter_ctx,\t\t\t\\\n\t/* include_subtree */ false,\t\t\t\t\t\\\n\t/* nextbound */ false, NULL, NULL,\t\t\t\t\\\n\t/* prevbound */ false, NULL, NULL);\t\t\t\t\\\n return result;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##nsearch_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *node_candidate;\t\t\t\t\t\t\\\n a_type *subtree_candidate;\t\t\t\t\t\t\\\n a_type *result = a_prefix##search_with_filter_bounds(rbtree, key,\t\\\n\tfilter_node, filter_subtree, filter_ctx,\t\t\t\\\n\t/* include_subtree */ true,\t\t\t\t\t\\\n\t/* nextbound */ true, &node_candidate, &subtree_candidate,\t\\\n\t/* prevbound */ false, NULL, NULL);\t\t\t\t\\\n if (result != NULL) {\t\t\t\t\t\t\\\n\treturn result;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (node_candidate != NULL) {\t\t\t\t\t\\\n\treturn node_candidate;\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (subtree_candidate != NULL) {\t\t\t\t\t\\\n\treturn a_prefix##first_filtered_from_node(\t\t\t\\\n\t subtree_candidate, filter_node, filter_subtree,\t\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return NULL;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##psearch_filtered(a_rbt_type *rbtree, const a_type *key,\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *node_candidate;\t\t\t\t\t\t\\\n a_type *subtree_candidate;\t\t\t\t\t\t\\\n a_type *result = a_prefix##search_with_filter_bounds(rbtree, key,\t\\\n\tfilter_node, filter_subtree, filter_ctx,\t\t\t\\\n\t/* include_subtree */ true,\t\t\t\t\t\\\n\t/* nextbound */ false, NULL, NULL,\t\t\t\t\\\n\t/* prevbound */ true, &node_candidate, &subtree_candidate);\t\\\n if (result != NULL) {\t\t\t\t\t\t\\\n\treturn result;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (node_candidate != NULL) {\t\t\t\t\t\\\n\treturn node_candidate;\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (subtree_candidate != NULL) {\t\t\t\t\t\\\n\treturn a_prefix##last_filtered_from_node(\t\t\t\\\n\t subtree_candidate, filter_node, filter_subtree,\t\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return NULL;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_recurse_filtered(a_rbt_type *rbtree, a_type *node,\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n if (node == NULL || !filter_subtree(filter_ctx, node)) {\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n a_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n ret = a_prefix##iter_recurse_filtered(rbtree, left, cb, arg,\t\\\n filter_node, filter_subtree, filter_ctx);\t\t\t\t\\\n if (ret != NULL) {\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\tret = cb(rbtree, node, arg);\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (ret != NULL) {\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return a_prefix##iter_recurse_filtered(rbtree, right, cb, arg,\t\\\n filter_node, filter_subtree, filter_ctx);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_start_filtered(a_rbt_type *rbtree, a_type *start,\t\\\n a_type *node, a_type *(*cb)(a_rbt_type *, a_type *, void *),\t\t\\\n void *arg, bool (*filter_node)(void *, a_type *),\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n if (!filter_subtree(filter_ctx, node)) {\t\t\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n int cmp = a_cmp(start, node);\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n a_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n if (cmp < 0) {\t\t\t\t\t\t\t\\\n\tret = a_prefix##iter_start_filtered(rbtree, start, left, cb,\t\\\n\t arg, filter_node, filter_subtree, filter_ctx);\t\t\\\n\tif (ret != NULL) {\t\t\t\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\t ret = cb(rbtree, node, arg);\t\t\t\t\\\n\t if (ret != NULL) {\t\t\t\t\t\t\\\n\t\treturn ret;\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##iter_recurse_filtered(rbtree, right, cb, arg,\t\\\n\t filter_node, filter_subtree, filter_ctx);\t\t\t\\\n } else if (cmp > 0) {\t\t\t\t\t\t\\\n\treturn a_prefix##iter_start_filtered(rbtree, start, right,\t\\\n\t cb, arg, filter_node, filter_subtree, filter_ctx);\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tif (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\t ret = cb(rbtree, node, arg);\t\t\t\t\\\n\t if (ret != NULL) {\t\t\t\t\t\t\\\n\t\treturn ret;\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##iter_recurse_filtered(rbtree, right, cb, arg,\t\\\n\t filter_node, filter_subtree, filter_ctx);\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##iter_filtered(a_rbt_type *rbtree, a_type *start,\t\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (start != NULL) {\t\t\t\t\t\t\\\n\tret = a_prefix##iter_start_filtered(rbtree, start,\t\t\\\n\t rbtree->rbt_root, cb, arg, filter_node, filter_subtree,\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tret = a_prefix##iter_recurse_filtered(rbtree, rbtree->rbt_root,\t\\\n\t cb, arg, filter_node, filter_subtree, filter_ctx);\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_recurse_filtered(a_rbt_type *rbtree,\t\t\\\n a_type *node, a_type *(*cb)(a_rbt_type *, a_type *, void *),\t\t\\\n void *arg,\t\t\t\t\t\t\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n if (node == NULL || !filter_subtree(filter_ctx, node)) {\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n a_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n ret = a_prefix##reverse_iter_recurse_filtered(rbtree, right, cb,\t\\\n\targ, filter_node, filter_subtree, filter_ctx);\t\t\t\\\n if (ret != NULL) {\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\tret = cb(rbtree, node, arg);\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n if (ret != NULL) {\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return a_prefix##reverse_iter_recurse_filtered(rbtree, left, cb,\t\\\n arg, filter_node, filter_subtree, filter_ctx);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_start_filtered(a_rbt_type *rbtree, a_type *start,\\\n a_type *node, a_type *(*cb)(a_rbt_type *, a_type *, void *),\t\t\\\n void *arg, bool (*filter_node)(void *, a_type *),\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n if (!filter_subtree(filter_ctx, node)) {\t\t\t\t\\\n\treturn NULL;\t\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n int cmp = a_cmp(start, node);\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n a_type *left = rbtn_left_get(a_type, a_field, node);\t\t\\\n a_type *right = rbtn_right_get(a_type, a_field, node);\t\t\\\n if (cmp > 0) {\t\t\t\t\t\t\t\\\n\tret = a_prefix##reverse_iter_start_filtered(rbtree, start,\t\\\n\t right, cb, arg, filter_node, filter_subtree, filter_ctx);\t\\\n\tif (ret != NULL) {\t\t\t\t\t\t\\\n\t return ret;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\t ret = cb(rbtree, node, arg);\t\t\t\t\\\n\t if (ret != NULL) {\t\t\t\t\t\t\\\n\t\treturn ret;\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_recurse_filtered(rbtree, left, cb,\\\n\t arg, filter_node, filter_subtree, filter_ctx);\t\t\\\n } else if (cmp < 0) {\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_start_filtered(rbtree, start,\t\\\n\t left, cb, arg, filter_node, filter_subtree, filter_ctx);\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tif (filter_node(filter_ctx, node)) {\t\t\t\t\\\n\t ret = cb(rbtree, node, arg);\t\t\t\t\\\n\t if (ret != NULL) {\t\t\t\t\t\t\\\n\t\treturn ret;\t\t\t\t\t\t\\\n\t }\t\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn a_prefix##reverse_iter_recurse_filtered(rbtree, left, cb,\\\n\t arg, filter_node, filter_subtree, filter_ctx);\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_type *\t\t\t\t\t\t\t\t\\\na_prefix##reverse_iter_filtered(a_rbt_type *rbtree, a_type *start,\t\\\n a_type *(*cb)(a_rbt_type *, a_type *, void *), void *arg,\t\t\\\n bool (*filter_node)(void *, a_type *),\t\t\t\t\\\n bool (*filter_subtree)(void *, a_type *),\t\t\t\t\\\n void *filter_ctx) {\t\t\t\t\t\t\t\\\n a_type *ret;\t\t\t\t\t\t\t\\\n if (start != NULL) {\t\t\t\t\t\t\\\n\tret = a_prefix##reverse_iter_start_filtered(rbtree, start,\t\\\n\t rbtree->rbt_root, cb, arg, filter_node, filter_subtree,\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n } else {\t\t\t\t\t\t\t\t\\\n\tret = a_prefix##reverse_iter_recurse_filtered(rbtree,\t\t\\\n\t rbtree->rbt_root, cb, arg, filter_node, filter_subtree,\t\\\n\t filter_ctx);\t\t\t\t\t\t\\\n }\t\t\t\t\t\t\t\t\t\\\n return ret;\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\n) /* end rb_summarized_only */\n\n#endif /* JEMALLOC_INTERNAL_RB_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/rtree.h", "content": "#ifndef JEMALLOC_INTERNAL_RTREE_H\n#define JEMALLOC_INTERNAL_RTREE_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/rtree_tsd.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/tsd.h\"\n\n/*\n * This radix tree implementation is tailored to the singular purpose of\n * associating metadata with extents that are currently owned by jemalloc.\n *\n *******************************************************************************\n */\n\n/* Number of high insignificant bits. */\n#define RTREE_NHIB ((1U << (LG_SIZEOF_PTR+3)) - LG_VADDR)\n/* Number of low insigificant bits. */\n#define RTREE_NLIB LG_PAGE\n/* Number of significant bits. */\n#define RTREE_NSB (LG_VADDR - RTREE_NLIB)\n/* Number of levels in radix tree. */\n#if RTREE_NSB <= 10\n# define RTREE_HEIGHT 1\n#elif RTREE_NSB <= 36\n# define RTREE_HEIGHT 2\n#elif RTREE_NSB <= 52\n# define RTREE_HEIGHT 3\n#else\n# error Unsupported number of significant virtual address bits\n#endif\n/* Use compact leaf representation if virtual address encoding allows. */\n#if RTREE_NHIB >= LG_CEIL(SC_NSIZES)\n# define RTREE_LEAF_COMPACT\n#endif\n\ntypedef struct rtree_node_elm_s rtree_node_elm_t;\nstruct rtree_node_elm_s {\n\tatomic_p_t\tchild; /* (rtree_{node,leaf}_elm_t *) */\n};\n\ntypedef struct rtree_metadata_s rtree_metadata_t;\nstruct rtree_metadata_s {\n\tszind_t szind;\n\textent_state_t state; /* Mirrors edata->state. */\n\tbool is_head; /* Mirrors edata->is_head. */\n\tbool slab;\n};\n\ntypedef struct rtree_contents_s rtree_contents_t;\nstruct rtree_contents_s {\n\tedata_t *edata;\n\trtree_metadata_t metadata;\n};\n\n#define RTREE_LEAF_STATE_WIDTH EDATA_BITS_STATE_WIDTH\n#define RTREE_LEAF_STATE_SHIFT 2\n#define RTREE_LEAF_STATE_MASK MASK(RTREE_LEAF_STATE_WIDTH, RTREE_LEAF_STATE_SHIFT)\n\nstruct rtree_leaf_elm_s {\n#ifdef RTREE_LEAF_COMPACT\n\t/*\n\t * Single pointer-width field containing all three leaf element fields.\n\t * For example, on a 64-bit x64 system with 48 significant virtual\n\t * memory address bits, the index, edata, and slab fields are packed as\n\t * such:\n\t *\n\t * x: index\n\t * e: edata\n\t * s: state\n\t * h: is_head\n\t * b: slab\n\t *\n\t * 00000000 xxxxxxxx eeeeeeee [...] eeeeeeee e00ssshb\n\t */\n\tatomic_p_t\tle_bits;\n#else\n\tatomic_p_t\tle_edata; /* (edata_t *) */\n\t/*\n\t * From high to low bits: szind (8 bits), state (4 bits), is_head, slab\n\t */\n\tatomic_u_t\tle_metadata;\n#endif\n};\n\ntypedef struct rtree_level_s rtree_level_t;\nstruct rtree_level_s {\n\t/* Number of key bits distinguished by this level. */\n\tunsigned\t\tbits;\n\t/*\n\t * Cumulative number of key bits distinguished by traversing to\n\t * corresponding tree level.\n\t */\n\tunsigned\t\tcumbits;\n};\n\ntypedef struct rtree_s rtree_t;\nstruct rtree_s {\n\tbase_t\t\t\t*base;\n\tmalloc_mutex_t\t\tinit_lock;\n\t/* Number of elements based on rtree_levels[0].bits. */\n#if RTREE_HEIGHT > 1\n\trtree_node_elm_t\troot[1U << (RTREE_NSB/RTREE_HEIGHT)];\n#else\n\trtree_leaf_elm_t\troot[1U << (RTREE_NSB/RTREE_HEIGHT)];\n#endif\n};\n\n/*\n * Split the bits into one to three partitions depending on number of\n * significant bits. It the number of bits does not divide evenly into the\n * number of levels, place one remainder bit per level starting at the leaf\n * level.\n */\nstatic const rtree_level_t rtree_levels[] = {\n#if RTREE_HEIGHT == 1\n\t{RTREE_NSB, RTREE_NHIB + RTREE_NSB}\n#elif RTREE_HEIGHT == 2\n\t{RTREE_NSB/2, RTREE_NHIB + RTREE_NSB/2},\n\t{RTREE_NSB/2 + RTREE_NSB%2, RTREE_NHIB + RTREE_NSB}\n#elif RTREE_HEIGHT == 3\n\t{RTREE_NSB/3, RTREE_NHIB + RTREE_NSB/3},\n\t{RTREE_NSB/3 + RTREE_NSB%3/2,\n\t RTREE_NHIB + RTREE_NSB/3*2 + RTREE_NSB%3/2},\n\t{RTREE_NSB/3 + RTREE_NSB%3 - RTREE_NSB%3/2, RTREE_NHIB + RTREE_NSB}\n#else\n# error Unsupported rtree height\n#endif\n};\n\nbool rtree_new(rtree_t *rtree, base_t *base, bool zeroed);\n\nrtree_leaf_elm_t *rtree_leaf_elm_lookup_hard(tsdn_t *tsdn, rtree_t *rtree,\n rtree_ctx_t *rtree_ctx, uintptr_t key, bool dependent, bool init_missing);\n\nJEMALLOC_ALWAYS_INLINE unsigned\nrtree_leaf_maskbits(void) {\n\tunsigned ptrbits = ZU(1) << (LG_SIZEOF_PTR+3);\n\tunsigned cumbits = (rtree_levels[RTREE_HEIGHT-1].cumbits -\n\t rtree_levels[RTREE_HEIGHT-1].bits);\n\treturn ptrbits - cumbits;\n}\n\nJEMALLOC_ALWAYS_INLINE uintptr_t\nrtree_leafkey(uintptr_t key) {\n\tuintptr_t mask = ~((ZU(1) << rtree_leaf_maskbits()) - 1);\n\treturn (key & mask);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nrtree_cache_direct_map(uintptr_t key) {\n\treturn (size_t)((key >> rtree_leaf_maskbits()) &\n\t (RTREE_CTX_NCACHE - 1));\n}\n\nJEMALLOC_ALWAYS_INLINE uintptr_t\nrtree_subkey(uintptr_t key, unsigned level) {\n\tunsigned ptrbits = ZU(1) << (LG_SIZEOF_PTR+3);\n\tunsigned cumbits = rtree_levels[level].cumbits;\n\tunsigned shiftbits = ptrbits - cumbits;\n\tunsigned maskbits = rtree_levels[level].bits;\n\tuintptr_t mask = (ZU(1) << maskbits) - 1;\n\treturn ((key >> shiftbits) & mask);\n}\n\n/*\n * Atomic getters.\n *\n * dependent: Reading a value on behalf of a pointer to a valid allocation\n * is guaranteed to be a clean read even without synchronization,\n * because the rtree update became visible in memory before the\n * pointer came into existence.\n * !dependent: An arbitrary read, e.g. on behalf of ivsalloc(), may not be\n * dependent on a previous rtree write, which means a stale read\n * could result if synchronization were omitted here.\n */\n# ifdef RTREE_LEAF_COMPACT\nJEMALLOC_ALWAYS_INLINE uintptr_t\nrtree_leaf_elm_bits_read(tsdn_t *tsdn, rtree_t *rtree,\n rtree_leaf_elm_t *elm, bool dependent) {\n\treturn (uintptr_t)atomic_load_p(&elm->le_bits, dependent\n\t ? ATOMIC_RELAXED : ATOMIC_ACQUIRE);\n}\n\nJEMALLOC_ALWAYS_INLINE uintptr_t\nrtree_leaf_elm_bits_encode(rtree_contents_t contents) {\n\tassert((uintptr_t)contents.edata % (uintptr_t)EDATA_ALIGNMENT == 0);\n\tuintptr_t edata_bits = (uintptr_t)contents.edata\n\t & (((uintptr_t)1 << LG_VADDR) - 1);\n\n\tuintptr_t szind_bits = (uintptr_t)contents.metadata.szind << LG_VADDR;\n\tuintptr_t slab_bits = (uintptr_t)contents.metadata.slab;\n\tuintptr_t is_head_bits = (uintptr_t)contents.metadata.is_head << 1;\n\tuintptr_t state_bits = (uintptr_t)contents.metadata.state <<\n\t RTREE_LEAF_STATE_SHIFT;\n\tuintptr_t metadata_bits = szind_bits | state_bits | is_head_bits |\n\t slab_bits;\n\tassert((edata_bits & metadata_bits) == 0);\n\n\treturn edata_bits | metadata_bits;\n}\n\nJEMALLOC_ALWAYS_INLINE rtree_contents_t\nrtree_leaf_elm_bits_decode(uintptr_t bits) {\n\trtree_contents_t contents;\n\t/* Do the easy things first. */\n\tcontents.metadata.szind = bits >> LG_VADDR;\n\tcontents.metadata.slab = (bool)(bits & 1);\n\tcontents.metadata.is_head = (bool)(bits & (1 << 1));\n\n\tuintptr_t state_bits = (bits & RTREE_LEAF_STATE_MASK) >>\n\t RTREE_LEAF_STATE_SHIFT;\n\tassert(state_bits <= extent_state_max);\n\tcontents.metadata.state = (extent_state_t)state_bits;\n\n\tuintptr_t low_bit_mask = ~((uintptr_t)EDATA_ALIGNMENT - 1);\n# ifdef __aarch64__\n\t/*\n\t * aarch64 doesn't sign extend the highest virtual address bit to set\n\t * the higher ones. Instead, the high bits get zeroed.\n\t */\n\tuintptr_t high_bit_mask = ((uintptr_t)1 << LG_VADDR) - 1;\n\t/* Mask off metadata. */\n\tuintptr_t mask = high_bit_mask & low_bit_mask;\n\tcontents.edata = (edata_t *)(bits & mask);\n# else\n\t/* Restore sign-extended high bits, mask metadata bits. */\n\tcontents.edata = (edata_t *)((uintptr_t)((intptr_t)(bits << RTREE_NHIB)\n\t >> RTREE_NHIB) & low_bit_mask);\n# endif\n\tassert((uintptr_t)contents.edata % (uintptr_t)EDATA_ALIGNMENT == 0);\n\treturn contents;\n}\n\n# endif /* RTREE_LEAF_COMPACT */\n\nJEMALLOC_ALWAYS_INLINE rtree_contents_t\nrtree_leaf_elm_read(tsdn_t *tsdn, rtree_t *rtree, rtree_leaf_elm_t *elm,\n bool dependent) {\n#ifdef RTREE_LEAF_COMPACT\n\tuintptr_t bits = rtree_leaf_elm_bits_read(tsdn, rtree, elm, dependent);\n\trtree_contents_t contents = rtree_leaf_elm_bits_decode(bits);\n\treturn contents;\n#else\n\trtree_contents_t contents;\n\tunsigned metadata_bits = atomic_load_u(&elm->le_metadata, dependent\n\t ? ATOMIC_RELAXED : ATOMIC_ACQUIRE);\n\tcontents.metadata.slab = (bool)(metadata_bits & 1);\n\tcontents.metadata.is_head = (bool)(metadata_bits & (1 << 1));\n\n\tuintptr_t state_bits = (metadata_bits & RTREE_LEAF_STATE_MASK) >>\n\t RTREE_LEAF_STATE_SHIFT;\n\tassert(state_bits <= extent_state_max);\n\tcontents.metadata.state = (extent_state_t)state_bits;\n\tcontents.metadata.szind = metadata_bits >> (RTREE_LEAF_STATE_SHIFT +\n\t RTREE_LEAF_STATE_WIDTH);\n\n\tcontents.edata = (edata_t *)atomic_load_p(&elm->le_edata, dependent\n\t ? ATOMIC_RELAXED : ATOMIC_ACQUIRE);\n\n\treturn contents;\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nrtree_contents_encode(rtree_contents_t contents, void **bits,\n unsigned *additional) {\n#ifdef RTREE_LEAF_COMPACT\n\t*bits = (void *)rtree_leaf_elm_bits_encode(contents);\n#else\n\t*additional = (unsigned)contents.metadata.slab\n\t | ((unsigned)contents.metadata.is_head << 1)\n\t | ((unsigned)contents.metadata.state << RTREE_LEAF_STATE_SHIFT)\n\t | ((unsigned)contents.metadata.szind << (RTREE_LEAF_STATE_SHIFT +\n\t RTREE_LEAF_STATE_WIDTH));\n\t*bits = contents.edata;\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nrtree_leaf_elm_write_commit(tsdn_t *tsdn, rtree_t *rtree,\n rtree_leaf_elm_t *elm, void *bits, unsigned additional) {\n#ifdef RTREE_LEAF_COMPACT\n\tatomic_store_p(&elm->le_bits, bits, ATOMIC_RELEASE);\n#else\n\tatomic_store_u(&elm->le_metadata, additional, ATOMIC_RELEASE);\n\t/*\n\t * Write edata last, since the element is atomically considered valid\n\t * as soon as the edata field is non-NULL.\n\t */\n\tatomic_store_p(&elm->le_edata, bits, ATOMIC_RELEASE);\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nrtree_leaf_elm_write(tsdn_t *tsdn, rtree_t *rtree,\n rtree_leaf_elm_t *elm, rtree_contents_t contents) {\n\tassert((uintptr_t)contents.edata % EDATA_ALIGNMENT == 0);\n\tvoid *bits;\n\tunsigned additional;\n\n\trtree_contents_encode(contents, &bits, &additional);\n\trtree_leaf_elm_write_commit(tsdn, rtree, elm, bits, additional);\n}\n\n/* The state field can be updated independently (and more frequently). */\nJEMALLOC_ALWAYS_INLINE void\nrtree_leaf_elm_state_update(tsdn_t *tsdn, rtree_t *rtree,\n rtree_leaf_elm_t *elm1, rtree_leaf_elm_t *elm2, extent_state_t state) {\n\tassert(elm1 != NULL);\n#ifdef RTREE_LEAF_COMPACT\n\tuintptr_t bits = rtree_leaf_elm_bits_read(tsdn, rtree, elm1,\n\t /* dependent */ true);\n\tbits &= ~RTREE_LEAF_STATE_MASK;\n\tbits |= state << RTREE_LEAF_STATE_SHIFT;\n\tatomic_store_p(&elm1->le_bits, (void *)bits, ATOMIC_RELEASE);\n\tif (elm2 != NULL) {\n\t\tatomic_store_p(&elm2->le_bits, (void *)bits, ATOMIC_RELEASE);\n\t}\n#else\n\tunsigned bits = atomic_load_u(&elm1->le_metadata, ATOMIC_RELAXED);\n\tbits &= ~RTREE_LEAF_STATE_MASK;\n\tbits |= state << RTREE_LEAF_STATE_SHIFT;\n\tatomic_store_u(&elm1->le_metadata, bits, ATOMIC_RELEASE);\n\tif (elm2 != NULL) {\n\t\tatomic_store_u(&elm2->le_metadata, bits, ATOMIC_RELEASE);\n\t}\n#endif\n}\n\n/*\n * Tries to look up the key in the L1 cache, returning false if there's a hit, or\n * true if there's a miss.\n * Key is allowed to be NULL; returns true in this case.\n */\nJEMALLOC_ALWAYS_INLINE bool\nrtree_leaf_elm_lookup_fast(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key, rtree_leaf_elm_t **elm) {\n\tsize_t slot = rtree_cache_direct_map(key);\n\tuintptr_t leafkey = rtree_leafkey(key);\n\tassert(leafkey != RTREE_LEAFKEY_INVALID);\n\n\tif (unlikely(rtree_ctx->cache[slot].leafkey != leafkey)) {\n\t\treturn true;\n\t}\n\n\trtree_leaf_elm_t *leaf = rtree_ctx->cache[slot].leaf;\n\tassert(leaf != NULL);\n\tuintptr_t subkey = rtree_subkey(key, RTREE_HEIGHT-1);\n\t*elm = &leaf[subkey];\n\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE rtree_leaf_elm_t *\nrtree_leaf_elm_lookup(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key, bool dependent, bool init_missing) {\n\tassert(key != 0);\n\tassert(!dependent || !init_missing);\n\n\tsize_t slot = rtree_cache_direct_map(key);\n\tuintptr_t leafkey = rtree_leafkey(key);\n\tassert(leafkey != RTREE_LEAFKEY_INVALID);\n\n\t/* Fast path: L1 direct mapped cache. */\n\tif (likely(rtree_ctx->cache[slot].leafkey == leafkey)) {\n\t\trtree_leaf_elm_t *leaf = rtree_ctx->cache[slot].leaf;\n\t\tassert(leaf != NULL);\n\t\tuintptr_t subkey = rtree_subkey(key, RTREE_HEIGHT-1);\n\t\treturn &leaf[subkey];\n\t}\n\t/*\n\t * Search the L2 LRU cache. On hit, swap the matching element into the\n\t * slot in L1 cache, and move the position in L2 up by 1.\n\t */\n#define RTREE_CACHE_CHECK_L2(i) do {\t\t\t\t\t\\\n\tif (likely(rtree_ctx->l2_cache[i].leafkey == leafkey)) {\t\\\n\t\trtree_leaf_elm_t *leaf = rtree_ctx->l2_cache[i].leaf;\t\\\n\t\tassert(leaf != NULL);\t\t\t\t\t\\\n\t\tif (i > 0) {\t\t\t\t\t\t\\\n\t\t\t/* Bubble up by one. */\t\t\t\t\\\n\t\t\trtree_ctx->l2_cache[i].leafkey =\t\t\\\n\t\t\t\trtree_ctx->l2_cache[i - 1].leafkey;\t\\\n\t\t\trtree_ctx->l2_cache[i].leaf =\t\t\t\\\n\t\t\t\trtree_ctx->l2_cache[i - 1].leaf;\t\\\n\t\t\trtree_ctx->l2_cache[i - 1].leafkey =\t\t\\\n\t\t\t rtree_ctx->cache[slot].leafkey;\t\t\\\n\t\t\trtree_ctx->l2_cache[i - 1].leaf =\t\t\\\n\t\t\t rtree_ctx->cache[slot].leaf;\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\trtree_ctx->l2_cache[0].leafkey =\t\t\\\n\t\t\t rtree_ctx->cache[slot].leafkey;\t\t\\\n\t\t\trtree_ctx->l2_cache[0].leaf =\t\t\t\\\n\t\t\t rtree_ctx->cache[slot].leaf;\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\trtree_ctx->cache[slot].leafkey = leafkey;\t\t\\\n\t\trtree_ctx->cache[slot].leaf = leaf;\t\t\t\\\n\t\tuintptr_t subkey = rtree_subkey(key, RTREE_HEIGHT-1);\t\\\n\t\treturn &leaf[subkey];\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\t/* Check the first cache entry. */\n\tRTREE_CACHE_CHECK_L2(0);\n\t/* Search the remaining cache elements. */\n\tfor (unsigned i = 1; i < RTREE_CTX_NCACHE_L2; i++) {\n\t\tRTREE_CACHE_CHECK_L2(i);\n\t}\n#undef RTREE_CACHE_CHECK_L2\n\n\treturn rtree_leaf_elm_lookup_hard(tsdn, rtree, rtree_ctx, key,\n\t dependent, init_missing);\n}\n\n/*\n * Returns true on lookup failure.\n */\nstatic inline bool\nrtree_read_independent(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key, rtree_contents_t *r_contents) {\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx,\n\t key, /* dependent */ false, /* init_missing */ false);\n\tif (elm == NULL) {\n\t\treturn true;\n\t}\n\t*r_contents = rtree_leaf_elm_read(tsdn, rtree, elm,\n\t /* dependent */ false);\n\treturn false;\n}\n\nstatic inline rtree_contents_t\nrtree_read(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key) {\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx,\n\t key, /* dependent */ true, /* init_missing */ false);\n\tassert(elm != NULL);\n\treturn rtree_leaf_elm_read(tsdn, rtree, elm, /* dependent */ true);\n}\n\nstatic inline rtree_metadata_t\nrtree_metadata_read(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key) {\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx,\n\t key, /* dependent */ true, /* init_missing */ false);\n\tassert(elm != NULL);\n\treturn rtree_leaf_elm_read(tsdn, rtree, elm,\n\t /* dependent */ true).metadata;\n}\n\n/*\n * Returns true when the request cannot be fulfilled by fastpath.\n */\nstatic inline bool\nrtree_metadata_try_read_fast(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key, rtree_metadata_t *r_rtree_metadata) {\n\trtree_leaf_elm_t *elm;\n\t/*\n\t * Should check the bool return value (lookup success or not) instead of\n\t * elm == NULL (which will result in an extra branch). This is because\n\t * when the cache lookup succeeds, there will never be a NULL pointer\n\t * returned (which is unknown to the compiler).\n\t */\n\tif (rtree_leaf_elm_lookup_fast(tsdn, rtree, rtree_ctx, key, &elm)) {\n\t\treturn true;\n\t}\n\tassert(elm != NULL);\n\t*r_rtree_metadata = rtree_leaf_elm_read(tsdn, rtree, elm,\n\t /* dependent */ true).metadata;\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nrtree_write_range_impl(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t base, uintptr_t end, rtree_contents_t contents, bool clearing) {\n\tassert((base & PAGE_MASK) == 0 && (end & PAGE_MASK) == 0);\n\t/*\n\t * Only used for emap_(de)register_interior, which implies the\n\t * boundaries have been registered already. Therefore all the lookups\n\t * are dependent w/o init_missing, assuming the range spans across at\n\t * most 2 rtree leaf nodes (each covers 1 GiB of vaddr).\n\t */\n\tvoid *bits;\n\tunsigned additional;\n\trtree_contents_encode(contents, &bits, &additional);\n\n\trtree_leaf_elm_t *elm = NULL; /* Dead store. */\n\tfor (uintptr_t addr = base; addr <= end; addr += PAGE) {\n\t\tif (addr == base ||\n\t\t (addr & ((ZU(1) << rtree_leaf_maskbits()) - 1)) == 0) {\n\t\t\telm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx, addr,\n\t\t\t /* dependent */ true, /* init_missing */ false);\n\t\t\tassert(elm != NULL);\n\t\t}\n\t\tassert(elm == rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx, addr,\n\t\t /* dependent */ true, /* init_missing */ false));\n\t\tassert(!clearing || rtree_leaf_elm_read(tsdn, rtree, elm,\n\t\t /* dependent */ true).edata != NULL);\n\t\trtree_leaf_elm_write_commit(tsdn, rtree, elm, bits, additional);\n\t\telm++;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nrtree_write_range(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t base, uintptr_t end, rtree_contents_t contents) {\n\trtree_write_range_impl(tsdn, rtree, rtree_ctx, base, end, contents,\n\t /* clearing */ false);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nrtree_write(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx, uintptr_t key,\n rtree_contents_t contents) {\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx,\n\t key, /* dependent */ false, /* init_missing */ true);\n\tif (elm == NULL) {\n\t\treturn true;\n\t}\n\n\trtree_leaf_elm_write(tsdn, rtree, elm, contents);\n\n\treturn false;\n}\n\nstatic inline void\nrtree_clear(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key) {\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree, rtree_ctx,\n\t key, /* dependent */ true, /* init_missing */ false);\n\tassert(elm != NULL);\n\tassert(rtree_leaf_elm_read(tsdn, rtree, elm,\n\t /* dependent */ true).edata != NULL);\n\trtree_contents_t contents;\n\tcontents.edata = NULL;\n\tcontents.metadata.szind = SC_NSIZES;\n\tcontents.metadata.slab = false;\n\tcontents.metadata.is_head = false;\n\tcontents.metadata.state = (extent_state_t)0;\n\trtree_leaf_elm_write(tsdn, rtree, elm, contents);\n}\n\nstatic inline void\nrtree_clear_range(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t base, uintptr_t end) {\n\trtree_contents_t contents;\n\tcontents.edata = NULL;\n\tcontents.metadata.szind = SC_NSIZES;\n\tcontents.metadata.slab = false;\n\tcontents.metadata.is_head = false;\n\tcontents.metadata.state = (extent_state_t)0;\n\trtree_write_range_impl(tsdn, rtree, rtree_ctx, base, end, contents,\n\t /* clearing */ true);\n}\n\n#endif /* JEMALLOC_INTERNAL_RTREE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/rtree_tsd.h", "content": "#ifndef JEMALLOC_INTERNAL_RTREE_CTX_H\n#define JEMALLOC_INTERNAL_RTREE_CTX_H\n\n/*\n * Number of leafkey/leaf pairs to cache in L1 and L2 level respectively. Each\n * entry supports an entire leaf, so the cache hit rate is typically high even\n * with a small number of entries. In rare cases extent activity will straddle\n * the boundary between two leaf nodes. Furthermore, an arena may use a\n * combination of dss and mmap. Note that as memory usage grows past the amount\n * that this cache can directly cover, the cache will become less effective if\n * locality of reference is low, but the consequence is merely cache misses\n * while traversing the tree nodes.\n *\n * The L1 direct mapped cache offers consistent and low cost on cache hit.\n * However collision could affect hit rate negatively. This is resolved by\n * combining with a L2 LRU cache, which requires linear search and re-ordering\n * on access but suffers no collision. Note that, the cache will itself suffer\n * cache misses if made overly large, plus the cost of linear search in the LRU\n * cache.\n */\n#define RTREE_CTX_NCACHE 16\n#define RTREE_CTX_NCACHE_L2 8\n\n/* Needed for initialization only. */\n#define RTREE_LEAFKEY_INVALID ((uintptr_t)1)\n#define RTREE_CTX_CACHE_ELM_INVALID {RTREE_LEAFKEY_INVALID, NULL}\n\n#define RTREE_CTX_INIT_ELM_1 RTREE_CTX_CACHE_ELM_INVALID\n#define RTREE_CTX_INIT_ELM_2 RTREE_CTX_INIT_ELM_1, RTREE_CTX_INIT_ELM_1\n#define RTREE_CTX_INIT_ELM_4 RTREE_CTX_INIT_ELM_2, RTREE_CTX_INIT_ELM_2\n#define RTREE_CTX_INIT_ELM_8 RTREE_CTX_INIT_ELM_4, RTREE_CTX_INIT_ELM_4\n#define RTREE_CTX_INIT_ELM_16 RTREE_CTX_INIT_ELM_8, RTREE_CTX_INIT_ELM_8\n\n#define _RTREE_CTX_INIT_ELM_DATA(n) RTREE_CTX_INIT_ELM_##n\n#define RTREE_CTX_INIT_ELM_DATA(n) _RTREE_CTX_INIT_ELM_DATA(n)\n\n/*\n * Static initializer (to invalidate the cache entries) is required because the\n * free fastpath may access the rtree cache before a full tsd initialization.\n */\n#define RTREE_CTX_INITIALIZER {{RTREE_CTX_INIT_ELM_DATA(RTREE_CTX_NCACHE)}, \\\n\t\t\t {RTREE_CTX_INIT_ELM_DATA(RTREE_CTX_NCACHE_L2)}}\n\ntypedef struct rtree_leaf_elm_s rtree_leaf_elm_t;\n\ntypedef struct rtree_ctx_cache_elm_s rtree_ctx_cache_elm_t;\nstruct rtree_ctx_cache_elm_s {\n\tuintptr_t\t\tleafkey;\n\trtree_leaf_elm_t\t*leaf;\n};\n\ntypedef struct rtree_ctx_s rtree_ctx_t;\nstruct rtree_ctx_s {\n\t/* Direct mapped cache. */\n\trtree_ctx_cache_elm_t\tcache[RTREE_CTX_NCACHE];\n\t/* L2 LRU cache. */\n\trtree_ctx_cache_elm_t\tl2_cache[RTREE_CTX_NCACHE_L2];\n};\n\nvoid rtree_ctx_data_init(rtree_ctx_t *ctx);\n\n#endif /* JEMALLOC_INTERNAL_RTREE_CTX_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/safety_check.h", "content": "#ifndef JEMALLOC_INTERNAL_SAFETY_CHECK_H\n#define JEMALLOC_INTERNAL_SAFETY_CHECK_H\n\nvoid safety_check_fail_sized_dealloc(bool current_dealloc, const void *ptr,\n size_t true_size, size_t input_size);\nvoid safety_check_fail(const char *format, ...);\n\ntypedef void (*safety_check_abort_hook_t)(const char *message);\n\n/* Can set to NULL for a default. */\nvoid safety_check_set_abort(safety_check_abort_hook_t abort_fn);\n\nJEMALLOC_ALWAYS_INLINE void\nsafety_check_set_redzone(void *ptr, size_t usize, size_t bumped_usize) {\n\tassert(usize < bumped_usize);\n\tfor (size_t i = usize; i < bumped_usize && i < usize + 32; ++i) {\n\t\t*((unsigned char *)ptr + i) = 0xBC;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nsafety_check_verify_redzone(const void *ptr, size_t usize, size_t bumped_usize)\n{\n\tfor (size_t i = usize; i < bumped_usize && i < usize + 32; ++i) {\n\t\tif (unlikely(*((unsigned char *)ptr + i) != 0xBC)) {\n\t\t\tsafety_check_fail(\"Use after free error\\n\");\n\t\t}\n\t}\n}\n\n#endif /*JEMALLOC_INTERNAL_SAFETY_CHECK_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/san.h", "content": "#ifndef JEMALLOC_INTERNAL_GUARD_H\n#define JEMALLOC_INTERNAL_GUARD_H\n\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/emap.h\"\n\n#define SAN_PAGE_GUARD PAGE\n#define SAN_PAGE_GUARDS_SIZE (SAN_PAGE_GUARD * 2)\n\n#define SAN_GUARD_LARGE_EVERY_N_EXTENTS_DEFAULT 0\n#define SAN_GUARD_SMALL_EVERY_N_EXTENTS_DEFAULT 0\n\n#define SAN_LG_UAF_ALIGN_DEFAULT (-1)\n#define SAN_CACHE_BIN_NONFAST_MASK_DEFAULT (uintptr_t)(-1)\n\nstatic const uintptr_t uaf_detect_junk = (uintptr_t)0x5b5b5b5b5b5b5b5bULL;\n\n/* 0 means disabled, i.e. never guarded. */\nextern size_t opt_san_guard_large;\nextern size_t opt_san_guard_small;\n/* -1 means disabled, i.e. never check for use-after-free. */\nextern ssize_t opt_lg_san_uaf_align;\n\nvoid san_guard_pages(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap, bool left, bool right, bool remap);\nvoid san_unguard_pages(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap, bool left, bool right);\n/*\n * Unguard the extent, but don't modify emap boundaries. Must be called on an\n * extent that has been erased from emap and shouldn't be placed back.\n */\nvoid san_unguard_pages_pre_destroy(tsdn_t *tsdn, ehooks_t *ehooks,\n edata_t *edata, emap_t *emap);\nvoid san_check_stashed_ptrs(void **ptrs, size_t nstashed, size_t usize);\n\nvoid tsd_san_init(tsd_t *tsd);\nvoid san_init(ssize_t lg_san_uaf_align);\n\nstatic inline void\nsan_guard_pages_two_sided(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap, bool remap) {\n\tsan_guard_pages(tsdn, ehooks, edata, emap, true, true, remap);\n}\n\nstatic inline void\nsan_unguard_pages_two_sided(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap) {\n\tsan_unguard_pages(tsdn, ehooks, edata, emap, true, true);\n}\n\nstatic inline size_t\nsan_two_side_unguarded_sz(size_t size) {\n\tassert(size % PAGE == 0);\n\tassert(size >= SAN_PAGE_GUARDS_SIZE);\n\treturn size - SAN_PAGE_GUARDS_SIZE;\n}\n\nstatic inline size_t\nsan_two_side_guarded_sz(size_t size) {\n\tassert(size % PAGE == 0);\n\treturn size + SAN_PAGE_GUARDS_SIZE;\n}\n\nstatic inline size_t\nsan_one_side_unguarded_sz(size_t size) {\n\tassert(size % PAGE == 0);\n\tassert(size >= SAN_PAGE_GUARD);\n\treturn size - SAN_PAGE_GUARD;\n}\n\nstatic inline size_t\nsan_one_side_guarded_sz(size_t size) {\n\tassert(size % PAGE == 0);\n\treturn size + SAN_PAGE_GUARD;\n}\n\nstatic inline bool\nsan_guard_enabled(void) {\n\treturn (opt_san_guard_large != 0 || opt_san_guard_small != 0);\n}\n\nstatic inline bool\nsan_large_extent_decide_guard(tsdn_t *tsdn, ehooks_t *ehooks, size_t size,\n size_t alignment) {\n\tif (opt_san_guard_large == 0 || ehooks_guard_will_fail(ehooks) ||\n\t tsdn_null(tsdn)) {\n\t\treturn false;\n\t}\n\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\tuint64_t n = tsd_san_extents_until_guard_large_get(tsd);\n\tassert(n >= 1);\n\tif (n > 1) {\n\t\t/*\n\t\t * Subtract conditionally because the guard may not happen due\n\t\t * to alignment or size restriction below.\n\t\t */\n\t\t*tsd_san_extents_until_guard_largep_get(tsd) = n - 1;\n\t}\n\n\tif (n == 1 && (alignment <= PAGE) &&\n\t (san_two_side_guarded_sz(size) <= SC_LARGE_MAXCLASS)) {\n\t\t*tsd_san_extents_until_guard_largep_get(tsd) =\n\t\t opt_san_guard_large;\n\t\treturn true;\n\t} else {\n\t\tassert(tsd_san_extents_until_guard_large_get(tsd) >= 1);\n\t\treturn false;\n\t}\n}\n\nstatic inline bool\nsan_slab_extent_decide_guard(tsdn_t *tsdn, ehooks_t *ehooks) {\n\tif (opt_san_guard_small == 0 || ehooks_guard_will_fail(ehooks) ||\n\t tsdn_null(tsdn)) {\n\t\treturn false;\n\t}\n\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\tuint64_t n = tsd_san_extents_until_guard_small_get(tsd);\n\tassert(n >= 1);\n\tif (n == 1) {\n\t\t*tsd_san_extents_until_guard_smallp_get(tsd) =\n\t\t opt_san_guard_small;\n\t\treturn true;\n\t} else {\n\t\t*tsd_san_extents_until_guard_smallp_get(tsd) = n - 1;\n\t\tassert(tsd_san_extents_until_guard_small_get(tsd) >= 1);\n\t\treturn false;\n\t}\n}\n\nstatic inline void\nsan_junk_ptr_locations(void *ptr, size_t usize, void **first, void **mid,\n void **last) {\n\tsize_t ptr_sz = sizeof(void *);\n\n\t*first = ptr;\n\n\t*mid = (void *)((uintptr_t)ptr + ((usize >> 1) & ~(ptr_sz - 1)));\n\tassert(*first != *mid || usize == ptr_sz);\n\tassert((uintptr_t)*first <= (uintptr_t)*mid);\n\n\t/*\n\t * When usize > 32K, the gap between requested_size and usize might be\n\t * greater than 4K -- this means the last write may access an\n\t * likely-untouched page (default settings w/ 4K pages). However by\n\t * default the tcache only goes up to the 32K size class, and is usually\n\t * tuned lower instead of higher, which makes it less of a concern.\n\t */\n\t*last = (void *)((uintptr_t)ptr + usize - sizeof(uaf_detect_junk));\n\tassert(*first != *last || usize == ptr_sz);\n\tassert(*mid != *last || usize <= ptr_sz * 2);\n\tassert((uintptr_t)*mid <= (uintptr_t)*last);\n}\n\nstatic inline bool\nsan_junk_ptr_should_slow(void) {\n\t/*\n\t * The latter condition (pointer size greater than the min size class)\n\t * is not expected -- fall back to the slow path for simplicity.\n\t */\n\treturn config_debug || (LG_SIZEOF_PTR > SC_LG_TINY_MIN);\n}\n\nstatic inline void\nsan_junk_ptr(void *ptr, size_t usize) {\n\tif (san_junk_ptr_should_slow()) {\n\t\tmemset(ptr, (char)uaf_detect_junk, usize);\n\t\treturn;\n\t}\n\n\tvoid *first, *mid, *last;\n\tsan_junk_ptr_locations(ptr, usize, &first, &mid, &last);\n\t*(uintptr_t *)first = uaf_detect_junk;\n\t*(uintptr_t *)mid = uaf_detect_junk;\n\t*(uintptr_t *)last = uaf_detect_junk;\n}\n\nstatic inline bool\nsan_uaf_detection_enabled(void) {\n\tbool ret = config_uaf_detection && (opt_lg_san_uaf_align != -1);\n\tif (config_uaf_detection && ret) {\n\t\tassert(san_cache_bin_nonfast_mask == ((uintptr_t)1 <<\n\t\t opt_lg_san_uaf_align) - 1);\n\t}\n\n\treturn ret;\n}\n\n#endif /* JEMALLOC_INTERNAL_GUARD_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/san_bump.h", "content": "#ifndef JEMALLOC_INTERNAL_SAN_BUMP_H\n#define JEMALLOC_INTERNAL_SAN_BUMP_H\n\n#include \"jemalloc/internal/edata.h\"\n#include \"jemalloc/internal/exp_grow.h\"\n#include \"jemalloc/internal/mutex.h\"\n\n#define SBA_RETAINED_ALLOC_SIZE ((size_t)4 << 20)\n\nextern bool opt_retain;\n\ntypedef struct ehooks_s ehooks_t;\ntypedef struct pac_s pac_t;\n\ntypedef struct san_bump_alloc_s san_bump_alloc_t;\nstruct san_bump_alloc_s {\n\tmalloc_mutex_t mtx;\n\n\tedata_t *curr_reg;\n};\n\nstatic inline bool\nsan_bump_enabled() {\n\t/*\n\t * We enable san_bump allocator only when it's possible to break up a\n\t * mapping and unmap a part of it (maps_coalesce). This is needed to\n\t * ensure the arena destruction process can destroy all retained guarded\n\t * extents one by one and to unmap a trailing part of a retained guarded\n\t * region when it's too small to fit a pending allocation.\n\t * opt_retain is required, because this allocator retains a large\n\t * virtual memory mapping and returns smaller parts of it.\n\t */\n\treturn maps_coalesce && opt_retain;\n}\n\nstatic inline bool\nsan_bump_alloc_init(san_bump_alloc_t* sba) {\n\tbool err = malloc_mutex_init(&sba->mtx, \"sanitizer_bump_allocator\",\n\t WITNESS_RANK_SAN_BUMP_ALLOC, malloc_mutex_rank_exclusive);\n\tif (err) {\n\t\treturn true;\n\t}\n\tsba->curr_reg = NULL;\n\n\treturn false;\n}\n\nedata_t *\nsan_bump_alloc(tsdn_t *tsdn, san_bump_alloc_t* sba, pac_t *pac, ehooks_t *ehooks,\n size_t size, bool zero);\n\n#endif /* JEMALLOC_INTERNAL_SAN_BUMP_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/sc.h", "content": "#ifndef JEMALLOC_INTERNAL_SC_H\n#define JEMALLOC_INTERNAL_SC_H\n\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n\n/*\n * Size class computations:\n *\n * These are a little tricky; we'll first start by describing how things\n * generally work, and then describe some of the details.\n *\n * Ignore the first few size classes for a moment. We can then split all the\n * remaining size classes into groups. The size classes in a group are spaced\n * such that they cover allocation request sizes in a power-of-2 range. The\n * power of two is called the base of the group, and the size classes in it\n * satisfy allocations in the half-open range (base, base * 2]. There are\n * SC_NGROUP size classes in each group, equally spaced in the range, so that\n * each one covers allocations for base / SC_NGROUP possible allocation sizes.\n * We call that value (base / SC_NGROUP) the delta of the group. Each size class\n * is delta larger than the one before it (including the initial size class in a\n * group, which is delta larger than base, the largest size class in the\n * previous group).\n * To make the math all work out nicely, we require that SC_NGROUP is a power of\n * two, and define it in terms of SC_LG_NGROUP. We'll often talk in terms of\n * lg_base and lg_delta. For each of these groups then, we have that\n * lg_delta == lg_base - SC_LG_NGROUP.\n * The size classes in a group with a given lg_base and lg_delta (which, recall,\n * can be computed from lg_base for these groups) are therefore:\n * base + 1 * delta\n * which covers allocations in (base, base + 1 * delta]\n * base + 2 * delta\n * which covers allocations in (base + 1 * delta, base + 2 * delta].\n * base + 3 * delta\n * which covers allocations in (base + 2 * delta, base + 3 * delta].\n * ...\n * base + SC_NGROUP * delta ( == 2 * base)\n * which covers allocations in (base + (SC_NGROUP - 1) * delta, 2 * base].\n * (Note that currently SC_NGROUP is always 4, so the \"...\" is empty in\n * practice.)\n * Note that the last size class in the group is the next power of two (after\n * base), so that we've set up the induction correctly for the next group's\n * selection of delta.\n *\n * Now, let's start considering the first few size classes. Two extra constants\n * come into play here: LG_QUANTUM and SC_LG_TINY_MIN. LG_QUANTUM ensures\n * correct platform alignment; all objects of size (1 << LG_QUANTUM) or larger\n * are at least (1 << LG_QUANTUM) aligned; this can be used to ensure that we\n * never return improperly aligned memory, by making (1 << LG_QUANTUM) equal the\n * highest required alignment of a platform. For allocation sizes smaller than\n * (1 << LG_QUANTUM) though, we can be more relaxed (since we don't support\n * platforms with types with alignment larger than their size). To allow such\n * allocations (without wasting space unnecessarily), we introduce tiny size\n * classes; one per power of two, up until we hit the quantum size. There are\n * therefore LG_QUANTUM - SC_LG_TINY_MIN such size classes.\n *\n * Next, we have a size class of size (1 << LG_QUANTUM). This can't be the\n * start of a group in the sense we described above (covering a power of two\n * range) since, if we divided into it to pick a value of delta, we'd get a\n * delta smaller than (1 << LG_QUANTUM) for sizes >= (1 << LG_QUANTUM), which\n * is against the rules.\n *\n * The first base we can divide by SC_NGROUP while still being at least\n * (1 << LG_QUANTUM) is SC_NGROUP * (1 << LG_QUANTUM). We can get there by\n * having SC_NGROUP size classes, spaced (1 << LG_QUANTUM) apart. These size\n * classes are:\n * 1 * (1 << LG_QUANTUM)\n * 2 * (1 << LG_QUANTUM)\n * 3 * (1 << LG_QUANTUM)\n * ... (although, as above, this \"...\" is empty in practice)\n * SC_NGROUP * (1 << LG_QUANTUM).\n *\n * There are SC_NGROUP of these size classes, so we can regard it as a sort of\n * pseudo-group, even though it spans multiple powers of 2, is divided\n * differently, and both starts and ends on a power of 2 (as opposed to just\n * ending). SC_NGROUP is itself a power of two, so the first group after the\n * pseudo-group has the power-of-two base SC_NGROUP * (1 << LG_QUANTUM), for a\n * lg_base of LG_QUANTUM + SC_LG_NGROUP. We can divide this base into SC_NGROUP\n * sizes without violating our LG_QUANTUM requirements, so we can safely set\n * lg_delta = lg_base - SC_LG_GROUP (== LG_QUANTUM).\n *\n * So, in order, the size classes are:\n *\n * Tiny size classes:\n * - Count: LG_QUANTUM - SC_LG_TINY_MIN.\n * - Sizes:\n * 1 << SC_LG_TINY_MIN\n * 1 << (SC_LG_TINY_MIN + 1)\n * 1 << (SC_LG_TINY_MIN + 2)\n * ...\n * 1 << (LG_QUANTUM - 1)\n *\n * Initial pseudo-group:\n * - Count: SC_NGROUP\n * - Sizes:\n * 1 * (1 << LG_QUANTUM)\n * 2 * (1 << LG_QUANTUM)\n * 3 * (1 << LG_QUANTUM)\n * ...\n * SC_NGROUP * (1 << LG_QUANTUM)\n *\n * Regular group 0:\n * - Count: SC_NGROUP\n * - Sizes:\n * (relative to lg_base of LG_QUANTUM + SC_LG_NGROUP and lg_delta of\n * lg_base - SC_LG_NGROUP)\n * (1 << lg_base) + 1 * (1 << lg_delta)\n * (1 << lg_base) + 2 * (1 << lg_delta)\n * (1 << lg_base) + 3 * (1 << lg_delta)\n * ...\n * (1 << lg_base) + SC_NGROUP * (1 << lg_delta) [ == (1 << (lg_base + 1)) ]\n *\n * Regular group 1:\n * - Count: SC_NGROUP\n * - Sizes:\n * (relative to lg_base of LG_QUANTUM + SC_LG_NGROUP + 1 and lg_delta of\n * lg_base - SC_LG_NGROUP)\n * (1 << lg_base) + 1 * (1 << lg_delta)\n * (1 << lg_base) + 2 * (1 << lg_delta)\n * (1 << lg_base) + 3 * (1 << lg_delta)\n * ...\n * (1 << lg_base) + SC_NGROUP * (1 << lg_delta) [ == (1 << (lg_base + 1)) ]\n *\n * ...\n *\n * Regular group N:\n * - Count: SC_NGROUP\n * - Sizes:\n * (relative to lg_base of LG_QUANTUM + SC_LG_NGROUP + N and lg_delta of\n * lg_base - SC_LG_NGROUP)\n * (1 << lg_base) + 1 * (1 << lg_delta)\n * (1 << lg_base) + 2 * (1 << lg_delta)\n * (1 << lg_base) + 3 * (1 << lg_delta)\n * ...\n * (1 << lg_base) + SC_NGROUP * (1 << lg_delta) [ == (1 << (lg_base + 1)) ]\n *\n *\n * Representation of metadata:\n * To make the math easy, we'll mostly work in lg quantities. We record lg_base,\n * lg_delta, and ndelta (i.e. number of deltas above the base) on a\n * per-size-class basis, and maintain the invariant that, across all size\n * classes, size == (1 << lg_base) + ndelta * (1 << lg_delta).\n *\n * For regular groups (i.e. those with lg_base >= LG_QUANTUM + SC_LG_NGROUP),\n * lg_delta is lg_base - SC_LG_NGROUP, and ndelta goes from 1 to SC_NGROUP.\n *\n * For the initial tiny size classes (if any), lg_base is lg(size class size).\n * lg_delta is lg_base for the first size class, and lg_base - 1 for all\n * subsequent ones. ndelta is always 0.\n *\n * For the pseudo-group, if there are no tiny size classes, then we set\n * lg_base == LG_QUANTUM, lg_delta == LG_QUANTUM, and have ndelta range from 0\n * to SC_NGROUP - 1. (Note that delta == base, so base + (SC_NGROUP - 1) * delta\n * is just SC_NGROUP * base, or (1 << (SC_LG_NGROUP + LG_QUANTUM)), so we do\n * indeed get a power of two that way). If there *are* tiny size classes, then\n * the first size class needs to have lg_delta relative to the largest tiny size\n * class. We therefore set lg_base == LG_QUANTUM - 1,\n * lg_delta == LG_QUANTUM - 1, and ndelta == 1, keeping the rest of the\n * pseudo-group the same.\n *\n *\n * Other terminology:\n * \"Small\" size classes mean those that are allocated out of bins, which is the\n * same as those that are slab allocated.\n * \"Large\" size classes are those that are not small. The cutoff for counting as\n * large is page size * group size.\n */\n\n/*\n * Size class N + (1 << SC_LG_NGROUP) twice the size of size class N.\n */\n#define SC_LG_NGROUP 2\n#define SC_LG_TINY_MIN 3\n\n#if SC_LG_TINY_MIN == 0\n/* The div module doesn't support division by 1, which this would require. */\n#error \"Unsupported LG_TINY_MIN\"\n#endif\n\n/*\n * The definitions below are all determined by the above settings and system\n * characteristics.\n */\n#define SC_NGROUP (1ULL << SC_LG_NGROUP)\n#define SC_PTR_BITS ((1ULL << LG_SIZEOF_PTR) * 8)\n#define SC_NTINY (LG_QUANTUM - SC_LG_TINY_MIN)\n#define SC_LG_TINY_MAXCLASS (LG_QUANTUM > SC_LG_TINY_MIN ? LG_QUANTUM - 1 : -1)\n#define SC_NPSEUDO SC_NGROUP\n#define SC_LG_FIRST_REGULAR_BASE (LG_QUANTUM + SC_LG_NGROUP)\n/*\n * We cap allocations to be less than 2 ** (ptr_bits - 1), so the highest base\n * we need is 2 ** (ptr_bits - 2). (This also means that the last group is 1\n * size class shorter than the others).\n * We could probably save some space in arenas by capping this at LG_VADDR size.\n */\n#define SC_LG_BASE_MAX (SC_PTR_BITS - 2)\n#define SC_NREGULAR (SC_NGROUP * \t\t\t\t\t\\\n (SC_LG_BASE_MAX - SC_LG_FIRST_REGULAR_BASE + 1) - 1)\n#define SC_NSIZES (SC_NTINY + SC_NPSEUDO + SC_NREGULAR)\n\n/*\n * The number of size classes that are a multiple of the page size.\n *\n * Here are the first few bases that have a page-sized SC.\n *\n * lg(base) | base | highest SC | page-multiple SCs\n * --------------|------------------------------------------\n * LG_PAGE - 1 | PAGE / 2 | PAGE | 1\n * LG_PAGE | PAGE | 2 * PAGE | 1\n * LG_PAGE + 1 | 2 * PAGE | 4 * PAGE | 2\n * LG_PAGE + 2 | 4 * PAGE | 8 * PAGE | 4\n *\n * The number of page-multiple SCs continues to grow in powers of two, up until\n * lg_delta == lg_page, which corresponds to setting lg_base to lg_page +\n * SC_LG_NGROUP. So, then, the number of size classes that are multiples of the\n * page size whose lg_delta is less than the page size are\n * is 1 + (2**0 + 2**1 + ... + 2**(lg_ngroup - 1) == 2**lg_ngroup.\n *\n * For each base with lg_base in [lg_page + lg_ngroup, lg_base_max), there are\n * NGROUP page-sized size classes, and when lg_base == lg_base_max, there are\n * NGROUP - 1.\n *\n * This gives us the quantity we seek.\n */\n#define SC_NPSIZES (\t\t\t\t\t\t\t\\\n SC_NGROUP\t\t\t\t\t\t\t\t\\\n + (SC_LG_BASE_MAX - (LG_PAGE + SC_LG_NGROUP)) * SC_NGROUP\t\t\\\n + SC_NGROUP - 1)\n\n/*\n * We declare a size class is binnable if size < page size * group. Or, in other\n * words, lg(size) < lg(page size) + lg(group size).\n */\n#define SC_NBINS (\t\t\t\t\t\t\t\\\n /* Sub-regular size classes. */\t\t\t\t\t\\\n SC_NTINY + SC_NPSEUDO\t\t\t\t\t\t\\\n /* Groups with lg_regular_min_base <= lg_base <= lg_base_max */\t\\\n + SC_NGROUP * (LG_PAGE + SC_LG_NGROUP - SC_LG_FIRST_REGULAR_BASE)\t\\\n /* Last SC of the last group hits the bound exactly; exclude it. */\t\\\n - 1)\n\n/*\n * The size2index_tab lookup table uses uint8_t to encode each bin index, so we\n * cannot support more than 256 small size classes.\n */\n#if (SC_NBINS > 256)\n# error \"Too many small size classes\"\n#endif\n\n/* The largest size class in the lookup table, and its binary log. */\n#define SC_LG_MAX_LOOKUP 12\n#define SC_LOOKUP_MAXCLASS (1 << SC_LG_MAX_LOOKUP)\n\n/* Internal, only used for the definition of SC_SMALL_MAXCLASS. */\n#define SC_SMALL_MAX_BASE (1 << (LG_PAGE + SC_LG_NGROUP - 1))\n#define SC_SMALL_MAX_DELTA (1 << (LG_PAGE - 1))\n\n/* The largest size class allocated out of a slab. */\n#define SC_SMALL_MAXCLASS (SC_SMALL_MAX_BASE\t\t\t\t\\\n + (SC_NGROUP - 1) * SC_SMALL_MAX_DELTA)\n\n/* The fastpath assumes all lookup-able sizes are small. */\n#if (SC_SMALL_MAXCLASS < SC_LOOKUP_MAXCLASS)\n# error \"Lookup table sizes must be small\"\n#endif\n\n/* The smallest size class not allocated out of a slab. */\n#define SC_LARGE_MINCLASS ((size_t)1ULL << (LG_PAGE + SC_LG_NGROUP))\n#define SC_LG_LARGE_MINCLASS (LG_PAGE + SC_LG_NGROUP)\n\n/* Internal; only used for the definition of SC_LARGE_MAXCLASS. */\n#define SC_MAX_BASE ((size_t)1 << (SC_PTR_BITS - 2))\n#define SC_MAX_DELTA ((size_t)1 << (SC_PTR_BITS - 2 - SC_LG_NGROUP))\n\n/* The largest size class supported. */\n#define SC_LARGE_MAXCLASS (SC_MAX_BASE + (SC_NGROUP - 1) * SC_MAX_DELTA)\n\n/* Maximum number of regions in one slab. */\n#ifndef CONFIG_LG_SLAB_MAXREGS\n# define SC_LG_SLAB_MAXREGS (LG_PAGE - SC_LG_TINY_MIN)\n#else\n# if CONFIG_LG_SLAB_MAXREGS < (LG_PAGE - SC_LG_TINY_MIN)\n# error \"Unsupported SC_LG_SLAB_MAXREGS\"\n# else\n# define SC_LG_SLAB_MAXREGS CONFIG_LG_SLAB_MAXREGS\n# endif\n#endif\n\n#define SC_SLAB_MAXREGS (1U << SC_LG_SLAB_MAXREGS)\n\ntypedef struct sc_s sc_t;\nstruct sc_s {\n\t/* Size class index, or -1 if not a valid size class. */\n\tint index;\n\t/* Lg group base size (no deltas added). */\n\tint lg_base;\n\t/* Lg delta to previous size class. */\n\tint lg_delta;\n\t/* Delta multiplier. size == 1<bytes += src->bytes;\n}\n\n/* A collections of free extents, all of the same size. */\ntypedef struct sec_bin_s sec_bin_t;\nstruct sec_bin_s {\n\t/*\n\t * When we fail to fulfill an allocation, we do a batch-alloc on the\n\t * underlying allocator to fill extra items, as well. We drop the SEC\n\t * lock while doing so, to allow operations on other bins to succeed.\n\t * That introduces the possibility of other threads also trying to\n\t * allocate out of this bin, failing, and also going to the backing\n\t * allocator. To avoid a thundering herd problem in which lots of\n\t * threads do batch allocs and overfill this bin as a result, we only\n\t * allow one batch allocation at a time for a bin. This bool tracks\n\t * whether or not some thread is already batch allocating.\n\t *\n\t * Eventually, the right answer may be a smarter sharding policy for the\n\t * bins (e.g. a mutex per bin, which would also be more scalable\n\t * generally; the batch-allocating thread could hold it while\n\t * batch-allocating).\n\t */\n\tbool being_batch_filled;\n\n\t/*\n\t * Number of bytes in this particular bin (as opposed to the\n\t * sec_shard_t's bytes_cur. This isn't user visible or reported in\n\t * stats; rather, it allows us to quickly determine the change in the\n\t * centralized counter when flushing.\n\t */\n\tsize_t bytes_cur;\n\tedata_list_active_t freelist;\n};\n\ntypedef struct sec_shard_s sec_shard_t;\nstruct sec_shard_s {\n\t/*\n\t * We don't keep per-bin mutexes, even though that would allow more\n\t * sharding; this allows global cache-eviction, which in turn allows for\n\t * better balancing across free lists.\n\t */\n\tmalloc_mutex_t mtx;\n\t/*\n\t * A SEC may need to be shut down (i.e. flushed of its contents and\n\t * prevented from further caching). To avoid tricky synchronization\n\t * issues, we just track enabled-status in each shard, guarded by a\n\t * mutex. In practice, this is only ever checked during brief races,\n\t * since the arena-level atomic boolean tracking HPA enabled-ness means\n\t * that we won't go down these pathways very often after custom extent\n\t * hooks are installed.\n\t */\n\tbool enabled;\n\tsec_bin_t *bins;\n\t/* Number of bytes in all bins in the shard. */\n\tsize_t bytes_cur;\n\t/* The next pszind to flush in the flush-some pathways. */\n\tpszind_t to_flush_next;\n};\n\ntypedef struct sec_s sec_t;\nstruct sec_s {\n\tpai_t pai;\n\tpai_t *fallback;\n\n\tsec_opts_t opts;\n\tsec_shard_t *shards;\n\tpszind_t npsizes;\n};\n\nbool sec_init(tsdn_t *tsdn, sec_t *sec, base_t *base, pai_t *fallback,\n const sec_opts_t *opts);\nvoid sec_flush(tsdn_t *tsdn, sec_t *sec);\nvoid sec_disable(tsdn_t *tsdn, sec_t *sec);\n\n/*\n * Morally, these two stats methods probably ought to be a single one (and the\n * mutex_prof_data ought to live in the sec_stats_t. But splitting them apart\n * lets them fit easily into the pa_shard stats framework (which also has this\n * split), which simplifies the stats management.\n */\nvoid sec_stats_merge(tsdn_t *tsdn, sec_t *sec, sec_stats_t *stats);\nvoid sec_mutex_stats_read(tsdn_t *tsdn, sec_t *sec,\n mutex_prof_data_t *mutex_prof_data);\n\n/*\n * We use the arena lock ordering; these are acquired in phase 2 of forking, but\n * should be acquired before the underlying allocator mutexes.\n */\nvoid sec_prefork2(tsdn_t *tsdn, sec_t *sec);\nvoid sec_postfork_parent(tsdn_t *tsdn, sec_t *sec);\nvoid sec_postfork_child(tsdn_t *tsdn, sec_t *sec);\n\n#endif /* JEMALLOC_INTERNAL_SEC_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/sec_opts.h", "content": "#ifndef JEMALLOC_INTERNAL_SEC_OPTS_H\n#define JEMALLOC_INTERNAL_SEC_OPTS_H\n\n/*\n * The configuration settings used by an sec_t. Morally, this is part of the\n * SEC interface, but we put it here for header-ordering reasons.\n */\n\ntypedef struct sec_opts_s sec_opts_t;\nstruct sec_opts_s {\n\t/*\n\t * We don't necessarily always use all the shards; requests are\n\t * distributed across shards [0, nshards - 1).\n\t */\n\tsize_t nshards;\n\t/*\n\t * We'll automatically refuse to cache any objects in this sec if\n\t * they're larger than max_alloc bytes, instead forwarding such objects\n\t * directly to the fallback.\n\t */\n\tsize_t max_alloc;\n\t/*\n\t * Exceeding this amount of cached extents in a shard causes us to start\n\t * flushing bins in that shard until we fall below bytes_after_flush.\n\t */\n\tsize_t max_bytes;\n\t/*\n\t * The number of bytes (in all bins) we flush down to when we exceed\n\t * bytes_cur. We want this to be less than bytes_cur, because\n\t * otherwise we could get into situations where a shard undergoing\n\t * net-deallocation keeps bytes_cur very near to max_bytes, so that\n\t * most deallocations get immediately forwarded to the underlying PAI\n\t * implementation, defeating the point of the SEC.\n\t */\n\tsize_t bytes_after_flush;\n\t/*\n\t * When we can't satisfy an allocation out of the SEC because there are\n\t * no available ones cached, we allocate multiple of that size out of\n\t * the fallback allocator. Eventually we might want to do something\n\t * cleverer, but for now we just grab a fixed number.\n\t */\n\tsize_t batch_fill_extra;\n};\n\n#define SEC_OPTS_DEFAULT {\t\t\t\t\t\t\\\n\t/* nshards */\t\t\t\t\t\t\t\\\n\t4,\t\t\t\t\t\t\t\t\\\n\t/* max_alloc */\t\t\t\t\t\t\t\\\n\t(32 * 1024) < PAGE ? PAGE : (32 * 1024),\t\t\t\\\n\t/* max_bytes */\t\t\t\t\t\t\t\\\n\t256 * 1024,\t\t\t\t\t\t\t\\\n\t/* bytes_after_flush */\t\t\t\t\t\t\\\n\t128 * 1024,\t\t\t\t\t\t\t\\\n\t/* batch_fill_extra */\t\t\t\t\t\t\\\n\t0\t\t\t\t\t\t\t\t\\\n}\n\n\n#endif /* JEMALLOC_INTERNAL_SEC_OPTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/seq.h", "content": "#ifndef JEMALLOC_INTERNAL_SEQ_H\n#define JEMALLOC_INTERNAL_SEQ_H\n\n#include \"jemalloc/internal/atomic.h\"\n\n/*\n * A simple seqlock implementation.\n */\n\n#define seq_define(type, short_type)\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tatomic_zu_t seq;\t\t\t\t\t\t\\\n\tatomic_zu_t data[\t\t\t\t\t\t\\\n\t (sizeof(type) + sizeof(size_t) - 1) / sizeof(size_t)];\t\\\n} seq_##short_type##_t;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n/*\t\t\t\t\t\t\t\t\t\\\n * No internal synchronization -- the caller must ensure that there's\t\\\n * only a single writer at a time.\t\t\t\t\t\\\n */\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nseq_store_##short_type(seq_##short_type##_t *dst, type *src) {\t\t\\\n\tsize_t buf[sizeof(dst->data) / sizeof(size_t)];\t\t\t\\\n\tbuf[sizeof(buf) / sizeof(size_t) - 1] = 0;\t\t\t\\\n\tmemcpy(buf, src, sizeof(type));\t\t\t\t\t\\\n\tsize_t old_seq = atomic_load_zu(&dst->seq, ATOMIC_RELAXED);\t\\\n\tatomic_store_zu(&dst->seq, old_seq + 1, ATOMIC_RELAXED);\t\\\n\tatomic_fence(ATOMIC_RELEASE);\t\t\t\t\t\\\n\tfor (size_t i = 0; i < sizeof(buf) / sizeof(size_t); i++) {\t\\\n\t\tatomic_store_zu(&dst->data[i], buf[i], ATOMIC_RELAXED);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tatomic_store_zu(&dst->seq, old_seq + 2, ATOMIC_RELEASE);\t\\\n}\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n/* Returns whether or not the read was consistent. */\t\t\t\\\nstatic inline bool\t\t\t\t\t\t\t\\\nseq_try_load_##short_type(type *dst, seq_##short_type##_t *src) {\t\\\n\tsize_t buf[sizeof(src->data) / sizeof(size_t)];\t\t\t\\\n\tsize_t seq1 = atomic_load_zu(&src->seq, ATOMIC_ACQUIRE);\t\\\n\tif (seq1 % 2 != 0) {\t\t\t\t\t\t\\\n\t\treturn false;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tfor (size_t i = 0; i < sizeof(buf) / sizeof(size_t); i++) {\t\\\n\t\tbuf[i] = atomic_load_zu(&src->data[i], ATOMIC_RELAXED);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tatomic_fence(ATOMIC_ACQUIRE);\t\t\t\t\t\\\n\tsize_t seq2 = atomic_load_zu(&src->seq, ATOMIC_RELAXED);\t\\\n\tif (seq1 != seq2) {\t\t\t\t\t\t\\\n\t\treturn false;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tmemcpy(dst, buf, sizeof(type));\t\t\t\t\t\\\n\treturn true;\t\t\t\t\t\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_SEQ_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/slab_data.h", "content": "#ifndef JEMALLOC_INTERNAL_SLAB_DATA_H\n#define JEMALLOC_INTERNAL_SLAB_DATA_H\n\n#include \"jemalloc/internal/bitmap.h\"\n\ntypedef struct slab_data_s slab_data_t;\nstruct slab_data_s {\n\t/* Per region allocated/deallocated bitmap. */\n\tbitmap_t bitmap[BITMAP_GROUPS_MAX];\n};\n\n#endif /* JEMALLOC_INTERNAL_SLAB_DATA_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/smoothstep.h", "content": "#ifndef JEMALLOC_INTERNAL_SMOOTHSTEP_H\n#define JEMALLOC_INTERNAL_SMOOTHSTEP_H\n\n/*\n * This file was generated by the following command:\n * sh smoothstep.sh smoother 200 24 3 15\n */\n/******************************************************************************/\n\n/*\n * This header defines a precomputed table based on the smoothstep family of\n * sigmoidal curves (https://en.wikipedia.org/wiki/Smoothstep) that grow from 0\n * to 1 in 0 <= x <= 1. The table is stored as integer fixed point values so\n * that floating point math can be avoided.\n *\n * 3 2\n * smoothstep(x) = -2x + 3x\n *\n * 5 4 3\n * smootherstep(x) = 6x - 15x + 10x\n *\n * 7 6 5 4\n * smootheststep(x) = -20x + 70x - 84x + 35x\n */\n\n#define SMOOTHSTEP_VARIANT\t\"smoother\"\n#define SMOOTHSTEP_NSTEPS\t200\n#define SMOOTHSTEP_BFP\t\t24\n#define SMOOTHSTEP \\\n /* STEP(step, h, x, y) */ \\\n STEP( 1, UINT64_C(0x0000000000000014), 0.005, 0.000001240643750) \\\n STEP( 2, UINT64_C(0x00000000000000a5), 0.010, 0.000009850600000) \\\n STEP( 3, UINT64_C(0x0000000000000229), 0.015, 0.000032995181250) \\\n STEP( 4, UINT64_C(0x0000000000000516), 0.020, 0.000077619200000) \\\n STEP( 5, UINT64_C(0x00000000000009dc), 0.025, 0.000150449218750) \\\n STEP( 6, UINT64_C(0x00000000000010e8), 0.030, 0.000257995800000) \\\n STEP( 7, UINT64_C(0x0000000000001aa4), 0.035, 0.000406555756250) \\\n STEP( 8, UINT64_C(0x0000000000002777), 0.040, 0.000602214400000) \\\n STEP( 9, UINT64_C(0x00000000000037c2), 0.045, 0.000850847793750) \\\n STEP( 10, UINT64_C(0x0000000000004be6), 0.050, 0.001158125000000) \\\n STEP( 11, UINT64_C(0x000000000000643c), 0.055, 0.001529510331250) \\\n STEP( 12, UINT64_C(0x000000000000811f), 0.060, 0.001970265600000) \\\n STEP( 13, UINT64_C(0x000000000000a2e2), 0.065, 0.002485452368750) \\\n STEP( 14, UINT64_C(0x000000000000c9d8), 0.070, 0.003079934200000) \\\n STEP( 15, UINT64_C(0x000000000000f64f), 0.075, 0.003758378906250) \\\n STEP( 16, UINT64_C(0x0000000000012891), 0.080, 0.004525260800000) \\\n STEP( 17, UINT64_C(0x00000000000160e7), 0.085, 0.005384862943750) \\\n STEP( 18, UINT64_C(0x0000000000019f95), 0.090, 0.006341279400000) \\\n STEP( 19, UINT64_C(0x000000000001e4dc), 0.095, 0.007398417481250) \\\n STEP( 20, UINT64_C(0x00000000000230fc), 0.100, 0.008560000000000) \\\n STEP( 21, UINT64_C(0x0000000000028430), 0.105, 0.009829567518750) \\\n STEP( 22, UINT64_C(0x000000000002deb0), 0.110, 0.011210480600000) \\\n STEP( 23, UINT64_C(0x00000000000340b1), 0.115, 0.012705922056250) \\\n STEP( 24, UINT64_C(0x000000000003aa67), 0.120, 0.014318899200000) \\\n STEP( 25, UINT64_C(0x0000000000041c00), 0.125, 0.016052246093750) \\\n STEP( 26, UINT64_C(0x00000000000495a8), 0.130, 0.017908625800000) \\\n STEP( 27, UINT64_C(0x000000000005178b), 0.135, 0.019890532631250) \\\n STEP( 28, UINT64_C(0x000000000005a1cf), 0.140, 0.022000294400000) \\\n STEP( 29, UINT64_C(0x0000000000063498), 0.145, 0.024240074668750) \\\n STEP( 30, UINT64_C(0x000000000006d009), 0.150, 0.026611875000000) \\\n STEP( 31, UINT64_C(0x000000000007743f), 0.155, 0.029117537206250) \\\n STEP( 32, UINT64_C(0x0000000000082157), 0.160, 0.031758745600000) \\\n STEP( 33, UINT64_C(0x000000000008d76b), 0.165, 0.034537029243750) \\\n STEP( 34, UINT64_C(0x0000000000099691), 0.170, 0.037453764200000) \\\n STEP( 35, UINT64_C(0x00000000000a5edf), 0.175, 0.040510175781250) \\\n STEP( 36, UINT64_C(0x00000000000b3067), 0.180, 0.043707340800000) \\\n STEP( 37, UINT64_C(0x00000000000c0b38), 0.185, 0.047046189818750) \\\n STEP( 38, UINT64_C(0x00000000000cef5e), 0.190, 0.050527509400000) \\\n STEP( 39, UINT64_C(0x00000000000ddce6), 0.195, 0.054151944356250) \\\n STEP( 40, UINT64_C(0x00000000000ed3d8), 0.200, 0.057920000000000) \\\n STEP( 41, UINT64_C(0x00000000000fd439), 0.205, 0.061832044393750) \\\n STEP( 42, UINT64_C(0x000000000010de0e), 0.210, 0.065888310600000) \\\n STEP( 43, UINT64_C(0x000000000011f158), 0.215, 0.070088898931250) \\\n STEP( 44, UINT64_C(0x0000000000130e17), 0.220, 0.074433779200000) \\\n STEP( 45, UINT64_C(0x0000000000143448), 0.225, 0.078922792968750) \\\n STEP( 46, UINT64_C(0x00000000001563e7), 0.230, 0.083555655800000) \\\n STEP( 47, UINT64_C(0x0000000000169cec), 0.235, 0.088331959506250) \\\n STEP( 48, UINT64_C(0x000000000017df4f), 0.240, 0.093251174400000) \\\n STEP( 49, UINT64_C(0x0000000000192b04), 0.245, 0.098312651543750) \\\n STEP( 50, UINT64_C(0x00000000001a8000), 0.250, 0.103515625000000) \\\n STEP( 51, UINT64_C(0x00000000001bde32), 0.255, 0.108859214081250) \\\n STEP( 52, UINT64_C(0x00000000001d458b), 0.260, 0.114342425600000) \\\n STEP( 53, UINT64_C(0x00000000001eb5f8), 0.265, 0.119964156118750) \\\n STEP( 54, UINT64_C(0x0000000000202f65), 0.270, 0.125723194200000) \\\n STEP( 55, UINT64_C(0x000000000021b1bb), 0.275, 0.131618222656250) \\\n STEP( 56, UINT64_C(0x0000000000233ce3), 0.280, 0.137647820800000) \\\n STEP( 57, UINT64_C(0x000000000024d0c3), 0.285, 0.143810466693750) \\\n STEP( 58, UINT64_C(0x0000000000266d40), 0.290, 0.150104539400000) \\\n STEP( 59, UINT64_C(0x000000000028123d), 0.295, 0.156528321231250) \\\n STEP( 60, UINT64_C(0x000000000029bf9c), 0.300, 0.163080000000000) \\\n STEP( 61, UINT64_C(0x00000000002b753d), 0.305, 0.169757671268750) \\\n STEP( 62, UINT64_C(0x00000000002d32fe), 0.310, 0.176559340600000) \\\n STEP( 63, UINT64_C(0x00000000002ef8bc), 0.315, 0.183482925806250) \\\n STEP( 64, UINT64_C(0x000000000030c654), 0.320, 0.190526259200000) \\\n STEP( 65, UINT64_C(0x0000000000329b9f), 0.325, 0.197687089843750) \\\n STEP( 66, UINT64_C(0x0000000000347875), 0.330, 0.204963085800000) \\\n STEP( 67, UINT64_C(0x0000000000365cb0), 0.335, 0.212351836381250) \\\n STEP( 68, UINT64_C(0x0000000000384825), 0.340, 0.219850854400000) \\\n STEP( 69, UINT64_C(0x00000000003a3aa8), 0.345, 0.227457578418750) \\\n STEP( 70, UINT64_C(0x00000000003c340f), 0.350, 0.235169375000000) \\\n STEP( 71, UINT64_C(0x00000000003e342b), 0.355, 0.242983540956250) \\\n STEP( 72, UINT64_C(0x0000000000403ace), 0.360, 0.250897305600000) \\\n STEP( 73, UINT64_C(0x00000000004247c8), 0.365, 0.258907832993750) \\\n STEP( 74, UINT64_C(0x0000000000445ae9), 0.370, 0.267012224200000) \\\n STEP( 75, UINT64_C(0x0000000000467400), 0.375, 0.275207519531250) \\\n STEP( 76, UINT64_C(0x00000000004892d8), 0.380, 0.283490700800000) \\\n STEP( 77, UINT64_C(0x00000000004ab740), 0.385, 0.291858693568750) \\\n STEP( 78, UINT64_C(0x00000000004ce102), 0.390, 0.300308369400000) \\\n STEP( 79, UINT64_C(0x00000000004f0fe9), 0.395, 0.308836548106250) \\\n STEP( 80, UINT64_C(0x00000000005143bf), 0.400, 0.317440000000000) \\\n STEP( 81, UINT64_C(0x0000000000537c4d), 0.405, 0.326115448143750) \\\n STEP( 82, UINT64_C(0x000000000055b95b), 0.410, 0.334859570600000) \\\n STEP( 83, UINT64_C(0x000000000057fab1), 0.415, 0.343669002681250) \\\n STEP( 84, UINT64_C(0x00000000005a4015), 0.420, 0.352540339200000) \\\n STEP( 85, UINT64_C(0x00000000005c894e), 0.425, 0.361470136718750) \\\n STEP( 86, UINT64_C(0x00000000005ed622), 0.430, 0.370454915800000) \\\n STEP( 87, UINT64_C(0x0000000000612655), 0.435, 0.379491163256250) \\\n STEP( 88, UINT64_C(0x00000000006379ac), 0.440, 0.388575334400000) \\\n STEP( 89, UINT64_C(0x000000000065cfeb), 0.445, 0.397703855293750) \\\n STEP( 90, UINT64_C(0x00000000006828d6), 0.450, 0.406873125000000) \\\n STEP( 91, UINT64_C(0x00000000006a842f), 0.455, 0.416079517831250) \\\n STEP( 92, UINT64_C(0x00000000006ce1bb), 0.460, 0.425319385600000) \\\n STEP( 93, UINT64_C(0x00000000006f413a), 0.465, 0.434589059868750) \\\n STEP( 94, UINT64_C(0x000000000071a270), 0.470, 0.443884854200000) \\\n STEP( 95, UINT64_C(0x000000000074051d), 0.475, 0.453203066406250) \\\n STEP( 96, UINT64_C(0x0000000000766905), 0.480, 0.462539980800000) \\\n STEP( 97, UINT64_C(0x000000000078cde7), 0.485, 0.471891870443750) \\\n STEP( 98, UINT64_C(0x00000000007b3387), 0.490, 0.481254999400000) \\\n STEP( 99, UINT64_C(0x00000000007d99a4), 0.495, 0.490625624981250) \\\n STEP( 100, UINT64_C(0x0000000000800000), 0.500, 0.500000000000000) \\\n STEP( 101, UINT64_C(0x000000000082665b), 0.505, 0.509374375018750) \\\n STEP( 102, UINT64_C(0x000000000084cc78), 0.510, 0.518745000600000) \\\n STEP( 103, UINT64_C(0x0000000000873218), 0.515, 0.528108129556250) \\\n STEP( 104, UINT64_C(0x00000000008996fa), 0.520, 0.537460019200000) \\\n STEP( 105, UINT64_C(0x00000000008bfae2), 0.525, 0.546796933593750) \\\n STEP( 106, UINT64_C(0x00000000008e5d8f), 0.530, 0.556115145800000) \\\n STEP( 107, UINT64_C(0x000000000090bec5), 0.535, 0.565410940131250) \\\n STEP( 108, UINT64_C(0x0000000000931e44), 0.540, 0.574680614400000) \\\n STEP( 109, UINT64_C(0x0000000000957bd0), 0.545, 0.583920482168750) \\\n STEP( 110, UINT64_C(0x000000000097d729), 0.550, 0.593126875000000) \\\n STEP( 111, UINT64_C(0x00000000009a3014), 0.555, 0.602296144706250) \\\n STEP( 112, UINT64_C(0x00000000009c8653), 0.560, 0.611424665600000) \\\n STEP( 113, UINT64_C(0x00000000009ed9aa), 0.565, 0.620508836743750) \\\n STEP( 114, UINT64_C(0x0000000000a129dd), 0.570, 0.629545084200000) \\\n STEP( 115, UINT64_C(0x0000000000a376b1), 0.575, 0.638529863281250) \\\n STEP( 116, UINT64_C(0x0000000000a5bfea), 0.580, 0.647459660800000) \\\n STEP( 117, UINT64_C(0x0000000000a8054e), 0.585, 0.656330997318750) \\\n STEP( 118, UINT64_C(0x0000000000aa46a4), 0.590, 0.665140429400000) \\\n STEP( 119, UINT64_C(0x0000000000ac83b2), 0.595, 0.673884551856250) \\\n STEP( 120, UINT64_C(0x0000000000aebc40), 0.600, 0.682560000000000) \\\n STEP( 121, UINT64_C(0x0000000000b0f016), 0.605, 0.691163451893750) \\\n STEP( 122, UINT64_C(0x0000000000b31efd), 0.610, 0.699691630600000) \\\n STEP( 123, UINT64_C(0x0000000000b548bf), 0.615, 0.708141306431250) \\\n STEP( 124, UINT64_C(0x0000000000b76d27), 0.620, 0.716509299200000) \\\n STEP( 125, UINT64_C(0x0000000000b98c00), 0.625, 0.724792480468750) \\\n STEP( 126, UINT64_C(0x0000000000bba516), 0.630, 0.732987775800000) \\\n STEP( 127, UINT64_C(0x0000000000bdb837), 0.635, 0.741092167006250) \\\n STEP( 128, UINT64_C(0x0000000000bfc531), 0.640, 0.749102694400000) \\\n STEP( 129, UINT64_C(0x0000000000c1cbd4), 0.645, 0.757016459043750) \\\n STEP( 130, UINT64_C(0x0000000000c3cbf0), 0.650, 0.764830625000000) \\\n STEP( 131, UINT64_C(0x0000000000c5c557), 0.655, 0.772542421581250) \\\n STEP( 132, UINT64_C(0x0000000000c7b7da), 0.660, 0.780149145600000) \\\n STEP( 133, UINT64_C(0x0000000000c9a34f), 0.665, 0.787648163618750) \\\n STEP( 134, UINT64_C(0x0000000000cb878a), 0.670, 0.795036914200000) \\\n STEP( 135, UINT64_C(0x0000000000cd6460), 0.675, 0.802312910156250) \\\n STEP( 136, UINT64_C(0x0000000000cf39ab), 0.680, 0.809473740800000) \\\n STEP( 137, UINT64_C(0x0000000000d10743), 0.685, 0.816517074193750) \\\n STEP( 138, UINT64_C(0x0000000000d2cd01), 0.690, 0.823440659400000) \\\n STEP( 139, UINT64_C(0x0000000000d48ac2), 0.695, 0.830242328731250) \\\n STEP( 140, UINT64_C(0x0000000000d64063), 0.700, 0.836920000000000) \\\n STEP( 141, UINT64_C(0x0000000000d7edc2), 0.705, 0.843471678768750) \\\n STEP( 142, UINT64_C(0x0000000000d992bf), 0.710, 0.849895460600000) \\\n STEP( 143, UINT64_C(0x0000000000db2f3c), 0.715, 0.856189533306250) \\\n STEP( 144, UINT64_C(0x0000000000dcc31c), 0.720, 0.862352179200000) \\\n STEP( 145, UINT64_C(0x0000000000de4e44), 0.725, 0.868381777343750) \\\n STEP( 146, UINT64_C(0x0000000000dfd09a), 0.730, 0.874276805800000) \\\n STEP( 147, UINT64_C(0x0000000000e14a07), 0.735, 0.880035843881250) \\\n STEP( 148, UINT64_C(0x0000000000e2ba74), 0.740, 0.885657574400000) \\\n STEP( 149, UINT64_C(0x0000000000e421cd), 0.745, 0.891140785918750) \\\n STEP( 150, UINT64_C(0x0000000000e58000), 0.750, 0.896484375000000) \\\n STEP( 151, UINT64_C(0x0000000000e6d4fb), 0.755, 0.901687348456250) \\\n STEP( 152, UINT64_C(0x0000000000e820b0), 0.760, 0.906748825600000) \\\n STEP( 153, UINT64_C(0x0000000000e96313), 0.765, 0.911668040493750) \\\n STEP( 154, UINT64_C(0x0000000000ea9c18), 0.770, 0.916444344200000) \\\n STEP( 155, UINT64_C(0x0000000000ebcbb7), 0.775, 0.921077207031250) \\\n STEP( 156, UINT64_C(0x0000000000ecf1e8), 0.780, 0.925566220800000) \\\n STEP( 157, UINT64_C(0x0000000000ee0ea7), 0.785, 0.929911101068750) \\\n STEP( 158, UINT64_C(0x0000000000ef21f1), 0.790, 0.934111689400000) \\\n STEP( 159, UINT64_C(0x0000000000f02bc6), 0.795, 0.938167955606250) \\\n STEP( 160, UINT64_C(0x0000000000f12c27), 0.800, 0.942080000000000) \\\n STEP( 161, UINT64_C(0x0000000000f22319), 0.805, 0.945848055643750) \\\n STEP( 162, UINT64_C(0x0000000000f310a1), 0.810, 0.949472490600000) \\\n STEP( 163, UINT64_C(0x0000000000f3f4c7), 0.815, 0.952953810181250) \\\n STEP( 164, UINT64_C(0x0000000000f4cf98), 0.820, 0.956292659200000) \\\n STEP( 165, UINT64_C(0x0000000000f5a120), 0.825, 0.959489824218750) \\\n STEP( 166, UINT64_C(0x0000000000f6696e), 0.830, 0.962546235800000) \\\n STEP( 167, UINT64_C(0x0000000000f72894), 0.835, 0.965462970756250) \\\n STEP( 168, UINT64_C(0x0000000000f7dea8), 0.840, 0.968241254400000) \\\n STEP( 169, UINT64_C(0x0000000000f88bc0), 0.845, 0.970882462793750) \\\n STEP( 170, UINT64_C(0x0000000000f92ff6), 0.850, 0.973388125000000) \\\n STEP( 171, UINT64_C(0x0000000000f9cb67), 0.855, 0.975759925331250) \\\n STEP( 172, UINT64_C(0x0000000000fa5e30), 0.860, 0.977999705600000) \\\n STEP( 173, UINT64_C(0x0000000000fae874), 0.865, 0.980109467368750) \\\n STEP( 174, UINT64_C(0x0000000000fb6a57), 0.870, 0.982091374200000) \\\n STEP( 175, UINT64_C(0x0000000000fbe400), 0.875, 0.983947753906250) \\\n STEP( 176, UINT64_C(0x0000000000fc5598), 0.880, 0.985681100800000) \\\n STEP( 177, UINT64_C(0x0000000000fcbf4e), 0.885, 0.987294077943750) \\\n STEP( 178, UINT64_C(0x0000000000fd214f), 0.890, 0.988789519400000) \\\n STEP( 179, UINT64_C(0x0000000000fd7bcf), 0.895, 0.990170432481250) \\\n STEP( 180, UINT64_C(0x0000000000fdcf03), 0.900, 0.991440000000000) \\\n STEP( 181, UINT64_C(0x0000000000fe1b23), 0.905, 0.992601582518750) \\\n STEP( 182, UINT64_C(0x0000000000fe606a), 0.910, 0.993658720600000) \\\n STEP( 183, UINT64_C(0x0000000000fe9f18), 0.915, 0.994615137056250) \\\n STEP( 184, UINT64_C(0x0000000000fed76e), 0.920, 0.995474739200000) \\\n STEP( 185, UINT64_C(0x0000000000ff09b0), 0.925, 0.996241621093750) \\\n STEP( 186, UINT64_C(0x0000000000ff3627), 0.930, 0.996920065800000) \\\n STEP( 187, UINT64_C(0x0000000000ff5d1d), 0.935, 0.997514547631250) \\\n STEP( 188, UINT64_C(0x0000000000ff7ee0), 0.940, 0.998029734400000) \\\n STEP( 189, UINT64_C(0x0000000000ff9bc3), 0.945, 0.998470489668750) \\\n STEP( 190, UINT64_C(0x0000000000ffb419), 0.950, 0.998841875000000) \\\n STEP( 191, UINT64_C(0x0000000000ffc83d), 0.955, 0.999149152206250) \\\n STEP( 192, UINT64_C(0x0000000000ffd888), 0.960, 0.999397785600000) \\\n STEP( 193, UINT64_C(0x0000000000ffe55b), 0.965, 0.999593444243750) \\\n STEP( 194, UINT64_C(0x0000000000ffef17), 0.970, 0.999742004200000) \\\n STEP( 195, UINT64_C(0x0000000000fff623), 0.975, 0.999849550781250) \\\n STEP( 196, UINT64_C(0x0000000000fffae9), 0.980, 0.999922380800000) \\\n STEP( 197, UINT64_C(0x0000000000fffdd6), 0.985, 0.999967004818750) \\\n STEP( 198, UINT64_C(0x0000000000ffff5a), 0.990, 0.999990149400000) \\\n STEP( 199, UINT64_C(0x0000000000ffffeb), 0.995, 0.999998759356250) \\\n STEP( 200, UINT64_C(0x0000000001000000), 1.000, 1.000000000000000) \\\n\n#endif /* JEMALLOC_INTERNAL_SMOOTHSTEP_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/smoothstep.sh", "content": "#!/bin/sh\n#\n# Generate a discrete lookup table for a sigmoid function in the smoothstep\n# family (https://en.wikipedia.org/wiki/Smoothstep), where the lookup table\n# entries correspond to x in [1/nsteps, 2/nsteps, ..., nsteps/nsteps]. Encode\n# the entries using a binary fixed point representation.\n#\n# Usage: smoothstep.sh \n#\n# is in {smooth, smoother, smoothest}.\n# must be greater than zero.\n# must be in [0..62]; reasonable values are roughly [10..30].\n# is x decimal precision.\n# is y decimal precision.\n\n#set -x\n\ncmd=\"sh smoothstep.sh $*\"\nvariant=$1\nnsteps=$2\nbfp=$3\nxprec=$4\nyprec=$5\n\ncase \"${variant}\" in\n smooth)\n ;;\n smoother)\n ;;\n smoothest)\n ;;\n *)\n echo \"Unsupported variant\"\n exit 1\n ;;\nesac\n\nsmooth() {\n step=$1\n y=`echo ${yprec} k ${step} ${nsteps} / sx _2 lx 3 ^ '*' 3 lx 2 ^ '*' + p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g'`\n h=`echo ${yprec} k 2 ${bfp} ^ ${y} '*' p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g' | tr '.' ' ' | awk '{print $1}' `\n}\n\nsmoother() {\n step=$1\n y=`echo ${yprec} k ${step} ${nsteps} / sx 6 lx 5 ^ '*' _15 lx 4 ^ '*' + 10 lx 3 ^ '*' + p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g'`\n h=`echo ${yprec} k 2 ${bfp} ^ ${y} '*' p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g' | tr '.' ' ' | awk '{print $1}' `\n}\n\nsmoothest() {\n step=$1\n y=`echo ${yprec} k ${step} ${nsteps} / sx _20 lx 7 ^ '*' 70 lx 6 ^ '*' + _84 lx 5 ^ '*' + 35 lx 4 ^ '*' + p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g'`\n h=`echo ${yprec} k 2 ${bfp} ^ ${y} '*' p | dc | tr -d '\\\\\\\\\\n' | sed -e 's#^\\.#0.#g' | tr '.' ' ' | awk '{print $1}' `\n}\n\ncat <iteration < 5) {\n\t\tfor (i = 0; i < (1U << spin->iteration); i++) {\n\t\t\tspin_cpu_spinwait();\n\t\t}\n\t\tspin->iteration++;\n\t} else {\n#ifdef _WIN32\n\t\tSwitchToThread();\n#else\n\t\tsched_yield();\n#endif\n\t}\n}\n\n#undef SPIN_INLINE\n\n#endif /* JEMALLOC_INTERNAL_SPIN_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/stats.h", "content": "#ifndef JEMALLOC_INTERNAL_STATS_H\n#define JEMALLOC_INTERNAL_STATS_H\n\n/* OPTION(opt,\t\tvar_name,\tdefault,\tset_value_to) */\n#define STATS_PRINT_OPTIONS\t\t\t\t\t\t\\\n OPTION('J',\t\tjson,\t\tfalse,\t\ttrue)\t\t\\\n OPTION('g',\t\tgeneral,\ttrue,\t\tfalse)\t\t\\\n OPTION('m',\t\tmerged,\t\tconfig_stats,\tfalse)\t\t\\\n OPTION('d',\t\tdestroyed,\tconfig_stats,\tfalse)\t\t\\\n OPTION('a',\t\tunmerged,\tconfig_stats,\tfalse)\t\t\\\n OPTION('b',\t\tbins,\t\ttrue,\t\tfalse)\t\t\\\n OPTION('l',\t\tlarge,\t\ttrue,\t\tfalse)\t\t\\\n OPTION('x',\t\tmutex,\t\ttrue,\t\tfalse)\t\t\\\n OPTION('e',\t\textents,\ttrue,\t\tfalse)\t\t\\\n OPTION('h',\t\thpa,\t\tconfig_stats,\tfalse)\n\nenum {\n#define OPTION(o, v, d, s) stats_print_option_num_##v,\n STATS_PRINT_OPTIONS\n#undef OPTION\n stats_print_tot_num_options\n};\n\n/* Options for stats_print. */\nextern bool opt_stats_print;\nextern char opt_stats_print_opts[stats_print_tot_num_options+1];\n\n/* Utilities for stats_interval. */\nextern int64_t opt_stats_interval;\nextern char opt_stats_interval_opts[stats_print_tot_num_options+1];\n\n#define STATS_INTERVAL_DEFAULT -1\n/*\n * Batch-increment the counter to reduce synchronization overhead. Each thread\n * merges after (interval >> LG_BATCH_SIZE) bytes of allocations; also limit the\n * BATCH_MAX for accuracy when the interval is huge (which is expected).\n */\n#define STATS_INTERVAL_ACCUM_LG_BATCH_SIZE 6\n#define STATS_INTERVAL_ACCUM_BATCH_MAX (4 << 20)\n\n/* Only accessed by thread event. */\nuint64_t stats_interval_new_event_wait(tsd_t *tsd);\nuint64_t stats_interval_postponed_event_wait(tsd_t *tsd);\nvoid stats_interval_event_handler(tsd_t *tsd, uint64_t elapsed);\n\n/* Implements je_malloc_stats_print. */\nvoid stats_print(write_cb_t *write_cb, void *cbopaque, const char *opts);\n\nbool stats_boot(void);\nvoid stats_prefork(tsdn_t *tsdn);\nvoid stats_postfork_parent(tsdn_t *tsdn);\nvoid stats_postfork_child(tsdn_t *tsdn);\n\n#endif /* JEMALLOC_INTERNAL_STATS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/sz.h", "content": "#ifndef JEMALLOC_INTERNAL_SIZE_H\n#define JEMALLOC_INTERNAL_SIZE_H\n\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/pages.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/util.h\"\n\n/*\n * sz module: Size computations.\n *\n * Some abbreviations used here:\n * p: Page\n * ind: Index\n * s, sz: Size\n * u: Usable size\n * a: Aligned\n *\n * These are not always used completely consistently, but should be enough to\n * interpret function names. E.g. sz_psz2ind converts page size to page size\n * index; sz_sa2u converts a (size, alignment) allocation request to the usable\n * size that would result from such an allocation.\n */\n\n/* Page size index type. */\ntypedef unsigned pszind_t;\n\n/* Size class index type. */\ntypedef unsigned szind_t;\n\n/*\n * sz_pind2sz_tab encodes the same information as could be computed by\n * sz_pind2sz_compute().\n */\nextern size_t sz_pind2sz_tab[SC_NPSIZES + 1];\n/*\n * sz_index2size_tab encodes the same information as could be computed (at\n * unacceptable cost in some code paths) by sz_index2size_compute().\n */\nextern size_t sz_index2size_tab[SC_NSIZES];\n/*\n * sz_size2index_tab is a compact lookup table that rounds request sizes up to\n * size classes. In order to reduce cache footprint, the table is compressed,\n * and all accesses are via sz_size2index().\n */\nextern uint8_t sz_size2index_tab[];\n\n/*\n * Padding for large allocations: PAGE when opt_cache_oblivious == true (to\n * enable cache index randomization); 0 otherwise.\n */\nextern size_t sz_large_pad;\n\nextern void sz_boot(const sc_data_t *sc_data, bool cache_oblivious);\n\nJEMALLOC_ALWAYS_INLINE pszind_t\nsz_psz2ind(size_t psz) {\n\tassert(psz > 0);\n\tif (unlikely(psz > SC_LARGE_MAXCLASS)) {\n\t\treturn SC_NPSIZES;\n\t}\n\t/* x is the lg of the first base >= psz. */\n\tpszind_t x = lg_ceil(psz);\n\t/*\n\t * sc.h introduces a lot of size classes. These size classes are divided\n\t * into different size class groups. There is a very special size class\n\t * group, each size class in or after it is an integer multiple of PAGE.\n\t * We call it first_ps_rg. It means first page size regular group. The\n\t * range of first_ps_rg is (base, base * 2], and base == PAGE *\n\t * SC_NGROUP. off_to_first_ps_rg begins from 1, instead of 0. e.g.\n\t * off_to_first_ps_rg is 1 when psz is (PAGE * SC_NGROUP + 1).\n\t */\n\tpszind_t off_to_first_ps_rg = (x < SC_LG_NGROUP + LG_PAGE) ?\n\t 0 : x - (SC_LG_NGROUP + LG_PAGE);\n\n\t/*\n\t * Same as sc_s::lg_delta.\n\t * Delta for off_to_first_ps_rg == 1 is PAGE,\n\t * for each increase in offset, it's multiplied by two.\n\t * Therefore, lg_delta = LG_PAGE + (off_to_first_ps_rg - 1).\n\t */\n\tpszind_t lg_delta = (off_to_first_ps_rg == 0) ?\n\t LG_PAGE : LG_PAGE + (off_to_first_ps_rg - 1);\n\n\t/*\n\t * Let's write psz in binary, e.g. 0011 for 0x3, 0111 for 0x7.\n\t * The leftmost bits whose len is lg_base decide the base of psz.\n\t * The rightmost bits whose len is lg_delta decide (pgz % PAGE).\n\t * The middle bits whose len is SC_LG_NGROUP decide ndelta.\n\t * ndelta is offset to the first size class in the size class group,\n\t * starts from 1.\n\t * If you don't know lg_base, ndelta or lg_delta, see sc.h.\n\t * |xxxxxxxxxxxxxxxxxxxx|------------------------|yyyyyyyyyyyyyyyyyyyyy|\n\t * |<-- len: lg_base -->|<-- len: SC_LG_NGROUP-->|<-- len: lg_delta -->|\n\t * |<-- ndelta -->|\n\t * rg_inner_off = ndelta - 1\n\t * Why use (psz - 1)?\n\t * To handle case: psz % (1 << lg_delta) == 0.\n\t */\n\tpszind_t rg_inner_off = (((psz - 1)) >> lg_delta) & (SC_NGROUP - 1);\n\n\tpszind_t base_ind = off_to_first_ps_rg << SC_LG_NGROUP;\n\tpszind_t ind = base_ind + rg_inner_off;\n\treturn ind;\n}\n\nstatic inline size_t\nsz_pind2sz_compute(pszind_t pind) {\n\tif (unlikely(pind == SC_NPSIZES)) {\n\t\treturn SC_LARGE_MAXCLASS + PAGE;\n\t}\n\tsize_t grp = pind >> SC_LG_NGROUP;\n\tsize_t mod = pind & ((ZU(1) << SC_LG_NGROUP) - 1);\n\n\tsize_t grp_size_mask = ~((!!grp)-1);\n\tsize_t grp_size = ((ZU(1) << (LG_PAGE + (SC_LG_NGROUP-1))) << grp)\n\t & grp_size_mask;\n\n\tsize_t shift = (grp == 0) ? 1 : grp;\n\tsize_t lg_delta = shift + (LG_PAGE-1);\n\tsize_t mod_size = (mod+1) << lg_delta;\n\n\tsize_t sz = grp_size + mod_size;\n\treturn sz;\n}\n\nstatic inline size_t\nsz_pind2sz_lookup(pszind_t pind) {\n\tsize_t ret = (size_t)sz_pind2sz_tab[pind];\n\tassert(ret == sz_pind2sz_compute(pind));\n\treturn ret;\n}\n\nstatic inline size_t\nsz_pind2sz(pszind_t pind) {\n\tassert(pind < SC_NPSIZES + 1);\n\treturn sz_pind2sz_lookup(pind);\n}\n\nstatic inline size_t\nsz_psz2u(size_t psz) {\n\tif (unlikely(psz > SC_LARGE_MAXCLASS)) {\n\t\treturn SC_LARGE_MAXCLASS + PAGE;\n\t}\n\tsize_t x = lg_floor((psz<<1)-1);\n\tsize_t lg_delta = (x < SC_LG_NGROUP + LG_PAGE + 1) ?\n\t LG_PAGE : x - SC_LG_NGROUP - 1;\n\tsize_t delta = ZU(1) << lg_delta;\n\tsize_t delta_mask = delta - 1;\n\tsize_t usize = (psz + delta_mask) & ~delta_mask;\n\treturn usize;\n}\n\nstatic inline szind_t\nsz_size2index_compute(size_t size) {\n\tif (unlikely(size > SC_LARGE_MAXCLASS)) {\n\t\treturn SC_NSIZES;\n\t}\n\n\tif (size == 0) {\n\t\treturn 0;\n\t}\n#if (SC_NTINY != 0)\n\tif (size <= (ZU(1) << SC_LG_TINY_MAXCLASS)) {\n\t\tszind_t lg_tmin = SC_LG_TINY_MAXCLASS - SC_NTINY + 1;\n\t\tszind_t lg_ceil = lg_floor(pow2_ceil_zu(size));\n\t\treturn (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin);\n\t}\n#endif\n\t{\n\t\tszind_t x = lg_floor((size<<1)-1);\n\t\tszind_t shift = (x < SC_LG_NGROUP + LG_QUANTUM) ? 0 :\n\t\t x - (SC_LG_NGROUP + LG_QUANTUM);\n\t\tszind_t grp = shift << SC_LG_NGROUP;\n\n\t\tszind_t lg_delta = (x < SC_LG_NGROUP + LG_QUANTUM + 1)\n\t\t ? LG_QUANTUM : x - SC_LG_NGROUP - 1;\n\n\t\tsize_t delta_inverse_mask = ZU(-1) << lg_delta;\n\t\tszind_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &\n\t\t ((ZU(1) << SC_LG_NGROUP) - 1);\n\n\t\tszind_t index = SC_NTINY + grp + mod;\n\t\treturn index;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE szind_t\nsz_size2index_lookup_impl(size_t size) {\n\tassert(size <= SC_LOOKUP_MAXCLASS);\n\treturn sz_size2index_tab[(size + (ZU(1) << SC_LG_TINY_MIN) - 1)\n\t >> SC_LG_TINY_MIN];\n}\n\nJEMALLOC_ALWAYS_INLINE szind_t\nsz_size2index_lookup(size_t size) {\n\tszind_t ret = sz_size2index_lookup_impl(size);\n\tassert(ret == sz_size2index_compute(size));\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE szind_t\nsz_size2index(size_t size) {\n\tif (likely(size <= SC_LOOKUP_MAXCLASS)) {\n\t\treturn sz_size2index_lookup(size);\n\t}\n\treturn sz_size2index_compute(size);\n}\n\nstatic inline size_t\nsz_index2size_compute(szind_t index) {\n#if (SC_NTINY > 0)\n\tif (index < SC_NTINY) {\n\t\treturn (ZU(1) << (SC_LG_TINY_MAXCLASS - SC_NTINY + 1 + index));\n\t}\n#endif\n\t{\n\t\tsize_t reduced_index = index - SC_NTINY;\n\t\tsize_t grp = reduced_index >> SC_LG_NGROUP;\n\t\tsize_t mod = reduced_index & ((ZU(1) << SC_LG_NGROUP) -\n\t\t 1);\n\n\t\tsize_t grp_size_mask = ~((!!grp)-1);\n\t\tsize_t grp_size = ((ZU(1) << (LG_QUANTUM +\n\t\t (SC_LG_NGROUP-1))) << grp) & grp_size_mask;\n\n\t\tsize_t shift = (grp == 0) ? 1 : grp;\n\t\tsize_t lg_delta = shift + (LG_QUANTUM-1);\n\t\tsize_t mod_size = (mod+1) << lg_delta;\n\n\t\tsize_t usize = grp_size + mod_size;\n\t\treturn usize;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nsz_index2size_lookup_impl(szind_t index) {\n\treturn sz_index2size_tab[index];\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nsz_index2size_lookup(szind_t index) {\n\tsize_t ret = sz_index2size_lookup_impl(index);\n\tassert(ret == sz_index2size_compute(index));\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nsz_index2size(szind_t index) {\n\tassert(index < SC_NSIZES);\n\treturn sz_index2size_lookup(index);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nsz_size2index_usize_fastpath(size_t size, szind_t *ind, size_t *usize) {\n\t*ind = sz_size2index_lookup_impl(size);\n\t*usize = sz_index2size_lookup_impl(*ind);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nsz_s2u_compute(size_t size) {\n\tif (unlikely(size > SC_LARGE_MAXCLASS)) {\n\t\treturn 0;\n\t}\n\n\tif (size == 0) {\n\t\tsize++;\n\t}\n#if (SC_NTINY > 0)\n\tif (size <= (ZU(1) << SC_LG_TINY_MAXCLASS)) {\n\t\tsize_t lg_tmin = SC_LG_TINY_MAXCLASS - SC_NTINY + 1;\n\t\tsize_t lg_ceil = lg_floor(pow2_ceil_zu(size));\n\t\treturn (lg_ceil < lg_tmin ? (ZU(1) << lg_tmin) :\n\t\t (ZU(1) << lg_ceil));\n\t}\n#endif\n\t{\n\t\tsize_t x = lg_floor((size<<1)-1);\n\t\tsize_t lg_delta = (x < SC_LG_NGROUP + LG_QUANTUM + 1)\n\t\t ? LG_QUANTUM : x - SC_LG_NGROUP - 1;\n\t\tsize_t delta = ZU(1) << lg_delta;\n\t\tsize_t delta_mask = delta - 1;\n\t\tsize_t usize = (size + delta_mask) & ~delta_mask;\n\t\treturn usize;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nsz_s2u_lookup(size_t size) {\n\tsize_t ret = sz_index2size_lookup(sz_size2index_lookup(size));\n\n\tassert(ret == sz_s2u_compute(size));\n\treturn ret;\n}\n\n/*\n * Compute usable size that would result from allocating an object with the\n * specified size.\n */\nJEMALLOC_ALWAYS_INLINE size_t\nsz_s2u(size_t size) {\n\tif (likely(size <= SC_LOOKUP_MAXCLASS)) {\n\t\treturn sz_s2u_lookup(size);\n\t}\n\treturn sz_s2u_compute(size);\n}\n\n/*\n * Compute usable size that would result from allocating an object with the\n * specified size and alignment.\n */\nJEMALLOC_ALWAYS_INLINE size_t\nsz_sa2u(size_t size, size_t alignment) {\n\tsize_t usize;\n\n\tassert(alignment != 0 && ((alignment - 1) & alignment) == 0);\n\n\t/* Try for a small size class. */\n\tif (size <= SC_SMALL_MAXCLASS && alignment <= PAGE) {\n\t\t/*\n\t\t * Round size up to the nearest multiple of alignment.\n\t\t *\n\t\t * This done, we can take advantage of the fact that for each\n\t\t * small size class, every object is aligned at the smallest\n\t\t * power of two that is non-zero in the base two representation\n\t\t * of the size. For example:\n\t\t *\n\t\t * Size | Base 2 | Minimum alignment\n\t\t * -----+----------+------------------\n\t\t * 96 | 1100000 | 32\n\t\t * 144 | 10100000 | 32\n\t\t * 192 | 11000000 | 64\n\t\t */\n\t\tusize = sz_s2u(ALIGNMENT_CEILING(size, alignment));\n\t\tif (usize < SC_LARGE_MINCLASS) {\n\t\t\treturn usize;\n\t\t}\n\t}\n\n\t/* Large size class. Beware of overflow. */\n\n\tif (unlikely(alignment > SC_LARGE_MAXCLASS)) {\n\t\treturn 0;\n\t}\n\n\t/* Make sure result is a large size class. */\n\tif (size <= SC_LARGE_MINCLASS) {\n\t\tusize = SC_LARGE_MINCLASS;\n\t} else {\n\t\tusize = sz_s2u(size);\n\t\tif (usize < size) {\n\t\t\t/* size_t overflow. */\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/*\n\t * Calculate the multi-page mapping that large_palloc() would need in\n\t * order to guarantee the alignment.\n\t */\n\tif (usize + sz_large_pad + PAGE_CEILING(alignment) - PAGE < usize) {\n\t\t/* size_t overflow. */\n\t\treturn 0;\n\t}\n\treturn usize;\n}\n\nsize_t sz_psz_quantize_floor(size_t size);\nsize_t sz_psz_quantize_ceil(size_t size);\n\n#endif /* JEMALLOC_INTERNAL_SIZE_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tcache_externs.h", "content": "#ifndef JEMALLOC_INTERNAL_TCACHE_EXTERNS_H\n#define JEMALLOC_INTERNAL_TCACHE_EXTERNS_H\n\nextern bool opt_tcache;\nextern size_t opt_tcache_max;\nextern ssize_t\topt_lg_tcache_nslots_mul;\nextern unsigned opt_tcache_nslots_small_min;\nextern unsigned opt_tcache_nslots_small_max;\nextern unsigned opt_tcache_nslots_large;\nextern ssize_t opt_lg_tcache_shift;\nextern size_t opt_tcache_gc_incr_bytes;\nextern size_t opt_tcache_gc_delay_bytes;\nextern unsigned opt_lg_tcache_flush_small_div;\nextern unsigned opt_lg_tcache_flush_large_div;\n\n/*\n * Number of tcache bins. There are SC_NBINS small-object bins, plus 0 or more\n * large-object bins.\n */\nextern unsigned\tnhbins;\n\n/* Maximum cached size class. */\nextern size_t\ttcache_maxclass;\n\nextern cache_bin_info_t *tcache_bin_info;\n\n/*\n * Explicit tcaches, managed via the tcache.{create,flush,destroy} mallctls and\n * usable via the MALLOCX_TCACHE() flag. The automatic per thread tcaches are\n * completely disjoint from this data structure. tcaches starts off as a sparse\n * array, so it has no physical memory footprint until individual pages are\n * touched. This allows the entire array to be allocated the first time an\n * explicit tcache is created without a disproportionate impact on memory usage.\n */\nextern tcaches_t\t*tcaches;\n\nsize_t tcache_salloc(tsdn_t *tsdn, const void *ptr);\nvoid *tcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena, tcache_t *tcache,\n cache_bin_t *tbin, szind_t binind, bool *tcache_success);\n\nvoid tcache_bin_flush_small(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,\n szind_t binind, unsigned rem);\nvoid tcache_bin_flush_large(tsd_t *tsd, tcache_t *tcache, cache_bin_t *tbin,\n szind_t binind, unsigned rem);\nvoid tcache_bin_flush_stashed(tsd_t *tsd, tcache_t *tcache, cache_bin_t *bin,\n szind_t binind, bool is_small);\nvoid tcache_arena_reassociate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,\n tcache_t *tcache, arena_t *arena);\ntcache_t *tcache_create_explicit(tsd_t *tsd);\nvoid tcache_cleanup(tsd_t *tsd);\nvoid tcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena);\nbool tcaches_create(tsd_t *tsd, base_t *base, unsigned *r_ind);\nvoid tcaches_flush(tsd_t *tsd, unsigned ind);\nvoid tcaches_destroy(tsd_t *tsd, unsigned ind);\nbool tcache_boot(tsdn_t *tsdn, base_t *base);\nvoid tcache_arena_associate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,\n tcache_t *tcache, arena_t *arena);\nvoid tcache_prefork(tsdn_t *tsdn);\nvoid tcache_postfork_parent(tsdn_t *tsdn);\nvoid tcache_postfork_child(tsdn_t *tsdn);\nvoid tcache_flush(tsd_t *tsd);\nbool tsd_tcache_data_init(tsd_t *tsd);\nbool tsd_tcache_enabled_data_init(tsd_t *tsd);\n\nvoid tcache_assert_initialized(tcache_t *tcache);\n\n/* Only accessed by thread event. */\nuint64_t tcache_gc_new_event_wait(tsd_t *tsd);\nuint64_t tcache_gc_postponed_event_wait(tsd_t *tsd);\nvoid tcache_gc_event_handler(tsd_t *tsd, uint64_t elapsed);\nuint64_t tcache_gc_dalloc_new_event_wait(tsd_t *tsd);\nuint64_t tcache_gc_dalloc_postponed_event_wait(tsd_t *tsd);\nvoid tcache_gc_dalloc_event_handler(tsd_t *tsd, uint64_t elapsed);\n\n#endif /* JEMALLOC_INTERNAL_TCACHE_EXTERNS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tcache_inlines.h", "content": "#ifndef JEMALLOC_INTERNAL_TCACHE_INLINES_H\n#define JEMALLOC_INTERNAL_TCACHE_INLINES_H\n\n#include \"jemalloc/internal/bin.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/util.h\"\n\nstatic inline bool\ntcache_enabled_get(tsd_t *tsd) {\n\treturn tsd_tcache_enabled_get(tsd);\n}\n\nstatic inline void\ntcache_enabled_set(tsd_t *tsd, bool enabled) {\n\tbool was_enabled = tsd_tcache_enabled_get(tsd);\n\n\tif (!was_enabled && enabled) {\n\t\ttsd_tcache_data_init(tsd);\n\t} else if (was_enabled && !enabled) {\n\t\ttcache_cleanup(tsd);\n\t}\n\t/* Commit the state last. Above calls check current state. */\n\ttsd_tcache_enabled_set(tsd, enabled);\n\ttsd_slow_update(tsd);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntcache_small_bin_disabled(szind_t ind, cache_bin_t *bin) {\n\tassert(ind < SC_NBINS);\n\tbool ret = (cache_bin_info_ncached_max(&tcache_bin_info[ind]) == 0);\n\tif (ret && bin != NULL) {\n\t\t/* small size class but cache bin disabled. */\n\t\tassert(ind >= nhbins);\n\t\tassert((uintptr_t)(*bin->stack_head) ==\n\t\t cache_bin_preceding_junk);\n\t}\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\ntcache_alloc_small(tsd_t *tsd, arena_t *arena, tcache_t *tcache,\n size_t size, szind_t binind, bool zero, bool slow_path) {\n\tvoid *ret;\n\tbool tcache_success;\n\n\tassert(binind < SC_NBINS);\n\tcache_bin_t *bin = &tcache->bins[binind];\n\tret = cache_bin_alloc(bin, &tcache_success);\n\tassert(tcache_success == (ret != NULL));\n\tif (unlikely(!tcache_success)) {\n\t\tbool tcache_hard_success;\n\t\tarena = arena_choose(tsd, arena);\n\t\tif (unlikely(arena == NULL)) {\n\t\t\treturn NULL;\n\t\t}\n\t\tif (unlikely(tcache_small_bin_disabled(binind, bin))) {\n\t\t\t/* stats and zero are handled directly by the arena. */\n\t\t\treturn arena_malloc_hard(tsd_tsdn(tsd), arena, size,\n\t\t\t binind, zero);\n\t\t}\n\t\ttcache_bin_flush_stashed(tsd, tcache, bin, binind,\n\t\t /* is_small */ true);\n\n\t\tret = tcache_alloc_small_hard(tsd_tsdn(tsd), arena, tcache,\n\t\t bin, binind, &tcache_hard_success);\n\t\tif (tcache_hard_success == false) {\n\t\t\treturn NULL;\n\t\t}\n\t}\n\n\tassert(ret);\n\tif (unlikely(zero)) {\n\t\tsize_t usize = sz_index2size(binind);\n\t\tassert(tcache_salloc(tsd_tsdn(tsd), ret) == usize);\n\t\tmemset(ret, 0, usize);\n\t}\n\tif (config_stats) {\n\t\tbin->tstats.nrequests++;\n\t}\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\ntcache_alloc_large(tsd_t *tsd, arena_t *arena, tcache_t *tcache, size_t size,\n szind_t binind, bool zero, bool slow_path) {\n\tvoid *ret;\n\tbool tcache_success;\n\n\tassert(binind >= SC_NBINS && binind < nhbins);\n\tcache_bin_t *bin = &tcache->bins[binind];\n\tret = cache_bin_alloc(bin, &tcache_success);\n\tassert(tcache_success == (ret != NULL));\n\tif (unlikely(!tcache_success)) {\n\t\t/*\n\t\t * Only allocate one large object at a time, because it's quite\n\t\t * expensive to create one and not use it.\n\t\t */\n\t\tarena = arena_choose(tsd, arena);\n\t\tif (unlikely(arena == NULL)) {\n\t\t\treturn NULL;\n\t\t}\n\t\ttcache_bin_flush_stashed(tsd, tcache, bin, binind,\n\t\t /* is_small */ false);\n\n\t\tret = large_malloc(tsd_tsdn(tsd), arena, sz_s2u(size), zero);\n\t\tif (ret == NULL) {\n\t\t\treturn NULL;\n\t\t}\n\t} else {\n\t\tif (unlikely(zero)) {\n\t\t\tsize_t usize = sz_index2size(binind);\n\t\t\tassert(usize <= tcache_maxclass);\n\t\t\tmemset(ret, 0, usize);\n\t\t}\n\n\t\tif (config_stats) {\n\t\t\tbin->tstats.nrequests++;\n\t\t}\n\t}\n\n\treturn ret;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntcache_dalloc_small(tsd_t *tsd, tcache_t *tcache, void *ptr, szind_t binind,\n bool slow_path) {\n\tassert(tcache_salloc(tsd_tsdn(tsd), ptr) <= SC_SMALL_MAXCLASS);\n\n\tcache_bin_t *bin = &tcache->bins[binind];\n\t/*\n\t * Not marking the branch unlikely because this is past free_fastpath()\n\t * (which handles the most common cases), i.e. at this point it's often\n\t * uncommon cases.\n\t */\n\tif (cache_bin_nonfast_aligned(ptr)) {\n\t\t/* Junk unconditionally, even if bin is full. */\n\t\tsan_junk_ptr(ptr, sz_index2size(binind));\n\t\tif (cache_bin_stash(bin, ptr)) {\n\t\t\treturn;\n\t\t}\n\t\tassert(cache_bin_full(bin));\n\t\t/* Bin full; fall through into the flush branch. */\n\t}\n\n\tif (unlikely(!cache_bin_dalloc_easy(bin, ptr))) {\n\t\tif (unlikely(tcache_small_bin_disabled(binind, bin))) {\n\t\t\tarena_dalloc_small(tsd_tsdn(tsd), ptr);\n\t\t\treturn;\n\t\t}\n\t\tcache_bin_sz_t max = cache_bin_info_ncached_max(\n\t\t &tcache_bin_info[binind]);\n\t\tunsigned remain = max >> opt_lg_tcache_flush_small_div;\n\t\ttcache_bin_flush_small(tsd, tcache, bin, binind, remain);\n\t\tbool ret = cache_bin_dalloc_easy(bin, ptr);\n\t\tassert(ret);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntcache_dalloc_large(tsd_t *tsd, tcache_t *tcache, void *ptr, szind_t binind,\n bool slow_path) {\n\n\tassert(tcache_salloc(tsd_tsdn(tsd), ptr)\n\t > SC_SMALL_MAXCLASS);\n\tassert(tcache_salloc(tsd_tsdn(tsd), ptr) <= tcache_maxclass);\n\n\tcache_bin_t *bin = &tcache->bins[binind];\n\tif (unlikely(!cache_bin_dalloc_easy(bin, ptr))) {\n\t\tunsigned remain = cache_bin_info_ncached_max(\n\t\t &tcache_bin_info[binind]) >> opt_lg_tcache_flush_large_div;\n\t\ttcache_bin_flush_large(tsd, tcache, bin, binind, remain);\n\t\tbool ret = cache_bin_dalloc_easy(bin, ptr);\n\t\tassert(ret);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE tcache_t *\ntcaches_get(tsd_t *tsd, unsigned ind) {\n\ttcaches_t *elm = &tcaches[ind];\n\tif (unlikely(elm->tcache == NULL)) {\n\t\tmalloc_printf(\": invalid tcache id (%u).\\n\", ind);\n\t\tabort();\n\t} else if (unlikely(elm->tcache == TCACHES_ELM_NEED_REINIT)) {\n\t\telm->tcache = tcache_create_explicit(tsd);\n\t}\n\treturn elm->tcache;\n}\n\n#endif /* JEMALLOC_INTERNAL_TCACHE_INLINES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tcache_structs.h", "content": "#ifndef JEMALLOC_INTERNAL_TCACHE_STRUCTS_H\n#define JEMALLOC_INTERNAL_TCACHE_STRUCTS_H\n\n#include \"jemalloc/internal/cache_bin.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/ticker.h\"\n#include \"jemalloc/internal/tsd_types.h\"\n\n/*\n * The tcache state is split into the slow and hot path data. Each has a\n * pointer to the other, and the data always comes in pairs. The layout of each\n * of them varies in practice; tcache_slow lives in the TSD for the automatic\n * tcache, and as part of a dynamic allocation for manual allocations. Keeping\n * a pointer to tcache_slow lets us treat these cases uniformly, rather than\n * splitting up the tcache [de]allocation code into those paths called with the\n * TSD tcache and those called with a manual tcache.\n */\n\nstruct tcache_slow_s {\n\t/* Lets us track all the tcaches in an arena. */\n\tql_elm(tcache_slow_t) link;\n\n\t/*\n\t * The descriptor lets the arena find our cache bins without seeing the\n\t * tcache definition. This enables arenas to aggregate stats across\n\t * tcaches without having a tcache dependency.\n\t */\n\tcache_bin_array_descriptor_t cache_bin_array_descriptor;\n\n\t/* The arena this tcache is associated with. */\n\tarena_t\t\t*arena;\n\t/* Next bin to GC. */\n\tszind_t\t\tnext_gc_bin;\n\t/* For small bins, fill (ncached_max >> lg_fill_div). */\n\tuint8_t\t\tlg_fill_div[SC_NBINS];\n\t/* For small bins, whether has been refilled since last GC. */\n\tbool\t\tbin_refilled[SC_NBINS];\n\t/*\n\t * For small bins, the number of items we can pretend to flush before\n\t * actually flushing.\n\t */\n\tuint8_t\t\tbin_flush_delay_items[SC_NBINS];\n\t/*\n\t * The start of the allocation containing the dynamic allocation for\n\t * either the cache bins alone, or the cache bin memory as well as this\n\t * tcache_slow_t and its associated tcache_t.\n\t */\n\tvoid\t\t*dyn_alloc;\n\n\t/* The associated bins. */\n\ttcache_t\t*tcache;\n};\n\nstruct tcache_s {\n\ttcache_slow_t\t*tcache_slow;\n\tcache_bin_t\tbins[TCACHE_NBINS_MAX];\n};\n\n/* Linkage for list of available (previously used) explicit tcache IDs. */\nstruct tcaches_s {\n\tunion {\n\t\ttcache_t\t*tcache;\n\t\ttcaches_t\t*next;\n\t};\n};\n\n#endif /* JEMALLOC_INTERNAL_TCACHE_STRUCTS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tcache_types.h", "content": "#ifndef JEMALLOC_INTERNAL_TCACHE_TYPES_H\n#define JEMALLOC_INTERNAL_TCACHE_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\ntypedef struct tcache_slow_s tcache_slow_t;\ntypedef struct tcache_s tcache_t;\ntypedef struct tcaches_s tcaches_t;\n\n/*\n * tcache pointers close to NULL are used to encode state information that is\n * used for two purposes: preventing thread caching on a per thread basis and\n * cleaning up during thread shutdown.\n */\n#define TCACHE_STATE_DISABLED\t\t((tcache_t *)(uintptr_t)1)\n#define TCACHE_STATE_REINCARNATED\t((tcache_t *)(uintptr_t)2)\n#define TCACHE_STATE_PURGATORY\t\t((tcache_t *)(uintptr_t)3)\n#define TCACHE_STATE_MAX\t\tTCACHE_STATE_PURGATORY\n\n/* Used in TSD static initializer only. Real init in tsd_tcache_data_init(). */\n#define TCACHE_ZERO_INITIALIZER {0}\n#define TCACHE_SLOW_ZERO_INITIALIZER {0}\n\n/* Used in TSD static initializer only. Will be initialized to opt_tcache. */\n#define TCACHE_ENABLED_ZERO_INITIALIZER false\n\n/* Used for explicit tcache only. Means flushed but not destroyed. */\n#define TCACHES_ELM_NEED_REINIT ((tcache_t *)(uintptr_t)1)\n\n#define TCACHE_LG_MAXCLASS_LIMIT 23 /* tcache_maxclass = 8M */\n#define TCACHE_MAXCLASS_LIMIT ((size_t)1 << TCACHE_LG_MAXCLASS_LIMIT)\n#define TCACHE_NBINS_MAX (SC_NBINS + SC_NGROUP *\t\t\t\\\n (TCACHE_LG_MAXCLASS_LIMIT - SC_LG_LARGE_MINCLASS) + 1)\n\n#endif /* JEMALLOC_INTERNAL_TCACHE_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/test_hooks.h", "content": "#ifndef JEMALLOC_INTERNAL_TEST_HOOKS_H\n#define JEMALLOC_INTERNAL_TEST_HOOKS_H\n\nextern JEMALLOC_EXPORT void (*test_hooks_arena_new_hook)();\nextern JEMALLOC_EXPORT void (*test_hooks_libc_hook)();\n\n#if defined(JEMALLOC_JET) || defined(JEMALLOC_UNIT_TEST)\n# define JEMALLOC_TEST_HOOK(fn, hook) ((void)(hook != NULL && (hook(), 0)), fn)\n\n# define open JEMALLOC_TEST_HOOK(open, test_hooks_libc_hook)\n# define read JEMALLOC_TEST_HOOK(read, test_hooks_libc_hook)\n# define write JEMALLOC_TEST_HOOK(write, test_hooks_libc_hook)\n# define readlink JEMALLOC_TEST_HOOK(readlink, test_hooks_libc_hook)\n# define close JEMALLOC_TEST_HOOK(close, test_hooks_libc_hook)\n# define creat JEMALLOC_TEST_HOOK(creat, test_hooks_libc_hook)\n# define secure_getenv JEMALLOC_TEST_HOOK(secure_getenv, test_hooks_libc_hook)\n/* Note that this is undef'd and re-define'd in src/prof.c. */\n# define _Unwind_Backtrace JEMALLOC_TEST_HOOK(_Unwind_Backtrace, test_hooks_libc_hook)\n#else\n# define JEMALLOC_TEST_HOOK(fn, hook) fn\n#endif\n\n\n#endif /* JEMALLOC_INTERNAL_TEST_HOOKS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/thread_event.h", "content": "#ifndef JEMALLOC_INTERNAL_THREAD_EVENT_H\n#define JEMALLOC_INTERNAL_THREAD_EVENT_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/* \"te\" is short for \"thread_event\" */\n\n/*\n * TE_MIN_START_WAIT should not exceed the minimal allocation usize.\n */\n#define TE_MIN_START_WAIT ((uint64_t)1U)\n#define TE_MAX_START_WAIT UINT64_MAX\n\n/*\n * Maximum threshold on thread_(de)allocated_next_event_fast, so that there is\n * no need to check overflow in malloc fast path. (The allocation size in malloc\n * fast path never exceeds SC_LOOKUP_MAXCLASS.)\n */\n#define TE_NEXT_EVENT_FAST_MAX (UINT64_MAX - SC_LOOKUP_MAXCLASS + 1U)\n\n/*\n * The max interval helps make sure that malloc stays on the fast path in the\n * common case, i.e. thread_allocated < thread_allocated_next_event_fast. When\n * thread_allocated is within an event's distance to TE_NEXT_EVENT_FAST_MAX\n * above, thread_allocated_next_event_fast is wrapped around and we fall back to\n * the medium-fast path. The max interval makes sure that we're not staying on\n * the fallback case for too long, even if there's no active event or if all\n * active events have long wait times.\n */\n#define TE_MAX_INTERVAL ((uint64_t)(4U << 20))\n\n/*\n * Invalid elapsed time, for situations where elapsed time is not needed. See\n * comments in thread_event.c for more info.\n */\n#define TE_INVALID_ELAPSED UINT64_MAX\n\ntypedef struct te_ctx_s {\n\tbool is_alloc;\n\tuint64_t *current;\n\tuint64_t *last_event;\n\tuint64_t *next_event;\n\tuint64_t *next_event_fast;\n} te_ctx_t;\n\nvoid te_assert_invariants_debug(tsd_t *tsd);\nvoid te_event_trigger(tsd_t *tsd, te_ctx_t *ctx);\nvoid te_recompute_fast_threshold(tsd_t *tsd);\nvoid tsd_te_init(tsd_t *tsd);\n\n/*\n * List of all events, in the following format:\n * E(event,\t\t(condition), is_alloc_event)\n */\n#define ITERATE_OVER_ALL_EVENTS\t\t\t\t\t\t\\\n E(tcache_gc,\t\t(opt_tcache_gc_incr_bytes > 0), true)\t\\\n E(prof_sample,\t\t(config_prof && opt_prof), true) \t\\\n E(stats_interval,\t\t(opt_stats_interval >= 0), true) \t\\\n E(tcache_gc_dalloc,\t\t(opt_tcache_gc_incr_bytes > 0), false)\t\\\n E(peak_alloc,\t\tconfig_stats, true)\t\t\t\\\n E(peak_dalloc,\t\tconfig_stats, false)\n\n#define E(event, condition_unused, is_alloc_event_unused)\t\t\\\n C(event##_event_wait)\n\n/* List of all thread event counters. */\n#define ITERATE_OVER_ALL_COUNTERS\t\t\t\t\t\\\n C(thread_allocated)\t\t\t\t\t\t\t\\\n C(thread_allocated_last_event)\t\t\t\t\t\\\n ITERATE_OVER_ALL_EVENTS\t\t\t\t\t\t\\\n C(prof_sample_last_event)\t\t\t\t\t\t\\\n C(stats_interval_last_event)\n\n/* Getters directly wrap TSD getters. */\n#define C(counter)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE uint64_t\t\t\t\t\t\t\\\ncounter##_get(tsd_t *tsd) {\t\t\t\t\t\t\\\n\treturn tsd_##counter##_get(tsd);\t\t\t\t\\\n}\n\nITERATE_OVER_ALL_COUNTERS\n#undef C\n\n/*\n * Setters call the TSD pointer getters rather than the TSD setters, so that\n * the counters can be modified even when TSD state is reincarnated or\n * minimal_initialized: if an event is triggered in such cases, we will\n * temporarily delay the event and let it be immediately triggered at the next\n * allocation call.\n */\n#define C(counter)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE void\t\t\t\t\t\t\\\ncounter##_set(tsd_t *tsd, uint64_t v) {\t\t\t\t\t\\\n\t*tsd_##counter##p_get(tsd) = v;\t\t\t\t\t\\\n}\n\nITERATE_OVER_ALL_COUNTERS\n#undef C\n\n/*\n * For generating _event_wait getter / setter functions for each individual\n * event.\n */\n#undef E\n\n/*\n * The malloc and free fastpath getters -- use the unsafe getters since tsd may\n * be non-nominal, in which case the fast_threshold will be set to 0. This\n * allows checking for events and tsd non-nominal in a single branch.\n *\n * Note that these can only be used on the fastpath.\n */\nJEMALLOC_ALWAYS_INLINE void\nte_malloc_fastpath_ctx(tsd_t *tsd, uint64_t *allocated, uint64_t *threshold) {\n\t*allocated = *tsd_thread_allocatedp_get_unsafe(tsd);\n\t*threshold = *tsd_thread_allocated_next_event_fastp_get_unsafe(tsd);\n\tassert(*threshold <= TE_NEXT_EVENT_FAST_MAX);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_free_fastpath_ctx(tsd_t *tsd, uint64_t *deallocated, uint64_t *threshold) {\n\t/* Unsafe getters since this may happen before tsd_init. */\n\t*deallocated = *tsd_thread_deallocatedp_get_unsafe(tsd);\n\t*threshold = *tsd_thread_deallocated_next_event_fastp_get_unsafe(tsd);\n\tassert(*threshold <= TE_NEXT_EVENT_FAST_MAX);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nte_ctx_is_alloc(te_ctx_t *ctx) {\n\treturn ctx->is_alloc;\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nte_ctx_current_bytes_get(te_ctx_t *ctx) {\n\treturn *ctx->current;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_ctx_current_bytes_set(te_ctx_t *ctx, uint64_t v) {\n\t*ctx->current = v;\n}\n\nJEMALLOC_ALWAYS_INLINE uint64_t\nte_ctx_last_event_get(te_ctx_t *ctx) {\n\treturn *ctx->last_event;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_ctx_last_event_set(te_ctx_t *ctx, uint64_t v) {\n\t*ctx->last_event = v;\n}\n\n/* Below 3 for next_event_fast. */\nJEMALLOC_ALWAYS_INLINE uint64_t\nte_ctx_next_event_fast_get(te_ctx_t *ctx) {\n\tuint64_t v = *ctx->next_event_fast;\n\tassert(v <= TE_NEXT_EVENT_FAST_MAX);\n\treturn v;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_ctx_next_event_fast_set(te_ctx_t *ctx, uint64_t v) {\n\tassert(v <= TE_NEXT_EVENT_FAST_MAX);\n\t*ctx->next_event_fast = v;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_next_event_fast_set_non_nominal(tsd_t *tsd) {\n\t/*\n\t * Set the fast thresholds to zero when tsd is non-nominal. Use the\n\t * unsafe getter as this may get called during tsd init and clean up.\n\t */\n\t*tsd_thread_allocated_next_event_fastp_get_unsafe(tsd) = 0;\n\t*tsd_thread_deallocated_next_event_fastp_get_unsafe(tsd) = 0;\n}\n\n/* For next_event. Setter also updates the fast threshold. */\nJEMALLOC_ALWAYS_INLINE uint64_t\nte_ctx_next_event_get(te_ctx_t *ctx) {\n\treturn *ctx->next_event;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_ctx_next_event_set(tsd_t *tsd, te_ctx_t *ctx, uint64_t v) {\n\t*ctx->next_event = v;\n\tte_recompute_fast_threshold(tsd);\n}\n\n/*\n * The function checks in debug mode whether the thread event counters are in\n * a consistent state, which forms the invariants before and after each round\n * of thread event handling that we can rely on and need to promise.\n * The invariants are only temporarily violated in the middle of\n * te_event_advance() if an event is triggered (the te_event_trigger() call at\n * the end will restore the invariants).\n */\nJEMALLOC_ALWAYS_INLINE void\nte_assert_invariants(tsd_t *tsd) {\n\tif (config_debug) {\n\t\tte_assert_invariants_debug(tsd);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_ctx_get(tsd_t *tsd, te_ctx_t *ctx, bool is_alloc) {\n\tctx->is_alloc = is_alloc;\n\tif (is_alloc) {\n\t\tctx->current = tsd_thread_allocatedp_get(tsd);\n\t\tctx->last_event = tsd_thread_allocated_last_eventp_get(tsd);\n\t\tctx->next_event = tsd_thread_allocated_next_eventp_get(tsd);\n\t\tctx->next_event_fast =\n\t\t tsd_thread_allocated_next_event_fastp_get(tsd);\n\t} else {\n\t\tctx->current = tsd_thread_deallocatedp_get(tsd);\n\t\tctx->last_event = tsd_thread_deallocated_last_eventp_get(tsd);\n\t\tctx->next_event = tsd_thread_deallocated_next_eventp_get(tsd);\n\t\tctx->next_event_fast =\n\t\t tsd_thread_deallocated_next_event_fastp_get(tsd);\n\t}\n}\n\n/*\n * The lookahead functionality facilitates events to be able to lookahead, i.e.\n * without touching the event counters, to determine whether an event would be\n * triggered. The event counters are not advanced until the end of the\n * allocation / deallocation calls, so the lookahead can be useful if some\n * preparation work for some event must be done early in the allocation /\n * deallocation calls.\n *\n * Currently only the profiling sampling event needs the lookahead\n * functionality, so we don't yet define general purpose lookahead functions.\n *\n * Surplus is a terminology referring to the amount of bytes beyond what's\n * needed for triggering an event, which can be a useful quantity to have in\n * general when lookahead is being called.\n */\n\nJEMALLOC_ALWAYS_INLINE bool\nte_prof_sample_event_lookahead_surplus(tsd_t *tsd, size_t usize,\n size_t *surplus) {\n\tif (surplus != NULL) {\n\t\t/*\n\t\t * This is a dead store: the surplus will be overwritten before\n\t\t * any read. The initialization suppresses compiler warnings.\n\t\t * Meanwhile, using SIZE_MAX to initialize is good for\n\t\t * debugging purpose, because a valid surplus value is strictly\n\t\t * less than usize, which is at most SIZE_MAX.\n\t\t */\n\t\t*surplus = SIZE_MAX;\n\t}\n\tif (unlikely(!tsd_nominal(tsd) || tsd_reentrancy_level_get(tsd) > 0)) {\n\t\treturn false;\n\t}\n\t/* The subtraction is intentionally susceptible to underflow. */\n\tuint64_t accumbytes = tsd_thread_allocated_get(tsd) + usize -\n\t tsd_thread_allocated_last_event_get(tsd);\n\tuint64_t sample_wait = tsd_prof_sample_event_wait_get(tsd);\n\tif (accumbytes < sample_wait) {\n\t\treturn false;\n\t}\n\tassert(accumbytes - sample_wait < (uint64_t)usize);\n\tif (surplus != NULL) {\n\t\t*surplus = (size_t)(accumbytes - sample_wait);\n\t}\n\treturn true;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nte_prof_sample_event_lookahead(tsd_t *tsd, size_t usize) {\n\treturn te_prof_sample_event_lookahead_surplus(tsd, usize, NULL);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nte_event_advance(tsd_t *tsd, size_t usize, bool is_alloc) {\n\tte_assert_invariants(tsd);\n\n\tte_ctx_t ctx;\n\tte_ctx_get(tsd, &ctx, is_alloc);\n\n\tuint64_t bytes_before = te_ctx_current_bytes_get(&ctx);\n\tte_ctx_current_bytes_set(&ctx, bytes_before + usize);\n\n\t/* The subtraction is intentionally susceptible to underflow. */\n\tif (likely(usize < te_ctx_next_event_get(&ctx) - bytes_before)) {\n\t\tte_assert_invariants(tsd);\n\t} else {\n\t\tte_event_trigger(tsd, &ctx);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nthread_dalloc_event(tsd_t *tsd, size_t usize) {\n\tte_event_advance(tsd, usize, false);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nthread_alloc_event(tsd_t *tsd, size_t usize) {\n\tte_event_advance(tsd, usize, true);\n}\n\n#endif /* JEMALLOC_INTERNAL_THREAD_EVENT_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/ticker.h", "content": "#ifndef JEMALLOC_INTERNAL_TICKER_H\n#define JEMALLOC_INTERNAL_TICKER_H\n\n#include \"jemalloc/internal/prng.h\"\n#include \"jemalloc/internal/util.h\"\n\n/**\n * A ticker makes it easy to count-down events until some limit. You\n * ticker_init the ticker to trigger every nticks events. You then notify it\n * that an event has occurred with calls to ticker_tick (or that nticks events\n * have occurred with a call to ticker_ticks), which will return true (and reset\n * the counter) if the countdown hit zero.\n */\ntypedef struct ticker_s ticker_t;\nstruct ticker_s {\n\tint32_t tick;\n\tint32_t nticks;\n};\n\nstatic inline void\nticker_init(ticker_t *ticker, int32_t nticks) {\n\tticker->tick = nticks;\n\tticker->nticks = nticks;\n}\n\nstatic inline void\nticker_copy(ticker_t *ticker, const ticker_t *other) {\n\t*ticker = *other;\n}\n\nstatic inline int32_t\nticker_read(const ticker_t *ticker) {\n\treturn ticker->tick;\n}\n\n/*\n * Not intended to be a public API. Unfortunately, on x86, neither gcc nor\n * clang seems smart enough to turn\n * ticker->tick -= nticks;\n * if (unlikely(ticker->tick < 0)) {\n * fixup ticker\n * return true;\n * }\n * return false;\n * into\n * subq %nticks_reg, (%ticker_reg)\n * js fixup ticker\n *\n * unless we force \"fixup ticker\" out of line. In that case, gcc gets it right,\n * but clang now does worse than before. So, on x86 with gcc, we force it out\n * of line, but otherwise let the inlining occur. Ordinarily this wouldn't be\n * worth the hassle, but this is on the fast path of both malloc and free (via\n * tcache_event).\n */\n#if defined(__GNUC__) && !defined(__clang__)\t\t\t\t\\\n && (defined(__x86_64__) || defined(__i386__))\nJEMALLOC_NOINLINE\n#endif\nstatic bool\nticker_fixup(ticker_t *ticker) {\n\tticker->tick = ticker->nticks;\n\treturn true;\n}\n\nstatic inline bool\nticker_ticks(ticker_t *ticker, int32_t nticks) {\n\tticker->tick -= nticks;\n\tif (unlikely(ticker->tick < 0)) {\n\t\treturn ticker_fixup(ticker);\n\t}\n\treturn false;\n}\n\nstatic inline bool\nticker_tick(ticker_t *ticker) {\n\treturn ticker_ticks(ticker, 1);\n}\n\n/*\n * Try to tick. If ticker would fire, return true, but rely on\n * slowpath to reset ticker.\n */\nstatic inline bool\nticker_trytick(ticker_t *ticker) {\n\t--ticker->tick;\n\tif (unlikely(ticker->tick < 0)) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/*\n * The ticker_geom_t is much like the ticker_t, except that instead of ticker\n * having a constant countdown, it has an approximate one; each tick has\n * approximately a 1/nticks chance of triggering the count.\n *\n * The motivation is in triggering arena decay. With a naive strategy, each\n * thread would maintain a ticker per arena, and check if decay is necessary\n * each time that the arena's ticker fires. This has two costs:\n * - Since under reasonable assumptions both threads and arenas can scale\n * linearly with the number of CPUs, maintaining per-arena data in each thread\n * scales quadratically with the number of CPUs.\n * - These tickers are often a cache miss down tcache flush pathways.\n *\n * By giving each tick a 1/nticks chance of firing, we still maintain the same\n * average number of ticks-until-firing per arena, with only a single ticker's\n * worth of metadata.\n */\n\n/* See ticker.c for an explanation of these constants. */\n#define TICKER_GEOM_NBITS 6\n#define TICKER_GEOM_MUL 61\nextern const uint8_t ticker_geom_table[1 << TICKER_GEOM_NBITS];\n\n/* Not actually any different from ticker_t; just for type safety. */\ntypedef struct ticker_geom_s ticker_geom_t;\nstruct ticker_geom_s {\n\tint32_t tick;\n\tint32_t nticks;\n};\n\n/*\n * Just pick the average delay for the first counter. We're more concerned with\n * the behavior over long periods of time rather than the exact timing of the\n * initial ticks.\n */\n#define TICKER_GEOM_INIT(nticks) {nticks, nticks}\n\nstatic inline void\nticker_geom_init(ticker_geom_t *ticker, int32_t nticks) {\n\t/*\n\t * Make sure there's no overflow possible. This shouldn't really be a\n\t * problem for reasonable nticks choices, which are all static and\n\t * relatively small.\n\t */\n\tassert((uint64_t)nticks * (uint64_t)255 / (uint64_t)TICKER_GEOM_MUL\n\t <= (uint64_t)INT32_MAX);\n\tticker->tick = nticks;\n\tticker->nticks = nticks;\n}\n\nstatic inline int32_t\nticker_geom_read(const ticker_geom_t *ticker) {\n\treturn ticker->tick;\n}\n\n/* Same deal as above. */\n#if defined(__GNUC__) && !defined(__clang__)\t\t\t\t\\\n && (defined(__x86_64__) || defined(__i386__))\nJEMALLOC_NOINLINE\n#endif\nstatic bool\nticker_geom_fixup(ticker_geom_t *ticker, uint64_t *prng_state) {\n\tuint64_t idx = prng_lg_range_u64(prng_state, TICKER_GEOM_NBITS);\n\tticker->tick = (uint32_t)(\n\t (uint64_t)ticker->nticks * (uint64_t)ticker_geom_table[idx]\n\t / (uint64_t)TICKER_GEOM_MUL);\n\treturn true;\n}\n\nstatic inline bool\nticker_geom_ticks(ticker_geom_t *ticker, uint64_t *prng_state, int32_t nticks) {\n\tticker->tick -= nticks;\n\tif (unlikely(ticker->tick < 0)) {\n\t\treturn ticker_geom_fixup(ticker, prng_state);\n\t}\n\treturn false;\n}\n\nstatic inline bool\nticker_geom_tick(ticker_geom_t *ticker, uint64_t *prng_state) {\n\treturn ticker_geom_ticks(ticker, prng_state, 1);\n}\n\n#endif /* JEMALLOC_INTERNAL_TICKER_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd.h", "content": "#ifndef JEMALLOC_INTERNAL_TSD_H\n#define JEMALLOC_INTERNAL_TSD_H\n\n#include \"jemalloc/internal/activity_callback.h\"\n#include \"jemalloc/internal/arena_types.h\"\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/bin_types.h\"\n#include \"jemalloc/internal/jemalloc_internal_externs.h\"\n#include \"jemalloc/internal/peak.h\"\n#include \"jemalloc/internal/prof_types.h\"\n#include \"jemalloc/internal/ql.h\"\n#include \"jemalloc/internal/rtree_tsd.h\"\n#include \"jemalloc/internal/tcache_types.h\"\n#include \"jemalloc/internal/tcache_structs.h\"\n#include \"jemalloc/internal/util.h\"\n#include \"jemalloc/internal/witness.h\"\n\n/*\n * Thread-Specific-Data layout\n *\n * At least some thread-local data gets touched on the fast-path of almost all\n * malloc operations. But much of it is only necessary down slow-paths, or\n * testing. We want to colocate the fast-path data so that it can live on the\n * same cacheline if possible. So we define three tiers of hotness:\n * TSD_DATA_FAST: Touched on the alloc/dalloc fast paths.\n * TSD_DATA_SLOW: Touched down slow paths. \"Slow\" here is sort of general;\n * there are \"semi-slow\" paths like \"not a sized deallocation, but can still\n * live in the tcache\". We'll want to keep these closer to the fast-path\n * data.\n * TSD_DATA_SLOWER: Only touched in test or debug modes, or not touched at all.\n *\n * An additional concern is that the larger tcache bins won't be used (we have a\n * bin per size class, but by default only cache relatively small objects). So\n * the earlier bins are in the TSD_DATA_FAST tier, but the later ones are in the\n * TSD_DATA_SLOWER tier.\n *\n * As a result of all this, we put the slow data first, then the fast data, then\n * the slower data, while keeping the tcache as the last element of the fast\n * data (so that the fast -> slower transition happens midway through the\n * tcache). While we don't yet play alignment tricks to guarantee it, this\n * increases our odds of getting some cache/page locality on fast paths.\n */\n\n#ifdef JEMALLOC_JET\ntypedef void (*test_callback_t)(int *);\n# define MALLOC_TSD_TEST_DATA_INIT 0x72b65c10\n# define MALLOC_TEST_TSD \\\n O(test_data,\t\tint,\t\t\tint)\t\t\\\n O(test_callback,\t\ttest_callback_t,\tint)\n# define MALLOC_TEST_TSD_INITIALIZER , MALLOC_TSD_TEST_DATA_INIT, NULL\n#else\n# define MALLOC_TEST_TSD\n# define MALLOC_TEST_TSD_INITIALIZER\n#endif\n\ntypedef ql_elm(tsd_t) tsd_link_t;\n\n/* O(name,\t\t\ttype,\t\t\tnullable type) */\n#define TSD_DATA_SLOW\t\t\t\t\t\t\t\\\n O(tcache_enabled,\t\tbool,\t\t\tbool)\t\t\\\n O(reentrancy_level,\t\tint8_t,\t\t\tint8_t)\t\t\\\n O(thread_allocated_last_event,\tuint64_t,\tuint64_t)\t\\\n O(thread_allocated_next_event,\tuint64_t,\tuint64_t)\t\\\n O(thread_deallocated_last_event,\tuint64_t,\tuint64_t)\t\\\n O(thread_deallocated_next_event,\tuint64_t,\tuint64_t)\t\\\n O(tcache_gc_event_wait,\tuint64_t,\t\tuint64_t)\t\\\n O(tcache_gc_dalloc_event_wait,\tuint64_t,\tuint64_t)\t\\\n O(prof_sample_event_wait,\tuint64_t,\t\tuint64_t)\t\\\n O(prof_sample_last_event,\tuint64_t,\t\tuint64_t)\t\\\n O(stats_interval_event_wait,\tuint64_t,\tuint64_t)\t\\\n O(stats_interval_last_event,\tuint64_t,\tuint64_t)\t\\\n O(peak_alloc_event_wait,\tuint64_t,\t\tuint64_t)\t\\\n O(peak_dalloc_event_wait,\tuint64_t,\tuint64_t)\t\t\\\n O(prof_tdata,\t\tprof_tdata_t *,\t\tprof_tdata_t *)\t\\\n O(prng_state,\t\tuint64_t,\t\tuint64_t)\t\\\n O(san_extents_until_guard_small,\tuint64_t,\tuint64_t)\t\\\n O(san_extents_until_guard_large,\tuint64_t,\tuint64_t)\t\\\n O(iarena,\t\t\tarena_t *,\t\tarena_t *)\t\\\n O(arena,\t\t\tarena_t *,\t\tarena_t *)\t\\\n O(arena_decay_ticker,\tticker_geom_t,\t\tticker_geom_t)\t\\\n O(sec_shard,\t\tuint8_t,\t\tuint8_t)\t\\\n O(binshards,\t\ttsd_binshards_t,\ttsd_binshards_t)\\\n O(tsd_link,\t\t\ttsd_link_t,\t\ttsd_link_t)\t\\\n O(in_hook,\t\t\tbool,\t\t\tbool)\t\t\\\n O(peak,\t\t\tpeak_t,\t\t\tpeak_t)\t\t\\\n O(activity_callback_thunk,\tactivity_callback_thunk_t,\t\t\\\n\tactivity_callback_thunk_t)\t\t\t\t\t\\\n O(tcache_slow,\t\ttcache_slow_t,\t\ttcache_slow_t)\t\\\n O(rtree_ctx,\t\trtree_ctx_t,\t\trtree_ctx_t)\n\n#define TSD_DATA_SLOW_INITIALIZER\t\t\t\t\t\\\n /* tcache_enabled */\tTCACHE_ENABLED_ZERO_INITIALIZER,\t\\\n /* reentrancy_level */\t0,\t\t\t\t\t\\\n /* thread_allocated_last_event */\t0,\t\t\t\t\\\n /* thread_allocated_next_event */\t0,\t\t\t\t\\\n /* thread_deallocated_last_event */\t0,\t\t\t\t\\\n /* thread_deallocated_next_event */\t0,\t\t\t\t\\\n /* tcache_gc_event_wait */\t\t0,\t\t\t\t\\\n /* tcache_gc_dalloc_event_wait */\t0,\t\t\t\t\\\n /* prof_sample_event_wait */\t0,\t\t\t\t\\\n /* prof_sample_last_event */\t0,\t\t\t\t\\\n /* stats_interval_event_wait */\t0,\t\t\t\t\\\n /* stats_interval_last_event */\t0,\t\t\t\t\\\n /* peak_alloc_event_wait */\t\t0,\t\t\t\t\\\n /* peak_dalloc_event_wait */\t0,\t\t\t\t\\\n /* prof_tdata */\t\tNULL,\t\t\t\t\t\\\n /* prng_state */\t\t0,\t\t\t\t\t\\\n /* san_extents_until_guard_small */\t0,\t\t\t\t\\\n /* san_extents_until_guard_large */\t0,\t\t\t\t\\\n /* iarena */\t\tNULL,\t\t\t\t\t\\\n /* arena */\t\t\tNULL,\t\t\t\t\t\\\n /* arena_decay_ticker */\t\t\t\t\t\t\\\n\tTICKER_GEOM_INIT(ARENA_DECAY_NTICKS_PER_UPDATE),\t\t\\\n /* sec_shard */\t\t(uint8_t)-1,\t\t\t\t\\\n /* binshards */\t\tTSD_BINSHARDS_ZERO_INITIALIZER,\t\t\\\n /* tsd_link */\t\t{NULL},\t\t\t\t\t\\\n /* in_hook */\t\tfalse,\t\t\t\t\t\\\n /* peak */\t\t\tPEAK_INITIALIZER,\t\t\t\\\n /* activity_callback_thunk */\t\t\t\t\t\\\n\tACTIVITY_CALLBACK_THUNK_INITIALIZER,\t\t\t\t\\\n /* tcache_slow */\t\tTCACHE_SLOW_ZERO_INITIALIZER,\t\t\\\n /* rtree_ctx */\t\tRTREE_CTX_INITIALIZER,\n\n/* O(name,\t\t\ttype,\t\t\tnullable type) */\n#define TSD_DATA_FAST\t\t\t\t\t\t\t\\\n O(thread_allocated,\t\tuint64_t,\t\tuint64_t)\t\\\n O(thread_allocated_next_event_fast,\tuint64_t,\tuint64_t)\t\\\n O(thread_deallocated,\tuint64_t,\t\tuint64_t)\t\\\n O(thread_deallocated_next_event_fast, uint64_t,\tuint64_t)\t\\\n O(tcache,\t\t\ttcache_t,\t\ttcache_t)\n\n#define TSD_DATA_FAST_INITIALIZER\t\t\t\t\t\\\n /* thread_allocated */\t0,\t\t\t\t\t\\\n /* thread_allocated_next_event_fast */ 0, \t\t\t\t\\\n /* thread_deallocated */\t0,\t\t\t\t\t\\\n /* thread_deallocated_next_event_fast */\t0,\t\t\t\\\n /* tcache */\t\tTCACHE_ZERO_INITIALIZER,\n\n/* O(name,\t\t\ttype,\t\t\tnullable type) */\n#define TSD_DATA_SLOWER\t\t\t\t\t\t\t\\\n O(witness_tsd, witness_tsd_t,\t\twitness_tsdn_t)\t\\\n MALLOC_TEST_TSD\n\n#define TSD_DATA_SLOWER_INITIALIZER\t\t\t\t\t\\\n /* witness */\t\tWITNESS_TSD_INITIALIZER\t\t\t\\\n /* test data */\t\tMALLOC_TEST_TSD_INITIALIZER\n\n\n#define TSD_INITIALIZER {\t\t\t\t\t\t\\\n \t\t\t\tTSD_DATA_SLOW_INITIALIZER\t\t\\\n /* state */\t\t\tATOMIC_INIT(tsd_state_uninitialized),\t\\\n \t\t\t\tTSD_DATA_FAST_INITIALIZER\t\t\\\n \t\t\t\tTSD_DATA_SLOWER_INITIALIZER\t\t\\\n}\n\n#if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32)\nvoid _malloc_tsd_cleanup_register(bool (*f)(void));\n#endif\n\nvoid *malloc_tsd_malloc(size_t size);\nvoid malloc_tsd_dalloc(void *wrapper);\ntsd_t *malloc_tsd_boot0(void);\nvoid malloc_tsd_boot1(void);\nvoid tsd_cleanup(void *arg);\ntsd_t *tsd_fetch_slow(tsd_t *tsd, bool internal);\nvoid tsd_state_set(tsd_t *tsd, uint8_t new_state);\nvoid tsd_slow_update(tsd_t *tsd);\nvoid tsd_prefork(tsd_t *tsd);\nvoid tsd_postfork_parent(tsd_t *tsd);\nvoid tsd_postfork_child(tsd_t *tsd);\n\n/*\n * Call ..._inc when your module wants to take all threads down the slow paths,\n * and ..._dec when it no longer needs to.\n */\nvoid tsd_global_slow_inc(tsdn_t *tsdn);\nvoid tsd_global_slow_dec(tsdn_t *tsdn);\nbool tsd_global_slow();\n\nenum {\n\t/* Common case --> jnz. */\n\ttsd_state_nominal = 0,\n\t/* Initialized but on slow path. */\n\ttsd_state_nominal_slow = 1,\n\t/*\n\t * Some thread has changed global state in such a way that all nominal\n\t * threads need to recompute their fast / slow status the next time they\n\t * get a chance.\n\t *\n\t * Any thread can change another thread's status *to* recompute, but\n\t * threads are the only ones who can change their status *from*\n\t * recompute.\n\t */\n\ttsd_state_nominal_recompute = 2,\n\t/*\n\t * The above nominal states should be lower values. We use\n\t * tsd_nominal_max to separate nominal states from threads in the\n\t * process of being born / dying.\n\t */\n\ttsd_state_nominal_max = 2,\n\n\t/*\n\t * A thread might free() during its death as its only allocator action;\n\t * in such scenarios, we need tsd, but set up in such a way that no\n\t * cleanup is necessary.\n\t */\n\ttsd_state_minimal_initialized = 3,\n\t/* States during which we know we're in thread death. */\n\ttsd_state_purgatory = 4,\n\ttsd_state_reincarnated = 5,\n\t/*\n\t * What it says on the tin; tsd that hasn't been initialized. Note\n\t * that even when the tsd struct lives in TLS, when need to keep track\n\t * of stuff like whether or not our pthread destructors have been\n\t * scheduled, so this really truly is different than the nominal state.\n\t */\n\ttsd_state_uninitialized = 6\n};\n\n/*\n * Some TSD accesses can only be done in a nominal state. To enforce this, we\n * wrap TSD member access in a function that asserts on TSD state, and mangle\n * field names to prevent touching them accidentally.\n */\n#define TSD_MANGLE(n) cant_access_tsd_items_directly_use_a_getter_or_setter_##n\n\n#ifdef JEMALLOC_U8_ATOMICS\n# define tsd_state_t atomic_u8_t\n# define tsd_atomic_load atomic_load_u8\n# define tsd_atomic_store atomic_store_u8\n# define tsd_atomic_exchange atomic_exchange_u8\n#else\n# define tsd_state_t atomic_u32_t\n# define tsd_atomic_load atomic_load_u32\n# define tsd_atomic_store atomic_store_u32\n# define tsd_atomic_exchange atomic_exchange_u32\n#endif\n\n/* The actual tsd. */\nstruct tsd_s {\n\t/*\n\t * The contents should be treated as totally opaque outside the tsd\n\t * module. Access any thread-local state through the getters and\n\t * setters below.\n\t */\n\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\n\tt TSD_MANGLE(n);\n\n\tTSD_DATA_SLOW\n\t/*\n\t * We manually limit the state to just a single byte. Unless the 8-bit\n\t * atomics are unavailable (which is rare).\n\t */\n\ttsd_state_t state;\n\tTSD_DATA_FAST\n\tTSD_DATA_SLOWER\n#undef O\n};\n\nJEMALLOC_ALWAYS_INLINE uint8_t\ntsd_state_get(tsd_t *tsd) {\n\t/*\n\t * This should be atomic. Unfortunately, compilers right now can't tell\n\t * that this can be done as a memory comparison, and forces a load into\n\t * a register that hurts fast-path performance.\n\t */\n\t/* return atomic_load_u8(&tsd->state, ATOMIC_RELAXED); */\n\treturn *(uint8_t *)&tsd->state;\n}\n\n/*\n * Wrapper around tsd_t that makes it possible to avoid implicit conversion\n * between tsd_t and tsdn_t, where tsdn_t is \"nullable\" and has to be\n * explicitly converted to tsd_t, which is non-nullable.\n */\nstruct tsdn_s {\n\ttsd_t tsd;\n};\n#define TSDN_NULL ((tsdn_t *)0)\nJEMALLOC_ALWAYS_INLINE tsdn_t *\ntsd_tsdn(tsd_t *tsd) {\n\treturn (tsdn_t *)tsd;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsdn_null(const tsdn_t *tsdn) {\n\treturn tsdn == NULL;\n}\n\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsdn_tsd(tsdn_t *tsdn) {\n\tassert(!tsdn_null(tsdn));\n\n\treturn &tsdn->tsd;\n}\n\n/*\n * We put the platform-specific data declarations and inlines into their own\n * header files to avoid cluttering this file. They define tsd_boot0,\n * tsd_boot1, tsd_boot, tsd_booted_get, tsd_get_allocates, tsd_get, and tsd_set.\n */\n#ifdef JEMALLOC_MALLOC_THREAD_CLEANUP\n#include \"jemalloc/internal/tsd_malloc_thread_cleanup.h\"\n#elif (defined(JEMALLOC_TLS))\n#include \"jemalloc/internal/tsd_tls.h\"\n#elif (defined(_WIN32))\n#include \"jemalloc/internal/tsd_win.h\"\n#else\n#include \"jemalloc/internal/tsd_generic.h\"\n#endif\n\n/*\n * tsd_foop_get_unsafe(tsd) returns a pointer to the thread-local instance of\n * foo. This omits some safety checks, and so can be used during tsd\n * initialization and cleanup.\n */\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE t *\t\t\t\t\t\t\\\ntsd_##n##p_get_unsafe(tsd_t *tsd) {\t\t\t\t\t\\\n\treturn &tsd->TSD_MANGLE(n);\t\t\t\t\t\\\n}\nTSD_DATA_SLOW\nTSD_DATA_FAST\nTSD_DATA_SLOWER\n#undef O\n\n/* tsd_foop_get(tsd) returns a pointer to the thread-local instance of foo. */\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE t *\t\t\t\t\t\t\\\ntsd_##n##p_get(tsd_t *tsd) {\t\t\t\t\t\t\\\n\t/*\t\t\t\t\t\t\t\t\\\n\t * Because the state might change asynchronously if it's\t\\\n\t * nominal, we need to make sure that we only read it once.\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tuint8_t state = tsd_state_get(tsd);\t\t\t\t\\\n\tassert(state == tsd_state_nominal ||\t\t\t\t\\\n\t state == tsd_state_nominal_slow ||\t\t\t\t\\\n\t state == tsd_state_nominal_recompute ||\t\t\t\\\n\t state == tsd_state_reincarnated ||\t\t\t\t\\\n\t state == tsd_state_minimal_initialized);\t\t\t\\\n\treturn tsd_##n##p_get_unsafe(tsd);\t\t\t\t\\\n}\nTSD_DATA_SLOW\nTSD_DATA_FAST\nTSD_DATA_SLOWER\n#undef O\n\n/*\n * tsdn_foop_get(tsdn) returns either the thread-local instance of foo (if tsdn\n * isn't NULL), or NULL (if tsdn is NULL), cast to the nullable pointer type.\n */\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE nt *\t\t\t\t\t\t\\\ntsdn_##n##p_get(tsdn_t *tsdn) {\t\t\t\t\t\t\\\n\tif (tsdn_null(tsdn)) {\t\t\t\t\t\t\\\n\t\treturn NULL;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ttsd_t *tsd = tsdn_tsd(tsdn);\t\t\t\t\t\\\n\treturn (nt *)tsd_##n##p_get(tsd);\t\t\t\t\\\n}\nTSD_DATA_SLOW\nTSD_DATA_FAST\nTSD_DATA_SLOWER\n#undef O\n\n/* tsd_foo_get(tsd) returns the value of the thread-local instance of foo. */\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE t\t\t\t\t\t\t\\\ntsd_##n##_get(tsd_t *tsd) {\t\t\t\t\t\t\\\n\treturn *tsd_##n##p_get(tsd);\t\t\t\t\t\\\n}\nTSD_DATA_SLOW\nTSD_DATA_FAST\nTSD_DATA_SLOWER\n#undef O\n\n/* tsd_foo_set(tsd, val) updates the thread-local instance of foo to be val. */\n#define O(n, t, nt)\t\t\t\t\t\t\t\\\nJEMALLOC_ALWAYS_INLINE void\t\t\t\t\t\t\\\ntsd_##n##_set(tsd_t *tsd, t val) {\t\t\t\t\t\\\n\tassert(tsd_state_get(tsd) != tsd_state_reincarnated &&\t\t\\\n\t tsd_state_get(tsd) != tsd_state_minimal_initialized);\t\\\n\t*tsd_##n##p_get(tsd) = val;\t\t\t\t\t\\\n}\nTSD_DATA_SLOW\nTSD_DATA_FAST\nTSD_DATA_SLOWER\n#undef O\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_assert_fast(tsd_t *tsd) {\n\t/*\n\t * Note that our fastness assertion does *not* include global slowness\n\t * counters; it's not in general possible to ensure that they won't\n\t * change asynchronously from underneath us.\n\t */\n\tassert(!malloc_slow && tsd_tcache_enabled_get(tsd) &&\n\t tsd_reentrancy_level_get(tsd) == 0);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_fast(tsd_t *tsd) {\n\tbool fast = (tsd_state_get(tsd) == tsd_state_nominal);\n\tif (fast) {\n\t\ttsd_assert_fast(tsd);\n\t}\n\n\treturn fast;\n}\n\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_fetch_impl(bool init, bool minimal) {\n\ttsd_t *tsd = tsd_get(init);\n\n\tif (!init && tsd_get_allocates() && tsd == NULL) {\n\t\treturn NULL;\n\t}\n\tassert(tsd != NULL);\n\n\tif (unlikely(tsd_state_get(tsd) != tsd_state_nominal)) {\n\t\treturn tsd_fetch_slow(tsd, minimal);\n\t}\n\tassert(tsd_fast(tsd));\n\ttsd_assert_fast(tsd);\n\n\treturn tsd;\n}\n\n/* Get a minimal TSD that requires no cleanup. See comments in free(). */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_fetch_min(void) {\n\treturn tsd_fetch_impl(true, true);\n}\n\n/* For internal background threads use only. */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_internal_fetch(void) {\n\ttsd_t *tsd = tsd_fetch_min();\n\t/* Use reincarnated state to prevent full initialization. */\n\ttsd_state_set(tsd, tsd_state_reincarnated);\n\n\treturn tsd;\n}\n\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_fetch(void) {\n\treturn tsd_fetch_impl(true, false);\n}\n\nstatic inline bool\ntsd_nominal(tsd_t *tsd) {\n\tbool nominal = tsd_state_get(tsd) <= tsd_state_nominal_max;\n\tassert(nominal || tsd_reentrancy_level_get(tsd) > 0);\n\n\treturn nominal;\n}\n\nJEMALLOC_ALWAYS_INLINE tsdn_t *\ntsdn_fetch(void) {\n\tif (!tsd_booted_get()) {\n\t\treturn NULL;\n\t}\n\n\treturn tsd_tsdn(tsd_fetch_impl(false, false));\n}\n\nJEMALLOC_ALWAYS_INLINE rtree_ctx_t *\ntsd_rtree_ctx(tsd_t *tsd) {\n\treturn tsd_rtree_ctxp_get(tsd);\n}\n\nJEMALLOC_ALWAYS_INLINE rtree_ctx_t *\ntsdn_rtree_ctx(tsdn_t *tsdn, rtree_ctx_t *fallback) {\n\t/*\n\t * If tsd cannot be accessed, initialize the fallback rtree_ctx and\n\t * return a pointer to it.\n\t */\n\tif (unlikely(tsdn_null(tsdn))) {\n\t\trtree_ctx_data_init(fallback);\n\t\treturn fallback;\n\t}\n\treturn tsd_rtree_ctx(tsdn_tsd(tsdn));\n}\n\nstatic inline bool\ntsd_state_nocleanup(tsd_t *tsd) {\n\treturn tsd_state_get(tsd) == tsd_state_reincarnated ||\n\t tsd_state_get(tsd) == tsd_state_minimal_initialized;\n}\n\n/*\n * These \"raw\" tsd reentrancy functions don't have any debug checking to make\n * sure that we're not touching arena 0. Better is to call pre_reentrancy and\n * post_reentrancy if this is possible.\n */\nstatic inline void\ntsd_pre_reentrancy_raw(tsd_t *tsd) {\n\tbool fast = tsd_fast(tsd);\n\tassert(tsd_reentrancy_level_get(tsd) < INT8_MAX);\n\t++*tsd_reentrancy_levelp_get(tsd);\n\tif (fast) {\n\t\t/* Prepare slow path for reentrancy. */\n\t\ttsd_slow_update(tsd);\n\t\tassert(tsd_state_get(tsd) == tsd_state_nominal_slow);\n\t}\n}\n\nstatic inline void\ntsd_post_reentrancy_raw(tsd_t *tsd) {\n\tint8_t *reentrancy_level = tsd_reentrancy_levelp_get(tsd);\n\tassert(*reentrancy_level > 0);\n\tif (--*reentrancy_level == 0) {\n\t\ttsd_slow_update(tsd);\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_TSD_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd_generic.h", "content": "#ifdef JEMALLOC_INTERNAL_TSD_GENERIC_H\n#error This file should be included only once, by tsd.h.\n#endif\n#define JEMALLOC_INTERNAL_TSD_GENERIC_H\n\ntypedef struct tsd_init_block_s tsd_init_block_t;\nstruct tsd_init_block_s {\n\tql_elm(tsd_init_block_t) link;\n\tpthread_t thread;\n\tvoid *data;\n};\n\n/* Defined in tsd.c, to allow the mutex headers to have tsd dependencies. */\ntypedef struct tsd_init_head_s tsd_init_head_t;\n\ntypedef struct {\n\tbool initialized;\n\ttsd_t val;\n} tsd_wrapper_t;\n\nvoid *tsd_init_check_recursion(tsd_init_head_t *head,\n tsd_init_block_t *block);\nvoid tsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block);\n\nextern pthread_key_t tsd_tsd;\nextern tsd_init_head_t tsd_init_head;\nextern tsd_wrapper_t tsd_boot_wrapper;\nextern bool tsd_booted;\n\n/* Initialization/cleanup. */\nJEMALLOC_ALWAYS_INLINE void\ntsd_cleanup_wrapper(void *arg) {\n\ttsd_wrapper_t *wrapper = (tsd_wrapper_t *)arg;\n\n\tif (wrapper->initialized) {\n\t\twrapper->initialized = false;\n\t\ttsd_cleanup(&wrapper->val);\n\t\tif (wrapper->initialized) {\n\t\t\t/* Trigger another cleanup round. */\n\t\t\tif (pthread_setspecific(tsd_tsd, (void *)wrapper) != 0)\n\t\t\t{\n\t\t\t\tmalloc_write(\": Error setting TSD\\n\");\n\t\t\t\tif (opt_abort) {\n\t\t\t\t\tabort();\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t}\n\tmalloc_tsd_dalloc(wrapper);\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_wrapper_set(tsd_wrapper_t *wrapper) {\n\tif (unlikely(!tsd_booted)) {\n\t\treturn;\n\t}\n\tif (pthread_setspecific(tsd_tsd, (void *)wrapper) != 0) {\n\t\tmalloc_write(\": Error setting TSD\\n\");\n\t\tabort();\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE tsd_wrapper_t *\ntsd_wrapper_get(bool init) {\n\ttsd_wrapper_t *wrapper;\n\n\tif (unlikely(!tsd_booted)) {\n\t\treturn &tsd_boot_wrapper;\n\t}\n\n\twrapper = (tsd_wrapper_t *)pthread_getspecific(tsd_tsd);\n\n\tif (init && unlikely(wrapper == NULL)) {\n\t\ttsd_init_block_t block;\n\t\twrapper = (tsd_wrapper_t *)\n\t\t tsd_init_check_recursion(&tsd_init_head, &block);\n\t\tif (wrapper) {\n\t\t\treturn wrapper;\n\t\t}\n\t\twrapper = (tsd_wrapper_t *)\n\t\t malloc_tsd_malloc(sizeof(tsd_wrapper_t));\n\t\tblock.data = (void *)wrapper;\n\t\tif (wrapper == NULL) {\n\t\t\tmalloc_write(\": Error allocating TSD\\n\");\n\t\t\tabort();\n\t\t} else {\n\t\t\twrapper->initialized = false;\n JEMALLOC_DIAGNOSTIC_PUSH\n JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n\t\t\ttsd_t initializer = TSD_INITIALIZER;\n JEMALLOC_DIAGNOSTIC_POP\n\t\t\twrapper->val = initializer;\n\t\t}\n\t\ttsd_wrapper_set(wrapper);\n\t\ttsd_init_finish(&tsd_init_head, &block);\n\t}\n\treturn wrapper;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot0(void) {\n\ttsd_wrapper_t *wrapper;\n\ttsd_init_block_t block;\n\n\twrapper = (tsd_wrapper_t *)\n\t tsd_init_check_recursion(&tsd_init_head, &block);\n\tif (wrapper) {\n\t\treturn false;\n\t}\n\tblock.data = &tsd_boot_wrapper;\n\tif (pthread_key_create(&tsd_tsd, tsd_cleanup_wrapper) != 0) {\n\t\treturn true;\n\t}\n\ttsd_booted = true;\n\ttsd_wrapper_set(&tsd_boot_wrapper);\n\ttsd_init_finish(&tsd_init_head, &block);\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_boot1(void) {\n\ttsd_wrapper_t *wrapper;\n\twrapper = (tsd_wrapper_t *)malloc_tsd_malloc(sizeof(tsd_wrapper_t));\n\tif (wrapper == NULL) {\n\t\tmalloc_write(\": Error allocating TSD\\n\");\n\t\tabort();\n\t}\n\ttsd_boot_wrapper.initialized = false;\n\ttsd_cleanup(&tsd_boot_wrapper.val);\n\twrapper->initialized = false;\n JEMALLOC_DIAGNOSTIC_PUSH\n JEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n\ttsd_t initializer = TSD_INITIALIZER;\n JEMALLOC_DIAGNOSTIC_POP\n\twrapper->val = initializer;\n\ttsd_wrapper_set(wrapper);\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot(void) {\n\tif (tsd_boot0()) {\n\t\treturn true;\n\t}\n\ttsd_boot1();\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_booted_get(void) {\n\treturn tsd_booted;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_get_allocates(void) {\n\treturn true;\n}\n\n/* Get/set. */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_get(bool init) {\n\ttsd_wrapper_t *wrapper;\n\n\tassert(tsd_booted);\n\twrapper = tsd_wrapper_get(init);\n\tif (tsd_get_allocates() && !init && wrapper == NULL) {\n\t\treturn NULL;\n\t}\n\treturn &wrapper->val;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_set(tsd_t *val) {\n\ttsd_wrapper_t *wrapper;\n\n\tassert(tsd_booted);\n\twrapper = tsd_wrapper_get(true);\n\tif (likely(&wrapper->val != val)) {\n\t\twrapper->val = *(val);\n\t}\n\twrapper->initialized = true;\n}\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd_malloc_thread_cleanup.h", "content": "#ifdef JEMALLOC_INTERNAL_TSD_MALLOC_THREAD_CLEANUP_H\n#error This file should be included only once, by tsd.h.\n#endif\n#define JEMALLOC_INTERNAL_TSD_MALLOC_THREAD_CLEANUP_H\n\n#define JEMALLOC_TSD_TYPE_ATTR(type) __thread type JEMALLOC_TLS_MODEL\n\nextern JEMALLOC_TSD_TYPE_ATTR(tsd_t) tsd_tls;\nextern JEMALLOC_TSD_TYPE_ATTR(bool) tsd_initialized;\nextern bool tsd_booted;\n\n/* Initialization/cleanup. */\nJEMALLOC_ALWAYS_INLINE bool\ntsd_cleanup_wrapper(void) {\n\tif (tsd_initialized) {\n\t\ttsd_initialized = false;\n\t\ttsd_cleanup(&tsd_tls);\n\t}\n\treturn tsd_initialized;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot0(void) {\n\t_malloc_tsd_cleanup_register(&tsd_cleanup_wrapper);\n\ttsd_booted = true;\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_boot1(void) {\n\t/* Do nothing. */\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot(void) {\n\treturn tsd_boot0();\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_booted_get(void) {\n\treturn tsd_booted;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_get_allocates(void) {\n\treturn false;\n}\n\n/* Get/set. */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_get(bool init) {\n\treturn &tsd_tls;\n}\nJEMALLOC_ALWAYS_INLINE void\ntsd_set(tsd_t *val) {\n\tassert(tsd_booted);\n\tif (likely(&tsd_tls != val)) {\n\t\ttsd_tls = (*val);\n\t}\n\ttsd_initialized = true;\n}\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd_tls.h", "content": "#ifdef JEMALLOC_INTERNAL_TSD_TLS_H\n#error This file should be included only once, by tsd.h.\n#endif\n#define JEMALLOC_INTERNAL_TSD_TLS_H\n\n#define JEMALLOC_TSD_TYPE_ATTR(type) __thread type JEMALLOC_TLS_MODEL\n\nextern JEMALLOC_TSD_TYPE_ATTR(tsd_t) tsd_tls;\nextern pthread_key_t tsd_tsd;\nextern bool tsd_booted;\n\n/* Initialization/cleanup. */\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot0(void) {\n\tif (pthread_key_create(&tsd_tsd, &tsd_cleanup) != 0) {\n\t\treturn true;\n\t}\n\ttsd_booted = true;\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_boot1(void) {\n\t/* Do nothing. */\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot(void) {\n\treturn tsd_boot0();\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_booted_get(void) {\n\treturn tsd_booted;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_get_allocates(void) {\n\treturn false;\n}\n\n/* Get/set. */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_get(bool init) {\n\treturn &tsd_tls;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_set(tsd_t *val) {\n\tassert(tsd_booted);\n\tif (likely(&tsd_tls != val)) {\n\t\ttsd_tls = (*val);\n\t}\n\tif (pthread_setspecific(tsd_tsd, (void *)(&tsd_tls)) != 0) {\n\t\tmalloc_write(\": Error setting tsd.\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n}\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd_types.h", "content": "#ifndef JEMALLOC_INTERNAL_TSD_TYPES_H\n#define JEMALLOC_INTERNAL_TSD_TYPES_H\n\n#define MALLOC_TSD_CLEANUPS_MAX\t4\n\ntypedef struct tsd_s tsd_t;\ntypedef struct tsdn_s tsdn_t;\ntypedef bool (*malloc_tsd_cleanup_t)(void);\n\n#endif /* JEMALLOC_INTERNAL_TSD_TYPES_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/tsd_win.h", "content": "#ifdef JEMALLOC_INTERNAL_TSD_WIN_H\n#error This file should be included only once, by tsd.h.\n#endif\n#define JEMALLOC_INTERNAL_TSD_WIN_H\n\ntypedef struct {\n\tbool initialized;\n\ttsd_t val;\n} tsd_wrapper_t;\n\nextern DWORD tsd_tsd;\nextern tsd_wrapper_t tsd_boot_wrapper;\nextern bool tsd_booted;\n\n/* Initialization/cleanup. */\nJEMALLOC_ALWAYS_INLINE bool\ntsd_cleanup_wrapper(void) {\n\tDWORD error = GetLastError();\n\ttsd_wrapper_t *wrapper = (tsd_wrapper_t *)TlsGetValue(tsd_tsd);\n\tSetLastError(error);\n\n\tif (wrapper == NULL) {\n\t\treturn false;\n\t}\n\n\tif (wrapper->initialized) {\n\t\twrapper->initialized = false;\n\t\ttsd_cleanup(&wrapper->val);\n\t\tif (wrapper->initialized) {\n\t\t\t/* Trigger another cleanup round. */\n\t\t\treturn true;\n\t\t}\n\t}\n\tmalloc_tsd_dalloc(wrapper);\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_wrapper_set(tsd_wrapper_t *wrapper) {\n\tif (!TlsSetValue(tsd_tsd, (void *)wrapper)) {\n\t\tmalloc_write(\": Error setting TSD\\n\");\n\t\tabort();\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE tsd_wrapper_t *\ntsd_wrapper_get(bool init) {\n\tDWORD error = GetLastError();\n\ttsd_wrapper_t *wrapper = (tsd_wrapper_t *) TlsGetValue(tsd_tsd);\n\tSetLastError(error);\n\n\tif (init && unlikely(wrapper == NULL)) {\n\t\twrapper = (tsd_wrapper_t *)\n\t\t malloc_tsd_malloc(sizeof(tsd_wrapper_t));\n\t\tif (wrapper == NULL) {\n\t\t\tmalloc_write(\": Error allocating TSD\\n\");\n\t\t\tabort();\n\t\t} else {\n\t\t\twrapper->initialized = false;\n\t\t\t/* MSVC is finicky about aggregate initialization. */\n\t\t\ttsd_t tsd_initializer = TSD_INITIALIZER;\n\t\t\twrapper->val = tsd_initializer;\n\t\t}\n\t\ttsd_wrapper_set(wrapper);\n\t}\n\treturn wrapper;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot0(void) {\n\ttsd_tsd = TlsAlloc();\n\tif (tsd_tsd == TLS_OUT_OF_INDEXES) {\n\t\treturn true;\n\t}\n\t_malloc_tsd_cleanup_register(&tsd_cleanup_wrapper);\n\ttsd_wrapper_set(&tsd_boot_wrapper);\n\ttsd_booted = true;\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_boot1(void) {\n\ttsd_wrapper_t *wrapper;\n\twrapper = (tsd_wrapper_t *)\n\t malloc_tsd_malloc(sizeof(tsd_wrapper_t));\n\tif (wrapper == NULL) {\n\t\tmalloc_write(\": Error allocating TSD\\n\");\n\t\tabort();\n\t}\n\ttsd_boot_wrapper.initialized = false;\n\ttsd_cleanup(&tsd_boot_wrapper.val);\n\twrapper->initialized = false;\n\ttsd_t initializer = TSD_INITIALIZER;\n\twrapper->val = initializer;\n\ttsd_wrapper_set(wrapper);\n}\nJEMALLOC_ALWAYS_INLINE bool\ntsd_boot(void) {\n\tif (tsd_boot0()) {\n\t\treturn true;\n\t}\n\ttsd_boot1();\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_booted_get(void) {\n\treturn tsd_booted;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntsd_get_allocates(void) {\n\treturn true;\n}\n\n/* Get/set. */\nJEMALLOC_ALWAYS_INLINE tsd_t *\ntsd_get(bool init) {\n\ttsd_wrapper_t *wrapper;\n\n\tassert(tsd_booted);\n\twrapper = tsd_wrapper_get(init);\n\tif (tsd_get_allocates() && !init && wrapper == NULL) {\n\t\treturn NULL;\n\t}\n\treturn &wrapper->val;\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntsd_set(tsd_t *val) {\n\ttsd_wrapper_t *wrapper;\n\n\tassert(tsd_booted);\n\twrapper = tsd_wrapper_get(true);\n\tif (likely(&wrapper->val != val)) {\n\t\twrapper->val = *(val);\n\t}\n\twrapper->initialized = true;\n}\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/typed_list.h", "content": "#ifndef JEMALLOC_INTERNAL_TYPED_LIST_H\n#define JEMALLOC_INTERNAL_TYPED_LIST_H\n\n/*\n * This wraps the ql module to implement a list class in a way that's a little\n * bit easier to use; it handles ql_elm_new calls and provides type safety.\n */\n\n#define TYPED_LIST(list_type, el_type, linkage)\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tql_head(el_type) head;\t\t\t\t\t\t\\\n} list_type##_t;\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_init(list_type##_t *list) {\t\t\t\t\t\\\n\tql_new(&list->head);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline el_type *\t\t\t\t\t\t\t\\\nlist_type##_first(const list_type##_t *list) {\t\t\t\t\\\n\treturn ql_first(&list->head);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline el_type *\t\t\t\t\t\t\t\\\nlist_type##_last(const list_type##_t *list) {\t\t\t\t\\\n\treturn ql_last(&list->head, linkage);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_append(list_type##_t *list, el_type *item) {\t\t\\\n\tql_elm_new(item, linkage);\t\t\t\t\t\\\n\tql_tail_insert(&list->head, item, linkage);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_prepend(list_type##_t *list, el_type *item) {\t\t\\\n\tql_elm_new(item, linkage);\t\t\t\t\t\\\n\tql_head_insert(&list->head, item, linkage);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_replace(list_type##_t *list, el_type *to_remove,\t\t\\\n el_type *to_insert) {\t\t\t\t\t\t\\\n\tql_elm_new(to_insert, linkage);\t\t\t\t\t\\\n\tql_after_insert(to_remove, to_insert, linkage);\t\t\t\\\n\tql_remove(&list->head, to_remove, linkage);\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_remove(list_type##_t *list, el_type *item) {\t\t\\\n\tql_remove(&list->head, item, linkage);\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline bool\t\t\t\t\t\t\t\\\nlist_type##_empty(list_type##_t *list) {\t\t\t\t\\\n\treturn ql_empty(&list->head);\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\nstatic inline void\t\t\t\t\t\t\t\\\nlist_type##_concat(list_type##_t *list_a, list_type##_t *list_b) {\t\\\n\tql_concat(&list_a->head, &list_b->head, linkage);\t\t\\\n}\n\n#endif /* JEMALLOC_INTERNAL_TYPED_LIST_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/util.h", "content": "#ifndef JEMALLOC_INTERNAL_UTIL_H\n#define JEMALLOC_INTERNAL_UTIL_H\n\n#define UTIL_INLINE static inline\n\n/* Junk fill patterns. */\n#ifndef JEMALLOC_ALLOC_JUNK\n# define JEMALLOC_ALLOC_JUNK\t((uint8_t)0xa5)\n#endif\n#ifndef JEMALLOC_FREE_JUNK\n# define JEMALLOC_FREE_JUNK\t((uint8_t)0x5a)\n#endif\n\n/*\n * Wrap a cpp argument that contains commas such that it isn't broken up into\n * multiple arguments.\n */\n#define JEMALLOC_ARG_CONCAT(...) __VA_ARGS__\n\n/* cpp macro definition stringification. */\n#define STRINGIFY_HELPER(x) #x\n#define STRINGIFY(x) STRINGIFY_HELPER(x)\n\n/*\n * Silence compiler warnings due to uninitialized values. This is used\n * wherever the compiler fails to recognize that the variable is never used\n * uninitialized.\n */\n#define JEMALLOC_CC_SILENCE_INIT(v) = v\n\n#ifdef __GNUC__\n# define likely(x) __builtin_expect(!!(x), 1)\n# define unlikely(x) __builtin_expect(!!(x), 0)\n#else\n# define likely(x) !!(x)\n# define unlikely(x) !!(x)\n#endif\n\n#if !defined(JEMALLOC_INTERNAL_UNREACHABLE)\n# error JEMALLOC_INTERNAL_UNREACHABLE should have been defined by configure\n#endif\n\n#define unreachable() JEMALLOC_INTERNAL_UNREACHABLE()\n\n/* Set error code. */\nUTIL_INLINE void\nset_errno(int errnum) {\n#ifdef _WIN32\n\tSetLastError(errnum);\n#else\n\terrno = errnum;\n#endif\n}\n\n/* Get last error code. */\nUTIL_INLINE int\nget_errno(void) {\n#ifdef _WIN32\n\treturn GetLastError();\n#else\n\treturn errno;\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nutil_assume(bool b) {\n\tif (!b) {\n\t\tunreachable();\n\t}\n}\n\n/* ptr should be valid. */\nJEMALLOC_ALWAYS_INLINE void\nutil_prefetch_read(void *ptr) {\n\t/*\n\t * This should arguably be a config check; but any version of GCC so old\n\t * that it doesn't support __builtin_prefetch is also too old to build\n\t * jemalloc.\n\t */\n#ifdef __GNUC__\n\tif (config_debug) {\n\t\t/* Enforce the \"valid ptr\" requirement. */\n\t\t*(volatile char *)ptr;\n\t}\n\t__builtin_prefetch(ptr, /* read or write */ 0, /* locality hint */ 3);\n#else\n\t*(volatile char *)ptr;\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nutil_prefetch_write(void *ptr) {\n#ifdef __GNUC__\n\tif (config_debug) {\n\t\t*(volatile char *)ptr;\n\t}\n\t/*\n\t * The only difference from the read variant is that this has a 1 as the\n\t * second argument (the write hint).\n\t */\n\t__builtin_prefetch(ptr, 1, 3);\n#else\n\t*(volatile char *)ptr;\n#endif\n}\n\nJEMALLOC_ALWAYS_INLINE void\nutil_prefetch_read_range(void *ptr, size_t sz) {\n\tfor (size_t i = 0; i < sz; i += CACHELINE) {\n\t\tutil_prefetch_read((void *)((uintptr_t)ptr + i));\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\nutil_prefetch_write_range(void *ptr, size_t sz) {\n\tfor (size_t i = 0; i < sz; i += CACHELINE) {\n\t\tutil_prefetch_write((void *)((uintptr_t)ptr + i));\n\t}\n}\n\n#undef UTIL_INLINE\n\n#endif /* JEMALLOC_INTERNAL_UTIL_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/internal/witness.h", "content": "#ifndef JEMALLOC_INTERNAL_WITNESS_H\n#define JEMALLOC_INTERNAL_WITNESS_H\n\n#include \"jemalloc/internal/ql.h\"\n\n/******************************************************************************/\n/* LOCK RANKS */\n/******************************************************************************/\n\nenum witness_rank_e {\n\t/*\n\t * Order matters within this enum listing -- higher valued locks can\n\t * only be acquired after lower-valued ones. We use the\n\t * auto-incrementing-ness of enum values to enforce this.\n\t */\n\n\t/*\n\t * Witnesses with rank WITNESS_RANK_OMIT are completely ignored by the\n\t * witness machinery.\n\t */\n\tWITNESS_RANK_OMIT,\n\tWITNESS_RANK_MIN,\n\tWITNESS_RANK_INIT = WITNESS_RANK_MIN,\n\tWITNESS_RANK_CTL,\n\tWITNESS_RANK_TCACHES,\n\tWITNESS_RANK_ARENAS,\n\tWITNESS_RANK_BACKGROUND_THREAD_GLOBAL,\n\tWITNESS_RANK_PROF_DUMP,\n\tWITNESS_RANK_PROF_BT2GCTX,\n\tWITNESS_RANK_PROF_TDATAS,\n\tWITNESS_RANK_PROF_TDATA,\n\tWITNESS_RANK_PROF_LOG,\n\tWITNESS_RANK_PROF_GCTX,\n\tWITNESS_RANK_PROF_RECENT_DUMP,\n\tWITNESS_RANK_BACKGROUND_THREAD,\n\t/*\n\t * Used as an argument to witness_assert_depth_to_rank() in order to\n\t * validate depth excluding non-core locks with lower ranks. Since the\n\t * rank argument to witness_assert_depth_to_rank() is inclusive rather\n\t * than exclusive, this definition can have the same value as the\n\t * minimally ranked core lock.\n\t */\n\tWITNESS_RANK_CORE,\n\tWITNESS_RANK_DECAY = WITNESS_RANK_CORE,\n\tWITNESS_RANK_TCACHE_QL,\n\n\tWITNESS_RANK_SEC_SHARD,\n\n\tWITNESS_RANK_EXTENT_GROW,\n\tWITNESS_RANK_HPA_SHARD_GROW = WITNESS_RANK_EXTENT_GROW,\n\tWITNESS_RANK_SAN_BUMP_ALLOC = WITNESS_RANK_EXTENT_GROW,\n\n\tWITNESS_RANK_EXTENTS,\n\tWITNESS_RANK_HPA_SHARD = WITNESS_RANK_EXTENTS,\n\n\tWITNESS_RANK_HPA_CENTRAL_GROW,\n\tWITNESS_RANK_HPA_CENTRAL,\n\n\tWITNESS_RANK_EDATA_CACHE,\n\n\tWITNESS_RANK_RTREE,\n\tWITNESS_RANK_BASE,\n\tWITNESS_RANK_ARENA_LARGE,\n\tWITNESS_RANK_HOOK,\n\n\tWITNESS_RANK_LEAF=0x1000,\n\tWITNESS_RANK_BIN = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_ARENA_STATS = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_COUNTER_ACCUM = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_DSS = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_ACTIVE = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_DUMP_FILENAME = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_GDUMP = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_NEXT_THR_UID = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_RECENT_ALLOC = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_STATS = WITNESS_RANK_LEAF,\n\tWITNESS_RANK_PROF_THREAD_ACTIVE_INIT = WITNESS_RANK_LEAF,\n};\ntypedef enum witness_rank_e witness_rank_t;\n\n/******************************************************************************/\n/* PER-WITNESS DATA */\n/******************************************************************************/\n#if defined(JEMALLOC_DEBUG)\n# define WITNESS_INITIALIZER(name, rank) {name, rank, NULL, NULL, {NULL, NULL}}\n#else\n# define WITNESS_INITIALIZER(name, rank)\n#endif\n\ntypedef struct witness_s witness_t;\ntypedef ql_head(witness_t) witness_list_t;\ntypedef int witness_comp_t (const witness_t *, void *, const witness_t *,\n void *);\n\nstruct witness_s {\n\t/* Name, used for printing lock order reversal messages. */\n\tconst char\t\t*name;\n\n\t/*\n\t * Witness rank, where 0 is lowest and WITNESS_RANK_LEAF is highest.\n\t * Witnesses must be acquired in order of increasing rank.\n\t */\n\twitness_rank_t\t\trank;\n\n\t/*\n\t * If two witnesses are of equal rank and they have the samp comp\n\t * function pointer, it is called as a last attempt to differentiate\n\t * between witnesses of equal rank.\n\t */\n\twitness_comp_t\t\t*comp;\n\n\t/* Opaque data, passed to comp(). */\n\tvoid\t\t\t*opaque;\n\n\t/* Linkage for thread's currently owned locks. */\n\tql_elm(witness_t)\tlink;\n};\n\n/******************************************************************************/\n/* PER-THREAD DATA */\n/******************************************************************************/\ntypedef struct witness_tsd_s witness_tsd_t;\nstruct witness_tsd_s {\n\twitness_list_t witnesses;\n\tbool forking;\n};\n\n#define WITNESS_TSD_INITIALIZER { ql_head_initializer(witnesses), false }\n#define WITNESS_TSDN_NULL ((witness_tsdn_t *)0)\n\n/******************************************************************************/\n/* (PER-THREAD) NULLABILITY HELPERS */\n/******************************************************************************/\ntypedef struct witness_tsdn_s witness_tsdn_t;\nstruct witness_tsdn_s {\n\twitness_tsd_t witness_tsd;\n};\n\nJEMALLOC_ALWAYS_INLINE witness_tsdn_t *\nwitness_tsd_tsdn(witness_tsd_t *witness_tsd) {\n\treturn (witness_tsdn_t *)witness_tsd;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nwitness_tsdn_null(witness_tsdn_t *witness_tsdn) {\n\treturn witness_tsdn == NULL;\n}\n\nJEMALLOC_ALWAYS_INLINE witness_tsd_t *\nwitness_tsdn_tsd(witness_tsdn_t *witness_tsdn) {\n\tassert(!witness_tsdn_null(witness_tsdn));\n\treturn &witness_tsdn->witness_tsd;\n}\n\n/******************************************************************************/\n/* API */\n/******************************************************************************/\nvoid witness_init(witness_t *witness, const char *name, witness_rank_t rank,\n witness_comp_t *comp, void *opaque);\n\ntypedef void (witness_lock_error_t)(const witness_list_t *, const witness_t *);\nextern witness_lock_error_t *JET_MUTABLE witness_lock_error;\n\ntypedef void (witness_owner_error_t)(const witness_t *);\nextern witness_owner_error_t *JET_MUTABLE witness_owner_error;\n\ntypedef void (witness_not_owner_error_t)(const witness_t *);\nextern witness_not_owner_error_t *JET_MUTABLE witness_not_owner_error;\n\ntypedef void (witness_depth_error_t)(const witness_list_t *,\n witness_rank_t rank_inclusive, unsigned depth);\nextern witness_depth_error_t *JET_MUTABLE witness_depth_error;\n\nvoid witnesses_cleanup(witness_tsd_t *witness_tsd);\nvoid witness_prefork(witness_tsd_t *witness_tsd);\nvoid witness_postfork_parent(witness_tsd_t *witness_tsd);\nvoid witness_postfork_child(witness_tsd_t *witness_tsd);\n\n/* Helper, not intended for direct use. */\nstatic inline bool\nwitness_owner(witness_tsd_t *witness_tsd, const witness_t *witness) {\n\twitness_list_t *witnesses;\n\twitness_t *w;\n\n\tcassert(config_debug);\n\n\twitnesses = &witness_tsd->witnesses;\n\tql_foreach(w, witnesses, link) {\n\t\tif (w == witness) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n\nstatic inline void\nwitness_assert_owner(witness_tsdn_t *witness_tsdn, const witness_t *witness) {\n\twitness_tsd_t *witness_tsd;\n\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\n\tif (witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\twitness_tsd = witness_tsdn_tsd(witness_tsdn);\n\tif (witness->rank == WITNESS_RANK_OMIT) {\n\t\treturn;\n\t}\n\n\tif (witness_owner(witness_tsd, witness)) {\n\t\treturn;\n\t}\n\twitness_owner_error(witness);\n}\n\nstatic inline void\nwitness_assert_not_owner(witness_tsdn_t *witness_tsdn,\n const witness_t *witness) {\n\twitness_tsd_t *witness_tsd;\n\twitness_list_t *witnesses;\n\twitness_t *w;\n\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\n\tif (witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\twitness_tsd = witness_tsdn_tsd(witness_tsdn);\n\tif (witness->rank == WITNESS_RANK_OMIT) {\n\t\treturn;\n\t}\n\n\twitnesses = &witness_tsd->witnesses;\n\tql_foreach(w, witnesses, link) {\n\t\tif (w == witness) {\n\t\t\twitness_not_owner_error(witness);\n\t\t}\n\t}\n}\n\n/* Returns depth. Not intended for direct use. */\nstatic inline unsigned\nwitness_depth_to_rank(witness_list_t *witnesses, witness_rank_t rank_inclusive)\n{\n\tunsigned d = 0;\n\twitness_t *w = ql_last(witnesses, link);\n\n\tif (w != NULL) {\n\t\tql_reverse_foreach(w, witnesses, link) {\n\t\t\tif (w->rank < rank_inclusive) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\td++;\n\t\t}\n\t}\n\n\treturn d;\n}\n\nstatic inline void\nwitness_assert_depth_to_rank(witness_tsdn_t *witness_tsdn,\n witness_rank_t rank_inclusive, unsigned depth) {\n\tif (!config_debug || witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\n\twitness_list_t *witnesses = &witness_tsdn_tsd(witness_tsdn)->witnesses;\n\tunsigned d = witness_depth_to_rank(witnesses, rank_inclusive);\n\n\tif (d != depth) {\n\t\twitness_depth_error(witnesses, rank_inclusive, depth);\n\t}\n}\n\nstatic inline void\nwitness_assert_depth(witness_tsdn_t *witness_tsdn, unsigned depth) {\n\twitness_assert_depth_to_rank(witness_tsdn, WITNESS_RANK_MIN, depth);\n}\n\nstatic inline void\nwitness_assert_lockless(witness_tsdn_t *witness_tsdn) {\n\twitness_assert_depth(witness_tsdn, 0);\n}\n\nstatic inline void\nwitness_assert_positive_depth_to_rank(witness_tsdn_t *witness_tsdn,\n witness_rank_t rank_inclusive) {\n\tif (!config_debug || witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\n\twitness_list_t *witnesses = &witness_tsdn_tsd(witness_tsdn)->witnesses;\n\tunsigned d = witness_depth_to_rank(witnesses, rank_inclusive);\n\n\tif (d == 0) {\n\t\twitness_depth_error(witnesses, rank_inclusive, 1);\n\t}\n}\n\nstatic inline void\nwitness_lock(witness_tsdn_t *witness_tsdn, witness_t *witness) {\n\twitness_tsd_t *witness_tsd;\n\twitness_list_t *witnesses;\n\twitness_t *w;\n\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\n\tif (witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\twitness_tsd = witness_tsdn_tsd(witness_tsdn);\n\tif (witness->rank == WITNESS_RANK_OMIT) {\n\t\treturn;\n\t}\n\n\twitness_assert_not_owner(witness_tsdn, witness);\n\n\twitnesses = &witness_tsd->witnesses;\n\tw = ql_last(witnesses, link);\n\tif (w == NULL) {\n\t\t/* No other locks; do nothing. */\n\t} else if (witness_tsd->forking && w->rank <= witness->rank) {\n\t\t/* Forking, and relaxed ranking satisfied. */\n\t} else if (w->rank > witness->rank) {\n\t\t/* Not forking, rank order reversal. */\n\t\twitness_lock_error(witnesses, witness);\n\t} else if (w->rank == witness->rank && (w->comp == NULL || w->comp !=\n\t witness->comp || w->comp(w, w->opaque, witness, witness->opaque) >\n\t 0)) {\n\t\t/*\n\t\t * Missing/incompatible comparison function, or comparison\n\t\t * function indicates rank order reversal.\n\t\t */\n\t\twitness_lock_error(witnesses, witness);\n\t}\n\n\tql_elm_new(witness, link);\n\tql_tail_insert(witnesses, witness, link);\n}\n\nstatic inline void\nwitness_unlock(witness_tsdn_t *witness_tsdn, witness_t *witness) {\n\twitness_tsd_t *witness_tsd;\n\twitness_list_t *witnesses;\n\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\n\tif (witness_tsdn_null(witness_tsdn)) {\n\t\treturn;\n\t}\n\twitness_tsd = witness_tsdn_tsd(witness_tsdn);\n\tif (witness->rank == WITNESS_RANK_OMIT) {\n\t\treturn;\n\t}\n\n\t/*\n\t * Check whether owner before removal, rather than relying on\n\t * witness_assert_owner() to abort, so that unit tests can test this\n\t * function's failure mode without causing undefined behavior.\n\t */\n\tif (witness_owner(witness_tsd, witness)) {\n\t\twitnesses = &witness_tsd->witnesses;\n\t\tql_remove(witnesses, witness, link);\n\t} else {\n\t\twitness_assert_owner(witness_tsdn, witness);\n\t}\n}\n\n#endif /* JEMALLOC_INTERNAL_WITNESS_H */\n" }, { "path": "deps/jemalloc/include/jemalloc/jemalloc.sh", "content": "#!/bin/sh\n\nobjroot=$1\n\ncat <\n#include \n#include \n#include \n#include \n\n#define JEMALLOC_VERSION \"@jemalloc_version@\"\n#define JEMALLOC_VERSION_MAJOR @jemalloc_version_major@\n#define JEMALLOC_VERSION_MINOR @jemalloc_version_minor@\n#define JEMALLOC_VERSION_BUGFIX @jemalloc_version_bugfix@\n#define JEMALLOC_VERSION_NREV @jemalloc_version_nrev@\n#define JEMALLOC_VERSION_GID \"@jemalloc_version_gid@\"\n#define JEMALLOC_VERSION_GID_IDENT @jemalloc_version_gid@\n\n#define MALLOCX_LG_ALIGN(la)\t((int)(la))\n#if LG_SIZEOF_PTR == 2\n# define MALLOCX_ALIGN(a)\t((int)(ffs((int)(a))-1))\n#else\n# define MALLOCX_ALIGN(a)\t\t\t\t\t\t\\\n ((int)(((size_t)(a) < (size_t)INT_MAX) ? ffs((int)(a))-1 :\t\\\n ffs((int)(((size_t)(a))>>32))+31))\n#endif\n#define MALLOCX_ZERO\t((int)0x40)\n/*\n * Bias tcache index bits so that 0 encodes \"automatic tcache management\", and 1\n * encodes MALLOCX_TCACHE_NONE.\n */\n#define MALLOCX_TCACHE(tc)\t((int)(((tc)+2) << 8))\n#define MALLOCX_TCACHE_NONE\tMALLOCX_TCACHE(-1)\n/*\n * Bias arena index bits so that 0 encodes \"use an automatically chosen arena\".\n */\n#define MALLOCX_ARENA(a)\t((((int)(a))+1) << 20)\n\n/*\n * Use as arena index in \"arena..{purge,decay,dss}\" and\n * \"stats.arenas..*\" mallctl interfaces to select all arenas. This\n * definition is intentionally specified in raw decimal format to support\n * cpp-based string concatenation, e.g.\n *\n * #define STRINGIFY_HELPER(x) #x\n * #define STRINGIFY(x) STRINGIFY_HELPER(x)\n *\n * mallctl(\"arena.\" STRINGIFY(MALLCTL_ARENAS_ALL) \".purge\", NULL, NULL, NULL,\n * 0);\n */\n#define MALLCTL_ARENAS_ALL\t4096\n/*\n * Use as arena index in \"stats.arenas..*\" mallctl interfaces to select\n * destroyed arenas.\n */\n#define MALLCTL_ARENAS_DESTROYED\t4097\n\n#if defined(__cplusplus) && defined(JEMALLOC_USE_CXX_THROW)\n# define JEMALLOC_CXX_THROW throw()\n#else\n# define JEMALLOC_CXX_THROW\n#endif\n\n#if defined(_MSC_VER)\n# define JEMALLOC_ATTR(s)\n# define JEMALLOC_ALIGNED(s) __declspec(align(s))\n# define JEMALLOC_ALLOC_SIZE(s)\n# define JEMALLOC_ALLOC_SIZE2(s1, s2)\n# ifndef JEMALLOC_EXPORT\n# ifdef DLLEXPORT\n# define JEMALLOC_EXPORT __declspec(dllexport)\n# else\n# define JEMALLOC_EXPORT __declspec(dllimport)\n# endif\n# endif\n# define JEMALLOC_FORMAT_ARG(i)\n# define JEMALLOC_FORMAT_PRINTF(s, i)\n# define JEMALLOC_FALLTHROUGH\n# define JEMALLOC_NOINLINE __declspec(noinline)\n# ifdef __cplusplus\n# define JEMALLOC_NOTHROW __declspec(nothrow)\n# else\n# define JEMALLOC_NOTHROW\n# endif\n# define JEMALLOC_SECTION(s) __declspec(allocate(s))\n# define JEMALLOC_RESTRICT_RETURN __declspec(restrict)\n# if _MSC_VER >= 1900 && !defined(__EDG__)\n# define JEMALLOC_ALLOCATOR __declspec(allocator)\n# else\n# define JEMALLOC_ALLOCATOR\n# endif\n# define JEMALLOC_COLD\n#elif defined(JEMALLOC_HAVE_ATTR)\n# define JEMALLOC_ATTR(s) __attribute__((s))\n# define JEMALLOC_ALIGNED(s) JEMALLOC_ATTR(aligned(s))\n# ifdef JEMALLOC_HAVE_ATTR_ALLOC_SIZE\n# define JEMALLOC_ALLOC_SIZE(s) JEMALLOC_ATTR(alloc_size(s))\n# define JEMALLOC_ALLOC_SIZE2(s1, s2) JEMALLOC_ATTR(alloc_size(s1, s2))\n# else\n# define JEMALLOC_ALLOC_SIZE(s)\n# define JEMALLOC_ALLOC_SIZE2(s1, s2)\n# endif\n# ifndef JEMALLOC_EXPORT\n# define JEMALLOC_EXPORT JEMALLOC_ATTR(visibility(\"default\"))\n# endif\n# ifdef JEMALLOC_HAVE_ATTR_FORMAT_ARG\n# define JEMALLOC_FORMAT_ARG(i) JEMALLOC_ATTR(__format_arg__(3))\n# else\n# define JEMALLOC_FORMAT_ARG(i)\n# endif\n# ifdef JEMALLOC_HAVE_ATTR_FORMAT_GNU_PRINTF\n# define JEMALLOC_FORMAT_PRINTF(s, i) JEMALLOC_ATTR(format(gnu_printf, s, i))\n# elif defined(JEMALLOC_HAVE_ATTR_FORMAT_PRINTF)\n# define JEMALLOC_FORMAT_PRINTF(s, i) JEMALLOC_ATTR(format(printf, s, i))\n# else\n# define JEMALLOC_FORMAT_PRINTF(s, i)\n# endif\n# ifdef JEMALLOC_HAVE_ATTR_FALLTHROUGH\n# define JEMALLOC_FALLTHROUGH JEMALLOC_ATTR(fallthrough)\n# else\n# define JEMALLOC_FALLTHROUGH\n# endif\n# define JEMALLOC_NOINLINE JEMALLOC_ATTR(noinline)\n# define JEMALLOC_NOTHROW JEMALLOC_ATTR(nothrow)\n# define JEMALLOC_SECTION(s) JEMALLOC_ATTR(section(s))\n# define JEMALLOC_RESTRICT_RETURN\n# define JEMALLOC_ALLOCATOR\n# ifdef JEMALLOC_HAVE_ATTR_COLD\n# define JEMALLOC_COLD JEMALLOC_ATTR(__cold__)\n# else\n# define JEMALLOC_COLD\n# endif\n#else\n# define JEMALLOC_ATTR(s)\n# define JEMALLOC_ALIGNED(s)\n# define JEMALLOC_ALLOC_SIZE(s)\n# define JEMALLOC_ALLOC_SIZE2(s1, s2)\n# define JEMALLOC_EXPORT\n# define JEMALLOC_FORMAT_PRINTF(s, i)\n# define JEMALLOC_FALLTHROUGH\n# define JEMALLOC_NOINLINE\n# define JEMALLOC_NOTHROW\n# define JEMALLOC_SECTION(s)\n# define JEMALLOC_RESTRICT_RETURN\n# define JEMALLOC_ALLOCATOR\n# define JEMALLOC_COLD\n#endif\n\n#if (defined(__APPLE__) || defined(__FreeBSD__)) && !defined(JEMALLOC_NO_RENAME)\n# define JEMALLOC_SYS_NOTHROW\n#else\n# define JEMALLOC_SYS_NOTHROW JEMALLOC_NOTHROW\n#endif\n\n/* This version of Jemalloc, modified for Redis, has the je_get_defrag_hint()\n * function. */\n#define JEMALLOC_FRAG_HINT\n\n/* This version of Jemalloc, modified for Redis, has the je_*_usable() family functions. */\n#define JEMALLOC_ALLOC_WITH_USIZE\n" }, { "path": "deps/jemalloc/include/jemalloc/jemalloc_mangle.sh", "content": "#!/bin/sh -eu\n\npublic_symbols_txt=$1\nsymbol_prefix=$2\n\ncat <\n\n/* MSVC doesn't define _Bool or bool in C, but does have BOOL */\n/* Note this doesn't pass autoconf's test because (bool) 0.5 != true */\n/* Clang-cl uses MSVC headers, so needs msvc_compat, but has _Bool as\n * a built-in type. */\n#ifndef __clang__\ntypedef BOOL _Bool;\n#endif\n\n#define bool _Bool\n#define true 1\n#define false 0\n\n#define __bool_true_false_are_defined 1\n\n#endif /* stdbool_h */\n" }, { "path": "deps/jemalloc/include/msvc_compat/C99/stdint.h", "content": "// ISO C9x compliant stdint.h for Microsoft Visual Studio\n// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 \n// \n// Copyright (c) 2006-2008 Alexander Chemeris\n// \n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are met:\n// \n// 1. Redistributions of source code must retain the above copyright notice,\n// this list of conditions and the following disclaimer.\n// \n// 2. Redistributions in binary form must reproduce the above copyright\n// notice, this list of conditions and the following disclaimer in the\n// documentation and/or other materials provided with the distribution.\n// \n// 3. The name of the author may be used to endorse or promote products\n// derived from this software without specific prior written permission.\n// \n// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED\n// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO\n// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\n// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \n// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\n// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n// \n///////////////////////////////////////////////////////////////////////////////\n\n#ifndef _MSC_VER // [\n#error \"Use this header only with Microsoft Visual C++ compilers!\"\n#endif // _MSC_VER ]\n\n#ifndef _MSC_STDINT_H_ // [\n#define _MSC_STDINT_H_\n\n#if _MSC_VER > 1000\n#pragma once\n#endif\n\n#include \n\n// For Visual Studio 6 in C++ mode and for many Visual Studio versions when\n// compiling for ARM we should wrap include with 'extern \"C++\" {}'\n// or compiler give many errors like this:\n// error C2733: second C linkage of overloaded function 'wmemchr' not allowed\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n# include \n#ifdef __cplusplus\n}\n#endif\n\n// Define _W64 macros to mark types changing their size, like intptr_t.\n#ifndef _W64\n# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300\n# define _W64 __w64\n# else\n# define _W64\n# endif\n#endif\n\n\n// 7.18.1 Integer types\n\n// 7.18.1.1 Exact-width integer types\n\n// Visual Studio 6 and Embedded Visual C++ 4 doesn't\n// realize that, e.g. char has the same size as __int8\n// so we give up on __intX for them.\n#if (_MSC_VER < 1300)\n typedef signed char int8_t;\n typedef signed short int16_t;\n typedef signed int int32_t;\n typedef unsigned char uint8_t;\n typedef unsigned short uint16_t;\n typedef unsigned int uint32_t;\n#else\n typedef signed __int8 int8_t;\n typedef signed __int16 int16_t;\n typedef signed __int32 int32_t;\n typedef unsigned __int8 uint8_t;\n typedef unsigned __int16 uint16_t;\n typedef unsigned __int32 uint32_t;\n#endif\ntypedef signed __int64 int64_t;\ntypedef unsigned __int64 uint64_t;\n\n\n// 7.18.1.2 Minimum-width integer types\ntypedef int8_t int_least8_t;\ntypedef int16_t int_least16_t;\ntypedef int32_t int_least32_t;\ntypedef int64_t int_least64_t;\ntypedef uint8_t uint_least8_t;\ntypedef uint16_t uint_least16_t;\ntypedef uint32_t uint_least32_t;\ntypedef uint64_t uint_least64_t;\n\n// 7.18.1.3 Fastest minimum-width integer types\ntypedef int8_t int_fast8_t;\ntypedef int16_t int_fast16_t;\ntypedef int32_t int_fast32_t;\ntypedef int64_t int_fast64_t;\ntypedef uint8_t uint_fast8_t;\ntypedef uint16_t uint_fast16_t;\ntypedef uint32_t uint_fast32_t;\ntypedef uint64_t uint_fast64_t;\n\n// 7.18.1.4 Integer types capable of holding object pointers\n#ifdef _WIN64 // [\n typedef signed __int64 intptr_t;\n typedef unsigned __int64 uintptr_t;\n#else // _WIN64 ][\n typedef _W64 signed int intptr_t;\n typedef _W64 unsigned int uintptr_t;\n#endif // _WIN64 ]\n\n// 7.18.1.5 Greatest-width integer types\ntypedef int64_t intmax_t;\ntypedef uint64_t uintmax_t;\n\n\n// 7.18.2 Limits of specified-width integer types\n\n#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259\n\n// 7.18.2.1 Limits of exact-width integer types\n#define INT8_MIN ((int8_t)_I8_MIN)\n#define INT8_MAX _I8_MAX\n#define INT16_MIN ((int16_t)_I16_MIN)\n#define INT16_MAX _I16_MAX\n#define INT32_MIN ((int32_t)_I32_MIN)\n#define INT32_MAX _I32_MAX\n#define INT64_MIN ((int64_t)_I64_MIN)\n#define INT64_MAX _I64_MAX\n#define UINT8_MAX _UI8_MAX\n#define UINT16_MAX _UI16_MAX\n#define UINT32_MAX _UI32_MAX\n#define UINT64_MAX _UI64_MAX\n\n// 7.18.2.2 Limits of minimum-width integer types\n#define INT_LEAST8_MIN INT8_MIN\n#define INT_LEAST8_MAX INT8_MAX\n#define INT_LEAST16_MIN INT16_MIN\n#define INT_LEAST16_MAX INT16_MAX\n#define INT_LEAST32_MIN INT32_MIN\n#define INT_LEAST32_MAX INT32_MAX\n#define INT_LEAST64_MIN INT64_MIN\n#define INT_LEAST64_MAX INT64_MAX\n#define UINT_LEAST8_MAX UINT8_MAX\n#define UINT_LEAST16_MAX UINT16_MAX\n#define UINT_LEAST32_MAX UINT32_MAX\n#define UINT_LEAST64_MAX UINT64_MAX\n\n// 7.18.2.3 Limits of fastest minimum-width integer types\n#define INT_FAST8_MIN INT8_MIN\n#define INT_FAST8_MAX INT8_MAX\n#define INT_FAST16_MIN INT16_MIN\n#define INT_FAST16_MAX INT16_MAX\n#define INT_FAST32_MIN INT32_MIN\n#define INT_FAST32_MAX INT32_MAX\n#define INT_FAST64_MIN INT64_MIN\n#define INT_FAST64_MAX INT64_MAX\n#define UINT_FAST8_MAX UINT8_MAX\n#define UINT_FAST16_MAX UINT16_MAX\n#define UINT_FAST32_MAX UINT32_MAX\n#define UINT_FAST64_MAX UINT64_MAX\n\n// 7.18.2.4 Limits of integer types capable of holding object pointers\n#ifdef _WIN64 // [\n# define INTPTR_MIN INT64_MIN\n# define INTPTR_MAX INT64_MAX\n# define UINTPTR_MAX UINT64_MAX\n#else // _WIN64 ][\n# define INTPTR_MIN INT32_MIN\n# define INTPTR_MAX INT32_MAX\n# define UINTPTR_MAX UINT32_MAX\n#endif // _WIN64 ]\n\n// 7.18.2.5 Limits of greatest-width integer types\n#define INTMAX_MIN INT64_MIN\n#define INTMAX_MAX INT64_MAX\n#define UINTMAX_MAX UINT64_MAX\n\n// 7.18.3 Limits of other integer types\n\n#ifdef _WIN64 // [\n# define PTRDIFF_MIN _I64_MIN\n# define PTRDIFF_MAX _I64_MAX\n#else // _WIN64 ][\n# define PTRDIFF_MIN _I32_MIN\n# define PTRDIFF_MAX _I32_MAX\n#endif // _WIN64 ]\n\n#define SIG_ATOMIC_MIN INT_MIN\n#define SIG_ATOMIC_MAX INT_MAX\n\n#ifndef SIZE_MAX // [\n# ifdef _WIN64 // [\n# define SIZE_MAX _UI64_MAX\n# else // _WIN64 ][\n# define SIZE_MAX _UI32_MAX\n# endif // _WIN64 ]\n#endif // SIZE_MAX ]\n\n// WCHAR_MIN and WCHAR_MAX are also defined in \n#ifndef WCHAR_MIN // [\n# define WCHAR_MIN 0\n#endif // WCHAR_MIN ]\n#ifndef WCHAR_MAX // [\n# define WCHAR_MAX _UI16_MAX\n#endif // WCHAR_MAX ]\n\n#define WINT_MIN 0\n#define WINT_MAX _UI16_MAX\n\n#endif // __STDC_LIMIT_MACROS ]\n\n\n// 7.18.4 Limits of other integer types\n\n#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260\n\n// 7.18.4.1 Macros for minimum-width integer constants\n\n#define INT8_C(val) val##i8\n#define INT16_C(val) val##i16\n#define INT32_C(val) val##i32\n#define INT64_C(val) val##i64\n\n#define UINT8_C(val) val##ui8\n#define UINT16_C(val) val##ui16\n#define UINT32_C(val) val##ui32\n#define UINT64_C(val) val##ui64\n\n// 7.18.4.2 Macros for greatest-width integer constants\n#define INTMAX_C INT64_C\n#define UINTMAX_C UINT64_C\n\n#endif // __STDC_CONSTANT_MACROS ]\n\n\n#endif // _MSC_STDINT_H_ ]\n" }, { "path": "deps/jemalloc/include/msvc_compat/strings.h", "content": "#ifndef strings_h\n#define strings_h\n\n/* MSVC doesn't define ffs/ffsl. This dummy strings.h header is provided\n * for both */\n#ifdef _MSC_VER\n# include \n# pragma intrinsic(_BitScanForward)\nstatic __forceinline int ffsl(long x) {\n\tunsigned long i;\n\n\tif (_BitScanForward(&i, x)) {\n\t\treturn i + 1;\n\t}\n\treturn 0;\n}\n\nstatic __forceinline int ffs(int x) {\n\treturn ffsl(x);\n}\n\n# ifdef _M_X64\n# pragma intrinsic(_BitScanForward64)\n# endif\n\nstatic __forceinline int ffsll(unsigned __int64 x) {\n\tunsigned long i;\n#ifdef _M_X64\n\tif (_BitScanForward64(&i, x)) {\n\t\treturn i + 1;\n\t}\n\treturn 0;\n#else\n// Fallback for 32-bit build where 64-bit version not available\n// assuming little endian\n\tunion {\n\t\tunsigned __int64 ll;\n\t\tunsigned long l[2];\n\t} s;\n\n\ts.ll = x;\n\n\tif (_BitScanForward(&i, s.l[0])) {\n\t\treturn i + 1;\n\t} else if(_BitScanForward(&i, s.l[1])) {\n\t\treturn i + 33;\n\t}\n\treturn 0;\n#endif\n}\n\n#else\n# define ffsll(x) __builtin_ffsll(x)\n# define ffsl(x) __builtin_ffsl(x)\n# define ffs(x) __builtin_ffs(x)\n#endif\n\n#endif /* strings_h */\n" }, { "path": "deps/jemalloc/include/msvc_compat/windows_extra.h", "content": "#ifndef MSVC_COMPAT_WINDOWS_EXTRA_H\n#define MSVC_COMPAT_WINDOWS_EXTRA_H\n\n#include \n\n#endif /* MSVC_COMPAT_WINDOWS_EXTRA_H */\n" }, { "path": "deps/jemalloc/jemalloc.pc.in", "content": "prefix=@prefix@\nexec_prefix=@exec_prefix@\nlibdir=@libdir@\nincludedir=@includedir@\ninstall_suffix=@install_suffix@\n\nName: jemalloc\nDescription: A general purpose malloc(3) implementation that emphasizes fragmentation avoidance and scalable concurrency support.\nURL: http://jemalloc.net/\nVersion: @jemalloc_version_major@.@jemalloc_version_minor@.@jemalloc_version_bugfix@_@jemalloc_version_nrev@\nCflags: -I${includedir}\nLibs: -L${libdir} -ljemalloc${install_suffix}\n" }, { "path": "deps/jemalloc/m4/ax_cxx_compile_stdcxx.m4", "content": "# ===========================================================================\n# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html\n# ===========================================================================\n#\n# SYNOPSIS\n#\n# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])\n#\n# DESCRIPTION\n#\n# Check for baseline language coverage in the compiler for the specified\n# version of the C++ standard. If necessary, add switches to CXX and\n# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard)\n# or '14' (for the C++14 standard).\n#\n# The second argument, if specified, indicates whether you insist on an\n# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.\n# -std=c++11). If neither is specified, you get whatever works, with\n# preference for an extended mode.\n#\n# The third argument, if specified 'mandatory' or if left unspecified,\n# indicates that baseline support for the specified C++ standard is\n# required and that the macro should error out if no mode with that\n# support is found. If specified 'optional', then configuration proceeds\n# regardless, after defining HAVE_CXX${VERSION} if and only if a\n# supporting mode is found.\n#\n# LICENSE\n#\n# Copyright (c) 2008 Benjamin Kosnik \n# Copyright (c) 2012 Zack Weinberg \n# Copyright (c) 2013 Roy Stogner \n# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov \n# Copyright (c) 2015 Paul Norman \n# Copyright (c) 2015 Moritz Klammler \n# Copyright (c) 2016, 2018 Krzesimir Nowak \n# Copyright (c) 2019 Enji Cooper \n#\n# Copying and distribution of this file, with or without modification, are\n# permitted in any medium without royalty provided the copyright notice\n# and this notice are preserved. This file is offered as-is, without any\n# warranty.\n\n#serial 11\n\ndnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro\ndnl (serial version number 13).\n\nAC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl\n m4_if([$1], [11], [ax_cxx_compile_alternatives=\"11 0x\"],\n [$1], [14], [ax_cxx_compile_alternatives=\"14 1y\"],\n [$1], [17], [ax_cxx_compile_alternatives=\"17 1z\"],\n [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl\n m4_if([$2], [], [],\n [$2], [ext], [],\n [$2], [noext], [],\n [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl\n m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],\n [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],\n [$3], [optional], [ax_cxx_compile_cxx$1_required=false],\n [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])\n AC_LANG_PUSH([C++])dnl\n ac_success=no\n\n m4_if([$2], [noext], [], [dnl\n if test x$ac_success = xno; then\n for alternative in ${ax_cxx_compile_alternatives}; do\n switch=\"-std=gnu++${alternative}\"\n cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])\n AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,\n $cachevar,\n [ac_save_CXX=\"$CXX\"\n CXX=\"$CXX $switch\"\n AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],\n [eval $cachevar=yes],\n [eval $cachevar=no])\n CXX=\"$ac_save_CXX\"])\n if eval test x\\$$cachevar = xyes; then\n CXX=\"$CXX $switch\"\n if test -n \"$CXXCPP\" ; then\n CXXCPP=\"$CXXCPP $switch\"\n fi\n ac_success=yes\n break\n fi\n done\n fi])\n\n m4_if([$2], [ext], [], [dnl\n if test x$ac_success = xno; then\n dnl HP's aCC needs +std=c++11 according to:\n dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf\n dnl Cray's crayCC needs \"-h std=c++11\"\n for alternative in ${ax_cxx_compile_alternatives}; do\n for switch in -std=c++${alternative} +std=c++${alternative} \"-h std=c++${alternative}\"; do\n cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])\n AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,\n $cachevar,\n [ac_save_CXX=\"$CXX\"\n CXX=\"$CXX $switch\"\n AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],\n [eval $cachevar=yes],\n [eval $cachevar=no])\n CXX=\"$ac_save_CXX\"])\n if eval test x\\$$cachevar = xyes; then\n CXX=\"$CXX $switch\"\n if test -n \"$CXXCPP\" ; then\n CXXCPP=\"$CXXCPP $switch\"\n fi\n ac_success=yes\n break\n fi\n done\n if test x$ac_success = xyes; then\n break\n fi\n done\n fi])\n AC_LANG_POP([C++])\n if test x$ax_cxx_compile_cxx$1_required = xtrue; then\n if test x$ac_success = xno; then\n AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])\n fi\n fi\n if test x$ac_success = xno; then\n HAVE_CXX$1=0\n AC_MSG_NOTICE([No compiler with C++$1 support was found])\n else\n HAVE_CXX$1=1\n AC_DEFINE(HAVE_CXX$1,1,\n [define if the compiler supports basic C++$1 syntax])\n fi\n AC_SUBST(HAVE_CXX$1)\n])\n\n\ndnl Test body for checking C++11 support\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_11\n)\n\n\ndnl Test body for checking C++14 support\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_11\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_14\n)\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_11\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_14\n _AX_CXX_COMPILE_STDCXX_testbody_new_in_17\n)\n\ndnl Tests for new features in C++11\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[\n\n// If the compiler admits that it is not ready for C++11, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201103L\n\n#error \"This is not a C++11 compiler\"\n\n#else\n\nnamespace cxx11\n{\n\n namespace test_static_assert\n {\n\n template \n struct check\n {\n static_assert(sizeof(int) <= sizeof(T), \"not big enough\");\n };\n\n }\n\n namespace test_final_override\n {\n\n struct Base\n {\n virtual ~Base() {}\n virtual void f() {}\n };\n\n struct Derived : public Base\n {\n virtual ~Derived() override {}\n virtual void f() override {}\n };\n\n }\n\n namespace test_double_right_angle_brackets\n {\n\n template < typename T >\n struct check {};\n\n typedef check single_type;\n typedef check> double_type;\n typedef check>> triple_type;\n typedef check>>> quadruple_type;\n\n }\n\n namespace test_decltype\n {\n\n int\n f()\n {\n int a = 1;\n decltype(a) b = 2;\n return a + b;\n }\n\n }\n\n namespace test_type_deduction\n {\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static const bool value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static const bool value = true;\n };\n\n template < typename T1, typename T2 >\n auto\n add(T1 a1, T2 a2) -> decltype(a1 + a2)\n {\n return a1 + a2;\n }\n\n int\n test(const int c, volatile int v)\n {\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == false, \"\");\n auto ac = c;\n auto av = v;\n auto sumi = ac + av + 'x';\n auto sumf = ac + av + 1.0;\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == true, \"\");\n static_assert(is_same::value == false, \"\");\n static_assert(is_same::value == true, \"\");\n return (sumf > 0.0) ? sumi : add(c, v);\n }\n\n }\n\n namespace test_noexcept\n {\n\n int f() { return 0; }\n int g() noexcept { return 0; }\n\n static_assert(noexcept(f()) == false, \"\");\n static_assert(noexcept(g()) == true, \"\");\n\n }\n\n namespace test_constexpr\n {\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c_r(const CharT *const s, const unsigned long acc) noexcept\n {\n return *s ? strlen_c_r(s + 1, acc + 1) : acc;\n }\n\n template < typename CharT >\n unsigned long constexpr\n strlen_c(const CharT *const s) noexcept\n {\n return strlen_c_r(s, 0UL);\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"1\") == 1UL, \"\");\n static_assert(strlen_c(\"example\") == 7UL, \"\");\n static_assert(strlen_c(\"another\\0example\") == 7UL, \"\");\n\n }\n\n namespace test_rvalue_references\n {\n\n template < int N >\n struct answer\n {\n static constexpr int value = N;\n };\n\n answer<1> f(int&) { return answer<1>(); }\n answer<2> f(const int&) { return answer<2>(); }\n answer<3> f(int&&) { return answer<3>(); }\n\n void\n test()\n {\n int i = 0;\n const int c = 0;\n static_assert(decltype(f(i))::value == 1, \"\");\n static_assert(decltype(f(c))::value == 2, \"\");\n static_assert(decltype(f(0))::value == 3, \"\");\n }\n\n }\n\n namespace test_uniform_initialization\n {\n\n struct test\n {\n static const int zero {};\n static const int one {1};\n };\n\n static_assert(test::zero == 0, \"\");\n static_assert(test::one == 1, \"\");\n\n }\n\n namespace test_lambdas\n {\n\n void\n test1()\n {\n auto lambda1 = [](){};\n auto lambda2 = lambda1;\n lambda1();\n lambda2();\n }\n\n int\n test2()\n {\n auto a = [](int i, int j){ return i + j; }(1, 2);\n auto b = []() -> int { return '0'; }();\n auto c = [=](){ return a + b; }();\n auto d = [&](){ return c; }();\n auto e = [a, &b](int x) mutable {\n const auto identity = [](int y){ return y; };\n for (auto i = 0; i < a; ++i)\n a += b--;\n return x + identity(a + b);\n }(0);\n return a + b + c + d + e;\n }\n\n int\n test3()\n {\n const auto nullary = [](){ return 0; };\n const auto unary = [](int x){ return x; };\n using nullary_t = decltype(nullary);\n using unary_t = decltype(unary);\n const auto higher1st = [](nullary_t f){ return f(); };\n const auto higher2nd = [unary](nullary_t f1){\n return [unary, f1](unary_t f2){ return f2(unary(f1())); };\n };\n return higher1st(nullary) + higher2nd(nullary)(unary);\n }\n\n }\n\n namespace test_variadic_templates\n {\n\n template \n struct sum;\n\n template \n struct sum\n {\n static constexpr auto value = N0 + sum::value;\n };\n\n template <>\n struct sum<>\n {\n static constexpr auto value = 0;\n };\n\n static_assert(sum<>::value == 0, \"\");\n static_assert(sum<1>::value == 1, \"\");\n static_assert(sum<23>::value == 23, \"\");\n static_assert(sum<1, 2>::value == 3, \"\");\n static_assert(sum<5, 5, 11>::value == 21, \"\");\n static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, \"\");\n\n }\n\n // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae\n // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function\n // because of this.\n namespace test_template_alias_sfinae\n {\n\n struct foo {};\n\n template\n using member = typename T::member_type;\n\n template\n void func(...) {}\n\n template\n void func(member*) {}\n\n void test();\n\n void test() { func(0); }\n\n }\n\n} // namespace cxx11\n\n#endif // __cplusplus >= 201103L\n\n]])\n\n\ndnl Tests for new features in C++14\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[\n\n// If the compiler admits that it is not ready for C++14, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201402L\n\n#error \"This is not a C++14 compiler\"\n\n#else\n\nnamespace cxx14\n{\n\n namespace test_polymorphic_lambdas\n {\n\n int\n test()\n {\n const auto lambda = [](auto&&... args){\n const auto istiny = [](auto x){\n return (sizeof(x) == 1UL) ? 1 : 0;\n };\n const int aretiny[] = { istiny(args)... };\n return aretiny[0];\n };\n return lambda(1, 1L, 1.0f, '1');\n }\n\n }\n\n namespace test_binary_literals\n {\n\n constexpr auto ivii = 0b0000000000101010;\n static_assert(ivii == 42, \"wrong value\");\n\n }\n\n namespace test_generalized_constexpr\n {\n\n template < typename CharT >\n constexpr unsigned long\n strlen_c(const CharT *const s) noexcept\n {\n auto length = 0UL;\n for (auto p = s; *p; ++p)\n ++length;\n return length;\n }\n\n static_assert(strlen_c(\"\") == 0UL, \"\");\n static_assert(strlen_c(\"x\") == 1UL, \"\");\n static_assert(strlen_c(\"test\") == 4UL, \"\");\n static_assert(strlen_c(\"another\\0test\") == 7UL, \"\");\n\n }\n\n namespace test_lambda_init_capture\n {\n\n int\n test()\n {\n auto x = 0;\n const auto lambda1 = [a = x](int b){ return a + b; };\n const auto lambda2 = [a = lambda1(x)](){ return a; };\n return lambda2();\n }\n\n }\n\n namespace test_digit_separators\n {\n\n constexpr auto ten_million = 100'000'000;\n static_assert(ten_million == 100000000, \"\");\n\n }\n\n namespace test_return_type_deduction\n {\n\n auto f(int& x) { return x; }\n decltype(auto) g(int& x) { return x; }\n\n template < typename T1, typename T2 >\n struct is_same\n {\n static constexpr auto value = false;\n };\n\n template < typename T >\n struct is_same\n {\n static constexpr auto value = true;\n };\n\n int\n test()\n {\n auto x = 0;\n static_assert(is_same::value, \"\");\n static_assert(is_same::value, \"\");\n return x;\n }\n\n }\n\n} // namespace cxx14\n\n#endif // __cplusplus >= 201402L\n\n]])\n\n\ndnl Tests for new features in C++17\n\nm4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[\n\n// If the compiler admits that it is not ready for C++17, why torture it?\n// Hopefully, this will speed up the test.\n\n#ifndef __cplusplus\n\n#error \"This is not a C++ compiler\"\n\n#elif __cplusplus < 201703L\n\n#error \"This is not a C++17 compiler\"\n\n#else\n\n#include \n#include \n#include \n\nnamespace cxx17\n{\n\n namespace test_constexpr_lambdas\n {\n\n constexpr int foo = [](){return 42;}();\n\n }\n\n namespace test::nested_namespace::definitions\n {\n\n }\n\n namespace test_fold_expression\n {\n\n template\n int multiply(Args... args)\n {\n return (args * ... * 1);\n }\n\n template\n bool all(Args... args)\n {\n return (args && ...);\n }\n\n }\n\n namespace test_extended_static_assert\n {\n\n static_assert (true);\n\n }\n\n namespace test_auto_brace_init_list\n {\n\n auto foo = {5};\n auto bar {5};\n\n static_assert(std::is_same, decltype(foo)>::value);\n static_assert(std::is_same::value);\n }\n\n namespace test_typename_in_template_template_parameter\n {\n\n template typename X> struct D;\n\n }\n\n namespace test_fallthrough_nodiscard_maybe_unused_attributes\n {\n\n int f1()\n {\n return 42;\n }\n\n [[nodiscard]] int f2()\n {\n [[maybe_unused]] auto unused = f1();\n\n switch (f1())\n {\n case 17:\n f1();\n [[fallthrough]];\n case 42:\n f1();\n }\n return f1();\n }\n\n }\n\n namespace test_extended_aggregate_initialization\n {\n\n struct base1\n {\n int b1, b2 = 42;\n };\n\n struct base2\n {\n base2() {\n b3 = 42;\n }\n int b3;\n };\n\n struct derived : base1, base2\n {\n int d;\n };\n\n derived d1 {{1, 2}, {}, 4}; // full initialization\n derived d2 {{}, {}, 4}; // value-initialized bases\n\n }\n\n namespace test_general_range_based_for_loop\n {\n\n struct iter\n {\n int i;\n\n int& operator* ()\n {\n return i;\n }\n\n const int& operator* () const\n {\n return i;\n }\n\n iter& operator++()\n {\n ++i;\n return *this;\n }\n };\n\n struct sentinel\n {\n int i;\n };\n\n bool operator== (const iter& i, const sentinel& s)\n {\n return i.i == s.i;\n }\n\n bool operator!= (const iter& i, const sentinel& s)\n {\n return !(i == s);\n }\n\n struct range\n {\n iter begin() const\n {\n return {0};\n }\n\n sentinel end() const\n {\n return {5};\n }\n };\n\n void f()\n {\n range r {};\n\n for (auto i : r)\n {\n [[maybe_unused]] auto v = i;\n }\n }\n\n }\n\n namespace test_lambda_capture_asterisk_this_by_value\n {\n\n struct t\n {\n int i;\n int foo()\n {\n return [*this]()\n {\n return i;\n }();\n }\n };\n\n }\n\n namespace test_enum_class_construction\n {\n\n enum class byte : unsigned char\n {};\n\n byte foo {42};\n\n }\n\n namespace test_constexpr_if\n {\n\n template \n int f ()\n {\n if constexpr(cond)\n {\n return 13;\n }\n else\n {\n return 42;\n }\n }\n\n }\n\n namespace test_selection_statement_with_initializer\n {\n\n int f()\n {\n return 13;\n }\n\n int f2()\n {\n if (auto i = f(); i > 0)\n {\n return 3;\n }\n\n switch (auto i = f(); i + 4)\n {\n case 17:\n return 2;\n\n default:\n return 1;\n }\n }\n\n }\n\n namespace test_template_argument_deduction_for_class_templates\n {\n\n template \n struct pair\n {\n pair (T1 p1, T2 p2)\n : m1 {p1},\n m2 {p2}\n {}\n\n T1 m1;\n T2 m2;\n };\n\n void f()\n {\n [[maybe_unused]] auto p = pair{13, 42u};\n }\n\n }\n\n namespace test_non_type_auto_template_parameters\n {\n\n template \n struct B\n {};\n\n B<5> b1;\n B<'a'> b2;\n\n }\n\n namespace test_structured_bindings\n {\n\n int arr[2] = { 1, 2 };\n std::pair pr = { 1, 2 };\n\n auto f1() -> int(&)[2]\n {\n return arr;\n }\n\n auto f2() -> std::pair&\n {\n return pr;\n }\n\n struct S\n {\n int x1 : 2;\n volatile double y1;\n };\n\n S f3()\n {\n return {};\n }\n\n auto [ x1, y1 ] = f1();\n auto& [ xr1, yr1 ] = f1();\n auto [ x2, y2 ] = f2();\n auto& [ xr2, yr2 ] = f2();\n const auto [ x3, y3 ] = f3();\n\n }\n\n namespace test_exception_spec_type_system\n {\n\n struct Good {};\n struct Bad {};\n\n void g1() noexcept;\n void g2();\n\n template\n Bad\n f(T*, T*);\n\n template\n Good\n f(T1*, T2*);\n\n static_assert (std::is_same_v);\n\n }\n\n namespace test_inline_variables\n {\n\n template void f(T)\n {}\n\n template inline T g(T)\n {\n return T{};\n }\n\n template<> inline void f<>(int)\n {}\n\n template<> int g<>(int)\n {\n return 5;\n }\n\n }\n\n} // namespace cxx17\n\n#endif // __cplusplus < 201703L\n\n]])\n" }, { "path": "deps/jemalloc/msvc/ReadMe.txt", "content": "\nHow to build jemalloc for Windows\n=================================\n\n1. Install Cygwin with at least the following packages:\n * autoconf\n * autogen\n * gawk\n * grep\n * sed\n\n2. Install Visual Studio 2015 or 2017 with Visual C++\n\n3. Add Cygwin\\bin to the PATH environment variable\n\n4. Open \"x64 Native Tools Command Prompt for VS 2017\"\n (note: x86/x64 doesn't matter at this point)\n\n5. Generate header files:\n sh -c \"CC=cl ./autogen.sh\"\n\n6. Now the project can be opened and built in Visual Studio:\n msvc\\jemalloc_vc2017.sln\n" }, { "path": "deps/jemalloc/msvc/jemalloc_vc2015.sln", "content": "\nMicrosoft Visual Studio Solution File, Format Version 12.00\n# Visual Studio 14\nVisualStudioVersion = 14.0.24720.0\nMinimumVisualStudioVersion = 10.0.40219.1\nProject(\"{2150E333-8FDC-42A3-9474-1A3956D46DE8}\") = \"Solution Items\", \"Solution Items\", \"{70A99006-6DE9-472B-8F83-4CEE6C616DF3}\"\n\tProjectSection(SolutionItems) = preProject\n\t\tReadMe.txt = ReadMe.txt\n\tEndProjectSection\nEndProject\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"jemalloc\", \"projects\\vc2015\\jemalloc\\jemalloc.vcxproj\", \"{8D6BB292-9E1C-413D-9F98-4864BDC1514A}\"\nEndProject\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"test_threads\", \"projects\\vc2015\\test_threads\\test_threads.vcxproj\", \"{09028CFD-4EB7-491D-869C-0708DB97ED44}\"\nEndProject\nGlobal\n\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n\t\tDebug|x64 = Debug|x64\n\t\tDebug|x86 = Debug|x86\n\t\tDebug-static|x64 = Debug-static|x64\n\t\tDebug-static|x86 = Debug-static|x86\n\t\tRelease|x64 = Release|x64\n\t\tRelease|x86 = Release|x86\n\t\tRelease-static|x64 = Release-static|x64\n\t\tRelease-static|x86 = Release-static|x86\n\tEndGlobalSection\n\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.ActiveCfg = Debug|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.Build.0 = Debug|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.ActiveCfg = Debug|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.Build.0 = Debug|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.ActiveCfg = Debug-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.Build.0 = Debug-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.ActiveCfg = Debug-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.Build.0 = Debug-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.ActiveCfg = Release|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.Build.0 = Release|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.ActiveCfg = Release|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.Build.0 = Release|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.ActiveCfg = Release-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.Build.0 = Release-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.ActiveCfg = Release-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.Build.0 = Release-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.ActiveCfg = Debug|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.Build.0 = Debug|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.ActiveCfg = Debug|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.Build.0 = Debug|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.ActiveCfg = Debug-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.Build.0 = Debug-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.ActiveCfg = Debug-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.Build.0 = Debug-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.ActiveCfg = Release|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.Build.0 = Release|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.ActiveCfg = Release|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.Build.0 = Release|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.ActiveCfg = Release-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.Build.0 = Release-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.ActiveCfg = Release-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.Build.0 = Release-static|Win32\n\tEndGlobalSection\n\tGlobalSection(SolutionProperties) = preSolution\n\t\tHideSolutionNode = FALSE\n\tEndGlobalSection\nEndGlobal\n" }, { "path": "deps/jemalloc/msvc/jemalloc_vc2017.sln", "content": "\nMicrosoft Visual Studio Solution File, Format Version 12.00\n# Visual Studio 14\nVisualStudioVersion = 14.0.24720.0\nMinimumVisualStudioVersion = 10.0.40219.1\nProject(\"{2150E333-8FDC-42A3-9474-1A3956D46DE8}\") = \"Solution Items\", \"Solution Items\", \"{70A99006-6DE9-472B-8F83-4CEE6C616DF3}\"\n\tProjectSection(SolutionItems) = preProject\n\t\tReadMe.txt = ReadMe.txt\n\tEndProjectSection\nEndProject\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"jemalloc\", \"projects\\vc2017\\jemalloc\\jemalloc.vcxproj\", \"{8D6BB292-9E1C-413D-9F98-4864BDC1514A}\"\nEndProject\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"test_threads\", \"projects\\vc2017\\test_threads\\test_threads.vcxproj\", \"{09028CFD-4EB7-491D-869C-0708DB97ED44}\"\nEndProject\nGlobal\n\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n\t\tDebug|x64 = Debug|x64\n\t\tDebug|x86 = Debug|x86\n\t\tDebug-static|x64 = Debug-static|x64\n\t\tDebug-static|x86 = Debug-static|x86\n\t\tRelease|x64 = Release|x64\n\t\tRelease|x86 = Release|x86\n\t\tRelease-static|x64 = Release-static|x64\n\t\tRelease-static|x86 = Release-static|x86\n\tEndGlobalSection\n\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.ActiveCfg = Debug|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x64.Build.0 = Debug|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.ActiveCfg = Debug|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug|x86.Build.0 = Debug|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.ActiveCfg = Debug-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x64.Build.0 = Debug-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.ActiveCfg = Debug-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Debug-static|x86.Build.0 = Debug-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.ActiveCfg = Release|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x64.Build.0 = Release|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.ActiveCfg = Release|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release|x86.Build.0 = Release|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.ActiveCfg = Release-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x64.Build.0 = Release-static|x64\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.ActiveCfg = Release-static|Win32\n\t\t{8D6BB292-9E1C-413D-9F98-4864BDC1514A}.Release-static|x86.Build.0 = Release-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.ActiveCfg = Debug|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x64.Build.0 = Debug|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.ActiveCfg = Debug|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug|x86.Build.0 = Debug|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.ActiveCfg = Debug-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x64.Build.0 = Debug-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.ActiveCfg = Debug-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Debug-static|x86.Build.0 = Debug-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.ActiveCfg = Release|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x64.Build.0 = Release|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.ActiveCfg = Release|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release|x86.Build.0 = Release|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.ActiveCfg = Release-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x64.Build.0 = Release-static|x64\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.ActiveCfg = Release-static|Win32\n\t\t{09028CFD-4EB7-491D-869C-0708DB97ED44}.Release-static|x86.Build.0 = Release-static|Win32\n\tEndGlobalSection\n\tGlobalSection(SolutionProperties) = preSolution\n\t\tHideSolutionNode = FALSE\n\tEndGlobalSection\nEndGlobal\n" }, { "path": "deps/jemalloc/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj", "content": "\n\n \n \n Debug-static\n Win32\n \n \n Debug-static\n x64\n \n \n Debug\n Win32\n \n \n Release-static\n Win32\n \n \n Release-static\n x64\n \n \n Release\n Win32\n \n \n Debug\n x64\n \n \n Release\n x64\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {8D6BB292-9E1C-413D-9F98-4864BDC1514A}\n Win32Proj\n jemalloc\n 8.1\n \n \n \n DynamicLibrary\n true\n v140\n MultiByte\n \n \n StaticLibrary\n true\n v140\n MultiByte\n \n \n DynamicLibrary\n false\n v140\n true\n MultiByte\n \n \n StaticLibrary\n false\n v140\n true\n MultiByte\n \n \n DynamicLibrary\n true\n v140\n MultiByte\n \n \n StaticLibrary\n true\n v140\n MultiByte\n \n \n DynamicLibrary\n false\n v140\n true\n MultiByte\n \n \n StaticLibrary\n false\n v140\n true\n MultiByte\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)d\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-$(PlatformToolset)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-$(PlatformToolset)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)d\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)\n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n 4090;4146;4267;4334\n OldStyle\n false\n \n \n Windows\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n 4090;4146;4267;4334\n OldStyle\n \n \n Windows\n true\n true\n true\n \n \n \n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2015/jemalloc/jemalloc.vcxproj.filters", "content": "\n\n \n \n {4FC737F1-C7A5-4376-A066-2A32D752A2FF}\n cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx\n \n \n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2015/test_threads/test_threads.vcxproj", "content": "\n\n \n \n Debug-static\n Win32\n \n \n Debug-static\n x64\n \n \n Debug\n Win32\n \n \n Release-static\n Win32\n \n \n Release-static\n x64\n \n \n Release\n Win32\n \n \n Debug\n x64\n \n \n Release\n x64\n \n \n \n {09028CFD-4EB7-491D-869C-0708DB97ED44}\n Win32Proj\n test_threads\n 8.1\n \n \n \n Application\n true\n v140\n MultiByte\n \n \n Application\n true\n v140\n MultiByte\n \n \n Application\n false\n v140\n true\n MultiByte\n \n \n Application\n false\n v140\n true\n MultiByte\n \n \n Application\n true\n v140\n MultiByte\n \n \n Application\n true\n v140\n MultiByte\n \n \n Application\n false\n v140\n true\n MultiByte\n \n \n Application\n false\n v140\n true\n MultiByte\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n true\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n true\n \n \n true\n $(SolutionDir)$(Platform)\\$(Configuration)\\\n \n \n true\n $(SolutionDir)$(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n \n \n \n Level3\n Disabled\n WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n \n \n Console\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n Level3\n Disabled\n _DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n $(SolutionDir)$(Platform)\\$(Configuration)\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n \n \n Console\n true\n jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n $(SolutionDir)$(Platform)\\$(Configuration)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n \n \n {8d6bb292-9e1c-413d-9f98-4864bdc1514a}\n \n \n \n \n \n \n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2015/test_threads/test_threads.vcxproj.filters", "content": "\n\n \n \n {4FC737F1-C7A5-4376-A066-2A32D752A2FF}\n cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx\n \n \n {93995380-89BD-4b04-88EB-625FBE52EBFB}\n h;hh;hpp;hxx;hm;inl;inc;xsd\n \n \n \n \n Source Files\n \n \n Source Files\n \n \n \n \n Header Files\n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj", "content": "\n\n \n \n Debug-static\n Win32\n \n \n Debug-static\n x64\n \n \n Debug\n Win32\n \n \n Release-static\n Win32\n \n \n Release-static\n x64\n \n \n Release\n Win32\n \n \n Debug\n x64\n \n \n Release\n x64\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {8D6BB292-9E1C-413D-9F98-4864BDC1514A}\n Win32Proj\n jemalloc\n \n \n \n DynamicLibrary\n true\n v141\n MultiByte\n \n \n StaticLibrary\n true\n v141\n MultiByte\n \n \n DynamicLibrary\n false\n v141\n true\n MultiByte\n \n \n StaticLibrary\n false\n v141\n true\n MultiByte\n \n \n DynamicLibrary\n true\n v141\n MultiByte\n \n \n StaticLibrary\n true\n v141\n MultiByte\n \n \n DynamicLibrary\n false\n v141\n true\n MultiByte\n \n \n StaticLibrary\n false\n v141\n true\n MultiByte\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)d\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-$(PlatformToolset)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-$(PlatformToolset)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)d\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n $(ProjectName)-vc$(PlatformToolsetVersion)-$(Configuration)\n \n \n \n \n \n Level3\n Disabled\n _REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;JEMALLOC_DEBUG;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_NO_PRIVATE_NAMESPACE;JEMALLOC_DEBUG;_REENTRANT;JEMALLOC_EXPORT=;_DEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n 4090;4146;4267;4334\n OldStyle\n false\n \n \n Windows\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n _REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n _REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;_WINDLL;DLLEXPORT;NDEBUG;%(PreprocessorDefinitions)\n 4090;4146;4267;4334\n $(OutputPath)$(TargetName).pdb\n \n \n Windows\n true\n true\n true\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_NO_PRIVATE_NAMESPACE;_REENTRANT;JEMALLOC_EXPORT=;NDEBUG;_LIB;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n 4090;4146;4267;4334\n OldStyle\n \n \n Windows\n true\n true\n true\n \n \n \n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2017/jemalloc/jemalloc.vcxproj.filters", "content": "\n\n \n \n {4FC737F1-C7A5-4376-A066-2A32D752A2FF}\n cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx\n \n \n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n Source Files\n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2017/test_threads/test_threads.vcxproj", "content": "\n\n \n \n Debug-static\n Win32\n \n \n Debug-static\n x64\n \n \n Debug\n Win32\n \n \n Release-static\n Win32\n \n \n Release-static\n x64\n \n \n Release\n Win32\n \n \n Debug\n x64\n \n \n Release\n x64\n \n \n \n {09028CFD-4EB7-491D-869C-0708DB97ED44}\n Win32Proj\n test_threads\n \n \n \n Application\n true\n v141\n MultiByte\n \n \n Application\n true\n v141\n MultiByte\n \n \n Application\n false\n v141\n true\n MultiByte\n \n \n Application\n false\n v141\n true\n MultiByte\n \n \n Application\n true\n v141\n MultiByte\n \n \n Application\n true\n v141\n MultiByte\n \n \n Application\n false\n v141\n true\n MultiByte\n \n \n Application\n false\n v141\n true\n MultiByte\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n true\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n true\n \n \n true\n $(SolutionDir)$(Platform)\\$(Configuration)\\\n \n \n true\n $(SolutionDir)$(Platform)\\$(Configuration)\\\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n $(SolutionDir)$(Platform)\\$(Configuration)\\\n $(Platform)\\$(Configuration)\\\n false\n \n \n \n \n \n Level3\n Disabled\n WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n \n \n Console\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n Level3\n Disabled\n _DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n jemallocd.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n $(SolutionDir)$(Platform)\\$(Configuration)\n \n \n \n \n \n \n Level3\n Disabled\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;_DEBUG;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreadedDebug\n \n \n Console\n true\n jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n $(SolutionDir)$(Platform)\\$(Configuration)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-$(PlatformToolset)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n Level3\n \n \n MaxSpeed\n true\n true\n JEMALLOC_EXPORT=;JEMALLOC_STATIC;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)\n ..\\..\\..\\..\\test\\include;..\\..\\..\\..\\include;..\\..\\..\\..\\include\\msvc_compat;%(AdditionalIncludeDirectories)\n MultiThreaded\n \n \n Console\n true\n true\n true\n $(SolutionDir)$(Platform)\\$(Configuration)\n jemalloc-vc$(PlatformToolsetVersion)-$(Configuration).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)\n \n \n \n \n \n \n \n \n {8d6bb292-9e1c-413d-9f98-4864bdc1514a}\n \n \n \n \n \n \n \n \n" }, { "path": "deps/jemalloc/msvc/projects/vc2017/test_threads/test_threads.vcxproj.filters", "content": "\n\n \n \n {4FC737F1-C7A5-4376-A066-2A32D752A2FF}\n cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx\n \n \n {93995380-89BD-4b04-88EB-625FBE52EBFB}\n h;hh;hpp;hxx;hm;inl;inc;xsd\n \n \n \n \n Source Files\n \n \n Source Files\n \n \n \n \n Header Files\n \n \n" }, { "path": "deps/jemalloc/msvc/test_threads/test_threads.cpp", "content": "// jemalloc C++ threaded test\n// Author: Rustam Abdullaev\n// Public Domain\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#define JEMALLOC_NO_DEMANGLE\n#include \n\nusing std::vector;\nusing std::thread;\nusing std::uniform_int_distribution;\nusing std::minstd_rand;\n\nint test_threads() {\n je_malloc_conf = \"narenas:3\";\n int narenas = 0;\n size_t sz = sizeof(narenas);\n je_mallctl(\"opt.narenas\", (void *)&narenas, &sz, NULL, 0);\n if (narenas != 3) {\n printf(\"Error: unexpected number of arenas: %d\\n\", narenas);\n return 1;\n }\n static const int sizes[] = { 7, 16, 32, 60, 91, 100, 120, 144, 169, 199, 255, 400, 670, 900, 917, 1025, 3333, 5190, 13131, 49192, 99999, 123123, 255265, 2333111 };\n static const int numSizes = (int)(sizeof(sizes) / sizeof(sizes[0]));\n vector workers;\n static const int numThreads = narenas + 1, numAllocsMax = 25, numIter1 = 50, numIter2 = 50;\n je_malloc_stats_print(NULL, NULL, NULL);\n size_t allocated1;\n size_t sz1 = sizeof(allocated1);\n je_mallctl(\"stats.active\", (void *)&allocated1, &sz1, NULL, 0);\n printf(\"\\nPress Enter to start threads...\\n\");\n getchar();\n printf(\"Starting %d threads x %d x %d iterations...\\n\", numThreads, numIter1, numIter2);\n for (int i = 0; i < numThreads; i++) {\n workers.emplace_back([tid=i]() {\n uniform_int_distribution sizeDist(0, numSizes - 1);\n minstd_rand rnd(tid * 17);\n uint8_t* ptrs[numAllocsMax];\n int ptrsz[numAllocsMax];\n for (int i = 0; i < numIter1; ++i) {\n thread t([&]() {\n for (int i = 0; i < numIter2; ++i) {\n const int numAllocs = numAllocsMax - sizeDist(rnd);\n for (int j = 0; j < numAllocs; j += 64) {\n const int x = sizeDist(rnd);\n const int sz = sizes[x];\n ptrsz[j] = sz;\n ptrs[j] = (uint8_t*)je_malloc(sz);\n if (!ptrs[j]) {\n printf(\"Unable to allocate %d bytes in thread %d, iter %d, alloc %d. %d\\n\", sz, tid, i, j, x);\n exit(1);\n }\n for (int k = 0; k < sz; k++)\n ptrs[j][k] = tid + k;\n }\n for (int j = 0; j < numAllocs; j += 64) {\n for (int k = 0, sz = ptrsz[j]; k < sz; k++)\n if (ptrs[j][k] != (uint8_t)(tid + k)) {\n printf(\"Memory error in thread %d, iter %d, alloc %d @ %d : %02X!=%02X\\n\", tid, i, j, k, ptrs[j][k], (uint8_t)(tid + k));\n exit(1);\n }\n je_free(ptrs[j]);\n }\n }\n });\n t.join();\n }\n });\n }\n for (thread& t : workers) {\n t.join();\n }\n je_malloc_stats_print(NULL, NULL, NULL);\n size_t allocated2;\n je_mallctl(\"stats.active\", (void *)&allocated2, &sz1, NULL, 0);\n size_t leaked = allocated2 - allocated1;\n printf(\"\\nDone. Leaked: %zd bytes\\n\", leaked);\n bool failed = leaked > 65536; // in case C++ runtime allocated something (e.g. iostream locale or facet)\n printf(\"\\nTest %s!\\n\", (failed ? \"FAILED\" : \"successful\"));\n printf(\"\\nPress Enter to continue...\\n\");\n getchar();\n return failed ? 1 : 0;\n}\n" }, { "path": "deps/jemalloc/msvc/test_threads/test_threads.h", "content": "#pragma once\n\nint test_threads();\n" }, { "path": "deps/jemalloc/msvc/test_threads/test_threads_main.cpp", "content": "#include \"test_threads.h\"\n#include \n#include \n#include \n\nusing namespace std::chrono_literals;\n\nint main(int argc, char** argv) {\n int rc = test_threads();\n return rc;\n}\n" }, { "path": "deps/jemalloc/run_tests.sh", "content": "$(dirname \"$)\")/scripts/gen_run_tests.py | bash\n" }, { "path": "deps/jemalloc/scripts/check-formatting.sh", "content": "#!/bin/bash\n\n# The files that need to be properly formatted. We'll grow this incrementally\n# until it includes all the jemalloc source files (as we convert things over),\n# and then just replace it with\n# find -name '*.c' -o -name '*.h' -o -name '*.cpp\nFILES=(\n)\n\nif command -v clang-format &> /dev/null; then\n CLANG_FORMAT=\"clang-format\"\nelif command -v clang-format-8 &> /dev/null; then\n CLANG_FORMAT=\"clang-format-8\"\nelse\n echo \"Couldn't find clang-format.\"\nfi\n\nif ! $CLANG_FORMAT -version | grep \"version 8\\.\" &> /dev/null; then\n echo \"clang-format is the wrong version.\"\n exit 1\nfi\n\nfor file in ${FILES[@]}; do\n if ! cmp --silent $file <($CLANG_FORMAT $file) &> /dev/null; then\n echo \"Error: $file is not clang-formatted\"\n exit 1\n fi\ndone\n" }, { "path": "deps/jemalloc/scripts/freebsd/before_install.sh", "content": "#!/bin/tcsh\n\nsu -m root -c 'pkg install -y git'\n" }, { "path": "deps/jemalloc/scripts/freebsd/before_script.sh", "content": "#!/bin/tcsh\n\nautoconf\n# We don't perfectly track freebsd stdlib.h definitions. This is fine when\n# we count as a system header, but breaks otherwise, like during these\n# tests.\n./configure --with-jemalloc-prefix=ci_ ${COMPILER_FLAGS:+ CC=\"$CC $COMPILER_FLAGS\" CXX=\"$CXX $COMPILER_FLAGS\"} $CONFIGURE_FLAGS\nJE_NCPUS=`sysctl -n kern.smp.cpus`\ngmake -j${JE_NCPUS}\ngmake -j${JE_NCPUS} tests\n" }, { "path": "deps/jemalloc/scripts/freebsd/script.sh", "content": "#!/bin/tcsh\n\ngmake check\n" }, { "path": "deps/jemalloc/scripts/gen_run_tests.py", "content": "#!/usr/bin/env python3\n\nimport sys\nfrom itertools import combinations\nfrom os import uname\nfrom multiprocessing import cpu_count\nfrom subprocess import call\n\n# Later, we want to test extended vaddr support. Apparently, the \"real\" way of\n# checking this is flaky on OS X.\nbits_64 = sys.maxsize > 2**32\n\nnparallel = cpu_count() * 2\n\nuname = uname()[0]\n\nif call(\"command -v gmake\", shell=True) == 0:\n make_cmd = 'gmake'\nelse:\n make_cmd = 'make'\n\ndef powerset(items):\n result = []\n for i in range(len(items) + 1):\n result += combinations(items, i)\n return result\n\npossible_compilers = []\nfor cc, cxx in (['gcc', 'g++'], ['clang', 'clang++']):\n try:\n cmd_ret = call([cc, \"-v\"])\n if cmd_ret == 0:\n possible_compilers.append((cc, cxx))\n except:\n pass\npossible_compiler_opts = [\n '-m32',\n]\npossible_config_opts = [\n '--enable-debug',\n '--enable-prof',\n '--disable-stats',\n '--enable-opt-safety-checks',\n '--with-lg-page=16',\n]\nif bits_64:\n possible_config_opts.append('--with-lg-vaddr=56')\n\npossible_malloc_conf_opts = [\n 'tcache:false',\n 'dss:primary',\n 'percpu_arena:percpu',\n 'background_thread:true',\n]\n\nprint('set -e')\nprint('if [ -f Makefile ] ; then %(make_cmd)s relclean ; fi' % {'make_cmd':\n make_cmd})\nprint('autoconf')\nprint('rm -rf run_tests.out')\nprint('mkdir run_tests.out')\nprint('cd run_tests.out')\n\nind = 0\nfor cc, cxx in possible_compilers:\n for compiler_opts in powerset(possible_compiler_opts):\n for config_opts in powerset(possible_config_opts):\n for malloc_conf_opts in powerset(possible_malloc_conf_opts):\n if cc == 'clang' \\\n and '-m32' in possible_compiler_opts \\\n and '--enable-prof' in config_opts:\n continue\n config_line = (\n 'EXTRA_CFLAGS=-Werror EXTRA_CXXFLAGS=-Werror '\n + 'CC=\"{} {}\" '.format(cc, \" \".join(compiler_opts))\n + 'CXX=\"{} {}\" '.format(cxx, \" \".join(compiler_opts))\n + '../../configure '\n + \" \".join(config_opts) + (' --with-malloc-conf=' +\n \",\".join(malloc_conf_opts) if len(malloc_conf_opts) > 0\n else '')\n )\n\n # We don't want to test large vaddr spaces in 32-bit mode.\n if ('-m32' in compiler_opts and '--with-lg-vaddr=56' in\n config_opts):\n continue\n\n # Per CPU arenas are only supported on Linux.\n linux_supported = ('percpu_arena:percpu' in malloc_conf_opts \\\n or 'background_thread:true' in malloc_conf_opts)\n # Heap profiling and dss are not supported on OS X.\n darwin_unsupported = ('--enable-prof' in config_opts or \\\n 'dss:primary' in malloc_conf_opts)\n if (uname == 'Linux' and linux_supported) \\\n or (not linux_supported and (uname != 'Darwin' or \\\n not darwin_unsupported)):\n print(\"\"\"cat < run_test_%(ind)d.sh\n#!/bin/sh\n\nset -e\n\nabort() {\n echo \"==> Error\" >> run_test.log\n echo \"Error; see run_tests.out/run_test_%(ind)d.out/run_test.log\"\n exit 255 # Special exit code tells xargs to terminate.\n}\n\n# Environment variables are not supported.\nrun_cmd() {\n echo \"==> \\$@\" >> run_test.log\n \\$@ >> run_test.log 2>&1 || abort\n}\n\necho \"=> run_test_%(ind)d: %(config_line)s\"\nmkdir run_test_%(ind)d.out\ncd run_test_%(ind)d.out\n\necho \"==> %(config_line)s\" >> run_test.log\n%(config_line)s >> run_test.log 2>&1 || abort\n\nrun_cmd %(make_cmd)s all tests\nrun_cmd %(make_cmd)s check\nrun_cmd %(make_cmd)s distclean\nEOF\nchmod 755 run_test_%(ind)d.sh\"\"\" % {'ind': ind, 'config_line': config_line,\n 'make_cmd': make_cmd})\n ind += 1\n\nprint('for i in `seq 0 %(last_ind)d` ; do echo run_test_${i}.sh ; done | xargs'\n ' -P %(nparallel)d -n 1 sh' % {'last_ind': ind-1, 'nparallel': nparallel})\n" }, { "path": "deps/jemalloc/scripts/gen_travis.py", "content": "#!/usr/bin/env python3\n\nfrom itertools import combinations, chain\nfrom enum import Enum, auto\n\n\nLINUX = 'linux'\nOSX = 'osx'\nWINDOWS = 'windows'\nFREEBSD = 'freebsd'\n\n\nAMD64 = 'amd64'\nARM64 = 'arm64'\nPPC64LE = 'ppc64le'\n\n\nTRAVIS_TEMPLATE = \"\"\"\\\n# This config file is generated by ./scripts/gen_travis.py.\n# Do not edit by hand.\n\n# We use 'minimal', because 'generic' makes Windows VMs hang at startup. Also\n# the software provided by 'generic' is simply not needed for our tests.\n# Differences are explained here:\n# https://docs.travis-ci.com/user/languages/minimal-and-generic/\nlanguage: minimal\ndist: focal\n\njobs:\n include:\n{jobs}\n\nbefore_install:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/before_install.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/before_install.sh\n fi\n\nbefore_script:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/before_script.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/before_script.sh\n else\n scripts/gen_travis.py > travis_script && diff .travis.yml travis_script\n autoconf\n # If COMPILER_FLAGS are not empty, add them to CC and CXX\n ./configure ${{COMPILER_FLAGS:+ CC=\"$CC $COMPILER_FLAGS\" \\\nCXX=\"$CXX $COMPILER_FLAGS\"}} $CONFIGURE_FLAGS\n make -j3\n make -j3 tests\n fi\n\nscript:\n - |-\n if test -f \"./scripts/$TRAVIS_OS_NAME/script.sh\"; then\n source ./scripts/$TRAVIS_OS_NAME/script.sh\n else\n make check\n fi\n\"\"\"\n\n\nclass Option(object):\n class Type:\n COMPILER = auto()\n COMPILER_FLAG = auto()\n CONFIGURE_FLAG = auto()\n MALLOC_CONF = auto()\n FEATURE = auto()\n\n def __init__(self, type, value):\n self.type = type\n self.value = value\n\n @staticmethod\n def as_compiler(value):\n return Option(Option.Type.COMPILER, value)\n\n @staticmethod\n def as_compiler_flag(value):\n return Option(Option.Type.COMPILER_FLAG, value)\n\n @staticmethod\n def as_configure_flag(value):\n return Option(Option.Type.CONFIGURE_FLAG, value)\n\n @staticmethod\n def as_malloc_conf(value):\n return Option(Option.Type.MALLOC_CONF, value)\n\n @staticmethod\n def as_feature(value):\n return Option(Option.Type.FEATURE, value)\n\n def __eq__(self, obj):\n return (isinstance(obj, Option) and obj.type == self.type\n and obj.value == self.value)\n\n\n# The 'default' configuration is gcc, on linux, with no compiler or configure\n# flags. We also test with clang, -m32, --enable-debug, --enable-prof,\n# --disable-stats, and --with-malloc-conf=tcache:false. To avoid abusing\n# travis though, we don't test all 2**7 = 128 possible combinations of these;\n# instead, we only test combinations of up to 2 'unusual' settings, under the\n# hope that bugs involving interactions of such settings are rare.\nMAX_UNUSUAL_OPTIONS = 2\n\n\nGCC = Option.as_compiler('CC=gcc CXX=g++')\nCLANG = Option.as_compiler('CC=clang CXX=clang++')\nCL = Option.as_compiler('CC=cl.exe CXX=cl.exe')\n\n\ncompilers_unusual = [CLANG,]\n\n\nCROSS_COMPILE_32BIT = Option.as_feature('CROSS_COMPILE_32BIT')\nfeature_unusuals = [CROSS_COMPILE_32BIT]\n\n\nconfigure_flag_unusuals = [Option.as_configure_flag(opt) for opt in (\n '--enable-debug',\n '--enable-prof',\n '--disable-stats',\n '--disable-libdl',\n '--enable-opt-safety-checks',\n '--with-lg-page=16',\n)]\n\n\nmalloc_conf_unusuals = [Option.as_malloc_conf(opt) for opt in (\n 'tcache:false',\n 'dss:primary',\n 'percpu_arena:percpu',\n 'background_thread:true',\n)]\n\n\nall_unusuals = (compilers_unusual + feature_unusuals\n + configure_flag_unusuals + malloc_conf_unusuals)\n\n\ndef get_extra_cflags(os, compiler):\n if os == FREEBSD:\n return []\n\n if os == WINDOWS:\n # For non-CL compilers under Windows (for now it's only MinGW-GCC),\n # -fcommon needs to be specified to correctly handle multiple\n # 'malloc_conf' symbols and such, which are declared weak under Linux.\n # Weak symbols don't work with MinGW-GCC.\n if compiler != CL.value:\n return ['-fcommon']\n else:\n return []\n\n # We get some spurious errors when -Warray-bounds is enabled.\n extra_cflags = ['-Werror', '-Wno-array-bounds']\n if compiler == CLANG.value or os == OSX:\n extra_cflags += [\n '-Wno-unknown-warning-option',\n '-Wno-ignored-attributes'\n ]\n if os == OSX:\n extra_cflags += [\n '-Wno-deprecated-declarations',\n ]\n return extra_cflags\n\n\n# Formats a job from a combination of flags\ndef format_job(os, arch, combination):\n compilers = [x.value for x in combination if x.type == Option.Type.COMPILER]\n assert(len(compilers) <= 1)\n compiler_flags = [x.value for x in combination if x.type == Option.Type.COMPILER_FLAG]\n configure_flags = [x.value for x in combination if x.type == Option.Type.CONFIGURE_FLAG]\n malloc_conf = [x.value for x in combination if x.type == Option.Type.MALLOC_CONF]\n features = [x.value for x in combination if x.type == Option.Type.FEATURE]\n\n if len(malloc_conf) > 0:\n configure_flags.append('--with-malloc-conf=' + ','.join(malloc_conf))\n\n if not compilers:\n compiler = GCC.value\n else:\n compiler = compilers[0]\n\n extra_environment_vars = ''\n cross_compile = CROSS_COMPILE_32BIT.value in features\n if os == LINUX and cross_compile:\n compiler_flags.append('-m32')\n\n features_str = ' '.join([' {}=yes'.format(feature) for feature in features])\n\n stringify = lambda arr, name: ' {}=\"{}\"'.format(name, ' '.join(arr)) if arr else ''\n env_string = '{}{}{}{}{}{}'.format(\n compiler,\n features_str,\n stringify(compiler_flags, 'COMPILER_FLAGS'),\n stringify(configure_flags, 'CONFIGURE_FLAGS'),\n stringify(get_extra_cflags(os, compiler), 'EXTRA_CFLAGS'),\n extra_environment_vars)\n\n job = ' - os: {}\\n'.format(os)\n job += ' arch: {}\\n'.format(arch)\n job += ' env: {}'.format(env_string)\n return job\n\n\ndef generate_unusual_combinations(unusuals, max_unusual_opts):\n \"\"\"\n Generates different combinations of non-standard compilers, compiler flags,\n configure flags and malloc_conf settings.\n\n @param max_unusual_opts: Limit of unusual options per combination.\n \"\"\"\n return chain.from_iterable(\n [combinations(unusuals, i) for i in range(max_unusual_opts + 1)])\n\n\ndef included(combination, exclude):\n \"\"\"\n Checks if the combination of options should be included in the Travis\n testing matrix.\n\n @param exclude: A list of options to be avoided.\n \"\"\"\n return not any(excluded in combination for excluded in exclude)\n\n\ndef generate_jobs(os, arch, exclude, max_unusual_opts, unusuals=all_unusuals):\n jobs = []\n for combination in generate_unusual_combinations(unusuals, max_unusual_opts):\n if included(combination, exclude):\n jobs.append(format_job(os, arch, combination))\n return '\\n'.join(jobs)\n\n\ndef generate_linux(arch):\n os = LINUX\n\n # Only generate 2 unusual options for AMD64 to reduce matrix size\n max_unusual_opts = MAX_UNUSUAL_OPTIONS if arch == AMD64 else 1\n\n exclude = []\n if arch == PPC64LE:\n # Avoid 32 bit builds and clang on PowerPC\n exclude = (CROSS_COMPILE_32BIT, CLANG,)\n\n return generate_jobs(os, arch, exclude, max_unusual_opts)\n\n\ndef generate_macos(arch):\n os = OSX\n\n max_unusual_opts = 1\n\n exclude = ([Option.as_malloc_conf(opt) for opt in (\n 'dss:primary',\n 'percpu_arena:percpu',\n 'background_thread:true')] +\n [Option.as_configure_flag('--enable-prof')] +\n [CLANG,])\n\n return generate_jobs(os, arch, exclude, max_unusual_opts)\n\n\ndef generate_windows(arch):\n os = WINDOWS\n\n max_unusual_opts = 3\n unusuals = (\n Option.as_configure_flag('--enable-debug'),\n CL,\n CROSS_COMPILE_32BIT,\n )\n return generate_jobs(os, arch, (), max_unusual_opts, unusuals)\n\n\ndef generate_freebsd(arch):\n os = FREEBSD\n\n max_unusual_opts = 4\n unusuals = (\n Option.as_configure_flag('--enable-debug'),\n Option.as_configure_flag('--enable-prof --enable-prof-libunwind'),\n Option.as_configure_flag('--with-lg-page=16 --with-malloc-conf=tcache:false'),\n CROSS_COMPILE_32BIT,\n )\n return generate_jobs(os, arch, (), max_unusual_opts, unusuals)\n\n\n\ndef get_manual_jobs():\n return \"\"\"\\\n # Development build\n - os: linux\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug \\\n--disable-cache-oblivious --enable-stats --enable-log --enable-prof\" \\\nEXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n # --enable-expermental-smallocx:\n - os: linux\n env: CC=gcc CXX=g++ CONFIGURE_FLAGS=\"--enable-debug \\\n--enable-experimental-smallocx --enable-stats --enable-prof\" \\\nEXTRA_CFLAGS=\"-Werror -Wno-array-bounds\"\n\"\"\"\n\n\ndef main():\n jobs = '\\n'.join((\n generate_windows(AMD64),\n\n generate_freebsd(AMD64),\n\n generate_linux(AMD64),\n generate_linux(PPC64LE),\n\n generate_macos(AMD64),\n\n get_manual_jobs(),\n ))\n\n print(TRAVIS_TEMPLATE.format(jobs=jobs))\n\n\nif __name__ == '__main__':\n main()\n" }, { "path": "deps/jemalloc/scripts/linux/before_install.sh", "content": "#!/bin/bash\n\nset -ev\n\nif [[ \"$TRAVIS_OS_NAME\" != \"linux\" ]]; then\n echo \"Incorrect \\$TRAVIS_OS_NAME: expected linux, got $TRAVIS_OS_NAME\"\n exit 1\nfi\n\nif [[ \"$CROSS_COMPILE_32BIT\" == \"yes\" ]]; then\n sudo apt-get update\n sudo apt-get -y install gcc-multilib g++-multilib\nfi\n" }, { "path": "deps/jemalloc/scripts/windows/before_install.sh", "content": "#!/bin/bash\n\nset -e\n\n# The purpose of this script is to install build dependencies and set\n# $build_env to a function that sets appropriate environment variables,\n# to enable (mingw32|mingw64) environment if we want to compile with gcc, or\n# (mingw32|mingw64) + vcvarsall.bat if we want to compile with cl.exe\n\nif [[ \"$TRAVIS_OS_NAME\" != \"windows\" ]]; then\n echo \"Incorrect \\$TRAVIS_OS_NAME: expected windows, got $TRAVIS_OS_NAME\"\n exit 1\nfi\n\n[[ ! -f C:/tools/msys64/msys2_shell.cmd ]] && rm -rf C:/tools/msys64\nchoco uninstall -y mingw\nchoco upgrade --no-progress -y msys2\n\nmsys_shell_cmd=\"cmd //C RefreshEnv.cmd && set MSYS=winsymlinks:nativestrict && C:\\\\tools\\\\msys64\\\\msys2_shell.cmd\"\n\nmsys2() { $msys_shell_cmd -defterm -no-start -msys2 -c \"$*\"; }\nmingw32() { $msys_shell_cmd -defterm -no-start -mingw32 -c \"$*\"; }\nmingw64() { $msys_shell_cmd -defterm -no-start -mingw64 -c \"$*\"; }\n\nif [[ \"$CROSS_COMPILE_32BIT\" == \"yes\" ]]; then\n mingw=mingw32\n mingw_gcc_package_arch=i686\nelse\n mingw=mingw64\n mingw_gcc_package_arch=x86_64\nfi\n\nif [[ \"$CC\" == *\"gcc\"* ]]; then\n $mingw pacman -S --noconfirm --needed \\\n autotools \\\n git \\\n mingw-w64-${mingw_gcc_package_arch}-make \\\n\t mingw-w64-${mingw_gcc_package_arch}-gcc \\\n\t mingw-w64-${mingw_gcc_package_arch}-binutils\n build_env=$mingw\nelif [[ \"$CC\" == *\"cl\"* ]]; then\n $mingw pacman -S --noconfirm --needed \\\n autotools \\\n\t git \\\n\t mingw-w64-${mingw_gcc_package_arch}-make \\\n\t mingw-w64-${mingw_gcc_package_arch}-binutils\n\n # In order to use MSVC compiler (cl.exe), we need to correctly set some environment\n # variables, namely PATH, INCLUDE, LIB and LIBPATH. The correct values of these\n # variables are set by a batch script \"vcvarsall.bat\". The code below generates\n # a batch script that calls \"vcvarsall.bat\" and prints the environment variables.\n #\n # Then, those environment variables are transformed from cmd to bash format and put\n # into a script $apply_vsenv. If cl.exe needs to be used from bash, one can\n # 'source $apply_vsenv' and it will apply the environment variables needed for cl.exe\n # to be located and function correctly.\n #\n # At last, a function \"mingw_with_msvc_vars\" is generated which forwards user input\n # into a correct mingw (32 or 64) subshell that automatically performs 'source $apply_vsenv',\n # making it possible for autotools to discover and use cl.exe.\n vcvarsall=\"vcvarsall.tmp.bat\"\n echo \"@echo off\" > $vcvarsall\n echo \"call \\\"c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\\\\\vcvarsall.bat\\\" $USE_MSVC\" >> $vcvarsall\n echo \"set\" >> $vcvarsall\n\n apply_vsenv=\"./apply_vsenv.sh\"\n cmd //C $vcvarsall | grep -E \"^PATH=\" | sed -n -e 's/\\(.*\\)=\\(.*\\)/export \\1=$PATH:\"\\2\"/g' \\\n -e 's/\\([a-zA-Z]\\):[\\\\\\/]/\\/\\1\\//g' \\\n -e 's/\\\\/\\//g' \\\n -e 's/;\\//:\\//gp' > $apply_vsenv\n cmd //C $vcvarsall | grep -E \"^(INCLUDE|LIB|LIBPATH)=\" | sed -n -e 's/\\(.*\\)=\\(.*\\)/export \\1=\"\\2\"/gp' >> $apply_vsenv\n\n cat $apply_vsenv\n mingw_with_msvc_vars() { $msys_shell_cmd -defterm -no-start -$mingw -c \"source $apply_vsenv && \"\"$*\"; }\n build_env=mingw_with_msvc_vars\n\n rm -f $vcvarsall\nelse\n echo \"Unknown C compiler: $CC\"\n exit 1\nfi\n\necho \"Build environment function: $build_env\"\n" }, { "path": "deps/jemalloc/scripts/windows/before_script.sh", "content": "#!/bin/bash\n\nset -e\n\nif [[ \"$TRAVIS_OS_NAME\" != \"windows\" ]]; then\n echo \"Incorrect \\$TRAVIS_OS_NAME: expected windows, got $TRAVIS_OS_NAME\"\n exit 1\nfi\n\n$build_env autoconf\n$build_env ./configure $CONFIGURE_FLAGS\n# mingw32-make simply means \"make\", unrelated to mingw32 vs mingw64.\n# Simply disregard the prefix and treat is as \"make\".\n$build_env mingw32-make -j3\n# At the moment, it's impossible to make tests in parallel,\n# seemingly due to concurrent writes to '.pdb' file. I don't know why\n# that happens, because we explicitly supply '/Fs' to the compiler.\n# Until we figure out how to fix it, we should build tests sequentially\n# on Windows.\n$build_env mingw32-make tests\n" }, { "path": "deps/jemalloc/scripts/windows/script.sh", "content": "#!/bin/bash\n\nset -e\n\nif [[ \"$TRAVIS_OS_NAME\" != \"windows\" ]]; then\n echo \"Incorrect \\$TRAVIS_OS_NAME: expected windows, got $TRAVIS_OS_NAME\"\n exit 1\nfi\n\n$build_env mingw32-make -k check\n" }, { "path": "deps/jemalloc/src/arena.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/decay.h\"\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/rtree.h\"\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/util.h\"\n\nJEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n\n/******************************************************************************/\n/* Data. */\n\n/*\n * Define names for both unininitialized and initialized phases, so that\n * options and mallctl processing are straightforward.\n */\nconst char *percpu_arena_mode_names[] = {\n\t\"percpu\",\n\t\"phycpu\",\n\t\"disabled\",\n\t\"percpu\",\n\t\"phycpu\"\n};\npercpu_arena_mode_t opt_percpu_arena = PERCPU_ARENA_DEFAULT;\n\nssize_t opt_dirty_decay_ms = DIRTY_DECAY_MS_DEFAULT;\nssize_t opt_muzzy_decay_ms = MUZZY_DECAY_MS_DEFAULT;\n\nstatic atomic_zd_t dirty_decay_ms_default;\nstatic atomic_zd_t muzzy_decay_ms_default;\n\nemap_t arena_emap_global;\npa_central_t arena_pa_central_global;\n\ndiv_info_t arena_binind_div_info[SC_NBINS];\n\nsize_t opt_oversize_threshold = OVERSIZE_THRESHOLD_DEFAULT;\nsize_t oversize_threshold = OVERSIZE_THRESHOLD_DEFAULT;\n\nuint32_t arena_bin_offsets[SC_NBINS];\nstatic unsigned nbins_total;\n\nstatic unsigned huge_arena_ind;\n\nconst arena_config_t arena_config_default = {\n\t/* .extent_hooks = */ (extent_hooks_t *)&ehooks_default_extent_hooks,\n\t/* .metadata_use_hooks = */ true,\n};\n\n/******************************************************************************/\n/*\n * Function prototypes for static functions that are referenced prior to\n * definition.\n */\n\nstatic bool arena_decay_dirty(tsdn_t *tsdn, arena_t *arena,\n bool is_background_thread, bool all);\nstatic void arena_bin_lower_slab(tsdn_t *tsdn, arena_t *arena, edata_t *slab,\n bin_t *bin);\nstatic void\narena_maybe_do_deferred_work(tsdn_t *tsdn, arena_t *arena, decay_t *decay,\n size_t npages_new);\n\n/******************************************************************************/\n\nvoid\narena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,\n const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms,\n size_t *nactive, size_t *ndirty, size_t *nmuzzy) {\n\t*nthreads += arena_nthreads_get(arena, false);\n\t*dss = dss_prec_names[arena_dss_prec_get(arena)];\n\t*dirty_decay_ms = arena_decay_ms_get(arena, extent_state_dirty);\n\t*muzzy_decay_ms = arena_decay_ms_get(arena, extent_state_muzzy);\n\tpa_shard_basic_stats_merge(&arena->pa_shard, nactive, ndirty, nmuzzy);\n}\n\nvoid\narena_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,\n const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms,\n size_t *nactive, size_t *ndirty, size_t *nmuzzy, arena_stats_t *astats,\n bin_stats_data_t *bstats, arena_stats_large_t *lstats,\n pac_estats_t *estats, hpa_shard_stats_t *hpastats, sec_stats_t *secstats) {\n\tcassert(config_stats);\n\n\tarena_basic_stats_merge(tsdn, arena, nthreads, dss, dirty_decay_ms,\n\t muzzy_decay_ms, nactive, ndirty, nmuzzy);\n\n\tsize_t base_allocated, base_resident, base_mapped, metadata_thp;\n\tbase_stats_get(tsdn, arena->base, &base_allocated, &base_resident,\n\t &base_mapped, &metadata_thp);\n\tsize_t pac_mapped_sz = pac_mapped(&arena->pa_shard.pac);\n\tastats->mapped += base_mapped + pac_mapped_sz;\n\tastats->resident += base_resident;\n\n\tLOCKEDINT_MTX_LOCK(tsdn, arena->stats.mtx);\n\n\tastats->base += base_allocated;\n\tatomic_load_add_store_zu(&astats->internal, arena_internal_get(arena));\n\tastats->metadata_thp += metadata_thp;\n\n\tfor (szind_t i = 0; i < SC_NSIZES - SC_NBINS; i++) {\n\t\tuint64_t nmalloc = locked_read_u64(tsdn,\n\t\t LOCKEDINT_MTX(arena->stats.mtx),\n\t\t &arena->stats.lstats[i].nmalloc);\n\t\tlocked_inc_u64_unsynchronized(&lstats[i].nmalloc, nmalloc);\n\t\tastats->nmalloc_large += nmalloc;\n\n\t\tuint64_t ndalloc = locked_read_u64(tsdn,\n\t\t LOCKEDINT_MTX(arena->stats.mtx),\n\t\t &arena->stats.lstats[i].ndalloc);\n\t\tlocked_inc_u64_unsynchronized(&lstats[i].ndalloc, ndalloc);\n\t\tastats->ndalloc_large += ndalloc;\n\n\t\tuint64_t nrequests = locked_read_u64(tsdn,\n\t\t LOCKEDINT_MTX(arena->stats.mtx),\n\t\t &arena->stats.lstats[i].nrequests);\n\t\tlocked_inc_u64_unsynchronized(&lstats[i].nrequests,\n\t\t nmalloc + nrequests);\n\t\tastats->nrequests_large += nmalloc + nrequests;\n\n\t\t/* nfill == nmalloc for large currently. */\n\t\tlocked_inc_u64_unsynchronized(&lstats[i].nfills, nmalloc);\n\t\tastats->nfills_large += nmalloc;\n\n\t\tuint64_t nflush = locked_read_u64(tsdn,\n\t\t LOCKEDINT_MTX(arena->stats.mtx),\n\t\t &arena->stats.lstats[i].nflushes);\n\t\tlocked_inc_u64_unsynchronized(&lstats[i].nflushes, nflush);\n\t\tastats->nflushes_large += nflush;\n\n\t\tassert(nmalloc >= ndalloc);\n\t\tassert(nmalloc - ndalloc <= SIZE_T_MAX);\n\t\tsize_t curlextents = (size_t)(nmalloc - ndalloc);\n\t\tlstats[i].curlextents += curlextents;\n\t\tastats->allocated_large +=\n\t\t curlextents * sz_index2size(SC_NBINS + i);\n\t}\n\n\tpa_shard_stats_merge(tsdn, &arena->pa_shard, &astats->pa_shard_stats,\n\t estats, hpastats, secstats, &astats->resident);\n\n\tLOCKEDINT_MTX_UNLOCK(tsdn, arena->stats.mtx);\n\n\t/* Currently cached bytes and sanitizer-stashed bytes in tcache. */\n\tastats->tcache_bytes = 0;\n\tastats->tcache_stashed_bytes = 0;\n\tmalloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);\n\tcache_bin_array_descriptor_t *descriptor;\n\tql_foreach(descriptor, &arena->cache_bin_array_descriptor_ql, link) {\n\t\tfor (szind_t i = 0; i < nhbins; i++) {\n\t\t\tcache_bin_t *cache_bin = &descriptor->bins[i];\n\t\t\tcache_bin_sz_t ncached, nstashed;\n\t\t\tcache_bin_nitems_get_remote(cache_bin,\n\t\t\t &tcache_bin_info[i], &ncached, &nstashed);\n\n\t\t\tastats->tcache_bytes += ncached * sz_index2size(i);\n\t\t\tastats->tcache_stashed_bytes += nstashed *\n\t\t\t sz_index2size(i);\n\t\t}\n\t}\n\tmalloc_mutex_prof_read(tsdn,\n\t &astats->mutex_prof_data[arena_prof_mutex_tcache_list],\n\t &arena->tcache_ql_mtx);\n\tmalloc_mutex_unlock(tsdn, &arena->tcache_ql_mtx);\n\n#define READ_ARENA_MUTEX_PROF_DATA(mtx, ind)\t\t\t\t\\\n malloc_mutex_lock(tsdn, &arena->mtx);\t\t\t\t\\\n malloc_mutex_prof_read(tsdn, &astats->mutex_prof_data[ind],\t\t\\\n &arena->mtx);\t\t\t\t\t\t\t\\\n malloc_mutex_unlock(tsdn, &arena->mtx);\n\n\t/* Gather per arena mutex profiling data. */\n\tREAD_ARENA_MUTEX_PROF_DATA(large_mtx, arena_prof_mutex_large);\n\tREAD_ARENA_MUTEX_PROF_DATA(base->mtx,\n\t arena_prof_mutex_base);\n#undef READ_ARENA_MUTEX_PROF_DATA\n\tpa_shard_mtx_stats_read(tsdn, &arena->pa_shard,\n\t astats->mutex_prof_data);\n\n\tnstime_copy(&astats->uptime, &arena->create_time);\n\tnstime_update(&astats->uptime);\n\tnstime_subtract(&astats->uptime, &arena->create_time);\n\n\tfor (szind_t i = 0; i < SC_NBINS; i++) {\n\t\tfor (unsigned j = 0; j < bin_infos[i].n_shards; j++) {\n\t\t\tbin_stats_merge(tsdn, &bstats[i],\n\t\t\t arena_get_bin(arena, i, j));\n\t\t}\n\t}\n}\n\nstatic void\narena_background_thread_inactivity_check(tsdn_t *tsdn, arena_t *arena,\n bool is_background_thread) {\n\tif (!background_thread_enabled() || is_background_thread) {\n\t\treturn;\n\t}\n\tbackground_thread_info_t *info =\n\t arena_background_thread_info_get(arena);\n\tif (background_thread_indefinite_sleep(info)) {\n\t\tarena_maybe_do_deferred_work(tsdn, arena,\n\t\t &arena->pa_shard.pac.decay_dirty, 0);\n\t}\n}\n\n/*\n * React to deferred work generated by a PAI function.\n */\nvoid arena_handle_deferred_work(tsdn_t *tsdn, arena_t *arena) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (decay_immediately(&arena->pa_shard.pac.decay_dirty)) {\n\t\tarena_decay_dirty(tsdn, arena, false, true);\n\t}\n\tarena_background_thread_inactivity_check(tsdn, arena, false);\n}\n\nstatic void *\narena_slab_reg_alloc(edata_t *slab, const bin_info_t *bin_info) {\n\tvoid *ret;\n\tslab_data_t *slab_data = edata_slab_data_get(slab);\n\tsize_t regind;\n\n\tassert(edata_nfree_get(slab) > 0);\n\tassert(!bitmap_full(slab_data->bitmap, &bin_info->bitmap_info));\n\n\tregind = bitmap_sfu(slab_data->bitmap, &bin_info->bitmap_info);\n\tret = (void *)((uintptr_t)edata_addr_get(slab) +\n\t (uintptr_t)(bin_info->reg_size * regind));\n\tedata_nfree_dec(slab);\n\treturn ret;\n}\n\nstatic void\narena_slab_reg_alloc_batch(edata_t *slab, const bin_info_t *bin_info,\n\t\t\t unsigned cnt, void** ptrs) {\n\tslab_data_t *slab_data = edata_slab_data_get(slab);\n\n\tassert(edata_nfree_get(slab) >= cnt);\n\tassert(!bitmap_full(slab_data->bitmap, &bin_info->bitmap_info));\n\n#if (! defined JEMALLOC_INTERNAL_POPCOUNTL) || (defined BITMAP_USE_TREE)\n\tfor (unsigned i = 0; i < cnt; i++) {\n\t\tsize_t regind = bitmap_sfu(slab_data->bitmap,\n\t\t\t\t\t &bin_info->bitmap_info);\n\t\t*(ptrs + i) = (void *)((uintptr_t)edata_addr_get(slab) +\n\t\t (uintptr_t)(bin_info->reg_size * regind));\n\t}\n#else\n\tunsigned group = 0;\n\tbitmap_t g = slab_data->bitmap[group];\n\tunsigned i = 0;\n\twhile (i < cnt) {\n\t\twhile (g == 0) {\n\t\t\tg = slab_data->bitmap[++group];\n\t\t}\n\t\tsize_t shift = group << LG_BITMAP_GROUP_NBITS;\n\t\tsize_t pop = popcount_lu(g);\n\t\tif (pop > (cnt - i)) {\n\t\t\tpop = cnt - i;\n\t\t}\n\n\t\t/*\n\t\t * Load from memory locations only once, outside the\n\t\t * hot loop below.\n\t\t */\n\t\tuintptr_t base = (uintptr_t)edata_addr_get(slab);\n\t\tuintptr_t regsize = (uintptr_t)bin_info->reg_size;\n\t\twhile (pop--) {\n\t\t\tsize_t bit = cfs_lu(&g);\n\t\t\tsize_t regind = shift + bit;\n\t\t\t*(ptrs + i) = (void *)(base + regsize * regind);\n\n\t\t\ti++;\n\t\t}\n\t\tslab_data->bitmap[group] = g;\n\t}\n#endif\n\tedata_nfree_sub(slab, cnt);\n}\n\nstatic void\narena_large_malloc_stats_update(tsdn_t *tsdn, arena_t *arena, size_t usize) {\n\tszind_t index, hindex;\n\n\tcassert(config_stats);\n\n\tif (usize < SC_LARGE_MINCLASS) {\n\t\tusize = SC_LARGE_MINCLASS;\n\t}\n\tindex = sz_size2index(usize);\n\thindex = (index >= SC_NBINS) ? index - SC_NBINS : 0;\n\n\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(arena->stats.mtx),\n\t &arena->stats.lstats[hindex].nmalloc, 1);\n}\n\nstatic void\narena_large_dalloc_stats_update(tsdn_t *tsdn, arena_t *arena, size_t usize) {\n\tszind_t index, hindex;\n\n\tcassert(config_stats);\n\n\tif (usize < SC_LARGE_MINCLASS) {\n\t\tusize = SC_LARGE_MINCLASS;\n\t}\n\tindex = sz_size2index(usize);\n\thindex = (index >= SC_NBINS) ? index - SC_NBINS : 0;\n\n\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(arena->stats.mtx),\n\t &arena->stats.lstats[hindex].ndalloc, 1);\n}\n\nstatic void\narena_large_ralloc_stats_update(tsdn_t *tsdn, arena_t *arena, size_t oldusize,\n size_t usize) {\n\tarena_large_malloc_stats_update(tsdn, arena, usize);\n\tarena_large_dalloc_stats_update(tsdn, arena, oldusize);\n}\n\nedata_t *\narena_extent_alloc_large(tsdn_t *tsdn, arena_t *arena, size_t usize,\n size_t alignment, bool zero) {\n\tbool deferred_work_generated = false;\n\tszind_t szind = sz_size2index(usize);\n\tsize_t esize = usize + sz_large_pad;\n\n\tbool guarded = san_large_extent_decide_guard(tsdn,\n\t arena_get_ehooks(arena), esize, alignment);\n\tedata_t *edata = pa_alloc(tsdn, &arena->pa_shard, esize, alignment,\n\t /* slab */ false, szind, zero, guarded, &deferred_work_generated);\n\tassert(deferred_work_generated == false);\n\n\tif (edata != NULL) {\n\t\tif (config_stats) {\n\t\t\tLOCKEDINT_MTX_LOCK(tsdn, arena->stats.mtx);\n\t\t\tarena_large_malloc_stats_update(tsdn, arena, usize);\n\t\t\tLOCKEDINT_MTX_UNLOCK(tsdn, arena->stats.mtx);\n\t\t}\n\t}\n\n\tif (edata != NULL && sz_large_pad != 0) {\n\t\tarena_cache_oblivious_randomize(tsdn, arena, edata, alignment);\n\t}\n\n\treturn edata;\n}\n\nvoid\narena_extent_dalloc_large_prep(tsdn_t *tsdn, arena_t *arena, edata_t *edata) {\n\tif (config_stats) {\n\t\tLOCKEDINT_MTX_LOCK(tsdn, arena->stats.mtx);\n\t\tarena_large_dalloc_stats_update(tsdn, arena,\n\t\t edata_usize_get(edata));\n\t\tLOCKEDINT_MTX_UNLOCK(tsdn, arena->stats.mtx);\n\t}\n}\n\nvoid\narena_extent_ralloc_large_shrink(tsdn_t *tsdn, arena_t *arena, edata_t *edata,\n size_t oldusize) {\n\tsize_t usize = edata_usize_get(edata);\n\n\tif (config_stats) {\n\t\tLOCKEDINT_MTX_LOCK(tsdn, arena->stats.mtx);\n\t\tarena_large_ralloc_stats_update(tsdn, arena, oldusize, usize);\n\t\tLOCKEDINT_MTX_UNLOCK(tsdn, arena->stats.mtx);\n\t}\n}\n\nvoid\narena_extent_ralloc_large_expand(tsdn_t *tsdn, arena_t *arena, edata_t *edata,\n size_t oldusize) {\n\tsize_t usize = edata_usize_get(edata);\n\n\tif (config_stats) {\n\t\tLOCKEDINT_MTX_LOCK(tsdn, arena->stats.mtx);\n\t\tarena_large_ralloc_stats_update(tsdn, arena, oldusize, usize);\n\t\tLOCKEDINT_MTX_UNLOCK(tsdn, arena->stats.mtx);\n\t}\n}\n\n/*\n * In situations where we're not forcing a decay (i.e. because the user\n * specifically requested it), should we purge ourselves, or wait for the\n * background thread to get to it.\n */\nstatic pac_purge_eagerness_t\narena_decide_unforced_purge_eagerness(bool is_background_thread) {\n\tif (is_background_thread) {\n\t\treturn PAC_PURGE_ALWAYS;\n\t} else if (!is_background_thread && background_thread_enabled()) {\n\t\treturn PAC_PURGE_NEVER;\n\t} else {\n\t\treturn PAC_PURGE_ON_EPOCH_ADVANCE;\n\t}\n}\n\nbool\narena_decay_ms_set(tsdn_t *tsdn, arena_t *arena, extent_state_t state,\n ssize_t decay_ms) {\n\tpac_purge_eagerness_t eagerness = arena_decide_unforced_purge_eagerness(\n\t /* is_background_thread */ false);\n\treturn pa_decay_ms_set(tsdn, &arena->pa_shard, state, decay_ms,\n\t eagerness);\n}\n\nssize_t\narena_decay_ms_get(arena_t *arena, extent_state_t state) {\n\treturn pa_decay_ms_get(&arena->pa_shard, state);\n}\n\nstatic bool\narena_decay_impl(tsdn_t *tsdn, arena_t *arena, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache,\n bool is_background_thread, bool all) {\n\tif (all) {\n\t\tmalloc_mutex_lock(tsdn, &decay->mtx);\n\t\tpac_decay_all(tsdn, &arena->pa_shard.pac, decay, decay_stats,\n\t\t ecache, /* fully_decay */ all);\n\t\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\t\treturn false;\n\t}\n\n\tif (malloc_mutex_trylock(tsdn, &decay->mtx)) {\n\t\t/* No need to wait if another thread is in progress. */\n\t\treturn true;\n\t}\n\tpac_purge_eagerness_t eagerness =\n\t arena_decide_unforced_purge_eagerness(is_background_thread);\n\tbool epoch_advanced = pac_maybe_decay_purge(tsdn, &arena->pa_shard.pac,\n\t decay, decay_stats, ecache, eagerness);\n\tsize_t npages_new;\n\tif (epoch_advanced) {\n\t\t/* Backlog is updated on epoch advance. */\n\t\tnpages_new = decay_epoch_npages_delta(decay);\n\t}\n\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\n\tif (have_background_thread && background_thread_enabled() &&\n\t epoch_advanced && !is_background_thread) {\n\t\tarena_maybe_do_deferred_work(tsdn, arena, decay, npages_new);\n\t}\n\n\treturn false;\n}\n\nstatic bool\narena_decay_dirty(tsdn_t *tsdn, arena_t *arena, bool is_background_thread,\n bool all) {\n\treturn arena_decay_impl(tsdn, arena, &arena->pa_shard.pac.decay_dirty,\n\t &arena->pa_shard.pac.stats->decay_dirty,\n\t &arena->pa_shard.pac.ecache_dirty, is_background_thread, all);\n}\n\nstatic bool\narena_decay_muzzy(tsdn_t *tsdn, arena_t *arena, bool is_background_thread,\n bool all) {\n\tif (pa_shard_dont_decay_muzzy(&arena->pa_shard)) {\n\t\treturn false;\n\t}\n\treturn arena_decay_impl(tsdn, arena, &arena->pa_shard.pac.decay_muzzy,\n\t &arena->pa_shard.pac.stats->decay_muzzy,\n\t &arena->pa_shard.pac.ecache_muzzy, is_background_thread, all);\n}\n\nvoid\narena_decay(tsdn_t *tsdn, arena_t *arena, bool is_background_thread, bool all) {\n\tif (all) {\n\t\t/*\n\t\t * We should take a purge of \"all\" to mean \"save as much memory\n\t\t * as possible\", including flushing any caches (for situations\n\t\t * like thread death, or manual purge calls).\n\t\t */\n\t\tsec_flush(tsdn, &arena->pa_shard.hpa_sec);\n\t}\n\tif (arena_decay_dirty(tsdn, arena, is_background_thread, all)) {\n\t\treturn;\n\t}\n\tarena_decay_muzzy(tsdn, arena, is_background_thread, all);\n}\n\nstatic bool\narena_should_decay_early(tsdn_t *tsdn, arena_t *arena, decay_t *decay,\n background_thread_info_t *info, nstime_t *remaining_sleep,\n size_t npages_new) {\n\tmalloc_mutex_assert_owner(tsdn, &info->mtx);\n\n\tif (malloc_mutex_trylock(tsdn, &decay->mtx)) {\n\t\treturn false;\n\t}\n\n\tif (!decay_gradually(decay)) {\n\t\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\t\treturn false;\n\t}\n\n\tnstime_init(remaining_sleep, background_thread_wakeup_time_get(info));\n\tif (nstime_compare(remaining_sleep, &decay->epoch) <= 0) {\n\t\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\t\treturn false;\n\t}\n\tnstime_subtract(remaining_sleep, &decay->epoch);\n\tif (npages_new > 0) {\n\t\tuint64_t npurge_new = decay_npages_purge_in(decay,\n\t\t remaining_sleep, npages_new);\n\t\tinfo->npages_to_purge_new += npurge_new;\n\t}\n\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\treturn info->npages_to_purge_new >\n\t ARENA_DEFERRED_PURGE_NPAGES_THRESHOLD;\n}\n\n/*\n * Check if deferred work needs to be done sooner than planned.\n * For decay we might want to wake up earlier because of an influx of dirty\n * pages. Rather than waiting for previously estimated time, we proactively\n * purge those pages.\n * If background thread sleeps indefinitely, always wake up because some\n * deferred work has been generated.\n */\nstatic void\narena_maybe_do_deferred_work(tsdn_t *tsdn, arena_t *arena, decay_t *decay,\n size_t npages_new) {\n\tbackground_thread_info_t *info = arena_background_thread_info_get(\n\t arena);\n\tif (malloc_mutex_trylock(tsdn, &info->mtx)) {\n\t\t/*\n\t\t * Background thread may hold the mutex for a long period of\n\t\t * time. We'd like to avoid the variance on application\n\t\t * threads. So keep this non-blocking, and leave the work to a\n\t\t * future epoch.\n\t\t */\n\t\treturn;\n\t}\n\tif (!background_thread_is_started(info)) {\n\t\tgoto label_done;\n\t}\n\n\tnstime_t remaining_sleep;\n\tif (background_thread_indefinite_sleep(info)) {\n\t\tbackground_thread_wakeup_early(info, NULL);\n\t} else if (arena_should_decay_early(tsdn, arena, decay, info,\n\t &remaining_sleep, npages_new)) {\n\t\tinfo->npages_to_purge_new = 0;\n\t\tbackground_thread_wakeup_early(info, &remaining_sleep);\n\t}\nlabel_done:\n\tmalloc_mutex_unlock(tsdn, &info->mtx);\n}\n\n/* Called from background threads. */\nvoid\narena_do_deferred_work(tsdn_t *tsdn, arena_t *arena) {\n\tarena_decay(tsdn, arena, true, false);\n\tpa_shard_do_deferred_work(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_slab_dalloc(tsdn_t *tsdn, arena_t *arena, edata_t *slab) {\n\tbool deferred_work_generated = false;\n\tpa_dalloc(tsdn, &arena->pa_shard, slab, &deferred_work_generated);\n\tif (deferred_work_generated) {\n\t\tarena_handle_deferred_work(tsdn, arena);\n\t}\n}\n\nstatic void\narena_bin_slabs_nonfull_insert(bin_t *bin, edata_t *slab) {\n\tassert(edata_nfree_get(slab) > 0);\n\tedata_heap_insert(&bin->slabs_nonfull, slab);\n\tif (config_stats) {\n\t\tbin->stats.nonfull_slabs++;\n\t}\n}\n\nstatic void\narena_bin_slabs_nonfull_remove(bin_t *bin, edata_t *slab) {\n\tedata_heap_remove(&bin->slabs_nonfull, slab);\n\tif (config_stats) {\n\t\tbin->stats.nonfull_slabs--;\n\t}\n}\n\nstatic edata_t *\narena_bin_slabs_nonfull_tryget(bin_t *bin) {\n\tedata_t *slab = edata_heap_remove_first(&bin->slabs_nonfull);\n\tif (slab == NULL) {\n\t\treturn NULL;\n\t}\n\tif (config_stats) {\n\t\tbin->stats.reslabs++;\n\t\tbin->stats.nonfull_slabs--;\n\t}\n\treturn slab;\n}\n\nstatic void\narena_bin_slabs_full_insert(arena_t *arena, bin_t *bin, edata_t *slab) {\n\tassert(edata_nfree_get(slab) == 0);\n\t/*\n\t * Tracking extents is required by arena_reset, which is not allowed\n\t * for auto arenas. Bypass this step to avoid touching the edata\n\t * linkage (often results in cache misses) for auto arenas.\n\t */\n\tif (arena_is_auto(arena)) {\n\t\treturn;\n\t}\n\tedata_list_active_append(&bin->slabs_full, slab);\n}\n\nstatic void\narena_bin_slabs_full_remove(arena_t *arena, bin_t *bin, edata_t *slab) {\n\tif (arena_is_auto(arena)) {\n\t\treturn;\n\t}\n\tedata_list_active_remove(&bin->slabs_full, slab);\n}\n\nstatic void\narena_bin_reset(tsd_t *tsd, arena_t *arena, bin_t *bin) {\n\tedata_t *slab;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);\n\tif (bin->slabcur != NULL) {\n\t\tslab = bin->slabcur;\n\t\tbin->slabcur = NULL;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);\n\t\tarena_slab_dalloc(tsd_tsdn(tsd), arena, slab);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);\n\t}\n\twhile ((slab = edata_heap_remove_first(&bin->slabs_nonfull)) != NULL) {\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);\n\t\tarena_slab_dalloc(tsd_tsdn(tsd), arena, slab);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);\n\t}\n\tfor (slab = edata_list_active_first(&bin->slabs_full); slab != NULL;\n\t slab = edata_list_active_first(&bin->slabs_full)) {\n\t\tarena_bin_slabs_full_remove(arena, bin, slab);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);\n\t\tarena_slab_dalloc(tsd_tsdn(tsd), arena, slab);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);\n\t}\n\tif (config_stats) {\n\t\tbin->stats.curregs = 0;\n\t\tbin->stats.curslabs = 0;\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);\n}\n\nvoid\narena_reset(tsd_t *tsd, arena_t *arena) {\n\t/*\n\t * Locking in this function is unintuitive. The caller guarantees that\n\t * no concurrent operations are happening in this arena, but there are\n\t * still reasons that some locking is necessary:\n\t *\n\t * - Some of the functions in the transitive closure of calls assume\n\t * appropriate locks are held, and in some cases these locks are\n\t * temporarily dropped to avoid lock order reversal or deadlock due to\n\t * reentry.\n\t * - mallctl(\"epoch\", ...) may concurrently refresh stats. While\n\t * strictly speaking this is a \"concurrent operation\", disallowing\n\t * stats refreshes would impose an inconvenient burden.\n\t */\n\n\t/* Large allocations. */\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &arena->large_mtx);\n\n\tfor (edata_t *edata = edata_list_active_first(&arena->large);\n\t edata != NULL; edata = edata_list_active_first(&arena->large)) {\n\t\tvoid *ptr = edata_base_get(edata);\n\t\tsize_t usize;\n\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &arena->large_mtx);\n\t\temap_alloc_ctx_t alloc_ctx;\n\t\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr,\n\t\t &alloc_ctx);\n\t\tassert(alloc_ctx.szind != SC_NSIZES);\n\n\t\tif (config_stats || (config_prof && opt_prof)) {\n\t\t\tusize = sz_index2size(alloc_ctx.szind);\n\t\t\tassert(usize == isalloc(tsd_tsdn(tsd), ptr));\n\t\t}\n\t\t/* Remove large allocation from prof sample set. */\n\t\tif (config_prof && opt_prof) {\n\t\t\tprof_free(tsd, ptr, usize, &alloc_ctx);\n\t\t}\n\t\tlarge_dalloc(tsd_tsdn(tsd), edata);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &arena->large_mtx);\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &arena->large_mtx);\n\n\t/* Bins. */\n\tfor (unsigned i = 0; i < SC_NBINS; i++) {\n\t\tfor (unsigned j = 0; j < bin_infos[i].n_shards; j++) {\n\t\t\tarena_bin_reset(tsd, arena, arena_get_bin(arena, i, j));\n\t\t}\n\t}\n\tpa_shard_reset(tsd_tsdn(tsd), &arena->pa_shard);\n}\n\nstatic void\narena_prepare_base_deletion_sync_finish(tsd_t *tsd, malloc_mutex_t **mutexes,\n unsigned n_mtx) {\n\tfor (unsigned i = 0; i < n_mtx; i++) {\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), mutexes[i]);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), mutexes[i]);\n\t}\n}\n\n#define ARENA_DESTROY_MAX_DELAYED_MTX 32\nstatic void\narena_prepare_base_deletion_sync(tsd_t *tsd, malloc_mutex_t *mtx,\n malloc_mutex_t **delayed_mtx, unsigned *n_delayed) {\n\tif (!malloc_mutex_trylock(tsd_tsdn(tsd), mtx)) {\n\t\t/* No contention. */\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), mtx);\n\t\treturn;\n\t}\n\tunsigned n = *n_delayed;\n\tassert(n < ARENA_DESTROY_MAX_DELAYED_MTX);\n\t/* Add another to the batch. */\n\tdelayed_mtx[n++] = mtx;\n\n\tif (n == ARENA_DESTROY_MAX_DELAYED_MTX) {\n\t\tarena_prepare_base_deletion_sync_finish(tsd, delayed_mtx, n);\n\t\tn = 0;\n\t}\n\t*n_delayed = n;\n}\n\nstatic void\narena_prepare_base_deletion(tsd_t *tsd, base_t *base_to_destroy) {\n\t/*\n\t * In order to coalesce, emap_try_acquire_edata_neighbor will attempt to\n\t * check neighbor edata's state to determine eligibility. This means\n\t * under certain conditions, the metadata from an arena can be accessed\n\t * w/o holding any locks from that arena. In order to guarantee safe\n\t * memory access, the metadata and the underlying base allocator needs\n\t * to be kept alive, until all pending accesses are done.\n\t *\n\t * 1) with opt_retain, the arena boundary implies the is_head state\n\t * (tracked in the rtree leaf), and the coalesce flow will stop at the\n\t * head state branch. Therefore no cross arena metadata access\n\t * possible.\n\t *\n\t * 2) w/o opt_retain, the arena id needs to be read from the edata_t,\n\t * meaning read only cross-arena metadata access is possible. The\n\t * coalesce attempt will stop at the arena_id mismatch, and is always\n\t * under one of the ecache locks. To allow safe passthrough of such\n\t * metadata accesses, the loop below will iterate through all manual\n\t * arenas' ecache locks. As all the metadata from this base allocator\n\t * have been unlinked from the rtree, after going through all the\n\t * relevant ecache locks, it's safe to say that a) pending accesses are\n\t * all finished, and b) no new access will be generated.\n\t */\n\tif (opt_retain) {\n\t\treturn;\n\t}\n\tunsigned destroy_ind = base_ind_get(base_to_destroy);\n\tassert(destroy_ind >= manual_arena_base);\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\tmalloc_mutex_t *delayed_mtx[ARENA_DESTROY_MAX_DELAYED_MTX];\n\tunsigned n_delayed = 0, total = narenas_total_get();\n\tfor (unsigned i = 0; i < total; i++) {\n\t\tif (i == destroy_ind) {\n\t\t\tcontinue;\n\t\t}\n\t\tarena_t *arena = arena_get(tsdn, i, false);\n\t\tif (arena == NULL) {\n\t\t\tcontinue;\n\t\t}\n\t\tpac_t *pac = &arena->pa_shard.pac;\n\t\tarena_prepare_base_deletion_sync(tsd, &pac->ecache_dirty.mtx,\n\t\t delayed_mtx, &n_delayed);\n\t\tarena_prepare_base_deletion_sync(tsd, &pac->ecache_muzzy.mtx,\n\t\t delayed_mtx, &n_delayed);\n\t\tarena_prepare_base_deletion_sync(tsd, &pac->ecache_retained.mtx,\n\t\t delayed_mtx, &n_delayed);\n\t}\n\tarena_prepare_base_deletion_sync_finish(tsd, delayed_mtx, n_delayed);\n}\n#undef ARENA_DESTROY_MAX_DELAYED_MTX\n\nvoid\narena_destroy(tsd_t *tsd, arena_t *arena) {\n\tassert(base_ind_get(arena->base) >= narenas_auto);\n\tassert(arena_nthreads_get(arena, false) == 0);\n\tassert(arena_nthreads_get(arena, true) == 0);\n\n\t/*\n\t * No allocations have occurred since arena_reset() was called.\n\t * Furthermore, the caller (arena_i_destroy_ctl()) purged all cached\n\t * extents, so only retained extents may remain and it's safe to call\n\t * pa_shard_destroy_retained.\n\t */\n\tpa_shard_destroy(tsd_tsdn(tsd), &arena->pa_shard);\n\n\t/*\n\t * Remove the arena pointer from the arenas array. We rely on the fact\n\t * that there is no way for the application to get a dirty read from the\n\t * arenas array unless there is an inherent race in the application\n\t * involving access of an arena being concurrently destroyed. The\n\t * application must synchronize knowledge of the arena's validity, so as\n\t * long as we use an atomic write to update the arenas array, the\n\t * application will get a clean read any time after it synchronizes\n\t * knowledge that the arena is no longer valid.\n\t */\n\tarena_set(base_ind_get(arena->base), NULL);\n\n\t/*\n\t * Destroy the base allocator, which manages all metadata ever mapped by\n\t * this arena. The prepare function will make sure no pending access to\n\t * the metadata in this base anymore.\n\t */\n\tarena_prepare_base_deletion(tsd, arena->base);\n\tbase_delete(tsd_tsdn(tsd), arena->base);\n}\n\nstatic edata_t *\narena_slab_alloc(tsdn_t *tsdn, arena_t *arena, szind_t binind, unsigned binshard,\n const bin_info_t *bin_info) {\n\tbool deferred_work_generated = false;\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tbool guarded = san_slab_extent_decide_guard(tsdn,\n\t arena_get_ehooks(arena));\n\tedata_t *slab = pa_alloc(tsdn, &arena->pa_shard, bin_info->slab_size,\n\t /* alignment */ PAGE, /* slab */ true, /* szind */ binind,\n\t /* zero */ false, guarded, &deferred_work_generated);\n\n\tif (deferred_work_generated) {\n\t\tarena_handle_deferred_work(tsdn, arena);\n\t}\n\n\tif (slab == NULL) {\n\t\treturn NULL;\n\t}\n\tassert(edata_slab_get(slab));\n\n\t/* Initialize slab internals. */\n\tslab_data_t *slab_data = edata_slab_data_get(slab);\n\tedata_nfree_binshard_set(slab, bin_info->nregs, binshard);\n\tbitmap_init(slab_data->bitmap, &bin_info->bitmap_info, false);\n\n\treturn slab;\n}\n\n/*\n * Before attempting the _with_fresh_slab approaches below, the _no_fresh_slab\n * variants (i.e. through slabcur and nonfull) must be tried first.\n */\nstatic void\narena_bin_refill_slabcur_with_fresh_slab(tsdn_t *tsdn, arena_t *arena,\n bin_t *bin, szind_t binind, edata_t *fresh_slab) {\n\tmalloc_mutex_assert_owner(tsdn, &bin->lock);\n\t/* Only called after slabcur and nonfull both failed. */\n\tassert(bin->slabcur == NULL);\n\tassert(edata_heap_first(&bin->slabs_nonfull) == NULL);\n\tassert(fresh_slab != NULL);\n\n\t/* A new slab from arena_slab_alloc() */\n\tassert(edata_nfree_get(fresh_slab) == bin_infos[binind].nregs);\n\tif (config_stats) {\n\t\tbin->stats.nslabs++;\n\t\tbin->stats.curslabs++;\n\t}\n\tbin->slabcur = fresh_slab;\n}\n\n/* Refill slabcur and then alloc using the fresh slab */\nstatic void *\narena_bin_malloc_with_fresh_slab(tsdn_t *tsdn, arena_t *arena, bin_t *bin,\n szind_t binind, edata_t *fresh_slab) {\n\tmalloc_mutex_assert_owner(tsdn, &bin->lock);\n\tarena_bin_refill_slabcur_with_fresh_slab(tsdn, arena, bin, binind,\n\t fresh_slab);\n\n\treturn arena_slab_reg_alloc(bin->slabcur, &bin_infos[binind]);\n}\n\nstatic bool\narena_bin_refill_slabcur_no_fresh_slab(tsdn_t *tsdn, arena_t *arena,\n bin_t *bin) {\n\tmalloc_mutex_assert_owner(tsdn, &bin->lock);\n\t/* Only called after arena_slab_reg_alloc[_batch] failed. */\n\tassert(bin->slabcur == NULL || edata_nfree_get(bin->slabcur) == 0);\n\n\tif (bin->slabcur != NULL) {\n\t\tarena_bin_slabs_full_insert(arena, bin, bin->slabcur);\n\t}\n\n\t/* Look for a usable slab. */\n\tbin->slabcur = arena_bin_slabs_nonfull_tryget(bin);\n\tassert(bin->slabcur == NULL || edata_nfree_get(bin->slabcur) > 0);\n\n\treturn (bin->slabcur == NULL);\n}\n\nbin_t *\narena_bin_choose(tsdn_t *tsdn, arena_t *arena, szind_t binind,\n unsigned *binshard_p) {\n\tunsigned binshard;\n\tif (tsdn_null(tsdn) || tsd_arena_get(tsdn_tsd(tsdn)) == NULL) {\n\t\tbinshard = 0;\n\t} else {\n\t\tbinshard = tsd_binshardsp_get(tsdn_tsd(tsdn))->binshard[binind];\n\t}\n\tassert(binshard < bin_infos[binind].n_shards);\n\tif (binshard_p != NULL) {\n\t\t*binshard_p = binshard;\n\t}\n\treturn arena_get_bin(arena, binind, binshard);\n}\n\nvoid\narena_cache_bin_fill_small(tsdn_t *tsdn, arena_t *arena,\n cache_bin_t *cache_bin, cache_bin_info_t *cache_bin_info, szind_t binind,\n const unsigned nfill) {\n\tassert(cache_bin_ncached_get_local(cache_bin, cache_bin_info) == 0);\n\n\tconst bin_info_t *bin_info = &bin_infos[binind];\n\n\tCACHE_BIN_PTR_ARRAY_DECLARE(ptrs, nfill);\n\tcache_bin_init_ptr_array_for_fill(cache_bin, cache_bin_info, &ptrs,\n\t nfill);\n\t/*\n\t * Bin-local resources are used first: 1) bin->slabcur, and 2) nonfull\n\t * slabs. After both are exhausted, new slabs will be allocated through\n\t * arena_slab_alloc().\n\t *\n\t * Bin lock is only taken / released right before / after the while(...)\n\t * refill loop, with new slab allocation (which has its own locking)\n\t * kept outside of the loop. This setup facilitates flat combining, at\n\t * the cost of the nested loop (through goto label_refill).\n\t *\n\t * To optimize for cases with contention and limited resources\n\t * (e.g. hugepage-backed or non-overcommit arenas), each fill-iteration\n\t * gets one chance of slab_alloc, and a retry of bin local resources\n\t * after the slab allocation (regardless if slab_alloc failed, because\n\t * the bin lock is dropped during the slab allocation).\n\t *\n\t * In other words, new slab allocation is allowed, as long as there was\n\t * progress since the previous slab_alloc. This is tracked with\n\t * made_progress below, initialized to true to jump start the first\n\t * iteration.\n\t *\n\t * In other words (again), the loop will only terminate early (i.e. stop\n\t * with filled < nfill) after going through the three steps: a) bin\n\t * local exhausted, b) unlock and slab_alloc returns null, c) re-lock\n\t * and bin local fails again.\n\t */\n\tbool made_progress = true;\n\tedata_t *fresh_slab = NULL;\n\tbool alloc_and_retry = false;\n\tunsigned filled = 0;\n\tunsigned binshard;\n\tbin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);\n\nlabel_refill:\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\n\twhile (filled < nfill) {\n\t\t/* Try batch-fill from slabcur first. */\n\t\tedata_t *slabcur = bin->slabcur;\n\t\tif (slabcur != NULL && edata_nfree_get(slabcur) > 0) {\n\t\t\tunsigned tofill = nfill - filled;\n\t\t\tunsigned nfree = edata_nfree_get(slabcur);\n\t\t\tunsigned cnt = tofill < nfree ? tofill : nfree;\n\n\t\t\tarena_slab_reg_alloc_batch(slabcur, bin_info, cnt,\n\t\t\t &ptrs.ptr[filled]);\n\t\t\tmade_progress = true;\n\t\t\tfilled += cnt;\n\t\t\tcontinue;\n\t\t}\n\t\t/* Next try refilling slabcur from nonfull slabs. */\n\t\tif (!arena_bin_refill_slabcur_no_fresh_slab(tsdn, arena, bin)) {\n\t\t\tassert(bin->slabcur != NULL);\n\t\t\tcontinue;\n\t\t}\n\n\t\t/* Then see if a new slab was reserved already. */\n\t\tif (fresh_slab != NULL) {\n\t\t\tarena_bin_refill_slabcur_with_fresh_slab(tsdn, arena,\n\t\t\t bin, binind, fresh_slab);\n\t\t\tassert(bin->slabcur != NULL);\n\t\t\tfresh_slab = NULL;\n\t\t\tcontinue;\n\t\t}\n\n\t\t/* Try slab_alloc if made progress (or never did slab_alloc). */\n\t\tif (made_progress) {\n\t\t\tassert(bin->slabcur == NULL);\n\t\t\tassert(fresh_slab == NULL);\n\t\t\talloc_and_retry = true;\n\t\t\t/* Alloc a new slab then come back. */\n\t\t\tbreak;\n\t\t}\n\n\t\t/* OOM. */\n\n\t\tassert(fresh_slab == NULL);\n\t\tassert(!alloc_and_retry);\n\t\tbreak;\n\t} /* while (filled < nfill) loop. */\n\n\tif (config_stats && !alloc_and_retry) {\n\t\tbin->stats.nmalloc += filled;\n\t\tbin->stats.nrequests += cache_bin->tstats.nrequests;\n\t\tbin->stats.curregs += filled;\n\t\tbin->stats.nfills++;\n\t\tcache_bin->tstats.nrequests = 0;\n\t}\n\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\n\tif (alloc_and_retry) {\n\t\tassert(fresh_slab == NULL);\n\t\tassert(filled < nfill);\n\t\tassert(made_progress);\n\n\t\tfresh_slab = arena_slab_alloc(tsdn, arena, binind, binshard,\n\t\t bin_info);\n\t\t/* fresh_slab NULL case handled in the for loop. */\n\n\t\talloc_and_retry = false;\n\t\tmade_progress = false;\n\t\tgoto label_refill;\n\t}\n\tassert(filled == nfill || (fresh_slab == NULL && !made_progress));\n\n\t/* Release if allocated but not used. */\n\tif (fresh_slab != NULL) {\n\t\tassert(edata_nfree_get(fresh_slab) == bin_info->nregs);\n\t\tarena_slab_dalloc(tsdn, arena, fresh_slab);\n\t\tfresh_slab = NULL;\n\t}\n\n\tcache_bin_finish_fill(cache_bin, cache_bin_info, &ptrs, filled);\n\tarena_decay_tick(tsdn, arena);\n}\n\nsize_t\narena_fill_small_fresh(tsdn_t *tsdn, arena_t *arena, szind_t binind,\n void **ptrs, size_t nfill, bool zero) {\n\tassert(binind < SC_NBINS);\n\tconst bin_info_t *bin_info = &bin_infos[binind];\n\tconst size_t nregs = bin_info->nregs;\n\tassert(nregs > 0);\n\tconst size_t usize = bin_info->reg_size;\n\n\tconst bool manual_arena = !arena_is_auto(arena);\n\tunsigned binshard;\n\tbin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);\n\n\tsize_t nslab = 0;\n\tsize_t filled = 0;\n\tedata_t *slab = NULL;\n\tedata_list_active_t fulls;\n\tedata_list_active_init(&fulls);\n\n\twhile (filled < nfill && (slab = arena_slab_alloc(tsdn, arena, binind,\n\t binshard, bin_info)) != NULL) {\n\t\tassert((size_t)edata_nfree_get(slab) == nregs);\n\t\t++nslab;\n\t\tsize_t batch = nfill - filled;\n\t\tif (batch > nregs) {\n\t\t\tbatch = nregs;\n\t\t}\n\t\tassert(batch > 0);\n\t\tarena_slab_reg_alloc_batch(slab, bin_info, (unsigned)batch,\n\t\t &ptrs[filled]);\n\t\tassert(edata_addr_get(slab) == ptrs[filled]);\n\t\tif (zero) {\n\t\t\tmemset(ptrs[filled], 0, batch * usize);\n\t\t}\n\t\tfilled += batch;\n\t\tif (batch == nregs) {\n\t\t\tif (manual_arena) {\n\t\t\t\tedata_list_active_append(&fulls, slab);\n\t\t\t}\n\t\t\tslab = NULL;\n\t\t}\n\t}\n\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\t/*\n\t * Only the last slab can be non-empty, and the last slab is non-empty\n\t * iff slab != NULL.\n\t */\n\tif (slab != NULL) {\n\t\tarena_bin_lower_slab(tsdn, arena, slab, bin);\n\t}\n\tif (manual_arena) {\n\t\tedata_list_active_concat(&bin->slabs_full, &fulls);\n\t}\n\tassert(edata_list_active_empty(&fulls));\n\tif (config_stats) {\n\t\tbin->stats.nslabs += nslab;\n\t\tbin->stats.curslabs += nslab;\n\t\tbin->stats.nmalloc += filled;\n\t\tbin->stats.nrequests += filled;\n\t\tbin->stats.curregs += filled;\n\t}\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\n\tarena_decay_tick(tsdn, arena);\n\treturn filled;\n}\n\n/*\n * Without allocating a new slab, try arena_slab_reg_alloc() and re-fill\n * bin->slabcur if necessary.\n */\nstatic void *\narena_bin_malloc_no_fresh_slab(tsdn_t *tsdn, arena_t *arena, bin_t *bin,\n szind_t binind) {\n\tmalloc_mutex_assert_owner(tsdn, &bin->lock);\n\tif (bin->slabcur == NULL || edata_nfree_get(bin->slabcur) == 0) {\n\t\tif (arena_bin_refill_slabcur_no_fresh_slab(tsdn, arena, bin)) {\n\t\t\treturn NULL;\n\t\t}\n\t}\n\n\tassert(bin->slabcur != NULL && edata_nfree_get(bin->slabcur) > 0);\n\treturn arena_slab_reg_alloc(bin->slabcur, &bin_infos[binind]);\n}\n\nstatic void *\narena_malloc_small(tsdn_t *tsdn, arena_t *arena, szind_t binind, bool zero) {\n\tassert(binind < SC_NBINS);\n\tconst bin_info_t *bin_info = &bin_infos[binind];\n\tsize_t usize = sz_index2size(binind);\n\tunsigned binshard;\n\tbin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);\n\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\tedata_t *fresh_slab = NULL;\n\tvoid *ret = arena_bin_malloc_no_fresh_slab(tsdn, arena, bin, binind);\n\tif (ret == NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\t\t/******************************/\n\t\tfresh_slab = arena_slab_alloc(tsdn, arena, binind, binshard,\n\t\t bin_info);\n\t\t/********************************/\n\t\tmalloc_mutex_lock(tsdn, &bin->lock);\n\t\t/* Retry since the lock was dropped. */\n\t\tret = arena_bin_malloc_no_fresh_slab(tsdn, arena, bin, binind);\n\t\tif (ret == NULL) {\n\t\t\tif (fresh_slab == NULL) {\n\t\t\t\t/* OOM */\n\t\t\t\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\t\t\t\treturn NULL;\n\t\t\t}\n\t\t\tret = arena_bin_malloc_with_fresh_slab(tsdn, arena, bin,\n\t\t\t binind, fresh_slab);\n\t\t\tfresh_slab = NULL;\n\t\t}\n\t}\n\tif (config_stats) {\n\t\tbin->stats.nmalloc++;\n\t\tbin->stats.nrequests++;\n\t\tbin->stats.curregs++;\n\t}\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\n\tif (fresh_slab != NULL) {\n\t\tarena_slab_dalloc(tsdn, arena, fresh_slab);\n\t}\n\tif (zero) {\n\t\tmemset(ret, 0, usize);\n\t}\n\tarena_decay_tick(tsdn, arena);\n\n\treturn ret;\n}\n\nvoid *\narena_malloc_hard(tsdn_t *tsdn, arena_t *arena, size_t size, szind_t ind,\n bool zero) {\n\tassert(!tsdn_null(tsdn) || arena != NULL);\n\n\tif (likely(!tsdn_null(tsdn))) {\n\t\tarena = arena_choose_maybe_huge(tsdn_tsd(tsdn), arena, size);\n\t}\n\tif (unlikely(arena == NULL)) {\n\t\treturn NULL;\n\t}\n\n\tif (likely(size <= SC_SMALL_MAXCLASS)) {\n\t\treturn arena_malloc_small(tsdn, arena, ind, zero);\n\t}\n\treturn large_malloc(tsdn, arena, sz_index2size(ind), zero);\n}\n\nvoid *\narena_palloc(tsdn_t *tsdn, arena_t *arena, size_t usize, size_t alignment,\n bool zero, tcache_t *tcache) {\n\tvoid *ret;\n\n\tif (usize <= SC_SMALL_MAXCLASS) {\n\t\t/* Small; alignment doesn't require special slab placement. */\n\n\t\t/* usize should be a result of sz_sa2u() */\n\t\tassert((usize & (alignment - 1)) == 0);\n\n\t\t/*\n\t\t * Small usize can't come from an alignment larger than a page.\n\t\t */\n\t\tassert(alignment <= PAGE);\n\n\t\tret = arena_malloc(tsdn, arena, usize, sz_size2index(usize),\n\t\t zero, tcache, true);\n\t} else {\n\t\tif (likely(alignment <= CACHELINE)) {\n\t\t\tret = large_malloc(tsdn, arena, usize, zero);\n\t\t} else {\n\t\t\tret = large_palloc(tsdn, arena, usize, alignment, zero);\n\t\t}\n\t}\n\treturn ret;\n}\n\nvoid\narena_prof_promote(tsdn_t *tsdn, void *ptr, size_t usize) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\tassert(isalloc(tsdn, ptr) == SC_LARGE_MINCLASS);\n\tassert(usize <= SC_SMALL_MAXCLASS);\n\n\tif (config_opt_safety_checks) {\n\t\tsafety_check_set_redzone(ptr, usize, SC_LARGE_MINCLASS);\n\t}\n\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\n\tszind_t szind = sz_size2index(usize);\n\tedata_szind_set(edata, szind);\n\temap_remap(tsdn, &arena_emap_global, edata, szind, /* slab */ false);\n\n\tassert(isalloc(tsdn, ptr) == usize);\n}\n\nstatic size_t\narena_prof_demote(tsdn_t *tsdn, edata_t *edata, const void *ptr) {\n\tcassert(config_prof);\n\tassert(ptr != NULL);\n\n\tedata_szind_set(edata, SC_NBINS);\n\temap_remap(tsdn, &arena_emap_global, edata, SC_NBINS, /* slab */ false);\n\n\tassert(isalloc(tsdn, ptr) == SC_LARGE_MINCLASS);\n\n\treturn SC_LARGE_MINCLASS;\n}\n\nvoid\narena_dalloc_promoted(tsdn_t *tsdn, void *ptr, tcache_t *tcache,\n bool slow_path) {\n\tcassert(config_prof);\n\tassert(opt_prof);\n\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tsize_t usize = edata_usize_get(edata);\n\tsize_t bumped_usize = arena_prof_demote(tsdn, edata, ptr);\n\tif (config_opt_safety_checks && usize < SC_LARGE_MINCLASS) {\n\t\t/*\n\t\t * Currently, we only do redzoning for small sampled\n\t\t * allocations.\n\t\t */\n\t\tassert(bumped_usize == SC_LARGE_MINCLASS);\n\t\tsafety_check_verify_redzone(ptr, usize, bumped_usize);\n\t}\n\tif (bumped_usize <= tcache_maxclass && tcache != NULL) {\n\t\ttcache_dalloc_large(tsdn_tsd(tsdn), tcache, ptr,\n\t\t sz_size2index(bumped_usize), slow_path);\n\t} else {\n\t\tlarge_dalloc(tsdn, edata);\n\t}\n}\n\nstatic void\narena_dissociate_bin_slab(arena_t *arena, edata_t *slab, bin_t *bin) {\n\t/* Dissociate slab from bin. */\n\tif (slab == bin->slabcur) {\n\t\tbin->slabcur = NULL;\n\t} else {\n\t\tszind_t binind = edata_szind_get(slab);\n\t\tconst bin_info_t *bin_info = &bin_infos[binind];\n\n\t\t/*\n\t\t * The following block's conditional is necessary because if the\n\t\t * slab only contains one region, then it never gets inserted\n\t\t * into the non-full slabs heap.\n\t\t */\n\t\tif (bin_info->nregs == 1) {\n\t\t\tarena_bin_slabs_full_remove(arena, bin, slab);\n\t\t} else {\n\t\t\tarena_bin_slabs_nonfull_remove(bin, slab);\n\t\t}\n\t}\n}\n\nstatic void\narena_bin_lower_slab(tsdn_t *tsdn, arena_t *arena, edata_t *slab,\n bin_t *bin) {\n\tassert(edata_nfree_get(slab) > 0);\n\n\t/*\n\t * Make sure that if bin->slabcur is non-NULL, it refers to the\n\t * oldest/lowest non-full slab. It is okay to NULL slabcur out rather\n\t * than proactively keeping it pointing at the oldest/lowest non-full\n\t * slab.\n\t */\n\tif (bin->slabcur != NULL && edata_snad_comp(bin->slabcur, slab) > 0) {\n\t\t/* Switch slabcur. */\n\t\tif (edata_nfree_get(bin->slabcur) > 0) {\n\t\t\tarena_bin_slabs_nonfull_insert(bin, bin->slabcur);\n\t\t} else {\n\t\t\tarena_bin_slabs_full_insert(arena, bin, bin->slabcur);\n\t\t}\n\t\tbin->slabcur = slab;\n\t\tif (config_stats) {\n\t\t\tbin->stats.reslabs++;\n\t\t}\n\t} else {\n\t\tarena_bin_slabs_nonfull_insert(bin, slab);\n\t}\n}\n\nstatic void\narena_dalloc_bin_slab_prepare(tsdn_t *tsdn, edata_t *slab, bin_t *bin) {\n\tmalloc_mutex_assert_owner(tsdn, &bin->lock);\n\n\tassert(slab != bin->slabcur);\n\tif (config_stats) {\n\t\tbin->stats.curslabs--;\n\t}\n}\n\nvoid\narena_dalloc_bin_locked_handle_newly_empty(tsdn_t *tsdn, arena_t *arena,\n edata_t *slab, bin_t *bin) {\n\tarena_dissociate_bin_slab(arena, slab, bin);\n\tarena_dalloc_bin_slab_prepare(tsdn, slab, bin);\n}\n\nvoid\narena_dalloc_bin_locked_handle_newly_nonempty(tsdn_t *tsdn, arena_t *arena,\n edata_t *slab, bin_t *bin) {\n\tarena_bin_slabs_full_remove(arena, bin, slab);\n\tarena_bin_lower_slab(tsdn, arena, slab, bin);\n}\n\nstatic void\narena_dalloc_bin(tsdn_t *tsdn, arena_t *arena, edata_t *edata, void *ptr) {\n\tszind_t binind = edata_szind_get(edata);\n\tunsigned binshard = edata_binshard_get(edata);\n\tbin_t *bin = arena_get_bin(arena, binind, binshard);\n\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\tarena_dalloc_bin_locked_info_t info;\n\tarena_dalloc_bin_locked_begin(&info, binind);\n\tbool ret = arena_dalloc_bin_locked_step(tsdn, arena, bin,\n\t &info, binind, edata, ptr);\n\tarena_dalloc_bin_locked_finish(tsdn, arena, bin, &info);\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\n\tif (ret) {\n\t\tarena_slab_dalloc(tsdn, arena, edata);\n\t}\n}\n\nvoid\narena_dalloc_small(tsdn_t *tsdn, void *ptr) {\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tarena_t *arena = arena_get_from_edata(edata);\n\n\tarena_dalloc_bin(tsdn, arena, edata, ptr);\n\tarena_decay_tick(tsdn, arena);\n}\n\nbool\narena_ralloc_no_move(tsdn_t *tsdn, void *ptr, size_t oldsize, size_t size,\n size_t extra, bool zero, size_t *newsize) {\n\tbool ret;\n\t/* Calls with non-zero extra had to clamp extra. */\n\tassert(extra == 0 || size + extra <= SC_LARGE_MAXCLASS);\n\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tif (unlikely(size > SC_LARGE_MAXCLASS)) {\n\t\tret = true;\n\t\tgoto done;\n\t}\n\n\tsize_t usize_min = sz_s2u(size);\n\tsize_t usize_max = sz_s2u(size + extra);\n\tif (likely(oldsize <= SC_SMALL_MAXCLASS && usize_min\n\t <= SC_SMALL_MAXCLASS)) {\n\t\t/*\n\t\t * Avoid moving the allocation if the size class can be left the\n\t\t * same.\n\t\t */\n\t\tassert(bin_infos[sz_size2index(oldsize)].reg_size ==\n\t\t oldsize);\n\t\tif ((usize_max > SC_SMALL_MAXCLASS\n\t\t || sz_size2index(usize_max) != sz_size2index(oldsize))\n\t\t && (size > oldsize || usize_max < oldsize)) {\n\t\t\tret = true;\n\t\t\tgoto done;\n\t\t}\n\n\t\tarena_t *arena = arena_get_from_edata(edata);\n\t\tarena_decay_tick(tsdn, arena);\n\t\tret = false;\n\t} else if (oldsize >= SC_LARGE_MINCLASS\n\t && usize_max >= SC_LARGE_MINCLASS) {\n\t\tret = large_ralloc_no_move(tsdn, edata, usize_min, usize_max,\n\t\t zero);\n\t} else {\n\t\tret = true;\n\t}\ndone:\n\tassert(edata == emap_edata_lookup(tsdn, &arena_emap_global, ptr));\n\t*newsize = edata_usize_get(edata);\n\n\treturn ret;\n}\n\nstatic void *\narena_ralloc_move_helper(tsdn_t *tsdn, arena_t *arena, size_t usize,\n size_t alignment, bool zero, tcache_t *tcache) {\n\tif (alignment == 0) {\n\t\treturn arena_malloc(tsdn, arena, usize, sz_size2index(usize),\n\t\t zero, tcache, true);\n\t}\n\tusize = sz_sa2u(usize, alignment);\n\tif (unlikely(usize == 0 || usize > SC_LARGE_MAXCLASS)) {\n\t\treturn NULL;\n\t}\n\treturn ipalloct(tsdn, usize, alignment, zero, tcache, arena);\n}\n\nvoid *\narena_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize,\n size_t size, size_t alignment, bool zero, tcache_t *tcache,\n hook_ralloc_args_t *hook_args) {\n\tsize_t usize = alignment == 0 ? sz_s2u(size) : sz_sa2u(size, alignment);\n\tif (unlikely(usize == 0 || size > SC_LARGE_MAXCLASS)) {\n\t\treturn NULL;\n\t}\n\n\tif (likely(usize <= SC_SMALL_MAXCLASS)) {\n\t\t/* Try to avoid moving the allocation. */\n\t\tUNUSED size_t newsize;\n\t\tif (!arena_ralloc_no_move(tsdn, ptr, oldsize, usize, 0, zero,\n\t\t &newsize)) {\n\t\t\thook_invoke_expand(hook_args->is_realloc\n\t\t\t ? hook_expand_realloc : hook_expand_rallocx,\n\t\t\t ptr, oldsize, usize, (uintptr_t)ptr,\n\t\t\t hook_args->args);\n\t\t\treturn ptr;\n\t\t}\n\t}\n\n\tif (oldsize >= SC_LARGE_MINCLASS\n\t && usize >= SC_LARGE_MINCLASS) {\n\t\treturn large_ralloc(tsdn, arena, ptr, usize,\n\t\t alignment, zero, tcache, hook_args);\n\t}\n\n\t/*\n\t * size and oldsize are different enough that we need to move the\n\t * object. In that case, fall back to allocating new space and copying.\n\t */\n\tvoid *ret = arena_ralloc_move_helper(tsdn, arena, usize, alignment,\n\t zero, tcache);\n\tif (ret == NULL) {\n\t\treturn NULL;\n\t}\n\n\thook_invoke_alloc(hook_args->is_realloc\n\t ? hook_alloc_realloc : hook_alloc_rallocx, ret, (uintptr_t)ret,\n\t hook_args->args);\n\thook_invoke_dalloc(hook_args->is_realloc\n\t ? hook_dalloc_realloc : hook_dalloc_rallocx, ptr, hook_args->args);\n\n\t/*\n\t * Junk/zero-filling were already done by\n\t * ipalloc()/arena_malloc().\n\t */\n\tsize_t copysize = (usize < oldsize) ? usize : oldsize;\n\tmemcpy(ret, ptr, copysize);\n\tisdalloct(tsdn, ptr, oldsize, tcache, NULL, true);\n\treturn ret;\n}\n\nehooks_t *\narena_get_ehooks(arena_t *arena) {\n\treturn base_ehooks_get(arena->base);\n}\n\nextent_hooks_t *\narena_set_extent_hooks(tsd_t *tsd, arena_t *arena,\n extent_hooks_t *extent_hooks) {\n\tbackground_thread_info_t *info;\n\tif (have_background_thread) {\n\t\tinfo = arena_background_thread_info_get(arena);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t}\n\t/* No using the HPA now that we have the custom hooks. */\n\tpa_shard_disable_hpa(tsd_tsdn(tsd), &arena->pa_shard);\n\textent_hooks_t *ret = base_extent_hooks_set(arena->base, extent_hooks);\n\tif (have_background_thread) {\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t}\n\n\treturn ret;\n}\n\ndss_prec_t\narena_dss_prec_get(arena_t *arena) {\n\treturn (dss_prec_t)atomic_load_u(&arena->dss_prec, ATOMIC_ACQUIRE);\n}\n\nbool\narena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec) {\n\tif (!have_dss) {\n\t\treturn (dss_prec != dss_prec_disabled);\n\t}\n\tatomic_store_u(&arena->dss_prec, (unsigned)dss_prec, ATOMIC_RELEASE);\n\treturn false;\n}\n\nssize_t\narena_dirty_decay_ms_default_get(void) {\n\treturn atomic_load_zd(&dirty_decay_ms_default, ATOMIC_RELAXED);\n}\n\nbool\narena_dirty_decay_ms_default_set(ssize_t decay_ms) {\n\tif (!decay_ms_valid(decay_ms)) {\n\t\treturn true;\n\t}\n\tatomic_store_zd(&dirty_decay_ms_default, decay_ms, ATOMIC_RELAXED);\n\treturn false;\n}\n\nssize_t\narena_muzzy_decay_ms_default_get(void) {\n\treturn atomic_load_zd(&muzzy_decay_ms_default, ATOMIC_RELAXED);\n}\n\nbool\narena_muzzy_decay_ms_default_set(ssize_t decay_ms) {\n\tif (!decay_ms_valid(decay_ms)) {\n\t\treturn true;\n\t}\n\tatomic_store_zd(&muzzy_decay_ms_default, decay_ms, ATOMIC_RELAXED);\n\treturn false;\n}\n\nbool\narena_retain_grow_limit_get_set(tsd_t *tsd, arena_t *arena, size_t *old_limit,\n size_t *new_limit) {\n\tassert(opt_retain);\n\treturn pac_retain_grow_limit_get_set(tsd_tsdn(tsd),\n\t &arena->pa_shard.pac, old_limit, new_limit);\n}\n\nunsigned\narena_nthreads_get(arena_t *arena, bool internal) {\n\treturn atomic_load_u(&arena->nthreads[internal], ATOMIC_RELAXED);\n}\n\nvoid\narena_nthreads_inc(arena_t *arena, bool internal) {\n\tatomic_fetch_add_u(&arena->nthreads[internal], 1, ATOMIC_RELAXED);\n}\n\nvoid\narena_nthreads_dec(arena_t *arena, bool internal) {\n\tatomic_fetch_sub_u(&arena->nthreads[internal], 1, ATOMIC_RELAXED);\n}\n\narena_t *\narena_new(tsdn_t *tsdn, unsigned ind, const arena_config_t *config) {\n\tarena_t *arena;\n\tbase_t *base;\n\tunsigned i;\n\n\tif (ind == 0) {\n\t\tbase = b0get();\n\t} else {\n\t\tbase = base_new(tsdn, ind, config->extent_hooks,\n\t\t config->metadata_use_hooks);\n\t\tif (base == NULL) {\n\t\t\treturn NULL;\n\t\t}\n\t}\n\n\tsize_t arena_size = sizeof(arena_t) + sizeof(bin_t) * nbins_total;\n\tarena = (arena_t *)base_alloc(tsdn, base, arena_size, CACHELINE);\n\tif (arena == NULL) {\n\t\tgoto label_error;\n\t}\n\n\tatomic_store_u(&arena->nthreads[0], 0, ATOMIC_RELAXED);\n\tatomic_store_u(&arena->nthreads[1], 0, ATOMIC_RELAXED);\n\tarena->last_thd = NULL;\n\n\tif (config_stats) {\n\t\tif (arena_stats_init(tsdn, &arena->stats)) {\n\t\t\tgoto label_error;\n\t\t}\n\n\t\tql_new(&arena->tcache_ql);\n\t\tql_new(&arena->cache_bin_array_descriptor_ql);\n\t\tif (malloc_mutex_init(&arena->tcache_ql_mtx, \"tcache_ql\",\n\t\t WITNESS_RANK_TCACHE_QL, malloc_mutex_rank_exclusive)) {\n\t\t\tgoto label_error;\n\t\t}\n\t}\n\n\tatomic_store_u(&arena->dss_prec, (unsigned)extent_dss_prec_get(),\n\t ATOMIC_RELAXED);\n\n\tedata_list_active_init(&arena->large);\n\tif (malloc_mutex_init(&arena->large_mtx, \"arena_large\",\n\t WITNESS_RANK_ARENA_LARGE, malloc_mutex_rank_exclusive)) {\n\t\tgoto label_error;\n\t}\n\n\tnstime_t cur_time;\n\tnstime_init_update(&cur_time);\n\tif (pa_shard_init(tsdn, &arena->pa_shard, &arena_pa_central_global,\n\t &arena_emap_global, base, ind, &arena->stats.pa_shard_stats,\n\t LOCKEDINT_MTX(arena->stats.mtx), &cur_time, oversize_threshold,\n\t arena_dirty_decay_ms_default_get(),\n\t arena_muzzy_decay_ms_default_get())) {\n\t\tgoto label_error;\n\t}\n\n\t/* Initialize bins. */\n\tatomic_store_u(&arena->binshard_next, 0, ATOMIC_RELEASE);\n\tfor (i = 0; i < nbins_total; i++) {\n\t\tbool err = bin_init(&arena->bins[i]);\n\t\tif (err) {\n\t\t\tgoto label_error;\n\t\t}\n\t}\n\n\tarena->base = base;\n\t/* Set arena before creating background threads. */\n\tarena_set(ind, arena);\n\tarena->ind = ind;\n\n\tnstime_init_update(&arena->create_time);\n\n\t/*\n\t * We turn on the HPA if set to. There are two exceptions:\n\t * - Custom extent hooks (we should only return memory allocated from\n\t * them in that case).\n\t * - Arena 0 initialization. In this case, we're mid-bootstrapping, and\n\t * so arena_hpa_global is not yet initialized.\n\t */\n\tif (opt_hpa && ehooks_are_default(base_ehooks_get(base)) && ind != 0) {\n\t\thpa_shard_opts_t hpa_shard_opts = opt_hpa_opts;\n\t\thpa_shard_opts.deferral_allowed = background_thread_enabled();\n\t\tif (pa_shard_enable_hpa(tsdn, &arena->pa_shard,\n\t\t &hpa_shard_opts, &opt_hpa_sec_opts)) {\n\t\t\tgoto label_error;\n\t\t}\n\t}\n\n\t/* We don't support reentrancy for arena 0 bootstrapping. */\n\tif (ind != 0) {\n\t\t/*\n\t\t * If we're here, then arena 0 already exists, so bootstrapping\n\t\t * is done enough that we should have tsd.\n\t\t */\n\t\tassert(!tsdn_null(tsdn));\n\t\tpre_reentrancy(tsdn_tsd(tsdn), arena);\n\t\tif (test_hooks_arena_new_hook) {\n\t\t\ttest_hooks_arena_new_hook();\n\t\t}\n\t\tpost_reentrancy(tsdn_tsd(tsdn));\n\t}\n\n\treturn arena;\nlabel_error:\n\tif (ind != 0) {\n\t\tbase_delete(tsdn, base);\n\t}\n\treturn NULL;\n}\n\narena_t *\narena_choose_huge(tsd_t *tsd) {\n\t/* huge_arena_ind can be 0 during init (will use a0). */\n\tif (huge_arena_ind == 0) {\n\t\tassert(!malloc_initialized());\n\t}\n\n\tarena_t *huge_arena = arena_get(tsd_tsdn(tsd), huge_arena_ind, false);\n\tif (huge_arena == NULL) {\n\t\t/* Create the huge arena on demand. */\n\t\tassert(huge_arena_ind != 0);\n\t\thuge_arena = arena_get(tsd_tsdn(tsd), huge_arena_ind, true);\n\t\tif (huge_arena == NULL) {\n\t\t\treturn NULL;\n\t\t}\n\t\t/*\n\t\t * Purge eagerly for huge allocations, because: 1) number of\n\t\t * huge allocations is usually small, which means ticker based\n\t\t * decay is not reliable; and 2) less immediate reuse is\n\t\t * expected for huge allocations.\n\t\t */\n\t\tif (arena_dirty_decay_ms_default_get() > 0) {\n\t\t\tarena_decay_ms_set(tsd_tsdn(tsd), huge_arena,\n\t\t\t extent_state_dirty, 0);\n\t\t}\n\t\tif (arena_muzzy_decay_ms_default_get() > 0) {\n\t\t\tarena_decay_ms_set(tsd_tsdn(tsd), huge_arena,\n\t\t\t extent_state_muzzy, 0);\n\t\t}\n\t}\n\n\treturn huge_arena;\n}\n\nbool\narena_init_huge(void) {\n\tbool huge_enabled;\n\n\t/* The threshold should be large size class. */\n\tif (opt_oversize_threshold > SC_LARGE_MAXCLASS ||\n\t opt_oversize_threshold < SC_LARGE_MINCLASS) {\n\t\topt_oversize_threshold = 0;\n\t\toversize_threshold = SC_LARGE_MAXCLASS + PAGE;\n\t\thuge_enabled = false;\n\t} else {\n\t\t/* Reserve the index for the huge arena. */\n\t\thuge_arena_ind = narenas_total_get();\n\t\toversize_threshold = opt_oversize_threshold;\n\t\thuge_enabled = true;\n\t}\n\n\treturn huge_enabled;\n}\n\nbool\narena_is_huge(unsigned arena_ind) {\n\tif (huge_arena_ind == 0) {\n\t\treturn false;\n\t}\n\treturn (arena_ind == huge_arena_ind);\n}\n\nbool\narena_boot(sc_data_t *sc_data, base_t *base, bool hpa) {\n\tarena_dirty_decay_ms_default_set(opt_dirty_decay_ms);\n\tarena_muzzy_decay_ms_default_set(opt_muzzy_decay_ms);\n\tfor (unsigned i = 0; i < SC_NBINS; i++) {\n\t\tsc_t *sc = &sc_data->sc[i];\n\t\tdiv_init(&arena_binind_div_info[i],\n\t\t (1U << sc->lg_base) + (sc->ndelta << sc->lg_delta));\n\t}\n\n\tuint32_t cur_offset = (uint32_t)offsetof(arena_t, bins);\n\tfor (szind_t i = 0; i < SC_NBINS; i++) {\n\t\tarena_bin_offsets[i] = cur_offset;\n\t\tnbins_total += bin_infos[i].n_shards;\n\t\tcur_offset += (uint32_t)(bin_infos[i].n_shards * sizeof(bin_t));\n\t}\n\treturn pa_central_init(&arena_pa_central_global, base, hpa,\n\t &hpa_hooks_default);\n}\n\nvoid\narena_prefork0(tsdn_t *tsdn, arena_t *arena) {\n\tpa_shard_prefork0(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_prefork1(tsdn_t *tsdn, arena_t *arena) {\n\tif (config_stats) {\n\t\tmalloc_mutex_prefork(tsdn, &arena->tcache_ql_mtx);\n\t}\n}\n\nvoid\narena_prefork2(tsdn_t *tsdn, arena_t *arena) {\n\tpa_shard_prefork2(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_prefork3(tsdn_t *tsdn, arena_t *arena) {\n\tpa_shard_prefork3(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_prefork4(tsdn_t *tsdn, arena_t *arena) {\n\tpa_shard_prefork4(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_prefork5(tsdn_t *tsdn, arena_t *arena) {\n\tpa_shard_prefork5(tsdn, &arena->pa_shard);\n}\n\nvoid\narena_prefork6(tsdn_t *tsdn, arena_t *arena) {\n\tbase_prefork(tsdn, arena->base);\n}\n\nvoid\narena_prefork7(tsdn_t *tsdn, arena_t *arena) {\n\tmalloc_mutex_prefork(tsdn, &arena->large_mtx);\n}\n\nvoid\narena_prefork8(tsdn_t *tsdn, arena_t *arena) {\n\tfor (unsigned i = 0; i < nbins_total; i++) {\n\t\tbin_prefork(tsdn, &arena->bins[i]);\n\t}\n}\n\nvoid\narena_postfork_parent(tsdn_t *tsdn, arena_t *arena) {\n\tfor (unsigned i = 0; i < nbins_total; i++) {\n\t\tbin_postfork_parent(tsdn, &arena->bins[i]);\n\t}\n\n\tmalloc_mutex_postfork_parent(tsdn, &arena->large_mtx);\n\tbase_postfork_parent(tsdn, arena->base);\n\tpa_shard_postfork_parent(tsdn, &arena->pa_shard);\n\tif (config_stats) {\n\t\tmalloc_mutex_postfork_parent(tsdn, &arena->tcache_ql_mtx);\n\t}\n}\n\nvoid\narena_postfork_child(tsdn_t *tsdn, arena_t *arena) {\n\tatomic_store_u(&arena->nthreads[0], 0, ATOMIC_RELAXED);\n\tatomic_store_u(&arena->nthreads[1], 0, ATOMIC_RELAXED);\n\tif (tsd_arena_get(tsdn_tsd(tsdn)) == arena) {\n\t\tarena_nthreads_inc(arena, false);\n\t}\n\tif (tsd_iarena_get(tsdn_tsd(tsdn)) == arena) {\n\t\tarena_nthreads_inc(arena, true);\n\t}\n\tif (config_stats) {\n\t\tql_new(&arena->tcache_ql);\n\t\tql_new(&arena->cache_bin_array_descriptor_ql);\n\t\ttcache_slow_t *tcache_slow = tcache_slow_get(tsdn_tsd(tsdn));\n\t\tif (tcache_slow != NULL && tcache_slow->arena == arena) {\n\t\t\ttcache_t *tcache = tcache_slow->tcache;\n\t\t\tql_elm_new(tcache_slow, link);\n\t\t\tql_tail_insert(&arena->tcache_ql, tcache_slow, link);\n\t\t\tcache_bin_array_descriptor_init(\n\t\t\t &tcache_slow->cache_bin_array_descriptor,\n\t\t\t tcache->bins);\n\t\t\tql_tail_insert(&arena->cache_bin_array_descriptor_ql,\n\t\t\t &tcache_slow->cache_bin_array_descriptor, link);\n\t\t}\n\t}\n\n\tfor (unsigned i = 0; i < nbins_total; i++) {\n\t\tbin_postfork_child(tsdn, &arena->bins[i]);\n\t}\n\n\tmalloc_mutex_postfork_child(tsdn, &arena->large_mtx);\n\tbase_postfork_child(tsdn, arena->base);\n\tpa_shard_postfork_child(tsdn, &arena->pa_shard);\n\tif (config_stats) {\n\t\tmalloc_mutex_postfork_child(tsdn, &arena->tcache_ql_mtx);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/background_thread.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n\nJEMALLOC_DIAGNOSTIC_DISABLE_SPURIOUS\n\n/******************************************************************************/\n/* Data. */\n\n/* This option should be opt-in only. */\n#define BACKGROUND_THREAD_DEFAULT false\n/* Read-only after initialization. */\nbool opt_background_thread = BACKGROUND_THREAD_DEFAULT;\nsize_t opt_max_background_threads = MAX_BACKGROUND_THREAD_LIMIT + 1;\n\n/* Used for thread creation, termination and stats. */\nmalloc_mutex_t background_thread_lock;\n/* Indicates global state. Atomic because decay reads this w/o locking. */\natomic_b_t background_thread_enabled_state;\nsize_t n_background_threads;\nsize_t max_background_threads;\n/* Thread info per-index. */\nbackground_thread_info_t *background_thread_info;\n\n/******************************************************************************/\n\n#ifdef JEMALLOC_PTHREAD_CREATE_WRAPPER\n\nstatic int (*pthread_create_fptr)(pthread_t *__restrict, const pthread_attr_t *,\n void *(*)(void *), void *__restrict);\n\nstatic void\npthread_create_wrapper_init(void) {\n#ifdef JEMALLOC_LAZY_LOCK\n\tif (!isthreaded) {\n\t\tisthreaded = true;\n\t}\n#endif\n}\n\nint\npthread_create_wrapper(pthread_t *__restrict thread, const pthread_attr_t *attr,\n void *(*start_routine)(void *), void *__restrict arg) {\n\tpthread_create_wrapper_init();\n\n\treturn pthread_create_fptr(thread, attr, start_routine, arg);\n}\n#endif /* JEMALLOC_PTHREAD_CREATE_WRAPPER */\n\n#ifndef JEMALLOC_BACKGROUND_THREAD\n#define NOT_REACHED { not_reached(); }\nbool background_thread_create(tsd_t *tsd, unsigned arena_ind) NOT_REACHED\nbool background_threads_enable(tsd_t *tsd) NOT_REACHED\nbool background_threads_disable(tsd_t *tsd) NOT_REACHED\nbool background_thread_is_started(background_thread_info_t *info) NOT_REACHED\nvoid background_thread_wakeup_early(background_thread_info_t *info,\n nstime_t *remaining_sleep) NOT_REACHED\nvoid background_thread_prefork0(tsdn_t *tsdn) NOT_REACHED\nvoid background_thread_prefork1(tsdn_t *tsdn) NOT_REACHED\nvoid background_thread_postfork_parent(tsdn_t *tsdn) NOT_REACHED\nvoid background_thread_postfork_child(tsdn_t *tsdn) NOT_REACHED\nbool background_thread_stats_read(tsdn_t *tsdn,\n background_thread_stats_t *stats) NOT_REACHED\nvoid background_thread_ctl_init(tsdn_t *tsdn) NOT_REACHED\n#undef NOT_REACHED\n#else\n\nstatic bool background_thread_enabled_at_fork;\n\nstatic void\nbackground_thread_info_init(tsdn_t *tsdn, background_thread_info_t *info) {\n\tbackground_thread_wakeup_time_set(tsdn, info, 0);\n\tinfo->npages_to_purge_new = 0;\n\tif (config_stats) {\n\t\tinfo->tot_n_runs = 0;\n\t\tnstime_init_zero(&info->tot_sleep_time);\n\t}\n}\n\nstatic inline bool\nset_current_thread_affinity(int cpu) {\n#if defined(JEMALLOC_HAVE_SCHED_SETAFFINITY)\n\tcpu_set_t cpuset;\n#else\n# ifndef __NetBSD__\n\tcpuset_t cpuset;\n# else\n\tcpuset_t *cpuset;\n# endif\n#endif\n\n#ifndef __NetBSD__\n\tCPU_ZERO(&cpuset);\n\tCPU_SET(cpu, &cpuset);\n#else\n\tcpuset = cpuset_create();\n#endif\n\n#if defined(JEMALLOC_HAVE_SCHED_SETAFFINITY)\n\treturn (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset) != 0);\n#else\n# ifndef __NetBSD__\n\tint ret = pthread_setaffinity_np(pthread_self(), sizeof(cpuset_t),\n\t &cpuset);\n# else\n\tint ret = pthread_setaffinity_np(pthread_self(), cpuset_size(cpuset),\n\t cpuset);\n\tcpuset_destroy(cpuset);\n# endif\n\treturn ret != 0;\n#endif\n}\n\n#define BILLION UINT64_C(1000000000)\n/* Minimal sleep interval 100 ms. */\n#define BACKGROUND_THREAD_MIN_INTERVAL_NS (BILLION / 10)\n\nstatic void\nbackground_thread_sleep(tsdn_t *tsdn, background_thread_info_t *info,\n uint64_t interval) {\n\tif (config_stats) {\n\t\tinfo->tot_n_runs++;\n\t}\n\tinfo->npages_to_purge_new = 0;\n\n\tstruct timeval tv;\n\t/* Specific clock required by timedwait. */\n\tgettimeofday(&tv, NULL);\n\tnstime_t before_sleep;\n\tnstime_init2(&before_sleep, tv.tv_sec, tv.tv_usec * 1000);\n\n\tint ret;\n\tif (interval == BACKGROUND_THREAD_INDEFINITE_SLEEP) {\n\t\tbackground_thread_wakeup_time_set(tsdn, info,\n\t\t BACKGROUND_THREAD_INDEFINITE_SLEEP);\n\t\tret = pthread_cond_wait(&info->cond, &info->mtx.lock);\n\t\tassert(ret == 0);\n\t} else {\n\t\tassert(interval >= BACKGROUND_THREAD_MIN_INTERVAL_NS &&\n\t\t interval <= BACKGROUND_THREAD_INDEFINITE_SLEEP);\n\t\t/* We need malloc clock (can be different from tv). */\n\t\tnstime_t next_wakeup;\n\t\tnstime_init_update(&next_wakeup);\n\t\tnstime_iadd(&next_wakeup, interval);\n\t\tassert(nstime_ns(&next_wakeup) <\n\t\t BACKGROUND_THREAD_INDEFINITE_SLEEP);\n\t\tbackground_thread_wakeup_time_set(tsdn, info,\n\t\t nstime_ns(&next_wakeup));\n\n\t\tnstime_t ts_wakeup;\n\t\tnstime_copy(&ts_wakeup, &before_sleep);\n\t\tnstime_iadd(&ts_wakeup, interval);\n\t\tstruct timespec ts;\n\t\tts.tv_sec = (size_t)nstime_sec(&ts_wakeup);\n\t\tts.tv_nsec = (size_t)nstime_nsec(&ts_wakeup);\n\n\t\tassert(!background_thread_indefinite_sleep(info));\n\t\tret = pthread_cond_timedwait(&info->cond, &info->mtx.lock, &ts);\n\t\tassert(ret == ETIMEDOUT || ret == 0);\n\t}\n\tif (config_stats) {\n\t\tgettimeofday(&tv, NULL);\n\t\tnstime_t after_sleep;\n\t\tnstime_init2(&after_sleep, tv.tv_sec, tv.tv_usec * 1000);\n\t\tif (nstime_compare(&after_sleep, &before_sleep) > 0) {\n\t\t\tnstime_subtract(&after_sleep, &before_sleep);\n\t\t\tnstime_add(&info->tot_sleep_time, &after_sleep);\n\t\t}\n\t}\n}\n\nstatic bool\nbackground_thread_pause_check(tsdn_t *tsdn, background_thread_info_t *info) {\n\tif (unlikely(info->state == background_thread_paused)) {\n\t\tmalloc_mutex_unlock(tsdn, &info->mtx);\n\t\t/* Wait on global lock to update status. */\n\t\tmalloc_mutex_lock(tsdn, &background_thread_lock);\n\t\tmalloc_mutex_unlock(tsdn, &background_thread_lock);\n\t\tmalloc_mutex_lock(tsdn, &info->mtx);\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic inline void\nbackground_work_sleep_once(tsdn_t *tsdn, background_thread_info_t *info,\n unsigned ind) {\n\tuint64_t ns_until_deferred = BACKGROUND_THREAD_DEFERRED_MAX;\n\tunsigned narenas = narenas_total_get();\n\tbool slept_indefinitely = background_thread_indefinite_sleep(info);\n\n\tfor (unsigned i = ind; i < narenas; i += max_background_threads) {\n\t\tarena_t *arena = arena_get(tsdn, i, false);\n\t\tif (!arena) {\n\t\t\tcontinue;\n\t\t}\n\t\t/*\n\t\t * If thread was woken up from the indefinite sleep, don't\n\t\t * do the work instantly, but rather check when the deferred\n\t\t * work that caused this thread to wake up is scheduled for.\n\t\t */\n\t\tif (!slept_indefinitely) {\n\t\t\tarena_do_deferred_work(tsdn, arena);\n\t\t}\n\t\tif (ns_until_deferred <= BACKGROUND_THREAD_MIN_INTERVAL_NS) {\n\t\t\t/* Min interval will be used. */\n\t\t\tcontinue;\n\t\t}\n\t\tuint64_t ns_arena_deferred = pa_shard_time_until_deferred_work(\n\t\t tsdn, &arena->pa_shard);\n\t\tif (ns_arena_deferred < ns_until_deferred) {\n\t\t\tns_until_deferred = ns_arena_deferred;\n\t\t}\n\t}\n\n\tuint64_t sleep_ns;\n\tif (ns_until_deferred == BACKGROUND_THREAD_DEFERRED_MAX) {\n\t\tsleep_ns = BACKGROUND_THREAD_INDEFINITE_SLEEP;\n\t} else {\n\t\tsleep_ns =\n\t\t (ns_until_deferred < BACKGROUND_THREAD_MIN_INTERVAL_NS)\n\t\t ? BACKGROUND_THREAD_MIN_INTERVAL_NS\n\t\t : ns_until_deferred;\n\n\t}\n\n\tbackground_thread_sleep(tsdn, info, sleep_ns);\n}\n\nstatic bool\nbackground_threads_disable_single(tsd_t *tsd, background_thread_info_t *info) {\n\tif (info == &background_thread_info[0]) {\n\t\tmalloc_mutex_assert_owner(tsd_tsdn(tsd),\n\t\t &background_thread_lock);\n\t} else {\n\t\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd),\n\t\t &background_thread_lock);\n\t}\n\n\tpre_reentrancy(tsd, NULL);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\tbool has_thread;\n\tassert(info->state != background_thread_paused);\n\tif (info->state == background_thread_started) {\n\t\thas_thread = true;\n\t\tinfo->state = background_thread_stopped;\n\t\tpthread_cond_signal(&info->cond);\n\t} else {\n\t\thas_thread = false;\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\n\tif (!has_thread) {\n\t\tpost_reentrancy(tsd);\n\t\treturn false;\n\t}\n\tvoid *ret;\n\tif (pthread_join(info->thread, &ret)) {\n\t\tpost_reentrancy(tsd);\n\t\treturn true;\n\t}\n\tassert(ret == NULL);\n\tn_background_threads--;\n\tpost_reentrancy(tsd);\n\n\treturn false;\n}\n\nstatic void *background_thread_entry(void *ind_arg);\n\nstatic int\nbackground_thread_create_signals_masked(pthread_t *thread,\n const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) {\n\t/*\n\t * Mask signals during thread creation so that the thread inherits\n\t * an empty signal set.\n\t */\n\tsigset_t set;\n\tsigfillset(&set);\n\tsigset_t oldset;\n\tint mask_err = pthread_sigmask(SIG_SETMASK, &set, &oldset);\n\tif (mask_err != 0) {\n\t\treturn mask_err;\n\t}\n\tint create_err = pthread_create_wrapper(thread, attr, start_routine,\n\t arg);\n\t/*\n\t * Restore the signal mask. Failure to restore the signal mask here\n\t * changes program behavior.\n\t */\n\tint restore_err = pthread_sigmask(SIG_SETMASK, &oldset, NULL);\n\tif (restore_err != 0) {\n\t\tmalloc_printf(\": background thread creation \"\n\t\t \"failed (%d), and signal mask restoration failed \"\n\t\t \"(%d)\\n\", create_err, restore_err);\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n\treturn create_err;\n}\n\nstatic bool\ncheck_background_thread_creation(tsd_t *tsd, unsigned *n_created,\n bool *created_threads) {\n\tbool ret = false;\n\tif (likely(*n_created == n_background_threads)) {\n\t\treturn ret;\n\t}\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\tmalloc_mutex_unlock(tsdn, &background_thread_info[0].mtx);\n\tfor (unsigned i = 1; i < max_background_threads; i++) {\n\t\tif (created_threads[i]) {\n\t\t\tcontinue;\n\t\t}\n\t\tbackground_thread_info_t *info = &background_thread_info[i];\n\t\tmalloc_mutex_lock(tsdn, &info->mtx);\n\t\t/*\n\t\t * In case of the background_thread_paused state because of\n\t\t * arena reset, delay the creation.\n\t\t */\n\t\tbool create = (info->state == background_thread_started);\n\t\tmalloc_mutex_unlock(tsdn, &info->mtx);\n\t\tif (!create) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tpre_reentrancy(tsd, NULL);\n\t\tint err = background_thread_create_signals_masked(&info->thread,\n\t\t NULL, background_thread_entry, (void *)(uintptr_t)i);\n\t\tpost_reentrancy(tsd);\n\n\t\tif (err == 0) {\n\t\t\t(*n_created)++;\n\t\t\tcreated_threads[i] = true;\n\t\t} else {\n\t\t\tmalloc_printf(\": background thread \"\n\t\t\t \"creation failed (%d)\\n\", err);\n\t\t\tif (opt_abort) {\n\t\t\t\tabort();\n\t\t\t}\n\t\t}\n\t\t/* Return to restart the loop since we unlocked. */\n\t\tret = true;\n\t\tbreak;\n\t}\n\tmalloc_mutex_lock(tsdn, &background_thread_info[0].mtx);\n\n\treturn ret;\n}\n\nstatic void\nbackground_thread0_work(tsd_t *tsd) {\n\t/* Thread0 is also responsible for launching / terminating threads. */\n\tVARIABLE_ARRAY(bool, created_threads, max_background_threads);\n\tunsigned i;\n\tfor (i = 1; i < max_background_threads; i++) {\n\t\tcreated_threads[i] = false;\n\t}\n\t/* Start working, and create more threads when asked. */\n\tunsigned n_created = 1;\n\twhile (background_thread_info[0].state != background_thread_stopped) {\n\t\tif (background_thread_pause_check(tsd_tsdn(tsd),\n\t\t &background_thread_info[0])) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (check_background_thread_creation(tsd, &n_created,\n\t\t (bool *)&created_threads)) {\n\t\t\tcontinue;\n\t\t}\n\t\tbackground_work_sleep_once(tsd_tsdn(tsd),\n\t\t &background_thread_info[0], 0);\n\t}\n\n\t/*\n\t * Shut down other threads at exit. Note that the ctl thread is holding\n\t * the global background_thread mutex (and is waiting) for us.\n\t */\n\tassert(!background_thread_enabled());\n\tfor (i = 1; i < max_background_threads; i++) {\n\t\tbackground_thread_info_t *info = &background_thread_info[i];\n\t\tassert(info->state != background_thread_paused);\n\t\tif (created_threads[i]) {\n\t\t\tbackground_threads_disable_single(tsd, info);\n\t\t} else {\n\t\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\t\tif (info->state != background_thread_stopped) {\n\t\t\t\t/* The thread was not created. */\n\t\t\t\tassert(info->state ==\n\t\t\t\t background_thread_started);\n\t\t\t\tn_background_threads--;\n\t\t\t\tinfo->state = background_thread_stopped;\n\t\t\t}\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\t}\n\t}\n\tbackground_thread_info[0].state = background_thread_stopped;\n\tassert(n_background_threads == 1);\n}\n\nstatic void\nbackground_work(tsd_t *tsd, unsigned ind) {\n\tbackground_thread_info_t *info = &background_thread_info[ind];\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\tbackground_thread_wakeup_time_set(tsd_tsdn(tsd), info,\n\t BACKGROUND_THREAD_INDEFINITE_SLEEP);\n\tif (ind == 0) {\n\t\tbackground_thread0_work(tsd);\n\t} else {\n\t\twhile (info->state != background_thread_stopped) {\n\t\t\tif (background_thread_pause_check(tsd_tsdn(tsd),\n\t\t\t info)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tbackground_work_sleep_once(tsd_tsdn(tsd), info, ind);\n\t\t}\n\t}\n\tassert(info->state == background_thread_stopped);\n\tbackground_thread_wakeup_time_set(tsd_tsdn(tsd), info, 0);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n}\n\nstatic void *\nbackground_thread_entry(void *ind_arg) {\n\tunsigned thread_ind = (unsigned)(uintptr_t)ind_arg;\n\tassert(thread_ind < max_background_threads);\n#ifdef JEMALLOC_HAVE_PTHREAD_SETNAME_NP\n\tpthread_setname_np(pthread_self(), \"jemalloc_bg_thd\");\n#elif defined(__FreeBSD__) || defined(__DragonFly__)\n\tpthread_set_name_np(pthread_self(), \"jemalloc_bg_thd\");\n#endif\n\tif (opt_percpu_arena != percpu_arena_disabled) {\n\t\tset_current_thread_affinity((int)thread_ind);\n\t}\n\t/*\n\t * Start periodic background work. We use internal tsd which avoids\n\t * side effects, for example triggering new arena creation (which in\n\t * turn triggers another background thread creation).\n\t */\n\tbackground_work(tsd_internal_fetch(), thread_ind);\n\tassert(pthread_equal(pthread_self(),\n\t background_thread_info[thread_ind].thread));\n\n\treturn NULL;\n}\n\nstatic void\nbackground_thread_init(tsd_t *tsd, background_thread_info_t *info) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &background_thread_lock);\n\tinfo->state = background_thread_started;\n\tbackground_thread_info_init(tsd_tsdn(tsd), info);\n\tn_background_threads++;\n}\n\nstatic bool\nbackground_thread_create_locked(tsd_t *tsd, unsigned arena_ind) {\n\tassert(have_background_thread);\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &background_thread_lock);\n\n\t/* We create at most NCPUs threads. */\n\tsize_t thread_ind = arena_ind % max_background_threads;\n\tbackground_thread_info_t *info = &background_thread_info[thread_ind];\n\n\tbool need_new_thread;\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\tneed_new_thread = background_thread_enabled() &&\n\t (info->state == background_thread_stopped);\n\tif (need_new_thread) {\n\t\tbackground_thread_init(tsd, info);\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\tif (!need_new_thread) {\n\t\treturn false;\n\t}\n\tif (arena_ind != 0) {\n\t\t/* Threads are created asynchronously by Thread 0. */\n\t\tbackground_thread_info_t *t0 = &background_thread_info[0];\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &t0->mtx);\n\t\tassert(t0->state == background_thread_started);\n\t\tpthread_cond_signal(&t0->cond);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &t0->mtx);\n\n\t\treturn false;\n\t}\n\n\tpre_reentrancy(tsd, NULL);\n\t/*\n\t * To avoid complications (besides reentrancy), create internal\n\t * background threads with the underlying pthread_create.\n\t */\n\tint err = background_thread_create_signals_masked(&info->thread, NULL,\n\t background_thread_entry, (void *)thread_ind);\n\tpost_reentrancy(tsd);\n\n\tif (err != 0) {\n\t\tmalloc_printf(\": arena 0 background thread creation \"\n\t\t \"failed (%d)\\n\", err);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\tinfo->state = background_thread_stopped;\n\t\tn_background_threads--;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\n/* Create a new background thread if needed. */\nbool\nbackground_thread_create(tsd_t *tsd, unsigned arena_ind) {\n\tassert(have_background_thread);\n\n\tbool ret;\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &background_thread_lock);\n\tret = background_thread_create_locked(tsd, arena_ind);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &background_thread_lock);\n\n\treturn ret;\n}\n\nbool\nbackground_threads_enable(tsd_t *tsd) {\n\tassert(n_background_threads == 0);\n\tassert(background_thread_enabled());\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &background_thread_lock);\n\n\tVARIABLE_ARRAY(bool, marked, max_background_threads);\n\tunsigned nmarked;\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tmarked[i] = false;\n\t}\n\tnmarked = 0;\n\t/* Thread 0 is required and created at the end. */\n\tmarked[0] = true;\n\t/* Mark the threads we need to create for thread 0. */\n\tunsigned narenas = narenas_total_get();\n\tfor (unsigned i = 1; i < narenas; i++) {\n\t\tif (marked[i % max_background_threads] ||\n\t\t arena_get(tsd_tsdn(tsd), i, false) == NULL) {\n\t\t\tcontinue;\n\t\t}\n\t\tbackground_thread_info_t *info = &background_thread_info[\n\t\t i % max_background_threads];\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\tassert(info->state == background_thread_stopped);\n\t\tbackground_thread_init(tsd, info);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\tmarked[i % max_background_threads] = true;\n\t\tif (++nmarked == max_background_threads) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\tbool err = background_thread_create_locked(tsd, 0);\n\tif (err) {\n\t\treturn true;\n\t}\n\tfor (unsigned i = 0; i < narenas; i++) {\n\t\tarena_t *arena = arena_get(tsd_tsdn(tsd), i, false);\n\t\tif (arena != NULL) {\n\t\t\tpa_shard_set_deferral_allowed(tsd_tsdn(tsd),\n\t\t\t &arena->pa_shard, true);\n\t\t}\n\t}\n\treturn false;\n}\n\nbool\nbackground_threads_disable(tsd_t *tsd) {\n\tassert(!background_thread_enabled());\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &background_thread_lock);\n\n\t/* Thread 0 will be responsible for terminating other threads. */\n\tif (background_threads_disable_single(tsd,\n\t &background_thread_info[0])) {\n\t\treturn true;\n\t}\n\tassert(n_background_threads == 0);\n\tunsigned narenas = narenas_total_get();\n\tfor (unsigned i = 0; i < narenas; i++) {\n\t\tarena_t *arena = arena_get(tsd_tsdn(tsd), i, false);\n\t\tif (arena != NULL) {\n\t\t\tpa_shard_set_deferral_allowed(tsd_tsdn(tsd),\n\t\t\t &arena->pa_shard, false);\n\t\t}\n\t}\n\n\treturn false;\n}\n\nbool\nbackground_thread_is_started(background_thread_info_t *info) {\n\treturn info->state == background_thread_started;\n}\n\nvoid\nbackground_thread_wakeup_early(background_thread_info_t *info,\n nstime_t *remaining_sleep) {\n\t/*\n\t * This is an optimization to increase batching. At this point\n\t * we know that background thread wakes up soon, so the time to cache\n\t * the just freed memory is bounded and low.\n\t */\n\tif (remaining_sleep != NULL && nstime_ns(remaining_sleep) <\n\t BACKGROUND_THREAD_MIN_INTERVAL_NS) {\n\t\treturn;\n\t}\n\tpthread_cond_signal(&info->cond);\n}\n\nvoid\nbackground_thread_prefork0(tsdn_t *tsdn) {\n\tmalloc_mutex_prefork(tsdn, &background_thread_lock);\n\tbackground_thread_enabled_at_fork = background_thread_enabled();\n}\n\nvoid\nbackground_thread_prefork1(tsdn_t *tsdn) {\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tmalloc_mutex_prefork(tsdn, &background_thread_info[i].mtx);\n\t}\n}\n\nvoid\nbackground_thread_postfork_parent(tsdn_t *tsdn) {\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tmalloc_mutex_postfork_parent(tsdn,\n\t\t &background_thread_info[i].mtx);\n\t}\n\tmalloc_mutex_postfork_parent(tsdn, &background_thread_lock);\n}\n\nvoid\nbackground_thread_postfork_child(tsdn_t *tsdn) {\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tmalloc_mutex_postfork_child(tsdn,\n\t\t &background_thread_info[i].mtx);\n\t}\n\tmalloc_mutex_postfork_child(tsdn, &background_thread_lock);\n\tif (!background_thread_enabled_at_fork) {\n\t\treturn;\n\t}\n\n\t/* Clear background_thread state (reset to disabled for child). */\n\tmalloc_mutex_lock(tsdn, &background_thread_lock);\n\tn_background_threads = 0;\n\tbackground_thread_enabled_set(tsdn, false);\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tbackground_thread_info_t *info = &background_thread_info[i];\n\t\tmalloc_mutex_lock(tsdn, &info->mtx);\n\t\tinfo->state = background_thread_stopped;\n\t\tint ret = pthread_cond_init(&info->cond, NULL);\n\t\tassert(ret == 0);\n\t\tbackground_thread_info_init(tsdn, info);\n\t\tmalloc_mutex_unlock(tsdn, &info->mtx);\n\t}\n\tmalloc_mutex_unlock(tsdn, &background_thread_lock);\n}\n\nbool\nbackground_thread_stats_read(tsdn_t *tsdn, background_thread_stats_t *stats) {\n\tassert(config_stats);\n\tmalloc_mutex_lock(tsdn, &background_thread_lock);\n\tif (!background_thread_enabled()) {\n\t\tmalloc_mutex_unlock(tsdn, &background_thread_lock);\n\t\treturn true;\n\t}\n\n\tnstime_init_zero(&stats->run_interval);\n\tmemset(&stats->max_counter_per_bg_thd, 0, sizeof(mutex_prof_data_t));\n\n\tuint64_t num_runs = 0;\n\tstats->num_threads = n_background_threads;\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tbackground_thread_info_t *info = &background_thread_info[i];\n\t\tif (malloc_mutex_trylock(tsdn, &info->mtx)) {\n\t\t\t/*\n\t\t\t * Each background thread run may take a long time;\n\t\t\t * avoid waiting on the stats if the thread is active.\n\t\t\t */\n\t\t\tcontinue;\n\t\t}\n\t\tif (info->state != background_thread_stopped) {\n\t\t\tnum_runs += info->tot_n_runs;\n\t\t\tnstime_add(&stats->run_interval, &info->tot_sleep_time);\n\t\t\tmalloc_mutex_prof_max_update(tsdn,\n\t\t\t &stats->max_counter_per_bg_thd, &info->mtx);\n\t\t}\n\t\tmalloc_mutex_unlock(tsdn, &info->mtx);\n\t}\n\tstats->num_runs = num_runs;\n\tif (num_runs > 0) {\n\t\tnstime_idivide(&stats->run_interval, num_runs);\n\t}\n\tmalloc_mutex_unlock(tsdn, &background_thread_lock);\n\n\treturn false;\n}\n\n#undef BACKGROUND_THREAD_NPAGES_THRESHOLD\n#undef BILLION\n#undef BACKGROUND_THREAD_MIN_INTERVAL_NS\n\n#ifdef JEMALLOC_HAVE_DLSYM\n#include \n#endif\n\nstatic bool\npthread_create_fptr_init(void) {\n\tif (pthread_create_fptr != NULL) {\n\t\treturn false;\n\t}\n\t/*\n\t * Try the next symbol first, because 1) when use lazy_lock we have a\n\t * wrapper for pthread_create; and 2) application may define its own\n\t * wrapper as well (and can call malloc within the wrapper).\n\t */\n#ifdef JEMALLOC_HAVE_DLSYM\n\tpthread_create_fptr = dlsym(RTLD_NEXT, \"pthread_create\");\n#else\n\tpthread_create_fptr = NULL;\n#endif\n\tif (pthread_create_fptr == NULL) {\n\t\tif (config_lazy_lock) {\n\t\t\tmalloc_write(\": Error in dlsym(RTLD_NEXT, \"\n\t\t\t \"\\\"pthread_create\\\")\\n\");\n\t\t\tabort();\n\t\t} else {\n\t\t\t/* Fall back to the default symbol. */\n\t\t\tpthread_create_fptr = pthread_create;\n\t\t}\n\t}\n\n\treturn false;\n}\n\n/*\n * When lazy lock is enabled, we need to make sure setting isthreaded before\n * taking any background_thread locks. This is called early in ctl (instead of\n * wait for the pthread_create calls to trigger) because the mutex is required\n * before creating background threads.\n */\nvoid\nbackground_thread_ctl_init(tsdn_t *tsdn) {\n\tmalloc_mutex_assert_not_owner(tsdn, &background_thread_lock);\n#ifdef JEMALLOC_PTHREAD_CREATE_WRAPPER\n\tpthread_create_fptr_init();\n\tpthread_create_wrapper_init();\n#endif\n}\n\n#endif /* defined(JEMALLOC_BACKGROUND_THREAD) */\n\nbool\nbackground_thread_boot0(void) {\n\tif (!have_background_thread && opt_background_thread) {\n\t\tmalloc_printf(\": option background_thread currently \"\n\t\t \"supports pthread only\\n\");\n\t\treturn true;\n\t}\n#ifdef JEMALLOC_PTHREAD_CREATE_WRAPPER\n\tif ((config_lazy_lock || opt_background_thread) &&\n\t pthread_create_fptr_init()) {\n\t\treturn true;\n\t}\n#endif\n\treturn false;\n}\n\nbool\nbackground_thread_boot1(tsdn_t *tsdn, base_t *base) {\n#ifdef JEMALLOC_BACKGROUND_THREAD\n\tassert(have_background_thread);\n\tassert(narenas_total_get() > 0);\n\n\tif (opt_max_background_threads > MAX_BACKGROUND_THREAD_LIMIT) {\n\t\topt_max_background_threads = DEFAULT_NUM_BACKGROUND_THREAD;\n\t}\n\tmax_background_threads = opt_max_background_threads;\n\n\tbackground_thread_enabled_set(tsdn, opt_background_thread);\n\tif (malloc_mutex_init(&background_thread_lock,\n\t \"background_thread_global\",\n\t WITNESS_RANK_BACKGROUND_THREAD_GLOBAL,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tbackground_thread_info = (background_thread_info_t *)base_alloc(tsdn,\n\t base, opt_max_background_threads *\n\t sizeof(background_thread_info_t), CACHELINE);\n\tif (background_thread_info == NULL) {\n\t\treturn true;\n\t}\n\n\tfor (unsigned i = 0; i < max_background_threads; i++) {\n\t\tbackground_thread_info_t *info = &background_thread_info[i];\n\t\t/* Thread mutex is rank_inclusive because of thread0. */\n\t\tif (malloc_mutex_init(&info->mtx, \"background_thread\",\n\t\t WITNESS_RANK_BACKGROUND_THREAD,\n\t\t malloc_mutex_address_ordered)) {\n\t\t\treturn true;\n\t\t}\n\t\tif (pthread_cond_init(&info->cond, NULL)) {\n\t\t\treturn true;\n\t\t}\n\t\tmalloc_mutex_lock(tsdn, &info->mtx);\n\t\tinfo->state = background_thread_stopped;\n\t\tbackground_thread_info_init(tsdn, info);\n\t\tmalloc_mutex_unlock(tsdn, &info->mtx);\n\t}\n#endif\n\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/base.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/sz.h\"\n\n/*\n * In auto mode, arenas switch to huge pages for the base allocator on the\n * second base block. a0 switches to thp on the 5th block (after 20 megabytes\n * of metadata), since more metadata (e.g. rtree nodes) come from a0's base.\n */\n\n#define BASE_AUTO_THP_THRESHOLD 2\n#define BASE_AUTO_THP_THRESHOLD_A0 5\n\n/******************************************************************************/\n/* Data. */\n\nstatic base_t *b0;\n\nmetadata_thp_mode_t opt_metadata_thp = METADATA_THP_DEFAULT;\n\nconst char *metadata_thp_mode_names[] = {\n\t\"disabled\",\n\t\"auto\",\n\t\"always\"\n};\n\n/******************************************************************************/\n\nstatic inline bool\nmetadata_thp_madvise(void) {\n\treturn (metadata_thp_enabled() &&\n\t (init_system_thp_mode == thp_mode_default));\n}\n\nstatic void *\nbase_map(tsdn_t *tsdn, ehooks_t *ehooks, unsigned ind, size_t size) {\n\tvoid *addr;\n\tbool zero = true;\n\tbool commit = true;\n\n\t/* Use huge page sizes and alignment regardless of opt_metadata_thp. */\n\tassert(size == HUGEPAGE_CEILING(size));\n\tsize_t alignment = HUGEPAGE;\n\tif (ehooks_are_default(ehooks)) {\n\t\taddr = extent_alloc_mmap(NULL, size, alignment, &zero, &commit);\n\t\tif (have_madvise_huge && addr) {\n\t\t\tpages_set_thp_state(addr, size);\n\t\t}\n\t} else {\n\t\taddr = ehooks_alloc(tsdn, ehooks, NULL, size, alignment, &zero,\n\t\t &commit);\n\t}\n\n\treturn addr;\n}\n\nstatic void\nbase_unmap(tsdn_t *tsdn, ehooks_t *ehooks, unsigned ind, void *addr,\n size_t size) {\n\t/*\n\t * Cascade through dalloc, decommit, purge_forced, and purge_lazy,\n\t * stopping at first success. This cascade is performed for consistency\n\t * with the cascade in extent_dalloc_wrapper() because an application's\n\t * custom hooks may not support e.g. dalloc. This function is only ever\n\t * called as a side effect of arena destruction, so although it might\n\t * seem pointless to do anything besides dalloc here, the application\n\t * may in fact want the end state of all associated virtual memory to be\n\t * in some consistent-but-allocated state.\n\t */\n\tif (ehooks_are_default(ehooks)) {\n\t\tif (!extent_dalloc_mmap(addr, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!pages_decommit(addr, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!pages_purge_forced(addr, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!pages_purge_lazy(addr, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\t/* Nothing worked. This should never happen. */\n\t\tnot_reached();\n\t} else {\n\t\tif (!ehooks_dalloc(tsdn, ehooks, addr, size, true)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!ehooks_decommit(tsdn, ehooks, addr, size, 0, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!ehooks_purge_forced(tsdn, ehooks, addr, size, 0, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tif (!ehooks_purge_lazy(tsdn, ehooks, addr, size, 0, size)) {\n\t\t\tgoto label_done;\n\t\t}\n\t\t/* Nothing worked. That's the application's problem. */\n\t}\nlabel_done:\n\tif (metadata_thp_madvise()) {\n\t\t/* Set NOHUGEPAGE after unmap to avoid kernel defrag. */\n\t\tassert(((uintptr_t)addr & HUGEPAGE_MASK) == 0 &&\n\t\t (size & HUGEPAGE_MASK) == 0);\n\t\tpages_nohuge(addr, size);\n\t}\n}\n\nstatic void\nbase_edata_init(size_t *extent_sn_next, edata_t *edata, void *addr,\n size_t size) {\n\tsize_t sn;\n\n\tsn = *extent_sn_next;\n\t(*extent_sn_next)++;\n\n\tedata_binit(edata, addr, size, sn);\n}\n\nstatic size_t\nbase_get_num_blocks(base_t *base, bool with_new_block) {\n\tbase_block_t *b = base->blocks;\n\tassert(b != NULL);\n\n\tsize_t n_blocks = with_new_block ? 2 : 1;\n\twhile (b->next != NULL) {\n\t\tn_blocks++;\n\t\tb = b->next;\n\t}\n\n\treturn n_blocks;\n}\n\nstatic void\nbase_auto_thp_switch(tsdn_t *tsdn, base_t *base) {\n\tassert(opt_metadata_thp == metadata_thp_auto);\n\tmalloc_mutex_assert_owner(tsdn, &base->mtx);\n\tif (base->auto_thp_switched) {\n\t\treturn;\n\t}\n\t/* Called when adding a new block. */\n\tbool should_switch;\n\tif (base_ind_get(base) != 0) {\n\t\tshould_switch = (base_get_num_blocks(base, true) ==\n\t\t BASE_AUTO_THP_THRESHOLD);\n\t} else {\n\t\tshould_switch = (base_get_num_blocks(base, true) ==\n\t\t BASE_AUTO_THP_THRESHOLD_A0);\n\t}\n\tif (!should_switch) {\n\t\treturn;\n\t}\n\n\tbase->auto_thp_switched = true;\n\tassert(!config_stats || base->n_thp == 0);\n\t/* Make the initial blocks THP lazily. */\n\tbase_block_t *block = base->blocks;\n\twhile (block != NULL) {\n\t\tassert((block->size & HUGEPAGE_MASK) == 0);\n\t\tpages_huge(block, block->size);\n\t\tif (config_stats) {\n\t\t\tbase->n_thp += HUGEPAGE_CEILING(block->size -\n\t\t\t edata_bsize_get(&block->edata)) >> LG_HUGEPAGE;\n\t\t}\n\t\tblock = block->next;\n\t\tassert(block == NULL || (base_ind_get(base) == 0));\n\t}\n}\n\nstatic void *\nbase_extent_bump_alloc_helper(edata_t *edata, size_t *gap_size, size_t size,\n size_t alignment) {\n\tvoid *ret;\n\n\tassert(alignment == ALIGNMENT_CEILING(alignment, QUANTUM));\n\tassert(size == ALIGNMENT_CEILING(size, alignment));\n\n\t*gap_size = ALIGNMENT_CEILING((uintptr_t)edata_addr_get(edata),\n\t alignment) - (uintptr_t)edata_addr_get(edata);\n\tret = (void *)((uintptr_t)edata_addr_get(edata) + *gap_size);\n\tassert(edata_bsize_get(edata) >= *gap_size + size);\n\tedata_binit(edata, (void *)((uintptr_t)edata_addr_get(edata) +\n\t *gap_size + size), edata_bsize_get(edata) - *gap_size - size,\n\t edata_sn_get(edata));\n\treturn ret;\n}\n\nstatic void\nbase_extent_bump_alloc_post(base_t *base, edata_t *edata, size_t gap_size,\n void *addr, size_t size) {\n\tif (edata_bsize_get(edata) > 0) {\n\t\t/*\n\t\t * Compute the index for the largest size class that does not\n\t\t * exceed extent's size.\n\t\t */\n\t\tszind_t index_floor =\n\t\t sz_size2index(edata_bsize_get(edata) + 1) - 1;\n\t\tedata_heap_insert(&base->avail[index_floor], edata);\n\t}\n\n\tif (config_stats) {\n\t\tbase->allocated += size;\n\t\t/*\n\t\t * Add one PAGE to base_resident for every page boundary that is\n\t\t * crossed by the new allocation. Adjust n_thp similarly when\n\t\t * metadata_thp is enabled.\n\t\t */\n\t\tbase->resident += PAGE_CEILING((uintptr_t)addr + size) -\n\t\t PAGE_CEILING((uintptr_t)addr - gap_size);\n\t\tassert(base->allocated <= base->resident);\n\t\tassert(base->resident <= base->mapped);\n\t\tif (metadata_thp_madvise() && (opt_metadata_thp ==\n\t\t metadata_thp_always || base->auto_thp_switched)) {\n\t\t\tbase->n_thp += (HUGEPAGE_CEILING((uintptr_t)addr + size)\n\t\t\t - HUGEPAGE_CEILING((uintptr_t)addr - gap_size)) >>\n\t\t\t LG_HUGEPAGE;\n\t\t\tassert(base->mapped >= base->n_thp << LG_HUGEPAGE);\n\t\t}\n\t}\n}\n\nstatic void *\nbase_extent_bump_alloc(base_t *base, edata_t *edata, size_t size,\n size_t alignment) {\n\tvoid *ret;\n\tsize_t gap_size;\n\n\tret = base_extent_bump_alloc_helper(edata, &gap_size, size, alignment);\n\tbase_extent_bump_alloc_post(base, edata, gap_size, ret, size);\n\treturn ret;\n}\n\n/*\n * Allocate a block of virtual memory that is large enough to start with a\n * base_block_t header, followed by an object of specified size and alignment.\n * On success a pointer to the initialized base_block_t header is returned.\n */\nstatic base_block_t *\nbase_block_alloc(tsdn_t *tsdn, base_t *base, ehooks_t *ehooks, unsigned ind,\n pszind_t *pind_last, size_t *extent_sn_next, size_t size,\n size_t alignment) {\n\talignment = ALIGNMENT_CEILING(alignment, QUANTUM);\n\tsize_t usize = ALIGNMENT_CEILING(size, alignment);\n\tsize_t header_size = sizeof(base_block_t);\n\tsize_t gap_size = ALIGNMENT_CEILING(header_size, alignment) -\n\t header_size;\n\t/*\n\t * Create increasingly larger blocks in order to limit the total number\n\t * of disjoint virtual memory ranges. Choose the next size in the page\n\t * size class series (skipping size classes that are not a multiple of\n\t * HUGEPAGE), or a size large enough to satisfy the requested size and\n\t * alignment, whichever is larger.\n\t */\n\tsize_t min_block_size = HUGEPAGE_CEILING(sz_psz2u(header_size + gap_size\n\t + usize));\n\tpszind_t pind_next = (*pind_last + 1 < sz_psz2ind(SC_LARGE_MAXCLASS)) ?\n\t *pind_last + 1 : *pind_last;\n\tsize_t next_block_size = HUGEPAGE_CEILING(sz_pind2sz(pind_next));\n\tsize_t block_size = (min_block_size > next_block_size) ? min_block_size\n\t : next_block_size;\n\tbase_block_t *block = (base_block_t *)base_map(tsdn, ehooks, ind,\n\t block_size);\n\tif (block == NULL) {\n\t\treturn NULL;\n\t}\n\n\tif (metadata_thp_madvise()) {\n\t\tvoid *addr = (void *)block;\n\t\tassert(((uintptr_t)addr & HUGEPAGE_MASK) == 0 &&\n\t\t (block_size & HUGEPAGE_MASK) == 0);\n\t\tif (opt_metadata_thp == metadata_thp_always) {\n\t\t\tpages_huge(addr, block_size);\n\t\t} else if (opt_metadata_thp == metadata_thp_auto &&\n\t\t base != NULL) {\n\t\t\t/* base != NULL indicates this is not a new base. */\n\t\t\tmalloc_mutex_lock(tsdn, &base->mtx);\n\t\t\tbase_auto_thp_switch(tsdn, base);\n\t\t\tif (base->auto_thp_switched) {\n\t\t\t\tpages_huge(addr, block_size);\n\t\t\t}\n\t\t\tmalloc_mutex_unlock(tsdn, &base->mtx);\n\t\t}\n\t}\n\n\t*pind_last = sz_psz2ind(block_size);\n\tblock->size = block_size;\n\tblock->next = NULL;\n\tassert(block_size >= header_size);\n\tbase_edata_init(extent_sn_next, &block->edata,\n\t (void *)((uintptr_t)block + header_size), block_size - header_size);\n\treturn block;\n}\n\n/*\n * Allocate an extent that is at least as large as specified size, with\n * specified alignment.\n */\nstatic edata_t *\nbase_extent_alloc(tsdn_t *tsdn, base_t *base, size_t size, size_t alignment) {\n\tmalloc_mutex_assert_owner(tsdn, &base->mtx);\n\n\tehooks_t *ehooks = base_ehooks_get_for_metadata(base);\n\t/*\n\t * Drop mutex during base_block_alloc(), because an extent hook will be\n\t * called.\n\t */\n\tmalloc_mutex_unlock(tsdn, &base->mtx);\n\tbase_block_t *block = base_block_alloc(tsdn, base, ehooks,\n\t base_ind_get(base), &base->pind_last, &base->extent_sn_next, size,\n\t alignment);\n\tmalloc_mutex_lock(tsdn, &base->mtx);\n\tif (block == NULL) {\n\t\treturn NULL;\n\t}\n\tblock->next = base->blocks;\n\tbase->blocks = block;\n\tif (config_stats) {\n\t\tbase->allocated += sizeof(base_block_t);\n\t\tbase->resident += PAGE_CEILING(sizeof(base_block_t));\n\t\tbase->mapped += block->size;\n\t\tif (metadata_thp_madvise() &&\n\t\t !(opt_metadata_thp == metadata_thp_auto\n\t\t && !base->auto_thp_switched)) {\n\t\t\tassert(base->n_thp > 0);\n\t\t\tbase->n_thp += HUGEPAGE_CEILING(sizeof(base_block_t)) >>\n\t\t\t LG_HUGEPAGE;\n\t\t}\n\t\tassert(base->allocated <= base->resident);\n\t\tassert(base->resident <= base->mapped);\n\t\tassert(base->n_thp << LG_HUGEPAGE <= base->mapped);\n\t}\n\treturn &block->edata;\n}\n\nbase_t *\nb0get(void) {\n\treturn b0;\n}\n\nbase_t *\nbase_new(tsdn_t *tsdn, unsigned ind, const extent_hooks_t *extent_hooks,\n bool metadata_use_hooks) {\n\tpszind_t pind_last = 0;\n\tsize_t extent_sn_next = 0;\n\n\t/*\n\t * The base will contain the ehooks eventually, but it itself is\n\t * allocated using them. So we use some stack ehooks to bootstrap its\n\t * memory, and then initialize the ehooks within the base_t.\n\t */\n\tehooks_t fake_ehooks;\n\tehooks_init(&fake_ehooks, metadata_use_hooks ?\n\t (extent_hooks_t *)extent_hooks :\n\t (extent_hooks_t *)&ehooks_default_extent_hooks, ind);\n\n\tbase_block_t *block = base_block_alloc(tsdn, NULL, &fake_ehooks, ind,\n\t &pind_last, &extent_sn_next, sizeof(base_t), QUANTUM);\n\tif (block == NULL) {\n\t\treturn NULL;\n\t}\n\n\tsize_t gap_size;\n\tsize_t base_alignment = CACHELINE;\n\tsize_t base_size = ALIGNMENT_CEILING(sizeof(base_t), base_alignment);\n\tbase_t *base = (base_t *)base_extent_bump_alloc_helper(&block->edata,\n\t &gap_size, base_size, base_alignment);\n\tehooks_init(&base->ehooks, (extent_hooks_t *)extent_hooks, ind);\n\tehooks_init(&base->ehooks_base, metadata_use_hooks ?\n\t (extent_hooks_t *)extent_hooks :\n\t (extent_hooks_t *)&ehooks_default_extent_hooks, ind);\n\tif (malloc_mutex_init(&base->mtx, \"base\", WITNESS_RANK_BASE,\n\t malloc_mutex_rank_exclusive)) {\n\t\tbase_unmap(tsdn, &fake_ehooks, ind, block, block->size);\n\t\treturn NULL;\n\t}\n\tbase->pind_last = pind_last;\n\tbase->extent_sn_next = extent_sn_next;\n\tbase->blocks = block;\n\tbase->auto_thp_switched = false;\n\tfor (szind_t i = 0; i < SC_NSIZES; i++) {\n\t\tedata_heap_new(&base->avail[i]);\n\t}\n\tif (config_stats) {\n\t\tbase->allocated = sizeof(base_block_t);\n\t\tbase->resident = PAGE_CEILING(sizeof(base_block_t));\n\t\tbase->mapped = block->size;\n\t\tbase->n_thp = (opt_metadata_thp == metadata_thp_always) &&\n\t\t metadata_thp_madvise() ? HUGEPAGE_CEILING(sizeof(base_block_t))\n\t\t >> LG_HUGEPAGE : 0;\n\t\tassert(base->allocated <= base->resident);\n\t\tassert(base->resident <= base->mapped);\n\t\tassert(base->n_thp << LG_HUGEPAGE <= base->mapped);\n\t}\n\tbase_extent_bump_alloc_post(base, &block->edata, gap_size, base,\n\t base_size);\n\n\treturn base;\n}\n\nvoid\nbase_delete(tsdn_t *tsdn, base_t *base) {\n\tehooks_t *ehooks = base_ehooks_get_for_metadata(base);\n\tbase_block_t *next = base->blocks;\n\tdo {\n\t\tbase_block_t *block = next;\n\t\tnext = block->next;\n\t\tbase_unmap(tsdn, ehooks, base_ind_get(base), block,\n\t\t block->size);\n\t} while (next != NULL);\n}\n\nehooks_t *\nbase_ehooks_get(base_t *base) {\n\treturn &base->ehooks;\n}\n\nehooks_t *\nbase_ehooks_get_for_metadata(base_t *base) {\n\treturn &base->ehooks_base;\n}\n\nextent_hooks_t *\nbase_extent_hooks_set(base_t *base, extent_hooks_t *extent_hooks) {\n\textent_hooks_t *old_extent_hooks =\n\t ehooks_get_extent_hooks_ptr(&base->ehooks);\n\tehooks_init(&base->ehooks, extent_hooks, ehooks_ind_get(&base->ehooks));\n\treturn old_extent_hooks;\n}\n\nstatic void *\nbase_alloc_impl(tsdn_t *tsdn, base_t *base, size_t size, size_t alignment,\n size_t *esn) {\n\talignment = QUANTUM_CEILING(alignment);\n\tsize_t usize = ALIGNMENT_CEILING(size, alignment);\n\tsize_t asize = usize + alignment - QUANTUM;\n\n\tedata_t *edata = NULL;\n\tmalloc_mutex_lock(tsdn, &base->mtx);\n\tfor (szind_t i = sz_size2index(asize); i < SC_NSIZES; i++) {\n\t\tedata = edata_heap_remove_first(&base->avail[i]);\n\t\tif (edata != NULL) {\n\t\t\t/* Use existing space. */\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (edata == NULL) {\n\t\t/* Try to allocate more space. */\n\t\tedata = base_extent_alloc(tsdn, base, usize, alignment);\n\t}\n\tvoid *ret;\n\tif (edata == NULL) {\n\t\tret = NULL;\n\t\tgoto label_return;\n\t}\n\n\tret = base_extent_bump_alloc(base, edata, usize, alignment);\n\tif (esn != NULL) {\n\t\t*esn = (size_t)edata_sn_get(edata);\n\t}\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &base->mtx);\n\treturn ret;\n}\n\n/*\n * base_alloc() returns zeroed memory, which is always demand-zeroed for the\n * auto arenas, in order to make multi-page sparse data structures such as radix\n * tree nodes efficient with respect to physical memory usage. Upon success a\n * pointer to at least size bytes with specified alignment is returned. Note\n * that size is rounded up to the nearest multiple of alignment to avoid false\n * sharing.\n */\nvoid *\nbase_alloc(tsdn_t *tsdn, base_t *base, size_t size, size_t alignment) {\n\treturn base_alloc_impl(tsdn, base, size, alignment, NULL);\n}\n\nedata_t *\nbase_alloc_edata(tsdn_t *tsdn, base_t *base) {\n\tsize_t esn;\n\tedata_t *edata = base_alloc_impl(tsdn, base, sizeof(edata_t),\n\t EDATA_ALIGNMENT, &esn);\n\tif (edata == NULL) {\n\t\treturn NULL;\n\t}\n\tedata_esn_set(edata, esn);\n\treturn edata;\n}\n\nvoid\nbase_stats_get(tsdn_t *tsdn, base_t *base, size_t *allocated, size_t *resident,\n size_t *mapped, size_t *n_thp) {\n\tcassert(config_stats);\n\n\tmalloc_mutex_lock(tsdn, &base->mtx);\n\tassert(base->allocated <= base->resident);\n\tassert(base->resident <= base->mapped);\n\t*allocated = base->allocated;\n\t*resident = base->resident;\n\t*mapped = base->mapped;\n\t*n_thp = base->n_thp;\n\tmalloc_mutex_unlock(tsdn, &base->mtx);\n}\n\nvoid\nbase_prefork(tsdn_t *tsdn, base_t *base) {\n\tmalloc_mutex_prefork(tsdn, &base->mtx);\n}\n\nvoid\nbase_postfork_parent(tsdn_t *tsdn, base_t *base) {\n\tmalloc_mutex_postfork_parent(tsdn, &base->mtx);\n}\n\nvoid\nbase_postfork_child(tsdn_t *tsdn, base_t *base) {\n\tmalloc_mutex_postfork_child(tsdn, &base->mtx);\n}\n\nbool\nbase_boot(tsdn_t *tsdn) {\n\tb0 = base_new(tsdn, 0, (extent_hooks_t *)&ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\treturn (b0 == NULL);\n}\n" }, { "path": "deps/jemalloc/src/bin.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/bin.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/witness.h\"\n\nbool\nbin_update_shard_size(unsigned bin_shard_sizes[SC_NBINS], size_t start_size,\n size_t end_size, size_t nshards) {\n\tif (nshards > BIN_SHARDS_MAX || nshards == 0) {\n\t\treturn true;\n\t}\n\n\tif (start_size > SC_SMALL_MAXCLASS) {\n\t\treturn false;\n\t}\n\tif (end_size > SC_SMALL_MAXCLASS) {\n\t\tend_size = SC_SMALL_MAXCLASS;\n\t}\n\n\t/* Compute the index since this may happen before sz init. */\n\tszind_t ind1 = sz_size2index_compute(start_size);\n\tszind_t ind2 = sz_size2index_compute(end_size);\n\tfor (unsigned i = ind1; i <= ind2; i++) {\n\t\tbin_shard_sizes[i] = (unsigned)nshards;\n\t}\n\n\treturn false;\n}\n\nvoid\nbin_shard_sizes_boot(unsigned bin_shard_sizes[SC_NBINS]) {\n\t/* Load the default number of shards. */\n\tfor (unsigned i = 0; i < SC_NBINS; i++) {\n\t\tbin_shard_sizes[i] = N_BIN_SHARDS_DEFAULT;\n\t}\n}\n\nbool\nbin_init(bin_t *bin) {\n\tif (malloc_mutex_init(&bin->lock, \"bin\", WITNESS_RANK_BIN,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tbin->slabcur = NULL;\n\tedata_heap_new(&bin->slabs_nonfull);\n\tedata_list_active_init(&bin->slabs_full);\n\tif (config_stats) {\n\t\tmemset(&bin->stats, 0, sizeof(bin_stats_t));\n\t}\n\treturn false;\n}\n\nvoid\nbin_prefork(tsdn_t *tsdn, bin_t *bin) {\n\tmalloc_mutex_prefork(tsdn, &bin->lock);\n}\n\nvoid\nbin_postfork_parent(tsdn_t *tsdn, bin_t *bin) {\n\tmalloc_mutex_postfork_parent(tsdn, &bin->lock);\n}\n\nvoid\nbin_postfork_child(tsdn_t *tsdn, bin_t *bin) {\n\tmalloc_mutex_postfork_child(tsdn, &bin->lock);\n}\n" }, { "path": "deps/jemalloc/src/bin_info.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/bin_info.h\"\n\nbin_info_t bin_infos[SC_NBINS];\n\nstatic void\nbin_infos_init(sc_data_t *sc_data, unsigned bin_shard_sizes[SC_NBINS],\n bin_info_t infos[SC_NBINS]) {\n\tfor (unsigned i = 0; i < SC_NBINS; i++) {\n\t\tbin_info_t *bin_info = &infos[i];\n\t\tsc_t *sc = &sc_data->sc[i];\n\t\tbin_info->reg_size = ((size_t)1U << sc->lg_base)\n\t\t + ((size_t)sc->ndelta << sc->lg_delta);\n\t\tbin_info->slab_size = (sc->pgs << LG_PAGE);\n\t\tbin_info->nregs =\n\t\t (uint32_t)(bin_info->slab_size / bin_info->reg_size);\n\t\tbin_info->n_shards = bin_shard_sizes[i];\n\t\tbitmap_info_t bitmap_info = BITMAP_INFO_INITIALIZER(\n\t\t bin_info->nregs);\n\t\tbin_info->bitmap_info = bitmap_info;\n\t}\n}\n\nvoid\nbin_info_boot(sc_data_t *sc_data, unsigned bin_shard_sizes[SC_NBINS]) {\n\tassert(sc_data->initialized);\n\tbin_infos_init(sc_data, bin_shard_sizes, bin_infos);\n}\n" }, { "path": "deps/jemalloc/src/bitmap.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n\n/******************************************************************************/\n\n#ifdef BITMAP_USE_TREE\n\nvoid\nbitmap_info_init(bitmap_info_t *binfo, size_t nbits) {\n\tunsigned i;\n\tsize_t group_count;\n\n\tassert(nbits > 0);\n\tassert(nbits <= (ZU(1) << LG_BITMAP_MAXBITS));\n\n\t/*\n\t * Compute the number of groups necessary to store nbits bits, and\n\t * progressively work upward through the levels until reaching a level\n\t * that requires only one group.\n\t */\n\tbinfo->levels[0].group_offset = 0;\n\tgroup_count = BITMAP_BITS2GROUPS(nbits);\n\tfor (i = 1; group_count > 1; i++) {\n\t\tassert(i < BITMAP_MAX_LEVELS);\n\t\tbinfo->levels[i].group_offset = binfo->levels[i-1].group_offset\n\t\t + group_count;\n\t\tgroup_count = BITMAP_BITS2GROUPS(group_count);\n\t}\n\tbinfo->levels[i].group_offset = binfo->levels[i-1].group_offset\n\t + group_count;\n\tassert(binfo->levels[i].group_offset <= BITMAP_GROUPS_MAX);\n\tbinfo->nlevels = i;\n\tbinfo->nbits = nbits;\n}\n\nstatic size_t\nbitmap_info_ngroups(const bitmap_info_t *binfo) {\n\treturn binfo->levels[binfo->nlevels].group_offset;\n}\n\nvoid\nbitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo, bool fill) {\n\tsize_t extra;\n\tunsigned i;\n\n\t/*\n\t * Bits are actually inverted with regard to the external bitmap\n\t * interface.\n\t */\n\n\tif (fill) {\n\t\t/* The \"filled\" bitmap starts out with all 0 bits. */\n\t\tmemset(bitmap, 0, bitmap_size(binfo));\n\t\treturn;\n\t}\n\n\t/*\n\t * The \"empty\" bitmap starts out with all 1 bits, except for trailing\n\t * unused bits (if any). Note that each group uses bit 0 to correspond\n\t * to the first logical bit in the group, so extra bits are the most\n\t * significant bits of the last group.\n\t */\n\tmemset(bitmap, 0xffU, bitmap_size(binfo));\n\textra = (BITMAP_GROUP_NBITS - (binfo->nbits & BITMAP_GROUP_NBITS_MASK))\n\t & BITMAP_GROUP_NBITS_MASK;\n\tif (extra != 0) {\n\t\tbitmap[binfo->levels[1].group_offset - 1] >>= extra;\n\t}\n\tfor (i = 1; i < binfo->nlevels; i++) {\n\t\tsize_t group_count = binfo->levels[i].group_offset -\n\t\t binfo->levels[i-1].group_offset;\n\t\textra = (BITMAP_GROUP_NBITS - (group_count &\n\t\t BITMAP_GROUP_NBITS_MASK)) & BITMAP_GROUP_NBITS_MASK;\n\t\tif (extra != 0) {\n\t\t\tbitmap[binfo->levels[i+1].group_offset - 1] >>= extra;\n\t\t}\n\t}\n}\n\n#else /* BITMAP_USE_TREE */\n\nvoid\nbitmap_info_init(bitmap_info_t *binfo, size_t nbits) {\n\tassert(nbits > 0);\n\tassert(nbits <= (ZU(1) << LG_BITMAP_MAXBITS));\n\n\tbinfo->ngroups = BITMAP_BITS2GROUPS(nbits);\n\tbinfo->nbits = nbits;\n}\n\nstatic size_t\nbitmap_info_ngroups(const bitmap_info_t *binfo) {\n\treturn binfo->ngroups;\n}\n\nvoid\nbitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo, bool fill) {\n\tsize_t extra;\n\n\tif (fill) {\n\t\tmemset(bitmap, 0, bitmap_size(binfo));\n\t\treturn;\n\t}\n\n\tmemset(bitmap, 0xffU, bitmap_size(binfo));\n\textra = (BITMAP_GROUP_NBITS - (binfo->nbits & BITMAP_GROUP_NBITS_MASK))\n\t & BITMAP_GROUP_NBITS_MASK;\n\tif (extra != 0) {\n\t\tbitmap[binfo->ngroups - 1] >>= extra;\n\t}\n}\n\n#endif /* BITMAP_USE_TREE */\n\nsize_t\nbitmap_size(const bitmap_info_t *binfo) {\n\treturn (bitmap_info_ngroups(binfo) << LG_SIZEOF_BITMAP);\n}\n" }, { "path": "deps/jemalloc/src/buf_writer.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/buf_writer.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n\nstatic void *\nbuf_writer_allocate_internal_buf(tsdn_t *tsdn, size_t buf_len) {\n#ifdef JEMALLOC_JET\n\tif (buf_len > SC_LARGE_MAXCLASS) {\n\t\treturn NULL;\n\t}\n#else\n\tassert(buf_len <= SC_LARGE_MAXCLASS);\n#endif\n\treturn iallocztm(tsdn, buf_len, sz_size2index(buf_len), false, NULL,\n\t true, arena_get(tsdn, 0, false), true);\n}\n\nstatic void\nbuf_writer_free_internal_buf(tsdn_t *tsdn, void *buf) {\n\tif (buf != NULL) {\n\t\tidalloctm(tsdn, buf, NULL, NULL, true, true);\n\t}\n}\n\nstatic void\nbuf_writer_assert(buf_writer_t *buf_writer) {\n\tassert(buf_writer != NULL);\n\tassert(buf_writer->write_cb != NULL);\n\tif (buf_writer->buf != NULL) {\n\t\tassert(buf_writer->buf_size > 0);\n\t} else {\n\t\tassert(buf_writer->buf_size == 0);\n\t\tassert(buf_writer->internal_buf);\n\t}\n\tassert(buf_writer->buf_end <= buf_writer->buf_size);\n}\n\nbool\nbuf_writer_init(tsdn_t *tsdn, buf_writer_t *buf_writer, write_cb_t *write_cb,\n void *cbopaque, char *buf, size_t buf_len) {\n\tif (write_cb != NULL) {\n\t\tbuf_writer->write_cb = write_cb;\n\t} else {\n\t\tbuf_writer->write_cb = je_malloc_message != NULL ?\n\t\t je_malloc_message : wrtmessage;\n\t}\n\tbuf_writer->cbopaque = cbopaque;\n\tassert(buf_len >= 2);\n\tif (buf != NULL) {\n\t\tbuf_writer->buf = buf;\n\t\tbuf_writer->internal_buf = false;\n\t} else {\n\t\tbuf_writer->buf = buf_writer_allocate_internal_buf(tsdn,\n\t\t buf_len);\n\t\tbuf_writer->internal_buf = true;\n\t}\n\tif (buf_writer->buf != NULL) {\n\t\tbuf_writer->buf_size = buf_len - 1; /* Allowing for '\\0'. */\n\t} else {\n\t\tbuf_writer->buf_size = 0;\n\t}\n\tbuf_writer->buf_end = 0;\n\tbuf_writer_assert(buf_writer);\n\treturn buf_writer->buf == NULL;\n}\n\nvoid\nbuf_writer_flush(buf_writer_t *buf_writer) {\n\tbuf_writer_assert(buf_writer);\n\tif (buf_writer->buf == NULL) {\n\t\treturn;\n\t}\n\tbuf_writer->buf[buf_writer->buf_end] = '\\0';\n\tbuf_writer->write_cb(buf_writer->cbopaque, buf_writer->buf);\n\tbuf_writer->buf_end = 0;\n\tbuf_writer_assert(buf_writer);\n}\n\nvoid\nbuf_writer_cb(void *buf_writer_arg, const char *s) {\n\tbuf_writer_t *buf_writer = (buf_writer_t *)buf_writer_arg;\n\tbuf_writer_assert(buf_writer);\n\tif (buf_writer->buf == NULL) {\n\t\tbuf_writer->write_cb(buf_writer->cbopaque, s);\n\t\treturn;\n\t}\n\tsize_t i, slen, n;\n\tfor (i = 0, slen = strlen(s); i < slen; i += n) {\n\t\tif (buf_writer->buf_end == buf_writer->buf_size) {\n\t\t\tbuf_writer_flush(buf_writer);\n\t\t}\n\t\tsize_t s_remain = slen - i;\n\t\tsize_t buf_remain = buf_writer->buf_size - buf_writer->buf_end;\n\t\tn = s_remain < buf_remain ? s_remain : buf_remain;\n\t\tmemcpy(buf_writer->buf + buf_writer->buf_end, s + i, n);\n\t\tbuf_writer->buf_end += n;\n\t\tbuf_writer_assert(buf_writer);\n\t}\n\tassert(i == slen);\n}\n\nvoid\nbuf_writer_terminate(tsdn_t *tsdn, buf_writer_t *buf_writer) {\n\tbuf_writer_assert(buf_writer);\n\tbuf_writer_flush(buf_writer);\n\tif (buf_writer->internal_buf) {\n\t\tbuf_writer_free_internal_buf(tsdn, buf_writer->buf);\n\t}\n}\n\nvoid\nbuf_writer_pipe(buf_writer_t *buf_writer, read_cb_t *read_cb,\n void *read_cbopaque) {\n\t/*\n\t * A tiny local buffer in case the buffered writer failed to allocate\n\t * at init.\n\t */\n\tstatic char backup_buf[16];\n\tstatic buf_writer_t backup_buf_writer;\n\n\tbuf_writer_assert(buf_writer);\n\tassert(read_cb != NULL);\n\tif (buf_writer->buf == NULL) {\n\t\tbuf_writer_init(TSDN_NULL, &backup_buf_writer,\n\t\t buf_writer->write_cb, buf_writer->cbopaque, backup_buf,\n\t\t sizeof(backup_buf));\n\t\tbuf_writer = &backup_buf_writer;\n\t}\n\tassert(buf_writer->buf != NULL);\n\tssize_t nread = 0;\n\tdo {\n\t\tbuf_writer->buf_end += nread;\n\t\tbuf_writer_assert(buf_writer);\n\t\tif (buf_writer->buf_end == buf_writer->buf_size) {\n\t\t\tbuf_writer_flush(buf_writer);\n\t\t}\n\t\tnread = read_cb(read_cbopaque,\n\t\t buf_writer->buf + buf_writer->buf_end,\n\t\t buf_writer->buf_size - buf_writer->buf_end);\n\t} while (nread > 0);\n\tbuf_writer_flush(buf_writer);\n}\n" }, { "path": "deps/jemalloc/src/cache_bin.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/cache_bin.h\"\n#include \"jemalloc/internal/safety_check.h\"\n\nvoid\ncache_bin_info_init(cache_bin_info_t *info,\n cache_bin_sz_t ncached_max) {\n\tassert(ncached_max <= CACHE_BIN_NCACHED_MAX);\n\tsize_t stack_size = (size_t)ncached_max * sizeof(void *);\n\tassert(stack_size < ((size_t)1 << (sizeof(cache_bin_sz_t) * 8)));\n\tinfo->ncached_max = (cache_bin_sz_t)ncached_max;\n}\n\nvoid\ncache_bin_info_compute_alloc(cache_bin_info_t *infos, szind_t ninfos,\n size_t *size, size_t *alignment) {\n\t/* For the total bin stack region (per tcache), reserve 2 more slots so\n\t * that\n\t * 1) the empty position can be safely read on the fast path before\n\t * checking \"is_empty\"; and\n\t * 2) the cur_ptr can go beyond the empty position by 1 step safely on\n\t * the fast path (i.e. no overflow).\n\t */\n\t*size = sizeof(void *) * 2;\n\tfor (szind_t i = 0; i < ninfos; i++) {\n\t\tassert(infos[i].ncached_max > 0);\n\t\t*size += infos[i].ncached_max * sizeof(void *);\n\t}\n\n\t/*\n\t * Align to at least PAGE, to minimize the # of TLBs needed by the\n\t * smaller sizes; also helps if the larger sizes don't get used at all.\n\t */\n\t*alignment = PAGE;\n}\n\nvoid\ncache_bin_preincrement(cache_bin_info_t *infos, szind_t ninfos, void *alloc,\n size_t *cur_offset) {\n\tif (config_debug) {\n\t\tsize_t computed_size;\n\t\tsize_t computed_alignment;\n\n\t\t/* Pointer should be as aligned as we asked for. */\n\t\tcache_bin_info_compute_alloc(infos, ninfos, &computed_size,\n\t\t &computed_alignment);\n\t\tassert(((uintptr_t)alloc & (computed_alignment - 1)) == 0);\n\t}\n\n\t*(uintptr_t *)((uintptr_t)alloc + *cur_offset) =\n\t cache_bin_preceding_junk;\n\t*cur_offset += sizeof(void *);\n}\n\nvoid\ncache_bin_postincrement(cache_bin_info_t *infos, szind_t ninfos, void *alloc,\n size_t *cur_offset) {\n\t*(uintptr_t *)((uintptr_t)alloc + *cur_offset) =\n\t cache_bin_trailing_junk;\n\t*cur_offset += sizeof(void *);\n}\n\nvoid\ncache_bin_init(cache_bin_t *bin, cache_bin_info_t *info, void *alloc,\n size_t *cur_offset) {\n\t/*\n\t * The full_position points to the lowest available space. Allocations\n\t * will access the slots toward higher addresses (for the benefit of\n\t * adjacent prefetch).\n\t */\n\tvoid *stack_cur = (void *)((uintptr_t)alloc + *cur_offset);\n\tvoid *full_position = stack_cur;\n\tuint16_t bin_stack_size = info->ncached_max * sizeof(void *);\n\n\t*cur_offset += bin_stack_size;\n\tvoid *empty_position = (void *)((uintptr_t)alloc + *cur_offset);\n\n\t/* Init to the empty position. */\n\tbin->stack_head = (void **)empty_position;\n\tbin->low_bits_low_water = (uint16_t)(uintptr_t)bin->stack_head;\n\tbin->low_bits_full = (uint16_t)(uintptr_t)full_position;\n\tbin->low_bits_empty = (uint16_t)(uintptr_t)empty_position;\n\tcache_bin_sz_t free_spots = cache_bin_diff(bin,\n\t bin->low_bits_full, (uint16_t)(uintptr_t)bin->stack_head,\n\t /* racy */ false);\n\tassert(free_spots == bin_stack_size);\n\tassert(cache_bin_ncached_get_local(bin, info) == 0);\n\tassert(cache_bin_empty_position_get(bin) == empty_position);\n\n\tassert(bin_stack_size > 0 || empty_position == full_position);\n}\n\nbool\ncache_bin_still_zero_initialized(cache_bin_t *bin) {\n\treturn bin->stack_head == NULL;\n}\n" }, { "path": "deps/jemalloc/src/ckh.c", "content": "/*\n *******************************************************************************\n * Implementation of (2^1+,2) cuckoo hashing, where 2^1+ indicates that each\n * hash bucket contains 2^n cells, for n >= 1, and 2 indicates that two hash\n * functions are employed. The original cuckoo hashing algorithm was described\n * in:\n *\n * Pagh, R., F.F. Rodler (2004) Cuckoo Hashing. Journal of Algorithms\n * 51(2):122-144.\n *\n * Generalization of cuckoo hashing was discussed in:\n *\n * Erlingsson, U., M. Manasse, F. McSherry (2006) A cool and practical\n * alternative to traditional hash tables. In Proceedings of the 7th\n * Workshop on Distributed Data and Structures (WDAS'06), Santa Clara, CA,\n * January 2006.\n *\n * This implementation uses precisely two hash functions because that is the\n * fewest that can work, and supporting multiple hashes is an implementation\n * burden. Here is a reproduction of Figure 1 from Erlingsson et al. (2006)\n * that shows approximate expected maximum load factors for various\n * configurations:\n *\n * | #cells/bucket |\n * #hashes | 1 | 2 | 4 | 8 |\n * --------+-------+-------+-------+-------+\n * 1 | 0.006 | 0.006 | 0.03 | 0.12 |\n * 2 | 0.49 | 0.86 |>0.93< |>0.96< |\n * 3 | 0.91 | 0.97 | 0.98 | 0.999 |\n * 4 | 0.97 | 0.99 | 0.999 | |\n *\n * The number of cells per bucket is chosen such that a bucket fits in one cache\n * line. So, on 32- and 64-bit systems, we use (8,2) and (4,2) cuckoo hashing,\n * respectively.\n *\n ******************************************************************************/\n#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n#include \"jemalloc/internal/ckh.h\"\n\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/hash.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/prng.h\"\n#include \"jemalloc/internal/util.h\"\n\n/******************************************************************************/\n/* Function prototypes for non-inline static functions. */\n\nstatic bool\tckh_grow(tsd_t *tsd, ckh_t *ckh);\nstatic void\tckh_shrink(tsd_t *tsd, ckh_t *ckh);\n\n/******************************************************************************/\n\n/*\n * Search bucket for key and return the cell number if found; SIZE_T_MAX\n * otherwise.\n */\nstatic size_t\nckh_bucket_search(ckh_t *ckh, size_t bucket, const void *key) {\n\tckhc_t *cell;\n\tunsigned i;\n\n\tfor (i = 0; i < (ZU(1) << LG_CKH_BUCKET_CELLS); i++) {\n\t\tcell = &ckh->tab[(bucket << LG_CKH_BUCKET_CELLS) + i];\n\t\tif (cell->key != NULL && ckh->keycomp(key, cell->key)) {\n\t\t\treturn (bucket << LG_CKH_BUCKET_CELLS) + i;\n\t\t}\n\t}\n\n\treturn SIZE_T_MAX;\n}\n\n/*\n * Search table for key and return cell number if found; SIZE_T_MAX otherwise.\n */\nstatic size_t\nckh_isearch(ckh_t *ckh, const void *key) {\n\tsize_t hashes[2], bucket, cell;\n\n\tassert(ckh != NULL);\n\n\tckh->hash(key, hashes);\n\n\t/* Search primary bucket. */\n\tbucket = hashes[0] & ((ZU(1) << ckh->lg_curbuckets) - 1);\n\tcell = ckh_bucket_search(ckh, bucket, key);\n\tif (cell != SIZE_T_MAX) {\n\t\treturn cell;\n\t}\n\n\t/* Search secondary bucket. */\n\tbucket = hashes[1] & ((ZU(1) << ckh->lg_curbuckets) - 1);\n\tcell = ckh_bucket_search(ckh, bucket, key);\n\treturn cell;\n}\n\nstatic bool\nckh_try_bucket_insert(ckh_t *ckh, size_t bucket, const void *key,\n const void *data) {\n\tckhc_t *cell;\n\tunsigned offset, i;\n\n\t/*\n\t * Cycle through the cells in the bucket, starting at a random position.\n\t * The randomness avoids worst-case search overhead as buckets fill up.\n\t */\n\toffset = (unsigned)prng_lg_range_u64(&ckh->prng_state,\n\t LG_CKH_BUCKET_CELLS);\n\tfor (i = 0; i < (ZU(1) << LG_CKH_BUCKET_CELLS); i++) {\n\t\tcell = &ckh->tab[(bucket << LG_CKH_BUCKET_CELLS) +\n\t\t ((i + offset) & ((ZU(1) << LG_CKH_BUCKET_CELLS) - 1))];\n\t\tif (cell->key == NULL) {\n\t\t\tcell->key = key;\n\t\t\tcell->data = data;\n\t\t\tckh->count++;\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\n/*\n * No space is available in bucket. Randomly evict an item, then try to find an\n * alternate location for that item. Iteratively repeat this\n * eviction/relocation procedure until either success or detection of an\n * eviction/relocation bucket cycle.\n */\nstatic bool\nckh_evict_reloc_insert(ckh_t *ckh, size_t argbucket, void const **argkey,\n void const **argdata) {\n\tconst void *key, *data, *tkey, *tdata;\n\tckhc_t *cell;\n\tsize_t hashes[2], bucket, tbucket;\n\tunsigned i;\n\n\tbucket = argbucket;\n\tkey = *argkey;\n\tdata = *argdata;\n\twhile (true) {\n\t\t/*\n\t\t * Choose a random item within the bucket to evict. This is\n\t\t * critical to correct function, because without (eventually)\n\t\t * evicting all items within a bucket during iteration, it\n\t\t * would be possible to get stuck in an infinite loop if there\n\t\t * were an item for which both hashes indicated the same\n\t\t * bucket.\n\t\t */\n\t\ti = (unsigned)prng_lg_range_u64(&ckh->prng_state,\n\t\t LG_CKH_BUCKET_CELLS);\n\t\tcell = &ckh->tab[(bucket << LG_CKH_BUCKET_CELLS) + i];\n\t\tassert(cell->key != NULL);\n\n\t\t/* Swap cell->{key,data} and {key,data} (evict). */\n\t\ttkey = cell->key; tdata = cell->data;\n\t\tcell->key = key; cell->data = data;\n\t\tkey = tkey; data = tdata;\n\n#ifdef CKH_COUNT\n\t\tckh->nrelocs++;\n#endif\n\n\t\t/* Find the alternate bucket for the evicted item. */\n\t\tckh->hash(key, hashes);\n\t\ttbucket = hashes[1] & ((ZU(1) << ckh->lg_curbuckets) - 1);\n\t\tif (tbucket == bucket) {\n\t\t\ttbucket = hashes[0] & ((ZU(1) << ckh->lg_curbuckets)\n\t\t\t - 1);\n\t\t\t/*\n\t\t\t * It may be that (tbucket == bucket) still, if the\n\t\t\t * item's hashes both indicate this bucket. However,\n\t\t\t * we are guaranteed to eventually escape this bucket\n\t\t\t * during iteration, assuming pseudo-random item\n\t\t\t * selection (true randomness would make infinite\n\t\t\t * looping a remote possibility). The reason we can\n\t\t\t * never get trapped forever is that there are two\n\t\t\t * cases:\n\t\t\t *\n\t\t\t * 1) This bucket == argbucket, so we will quickly\n\t\t\t * detect an eviction cycle and terminate.\n\t\t\t * 2) An item was evicted to this bucket from another,\n\t\t\t * which means that at least one item in this bucket\n\t\t\t * has hashes that indicate distinct buckets.\n\t\t\t */\n\t\t}\n\t\t/* Check for a cycle. */\n\t\tif (tbucket == argbucket) {\n\t\t\t*argkey = key;\n\t\t\t*argdata = data;\n\t\t\treturn true;\n\t\t}\n\n\t\tbucket = tbucket;\n\t\tif (!ckh_try_bucket_insert(ckh, bucket, key, data)) {\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\nstatic bool\nckh_try_insert(ckh_t *ckh, void const**argkey, void const**argdata) {\n\tsize_t hashes[2], bucket;\n\tconst void *key = *argkey;\n\tconst void *data = *argdata;\n\n\tckh->hash(key, hashes);\n\n\t/* Try to insert in primary bucket. */\n\tbucket = hashes[0] & ((ZU(1) << ckh->lg_curbuckets) - 1);\n\tif (!ckh_try_bucket_insert(ckh, bucket, key, data)) {\n\t\treturn false;\n\t}\n\n\t/* Try to insert in secondary bucket. */\n\tbucket = hashes[1] & ((ZU(1) << ckh->lg_curbuckets) - 1);\n\tif (!ckh_try_bucket_insert(ckh, bucket, key, data)) {\n\t\treturn false;\n\t}\n\n\t/*\n\t * Try to find a place for this item via iterative eviction/relocation.\n\t */\n\treturn ckh_evict_reloc_insert(ckh, bucket, argkey, argdata);\n}\n\n/*\n * Try to rebuild the hash table from scratch by inserting all items from the\n * old table into the new.\n */\nstatic bool\nckh_rebuild(ckh_t *ckh, ckhc_t *aTab) {\n\tsize_t count, i, nins;\n\tconst void *key, *data;\n\n\tcount = ckh->count;\n\tckh->count = 0;\n\tfor (i = nins = 0; nins < count; i++) {\n\t\tif (aTab[i].key != NULL) {\n\t\t\tkey = aTab[i].key;\n\t\t\tdata = aTab[i].data;\n\t\t\tif (ckh_try_insert(ckh, &key, &data)) {\n\t\t\t\tckh->count = count;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tnins++;\n\t\t}\n\t}\n\n\treturn false;\n}\n\nstatic bool\nckh_grow(tsd_t *tsd, ckh_t *ckh) {\n\tbool ret;\n\tckhc_t *tab, *ttab;\n\tunsigned lg_prevbuckets, lg_curcells;\n\n#ifdef CKH_COUNT\n\tckh->ngrows++;\n#endif\n\n\t/*\n\t * It is possible (though unlikely, given well behaved hashes) that the\n\t * table will have to be doubled more than once in order to create a\n\t * usable table.\n\t */\n\tlg_prevbuckets = ckh->lg_curbuckets;\n\tlg_curcells = ckh->lg_curbuckets + LG_CKH_BUCKET_CELLS;\n\twhile (true) {\n\t\tsize_t usize;\n\n\t\tlg_curcells++;\n\t\tusize = sz_sa2u(sizeof(ckhc_t) << lg_curcells, CACHELINE);\n\t\tif (unlikely(usize == 0\n\t\t || usize > SC_LARGE_MAXCLASS)) {\n\t\t\tret = true;\n\t\t\tgoto label_return;\n\t\t}\n\t\ttab = (ckhc_t *)ipallocztm(tsd_tsdn(tsd), usize, CACHELINE,\n\t\t true, NULL, true, arena_ichoose(tsd, NULL));\n\t\tif (tab == NULL) {\n\t\t\tret = true;\n\t\t\tgoto label_return;\n\t\t}\n\t\t/* Swap in new table. */\n\t\tttab = ckh->tab;\n\t\tckh->tab = tab;\n\t\ttab = ttab;\n\t\tckh->lg_curbuckets = lg_curcells - LG_CKH_BUCKET_CELLS;\n\n\t\tif (!ckh_rebuild(ckh, tab)) {\n\t\t\tidalloctm(tsd_tsdn(tsd), tab, NULL, NULL, true, true);\n\t\t\tbreak;\n\t\t}\n\n\t\t/* Rebuilding failed, so back out partially rebuilt table. */\n\t\tidalloctm(tsd_tsdn(tsd), ckh->tab, NULL, NULL, true, true);\n\t\tckh->tab = tab;\n\t\tckh->lg_curbuckets = lg_prevbuckets;\n\t}\n\n\tret = false;\nlabel_return:\n\treturn ret;\n}\n\nstatic void\nckh_shrink(tsd_t *tsd, ckh_t *ckh) {\n\tckhc_t *tab, *ttab;\n\tsize_t usize;\n\tunsigned lg_prevbuckets, lg_curcells;\n\n\t/*\n\t * It is possible (though unlikely, given well behaved hashes) that the\n\t * table rebuild will fail.\n\t */\n\tlg_prevbuckets = ckh->lg_curbuckets;\n\tlg_curcells = ckh->lg_curbuckets + LG_CKH_BUCKET_CELLS - 1;\n\tusize = sz_sa2u(sizeof(ckhc_t) << lg_curcells, CACHELINE);\n\tif (unlikely(usize == 0 || usize > SC_LARGE_MAXCLASS)) {\n\t\treturn;\n\t}\n\ttab = (ckhc_t *)ipallocztm(tsd_tsdn(tsd), usize, CACHELINE, true, NULL,\n\t true, arena_ichoose(tsd, NULL));\n\tif (tab == NULL) {\n\t\t/*\n\t\t * An OOM error isn't worth propagating, since it doesn't\n\t\t * prevent this or future operations from proceeding.\n\t\t */\n\t\treturn;\n\t}\n\t/* Swap in new table. */\n\tttab = ckh->tab;\n\tckh->tab = tab;\n\ttab = ttab;\n\tckh->lg_curbuckets = lg_curcells - LG_CKH_BUCKET_CELLS;\n\n\tif (!ckh_rebuild(ckh, tab)) {\n\t\tidalloctm(tsd_tsdn(tsd), tab, NULL, NULL, true, true);\n#ifdef CKH_COUNT\n\t\tckh->nshrinks++;\n#endif\n\t\treturn;\n\t}\n\n\t/* Rebuilding failed, so back out partially rebuilt table. */\n\tidalloctm(tsd_tsdn(tsd), ckh->tab, NULL, NULL, true, true);\n\tckh->tab = tab;\n\tckh->lg_curbuckets = lg_prevbuckets;\n#ifdef CKH_COUNT\n\tckh->nshrinkfails++;\n#endif\n}\n\nbool\nckh_new(tsd_t *tsd, ckh_t *ckh, size_t minitems, ckh_hash_t *ckh_hash,\n ckh_keycomp_t *keycomp) {\n\tbool ret;\n\tsize_t mincells, usize;\n\tunsigned lg_mincells;\n\n\tassert(minitems > 0);\n\tassert(ckh_hash != NULL);\n\tassert(keycomp != NULL);\n\n#ifdef CKH_COUNT\n\tckh->ngrows = 0;\n\tckh->nshrinks = 0;\n\tckh->nshrinkfails = 0;\n\tckh->ninserts = 0;\n\tckh->nrelocs = 0;\n#endif\n\tckh->prng_state = 42; /* Value doesn't really matter. */\n\tckh->count = 0;\n\n\t/*\n\t * Find the minimum power of 2 that is large enough to fit minitems\n\t * entries. We are using (2+,2) cuckoo hashing, which has an expected\n\t * maximum load factor of at least ~0.86, so 0.75 is a conservative load\n\t * factor that will typically allow mincells items to fit without ever\n\t * growing the table.\n\t */\n\tassert(LG_CKH_BUCKET_CELLS > 0);\n\tmincells = ((minitems + (3 - (minitems % 3))) / 3) << 2;\n\tfor (lg_mincells = LG_CKH_BUCKET_CELLS;\n\t (ZU(1) << lg_mincells) < mincells;\n\t lg_mincells++) {\n\t\t/* Do nothing. */\n\t}\n\tckh->lg_minbuckets = lg_mincells - LG_CKH_BUCKET_CELLS;\n\tckh->lg_curbuckets = lg_mincells - LG_CKH_BUCKET_CELLS;\n\tckh->hash = ckh_hash;\n\tckh->keycomp = keycomp;\n\n\tusize = sz_sa2u(sizeof(ckhc_t) << lg_mincells, CACHELINE);\n\tif (unlikely(usize == 0 || usize > SC_LARGE_MAXCLASS)) {\n\t\tret = true;\n\t\tgoto label_return;\n\t}\n\tckh->tab = (ckhc_t *)ipallocztm(tsd_tsdn(tsd), usize, CACHELINE, true,\n\t NULL, true, arena_ichoose(tsd, NULL));\n\tif (ckh->tab == NULL) {\n\t\tret = true;\n\t\tgoto label_return;\n\t}\n\n\tret = false;\nlabel_return:\n\treturn ret;\n}\n\nvoid\nckh_delete(tsd_t *tsd, ckh_t *ckh) {\n\tassert(ckh != NULL);\n\n#ifdef CKH_VERBOSE\n\tmalloc_printf(\n\t \"%s(%p): ngrows: %\"FMTu64\", nshrinks: %\"FMTu64\",\"\n\t \" nshrinkfails: %\"FMTu64\", ninserts: %\"FMTu64\",\"\n\t \" nrelocs: %\"FMTu64\"\\n\", __func__, ckh,\n\t (unsigned long long)ckh->ngrows,\n\t (unsigned long long)ckh->nshrinks,\n\t (unsigned long long)ckh->nshrinkfails,\n\t (unsigned long long)ckh->ninserts,\n\t (unsigned long long)ckh->nrelocs);\n#endif\n\n\tidalloctm(tsd_tsdn(tsd), ckh->tab, NULL, NULL, true, true);\n\tif (config_debug) {\n\t\tmemset(ckh, JEMALLOC_FREE_JUNK, sizeof(ckh_t));\n\t}\n}\n\nsize_t\nckh_count(ckh_t *ckh) {\n\tassert(ckh != NULL);\n\n\treturn ckh->count;\n}\n\nbool\nckh_iter(ckh_t *ckh, size_t *tabind, void **key, void **data) {\n\tsize_t i, ncells;\n\n\tfor (i = *tabind, ncells = (ZU(1) << (ckh->lg_curbuckets +\n\t LG_CKH_BUCKET_CELLS)); i < ncells; i++) {\n\t\tif (ckh->tab[i].key != NULL) {\n\t\t\tif (key != NULL) {\n\t\t\t\t*key = (void *)ckh->tab[i].key;\n\t\t\t}\n\t\t\tif (data != NULL) {\n\t\t\t\t*data = (void *)ckh->tab[i].data;\n\t\t\t}\n\t\t\t*tabind = i + 1;\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\nbool\nckh_insert(tsd_t *tsd, ckh_t *ckh, const void *key, const void *data) {\n\tbool ret;\n\n\tassert(ckh != NULL);\n\tassert(ckh_search(ckh, key, NULL, NULL));\n\n#ifdef CKH_COUNT\n\tckh->ninserts++;\n#endif\n\n\twhile (ckh_try_insert(ckh, &key, &data)) {\n\t\tif (ckh_grow(tsd, ckh)) {\n\t\t\tret = true;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\n\tret = false;\nlabel_return:\n\treturn ret;\n}\n\nbool\nckh_remove(tsd_t *tsd, ckh_t *ckh, const void *searchkey, void **key,\n void **data) {\n\tsize_t cell;\n\n\tassert(ckh != NULL);\n\n\tcell = ckh_isearch(ckh, searchkey);\n\tif (cell != SIZE_T_MAX) {\n\t\tif (key != NULL) {\n\t\t\t*key = (void *)ckh->tab[cell].key;\n\t\t}\n\t\tif (data != NULL) {\n\t\t\t*data = (void *)ckh->tab[cell].data;\n\t\t}\n\t\tckh->tab[cell].key = NULL;\n\t\tckh->tab[cell].data = NULL; /* Not necessary. */\n\n\t\tckh->count--;\n\t\t/* Try to halve the table if it is less than 1/4 full. */\n\t\tif (ckh->count < (ZU(1) << (ckh->lg_curbuckets\n\t\t + LG_CKH_BUCKET_CELLS - 2)) && ckh->lg_curbuckets\n\t\t > ckh->lg_minbuckets) {\n\t\t\t/* Ignore error due to OOM. */\n\t\t\tckh_shrink(tsd, ckh);\n\t\t}\n\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\nbool\nckh_search(ckh_t *ckh, const void *searchkey, void **key, void **data) {\n\tsize_t cell;\n\n\tassert(ckh != NULL);\n\n\tcell = ckh_isearch(ckh, searchkey);\n\tif (cell != SIZE_T_MAX) {\n\t\tif (key != NULL) {\n\t\t\t*key = (void *)ckh->tab[cell].key;\n\t\t}\n\t\tif (data != NULL) {\n\t\t\t*data = (void *)ckh->tab[cell].data;\n\t\t}\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\nvoid\nckh_string_hash(const void *key, size_t r_hash[2]) {\n\thash(key, strlen((const char *)key), 0x94122f33U, r_hash);\n}\n\nbool\nckh_string_keycomp(const void *k1, const void *k2) {\n\tassert(k1 != NULL);\n\tassert(k2 != NULL);\n\n\treturn !strcmp((char *)k1, (char *)k2);\n}\n\nvoid\nckh_pointer_hash(const void *key, size_t r_hash[2]) {\n\tunion {\n\t\tconst void\t*v;\n\t\tsize_t\t\ti;\n\t} u;\n\n\tassert(sizeof(u.v) == sizeof(u.i));\n\tu.v = key;\n\thash(&u.i, sizeof(u.i), 0xd983396eU, r_hash);\n}\n\nbool\nckh_pointer_keycomp(const void *k1, const void *k2) {\n\treturn (k1 == k2);\n}\n" }, { "path": "deps/jemalloc/src/counter.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/counter.h\"\n\nbool\ncounter_accum_init(counter_accum_t *counter, uint64_t interval) {\n\tif (LOCKEDINT_MTX_INIT(counter->mtx, \"counter_accum\",\n\t WITNESS_RANK_COUNTER_ACCUM, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tlocked_init_u64_unsynchronized(&counter->accumbytes, 0);\n\tcounter->interval = interval;\n\treturn false;\n}\n\nvoid\ncounter_prefork(tsdn_t *tsdn, counter_accum_t *counter) {\n\tLOCKEDINT_MTX_PREFORK(tsdn, counter->mtx);\n}\n\nvoid\ncounter_postfork_parent(tsdn_t *tsdn, counter_accum_t *counter) {\n\tLOCKEDINT_MTX_POSTFORK_PARENT(tsdn, counter->mtx);\n}\n\nvoid\ncounter_postfork_child(tsdn_t *tsdn, counter_accum_t *counter) {\n\tLOCKEDINT_MTX_POSTFORK_CHILD(tsdn, counter->mtx);\n}\n" }, { "path": "deps/jemalloc/src/ctl.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/inspect.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/nstime.h\"\n#include \"jemalloc/internal/peak_event.h\"\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_log.h\"\n#include \"jemalloc/internal/prof_recent.h\"\n#include \"jemalloc/internal/prof_stats.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/util.h\"\n\n/******************************************************************************/\n/* Data. */\n\n/*\n * ctl_mtx protects the following:\n * - ctl_stats->*\n */\nstatic malloc_mutex_t\tctl_mtx;\nstatic bool\t\tctl_initialized;\nstatic ctl_stats_t\t*ctl_stats;\nstatic ctl_arenas_t\t*ctl_arenas;\n\n/******************************************************************************/\n/* Helpers for named and indexed nodes. */\n\nstatic const ctl_named_node_t *\nctl_named_node(const ctl_node_t *node) {\n\treturn ((node->named) ? (const ctl_named_node_t *)node : NULL);\n}\n\nstatic const ctl_named_node_t *\nctl_named_children(const ctl_named_node_t *node, size_t index) {\n\tconst ctl_named_node_t *children = ctl_named_node(node->children);\n\n\treturn (children ? &children[index] : NULL);\n}\n\nstatic const ctl_indexed_node_t *\nctl_indexed_node(const ctl_node_t *node) {\n\treturn (!node->named ? (const ctl_indexed_node_t *)node : NULL);\n}\n\n/******************************************************************************/\n/* Function prototypes for non-inline static functions. */\n\n#define CTL_PROTO(n)\t\t\t\t\t\t\t\\\nstatic int\tn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\t\\\n void *oldp, size_t *oldlenp, void *newp, size_t newlen);\n\n#define INDEX_PROTO(n)\t\t\t\t\t\t\t\\\nstatic const ctl_named_node_t\t*n##_index(tsdn_t *tsdn,\t\t\\\n const size_t *mib, size_t miblen, size_t i);\n\nCTL_PROTO(version)\nCTL_PROTO(epoch)\nCTL_PROTO(background_thread)\nCTL_PROTO(max_background_threads)\nCTL_PROTO(thread_tcache_enabled)\nCTL_PROTO(thread_tcache_flush)\nCTL_PROTO(thread_peak_read)\nCTL_PROTO(thread_peak_reset)\nCTL_PROTO(thread_prof_name)\nCTL_PROTO(thread_prof_active)\nCTL_PROTO(thread_arena)\nCTL_PROTO(thread_allocated)\nCTL_PROTO(thread_allocatedp)\nCTL_PROTO(thread_deallocated)\nCTL_PROTO(thread_deallocatedp)\nCTL_PROTO(thread_idle)\nCTL_PROTO(config_cache_oblivious)\nCTL_PROTO(config_debug)\nCTL_PROTO(config_fill)\nCTL_PROTO(config_lazy_lock)\nCTL_PROTO(config_malloc_conf)\nCTL_PROTO(config_opt_safety_checks)\nCTL_PROTO(config_prof)\nCTL_PROTO(config_prof_libgcc)\nCTL_PROTO(config_prof_libunwind)\nCTL_PROTO(config_stats)\nCTL_PROTO(config_utrace)\nCTL_PROTO(config_xmalloc)\nCTL_PROTO(opt_abort)\nCTL_PROTO(opt_abort_conf)\nCTL_PROTO(opt_cache_oblivious)\nCTL_PROTO(opt_trust_madvise)\nCTL_PROTO(opt_confirm_conf)\nCTL_PROTO(opt_hpa)\nCTL_PROTO(opt_hpa_slab_max_alloc)\nCTL_PROTO(opt_hpa_hugification_threshold)\nCTL_PROTO(opt_hpa_hugify_delay_ms)\nCTL_PROTO(opt_hpa_min_purge_interval_ms)\nCTL_PROTO(opt_hpa_dirty_mult)\nCTL_PROTO(opt_hpa_sec_nshards)\nCTL_PROTO(opt_hpa_sec_max_alloc)\nCTL_PROTO(opt_hpa_sec_max_bytes)\nCTL_PROTO(opt_hpa_sec_bytes_after_flush)\nCTL_PROTO(opt_hpa_sec_batch_fill_extra)\nCTL_PROTO(opt_metadata_thp)\nCTL_PROTO(opt_retain)\nCTL_PROTO(opt_dss)\nCTL_PROTO(opt_narenas)\nCTL_PROTO(opt_percpu_arena)\nCTL_PROTO(opt_oversize_threshold)\nCTL_PROTO(opt_background_thread)\nCTL_PROTO(opt_mutex_max_spin)\nCTL_PROTO(opt_max_background_threads)\nCTL_PROTO(opt_dirty_decay_ms)\nCTL_PROTO(opt_muzzy_decay_ms)\nCTL_PROTO(opt_stats_print)\nCTL_PROTO(opt_stats_print_opts)\nCTL_PROTO(opt_stats_interval)\nCTL_PROTO(opt_stats_interval_opts)\nCTL_PROTO(opt_junk)\nCTL_PROTO(opt_zero)\nCTL_PROTO(opt_utrace)\nCTL_PROTO(opt_xmalloc)\nCTL_PROTO(opt_experimental_infallible_new)\nCTL_PROTO(opt_tcache)\nCTL_PROTO(opt_tcache_max)\nCTL_PROTO(opt_tcache_nslots_small_min)\nCTL_PROTO(opt_tcache_nslots_small_max)\nCTL_PROTO(opt_tcache_nslots_large)\nCTL_PROTO(opt_lg_tcache_nslots_mul)\nCTL_PROTO(opt_tcache_gc_incr_bytes)\nCTL_PROTO(opt_tcache_gc_delay_bytes)\nCTL_PROTO(opt_lg_tcache_flush_small_div)\nCTL_PROTO(opt_lg_tcache_flush_large_div)\nCTL_PROTO(opt_thp)\nCTL_PROTO(opt_lg_extent_max_active_fit)\nCTL_PROTO(opt_prof)\nCTL_PROTO(opt_prof_prefix)\nCTL_PROTO(opt_prof_active)\nCTL_PROTO(opt_prof_thread_active_init)\nCTL_PROTO(opt_lg_prof_sample)\nCTL_PROTO(opt_lg_prof_interval)\nCTL_PROTO(opt_prof_gdump)\nCTL_PROTO(opt_prof_final)\nCTL_PROTO(opt_prof_leak)\nCTL_PROTO(opt_prof_leak_error)\nCTL_PROTO(opt_prof_accum)\nCTL_PROTO(opt_prof_recent_alloc_max)\nCTL_PROTO(opt_prof_stats)\nCTL_PROTO(opt_prof_sys_thread_name)\nCTL_PROTO(opt_prof_time_res)\nCTL_PROTO(opt_lg_san_uaf_align)\nCTL_PROTO(opt_zero_realloc)\nCTL_PROTO(tcache_create)\nCTL_PROTO(tcache_flush)\nCTL_PROTO(tcache_destroy)\nCTL_PROTO(arena_i_initialized)\nCTL_PROTO(arena_i_decay)\nCTL_PROTO(arena_i_purge)\nCTL_PROTO(arena_i_reset)\nCTL_PROTO(arena_i_destroy)\nCTL_PROTO(arena_i_dss)\nCTL_PROTO(arena_i_oversize_threshold)\nCTL_PROTO(arena_i_dirty_decay_ms)\nCTL_PROTO(arena_i_muzzy_decay_ms)\nCTL_PROTO(arena_i_extent_hooks)\nCTL_PROTO(arena_i_retain_grow_limit)\nINDEX_PROTO(arena_i)\nCTL_PROTO(arenas_bin_i_size)\nCTL_PROTO(arenas_bin_i_nregs)\nCTL_PROTO(arenas_bin_i_slab_size)\nCTL_PROTO(arenas_bin_i_nshards)\nINDEX_PROTO(arenas_bin_i)\nCTL_PROTO(arenas_lextent_i_size)\nINDEX_PROTO(arenas_lextent_i)\nCTL_PROTO(arenas_narenas)\nCTL_PROTO(arenas_dirty_decay_ms)\nCTL_PROTO(arenas_muzzy_decay_ms)\nCTL_PROTO(arenas_quantum)\nCTL_PROTO(arenas_page)\nCTL_PROTO(arenas_tcache_max)\nCTL_PROTO(arenas_nbins)\nCTL_PROTO(arenas_nhbins)\nCTL_PROTO(arenas_nlextents)\nCTL_PROTO(arenas_create)\nCTL_PROTO(arenas_lookup)\nCTL_PROTO(prof_thread_active_init)\nCTL_PROTO(prof_active)\nCTL_PROTO(prof_dump)\nCTL_PROTO(prof_gdump)\nCTL_PROTO(prof_prefix)\nCTL_PROTO(prof_reset)\nCTL_PROTO(prof_interval)\nCTL_PROTO(lg_prof_sample)\nCTL_PROTO(prof_log_start)\nCTL_PROTO(prof_log_stop)\nCTL_PROTO(prof_stats_bins_i_live)\nCTL_PROTO(prof_stats_bins_i_accum)\nINDEX_PROTO(prof_stats_bins_i)\nCTL_PROTO(prof_stats_lextents_i_live)\nCTL_PROTO(prof_stats_lextents_i_accum)\nINDEX_PROTO(prof_stats_lextents_i)\nCTL_PROTO(stats_arenas_i_small_allocated)\nCTL_PROTO(stats_arenas_i_small_nmalloc)\nCTL_PROTO(stats_arenas_i_small_ndalloc)\nCTL_PROTO(stats_arenas_i_small_nrequests)\nCTL_PROTO(stats_arenas_i_small_nfills)\nCTL_PROTO(stats_arenas_i_small_nflushes)\nCTL_PROTO(stats_arenas_i_large_allocated)\nCTL_PROTO(stats_arenas_i_large_nmalloc)\nCTL_PROTO(stats_arenas_i_large_ndalloc)\nCTL_PROTO(stats_arenas_i_large_nrequests)\nCTL_PROTO(stats_arenas_i_large_nfills)\nCTL_PROTO(stats_arenas_i_large_nflushes)\nCTL_PROTO(stats_arenas_i_bins_j_nmalloc)\nCTL_PROTO(stats_arenas_i_bins_j_ndalloc)\nCTL_PROTO(stats_arenas_i_bins_j_nrequests)\nCTL_PROTO(stats_arenas_i_bins_j_curregs)\nCTL_PROTO(stats_arenas_i_bins_j_nfills)\nCTL_PROTO(stats_arenas_i_bins_j_nflushes)\nCTL_PROTO(stats_arenas_i_bins_j_nslabs)\nCTL_PROTO(stats_arenas_i_bins_j_nreslabs)\nCTL_PROTO(stats_arenas_i_bins_j_curslabs)\nCTL_PROTO(stats_arenas_i_bins_j_nonfull_slabs)\nINDEX_PROTO(stats_arenas_i_bins_j)\nCTL_PROTO(stats_arenas_i_lextents_j_nmalloc)\nCTL_PROTO(stats_arenas_i_lextents_j_ndalloc)\nCTL_PROTO(stats_arenas_i_lextents_j_nrequests)\nCTL_PROTO(stats_arenas_i_lextents_j_curlextents)\nINDEX_PROTO(stats_arenas_i_lextents_j)\nCTL_PROTO(stats_arenas_i_extents_j_ndirty)\nCTL_PROTO(stats_arenas_i_extents_j_nmuzzy)\nCTL_PROTO(stats_arenas_i_extents_j_nretained)\nCTL_PROTO(stats_arenas_i_extents_j_dirty_bytes)\nCTL_PROTO(stats_arenas_i_extents_j_muzzy_bytes)\nCTL_PROTO(stats_arenas_i_extents_j_retained_bytes)\nINDEX_PROTO(stats_arenas_i_extents_j)\nCTL_PROTO(stats_arenas_i_hpa_shard_npurge_passes)\nCTL_PROTO(stats_arenas_i_hpa_shard_npurges)\nCTL_PROTO(stats_arenas_i_hpa_shard_nhugifies)\nCTL_PROTO(stats_arenas_i_hpa_shard_ndehugifies)\n\n/* We have a set of stats for full slabs. */\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_npageslabs_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_npageslabs_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_nactive_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_nactive_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_ndirty_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_full_slabs_ndirty_huge)\n\n/* A parallel set for the empty slabs. */\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_npageslabs_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_npageslabs_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_nactive_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_nactive_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_ndirty_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_empty_slabs_ndirty_huge)\n\n/*\n * And one for the slabs that are neither empty nor full, but indexed by how\n * full they are.\n */\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_huge)\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_nonhuge)\nCTL_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_huge)\n\nINDEX_PROTO(stats_arenas_i_hpa_shard_nonfull_slabs_j)\nCTL_PROTO(stats_arenas_i_nthreads)\nCTL_PROTO(stats_arenas_i_uptime)\nCTL_PROTO(stats_arenas_i_dss)\nCTL_PROTO(stats_arenas_i_dirty_decay_ms)\nCTL_PROTO(stats_arenas_i_muzzy_decay_ms)\nCTL_PROTO(stats_arenas_i_pactive)\nCTL_PROTO(stats_arenas_i_pdirty)\nCTL_PROTO(stats_arenas_i_pmuzzy)\nCTL_PROTO(stats_arenas_i_mapped)\nCTL_PROTO(stats_arenas_i_retained)\nCTL_PROTO(stats_arenas_i_extent_avail)\nCTL_PROTO(stats_arenas_i_dirty_npurge)\nCTL_PROTO(stats_arenas_i_dirty_nmadvise)\nCTL_PROTO(stats_arenas_i_dirty_purged)\nCTL_PROTO(stats_arenas_i_muzzy_npurge)\nCTL_PROTO(stats_arenas_i_muzzy_nmadvise)\nCTL_PROTO(stats_arenas_i_muzzy_purged)\nCTL_PROTO(stats_arenas_i_base)\nCTL_PROTO(stats_arenas_i_internal)\nCTL_PROTO(stats_arenas_i_metadata_thp)\nCTL_PROTO(stats_arenas_i_tcache_bytes)\nCTL_PROTO(stats_arenas_i_tcache_stashed_bytes)\nCTL_PROTO(stats_arenas_i_resident)\nCTL_PROTO(stats_arenas_i_abandoned_vm)\nCTL_PROTO(stats_arenas_i_hpa_sec_bytes)\nINDEX_PROTO(stats_arenas_i)\nCTL_PROTO(stats_allocated)\nCTL_PROTO(stats_active)\nCTL_PROTO(stats_background_thread_num_threads)\nCTL_PROTO(stats_background_thread_num_runs)\nCTL_PROTO(stats_background_thread_run_interval)\nCTL_PROTO(stats_metadata)\nCTL_PROTO(stats_metadata_thp)\nCTL_PROTO(stats_resident)\nCTL_PROTO(stats_mapped)\nCTL_PROTO(stats_retained)\nCTL_PROTO(stats_zero_reallocs)\nCTL_PROTO(experimental_hooks_install)\nCTL_PROTO(experimental_hooks_remove)\nCTL_PROTO(experimental_hooks_prof_backtrace)\nCTL_PROTO(experimental_hooks_prof_dump)\nCTL_PROTO(experimental_hooks_safety_check_abort)\nCTL_PROTO(experimental_thread_activity_callback)\nCTL_PROTO(experimental_utilization_query)\nCTL_PROTO(experimental_utilization_batch_query)\nCTL_PROTO(experimental_arenas_i_pactivep)\nINDEX_PROTO(experimental_arenas_i)\nCTL_PROTO(experimental_prof_recent_alloc_max)\nCTL_PROTO(experimental_prof_recent_alloc_dump)\nCTL_PROTO(experimental_batch_alloc)\nCTL_PROTO(experimental_arenas_create_ext)\n\n#define MUTEX_STATS_CTL_PROTO_GEN(n)\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_num_ops)\t\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_num_wait)\t\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_num_spin_acq)\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_num_owner_switch)\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_total_wait_time)\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_max_wait_time)\t\t\t\t\t\\\nCTL_PROTO(stats_##n##_max_num_thds)\n\n/* Global mutexes. */\n#define OP(mtx) MUTEX_STATS_CTL_PROTO_GEN(mutexes_##mtx)\nMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n\n/* Per arena mutexes. */\n#define OP(mtx) MUTEX_STATS_CTL_PROTO_GEN(arenas_i_mutexes_##mtx)\nMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n\n/* Arena bin mutexes. */\nMUTEX_STATS_CTL_PROTO_GEN(arenas_i_bins_j_mutex)\n#undef MUTEX_STATS_CTL_PROTO_GEN\n\nCTL_PROTO(stats_mutexes_reset)\n\n/******************************************************************************/\n/* mallctl tree. */\n\n#define NAME(n)\t{true},\tn\n#define CHILD(t, c)\t\t\t\t\t\t\t\\\n\tsizeof(c##_node) / sizeof(ctl_##t##_node_t),\t\t\t\\\n\t(ctl_node_t *)c##_node,\t\t\t\t\t\t\\\n\tNULL\n#define CTL(c)\t0, NULL, c##_ctl\n\n/*\n * Only handles internal indexed nodes, since there are currently no external\n * ones.\n */\n#define INDEX(i)\t{false},\ti##_index\n\nstatic const ctl_named_node_t\tthread_tcache_node[] = {\n\t{NAME(\"enabled\"),\tCTL(thread_tcache_enabled)},\n\t{NAME(\"flush\"),\t\tCTL(thread_tcache_flush)}\n};\n\nstatic const ctl_named_node_t\tthread_peak_node[] = {\n\t{NAME(\"read\"),\t\tCTL(thread_peak_read)},\n\t{NAME(\"reset\"),\t\tCTL(thread_peak_reset)},\n};\n\nstatic const ctl_named_node_t\tthread_prof_node[] = {\n\t{NAME(\"name\"),\t\tCTL(thread_prof_name)},\n\t{NAME(\"active\"),\tCTL(thread_prof_active)}\n};\n\nstatic const ctl_named_node_t\tthread_node[] = {\n\t{NAME(\"arena\"),\t\tCTL(thread_arena)},\n\t{NAME(\"allocated\"),\tCTL(thread_allocated)},\n\t{NAME(\"allocatedp\"),\tCTL(thread_allocatedp)},\n\t{NAME(\"deallocated\"),\tCTL(thread_deallocated)},\n\t{NAME(\"deallocatedp\"),\tCTL(thread_deallocatedp)},\n\t{NAME(\"tcache\"),\tCHILD(named, thread_tcache)},\n\t{NAME(\"peak\"),\t\tCHILD(named, thread_peak)},\n\t{NAME(\"prof\"),\t\tCHILD(named, thread_prof)},\n\t{NAME(\"idle\"),\t\tCTL(thread_idle)}\n};\n\nstatic const ctl_named_node_t\tconfig_node[] = {\n\t{NAME(\"cache_oblivious\"), CTL(config_cache_oblivious)},\n\t{NAME(\"debug\"),\t\tCTL(config_debug)},\n\t{NAME(\"fill\"),\t\tCTL(config_fill)},\n\t{NAME(\"lazy_lock\"),\tCTL(config_lazy_lock)},\n\t{NAME(\"malloc_conf\"),\tCTL(config_malloc_conf)},\n\t{NAME(\"opt_safety_checks\"),\tCTL(config_opt_safety_checks)},\n\t{NAME(\"prof\"),\t\tCTL(config_prof)},\n\t{NAME(\"prof_libgcc\"),\tCTL(config_prof_libgcc)},\n\t{NAME(\"prof_libunwind\"), CTL(config_prof_libunwind)},\n\t{NAME(\"stats\"),\t\tCTL(config_stats)},\n\t{NAME(\"utrace\"),\tCTL(config_utrace)},\n\t{NAME(\"xmalloc\"),\tCTL(config_xmalloc)}\n};\n\nstatic const ctl_named_node_t opt_node[] = {\n\t{NAME(\"abort\"),\t\tCTL(opt_abort)},\n\t{NAME(\"abort_conf\"),\tCTL(opt_abort_conf)},\n\t{NAME(\"cache_oblivious\"),\tCTL(opt_cache_oblivious)},\n\t{NAME(\"trust_madvise\"),\tCTL(opt_trust_madvise)},\n\t{NAME(\"confirm_conf\"),\tCTL(opt_confirm_conf)},\n\t{NAME(\"hpa\"),\t\tCTL(opt_hpa)},\n\t{NAME(\"hpa_slab_max_alloc\"),\tCTL(opt_hpa_slab_max_alloc)},\n\t{NAME(\"hpa_hugification_threshold\"),\n\t\tCTL(opt_hpa_hugification_threshold)},\n\t{NAME(\"hpa_hugify_delay_ms\"), CTL(opt_hpa_hugify_delay_ms)},\n\t{NAME(\"hpa_min_purge_interval_ms\"), CTL(opt_hpa_min_purge_interval_ms)},\n\t{NAME(\"hpa_dirty_mult\"), CTL(opt_hpa_dirty_mult)},\n\t{NAME(\"hpa_sec_nshards\"),\tCTL(opt_hpa_sec_nshards)},\n\t{NAME(\"hpa_sec_max_alloc\"),\tCTL(opt_hpa_sec_max_alloc)},\n\t{NAME(\"hpa_sec_max_bytes\"),\tCTL(opt_hpa_sec_max_bytes)},\n\t{NAME(\"hpa_sec_bytes_after_flush\"),\n\t\tCTL(opt_hpa_sec_bytes_after_flush)},\n\t{NAME(\"hpa_sec_batch_fill_extra\"),\n\t\tCTL(opt_hpa_sec_batch_fill_extra)},\n\t{NAME(\"metadata_thp\"),\tCTL(opt_metadata_thp)},\n\t{NAME(\"retain\"),\tCTL(opt_retain)},\n\t{NAME(\"dss\"),\t\tCTL(opt_dss)},\n\t{NAME(\"narenas\"),\tCTL(opt_narenas)},\n\t{NAME(\"percpu_arena\"),\tCTL(opt_percpu_arena)},\n\t{NAME(\"oversize_threshold\"),\tCTL(opt_oversize_threshold)},\n\t{NAME(\"mutex_max_spin\"),\tCTL(opt_mutex_max_spin)},\n\t{NAME(\"background_thread\"),\tCTL(opt_background_thread)},\n\t{NAME(\"max_background_threads\"),\tCTL(opt_max_background_threads)},\n\t{NAME(\"dirty_decay_ms\"), CTL(opt_dirty_decay_ms)},\n\t{NAME(\"muzzy_decay_ms\"), CTL(opt_muzzy_decay_ms)},\n\t{NAME(\"stats_print\"),\tCTL(opt_stats_print)},\n\t{NAME(\"stats_print_opts\"),\tCTL(opt_stats_print_opts)},\n\t{NAME(\"stats_interval\"),\tCTL(opt_stats_interval)},\n\t{NAME(\"stats_interval_opts\"),\tCTL(opt_stats_interval_opts)},\n\t{NAME(\"junk\"),\t\tCTL(opt_junk)},\n\t{NAME(\"zero\"),\t\tCTL(opt_zero)},\n\t{NAME(\"utrace\"),\tCTL(opt_utrace)},\n\t{NAME(\"xmalloc\"),\tCTL(opt_xmalloc)},\n\t{NAME(\"experimental_infallible_new\"),\n\t\tCTL(opt_experimental_infallible_new)},\n\t{NAME(\"tcache\"),\tCTL(opt_tcache)},\n\t{NAME(\"tcache_max\"),\tCTL(opt_tcache_max)},\n\t{NAME(\"tcache_nslots_small_min\"),\n\t\tCTL(opt_tcache_nslots_small_min)},\n\t{NAME(\"tcache_nslots_small_max\"),\n\t\tCTL(opt_tcache_nslots_small_max)},\n\t{NAME(\"tcache_nslots_large\"),\tCTL(opt_tcache_nslots_large)},\n\t{NAME(\"lg_tcache_nslots_mul\"),\tCTL(opt_lg_tcache_nslots_mul)},\n\t{NAME(\"tcache_gc_incr_bytes\"),\tCTL(opt_tcache_gc_incr_bytes)},\n\t{NAME(\"tcache_gc_delay_bytes\"),\tCTL(opt_tcache_gc_delay_bytes)},\n\t{NAME(\"lg_tcache_flush_small_div\"),\n\t\tCTL(opt_lg_tcache_flush_small_div)},\n\t{NAME(\"lg_tcache_flush_large_div\"),\n\t\tCTL(opt_lg_tcache_flush_large_div)},\n\t{NAME(\"thp\"),\t\tCTL(opt_thp)},\n\t{NAME(\"lg_extent_max_active_fit\"), CTL(opt_lg_extent_max_active_fit)},\n\t{NAME(\"prof\"),\t\tCTL(opt_prof)},\n\t{NAME(\"prof_prefix\"),\tCTL(opt_prof_prefix)},\n\t{NAME(\"prof_active\"),\tCTL(opt_prof_active)},\n\t{NAME(\"prof_thread_active_init\"), CTL(opt_prof_thread_active_init)},\n\t{NAME(\"lg_prof_sample\"), CTL(opt_lg_prof_sample)},\n\t{NAME(\"lg_prof_interval\"), CTL(opt_lg_prof_interval)},\n\t{NAME(\"prof_gdump\"),\tCTL(opt_prof_gdump)},\n\t{NAME(\"prof_final\"),\tCTL(opt_prof_final)},\n\t{NAME(\"prof_leak\"),\tCTL(opt_prof_leak)},\n\t{NAME(\"prof_leak_error\"),\tCTL(opt_prof_leak_error)},\n\t{NAME(\"prof_accum\"),\tCTL(opt_prof_accum)},\n\t{NAME(\"prof_recent_alloc_max\"),\tCTL(opt_prof_recent_alloc_max)},\n\t{NAME(\"prof_stats\"),\tCTL(opt_prof_stats)},\n\t{NAME(\"prof_sys_thread_name\"),\tCTL(opt_prof_sys_thread_name)},\n\t{NAME(\"prof_time_resolution\"),\tCTL(opt_prof_time_res)},\n\t{NAME(\"lg_san_uaf_align\"),\tCTL(opt_lg_san_uaf_align)},\n\t{NAME(\"zero_realloc\"),\tCTL(opt_zero_realloc)}\n};\n\nstatic const ctl_named_node_t\ttcache_node[] = {\n\t{NAME(\"create\"),\tCTL(tcache_create)},\n\t{NAME(\"flush\"),\t\tCTL(tcache_flush)},\n\t{NAME(\"destroy\"),\tCTL(tcache_destroy)}\n};\n\nstatic const ctl_named_node_t arena_i_node[] = {\n\t{NAME(\"initialized\"),\tCTL(arena_i_initialized)},\n\t{NAME(\"decay\"),\t\tCTL(arena_i_decay)},\n\t{NAME(\"purge\"),\t\tCTL(arena_i_purge)},\n\t{NAME(\"reset\"),\t\tCTL(arena_i_reset)},\n\t{NAME(\"destroy\"),\tCTL(arena_i_destroy)},\n\t{NAME(\"dss\"),\t\tCTL(arena_i_dss)},\n\t/*\n\t * Undocumented for now, since we anticipate an arena API in flux after\n\t * we cut the last 5-series release.\n\t */\n\t{NAME(\"oversize_threshold\"), CTL(arena_i_oversize_threshold)},\n\t{NAME(\"dirty_decay_ms\"), CTL(arena_i_dirty_decay_ms)},\n\t{NAME(\"muzzy_decay_ms\"), CTL(arena_i_muzzy_decay_ms)},\n\t{NAME(\"extent_hooks\"),\tCTL(arena_i_extent_hooks)},\n\t{NAME(\"retain_grow_limit\"),\tCTL(arena_i_retain_grow_limit)}\n};\nstatic const ctl_named_node_t super_arena_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, arena_i)}\n};\n\nstatic const ctl_indexed_node_t arena_node[] = {\n\t{INDEX(arena_i)}\n};\n\nstatic const ctl_named_node_t arenas_bin_i_node[] = {\n\t{NAME(\"size\"),\t\tCTL(arenas_bin_i_size)},\n\t{NAME(\"nregs\"),\t\tCTL(arenas_bin_i_nregs)},\n\t{NAME(\"slab_size\"),\tCTL(arenas_bin_i_slab_size)},\n\t{NAME(\"nshards\"),\tCTL(arenas_bin_i_nshards)}\n};\nstatic const ctl_named_node_t super_arenas_bin_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, arenas_bin_i)}\n};\n\nstatic const ctl_indexed_node_t arenas_bin_node[] = {\n\t{INDEX(arenas_bin_i)}\n};\n\nstatic const ctl_named_node_t arenas_lextent_i_node[] = {\n\t{NAME(\"size\"),\t\tCTL(arenas_lextent_i_size)}\n};\nstatic const ctl_named_node_t super_arenas_lextent_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, arenas_lextent_i)}\n};\n\nstatic const ctl_indexed_node_t arenas_lextent_node[] = {\n\t{INDEX(arenas_lextent_i)}\n};\n\nstatic const ctl_named_node_t arenas_node[] = {\n\t{NAME(\"narenas\"),\tCTL(arenas_narenas)},\n\t{NAME(\"dirty_decay_ms\"), CTL(arenas_dirty_decay_ms)},\n\t{NAME(\"muzzy_decay_ms\"), CTL(arenas_muzzy_decay_ms)},\n\t{NAME(\"quantum\"),\tCTL(arenas_quantum)},\n\t{NAME(\"page\"),\t\tCTL(arenas_page)},\n\t{NAME(\"tcache_max\"),\tCTL(arenas_tcache_max)},\n\t{NAME(\"nbins\"),\t\tCTL(arenas_nbins)},\n\t{NAME(\"nhbins\"),\tCTL(arenas_nhbins)},\n\t{NAME(\"bin\"),\t\tCHILD(indexed, arenas_bin)},\n\t{NAME(\"nlextents\"),\tCTL(arenas_nlextents)},\n\t{NAME(\"lextent\"),\tCHILD(indexed, arenas_lextent)},\n\t{NAME(\"create\"),\tCTL(arenas_create)},\n\t{NAME(\"lookup\"),\tCTL(arenas_lookup)}\n};\n\nstatic const ctl_named_node_t prof_stats_bins_i_node[] = {\n\t{NAME(\"live\"),\t\tCTL(prof_stats_bins_i_live)},\n\t{NAME(\"accum\"),\t\tCTL(prof_stats_bins_i_accum)}\n};\n\nstatic const ctl_named_node_t super_prof_stats_bins_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, prof_stats_bins_i)}\n};\n\nstatic const ctl_indexed_node_t prof_stats_bins_node[] = {\n\t{INDEX(prof_stats_bins_i)}\n};\n\nstatic const ctl_named_node_t prof_stats_lextents_i_node[] = {\n\t{NAME(\"live\"),\t\tCTL(prof_stats_lextents_i_live)},\n\t{NAME(\"accum\"),\t\tCTL(prof_stats_lextents_i_accum)}\n};\n\nstatic const ctl_named_node_t super_prof_stats_lextents_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, prof_stats_lextents_i)}\n};\n\nstatic const ctl_indexed_node_t prof_stats_lextents_node[] = {\n\t{INDEX(prof_stats_lextents_i)}\n};\n\nstatic const ctl_named_node_t\tprof_stats_node[] = {\n\t{NAME(\"bins\"),\t\tCHILD(indexed, prof_stats_bins)},\n\t{NAME(\"lextents\"),\tCHILD(indexed, prof_stats_lextents)},\n};\n\nstatic const ctl_named_node_t\tprof_node[] = {\n\t{NAME(\"thread_active_init\"), CTL(prof_thread_active_init)},\n\t{NAME(\"active\"),\tCTL(prof_active)},\n\t{NAME(\"dump\"),\t\tCTL(prof_dump)},\n\t{NAME(\"gdump\"),\t\tCTL(prof_gdump)},\n\t{NAME(\"prefix\"),\tCTL(prof_prefix)},\n\t{NAME(\"reset\"),\t\tCTL(prof_reset)},\n\t{NAME(\"interval\"),\tCTL(prof_interval)},\n\t{NAME(\"lg_sample\"),\tCTL(lg_prof_sample)},\n\t{NAME(\"log_start\"),\tCTL(prof_log_start)},\n\t{NAME(\"log_stop\"),\tCTL(prof_log_stop)},\n\t{NAME(\"stats\"),\t\tCHILD(named, prof_stats)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_small_node[] = {\n\t{NAME(\"allocated\"),\tCTL(stats_arenas_i_small_allocated)},\n\t{NAME(\"nmalloc\"),\tCTL(stats_arenas_i_small_nmalloc)},\n\t{NAME(\"ndalloc\"),\tCTL(stats_arenas_i_small_ndalloc)},\n\t{NAME(\"nrequests\"),\tCTL(stats_arenas_i_small_nrequests)},\n\t{NAME(\"nfills\"),\tCTL(stats_arenas_i_small_nfills)},\n\t{NAME(\"nflushes\"),\tCTL(stats_arenas_i_small_nflushes)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_large_node[] = {\n\t{NAME(\"allocated\"),\tCTL(stats_arenas_i_large_allocated)},\n\t{NAME(\"nmalloc\"),\tCTL(stats_arenas_i_large_nmalloc)},\n\t{NAME(\"ndalloc\"),\tCTL(stats_arenas_i_large_ndalloc)},\n\t{NAME(\"nrequests\"),\tCTL(stats_arenas_i_large_nrequests)},\n\t{NAME(\"nfills\"),\tCTL(stats_arenas_i_large_nfills)},\n\t{NAME(\"nflushes\"),\tCTL(stats_arenas_i_large_nflushes)}\n};\n\n#define MUTEX_PROF_DATA_NODE(prefix)\t\t\t\t\t\\\nstatic const ctl_named_node_t stats_##prefix##_node[] = {\t\t\\\n\t{NAME(\"num_ops\"),\t\t\t\t\t\t\\\n\t CTL(stats_##prefix##_num_ops)},\t\t\t\t\\\n\t{NAME(\"num_wait\"),\t\t\t\t\t\t\\\n\t CTL(stats_##prefix##_num_wait)},\t\t\t\t\\\n\t{NAME(\"num_spin_acq\"),\t\t\t\t\t\t\\\n\t CTL(stats_##prefix##_num_spin_acq)},\t\t\t\t\\\n\t{NAME(\"num_owner_switch\"),\t\t\t\t\t\\\n\t CTL(stats_##prefix##_num_owner_switch)},\t\t\t\\\n\t{NAME(\"total_wait_time\"),\t\t\t\t\t\\\n\t CTL(stats_##prefix##_total_wait_time)},\t\t\t\\\n\t{NAME(\"max_wait_time\"),\t\t\t\t\t\t\\\n\t CTL(stats_##prefix##_max_wait_time)},\t\t\t\t\\\n\t{NAME(\"max_num_thds\"),\t\t\t\t\t\t\\\n\t CTL(stats_##prefix##_max_num_thds)}\t\t\t\t\\\n\t/* Note that # of current waiting thread not provided. */\t\\\n};\n\nMUTEX_PROF_DATA_NODE(arenas_i_bins_j_mutex)\n\nstatic const ctl_named_node_t stats_arenas_i_bins_j_node[] = {\n\t{NAME(\"nmalloc\"),\tCTL(stats_arenas_i_bins_j_nmalloc)},\n\t{NAME(\"ndalloc\"),\tCTL(stats_arenas_i_bins_j_ndalloc)},\n\t{NAME(\"nrequests\"),\tCTL(stats_arenas_i_bins_j_nrequests)},\n\t{NAME(\"curregs\"),\tCTL(stats_arenas_i_bins_j_curregs)},\n\t{NAME(\"nfills\"),\tCTL(stats_arenas_i_bins_j_nfills)},\n\t{NAME(\"nflushes\"),\tCTL(stats_arenas_i_bins_j_nflushes)},\n\t{NAME(\"nslabs\"),\tCTL(stats_arenas_i_bins_j_nslabs)},\n\t{NAME(\"nreslabs\"),\tCTL(stats_arenas_i_bins_j_nreslabs)},\n\t{NAME(\"curslabs\"),\tCTL(stats_arenas_i_bins_j_curslabs)},\n\t{NAME(\"nonfull_slabs\"),\tCTL(stats_arenas_i_bins_j_nonfull_slabs)},\n\t{NAME(\"mutex\"),\t\tCHILD(named, stats_arenas_i_bins_j_mutex)}\n};\n\nstatic const ctl_named_node_t super_stats_arenas_i_bins_j_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, stats_arenas_i_bins_j)}\n};\n\nstatic const ctl_indexed_node_t stats_arenas_i_bins_node[] = {\n\t{INDEX(stats_arenas_i_bins_j)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_lextents_j_node[] = {\n\t{NAME(\"nmalloc\"),\tCTL(stats_arenas_i_lextents_j_nmalloc)},\n\t{NAME(\"ndalloc\"),\tCTL(stats_arenas_i_lextents_j_ndalloc)},\n\t{NAME(\"nrequests\"),\tCTL(stats_arenas_i_lextents_j_nrequests)},\n\t{NAME(\"curlextents\"),\tCTL(stats_arenas_i_lextents_j_curlextents)}\n};\nstatic const ctl_named_node_t super_stats_arenas_i_lextents_j_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, stats_arenas_i_lextents_j)}\n};\n\nstatic const ctl_indexed_node_t stats_arenas_i_lextents_node[] = {\n\t{INDEX(stats_arenas_i_lextents_j)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_extents_j_node[] = {\n\t{NAME(\"ndirty\"),\tCTL(stats_arenas_i_extents_j_ndirty)},\n\t{NAME(\"nmuzzy\"),\tCTL(stats_arenas_i_extents_j_nmuzzy)},\n\t{NAME(\"nretained\"),\tCTL(stats_arenas_i_extents_j_nretained)},\n\t{NAME(\"dirty_bytes\"),\tCTL(stats_arenas_i_extents_j_dirty_bytes)},\n\t{NAME(\"muzzy_bytes\"),\tCTL(stats_arenas_i_extents_j_muzzy_bytes)},\n\t{NAME(\"retained_bytes\"), CTL(stats_arenas_i_extents_j_retained_bytes)}\n};\n\nstatic const ctl_named_node_t super_stats_arenas_i_extents_j_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, stats_arenas_i_extents_j)}\n};\n\nstatic const ctl_indexed_node_t stats_arenas_i_extents_node[] = {\n\t{INDEX(stats_arenas_i_extents_j)}\n};\n\n#define OP(mtx) MUTEX_PROF_DATA_NODE(arenas_i_mutexes_##mtx)\nMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n\nstatic const ctl_named_node_t stats_arenas_i_mutexes_node[] = {\n#define OP(mtx) {NAME(#mtx), CHILD(named, stats_arenas_i_mutexes_##mtx)},\nMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n};\n\nstatic const ctl_named_node_t stats_arenas_i_hpa_shard_full_slabs_node[] = {\n\t{NAME(\"npageslabs_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_npageslabs_nonhuge)},\n\t{NAME(\"npageslabs_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_npageslabs_huge)},\n\t{NAME(\"nactive_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_nactive_nonhuge)},\n\t{NAME(\"nactive_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_nactive_huge)},\n\t{NAME(\"ndirty_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_ndirty_nonhuge)},\n\t{NAME(\"ndirty_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_full_slabs_ndirty_huge)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_hpa_shard_empty_slabs_node[] = {\n\t{NAME(\"npageslabs_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_npageslabs_nonhuge)},\n\t{NAME(\"npageslabs_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_npageslabs_huge)},\n\t{NAME(\"nactive_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_nactive_nonhuge)},\n\t{NAME(\"nactive_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_nactive_huge)},\n\t{NAME(\"ndirty_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_ndirty_nonhuge)},\n\t{NAME(\"ndirty_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_empty_slabs_ndirty_huge)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_hpa_shard_nonfull_slabs_j_node[] = {\n\t{NAME(\"npageslabs_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_nonhuge)},\n\t{NAME(\"npageslabs_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_huge)},\n\t{NAME(\"nactive_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_nonhuge)},\n\t{NAME(\"nactive_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_huge)},\n\t{NAME(\"ndirty_nonhuge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_nonhuge)},\n\t{NAME(\"ndirty_huge\"),\n\t\tCTL(stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_huge)}\n};\n\nstatic const ctl_named_node_t super_stats_arenas_i_hpa_shard_nonfull_slabs_j_node[] = {\n\t{NAME(\"\"),\n\t\tCHILD(named, stats_arenas_i_hpa_shard_nonfull_slabs_j)}\n};\n\nstatic const ctl_indexed_node_t stats_arenas_i_hpa_shard_nonfull_slabs_node[] =\n{\n\t{INDEX(stats_arenas_i_hpa_shard_nonfull_slabs_j)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_hpa_shard_node[] = {\n\t{NAME(\"full_slabs\"),\tCHILD(named,\n\t stats_arenas_i_hpa_shard_full_slabs)},\n\t{NAME(\"empty_slabs\"),\tCHILD(named,\n\t stats_arenas_i_hpa_shard_empty_slabs)},\n\t{NAME(\"nonfull_slabs\"),\tCHILD(indexed,\n\t stats_arenas_i_hpa_shard_nonfull_slabs)},\n\n\t{NAME(\"npurge_passes\"),\tCTL(stats_arenas_i_hpa_shard_npurge_passes)},\n\t{NAME(\"npurges\"),\tCTL(stats_arenas_i_hpa_shard_npurges)},\n\t{NAME(\"nhugifies\"),\tCTL(stats_arenas_i_hpa_shard_nhugifies)},\n\t{NAME(\"ndehugifies\"),\tCTL(stats_arenas_i_hpa_shard_ndehugifies)}\n};\n\nstatic const ctl_named_node_t stats_arenas_i_node[] = {\n\t{NAME(\"nthreads\"),\tCTL(stats_arenas_i_nthreads)},\n\t{NAME(\"uptime\"),\tCTL(stats_arenas_i_uptime)},\n\t{NAME(\"dss\"),\t\tCTL(stats_arenas_i_dss)},\n\t{NAME(\"dirty_decay_ms\"), CTL(stats_arenas_i_dirty_decay_ms)},\n\t{NAME(\"muzzy_decay_ms\"), CTL(stats_arenas_i_muzzy_decay_ms)},\n\t{NAME(\"pactive\"),\tCTL(stats_arenas_i_pactive)},\n\t{NAME(\"pdirty\"),\tCTL(stats_arenas_i_pdirty)},\n\t{NAME(\"pmuzzy\"),\tCTL(stats_arenas_i_pmuzzy)},\n\t{NAME(\"mapped\"),\tCTL(stats_arenas_i_mapped)},\n\t{NAME(\"retained\"),\tCTL(stats_arenas_i_retained)},\n\t{NAME(\"extent_avail\"),\tCTL(stats_arenas_i_extent_avail)},\n\t{NAME(\"dirty_npurge\"),\tCTL(stats_arenas_i_dirty_npurge)},\n\t{NAME(\"dirty_nmadvise\"), CTL(stats_arenas_i_dirty_nmadvise)},\n\t{NAME(\"dirty_purged\"),\tCTL(stats_arenas_i_dirty_purged)},\n\t{NAME(\"muzzy_npurge\"),\tCTL(stats_arenas_i_muzzy_npurge)},\n\t{NAME(\"muzzy_nmadvise\"), CTL(stats_arenas_i_muzzy_nmadvise)},\n\t{NAME(\"muzzy_purged\"),\tCTL(stats_arenas_i_muzzy_purged)},\n\t{NAME(\"base\"),\t\tCTL(stats_arenas_i_base)},\n\t{NAME(\"internal\"),\tCTL(stats_arenas_i_internal)},\n\t{NAME(\"metadata_thp\"),\tCTL(stats_arenas_i_metadata_thp)},\n\t{NAME(\"tcache_bytes\"),\tCTL(stats_arenas_i_tcache_bytes)},\n\t{NAME(\"tcache_stashed_bytes\"),\n\t CTL(stats_arenas_i_tcache_stashed_bytes)},\n\t{NAME(\"resident\"),\tCTL(stats_arenas_i_resident)},\n\t{NAME(\"abandoned_vm\"),\tCTL(stats_arenas_i_abandoned_vm)},\n\t{NAME(\"hpa_sec_bytes\"),\tCTL(stats_arenas_i_hpa_sec_bytes)},\n\t{NAME(\"small\"),\t\tCHILD(named, stats_arenas_i_small)},\n\t{NAME(\"large\"),\t\tCHILD(named, stats_arenas_i_large)},\n\t{NAME(\"bins\"),\t\tCHILD(indexed, stats_arenas_i_bins)},\n\t{NAME(\"lextents\"),\tCHILD(indexed, stats_arenas_i_lextents)},\n\t{NAME(\"extents\"),\tCHILD(indexed, stats_arenas_i_extents)},\n\t{NAME(\"mutexes\"),\tCHILD(named, stats_arenas_i_mutexes)},\n\t{NAME(\"hpa_shard\"),\tCHILD(named, stats_arenas_i_hpa_shard)}\n};\nstatic const ctl_named_node_t super_stats_arenas_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, stats_arenas_i)}\n};\n\nstatic const ctl_indexed_node_t stats_arenas_node[] = {\n\t{INDEX(stats_arenas_i)}\n};\n\nstatic const ctl_named_node_t stats_background_thread_node[] = {\n\t{NAME(\"num_threads\"),\tCTL(stats_background_thread_num_threads)},\n\t{NAME(\"num_runs\"),\tCTL(stats_background_thread_num_runs)},\n\t{NAME(\"run_interval\"),\tCTL(stats_background_thread_run_interval)}\n};\n\n#define OP(mtx) MUTEX_PROF_DATA_NODE(mutexes_##mtx)\nMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n\nstatic const ctl_named_node_t stats_mutexes_node[] = {\n#define OP(mtx) {NAME(#mtx), CHILD(named, stats_mutexes_##mtx)},\nMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n\t{NAME(\"reset\"),\t\tCTL(stats_mutexes_reset)}\n};\n#undef MUTEX_PROF_DATA_NODE\n\nstatic const ctl_named_node_t stats_node[] = {\n\t{NAME(\"allocated\"),\tCTL(stats_allocated)},\n\t{NAME(\"active\"),\tCTL(stats_active)},\n\t{NAME(\"metadata\"),\tCTL(stats_metadata)},\n\t{NAME(\"metadata_thp\"),\tCTL(stats_metadata_thp)},\n\t{NAME(\"resident\"),\tCTL(stats_resident)},\n\t{NAME(\"mapped\"),\tCTL(stats_mapped)},\n\t{NAME(\"retained\"),\tCTL(stats_retained)},\n\t{NAME(\"background_thread\"),\n\t CHILD(named, stats_background_thread)},\n\t{NAME(\"mutexes\"),\tCHILD(named, stats_mutexes)},\n\t{NAME(\"arenas\"),\tCHILD(indexed, stats_arenas)},\n\t{NAME(\"zero_reallocs\"),\tCTL(stats_zero_reallocs)},\n};\n\nstatic const ctl_named_node_t experimental_hooks_node[] = {\n\t{NAME(\"install\"),\tCTL(experimental_hooks_install)},\n\t{NAME(\"remove\"),\tCTL(experimental_hooks_remove)},\n\t{NAME(\"prof_backtrace\"),\tCTL(experimental_hooks_prof_backtrace)},\n\t{NAME(\"prof_dump\"),\tCTL(experimental_hooks_prof_dump)},\n\t{NAME(\"safety_check_abort\"),\tCTL(experimental_hooks_safety_check_abort)},\n};\n\nstatic const ctl_named_node_t experimental_thread_node[] = {\n\t{NAME(\"activity_callback\"),\n\t\tCTL(experimental_thread_activity_callback)}\n};\n\nstatic const ctl_named_node_t experimental_utilization_node[] = {\n\t{NAME(\"query\"),\t\tCTL(experimental_utilization_query)},\n\t{NAME(\"batch_query\"),\tCTL(experimental_utilization_batch_query)}\n};\n\nstatic const ctl_named_node_t experimental_arenas_i_node[] = {\n\t{NAME(\"pactivep\"),\tCTL(experimental_arenas_i_pactivep)}\n};\nstatic const ctl_named_node_t super_experimental_arenas_i_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, experimental_arenas_i)}\n};\n\nstatic const ctl_indexed_node_t experimental_arenas_node[] = {\n\t{INDEX(experimental_arenas_i)}\n};\n\nstatic const ctl_named_node_t experimental_prof_recent_node[] = {\n\t{NAME(\"alloc_max\"),\tCTL(experimental_prof_recent_alloc_max)},\n\t{NAME(\"alloc_dump\"),\tCTL(experimental_prof_recent_alloc_dump)},\n};\n\nstatic const ctl_named_node_t experimental_node[] = {\n\t{NAME(\"hooks\"),\t\tCHILD(named, experimental_hooks)},\n\t{NAME(\"utilization\"),\tCHILD(named, experimental_utilization)},\n\t{NAME(\"arenas\"),\tCHILD(indexed, experimental_arenas)},\n\t{NAME(\"arenas_create_ext\"),\tCTL(experimental_arenas_create_ext)},\n\t{NAME(\"prof_recent\"),\tCHILD(named, experimental_prof_recent)},\n\t{NAME(\"batch_alloc\"),\tCTL(experimental_batch_alloc)},\n\t{NAME(\"thread\"),\tCHILD(named, experimental_thread)}\n};\n\nstatic const ctl_named_node_t\troot_node[] = {\n\t{NAME(\"version\"),\tCTL(version)},\n\t{NAME(\"epoch\"),\t\tCTL(epoch)},\n\t{NAME(\"background_thread\"),\tCTL(background_thread)},\n\t{NAME(\"max_background_threads\"),\tCTL(max_background_threads)},\n\t{NAME(\"thread\"),\tCHILD(named, thread)},\n\t{NAME(\"config\"),\tCHILD(named, config)},\n\t{NAME(\"opt\"),\t\tCHILD(named, opt)},\n\t{NAME(\"tcache\"),\tCHILD(named, tcache)},\n\t{NAME(\"arena\"),\t\tCHILD(indexed, arena)},\n\t{NAME(\"arenas\"),\tCHILD(named, arenas)},\n\t{NAME(\"prof\"),\t\tCHILD(named, prof)},\n\t{NAME(\"stats\"),\t\tCHILD(named, stats)},\n\t{NAME(\"experimental\"),\tCHILD(named, experimental)}\n};\nstatic const ctl_named_node_t super_root_node[] = {\n\t{NAME(\"\"),\t\tCHILD(named, root)}\n};\n\n#undef NAME\n#undef CHILD\n#undef CTL\n#undef INDEX\n\n/******************************************************************************/\n\n/*\n * Sets *dst + *src non-atomically. This is safe, since everything is\n * synchronized by the ctl mutex.\n */\nstatic void\nctl_accum_locked_u64(locked_u64_t *dst, locked_u64_t *src) {\n\tlocked_inc_u64_unsynchronized(dst,\n\t locked_read_u64_unsynchronized(src));\n}\n\nstatic void\nctl_accum_atomic_zu(atomic_zu_t *dst, atomic_zu_t *src) {\n\tsize_t cur_dst = atomic_load_zu(dst, ATOMIC_RELAXED);\n\tsize_t cur_src = atomic_load_zu(src, ATOMIC_RELAXED);\n\tatomic_store_zu(dst, cur_dst + cur_src, ATOMIC_RELAXED);\n}\n\n/******************************************************************************/\n\nstatic unsigned\narenas_i2a_impl(size_t i, bool compat, bool validate) {\n\tunsigned a;\n\n\tswitch (i) {\n\tcase MALLCTL_ARENAS_ALL:\n\t\ta = 0;\n\t\tbreak;\n\tcase MALLCTL_ARENAS_DESTROYED:\n\t\ta = 1;\n\t\tbreak;\n\tdefault:\n\t\tif (compat && i == ctl_arenas->narenas) {\n\t\t\t/*\n\t\t\t * Provide deprecated backward compatibility for\n\t\t\t * accessing the merged stats at index narenas rather\n\t\t\t * than via MALLCTL_ARENAS_ALL. This is scheduled for\n\t\t\t * removal in 6.0.0.\n\t\t\t */\n\t\t\ta = 0;\n\t\t} else if (validate && i >= ctl_arenas->narenas) {\n\t\t\ta = UINT_MAX;\n\t\t} else {\n\t\t\t/*\n\t\t\t * This function should never be called for an index\n\t\t\t * more than one past the range of indices that have\n\t\t\t * initialized ctl data.\n\t\t\t */\n\t\t\tassert(i < ctl_arenas->narenas || (!validate && i ==\n\t\t\t ctl_arenas->narenas));\n\t\t\ta = (unsigned)i + 2;\n\t\t}\n\t\tbreak;\n\t}\n\n\treturn a;\n}\n\nstatic unsigned\narenas_i2a(size_t i) {\n\treturn arenas_i2a_impl(i, true, false);\n}\n\nstatic ctl_arena_t *\narenas_i_impl(tsd_t *tsd, size_t i, bool compat, bool init) {\n\tctl_arena_t *ret;\n\n\tassert(!compat || !init);\n\n\tret = ctl_arenas->arenas[arenas_i2a_impl(i, compat, false)];\n\tif (init && ret == NULL) {\n\t\tif (config_stats) {\n\t\t\tstruct container_s {\n\t\t\t\tctl_arena_t\t\tctl_arena;\n\t\t\t\tctl_arena_stats_t\tastats;\n\t\t\t};\n\t\t\tstruct container_s *cont =\n\t\t\t (struct container_s *)base_alloc(tsd_tsdn(tsd),\n\t\t\t b0get(), sizeof(struct container_s), QUANTUM);\n\t\t\tif (cont == NULL) {\n\t\t\t\treturn NULL;\n\t\t\t}\n\t\t\tret = &cont->ctl_arena;\n\t\t\tret->astats = &cont->astats;\n\t\t} else {\n\t\t\tret = (ctl_arena_t *)base_alloc(tsd_tsdn(tsd), b0get(),\n\t\t\t sizeof(ctl_arena_t), QUANTUM);\n\t\t\tif (ret == NULL) {\n\t\t\t\treturn NULL;\n\t\t\t}\n\t\t}\n\t\tret->arena_ind = (unsigned)i;\n\t\tctl_arenas->arenas[arenas_i2a_impl(i, compat, false)] = ret;\n\t}\n\n\tassert(ret == NULL || arenas_i2a(ret->arena_ind) == arenas_i2a(i));\n\treturn ret;\n}\n\nstatic ctl_arena_t *\narenas_i(size_t i) {\n\tctl_arena_t *ret = arenas_i_impl(tsd_fetch(), i, true, false);\n\tassert(ret != NULL);\n\treturn ret;\n}\n\nstatic void\nctl_arena_clear(ctl_arena_t *ctl_arena) {\n\tctl_arena->nthreads = 0;\n\tctl_arena->dss = dss_prec_names[dss_prec_limit];\n\tctl_arena->dirty_decay_ms = -1;\n\tctl_arena->muzzy_decay_ms = -1;\n\tctl_arena->pactive = 0;\n\tctl_arena->pdirty = 0;\n\tctl_arena->pmuzzy = 0;\n\tif (config_stats) {\n\t\tmemset(&ctl_arena->astats->astats, 0, sizeof(arena_stats_t));\n\t\tctl_arena->astats->allocated_small = 0;\n\t\tctl_arena->astats->nmalloc_small = 0;\n\t\tctl_arena->astats->ndalloc_small = 0;\n\t\tctl_arena->astats->nrequests_small = 0;\n\t\tctl_arena->astats->nfills_small = 0;\n\t\tctl_arena->astats->nflushes_small = 0;\n\t\tmemset(ctl_arena->astats->bstats, 0, SC_NBINS *\n\t\t sizeof(bin_stats_data_t));\n\t\tmemset(ctl_arena->astats->lstats, 0, (SC_NSIZES - SC_NBINS) *\n\t\t sizeof(arena_stats_large_t));\n\t\tmemset(ctl_arena->astats->estats, 0, SC_NPSIZES *\n\t\t sizeof(pac_estats_t));\n\t\tmemset(&ctl_arena->astats->hpastats, 0,\n\t\t sizeof(hpa_shard_stats_t));\n\t\tmemset(&ctl_arena->astats->secstats, 0,\n\t\t sizeof(sec_stats_t));\n\t}\n}\n\nstatic void\nctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_t *ctl_arena, arena_t *arena) {\n\tunsigned i;\n\n\tif (config_stats) {\n\t\tarena_stats_merge(tsdn, arena, &ctl_arena->nthreads,\n\t\t &ctl_arena->dss, &ctl_arena->dirty_decay_ms,\n\t\t &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive,\n\t\t &ctl_arena->pdirty, &ctl_arena->pmuzzy,\n\t\t &ctl_arena->astats->astats, ctl_arena->astats->bstats,\n\t\t ctl_arena->astats->lstats, ctl_arena->astats->estats,\n\t\t &ctl_arena->astats->hpastats, &ctl_arena->astats->secstats);\n\n\t\tfor (i = 0; i < SC_NBINS; i++) {\n\t\t\tbin_stats_t *bstats =\n\t\t\t &ctl_arena->astats->bstats[i].stats_data;\n\t\t\tctl_arena->astats->allocated_small += bstats->curregs *\n\t\t\t sz_index2size(i);\n\t\t\tctl_arena->astats->nmalloc_small += bstats->nmalloc;\n\t\t\tctl_arena->astats->ndalloc_small += bstats->ndalloc;\n\t\t\tctl_arena->astats->nrequests_small += bstats->nrequests;\n\t\t\tctl_arena->astats->nfills_small += bstats->nfills;\n\t\t\tctl_arena->astats->nflushes_small += bstats->nflushes;\n\t\t}\n\t} else {\n\t\tarena_basic_stats_merge(tsdn, arena, &ctl_arena->nthreads,\n\t\t &ctl_arena->dss, &ctl_arena->dirty_decay_ms,\n\t\t &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive,\n\t\t &ctl_arena->pdirty, &ctl_arena->pmuzzy);\n\t}\n}\n\nstatic void\nctl_arena_stats_sdmerge(ctl_arena_t *ctl_sdarena, ctl_arena_t *ctl_arena,\n bool destroyed) {\n\tunsigned i;\n\n\tif (!destroyed) {\n\t\tctl_sdarena->nthreads += ctl_arena->nthreads;\n\t\tctl_sdarena->pactive += ctl_arena->pactive;\n\t\tctl_sdarena->pdirty += ctl_arena->pdirty;\n\t\tctl_sdarena->pmuzzy += ctl_arena->pmuzzy;\n\t} else {\n\t\tassert(ctl_arena->nthreads == 0);\n\t\tassert(ctl_arena->pactive == 0);\n\t\tassert(ctl_arena->pdirty == 0);\n\t\tassert(ctl_arena->pmuzzy == 0);\n\t}\n\n\tif (config_stats) {\n\t\tctl_arena_stats_t *sdstats = ctl_sdarena->astats;\n\t\tctl_arena_stats_t *astats = ctl_arena->astats;\n\n\t\tif (!destroyed) {\n\t\t\tsdstats->astats.mapped += astats->astats.mapped;\n\t\t\tsdstats->astats.pa_shard_stats.pac_stats.retained\n\t\t\t += astats->astats.pa_shard_stats.pac_stats.retained;\n\t\t\tsdstats->astats.pa_shard_stats.edata_avail\n\t\t\t += astats->astats.pa_shard_stats.edata_avail;\n\t\t}\n\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_dirty.npurge,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_dirty.npurge);\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_dirty.nmadvise,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_dirty.nmadvise);\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_dirty.purged,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_dirty.purged);\n\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_muzzy.npurge,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_muzzy.npurge);\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_muzzy.nmadvise,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_muzzy.nmadvise);\n\t\tctl_accum_locked_u64(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.decay_muzzy.purged,\n\t\t &astats->astats.pa_shard_stats.pac_stats.decay_muzzy.purged);\n\n#define OP(mtx) malloc_mutex_prof_merge(\t\t\t\t\\\n\t\t &(sdstats->astats.mutex_prof_data[\t\t\t\\\n\t\t arena_prof_mutex_##mtx]),\t\t\t\\\n\t\t &(astats->astats.mutex_prof_data[\t\t\t\\\n\t\t arena_prof_mutex_##mtx]));\nMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n\t\tif (!destroyed) {\n\t\t\tsdstats->astats.base += astats->astats.base;\n\t\t\tsdstats->astats.resident += astats->astats.resident;\n\t\t\tsdstats->astats.metadata_thp += astats->astats.metadata_thp;\n\t\t\tctl_accum_atomic_zu(&sdstats->astats.internal,\n\t\t\t &astats->astats.internal);\n\t\t} else {\n\t\t\tassert(atomic_load_zu(\n\t\t\t &astats->astats.internal, ATOMIC_RELAXED) == 0);\n\t\t}\n\n\t\tif (!destroyed) {\n\t\t\tsdstats->allocated_small += astats->allocated_small;\n\t\t} else {\n\t\t\tassert(astats->allocated_small == 0);\n\t\t}\n\t\tsdstats->nmalloc_small += astats->nmalloc_small;\n\t\tsdstats->ndalloc_small += astats->ndalloc_small;\n\t\tsdstats->nrequests_small += astats->nrequests_small;\n\t\tsdstats->nfills_small += astats->nfills_small;\n\t\tsdstats->nflushes_small += astats->nflushes_small;\n\n\t\tif (!destroyed) {\n\t\t\tsdstats->astats.allocated_large +=\n\t\t\t astats->astats.allocated_large;\n\t\t} else {\n\t\t\tassert(astats->astats.allocated_large == 0);\n\t\t}\n\t\tsdstats->astats.nmalloc_large += astats->astats.nmalloc_large;\n\t\tsdstats->astats.ndalloc_large += astats->astats.ndalloc_large;\n\t\tsdstats->astats.nrequests_large\n\t\t += astats->astats.nrequests_large;\n\t\tsdstats->astats.nflushes_large += astats->astats.nflushes_large;\n\t\tctl_accum_atomic_zu(\n\t\t &sdstats->astats.pa_shard_stats.pac_stats.abandoned_vm,\n\t\t &astats->astats.pa_shard_stats.pac_stats.abandoned_vm);\n\n\t\tsdstats->astats.tcache_bytes += astats->astats.tcache_bytes;\n\t\tsdstats->astats.tcache_stashed_bytes +=\n\t\t astats->astats.tcache_stashed_bytes;\n\n\t\tif (ctl_arena->arena_ind == 0) {\n\t\t\tsdstats->astats.uptime = astats->astats.uptime;\n\t\t}\n\n\t\t/* Merge bin stats. */\n\t\tfor (i = 0; i < SC_NBINS; i++) {\n\t\t\tbin_stats_t *bstats = &astats->bstats[i].stats_data;\n\t\t\tbin_stats_t *merged = &sdstats->bstats[i].stats_data;\n\t\t\tmerged->nmalloc += bstats->nmalloc;\n\t\t\tmerged->ndalloc += bstats->ndalloc;\n\t\t\tmerged->nrequests += bstats->nrequests;\n\t\t\tif (!destroyed) {\n\t\t\t\tmerged->curregs += bstats->curregs;\n\t\t\t} else {\n\t\t\t\tassert(bstats->curregs == 0);\n\t\t\t}\n\t\t\tmerged->nfills += bstats->nfills;\n\t\t\tmerged->nflushes += bstats->nflushes;\n\t\t\tmerged->nslabs += bstats->nslabs;\n\t\t\tmerged->reslabs += bstats->reslabs;\n\t\t\tif (!destroyed) {\n\t\t\t\tmerged->curslabs += bstats->curslabs;\n\t\t\t\tmerged->nonfull_slabs += bstats->nonfull_slabs;\n\t\t\t} else {\n\t\t\t\tassert(bstats->curslabs == 0);\n\t\t\t\tassert(bstats->nonfull_slabs == 0);\n\t\t\t}\n\t\t\tmalloc_mutex_prof_merge(&sdstats->bstats[i].mutex_data,\n\t\t\t &astats->bstats[i].mutex_data);\n\t\t}\n\n\t\t/* Merge stats for large allocations. */\n\t\tfor (i = 0; i < SC_NSIZES - SC_NBINS; i++) {\n\t\t\tctl_accum_locked_u64(&sdstats->lstats[i].nmalloc,\n\t\t\t &astats->lstats[i].nmalloc);\n\t\t\tctl_accum_locked_u64(&sdstats->lstats[i].ndalloc,\n\t\t\t &astats->lstats[i].ndalloc);\n\t\t\tctl_accum_locked_u64(&sdstats->lstats[i].nrequests,\n\t\t\t &astats->lstats[i].nrequests);\n\t\t\tif (!destroyed) {\n\t\t\t\tsdstats->lstats[i].curlextents +=\n\t\t\t\t astats->lstats[i].curlextents;\n\t\t\t} else {\n\t\t\t\tassert(astats->lstats[i].curlextents == 0);\n\t\t\t}\n\t\t}\n\n\t\t/* Merge extents stats. */\n\t\tfor (i = 0; i < SC_NPSIZES; i++) {\n\t\t\tsdstats->estats[i].ndirty += astats->estats[i].ndirty;\n\t\t\tsdstats->estats[i].nmuzzy += astats->estats[i].nmuzzy;\n\t\t\tsdstats->estats[i].nretained\n\t\t\t += astats->estats[i].nretained;\n\t\t\tsdstats->estats[i].dirty_bytes\n\t\t\t += astats->estats[i].dirty_bytes;\n\t\t\tsdstats->estats[i].muzzy_bytes\n\t\t\t += astats->estats[i].muzzy_bytes;\n\t\t\tsdstats->estats[i].retained_bytes\n\t\t\t += astats->estats[i].retained_bytes;\n\t\t}\n\n\t\t/* Merge HPA stats. */\n\t\thpa_shard_stats_accum(&sdstats->hpastats, &astats->hpastats);\n\t\tsec_stats_accum(&sdstats->secstats, &astats->secstats);\n\t}\n}\n\nstatic void\nctl_arena_refresh(tsdn_t *tsdn, arena_t *arena, ctl_arena_t *ctl_sdarena,\n unsigned i, bool destroyed) {\n\tctl_arena_t *ctl_arena = arenas_i(i);\n\n\tctl_arena_clear(ctl_arena);\n\tctl_arena_stats_amerge(tsdn, ctl_arena, arena);\n\t/* Merge into sum stats as well. */\n\tctl_arena_stats_sdmerge(ctl_sdarena, ctl_arena, destroyed);\n}\n\nstatic unsigned\nctl_arena_init(tsd_t *tsd, const arena_config_t *config) {\n\tunsigned arena_ind;\n\tctl_arena_t *ctl_arena;\n\n\tif ((ctl_arena = ql_last(&ctl_arenas->destroyed, destroyed_link)) !=\n\t NULL) {\n\t\tql_remove(&ctl_arenas->destroyed, ctl_arena, destroyed_link);\n\t\tarena_ind = ctl_arena->arena_ind;\n\t} else {\n\t\tarena_ind = ctl_arenas->narenas;\n\t}\n\n\t/* Trigger stats allocation. */\n\tif (arenas_i_impl(tsd, arena_ind, false, true) == NULL) {\n\t\treturn UINT_MAX;\n\t}\n\n\t/* Initialize new arena. */\n\tif (arena_init(tsd_tsdn(tsd), arena_ind, config) == NULL) {\n\t\treturn UINT_MAX;\n\t}\n\n\tif (arena_ind == ctl_arenas->narenas) {\n\t\tctl_arenas->narenas++;\n\t}\n\n\treturn arena_ind;\n}\n\nstatic void\nctl_background_thread_stats_read(tsdn_t *tsdn) {\n\tbackground_thread_stats_t *stats = &ctl_stats->background_thread;\n\tif (!have_background_thread ||\n\t background_thread_stats_read(tsdn, stats)) {\n\t\tmemset(stats, 0, sizeof(background_thread_stats_t));\n\t\tnstime_init_zero(&stats->run_interval);\n\t}\n\tmalloc_mutex_prof_copy(\n\t &ctl_stats->mutex_prof_data[global_prof_mutex_max_per_bg_thd],\n\t &stats->max_counter_per_bg_thd);\n}\n\nstatic void\nctl_refresh(tsdn_t *tsdn) {\n\tunsigned i;\n\tctl_arena_t *ctl_sarena = arenas_i(MALLCTL_ARENAS_ALL);\n\tVARIABLE_ARRAY(arena_t *, tarenas, ctl_arenas->narenas);\n\n\t/*\n\t * Clear sum stats, since they will be merged into by\n\t * ctl_arena_refresh().\n\t */\n\tctl_arena_clear(ctl_sarena);\n\n\tfor (i = 0; i < ctl_arenas->narenas; i++) {\n\t\ttarenas[i] = arena_get(tsdn, i, false);\n\t}\n\n\tfor (i = 0; i < ctl_arenas->narenas; i++) {\n\t\tctl_arena_t *ctl_arena = arenas_i(i);\n\t\tbool initialized = (tarenas[i] != NULL);\n\n\t\tctl_arena->initialized = initialized;\n\t\tif (initialized) {\n\t\t\tctl_arena_refresh(tsdn, tarenas[i], ctl_sarena, i,\n\t\t\t false);\n\t\t}\n\t}\n\n\tif (config_stats) {\n\t\tctl_stats->allocated = ctl_sarena->astats->allocated_small +\n\t\t ctl_sarena->astats->astats.allocated_large;\n\t\tctl_stats->active = (ctl_sarena->pactive << LG_PAGE);\n\t\tctl_stats->metadata = ctl_sarena->astats->astats.base +\n\t\t atomic_load_zu(&ctl_sarena->astats->astats.internal,\n\t\t\tATOMIC_RELAXED);\n\t\tctl_stats->resident = ctl_sarena->astats->astats.resident;\n\t\tctl_stats->metadata_thp =\n\t\t ctl_sarena->astats->astats.metadata_thp;\n\t\tctl_stats->mapped = ctl_sarena->astats->astats.mapped;\n\t\tctl_stats->retained = ctl_sarena->astats->astats\n\t\t .pa_shard_stats.pac_stats.retained;\n\n\t\tctl_background_thread_stats_read(tsdn);\n\n#define READ_GLOBAL_MUTEX_PROF_DATA(i, mtx)\t\t\t\t\\\n malloc_mutex_lock(tsdn, &mtx);\t\t\t\t\t\\\n malloc_mutex_prof_read(tsdn, &ctl_stats->mutex_prof_data[i], &mtx);\t\\\n malloc_mutex_unlock(tsdn, &mtx);\n\n\t\tif (config_prof && opt_prof) {\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof, bt2gctx_mtx);\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof_thds_data, tdatas_mtx);\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof_dump, prof_dump_mtx);\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof_recent_alloc,\n\t\t\t prof_recent_alloc_mtx);\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof_recent_dump,\n\t\t\t prof_recent_dump_mtx);\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_prof_stats, prof_stats_mtx);\n\t\t}\n\t\tif (have_background_thread) {\n\t\t\tREAD_GLOBAL_MUTEX_PROF_DATA(\n\t\t\t global_prof_mutex_background_thread,\n\t\t\t background_thread_lock);\n\t\t} else {\n\t\t\tmemset(&ctl_stats->mutex_prof_data[\n\t\t\t global_prof_mutex_background_thread], 0,\n\t\t\t sizeof(mutex_prof_data_t));\n\t\t}\n\t\t/* We own ctl mutex already. */\n\t\tmalloc_mutex_prof_read(tsdn,\n\t\t &ctl_stats->mutex_prof_data[global_prof_mutex_ctl],\n\t\t &ctl_mtx);\n#undef READ_GLOBAL_MUTEX_PROF_DATA\n\t}\n\tctl_arenas->epoch++;\n}\n\nstatic bool\nctl_init(tsd_t *tsd) {\n\tbool ret;\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\tif (!ctl_initialized) {\n\t\tctl_arena_t *ctl_sarena, *ctl_darena;\n\t\tunsigned i;\n\n\t\t/*\n\t\t * Allocate demand-zeroed space for pointers to the full\n\t\t * range of supported arena indices.\n\t\t */\n\t\tif (ctl_arenas == NULL) {\n\t\t\tctl_arenas = (ctl_arenas_t *)base_alloc(tsdn,\n\t\t\t b0get(), sizeof(ctl_arenas_t), QUANTUM);\n\t\t\tif (ctl_arenas == NULL) {\n\t\t\t\tret = true;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\n\t\tif (config_stats && ctl_stats == NULL) {\n\t\t\tctl_stats = (ctl_stats_t *)base_alloc(tsdn, b0get(),\n\t\t\t sizeof(ctl_stats_t), QUANTUM);\n\t\t\tif (ctl_stats == NULL) {\n\t\t\t\tret = true;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * Allocate space for the current full range of arenas\n\t\t * here rather than doing it lazily elsewhere, in order\n\t\t * to limit when OOM-caused errors can occur.\n\t\t */\n\t\tif ((ctl_sarena = arenas_i_impl(tsd, MALLCTL_ARENAS_ALL, false,\n\t\t true)) == NULL) {\n\t\t\tret = true;\n\t\t\tgoto label_return;\n\t\t}\n\t\tctl_sarena->initialized = true;\n\n\t\tif ((ctl_darena = arenas_i_impl(tsd, MALLCTL_ARENAS_DESTROYED,\n\t\t false, true)) == NULL) {\n\t\t\tret = true;\n\t\t\tgoto label_return;\n\t\t}\n\t\tctl_arena_clear(ctl_darena);\n\t\t/*\n\t\t * Don't toggle ctl_darena to initialized until an arena is\n\t\t * actually destroyed, so that arena..initialized can be used\n\t\t * to query whether the stats are relevant.\n\t\t */\n\n\t\tctl_arenas->narenas = narenas_total_get();\n\t\tfor (i = 0; i < ctl_arenas->narenas; i++) {\n\t\t\tif (arenas_i_impl(tsd, i, false, true) == NULL) {\n\t\t\t\tret = true;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\n\t\tql_new(&ctl_arenas->destroyed);\n\t\tctl_refresh(tsdn);\n\n\t\tctl_initialized = true;\n\t}\n\n\tret = false;\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nctl_lookup(tsdn_t *tsdn, const ctl_named_node_t *starting_node,\n const char *name, const ctl_named_node_t **ending_nodep, size_t *mibp,\n size_t *depthp) {\n\tint ret;\n\tconst char *elm, *tdot, *dot;\n\tsize_t elen, i, j;\n\tconst ctl_named_node_t *node;\n\n\telm = name;\n\t/* Equivalent to strchrnul(). */\n\tdot = ((tdot = strchr(elm, '.')) != NULL) ? tdot : strchr(elm, '\\0');\n\telen = (size_t)((uintptr_t)dot - (uintptr_t)elm);\n\tif (elen == 0) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\tnode = starting_node;\n\tfor (i = 0; i < *depthp; i++) {\n\t\tassert(node);\n\t\tassert(node->nchildren > 0);\n\t\tif (ctl_named_node(node->children) != NULL) {\n\t\t\tconst ctl_named_node_t *pnode = node;\n\n\t\t\t/* Children are named. */\n\t\t\tfor (j = 0; j < node->nchildren; j++) {\n\t\t\t\tconst ctl_named_node_t *child =\n\t\t\t\t ctl_named_children(node, j);\n\t\t\t\tif (strlen(child->name) == elen &&\n\t\t\t\t strncmp(elm, child->name, elen) == 0) {\n\t\t\t\t\tnode = child;\n\t\t\t\t\tmibp[i] = j;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (node == pnode) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t} else {\n\t\t\tuintmax_t index;\n\t\t\tconst ctl_indexed_node_t *inode;\n\n\t\t\t/* Children are indexed. */\n\t\t\tindex = malloc_strtoumax(elm, NULL, 10);\n\t\t\tif (index == UINTMAX_MAX || index > SIZE_T_MAX) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\n\t\t\tinode = ctl_indexed_node(node->children);\n\t\t\tnode = inode->index(tsdn, mibp, *depthp, (size_t)index);\n\t\t\tif (node == NULL) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\n\t\t\tmibp[i] = (size_t)index;\n\t\t}\n\n\t\t/* Reached the end? */\n\t\tif (node->ctl != NULL || *dot == '\\0') {\n\t\t\t/* Terminal node. */\n\t\t\tif (*dot != '\\0') {\n\t\t\t\t/*\n\t\t\t\t * The name contains more elements than are\n\t\t\t\t * in this path through the tree.\n\t\t\t\t */\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t\t/* Complete lookup successful. */\n\t\t\t*depthp = i + 1;\n\t\t\tbreak;\n\t\t}\n\n\t\t/* Update elm. */\n\t\telm = &dot[1];\n\t\tdot = ((tdot = strchr(elm, '.')) != NULL) ? tdot :\n\t\t strchr(elm, '\\0');\n\t\telen = (size_t)((uintptr_t)dot - (uintptr_t)elm);\n\t}\n\tif (ending_nodep != NULL) {\n\t\t*ending_nodep = node;\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nint\nctl_byname(tsd_t *tsd, const char *name, void *oldp, size_t *oldlenp,\n void *newp, size_t newlen) {\n\tint ret;\n\tsize_t depth;\n\tsize_t mib[CTL_MAX_DEPTH];\n\tconst ctl_named_node_t *node;\n\n\tif (!ctl_initialized && ctl_init(tsd)) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\n\tdepth = CTL_MAX_DEPTH;\n\tret = ctl_lookup(tsd_tsdn(tsd), super_root_node, name, &node, mib,\n\t &depth);\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\n\tif (node != NULL && node->ctl) {\n\t\tret = node->ctl(tsd, mib, depth, oldp, oldlenp, newp, newlen);\n\t} else {\n\t\t/* The name refers to a partial path through the ctl tree. */\n\t\tret = ENOENT;\n\t}\n\nlabel_return:\n\treturn(ret);\n}\n\nint\nctl_nametomib(tsd_t *tsd, const char *name, size_t *mibp, size_t *miblenp) {\n\tint ret;\n\n\tif (!ctl_initialized && ctl_init(tsd)) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\n\tret = ctl_lookup(tsd_tsdn(tsd), super_root_node, name, NULL, mibp,\n\t miblenp);\nlabel_return:\n\treturn(ret);\n}\n\nstatic int\nctl_lookupbymib(tsdn_t *tsdn, const ctl_named_node_t **ending_nodep,\n const size_t *mib, size_t miblen) {\n\tint ret;\n\n\tconst ctl_named_node_t *node = super_root_node;\n\tfor (size_t i = 0; i < miblen; i++) {\n\t\tassert(node);\n\t\tassert(node->nchildren > 0);\n\t\tif (ctl_named_node(node->children) != NULL) {\n\t\t\t/* Children are named. */\n\t\t\tif (node->nchildren <= mib[i]) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t\tnode = ctl_named_children(node, mib[i]);\n\t\t} else {\n\t\t\tconst ctl_indexed_node_t *inode;\n\n\t\t\t/* Indexed element. */\n\t\t\tinode = ctl_indexed_node(node->children);\n\t\t\tnode = inode->index(tsdn, mib, miblen, mib[i]);\n\t\t\tif (node == NULL) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\t}\n\tassert(ending_nodep != NULL);\n\t*ending_nodep = node;\n\tret = 0;\n\nlabel_return:\n\treturn(ret);\n}\n\nint\nctl_bymib(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tconst ctl_named_node_t *node;\n\n\tif (!ctl_initialized && ctl_init(tsd)) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\n\tret = ctl_lookupbymib(tsd_tsdn(tsd), &node, mib, miblen);\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\n\t/* Call the ctl function. */\n\tif (node && node->ctl) {\n\t\tret = node->ctl(tsd, mib, miblen, oldp, oldlenp, newp, newlen);\n\t} else {\n\t\t/* Partial MIB. */\n\t\tret = ENOENT;\n\t}\n\nlabel_return:\n\treturn(ret);\n}\n\nint\nctl_mibnametomib(tsd_t *tsd, size_t *mib, size_t miblen, const char *name,\n size_t *miblenp) {\n\tint ret;\n\tconst ctl_named_node_t *node;\n\n\tif (!ctl_initialized && ctl_init(tsd)) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\n\tret = ctl_lookupbymib(tsd_tsdn(tsd), &node, mib, miblen);\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\tif (node == NULL || node->ctl != NULL) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tassert(miblenp != NULL);\n\tassert(*miblenp >= miblen);\n\t*miblenp -= miblen;\n\tret = ctl_lookup(tsd_tsdn(tsd), node, name, NULL, mib + miblen,\n\t miblenp);\n\t*miblenp += miblen;\nlabel_return:\n\treturn(ret);\n}\n\nint\nctl_bymibname(tsd_t *tsd, size_t *mib, size_t miblen, const char *name,\n size_t *miblenp, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tconst ctl_named_node_t *node;\n\n\tif (!ctl_initialized && ctl_init(tsd)) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\n\tret = ctl_lookupbymib(tsd_tsdn(tsd), &node, mib, miblen);\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\tif (node == NULL || node->ctl != NULL) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tassert(miblenp != NULL);\n\tassert(*miblenp >= miblen);\n\t*miblenp -= miblen;\n\t/*\n\t * The same node supplies the starting node and stores the ending node.\n\t */\n\tret = ctl_lookup(tsd_tsdn(tsd), node, name, &node, mib + miblen,\n\t miblenp);\n\t*miblenp += miblen;\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\n\tif (node != NULL && node->ctl) {\n\t\tret = node->ctl(tsd, mib, *miblenp, oldp, oldlenp, newp,\n\t\t newlen);\n\t} else {\n\t\t/* The name refers to a partial path through the ctl tree. */\n\t\tret = ENOENT;\n\t}\n\nlabel_return:\n\treturn(ret);\n}\n\nbool\nctl_boot(void) {\n\tif (malloc_mutex_init(&ctl_mtx, \"ctl\", WITNESS_RANK_CTL,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tctl_initialized = false;\n\n\treturn false;\n}\n\nvoid\nctl_prefork(tsdn_t *tsdn) {\n\tmalloc_mutex_prefork(tsdn, &ctl_mtx);\n}\n\nvoid\nctl_postfork_parent(tsdn_t *tsdn) {\n\tmalloc_mutex_postfork_parent(tsdn, &ctl_mtx);\n}\n\nvoid\nctl_postfork_child(tsdn_t *tsdn) {\n\tmalloc_mutex_postfork_child(tsdn, &ctl_mtx);\n}\n\nvoid\nctl_mtx_assert_held(tsdn_t *tsdn) {\n\tmalloc_mutex_assert_owner(tsdn, &ctl_mtx);\n}\n\n/******************************************************************************/\n/* *_ctl() functions. */\n\n#define READONLY()\tdo {\t\t\t\t\t\t\\\n\tif (newp != NULL || newlen != 0) {\t\t\t\t\\\n\t\tret = EPERM;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define WRITEONLY()\tdo {\t\t\t\t\t\t\\\n\tif (oldp != NULL || oldlenp != NULL) {\t\t\t\t\\\n\t\tret = EPERM;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Can read or write, but not both. */\n#define READ_XOR_WRITE()\tdo {\t\t\t\t\t\\\n\tif ((oldp != NULL && oldlenp != NULL) && (newp != NULL ||\t\\\n\t newlen != 0)) {\t\t\t\t\t\t\\\n\t\tret = EPERM;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Can neither read nor write. */\n#define NEITHER_READ_NOR_WRITE()\tdo {\t\t\t\t\\\n\tif (oldp != NULL || oldlenp != NULL || newp != NULL ||\t\t\\\n\t newlen != 0) {\t\t\t\t\t\t\\\n\t\tret = EPERM;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/* Verify that the space provided is enough. */\n#define VERIFY_READ(t)\tdo {\t\t\t\t\t\t\\\n\tif (oldp == NULL || oldlenp == NULL || *oldlenp != sizeof(t)) {\t\\\n\t\t*oldlenp = 0;\t\t\t\t\t\t\\\n\t\tret = EINVAL;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define READ(v, t)\tdo {\t\t\t\t\t\t\\\n\tif (oldp != NULL && oldlenp != NULL) {\t\t\t\t\\\n\t\tif (*oldlenp != sizeof(t)) {\t\t\t\t\\\n\t\t\tsize_t\tcopylen = (sizeof(t) <= *oldlenp)\t\\\n\t\t\t ? sizeof(t) : *oldlenp;\t\t\t\\\n\t\t\tmemcpy(oldp, (void *)&(v), copylen);\t\t\\\n\t\t\t*oldlenp = copylen;\t\t\t\t\\\n\t\t\tret = EINVAL;\t\t\t\t\t\\\n\t\t\tgoto label_return;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\t*(t *)oldp = (v);\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define WRITE(v, t)\tdo {\t\t\t\t\t\t\\\n\tif (newp != NULL) {\t\t\t\t\t\t\\\n\t\tif (newlen != sizeof(t)) {\t\t\t\t\\\n\t\t\tret = EINVAL;\t\t\t\t\t\\\n\t\t\tgoto label_return;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\t(v) = *(t *)newp;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define ASSURED_WRITE(v, t)\tdo {\t\t\t\t\t\\\n\tif (newp == NULL || newlen != sizeof(t)) {\t\t\t\\\n\t\tret = EINVAL;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t(v) = *(t *)newp;\t\t\t\t\t\t\\\n} while (0)\n\n#define MIB_UNSIGNED(v, i) do {\t\t\t\t\t\t\\\n\tif (mib[i] > UINT_MAX) {\t\t\t\t\t\\\n\t\tret = EFAULT;\t\t\t\t\t\t\\\n\t\tgoto label_return;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tv = (unsigned)mib[i];\t\t\t\t\t\t\\\n} while (0)\n\n/*\n * There's a lot of code duplication in the following macros due to limitations\n * in how nested cpp macros are expanded.\n */\n#define CTL_RO_CLGEN(c, l, n, v, t)\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\t\\\n size_t *oldlenp, void *newp, size_t newlen) {\t\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tif (!(c)) {\t\t\t\t\t\t\t\\\n\t\treturn ENOENT;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (l) {\t\t\t\t\t\t\t\\\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = (v);\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\tif (l) {\t\t\t\t\t\t\t\\\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n#define CTL_RO_CGEN(c, n, v, t)\t\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\t\t\t\\\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tif (!(c)) {\t\t\t\t\t\t\t\\\n\t\treturn ENOENT;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = (v);\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n#define CTL_RO_GEN(n, v, t)\t\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\t\\\n size_t *oldlenp, void *newp, size_t newlen) {\t\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = (v);\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n/*\n * ctl_mtx is not acquired, under the assumption that no pertinent data will\n * mutate during the call.\n */\n#define CTL_RO_NL_CGEN(c, n, v, t)\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\t\t\t\\\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tif (!(c)) {\t\t\t\t\t\t\t\\\n\t\treturn ENOENT;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = (v);\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n#define CTL_RO_NL_GEN(n, v, t)\t\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\t\t\t\\\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = (v);\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n#define CTL_RO_CONFIG_GEN(n, t)\t\t\t\t\t\t\\\nstatic int\t\t\t\t\t\t\t\t\\\nn##_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\t\t\t\\\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\t\t\\\n\tint ret;\t\t\t\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tREADONLY();\t\t\t\t\t\t\t\\\n\toldval = n;\t\t\t\t\t\t\t\\\n\tREAD(oldval, t);\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tret = 0;\t\t\t\t\t\t\t\\\nlabel_return:\t\t\t\t\t\t\t\t\\\n\treturn ret;\t\t\t\t\t\t\t\\\n}\n\n/******************************************************************************/\n\nCTL_RO_NL_GEN(version, JEMALLOC_VERSION, const char *)\n\nstatic int\nepoch_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tUNUSED uint64_t newval;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tWRITE(newval, uint64_t);\n\tif (newp != NULL) {\n\t\tctl_refresh(tsd_tsdn(tsd));\n\t}\n\tREAD(ctl_arenas->epoch, uint64_t);\n\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nbackground_thread_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp,\n void *newp, size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\tif (!have_background_thread) {\n\t\treturn ENOENT;\n\t}\n\tbackground_thread_ctl_init(tsd_tsdn(tsd));\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &background_thread_lock);\n\tif (newp == NULL) {\n\t\toldval = background_thread_enabled();\n\t\tREAD(oldval, bool);\n\t} else {\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\toldval = background_thread_enabled();\n\t\tREAD(oldval, bool);\n\n\t\tbool newval = *(bool *)newp;\n\t\tif (newval == oldval) {\n\t\t\tret = 0;\n\t\t\tgoto label_return;\n\t\t}\n\n\t\tbackground_thread_enabled_set(tsd_tsdn(tsd), newval);\n\t\tif (newval) {\n\t\t\tif (background_threads_enable(tsd)) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t} else {\n\t\t\tif (background_threads_disable(tsd)) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\t}\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &background_thread_lock);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\n\treturn ret;\n}\n\nstatic int\nmax_background_threads_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tsize_t oldval;\n\n\tif (!have_background_thread) {\n\t\treturn ENOENT;\n\t}\n\tbackground_thread_ctl_init(tsd_tsdn(tsd));\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &background_thread_lock);\n\tif (newp == NULL) {\n\t\toldval = max_background_threads;\n\t\tREAD(oldval, size_t);\n\t} else {\n\t\tif (newlen != sizeof(size_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\toldval = max_background_threads;\n\t\tREAD(oldval, size_t);\n\n\t\tsize_t newval = *(size_t *)newp;\n\t\tif (newval == oldval) {\n\t\t\tret = 0;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (newval > opt_max_background_threads) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\n\t\tif (background_thread_enabled()) {\n\t\t\tbackground_thread_enabled_set(tsd_tsdn(tsd), false);\n\t\t\tif (background_threads_disable(tsd)) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t\tmax_background_threads = newval;\n\t\t\tbackground_thread_enabled_set(tsd_tsdn(tsd), true);\n\t\t\tif (background_threads_enable(tsd)) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t} else {\n\t\t\tmax_background_threads = newval;\n\t\t}\n\t}\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &background_thread_lock);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\n\treturn ret;\n}\n\n/******************************************************************************/\n\nCTL_RO_CONFIG_GEN(config_cache_oblivious, bool)\nCTL_RO_CONFIG_GEN(config_debug, bool)\nCTL_RO_CONFIG_GEN(config_fill, bool)\nCTL_RO_CONFIG_GEN(config_lazy_lock, bool)\nCTL_RO_CONFIG_GEN(config_malloc_conf, const char *)\nCTL_RO_CONFIG_GEN(config_opt_safety_checks, bool)\nCTL_RO_CONFIG_GEN(config_prof, bool)\nCTL_RO_CONFIG_GEN(config_prof_libgcc, bool)\nCTL_RO_CONFIG_GEN(config_prof_libunwind, bool)\nCTL_RO_CONFIG_GEN(config_stats, bool)\nCTL_RO_CONFIG_GEN(config_utrace, bool)\nCTL_RO_CONFIG_GEN(config_xmalloc, bool)\n\n/******************************************************************************/\n\nCTL_RO_NL_GEN(opt_abort, opt_abort, bool)\nCTL_RO_NL_GEN(opt_abort_conf, opt_abort_conf, bool)\nCTL_RO_NL_GEN(opt_cache_oblivious, opt_cache_oblivious, bool)\nCTL_RO_NL_GEN(opt_trust_madvise, opt_trust_madvise, bool)\nCTL_RO_NL_GEN(opt_confirm_conf, opt_confirm_conf, bool)\n\n/* HPA options. */\nCTL_RO_NL_GEN(opt_hpa, opt_hpa, bool)\nCTL_RO_NL_GEN(opt_hpa_hugification_threshold,\n opt_hpa_opts.hugification_threshold, size_t)\nCTL_RO_NL_GEN(opt_hpa_hugify_delay_ms, opt_hpa_opts.hugify_delay_ms, uint64_t)\nCTL_RO_NL_GEN(opt_hpa_min_purge_interval_ms, opt_hpa_opts.min_purge_interval_ms,\n uint64_t)\n\n/*\n * This will have to change before we publicly document this option; fxp_t and\n * its representation are internal implementation details.\n */\nCTL_RO_NL_GEN(opt_hpa_dirty_mult, opt_hpa_opts.dirty_mult, fxp_t)\nCTL_RO_NL_GEN(opt_hpa_slab_max_alloc, opt_hpa_opts.slab_max_alloc, size_t)\n\n/* HPA SEC options */\nCTL_RO_NL_GEN(opt_hpa_sec_nshards, opt_hpa_sec_opts.nshards, size_t)\nCTL_RO_NL_GEN(opt_hpa_sec_max_alloc, opt_hpa_sec_opts.max_alloc, size_t)\nCTL_RO_NL_GEN(opt_hpa_sec_max_bytes, opt_hpa_sec_opts.max_bytes, size_t)\nCTL_RO_NL_GEN(opt_hpa_sec_bytes_after_flush, opt_hpa_sec_opts.bytes_after_flush,\n size_t)\nCTL_RO_NL_GEN(opt_hpa_sec_batch_fill_extra, opt_hpa_sec_opts.batch_fill_extra,\n size_t)\n\nCTL_RO_NL_GEN(opt_metadata_thp, metadata_thp_mode_names[opt_metadata_thp],\n const char *)\nCTL_RO_NL_GEN(opt_retain, opt_retain, bool)\nCTL_RO_NL_GEN(opt_dss, opt_dss, const char *)\nCTL_RO_NL_GEN(opt_narenas, opt_narenas, unsigned)\nCTL_RO_NL_GEN(opt_percpu_arena, percpu_arena_mode_names[opt_percpu_arena],\n const char *)\nCTL_RO_NL_GEN(opt_mutex_max_spin, opt_mutex_max_spin, int64_t)\nCTL_RO_NL_GEN(opt_oversize_threshold, opt_oversize_threshold, size_t)\nCTL_RO_NL_GEN(opt_background_thread, opt_background_thread, bool)\nCTL_RO_NL_GEN(opt_max_background_threads, opt_max_background_threads, size_t)\nCTL_RO_NL_GEN(opt_dirty_decay_ms, opt_dirty_decay_ms, ssize_t)\nCTL_RO_NL_GEN(opt_muzzy_decay_ms, opt_muzzy_decay_ms, ssize_t)\nCTL_RO_NL_GEN(opt_stats_print, opt_stats_print, bool)\nCTL_RO_NL_GEN(opt_stats_print_opts, opt_stats_print_opts, const char *)\nCTL_RO_NL_GEN(opt_stats_interval, opt_stats_interval, int64_t)\nCTL_RO_NL_GEN(opt_stats_interval_opts, opt_stats_interval_opts, const char *)\nCTL_RO_NL_CGEN(config_fill, opt_junk, opt_junk, const char *)\nCTL_RO_NL_CGEN(config_fill, opt_zero, opt_zero, bool)\nCTL_RO_NL_CGEN(config_utrace, opt_utrace, opt_utrace, bool)\nCTL_RO_NL_CGEN(config_xmalloc, opt_xmalloc, opt_xmalloc, bool)\nCTL_RO_NL_CGEN(config_enable_cxx, opt_experimental_infallible_new,\n opt_experimental_infallible_new, bool)\nCTL_RO_NL_GEN(opt_tcache, opt_tcache, bool)\nCTL_RO_NL_GEN(opt_tcache_max, opt_tcache_max, size_t)\nCTL_RO_NL_GEN(opt_tcache_nslots_small_min, opt_tcache_nslots_small_min,\n unsigned)\nCTL_RO_NL_GEN(opt_tcache_nslots_small_max, opt_tcache_nslots_small_max,\n unsigned)\nCTL_RO_NL_GEN(opt_tcache_nslots_large, opt_tcache_nslots_large, unsigned)\nCTL_RO_NL_GEN(opt_lg_tcache_nslots_mul, opt_lg_tcache_nslots_mul, ssize_t)\nCTL_RO_NL_GEN(opt_tcache_gc_incr_bytes, opt_tcache_gc_incr_bytes, size_t)\nCTL_RO_NL_GEN(opt_tcache_gc_delay_bytes, opt_tcache_gc_delay_bytes, size_t)\nCTL_RO_NL_GEN(opt_lg_tcache_flush_small_div, opt_lg_tcache_flush_small_div,\n unsigned)\nCTL_RO_NL_GEN(opt_lg_tcache_flush_large_div, opt_lg_tcache_flush_large_div,\n unsigned)\nCTL_RO_NL_GEN(opt_thp, thp_mode_names[opt_thp], const char *)\nCTL_RO_NL_GEN(opt_lg_extent_max_active_fit, opt_lg_extent_max_active_fit,\n size_t)\nCTL_RO_NL_CGEN(config_prof, opt_prof, opt_prof, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_prefix, opt_prof_prefix, const char *)\nCTL_RO_NL_CGEN(config_prof, opt_prof_active, opt_prof_active, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_thread_active_init,\n opt_prof_thread_active_init, bool)\nCTL_RO_NL_CGEN(config_prof, opt_lg_prof_sample, opt_lg_prof_sample, size_t)\nCTL_RO_NL_CGEN(config_prof, opt_prof_accum, opt_prof_accum, bool)\nCTL_RO_NL_CGEN(config_prof, opt_lg_prof_interval, opt_lg_prof_interval, ssize_t)\nCTL_RO_NL_CGEN(config_prof, opt_prof_gdump, opt_prof_gdump, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_final, opt_prof_final, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_leak, opt_prof_leak, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_leak_error, opt_prof_leak_error, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_recent_alloc_max,\n opt_prof_recent_alloc_max, ssize_t)\nCTL_RO_NL_CGEN(config_prof, opt_prof_stats, opt_prof_stats, bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_sys_thread_name, opt_prof_sys_thread_name,\n bool)\nCTL_RO_NL_CGEN(config_prof, opt_prof_time_res,\n prof_time_res_mode_names[opt_prof_time_res], const char *)\nCTL_RO_NL_CGEN(config_uaf_detection, opt_lg_san_uaf_align,\n opt_lg_san_uaf_align, ssize_t)\nCTL_RO_NL_GEN(opt_zero_realloc,\n zero_realloc_mode_names[opt_zero_realloc_action], const char *)\n\n/******************************************************************************/\n\nstatic int\nthread_arena_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tarena_t *oldarena;\n\tunsigned newind, oldind;\n\n\toldarena = arena_choose(tsd, NULL);\n\tif (oldarena == NULL) {\n\t\treturn EAGAIN;\n\t}\n\tnewind = oldind = arena_ind_get(oldarena);\n\tWRITE(newind, unsigned);\n\tREAD(oldind, unsigned);\n\n\tif (newind != oldind) {\n\t\tarena_t *newarena;\n\n\t\tif (newind >= narenas_total_get()) {\n\t\t\t/* New arena index is out of range. */\n\t\t\tret = EFAULT;\n\t\t\tgoto label_return;\n\t\t}\n\n\t\tif (have_percpu_arena &&\n\t\t PERCPU_ARENA_ENABLED(opt_percpu_arena)) {\n\t\t\tif (newind < percpu_arena_ind_limit(opt_percpu_arena)) {\n\t\t\t\t/*\n\t\t\t\t * If perCPU arena is enabled, thread_arena\n\t\t\t\t * control is not allowed for the auto arena\n\t\t\t\t * range.\n\t\t\t\t */\n\t\t\t\tret = EPERM;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\n\t\t/* Initialize arena if necessary. */\n\t\tnewarena = arena_get(tsd_tsdn(tsd), newind, true);\n\t\tif (newarena == NULL) {\n\t\t\tret = EAGAIN;\n\t\t\tgoto label_return;\n\t\t}\n\t\t/* Set new arena/tcache associations. */\n\t\tarena_migrate(tsd, oldarena, newarena);\n\t\tif (tcache_available(tsd)) {\n\t\t\ttcache_arena_reassociate(tsd_tsdn(tsd),\n\t\t\t tsd_tcache_slowp_get(tsd), tsd_tcachep_get(tsd),\n\t\t\t newarena);\n\t\t}\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nCTL_RO_NL_GEN(thread_allocated, tsd_thread_allocated_get(tsd), uint64_t)\nCTL_RO_NL_GEN(thread_allocatedp, tsd_thread_allocatedp_get(tsd), uint64_t *)\nCTL_RO_NL_GEN(thread_deallocated, tsd_thread_deallocated_get(tsd), uint64_t)\nCTL_RO_NL_GEN(thread_deallocatedp, tsd_thread_deallocatedp_get(tsd), uint64_t *)\n\nstatic int\nthread_tcache_enabled_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\toldval = tcache_enabled_get(tsd);\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\ttcache_enabled_set(tsd, *(bool *)newp);\n\t}\n\tREAD(oldval, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_tcache_flush_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\n\tif (!tcache_available(tsd)) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tNEITHER_READ_NOR_WRITE();\n\n\ttcache_flush(tsd);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_peak_read_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tif (!config_stats) {\n\t\treturn ENOENT;\n\t}\n\tREADONLY();\n\tpeak_event_update(tsd);\n\tuint64_t result = peak_event_max(tsd);\n\tREAD(result, uint64_t);\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_peak_reset_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tif (!config_stats) {\n\t\treturn ENOENT;\n\t}\n\tNEITHER_READ_NOR_WRITE();\n\tpeak_event_zero(tsd);\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_prof_name_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tREAD_XOR_WRITE();\n\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(const char *)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\n\t\tif ((ret = prof_thread_name_set(tsd, *(const char **)newp)) !=\n\t\t 0) {\n\t\t\tgoto label_return;\n\t\t}\n\t} else {\n\t\tconst char *oldname = prof_thread_name_get(tsd);\n\t\tREAD(oldname, const char *);\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_prof_active_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\tif (!config_prof) {\n\t\treturn ENOENT;\n\t}\n\n\toldval = opt_prof ? prof_thread_active_get(tsd) : false;\n\tif (newp != NULL) {\n\t\tif (!opt_prof) {\n\t\t\tret = ENOENT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (prof_thread_active_set(tsd, *(bool *)newp)) {\n\t\t\tret = EAGAIN;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\tREAD(oldval, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nthread_idle_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\n\tNEITHER_READ_NOR_WRITE();\n\n\tif (tcache_available(tsd)) {\n\t\ttcache_flush(tsd);\n\t}\n\t/*\n\t * This heuristic is perhaps not the most well-considered. But it\n\t * matches the only idling policy we have experience with in the status\n\t * quo. Over time we should investigate more principled approaches.\n\t */\n\tif (opt_narenas > ncpus * 2) {\n\t\tarena_t *arena = arena_choose(tsd, NULL);\n\t\tif (arena != NULL) {\n\t\t\tarena_decay(tsd_tsdn(tsd), arena, false, true);\n\t\t}\n\t\t/*\n\t\t * The missing arena case is not actually an error; a thread\n\t\t * might be idle before it associates itself to one. This is\n\t\t * unusual, but not wrong.\n\t\t */\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\n/******************************************************************************/\n\nstatic int\ntcache_create_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned tcache_ind;\n\n\tREADONLY();\n\tVERIFY_READ(unsigned);\n\tif (tcaches_create(tsd, b0get(), &tcache_ind)) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\tREAD(tcache_ind, unsigned);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\ntcache_flush_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned tcache_ind;\n\n\tWRITEONLY();\n\tASSURED_WRITE(tcache_ind, unsigned);\n\ttcaches_flush(tsd, tcache_ind);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\ntcache_destroy_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned tcache_ind;\n\n\tWRITEONLY();\n\tASSURED_WRITE(tcache_ind, unsigned);\n\ttcaches_destroy(tsd, tcache_ind);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\n/******************************************************************************/\n\nstatic int\narena_i_initialized_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\tunsigned arena_ind;\n\tbool initialized;\n\n\tREADONLY();\n\tMIB_UNSIGNED(arena_ind, 1);\n\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\tinitialized = arenas_i(arena_ind)->initialized;\n\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\n\tREAD(initialized, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic void\narena_i_decay(tsdn_t *tsdn, unsigned arena_ind, bool all) {\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\t{\n\t\tunsigned narenas = ctl_arenas->narenas;\n\n\t\t/*\n\t\t * Access via index narenas is deprecated, and scheduled for\n\t\t * removal in 6.0.0.\n\t\t */\n\t\tif (arena_ind == MALLCTL_ARENAS_ALL || arena_ind == narenas) {\n\t\t\tunsigned i;\n\t\t\tVARIABLE_ARRAY(arena_t *, tarenas, narenas);\n\n\t\t\tfor (i = 0; i < narenas; i++) {\n\t\t\t\ttarenas[i] = arena_get(tsdn, i, false);\n\t\t\t}\n\n\t\t\t/*\n\t\t\t * No further need to hold ctl_mtx, since narenas and\n\t\t\t * tarenas contain everything needed below.\n\t\t\t */\n\t\t\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\n\t\t\tfor (i = 0; i < narenas; i++) {\n\t\t\t\tif (tarenas[i] != NULL) {\n\t\t\t\t\tarena_decay(tsdn, tarenas[i], false,\n\t\t\t\t\t all);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tarena_t *tarena;\n\n\t\t\tassert(arena_ind < narenas);\n\n\t\t\ttarena = arena_get(tsdn, arena_ind, false);\n\n\t\t\t/* No further need to hold ctl_mtx. */\n\t\t\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\n\t\t\tif (tarena != NULL) {\n\t\t\t\tarena_decay(tsdn, tarena, false, all);\n\t\t\t}\n\t\t}\n\t}\n}\n\nstatic int\narena_i_decay_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\n\tNEITHER_READ_NOR_WRITE();\n\tMIB_UNSIGNED(arena_ind, 1);\n\tarena_i_decay(tsd_tsdn(tsd), arena_ind, false);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\narena_i_purge_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\n\tNEITHER_READ_NOR_WRITE();\n\tMIB_UNSIGNED(arena_ind, 1);\n\tarena_i_decay(tsd_tsdn(tsd), arena_ind, true);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\narena_i_reset_destroy_helper(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen, unsigned *arena_ind,\n arena_t **arena) {\n\tint ret;\n\n\tNEITHER_READ_NOR_WRITE();\n\tMIB_UNSIGNED(*arena_ind, 1);\n\n\t*arena = arena_get(tsd_tsdn(tsd), *arena_ind, false);\n\tif (*arena == NULL || arena_is_auto(*arena)) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic void\narena_reset_prepare_background_thread(tsd_t *tsd, unsigned arena_ind) {\n\t/* Temporarily disable the background thread during arena reset. */\n\tif (have_background_thread) {\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &background_thread_lock);\n\t\tif (background_thread_enabled()) {\n\t\t\tbackground_thread_info_t *info =\n\t\t\t background_thread_info_get(arena_ind);\n\t\t\tassert(info->state == background_thread_started);\n\t\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\t\tinfo->state = background_thread_paused;\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\t}\n\t}\n}\n\nstatic void\narena_reset_finish_background_thread(tsd_t *tsd, unsigned arena_ind) {\n\tif (have_background_thread) {\n\t\tif (background_thread_enabled()) {\n\t\t\tbackground_thread_info_t *info =\n\t\t\t background_thread_info_get(arena_ind);\n\t\t\tassert(info->state == background_thread_paused);\n\t\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\t\tinfo->state = background_thread_started;\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\t}\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &background_thread_lock);\n\t}\n}\n\nstatic int\narena_i_reset_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\tarena_t *arena;\n\n\tret = arena_i_reset_destroy_helper(tsd, mib, miblen, oldp, oldlenp,\n\t newp, newlen, &arena_ind, &arena);\n\tif (ret != 0) {\n\t\treturn ret;\n\t}\n\n\tarena_reset_prepare_background_thread(tsd, arena_ind);\n\tarena_reset(tsd, arena);\n\tarena_reset_finish_background_thread(tsd, arena_ind);\n\n\treturn ret;\n}\n\nstatic int\narena_i_destroy_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\tarena_t *arena;\n\tctl_arena_t *ctl_darena, *ctl_arena;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\n\tret = arena_i_reset_destroy_helper(tsd, mib, miblen, oldp, oldlenp,\n\t newp, newlen, &arena_ind, &arena);\n\tif (ret != 0) {\n\t\tgoto label_return;\n\t}\n\n\tif (arena_nthreads_get(arena, false) != 0 || arena_nthreads_get(arena,\n\t true) != 0) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tarena_reset_prepare_background_thread(tsd, arena_ind);\n\t/* Merge stats after resetting and purging arena. */\n\tarena_reset(tsd, arena);\n\tarena_decay(tsd_tsdn(tsd), arena, false, true);\n\tctl_darena = arenas_i(MALLCTL_ARENAS_DESTROYED);\n\tctl_darena->initialized = true;\n\tctl_arena_refresh(tsd_tsdn(tsd), arena, ctl_darena, arena_ind, true);\n\t/* Destroy arena. */\n\tarena_destroy(tsd, arena);\n\tctl_arena = arenas_i(arena_ind);\n\tctl_arena->initialized = false;\n\t/* Record arena index for later recycling via arenas.create. */\n\tql_elm_new(ctl_arena, destroyed_link);\n\tql_tail_insert(&ctl_arenas->destroyed, ctl_arena, destroyed_link);\n\tarena_reset_finish_background_thread(tsd, arena_ind);\n\n\tassert(ret == 0);\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\n\treturn ret;\n}\n\nstatic int\narena_i_dss_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tconst char *dss = NULL;\n\tunsigned arena_ind;\n\tdss_prec_t dss_prec_old = dss_prec_limit;\n\tdss_prec_t dss_prec = dss_prec_limit;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tWRITE(dss, const char *);\n\tMIB_UNSIGNED(arena_ind, 1);\n\tif (dss != NULL) {\n\t\tint i;\n\t\tbool match = false;\n\n\t\tfor (i = 0; i < dss_prec_limit; i++) {\n\t\t\tif (strcmp(dss_prec_names[i], dss) == 0) {\n\t\t\t\tdss_prec = i;\n\t\t\t\tmatch = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (!match) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\n\t/*\n\t * Access via index narenas is deprecated, and scheduled for removal in\n\t * 6.0.0.\n\t */\n\tif (arena_ind == MALLCTL_ARENAS_ALL || arena_ind ==\n\t ctl_arenas->narenas) {\n\t\tif (dss_prec != dss_prec_limit &&\n\t\t extent_dss_prec_set(dss_prec)) {\n\t\t\tret = EFAULT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tdss_prec_old = extent_dss_prec_get();\n\t} else {\n\t\tarena_t *arena = arena_get(tsd_tsdn(tsd), arena_ind, false);\n\t\tif (arena == NULL || (dss_prec != dss_prec_limit &&\n\t\t arena_dss_prec_set(arena, dss_prec))) {\n\t\t\tret = EFAULT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tdss_prec_old = arena_dss_prec_get(arena);\n\t}\n\n\tdss = dss_prec_names[dss_prec_old];\n\tREAD(dss, const char *);\n\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\narena_i_oversize_threshold_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tunsigned arena_ind;\n\tMIB_UNSIGNED(arena_ind, 1);\n\n\tarena_t *arena = arena_get(tsd_tsdn(tsd), arena_ind, false);\n\tif (arena == NULL) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tif (oldp != NULL && oldlenp != NULL) {\n\t\tsize_t oldval = atomic_load_zu(\n\t\t &arena->pa_shard.pac.oversize_threshold, ATOMIC_RELAXED);\n\t\tREAD(oldval, size_t);\n\t}\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(size_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tatomic_store_zu(&arena->pa_shard.pac.oversize_threshold,\n\t\t *(size_t *)newp, ATOMIC_RELAXED);\n\t}\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\narena_i_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen, bool dirty) {\n\tint ret;\n\tunsigned arena_ind;\n\tarena_t *arena;\n\n\tMIB_UNSIGNED(arena_ind, 1);\n\tarena = arena_get(tsd_tsdn(tsd), arena_ind, false);\n\tif (arena == NULL) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\textent_state_t state = dirty ? extent_state_dirty : extent_state_muzzy;\n\n\tif (oldp != NULL && oldlenp != NULL) {\n\t\tsize_t oldval = arena_decay_ms_get(arena, state);\n\t\tREAD(oldval, ssize_t);\n\t}\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(ssize_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (arena_is_huge(arena_ind) && *(ssize_t *)newp > 0) {\n\t\t\t/*\n\t\t\t * By default the huge arena purges eagerly. If it is\n\t\t\t * set to non-zero decay time afterwards, background\n\t\t\t * thread might be needed.\n\t\t\t */\n\t\t\tif (background_thread_create(tsd, arena_ind)) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\n\t\tif (arena_decay_ms_set(tsd_tsdn(tsd), arena, state,\n\t\t *(ssize_t *)newp)) {\n\t\t\tret = EFAULT;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\narena_i_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\treturn arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,\n\t newlen, true);\n}\n\nstatic int\narena_i_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\treturn arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,\n\t newlen, false);\n}\n\nstatic int\narena_i_extent_hooks_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\tarena_t *arena;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tMIB_UNSIGNED(arena_ind, 1);\n\tif (arena_ind < narenas_total_get()) {\n\t\textent_hooks_t *old_extent_hooks;\n\t\tarena = arena_get(tsd_tsdn(tsd), arena_ind, false);\n\t\tif (arena == NULL) {\n\t\t\tif (arena_ind >= narenas_auto) {\n\t\t\t\tret = EFAULT;\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t\told_extent_hooks =\n\t\t\t (extent_hooks_t *)&ehooks_default_extent_hooks;\n\t\t\tREAD(old_extent_hooks, extent_hooks_t *);\n\t\t\tif (newp != NULL) {\n\t\t\t\t/* Initialize a new arena as a side effect. */\n\t\t\t\textent_hooks_t *new_extent_hooks\n\t\t\t\t JEMALLOC_CC_SILENCE_INIT(NULL);\n\t\t\t\tWRITE(new_extent_hooks, extent_hooks_t *);\n\t\t\t\tarena_config_t config = arena_config_default;\n\t\t\t\tconfig.extent_hooks = new_extent_hooks;\n\n\t\t\t\tarena = arena_init(tsd_tsdn(tsd), arena_ind,\n\t\t\t\t &config);\n\t\t\t\tif (arena == NULL) {\n\t\t\t\t\tret = EFAULT;\n\t\t\t\t\tgoto label_return;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (newp != NULL) {\n\t\t\t\textent_hooks_t *new_extent_hooks\n\t\t\t\t JEMALLOC_CC_SILENCE_INIT(NULL);\n\t\t\t\tWRITE(new_extent_hooks, extent_hooks_t *);\n\t\t\t\told_extent_hooks = arena_set_extent_hooks(tsd,\n\t\t\t\t arena, new_extent_hooks);\n\t\t\t\tREAD(old_extent_hooks, extent_hooks_t *);\n\t\t\t} else {\n\t\t\t\told_extent_hooks =\n\t\t\t\t ehooks_get_extent_hooks_ptr(\n\t\t\t\t\tarena_get_ehooks(arena));\n\t\t\t\tREAD(old_extent_hooks, extent_hooks_t *);\n\t\t\t}\n\t\t}\n\t} else {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\narena_i_retain_grow_limit_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\tarena_t *arena;\n\n\tif (!opt_retain) {\n\t\t/* Only relevant when retain is enabled. */\n\t\treturn ENOENT;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tMIB_UNSIGNED(arena_ind, 1);\n\tif (arena_ind < narenas_total_get() && (arena =\n\t arena_get(tsd_tsdn(tsd), arena_ind, false)) != NULL) {\n\t\tsize_t old_limit, new_limit;\n\t\tif (newp != NULL) {\n\t\t\tWRITE(new_limit, size_t);\n\t\t}\n\t\tbool err = arena_retain_grow_limit_get_set(tsd, arena,\n\t\t &old_limit, newp != NULL ? &new_limit : NULL);\n\t\tif (!err) {\n\t\t\tREAD(old_limit, size_t);\n\t\t\tret = 0;\n\t\t} else {\n\t\t\tret = EFAULT;\n\t\t}\n\t} else {\n\t\tret = EFAULT;\n\t}\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic const ctl_named_node_t *\narena_i_index(tsdn_t *tsdn, const size_t *mib, size_t miblen,\n size_t i) {\n\tconst ctl_named_node_t *ret;\n\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\tswitch (i) {\n\tcase MALLCTL_ARENAS_ALL:\n\tcase MALLCTL_ARENAS_DESTROYED:\n\t\tbreak;\n\tdefault:\n\t\tif (i > ctl_arenas->narenas) {\n\t\t\tret = NULL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tbreak;\n\t}\n\n\tret = super_arena_i_node;\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\treturn ret;\n}\n\n/******************************************************************************/\n\nstatic int\narenas_narenas_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned narenas;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tREADONLY();\n\tnarenas = ctl_arenas->narenas;\n\tREAD(narenas, unsigned);\n\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\narenas_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen, bool dirty) {\n\tint ret;\n\n\tif (oldp != NULL && oldlenp != NULL) {\n\t\tsize_t oldval = (dirty ? arena_dirty_decay_ms_default_get() :\n\t\t arena_muzzy_decay_ms_default_get());\n\t\tREAD(oldval, ssize_t);\n\t}\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(ssize_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (dirty ? arena_dirty_decay_ms_default_set(*(ssize_t *)newp)\n\t\t : arena_muzzy_decay_ms_default_set(*(ssize_t *)newp)) {\n\t\t\tret = EFAULT;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\narenas_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\treturn arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,\n\t newlen, true);\n}\n\nstatic int\narenas_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\treturn arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,\n\t newlen, false);\n}\n\nCTL_RO_NL_GEN(arenas_quantum, QUANTUM, size_t)\nCTL_RO_NL_GEN(arenas_page, PAGE, size_t)\nCTL_RO_NL_GEN(arenas_tcache_max, tcache_maxclass, size_t)\nCTL_RO_NL_GEN(arenas_nbins, SC_NBINS, unsigned)\nCTL_RO_NL_GEN(arenas_nhbins, nhbins, unsigned)\nCTL_RO_NL_GEN(arenas_bin_i_size, bin_infos[mib[2]].reg_size, size_t)\nCTL_RO_NL_GEN(arenas_bin_i_nregs, bin_infos[mib[2]].nregs, uint32_t)\nCTL_RO_NL_GEN(arenas_bin_i_slab_size, bin_infos[mib[2]].slab_size, size_t)\nCTL_RO_NL_GEN(arenas_bin_i_nshards, bin_infos[mib[2]].n_shards, uint32_t)\nstatic const ctl_named_node_t *\narenas_bin_i_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t i) {\n\tif (i > SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_arenas_bin_i_node;\n}\n\nCTL_RO_NL_GEN(arenas_nlextents, SC_NSIZES - SC_NBINS, unsigned)\nCTL_RO_NL_GEN(arenas_lextent_i_size, sz_index2size(SC_NBINS+(szind_t)mib[2]),\n size_t)\nstatic const ctl_named_node_t *\narenas_lextent_i_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t i) {\n\tif (i > SC_NSIZES - SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_arenas_lextent_i_node;\n}\n\nstatic int\narenas_create_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\n\tVERIFY_READ(unsigned);\n\tarena_config_t config = arena_config_default;\n\tWRITE(config.extent_hooks, extent_hooks_t *);\n\tif ((arena_ind = ctl_arena_init(tsd, &config)) == UINT_MAX) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\tREAD(arena_ind, unsigned);\n\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nexperimental_arenas_create_ext_ctl(tsd_t *tsd,\n const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\n\tarena_config_t config = arena_config_default;\n\tVERIFY_READ(unsigned);\n\tWRITE(config, arena_config_t);\n\n\tif ((arena_ind = ctl_arena_init(tsd, &config)) == UINT_MAX) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\tREAD(arena_ind, unsigned);\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\narenas_lookup_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tunsigned arena_ind;\n\tvoid *ptr;\n\tedata_t *edata;\n\tarena_t *arena;\n\n\tptr = NULL;\n\tret = EINVAL;\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tWRITE(ptr, void *);\n\tedata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr);\n\tif (edata == NULL) {\n\t\tgoto label_return;\n\t}\n\n\tarena = arena_get_from_edata(edata);\n\tif (arena == NULL) {\n\t\tgoto label_return;\n\t}\n\n\tarena_ind = arena_ind_get(arena);\n\tREAD(arena_ind, unsigned);\n\n\tret = 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\n/******************************************************************************/\n\nstatic int\nprof_thread_active_init_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\tif (!config_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tif (newp != NULL) {\n\t\tif (!opt_prof) {\n\t\t\tret = ENOENT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\toldval = prof_thread_active_init_set(tsd_tsdn(tsd),\n\t\t *(bool *)newp);\n\t} else {\n\t\toldval = opt_prof ? prof_thread_active_init_get(tsd_tsdn(tsd)) :\n\t\t false;\n\t}\n\tREAD(oldval, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_active_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\tif (!config_prof) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tbool val = *(bool *)newp;\n\t\tif (!opt_prof) {\n\t\t\tif (val) {\n\t\t\t\tret = ENOENT;\n\t\t\t\tgoto label_return;\n\t\t\t} else {\n\t\t\t\t/* No change needed (already off). */\n\t\t\t\toldval = false;\n\t\t\t}\n\t\t} else {\n\t\t\toldval = prof_active_set(tsd_tsdn(tsd), val);\n\t\t}\n\t} else {\n\t\toldval = opt_prof ? prof_active_get(tsd_tsdn(tsd)) : false;\n\t}\n\tREAD(oldval, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_dump_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tconst char *filename = NULL;\n\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tWRITEONLY();\n\tWRITE(filename, const char *);\n\n\tif (prof_mdump(tsd, filename)) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_gdump_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tbool oldval;\n\n\tif (!config_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tif (newp != NULL) {\n\t\tif (!opt_prof) {\n\t\t\tret = ENOENT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tif (newlen != sizeof(bool)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\toldval = prof_gdump_set(tsd_tsdn(tsd), *(bool *)newp);\n\t} else {\n\t\toldval = opt_prof ? prof_gdump_get(tsd_tsdn(tsd)) : false;\n\t}\n\tREAD(oldval, bool);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_prefix_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tconst char *prefix = NULL;\n\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tWRITEONLY();\n\tWRITE(prefix, const char *);\n\n\tret = prof_prefix_set(tsd_tsdn(tsd), prefix) ? EFAULT : 0;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nprof_reset_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tsize_t lg_sample = lg_prof_sample;\n\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tWRITEONLY();\n\tWRITE(lg_sample, size_t);\n\tif (lg_sample >= (sizeof(uint64_t) << 3)) {\n\t\tlg_sample = (sizeof(uint64_t) << 3) - 1;\n\t}\n\n\tprof_reset(tsd, lg_sample);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nCTL_RO_NL_CGEN(config_prof, prof_interval, prof_interval, uint64_t)\nCTL_RO_NL_CGEN(config_prof, lg_prof_sample, lg_prof_sample, size_t)\n\nstatic int\nprof_log_start_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tconst char *filename = NULL;\n\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tWRITEONLY();\n\tWRITE(filename, const char *);\n\n\tif (prof_log_start(tsd_tsdn(tsd), filename)) {\n\t\tret = EFAULT;\n\t\tgoto label_return;\n\t}\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_log_stop_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,\n size_t *oldlenp, void *newp, size_t newlen) {\n\tif (!config_prof || !opt_prof) {\n\t\treturn ENOENT;\n\t}\n\n\tif (prof_log_stop(tsd_tsdn(tsd))) {\n\t\treturn EFAULT;\n\t}\n\n\treturn 0;\n}\n\nstatic int\nexperimental_hooks_prof_backtrace_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tif (oldp == NULL && newp == NULL) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tif (oldp != NULL) {\n\t\tprof_backtrace_hook_t old_hook =\n\t\t prof_backtrace_hook_get();\n\t\tREAD(old_hook, prof_backtrace_hook_t);\n\t}\n\tif (newp != NULL) {\n\t\tif (!opt_prof) {\n\t\t\tret = ENOENT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tprof_backtrace_hook_t new_hook JEMALLOC_CC_SILENCE_INIT(NULL);\n\t\tWRITE(new_hook, prof_backtrace_hook_t);\n\t\tif (new_hook == NULL) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tprof_backtrace_hook_set(new_hook);\n\t}\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nexperimental_hooks_prof_dump_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tif (oldp == NULL && newp == NULL) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tif (oldp != NULL) {\n\t\tprof_dump_hook_t old_hook =\n\t\t prof_dump_hook_get();\n\t\tREAD(old_hook, prof_dump_hook_t);\n\t}\n\tif (newp != NULL) {\n\t\tif (!opt_prof) {\n\t\t\tret = ENOENT;\n\t\t\tgoto label_return;\n\t\t}\n\t\tprof_dump_hook_t new_hook JEMALLOC_CC_SILENCE_INIT(NULL);\n\t\tWRITE(new_hook, prof_dump_hook_t);\n\t\tprof_dump_hook_set(new_hook);\n\t}\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\n/* For integration test purpose only. No plan to move out of experimental. */\nstatic int\nexperimental_hooks_safety_check_abort_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tWRITEONLY();\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(safety_check_abort_hook_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tsafety_check_abort_hook_t hook JEMALLOC_CC_SILENCE_INIT(NULL);\n\t\tWRITE(hook, safety_check_abort_hook_t);\n\t\tsafety_check_set_abort(hook);\n\t}\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\n/******************************************************************************/\n\nCTL_RO_CGEN(config_stats, stats_allocated, ctl_stats->allocated, size_t)\nCTL_RO_CGEN(config_stats, stats_active, ctl_stats->active, size_t)\nCTL_RO_CGEN(config_stats, stats_metadata, ctl_stats->metadata, size_t)\nCTL_RO_CGEN(config_stats, stats_metadata_thp, ctl_stats->metadata_thp, size_t)\nCTL_RO_CGEN(config_stats, stats_resident, ctl_stats->resident, size_t)\nCTL_RO_CGEN(config_stats, stats_mapped, ctl_stats->mapped, size_t)\nCTL_RO_CGEN(config_stats, stats_retained, ctl_stats->retained, size_t)\n\nCTL_RO_CGEN(config_stats, stats_background_thread_num_threads,\n ctl_stats->background_thread.num_threads, size_t)\nCTL_RO_CGEN(config_stats, stats_background_thread_num_runs,\n ctl_stats->background_thread.num_runs, uint64_t)\nCTL_RO_CGEN(config_stats, stats_background_thread_run_interval,\n nstime_ns(&ctl_stats->background_thread.run_interval), uint64_t)\n\nCTL_RO_CGEN(config_stats, stats_zero_reallocs,\n atomic_load_zu(&zero_realloc_count, ATOMIC_RELAXED), size_t)\n\nCTL_RO_GEN(stats_arenas_i_dss, arenas_i(mib[2])->dss, const char *)\nCTL_RO_GEN(stats_arenas_i_dirty_decay_ms, arenas_i(mib[2])->dirty_decay_ms,\n ssize_t)\nCTL_RO_GEN(stats_arenas_i_muzzy_decay_ms, arenas_i(mib[2])->muzzy_decay_ms,\n ssize_t)\nCTL_RO_GEN(stats_arenas_i_nthreads, arenas_i(mib[2])->nthreads, unsigned)\nCTL_RO_GEN(stats_arenas_i_uptime,\n nstime_ns(&arenas_i(mib[2])->astats->astats.uptime), uint64_t)\nCTL_RO_GEN(stats_arenas_i_pactive, arenas_i(mib[2])->pactive, size_t)\nCTL_RO_GEN(stats_arenas_i_pdirty, arenas_i(mib[2])->pdirty, size_t)\nCTL_RO_GEN(stats_arenas_i_pmuzzy, arenas_i(mib[2])->pmuzzy, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_mapped,\n arenas_i(mib[2])->astats->astats.mapped, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_retained,\n arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.retained, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_extent_avail,\n arenas_i(mib[2])->astats->astats.pa_shard_stats.edata_avail, size_t)\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_dirty_npurge,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_dirty.npurge),\n uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_dirty_nmadvise,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_dirty.nmadvise),\n uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_dirty_purged,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_dirty.purged),\n uint64_t)\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_muzzy_npurge,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_muzzy.npurge),\n uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_muzzy_nmadvise,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_muzzy.nmadvise),\n uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_muzzy_purged,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.decay_muzzy.purged),\n uint64_t)\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_base,\n arenas_i(mib[2])->astats->astats.base,\n size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_internal,\n atomic_load_zu(&arenas_i(mib[2])->astats->astats.internal, ATOMIC_RELAXED),\n size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_metadata_thp,\n arenas_i(mib[2])->astats->astats.metadata_thp, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_tcache_bytes,\n arenas_i(mib[2])->astats->astats.tcache_bytes, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_tcache_stashed_bytes,\n arenas_i(mib[2])->astats->astats.tcache_stashed_bytes, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_resident,\n arenas_i(mib[2])->astats->astats.resident,\n size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_abandoned_vm,\n atomic_load_zu(\n &arenas_i(mib[2])->astats->astats.pa_shard_stats.pac_stats.abandoned_vm,\n ATOMIC_RELAXED), size_t)\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_sec_bytes,\n arenas_i(mib[2])->astats->secstats.bytes, size_t)\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_allocated,\n arenas_i(mib[2])->astats->allocated_small, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_nmalloc,\n arenas_i(mib[2])->astats->nmalloc_small, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_ndalloc,\n arenas_i(mib[2])->astats->ndalloc_small, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_nrequests,\n arenas_i(mib[2])->astats->nrequests_small, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_nfills,\n arenas_i(mib[2])->astats->nfills_small, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_small_nflushes,\n arenas_i(mib[2])->astats->nflushes_small, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_allocated,\n arenas_i(mib[2])->astats->astats.allocated_large, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_nmalloc,\n arenas_i(mib[2])->astats->astats.nmalloc_large, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_ndalloc,\n arenas_i(mib[2])->astats->astats.ndalloc_large, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_nrequests,\n arenas_i(mib[2])->astats->astats.nrequests_large, uint64_t)\n/*\n * Note: \"nmalloc_large\" here instead of \"nfills\" in the read. This is\n * intentional (large has no batch fill).\n */\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_nfills,\n arenas_i(mib[2])->astats->astats.nmalloc_large, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_large_nflushes,\n arenas_i(mib[2])->astats->astats.nflushes_large, uint64_t)\n\n/* Lock profiling related APIs below. */\n#define RO_MUTEX_CTL_GEN(n, l)\t\t\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_num_ops,\t\t\t\t\\\n l.n_lock_ops, uint64_t)\t\t\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_num_wait,\t\t\t\t\\\n l.n_wait_times, uint64_t)\t\t\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_num_spin_acq,\t\t\t\\\n l.n_spin_acquired, uint64_t)\t\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_num_owner_switch,\t\t\t\\\n l.n_owner_switches, uint64_t) \t\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_total_wait_time,\t\t\t\\\n nstime_ns(&l.tot_wait_time), uint64_t)\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_max_wait_time,\t\t\t\\\n nstime_ns(&l.max_wait_time), uint64_t)\t\t\t\t\\\nCTL_RO_CGEN(config_stats, stats_##n##_max_num_thds,\t\t\t\\\n l.max_n_thds, uint32_t)\n\n/* Global mutexes. */\n#define OP(mtx)\t\t\t\t\t\t\t\t\\\n RO_MUTEX_CTL_GEN(mutexes_##mtx,\t\t\t\t\t\\\n ctl_stats->mutex_prof_data[global_prof_mutex_##mtx])\nMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n\n/* Per arena mutexes */\n#define OP(mtx) RO_MUTEX_CTL_GEN(arenas_i_mutexes_##mtx,\t\t\\\n arenas_i(mib[2])->astats->astats.mutex_prof_data[arena_prof_mutex_##mtx])\nMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n\n/* tcache bin mutex */\nRO_MUTEX_CTL_GEN(arenas_i_bins_j_mutex,\n arenas_i(mib[2])->astats->bstats[mib[4]].mutex_data)\n#undef RO_MUTEX_CTL_GEN\n\n/* Resets all mutex stats, including global, arena and bin mutexes. */\nstatic int\nstats_mutexes_reset_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp,\n void *newp, size_t newlen) {\n\tif (!config_stats) {\n\t\treturn ENOENT;\n\t}\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\n#define MUTEX_PROF_RESET(mtx)\t\t\t\t\t\t\\\n malloc_mutex_lock(tsdn, &mtx);\t\t\t\t\t\\\n malloc_mutex_prof_data_reset(tsdn, &mtx);\t\t\t\t\\\n malloc_mutex_unlock(tsdn, &mtx);\n\n\t/* Global mutexes: ctl and prof. */\n\tMUTEX_PROF_RESET(ctl_mtx);\n\tif (have_background_thread) {\n\t\tMUTEX_PROF_RESET(background_thread_lock);\n\t}\n\tif (config_prof && opt_prof) {\n\t\tMUTEX_PROF_RESET(bt2gctx_mtx);\n\t\tMUTEX_PROF_RESET(tdatas_mtx);\n\t\tMUTEX_PROF_RESET(prof_dump_mtx);\n\t\tMUTEX_PROF_RESET(prof_recent_alloc_mtx);\n\t\tMUTEX_PROF_RESET(prof_recent_dump_mtx);\n\t\tMUTEX_PROF_RESET(prof_stats_mtx);\n\t}\n\n\t/* Per arena mutexes. */\n\tunsigned n = narenas_total_get();\n\n\tfor (unsigned i = 0; i < n; i++) {\n\t\tarena_t *arena = arena_get(tsdn, i, false);\n\t\tif (!arena) {\n\t\t\tcontinue;\n\t\t}\n\t\tMUTEX_PROF_RESET(arena->large_mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.edata_cache.mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.pac.ecache_dirty.mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.pac.ecache_muzzy.mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.pac.ecache_retained.mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.pac.decay_dirty.mtx);\n\t\tMUTEX_PROF_RESET(arena->pa_shard.pac.decay_muzzy.mtx);\n\t\tMUTEX_PROF_RESET(arena->tcache_ql_mtx);\n\t\tMUTEX_PROF_RESET(arena->base->mtx);\n\n\t\tfor (szind_t j = 0; j < SC_NBINS; j++) {\n\t\t\tfor (unsigned k = 0; k < bin_infos[j].n_shards; k++) {\n\t\t\t\tbin_t *bin = arena_get_bin(arena, j, k);\n\t\t\t\tMUTEX_PROF_RESET(bin->lock);\n\t\t\t}\n\t\t}\n\t}\n#undef MUTEX_PROF_RESET\n\treturn 0;\n}\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nmalloc,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nmalloc, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_ndalloc,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.ndalloc, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nrequests,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nrequests, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_curregs,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.curregs, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nfills,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nfills, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nflushes,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nflushes, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nslabs,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nslabs, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nreslabs,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.reslabs, uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_curslabs,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.curslabs, size_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nonfull_slabs,\n arenas_i(mib[2])->astats->bstats[mib[4]].stats_data.nonfull_slabs, size_t)\n\nstatic const ctl_named_node_t *\nstats_arenas_i_bins_j_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t j) {\n\tif (j > SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_stats_arenas_i_bins_j_node;\n}\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_lextents_j_nmalloc,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->lstats[mib[4]].nmalloc), uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_lextents_j_ndalloc,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->lstats[mib[4]].ndalloc), uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_lextents_j_nrequests,\n locked_read_u64_unsynchronized(\n &arenas_i(mib[2])->astats->lstats[mib[4]].nrequests), uint64_t)\nCTL_RO_CGEN(config_stats, stats_arenas_i_lextents_j_curlextents,\n arenas_i(mib[2])->astats->lstats[mib[4]].curlextents, size_t)\n\nstatic const ctl_named_node_t *\nstats_arenas_i_lextents_j_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t j) {\n\tif (j > SC_NSIZES - SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_stats_arenas_i_lextents_j_node;\n}\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_ndirty,\n arenas_i(mib[2])->astats->estats[mib[4]].ndirty, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_nmuzzy,\n arenas_i(mib[2])->astats->estats[mib[4]].nmuzzy, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_nretained,\n arenas_i(mib[2])->astats->estats[mib[4]].nretained, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_dirty_bytes,\n arenas_i(mib[2])->astats->estats[mib[4]].dirty_bytes, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_muzzy_bytes,\n arenas_i(mib[2])->astats->estats[mib[4]].muzzy_bytes, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_extents_j_retained_bytes,\n arenas_i(mib[2])->astats->estats[mib[4]].retained_bytes, size_t);\n\nstatic const ctl_named_node_t *\nstats_arenas_i_extents_j_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t j) {\n\tif (j >= SC_NPSIZES) {\n\t\treturn NULL;\n\t}\n\treturn super_stats_arenas_i_extents_j_node;\n}\n\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_npurge_passes,\n arenas_i(mib[2])->astats->hpastats.nonderived_stats.npurge_passes, uint64_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_npurges,\n arenas_i(mib[2])->astats->hpastats.nonderived_stats.npurges, uint64_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nhugifies,\n arenas_i(mib[2])->astats->hpastats.nonderived_stats.nhugifies, uint64_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_ndehugifies,\n arenas_i(mib[2])->astats->hpastats.nonderived_stats.ndehugifies, uint64_t);\n\n/* Full, nonhuge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_npageslabs_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[0].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_nactive_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[0].nactive, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_ndirty_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[0].ndirty, size_t);\n\n/* Full, huge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_npageslabs_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[1].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_nactive_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[1].nactive, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_full_slabs_ndirty_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.full_slabs[1].ndirty, size_t);\n\n/* Empty, nonhuge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_npageslabs_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[0].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_nactive_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[0].nactive, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_ndirty_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[0].ndirty, size_t);\n\n/* Empty, huge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_npageslabs_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[1].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_nactive_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[1].nactive, size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_empty_slabs_ndirty_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.empty_slabs[1].ndirty, size_t);\n\n/* Nonfull, nonhuge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][0].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][0].nactive,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_nonhuge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][0].ndirty,\n size_t);\n\n/* Nonfull, huge */\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_npageslabs_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][1].npageslabs,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_nactive_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][1].nactive,\n size_t);\nCTL_RO_CGEN(config_stats, stats_arenas_i_hpa_shard_nonfull_slabs_j_ndirty_huge,\n arenas_i(mib[2])->astats->hpastats.psset_stats.nonfull_slabs[mib[5]][1].ndirty,\n size_t);\n\nstatic const ctl_named_node_t *\nstats_arenas_i_hpa_shard_nonfull_slabs_j_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t j) {\n\tif (j >= PSSET_NPSIZES) {\n\t\treturn NULL;\n\t}\n\treturn super_stats_arenas_i_hpa_shard_nonfull_slabs_j_node;\n}\n\nstatic bool\nctl_arenas_i_verify(size_t i) {\n\tsize_t a = arenas_i2a_impl(i, true, true);\n\tif (a == UINT_MAX || !ctl_arenas->arenas[a]->initialized) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic const ctl_named_node_t *\nstats_arenas_i_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t i) {\n\tconst ctl_named_node_t *ret;\n\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\tif (ctl_arenas_i_verify(i)) {\n\t\tret = NULL;\n\t\tgoto label_return;\n\t}\n\n\tret = super_stats_arenas_i_node;\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nexperimental_hooks_install_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tif (oldp == NULL || oldlenp == NULL|| newp == NULL) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\t/*\n\t * Note: this is a *private* struct. This is an experimental interface;\n\t * forcing the user to know the jemalloc internals well enough to\n\t * extract the ABI hopefully ensures nobody gets too comfortable with\n\t * this API, which can change at a moment's notice.\n\t */\n\thooks_t hooks;\n\tWRITE(hooks, hooks_t);\n\tvoid *handle = hook_install(tsd_tsdn(tsd), &hooks);\n\tif (handle == NULL) {\n\t\tret = EAGAIN;\n\t\tgoto label_return;\n\t}\n\tREAD(handle, void *);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nexperimental_hooks_remove_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tWRITEONLY();\n\tvoid *handle = NULL;\n\tWRITE(handle, void *);\n\tif (handle == NULL) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\thook_remove(tsd_tsdn(tsd), handle);\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nexperimental_thread_activity_callback_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tif (!config_stats) {\n\t\treturn ENOENT;\n\t}\n\n\tactivity_callback_thunk_t t_old = tsd_activity_callback_thunk_get(tsd);\n\tREAD(t_old, activity_callback_thunk_t);\n\n\tif (newp != NULL) {\n\t\t/*\n\t\t * This initialization is unnecessary. If it's omitted, though,\n\t\t * clang gets confused and warns on the subsequent use of t_new.\n\t\t */\n\t\tactivity_callback_thunk_t t_new = {NULL, NULL};\n\t\tWRITE(t_new, activity_callback_thunk_t);\n\t\ttsd_activity_callback_thunk_set(tsd, t_new);\n\t}\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\n/*\n * Output six memory utilization entries for an input pointer, the first one of\n * type (void *) and the remaining five of type size_t, describing the following\n * (in the same order):\n *\n * (a) memory address of the extent a potential reallocation would go into,\n * == the five fields below describe about the extent the pointer resides in ==\n * (b) number of free regions in the extent,\n * (c) number of regions in the extent,\n * (d) size of the extent in terms of bytes,\n * (e) total number of free regions in the bin the extent belongs to, and\n * (f) total number of regions in the bin the extent belongs to.\n *\n * Note that \"(e)\" and \"(f)\" are only available when stats are enabled;\n * otherwise their values are undefined.\n *\n * This API is mainly intended for small class allocations, where extents are\n * used as slab. Note that if the bin the extent belongs to is completely\n * full, \"(a)\" will be NULL.\n *\n * In case of large class allocations, \"(a)\" will be NULL, and \"(e)\" and \"(f)\"\n * will be zero (if stats are enabled; otherwise undefined). The other three\n * fields will be properly set though the values are trivial: \"(b)\" will be 0,\n * \"(c)\" will be 1, and \"(d)\" will be the usable size.\n *\n * The input pointer and size are respectively passed in by newp and newlen,\n * and the output fields and size are respectively oldp and *oldlenp.\n *\n * It can be beneficial to define the following macros to make it easier to\n * access the output:\n *\n * #define SLABCUR_READ(out) (*(void **)out)\n * #define COUNTS(out) ((size_t *)((void **)out + 1))\n * #define NFREE_READ(out) COUNTS(out)[0]\n * #define NREGS_READ(out) COUNTS(out)[1]\n * #define SIZE_READ(out) COUNTS(out)[2]\n * #define BIN_NFREE_READ(out) COUNTS(out)[3]\n * #define BIN_NREGS_READ(out) COUNTS(out)[4]\n *\n * and then write e.g. NFREE_READ(oldp) to fetch the output. See the unit test\n * test_query in test/unit/extent_util.c for an example.\n *\n * For a typical defragmentation workflow making use of this API for\n * understanding the fragmentation level, please refer to the comment for\n * experimental_utilization_batch_query_ctl.\n *\n * It's up to the application how to determine the significance of\n * fragmentation relying on the outputs returned. Possible choices are:\n *\n * (a) if extent utilization ratio is below certain threshold,\n * (b) if extent memory consumption is above certain threshold,\n * (c) if extent utilization ratio is significantly below bin utilization ratio,\n * (d) if input pointer deviates a lot from potential reallocation address, or\n * (e) some selection/combination of the above.\n *\n * The caller needs to make sure that the input/output arguments are valid,\n * in particular, that the size of the output is correct, i.e.:\n *\n * *oldlenp = sizeof(void *) + sizeof(size_t) * 5\n *\n * Otherwise, the function immediately returns EINVAL without touching anything.\n *\n * In the rare case where there's no associated extent found for the input\n * pointer, the function zeros out all output fields and return. Please refer\n * to the comment for experimental_utilization_batch_query_ctl to understand the\n * motivation from C++.\n */\nstatic int\nexperimental_utilization_query_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tassert(sizeof(inspect_extent_util_stats_verbose_t)\n\t == sizeof(void *) + sizeof(size_t) * 5);\n\n\tif (oldp == NULL || oldlenp == NULL\n\t || *oldlenp != sizeof(inspect_extent_util_stats_verbose_t)\n\t || newp == NULL) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\n\tvoid *ptr = NULL;\n\tWRITE(ptr, void *);\n\tinspect_extent_util_stats_verbose_t *util_stats\n\t = (inspect_extent_util_stats_verbose_t *)oldp;\n\tinspect_extent_util_stats_verbose_get(tsd_tsdn(tsd), ptr,\n\t &util_stats->nfree, &util_stats->nregs, &util_stats->size,\n\t &util_stats->bin_nfree, &util_stats->bin_nregs,\n\t &util_stats->slabcur_addr);\n\tret = 0;\n\nlabel_return:\n\treturn ret;\n}\n\n/*\n * Given an input array of pointers, output three memory utilization entries of\n * type size_t for each input pointer about the extent it resides in:\n *\n * (a) number of free regions in the extent,\n * (b) number of regions in the extent, and\n * (c) size of the extent in terms of bytes.\n *\n * This API is mainly intended for small class allocations, where extents are\n * used as slab. In case of large class allocations, the outputs are trivial:\n * \"(a)\" will be 0, \"(b)\" will be 1, and \"(c)\" will be the usable size.\n *\n * Note that multiple input pointers may reside on a same extent so the output\n * fields may contain duplicates.\n *\n * The format of the input/output looks like:\n *\n * input[0]: 1st_pointer_to_query\t| output[0]: 1st_extent_n_free_regions\n *\t\t\t\t\t| output[1]: 1st_extent_n_regions\n *\t\t\t\t\t| output[2]: 1st_extent_size\n * input[1]: 2nd_pointer_to_query\t| output[3]: 2nd_extent_n_free_regions\n *\t\t\t\t\t| output[4]: 2nd_extent_n_regions\n *\t\t\t\t\t| output[5]: 2nd_extent_size\n * ...\t\t\t\t\t| ...\n *\n * The input array and size are respectively passed in by newp and newlen, and\n * the output array and size are respectively oldp and *oldlenp.\n *\n * It can be beneficial to define the following macros to make it easier to\n * access the output:\n *\n * #define NFREE_READ(out, i) out[(i) * 3]\n * #define NREGS_READ(out, i) out[(i) * 3 + 1]\n * #define SIZE_READ(out, i) out[(i) * 3 + 2]\n *\n * and then write e.g. NFREE_READ(oldp, i) to fetch the output. See the unit\n * test test_batch in test/unit/extent_util.c for a concrete example.\n *\n * A typical workflow would be composed of the following steps:\n *\n * (1) flush tcache: mallctl(\"thread.tcache.flush\", ...)\n * (2) initialize input array of pointers to query fragmentation\n * (3) allocate output array to hold utilization statistics\n * (4) query utilization: mallctl(\"experimental.utilization.batch_query\", ...)\n * (5) (optional) decide if it's worthwhile to defragment; otherwise stop here\n * (6) disable tcache: mallctl(\"thread.tcache.enabled\", ...)\n * (7) defragment allocations with significant fragmentation, e.g.:\n * for each allocation {\n * if it's fragmented {\n * malloc(...);\n * memcpy(...);\n * free(...);\n * }\n * }\n * (8) enable tcache: mallctl(\"thread.tcache.enabled\", ...)\n *\n * The application can determine the significance of fragmentation themselves\n * relying on the statistics returned, both at the overall level i.e. step \"(5)\"\n * and at individual allocation level i.e. within step \"(7)\". Possible choices\n * are:\n *\n * (a) whether memory utilization ratio is below certain threshold,\n * (b) whether memory consumption is above certain threshold, or\n * (c) some combination of the two.\n *\n * The caller needs to make sure that the input/output arrays are valid and\n * their sizes are proper as well as matched, meaning:\n *\n * (a) newlen = n_pointers * sizeof(const void *)\n * (b) *oldlenp = n_pointers * sizeof(size_t) * 3\n * (c) n_pointers > 0\n *\n * Otherwise, the function immediately returns EINVAL without touching anything.\n *\n * In the rare case where there's no associated extent found for some pointers,\n * rather than immediately terminating the computation and raising an error,\n * the function simply zeros out the corresponding output fields and continues\n * the computation until all input pointers are handled. The motivations of\n * such a design are as follows:\n *\n * (a) The function always either processes nothing or processes everything, and\n * never leaves the output half touched and half untouched.\n *\n * (b) It facilitates usage needs especially common in C++. A vast variety of\n * C++ objects are instantiated with multiple dynamic memory allocations. For\n * example, std::string and std::vector typically use at least two allocations,\n * one for the metadata and one for the actual content. Other types may use\n * even more allocations. When inquiring about utilization statistics, the\n * caller often wants to examine into all such allocations, especially internal\n * one(s), rather than just the topmost one. The issue comes when some\n * implementations do certain optimizations to reduce/aggregate some internal\n * allocations, e.g. putting short strings directly into the metadata, and such\n * decisions are not known to the caller. Therefore, we permit pointers to\n * memory usages that may not be returned by previous malloc calls, and we\n * provide the caller a convenient way to identify such cases.\n */\nstatic int\nexperimental_utilization_batch_query_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tassert(sizeof(inspect_extent_util_stats_t) == sizeof(size_t) * 3);\n\n\tconst size_t len = newlen / sizeof(const void *);\n\tif (oldp == NULL || oldlenp == NULL || newp == NULL || newlen == 0\n\t || newlen != len * sizeof(const void *)\n\t || *oldlenp != len * sizeof(inspect_extent_util_stats_t)) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\n\tvoid **ptrs = (void **)newp;\n\tinspect_extent_util_stats_t *util_stats =\n\t (inspect_extent_util_stats_t *)oldp;\n\tsize_t i;\n\tfor (i = 0; i < len; ++i) {\n\t\tinspect_extent_util_stats_get(tsd_tsdn(tsd), ptrs[i],\n\t\t &util_stats[i].nfree, &util_stats[i].nregs,\n\t\t &util_stats[i].size);\n\t}\n\tret = 0;\n\nlabel_return:\n\treturn ret;\n}\n\nstatic const ctl_named_node_t *\nexperimental_arenas_i_index(tsdn_t *tsdn, const size_t *mib,\n size_t miblen, size_t i) {\n\tconst ctl_named_node_t *ret;\n\n\tmalloc_mutex_lock(tsdn, &ctl_mtx);\n\tif (ctl_arenas_i_verify(i)) {\n\t\tret = NULL;\n\t\tgoto label_return;\n\t}\n\tret = super_experimental_arenas_i_node;\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nexperimental_arenas_i_pactivep_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tif (!config_stats) {\n\t\treturn ENOENT;\n\t}\n\tif (oldp == NULL || oldlenp == NULL || *oldlenp != sizeof(size_t *)) {\n\t\treturn EINVAL;\n\t}\n\n\tunsigned arena_ind;\n\tarena_t *arena;\n\tint ret;\n\tsize_t *pactivep;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);\n\tREADONLY();\n\tMIB_UNSIGNED(arena_ind, 2);\n\tif (arena_ind < narenas_total_get() && (arena =\n\t arena_get(tsd_tsdn(tsd), arena_ind, false)) != NULL) {\n#if defined(JEMALLOC_GCC_ATOMIC_ATOMICS) ||\t\t\t\t\\\n defined(JEMALLOC_GCC_SYNC_ATOMICS) || defined(_MSC_VER)\n\t\t/* Expose the underlying counter for fast read. */\n\t\tpactivep = (size_t *)&(arena->pa_shard.nactive.repr);\n\t\tREAD(pactivep, size_t *);\n\t\tret = 0;\n#else\n\t\tret = EFAULT;\n#endif\n\t} else {\n\t\tret = EFAULT;\n\t}\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);\n\treturn ret;\n}\n\nstatic int\nexperimental_prof_recent_alloc_max_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tif (!(config_prof && opt_prof)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tssize_t old_max;\n\tif (newp != NULL) {\n\t\tif (newlen != sizeof(ssize_t)) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\tssize_t max = *(ssize_t *)newp;\n\t\tif (max < -1) {\n\t\t\tret = EINVAL;\n\t\t\tgoto label_return;\n\t\t}\n\t\told_max = prof_recent_alloc_max_ctl_write(tsd, max);\n\t} else {\n\t\told_max = prof_recent_alloc_max_ctl_read();\n\t}\n\tREAD(old_max, ssize_t);\n\n\tret = 0;\n\nlabel_return:\n\treturn ret;\n}\n\ntypedef struct write_cb_packet_s write_cb_packet_t;\nstruct write_cb_packet_s {\n\twrite_cb_t *write_cb;\n\tvoid *cbopaque;\n};\n\nstatic int\nexperimental_prof_recent_alloc_dump_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tif (!(config_prof && opt_prof)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tassert(sizeof(write_cb_packet_t) == sizeof(void *) * 2);\n\n\tWRITEONLY();\n\twrite_cb_packet_t write_cb_packet;\n\tASSURED_WRITE(write_cb_packet, write_cb_packet_t);\n\n\tprof_recent_alloc_dump(tsd, write_cb_packet.write_cb,\n\t write_cb_packet.cbopaque);\n\n\tret = 0;\n\nlabel_return:\n\treturn ret;\n}\n\ntypedef struct batch_alloc_packet_s batch_alloc_packet_t;\nstruct batch_alloc_packet_s {\n\tvoid **ptrs;\n\tsize_t num;\n\tsize_t size;\n\tint flags;\n};\n\nstatic int\nexperimental_batch_alloc_ctl(tsd_t *tsd, const size_t *mib,\n size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\n\tVERIFY_READ(size_t);\n\n\tbatch_alloc_packet_t batch_alloc_packet;\n\tASSURED_WRITE(batch_alloc_packet, batch_alloc_packet_t);\n\tsize_t filled = batch_alloc(batch_alloc_packet.ptrs,\n\t batch_alloc_packet.num, batch_alloc_packet.size,\n\t batch_alloc_packet.flags);\n\tREAD(filled, size_t);\n\n\tret = 0;\n\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_stats_bins_i_live_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned binind;\n\tprof_stats_t stats;\n\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tREADONLY();\n\tMIB_UNSIGNED(binind, 3);\n\tif (binind >= SC_NBINS) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tprof_stats_get_live(tsd, (szind_t)binind, &stats);\n\tREAD(stats, prof_stats_t);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_stats_bins_i_accum_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned binind;\n\tprof_stats_t stats;\n\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tREADONLY();\n\tMIB_UNSIGNED(binind, 3);\n\tif (binind >= SC_NBINS) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tprof_stats_get_accum(tsd, (szind_t)binind, &stats);\n\tREAD(stats, prof_stats_t);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic const ctl_named_node_t *\nprof_stats_bins_i_index(tsdn_t *tsdn, const size_t *mib, size_t miblen,\n size_t i) {\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\treturn NULL;\n\t}\n\tif (i >= SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_prof_stats_bins_i_node;\n}\n\nstatic int\nprof_stats_lextents_i_live_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned lextent_ind;\n\tprof_stats_t stats;\n\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tREADONLY();\n\tMIB_UNSIGNED(lextent_ind, 3);\n\tif (lextent_ind >= SC_NSIZES - SC_NBINS) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tprof_stats_get_live(tsd, (szind_t)(lextent_ind + SC_NBINS), &stats);\n\tREAD(stats, prof_stats_t);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic int\nprof_stats_lextents_i_accum_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,\n void *oldp, size_t *oldlenp, void *newp, size_t newlen) {\n\tint ret;\n\tunsigned lextent_ind;\n\tprof_stats_t stats;\n\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\tret = ENOENT;\n\t\tgoto label_return;\n\t}\n\n\tREADONLY();\n\tMIB_UNSIGNED(lextent_ind, 3);\n\tif (lextent_ind >= SC_NSIZES - SC_NBINS) {\n\t\tret = EINVAL;\n\t\tgoto label_return;\n\t}\n\tprof_stats_get_accum(tsd, (szind_t)(lextent_ind + SC_NBINS), &stats);\n\tREAD(stats, prof_stats_t);\n\n\tret = 0;\nlabel_return:\n\treturn ret;\n}\n\nstatic const ctl_named_node_t *\nprof_stats_lextents_i_index(tsdn_t *tsdn, const size_t *mib, size_t miblen,\n size_t i) {\n\tif (!(config_prof && opt_prof && opt_prof_stats)) {\n\t\treturn NULL;\n\t}\n\tif (i >= SC_NSIZES - SC_NBINS) {\n\t\treturn NULL;\n\t}\n\treturn super_prof_stats_lextents_i_node;\n}\n" }, { "path": "deps/jemalloc/src/decay.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/decay.h\"\n\nstatic const uint64_t h_steps[SMOOTHSTEP_NSTEPS] = {\n#define STEP(step, h, x, y)\t\t\t\\\n\t\th,\n\t\tSMOOTHSTEP\n#undef STEP\n};\n\n/*\n * Generate a new deadline that is uniformly random within the next epoch after\n * the current one.\n */\nvoid\ndecay_deadline_init(decay_t *decay) {\n\tnstime_copy(&decay->deadline, &decay->epoch);\n\tnstime_add(&decay->deadline, &decay->interval);\n\tif (decay_ms_read(decay) > 0) {\n\t\tnstime_t jitter;\n\n\t\tnstime_init(&jitter, prng_range_u64(&decay->jitter_state,\n\t\t nstime_ns(&decay->interval)));\n\t\tnstime_add(&decay->deadline, &jitter);\n\t}\n}\n\nvoid\ndecay_reinit(decay_t *decay, nstime_t *cur_time, ssize_t decay_ms) {\n\tatomic_store_zd(&decay->time_ms, decay_ms, ATOMIC_RELAXED);\n\tif (decay_ms > 0) {\n\t\tnstime_init(&decay->interval, (uint64_t)decay_ms *\n\t\t KQU(1000000));\n\t\tnstime_idivide(&decay->interval, SMOOTHSTEP_NSTEPS);\n\t}\n\n\tnstime_copy(&decay->epoch, cur_time);\n\tdecay->jitter_state = (uint64_t)(uintptr_t)decay;\n\tdecay_deadline_init(decay);\n\tdecay->nunpurged = 0;\n\tmemset(decay->backlog, 0, SMOOTHSTEP_NSTEPS * sizeof(size_t));\n}\n\nbool\ndecay_init(decay_t *decay, nstime_t *cur_time, ssize_t decay_ms) {\n\tif (config_debug) {\n\t\tfor (size_t i = 0; i < sizeof(decay_t); i++) {\n\t\t\tassert(((char *)decay)[i] == 0);\n\t\t}\n\t\tdecay->ceil_npages = 0;\n\t}\n\tif (malloc_mutex_init(&decay->mtx, \"decay\", WITNESS_RANK_DECAY,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tdecay->purging = false;\n\tdecay_reinit(decay, cur_time, decay_ms);\n\treturn false;\n}\n\nbool\ndecay_ms_valid(ssize_t decay_ms) {\n\tif (decay_ms < -1) {\n\t\treturn false;\n\t}\n\tif (decay_ms == -1 || (uint64_t)decay_ms <= NSTIME_SEC_MAX *\n\t KQU(1000)) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\nstatic void\ndecay_maybe_update_time(decay_t *decay, nstime_t *new_time) {\n\tif (unlikely(!nstime_monotonic() && nstime_compare(&decay->epoch,\n\t new_time) > 0)) {\n\t\t/*\n\t\t * Time went backwards. Move the epoch back in time and\n\t\t * generate a new deadline, with the expectation that time\n\t\t * typically flows forward for long enough periods of time that\n\t\t * epochs complete. Unfortunately, this strategy is susceptible\n\t\t * to clock jitter triggering premature epoch advances, but\n\t\t * clock jitter estimation and compensation isn't feasible here\n\t\t * because calls into this code are event-driven.\n\t\t */\n\t\tnstime_copy(&decay->epoch, new_time);\n\t\tdecay_deadline_init(decay);\n\t} else {\n\t\t/* Verify that time does not go backwards. */\n\t\tassert(nstime_compare(&decay->epoch, new_time) <= 0);\n\t}\n}\n\nstatic size_t\ndecay_backlog_npages_limit(const decay_t *decay) {\n\t/*\n\t * For each element of decay_backlog, multiply by the corresponding\n\t * fixed-point smoothstep decay factor. Sum the products, then divide\n\t * to round down to the nearest whole number of pages.\n\t */\n\tuint64_t sum = 0;\n\tfor (unsigned i = 0; i < SMOOTHSTEP_NSTEPS; i++) {\n\t\tsum += decay->backlog[i] * h_steps[i];\n\t}\n\tsize_t npages_limit_backlog = (size_t)(sum >> SMOOTHSTEP_BFP);\n\n\treturn npages_limit_backlog;\n}\n\n/*\n * Update backlog, assuming that 'nadvance_u64' time intervals have passed.\n * Trailing 'nadvance_u64' records should be erased and 'current_npages' is\n * placed as the newest record.\n */\nstatic void\ndecay_backlog_update(decay_t *decay, uint64_t nadvance_u64,\n size_t current_npages) {\n\tif (nadvance_u64 >= SMOOTHSTEP_NSTEPS) {\n\t\tmemset(decay->backlog, 0, (SMOOTHSTEP_NSTEPS-1) *\n\t\t sizeof(size_t));\n\t} else {\n\t\tsize_t nadvance_z = (size_t)nadvance_u64;\n\n\t\tassert((uint64_t)nadvance_z == nadvance_u64);\n\n\t\tmemmove(decay->backlog, &decay->backlog[nadvance_z],\n\t\t (SMOOTHSTEP_NSTEPS - nadvance_z) * sizeof(size_t));\n\t\tif (nadvance_z > 1) {\n\t\t\tmemset(&decay->backlog[SMOOTHSTEP_NSTEPS -\n\t\t\t nadvance_z], 0, (nadvance_z-1) * sizeof(size_t));\n\t\t}\n\t}\n\n\tsize_t npages_delta = (current_npages > decay->nunpurged) ?\n\t current_npages - decay->nunpurged : 0;\n\tdecay->backlog[SMOOTHSTEP_NSTEPS-1] = npages_delta;\n\n\tif (config_debug) {\n\t\tif (current_npages > decay->ceil_npages) {\n\t\t\tdecay->ceil_npages = current_npages;\n\t\t}\n\t\tsize_t npages_limit = decay_backlog_npages_limit(decay);\n\t\tassert(decay->ceil_npages >= npages_limit);\n\t\tif (decay->ceil_npages > npages_limit) {\n\t\t\tdecay->ceil_npages = npages_limit;\n\t\t}\n\t}\n}\n\nstatic inline bool\ndecay_deadline_reached(const decay_t *decay, const nstime_t *time) {\n\treturn (nstime_compare(&decay->deadline, time) <= 0);\n}\n\nuint64_t\ndecay_npages_purge_in(decay_t *decay, nstime_t *time, size_t npages_new) {\n\tuint64_t decay_interval_ns = decay_epoch_duration_ns(decay);\n\tsize_t n_epoch = (size_t)(nstime_ns(time) / decay_interval_ns);\n\n\tuint64_t npages_purge;\n\tif (n_epoch >= SMOOTHSTEP_NSTEPS) {\n\t\tnpages_purge = npages_new;\n\t} else {\n\t\tuint64_t h_steps_max = h_steps[SMOOTHSTEP_NSTEPS - 1];\n\t\tassert(h_steps_max >=\n\t\t h_steps[SMOOTHSTEP_NSTEPS - 1 - n_epoch]);\n\t\tnpages_purge = npages_new * (h_steps_max -\n\t\t h_steps[SMOOTHSTEP_NSTEPS - 1 - n_epoch]);\n\t\tnpages_purge >>= SMOOTHSTEP_BFP;\n\t}\n\treturn npages_purge;\n}\n\nbool\ndecay_maybe_advance_epoch(decay_t *decay, nstime_t *new_time,\n size_t npages_current) {\n\t/* Handle possible non-monotonicity of time. */\n\tdecay_maybe_update_time(decay, new_time);\n\n\tif (!decay_deadline_reached(decay, new_time)) {\n\t\treturn false;\n\t}\n\tnstime_t delta;\n\tnstime_copy(&delta, new_time);\n\tnstime_subtract(&delta, &decay->epoch);\n\n\tuint64_t nadvance_u64 = nstime_divide(&delta, &decay->interval);\n\tassert(nadvance_u64 > 0);\n\n\t/* Add nadvance_u64 decay intervals to epoch. */\n\tnstime_copy(&delta, &decay->interval);\n\tnstime_imultiply(&delta, nadvance_u64);\n\tnstime_add(&decay->epoch, &delta);\n\n\t/* Set a new deadline. */\n\tdecay_deadline_init(decay);\n\n\t/* Update the backlog. */\n\tdecay_backlog_update(decay, nadvance_u64, npages_current);\n\n\tdecay->npages_limit = decay_backlog_npages_limit(decay);\n\tdecay->nunpurged = (decay->npages_limit > npages_current) ?\n\t decay->npages_limit : npages_current;\n\n\treturn true;\n}\n\n/*\n * Calculate how many pages should be purged after 'interval'.\n *\n * First, calculate how many pages should remain at the moment, then subtract\n * the number of pages that should remain after 'interval'. The difference is\n * how many pages should be purged until then.\n *\n * The number of pages that should remain at a specific moment is calculated\n * like this: pages(now) = sum(backlog[i] * h_steps[i]). After 'interval'\n * passes, backlog would shift 'interval' positions to the left and sigmoid\n * curve would be applied starting with backlog[interval].\n *\n * The implementation doesn't directly map to the description, but it's\n * essentially the same calculation, optimized to avoid iterating over\n * [interval..SMOOTHSTEP_NSTEPS) twice.\n */\nstatic inline size_t\ndecay_npurge_after_interval(decay_t *decay, size_t interval) {\n\tsize_t i;\n\tuint64_t sum = 0;\n\tfor (i = 0; i < interval; i++) {\n\t\tsum += decay->backlog[i] * h_steps[i];\n\t}\n\tfor (; i < SMOOTHSTEP_NSTEPS; i++) {\n\t\tsum += decay->backlog[i] *\n\t\t (h_steps[i] - h_steps[i - interval]);\n\t}\n\n\treturn (size_t)(sum >> SMOOTHSTEP_BFP);\n}\n\nuint64_t decay_ns_until_purge(decay_t *decay, size_t npages_current,\n uint64_t npages_threshold) {\n\tif (!decay_gradually(decay)) {\n\t\treturn DECAY_UNBOUNDED_TIME_TO_PURGE;\n\t}\n\tuint64_t decay_interval_ns = decay_epoch_duration_ns(decay);\n\tassert(decay_interval_ns > 0);\n\tif (npages_current == 0) {\n\t\tunsigned i;\n\t\tfor (i = 0; i < SMOOTHSTEP_NSTEPS; i++) {\n\t\t\tif (decay->backlog[i] > 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (i == SMOOTHSTEP_NSTEPS) {\n\t\t\t/* No dirty pages recorded. Sleep indefinitely. */\n\t\t\treturn DECAY_UNBOUNDED_TIME_TO_PURGE;\n\t\t}\n\t}\n\tif (npages_current <= npages_threshold) {\n\t\t/* Use max interval. */\n\t\treturn decay_interval_ns * SMOOTHSTEP_NSTEPS;\n\t}\n\n\t/* Minimal 2 intervals to ensure reaching next epoch deadline. */\n\tsize_t lb = 2;\n\tsize_t ub = SMOOTHSTEP_NSTEPS;\n\n\tsize_t npurge_lb, npurge_ub;\n\tnpurge_lb = decay_npurge_after_interval(decay, lb);\n\tif (npurge_lb > npages_threshold) {\n\t\treturn decay_interval_ns * lb;\n\t}\n\tnpurge_ub = decay_npurge_after_interval(decay, ub);\n\tif (npurge_ub < npages_threshold) {\n\t\treturn decay_interval_ns * ub;\n\t}\n\n\tunsigned n_search = 0;\n\tsize_t target, npurge;\n\twhile ((npurge_lb + npages_threshold < npurge_ub) && (lb + 2 < ub)) {\n\t\ttarget = (lb + ub) / 2;\n\t\tnpurge = decay_npurge_after_interval(decay, target);\n\t\tif (npurge > npages_threshold) {\n\t\t\tub = target;\n\t\t\tnpurge_ub = npurge;\n\t\t} else {\n\t\t\tlb = target;\n\t\t\tnpurge_lb = npurge;\n\t\t}\n\t\tassert(n_search < lg_floor(SMOOTHSTEP_NSTEPS) + 1);\n\t\t++n_search;\n\t}\n\treturn decay_interval_ns * (ub + lb) / 2;\n}\n" }, { "path": "deps/jemalloc/src/div.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n#include \"jemalloc/internal/div.h\"\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * Suppose we have n = q * d, all integers. We know n and d, and want q = n / d.\n *\n * For any k, we have (here, all division is exact; not C-style rounding):\n * floor(ceil(2^k / d) * n / 2^k) = floor((2^k + r) / d * n / 2^k), where\n * r = (-2^k) mod d.\n *\n * Expanding this out:\n * ... = floor(2^k / d * n / 2^k + r / d * n / 2^k)\n * = floor(n / d + (r / d) * (n / 2^k)).\n *\n * The fractional part of n / d is 0 (because of the assumption that d divides n\n * exactly), so we have:\n * ... = n / d + floor((r / d) * (n / 2^k))\n *\n * So that our initial expression is equal to the quantity we seek, so long as\n * (r / d) * (n / 2^k) < 1.\n *\n * r is a remainder mod d, so r < d and r / d < 1 always. We can make\n * n / 2 ^ k < 1 by setting k = 32. This gets us a value of magic that works.\n */\n\nvoid\ndiv_init(div_info_t *div_info, size_t d) {\n\t/* Nonsensical. */\n\tassert(d != 0);\n\t/*\n\t * This would make the value of magic too high to fit into a uint32_t\n\t * (we would want magic = 2^32 exactly). This would mess with code gen\n\t * on 32-bit machines.\n\t */\n\tassert(d != 1);\n\n\tuint64_t two_to_k = ((uint64_t)1 << 32);\n\tuint32_t magic = (uint32_t)(two_to_k / d);\n\n\t/*\n\t * We want magic = ceil(2^k / d), but C gives us floor. We have to\n\t * increment it unless the result was exact (i.e. unless d is a power of\n\t * two).\n\t */\n\tif (two_to_k % d != 0) {\n\t\tmagic++;\n\t}\n\tdiv_info->magic = magic;\n#ifdef JEMALLOC_DEBUG\n\tdiv_info->d = d;\n#endif\n}\n" }, { "path": "deps/jemalloc/src/ecache.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/san.h\"\n\nbool\necache_init(tsdn_t *tsdn, ecache_t *ecache, extent_state_t state, unsigned ind,\n bool delay_coalesce) {\n\tif (malloc_mutex_init(&ecache->mtx, \"extents\", WITNESS_RANK_EXTENTS,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tecache->state = state;\n\tecache->ind = ind;\n\tecache->delay_coalesce = delay_coalesce;\n\teset_init(&ecache->eset, state);\n\teset_init(&ecache->guarded_eset, state);\n\n\treturn false;\n}\n\nvoid\necache_prefork(tsdn_t *tsdn, ecache_t *ecache) {\n\tmalloc_mutex_prefork(tsdn, &ecache->mtx);\n}\n\nvoid\necache_postfork_parent(tsdn_t *tsdn, ecache_t *ecache) {\n\tmalloc_mutex_postfork_parent(tsdn, &ecache->mtx);\n}\n\nvoid\necache_postfork_child(tsdn_t *tsdn, ecache_t *ecache) {\n\tmalloc_mutex_postfork_child(tsdn, &ecache->mtx);\n}\n" }, { "path": "deps/jemalloc/src/edata.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nph_gen(, edata_avail, edata_t, avail_link,\n edata_esnead_comp)\nph_gen(, edata_heap, edata_t, heap_link, edata_snad_comp)\n" }, { "path": "deps/jemalloc/src/edata_cache.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nbool\nedata_cache_init(edata_cache_t *edata_cache, base_t *base) {\n\tedata_avail_new(&edata_cache->avail);\n\t/*\n\t * This is not strictly necessary, since the edata_cache_t is only\n\t * created inside an arena, which is zeroed on creation. But this is\n\t * handy as a safety measure.\n\t */\n\tatomic_store_zu(&edata_cache->count, 0, ATOMIC_RELAXED);\n\tif (malloc_mutex_init(&edata_cache->mtx, \"edata_cache\",\n\t WITNESS_RANK_EDATA_CACHE, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tedata_cache->base = base;\n\treturn false;\n}\n\nedata_t *\nedata_cache_get(tsdn_t *tsdn, edata_cache_t *edata_cache) {\n\tmalloc_mutex_lock(tsdn, &edata_cache->mtx);\n\tedata_t *edata = edata_avail_first(&edata_cache->avail);\n\tif (edata == NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &edata_cache->mtx);\n\t\treturn base_alloc_edata(tsdn, edata_cache->base);\n\t}\n\tedata_avail_remove(&edata_cache->avail, edata);\n\tatomic_load_sub_store_zu(&edata_cache->count, 1);\n\tmalloc_mutex_unlock(tsdn, &edata_cache->mtx);\n\treturn edata;\n}\n\nvoid\nedata_cache_put(tsdn_t *tsdn, edata_cache_t *edata_cache, edata_t *edata) {\n\tmalloc_mutex_lock(tsdn, &edata_cache->mtx);\n\tedata_avail_insert(&edata_cache->avail, edata);\n\tatomic_load_add_store_zu(&edata_cache->count, 1);\n\tmalloc_mutex_unlock(tsdn, &edata_cache->mtx);\n}\n\nvoid\nedata_cache_prefork(tsdn_t *tsdn, edata_cache_t *edata_cache) {\n\tmalloc_mutex_prefork(tsdn, &edata_cache->mtx);\n}\n\nvoid\nedata_cache_postfork_parent(tsdn_t *tsdn, edata_cache_t *edata_cache) {\n\tmalloc_mutex_postfork_parent(tsdn, &edata_cache->mtx);\n}\n\nvoid\nedata_cache_postfork_child(tsdn_t *tsdn, edata_cache_t *edata_cache) {\n\tmalloc_mutex_postfork_child(tsdn, &edata_cache->mtx);\n}\n\nvoid\nedata_cache_fast_init(edata_cache_fast_t *ecs, edata_cache_t *fallback) {\n\tedata_list_inactive_init(&ecs->list);\n\tecs->fallback = fallback;\n\tecs->disabled = false;\n}\n\nstatic void\nedata_cache_fast_try_fill_from_fallback(tsdn_t *tsdn,\n edata_cache_fast_t *ecs) {\n\tedata_t *edata;\n\tmalloc_mutex_lock(tsdn, &ecs->fallback->mtx);\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL; i++) {\n\t\tedata = edata_avail_remove_first(&ecs->fallback->avail);\n\t\tif (edata == NULL) {\n\t\t\tbreak;\n\t\t}\n\t\tedata_list_inactive_append(&ecs->list, edata);\n\t\tatomic_load_sub_store_zu(&ecs->fallback->count, 1);\n\t}\n\tmalloc_mutex_unlock(tsdn, &ecs->fallback->mtx);\n}\n\nedata_t *\nedata_cache_fast_get(tsdn_t *tsdn, edata_cache_fast_t *ecs) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_EDATA_CACHE, 0);\n\n\tif (ecs->disabled) {\n\t\tassert(edata_list_inactive_first(&ecs->list) == NULL);\n\t\treturn edata_cache_get(tsdn, ecs->fallback);\n\t}\n\n\tedata_t *edata = edata_list_inactive_first(&ecs->list);\n\tif (edata != NULL) {\n\t\tedata_list_inactive_remove(&ecs->list, edata);\n\t\treturn edata;\n\t}\n\t/* Slow path; requires synchronization. */\n\tedata_cache_fast_try_fill_from_fallback(tsdn, ecs);\n\tedata = edata_list_inactive_first(&ecs->list);\n\tif (edata != NULL) {\n\t\tedata_list_inactive_remove(&ecs->list, edata);\n\t} else {\n\t\t/*\n\t\t * Slowest path (fallback was also empty); allocate something\n\t\t * new.\n\t\t */\n\t\tedata = base_alloc_edata(tsdn, ecs->fallback->base);\n\t}\n\treturn edata;\n}\n\nstatic void\nedata_cache_fast_flush_all(tsdn_t *tsdn, edata_cache_fast_t *ecs) {\n\t/*\n\t * You could imagine smarter cache management policies (like\n\t * only flushing down to some threshold in anticipation of\n\t * future get requests). But just flushing everything provides\n\t * a good opportunity to defrag too, and lets us share code between the\n\t * flush and disable pathways.\n\t */\n\tedata_t *edata;\n\tsize_t nflushed = 0;\n\tmalloc_mutex_lock(tsdn, &ecs->fallback->mtx);\n\twhile ((edata = edata_list_inactive_first(&ecs->list)) != NULL) {\n\t\tedata_list_inactive_remove(&ecs->list, edata);\n\t\tedata_avail_insert(&ecs->fallback->avail, edata);\n\t\tnflushed++;\n\t}\n\tatomic_load_add_store_zu(&ecs->fallback->count, nflushed);\n\tmalloc_mutex_unlock(tsdn, &ecs->fallback->mtx);\n}\n\nvoid\nedata_cache_fast_put(tsdn_t *tsdn, edata_cache_fast_t *ecs, edata_t *edata) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_EDATA_CACHE, 0);\n\n\tif (ecs->disabled) {\n\t\tassert(edata_list_inactive_first(&ecs->list) == NULL);\n\t\tedata_cache_put(tsdn, ecs->fallback, edata);\n\t\treturn;\n\t}\n\n\t/*\n\t * Prepend rather than append, to do LIFO ordering in the hopes of some\n\t * cache locality.\n\t */\n\tedata_list_inactive_prepend(&ecs->list, edata);\n}\n\nvoid\nedata_cache_fast_disable(tsdn_t *tsdn, edata_cache_fast_t *ecs) {\n\tedata_cache_fast_flush_all(tsdn, ecs);\n\tecs->disabled = true;\n}\n" }, { "path": "deps/jemalloc/src/ehooks.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n\nvoid\nehooks_init(ehooks_t *ehooks, extent_hooks_t *extent_hooks, unsigned ind) {\n\t/* All other hooks are optional; this one is not. */\n\tassert(extent_hooks->alloc != NULL);\n\tehooks->ind = ind;\n\tehooks_set_extent_hooks_ptr(ehooks, extent_hooks);\n}\n\n/*\n * If the caller specifies (!*zero), it is still possible to receive zeroed\n * memory, in which case *zero is toggled to true. arena_extent_alloc() takes\n * advantage of this to avoid demanding zeroed extents, but taking advantage of\n * them if they are returned.\n */\nstatic void *\nextent_alloc_core(tsdn_t *tsdn, arena_t *arena, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, dss_prec_t dss_prec) {\n\tvoid *ret;\n\n\tassert(size != 0);\n\tassert(alignment != 0);\n\n\t/* \"primary\" dss. */\n\tif (have_dss && dss_prec == dss_prec_primary && (ret =\n\t extent_alloc_dss(tsdn, arena, new_addr, size, alignment, zero,\n\t commit)) != NULL) {\n\t\treturn ret;\n\t}\n\t/* mmap. */\n\tif ((ret = extent_alloc_mmap(new_addr, size, alignment, zero, commit))\n\t != NULL) {\n\t\treturn ret;\n\t}\n\t/* \"secondary\" dss. */\n\tif (have_dss && dss_prec == dss_prec_secondary && (ret =\n\t extent_alloc_dss(tsdn, arena, new_addr, size, alignment, zero,\n\t commit)) != NULL) {\n\t\treturn ret;\n\t}\n\n\t/* All strategies for allocation failed. */\n\treturn NULL;\n}\n\nvoid *\nehooks_default_alloc_impl(tsdn_t *tsdn, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, unsigned arena_ind) {\n\tarena_t *arena = arena_get(tsdn, arena_ind, false);\n\t/* NULL arena indicates arena_create. */\n\tassert(arena != NULL || alignment == HUGEPAGE);\n\tdss_prec_t dss = (arena == NULL) ? dss_prec_disabled :\n\t (dss_prec_t)atomic_load_u(&arena->dss_prec, ATOMIC_RELAXED);\n\tvoid *ret = extent_alloc_core(tsdn, arena, new_addr, size, alignment,\n\t zero, commit, dss);\n\tif (have_madvise_huge && ret) {\n\t\tpages_set_thp_state(ret, size);\n\t}\n\treturn ret;\n}\n\nstatic void *\nehooks_default_alloc(extent_hooks_t *extent_hooks, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, unsigned arena_ind) {\n\treturn ehooks_default_alloc_impl(tsdn_fetch(), new_addr, size,\n\t ALIGNMENT_CEILING(alignment, PAGE), zero, commit, arena_ind);\n}\n\nbool\nehooks_default_dalloc_impl(void *addr, size_t size) {\n\tif (!have_dss || !extent_in_dss(addr)) {\n\t\treturn extent_dalloc_mmap(addr, size);\n\t}\n\treturn true;\n}\n\nstatic bool\nehooks_default_dalloc(extent_hooks_t *extent_hooks, void *addr, size_t size,\n bool committed, unsigned arena_ind) {\n\treturn ehooks_default_dalloc_impl(addr, size);\n}\n\nvoid\nehooks_default_destroy_impl(void *addr, size_t size) {\n\tif (!have_dss || !extent_in_dss(addr)) {\n\t\tpages_unmap(addr, size);\n\t}\n}\n\nstatic void\nehooks_default_destroy(extent_hooks_t *extent_hooks, void *addr, size_t size,\n bool committed, unsigned arena_ind) {\n\tehooks_default_destroy_impl(addr, size);\n}\n\nbool\nehooks_default_commit_impl(void *addr, size_t offset, size_t length) {\n\treturn pages_commit((void *)((uintptr_t)addr + (uintptr_t)offset),\n\t length);\n}\n\nstatic bool\nehooks_default_commit(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\treturn ehooks_default_commit_impl(addr, offset, length);\n}\n\nbool\nehooks_default_decommit_impl(void *addr, size_t offset, size_t length) {\n\treturn pages_decommit((void *)((uintptr_t)addr + (uintptr_t)offset),\n\t length);\n}\n\nstatic bool\nehooks_default_decommit(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\treturn ehooks_default_decommit_impl(addr, offset, length);\n}\n\n#ifdef PAGES_CAN_PURGE_LAZY\nbool\nehooks_default_purge_lazy_impl(void *addr, size_t offset, size_t length) {\n\treturn pages_purge_lazy((void *)((uintptr_t)addr + (uintptr_t)offset),\n\t length);\n}\n\nstatic bool\nehooks_default_purge_lazy(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\tassert(addr != NULL);\n\tassert((offset & PAGE_MASK) == 0);\n\tassert(length != 0);\n\tassert((length & PAGE_MASK) == 0);\n\treturn ehooks_default_purge_lazy_impl(addr, offset, length);\n}\n#endif\n\n#ifdef PAGES_CAN_PURGE_FORCED\nbool\nehooks_default_purge_forced_impl(void *addr, size_t offset, size_t length) {\n\treturn pages_purge_forced((void *)((uintptr_t)addr +\n\t (uintptr_t)offset), length);\n}\n\nstatic bool\nehooks_default_purge_forced(extent_hooks_t *extent_hooks, void *addr,\n size_t size, size_t offset, size_t length, unsigned arena_ind) {\n\tassert(addr != NULL);\n\tassert((offset & PAGE_MASK) == 0);\n\tassert(length != 0);\n\tassert((length & PAGE_MASK) == 0);\n\treturn ehooks_default_purge_forced_impl(addr, offset, length);\n}\n#endif\n\nbool\nehooks_default_split_impl() {\n\tif (!maps_coalesce) {\n\t\t/*\n\t\t * Without retain, only whole regions can be purged (required by\n\t\t * MEM_RELEASE on Windows) -- therefore disallow splitting. See\n\t\t * comments in extent_head_no_merge().\n\t\t */\n\t\treturn !opt_retain;\n\t}\n\n\treturn false;\n}\n\nstatic bool\nehooks_default_split(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t size_a, size_t size_b, bool committed, unsigned arena_ind) {\n\treturn ehooks_default_split_impl();\n}\n\nbool\nehooks_default_merge_impl(tsdn_t *tsdn, void *addr_a, void *addr_b) {\n\tassert(addr_a < addr_b);\n\t/*\n\t * For non-DSS cases --\n\t * a) W/o maps_coalesce, merge is not always allowed (Windows):\n\t * 1) w/o retain, never merge (first branch below).\n\t * 2) with retain, only merge extents from the same VirtualAlloc\n\t * region (in which case MEM_DECOMMIT is utilized for purging).\n\t *\n\t * b) With maps_coalesce, it's always possible to merge.\n\t * 1) w/o retain, always allow merge (only about dirty / muzzy).\n\t * 2) with retain, to preserve the SN / first-fit, merge is still\n\t * disallowed if b is a head extent, i.e. no merging across\n\t * different mmap regions.\n\t *\n\t * a2) and b2) are implemented in emap_try_acquire_edata_neighbor, and\n\t * sanity checked in the second branch below.\n\t */\n\tif (!maps_coalesce && !opt_retain) {\n\t\treturn true;\n\t}\n\tif (config_debug) {\n\t\tedata_t *a = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t addr_a);\n\t\tbool head_a = edata_is_head_get(a);\n\t\tedata_t *b = emap_edata_lookup(tsdn, &arena_emap_global,\n\t\t addr_b);\n\t\tbool head_b = edata_is_head_get(b);\n\t\temap_assert_mapped(tsdn, &arena_emap_global, a);\n\t\temap_assert_mapped(tsdn, &arena_emap_global, b);\n\t\tassert(extent_neighbor_head_state_mergeable(head_a, head_b,\n\t\t /* forward */ true));\n\t}\n\tif (have_dss && !extent_dss_mergeable(addr_a, addr_b)) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nbool\nehooks_default_merge(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a,\n void *addr_b, size_t size_b, bool committed, unsigned arena_ind) {\n\ttsdn_t *tsdn = tsdn_fetch();\n\n\treturn ehooks_default_merge_impl(tsdn, addr_a, addr_b);\n}\n\nvoid\nehooks_default_zero_impl(void *addr, size_t size) {\n\t/*\n\t * By default, we try to zero out memory using OS-provided demand-zeroed\n\t * pages. If the user has specifically requested hugepages, though, we\n\t * don't want to purge in the middle of a hugepage (which would break it\n\t * up), so we act conservatively and use memset.\n\t */\n\tbool needs_memset = true;\n\tif (opt_thp != thp_mode_always) {\n\t\tneeds_memset = pages_purge_forced(addr, size);\n\t}\n\tif (needs_memset) {\n\t\tmemset(addr, 0, size);\n\t}\n}\n\nvoid\nehooks_default_guard_impl(void *guard1, void *guard2) {\n\tpages_mark_guards(guard1, guard2);\n}\n\nvoid\nehooks_default_unguard_impl(void *guard1, void *guard2) {\n\tpages_unmark_guards(guard1, guard2);\n}\n\nconst extent_hooks_t ehooks_default_extent_hooks = {\n\tehooks_default_alloc,\n\tehooks_default_dalloc,\n\tehooks_default_destroy,\n\tehooks_default_commit,\n\tehooks_default_decommit,\n#ifdef PAGES_CAN_PURGE_LAZY\n\tehooks_default_purge_lazy,\n#else\n\tNULL,\n#endif\n#ifdef PAGES_CAN_PURGE_FORCED\n\tehooks_default_purge_forced,\n#else\n\tNULL,\n#endif\n\tehooks_default_split,\n\tehooks_default_merge\n};\n" }, { "path": "deps/jemalloc/src/emap.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/emap.h\"\n\nenum emap_lock_result_e {\n\temap_lock_result_success,\n\temap_lock_result_failure,\n\temap_lock_result_no_extent\n};\ntypedef enum emap_lock_result_e emap_lock_result_t;\n\nbool\nemap_init(emap_t *emap, base_t *base, bool zeroed) {\n\treturn rtree_new(&emap->rtree, base, zeroed);\n}\n\nvoid\nemap_update_edata_state(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_state_t state) {\n\twitness_assert_positive_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE);\n\n\tedata_state_set(edata, state);\n\n\tEMAP_DECLARE_RTREE_CTX;\n\trtree_leaf_elm_t *elm1 = rtree_leaf_elm_lookup(tsdn, &emap->rtree,\n\t rtree_ctx, (uintptr_t)edata_base_get(edata), /* dependent */ true,\n\t /* init_missing */ false);\n\tassert(elm1 != NULL);\n\trtree_leaf_elm_t *elm2 = edata_size_get(edata) == PAGE ? NULL :\n\t rtree_leaf_elm_lookup(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_last_get(edata), /* dependent */ true,\n\t /* init_missing */ false);\n\n\trtree_leaf_elm_state_update(tsdn, &emap->rtree, elm1, elm2, state);\n\n\temap_assert_mapped(tsdn, emap, edata);\n}\n\nstatic inline edata_t *\nemap_try_acquire_edata_neighbor_impl(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_pai_t pai, extent_state_t expected_state, bool forward,\n bool expanding) {\n\twitness_assert_positive_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE);\n\tassert(!edata_guarded_get(edata));\n\tassert(!expanding || forward);\n\tassert(!edata_state_in_transition(expected_state));\n\tassert(expected_state == extent_state_dirty ||\n\t expected_state == extent_state_muzzy ||\n\t expected_state == extent_state_retained);\n\n\tvoid *neighbor_addr = forward ? edata_past_get(edata) :\n\t edata_before_get(edata);\n\t/*\n\t * This is subtle; the rtree code asserts that its input pointer is\n\t * non-NULL, and this is a useful thing to check. But it's possible\n\t * that edata corresponds to an address of (void *)PAGE (in practice,\n\t * this has only been observed on FreeBSD when address-space\n\t * randomization is on, but it could in principle happen anywhere). In\n\t * this case, edata_before_get(edata) is NULL, triggering the assert.\n\t */\n\tif (neighbor_addr == NULL) {\n\t\treturn NULL;\n\t}\n\n\tEMAP_DECLARE_RTREE_CTX;\n\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, &emap->rtree,\n\t rtree_ctx, (uintptr_t)neighbor_addr, /* dependent*/ false,\n\t /* init_missing */ false);\n\tif (elm == NULL) {\n\t\treturn NULL;\n\t}\n\n\trtree_contents_t neighbor_contents = rtree_leaf_elm_read(tsdn,\n\t &emap->rtree, elm, /* dependent */ true);\n\tif (!extent_can_acquire_neighbor(edata, neighbor_contents, pai,\n\t expected_state, forward, expanding)) {\n\t\treturn NULL;\n\t}\n\n\t/* From this point, the neighbor edata can be safely acquired. */\n\tedata_t *neighbor = neighbor_contents.edata;\n\tassert(edata_state_get(neighbor) == expected_state);\n\temap_update_edata_state(tsdn, emap, neighbor, extent_state_merging);\n\tif (expanding) {\n\t\textent_assert_can_expand(edata, neighbor);\n\t} else {\n\t\textent_assert_can_coalesce(edata, neighbor);\n\t}\n\n\treturn neighbor;\n}\n\nedata_t *\nemap_try_acquire_edata_neighbor(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_pai_t pai, extent_state_t expected_state, bool forward) {\n\treturn emap_try_acquire_edata_neighbor_impl(tsdn, emap, edata, pai,\n\t expected_state, forward, /* expand */ false);\n}\n\nedata_t *\nemap_try_acquire_edata_neighbor_expand(tsdn_t *tsdn, emap_t *emap,\n edata_t *edata, extent_pai_t pai, extent_state_t expected_state) {\n\t/* Try expanding forward. */\n\treturn emap_try_acquire_edata_neighbor_impl(tsdn, emap, edata, pai,\n\t expected_state, /* forward */ true, /* expand */ true);\n}\n\nvoid\nemap_release_edata(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n extent_state_t new_state) {\n\tassert(emap_edata_in_transition(tsdn, emap, edata));\n\tassert(emap_edata_is_acquired(tsdn, emap, edata));\n\n\temap_update_edata_state(tsdn, emap, edata, new_state);\n}\n\nstatic bool\nemap_rtree_leaf_elms_lookup(tsdn_t *tsdn, emap_t *emap, rtree_ctx_t *rtree_ctx,\n const edata_t *edata, bool dependent, bool init_missing,\n rtree_leaf_elm_t **r_elm_a, rtree_leaf_elm_t **r_elm_b) {\n\t*r_elm_a = rtree_leaf_elm_lookup(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_base_get(edata), dependent, init_missing);\n\tif (!dependent && *r_elm_a == NULL) {\n\t\treturn true;\n\t}\n\tassert(*r_elm_a != NULL);\n\n\t*r_elm_b = rtree_leaf_elm_lookup(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_last_get(edata), dependent, init_missing);\n\tif (!dependent && *r_elm_b == NULL) {\n\t\treturn true;\n\t}\n\tassert(*r_elm_b != NULL);\n\n\treturn false;\n}\n\nstatic void\nemap_rtree_write_acquired(tsdn_t *tsdn, emap_t *emap, rtree_leaf_elm_t *elm_a,\n rtree_leaf_elm_t *elm_b, edata_t *edata, szind_t szind, bool slab) {\n\trtree_contents_t contents;\n\tcontents.edata = edata;\n\tcontents.metadata.szind = szind;\n\tcontents.metadata.slab = slab;\n\tcontents.metadata.is_head = (edata == NULL) ? false :\n\t edata_is_head_get(edata);\n\tcontents.metadata.state = (edata == NULL) ? 0 : edata_state_get(edata);\n\trtree_leaf_elm_write(tsdn, &emap->rtree, elm_a, contents);\n\tif (elm_b != NULL) {\n\t\trtree_leaf_elm_write(tsdn, &emap->rtree, elm_b, contents);\n\t}\n}\n\nbool\nemap_register_boundary(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n szind_t szind, bool slab) {\n\tassert(edata_state_get(edata) == extent_state_active);\n\tEMAP_DECLARE_RTREE_CTX;\n\n\trtree_leaf_elm_t *elm_a, *elm_b;\n\tbool err = emap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, edata,\n\t false, true, &elm_a, &elm_b);\n\tif (err) {\n\t\treturn true;\n\t}\n\tassert(rtree_leaf_elm_read(tsdn, &emap->rtree, elm_a,\n\t /* dependent */ false).edata == NULL);\n\tassert(rtree_leaf_elm_read(tsdn, &emap->rtree, elm_b,\n\t /* dependent */ false).edata == NULL);\n\temap_rtree_write_acquired(tsdn, emap, elm_a, elm_b, edata, szind, slab);\n\treturn false;\n}\n\n/* Invoked *after* emap_register_boundary. */\nvoid\nemap_register_interior(tsdn_t *tsdn, emap_t *emap, edata_t *edata,\n szind_t szind) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\tassert(edata_slab_get(edata));\n\tassert(edata_state_get(edata) == extent_state_active);\n\n\tif (config_debug) {\n\t\t/* Making sure the boundary is registered already. */\n\t\trtree_leaf_elm_t *elm_a, *elm_b;\n\t\tbool err = emap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx,\n\t\t edata, /* dependent */ true, /* init_missing */ false,\n\t\t &elm_a, &elm_b);\n\t\tassert(!err);\n\t\trtree_contents_t contents_a, contents_b;\n\t\tcontents_a = rtree_leaf_elm_read(tsdn, &emap->rtree, elm_a,\n\t\t /* dependent */ true);\n\t\tcontents_b = rtree_leaf_elm_read(tsdn, &emap->rtree, elm_b,\n\t\t /* dependent */ true);\n\t\tassert(contents_a.edata == edata && contents_b.edata == edata);\n\t\tassert(contents_a.metadata.slab && contents_b.metadata.slab);\n\t}\n\n\trtree_contents_t contents;\n\tcontents.edata = edata;\n\tcontents.metadata.szind = szind;\n\tcontents.metadata.slab = true;\n\tcontents.metadata.state = extent_state_active;\n\tcontents.metadata.is_head = false; /* Not allowed to access. */\n\n\tassert(edata_size_get(edata) > (2 << LG_PAGE));\n\trtree_write_range(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_base_get(edata) + PAGE,\n\t (uintptr_t)edata_last_get(edata) - PAGE, contents);\n}\n\nvoid\nemap_deregister_boundary(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\t/*\n\t * The edata must be either in an acquired state, or protected by state\n\t * based locks.\n\t */\n\tif (!emap_edata_is_acquired(tsdn, emap, edata)) {\n\t\twitness_assert_positive_depth_to_rank(\n\t\t tsdn_witness_tsdp_get(tsdn), WITNESS_RANK_CORE);\n\t}\n\n\tEMAP_DECLARE_RTREE_CTX;\n\trtree_leaf_elm_t *elm_a, *elm_b;\n\n\temap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, edata,\n\t true, false, &elm_a, &elm_b);\n\temap_rtree_write_acquired(tsdn, emap, elm_a, elm_b, NULL, SC_NSIZES,\n\t false);\n}\n\nvoid\nemap_deregister_interior(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\tassert(edata_slab_get(edata));\n\tif (edata_size_get(edata) > (2 << LG_PAGE)) {\n\t\trtree_clear_range(tsdn, &emap->rtree, rtree_ctx,\n\t\t (uintptr_t)edata_base_get(edata) + PAGE,\n\t\t (uintptr_t)edata_last_get(edata) - PAGE);\n\t}\n}\n\nvoid\nemap_remap(tsdn_t *tsdn, emap_t *emap, edata_t *edata, szind_t szind,\n bool slab) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\tif (szind != SC_NSIZES) {\n\t\trtree_contents_t contents;\n\t\tcontents.edata = edata;\n\t\tcontents.metadata.szind = szind;\n\t\tcontents.metadata.slab = slab;\n\t\tcontents.metadata.is_head = edata_is_head_get(edata);\n\t\tcontents.metadata.state = edata_state_get(edata);\n\n\t\trtree_write(tsdn, &emap->rtree, rtree_ctx,\n\t\t (uintptr_t)edata_addr_get(edata), contents);\n\t\t/*\n\t\t * Recall that this is called only for active->inactive and\n\t\t * inactive->active transitions (since only active extents have\n\t\t * meaningful values for szind and slab). Active, non-slab\n\t\t * extents only need to handle lookups at their head (on\n\t\t * deallocation), so we don't bother filling in the end\n\t\t * boundary.\n\t\t *\n\t\t * For slab extents, we do the end-mapping change. This still\n\t\t * leaves the interior unmodified; an emap_register_interior\n\t\t * call is coming in those cases, though.\n\t\t */\n\t\tif (slab && edata_size_get(edata) > PAGE) {\n\t\t\tuintptr_t key = (uintptr_t)edata_past_get(edata)\n\t\t\t - (uintptr_t)PAGE;\n\t\t\trtree_write(tsdn, &emap->rtree, rtree_ctx, key,\n\t\t\t contents);\n\t\t}\n\t}\n}\n\nbool\nemap_split_prepare(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *edata, size_t size_a, edata_t *trail, size_t size_b) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\t/*\n\t * We use incorrect constants for things like arena ind, zero, ranged,\n\t * and commit state, and head status. This is a fake edata_t, used to\n\t * facilitate a lookup.\n\t */\n\tedata_t lead = {0};\n\tedata_init(&lead, 0U, edata_addr_get(edata), size_a, false, 0, 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\n\temap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, &lead, false, true,\n\t &prepare->lead_elm_a, &prepare->lead_elm_b);\n\temap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, trail, false, true,\n\t &prepare->trail_elm_a, &prepare->trail_elm_b);\n\n\tif (prepare->lead_elm_a == NULL || prepare->lead_elm_b == NULL\n\t || prepare->trail_elm_a == NULL || prepare->trail_elm_b == NULL) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\nvoid\nemap_split_commit(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, size_t size_a, edata_t *trail, size_t size_b) {\n\t/*\n\t * We should think about not writing to the lead leaf element. We can\n\t * get into situations where a racing realloc-like call can disagree\n\t * with a size lookup request. I think it's fine to declare that these\n\t * situations are race bugs, but there's an argument to be made that for\n\t * things like xallocx, a size lookup call should return either the old\n\t * size or the new size, but not anything else.\n\t */\n\temap_rtree_write_acquired(tsdn, emap, prepare->lead_elm_a,\n\t prepare->lead_elm_b, lead, SC_NSIZES, /* slab */ false);\n\temap_rtree_write_acquired(tsdn, emap, prepare->trail_elm_a,\n\t prepare->trail_elm_b, trail, SC_NSIZES, /* slab */ false);\n}\n\nvoid\nemap_merge_prepare(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, edata_t *trail) {\n\tEMAP_DECLARE_RTREE_CTX;\n\temap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, lead, true, false,\n\t &prepare->lead_elm_a, &prepare->lead_elm_b);\n\temap_rtree_leaf_elms_lookup(tsdn, emap, rtree_ctx, trail, true, false,\n\t &prepare->trail_elm_a, &prepare->trail_elm_b);\n}\n\nvoid\nemap_merge_commit(tsdn_t *tsdn, emap_t *emap, emap_prepare_t *prepare,\n edata_t *lead, edata_t *trail) {\n\trtree_contents_t clear_contents;\n\tclear_contents.edata = NULL;\n\tclear_contents.metadata.szind = SC_NSIZES;\n\tclear_contents.metadata.slab = false;\n\tclear_contents.metadata.is_head = false;\n\tclear_contents.metadata.state = (extent_state_t)0;\n\n\tif (prepare->lead_elm_b != NULL) {\n\t\trtree_leaf_elm_write(tsdn, &emap->rtree,\n\t\t prepare->lead_elm_b, clear_contents);\n\t}\n\n\trtree_leaf_elm_t *merged_b;\n\tif (prepare->trail_elm_b != NULL) {\n\t\trtree_leaf_elm_write(tsdn, &emap->rtree,\n\t\t prepare->trail_elm_a, clear_contents);\n\t\tmerged_b = prepare->trail_elm_b;\n\t} else {\n\t\tmerged_b = prepare->trail_elm_a;\n\t}\n\n\temap_rtree_write_acquired(tsdn, emap, prepare->lead_elm_a, merged_b,\n\t lead, SC_NSIZES, false);\n}\n\nvoid\nemap_do_assert_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\tEMAP_DECLARE_RTREE_CTX;\n\n\trtree_contents_t contents = rtree_read(tsdn, &emap->rtree, rtree_ctx,\n\t (uintptr_t)edata_base_get(edata));\n\tassert(contents.edata == edata);\n\tassert(contents.metadata.is_head == edata_is_head_get(edata));\n\tassert(contents.metadata.state == edata_state_get(edata));\n}\n\nvoid\nemap_do_assert_not_mapped(tsdn_t *tsdn, emap_t *emap, edata_t *edata) {\n\temap_full_alloc_ctx_t context1 = {0};\n\temap_full_alloc_ctx_try_lookup(tsdn, emap, edata_base_get(edata),\n\t &context1);\n\tassert(context1.edata == NULL);\n\n\temap_full_alloc_ctx_t context2 = {0};\n\temap_full_alloc_ctx_try_lookup(tsdn, emap, edata_last_get(edata),\n\t &context2);\n\tassert(context2.edata == NULL);\n}\n" }, { "path": "deps/jemalloc/src/eset.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/eset.h\"\n\n#define ESET_NPSIZES (SC_NPSIZES + 1)\n\nstatic void\neset_bin_init(eset_bin_t *bin) {\n\tedata_heap_new(&bin->heap);\n\t/*\n\t * heap_min doesn't need initialization; it gets filled in when the bin\n\t * goes from non-empty to empty.\n\t */\n}\n\nstatic void\neset_bin_stats_init(eset_bin_stats_t *bin_stats) {\n\tatomic_store_zu(&bin_stats->nextents, 0, ATOMIC_RELAXED);\n\tatomic_store_zu(&bin_stats->nbytes, 0, ATOMIC_RELAXED);\n}\n\nvoid\neset_init(eset_t *eset, extent_state_t state) {\n\tfor (unsigned i = 0; i < ESET_NPSIZES; i++) {\n\t\teset_bin_init(&eset->bins[i]);\n\t\teset_bin_stats_init(&eset->bin_stats[i]);\n\t}\n\tfb_init(eset->bitmap, ESET_NPSIZES);\n\tedata_list_inactive_init(&eset->lru);\n\teset->state = state;\n}\n\nsize_t\neset_npages_get(eset_t *eset) {\n\treturn atomic_load_zu(&eset->npages, ATOMIC_RELAXED);\n}\n\nsize_t\neset_nextents_get(eset_t *eset, pszind_t pind) {\n\treturn atomic_load_zu(&eset->bin_stats[pind].nextents, ATOMIC_RELAXED);\n}\n\nsize_t\neset_nbytes_get(eset_t *eset, pszind_t pind) {\n\treturn atomic_load_zu(&eset->bin_stats[pind].nbytes, ATOMIC_RELAXED);\n}\n\nstatic void\neset_stats_add(eset_t *eset, pszind_t pind, size_t sz) {\n\tsize_t cur = atomic_load_zu(&eset->bin_stats[pind].nextents,\n\t ATOMIC_RELAXED);\n\tatomic_store_zu(&eset->bin_stats[pind].nextents, cur + 1,\n\t ATOMIC_RELAXED);\n\tcur = atomic_load_zu(&eset->bin_stats[pind].nbytes, ATOMIC_RELAXED);\n\tatomic_store_zu(&eset->bin_stats[pind].nbytes, cur + sz,\n\t ATOMIC_RELAXED);\n}\n\nstatic void\neset_stats_sub(eset_t *eset, pszind_t pind, size_t sz) {\n\tsize_t cur = atomic_load_zu(&eset->bin_stats[pind].nextents,\n\t ATOMIC_RELAXED);\n\tatomic_store_zu(&eset->bin_stats[pind].nextents, cur - 1,\n\t ATOMIC_RELAXED);\n\tcur = atomic_load_zu(&eset->bin_stats[pind].nbytes, ATOMIC_RELAXED);\n\tatomic_store_zu(&eset->bin_stats[pind].nbytes, cur - sz,\n\t ATOMIC_RELAXED);\n}\n\nvoid\neset_insert(eset_t *eset, edata_t *edata) {\n\tassert(edata_state_get(edata) == eset->state);\n\n\tsize_t size = edata_size_get(edata);\n\tsize_t psz = sz_psz_quantize_floor(size);\n\tpszind_t pind = sz_psz2ind(psz);\n\n\tedata_cmp_summary_t edata_cmp_summary = edata_cmp_summary_get(edata);\n\tif (edata_heap_empty(&eset->bins[pind].heap)) {\n\t\tfb_set(eset->bitmap, ESET_NPSIZES, (size_t)pind);\n\t\t/* Only element is automatically the min element. */\n\t\teset->bins[pind].heap_min = edata_cmp_summary;\n\t} else {\n\t\t/*\n\t\t * There's already a min element; update the summary if we're\n\t\t * about to insert a lower one.\n\t\t */\n\t\tif (edata_cmp_summary_comp(edata_cmp_summary,\n\t\t eset->bins[pind].heap_min) < 0) {\n\t\t\teset->bins[pind].heap_min = edata_cmp_summary;\n\t\t}\n\t}\n\tedata_heap_insert(&eset->bins[pind].heap, edata);\n\n\tif (config_stats) {\n\t\teset_stats_add(eset, pind, size);\n\t}\n\n\tedata_list_inactive_append(&eset->lru, edata);\n\tsize_t npages = size >> LG_PAGE;\n\t/*\n\t * All modifications to npages hold the mutex (as asserted above), so we\n\t * don't need an atomic fetch-add; we can get by with a load followed by\n\t * a store.\n\t */\n\tsize_t cur_eset_npages =\n\t atomic_load_zu(&eset->npages, ATOMIC_RELAXED);\n\tatomic_store_zu(&eset->npages, cur_eset_npages + npages,\n\t ATOMIC_RELAXED);\n}\n\nvoid\neset_remove(eset_t *eset, edata_t *edata) {\n\tassert(edata_state_get(edata) == eset->state ||\n\t edata_state_in_transition(edata_state_get(edata)));\n\n\tsize_t size = edata_size_get(edata);\n\tsize_t psz = sz_psz_quantize_floor(size);\n\tpszind_t pind = sz_psz2ind(psz);\n\tif (config_stats) {\n\t\teset_stats_sub(eset, pind, size);\n\t}\n\n\tedata_cmp_summary_t edata_cmp_summary = edata_cmp_summary_get(edata);\n\tedata_heap_remove(&eset->bins[pind].heap, edata);\n\tif (edata_heap_empty(&eset->bins[pind].heap)) {\n\t\tfb_unset(eset->bitmap, ESET_NPSIZES, (size_t)pind);\n\t} else {\n\t\t/*\n\t\t * This is a little weird; we compare if the summaries are\n\t\t * equal, rather than if the edata we removed was the heap\n\t\t * minimum. The reason why is that getting the heap minimum\n\t\t * can cause a pairing heap merge operation. We can avoid this\n\t\t * if we only update the min if it's changed, in which case the\n\t\t * summaries of the removed element and the min element should\n\t\t * compare equal.\n\t\t */\n\t\tif (edata_cmp_summary_comp(edata_cmp_summary,\n\t\t eset->bins[pind].heap_min) == 0) {\n\t\t\teset->bins[pind].heap_min = edata_cmp_summary_get(\n\t\t\t edata_heap_first(&eset->bins[pind].heap));\n\t\t}\n\t}\n\tedata_list_inactive_remove(&eset->lru, edata);\n\tsize_t npages = size >> LG_PAGE;\n\t/*\n\t * As in eset_insert, we hold eset->mtx and so don't need atomic\n\t * operations for updating eset->npages.\n\t */\n\tsize_t cur_extents_npages =\n\t atomic_load_zu(&eset->npages, ATOMIC_RELAXED);\n\tassert(cur_extents_npages >= npages);\n\tatomic_store_zu(&eset->npages,\n\t cur_extents_npages - (size >> LG_PAGE), ATOMIC_RELAXED);\n}\n\n/*\n * Find an extent with size [min_size, max_size) to satisfy the alignment\n * requirement. For each size, try only the first extent in the heap.\n */\nstatic edata_t *\neset_fit_alignment(eset_t *eset, size_t min_size, size_t max_size,\n size_t alignment) {\n pszind_t pind = sz_psz2ind(sz_psz_quantize_ceil(min_size));\n pszind_t pind_max = sz_psz2ind(sz_psz_quantize_ceil(max_size));\n\n\tfor (pszind_t i =\n\t (pszind_t)fb_ffs(eset->bitmap, ESET_NPSIZES, (size_t)pind);\n\t i < pind_max;\n\t i = (pszind_t)fb_ffs(eset->bitmap, ESET_NPSIZES, (size_t)i + 1)) {\n\t\tassert(i < SC_NPSIZES);\n\t\tassert(!edata_heap_empty(&eset->bins[i].heap));\n\t\tedata_t *edata = edata_heap_first(&eset->bins[i].heap);\n\t\tuintptr_t base = (uintptr_t)edata_base_get(edata);\n\t\tsize_t candidate_size = edata_size_get(edata);\n\t\tassert(candidate_size >= min_size);\n\n\t\tuintptr_t next_align = ALIGNMENT_CEILING((uintptr_t)base,\n\t\t PAGE_CEILING(alignment));\n\t\tif (base > next_align || base + candidate_size <= next_align) {\n\t\t\t/* Overflow or not crossing the next alignment. */\n\t\t\tcontinue;\n\t\t}\n\n\t\tsize_t leadsize = next_align - base;\n\t\tif (candidate_size - leadsize >= min_size) {\n\t\t\treturn edata;\n\t\t}\n\t}\n\n\treturn NULL;\n}\n\n/*\n * Do first-fit extent selection, i.e. select the oldest/lowest extent that is\n * large enough.\n *\n * lg_max_fit is the (log of the) maximum ratio between the requested size and\n * the returned size that we'll allow. This can reduce fragmentation by\n * avoiding reusing and splitting large extents for smaller sizes. In practice,\n * it's set to opt_lg_extent_max_active_fit for the dirty eset and SC_PTR_BITS\n * for others.\n */\nstatic edata_t *\neset_first_fit(eset_t *eset, size_t size, bool exact_only,\n unsigned lg_max_fit) {\n\tedata_t *ret = NULL;\n\tedata_cmp_summary_t ret_summ JEMALLOC_CC_SILENCE_INIT({0});\n\n\tpszind_t pind = sz_psz2ind(sz_psz_quantize_ceil(size));\n\n\tif (exact_only) {\n\t\treturn edata_heap_empty(&eset->bins[pind].heap) ? NULL :\n\t\t edata_heap_first(&eset->bins[pind].heap);\n\t}\n\n\tfor (pszind_t i =\n\t (pszind_t)fb_ffs(eset->bitmap, ESET_NPSIZES, (size_t)pind);\n\t i < ESET_NPSIZES;\n\t i = (pszind_t)fb_ffs(eset->bitmap, ESET_NPSIZES, (size_t)i + 1)) {\n\t\tassert(!edata_heap_empty(&eset->bins[i].heap));\n\t\tif (lg_max_fit == SC_PTR_BITS) {\n\t\t\t/*\n\t\t\t * We'll shift by this below, and shifting out all the\n\t\t\t * bits is undefined. Decreasing is safe, since the\n\t\t\t * page size is larger than 1 byte.\n\t\t\t */\n\t\t\tlg_max_fit = SC_PTR_BITS - 1;\n\t\t}\n\t\tif ((sz_pind2sz(i) >> lg_max_fit) > size) {\n\t\t\tbreak;\n\t\t}\n\t\tif (ret == NULL || edata_cmp_summary_comp(\n\t\t eset->bins[i].heap_min, ret_summ) < 0) {\n\t\t\t/*\n\t\t\t * We grab the edata as early as possible, even though\n\t\t\t * we might change it later. Practically, a large\n\t\t\t * portion of eset_fit calls succeed at the first valid\n\t\t\t * index, so this doesn't cost much, and we get the\n\t\t\t * effect of prefetching the edata as early as possible.\n\t\t\t */\n\t\t\tedata_t *edata = edata_heap_first(&eset->bins[i].heap);\n\t\t\tassert(edata_size_get(edata) >= size);\n\t\t\tassert(ret == NULL || edata_snad_comp(edata, ret) < 0);\n\t\t\tassert(ret == NULL || edata_cmp_summary_comp(\n\t\t\t eset->bins[i].heap_min,\n\t\t\t edata_cmp_summary_get(edata)) == 0);\n\t\t\tret = edata;\n\t\t\tret_summ = eset->bins[i].heap_min;\n\t\t}\n\t\tif (i == SC_NPSIZES) {\n\t\t\tbreak;\n\t\t}\n\t\tassert(i < SC_NPSIZES);\n\t}\n\n\treturn ret;\n}\n\nedata_t *\neset_fit(eset_t *eset, size_t esize, size_t alignment, bool exact_only,\n unsigned lg_max_fit) {\n\tsize_t max_size = esize + PAGE_CEILING(alignment) - PAGE;\n\t/* Beware size_t wrap-around. */\n\tif (max_size < esize) {\n\t\treturn NULL;\n\t}\n\n\tedata_t *edata = eset_first_fit(eset, max_size, exact_only, lg_max_fit);\n\n\tif (alignment > PAGE && edata == NULL) {\n\t\t/*\n\t\t * max_size guarantees the alignment requirement but is rather\n\t\t * pessimistic. Next we try to satisfy the aligned allocation\n\t\t * with sizes in [esize, max_size).\n\t\t */\n\t\tedata = eset_fit_alignment(eset, esize, max_size, alignment);\n\t}\n\n\treturn edata;\n}\n" }, { "path": "deps/jemalloc/src/exp_grow.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nvoid\nexp_grow_init(exp_grow_t *exp_grow) {\n\texp_grow->next = sz_psz2ind(HUGEPAGE);\n\texp_grow->limit = sz_psz2ind(SC_LARGE_MAXCLASS);\n}\n" }, { "path": "deps/jemalloc/src/extent.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/emap.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/ph.h\"\n#include \"jemalloc/internal/mutex.h\"\n\n/******************************************************************************/\n/* Data. */\n\nsize_t opt_lg_extent_max_active_fit = LG_EXTENT_MAX_ACTIVE_FIT_DEFAULT;\n\nstatic bool extent_commit_impl(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length, bool growing_retained);\nstatic bool extent_purge_lazy_impl(tsdn_t *tsdn, ehooks_t *ehooks,\n edata_t *edata, size_t offset, size_t length, bool growing_retained);\nstatic bool extent_purge_forced_impl(tsdn_t *tsdn, ehooks_t *ehooks,\n edata_t *edata, size_t offset, size_t length, bool growing_retained);\nstatic edata_t *extent_split_impl(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata, size_t size_a, size_t size_b, bool holding_core_locks);\nstatic bool extent_merge_impl(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *a, edata_t *b, bool holding_core_locks);\n\n/* Used exclusively for gdump triggering. */\nstatic atomic_zu_t curpages;\nstatic atomic_zu_t highpages;\n\n/******************************************************************************/\n/*\n * Function prototypes for static functions that are referenced prior to\n * definition.\n */\n\nstatic void extent_deregister(tsdn_t *tsdn, pac_t *pac, edata_t *edata);\nstatic edata_t *extent_recycle(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *expand_edata, size_t usize, size_t alignment,\n bool zero, bool *commit, bool growing_retained, bool guarded);\nstatic edata_t *extent_try_coalesce(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata, bool *coalesced);\nstatic edata_t *extent_alloc_retained(tsdn_t *tsdn, pac_t *pac,\n ehooks_t *ehooks, edata_t *expand_edata, size_t size, size_t alignment,\n bool zero, bool *commit, bool guarded);\n\n/******************************************************************************/\n\nsize_t\nextent_sn_next(pac_t *pac) {\n\treturn atomic_fetch_add_zu(&pac->extent_sn_next, 1, ATOMIC_RELAXED);\n}\n\nstatic inline bool\nextent_may_force_decay(pac_t *pac) {\n\treturn !(pac_decay_ms_get(pac, extent_state_dirty) == -1\n\t || pac_decay_ms_get(pac, extent_state_muzzy) == -1);\n}\n\nstatic bool\nextent_try_delayed_coalesce(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata) {\n\temap_update_edata_state(tsdn, pac->emap, edata, extent_state_active);\n\n\tbool coalesced;\n\tedata = extent_try_coalesce(tsdn, pac, ehooks, ecache,\n\t edata, &coalesced);\n\temap_update_edata_state(tsdn, pac->emap, edata, ecache->state);\n\n\tif (!coalesced) {\n\t\treturn true;\n\t}\n\teset_insert(&ecache->eset, edata);\n\treturn false;\n}\n\nedata_t *\necache_alloc(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *expand_edata, size_t size, size_t alignment, bool zero,\n bool guarded) {\n\tassert(size != 0);\n\tassert(alignment != 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tbool commit = true;\n\tedata_t *edata = extent_recycle(tsdn, pac, ehooks, ecache, expand_edata,\n\t size, alignment, zero, &commit, false, guarded);\n\tassert(edata == NULL || edata_pai_get(edata) == EXTENT_PAI_PAC);\n\tassert(edata == NULL || edata_guarded_get(edata) == guarded);\n\treturn edata;\n}\n\nedata_t *\necache_alloc_grow(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *expand_edata, size_t size, size_t alignment, bool zero,\n bool guarded) {\n\tassert(size != 0);\n\tassert(alignment != 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tbool commit = true;\n\tedata_t *edata = extent_alloc_retained(tsdn, pac, ehooks, expand_edata,\n\t size, alignment, zero, &commit, guarded);\n\tif (edata == NULL) {\n\t\tif (opt_retain && expand_edata != NULL) {\n\t\t\t/*\n\t\t\t * When retain is enabled and trying to expand, we do\n\t\t\t * not attempt extent_alloc_wrapper which does mmap that\n\t\t\t * is very unlikely to succeed (unless it happens to be\n\t\t\t * at the end).\n\t\t\t */\n\t\t\treturn NULL;\n\t\t}\n\t\tif (guarded) {\n\t\t\t/*\n\t\t\t * Means no cached guarded extents available (and no\n\t\t\t * grow_retained was attempted). The pac_alloc flow\n\t\t\t * will alloc regular extents to make new guarded ones.\n\t\t\t */\n\t\t\treturn NULL;\n\t\t}\n\t\tvoid *new_addr = (expand_edata == NULL) ? NULL :\n\t\t edata_past_get(expand_edata);\n\t\tedata = extent_alloc_wrapper(tsdn, pac, ehooks, new_addr,\n\t\t size, alignment, zero, &commit,\n\t\t /* growing_retained */ false);\n\t}\n\n\tassert(edata == NULL || edata_pai_get(edata) == EXTENT_PAI_PAC);\n\treturn edata;\n}\n\nvoid\necache_dalloc(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *edata) {\n\tassert(edata_base_get(edata) != NULL);\n\tassert(edata_size_get(edata) != 0);\n\tassert(edata_pai_get(edata) == EXTENT_PAI_PAC);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tedata_addr_set(edata, edata_base_get(edata));\n\tedata_zeroed_set(edata, false);\n\n\textent_record(tsdn, pac, ehooks, ecache, edata);\n}\n\nedata_t *\necache_evict(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, size_t npages_min) {\n\tmalloc_mutex_lock(tsdn, &ecache->mtx);\n\n\t/*\n\t * Get the LRU coalesced extent, if any. If coalescing was delayed,\n\t * the loop will iterate until the LRU extent is fully coalesced.\n\t */\n\tedata_t *edata;\n\twhile (true) {\n\t\t/* Get the LRU extent, if any. */\n\t\teset_t *eset = &ecache->eset;\n\t\tedata = edata_list_inactive_first(&eset->lru);\n\t\tif (edata == NULL) {\n\t\t\t/*\n\t\t\t * Next check if there are guarded extents. They are\n\t\t\t * more expensive to purge (since they are not\n\t\t\t * mergeable), thus in favor of caching them longer.\n\t\t\t */\n\t\t\teset = &ecache->guarded_eset;\n\t\t\tedata = edata_list_inactive_first(&eset->lru);\n\t\t\tif (edata == NULL) {\n\t\t\t\tgoto label_return;\n\t\t\t}\n\t\t}\n\t\t/* Check the eviction limit. */\n\t\tsize_t extents_npages = ecache_npages_get(ecache);\n\t\tif (extents_npages <= npages_min) {\n\t\t\tedata = NULL;\n\t\t\tgoto label_return;\n\t\t}\n\t\teset_remove(eset, edata);\n\t\tif (!ecache->delay_coalesce || edata_guarded_get(edata)) {\n\t\t\tbreak;\n\t\t}\n\t\t/* Try to coalesce. */\n\t\tif (extent_try_delayed_coalesce(tsdn, pac, ehooks, ecache,\n\t\t edata)) {\n\t\t\tbreak;\n\t\t}\n\t\t/*\n\t\t * The LRU extent was just coalesced and the result placed in\n\t\t * the LRU at its neighbor's position. Start over.\n\t\t */\n\t}\n\n\t/*\n\t * Either mark the extent active or deregister it to protect against\n\t * concurrent operations.\n\t */\n\tswitch (ecache->state) {\n\tcase extent_state_active:\n\t\tnot_reached();\n\tcase extent_state_dirty:\n\tcase extent_state_muzzy:\n\t\temap_update_edata_state(tsdn, pac->emap, edata,\n\t\t extent_state_active);\n\t\tbreak;\n\tcase extent_state_retained:\n\t\textent_deregister(tsdn, pac, edata);\n\t\tbreak;\n\tdefault:\n\t\tnot_reached();\n\t}\n\nlabel_return:\n\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n\treturn edata;\n}\n\n/*\n * This can only happen when we fail to allocate a new extent struct (which\n * indicates OOM), e.g. when trying to split an existing extent.\n */\nstatic void\nextents_abandon_vm(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *edata, bool growing_retained) {\n\tsize_t sz = edata_size_get(edata);\n\tif (config_stats) {\n\t\tatomic_fetch_add_zu(&pac->stats->abandoned_vm, sz,\n\t\t ATOMIC_RELAXED);\n\t}\n\t/*\n\t * Leak extent after making sure its pages have already been purged, so\n\t * that this is only a virtual memory leak.\n\t */\n\tif (ecache->state == extent_state_dirty) {\n\t\tif (extent_purge_lazy_impl(tsdn, ehooks, edata, 0, sz,\n\t\t growing_retained)) {\n\t\t\textent_purge_forced_impl(tsdn, ehooks, edata, 0,\n\t\t\t edata_size_get(edata), growing_retained);\n\t\t}\n\t}\n\tedata_cache_put(tsdn, pac->edata_cache, edata);\n}\n\nstatic void\nextent_deactivate_locked_impl(tsdn_t *tsdn, pac_t *pac, ecache_t *ecache,\n edata_t *edata) {\n\tmalloc_mutex_assert_owner(tsdn, &ecache->mtx);\n\tassert(edata_arena_ind_get(edata) == ecache_ind_get(ecache));\n\n\temap_update_edata_state(tsdn, pac->emap, edata, ecache->state);\n\teset_t *eset = edata_guarded_get(edata) ? &ecache->guarded_eset :\n\t &ecache->eset;\n\teset_insert(eset, edata);\n}\n\nstatic void\nextent_deactivate_locked(tsdn_t *tsdn, pac_t *pac, ecache_t *ecache,\n edata_t *edata) {\n\tassert(edata_state_get(edata) == extent_state_active);\n\textent_deactivate_locked_impl(tsdn, pac, ecache, edata);\n}\n\nstatic void\nextent_deactivate_check_state_locked(tsdn_t *tsdn, pac_t *pac, ecache_t *ecache,\n edata_t *edata, extent_state_t expected_state) {\n\tassert(edata_state_get(edata) == expected_state);\n\textent_deactivate_locked_impl(tsdn, pac, ecache, edata);\n}\n\nstatic void\nextent_activate_locked(tsdn_t *tsdn, pac_t *pac, ecache_t *ecache, eset_t *eset,\n edata_t *edata) {\n\tassert(edata_arena_ind_get(edata) == ecache_ind_get(ecache));\n\tassert(edata_state_get(edata) == ecache->state ||\n\t edata_state_get(edata) == extent_state_merging);\n\n\teset_remove(eset, edata);\n\temap_update_edata_state(tsdn, pac->emap, edata, extent_state_active);\n}\n\nvoid\nextent_gdump_add(tsdn_t *tsdn, const edata_t *edata) {\n\tcassert(config_prof);\n\t/* prof_gdump() requirement. */\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (opt_prof && edata_state_get(edata) == extent_state_active) {\n\t\tsize_t nadd = edata_size_get(edata) >> LG_PAGE;\n\t\tsize_t cur = atomic_fetch_add_zu(&curpages, nadd,\n\t\t ATOMIC_RELAXED) + nadd;\n\t\tsize_t high = atomic_load_zu(&highpages, ATOMIC_RELAXED);\n\t\twhile (cur > high && !atomic_compare_exchange_weak_zu(\n\t\t &highpages, &high, cur, ATOMIC_RELAXED, ATOMIC_RELAXED)) {\n\t\t\t/*\n\t\t\t * Don't refresh cur, because it may have decreased\n\t\t\t * since this thread lost the highpages update race.\n\t\t\t * Note that high is updated in case of CAS failure.\n\t\t\t */\n\t\t}\n\t\tif (cur > high && prof_gdump_get_unlocked()) {\n\t\t\tprof_gdump(tsdn);\n\t\t}\n\t}\n}\n\nstatic void\nextent_gdump_sub(tsdn_t *tsdn, const edata_t *edata) {\n\tcassert(config_prof);\n\n\tif (opt_prof && edata_state_get(edata) == extent_state_active) {\n\t\tsize_t nsub = edata_size_get(edata) >> LG_PAGE;\n\t\tassert(atomic_load_zu(&curpages, ATOMIC_RELAXED) >= nsub);\n\t\tatomic_fetch_sub_zu(&curpages, nsub, ATOMIC_RELAXED);\n\t}\n}\n\nstatic bool\nextent_register_impl(tsdn_t *tsdn, pac_t *pac, edata_t *edata, bool gdump_add) {\n\tassert(edata_state_get(edata) == extent_state_active);\n\t/*\n\t * No locking needed, as the edata must be in active state, which\n\t * prevents other threads from accessing the edata.\n\t */\n\tif (emap_register_boundary(tsdn, pac->emap, edata, SC_NSIZES,\n\t /* slab */ false)) {\n\t\treturn true;\n\t}\n\n\tif (config_prof && gdump_add) {\n\t\textent_gdump_add(tsdn, edata);\n\t}\n\n\treturn false;\n}\n\nstatic bool\nextent_register(tsdn_t *tsdn, pac_t *pac, edata_t *edata) {\n\treturn extent_register_impl(tsdn, pac, edata, true);\n}\n\nstatic bool\nextent_register_no_gdump_add(tsdn_t *tsdn, pac_t *pac, edata_t *edata) {\n\treturn extent_register_impl(tsdn, pac, edata, false);\n}\n\nstatic void\nextent_reregister(tsdn_t *tsdn, pac_t *pac, edata_t *edata) {\n\tbool err = extent_register(tsdn, pac, edata);\n\tassert(!err);\n}\n\n/*\n * Removes all pointers to the given extent from the global rtree.\n */\nstatic void\nextent_deregister_impl(tsdn_t *tsdn, pac_t *pac, edata_t *edata,\n bool gdump) {\n\temap_deregister_boundary(tsdn, pac->emap, edata);\n\n\tif (config_prof && gdump) {\n\t\textent_gdump_sub(tsdn, edata);\n\t}\n}\n\nstatic void\nextent_deregister(tsdn_t *tsdn, pac_t *pac, edata_t *edata) {\n\textent_deregister_impl(tsdn, pac, edata, true);\n}\n\nstatic void\nextent_deregister_no_gdump_sub(tsdn_t *tsdn, pac_t *pac,\n edata_t *edata) {\n\textent_deregister_impl(tsdn, pac, edata, false);\n}\n\n/*\n * Tries to find and remove an extent from ecache that can be used for the\n * given allocation request.\n */\nstatic edata_t *\nextent_recycle_extract(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *expand_edata, size_t size, size_t alignment,\n bool guarded) {\n\tmalloc_mutex_assert_owner(tsdn, &ecache->mtx);\n\tassert(alignment > 0);\n\tif (config_debug && expand_edata != NULL) {\n\t\t/*\n\t\t * Non-NULL expand_edata indicates in-place expanding realloc.\n\t\t * new_addr must either refer to a non-existing extent, or to\n\t\t * the base of an extant extent, since only active slabs support\n\t\t * interior lookups (which of course cannot be recycled).\n\t\t */\n\t\tvoid *new_addr = edata_past_get(expand_edata);\n\t\tassert(PAGE_ADDR2BASE(new_addr) == new_addr);\n\t\tassert(alignment <= PAGE);\n\t}\n\n\tedata_t *edata;\n\teset_t *eset = guarded ? &ecache->guarded_eset : &ecache->eset;\n\tif (expand_edata != NULL) {\n\t\tedata = emap_try_acquire_edata_neighbor_expand(tsdn, pac->emap,\n\t\t expand_edata, EXTENT_PAI_PAC, ecache->state);\n\t\tif (edata != NULL) {\n\t\t\textent_assert_can_expand(expand_edata, edata);\n\t\t\tif (edata_size_get(edata) < size) {\n\t\t\t\temap_release_edata(tsdn, pac->emap, edata,\n\t\t\t\t ecache->state);\n\t\t\t\tedata = NULL;\n\t\t\t}\n\t\t}\n\t} else {\n\t\t/*\n\t\t * A large extent might be broken up from its original size to\n\t\t * some small size to satisfy a small request. When that small\n\t\t * request is freed, though, it won't merge back with the larger\n\t\t * extent if delayed coalescing is on. The large extent can\n\t\t * then no longer satify a request for its original size. To\n\t\t * limit this effect, when delayed coalescing is enabled, we\n\t\t * put a cap on how big an extent we can split for a request.\n\t\t */\n\t\tunsigned lg_max_fit = ecache->delay_coalesce\n\t\t ? (unsigned)opt_lg_extent_max_active_fit : SC_PTR_BITS;\n\n\t\t/*\n\t\t * If split and merge are not allowed (Windows w/o retain), try\n\t\t * exact fit only.\n\t\t *\n\t\t * For simplicity purposes, splitting guarded extents is not\n\t\t * supported. Hence, we do only exact fit for guarded\n\t\t * allocations.\n\t\t */\n\t\tbool exact_only = (!maps_coalesce && !opt_retain) || guarded;\n\t\tedata = eset_fit(eset, size, alignment, exact_only,\n\t\t lg_max_fit);\n\t}\n\tif (edata == NULL) {\n\t\treturn NULL;\n\t}\n\tassert(!guarded || edata_guarded_get(edata));\n\textent_activate_locked(tsdn, pac, ecache, eset, edata);\n\n\treturn edata;\n}\n\n/*\n * Given an allocation request and an extent guaranteed to be able to satisfy\n * it, this splits off lead and trail extents, leaving edata pointing to an\n * extent satisfying the allocation.\n * This function doesn't put lead or trail into any ecache; it's the caller's\n * job to ensure that they can be reused.\n */\ntypedef enum {\n\t/*\n\t * Split successfully. lead, edata, and trail, are modified to extents\n\t * describing the ranges before, in, and after the given allocation.\n\t */\n\textent_split_interior_ok,\n\t/*\n\t * The extent can't satisfy the given allocation request. None of the\n\t * input edata_t *s are touched.\n\t */\n\textent_split_interior_cant_alloc,\n\t/*\n\t * In a potentially invalid state. Must leak (if *to_leak is non-NULL),\n\t * and salvage what's still salvageable (if *to_salvage is non-NULL).\n\t * None of lead, edata, or trail are valid.\n\t */\n\textent_split_interior_error\n} extent_split_interior_result_t;\n\nstatic extent_split_interior_result_t\nextent_split_interior(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n /* The result of splitting, in case of success. */\n edata_t **edata, edata_t **lead, edata_t **trail,\n /* The mess to clean up, in case of error. */\n edata_t **to_leak, edata_t **to_salvage,\n edata_t *expand_edata, size_t size, size_t alignment) {\n\tsize_t leadsize = ALIGNMENT_CEILING((uintptr_t)edata_base_get(*edata),\n\t PAGE_CEILING(alignment)) - (uintptr_t)edata_base_get(*edata);\n\tassert(expand_edata == NULL || leadsize == 0);\n\tif (edata_size_get(*edata) < leadsize + size) {\n\t\treturn extent_split_interior_cant_alloc;\n\t}\n\tsize_t trailsize = edata_size_get(*edata) - leadsize - size;\n\n\t*lead = NULL;\n\t*trail = NULL;\n\t*to_leak = NULL;\n\t*to_salvage = NULL;\n\n\t/* Split the lead. */\n\tif (leadsize != 0) {\n\t\tassert(!edata_guarded_get(*edata));\n\t\t*lead = *edata;\n\t\t*edata = extent_split_impl(tsdn, pac, ehooks, *lead, leadsize,\n\t\t size + trailsize, /* holding_core_locks*/ true);\n\t\tif (*edata == NULL) {\n\t\t\t*to_leak = *lead;\n\t\t\t*lead = NULL;\n\t\t\treturn extent_split_interior_error;\n\t\t}\n\t}\n\n\t/* Split the trail. */\n\tif (trailsize != 0) {\n\t\tassert(!edata_guarded_get(*edata));\n\t\t*trail = extent_split_impl(tsdn, pac, ehooks, *edata, size,\n\t\t trailsize, /* holding_core_locks */ true);\n\t\tif (*trail == NULL) {\n\t\t\t*to_leak = *edata;\n\t\t\t*to_salvage = *lead;\n\t\t\t*lead = NULL;\n\t\t\t*edata = NULL;\n\t\t\treturn extent_split_interior_error;\n\t\t}\n\t}\n\n\treturn extent_split_interior_ok;\n}\n\n/*\n * This fulfills the indicated allocation request out of the given extent (which\n * the caller should have ensured was big enough). If there's any unused space\n * before or after the resulting allocation, that space is given its own extent\n * and put back into ecache.\n */\nstatic edata_t *\nextent_recycle_split(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *expand_edata, size_t size, size_t alignment,\n edata_t *edata, bool growing_retained) {\n\tassert(!edata_guarded_get(edata) || size == edata_size_get(edata));\n\tmalloc_mutex_assert_owner(tsdn, &ecache->mtx);\n\n\tedata_t *lead;\n\tedata_t *trail;\n\tedata_t *to_leak JEMALLOC_CC_SILENCE_INIT(NULL);\n\tedata_t *to_salvage JEMALLOC_CC_SILENCE_INIT(NULL);\n\n\textent_split_interior_result_t result = extent_split_interior(\n\t tsdn, pac, ehooks, &edata, &lead, &trail, &to_leak, &to_salvage,\n\t expand_edata, size, alignment);\n\n\tif (!maps_coalesce && result != extent_split_interior_ok\n\t && !opt_retain) {\n\t\t/*\n\t\t * Split isn't supported (implies Windows w/o retain). Avoid\n\t\t * leaking the extent.\n\t\t */\n\t\tassert(to_leak != NULL && lead == NULL && trail == NULL);\n\t\textent_deactivate_locked(tsdn, pac, ecache, to_leak);\n\t\treturn NULL;\n\t}\n\n\tif (result == extent_split_interior_ok) {\n\t\tif (lead != NULL) {\n\t\t\textent_deactivate_locked(tsdn, pac, ecache, lead);\n\t\t}\n\t\tif (trail != NULL) {\n\t\t\textent_deactivate_locked(tsdn, pac, ecache, trail);\n\t\t}\n\t\treturn edata;\n\t} else {\n\t\t/*\n\t\t * We should have picked an extent that was large enough to\n\t\t * fulfill our allocation request.\n\t\t */\n\t\tassert(result == extent_split_interior_error);\n\t\tif (to_salvage != NULL) {\n\t\t\textent_deregister(tsdn, pac, to_salvage);\n\t\t}\n\t\tif (to_leak != NULL) {\n\t\t\textent_deregister_no_gdump_sub(tsdn, pac, to_leak);\n\t\t\t/*\n\t\t\t * May go down the purge path (which assume no ecache\n\t\t\t * locks). Only happens with OOM caused split failures.\n\t\t\t */\n\t\t\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n\t\t\textents_abandon_vm(tsdn, pac, ehooks, ecache, to_leak,\n\t\t\t growing_retained);\n\t\t\tmalloc_mutex_lock(tsdn, &ecache->mtx);\n\t\t}\n\t\treturn NULL;\n\t}\n\tunreachable();\n}\n\n/*\n * Tries to satisfy the given allocation request by reusing one of the extents\n * in the given ecache_t.\n */\nstatic edata_t *\nextent_recycle(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *expand_edata, size_t size, size_t alignment, bool zero,\n bool *commit, bool growing_retained, bool guarded) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\tassert(!guarded || expand_edata == NULL);\n\tassert(!guarded || alignment <= PAGE);\n\n\tmalloc_mutex_lock(tsdn, &ecache->mtx);\n\n\tedata_t *edata = extent_recycle_extract(tsdn, pac, ehooks, ecache,\n\t expand_edata, size, alignment, guarded);\n\tif (edata == NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n\t\treturn NULL;\n\t}\n\n\tedata = extent_recycle_split(tsdn, pac, ehooks, ecache, expand_edata,\n\t size, alignment, edata, growing_retained);\n\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n\tif (edata == NULL) {\n\t\treturn NULL;\n\t}\n\n\tassert(edata_state_get(edata) == extent_state_active);\n\tif (extent_commit_zero(tsdn, ehooks, edata, *commit, zero,\n\t growing_retained)) {\n\t\textent_record(tsdn, pac, ehooks, ecache, edata);\n\t\treturn NULL;\n\t}\n\tif (edata_committed_get(edata)) {\n\t\t/*\n\t\t * This reverses the purpose of this variable - previously it\n\t\t * was treated as an input parameter, now it turns into an\n\t\t * output parameter, reporting if the edata has actually been\n\t\t * committed.\n\t\t */\n\t\t*commit = true;\n\t}\n\treturn edata;\n}\n\n/*\n * If virtual memory is retained, create increasingly larger extents from which\n * to split requested extents in order to limit the total number of disjoint\n * virtual memory ranges retained by each shard.\n */\nstatic edata_t *\nextent_grow_retained(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n size_t size, size_t alignment, bool zero, bool *commit) {\n\tmalloc_mutex_assert_owner(tsdn, &pac->grow_mtx);\n\n\tsize_t alloc_size_min = size + PAGE_CEILING(alignment) - PAGE;\n\t/* Beware size_t wrap-around. */\n\tif (alloc_size_min < size) {\n\t\tgoto label_err;\n\t}\n\t/*\n\t * Find the next extent size in the series that would be large enough to\n\t * satisfy this request.\n\t */\n\tsize_t alloc_size;\n\tpszind_t exp_grow_skip;\n\tbool err = exp_grow_size_prepare(&pac->exp_grow, alloc_size_min,\n\t &alloc_size, &exp_grow_skip);\n\tif (err) {\n\t\tgoto label_err;\n\t}\n\n\tedata_t *edata = edata_cache_get(tsdn, pac->edata_cache);\n\tif (edata == NULL) {\n\t\tgoto label_err;\n\t}\n\tbool zeroed = false;\n\tbool committed = false;\n\n\tvoid *ptr = ehooks_alloc(tsdn, ehooks, NULL, alloc_size, PAGE, &zeroed,\n\t &committed);\n\n\tif (ptr == NULL) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t\tgoto label_err;\n\t}\n\n\tedata_init(edata, ecache_ind_get(&pac->ecache_retained), ptr,\n\t alloc_size, false, SC_NSIZES, extent_sn_next(pac),\n\t extent_state_active, zeroed, committed, EXTENT_PAI_PAC,\n\t EXTENT_IS_HEAD);\n\n\tif (extent_register_no_gdump_add(tsdn, pac, edata)) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t\tgoto label_err;\n\t}\n\n\tif (edata_committed_get(edata)) {\n\t\t*commit = true;\n\t}\n\n\tedata_t *lead;\n\tedata_t *trail;\n\tedata_t *to_leak JEMALLOC_CC_SILENCE_INIT(NULL);\n\tedata_t *to_salvage JEMALLOC_CC_SILENCE_INIT(NULL);\n\n\textent_split_interior_result_t result = extent_split_interior(tsdn,\n\t pac, ehooks, &edata, &lead, &trail, &to_leak, &to_salvage, NULL,\n\t size, alignment);\n\n\tif (result == extent_split_interior_ok) {\n\t\tif (lead != NULL) {\n\t\t\textent_record(tsdn, pac, ehooks, &pac->ecache_retained,\n\t\t\t lead);\n\t\t}\n\t\tif (trail != NULL) {\n\t\t\textent_record(tsdn, pac, ehooks, &pac->ecache_retained,\n\t\t\t trail);\n\t\t}\n\t} else {\n\t\t/*\n\t\t * We should have allocated a sufficiently large extent; the\n\t\t * cant_alloc case should not occur.\n\t\t */\n\t\tassert(result == extent_split_interior_error);\n\t\tif (to_salvage != NULL) {\n\t\t\tif (config_prof) {\n\t\t\t\textent_gdump_add(tsdn, to_salvage);\n\t\t\t}\n\t\t\textent_record(tsdn, pac, ehooks, &pac->ecache_retained,\n\t\t\t to_salvage);\n\t\t}\n\t\tif (to_leak != NULL) {\n\t\t\textent_deregister_no_gdump_sub(tsdn, pac, to_leak);\n\t\t\textents_abandon_vm(tsdn, pac, ehooks,\n\t\t\t &pac->ecache_retained, to_leak, true);\n\t\t}\n\t\tgoto label_err;\n\t}\n\n\tif (*commit && !edata_committed_get(edata)) {\n\t\tif (extent_commit_impl(tsdn, ehooks, edata, 0,\n\t\t edata_size_get(edata), true)) {\n\t\t\textent_record(tsdn, pac, ehooks,\n\t\t\t &pac->ecache_retained, edata);\n\t\t\tgoto label_err;\n\t\t}\n\t\t/* A successful commit should return zeroed memory. */\n\t\tif (config_debug) {\n\t\t\tvoid *addr = edata_addr_get(edata);\n\t\t\tsize_t *p = (size_t *)(uintptr_t)addr;\n\t\t\t/* Check the first page only. */\n\t\t\tfor (size_t i = 0; i < PAGE / sizeof(size_t); i++) {\n\t\t\t\tassert(p[i] == 0);\n\t\t\t}\n\t\t}\n\t}\n\n\t/*\n\t * Increment extent_grow_next if doing so wouldn't exceed the allowed\n\t * range.\n\t */\n\t/* All opportunities for failure are past. */\n\texp_grow_size_commit(&pac->exp_grow, exp_grow_skip);\n\tmalloc_mutex_unlock(tsdn, &pac->grow_mtx);\n\n\tif (config_prof) {\n\t\t/* Adjust gdump stats now that extent is final size. */\n\t\textent_gdump_add(tsdn, edata);\n\t}\n\tif (zero && !edata_zeroed_get(edata)) {\n\t\tehooks_zero(tsdn, ehooks, edata_base_get(edata),\n\t\t edata_size_get(edata));\n\t}\n\treturn edata;\nlabel_err:\n\tmalloc_mutex_unlock(tsdn, &pac->grow_mtx);\n\treturn NULL;\n}\n\nstatic edata_t *\nextent_alloc_retained(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *expand_edata, size_t size, size_t alignment, bool zero,\n bool *commit, bool guarded) {\n\tassert(size != 0);\n\tassert(alignment != 0);\n\n\tmalloc_mutex_lock(tsdn, &pac->grow_mtx);\n\n\tedata_t *edata = extent_recycle(tsdn, pac, ehooks,\n\t &pac->ecache_retained, expand_edata, size, alignment, zero, commit,\n\t /* growing_retained */ true, guarded);\n\tif (edata != NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &pac->grow_mtx);\n\t\tif (config_prof) {\n\t\t\textent_gdump_add(tsdn, edata);\n\t\t}\n\t} else if (opt_retain && expand_edata == NULL && !guarded) {\n\t\tedata = extent_grow_retained(tsdn, pac, ehooks, size,\n\t\t alignment, zero, commit);\n\t\t/* extent_grow_retained() always releases pac->grow_mtx. */\n\t} else {\n\t\tmalloc_mutex_unlock(tsdn, &pac->grow_mtx);\n\t}\n\tmalloc_mutex_assert_not_owner(tsdn, &pac->grow_mtx);\n\n\treturn edata;\n}\n\nstatic bool\nextent_coalesce(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *inner, edata_t *outer, bool forward) {\n\textent_assert_can_coalesce(inner, outer);\n\teset_remove(&ecache->eset, outer);\n\n\tbool err = extent_merge_impl(tsdn, pac, ehooks,\n\t forward ? inner : outer, forward ? outer : inner,\n\t /* holding_core_locks */ true);\n\tif (err) {\n\t\textent_deactivate_check_state_locked(tsdn, pac, ecache, outer,\n\t\t extent_state_merging);\n\t}\n\n\treturn err;\n}\n\nstatic edata_t *\nextent_try_coalesce_impl(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata, bool *coalesced) {\n\tassert(!edata_guarded_get(edata));\n\t/*\n\t * We avoid checking / locking inactive neighbors for large size\n\t * classes, since they are eagerly coalesced on deallocation which can\n\t * cause lock contention.\n\t */\n\t/*\n\t * Continue attempting to coalesce until failure, to protect against\n\t * races with other threads that are thwarted by this one.\n\t */\n\tbool again;\n\tdo {\n\t\tagain = false;\n\n\t\t/* Try to coalesce forward. */\n\t\tedata_t *next = emap_try_acquire_edata_neighbor(tsdn, pac->emap,\n\t\t edata, EXTENT_PAI_PAC, ecache->state, /* forward */ true);\n\t\tif (next != NULL) {\n\t\t\tif (!extent_coalesce(tsdn, pac, ehooks, ecache, edata,\n\t\t\t next, true)) {\n\t\t\t\tif (ecache->delay_coalesce) {\n\t\t\t\t\t/* Do minimal coalescing. */\n\t\t\t\t\t*coalesced = true;\n\t\t\t\t\treturn edata;\n\t\t\t\t}\n\t\t\t\tagain = true;\n\t\t\t}\n\t\t}\n\n\t\t/* Try to coalesce backward. */\n\t\tedata_t *prev = emap_try_acquire_edata_neighbor(tsdn, pac->emap,\n\t\t edata, EXTENT_PAI_PAC, ecache->state, /* forward */ false);\n\t\tif (prev != NULL) {\n\t\t\tif (!extent_coalesce(tsdn, pac, ehooks, ecache, edata,\n\t\t\t prev, false)) {\n\t\t\t\tedata = prev;\n\t\t\t\tif (ecache->delay_coalesce) {\n\t\t\t\t\t/* Do minimal coalescing. */\n\t\t\t\t\t*coalesced = true;\n\t\t\t\t\treturn edata;\n\t\t\t\t}\n\t\t\t\tagain = true;\n\t\t\t}\n\t\t}\n\t} while (again);\n\n\tif (ecache->delay_coalesce) {\n\t\t*coalesced = false;\n\t}\n\treturn edata;\n}\n\nstatic edata_t *\nextent_try_coalesce(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata, bool *coalesced) {\n\treturn extent_try_coalesce_impl(tsdn, pac, ehooks, ecache, edata,\n\t coalesced);\n}\n\nstatic edata_t *\nextent_try_coalesce_large(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n ecache_t *ecache, edata_t *edata, bool *coalesced) {\n\treturn extent_try_coalesce_impl(tsdn, pac, ehooks, ecache, edata,\n\t coalesced);\n}\n\n/* Purge a single extent to retained / unmapped directly. */\nstatic void\nextent_maximally_purge(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata) {\n\tsize_t extent_size = edata_size_get(edata);\n\textent_dalloc_wrapper(tsdn, pac, ehooks, edata);\n\tif (config_stats) {\n\t\t/* Update stats accordingly. */\n\t\tLOCKEDINT_MTX_LOCK(tsdn, *pac->stats_mtx);\n\t\tlocked_inc_u64(tsdn,\n\t\t LOCKEDINT_MTX(*pac->stats_mtx),\n\t\t &pac->stats->decay_dirty.nmadvise, 1);\n\t\tlocked_inc_u64(tsdn,\n\t\t LOCKEDINT_MTX(*pac->stats_mtx),\n\t\t &pac->stats->decay_dirty.purged,\n\t\t extent_size >> LG_PAGE);\n\t\tLOCKEDINT_MTX_UNLOCK(tsdn, *pac->stats_mtx);\n\t\tatomic_fetch_sub_zu(&pac->stats->pac_mapped, extent_size,\n\t\t ATOMIC_RELAXED);\n\t}\n}\n\n/*\n * Does the metadata management portions of putting an unused extent into the\n * given ecache_t (coalesces and inserts into the eset).\n */\nvoid\nextent_record(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, ecache_t *ecache,\n edata_t *edata) {\n\tassert((ecache->state != extent_state_dirty &&\n\t ecache->state != extent_state_muzzy) ||\n\t !edata_zeroed_get(edata));\n\n\tmalloc_mutex_lock(tsdn, &ecache->mtx);\n\n\temap_assert_mapped(tsdn, pac->emap, edata);\n\n\tif (edata_guarded_get(edata)) {\n\t\tgoto label_skip_coalesce;\n\t}\n\tif (!ecache->delay_coalesce) {\n\t\tedata = extent_try_coalesce(tsdn, pac, ehooks, ecache, edata,\n\t\t NULL);\n\t} else if (edata_size_get(edata) >= SC_LARGE_MINCLASS) {\n\t\tassert(ecache == &pac->ecache_dirty);\n\t\t/* Always coalesce large extents eagerly. */\n\t\tbool coalesced;\n\t\tdo {\n\t\t\tassert(edata_state_get(edata) == extent_state_active);\n\t\t\tedata = extent_try_coalesce_large(tsdn, pac, ehooks,\n\t\t\t ecache, edata, &coalesced);\n\t\t} while (coalesced);\n\t\tif (edata_size_get(edata) >=\n\t\t atomic_load_zu(&pac->oversize_threshold, ATOMIC_RELAXED)\n\t\t && extent_may_force_decay(pac)) {\n\t\t\t/* Shortcut to purge the oversize extent eagerly. */\n\t\t\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n\t\t\textent_maximally_purge(tsdn, pac, ehooks, edata);\n\t\t\treturn;\n\t\t}\n\t}\nlabel_skip_coalesce:\n\textent_deactivate_locked(tsdn, pac, ecache, edata);\n\n\tmalloc_mutex_unlock(tsdn, &ecache->mtx);\n}\n\nvoid\nextent_dalloc_gap(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (extent_register(tsdn, pac, edata)) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t\treturn;\n\t}\n\textent_dalloc_wrapper(tsdn, pac, ehooks, edata);\n}\n\nstatic bool\nextent_dalloc_wrapper_try(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata) {\n\tbool err;\n\n\tassert(edata_base_get(edata) != NULL);\n\tassert(edata_size_get(edata) != 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tedata_addr_set(edata, edata_base_get(edata));\n\n\t/* Try to deallocate. */\n\terr = ehooks_dalloc(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), edata_committed_get(edata));\n\n\tif (!err) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t}\n\n\treturn err;\n}\n\nedata_t *\nextent_alloc_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n void *new_addr, size_t size, size_t alignment, bool zero, bool *commit,\n bool growing_retained) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\n\tedata_t *edata = edata_cache_get(tsdn, pac->edata_cache);\n\tif (edata == NULL) {\n\t\treturn NULL;\n\t}\n\tsize_t palignment = ALIGNMENT_CEILING(alignment, PAGE);\n\tvoid *addr = ehooks_alloc(tsdn, ehooks, new_addr, size, palignment,\n\t &zero, commit);\n\tif (addr == NULL) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t\treturn NULL;\n\t}\n\tedata_init(edata, ecache_ind_get(&pac->ecache_dirty), addr,\n\t size, /* slab */ false, SC_NSIZES, extent_sn_next(pac),\n\t extent_state_active, zero, *commit, EXTENT_PAI_PAC,\n\t opt_retain ? EXTENT_IS_HEAD : EXTENT_NOT_HEAD);\n\t/*\n\t * Retained memory is not counted towards gdump. Only if an extent is\n\t * allocated as a separate mapping, i.e. growing_retained is false, then\n\t * gdump should be updated.\n\t */\n\tbool gdump_add = !growing_retained;\n\tif (extent_register_impl(tsdn, pac, edata, gdump_add)) {\n\t\tedata_cache_put(tsdn, pac->edata_cache, edata);\n\t\treturn NULL;\n\t}\n\n\treturn edata;\n}\n\nvoid\nextent_dalloc_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata) {\n\tassert(edata_pai_get(edata) == EXTENT_PAI_PAC);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\t/* Avoid calling the default extent_dalloc unless have to. */\n\tif (!ehooks_dalloc_will_fail(ehooks)) {\n\t\t/* Remove guard pages for dalloc / unmap. */\n\t\tif (edata_guarded_get(edata)) {\n\t\t\tassert(ehooks_are_default(ehooks));\n\t\t\tsan_unguard_pages_two_sided(tsdn, ehooks, edata,\n\t\t\t pac->emap);\n\t\t}\n\t\t/*\n\t\t * Deregister first to avoid a race with other allocating\n\t\t * threads, and reregister if deallocation fails.\n\t\t */\n\t\textent_deregister(tsdn, pac, edata);\n\t\tif (!extent_dalloc_wrapper_try(tsdn, pac, ehooks, edata)) {\n\t\t\treturn;\n\t\t}\n\t\textent_reregister(tsdn, pac, edata);\n\t}\n\n\t/* Try to decommit; purge if that fails. */\n\tbool zeroed;\n\tif (!edata_committed_get(edata)) {\n\t\tzeroed = true;\n\t} else if (!extent_decommit_wrapper(tsdn, ehooks, edata, 0,\n\t edata_size_get(edata))) {\n\t\tzeroed = true;\n\t} else if (!ehooks_purge_forced(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), 0, edata_size_get(edata))) {\n\t\tzeroed = true;\n\t} else if (edata_state_get(edata) == extent_state_muzzy ||\n\t !ehooks_purge_lazy(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), 0, edata_size_get(edata))) {\n\t\tzeroed = false;\n\t} else {\n\t\tzeroed = false;\n\t}\n\tedata_zeroed_set(edata, zeroed);\n\n\tif (config_prof) {\n\t\textent_gdump_sub(tsdn, edata);\n\t}\n\n\textent_record(tsdn, pac, ehooks, &pac->ecache_retained, edata);\n}\n\nvoid\nextent_destroy_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata) {\n\tassert(edata_base_get(edata) != NULL);\n\tassert(edata_size_get(edata) != 0);\n\textent_state_t state = edata_state_get(edata);\n\tassert(state == extent_state_retained || state == extent_state_active);\n\tassert(emap_edata_is_acquired(tsdn, pac->emap, edata));\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\tif (edata_guarded_get(edata)) {\n\t\tassert(opt_retain);\n\t\tsan_unguard_pages_pre_destroy(tsdn, ehooks, edata, pac->emap);\n\t}\n\tedata_addr_set(edata, edata_base_get(edata));\n\n\t/* Try to destroy; silently fail otherwise. */\n\tehooks_destroy(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), edata_committed_get(edata));\n\n\tedata_cache_put(tsdn, pac->edata_cache, edata);\n}\n\nstatic bool\nextent_commit_impl(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length, bool growing_retained) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\tbool err = ehooks_commit(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), offset, length);\n\tedata_committed_set(edata, edata_committed_get(edata) || !err);\n\treturn err;\n}\n\nbool\nextent_commit_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length) {\n\treturn extent_commit_impl(tsdn, ehooks, edata, offset, length,\n\t /* growing_retained */ false);\n}\n\nbool\nextent_decommit_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tbool err = ehooks_decommit(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), offset, length);\n\tedata_committed_set(edata, edata_committed_get(edata) && err);\n\treturn err;\n}\n\nstatic bool\nextent_purge_lazy_impl(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length, bool growing_retained) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\tbool err = ehooks_purge_lazy(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), offset, length);\n\treturn err;\n}\n\nbool\nextent_purge_lazy_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length) {\n\treturn extent_purge_lazy_impl(tsdn, ehooks, edata, offset,\n\t length, false);\n}\n\nstatic bool\nextent_purge_forced_impl(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length, bool growing_retained) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\tbool err = ehooks_purge_forced(tsdn, ehooks, edata_base_get(edata),\n\t edata_size_get(edata), offset, length);\n\treturn err;\n}\n\nbool\nextent_purge_forced_wrapper(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n size_t offset, size_t length) {\n\treturn extent_purge_forced_impl(tsdn, ehooks, edata, offset, length,\n\t false);\n}\n\n/*\n * Accepts the extent to split, and the characteristics of each side of the\n * split. The 'a' parameters go with the 'lead' of the resulting pair of\n * extents (the lower addressed portion of the split), and the 'b' parameters go\n * with the trail (the higher addressed portion). This makes 'extent' the lead,\n * and returns the trail (except in case of error).\n */\nstatic edata_t *\nextent_split_impl(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *edata, size_t size_a, size_t size_b, bool holding_core_locks) {\n\tassert(edata_size_get(edata) == size_a + size_b);\n\t/* Only the shrink path may split w/o holding core locks. */\n\tif (holding_core_locks) {\n\t\twitness_assert_positive_depth_to_rank(\n\t\t tsdn_witness_tsdp_get(tsdn), WITNESS_RANK_CORE);\n\t} else {\n\t\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t\t WITNESS_RANK_CORE, 0);\n\t}\n\n\tif (ehooks_split_will_fail(ehooks)) {\n\t\treturn NULL;\n\t}\n\n\tedata_t *trail = edata_cache_get(tsdn, pac->edata_cache);\n\tif (trail == NULL) {\n\t\tgoto label_error_a;\n\t}\n\n\tedata_init(trail, edata_arena_ind_get(edata),\n\t (void *)((uintptr_t)edata_base_get(edata) + size_a), size_b,\n\t /* slab */ false, SC_NSIZES, edata_sn_get(edata),\n\t edata_state_get(edata), edata_zeroed_get(edata),\n\t edata_committed_get(edata), EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\temap_prepare_t prepare;\n\tbool err = emap_split_prepare(tsdn, pac->emap, &prepare, edata,\n\t size_a, trail, size_b);\n\tif (err) {\n\t\tgoto label_error_b;\n\t}\n\n\t/*\n\t * No need to acquire trail or edata, because: 1) trail was new (just\n\t * allocated); and 2) edata is either an active allocation (the shrink\n\t * path), or in an acquired state (extracted from the ecache on the\n\t * extent_recycle_split path).\n\t */\n\tassert(emap_edata_is_acquired(tsdn, pac->emap, edata));\n\tassert(emap_edata_is_acquired(tsdn, pac->emap, trail));\n\n\terr = ehooks_split(tsdn, ehooks, edata_base_get(edata), size_a + size_b,\n\t size_a, size_b, edata_committed_get(edata));\n\n\tif (err) {\n\t\tgoto label_error_b;\n\t}\n\n\tedata_size_set(edata, size_a);\n\temap_split_commit(tsdn, pac->emap, &prepare, edata, size_a, trail,\n\t size_b);\n\n\treturn trail;\nlabel_error_b:\n\tedata_cache_put(tsdn, pac->edata_cache, trail);\nlabel_error_a:\n\treturn NULL;\n}\n\nedata_t *\nextent_split_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, edata_t *edata,\n size_t size_a, size_t size_b, bool holding_core_locks) {\n\treturn extent_split_impl(tsdn, pac, ehooks, edata, size_a, size_b,\n\t holding_core_locks);\n}\n\nstatic bool\nextent_merge_impl(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, edata_t *a,\n edata_t *b, bool holding_core_locks) {\n\t/* Only the expanding path may merge w/o holding ecache locks. */\n\tif (holding_core_locks) {\n\t\twitness_assert_positive_depth_to_rank(\n\t\t tsdn_witness_tsdp_get(tsdn), WITNESS_RANK_CORE);\n\t} else {\n\t\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t\t WITNESS_RANK_CORE, 0);\n\t}\n\n\tassert(edata_base_get(a) < edata_base_get(b));\n\tassert(edata_arena_ind_get(a) == edata_arena_ind_get(b));\n\tassert(edata_arena_ind_get(a) == ehooks_ind_get(ehooks));\n\temap_assert_mapped(tsdn, pac->emap, a);\n\temap_assert_mapped(tsdn, pac->emap, b);\n\n\tbool err = ehooks_merge(tsdn, ehooks, edata_base_get(a),\n\t edata_size_get(a), edata_base_get(b), edata_size_get(b),\n\t edata_committed_get(a));\n\n\tif (err) {\n\t\treturn true;\n\t}\n\n\t/*\n\t * The rtree writes must happen while all the relevant elements are\n\t * owned, so the following code uses decomposed helper functions rather\n\t * than extent_{,de}register() to do things in the right order.\n\t */\n\temap_prepare_t prepare;\n\temap_merge_prepare(tsdn, pac->emap, &prepare, a, b);\n\n\tassert(edata_state_get(a) == extent_state_active ||\n\t edata_state_get(a) == extent_state_merging);\n\tedata_state_set(a, extent_state_active);\n\tedata_size_set(a, edata_size_get(a) + edata_size_get(b));\n\tedata_sn_set(a, (edata_sn_get(a) < edata_sn_get(b)) ?\n\t edata_sn_get(a) : edata_sn_get(b));\n\tedata_zeroed_set(a, edata_zeroed_get(a) && edata_zeroed_get(b));\n\n\temap_merge_commit(tsdn, pac->emap, &prepare, a, b);\n\n\tedata_cache_put(tsdn, pac->edata_cache, b);\n\n\treturn false;\n}\n\nbool\nextent_merge_wrapper(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks,\n edata_t *a, edata_t *b) {\n\treturn extent_merge_impl(tsdn, pac, ehooks, a, b,\n\t /* holding_core_locks */ false);\n}\n\nbool\nextent_commit_zero(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n bool commit, bool zero, bool growing_retained) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, growing_retained ? 1 : 0);\n\n\tif (commit && !edata_committed_get(edata)) {\n\t\tif (extent_commit_impl(tsdn, ehooks, edata, 0,\n\t\t edata_size_get(edata), growing_retained)) {\n\t\t\treturn true;\n\t\t}\n\t}\n\tif (zero && !edata_zeroed_get(edata)) {\n\t\tvoid *addr = edata_base_get(edata);\n\t\tsize_t size = edata_size_get(edata);\n\t\tehooks_zero(tsdn, ehooks, addr, size);\n\t}\n\treturn false;\n}\n\nbool\nextent_boot(void) {\n\tassert(sizeof(slab_data_t) >= sizeof(e_prof_info_t));\n\n\tif (have_dss) {\n\t\textent_dss_boot();\n\t}\n\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/extent_dss.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/spin.h\"\n\n/******************************************************************************/\n/* Data. */\n\nconst char\t*opt_dss = DSS_DEFAULT;\n\nconst char\t*dss_prec_names[] = {\n\t\"disabled\",\n\t\"primary\",\n\t\"secondary\",\n\t\"N/A\"\n};\n\n/*\n * Current dss precedence default, used when creating new arenas. NB: This is\n * stored as unsigned rather than dss_prec_t because in principle there's no\n * guarantee that sizeof(dss_prec_t) is the same as sizeof(unsigned), and we use\n * atomic operations to synchronize the setting.\n */\nstatic atomic_u_t\tdss_prec_default = ATOMIC_INIT(\n (unsigned)DSS_PREC_DEFAULT);\n\n/* Base address of the DSS. */\nstatic void\t\t*dss_base;\n/* Atomic boolean indicating whether a thread is currently extending DSS. */\nstatic atomic_b_t\tdss_extending;\n/* Atomic boolean indicating whether the DSS is exhausted. */\nstatic atomic_b_t\tdss_exhausted;\n/* Atomic current upper limit on DSS addresses. */\nstatic atomic_p_t\tdss_max;\n\n/******************************************************************************/\n\nstatic void *\nextent_dss_sbrk(intptr_t increment) {\n#ifdef JEMALLOC_DSS\n\treturn sbrk(increment);\n#else\n\tnot_implemented();\n\treturn NULL;\n#endif\n}\n\ndss_prec_t\nextent_dss_prec_get(void) {\n\tdss_prec_t ret;\n\n\tif (!have_dss) {\n\t\treturn dss_prec_disabled;\n\t}\n\tret = (dss_prec_t)atomic_load_u(&dss_prec_default, ATOMIC_ACQUIRE);\n\treturn ret;\n}\n\nbool\nextent_dss_prec_set(dss_prec_t dss_prec) {\n\tif (!have_dss) {\n\t\treturn (dss_prec != dss_prec_disabled);\n\t}\n\tatomic_store_u(&dss_prec_default, (unsigned)dss_prec, ATOMIC_RELEASE);\n\treturn false;\n}\n\nstatic void\nextent_dss_extending_start(void) {\n\tspin_t spinner = SPIN_INITIALIZER;\n\twhile (true) {\n\t\tbool expected = false;\n\t\tif (atomic_compare_exchange_weak_b(&dss_extending, &expected,\n\t\t true, ATOMIC_ACQ_REL, ATOMIC_RELAXED)) {\n\t\t\tbreak;\n\t\t}\n\t\tspin_adaptive(&spinner);\n\t}\n}\n\nstatic void\nextent_dss_extending_finish(void) {\n\tassert(atomic_load_b(&dss_extending, ATOMIC_RELAXED));\n\n\tatomic_store_b(&dss_extending, false, ATOMIC_RELEASE);\n}\n\nstatic void *\nextent_dss_max_update(void *new_addr) {\n\t/*\n\t * Get the current end of the DSS as max_cur and assure that dss_max is\n\t * up to date.\n\t */\n\tvoid *max_cur = extent_dss_sbrk(0);\n\tif (max_cur == (void *)-1) {\n\t\treturn NULL;\n\t}\n\tatomic_store_p(&dss_max, max_cur, ATOMIC_RELEASE);\n\t/* Fixed new_addr can only be supported if it is at the edge of DSS. */\n\tif (new_addr != NULL && max_cur != new_addr) {\n\t\treturn NULL;\n\t}\n\treturn max_cur;\n}\n\nvoid *\nextent_alloc_dss(tsdn_t *tsdn, arena_t *arena, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit) {\n\tedata_t *gap;\n\n\tcassert(have_dss);\n\tassert(size > 0);\n\tassert(alignment == ALIGNMENT_CEILING(alignment, PAGE));\n\n\t/*\n\t * sbrk() uses a signed increment argument, so take care not to\n\t * interpret a large allocation request as a negative increment.\n\t */\n\tif ((intptr_t)size < 0) {\n\t\treturn NULL;\n\t}\n\n\tgap = edata_cache_get(tsdn, &arena->pa_shard.edata_cache);\n\tif (gap == NULL) {\n\t\treturn NULL;\n\t}\n\n\textent_dss_extending_start();\n\tif (!atomic_load_b(&dss_exhausted, ATOMIC_ACQUIRE)) {\n\t\t/*\n\t\t * The loop is necessary to recover from races with other\n\t\t * threads that are using the DSS for something other than\n\t\t * malloc.\n\t\t */\n\t\twhile (true) {\n\t\t\tvoid *max_cur = extent_dss_max_update(new_addr);\n\t\t\tif (max_cur == NULL) {\n\t\t\t\tgoto label_oom;\n\t\t\t}\n\n\t\t\tbool head_state = opt_retain ? EXTENT_IS_HEAD :\n\t\t\t EXTENT_NOT_HEAD;\n\t\t\t/*\n\t\t\t * Compute how much page-aligned gap space (if any) is\n\t\t\t * necessary to satisfy alignment. This space can be\n\t\t\t * recycled for later use.\n\t\t\t */\n\t\t\tvoid *gap_addr_page = (void *)(PAGE_CEILING(\n\t\t\t (uintptr_t)max_cur));\n\t\t\tvoid *ret = (void *)ALIGNMENT_CEILING(\n\t\t\t (uintptr_t)gap_addr_page, alignment);\n\t\t\tsize_t gap_size_page = (uintptr_t)ret -\n\t\t\t (uintptr_t)gap_addr_page;\n\t\t\tif (gap_size_page != 0) {\n\t\t\t\tedata_init(gap, arena_ind_get(arena),\n\t\t\t\t gap_addr_page, gap_size_page, false,\n\t\t\t\t SC_NSIZES, extent_sn_next(\n\t\t\t\t\t&arena->pa_shard.pac),\n\t\t\t\t extent_state_active, false, true,\n\t\t\t\t EXTENT_PAI_PAC, head_state);\n\t\t\t}\n\t\t\t/*\n\t\t\t * Compute the address just past the end of the desired\n\t\t\t * allocation space.\n\t\t\t */\n\t\t\tvoid *dss_next = (void *)((uintptr_t)ret + size);\n\t\t\tif ((uintptr_t)ret < (uintptr_t)max_cur ||\n\t\t\t (uintptr_t)dss_next < (uintptr_t)max_cur) {\n\t\t\t\tgoto label_oom; /* Wrap-around. */\n\t\t\t}\n\t\t\t/* Compute the increment, including subpage bytes. */\n\t\t\tvoid *gap_addr_subpage = max_cur;\n\t\t\tsize_t gap_size_subpage = (uintptr_t)ret -\n\t\t\t (uintptr_t)gap_addr_subpage;\n\t\t\tintptr_t incr = gap_size_subpage + size;\n\n\t\t\tassert((uintptr_t)max_cur + incr == (uintptr_t)ret +\n\t\t\t size);\n\n\t\t\t/* Try to allocate. */\n\t\t\tvoid *dss_prev = extent_dss_sbrk(incr);\n\t\t\tif (dss_prev == max_cur) {\n\t\t\t\t/* Success. */\n\t\t\t\tatomic_store_p(&dss_max, dss_next,\n\t\t\t\t ATOMIC_RELEASE);\n\t\t\t\textent_dss_extending_finish();\n\n\t\t\t\tif (gap_size_page != 0) {\n\t\t\t\t\tehooks_t *ehooks = arena_get_ehooks(\n\t\t\t\t\t arena);\n\t\t\t\t\textent_dalloc_gap(tsdn,\n\t\t\t\t\t &arena->pa_shard.pac, ehooks, gap);\n\t\t\t\t} else {\n\t\t\t\t\tedata_cache_put(tsdn,\n\t\t\t\t\t &arena->pa_shard.edata_cache, gap);\n\t\t\t\t}\n\t\t\t\tif (!*commit) {\n\t\t\t\t\t*commit = pages_decommit(ret, size);\n\t\t\t\t}\n\t\t\t\tif (*zero && *commit) {\n\t\t\t\t\tedata_t edata = {0};\n\t\t\t\t\tehooks_t *ehooks = arena_get_ehooks(\n\t\t\t\t\t arena);\n\n\t\t\t\t\tedata_init(&edata,\n\t\t\t\t\t arena_ind_get(arena), ret, size,\n\t\t\t\t\t size, false, SC_NSIZES,\n\t\t\t\t\t extent_state_active, false, true,\n\t\t\t\t\t EXTENT_PAI_PAC, head_state);\n\t\t\t\t\tif (extent_purge_forced_wrapper(tsdn,\n\t\t\t\t\t ehooks, &edata, 0, size)) {\n\t\t\t\t\t\tmemset(ret, 0, size);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t\t/*\n\t\t\t * Failure, whether due to OOM or a race with a raw\n\t\t\t * sbrk() call from outside the allocator.\n\t\t\t */\n\t\t\tif (dss_prev == (void *)-1) {\n\t\t\t\t/* OOM. */\n\t\t\t\tatomic_store_b(&dss_exhausted, true,\n\t\t\t\t ATOMIC_RELEASE);\n\t\t\t\tgoto label_oom;\n\t\t\t}\n\t\t}\n\t}\nlabel_oom:\n\textent_dss_extending_finish();\n\tedata_cache_put(tsdn, &arena->pa_shard.edata_cache, gap);\n\treturn NULL;\n}\n\nstatic bool\nextent_in_dss_helper(void *addr, void *max) {\n\treturn ((uintptr_t)addr >= (uintptr_t)dss_base && (uintptr_t)addr <\n\t (uintptr_t)max);\n}\n\nbool\nextent_in_dss(void *addr) {\n\tcassert(have_dss);\n\n\treturn extent_in_dss_helper(addr, atomic_load_p(&dss_max,\n\t ATOMIC_ACQUIRE));\n}\n\nbool\nextent_dss_mergeable(void *addr_a, void *addr_b) {\n\tvoid *max;\n\n\tcassert(have_dss);\n\n\tif ((uintptr_t)addr_a < (uintptr_t)dss_base && (uintptr_t)addr_b <\n\t (uintptr_t)dss_base) {\n\t\treturn true;\n\t}\n\n\tmax = atomic_load_p(&dss_max, ATOMIC_ACQUIRE);\n\treturn (extent_in_dss_helper(addr_a, max) ==\n\t extent_in_dss_helper(addr_b, max));\n}\n\nvoid\nextent_dss_boot(void) {\n\tcassert(have_dss);\n\n\tdss_base = extent_dss_sbrk(0);\n\tatomic_store_b(&dss_extending, false, ATOMIC_RELAXED);\n\tatomic_store_b(&dss_exhausted, dss_base == (void *)-1, ATOMIC_RELAXED);\n\tatomic_store_p(&dss_max, dss_base, ATOMIC_RELAXED);\n}\n\n/******************************************************************************/\n" }, { "path": "deps/jemalloc/src/extent_mmap.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n\n/******************************************************************************/\n/* Data. */\n\nbool\topt_retain =\n#ifdef JEMALLOC_RETAIN\n true\n#else\n false\n#endif\n ;\n\n/******************************************************************************/\n\nvoid *\nextent_alloc_mmap(void *new_addr, size_t size, size_t alignment, bool *zero,\n bool *commit) {\n\tassert(alignment == ALIGNMENT_CEILING(alignment, PAGE));\n\tvoid *ret = pages_map(new_addr, size, alignment, commit);\n\tif (ret == NULL) {\n\t\treturn NULL;\n\t}\n\tassert(ret != NULL);\n\tif (*commit) {\n\t\t*zero = true;\n\t}\n\treturn ret;\n}\n\nbool\nextent_dalloc_mmap(void *addr, size_t size) {\n\tif (!opt_retain) {\n\t\tpages_unmap(addr, size);\n\t}\n\treturn opt_retain;\n}\n" }, { "path": "deps/jemalloc/src/fxp.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/fxp.h\"\n\nstatic bool\nfxp_isdigit(char c) {\n\treturn '0' <= c && c <= '9';\n}\n\nbool\nfxp_parse(fxp_t *result, const char *str, char **end) {\n\t/*\n\t * Using malloc_strtoumax in this method isn't as handy as you might\n\t * expect (I tried). In the fractional part, significant leading zeros\n\t * mean that you still need to do your own parsing, now with trickier\n\t * math. In the integer part, the casting (uintmax_t to uint32_t)\n\t * forces more reasoning about bounds than just checking for overflow as\n\t * we parse.\n\t */\n\tuint32_t integer_part = 0;\n\n\tconst char *cur = str;\n\n\t/* The string must start with a digit or a decimal point. */\n\tif (*cur != '.' && !fxp_isdigit(*cur)) {\n\t\treturn true;\n\t}\n\n\twhile ('0' <= *cur && *cur <= '9') {\n\t\tinteger_part *= 10;\n\t\tinteger_part += *cur - '0';\n\t\tif (integer_part >= (1U << 16)) {\n\t\t\treturn true;\n\t\t}\n\t\tcur++;\n\t}\n\n\t/*\n\t * We've parsed all digits at the beginning of the string, without\n\t * overflow. Either we're done, or there's a fractional part.\n\t */\n\tif (*cur != '.') {\n\t\t*result = (integer_part << 16);\n\t\tif (end != NULL) {\n\t\t\t*end = (char *)cur;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/* There's a fractional part. */\n\tcur++;\n\tif (!fxp_isdigit(*cur)) {\n\t\t/* Shouldn't end on the decimal point. */\n\t\treturn true;\n\t}\n\n\t/*\n\t * We use a lot of precision for the fractional part, even though we'll\n\t * discard most of it; this lets us get exact values for the important\n\t * special case where the denominator is a small power of 2 (for\n\t * instance, 1/512 == 0.001953125 is exactly representable even with\n\t * only 16 bits of fractional precision). We need to left-shift by 16\n\t * before dividing so we pick the number of digits to be\n\t * floor(log(2**48)) = 14.\n\t */\n\tuint64_t fractional_part = 0;\n\tuint64_t frac_div = 1;\n\tfor (int i = 0; i < FXP_FRACTIONAL_PART_DIGITS; i++) {\n\t\tfractional_part *= 10;\n\t\tfrac_div *= 10;\n\t\tif (fxp_isdigit(*cur)) {\n\t\t\tfractional_part += *cur - '0';\n\t\t\tcur++;\n\t\t}\n\t}\n\t/*\n\t * We only parse the first maxdigits characters, but we can still ignore\n\t * any digits after that.\n\t */\n\twhile (fxp_isdigit(*cur)) {\n\t\tcur++;\n\t}\n\n\tassert(fractional_part < frac_div);\n\tuint32_t fractional_repr = (uint32_t)(\n\t (fractional_part << 16) / frac_div);\n\n\t/* Success! */\n\t*result = (integer_part << 16) + fractional_repr;\n\tif (end != NULL) {\n\t\t*end = (char *)cur;\n\t}\n\treturn false;\n}\n\nvoid\nfxp_print(fxp_t a, char buf[FXP_BUF_SIZE]) {\n\tuint32_t integer_part = fxp_round_down(a);\n\tuint32_t fractional_part = (a & ((1U << 16) - 1));\n\n\tint leading_fraction_zeros = 0;\n\tuint64_t fraction_digits = fractional_part;\n\tfor (int i = 0; i < FXP_FRACTIONAL_PART_DIGITS; i++) {\n\t\tif (fraction_digits < (1U << 16)\n\t\t && fraction_digits * 10 >= (1U << 16)) {\n\t\t\tleading_fraction_zeros = i;\n\t\t}\n\t\tfraction_digits *= 10;\n\t}\n\tfraction_digits >>= 16;\n\twhile (fraction_digits > 0 && fraction_digits % 10 == 0) {\n\t\tfraction_digits /= 10;\n\t}\n\n\tsize_t printed = malloc_snprintf(buf, FXP_BUF_SIZE, \"%\"FMTu32\".\",\n\t integer_part);\n\tfor (int i = 0; i < leading_fraction_zeros; i++) {\n\t\tbuf[printed] = '0';\n\t\tprinted++;\n\t}\n\tmalloc_snprintf(&buf[printed], FXP_BUF_SIZE - printed, \"%\"FMTu64,\n\t fraction_digits);\n}\n" }, { "path": "deps/jemalloc/src/hook.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n#include \"jemalloc/internal/hook.h\"\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/seq.h\"\n\ntypedef struct hooks_internal_s hooks_internal_t;\nstruct hooks_internal_s {\n\thooks_t hooks;\n\tbool in_use;\n};\n\nseq_define(hooks_internal_t, hooks)\n\nstatic atomic_u_t nhooks = ATOMIC_INIT(0);\nstatic seq_hooks_t hooks[HOOK_MAX];\nstatic malloc_mutex_t hooks_mu;\n\nbool\nhook_boot() {\n\treturn malloc_mutex_init(&hooks_mu, \"hooks\", WITNESS_RANK_HOOK,\n\t malloc_mutex_rank_exclusive);\n}\n\nstatic void *\nhook_install_locked(hooks_t *to_install) {\n\thooks_internal_t hooks_internal;\n\tfor (int i = 0; i < HOOK_MAX; i++) {\n\t\tbool success = seq_try_load_hooks(&hooks_internal, &hooks[i]);\n\t\t/* We hold mu; no concurrent access. */\n\t\tassert(success);\n\t\tif (!hooks_internal.in_use) {\n\t\t\thooks_internal.hooks = *to_install;\n\t\t\thooks_internal.in_use = true;\n\t\t\tseq_store_hooks(&hooks[i], &hooks_internal);\n\t\t\tatomic_store_u(&nhooks,\n\t\t\t atomic_load_u(&nhooks, ATOMIC_RELAXED) + 1,\n\t\t\t ATOMIC_RELAXED);\n\t\t\treturn &hooks[i];\n\t\t}\n\t}\n\treturn NULL;\n}\n\nvoid *\nhook_install(tsdn_t *tsdn, hooks_t *to_install) {\n\tmalloc_mutex_lock(tsdn, &hooks_mu);\n\tvoid *ret = hook_install_locked(to_install);\n\tif (ret != NULL) {\n\t\ttsd_global_slow_inc(tsdn);\n\t}\n\tmalloc_mutex_unlock(tsdn, &hooks_mu);\n\treturn ret;\n}\n\nstatic void\nhook_remove_locked(seq_hooks_t *to_remove) {\n\thooks_internal_t hooks_internal;\n\tbool success = seq_try_load_hooks(&hooks_internal, to_remove);\n\t/* We hold mu; no concurrent access. */\n\tassert(success);\n\t/* Should only remove hooks that were added. */\n\tassert(hooks_internal.in_use);\n\thooks_internal.in_use = false;\n\tseq_store_hooks(to_remove, &hooks_internal);\n\tatomic_store_u(&nhooks, atomic_load_u(&nhooks, ATOMIC_RELAXED) - 1,\n\t ATOMIC_RELAXED);\n}\n\nvoid\nhook_remove(tsdn_t *tsdn, void *opaque) {\n\tif (config_debug) {\n\t\tchar *hooks_begin = (char *)&hooks[0];\n\t\tchar *hooks_end = (char *)&hooks[HOOK_MAX];\n\t\tchar *hook = (char *)opaque;\n\t\tassert(hooks_begin <= hook && hook < hooks_end\n\t\t && (hook - hooks_begin) % sizeof(seq_hooks_t) == 0);\n\t}\n\tmalloc_mutex_lock(tsdn, &hooks_mu);\n\thook_remove_locked((seq_hooks_t *)opaque);\n\ttsd_global_slow_dec(tsdn);\n\tmalloc_mutex_unlock(tsdn, &hooks_mu);\n}\n\n#define FOR_EACH_HOOK_BEGIN(hooks_internal_ptr)\t\t\t\t\\\nfor (int for_each_hook_counter = 0;\t\t\t\t\t\\\n for_each_hook_counter < HOOK_MAX;\t\t\t\t\t\\\n for_each_hook_counter++) {\t\t\t\t\t\t\\\n\tbool for_each_hook_success = seq_try_load_hooks(\t\t\\\n\t (hooks_internal_ptr), &hooks[for_each_hook_counter]);\t\\\n\tif (!for_each_hook_success) {\t\t\t\t\t\\\n\t\tcontinue;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tif (!(hooks_internal_ptr)->in_use) {\t\t\t\t\\\n\t\tcontinue;\t\t\t\t\t\t\\\n\t}\n#define FOR_EACH_HOOK_END\t\t\t\t\t\t\\\n}\n\nstatic bool *\nhook_reentrantp() {\n\t/*\n\t * We prevent user reentrancy within hooks. This is basically just a\n\t * thread-local bool that triggers an early-exit.\n\t *\n\t * We don't fold in_hook into reentrancy. There are two reasons for\n\t * this:\n\t * - Right now, we turn on reentrancy during things like extent hook\n\t * execution. Allocating during extent hooks is not officially\n\t * supported, but we don't want to break it for the time being. These\n\t * sorts of allocations should probably still be hooked, though.\n\t * - If a hook allocates, we may want it to be relatively fast (after\n\t * all, it executes on every allocator operation). Turning on\n\t * reentrancy is a fairly heavyweight mode (disabling tcache,\n\t * redirecting to arena 0, etc.). It's possible we may one day want\n\t * to turn on reentrant mode here, if it proves too difficult to keep\n\t * this working. But that's fairly easy for us to see; OTOH, people\n\t * not using hooks because they're too slow is easy for us to miss.\n\t *\n\t * The tricky part is\n\t * that this code might get invoked even if we don't have access to tsd.\n\t * This function mimics getting a pointer to thread-local data, except\n\t * that it might secretly return a pointer to some global data if we\n\t * know that the caller will take the early-exit path.\n\t * If we return a bool that indicates that we are reentrant, then the\n\t * caller will go down the early exit path, leaving the global\n\t * untouched.\n\t */\n\tstatic bool in_hook_global = true;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tbool *in_hook = tsdn_in_hookp_get(tsdn);\n\tif (in_hook!= NULL) {\n\t\treturn in_hook;\n\t}\n\treturn &in_hook_global;\n}\n\n#define HOOK_PROLOGUE\t\t\t\t\t\t\t\\\n\tif (likely(atomic_load_u(&nhooks, ATOMIC_RELAXED) == 0)) {\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tbool *in_hook = hook_reentrantp();\t\t\t\t\\\n\tif (*in_hook) {\t\t\t\t\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t*in_hook = true;\n\n#define HOOK_EPILOGUE\t\t\t\t\t\t\t\\\n\t*in_hook = false;\n\nvoid\nhook_invoke_alloc(hook_alloc_t type, void *result, uintptr_t result_raw,\n uintptr_t args_raw[3]) {\n\tHOOK_PROLOGUE\n\n\thooks_internal_t hook;\n\tFOR_EACH_HOOK_BEGIN(&hook)\n\t\thook_alloc h = hook.hooks.alloc_hook;\n\t\tif (h != NULL) {\n\t\t\th(hook.hooks.extra, type, result, result_raw, args_raw);\n\t\t}\n\tFOR_EACH_HOOK_END\n\n\tHOOK_EPILOGUE\n}\n\nvoid\nhook_invoke_dalloc(hook_dalloc_t type, void *address, uintptr_t args_raw[3]) {\n\tHOOK_PROLOGUE\n\thooks_internal_t hook;\n\tFOR_EACH_HOOK_BEGIN(&hook)\n\t\thook_dalloc h = hook.hooks.dalloc_hook;\n\t\tif (h != NULL) {\n\t\t\th(hook.hooks.extra, type, address, args_raw);\n\t\t}\n\tFOR_EACH_HOOK_END\n\tHOOK_EPILOGUE\n}\n\nvoid\nhook_invoke_expand(hook_expand_t type, void *address, size_t old_usize,\n size_t new_usize, uintptr_t result_raw, uintptr_t args_raw[4]) {\n\tHOOK_PROLOGUE\n\thooks_internal_t hook;\n\tFOR_EACH_HOOK_BEGIN(&hook)\n\t\thook_expand h = hook.hooks.expand_hook;\n\t\tif (h != NULL) {\n\t\t\th(hook.hooks.extra, type, address, old_usize, new_usize,\n\t\t\t result_raw, args_raw);\n\t\t}\n\tFOR_EACH_HOOK_END\n\tHOOK_EPILOGUE\n}\n" }, { "path": "deps/jemalloc/src/hpa.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/hpa.h\"\n\n#include \"jemalloc/internal/fb.h\"\n#include \"jemalloc/internal/witness.h\"\n\n#define HPA_EDEN_SIZE (128 * HUGEPAGE)\n\nstatic edata_t *hpa_alloc(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t alignment, bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated);\nstatic size_t hpa_alloc_batch(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t nallocs, edata_list_active_t *results, bool *deferred_work_generated);\nstatic bool hpa_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool zero, bool *deferred_work_generated);\nstatic bool hpa_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool *deferred_work_generated);\nstatic void hpa_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated);\nstatic void hpa_dalloc_batch(tsdn_t *tsdn, pai_t *self,\n edata_list_active_t *list, bool *deferred_work_generated);\nstatic uint64_t hpa_time_until_deferred_work(tsdn_t *tsdn, pai_t *self);\n\nbool\nhpa_supported() {\n#ifdef _WIN32\n\t/*\n\t * At least until the API and implementation is somewhat settled, we\n\t * don't want to try to debug the VM subsystem on the hardest-to-test\n\t * platform.\n\t */\n\treturn false;\n#endif\n\tif (!pages_can_hugify) {\n\t\treturn false;\n\t}\n\t/*\n\t * We fundamentally rely on a address-space-hungry growth strategy for\n\t * hugepages.\n\t */\n\tif (LG_SIZEOF_PTR != 3) {\n\t\treturn false;\n\t}\n\t/*\n\t * If we couldn't detect the value of HUGEPAGE, HUGEPAGE_PAGES becomes\n\t * this sentinel value -- see the comment in pages.h.\n\t */\n\tif (HUGEPAGE_PAGES == 1) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nstatic void\nhpa_do_consistency_checks(hpa_shard_t *shard) {\n\tassert(shard->base != NULL);\n}\n\nbool\nhpa_central_init(hpa_central_t *central, base_t *base, const hpa_hooks_t *hooks) {\n\t/* malloc_conf processing should have filtered out these cases. */\n\tassert(hpa_supported());\n\tbool err;\n\terr = malloc_mutex_init(¢ral->grow_mtx, \"hpa_central_grow\",\n\t WITNESS_RANK_HPA_CENTRAL_GROW, malloc_mutex_rank_exclusive);\n\tif (err) {\n\t\treturn true;\n\t}\n\terr = malloc_mutex_init(¢ral->mtx, \"hpa_central\",\n\t WITNESS_RANK_HPA_CENTRAL, malloc_mutex_rank_exclusive);\n\tif (err) {\n\t\treturn true;\n\t}\n\tcentral->base = base;\n\tcentral->eden = NULL;\n\tcentral->eden_len = 0;\n\tcentral->age_counter = 0;\n\tcentral->hooks = *hooks;\n\treturn false;\n}\n\nstatic hpdata_t *\nhpa_alloc_ps(tsdn_t *tsdn, hpa_central_t *central) {\n\treturn (hpdata_t *)base_alloc(tsdn, central->base, sizeof(hpdata_t),\n\t CACHELINE);\n}\n\nhpdata_t *\nhpa_central_extract(tsdn_t *tsdn, hpa_central_t *central, size_t size,\n bool *oom) {\n\t/* Don't yet support big allocations; these should get filtered out. */\n\tassert(size <= HUGEPAGE);\n\t/*\n\t * Should only try to extract from the central allocator if the local\n\t * shard is exhausted. We should hold the grow_mtx on that shard.\n\t */\n\twitness_assert_positive_depth_to_rank(\n\t tsdn_witness_tsdp_get(tsdn), WITNESS_RANK_HPA_SHARD_GROW);\n\n\tmalloc_mutex_lock(tsdn, ¢ral->grow_mtx);\n\t*oom = false;\n\n\thpdata_t *ps = NULL;\n\n\t/* Is eden a perfect fit? */\n\tif (central->eden != NULL && central->eden_len == HUGEPAGE) {\n\t\tps = hpa_alloc_ps(tsdn, central);\n\t\tif (ps == NULL) {\n\t\t\t*oom = true;\n\t\t\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\t\t\treturn NULL;\n\t\t}\n\t\thpdata_init(ps, central->eden, central->age_counter++);\n\t\tcentral->eden = NULL;\n\t\tcentral->eden_len = 0;\n\t\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\t\treturn ps;\n\t}\n\n\t/*\n\t * We're about to try to allocate from eden by splitting. If eden is\n\t * NULL, we have to allocate it too. Otherwise, we just have to\n\t * allocate an edata_t for the new psset.\n\t */\n\tif (central->eden == NULL) {\n\t\t/*\n\t\t * During development, we're primarily concerned with systems\n\t\t * with overcommit. Eventually, we should be more careful here.\n\t\t */\n\t\tbool commit = true;\n\t\t/* Allocate address space, bailing if we fail. */\n\t\tvoid *new_eden = pages_map(NULL, HPA_EDEN_SIZE, HUGEPAGE,\n\t\t &commit);\n\t\tif (new_eden == NULL) {\n\t\t\t*oom = true;\n\t\t\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\t\t\treturn NULL;\n\t\t}\n\t\tps = hpa_alloc_ps(tsdn, central);\n\t\tif (ps == NULL) {\n\t\t\tpages_unmap(new_eden, HPA_EDEN_SIZE);\n\t\t\t*oom = true;\n\t\t\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\t\t\treturn NULL;\n\t\t}\n\t\tcentral->eden = new_eden;\n\t\tcentral->eden_len = HPA_EDEN_SIZE;\n\t} else {\n\t\t/* Eden is already nonempty; only need an edata for ps. */\n\t\tps = hpa_alloc_ps(tsdn, central);\n\t\tif (ps == NULL) {\n\t\t\t*oom = true;\n\t\t\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\t\t\treturn NULL;\n\t\t}\n\t}\n\tassert(ps != NULL);\n\tassert(central->eden != NULL);\n\tassert(central->eden_len > HUGEPAGE);\n\tassert(central->eden_len % HUGEPAGE == 0);\n\tassert(HUGEPAGE_ADDR2BASE(central->eden) == central->eden);\n\n\thpdata_init(ps, central->eden, central->age_counter++);\n\n\tchar *eden_char = (char *)central->eden;\n\teden_char += HUGEPAGE;\n\tcentral->eden = (void *)eden_char;\n\tcentral->eden_len -= HUGEPAGE;\n\n\tmalloc_mutex_unlock(tsdn, ¢ral->grow_mtx);\n\n\treturn ps;\n}\n\nbool\nhpa_shard_init(hpa_shard_t *shard, hpa_central_t *central, emap_t *emap,\n base_t *base, edata_cache_t *edata_cache, unsigned ind,\n const hpa_shard_opts_t *opts) {\n\t/* malloc_conf processing should have filtered out these cases. */\n\tassert(hpa_supported());\n\tbool err;\n\terr = malloc_mutex_init(&shard->grow_mtx, \"hpa_shard_grow\",\n\t WITNESS_RANK_HPA_SHARD_GROW, malloc_mutex_rank_exclusive);\n\tif (err) {\n\t\treturn true;\n\t}\n\terr = malloc_mutex_init(&shard->mtx, \"hpa_shard\",\n\t WITNESS_RANK_HPA_SHARD, malloc_mutex_rank_exclusive);\n\tif (err) {\n\t\treturn true;\n\t}\n\n\tassert(edata_cache != NULL);\n\tshard->central = central;\n\tshard->base = base;\n\tedata_cache_fast_init(&shard->ecf, edata_cache);\n\tpsset_init(&shard->psset);\n\tshard->age_counter = 0;\n\tshard->ind = ind;\n\tshard->emap = emap;\n\n\tshard->opts = *opts;\n\n\tshard->npending_purge = 0;\n\tnstime_init_zero(&shard->last_purge);\n\n\tshard->stats.npurge_passes = 0;\n\tshard->stats.npurges = 0;\n\tshard->stats.nhugifies = 0;\n\tshard->stats.ndehugifies = 0;\n\n\t/*\n\t * Fill these in last, so that if an hpa_shard gets used despite\n\t * initialization failing, we'll at least crash instead of just\n\t * operating on corrupted data.\n\t */\n\tshard->pai.alloc = &hpa_alloc;\n\tshard->pai.alloc_batch = &hpa_alloc_batch;\n\tshard->pai.expand = &hpa_expand;\n\tshard->pai.shrink = &hpa_shrink;\n\tshard->pai.dalloc = &hpa_dalloc;\n\tshard->pai.dalloc_batch = &hpa_dalloc_batch;\n\tshard->pai.time_until_deferred_work = &hpa_time_until_deferred_work;\n\n\thpa_do_consistency_checks(shard);\n\n\treturn false;\n}\n\n/*\n * Note that the stats functions here follow the usual stats naming conventions;\n * \"merge\" obtains the stats from some live object of instance, while \"accum\"\n * only combines the stats from one stats objet to another. Hence the lack of\n * locking here.\n */\nstatic void\nhpa_shard_nonderived_stats_accum(hpa_shard_nonderived_stats_t *dst,\n hpa_shard_nonderived_stats_t *src) {\n\tdst->npurge_passes += src->npurge_passes;\n\tdst->npurges += src->npurges;\n\tdst->nhugifies += src->nhugifies;\n\tdst->ndehugifies += src->ndehugifies;\n}\n\nvoid\nhpa_shard_stats_accum(hpa_shard_stats_t *dst, hpa_shard_stats_t *src) {\n\tpsset_stats_accum(&dst->psset_stats, &src->psset_stats);\n\thpa_shard_nonderived_stats_accum(&dst->nonderived_stats,\n\t &src->nonderived_stats);\n}\n\nvoid\nhpa_shard_stats_merge(tsdn_t *tsdn, hpa_shard_t *shard,\n hpa_shard_stats_t *dst) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_lock(tsdn, &shard->grow_mtx);\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tpsset_stats_accum(&dst->psset_stats, &shard->psset.stats);\n\thpa_shard_nonderived_stats_accum(&dst->nonderived_stats, &shard->stats);\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\tmalloc_mutex_unlock(tsdn, &shard->grow_mtx);\n}\n\nstatic bool\nhpa_good_hugification_candidate(hpa_shard_t *shard, hpdata_t *ps) {\n\t/*\n\t * Note that this needs to be >= rather than just >, because of the\n\t * important special case in which the hugification threshold is exactly\n\t * HUGEPAGE.\n\t */\n\treturn hpdata_nactive_get(ps) * PAGE\n\t >= shard->opts.hugification_threshold;\n}\n\nstatic size_t\nhpa_adjusted_ndirty(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\treturn psset_ndirty(&shard->psset) - shard->npending_purge;\n}\n\nstatic size_t\nhpa_ndirty_max(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tif (shard->opts.dirty_mult == (fxp_t)-1) {\n\t\treturn (size_t)-1;\n\t}\n\treturn fxp_mul_frac(psset_nactive(&shard->psset),\n\t shard->opts.dirty_mult);\n}\n\nstatic bool\nhpa_hugify_blocked_by_ndirty(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\thpdata_t *to_hugify = psset_pick_hugify(&shard->psset);\n\tif (to_hugify == NULL) {\n\t\treturn false;\n\t}\n\treturn hpa_adjusted_ndirty(tsdn, shard)\n\t + hpdata_nretained_get(to_hugify) > hpa_ndirty_max(tsdn, shard);\n}\n\nstatic bool\nhpa_should_purge(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tif (hpa_adjusted_ndirty(tsdn, shard) > hpa_ndirty_max(tsdn, shard)) {\n\t\treturn true;\n\t}\n\tif (hpa_hugify_blocked_by_ndirty(tsdn, shard)) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\nstatic void\nhpa_update_purge_hugify_eligibility(tsdn_t *tsdn, hpa_shard_t *shard,\n hpdata_t *ps) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tif (hpdata_changing_state_get(ps)) {\n\t\thpdata_purge_allowed_set(ps, false);\n\t\thpdata_disallow_hugify(ps);\n\t\treturn;\n\t}\n\t/*\n\t * Hugepages are distinctly costly to purge, so try to avoid it unless\n\t * they're *particularly* full of dirty pages. Eventually, we should\n\t * use a smarter / more dynamic heuristic for situations where we have\n\t * to manually hugify.\n\t *\n\t * In situations where we don't manually hugify, this problem is\n\t * reduced. The \"bad\" situation we're trying to avoid is one's that's\n\t * common in some Linux configurations (where both enabled and defrag\n\t * are set to madvise) that can lead to long latency spikes on the first\n\t * access after a hugification. The ideal policy in such configurations\n\t * is probably time-based for both purging and hugifying; only hugify a\n\t * hugepage if it's met the criteria for some extended period of time,\n\t * and only dehugify it if it's failed to meet the criteria for an\n\t * extended period of time. When background threads are on, we should\n\t * try to take this hit on one of them, as well.\n\t *\n\t * I think the ideal setting is THP always enabled, and defrag set to\n\t * deferred; in that case we don't need any explicit calls on the\n\t * allocator's end at all; we just try to pack allocations in a\n\t * hugepage-friendly manner and let the OS hugify in the background.\n\t */\n\thpdata_purge_allowed_set(ps, hpdata_ndirty_get(ps) > 0);\n\tif (hpa_good_hugification_candidate(shard, ps)\n\t && !hpdata_huge_get(ps)) {\n\t\tnstime_t now;\n\t\tshard->central->hooks.curtime(&now, /* first_reading */ true);\n\t\thpdata_allow_hugify(ps, now);\n\t}\n\t/*\n\t * Once a hugepage has become eligible for hugification, we don't mark\n\t * it as ineligible just because it stops meeting the criteria (this\n\t * could lead to situations where a hugepage that spends most of its\n\t * time meeting the criteria never quite getting hugified if there are\n\t * intervening deallocations). The idea is that the hugification delay\n\t * will allow them to get purged, reseting their \"hugify-allowed\" bit.\n\t * If they don't get purged, then the hugification isn't hurting and\n\t * might help. As an exception, we don't hugify hugepages that are now\n\t * empty; it definitely doesn't help there until the hugepage gets\n\t * reused, which is likely not for a while.\n\t */\n\tif (hpdata_nactive_get(ps) == 0) {\n\t\thpdata_disallow_hugify(ps);\n\t}\n}\n\nstatic bool\nhpa_shard_has_deferred_work(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\thpdata_t *to_hugify = psset_pick_hugify(&shard->psset);\n\treturn to_hugify != NULL || hpa_should_purge(tsdn, shard);\n}\n\n/* Returns whether or not we purged anything. */\nstatic bool\nhpa_try_purge(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\n\thpdata_t *to_purge = psset_pick_purge(&shard->psset);\n\tif (to_purge == NULL) {\n\t\treturn false;\n\t}\n\tassert(hpdata_purge_allowed_get(to_purge));\n\tassert(!hpdata_changing_state_get(to_purge));\n\n\t/*\n\t * Don't let anyone else purge or hugify this page while\n\t * we're purging it (allocations and deallocations are\n\t * OK).\n\t */\n\tpsset_update_begin(&shard->psset, to_purge);\n\tassert(hpdata_alloc_allowed_get(to_purge));\n\thpdata_mid_purge_set(to_purge, true);\n\thpdata_purge_allowed_set(to_purge, false);\n\thpdata_disallow_hugify(to_purge);\n\t/*\n\t * Unlike with hugification (where concurrent\n\t * allocations are allowed), concurrent allocation out\n\t * of a hugepage being purged is unsafe; we might hand\n\t * out an extent for an allocation and then purge it\n\t * (clearing out user data).\n\t */\n\thpdata_alloc_allowed_set(to_purge, false);\n\tpsset_update_end(&shard->psset, to_purge);\n\n\t/* Gather all the metadata we'll need during the purge. */\n\tbool dehugify = hpdata_huge_get(to_purge);\n\thpdata_purge_state_t purge_state;\n\tsize_t num_to_purge = hpdata_purge_begin(to_purge, &purge_state);\n\n\tshard->npending_purge += num_to_purge;\n\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\n\t/* Actually do the purging, now that the lock is dropped. */\n\tif (dehugify) {\n\t\tshard->central->hooks.dehugify(hpdata_addr_get(to_purge),\n\t\t HUGEPAGE);\n\t}\n\tsize_t total_purged = 0;\n\tuint64_t purges_this_pass = 0;\n\tvoid *purge_addr;\n\tsize_t purge_size;\n\twhile (hpdata_purge_next(to_purge, &purge_state, &purge_addr,\n\t &purge_size)) {\n\t\ttotal_purged += purge_size;\n\t\tassert(total_purged <= HUGEPAGE);\n\t\tpurges_this_pass++;\n\t\tshard->central->hooks.purge(purge_addr, purge_size);\n\t}\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\t/* The shard updates */\n\tshard->npending_purge -= num_to_purge;\n\tshard->stats.npurge_passes++;\n\tshard->stats.npurges += purges_this_pass;\n\tshard->central->hooks.curtime(&shard->last_purge,\n\t /* first_reading */ false);\n\tif (dehugify) {\n\t\tshard->stats.ndehugifies++;\n\t}\n\n\t/* The hpdata updates. */\n\tpsset_update_begin(&shard->psset, to_purge);\n\tif (dehugify) {\n\t\thpdata_dehugify(to_purge);\n\t}\n\thpdata_purge_end(to_purge, &purge_state);\n\thpdata_mid_purge_set(to_purge, false);\n\n\thpdata_alloc_allowed_set(to_purge, true);\n\thpa_update_purge_hugify_eligibility(tsdn, shard, to_purge);\n\n\tpsset_update_end(&shard->psset, to_purge);\n\n\treturn true;\n}\n\n/* Returns whether or not we hugified anything. */\nstatic bool\nhpa_try_hugify(tsdn_t *tsdn, hpa_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\n\tif (hpa_hugify_blocked_by_ndirty(tsdn, shard)) {\n\t\treturn false;\n\t}\n\n\thpdata_t *to_hugify = psset_pick_hugify(&shard->psset);\n\tif (to_hugify == NULL) {\n\t\treturn false;\n\t}\n\tassert(hpdata_hugify_allowed_get(to_hugify));\n\tassert(!hpdata_changing_state_get(to_hugify));\n\n\t/* Make sure that it's been hugifiable for long enough. */\n\tnstime_t time_hugify_allowed = hpdata_time_hugify_allowed(to_hugify);\n\tuint64_t millis = shard->central->hooks.ms_since(&time_hugify_allowed);\n\tif (millis < shard->opts.hugify_delay_ms) {\n\t\treturn false;\n\t}\n\n\t/*\n\t * Don't let anyone else purge or hugify this page while\n\t * we're hugifying it (allocations and deallocations are\n\t * OK).\n\t */\n\tpsset_update_begin(&shard->psset, to_hugify);\n\thpdata_mid_hugify_set(to_hugify, true);\n\thpdata_purge_allowed_set(to_hugify, false);\n\thpdata_disallow_hugify(to_hugify);\n\tassert(hpdata_alloc_allowed_get(to_hugify));\n\tpsset_update_end(&shard->psset, to_hugify);\n\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\n\tshard->central->hooks.hugify(hpdata_addr_get(to_hugify), HUGEPAGE);\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tshard->stats.nhugifies++;\n\n\tpsset_update_begin(&shard->psset, to_hugify);\n\thpdata_hugify(to_hugify);\n\thpdata_mid_hugify_set(to_hugify, false);\n\thpa_update_purge_hugify_eligibility(tsdn, shard, to_hugify);\n\tpsset_update_end(&shard->psset, to_hugify);\n\n\treturn true;\n}\n\n/*\n * Execution of deferred work is forced if it's triggered by an explicit\n * hpa_shard_do_deferred_work() call.\n */\nstatic void\nhpa_shard_maybe_do_deferred_work(tsdn_t *tsdn, hpa_shard_t *shard,\n bool forced) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tif (!forced && shard->opts.deferral_allowed) {\n\t\treturn;\n\t}\n\t/*\n\t * If we're on a background thread, do work so long as there's work to\n\t * be done. Otherwise, bound latency to not be *too* bad by doing at\n\t * most a small fixed number of operations.\n\t */\n\tbool hugified = false;\n\tbool purged = false;\n\tsize_t max_ops = (forced ? (size_t)-1 : 16);\n\tsize_t nops = 0;\n\tdo {\n\t\t/*\n\t\t * Always purge before hugifying, to make sure we get some\n\t\t * ability to hit our quiescence targets.\n\t\t */\n\t\tpurged = false;\n\t\twhile (hpa_should_purge(tsdn, shard) && nops < max_ops) {\n\t\t\tpurged = hpa_try_purge(tsdn, shard);\n\t\t\tif (purged) {\n\t\t\t\tnops++;\n\t\t\t}\n\t\t}\n\t\thugified = hpa_try_hugify(tsdn, shard);\n\t\tif (hugified) {\n\t\t\tnops++;\n\t\t}\n\t\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\t\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\t} while ((hugified || purged) && nops < max_ops);\n}\n\nstatic edata_t *\nhpa_try_alloc_one_no_grow(tsdn_t *tsdn, hpa_shard_t *shard, size_t size,\n bool *oom) {\n\tbool err;\n\tedata_t *edata = edata_cache_fast_get(tsdn, &shard->ecf);\n\tif (edata == NULL) {\n\t\t*oom = true;\n\t\treturn NULL;\n\t}\n\n\thpdata_t *ps = psset_pick_alloc(&shard->psset, size);\n\tif (ps == NULL) {\n\t\tedata_cache_fast_put(tsdn, &shard->ecf, edata);\n\t\treturn NULL;\n\t}\n\n\tpsset_update_begin(&shard->psset, ps);\n\n\tif (hpdata_empty(ps)) {\n\t\t/*\n\t\t * If the pageslab used to be empty, treat it as though it's\n\t\t * brand new for fragmentation-avoidance purposes; what we're\n\t\t * trying to approximate is the age of the allocations *in* that\n\t\t * pageslab, and the allocations in the new pageslab are\n\t\t * definitionally the youngest in this hpa shard.\n\t\t */\n\t\thpdata_age_set(ps, shard->age_counter++);\n\t}\n\n\tvoid *addr = hpdata_reserve_alloc(ps, size);\n\tedata_init(edata, shard->ind, addr, size, /* slab */ false,\n\t SC_NSIZES, /* sn */ hpdata_age_get(ps), extent_state_active,\n\t /* zeroed */ false, /* committed */ true, EXTENT_PAI_HPA,\n\t EXTENT_NOT_HEAD);\n\tedata_ps_set(edata, ps);\n\n\t/*\n\t * This could theoretically be moved outside of the critical section,\n\t * but that introduces the potential for a race. Without the lock, the\n\t * (initially nonempty, since this is the reuse pathway) pageslab we\n\t * allocated out of could become otherwise empty while the lock is\n\t * dropped. This would force us to deal with a pageslab eviction down\n\t * the error pathway, which is a pain.\n\t */\n\terr = emap_register_boundary(tsdn, shard->emap, edata,\n\t SC_NSIZES, /* slab */ false);\n\tif (err) {\n\t\thpdata_unreserve(ps, edata_addr_get(edata),\n\t\t edata_size_get(edata));\n\t\t/*\n\t\t * We should arguably reset dirty state here, but this would\n\t\t * require some sort of prepare + commit functionality that's a\n\t\t * little much to deal with for now.\n\t\t *\n\t\t * We don't have a do_deferred_work down this pathway, on the\n\t\t * principle that we didn't *really* affect shard state (we\n\t\t * tweaked the stats, but our tweaks weren't really accurate).\n\t\t */\n\t\tpsset_update_end(&shard->psset, ps);\n\t\tedata_cache_fast_put(tsdn, &shard->ecf, edata);\n\t\t*oom = true;\n\t\treturn NULL;\n\t}\n\n\thpa_update_purge_hugify_eligibility(tsdn, shard, ps);\n\tpsset_update_end(&shard->psset, ps);\n\treturn edata;\n}\n\nstatic size_t\nhpa_try_alloc_batch_no_grow(tsdn_t *tsdn, hpa_shard_t *shard, size_t size,\n bool *oom, size_t nallocs, edata_list_active_t *results,\n bool *deferred_work_generated) {\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tsize_t nsuccess = 0;\n\tfor (; nsuccess < nallocs; nsuccess++) {\n\t\tedata_t *edata = hpa_try_alloc_one_no_grow(tsdn, shard, size,\n\t\t oom);\n\t\tif (edata == NULL) {\n\t\t\tbreak;\n\t\t}\n\t\tedata_list_active_append(results, edata);\n\t}\n\n\thpa_shard_maybe_do_deferred_work(tsdn, shard, /* forced */ false);\n\t*deferred_work_generated = hpa_shard_has_deferred_work(tsdn, shard);\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\treturn nsuccess;\n}\n\nstatic size_t\nhpa_alloc_batch_psset(tsdn_t *tsdn, hpa_shard_t *shard, size_t size,\n size_t nallocs, edata_list_active_t *results,\n bool *deferred_work_generated) {\n\tassert(size <= shard->opts.slab_max_alloc);\n\tbool oom = false;\n\n\tsize_t nsuccess = hpa_try_alloc_batch_no_grow(tsdn, shard, size, &oom,\n\t nallocs, results, deferred_work_generated);\n\n\tif (nsuccess == nallocs || oom) {\n\t\treturn nsuccess;\n\t}\n\n\t/*\n\t * We didn't OOM, but weren't able to fill everything requested of us;\n\t * try to grow.\n\t */\n\tmalloc_mutex_lock(tsdn, &shard->grow_mtx);\n\t/*\n\t * Check for grow races; maybe some earlier thread expanded the psset\n\t * in between when we dropped the main mutex and grabbed the grow mutex.\n\t */\n\tnsuccess += hpa_try_alloc_batch_no_grow(tsdn, shard, size, &oom,\n\t nallocs - nsuccess, results, deferred_work_generated);\n\tif (nsuccess == nallocs || oom) {\n\t\tmalloc_mutex_unlock(tsdn, &shard->grow_mtx);\n\t\treturn nsuccess;\n\t}\n\n\t/*\n\t * Note that we don't hold shard->mtx here (while growing);\n\t * deallocations (and allocations of smaller sizes) may still succeed\n\t * while we're doing this potentially expensive system call.\n\t */\n\thpdata_t *ps = hpa_central_extract(tsdn, shard->central, size, &oom);\n\tif (ps == NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &shard->grow_mtx);\n\t\treturn nsuccess;\n\t}\n\n\t/*\n\t * We got the pageslab; allocate from it. This does an unlock followed\n\t * by a lock on the same mutex, and holds the grow mutex while doing\n\t * deferred work, but this is an uncommon path; the simplicity is worth\n\t * it.\n\t */\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tpsset_insert(&shard->psset, ps);\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\n\tnsuccess += hpa_try_alloc_batch_no_grow(tsdn, shard, size, &oom,\n\t nallocs - nsuccess, results, deferred_work_generated);\n\t/*\n\t * Drop grow_mtx before doing deferred work; other threads blocked on it\n\t * should be allowed to proceed while we're working.\n\t */\n\tmalloc_mutex_unlock(tsdn, &shard->grow_mtx);\n\n\treturn nsuccess;\n}\n\nstatic hpa_shard_t *\nhpa_from_pai(pai_t *self) {\n\tassert(self->alloc = &hpa_alloc);\n\tassert(self->expand = &hpa_expand);\n\tassert(self->shrink = &hpa_shrink);\n\tassert(self->dalloc = &hpa_dalloc);\n\treturn (hpa_shard_t *)self;\n}\n\nstatic size_t\nhpa_alloc_batch(tsdn_t *tsdn, pai_t *self, size_t size, size_t nallocs,\n edata_list_active_t *results, bool *deferred_work_generated) {\n\tassert(nallocs > 0);\n\tassert((size & PAGE_MASK) == 0);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\thpa_shard_t *shard = hpa_from_pai(self);\n\n\tif (size > shard->opts.slab_max_alloc) {\n\t\treturn 0;\n\t}\n\n\tsize_t nsuccess = hpa_alloc_batch_psset(tsdn, shard, size, nallocs,\n\t results, deferred_work_generated);\n\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\t/*\n\t * Guard the sanity checks with config_debug because the loop cannot be\n\t * proven non-circular by the compiler, even if everything within the\n\t * loop is optimized away.\n\t */\n\tif (config_debug) {\n\t\tedata_t *edata;\n\t\tql_foreach(edata, &results->head, ql_link_active) {\n\t\t\temap_assert_mapped(tsdn, shard->emap, edata);\n\t\t\tassert(edata_pai_get(edata) == EXTENT_PAI_HPA);\n\t\t\tassert(edata_state_get(edata) == extent_state_active);\n\t\t\tassert(edata_arena_ind_get(edata) == shard->ind);\n\t\t\tassert(edata_szind_get_maybe_invalid(edata) ==\n\t\t\t SC_NSIZES);\n\t\t\tassert(!edata_slab_get(edata));\n\t\t\tassert(edata_committed_get(edata));\n\t\t\tassert(edata_base_get(edata) == edata_addr_get(edata));\n\t\t\tassert(edata_base_get(edata) != NULL);\n\t\t}\n\t}\n\treturn nsuccess;\n}\n\nstatic edata_t *\nhpa_alloc(tsdn_t *tsdn, pai_t *self, size_t size, size_t alignment, bool zero,\n bool guarded, bool frequent_reuse, bool *deferred_work_generated) {\n\tassert((size & PAGE_MASK) == 0);\n\tassert(!guarded);\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\n\t/* We don't handle alignment or zeroing for now. */\n\tif (alignment > PAGE || zero) {\n\t\treturn NULL;\n\t}\n\t/*\n\t * An alloc with alignment == PAGE and zero == false is equivalent to a\n\t * batch alloc of 1. Just do that, so we can share code.\n\t */\n\tedata_list_active_t results;\n\tedata_list_active_init(&results);\n\tsize_t nallocs = hpa_alloc_batch(tsdn, self, size, /* nallocs */ 1,\n\t &results, deferred_work_generated);\n\tassert(nallocs == 0 || nallocs == 1);\n\tedata_t *edata = edata_list_active_first(&results);\n\treturn edata;\n}\n\nstatic bool\nhpa_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool zero, bool *deferred_work_generated) {\n\t/* Expand not yet supported. */\n\treturn true;\n}\n\nstatic bool\nhpa_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool *deferred_work_generated) {\n\t/* Shrink not yet supported. */\n\treturn true;\n}\n\nstatic void\nhpa_dalloc_prepare_unlocked(tsdn_t *tsdn, hpa_shard_t *shard, edata_t *edata) {\n\tmalloc_mutex_assert_not_owner(tsdn, &shard->mtx);\n\n\tassert(edata_pai_get(edata) == EXTENT_PAI_HPA);\n\tassert(edata_state_get(edata) == extent_state_active);\n\tassert(edata_arena_ind_get(edata) == shard->ind);\n\tassert(edata_szind_get_maybe_invalid(edata) == SC_NSIZES);\n\tassert(edata_committed_get(edata));\n\tassert(edata_base_get(edata) != NULL);\n\n\t/*\n\t * Another thread shouldn't be trying to touch the metadata of an\n\t * allocation being freed. The one exception is a merge attempt from a\n\t * lower-addressed PAC extent; in this case we have a nominal race on\n\t * the edata metadata bits, but in practice the fact that the PAI bits\n\t * are different will prevent any further access. The race is bad, but\n\t * benign in practice, and the long term plan is to track enough state\n\t * in the rtree to prevent these merge attempts in the first place.\n\t */\n\tedata_addr_set(edata, edata_base_get(edata));\n\tedata_zeroed_set(edata, false);\n\temap_deregister_boundary(tsdn, shard->emap, edata);\n}\n\nstatic void\nhpa_dalloc_locked(tsdn_t *tsdn, hpa_shard_t *shard, edata_t *edata) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\n\t/*\n\t * Release the metadata early, to avoid having to remember to do it\n\t * while we're also doing tricky purging logic. First, we need to grab\n\t * a few bits of metadata from it.\n\t *\n\t * Note that the shard mutex protects ps's metadata too; it wouldn't be\n\t * correct to try to read most information out of it without the lock.\n\t */\n\thpdata_t *ps = edata_ps_get(edata);\n\t/* Currently, all edatas come from pageslabs. */\n\tassert(ps != NULL);\n\tvoid *unreserve_addr = edata_addr_get(edata);\n\tsize_t unreserve_size = edata_size_get(edata);\n\tedata_cache_fast_put(tsdn, &shard->ecf, edata);\n\n\tpsset_update_begin(&shard->psset, ps);\n\thpdata_unreserve(ps, unreserve_addr, unreserve_size);\n\thpa_update_purge_hugify_eligibility(tsdn, shard, ps);\n\tpsset_update_end(&shard->psset, ps);\n}\n\nstatic void\nhpa_dalloc_batch(tsdn_t *tsdn, pai_t *self, edata_list_active_t *list,\n bool *deferred_work_generated) {\n\thpa_shard_t *shard = hpa_from_pai(self);\n\n\tedata_t *edata;\n\tql_foreach(edata, &list->head, ql_link_active) {\n\t\thpa_dalloc_prepare_unlocked(tsdn, shard, edata);\n\t}\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\t/* Now, remove from the list. */\n\twhile ((edata = edata_list_active_first(list)) != NULL) {\n\t\tedata_list_active_remove(list, edata);\n\t\thpa_dalloc_locked(tsdn, shard, edata);\n\t}\n\thpa_shard_maybe_do_deferred_work(tsdn, shard, /* forced */ false);\n\t*deferred_work_generated =\n\t hpa_shard_has_deferred_work(tsdn, shard);\n\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n}\n\nstatic void\nhpa_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated) {\n\tassert(!edata_guarded_get(edata));\n\t/* Just a dalloc_batch of size 1; this lets us share logic. */\n\tedata_list_active_t dalloc_list;\n\tedata_list_active_init(&dalloc_list);\n\tedata_list_active_append(&dalloc_list, edata);\n\thpa_dalloc_batch(tsdn, self, &dalloc_list, deferred_work_generated);\n}\n\n/*\n * Calculate time until either purging or hugification ought to happen.\n * Called by background threads.\n */\nstatic uint64_t\nhpa_time_until_deferred_work(tsdn_t *tsdn, pai_t *self) {\n\thpa_shard_t *shard = hpa_from_pai(self);\n\tuint64_t time_ns = BACKGROUND_THREAD_DEFERRED_MAX;\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\n\thpdata_t *to_hugify = psset_pick_hugify(&shard->psset);\n\tif (to_hugify != NULL) {\n\t\tnstime_t time_hugify_allowed =\n\t\t hpdata_time_hugify_allowed(to_hugify);\n\t\tuint64_t since_hugify_allowed_ms =\n\t\t shard->central->hooks.ms_since(&time_hugify_allowed);\n\t\t/*\n\t\t * If not enough time has passed since hugification was allowed,\n\t\t * sleep for the rest.\n\t\t */\n\t\tif (since_hugify_allowed_ms < shard->opts.hugify_delay_ms) {\n\t\t\ttime_ns = shard->opts.hugify_delay_ms -\n\t\t\t since_hugify_allowed_ms;\n\t\t\ttime_ns *= 1000 * 1000;\n\t\t} else {\n\t\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t\t\treturn BACKGROUND_THREAD_DEFERRED_MIN;\n\t\t}\n\t}\n\n\tif (hpa_should_purge(tsdn, shard)) {\n\t\t/*\n\t\t * If we haven't purged before, no need to check interval\n\t\t * between purges. Simply purge as soon as possible.\n\t\t */\n\t\tif (shard->stats.npurge_passes == 0) {\n\t\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t\t\treturn BACKGROUND_THREAD_DEFERRED_MIN;\n\t\t}\n\t\tuint64_t since_last_purge_ms = shard->central->hooks.ms_since(\n\t\t &shard->last_purge);\n\n\t\tif (since_last_purge_ms < shard->opts.min_purge_interval_ms) {\n\t\t\tuint64_t until_purge_ns;\n\t\t\tuntil_purge_ns = shard->opts.min_purge_interval_ms -\n\t\t\t since_last_purge_ms;\n\t\t\tuntil_purge_ns *= 1000 * 1000;\n\n\t\t\tif (until_purge_ns < time_ns) {\n\t\t\t\ttime_ns = until_purge_ns;\n\t\t\t}\n\t\t} else {\n\t\t\ttime_ns = BACKGROUND_THREAD_DEFERRED_MIN;\n\t\t}\n\t}\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\treturn time_ns;\n}\n\nvoid\nhpa_shard_disable(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tedata_cache_fast_disable(tsdn, &shard->ecf);\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n}\n\nstatic void\nhpa_shard_assert_stats_empty(psset_bin_stats_t *bin_stats) {\n\tassert(bin_stats->npageslabs == 0);\n\tassert(bin_stats->nactive == 0);\n}\n\nstatic void\nhpa_assert_empty(tsdn_t *tsdn, hpa_shard_t *shard, psset_t *psset) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tfor (int huge = 0; huge <= 1; huge++) {\n\t\thpa_shard_assert_stats_empty(&psset->stats.full_slabs[huge]);\n\t\tfor (pszind_t i = 0; i < PSSET_NPSIZES; i++) {\n\t\t\thpa_shard_assert_stats_empty(\n\t\t\t &psset->stats.nonfull_slabs[i][huge]);\n\t\t}\n\t}\n}\n\nvoid\nhpa_shard_destroy(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\t/*\n\t * By the time we're here, the arena code should have dalloc'd all the\n\t * active extents, which means we should have eventually evicted\n\t * everything from the psset, so it shouldn't be able to serve even a\n\t * 1-page allocation.\n\t */\n\tif (config_debug) {\n\t\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\t\thpa_assert_empty(tsdn, shard, &shard->psset);\n\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t}\n\thpdata_t *ps;\n\twhile ((ps = psset_pick_alloc(&shard->psset, PAGE)) != NULL) {\n\t\t/* There should be no allocations anywhere. */\n\t\tassert(hpdata_empty(ps));\n\t\tpsset_remove(&shard->psset, ps);\n\t\tshard->central->hooks.unmap(hpdata_addr_get(ps), HUGEPAGE);\n\t}\n}\n\nvoid\nhpa_shard_set_deferral_allowed(tsdn_t *tsdn, hpa_shard_t *shard,\n bool deferral_allowed) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tbool deferral_previously_allowed = shard->opts.deferral_allowed;\n\tshard->opts.deferral_allowed = deferral_allowed;\n\tif (deferral_previously_allowed && !deferral_allowed) {\n\t\thpa_shard_maybe_do_deferred_work(tsdn, shard,\n\t\t /* forced */ true);\n\t}\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n}\n\nvoid\nhpa_shard_do_deferred_work(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\thpa_shard_maybe_do_deferred_work(tsdn, shard, /* forced */ true);\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n}\n\nvoid\nhpa_shard_prefork3(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_prefork(tsdn, &shard->grow_mtx);\n}\n\nvoid\nhpa_shard_prefork4(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_prefork(tsdn, &shard->mtx);\n}\n\nvoid\nhpa_shard_postfork_parent(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_postfork_parent(tsdn, &shard->grow_mtx);\n\tmalloc_mutex_postfork_parent(tsdn, &shard->mtx);\n}\n\nvoid\nhpa_shard_postfork_child(tsdn_t *tsdn, hpa_shard_t *shard) {\n\thpa_do_consistency_checks(shard);\n\n\tmalloc_mutex_postfork_child(tsdn, &shard->grow_mtx);\n\tmalloc_mutex_postfork_child(tsdn, &shard->mtx);\n}\n" }, { "path": "deps/jemalloc/src/hpa_hooks.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/hpa_hooks.h\"\n\nstatic void *hpa_hooks_map(size_t size);\nstatic void hpa_hooks_unmap(void *ptr, size_t size);\nstatic void hpa_hooks_purge(void *ptr, size_t size);\nstatic void hpa_hooks_hugify(void *ptr, size_t size);\nstatic void hpa_hooks_dehugify(void *ptr, size_t size);\nstatic void hpa_hooks_curtime(nstime_t *r_nstime, bool first_reading);\nstatic uint64_t hpa_hooks_ms_since(nstime_t *past_nstime);\n\nhpa_hooks_t hpa_hooks_default = {\n\t&hpa_hooks_map,\n\t&hpa_hooks_unmap,\n\t&hpa_hooks_purge,\n\t&hpa_hooks_hugify,\n\t&hpa_hooks_dehugify,\n\t&hpa_hooks_curtime,\n\t&hpa_hooks_ms_since\n};\n\nstatic void *\nhpa_hooks_map(size_t size) {\n\tbool commit = true;\n\treturn pages_map(NULL, size, HUGEPAGE, &commit);\n}\n\nstatic void\nhpa_hooks_unmap(void *ptr, size_t size) {\n\tpages_unmap(ptr, size);\n}\n\nstatic void\nhpa_hooks_purge(void *ptr, size_t size) {\n\tpages_purge_forced(ptr, size);\n}\n\nstatic void\nhpa_hooks_hugify(void *ptr, size_t size) {\n\tbool err = pages_huge(ptr, size);\n\t(void)err;\n}\n\nstatic void\nhpa_hooks_dehugify(void *ptr, size_t size) {\n\tbool err = pages_nohuge(ptr, size);\n\t(void)err;\n}\n\nstatic void\nhpa_hooks_curtime(nstime_t *r_nstime, bool first_reading) {\n\tif (first_reading) {\n\t\tnstime_init_zero(r_nstime);\n\t}\n\tnstime_update(r_nstime);\n}\n\nstatic uint64_t\nhpa_hooks_ms_since(nstime_t *past_nstime) {\n\treturn nstime_ns_since(past_nstime) / 1000 / 1000;\n}\n" }, { "path": "deps/jemalloc/src/hpdata.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/hpdata.h\"\n\nstatic int\nhpdata_age_comp(const hpdata_t *a, const hpdata_t *b) {\n\tuint64_t a_age = hpdata_age_get(a);\n\tuint64_t b_age = hpdata_age_get(b);\n\t/*\n\t * hpdata ages are operation counts in the psset; no two should be the\n\t * same.\n\t */\n\tassert(a_age != b_age);\n\treturn (a_age > b_age) - (a_age < b_age);\n}\n\nph_gen(, hpdata_age_heap, hpdata_t, age_link, hpdata_age_comp)\n\nvoid\nhpdata_init(hpdata_t *hpdata, void *addr, uint64_t age) {\n\thpdata_addr_set(hpdata, addr);\n\thpdata_age_set(hpdata, age);\n\thpdata->h_huge = false;\n\thpdata->h_alloc_allowed = true;\n\thpdata->h_in_psset_alloc_container = false;\n\thpdata->h_purge_allowed = false;\n\thpdata->h_hugify_allowed = false;\n\thpdata->h_in_psset_hugify_container = false;\n\thpdata->h_mid_purge = false;\n\thpdata->h_mid_hugify = false;\n\thpdata->h_updating = false;\n\thpdata->h_in_psset = false;\n\thpdata_longest_free_range_set(hpdata, HUGEPAGE_PAGES);\n\thpdata->h_nactive = 0;\n\tfb_init(hpdata->active_pages, HUGEPAGE_PAGES);\n\thpdata->h_ntouched = 0;\n\tfb_init(hpdata->touched_pages, HUGEPAGE_PAGES);\n\n\thpdata_assert_consistent(hpdata);\n}\n\nvoid *\nhpdata_reserve_alloc(hpdata_t *hpdata, size_t sz) {\n\thpdata_assert_consistent(hpdata);\n\t/*\n\t * This is a metadata change; the hpdata should therefore either not be\n\t * in the psset, or should have explicitly marked itself as being\n\t * mid-update.\n\t */\n\tassert(!hpdata->h_in_psset || hpdata->h_updating);\n\tassert(hpdata->h_alloc_allowed);\n\tassert((sz & PAGE_MASK) == 0);\n\tsize_t npages = sz >> LG_PAGE;\n\tassert(npages <= hpdata_longest_free_range_get(hpdata));\n\n\tsize_t result;\n\n\tsize_t start = 0;\n\t/*\n\t * These are dead stores, but the compiler will issue warnings on them\n\t * since it can't tell statically that found is always true below.\n\t */\n\tsize_t begin = 0;\n\tsize_t len = 0;\n\n\tsize_t largest_unchosen_range = 0;\n\twhile (true) {\n\t\tbool found = fb_urange_iter(hpdata->active_pages,\n\t\t HUGEPAGE_PAGES, start, &begin, &len);\n\t\t/*\n\t\t * A precondition to this function is that hpdata must be able\n\t\t * to serve the allocation.\n\t\t */\n\t\tassert(found);\n\t\tassert(len <= hpdata_longest_free_range_get(hpdata));\n\t\tif (len >= npages) {\n\t\t\t/*\n\t\t\t * We use first-fit within the page slabs; this gives\n\t\t\t * bounded worst-case fragmentation within a slab. It's\n\t\t\t * not necessarily right; we could experiment with\n\t\t\t * various other options.\n\t\t\t */\n\t\t\tbreak;\n\t\t}\n\t\tif (len > largest_unchosen_range) {\n\t\t\tlargest_unchosen_range = len;\n\t\t}\n\t\tstart = begin + len;\n\t}\n\t/* We found a range; remember it. */\n\tresult = begin;\n\tfb_set_range(hpdata->active_pages, HUGEPAGE_PAGES, begin, npages);\n\thpdata->h_nactive += npages;\n\n\t/*\n\t * We might be about to dirty some memory for the first time; update our\n\t * count if so.\n\t */\n\tsize_t new_dirty = fb_ucount(hpdata->touched_pages, HUGEPAGE_PAGES,\n\t result, npages);\n\tfb_set_range(hpdata->touched_pages, HUGEPAGE_PAGES, result, npages);\n\thpdata->h_ntouched += new_dirty;\n\n\t/*\n\t * If we allocated out of a range that was the longest in the hpdata, it\n\t * might be the only one of that size and we'll have to adjust the\n\t * metadata.\n\t */\n\tif (len == hpdata_longest_free_range_get(hpdata)) {\n\t\tstart = begin + npages;\n\t\twhile (start < HUGEPAGE_PAGES) {\n\t\t\tbool found = fb_urange_iter(hpdata->active_pages,\n\t\t\t HUGEPAGE_PAGES, start, &begin, &len);\n\t\t\tif (!found) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tassert(len <= hpdata_longest_free_range_get(hpdata));\n\t\t\tif (len == hpdata_longest_free_range_get(hpdata)) {\n\t\t\t\tlargest_unchosen_range = len;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (len > largest_unchosen_range) {\n\t\t\t\tlargest_unchosen_range = len;\n\t\t\t}\n\t\t\tstart = begin + len;\n\t\t}\n\t\thpdata_longest_free_range_set(hpdata, largest_unchosen_range);\n\t}\n\n\thpdata_assert_consistent(hpdata);\n\treturn (void *)(\n\t (uintptr_t)hpdata_addr_get(hpdata) + (result << LG_PAGE));\n}\n\nvoid\nhpdata_unreserve(hpdata_t *hpdata, void *addr, size_t sz) {\n\thpdata_assert_consistent(hpdata);\n\t/* See the comment in reserve. */\n\tassert(!hpdata->h_in_psset || hpdata->h_updating);\n\tassert(((uintptr_t)addr & PAGE_MASK) == 0);\n\tassert((sz & PAGE_MASK) == 0);\n\tsize_t begin = ((uintptr_t)addr - (uintptr_t)hpdata_addr_get(hpdata))\n\t >> LG_PAGE;\n\tassert(begin < HUGEPAGE_PAGES);\n\tsize_t npages = sz >> LG_PAGE;\n\tsize_t old_longest_range = hpdata_longest_free_range_get(hpdata);\n\n\tfb_unset_range(hpdata->active_pages, HUGEPAGE_PAGES, begin, npages);\n\t/* We might have just created a new, larger range. */\n\tsize_t new_begin = (fb_fls(hpdata->active_pages, HUGEPAGE_PAGES,\n\t begin) + 1);\n\tsize_t new_end = fb_ffs(hpdata->active_pages, HUGEPAGE_PAGES,\n\t begin + npages - 1);\n\tsize_t new_range_len = new_end - new_begin;\n\n\tif (new_range_len > old_longest_range) {\n\t\thpdata_longest_free_range_set(hpdata, new_range_len);\n\t}\n\n\thpdata->h_nactive -= npages;\n\n\thpdata_assert_consistent(hpdata);\n}\n\nsize_t\nhpdata_purge_begin(hpdata_t *hpdata, hpdata_purge_state_t *purge_state) {\n\thpdata_assert_consistent(hpdata);\n\t/*\n\t * See the comment below; we might purge any inactive extent, so it's\n\t * unsafe for any other thread to turn any inactive extent active while\n\t * we're operating on it.\n\t */\n\tassert(!hpdata_alloc_allowed_get(hpdata));\n\n\tpurge_state->npurged = 0;\n\tpurge_state->next_purge_search_begin = 0;\n\n\t/*\n\t * Initialize to_purge.\n\t *\n\t * It's possible to end up in situations where two dirty extents are\n\t * separated by a retained extent:\n\t * - 1 page allocated.\n\t * - 1 page allocated.\n\t * - 1 pages allocated.\n\t *\n\t * If the middle page is freed and purged, and then the first and third\n\t * pages are freed, and then another purge pass happens, the hpdata\n\t * looks like this:\n\t * - 1 page dirty.\n\t * - 1 page retained.\n\t * - 1 page dirty.\n\t *\n\t * But it's safe to do a single 3-page purge.\n\t *\n\t * We do this by first computing the dirty pages, and then filling in\n\t * any gaps by extending each range in the dirty bitmap to extend until\n\t * the next active page. This purges more pages, but the expensive part\n\t * of purging is the TLB shootdowns, rather than the kernel state\n\t * tracking; doing a little bit more of the latter is fine if it saves\n\t * us from doing some of the former.\n\t */\n\n\t/*\n\t * The dirty pages are those that are touched but not active. Note that\n\t * in a normal-ish case, HUGEPAGE_PAGES is something like 512 and the\n\t * fb_group_t is 64 bits, so this is 64 bytes, spread across 8\n\t * fb_group_ts.\n\t */\n\tfb_group_t dirty_pages[FB_NGROUPS(HUGEPAGE_PAGES)];\n\tfb_init(dirty_pages, HUGEPAGE_PAGES);\n\tfb_bit_not(dirty_pages, hpdata->active_pages, HUGEPAGE_PAGES);\n\tfb_bit_and(dirty_pages, dirty_pages, hpdata->touched_pages,\n\t HUGEPAGE_PAGES);\n\n\tfb_init(purge_state->to_purge, HUGEPAGE_PAGES);\n\tsize_t next_bit = 0;\n\twhile (next_bit < HUGEPAGE_PAGES) {\n\t\tsize_t next_dirty = fb_ffs(dirty_pages, HUGEPAGE_PAGES,\n\t\t next_bit);\n\t\t/* Recall that fb_ffs returns nbits if no set bit is found. */\n\t\tif (next_dirty == HUGEPAGE_PAGES) {\n\t\t\tbreak;\n\t\t}\n\t\tsize_t next_active = fb_ffs(hpdata->active_pages,\n\t\t HUGEPAGE_PAGES, next_dirty);\n\t\t/*\n\t\t * Don't purge past the end of the dirty extent, into retained\n\t\t * pages. This helps the kernel a tiny bit, but honestly it's\n\t\t * mostly helpful for testing (where we tend to write test cases\n\t\t * that think in terms of the dirty ranges).\n\t\t */\n\t\tssize_t last_dirty = fb_fls(dirty_pages, HUGEPAGE_PAGES,\n\t\t next_active - 1);\n\t\tassert(last_dirty >= 0);\n\t\tassert((size_t)last_dirty >= next_dirty);\n\t\tassert((size_t)last_dirty - next_dirty + 1 <= HUGEPAGE_PAGES);\n\n\t\tfb_set_range(purge_state->to_purge, HUGEPAGE_PAGES, next_dirty,\n\t\t last_dirty - next_dirty + 1);\n\t\tnext_bit = next_active + 1;\n\t}\n\n\t/* We should purge, at least, everything dirty. */\n\tsize_t ndirty = hpdata->h_ntouched - hpdata->h_nactive;\n\tpurge_state->ndirty_to_purge = ndirty;\n\tassert(ndirty <= fb_scount(\n\t purge_state->to_purge, HUGEPAGE_PAGES, 0, HUGEPAGE_PAGES));\n\tassert(ndirty == fb_scount(dirty_pages, HUGEPAGE_PAGES, 0,\n\t HUGEPAGE_PAGES));\n\n\thpdata_assert_consistent(hpdata);\n\n\treturn ndirty;\n}\n\nbool\nhpdata_purge_next(hpdata_t *hpdata, hpdata_purge_state_t *purge_state,\n void **r_purge_addr, size_t *r_purge_size) {\n\t/*\n\t * Note that we don't have a consistency check here; we're accessing\n\t * hpdata without synchronization, and therefore have no right to expect\n\t * a consistent state.\n\t */\n\tassert(!hpdata_alloc_allowed_get(hpdata));\n\n\tif (purge_state->next_purge_search_begin == HUGEPAGE_PAGES) {\n\t\treturn false;\n\t}\n\tsize_t purge_begin;\n\tsize_t purge_len;\n\tbool found_range = fb_srange_iter(purge_state->to_purge, HUGEPAGE_PAGES,\n\t purge_state->next_purge_search_begin, &purge_begin, &purge_len);\n\tif (!found_range) {\n\t\treturn false;\n\t}\n\n\t*r_purge_addr = (void *)(\n\t (uintptr_t)hpdata_addr_get(hpdata) + purge_begin * PAGE);\n\t*r_purge_size = purge_len * PAGE;\n\n\tpurge_state->next_purge_search_begin = purge_begin + purge_len;\n\tpurge_state->npurged += purge_len;\n\tassert(purge_state->npurged <= HUGEPAGE_PAGES);\n\n\treturn true;\n}\n\nvoid\nhpdata_purge_end(hpdata_t *hpdata, hpdata_purge_state_t *purge_state) {\n\tassert(!hpdata_alloc_allowed_get(hpdata));\n\thpdata_assert_consistent(hpdata);\n\t/* See the comment in reserve. */\n\tassert(!hpdata->h_in_psset || hpdata->h_updating);\n\n\tassert(purge_state->npurged == fb_scount(purge_state->to_purge,\n\t HUGEPAGE_PAGES, 0, HUGEPAGE_PAGES));\n\tassert(purge_state->npurged >= purge_state->ndirty_to_purge);\n\n\tfb_bit_not(purge_state->to_purge, purge_state->to_purge,\n\t HUGEPAGE_PAGES);\n\tfb_bit_and(hpdata->touched_pages, hpdata->touched_pages,\n\t purge_state->to_purge, HUGEPAGE_PAGES);\n\tassert(hpdata->h_ntouched >= purge_state->ndirty_to_purge);\n\thpdata->h_ntouched -= purge_state->ndirty_to_purge;\n\n\thpdata_assert_consistent(hpdata);\n}\n\nvoid\nhpdata_hugify(hpdata_t *hpdata) {\n\thpdata_assert_consistent(hpdata);\n\thpdata->h_huge = true;\n\tfb_set_range(hpdata->touched_pages, HUGEPAGE_PAGES, 0, HUGEPAGE_PAGES);\n\thpdata->h_ntouched = HUGEPAGE_PAGES;\n\thpdata_assert_consistent(hpdata);\n}\n\nvoid\nhpdata_dehugify(hpdata_t *hpdata) {\n\thpdata_assert_consistent(hpdata);\n\thpdata->h_huge = false;\n\thpdata_assert_consistent(hpdata);\n}\n" }, { "path": "deps/jemalloc/src/inspect.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nvoid\ninspect_extent_util_stats_get(tsdn_t *tsdn, const void *ptr, size_t *nfree,\n size_t *nregs, size_t *size) {\n\tassert(ptr != NULL && nfree != NULL && nregs != NULL && size != NULL);\n\n\tconst edata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tif (unlikely(edata == NULL)) {\n\t\t*nfree = *nregs = *size = 0;\n\t\treturn;\n\t}\n\n\t*size = edata_size_get(edata);\n\tif (!edata_slab_get(edata)) {\n\t\t*nfree = 0;\n\t\t*nregs = 1;\n\t} else {\n\t\t*nfree = edata_nfree_get(edata);\n\t\t*nregs = bin_infos[edata_szind_get(edata)].nregs;\n\t\tassert(*nfree <= *nregs);\n\t\tassert(*nfree * edata_usize_get(edata) <= *size);\n\t}\n}\n\nvoid\ninspect_extent_util_stats_verbose_get(tsdn_t *tsdn, const void *ptr,\n size_t *nfree, size_t *nregs, size_t *size, size_t *bin_nfree,\n size_t *bin_nregs, void **slabcur_addr) {\n\tassert(ptr != NULL && nfree != NULL && nregs != NULL && size != NULL\n\t && bin_nfree != NULL && bin_nregs != NULL && slabcur_addr != NULL);\n\n\tconst edata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\tif (unlikely(edata == NULL)) {\n\t\t*nfree = *nregs = *size = *bin_nfree = *bin_nregs = 0;\n\t\t*slabcur_addr = NULL;\n\t\treturn;\n\t}\n\n\t*size = edata_size_get(edata);\n\tif (!edata_slab_get(edata)) {\n\t\t*nfree = *bin_nfree = *bin_nregs = 0;\n\t\t*nregs = 1;\n\t\t*slabcur_addr = NULL;\n\t\treturn;\n\t}\n\n\t*nfree = edata_nfree_get(edata);\n\tconst szind_t szind = edata_szind_get(edata);\n\t*nregs = bin_infos[szind].nregs;\n\tassert(*nfree <= *nregs);\n\tassert(*nfree * edata_usize_get(edata) <= *size);\n\n\tarena_t *arena = (arena_t *)atomic_load_p(\n\t &arenas[edata_arena_ind_get(edata)], ATOMIC_RELAXED);\n\tassert(arena != NULL);\n\tconst unsigned binshard = edata_binshard_get(edata);\n\tbin_t *bin = arena_get_bin(arena, szind, binshard);\n\n\tmalloc_mutex_lock(tsdn, &bin->lock);\n\tif (config_stats) {\n\t\t*bin_nregs = *nregs * bin->stats.curslabs;\n\t\tassert(*bin_nregs >= bin->stats.curregs);\n\t\t*bin_nfree = *bin_nregs - bin->stats.curregs;\n\t} else {\n\t\t*bin_nfree = *bin_nregs = 0;\n\t}\n\tedata_t *slab;\n\tif (bin->slabcur != NULL) {\n\t\tslab = bin->slabcur;\n\t} else {\n\t\tslab = edata_heap_first(&bin->slabs_nonfull);\n\t}\n\t*slabcur_addr = slab != NULL ? edata_addr_get(slab) : NULL;\n\tmalloc_mutex_unlock(tsdn, &bin->lock);\n}\n" }, { "path": "deps/jemalloc/src/jemalloc.c", "content": "#define JEMALLOC_C_\n#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemalloc/internal/buf_writer.h\"\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/emap.h\"\n#include \"jemalloc/internal/extent_dss.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/fxp.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/hook.h\"\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n#include \"jemalloc/internal/log.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/nstime.h\"\n#include \"jemalloc/internal/rtree.h\"\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/sc.h\"\n#include \"jemalloc/internal/spin.h\"\n#include \"jemalloc/internal/sz.h\"\n#include \"jemalloc/internal/ticker.h\"\n#include \"jemalloc/internal/thread_event.h\"\n#include \"jemalloc/internal/util.h\"\n\n/******************************************************************************/\n/* Data. */\n\n/* Runtime configuration options. */\nconst char\t*je_malloc_conf\n#ifndef _WIN32\n JEMALLOC_ATTR(weak)\n#endif\n ;\n/*\n * The usual rule is that the closer to runtime you are, the higher priority\n * your configuration settings are (so the jemalloc config options get lower\n * priority than the per-binary setting, which gets lower priority than the /etc\n * setting, which gets lower priority than the environment settings).\n *\n * But it's a fairly common use case in some testing environments for a user to\n * be able to control the binary, but nothing else (e.g. a performancy canary\n * uses the production OS and environment variables, but can run any binary in\n * those circumstances). For these use cases, it's handy to have an in-binary\n * mechanism for overriding environment variable settings, with the idea that if\n * the results are positive they get promoted to the official settings, and\n * moved from the binary to the environment variable.\n *\n * We don't actually want this to be widespread, so we'll give it a silly name\n * and not mention it in headers or documentation.\n */\nconst char\t*je_malloc_conf_2_conf_harder\n#ifndef _WIN32\n JEMALLOC_ATTR(weak)\n#endif\n ;\n\nbool\topt_abort =\n#ifdef JEMALLOC_DEBUG\n true\n#else\n false\n#endif\n ;\nbool\topt_abort_conf =\n#ifdef JEMALLOC_DEBUG\n true\n#else\n false\n#endif\n ;\n/* Intentionally default off, even with debug builds. */\nbool\topt_confirm_conf = false;\nconst char\t*opt_junk =\n#if (defined(JEMALLOC_DEBUG) && defined(JEMALLOC_FILL))\n \"true\"\n#else\n \"false\"\n#endif\n ;\nbool\topt_junk_alloc =\n#if (defined(JEMALLOC_DEBUG) && defined(JEMALLOC_FILL))\n true\n#else\n false\n#endif\n ;\nbool\topt_junk_free =\n#if (defined(JEMALLOC_DEBUG) && defined(JEMALLOC_FILL))\n true\n#else\n false\n#endif\n ;\nbool\topt_trust_madvise =\n#ifdef JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS\n false\n#else\n true\n#endif\n ;\n\nbool opt_cache_oblivious =\n#ifdef JEMALLOC_CACHE_OBLIVIOUS\n true\n#else\n false\n#endif\n ;\n\nzero_realloc_action_t opt_zero_realloc_action =\n#ifdef JEMALLOC_ZERO_REALLOC_DEFAULT_FREE\n zero_realloc_action_free\n#else\n zero_realloc_action_alloc\n#endif\n ;\n\natomic_zu_t zero_realloc_count = ATOMIC_INIT(0);\n\nconst char *zero_realloc_mode_names[] = {\n\t\"alloc\",\n\t\"free\",\n\t\"abort\",\n};\n\n/*\n * These are the documented values for junk fill debugging facilities -- see the\n * man page.\n */\nstatic const uint8_t junk_alloc_byte = 0xa5;\nstatic const uint8_t junk_free_byte = 0x5a;\n\nstatic void default_junk_alloc(void *ptr, size_t usize) {\n\tmemset(ptr, junk_alloc_byte, usize);\n}\n\nstatic void default_junk_free(void *ptr, size_t usize) {\n\tmemset(ptr, junk_free_byte, usize);\n}\n\nvoid (*junk_alloc_callback)(void *ptr, size_t size) = &default_junk_alloc;\nvoid (*junk_free_callback)(void *ptr, size_t size) = &default_junk_free;\n\nbool\topt_utrace = false;\nbool\topt_xmalloc = false;\nbool\topt_experimental_infallible_new = false;\nbool\topt_zero = false;\nunsigned\topt_narenas = 0;\nfxp_t\t\topt_narenas_ratio = FXP_INIT_INT(4);\n\nunsigned\tncpus;\n\n/* Protects arenas initialization. */\nmalloc_mutex_t arenas_lock;\n\n/* The global hpa, and whether it's on. */\nbool opt_hpa = false;\nhpa_shard_opts_t opt_hpa_opts = HPA_SHARD_OPTS_DEFAULT;\nsec_opts_t opt_hpa_sec_opts = SEC_OPTS_DEFAULT;\n\n/*\n * Arenas that are used to service external requests. Not all elements of the\n * arenas array are necessarily used; arenas are created lazily as needed.\n *\n * arenas[0..narenas_auto) are used for automatic multiplexing of threads and\n * arenas. arenas[narenas_auto..narenas_total) are only used if the application\n * takes some action to create them and allocate from them.\n *\n * Points to an arena_t.\n */\nJEMALLOC_ALIGNED(CACHELINE)\natomic_p_t\t\tarenas[MALLOCX_ARENA_LIMIT];\nstatic atomic_u_t\tnarenas_total; /* Use narenas_total_*(). */\n/* Below three are read-only after initialization. */\nstatic arena_t\t\t*a0; /* arenas[0]. */\nunsigned\t\tnarenas_auto;\nunsigned\t\tmanual_arena_base;\n\nmalloc_init_t malloc_init_state = malloc_init_uninitialized;\n\n/* False should be the common case. Set to true to trigger initialization. */\nbool\t\t\tmalloc_slow = true;\n\n/* When malloc_slow is true, set the corresponding bits for sanity check. */\nenum {\n\tflag_opt_junk_alloc\t= (1U),\n\tflag_opt_junk_free\t= (1U << 1),\n\tflag_opt_zero\t\t= (1U << 2),\n\tflag_opt_utrace\t\t= (1U << 3),\n\tflag_opt_xmalloc\t= (1U << 4)\n};\nstatic uint8_t\tmalloc_slow_flags;\n\n#ifdef JEMALLOC_THREADED_INIT\n/* Used to let the initializing thread recursively allocate. */\n# define NO_INITIALIZER\t((unsigned long)0)\n# define INITIALIZER\t\tpthread_self()\n# define IS_INITIALIZER\t(malloc_initializer == pthread_self())\nstatic pthread_t\t\tmalloc_initializer = NO_INITIALIZER;\n#else\n# define NO_INITIALIZER\tfalse\n# define INITIALIZER\t\ttrue\n# define IS_INITIALIZER\tmalloc_initializer\nstatic bool\t\t\tmalloc_initializer = NO_INITIALIZER;\n#endif\n\n/* Used to avoid initialization races. */\n#ifdef _WIN32\n#if _WIN32_WINNT >= 0x0600\nstatic malloc_mutex_t\tinit_lock = SRWLOCK_INIT;\n#else\nstatic malloc_mutex_t\tinit_lock;\nstatic bool init_lock_initialized = false;\n\nJEMALLOC_ATTR(constructor)\nstatic void WINAPI\n_init_init_lock(void) {\n\t/*\n\t * If another constructor in the same binary is using mallctl to e.g.\n\t * set up extent hooks, it may end up running before this one, and\n\t * malloc_init_hard will crash trying to lock the uninitialized lock. So\n\t * we force an initialization of the lock in malloc_init_hard as well.\n\t * We don't try to care about atomicity of the accessed to the\n\t * init_lock_initialized boolean, since it really only matters early in\n\t * the process creation, before any separate thread normally starts\n\t * doing anything.\n\t */\n\tif (!init_lock_initialized) {\n\t\tmalloc_mutex_init(&init_lock, \"init\", WITNESS_RANK_INIT,\n\t\t malloc_mutex_rank_exclusive);\n\t}\n\tinit_lock_initialized = true;\n}\n\n#ifdef _MSC_VER\n# pragma section(\".CRT$XCU\", read)\nJEMALLOC_SECTION(\".CRT$XCU\") JEMALLOC_ATTR(used)\nstatic const void (WINAPI *init_init_lock)(void) = _init_init_lock;\n#endif\n#endif\n#else\nstatic malloc_mutex_t\tinit_lock = MALLOC_MUTEX_INITIALIZER;\n#endif\n\ntypedef struct {\n\tvoid\t*p;\t/* Input pointer (as in realloc(p, s)). */\n\tsize_t\ts;\t/* Request size. */\n\tvoid\t*r;\t/* Result pointer. */\n} malloc_utrace_t;\n\n#ifdef JEMALLOC_UTRACE\n# define UTRACE(a, b, c) do {\t\t\t\t\t\t\\\n\tif (unlikely(opt_utrace)) {\t\t\t\t\t\\\n\t\tint utrace_serrno = errno;\t\t\t\t\\\n\t\tmalloc_utrace_t ut;\t\t\t\t\t\\\n\t\tut.p = (a);\t\t\t\t\t\t\\\n\t\tut.s = (b);\t\t\t\t\t\t\\\n\t\tut.r = (c);\t\t\t\t\t\t\\\n\t\tUTRACE_CALL(&ut, sizeof(ut));\t\t\t\t\\\n\t\terrno = utrace_serrno;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#else\n# define UTRACE(a, b, c)\n#endif\n\n/* Whether encountered any invalid config options. */\nstatic bool had_conf_error = false;\n\n/******************************************************************************/\n/*\n * Function prototypes for static functions that are referenced prior to\n * definition.\n */\n\nstatic bool\tmalloc_init_hard_a0(void);\nstatic bool\tmalloc_init_hard(void);\n\n/******************************************************************************/\n/*\n * Begin miscellaneous support functions.\n */\n\nJEMALLOC_ALWAYS_INLINE bool\nmalloc_init_a0(void) {\n\tif (unlikely(malloc_init_state == malloc_init_uninitialized)) {\n\t\treturn malloc_init_hard_a0();\n\t}\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nmalloc_init(void) {\n\tif (unlikely(!malloc_initialized()) && malloc_init_hard()) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/*\n * The a0*() functions are used instead of i{d,}alloc() in situations that\n * cannot tolerate TLS variable access.\n */\n\nstatic void *\na0ialloc(size_t size, bool zero, bool is_internal) {\n\tif (unlikely(malloc_init_a0())) {\n\t\treturn NULL;\n\t}\n\n\treturn iallocztm(TSDN_NULL, size, sz_size2index(size), zero, NULL,\n\t is_internal, arena_get(TSDN_NULL, 0, true), true);\n}\n\nstatic void\na0idalloc(void *ptr, bool is_internal) {\n\tidalloctm(TSDN_NULL, ptr, NULL, NULL, is_internal, true);\n}\n\nvoid *\na0malloc(size_t size) {\n\treturn a0ialloc(size, false, true);\n}\n\nvoid\na0dalloc(void *ptr) {\n\ta0idalloc(ptr, true);\n}\n\n/*\n * FreeBSD's libc uses the bootstrap_*() functions in bootstrap-sensitive\n * situations that cannot tolerate TLS variable access (TLS allocation and very\n * early internal data structure initialization).\n */\n\nvoid *\nbootstrap_malloc(size_t size) {\n\tif (unlikely(size == 0)) {\n\t\tsize = 1;\n\t}\n\n\treturn a0ialloc(size, false, false);\n}\n\nvoid *\nbootstrap_calloc(size_t num, size_t size) {\n\tsize_t num_size;\n\n\tnum_size = num * size;\n\tif (unlikely(num_size == 0)) {\n\t\tassert(num == 0 || size == 0);\n\t\tnum_size = 1;\n\t}\n\n\treturn a0ialloc(num_size, true, false);\n}\n\nvoid\nbootstrap_free(void *ptr) {\n\tif (unlikely(ptr == NULL)) {\n\t\treturn;\n\t}\n\n\ta0idalloc(ptr, false);\n}\n\nvoid\narena_set(unsigned ind, arena_t *arena) {\n\tatomic_store_p(&arenas[ind], arena, ATOMIC_RELEASE);\n}\n\nstatic void\nnarenas_total_set(unsigned narenas) {\n\tatomic_store_u(&narenas_total, narenas, ATOMIC_RELEASE);\n}\n\nstatic void\nnarenas_total_inc(void) {\n\tatomic_fetch_add_u(&narenas_total, 1, ATOMIC_RELEASE);\n}\n\nunsigned\nnarenas_total_get(void) {\n\treturn atomic_load_u(&narenas_total, ATOMIC_ACQUIRE);\n}\n\n/* Create a new arena and insert it into the arenas array at index ind. */\nstatic arena_t *\narena_init_locked(tsdn_t *tsdn, unsigned ind, const arena_config_t *config) {\n\tarena_t *arena;\n\n\tassert(ind <= narenas_total_get());\n\tif (ind >= MALLOCX_ARENA_LIMIT) {\n\t\treturn NULL;\n\t}\n\tif (ind == narenas_total_get()) {\n\t\tnarenas_total_inc();\n\t}\n\n\t/*\n\t * Another thread may have already initialized arenas[ind] if it's an\n\t * auto arena.\n\t */\n\tarena = arena_get(tsdn, ind, false);\n\tif (arena != NULL) {\n\t\tassert(arena_is_auto(arena));\n\t\treturn arena;\n\t}\n\n\t/* Actually initialize the arena. */\n\tarena = arena_new(tsdn, ind, config);\n\n\treturn arena;\n}\n\nstatic void\narena_new_create_background_thread(tsdn_t *tsdn, unsigned ind) {\n\tif (ind == 0) {\n\t\treturn;\n\t}\n\t/*\n\t * Avoid creating a new background thread just for the huge arena, which\n\t * purges eagerly by default.\n\t */\n\tif (have_background_thread && !arena_is_huge(ind)) {\n\t\tif (background_thread_create(tsdn_tsd(tsdn), ind)) {\n\t\t\tmalloc_printf(\": error in background thread \"\n\t\t\t\t \"creation for arena %u. Abort.\\n\", ind);\n\t\t\tabort();\n\t\t}\n\t}\n}\n\narena_t *\narena_init(tsdn_t *tsdn, unsigned ind, const arena_config_t *config) {\n\tarena_t *arena;\n\n\tmalloc_mutex_lock(tsdn, &arenas_lock);\n\tarena = arena_init_locked(tsdn, ind, config);\n\tmalloc_mutex_unlock(tsdn, &arenas_lock);\n\n\tarena_new_create_background_thread(tsdn, ind);\n\n\treturn arena;\n}\n\nstatic void\narena_bind(tsd_t *tsd, unsigned ind, bool internal) {\n\tarena_t *arena = arena_get(tsd_tsdn(tsd), ind, false);\n\tarena_nthreads_inc(arena, internal);\n\n\tif (internal) {\n\t\ttsd_iarena_set(tsd, arena);\n\t} else {\n\t\ttsd_arena_set(tsd, arena);\n\t\tunsigned shard = atomic_fetch_add_u(&arena->binshard_next, 1,\n\t\t ATOMIC_RELAXED);\n\t\ttsd_binshards_t *bins = tsd_binshardsp_get(tsd);\n\t\tfor (unsigned i = 0; i < SC_NBINS; i++) {\n\t\t\tassert(bin_infos[i].n_shards > 0 &&\n\t\t\t bin_infos[i].n_shards <= BIN_SHARDS_MAX);\n\t\t\tbins->binshard[i] = shard % bin_infos[i].n_shards;\n\t\t}\n\t}\n}\n\nvoid\narena_migrate(tsd_t *tsd, arena_t *oldarena, arena_t *newarena) {\n\tassert(oldarena != NULL);\n\tassert(newarena != NULL);\n\n\tarena_nthreads_dec(oldarena, false);\n\tarena_nthreads_inc(newarena, false);\n\ttsd_arena_set(tsd, newarena);\n\n\tif (arena_nthreads_get(oldarena, false) == 0) {\n\t\t/* Purge if the old arena has no associated threads anymore. */\n\t\tarena_decay(tsd_tsdn(tsd), oldarena,\n\t\t /* is_background_thread */ false, /* all */ true);\n\t}\n}\n\nstatic void\narena_unbind(tsd_t *tsd, unsigned ind, bool internal) {\n\tarena_t *arena;\n\n\tarena = arena_get(tsd_tsdn(tsd), ind, false);\n\tarena_nthreads_dec(arena, internal);\n\n\tif (internal) {\n\t\ttsd_iarena_set(tsd, NULL);\n\t} else {\n\t\ttsd_arena_set(tsd, NULL);\n\t}\n}\n\n/* Slow path, called only by arena_choose(). */\narena_t *\narena_choose_hard(tsd_t *tsd, bool internal) {\n\tarena_t *ret JEMALLOC_CC_SILENCE_INIT(NULL);\n\n\tif (have_percpu_arena && PERCPU_ARENA_ENABLED(opt_percpu_arena)) {\n\t\tunsigned choose = percpu_arena_choose();\n\t\tret = arena_get(tsd_tsdn(tsd), choose, true);\n\t\tassert(ret != NULL);\n\t\tarena_bind(tsd, arena_ind_get(ret), false);\n\t\tarena_bind(tsd, arena_ind_get(ret), true);\n\n\t\treturn ret;\n\t}\n\n\tif (narenas_auto > 1) {\n\t\tunsigned i, j, choose[2], first_null;\n\t\tbool is_new_arena[2];\n\n\t\t/*\n\t\t * Determine binding for both non-internal and internal\n\t\t * allocation.\n\t\t *\n\t\t * choose[0]: For application allocation.\n\t\t * choose[1]: For internal metadata allocation.\n\t\t */\n\n\t\tfor (j = 0; j < 2; j++) {\n\t\t\tchoose[j] = 0;\n\t\t\tis_new_arena[j] = false;\n\t\t}\n\n\t\tfirst_null = narenas_auto;\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &arenas_lock);\n\t\tassert(arena_get(tsd_tsdn(tsd), 0, false) != NULL);\n\t\tfor (i = 1; i < narenas_auto; i++) {\n\t\t\tif (arena_get(tsd_tsdn(tsd), i, false) != NULL) {\n\t\t\t\t/*\n\t\t\t\t * Choose the first arena that has the lowest\n\t\t\t\t * number of threads assigned to it.\n\t\t\t\t */\n\t\t\t\tfor (j = 0; j < 2; j++) {\n\t\t\t\t\tif (arena_nthreads_get(arena_get(\n\t\t\t\t\t tsd_tsdn(tsd), i, false), !!j) <\n\t\t\t\t\t arena_nthreads_get(arena_get(\n\t\t\t\t\t tsd_tsdn(tsd), choose[j], false),\n\t\t\t\t\t !!j)) {\n\t\t\t\t\t\tchoose[j] = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (first_null == narenas_auto) {\n\t\t\t\t/*\n\t\t\t\t * Record the index of the first uninitialized\n\t\t\t\t * arena, in case all extant arenas are in use.\n\t\t\t\t *\n\t\t\t\t * NB: It is possible for there to be\n\t\t\t\t * discontinuities in terms of initialized\n\t\t\t\t * versus uninitialized arenas, due to the\n\t\t\t\t * \"thread.arena\" mallctl.\n\t\t\t\t */\n\t\t\t\tfirst_null = i;\n\t\t\t}\n\t\t}\n\n\t\tfor (j = 0; j < 2; j++) {\n\t\t\tif (arena_nthreads_get(arena_get(tsd_tsdn(tsd),\n\t\t\t choose[j], false), !!j) == 0 || first_null ==\n\t\t\t narenas_auto) {\n\t\t\t\t/*\n\t\t\t\t * Use an unloaded arena, or the least loaded\n\t\t\t\t * arena if all arenas are already initialized.\n\t\t\t\t */\n\t\t\t\tif (!!j == internal) {\n\t\t\t\t\tret = arena_get(tsd_tsdn(tsd),\n\t\t\t\t\t choose[j], false);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tarena_t *arena;\n\n\t\t\t\t/* Initialize a new arena. */\n\t\t\t\tchoose[j] = first_null;\n\t\t\t\tarena = arena_init_locked(tsd_tsdn(tsd),\n\t\t\t\t choose[j], &arena_config_default);\n\t\t\t\tif (arena == NULL) {\n\t\t\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd),\n\t\t\t\t\t &arenas_lock);\n\t\t\t\t\treturn NULL;\n\t\t\t\t}\n\t\t\t\tis_new_arena[j] = true;\n\t\t\t\tif (!!j == internal) {\n\t\t\t\t\tret = arena;\n\t\t\t\t}\n\t\t\t}\n\t\t\tarena_bind(tsd, choose[j], !!j);\n\t\t}\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &arenas_lock);\n\n\t\tfor (j = 0; j < 2; j++) {\n\t\t\tif (is_new_arena[j]) {\n\t\t\t\tassert(choose[j] > 0);\n\t\t\t\tarena_new_create_background_thread(\n\t\t\t\t tsd_tsdn(tsd), choose[j]);\n\t\t\t}\n\t\t}\n\n\t} else {\n\t\tret = arena_get(tsd_tsdn(tsd), 0, false);\n\t\tarena_bind(tsd, 0, false);\n\t\tarena_bind(tsd, 0, true);\n\t}\n\n\treturn ret;\n}\n\nvoid\niarena_cleanup(tsd_t *tsd) {\n\tarena_t *iarena;\n\n\tiarena = tsd_iarena_get(tsd);\n\tif (iarena != NULL) {\n\t\tarena_unbind(tsd, arena_ind_get(iarena), true);\n\t}\n}\n\nvoid\narena_cleanup(tsd_t *tsd) {\n\tarena_t *arena;\n\n\tarena = tsd_arena_get(tsd);\n\tif (arena != NULL) {\n\t\tarena_unbind(tsd, arena_ind_get(arena), false);\n\t}\n}\n\nstatic void\nstats_print_atexit(void) {\n\tif (config_stats) {\n\t\ttsdn_t *tsdn;\n\t\tunsigned narenas, i;\n\n\t\ttsdn = tsdn_fetch();\n\n\t\t/*\n\t\t * Merge stats from extant threads. This is racy, since\n\t\t * individual threads do not lock when recording tcache stats\n\t\t * events. As a consequence, the final stats may be slightly\n\t\t * out of date by the time they are reported, if other threads\n\t\t * continue to allocate.\n\t\t */\n\t\tfor (i = 0, narenas = narenas_total_get(); i < narenas; i++) {\n\t\t\tarena_t *arena = arena_get(tsdn, i, false);\n\t\t\tif (arena != NULL) {\n\t\t\t\ttcache_slow_t *tcache_slow;\n\n\t\t\t\tmalloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);\n\t\t\t\tql_foreach(tcache_slow, &arena->tcache_ql,\n\t\t\t\t link) {\n\t\t\t\t\ttcache_stats_merge(tsdn,\n\t\t\t\t\t tcache_slow->tcache, arena);\n\t\t\t\t}\n\t\t\t\tmalloc_mutex_unlock(tsdn,\n\t\t\t\t &arena->tcache_ql_mtx);\n\t\t\t}\n\t\t}\n\t}\n\tje_malloc_stats_print(NULL, NULL, opt_stats_print_opts);\n}\n\n/*\n * Ensure that we don't hold any locks upon entry to or exit from allocator\n * code (in a \"broad\" sense that doesn't count a reentrant allocation as an\n * entrance or exit).\n */\nJEMALLOC_ALWAYS_INLINE void\ncheck_entry_exit_locking(tsdn_t *tsdn) {\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\tif (tsdn_null(tsdn)) {\n\t\treturn;\n\t}\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\t/*\n\t * It's possible we hold locks at entry/exit if we're in a nested\n\t * allocation.\n\t */\n\tint8_t reentrancy_level = tsd_reentrancy_level_get(tsd);\n\tif (reentrancy_level != 0) {\n\t\treturn;\n\t}\n\twitness_assert_lockless(tsdn_witness_tsdp_get(tsdn));\n}\n\n/*\n * End miscellaneous support functions.\n */\n/******************************************************************************/\n/*\n * Begin initialization functions.\n */\n\nstatic char *\njemalloc_secure_getenv(const char *name) {\n#ifdef JEMALLOC_HAVE_SECURE_GETENV\n\treturn secure_getenv(name);\n#else\n# ifdef JEMALLOC_HAVE_ISSETUGID\n\tif (issetugid() != 0) {\n\t\treturn NULL;\n\t}\n# endif\n\treturn getenv(name);\n#endif\n}\n\nstatic unsigned\nmalloc_ncpus(void) {\n\tlong result;\n\n#ifdef _WIN32\n\tSYSTEM_INFO si;\n\tGetSystemInfo(&si);\n\tresult = si.dwNumberOfProcessors;\n#elif defined(CPU_COUNT)\n\t/*\n\t * glibc >= 2.6 has the CPU_COUNT macro.\n\t *\n\t * glibc's sysconf() uses isspace(). glibc allocates for the first time\n\t * *before* setting up the isspace tables. Therefore we need a\n\t * different method to get the number of CPUs.\n\t *\n\t * The getaffinity approach is also preferred when only a subset of CPUs\n\t * is available, to avoid using more arenas than necessary.\n\t */\n\t{\n# if defined(__FreeBSD__) || defined(__DragonFly__)\n\t\tcpuset_t set;\n# else\n\t\tcpu_set_t set;\n# endif\n# if defined(JEMALLOC_HAVE_SCHED_SETAFFINITY)\n\t\tsched_getaffinity(0, sizeof(set), &set);\n# else\n\t\tpthread_getaffinity_np(pthread_self(), sizeof(set), &set);\n# endif\n\t\tresult = CPU_COUNT(&set);\n\t}\n#else\n\tresult = sysconf(_SC_NPROCESSORS_ONLN);\n#endif\n\treturn ((result == -1) ? 1 : (unsigned)result);\n}\n\n/*\n * Ensure that number of CPUs is determistinc, i.e. it is the same based on:\n * - sched_getaffinity()\n * - _SC_NPROCESSORS_ONLN\n * - _SC_NPROCESSORS_CONF\n * Since otherwise tricky things is possible with percpu arenas in use.\n */\nstatic bool\nmalloc_cpu_count_is_deterministic()\n{\n#ifdef _WIN32\n\treturn true;\n#else\n\tlong cpu_onln = sysconf(_SC_NPROCESSORS_ONLN);\n\tlong cpu_conf = sysconf(_SC_NPROCESSORS_CONF);\n\tif (cpu_onln != cpu_conf) {\n\t\treturn false;\n\t}\n# if defined(CPU_COUNT)\n# if defined(__FreeBSD__) || defined(__DragonFly__)\n\tcpuset_t set;\n# else\n\tcpu_set_t set;\n# endif /* __FreeBSD__ */\n# if defined(JEMALLOC_HAVE_SCHED_SETAFFINITY)\n\tsched_getaffinity(0, sizeof(set), &set);\n# else /* !JEMALLOC_HAVE_SCHED_SETAFFINITY */\n\tpthread_getaffinity_np(pthread_self(), sizeof(set), &set);\n# endif /* JEMALLOC_HAVE_SCHED_SETAFFINITY */\n\tlong cpu_affinity = CPU_COUNT(&set);\n\tif (cpu_affinity != cpu_conf) {\n\t\treturn false;\n\t}\n# endif /* CPU_COUNT */\n\treturn true;\n#endif\n}\n\nstatic void\ninit_opt_stats_opts(const char *v, size_t vlen, char *dest) {\n\tsize_t opts_len = strlen(dest);\n\tassert(opts_len <= stats_print_tot_num_options);\n\n\tfor (size_t i = 0; i < vlen; i++) {\n\t\tswitch (v[i]) {\n#define OPTION(o, v, d, s) case o: break;\n\t\t\tSTATS_PRINT_OPTIONS\n#undef OPTION\n\t\tdefault: continue;\n\t\t}\n\n\t\tif (strchr(dest, v[i]) != NULL) {\n\t\t\t/* Ignore repeated. */\n\t\t\tcontinue;\n\t\t}\n\n\t\tdest[opts_len++] = v[i];\n\t\tdest[opts_len] = '\\0';\n\t\tassert(opts_len <= stats_print_tot_num_options);\n\t}\n\tassert(opts_len == strlen(dest));\n}\n\n/* Reads the next size pair in a multi-sized option. */\nstatic bool\nmalloc_conf_multi_sizes_next(const char **slab_size_segment_cur,\n size_t *vlen_left, size_t *slab_start, size_t *slab_end, size_t *new_size) {\n\tconst char *cur = *slab_size_segment_cur;\n\tchar *end;\n\tuintmax_t um;\n\n\tset_errno(0);\n\n\t/* First number, then '-' */\n\tum = malloc_strtoumax(cur, &end, 0);\n\tif (get_errno() != 0 || *end != '-') {\n\t\treturn true;\n\t}\n\t*slab_start = (size_t)um;\n\tcur = end + 1;\n\n\t/* Second number, then ':' */\n\tum = malloc_strtoumax(cur, &end, 0);\n\tif (get_errno() != 0 || *end != ':') {\n\t\treturn true;\n\t}\n\t*slab_end = (size_t)um;\n\tcur = end + 1;\n\n\t/* Last number */\n\tum = malloc_strtoumax(cur, &end, 0);\n\tif (get_errno() != 0) {\n\t\treturn true;\n\t}\n\t*new_size = (size_t)um;\n\n\t/* Consume the separator if there is one. */\n\tif (*end == '|') {\n\t\tend++;\n\t}\n\n\t*vlen_left -= end - *slab_size_segment_cur;\n\t*slab_size_segment_cur = end;\n\n\treturn false;\n}\n\nstatic bool\nmalloc_conf_next(char const **opts_p, char const **k_p, size_t *klen_p,\n char const **v_p, size_t *vlen_p) {\n\tbool accept;\n\tconst char *opts = *opts_p;\n\n\t*k_p = opts;\n\n\tfor (accept = false; !accept;) {\n\t\tswitch (*opts) {\n\t\tcase 'A': case 'B': case 'C': case 'D': case 'E': case 'F':\n\t\tcase 'G': case 'H': case 'I': case 'J': case 'K': case 'L':\n\t\tcase 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':\n\t\tcase 'S': case 'T': case 'U': case 'V': case 'W': case 'X':\n\t\tcase 'Y': case 'Z':\n\t\tcase 'a': case 'b': case 'c': case 'd': case 'e': case 'f':\n\t\tcase 'g': case 'h': case 'i': case 'j': case 'k': case 'l':\n\t\tcase 'm': case 'n': case 'o': case 'p': case 'q': case 'r':\n\t\tcase 's': case 't': case 'u': case 'v': case 'w': case 'x':\n\t\tcase 'y': case 'z':\n\t\tcase '0': case '1': case '2': case '3': case '4': case '5':\n\t\tcase '6': case '7': case '8': case '9':\n\t\tcase '_':\n\t\t\topts++;\n\t\t\tbreak;\n\t\tcase ':':\n\t\t\topts++;\n\t\t\t*klen_p = (uintptr_t)opts - 1 - (uintptr_t)*k_p;\n\t\t\t*v_p = opts;\n\t\t\taccept = true;\n\t\t\tbreak;\n\t\tcase '\\0':\n\t\t\tif (opts != *opts_p) {\n\t\t\t\tmalloc_write(\": Conf string ends \"\n\t\t\t\t \"with key\\n\");\n\t\t\t\thad_conf_error = true;\n\t\t\t}\n\t\t\treturn true;\n\t\tdefault:\n\t\t\tmalloc_write(\": Malformed conf string\\n\");\n\t\t\thad_conf_error = true;\n\t\t\treturn true;\n\t\t}\n\t}\n\n\tfor (accept = false; !accept;) {\n\t\tswitch (*opts) {\n\t\tcase ',':\n\t\t\topts++;\n\t\t\t/*\n\t\t\t * Look ahead one character here, because the next time\n\t\t\t * this function is called, it will assume that end of\n\t\t\t * input has been cleanly reached if no input remains,\n\t\t\t * but we have optimistically already consumed the\n\t\t\t * comma if one exists.\n\t\t\t */\n\t\t\tif (*opts == '\\0') {\n\t\t\t\tmalloc_write(\": Conf string ends \"\n\t\t\t\t \"with comma\\n\");\n\t\t\t\thad_conf_error = true;\n\t\t\t}\n\t\t\t*vlen_p = (uintptr_t)opts - 1 - (uintptr_t)*v_p;\n\t\t\taccept = true;\n\t\t\tbreak;\n\t\tcase '\\0':\n\t\t\t*vlen_p = (uintptr_t)opts - (uintptr_t)*v_p;\n\t\t\taccept = true;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\topts++;\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t*opts_p = opts;\n\treturn false;\n}\n\nstatic void\nmalloc_abort_invalid_conf(void) {\n\tassert(opt_abort_conf);\n\tmalloc_printf(\": Abort (abort_conf:true) on invalid conf \"\n\t \"value (see above).\\n\");\n\tabort();\n}\n\nstatic void\nmalloc_conf_error(const char *msg, const char *k, size_t klen, const char *v,\n size_t vlen) {\n\tmalloc_printf(\": %s: %.*s:%.*s\\n\", msg, (int)klen, k,\n\t (int)vlen, v);\n\t/* If abort_conf is set, error out after processing all options. */\n\tconst char *experimental = \"experimental_\";\n\tif (strncmp(k, experimental, strlen(experimental)) == 0) {\n\t\t/* However, tolerate experimental features. */\n\t\treturn;\n\t}\n\thad_conf_error = true;\n}\n\nstatic void\nmalloc_slow_flag_init(void) {\n\t/*\n\t * Combine the runtime options into malloc_slow for fast path. Called\n\t * after processing all the options.\n\t */\n\tmalloc_slow_flags |= (opt_junk_alloc ? flag_opt_junk_alloc : 0)\n\t | (opt_junk_free ? flag_opt_junk_free : 0)\n\t | (opt_zero ? flag_opt_zero : 0)\n\t | (opt_utrace ? flag_opt_utrace : 0)\n\t | (opt_xmalloc ? flag_opt_xmalloc : 0);\n\n\tmalloc_slow = (malloc_slow_flags != 0);\n}\n\n/* Number of sources for initializing malloc_conf */\n#define MALLOC_CONF_NSOURCES 5\n\nstatic const char *\nobtain_malloc_conf(unsigned which_source, char buf[PATH_MAX + 1]) {\n\tif (config_debug) {\n\t\tstatic unsigned read_source = 0;\n\t\t/*\n\t\t * Each source should only be read once, to minimize # of\n\t\t * syscalls on init.\n\t\t */\n\t\tassert(read_source++ == which_source);\n\t}\n\tassert(which_source < MALLOC_CONF_NSOURCES);\n\n\tconst char *ret;\n\tswitch (which_source) {\n\tcase 0:\n\t\tret = config_malloc_conf;\n\t\tbreak;\n\tcase 1:\n\t\tif (je_malloc_conf != NULL) {\n\t\t\t/* Use options that were compiled into the program. */\n\t\t\tret = je_malloc_conf;\n\t\t} else {\n\t\t\t/* No configuration specified. */\n\t\t\tret = NULL;\n\t\t}\n\t\tbreak;\n\tcase 2: {\n\t\tssize_t linklen = 0;\n#ifndef _WIN32\n\t\tint saved_errno = errno;\n\t\tconst char *linkname =\n# ifdef JEMALLOC_PREFIX\n\t\t \"/etc/\"JEMALLOC_PREFIX\"malloc.conf\"\n# else\n\t\t \"/etc/malloc.conf\"\n# endif\n\t\t ;\n\n\t\t/*\n\t\t * Try to use the contents of the \"/etc/malloc.conf\" symbolic\n\t\t * link's name.\n\t\t */\n#ifndef JEMALLOC_READLINKAT\n\t\tlinklen = readlink(linkname, buf, PATH_MAX);\n#else\n\t\tlinklen = readlinkat(AT_FDCWD, linkname, buf, PATH_MAX);\n#endif\n\t\tif (linklen == -1) {\n\t\t\t/* No configuration specified. */\n\t\t\tlinklen = 0;\n\t\t\t/* Restore errno. */\n\t\t\tset_errno(saved_errno);\n\t\t}\n#endif\n\t\tbuf[linklen] = '\\0';\n\t\tret = buf;\n\t\tbreak;\n\t} case 3: {\n\t\tconst char *envname =\n#ifdef JEMALLOC_PREFIX\n\t\t JEMALLOC_CPREFIX\"MALLOC_CONF\"\n#else\n\t\t \"MALLOC_CONF\"\n#endif\n\t\t ;\n\n\t\tif ((ret = jemalloc_secure_getenv(envname)) != NULL) {\n\t\t\t/*\n\t\t\t * Do nothing; opts is already initialized to the value\n\t\t\t * of the MALLOC_CONF environment variable.\n\t\t\t */\n\t\t} else {\n\t\t\t/* No configuration specified. */\n\t\t\tret = NULL;\n\t\t}\n\t\tbreak;\n\t} case 4: {\n\t\tret = je_malloc_conf_2_conf_harder;\n\t\tbreak;\n\t} default:\n\t\tnot_reached();\n\t\tret = NULL;\n\t}\n\treturn ret;\n}\n\nstatic void\nmalloc_conf_init_helper(sc_data_t *sc_data, unsigned bin_shard_sizes[SC_NBINS],\n bool initial_call, const char *opts_cache[MALLOC_CONF_NSOURCES],\n char buf[PATH_MAX + 1]) {\n\tstatic const char *opts_explain[MALLOC_CONF_NSOURCES] = {\n\t\t\"string specified via --with-malloc-conf\",\n\t\t\"string pointed to by the global variable malloc_conf\",\n\t\t(\"\\\"name\\\" of the file referenced by the symbolic link named \"\n\t\t \"/etc/malloc.conf\"),\n\t\t\"value of the environment variable MALLOC_CONF\",\n\t\t(\"string pointed to by the global variable \"\n\t\t \"malloc_conf_2_conf_harder\"),\n\t};\n\tunsigned i;\n\tconst char *opts, *k, *v;\n\tsize_t klen, vlen;\n\n\tfor (i = 0; i < MALLOC_CONF_NSOURCES; i++) {\n\t\t/* Get runtime configuration. */\n\t\tif (initial_call) {\n\t\t\topts_cache[i] = obtain_malloc_conf(i, buf);\n\t\t}\n\t\topts = opts_cache[i];\n\t\tif (!initial_call && opt_confirm_conf) {\n\t\t\tmalloc_printf(\n\t\t\t \": malloc_conf #%u (%s): \\\"%s\\\"\\n\",\n\t\t\t i + 1, opts_explain[i], opts != NULL ? opts : \"\");\n\t\t}\n\t\tif (opts == NULL) {\n\t\t\tcontinue;\n\t\t}\n\n\t\twhile (*opts != '\\0' && !malloc_conf_next(&opts, &k, &klen, &v,\n\t\t &vlen)) {\n\n#define CONF_ERROR(msg, k, klen, v, vlen)\t\t\t\t\\\n\t\t\tif (!initial_call) {\t\t\t\t\\\n\t\t\t\tmalloc_conf_error(\t\t\t\\\n\t\t\t\t msg, k, klen, v, vlen);\t\t\\\n\t\t\t\tcur_opt_valid = false;\t\t\t\\\n\t\t\t}\n#define CONF_CONTINUE\t{\t\t\t\t\t\t\\\n\t\t\t\tif (!initial_call && opt_confirm_conf\t\\\n\t\t\t\t && cur_opt_valid) {\t\t\t\\\n\t\t\t\t\tmalloc_printf(\": -- \"\t\\\n\t\t\t\t\t \"Set conf value: %.*s:%.*s\"\t\\\n\t\t\t\t\t \"\\n\", (int)klen, k,\t\t\\\n\t\t\t\t\t (int)vlen, v);\t\t\\\n\t\t\t\t}\t\t\t\t\t\\\n\t\t\t\tcontinue;\t\t\t\t\\\n\t\t\t}\n#define CONF_MATCH(n)\t\t\t\t\t\t\t\\\n\t(sizeof(n)-1 == klen && strncmp(n, k, klen) == 0)\n#define CONF_MATCH_VALUE(n)\t\t\t\t\t\t\\\n\t(sizeof(n)-1 == vlen && strncmp(n, v, vlen) == 0)\n#define CONF_HANDLE_BOOL(o, n)\t\t\t\t\t\t\\\n\t\t\tif (CONF_MATCH(n)) {\t\t\t\t\\\n\t\t\t\tif (CONF_MATCH_VALUE(\"true\")) {\t\t\\\n\t\t\t\t\to = true;\t\t\t\\\n\t\t\t\t} else if (CONF_MATCH_VALUE(\"false\")) {\t\\\n\t\t\t\t\to = false;\t\t\t\\\n\t\t\t\t} else {\t\t\t\t\\\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\\\n\t\t\t\t\t k, klen, v, vlen);\t\t\\\n\t\t\t\t}\t\t\t\t\t\\\n\t\t\t\tCONF_CONTINUE;\t\t\t\t\\\n\t\t\t}\n /*\n * One of the CONF_MIN macros below expands, in one of the use points,\n * to \"unsigned integer < 0\", which is always false, triggering the\n * GCC -Wtype-limits warning, which we disable here and re-enable below.\n */\n JEMALLOC_DIAGNOSTIC_PUSH\n JEMALLOC_DIAGNOSTIC_IGNORE_TYPE_LIMITS\n\n#define CONF_DONT_CHECK_MIN(um, min)\tfalse\n#define CONF_CHECK_MIN(um, min)\t((um) < (min))\n#define CONF_DONT_CHECK_MAX(um, max)\tfalse\n#define CONF_CHECK_MAX(um, max)\t((um) > (max))\n\n#define CONF_VALUE_READ(max_t, result)\t\t\t\t\t\\\n\t char *end;\t\t\t\t\t\t\\\n\t set_errno(0);\t\t\t\t\t\t\\\n\t result = (max_t)malloc_strtoumax(v, &end, 0);\n#define CONF_VALUE_READ_FAIL()\t\t\t\t\t\t\\\n\t (get_errno() != 0 || (uintptr_t)end - (uintptr_t)v != vlen)\n\n#define CONF_HANDLE_T(t, max_t, o, n, min, max, check_min, check_max, clip) \\\n\t\t\tif (CONF_MATCH(n)) {\t\t\t\t\\\n\t\t\t\tmax_t mv;\t\t\t\t\\\n\t\t\t\tCONF_VALUE_READ(max_t, mv)\t\t\\\n\t\t\t\tif (CONF_VALUE_READ_FAIL()) {\t\t\\\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\\\n\t\t\t\t\t k, klen, v, vlen);\t\t\\\n\t\t\t\t} else if (clip) {\t\t\t\\\n\t\t\t\t\tif (check_min(mv, (t)(min))) {\t\\\n\t\t\t\t\t\to = (t)(min);\t\t\\\n\t\t\t\t\t} else if (\t\t\t\\\n\t\t\t\t\t check_max(mv, (t)(max))) {\t\\\n\t\t\t\t\t\to = (t)(max);\t\t\\\n\t\t\t\t\t} else {\t\t\t\\\n\t\t\t\t\t\to = (t)mv;\t\t\\\n\t\t\t\t\t}\t\t\t\t\\\n\t\t\t\t} else {\t\t\t\t\\\n\t\t\t\t\tif (check_min(mv, (t)(min)) ||\t\\\n\t\t\t\t\t check_max(mv, (t)(max))) {\t\\\n\t\t\t\t\t\tCONF_ERROR(\t\t\\\n\t\t\t\t\t\t \"Out-of-range \"\t\\\n\t\t\t\t\t\t \"conf value\",\t\\\n\t\t\t\t\t\t k, klen, v, vlen);\t\\\n\t\t\t\t\t} else {\t\t\t\\\n\t\t\t\t\t\to = (t)mv;\t\t\\\n\t\t\t\t\t}\t\t\t\t\\\n\t\t\t\t}\t\t\t\t\t\\\n\t\t\t\tCONF_CONTINUE;\t\t\t\t\\\n\t\t\t}\n#define CONF_HANDLE_T_U(t, o, n, min, max, check_min, check_max, clip)\t\\\n\t CONF_HANDLE_T(t, uintmax_t, o, n, min, max, check_min,\t\\\n\t\t\t check_max, clip)\n#define CONF_HANDLE_T_SIGNED(t, o, n, min, max, check_min, check_max, clip)\\\n\t CONF_HANDLE_T(t, intmax_t, o, n, min, max, check_min,\t\\\n\t\t\t check_max, clip)\n\n#define CONF_HANDLE_UNSIGNED(o, n, min, max, check_min, check_max,\t\\\n clip)\t\t\t\t\t\t\t\t\\\n\t\t\tCONF_HANDLE_T_U(unsigned, o, n, min, max,\t\\\n\t\t\t check_min, check_max, clip)\n#define CONF_HANDLE_SIZE_T(o, n, min, max, check_min, check_max, clip)\t\\\n\t\t\tCONF_HANDLE_T_U(size_t, o, n, min, max,\t\t\\\n\t\t\t check_min, check_max, clip)\n#define CONF_HANDLE_INT64_T(o, n, min, max, check_min, check_max, clip)\t\\\n\t\t\tCONF_HANDLE_T_SIGNED(int64_t, o, n, min, max,\t\\\n\t\t\t check_min, check_max, clip)\n#define CONF_HANDLE_UINT64_T(o, n, min, max, check_min, check_max, clip)\\\n\t\t\tCONF_HANDLE_T_U(uint64_t, o, n, min, max,\t\\\n\t\t\t check_min, check_max, clip)\n#define CONF_HANDLE_SSIZE_T(o, n, min, max)\t\t\t\t\\\n\t\t\tCONF_HANDLE_T_SIGNED(ssize_t, o, n, min, max,\t\\\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, false)\n#define CONF_HANDLE_CHAR_P(o, n, d)\t\t\t\t\t\\\n\t\t\tif (CONF_MATCH(n)) {\t\t\t\t\\\n\t\t\t\tsize_t cpylen = (vlen <=\t\t\\\n\t\t\t\t sizeof(o)-1) ? vlen :\t\t\\\n\t\t\t\t sizeof(o)-1;\t\t\t\\\n\t\t\t\tstrncpy(o, v, cpylen);\t\t\t\\\n\t\t\t\to[cpylen] = '\\0';\t\t\t\\\n\t\t\t\tCONF_CONTINUE;\t\t\t\t\\\n\t\t\t}\n\n\t\t\tbool cur_opt_valid = true;\n\n\t\t\tCONF_HANDLE_BOOL(opt_confirm_conf, \"confirm_conf\")\n\t\t\tif (initial_call) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tCONF_HANDLE_BOOL(opt_abort, \"abort\")\n\t\t\tCONF_HANDLE_BOOL(opt_abort_conf, \"abort_conf\")\n\t\t\tCONF_HANDLE_BOOL(opt_trust_madvise, \"trust_madvise\")\n\t\t\tif (strncmp(\"metadata_thp\", k, klen) == 0) {\n\t\t\t\tint m;\n\t\t\t\tbool match = false;\n\t\t\t\tfor (m = 0; m < metadata_thp_mode_limit; m++) {\n\t\t\t\t\tif (strncmp(metadata_thp_mode_names[m],\n\t\t\t\t\t v, vlen) == 0) {\n\t\t\t\t\t\topt_metadata_thp = m;\n\t\t\t\t\t\tmatch = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!match) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tCONF_HANDLE_BOOL(opt_retain, \"retain\")\n\t\t\tif (strncmp(\"dss\", k, klen) == 0) {\n\t\t\t\tint m;\n\t\t\t\tbool match = false;\n\t\t\t\tfor (m = 0; m < dss_prec_limit; m++) {\n\t\t\t\t\tif (strncmp(dss_prec_names[m], v, vlen)\n\t\t\t\t\t == 0) {\n\t\t\t\t\t\tif (extent_dss_prec_set(m)) {\n\t\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t\t \"Error setting dss\",\n\t\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\topt_dss =\n\t\t\t\t\t\t\t dss_prec_names[m];\n\t\t\t\t\t\t\tmatch = true;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!match) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (CONF_MATCH(\"narenas\")) {\n\t\t\t\tif (CONF_MATCH_VALUE(\"default\")) {\n\t\t\t\t\topt_narenas = 0;\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t} else {\n\t\t\t\t\tCONF_HANDLE_UNSIGNED(opt_narenas,\n\t\t\t\t\t \"narenas\", 1, UINT_MAX,\n\t\t\t\t\t CONF_CHECK_MIN, CONF_DONT_CHECK_MAX,\n\t\t\t\t\t /* clip */ false)\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (CONF_MATCH(\"narenas_ratio\")) {\n\t\t\t\tchar *end;\n\t\t\t\tbool err = fxp_parse(&opt_narenas_ratio, v,\n\t\t\t\t &end);\n\t\t\t\tif (err || (size_t)(end - v) != vlen) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (CONF_MATCH(\"bin_shards\")) {\n\t\t\t\tconst char *bin_shards_segment_cur = v;\n\t\t\t\tsize_t vlen_left = vlen;\n\t\t\t\tdo {\n\t\t\t\t\tsize_t size_start;\n\t\t\t\t\tsize_t size_end;\n\t\t\t\t\tsize_t nshards;\n\t\t\t\t\tbool err = malloc_conf_multi_sizes_next(\n\t\t\t\t\t &bin_shards_segment_cur, &vlen_left,\n\t\t\t\t\t &size_start, &size_end, &nshards);\n\t\t\t\t\tif (err || bin_update_shard_size(\n\t\t\t\t\t bin_shard_sizes, size_start,\n\t\t\t\t\t size_end, nshards)) {\n\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t \"Invalid settings for \"\n\t\t\t\t\t\t \"bin_shards\", k, klen, v,\n\t\t\t\t\t\t vlen);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} while (vlen_left > 0);\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tCONF_HANDLE_INT64_T(opt_mutex_max_spin,\n\t\t\t \"mutex_max_spin\", -1, INT64_MAX, CONF_CHECK_MIN,\n\t\t\t CONF_DONT_CHECK_MAX, false);\n\t\t\tCONF_HANDLE_SSIZE_T(opt_dirty_decay_ms,\n\t\t\t \"dirty_decay_ms\", -1, NSTIME_SEC_MAX * KQU(1000) <\n\t\t\t QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) :\n\t\t\t SSIZE_MAX);\n\t\t\tCONF_HANDLE_SSIZE_T(opt_muzzy_decay_ms,\n\t\t\t \"muzzy_decay_ms\", -1, NSTIME_SEC_MAX * KQU(1000) <\n\t\t\t QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) :\n\t\t\t SSIZE_MAX);\n\t\t\tCONF_HANDLE_BOOL(opt_stats_print, \"stats_print\")\n\t\t\tif (CONF_MATCH(\"stats_print_opts\")) {\n\t\t\t\tinit_opt_stats_opts(v, vlen,\n\t\t\t\t opt_stats_print_opts);\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tCONF_HANDLE_INT64_T(opt_stats_interval,\n\t\t\t \"stats_interval\", -1, INT64_MAX,\n\t\t\t CONF_CHECK_MIN, CONF_DONT_CHECK_MAX, false)\n\t\t\tif (CONF_MATCH(\"stats_interval_opts\")) {\n\t\t\t\tinit_opt_stats_opts(v, vlen,\n\t\t\t\t opt_stats_interval_opts);\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (config_fill) {\n\t\t\t\tif (CONF_MATCH(\"junk\")) {\n\t\t\t\t\tif (CONF_MATCH_VALUE(\"true\")) {\n\t\t\t\t\t\topt_junk = \"true\";\n\t\t\t\t\t\topt_junk_alloc = opt_junk_free =\n\t\t\t\t\t\t true;\n\t\t\t\t\t} else if (CONF_MATCH_VALUE(\"false\")) {\n\t\t\t\t\t\topt_junk = \"false\";\n\t\t\t\t\t\topt_junk_alloc = opt_junk_free =\n\t\t\t\t\t\t false;\n\t\t\t\t\t} else if (CONF_MATCH_VALUE(\"alloc\")) {\n\t\t\t\t\t\topt_junk = \"alloc\";\n\t\t\t\t\t\topt_junk_alloc = true;\n\t\t\t\t\t\topt_junk_free = false;\n\t\t\t\t\t} else if (CONF_MATCH_VALUE(\"free\")) {\n\t\t\t\t\t\topt_junk = \"free\";\n\t\t\t\t\t\topt_junk_alloc = false;\n\t\t\t\t\t\topt_junk_free = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t \"Invalid conf value\",\n\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t}\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\t\t\t\tCONF_HANDLE_BOOL(opt_zero, \"zero\")\n\t\t\t}\n\t\t\tif (config_utrace) {\n\t\t\t\tCONF_HANDLE_BOOL(opt_utrace, \"utrace\")\n\t\t\t}\n\t\t\tif (config_xmalloc) {\n\t\t\t\tCONF_HANDLE_BOOL(opt_xmalloc, \"xmalloc\")\n\t\t\t}\n\t\t\tif (config_enable_cxx) {\n\t\t\t\tCONF_HANDLE_BOOL(\n\t\t\t\t opt_experimental_infallible_new,\n\t\t\t\t \"experimental_infallible_new\")\n\t\t\t}\n\n\t\t\tCONF_HANDLE_BOOL(opt_tcache, \"tcache\")\n\t\t\tCONF_HANDLE_SIZE_T(opt_tcache_max, \"tcache_max\",\n\t\t\t 0, TCACHE_MAXCLASS_LIMIT, CONF_DONT_CHECK_MIN,\n\t\t\t CONF_CHECK_MAX, /* clip */ true)\n\t\t\tif (CONF_MATCH(\"lg_tcache_max\")) {\n\t\t\t\tsize_t m;\n\t\t\t\tCONF_VALUE_READ(size_t, m)\n\t\t\t\tif (CONF_VALUE_READ_FAIL()) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t} else {\n\t\t\t\t\t/* clip if necessary */\n\t\t\t\t\tif (m > TCACHE_LG_MAXCLASS_LIMIT) {\n\t\t\t\t\t\tm = TCACHE_LG_MAXCLASS_LIMIT;\n\t\t\t\t\t}\n\t\t\t\t\topt_tcache_max = (size_t)1 << m;\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\t/*\n\t\t\t * Anyone trying to set a value outside -16 to 16 is\n\t\t\t * deeply confused.\n\t\t\t */\n\t\t\tCONF_HANDLE_SSIZE_T(opt_lg_tcache_nslots_mul,\n\t\t\t \"lg_tcache_nslots_mul\", -16, 16)\n\t\t\t/* Ditto with values past 2048. */\n\t\t\tCONF_HANDLE_UNSIGNED(opt_tcache_nslots_small_min,\n\t\t\t \"tcache_nslots_small_min\", 1, 2048,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, /* clip */ true)\n\t\t\tCONF_HANDLE_UNSIGNED(opt_tcache_nslots_small_max,\n\t\t\t \"tcache_nslots_small_max\", 1, 2048,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, /* clip */ true)\n\t\t\tCONF_HANDLE_UNSIGNED(opt_tcache_nslots_large,\n\t\t\t \"tcache_nslots_large\", 1, 2048,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, /* clip */ true)\n\t\t\tCONF_HANDLE_SIZE_T(opt_tcache_gc_incr_bytes,\n\t\t\t \"tcache_gc_incr_bytes\", 1024, SIZE_T_MAX,\n\t\t\t CONF_CHECK_MIN, CONF_DONT_CHECK_MAX,\n\t\t\t /* clip */ true)\n\t\t\tCONF_HANDLE_SIZE_T(opt_tcache_gc_delay_bytes,\n\t\t\t \"tcache_gc_delay_bytes\", 0, SIZE_T_MAX,\n\t\t\t CONF_DONT_CHECK_MIN, CONF_DONT_CHECK_MAX,\n\t\t\t /* clip */ false)\n\t\t\tCONF_HANDLE_UNSIGNED(opt_lg_tcache_flush_small_div,\n\t\t\t \"lg_tcache_flush_small_div\", 1, 16,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, /* clip */ true)\n\t\t\tCONF_HANDLE_UNSIGNED(opt_lg_tcache_flush_large_div,\n\t\t\t \"lg_tcache_flush_large_div\", 1, 16,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, /* clip */ true)\n\n\t\t\t/*\n\t\t\t * The runtime option of oversize_threshold remains\n\t\t\t * undocumented. It may be tweaked in the next major\n\t\t\t * release (6.0). The default value 8M is rather\n\t\t\t * conservative / safe. Tuning it further down may\n\t\t\t * improve fragmentation a bit more, but may also cause\n\t\t\t * contention on the huge arena.\n\t\t\t */\n\t\t\tCONF_HANDLE_SIZE_T(opt_oversize_threshold,\n\t\t\t \"oversize_threshold\", 0, SC_LARGE_MAXCLASS,\n\t\t\t CONF_DONT_CHECK_MIN, CONF_CHECK_MAX, false)\n\t\t\tCONF_HANDLE_SIZE_T(opt_lg_extent_max_active_fit,\n\t\t\t \"lg_extent_max_active_fit\", 0,\n\t\t\t (sizeof(size_t) << 3), CONF_DONT_CHECK_MIN,\n\t\t\t CONF_CHECK_MAX, false)\n\n\t\t\tif (strncmp(\"percpu_arena\", k, klen) == 0) {\n\t\t\t\tbool match = false;\n\t\t\t\tfor (int m = percpu_arena_mode_names_base; m <\n\t\t\t\t percpu_arena_mode_names_limit; m++) {\n\t\t\t\t\tif (strncmp(percpu_arena_mode_names[m],\n\t\t\t\t\t v, vlen) == 0) {\n\t\t\t\t\t\tif (!have_percpu_arena) {\n\t\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t\t \"No getcpu support\",\n\t\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t\t}\n\t\t\t\t\t\topt_percpu_arena = m;\n\t\t\t\t\t\tmatch = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!match) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tCONF_HANDLE_BOOL(opt_background_thread,\n\t\t\t \"background_thread\");\n\t\t\tCONF_HANDLE_SIZE_T(opt_max_background_threads,\n\t\t\t\t\t \"max_background_threads\", 1,\n\t\t\t\t\t opt_max_background_threads,\n\t\t\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX,\n\t\t\t\t\t true);\n\t\t\tCONF_HANDLE_BOOL(opt_hpa, \"hpa\")\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_opts.slab_max_alloc,\n\t\t\t \"hpa_slab_max_alloc\", PAGE, HUGEPAGE,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, true);\n\n\t\t\t/*\n\t\t\t * Accept either a ratio-based or an exact hugification\n\t\t\t * threshold.\n\t\t\t */\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_opts.hugification_threshold,\n\t\t\t \"hpa_hugification_threshold\", PAGE, HUGEPAGE,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, true);\n\t\t\tif (CONF_MATCH(\"hpa_hugification_threshold_ratio\")) {\n\t\t\t\tfxp_t ratio;\n\t\t\t\tchar *end;\n\t\t\t\tbool err = fxp_parse(&ratio, v,\n\t\t\t\t &end);\n\t\t\t\tif (err || (size_t)(end - v) != vlen\n\t\t\t\t || ratio > FXP_INIT_INT(1)) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t} else {\n\t\t\t\t\topt_hpa_opts.hugification_threshold =\n\t\t\t\t\t fxp_mul_frac(HUGEPAGE, ratio);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\n\t\t\tCONF_HANDLE_UINT64_T(\n\t\t\t opt_hpa_opts.hugify_delay_ms, \"hpa_hugify_delay_ms\",\n\t\t\t 0, 0, CONF_DONT_CHECK_MIN, CONF_DONT_CHECK_MAX,\n\t\t\t false);\n\n\t\t\tCONF_HANDLE_UINT64_T(\n\t\t\t opt_hpa_opts.min_purge_interval_ms,\n\t\t\t \"hpa_min_purge_interval_ms\", 0, 0,\n\t\t\t CONF_DONT_CHECK_MIN, CONF_DONT_CHECK_MAX, false);\n\n\t\t\tif (CONF_MATCH(\"hpa_dirty_mult\")) {\n\t\t\t\tif (CONF_MATCH_VALUE(\"-1\")) {\n\t\t\t\t\topt_hpa_opts.dirty_mult = (fxp_t)-1;\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\t\t\t\tfxp_t ratio;\n\t\t\t\tchar *end;\n\t\t\t\tbool err = fxp_parse(&ratio, v,\n\t\t\t\t &end);\n\t\t\t\tif (err || (size_t)(end - v) != vlen) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t} else {\n\t\t\t\t\topt_hpa_opts.dirty_mult = ratio;\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_sec_opts.nshards,\n\t\t\t \"hpa_sec_nshards\", 0, 0, CONF_CHECK_MIN,\n\t\t\t CONF_DONT_CHECK_MAX, true);\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_sec_opts.max_alloc,\n\t\t\t \"hpa_sec_max_alloc\", PAGE, 0, CONF_CHECK_MIN,\n\t\t\t CONF_DONT_CHECK_MAX, true);\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_sec_opts.max_bytes,\n\t\t\t \"hpa_sec_max_bytes\", PAGE, 0, CONF_CHECK_MIN,\n\t\t\t CONF_DONT_CHECK_MAX, true);\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_sec_opts.bytes_after_flush,\n\t\t\t \"hpa_sec_bytes_after_flush\", PAGE, 0,\n\t\t\t CONF_CHECK_MIN, CONF_DONT_CHECK_MAX, true);\n\t\t\tCONF_HANDLE_SIZE_T(opt_hpa_sec_opts.batch_fill_extra,\n\t\t\t \"hpa_sec_batch_fill_extra\", 0, HUGEPAGE_PAGES,\n\t\t\t CONF_CHECK_MIN, CONF_CHECK_MAX, true);\n\n\t\t\tif (CONF_MATCH(\"slab_sizes\")) {\n\t\t\t\tif (CONF_MATCH_VALUE(\"default\")) {\n\t\t\t\t\tsc_data_init(sc_data);\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\t\t\t\tbool err;\n\t\t\t\tconst char *slab_size_segment_cur = v;\n\t\t\t\tsize_t vlen_left = vlen;\n\t\t\t\tdo {\n\t\t\t\t\tsize_t slab_start;\n\t\t\t\t\tsize_t slab_end;\n\t\t\t\t\tsize_t pgs;\n\t\t\t\t\terr = malloc_conf_multi_sizes_next(\n\t\t\t\t\t &slab_size_segment_cur,\n\t\t\t\t\t &vlen_left, &slab_start, &slab_end,\n\t\t\t\t\t &pgs);\n\t\t\t\t\tif (!err) {\n\t\t\t\t\t\tsc_data_update_slab_size(\n\t\t\t\t\t\t sc_data, slab_start,\n\t\t\t\t\t\t slab_end, (int)pgs);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tCONF_ERROR(\"Invalid settings \"\n\t\t\t\t\t\t \"for slab_sizes\",\n\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t}\n\t\t\t\t} while (!err && vlen_left > 0);\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (config_prof) {\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof, \"prof\")\n\t\t\t\tCONF_HANDLE_CHAR_P(opt_prof_prefix,\n\t\t\t\t \"prof_prefix\", \"jeprof\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_active, \"prof_active\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_thread_active_init,\n\t\t\t\t \"prof_thread_active_init\")\n\t\t\t\tCONF_HANDLE_SIZE_T(opt_lg_prof_sample,\n\t\t\t\t \"lg_prof_sample\", 0, (sizeof(uint64_t) << 3)\n\t\t\t\t - 1, CONF_DONT_CHECK_MIN, CONF_CHECK_MAX,\n\t\t\t\t true)\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_accum, \"prof_accum\")\n\t\t\t\tCONF_HANDLE_SSIZE_T(opt_lg_prof_interval,\n\t\t\t\t \"lg_prof_interval\", -1,\n\t\t\t\t (sizeof(uint64_t) << 3) - 1)\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_gdump, \"prof_gdump\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_final, \"prof_final\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_leak, \"prof_leak\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_leak_error,\n\t\t\t\t \"prof_leak_error\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_log, \"prof_log\")\n\t\t\t\tCONF_HANDLE_SSIZE_T(opt_prof_recent_alloc_max,\n\t\t\t\t \"prof_recent_alloc_max\", -1, SSIZE_MAX)\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_stats, \"prof_stats\")\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_sys_thread_name,\n\t\t\t\t \"prof_sys_thread_name\")\n\t\t\t\tif (CONF_MATCH(\"prof_time_resolution\")) {\n\t\t\t\t\tif (CONF_MATCH_VALUE(\"default\")) {\n\t\t\t\t\t\topt_prof_time_res =\n\t\t\t\t\t\t prof_time_res_default;\n\t\t\t\t\t} else if (CONF_MATCH_VALUE(\"high\")) {\n\t\t\t\t\t\tif (!config_high_res_timer) {\n\t\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t\t \"No high resolution\"\n\t\t\t\t\t\t\t \" timer support\",\n\t\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\topt_prof_time_res =\n\t\t\t\t\t\t\t prof_time_res_high;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t}\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\t\t\t\t/*\n\t\t\t\t * Undocumented. When set to false, don't\n\t\t\t\t * correct for an unbiasing bug in jeprof\n\t\t\t\t * attribution. This can be handy if you want\n\t\t\t\t * to get consistent numbers from your binary\n\t\t\t\t * across different jemalloc versions, even if\n\t\t\t\t * those numbers are incorrect. The default is\n\t\t\t\t * true.\n\t\t\t\t */\n\t\t\t\tCONF_HANDLE_BOOL(opt_prof_unbias, \"prof_unbias\")\n\t\t\t}\n\t\t\tif (config_log) {\n\t\t\t\tif (CONF_MATCH(\"log\")) {\n\t\t\t\t\tsize_t cpylen = (\n\t\t\t\t\t vlen <= sizeof(log_var_names) ?\n\t\t\t\t\t vlen : sizeof(log_var_names) - 1);\n\t\t\t\t\tstrncpy(log_var_names, v, cpylen);\n\t\t\t\t\tlog_var_names[cpylen] = '\\0';\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (CONF_MATCH(\"thp\")) {\n\t\t\t\tbool match = false;\n\t\t\t\tfor (int m = 0; m < thp_mode_names_limit; m++) {\n\t\t\t\t\tif (strncmp(thp_mode_names[m],v, vlen)\n\t\t\t\t\t == 0) {\n\t\t\t\t\t\tif (!have_madvise_huge && !have_memcntl) {\n\t\t\t\t\t\t\tCONF_ERROR(\n\t\t\t\t\t\t\t \"No THP support\",\n\t\t\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t\t\t}\n\t\t\t\t\t\topt_thp = m;\n\t\t\t\t\t\tmatch = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!match) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (CONF_MATCH(\"zero_realloc\")) {\n\t\t\t\tif (CONF_MATCH_VALUE(\"alloc\")) {\n\t\t\t\t\topt_zero_realloc_action\n\t\t\t\t\t = zero_realloc_action_alloc;\n\t\t\t\t} else if (CONF_MATCH_VALUE(\"free\")) {\n\t\t\t\t\topt_zero_realloc_action\n\t\t\t\t\t = zero_realloc_action_free;\n\t\t\t\t} else if (CONF_MATCH_VALUE(\"abort\")) {\n\t\t\t\t\topt_zero_realloc_action\n\t\t\t\t\t = zero_realloc_action_abort;\n\t\t\t\t} else {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\t\t\tif (config_uaf_detection &&\n\t\t\t CONF_MATCH(\"lg_san_uaf_align\")) {\n\t\t\t\tssize_t a;\n\t\t\t\tCONF_VALUE_READ(ssize_t, a)\n\t\t\t\tif (CONF_VALUE_READ_FAIL() || a < -1) {\n\t\t\t\t\tCONF_ERROR(\"Invalid conf value\",\n\t\t\t\t\t k, klen, v, vlen);\n\t\t\t\t}\n\t\t\t\tif (a == -1) {\n\t\t\t\t\topt_lg_san_uaf_align = -1;\n\t\t\t\t\tCONF_CONTINUE;\n\t\t\t\t}\n\n\t\t\t\t/* clip if necessary */\n\t\t\t\tssize_t max_allowed = (sizeof(size_t) << 3) - 1;\n\t\t\t\tssize_t min_allowed = LG_PAGE;\n\t\t\t\tif (a > max_allowed) {\n\t\t\t\t\ta = max_allowed;\n\t\t\t\t} else if (a < min_allowed) {\n\t\t\t\t\ta = min_allowed;\n\t\t\t\t}\n\n\t\t\t\topt_lg_san_uaf_align = a;\n\t\t\t\tCONF_CONTINUE;\n\t\t\t}\n\n\t\t\tCONF_HANDLE_SIZE_T(opt_san_guard_small,\n\t\t\t \"san_guard_small\", 0, SIZE_T_MAX,\n\t\t\t CONF_DONT_CHECK_MIN, CONF_DONT_CHECK_MAX, false)\n\t\t\tCONF_HANDLE_SIZE_T(opt_san_guard_large,\n\t\t\t \"san_guard_large\", 0, SIZE_T_MAX,\n\t\t\t CONF_DONT_CHECK_MIN, CONF_DONT_CHECK_MAX, false)\n\n\t\t\tCONF_ERROR(\"Invalid conf pair\", k, klen, v, vlen);\n#undef CONF_ERROR\n#undef CONF_CONTINUE\n#undef CONF_MATCH\n#undef CONF_MATCH_VALUE\n#undef CONF_HANDLE_BOOL\n#undef CONF_DONT_CHECK_MIN\n#undef CONF_CHECK_MIN\n#undef CONF_DONT_CHECK_MAX\n#undef CONF_CHECK_MAX\n#undef CONF_HANDLE_T\n#undef CONF_HANDLE_T_U\n#undef CONF_HANDLE_T_SIGNED\n#undef CONF_HANDLE_UNSIGNED\n#undef CONF_HANDLE_SIZE_T\n#undef CONF_HANDLE_SSIZE_T\n#undef CONF_HANDLE_CHAR_P\n /* Re-enable diagnostic \"-Wtype-limits\" */\n JEMALLOC_DIAGNOSTIC_POP\n\t\t}\n\t\tif (opt_abort_conf && had_conf_error) {\n\t\t\tmalloc_abort_invalid_conf();\n\t\t}\n\t}\n\tatomic_store_b(&log_init_done, true, ATOMIC_RELEASE);\n}\n\nstatic bool\nmalloc_conf_init_check_deps(void) {\n\tif (opt_prof_leak_error && !opt_prof_final) {\n\t\tmalloc_printf(\": prof_leak_error is set w/o \"\n\t\t \"prof_final.\\n\");\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic void\nmalloc_conf_init(sc_data_t *sc_data, unsigned bin_shard_sizes[SC_NBINS]) {\n\tconst char *opts_cache[MALLOC_CONF_NSOURCES] = {NULL, NULL, NULL, NULL,\n\t\tNULL};\n\tchar buf[PATH_MAX + 1];\n\n\t/* The first call only set the confirm_conf option and opts_cache */\n\tmalloc_conf_init_helper(NULL, NULL, true, opts_cache, buf);\n\tmalloc_conf_init_helper(sc_data, bin_shard_sizes, false, opts_cache,\n\t NULL);\n\tif (malloc_conf_init_check_deps()) {\n\t\t/* check_deps does warning msg only; abort below if needed. */\n\t\tif (opt_abort_conf) {\n\t\t\tmalloc_abort_invalid_conf();\n\t\t}\n\t}\n}\n\n#undef MALLOC_CONF_NSOURCES\n\nstatic bool\nmalloc_init_hard_needed(void) {\n\tif (malloc_initialized() || (IS_INITIALIZER && malloc_init_state ==\n\t malloc_init_recursible)) {\n\t\t/*\n\t\t * Another thread initialized the allocator before this one\n\t\t * acquired init_lock, or this thread is the initializing\n\t\t * thread, and it is recursively allocating.\n\t\t */\n\t\treturn false;\n\t}\n#ifdef JEMALLOC_THREADED_INIT\n\tif (malloc_initializer != NO_INITIALIZER && !IS_INITIALIZER) {\n\t\t/* Busy-wait until the initializing thread completes. */\n\t\tspin_t spinner = SPIN_INITIALIZER;\n\t\tdo {\n\t\t\tmalloc_mutex_unlock(TSDN_NULL, &init_lock);\n\t\t\tspin_adaptive(&spinner);\n\t\t\tmalloc_mutex_lock(TSDN_NULL, &init_lock);\n\t\t} while (!malloc_initialized());\n\t\treturn false;\n\t}\n#endif\n\treturn true;\n}\n\nstatic bool\nmalloc_init_hard_a0_locked() {\n\tmalloc_initializer = INITIALIZER;\n\n\tJEMALLOC_DIAGNOSTIC_PUSH\n\tJEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n\tsc_data_t sc_data = {0};\n\tJEMALLOC_DIAGNOSTIC_POP\n\n\t/*\n\t * Ordering here is somewhat tricky; we need sc_boot() first, since that\n\t * determines what the size classes will be, and then\n\t * malloc_conf_init(), since any slab size tweaking will need to be done\n\t * before sz_boot and bin_info_boot, which assume that the values they\n\t * read out of sc_data_global are final.\n\t */\n\tsc_boot(&sc_data);\n\tunsigned bin_shard_sizes[SC_NBINS];\n\tbin_shard_sizes_boot(bin_shard_sizes);\n\t/*\n\t * prof_boot0 only initializes opt_prof_prefix. We need to do it before\n\t * we parse malloc_conf options, in case malloc_conf parsing overwrites\n\t * it.\n\t */\n\tif (config_prof) {\n\t\tprof_boot0();\n\t}\n\tmalloc_conf_init(&sc_data, bin_shard_sizes);\n\tsan_init(opt_lg_san_uaf_align);\n\tsz_boot(&sc_data, opt_cache_oblivious);\n\tbin_info_boot(&sc_data, bin_shard_sizes);\n\n\tif (opt_stats_print) {\n\t\t/* Print statistics at exit. */\n\t\tif (atexit(stats_print_atexit) != 0) {\n\t\t\tmalloc_write(\": Error in atexit()\\n\");\n\t\t\tif (opt_abort) {\n\t\t\t\tabort();\n\t\t\t}\n\t\t}\n\t}\n\n\tif (stats_boot()) {\n\t\treturn true;\n\t}\n\tif (pages_boot()) {\n\t\treturn true;\n\t}\n\tif (base_boot(TSDN_NULL)) {\n\t\treturn true;\n\t}\n\t/* emap_global is static, hence zeroed. */\n\tif (emap_init(&arena_emap_global, b0get(), /* zeroed */ true)) {\n\t\treturn true;\n\t}\n\tif (extent_boot()) {\n\t\treturn true;\n\t}\n\tif (ctl_boot()) {\n\t\treturn true;\n\t}\n\tif (config_prof) {\n\t\tprof_boot1();\n\t}\n\tif (opt_hpa && !hpa_supported()) {\n\t\tmalloc_printf(\": HPA not supported in the current \"\n\t\t \"configuration; %s.\",\n\t\t opt_abort_conf ? \"aborting\" : \"disabling\");\n\t\tif (opt_abort_conf) {\n\t\t\tmalloc_abort_invalid_conf();\n\t\t} else {\n\t\t\topt_hpa = false;\n\t\t}\n\t}\n\tif (arena_boot(&sc_data, b0get(), opt_hpa)) {\n\t\treturn true;\n\t}\n\tif (tcache_boot(TSDN_NULL, b0get())) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&arenas_lock, \"arenas\", WITNESS_RANK_ARENAS,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\thook_boot();\n\t/*\n\t * Create enough scaffolding to allow recursive allocation in\n\t * malloc_ncpus().\n\t */\n\tnarenas_auto = 1;\n\tmanual_arena_base = narenas_auto + 1;\n\tmemset(arenas, 0, sizeof(arena_t *) * narenas_auto);\n\t/*\n\t * Initialize one arena here. The rest are lazily created in\n\t * arena_choose_hard().\n\t */\n\tif (arena_init(TSDN_NULL, 0, &arena_config_default) == NULL) {\n\t\treturn true;\n\t}\n\ta0 = arena_get(TSDN_NULL, 0, false);\n\n\tif (opt_hpa && !hpa_supported()) {\n\t\tmalloc_printf(\": HPA not supported in the current \"\n\t\t \"configuration; %s.\",\n\t\t opt_abort_conf ? \"aborting\" : \"disabling\");\n\t\tif (opt_abort_conf) {\n\t\t\tmalloc_abort_invalid_conf();\n\t\t} else {\n\t\t\topt_hpa = false;\n\t\t}\n\t} else if (opt_hpa) {\n\t\thpa_shard_opts_t hpa_shard_opts = opt_hpa_opts;\n\t\thpa_shard_opts.deferral_allowed = background_thread_enabled();\n\t\tif (pa_shard_enable_hpa(TSDN_NULL, &a0->pa_shard,\n\t\t &hpa_shard_opts, &opt_hpa_sec_opts)) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\tmalloc_init_state = malloc_init_a0_initialized;\n\n\treturn false;\n}\n\nstatic bool\nmalloc_init_hard_a0(void) {\n\tbool ret;\n\n\tmalloc_mutex_lock(TSDN_NULL, &init_lock);\n\tret = malloc_init_hard_a0_locked();\n\tmalloc_mutex_unlock(TSDN_NULL, &init_lock);\n\treturn ret;\n}\n\n/* Initialize data structures which may trigger recursive allocation. */\nstatic bool\nmalloc_init_hard_recursible(void) {\n\tmalloc_init_state = malloc_init_recursible;\n\n\tncpus = malloc_ncpus();\n\tif (opt_percpu_arena != percpu_arena_disabled) {\n\t\tbool cpu_count_is_deterministic =\n\t\t malloc_cpu_count_is_deterministic();\n\t\tif (!cpu_count_is_deterministic) {\n\t\t\t/*\n\t\t\t * If # of CPU is not deterministic, and narenas not\n\t\t\t * specified, disables per cpu arena since it may not\n\t\t\t * detect CPU IDs properly.\n\t\t\t */\n\t\t\tif (opt_narenas == 0) {\n\t\t\t\topt_percpu_arena = percpu_arena_disabled;\n\t\t\t\tmalloc_write(\": Number of CPUs \"\n\t\t\t\t \"detected is not deterministic. Per-CPU \"\n\t\t\t\t \"arena disabled.\\n\");\n\t\t\t\tif (opt_abort_conf) {\n\t\t\t\t\tmalloc_abort_invalid_conf();\n\t\t\t\t}\n\t\t\t\tif (opt_abort) {\n\t\t\t\t\tabort();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n#if (defined(JEMALLOC_HAVE_PTHREAD_ATFORK) && !defined(JEMALLOC_MUTEX_INIT_CB) \\\n && !defined(JEMALLOC_ZONE) && !defined(_WIN32) && \\\n !defined(__native_client__))\n\t/* LinuxThreads' pthread_atfork() allocates. */\n\tif (pthread_atfork(jemalloc_prefork, jemalloc_postfork_parent,\n\t jemalloc_postfork_child) != 0) {\n\t\tmalloc_write(\": Error in pthread_atfork()\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t\treturn true;\n\t}\n#endif\n\n\tif (background_thread_boot0()) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic unsigned\nmalloc_narenas_default(void) {\n\tassert(ncpus > 0);\n\t/*\n\t * For SMP systems, create more than one arena per CPU by\n\t * default.\n\t */\n\tif (ncpus > 1) {\n\t\tfxp_t fxp_ncpus = FXP_INIT_INT(ncpus);\n\t\tfxp_t goal = fxp_mul(fxp_ncpus, opt_narenas_ratio);\n\t\tuint32_t int_goal = fxp_round_nearest(goal);\n\t\tif (int_goal == 0) {\n\t\t\treturn 1;\n\t\t}\n\t\treturn int_goal;\n\t} else {\n\t\treturn 1;\n\t}\n}\n\nstatic percpu_arena_mode_t\npercpu_arena_as_initialized(percpu_arena_mode_t mode) {\n\tassert(!malloc_initialized());\n\tassert(mode <= percpu_arena_disabled);\n\n\tif (mode != percpu_arena_disabled) {\n\t\tmode += percpu_arena_mode_enabled_base;\n\t}\n\n\treturn mode;\n}\n\nstatic bool\nmalloc_init_narenas(void) {\n\tassert(ncpus > 0);\n\n\tif (opt_percpu_arena != percpu_arena_disabled) {\n\t\tif (!have_percpu_arena || malloc_getcpu() < 0) {\n\t\t\topt_percpu_arena = percpu_arena_disabled;\n\t\t\tmalloc_printf(\": perCPU arena getcpu() not \"\n\t\t\t \"available. Setting narenas to %u.\\n\", opt_narenas ?\n\t\t\t opt_narenas : malloc_narenas_default());\n\t\t\tif (opt_abort) {\n\t\t\t\tabort();\n\t\t\t}\n\t\t} else {\n\t\t\tif (ncpus >= MALLOCX_ARENA_LIMIT) {\n\t\t\t\tmalloc_printf(\": narenas w/ percpu\"\n\t\t\t\t \"arena beyond limit (%d)\\n\", ncpus);\n\t\t\t\tif (opt_abort) {\n\t\t\t\t\tabort();\n\t\t\t\t}\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t/* NB: opt_percpu_arena isn't fully initialized yet. */\n\t\t\tif (percpu_arena_as_initialized(opt_percpu_arena) ==\n\t\t\t per_phycpu_arena && ncpus % 2 != 0) {\n\t\t\t\tmalloc_printf(\": invalid \"\n\t\t\t\t \"configuration -- per physical CPU arena \"\n\t\t\t\t \"with odd number (%u) of CPUs (no hyper \"\n\t\t\t\t \"threading?).\\n\", ncpus);\n\t\t\t\tif (opt_abort)\n\t\t\t\t\tabort();\n\t\t\t}\n\t\t\tunsigned n = percpu_arena_ind_limit(\n\t\t\t percpu_arena_as_initialized(opt_percpu_arena));\n\t\t\tif (opt_narenas < n) {\n\t\t\t\t/*\n\t\t\t\t * If narenas is specified with percpu_arena\n\t\t\t\t * enabled, actual narenas is set as the greater\n\t\t\t\t * of the two. percpu_arena_choose will be free\n\t\t\t\t * to use any of the arenas based on CPU\n\t\t\t\t * id. This is conservative (at a small cost)\n\t\t\t\t * but ensures correctness.\n\t\t\t\t *\n\t\t\t\t * If for some reason the ncpus determined at\n\t\t\t\t * boot is not the actual number (e.g. because\n\t\t\t\t * of affinity setting from numactl), reserving\n\t\t\t\t * narenas this way provides a workaround for\n\t\t\t\t * percpu_arena.\n\t\t\t\t */\n\t\t\t\topt_narenas = n;\n\t\t\t}\n\t\t}\n\t}\n\tif (opt_narenas == 0) {\n\t\topt_narenas = malloc_narenas_default();\n\t}\n\tassert(opt_narenas > 0);\n\n\tnarenas_auto = opt_narenas;\n\t/*\n\t * Limit the number of arenas to the indexing range of MALLOCX_ARENA().\n\t */\n\tif (narenas_auto >= MALLOCX_ARENA_LIMIT) {\n\t\tnarenas_auto = MALLOCX_ARENA_LIMIT - 1;\n\t\tmalloc_printf(\": Reducing narenas to limit (%d)\\n\",\n\t\t narenas_auto);\n\t}\n\tnarenas_total_set(narenas_auto);\n\tif (arena_init_huge()) {\n\t\tnarenas_total_inc();\n\t}\n\tmanual_arena_base = narenas_total_get();\n\n\treturn false;\n}\n\nstatic void\nmalloc_init_percpu(void) {\n\topt_percpu_arena = percpu_arena_as_initialized(opt_percpu_arena);\n}\n\nstatic bool\nmalloc_init_hard_finish(void) {\n\tif (malloc_mutex_boot()) {\n\t\treturn true;\n\t}\n\n\tmalloc_init_state = malloc_init_initialized;\n\tmalloc_slow_flag_init();\n\n\treturn false;\n}\n\nstatic void\nmalloc_init_hard_cleanup(tsdn_t *tsdn, bool reentrancy_set) {\n\tmalloc_mutex_assert_owner(tsdn, &init_lock);\n\tmalloc_mutex_unlock(tsdn, &init_lock);\n\tif (reentrancy_set) {\n\t\tassert(!tsdn_null(tsdn));\n\t\ttsd_t *tsd = tsdn_tsd(tsdn);\n\t\tassert(tsd_reentrancy_level_get(tsd) > 0);\n\t\tpost_reentrancy(tsd);\n\t}\n}\n\nstatic bool\nmalloc_init_hard(void) {\n\ttsd_t *tsd;\n\n#if defined(_WIN32) && _WIN32_WINNT < 0x0600\n\t_init_init_lock();\n#endif\n\tmalloc_mutex_lock(TSDN_NULL, &init_lock);\n\n#define UNLOCK_RETURN(tsdn, ret, reentrancy)\t\t\\\n\tmalloc_init_hard_cleanup(tsdn, reentrancy);\t\\\n\treturn ret;\n\n\tif (!malloc_init_hard_needed()) {\n\t\tUNLOCK_RETURN(TSDN_NULL, false, false)\n\t}\n\n\tif (malloc_init_state != malloc_init_a0_initialized &&\n\t malloc_init_hard_a0_locked()) {\n\t\tUNLOCK_RETURN(TSDN_NULL, true, false)\n\t}\n\n\tmalloc_mutex_unlock(TSDN_NULL, &init_lock);\n\t/* Recursive allocation relies on functional tsd. */\n\ttsd = malloc_tsd_boot0();\n\tif (tsd == NULL) {\n\t\treturn true;\n\t}\n\tif (malloc_init_hard_recursible()) {\n\t\treturn true;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &init_lock);\n\t/* Set reentrancy level to 1 during init. */\n\tpre_reentrancy(tsd, NULL);\n\t/* Initialize narenas before prof_boot2 (for allocation). */\n\tif (malloc_init_narenas()\n\t || background_thread_boot1(tsd_tsdn(tsd), b0get())) {\n\t\tUNLOCK_RETURN(tsd_tsdn(tsd), true, true)\n\t}\n\tif (config_prof && prof_boot2(tsd, b0get())) {\n\t\tUNLOCK_RETURN(tsd_tsdn(tsd), true, true)\n\t}\n\n\tmalloc_init_percpu();\n\n\tif (malloc_init_hard_finish()) {\n\t\tUNLOCK_RETURN(tsd_tsdn(tsd), true, true)\n\t}\n\tpost_reentrancy(tsd);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &init_lock);\n\n\twitness_assert_lockless(witness_tsd_tsdn(\n\t tsd_witness_tsdp_get_unsafe(tsd)));\n\tmalloc_tsd_boot1();\n\t/* Update TSD after tsd_boot1. */\n\ttsd = tsd_fetch();\n\tif (opt_background_thread) {\n\t\tassert(have_background_thread);\n\t\t/*\n\t\t * Need to finish init & unlock first before creating background\n\t\t * threads (pthread_create depends on malloc). ctl_init (which\n\t\t * sets isthreaded) needs to be called without holding any lock.\n\t\t */\n\t\tbackground_thread_ctl_init(tsd_tsdn(tsd));\n\t\tif (background_thread_create(tsd, 0)) {\n\t\t\treturn true;\n\t\t}\n\t}\n#undef UNLOCK_RETURN\n\treturn false;\n}\n\n/*\n * End initialization functions.\n */\n/******************************************************************************/\n/*\n * Begin allocation-path internal functions and data structures.\n */\n\n/*\n * Settings determined by the documented behavior of the allocation functions.\n */\ntypedef struct static_opts_s static_opts_t;\nstruct static_opts_s {\n\t/* Whether or not allocation size may overflow. */\n\tbool may_overflow;\n\n\t/*\n\t * Whether or not allocations (with alignment) of size 0 should be\n\t * treated as size 1.\n\t */\n\tbool bump_empty_aligned_alloc;\n\t/*\n\t * Whether to assert that allocations are not of size 0 (after any\n\t * bumping).\n\t */\n\tbool assert_nonempty_alloc;\n\n\t/*\n\t * Whether or not to modify the 'result' argument to malloc in case of\n\t * error.\n\t */\n\tbool null_out_result_on_error;\n\t/* Whether to set errno when we encounter an error condition. */\n\tbool set_errno_on_error;\n\n\t/*\n\t * The minimum valid alignment for functions requesting aligned storage.\n\t */\n\tsize_t min_alignment;\n\n\t/* The error string to use if we oom. */\n\tconst char *oom_string;\n\t/* The error string to use if the passed-in alignment is invalid. */\n\tconst char *invalid_alignment_string;\n\n\t/*\n\t * False if we're configured to skip some time-consuming operations.\n\t *\n\t * This isn't really a malloc \"behavior\", but it acts as a useful\n\t * summary of several other static (or at least, static after program\n\t * initialization) options.\n\t */\n\tbool slow;\n\t/*\n\t * Return size.\n\t */\n\tbool usize;\n};\n\nJEMALLOC_ALWAYS_INLINE void\nstatic_opts_init(static_opts_t *static_opts) {\n\tstatic_opts->may_overflow = false;\n\tstatic_opts->bump_empty_aligned_alloc = false;\n\tstatic_opts->assert_nonempty_alloc = false;\n\tstatic_opts->null_out_result_on_error = false;\n\tstatic_opts->set_errno_on_error = false;\n\tstatic_opts->min_alignment = 0;\n\tstatic_opts->oom_string = \"\";\n\tstatic_opts->invalid_alignment_string = \"\";\n\tstatic_opts->slow = false;\n\tstatic_opts->usize = false;\n}\n\n/*\n * These correspond to the macros in jemalloc/jemalloc_macros.h. Broadly, we\n * should have one constant here per magic value there. Note however that the\n * representations need not be related.\n */\n#define TCACHE_IND_NONE ((unsigned)-1)\n#define TCACHE_IND_AUTOMATIC ((unsigned)-2)\n#define ARENA_IND_AUTOMATIC ((unsigned)-1)\n\ntypedef struct dynamic_opts_s dynamic_opts_t;\nstruct dynamic_opts_s {\n\tvoid **result;\n\tsize_t usize;\n\tsize_t num_items;\n\tsize_t item_size;\n\tsize_t alignment;\n\tbool zero;\n\tunsigned tcache_ind;\n\tunsigned arena_ind;\n};\n\nJEMALLOC_ALWAYS_INLINE void\ndynamic_opts_init(dynamic_opts_t *dynamic_opts) {\n\tdynamic_opts->result = NULL;\n\tdynamic_opts->usize = 0;\n\tdynamic_opts->num_items = 0;\n\tdynamic_opts->item_size = 0;\n\tdynamic_opts->alignment = 0;\n\tdynamic_opts->zero = false;\n\tdynamic_opts->tcache_ind = TCACHE_IND_AUTOMATIC;\n\tdynamic_opts->arena_ind = ARENA_IND_AUTOMATIC;\n}\n\n/*\n * ind parameter is optional and is only checked and filled if alignment == 0;\n * return true if result is out of range.\n */\nJEMALLOC_ALWAYS_INLINE bool\naligned_usize_get(size_t size, size_t alignment, size_t *usize, szind_t *ind,\n bool bump_empty_aligned_alloc) {\n\tassert(usize != NULL);\n\tif (alignment == 0) {\n\t\tif (ind != NULL) {\n\t\t\t*ind = sz_size2index(size);\n\t\t\tif (unlikely(*ind >= SC_NSIZES)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t*usize = sz_index2size(*ind);\n\t\t\tassert(*usize > 0 && *usize <= SC_LARGE_MAXCLASS);\n\t\t\treturn false;\n\t\t}\n\t\t*usize = sz_s2u(size);\n\t} else {\n\t\tif (bump_empty_aligned_alloc && unlikely(size == 0)) {\n\t\t\tsize = 1;\n\t\t}\n\t\t*usize = sz_sa2u(size, alignment);\n\t}\n\tif (unlikely(*usize == 0 || *usize > SC_LARGE_MAXCLASS)) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nzero_get(bool guarantee, bool slow) {\n\tif (config_fill && slow && unlikely(opt_zero)) {\n\t\treturn true;\n\t} else {\n\t\treturn guarantee;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE tcache_t *\ntcache_get_from_ind(tsd_t *tsd, unsigned tcache_ind, bool slow, bool is_alloc) {\n\ttcache_t *tcache;\n\tif (tcache_ind == TCACHE_IND_AUTOMATIC) {\n\t\tif (likely(!slow)) {\n\t\t\t/* Getting tcache ptr unconditionally. */\n\t\t\ttcache = tsd_tcachep_get(tsd);\n\t\t\tassert(tcache == tcache_get(tsd));\n\t\t} else if (is_alloc ||\n\t\t likely(tsd_reentrancy_level_get(tsd) == 0)) {\n\t\t\ttcache = tcache_get(tsd);\n\t\t} else {\n\t\t\ttcache = NULL;\n\t\t}\n\t} else {\n\t\t/*\n\t\t * Should not specify tcache on deallocation path when being\n\t\t * reentrant.\n\t\t */\n\t\tassert(is_alloc || tsd_reentrancy_level_get(tsd) == 0 ||\n\t\t tsd_state_nocleanup(tsd));\n\t\tif (tcache_ind == TCACHE_IND_NONE) {\n\t\t\ttcache = NULL;\n\t\t} else {\n\t\t\ttcache = tcaches_get(tsd, tcache_ind);\n\t\t}\n\t}\n\treturn tcache;\n}\n\n/* Return true if a manual arena is specified and arena_get() OOMs. */\nJEMALLOC_ALWAYS_INLINE bool\narena_get_from_ind(tsd_t *tsd, unsigned arena_ind, arena_t **arena_p) {\n\tif (arena_ind == ARENA_IND_AUTOMATIC) {\n\t\t/*\n\t\t * In case of automatic arena management, we defer arena\n\t\t * computation until as late as we can, hoping to fill the\n\t\t * allocation out of the tcache.\n\t\t */\n\t\t*arena_p = NULL;\n\t} else {\n\t\t*arena_p = arena_get(tsd_tsdn(tsd), arena_ind, true);\n\t\tif (unlikely(*arena_p == NULL) && arena_ind >= narenas_auto) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/* ind is ignored if dopts->alignment > 0. */\nJEMALLOC_ALWAYS_INLINE void *\nimalloc_no_sample(static_opts_t *sopts, dynamic_opts_t *dopts, tsd_t *tsd,\n size_t size, size_t usize, szind_t ind) {\n\t/* Fill in the tcache. */\n\ttcache_t *tcache = tcache_get_from_ind(tsd, dopts->tcache_ind,\n\t sopts->slow, /* is_alloc */ true);\n\n\t/* Fill in the arena. */\n\tarena_t *arena;\n\tif (arena_get_from_ind(tsd, dopts->arena_ind, &arena)) {\n\t\treturn NULL;\n\t}\n\n\tif (unlikely(dopts->alignment != 0)) {\n\t\treturn ipalloct(tsd_tsdn(tsd), usize, dopts->alignment,\n\t\t dopts->zero, tcache, arena);\n\t}\n\n\treturn iallocztm(tsd_tsdn(tsd), size, ind, dopts->zero, tcache, false,\n\t arena, sopts->slow);\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nimalloc_sample(static_opts_t *sopts, dynamic_opts_t *dopts, tsd_t *tsd,\n size_t usize, szind_t ind) {\n\tvoid *ret;\n\n\t/*\n\t * For small allocations, sampling bumps the usize. If so, we allocate\n\t * from the ind_large bucket.\n\t */\n\tszind_t ind_large;\n\tsize_t bumped_usize = usize;\n\n\tdopts->alignment = prof_sample_align(dopts->alignment);\n\tif (usize <= SC_SMALL_MAXCLASS) {\n\t\tassert(((dopts->alignment == 0) ?\n\t\t sz_s2u(SC_LARGE_MINCLASS) :\n\t\t sz_sa2u(SC_LARGE_MINCLASS, dopts->alignment))\n\t\t\t== SC_LARGE_MINCLASS);\n\t\tind_large = sz_size2index(SC_LARGE_MINCLASS);\n\t\tbumped_usize = sz_s2u(SC_LARGE_MINCLASS);\n\t\tret = imalloc_no_sample(sopts, dopts, tsd, bumped_usize,\n\t\t bumped_usize, ind_large);\n\t\tif (unlikely(ret == NULL)) {\n\t\t\treturn NULL;\n\t\t}\n\t\tarena_prof_promote(tsd_tsdn(tsd), ret, usize);\n\t} else {\n\t\tret = imalloc_no_sample(sopts, dopts, tsd, usize, usize, ind);\n\t}\n\tassert(prof_sample_aligned(ret));\n\n\treturn ret;\n}\n\n/*\n * Returns true if the allocation will overflow, and false otherwise. Sets\n * *size to the product either way.\n */\nJEMALLOC_ALWAYS_INLINE bool\ncompute_size_with_overflow(bool may_overflow, dynamic_opts_t *dopts,\n size_t *size) {\n\t/*\n\t * This function is just num_items * item_size, except that we may have\n\t * to check for overflow.\n\t */\n\n\tif (!may_overflow) {\n\t\tassert(dopts->num_items == 1);\n\t\t*size = dopts->item_size;\n\t\treturn false;\n\t}\n\n\t/* A size_t with its high-half bits all set to 1. */\n\tstatic const size_t high_bits = SIZE_T_MAX << (sizeof(size_t) * 8 / 2);\n\n\t*size = dopts->item_size * dopts->num_items;\n\n\tif (unlikely(*size == 0)) {\n\t\treturn (dopts->num_items != 0 && dopts->item_size != 0);\n\t}\n\n\t/*\n\t * We got a non-zero size, but we don't know if we overflowed to get\n\t * there. To avoid having to do a divide, we'll be clever and note that\n\t * if both A and B can be represented in N/2 bits, then their product\n\t * can be represented in N bits (without the possibility of overflow).\n\t */\n\tif (likely((high_bits & (dopts->num_items | dopts->item_size)) == 0)) {\n\t\treturn false;\n\t}\n\tif (likely(*size / dopts->item_size == dopts->num_items)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nJEMALLOC_ALWAYS_INLINE int\nimalloc_body(static_opts_t *sopts, dynamic_opts_t *dopts, tsd_t *tsd) {\n\t/* Where the actual allocated memory will live. */\n\tvoid *allocation = NULL;\n\t/* Filled in by compute_size_with_overflow below. */\n\tsize_t size = 0;\n\t/*\n\t * The zero initialization for ind is actually dead store, in that its\n\t * value is reset before any branch on its value is taken. Sometimes\n\t * though, it's convenient to pass it as arguments before this point.\n\t * To avoid undefined behavior then, we initialize it with dummy stores.\n\t */\n\tszind_t ind = 0;\n\t/* usize will always be properly initialized. */\n\tsize_t usize;\n\n\t/* Reentrancy is only checked on slow path. */\n\tint8_t reentrancy_level;\n\n\t/* Compute the amount of memory the user wants. */\n\tif (unlikely(compute_size_with_overflow(sopts->may_overflow, dopts,\n\t &size))) {\n\t\tgoto label_oom;\n\t}\n\n\tif (unlikely(dopts->alignment < sopts->min_alignment\n\t || (dopts->alignment & (dopts->alignment - 1)) != 0)) {\n\t\tgoto label_invalid_alignment;\n\t}\n\n\t/* This is the beginning of the \"core\" algorithm. */\n\tdopts->zero = zero_get(dopts->zero, sopts->slow);\n\tif (aligned_usize_get(size, dopts->alignment, &usize, &ind,\n\t sopts->bump_empty_aligned_alloc)) {\n\t\tgoto label_oom;\n\t}\n\tdopts->usize = usize;\n\t/* Validate the user input. */\n\tif (sopts->assert_nonempty_alloc) {\n\t\tassert (size != 0);\n\t}\n\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\t/*\n\t * If we need to handle reentrancy, we can do it out of a\n\t * known-initialized arena (i.e. arena 0).\n\t */\n\treentrancy_level = tsd_reentrancy_level_get(tsd);\n\tif (sopts->slow && unlikely(reentrancy_level > 0)) {\n\t\t/*\n\t\t * We should never specify particular arenas or tcaches from\n\t\t * within our internal allocations.\n\t\t */\n\t\tassert(dopts->tcache_ind == TCACHE_IND_AUTOMATIC ||\n\t\t dopts->tcache_ind == TCACHE_IND_NONE);\n\t\tassert(dopts->arena_ind == ARENA_IND_AUTOMATIC);\n\t\tdopts->tcache_ind = TCACHE_IND_NONE;\n\t\t/* We know that arena 0 has already been initialized. */\n\t\tdopts->arena_ind = 0;\n\t}\n\n\t/*\n\t * If dopts->alignment > 0, then ind is still 0, but usize was computed\n\t * in the previous if statement. Down the positive alignment path,\n\t * imalloc_no_sample and imalloc_sample will ignore ind.\n\t */\n\n\t/* If profiling is on, get our profiling context. */\n\tif (config_prof && opt_prof) {\n\t\tbool prof_active = prof_active_get_unlocked();\n\t\tbool sample_event = te_prof_sample_event_lookahead(tsd, usize);\n\t\tprof_tctx_t *tctx = prof_alloc_prep(tsd, prof_active,\n\t\t sample_event);\n\n\t\temap_alloc_ctx_t alloc_ctx;\n\t\tif (likely((uintptr_t)tctx == (uintptr_t)1U)) {\n\t\t\talloc_ctx.slab = (usize <= SC_SMALL_MAXCLASS);\n\t\t\tallocation = imalloc_no_sample(\n\t\t\t sopts, dopts, tsd, usize, usize, ind);\n\t\t} else if ((uintptr_t)tctx > (uintptr_t)1U) {\n\t\t\tallocation = imalloc_sample(\n\t\t\t sopts, dopts, tsd, usize, ind);\n\t\t\talloc_ctx.slab = false;\n\t\t} else {\n\t\t\tallocation = NULL;\n\t\t}\n\n\t\tif (unlikely(allocation == NULL)) {\n\t\t\tprof_alloc_rollback(tsd, tctx);\n\t\t\tgoto label_oom;\n\t\t}\n\t\tprof_malloc(tsd, allocation, size, usize, &alloc_ctx, tctx);\n\t} else {\n\t\tassert(!opt_prof);\n\t\tallocation = imalloc_no_sample(sopts, dopts, tsd, size, usize,\n\t\t ind);\n\t\tif (unlikely(allocation == NULL)) {\n\t\t\tgoto label_oom;\n\t\t}\n\t}\n\n\t/*\n\t * Allocation has been done at this point. We still have some\n\t * post-allocation work to do though.\n\t */\n\n\tthread_alloc_event(tsd, usize);\n\n\tassert(dopts->alignment == 0\n\t || ((uintptr_t)allocation & (dopts->alignment - 1)) == ZU(0));\n\n\tassert(usize == isalloc(tsd_tsdn(tsd), allocation));\n\n\tif (config_fill && sopts->slow && !dopts->zero\n\t && unlikely(opt_junk_alloc)) {\n\t\tjunk_alloc_callback(allocation, usize);\n\t}\n\n\tif (sopts->slow) {\n\t\tUTRACE(0, size, allocation);\n\t}\n\n\t/* Success! */\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\t*dopts->result = allocation;\n\treturn 0;\n\nlabel_oom:\n\tif (unlikely(sopts->slow) && config_xmalloc && unlikely(opt_xmalloc)) {\n\t\tmalloc_write(sopts->oom_string);\n\t\tabort();\n\t}\n\n\tif (sopts->slow) {\n\t\tUTRACE(NULL, size, NULL);\n\t}\n\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tif (sopts->set_errno_on_error) {\n\t\tset_errno(ENOMEM);\n\t}\n\n\tif (sopts->null_out_result_on_error) {\n\t\t*dopts->result = NULL;\n\t}\n\n\treturn ENOMEM;\n\n\t/*\n\t * This label is only jumped to by one goto; we move it out of line\n\t * anyways to avoid obscuring the non-error paths, and for symmetry with\n\t * the oom case.\n\t */\nlabel_invalid_alignment:\n\tif (config_xmalloc && unlikely(opt_xmalloc)) {\n\t\tmalloc_write(sopts->invalid_alignment_string);\n\t\tabort();\n\t}\n\n\tif (sopts->set_errno_on_error) {\n\t\tset_errno(EINVAL);\n\t}\n\n\tif (sopts->slow) {\n\t\tUTRACE(NULL, size, NULL);\n\t}\n\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tif (sopts->null_out_result_on_error) {\n\t\t*dopts->result = NULL;\n\t}\n\n\treturn EINVAL;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nimalloc_init_check(static_opts_t *sopts, dynamic_opts_t *dopts) {\n\tif (unlikely(!malloc_initialized()) && unlikely(malloc_init())) {\n\t\tif (config_xmalloc && unlikely(opt_xmalloc)) {\n\t\t\tmalloc_write(sopts->oom_string);\n\t\t\tabort();\n\t\t}\n\t\tUTRACE(NULL, dopts->num_items * dopts->item_size, NULL);\n\t\tset_errno(ENOMEM);\n\t\t*dopts->result = NULL;\n\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n/* Returns the errno-style error code of the allocation. */\nJEMALLOC_ALWAYS_INLINE int\nimalloc(static_opts_t *sopts, dynamic_opts_t *dopts) {\n\tif (tsd_get_allocates() && !imalloc_init_check(sopts, dopts)) {\n\t\treturn ENOMEM;\n\t}\n\n\t/* We always need the tsd. Let's grab it right away. */\n\ttsd_t *tsd = tsd_fetch();\n\tassert(tsd);\n\tif (likely(tsd_fast(tsd))) {\n\t\t/* Fast and common path. */\n\t\ttsd_assert_fast(tsd);\n\t\tsopts->slow = false;\n\t\treturn imalloc_body(sopts, dopts, tsd);\n\t} else {\n\t\tif (!tsd_get_allocates() && !imalloc_init_check(sopts, dopts)) {\n\t\t\treturn ENOMEM;\n\t\t}\n\n\t\tsopts->slow = true;\n\t\treturn imalloc_body(sopts, dopts, tsd);\n\t}\n}\n\nJEMALLOC_NOINLINE\nvoid *\nmalloc_default(size_t size, size_t *usize) {\n\tvoid *ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\t/*\n\t * This variant has logging hook on exit but not on entry. It's callled\n\t * only by je_malloc, below, which emits the entry one for us (and, if\n\t * it calls us, does so only via tail call).\n\t */\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.null_out_result_on_error = true;\n\tsopts.set_errno_on_error = true;\n\tsopts.oom_string = \": Error in malloc(): out of memory\\n\";\n\n\tdopts.result = &ret;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\n\timalloc(&sopts, &dopts);\n\t/*\n\t * Note that this branch gets optimized away -- it immediately follows\n\t * the check on tsd_fast that sets sopts.slow.\n\t */\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {size};\n\t\thook_invoke_alloc(hook_alloc_malloc, ret, (uintptr_t)ret, args);\n\t}\n\n\tLOG(\"core.malloc.exit\", \"result: %p\", ret);\n\n\tif (usize) *usize = dopts.usize;\n\treturn ret;\n}\n\n/******************************************************************************/\n/*\n * Begin malloc(3)-compatible functions.\n */\n\nstatic inline void *je_malloc_internal(size_t size, size_t *usize) {\n\treturn imalloc_fastpath(size, &malloc_default, usize);\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE(1)\nje_malloc(size_t size) {\n\treturn je_malloc_internal(size, NULL);\n}\n\nJEMALLOC_EXPORT int JEMALLOC_NOTHROW\nJEMALLOC_ATTR(nonnull(1))\nje_posix_memalign(void **memptr, size_t alignment, size_t size) {\n\tint ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.posix_memalign.entry\", \"mem ptr: %p, alignment: %zu, \"\n\t \"size: %zu\", memptr, alignment, size);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.bump_empty_aligned_alloc = true;\n\tsopts.min_alignment = sizeof(void *);\n\tsopts.oom_string =\n\t \": Error allocating aligned memory: out of memory\\n\";\n\tsopts.invalid_alignment_string =\n\t \": Error allocating aligned memory: invalid alignment\\n\";\n\n\tdopts.result = memptr;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tdopts.alignment = alignment;\n\n\tret = imalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {(uintptr_t)memptr, (uintptr_t)alignment,\n\t\t\t(uintptr_t)size};\n\t\thook_invoke_alloc(hook_alloc_posix_memalign, *memptr,\n\t\t (uintptr_t)ret, args);\n\t}\n\n\tLOG(\"core.posix_memalign.exit\", \"result: %d, alloc ptr: %p\", ret,\n\t *memptr);\n\n\treturn ret;\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE(2)\nje_aligned_alloc(size_t alignment, size_t size) {\n\tvoid *ret;\n\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.aligned_alloc.entry\", \"alignment: %zu, size: %zu\\n\",\n\t alignment, size);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.bump_empty_aligned_alloc = true;\n\tsopts.null_out_result_on_error = true;\n\tsopts.set_errno_on_error = true;\n\tsopts.min_alignment = 1;\n\tsopts.oom_string =\n\t \": Error allocating aligned memory: out of memory\\n\";\n\tsopts.invalid_alignment_string =\n\t \": Error allocating aligned memory: invalid alignment\\n\";\n\n\tdopts.result = &ret;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tdopts.alignment = alignment;\n\n\timalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {(uintptr_t)alignment, (uintptr_t)size};\n\t\thook_invoke_alloc(hook_alloc_aligned_alloc, ret,\n\t\t (uintptr_t)ret, args);\n\t}\n\n\tLOG(\"core.aligned_alloc.exit\", \"result: %p\", ret);\n\n\treturn ret;\n}\n\nstatic void *je_calloc_internal(size_t num, size_t size, size_t *usize) {\n\tvoid *ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.calloc.entry\", \"num: %zu, size: %zu\\n\", num, size);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.may_overflow = true;\n\tsopts.null_out_result_on_error = true;\n\tsopts.set_errno_on_error = true;\n\tsopts.oom_string = \": Error in calloc(): out of memory\\n\";\n\n\tdopts.result = &ret;\n\tdopts.num_items = num;\n\tdopts.item_size = size;\n\tdopts.zero = true;\n\n\timalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {(uintptr_t)num, (uintptr_t)size};\n\t\thook_invoke_alloc(hook_alloc_calloc, ret, (uintptr_t)ret, args);\n\t}\n\n\tLOG(\"core.calloc.exit\", \"result: %p\", ret);\n\n\tif (usize) *usize = dopts.usize;\n\treturn ret;\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE2(1, 2)\nje_calloc(size_t num, size_t size) {\n\treturn je_calloc_internal(num, size, NULL);\n}\n\nJEMALLOC_ALWAYS_INLINE void\nifree(tsd_t *tsd, void *ptr, tcache_t *tcache, bool slow_path, size_t *usable) {\n\tif (!slow_path) {\n\t\ttsd_assert_fast(tsd);\n\t}\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tif (tsd_reentrancy_level_get(tsd) != 0) {\n\t\tassert(slow_path);\n\t}\n\n\tassert(ptr != NULL);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr,\n\t &alloc_ctx);\n\tassert(alloc_ctx.szind != SC_NSIZES);\n\n\tsize_t usize = sz_index2size(alloc_ctx.szind);\n\tif (config_prof && opt_prof) {\n\t\tprof_free(tsd, ptr, usize, &alloc_ctx);\n\t}\n\n\tif (likely(!slow_path)) {\n\t\tidalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false,\n\t\t false);\n\t} else {\n\t\tif (config_fill && slow_path && opt_junk_free) {\n\t\t\tjunk_free_callback(ptr, usize);\n\t\t}\n\t\tidalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false,\n\t\t true);\n\t}\n\tthread_dalloc_event(tsd, usize);\n\tif (usable) *usable = usize;\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nmaybe_check_alloc_ctx(tsd_t *tsd, void *ptr, emap_alloc_ctx_t *alloc_ctx) {\n\tif (config_opt_size_checks) {\n\t\temap_alloc_ctx_t dbg_ctx;\n\t\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr,\n\t\t &dbg_ctx);\n\t\tif (alloc_ctx->szind != dbg_ctx.szind) {\n\t\t\tsafety_check_fail_sized_dealloc(\n\t\t\t /* current_dealloc */ true, ptr,\n\t\t\t /* true_size */ sz_size2index(dbg_ctx.szind),\n\t\t\t /* input_size */ sz_size2index(alloc_ctx->szind));\n\t\t\treturn true;\n\t\t}\n\t\tif (alloc_ctx->slab != dbg_ctx.slab) {\n\t\t\tsafety_check_fail(\n\t\t\t \"Internal heap corruption detected: \"\n\t\t\t \"mismatch in slab bit\");\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nJEMALLOC_ALWAYS_INLINE void\nisfree(tsd_t *tsd, void *ptr, size_t usize, tcache_t *tcache, bool slow_path) {\n\tif (!slow_path) {\n\t\ttsd_assert_fast(tsd);\n\t}\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tif (tsd_reentrancy_level_get(tsd) != 0) {\n\t\tassert(slow_path);\n\t}\n\n\tassert(ptr != NULL);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\n\temap_alloc_ctx_t alloc_ctx;\n\tif (!config_prof) {\n\t\talloc_ctx.szind = sz_size2index(usize);\n\t\talloc_ctx.slab = (alloc_ctx.szind < SC_NBINS);\n\t} else {\n\t\tif (likely(!prof_sample_aligned(ptr))) {\n\t\t\t/*\n\t\t\t * When the ptr is not page aligned, it was not sampled.\n\t\t\t * usize can be trusted to determine szind and slab.\n\t\t\t */\n\t\t\talloc_ctx.szind = sz_size2index(usize);\n\t\t\talloc_ctx.slab = (alloc_ctx.szind < SC_NBINS);\n\t\t} else if (opt_prof) {\n\t\t\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global,\n\t\t\t ptr, &alloc_ctx);\n\n\t\t\tif (config_opt_safety_checks) {\n\t\t\t\t/* Small alloc may have !slab (sampled). */\n\t\t\t\tif (unlikely(alloc_ctx.szind !=\n\t\t\t\t sz_size2index(usize))) {\n\t\t\t\t\tsafety_check_fail_sized_dealloc(\n\t\t\t\t\t /* current_dealloc */ true, ptr,\n\t\t\t\t\t /* true_size */ sz_index2size(\n\t\t\t\t\t alloc_ctx.szind),\n\t\t\t\t\t /* input_size */ usize);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\talloc_ctx.szind = sz_size2index(usize);\n\t\t\talloc_ctx.slab = (alloc_ctx.szind < SC_NBINS);\n\t\t}\n\t}\n\tbool fail = maybe_check_alloc_ctx(tsd, ptr, &alloc_ctx);\n\tif (fail) {\n\t\t/*\n\t\t * This is a heap corruption bug. In real life we'll crash; for\n\t\t * the unit test we just want to avoid breaking anything too\n\t\t * badly to get a test result out. Let's leak instead of trying\n\t\t * to free.\n\t\t */\n\t\treturn;\n\t}\n\n\tif (config_prof && opt_prof) {\n\t\tprof_free(tsd, ptr, usize, &alloc_ctx);\n\t}\n\tif (likely(!slow_path)) {\n\t\tisdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx,\n\t\t false);\n\t} else {\n\t\tif (config_fill && slow_path && opt_junk_free) {\n\t\t\tjunk_free_callback(ptr, usize);\n\t\t}\n\t\tisdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx,\n\t\t true);\n\t}\n\tthread_dalloc_event(tsd, usize);\n}\n\nJEMALLOC_NOINLINE\nvoid\nfree_default(void *ptr, size_t *usize) {\n\tUTRACE(ptr, 0, 0);\n\tif (likely(ptr != NULL)) {\n\t\t/*\n\t\t * We avoid setting up tsd fully (e.g. tcache, arena binding)\n\t\t * based on only free() calls -- other activities trigger the\n\t\t * minimal to full transition. This is because free() may\n\t\t * happen during thread shutdown after tls deallocation: if a\n\t\t * thread never had any malloc activities until then, a\n\t\t * fully-setup tsd won't be destructed properly.\n\t\t */\n\t\ttsd_t *tsd = tsd_fetch_min();\n\t\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\t\tif (likely(tsd_fast(tsd))) {\n\t\t\ttcache_t *tcache = tcache_get_from_ind(tsd,\n\t\t\t TCACHE_IND_AUTOMATIC, /* slow */ false,\n\t\t\t /* is_alloc */ false);\n\t\t\tifree(tsd, ptr, tcache, /* slow */ false, usize);\n\t\t} else {\n\t\t\ttcache_t *tcache = tcache_get_from_ind(tsd,\n\t\t\t TCACHE_IND_AUTOMATIC, /* slow */ true,\n\t\t\t /* is_alloc */ false);\n\t\t\tuintptr_t args_raw[3] = {(uintptr_t)ptr};\n\t\t\thook_invoke_dalloc(hook_dalloc_free, ptr, args_raw);\n\t\t\tifree(tsd, ptr, tcache, /* slow */ true, usize);\n\t\t}\n\n\t\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE bool\nfree_fastpath_nonfast_aligned(void *ptr, bool check_prof) {\n\t/*\n\t * free_fastpath do not handle two uncommon cases: 1) sampled profiled\n\t * objects and 2) sampled junk & stash for use-after-free detection.\n\t * Both have special alignments which are used to escape the fastpath.\n\t *\n\t * prof_sample is page-aligned, which covers the UAF check when both\n\t * are enabled (the assertion below). Avoiding redundant checks since\n\t * this is on the fastpath -- at most one runtime branch from this.\n\t */\n\tif (config_debug && cache_bin_nonfast_aligned(ptr)) {\n\t\tassert(prof_sample_aligned(ptr));\n\t}\n\n\tif (config_prof && check_prof) {\n\t\t/* When prof is enabled, the prof_sample alignment is enough. */\n\t\tif (prof_sample_aligned(ptr)) {\n\t\t\treturn true;\n\t\t} else {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tif (config_uaf_detection) {\n\t\tif (cache_bin_nonfast_aligned(ptr)) {\n\t\t\treturn true;\n\t\t} else {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn false;\n}\n\n/* Returns whether or not the free attempt was successful. */\nJEMALLOC_ALWAYS_INLINE\nbool free_fastpath(void *ptr, size_t size, bool size_hint, size_t *usable_size) {\n\ttsd_t *tsd = tsd_get(false);\n\t/* The branch gets optimized away unless tsd_get_allocates(). */\n\tif (unlikely(tsd == NULL)) {\n\t\treturn false;\n\t}\n\t/*\n\t * The tsd_fast() / initialized checks are folded into the branch\n\t * testing (deallocated_after >= threshold) later in this function.\n\t * The threshold will be set to 0 when !tsd_fast.\n\t */\n\tassert(tsd_fast(tsd) ||\n\t *tsd_thread_deallocated_next_event_fastp_get_unsafe(tsd) == 0);\n\n\temap_alloc_ctx_t alloc_ctx;\n\tif (!size_hint) {\n\t\tbool err = emap_alloc_ctx_try_lookup_fast(tsd,\n\t\t &arena_emap_global, ptr, &alloc_ctx);\n\n\t\t/* Note: profiled objects will have alloc_ctx.slab set */\n\t\tif (unlikely(err || !alloc_ctx.slab ||\n\t\t free_fastpath_nonfast_aligned(ptr,\n\t\t /* check_prof */ false))) {\n\t\t\treturn false;\n\t\t}\n\t\tassert(alloc_ctx.szind != SC_NSIZES);\n\t} else {\n\t\t/*\n\t\t * Check for both sizes that are too large, and for sampled /\n\t\t * special aligned objects. The alignment check will also check\n\t\t * for null ptr.\n\t\t */\n\t\tif (unlikely(size > SC_LOOKUP_MAXCLASS ||\n\t\t free_fastpath_nonfast_aligned(ptr,\n\t\t /* check_prof */ true))) {\n\t\t\treturn false;\n\t\t}\n\t\talloc_ctx.szind = sz_size2index_lookup(size);\n\t\t/* Max lookup class must be small. */\n\t\tassert(alloc_ctx.szind < SC_NBINS);\n\t\t/* This is a dead store, except when opt size checking is on. */\n\t\talloc_ctx.slab = true;\n\t}\n\t/*\n\t * Currently the fastpath only handles small sizes. The branch on\n\t * SC_LOOKUP_MAXCLASS makes sure of it. This lets us avoid checking\n\t * tcache szind upper limit (i.e. tcache_maxclass) as well.\n\t */\n\tassert(alloc_ctx.slab);\n\n\tuint64_t deallocated, threshold;\n\tte_free_fastpath_ctx(tsd, &deallocated, &threshold);\n\n\tsize_t usize = sz_index2size(alloc_ctx.szind);\n\tuint64_t deallocated_after = deallocated + usize;\n\t/*\n\t * Check for events and tsd non-nominal (fast_threshold will be set to\n\t * 0) in a single branch. Note that this handles the uninitialized case\n\t * as well (TSD init will be triggered on the non-fastpath). Therefore\n\t * anything depends on a functional TSD (e.g. the alloc_ctx sanity check\n\t * below) needs to be after this branch.\n\t */\n\tif (unlikely(deallocated_after >= threshold)) {\n\t\treturn false;\n\t}\n\tassert(tsd_fast(tsd));\n\tbool fail = maybe_check_alloc_ctx(tsd, ptr, &alloc_ctx);\n\tif (fail) {\n\t\t/* See the comment in isfree. */\n\t\tif (usable_size) *usable_size = usize;\n\t\treturn true;\n\t}\n\n\ttcache_t *tcache = tcache_get_from_ind(tsd, TCACHE_IND_AUTOMATIC,\n\t /* slow */ false, /* is_alloc */ false);\n\tcache_bin_t *bin = &tcache->bins[alloc_ctx.szind];\n\n\t/*\n\t * If junking were enabled, this is where we would do it. It's not\n\t * though, since we ensured above that we're on the fast path. Assert\n\t * that to double-check.\n\t */\n\tassert(!opt_junk_free);\n\n\tif (!cache_bin_dalloc_easy(bin, ptr)) {\n\t\treturn false;\n\t}\n\n\t*tsd_thread_deallocatedp_get(tsd) = deallocated_after;\n\n\tif (usable_size) *usable_size = usize;\n\treturn true;\n}\n\nstatic inline void je_free_internal(void *ptr, size_t *usize) {\n\tLOG(\"core.free.entry\", \"ptr: %p\", ptr);\n\n\tif (!free_fastpath(ptr, 0, false, usize)) {\n\t\tfree_default(ptr, usize);\n\t}\n\n\tLOG(\"core.free.exit\", \"\");\n}\n\nJEMALLOC_EXPORT void JEMALLOC_NOTHROW\nje_free(void *ptr) {\n\tje_free_internal(ptr, NULL);\n}\n\n/*\n * End malloc(3)-compatible functions.\n */\n/******************************************************************************/\n/*\n * Begin non-standard override functions.\n */\n\n#ifdef JEMALLOC_OVERRIDE_MEMALIGN\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc)\nje_memalign(size_t alignment, size_t size) {\n\tvoid *ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.memalign.entry\", \"alignment: %zu, size: %zu\\n\", alignment,\n\t size);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.min_alignment = 1;\n\tsopts.oom_string =\n\t \": Error allocating aligned memory: out of memory\\n\";\n\tsopts.invalid_alignment_string =\n\t \": Error allocating aligned memory: invalid alignment\\n\";\n\tsopts.null_out_result_on_error = true;\n\n\tdopts.result = &ret;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tdopts.alignment = alignment;\n\n\timalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {alignment, size};\n\t\thook_invoke_alloc(hook_alloc_memalign, ret, (uintptr_t)ret,\n\t\t args);\n\t}\n\n\tLOG(\"core.memalign.exit\", \"result: %p\", ret);\n\treturn ret;\n}\n#endif\n\n#ifdef JEMALLOC_OVERRIDE_VALLOC\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc)\nje_valloc(size_t size) {\n\tvoid *ret;\n\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.valloc.entry\", \"size: %zu\\n\", size);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.null_out_result_on_error = true;\n\tsopts.min_alignment = PAGE;\n\tsopts.oom_string =\n\t \": Error allocating aligned memory: out of memory\\n\";\n\tsopts.invalid_alignment_string =\n\t \": Error allocating aligned memory: invalid alignment\\n\";\n\n\tdopts.result = &ret;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tdopts.alignment = PAGE;\n\n\timalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {size};\n\t\thook_invoke_alloc(hook_alloc_valloc, ret, (uintptr_t)ret, args);\n\t}\n\n\tLOG(\"core.valloc.exit\", \"result: %p\\n\", ret);\n\treturn ret;\n}\n#endif\n\n#if defined(JEMALLOC_IS_MALLOC) && defined(JEMALLOC_GLIBC_MALLOC_HOOK)\n/*\n * glibc provides the RTLD_DEEPBIND flag for dlopen which can make it possible\n * to inconsistently reference libc's malloc(3)-compatible functions\n * (https://bugzilla.mozilla.org/show_bug.cgi?id=493541).\n *\n * These definitions interpose hooks in glibc. The functions are actually\n * passed an extra argument for the caller return address, which will be\n * ignored.\n */\n#include // defines __GLIBC__ if we are compiling against glibc\n\nJEMALLOC_EXPORT void (*__free_hook)(void *ptr) = je_free;\nJEMALLOC_EXPORT void *(*__malloc_hook)(size_t size) = je_malloc;\nJEMALLOC_EXPORT void *(*__realloc_hook)(void *ptr, size_t size) = je_realloc;\n# ifdef JEMALLOC_GLIBC_MEMALIGN_HOOK\nJEMALLOC_EXPORT void *(*__memalign_hook)(size_t alignment, size_t size) =\n je_memalign;\n# endif\n\n# ifdef __GLIBC__\n/*\n * To enable static linking with glibc, the libc specific malloc interface must\n * be implemented also, so none of glibc's malloc.o functions are added to the\n * link.\n */\n# define ALIAS(je_fn)\t__attribute__((alias (#je_fn), used))\n/* To force macro expansion of je_ prefix before stringification. */\n# define PREALIAS(je_fn)\tALIAS(je_fn)\n# ifdef JEMALLOC_OVERRIDE___LIBC_CALLOC\nvoid *__libc_calloc(size_t n, size_t size) PREALIAS(je_calloc);\n# endif\n# ifdef JEMALLOC_OVERRIDE___LIBC_FREE\nvoid __libc_free(void* ptr) PREALIAS(je_free);\n# endif\n# ifdef JEMALLOC_OVERRIDE___LIBC_MALLOC\nvoid *__libc_malloc(size_t size) PREALIAS(je_malloc);\n# endif\n# ifdef JEMALLOC_OVERRIDE___LIBC_MEMALIGN\nvoid *__libc_memalign(size_t align, size_t s) PREALIAS(je_memalign);\n# endif\n# ifdef JEMALLOC_OVERRIDE___LIBC_REALLOC\nvoid *__libc_realloc(void* ptr, size_t size) PREALIAS(je_realloc);\n# endif\n# ifdef JEMALLOC_OVERRIDE___LIBC_VALLOC\nvoid *__libc_valloc(size_t size) PREALIAS(je_valloc);\n# endif\n# ifdef JEMALLOC_OVERRIDE___POSIX_MEMALIGN\nint __posix_memalign(void** r, size_t a, size_t s) PREALIAS(je_posix_memalign);\n# endif\n# undef PREALIAS\n# undef ALIAS\n# endif\n#endif\n\n/*\n * End non-standard override functions.\n */\n/******************************************************************************/\n/*\n * Begin non-standard functions.\n */\n\nJEMALLOC_ALWAYS_INLINE unsigned\nmallocx_tcache_get(int flags) {\n\tif (likely((flags & MALLOCX_TCACHE_MASK) == 0)) {\n\t\treturn TCACHE_IND_AUTOMATIC;\n\t} else if ((flags & MALLOCX_TCACHE_MASK) == MALLOCX_TCACHE_NONE) {\n\t\treturn TCACHE_IND_NONE;\n\t} else {\n\t\treturn MALLOCX_TCACHE_GET(flags);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE unsigned\nmallocx_arena_get(int flags) {\n\tif (unlikely((flags & MALLOCX_ARENA_MASK) != 0)) {\n\t\treturn MALLOCX_ARENA_GET(flags);\n\t} else {\n\t\treturn ARENA_IND_AUTOMATIC;\n\t}\n}\n\n#ifdef JEMALLOC_EXPERIMENTAL_SMALLOCX_API\n\n#define JEMALLOC_SMALLOCX_CONCAT_HELPER(x, y) x ## y\n#define JEMALLOC_SMALLOCX_CONCAT_HELPER2(x, y) \\\n JEMALLOC_SMALLOCX_CONCAT_HELPER(x, y)\n\ntypedef struct {\n\tvoid *ptr;\n\tsize_t size;\n} smallocx_return_t;\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nsmallocx_return_t JEMALLOC_NOTHROW\n/*\n * The attribute JEMALLOC_ATTR(malloc) cannot be used due to:\n * - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86488\n */\nJEMALLOC_SMALLOCX_CONCAT_HELPER2(je_smallocx_, JEMALLOC_VERSION_GID_IDENT)\n (size_t size, int flags) {\n\t/*\n\t * Note: the attribute JEMALLOC_ALLOC_SIZE(1) cannot be\n\t * used here because it makes writing beyond the `size`\n\t * of the `ptr` undefined behavior, but the objective\n\t * of this function is to allow writing beyond `size`\n\t * up to `smallocx_return_t::size`.\n\t */\n\tsmallocx_return_t ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.smallocx.entry\", \"size: %zu, flags: %d\", size, flags);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.assert_nonempty_alloc = true;\n\tsopts.null_out_result_on_error = true;\n\tsopts.oom_string = \": Error in mallocx(): out of memory\\n\";\n\tsopts.usize = true;\n\n\tdopts.result = &ret.ptr;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tif (unlikely(flags != 0)) {\n\t\tdopts.alignment = MALLOCX_ALIGN_GET(flags);\n\t\tdopts.zero = MALLOCX_ZERO_GET(flags);\n\t\tdopts.tcache_ind = mallocx_tcache_get(flags);\n\t\tdopts.arena_ind = mallocx_arena_get(flags);\n\t}\n\n\timalloc(&sopts, &dopts);\n\tassert(dopts.usize == je_nallocx(size, flags));\n\tret.size = dopts.usize;\n\n\tLOG(\"core.smallocx.exit\", \"result: %p, size: %zu\", ret.ptr, ret.size);\n\treturn ret;\n}\n#undef JEMALLOC_SMALLOCX_CONCAT_HELPER\n#undef JEMALLOC_SMALLOCX_CONCAT_HELPER2\n#endif\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE(1)\nje_mallocx(size_t size, int flags) {\n\tvoid *ret;\n\tstatic_opts_t sopts;\n\tdynamic_opts_t dopts;\n\n\tLOG(\"core.mallocx.entry\", \"size: %zu, flags: %d\", size, flags);\n\n\tstatic_opts_init(&sopts);\n\tdynamic_opts_init(&dopts);\n\n\tsopts.assert_nonempty_alloc = true;\n\tsopts.null_out_result_on_error = true;\n\tsopts.oom_string = \": Error in mallocx(): out of memory\\n\";\n\n\tdopts.result = &ret;\n\tdopts.num_items = 1;\n\tdopts.item_size = size;\n\tif (unlikely(flags != 0)) {\n\t\tdopts.alignment = MALLOCX_ALIGN_GET(flags);\n\t\tdopts.zero = MALLOCX_ZERO_GET(flags);\n\t\tdopts.tcache_ind = mallocx_tcache_get(flags);\n\t\tdopts.arena_ind = mallocx_arena_get(flags);\n\t}\n\n\timalloc(&sopts, &dopts);\n\tif (sopts.slow) {\n\t\tuintptr_t args[3] = {size, flags};\n\t\thook_invoke_alloc(hook_alloc_mallocx, ret, (uintptr_t)ret,\n\t\t args);\n\t}\n\n\tLOG(\"core.mallocx.exit\", \"result: %p\", ret);\n\treturn ret;\n}\n\nstatic void *\nirallocx_prof_sample(tsdn_t *tsdn, void *old_ptr, size_t old_usize,\n size_t usize, size_t alignment, bool zero, tcache_t *tcache, arena_t *arena,\n prof_tctx_t *tctx, hook_ralloc_args_t *hook_args) {\n\tvoid *p;\n\n\tif (tctx == NULL) {\n\t\treturn NULL;\n\t}\n\n\talignment = prof_sample_align(alignment);\n\tif (usize <= SC_SMALL_MAXCLASS) {\n\t\tp = iralloct(tsdn, old_ptr, old_usize,\n\t\t SC_LARGE_MINCLASS, alignment, zero, tcache,\n\t\t arena, hook_args);\n\t\tif (p == NULL) {\n\t\t\treturn NULL;\n\t\t}\n\t\tarena_prof_promote(tsdn, p, usize);\n\t} else {\n\t\tp = iralloct(tsdn, old_ptr, old_usize, usize, alignment, zero,\n\t\t tcache, arena, hook_args);\n\t}\n\tassert(prof_sample_aligned(p));\n\n\treturn p;\n}\n\nJEMALLOC_ALWAYS_INLINE void *\nirallocx_prof(tsd_t *tsd, void *old_ptr, size_t old_usize, size_t size,\n size_t alignment, size_t usize, bool zero, tcache_t *tcache,\n arena_t *arena, emap_alloc_ctx_t *alloc_ctx,\n hook_ralloc_args_t *hook_args) {\n\tprof_info_t old_prof_info;\n\tprof_info_get_and_reset_recent(tsd, old_ptr, alloc_ctx, &old_prof_info);\n\tbool prof_active = prof_active_get_unlocked();\n\tbool sample_event = te_prof_sample_event_lookahead(tsd, usize);\n\tprof_tctx_t *tctx = prof_alloc_prep(tsd, prof_active, sample_event);\n\tvoid *p;\n\tif (unlikely((uintptr_t)tctx != (uintptr_t)1U)) {\n\t\tp = irallocx_prof_sample(tsd_tsdn(tsd), old_ptr, old_usize,\n\t\t usize, alignment, zero, tcache, arena, tctx, hook_args);\n\t} else {\n\t\tp = iralloct(tsd_tsdn(tsd), old_ptr, old_usize, size, alignment,\n\t\t zero, tcache, arena, hook_args);\n\t}\n\tif (unlikely(p == NULL)) {\n\t\tprof_alloc_rollback(tsd, tctx);\n\t\treturn NULL;\n\t}\n\tassert(usize == isalloc(tsd_tsdn(tsd), p));\n\tprof_realloc(tsd, p, size, usize, tctx, prof_active, old_ptr,\n\t old_usize, &old_prof_info, sample_event);\n\n\treturn p;\n}\n\nstatic void *\ndo_rallocx(void *ptr, size_t size, int flags, bool is_realloc, size_t *old_usable_size, size_t *new_usable_size) {\n\tvoid *p;\n\ttsd_t *tsd;\n\tsize_t usize;\n\tsize_t old_usize;\n\tsize_t alignment = MALLOCX_ALIGN_GET(flags);\n\tarena_t *arena;\n\n\tassert(ptr != NULL);\n\tassert(size != 0);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\ttsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tbool zero = zero_get(MALLOCX_ZERO_GET(flags), /* slow */ true);\n\n\tunsigned arena_ind = mallocx_arena_get(flags);\n\tif (arena_get_from_ind(tsd, arena_ind, &arena)) {\n\t\tgoto label_oom;\n\t}\n\n\tunsigned tcache_ind = mallocx_tcache_get(flags);\n\ttcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind,\n\t /* slow */ true, /* is_alloc */ true);\n\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr,\n\t &alloc_ctx);\n\tassert(alloc_ctx.szind != SC_NSIZES);\n\told_usize = sz_index2size(alloc_ctx.szind);\n\tassert(old_usize == isalloc(tsd_tsdn(tsd), ptr));\n\tif (aligned_usize_get(size, alignment, &usize, NULL, false)) {\n\t\tgoto label_oom;\n\t}\n\n\thook_ralloc_args_t hook_args = {is_realloc, {(uintptr_t)ptr, size,\n\t\tflags, 0}};\n\tif (config_prof && opt_prof) {\n\t\tp = irallocx_prof(tsd, ptr, old_usize, size, alignment, usize,\n\t\t zero, tcache, arena, &alloc_ctx, &hook_args);\n\t\tif (unlikely(p == NULL)) {\n\t\t\tgoto label_oom;\n\t\t}\n\t} else {\n\t\tp = iralloct(tsd_tsdn(tsd), ptr, old_usize, size, alignment,\n\t\t zero, tcache, arena, &hook_args);\n\t\tif (unlikely(p == NULL)) {\n\t\t\tgoto label_oom;\n\t\t}\n\t\tassert(usize == isalloc(tsd_tsdn(tsd), p));\n\t}\n\tassert(alignment == 0 || ((uintptr_t)p & (alignment - 1)) == ZU(0));\n\tthread_alloc_event(tsd, usize);\n\tthread_dalloc_event(tsd, old_usize);\n\n\tUTRACE(ptr, size, p);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tif (config_fill && unlikely(opt_junk_alloc) && usize > old_usize\n\t && !zero) {\n\t\tsize_t excess_len = usize - old_usize;\n\t\tvoid *excess_start = (void *)((uintptr_t)p + old_usize);\n\t\tjunk_alloc_callback(excess_start, excess_len);\n\t}\n\n\tif (old_usable_size) *old_usable_size = old_usize;\n\tif (new_usable_size) *new_usable_size = usize;\n\treturn p;\nlabel_oom:\n\tif (config_xmalloc && unlikely(opt_xmalloc)) {\n\t\tmalloc_write(\": Error in rallocx(): out of memory\\n\");\n\t\tabort();\n\t}\n\tUTRACE(ptr, size, 0);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\treturn NULL;\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ALLOC_SIZE(2)\nje_rallocx(void *ptr, size_t size, int flags) {\n\tLOG(\"core.rallocx.entry\", \"ptr: %p, size: %zu, flags: %d\", ptr,\n\t size, flags);\n\tvoid *ret = do_rallocx(ptr, size, flags, false, NULL, NULL);\n\tLOG(\"core.rallocx.exit\", \"result: %p\", ret);\n\treturn ret;\n}\n\nstatic void *\ndo_realloc_nonnull_zero(void *ptr, size_t *old_usize, size_t *new_usize) {\n\tif (config_stats) {\n\t\tatomic_fetch_add_zu(&zero_realloc_count, 1, ATOMIC_RELAXED);\n\t}\n\tif (opt_zero_realloc_action == zero_realloc_action_alloc) {\n\t\t/*\n\t\t * The user might have gotten an alloc setting while expecting a\n\t\t * free setting. If that's the case, we at least try to\n\t\t * reduce the harm, and turn off the tcache while allocating, so\n\t\t * that we'll get a true first fit.\n\t\t */\n\t\treturn do_rallocx(ptr, 1, MALLOCX_TCACHE_NONE, true, old_usize, new_usize);\n\t} else if (opt_zero_realloc_action == zero_realloc_action_free) {\n\t\tUTRACE(ptr, 0, 0);\n\t\ttsd_t *tsd = tsd_fetch();\n\t\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\t\ttcache_t *tcache = tcache_get_from_ind(tsd,\n\t\t TCACHE_IND_AUTOMATIC, /* slow */ true,\n\t\t /* is_alloc */ false);\n\t\tuintptr_t args[3] = {(uintptr_t)ptr, 0};\n\t\thook_invoke_dalloc(hook_dalloc_realloc, ptr, args);\n\t\tsize_t usize;\n\t\tifree(tsd, ptr, tcache, true, &usize);\n\t\tif (old_usize) *old_usize = usize;\n\t\tif (new_usize) *new_usize = 0;\n\n\t\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\t\treturn NULL;\n\t} else {\n\t\tsafety_check_fail(\"Called realloc(non-null-ptr, 0) with \"\n\t\t \"zero_realloc:abort set\\n\");\n\t\t/* In real code, this will never run; the safety check failure\n\t\t * will call abort. In the unit test, we just want to bail out\n\t\t * without corrupting internal state that the test needs to\n\t\t * finish.\n\t\t */\n\t\treturn NULL;\n\t}\n}\n\nstatic inline void *je_realloc_internal(void *ptr, size_t size, size_t *old_usize, size_t *new_usize) {\n\tLOG(\"core.realloc.entry\", \"ptr: %p, size: %zu\\n\", ptr, size);\n\n\tif (likely(ptr != NULL && size != 0)) {\n\t\tvoid *ret = do_rallocx(ptr, size, 0, true, old_usize, new_usize);\n\t\tLOG(\"core.realloc.exit\", \"result: %p\", ret);\n\t\treturn ret;\n\t} else if (ptr != NULL && size == 0) {\n\t\tvoid *ret = do_realloc_nonnull_zero(ptr, old_usize, new_usize);\n\t\tLOG(\"core.realloc.exit\", \"result: %p\", ret);\n\t\treturn ret;\n\t} else {\n\t\t/* realloc(NULL, size) is equivalent to malloc(size). */\n\t\tvoid *ret;\n\n\t\tstatic_opts_t sopts;\n\t\tdynamic_opts_t dopts;\n\n\t\tstatic_opts_init(&sopts);\n\t\tdynamic_opts_init(&dopts);\n\n\t\tsopts.null_out_result_on_error = true;\n\t\tsopts.set_errno_on_error = true;\n\t\tsopts.oom_string =\n\t\t \": Error in realloc(): out of memory\\n\";\n\n\t\tdopts.result = &ret;\n\t\tdopts.num_items = 1;\n\t\tdopts.item_size = size;\n\n\t\timalloc(&sopts, &dopts);\n\t\tif (sopts.slow) {\n\t\t\tuintptr_t args[3] = {(uintptr_t)ptr, size};\n\t\t\thook_invoke_alloc(hook_alloc_realloc, ret,\n\t\t\t (uintptr_t)ret, args);\n\t\t}\n\t\tLOG(\"core.realloc.exit\", \"result: %p\", ret);\n\t\tif (old_usize) *old_usize = 0;\n\t\tif (new_usize) *new_usize = dopts.usize;\n\t\treturn ret;\n\t}\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ALLOC_SIZE(2)\nje_realloc(void *ptr, size_t size) {\n\treturn je_realloc_internal(ptr, size, NULL, NULL);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nixallocx_helper(tsdn_t *tsdn, void *ptr, size_t old_usize, size_t size,\n size_t extra, size_t alignment, bool zero) {\n\tsize_t newsize;\n\n\tif (ixalloc(tsdn, ptr, old_usize, size, extra, alignment, zero,\n\t &newsize)) {\n\t\treturn old_usize;\n\t}\n\n\treturn newsize;\n}\n\nstatic size_t\nixallocx_prof_sample(tsdn_t *tsdn, void *ptr, size_t old_usize, size_t size,\n size_t extra, size_t alignment, bool zero, prof_tctx_t *tctx) {\n\t/* Sampled allocation needs to be page aligned. */\n\tif (tctx == NULL || !prof_sample_aligned(ptr)) {\n\t\treturn old_usize;\n\t}\n\n\treturn ixallocx_helper(tsdn, ptr, old_usize, size, extra, alignment,\n\t zero);\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\nixallocx_prof(tsd_t *tsd, void *ptr, size_t old_usize, size_t size,\n size_t extra, size_t alignment, bool zero, emap_alloc_ctx_t *alloc_ctx) {\n\t/*\n\t * old_prof_info is only used for asserting that the profiling info\n\t * isn't changed by the ixalloc() call.\n\t */\n\tprof_info_t old_prof_info;\n\tprof_info_get(tsd, ptr, alloc_ctx, &old_prof_info);\n\n\t/*\n\t * usize isn't knowable before ixalloc() returns when extra is non-zero.\n\t * Therefore, compute its maximum possible value and use that in\n\t * prof_alloc_prep() to decide whether to capture a backtrace.\n\t * prof_realloc() will use the actual usize to decide whether to sample.\n\t */\n\tsize_t usize_max;\n\tif (aligned_usize_get(size + extra, alignment, &usize_max, NULL,\n\t false)) {\n\t\t/*\n\t\t * usize_max is out of range, and chances are that allocation\n\t\t * will fail, but use the maximum possible value and carry on\n\t\t * with prof_alloc_prep(), just in case allocation succeeds.\n\t\t */\n\t\tusize_max = SC_LARGE_MAXCLASS;\n\t}\n\tbool prof_active = prof_active_get_unlocked();\n\tbool sample_event = te_prof_sample_event_lookahead(tsd, usize_max);\n\tprof_tctx_t *tctx = prof_alloc_prep(tsd, prof_active, sample_event);\n\n\tsize_t usize;\n\tif (unlikely((uintptr_t)tctx != (uintptr_t)1U)) {\n\t\tusize = ixallocx_prof_sample(tsd_tsdn(tsd), ptr, old_usize,\n\t\t size, extra, alignment, zero, tctx);\n\t} else {\n\t\tusize = ixallocx_helper(tsd_tsdn(tsd), ptr, old_usize, size,\n\t\t extra, alignment, zero);\n\t}\n\n\t/*\n\t * At this point we can still safely get the original profiling\n\t * information associated with the ptr, because (a) the edata_t object\n\t * associated with the ptr still lives and (b) the profiling info\n\t * fields are not touched. \"(a)\" is asserted in the outer je_xallocx()\n\t * function, and \"(b)\" is indirectly verified below by checking that\n\t * the alloc_tctx field is unchanged.\n\t */\n\tprof_info_t prof_info;\n\tif (usize == old_usize) {\n\t\tprof_info_get(tsd, ptr, alloc_ctx, &prof_info);\n\t\tprof_alloc_rollback(tsd, tctx);\n\t} else {\n\t\tprof_info_get_and_reset_recent(tsd, ptr, alloc_ctx, &prof_info);\n\t\tassert(usize <= usize_max);\n\t\tsample_event = te_prof_sample_event_lookahead(tsd, usize);\n\t\tprof_realloc(tsd, ptr, size, usize, tctx, prof_active, ptr,\n\t\t old_usize, &prof_info, sample_event);\n\t}\n\n\tassert(old_prof_info.alloc_tctx == prof_info.alloc_tctx);\n\treturn usize;\n}\n\nJEMALLOC_EXPORT size_t JEMALLOC_NOTHROW\nje_xallocx(void *ptr, size_t size, size_t extra, int flags) {\n\ttsd_t *tsd;\n\tsize_t usize, old_usize;\n\tsize_t alignment = MALLOCX_ALIGN_GET(flags);\n\tbool zero = zero_get(MALLOCX_ZERO_GET(flags), /* slow */ true);\n\n\tLOG(\"core.xallocx.entry\", \"ptr: %p, size: %zu, extra: %zu, \"\n\t \"flags: %d\", ptr, size, extra, flags);\n\n\tassert(ptr != NULL);\n\tassert(size != 0);\n\tassert(SIZE_T_MAX - size >= extra);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\ttsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\t/*\n\t * old_edata is only for verifying that xallocx() keeps the edata_t\n\t * object associated with the ptr (though the content of the edata_t\n\t * object can be changed).\n\t */\n\tedata_t *old_edata = emap_edata_lookup(tsd_tsdn(tsd),\n\t &arena_emap_global, ptr);\n\n\temap_alloc_ctx_t alloc_ctx;\n\temap_alloc_ctx_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr,\n\t &alloc_ctx);\n\tassert(alloc_ctx.szind != SC_NSIZES);\n\told_usize = sz_index2size(alloc_ctx.szind);\n\tassert(old_usize == isalloc(tsd_tsdn(tsd), ptr));\n\t/*\n\t * The API explicitly absolves itself of protecting against (size +\n\t * extra) numerical overflow, but we may need to clamp extra to avoid\n\t * exceeding SC_LARGE_MAXCLASS.\n\t *\n\t * Ordinarily, size limit checking is handled deeper down, but here we\n\t * have to check as part of (size + extra) clamping, since we need the\n\t * clamped value in the above helper functions.\n\t */\n\tif (unlikely(size > SC_LARGE_MAXCLASS)) {\n\t\tusize = old_usize;\n\t\tgoto label_not_resized;\n\t}\n\tif (unlikely(SC_LARGE_MAXCLASS - size < extra)) {\n\t\textra = SC_LARGE_MAXCLASS - size;\n\t}\n\n\tif (config_prof && opt_prof) {\n\t\tusize = ixallocx_prof(tsd, ptr, old_usize, size, extra,\n\t\t alignment, zero, &alloc_ctx);\n\t} else {\n\t\tusize = ixallocx_helper(tsd_tsdn(tsd), ptr, old_usize, size,\n\t\t extra, alignment, zero);\n\t}\n\n\t/*\n\t * xallocx() should keep using the same edata_t object (though its\n\t * content can be changed).\n\t */\n\tassert(emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global, ptr)\n\t == old_edata);\n\n\tif (unlikely(usize == old_usize)) {\n\t\tgoto label_not_resized;\n\t}\n\tthread_alloc_event(tsd, usize);\n\tthread_dalloc_event(tsd, old_usize);\n\n\tif (config_fill && unlikely(opt_junk_alloc) && usize > old_usize &&\n\t !zero) {\n\t\tsize_t excess_len = usize - old_usize;\n\t\tvoid *excess_start = (void *)((uintptr_t)ptr + old_usize);\n\t\tjunk_alloc_callback(excess_start, excess_len);\n\t}\nlabel_not_resized:\n\tif (unlikely(!tsd_fast(tsd))) {\n\t\tuintptr_t args[4] = {(uintptr_t)ptr, size, extra, flags};\n\t\thook_invoke_expand(hook_expand_xallocx, ptr, old_usize,\n\t\t usize, (uintptr_t)usize, args);\n\t}\n\n\tUTRACE(ptr, size, ptr);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tLOG(\"core.xallocx.exit\", \"result: %zu\", usize);\n\treturn usize;\n}\n\nJEMALLOC_EXPORT size_t JEMALLOC_NOTHROW\nJEMALLOC_ATTR(pure)\nje_sallocx(const void *ptr, int flags) {\n\tsize_t usize;\n\ttsdn_t *tsdn;\n\n\tLOG(\"core.sallocx.entry\", \"ptr: %p, flags: %d\", ptr, flags);\n\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\tassert(ptr != NULL);\n\n\ttsdn = tsdn_fetch();\n\tcheck_entry_exit_locking(tsdn);\n\n\tif (config_debug || force_ivsalloc) {\n\t\tusize = ivsalloc(tsdn, ptr);\n\t\tassert(force_ivsalloc || usize != 0);\n\t} else {\n\t\tusize = isalloc(tsdn, ptr);\n\t}\n\n\tcheck_entry_exit_locking(tsdn);\n\n\tLOG(\"core.sallocx.exit\", \"result: %zu\", usize);\n\treturn usize;\n}\n\nJEMALLOC_EXPORT void JEMALLOC_NOTHROW\nje_dallocx(void *ptr, int flags) {\n\tLOG(\"core.dallocx.entry\", \"ptr: %p, flags: %d\", ptr, flags);\n\n\tassert(ptr != NULL);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\n\ttsd_t *tsd = tsd_fetch_min();\n\tbool fast = tsd_fast(tsd);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tunsigned tcache_ind = mallocx_tcache_get(flags);\n\ttcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast,\n\t /* is_alloc */ false);\n\n\tUTRACE(ptr, 0, 0);\n\tif (likely(fast)) {\n\t\ttsd_assert_fast(tsd);\n\t\tifree(tsd, ptr, tcache, false, NULL);\n\t} else {\n\t\tuintptr_t args_raw[3] = {(uintptr_t)ptr, flags};\n\t\thook_invoke_dalloc(hook_dalloc_dallocx, ptr, args_raw);\n\t\tifree(tsd, ptr, tcache, true, NULL);\n\t}\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tLOG(\"core.dallocx.exit\", \"\");\n}\n\nJEMALLOC_ALWAYS_INLINE size_t\ninallocx(tsdn_t *tsdn, size_t size, int flags) {\n\tcheck_entry_exit_locking(tsdn);\n\tsize_t usize;\n\t/* In case of out of range, let the user see it rather than fail. */\n\taligned_usize_get(size, MALLOCX_ALIGN_GET(flags), &usize, NULL, false);\n\tcheck_entry_exit_locking(tsdn);\n\treturn usize;\n}\n\nJEMALLOC_NOINLINE void\nsdallocx_default(void *ptr, size_t size, int flags) {\n\tassert(ptr != NULL);\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\n\ttsd_t *tsd = tsd_fetch_min();\n\tbool fast = tsd_fast(tsd);\n\tsize_t usize = inallocx(tsd_tsdn(tsd), size, flags);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tunsigned tcache_ind = mallocx_tcache_get(flags);\n\ttcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast,\n\t /* is_alloc */ false);\n\n\tUTRACE(ptr, 0, 0);\n\tif (likely(fast)) {\n\t\ttsd_assert_fast(tsd);\n\t\tisfree(tsd, ptr, usize, tcache, false);\n\t} else {\n\t\tuintptr_t args_raw[3] = {(uintptr_t)ptr, size, flags};\n\t\thook_invoke_dalloc(hook_dalloc_sdallocx, ptr, args_raw);\n\t\tisfree(tsd, ptr, usize, tcache, true);\n\t}\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n}\n\nJEMALLOC_EXPORT void JEMALLOC_NOTHROW\nje_sdallocx(void *ptr, size_t size, int flags) {\n\tLOG(\"core.sdallocx.entry\", \"ptr: %p, size: %zu, flags: %d\", ptr,\n\t\tsize, flags);\n\n\tif (flags != 0 || !free_fastpath(ptr, size, true, NULL)) {\n\t\tsdallocx_default(ptr, size, flags);\n\t}\n\n\tLOG(\"core.sdallocx.exit\", \"\");\n}\n\nvoid JEMALLOC_NOTHROW\nje_sdallocx_noflags(void *ptr, size_t size) {\n\tLOG(\"core.sdallocx.entry\", \"ptr: %p, size: %zu, flags: 0\", ptr,\n\t\tsize);\n\n\tif (!free_fastpath(ptr, size, true, NULL)) {\n\t\tsdallocx_default(ptr, size, 0);\n\t}\n\n\tLOG(\"core.sdallocx.exit\", \"\");\n}\n\nJEMALLOC_EXPORT size_t JEMALLOC_NOTHROW\nJEMALLOC_ATTR(pure)\nje_nallocx(size_t size, int flags) {\n\tsize_t usize;\n\ttsdn_t *tsdn;\n\n\tassert(size != 0);\n\n\tif (unlikely(malloc_init())) {\n\t\tLOG(\"core.nallocx.exit\", \"result: %zu\", ZU(0));\n\t\treturn 0;\n\t}\n\n\ttsdn = tsdn_fetch();\n\tcheck_entry_exit_locking(tsdn);\n\n\tusize = inallocx(tsdn, size, flags);\n\tif (unlikely(usize > SC_LARGE_MAXCLASS)) {\n\t\tLOG(\"core.nallocx.exit\", \"result: %zu\", ZU(0));\n\t\treturn 0;\n\t}\n\n\tcheck_entry_exit_locking(tsdn);\n\tLOG(\"core.nallocx.exit\", \"result: %zu\", usize);\n\treturn usize;\n}\n\nJEMALLOC_EXPORT int JEMALLOC_NOTHROW\nje_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp,\n size_t newlen) {\n\tint ret;\n\ttsd_t *tsd;\n\n\tLOG(\"core.mallctl.entry\", \"name: %s\", name);\n\n\tif (unlikely(malloc_init())) {\n\t\tLOG(\"core.mallctl.exit\", \"result: %d\", EAGAIN);\n\t\treturn EAGAIN;\n\t}\n\n\ttsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tret = ctl_byname(tsd, name, oldp, oldlenp, newp, newlen);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tLOG(\"core.mallctl.exit\", \"result: %d\", ret);\n\treturn ret;\n}\n\nJEMALLOC_EXPORT int JEMALLOC_NOTHROW\nje_mallctlnametomib(const char *name, size_t *mibp, size_t *miblenp) {\n\tint ret;\n\n\tLOG(\"core.mallctlnametomib.entry\", \"name: %s\", name);\n\n\tif (unlikely(malloc_init())) {\n\t\tLOG(\"core.mallctlnametomib.exit\", \"result: %d\", EAGAIN);\n\t\treturn EAGAIN;\n\t}\n\n\ttsd_t *tsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tret = ctl_nametomib(tsd, name, mibp, miblenp);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tLOG(\"core.mallctlnametomib.exit\", \"result: %d\", ret);\n\treturn ret;\n}\n\nJEMALLOC_EXPORT int JEMALLOC_NOTHROW\nje_mallctlbymib(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,\n void *newp, size_t newlen) {\n\tint ret;\n\ttsd_t *tsd;\n\n\tLOG(\"core.mallctlbymib.entry\", \"\");\n\n\tif (unlikely(malloc_init())) {\n\t\tLOG(\"core.mallctlbymib.exit\", \"result: %d\", EAGAIN);\n\t\treturn EAGAIN;\n\t}\n\n\ttsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tret = ctl_bymib(tsd, mib, miblen, oldp, oldlenp, newp, newlen);\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tLOG(\"core.mallctlbymib.exit\", \"result: %d\", ret);\n\treturn ret;\n}\n\n#define STATS_PRINT_BUFSIZE 65536\nJEMALLOC_EXPORT void JEMALLOC_NOTHROW\nje_malloc_stats_print(void (*write_cb)(void *, const char *), void *cbopaque,\n const char *opts) {\n\ttsdn_t *tsdn;\n\n\tLOG(\"core.malloc_stats_print.entry\", \"\");\n\n\ttsdn = tsdn_fetch();\n\tcheck_entry_exit_locking(tsdn);\n\n\tif (config_debug) {\n\t\tstats_print(write_cb, cbopaque, opts);\n\t} else {\n\t\tbuf_writer_t buf_writer;\n\t\tbuf_writer_init(tsdn, &buf_writer, write_cb, cbopaque, NULL,\n\t\t STATS_PRINT_BUFSIZE);\n\t\tstats_print(buf_writer_cb, &buf_writer, opts);\n\t\tbuf_writer_terminate(tsdn, &buf_writer);\n\t}\n\n\tcheck_entry_exit_locking(tsdn);\n\tLOG(\"core.malloc_stats_print.exit\", \"\");\n}\n#undef STATS_PRINT_BUFSIZE\n\nJEMALLOC_ALWAYS_INLINE size_t\nje_malloc_usable_size_impl(JEMALLOC_USABLE_SIZE_CONST void *ptr) {\n\tassert(malloc_initialized() || IS_INITIALIZER);\n\n\ttsdn_t *tsdn = tsdn_fetch();\n\tcheck_entry_exit_locking(tsdn);\n\n\tsize_t ret;\n\tif (unlikely(ptr == NULL)) {\n\t\tret = 0;\n\t} else {\n\t\tif (config_debug || force_ivsalloc) {\n\t\t\tret = ivsalloc(tsdn, ptr);\n\t\t\tassert(force_ivsalloc || ret != 0);\n\t\t} else {\n\t\t\tret = isalloc(tsdn, ptr);\n\t\t}\n\t}\n\tcheck_entry_exit_locking(tsdn);\n\n\treturn ret;\n}\n\nJEMALLOC_EXPORT size_t JEMALLOC_NOTHROW\nje_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr) {\n\tLOG(\"core.malloc_usable_size.entry\", \"ptr: %p\", ptr);\n\n\tsize_t ret = je_malloc_usable_size_impl(ptr);\n\n\tLOG(\"core.malloc_usable_size.exit\", \"result: %zu\", ret);\n\treturn ret;\n}\n\n#ifdef JEMALLOC_HAVE_MALLOC_SIZE\nJEMALLOC_EXPORT size_t JEMALLOC_NOTHROW\nje_malloc_size(const void *ptr) {\n\tLOG(\"core.malloc_size.entry\", \"ptr: %p\", ptr);\n\n\tsize_t ret = je_malloc_usable_size_impl(ptr);\n\n\tLOG(\"core.malloc_size.exit\", \"result: %zu\", ret);\n\treturn ret;\n}\n#endif\n\nstatic void\nbatch_alloc_prof_sample_assert(tsd_t *tsd, size_t batch, size_t usize) {\n\tassert(config_prof && opt_prof);\n\tbool prof_sample_event = te_prof_sample_event_lookahead(tsd,\n\t batch * usize);\n\tassert(!prof_sample_event);\n\tsize_t surplus;\n\tprof_sample_event = te_prof_sample_event_lookahead_surplus(tsd,\n\t (batch + 1) * usize, &surplus);\n\tassert(prof_sample_event);\n\tassert(surplus < usize);\n}\n\nsize_t\nbatch_alloc(void **ptrs, size_t num, size_t size, int flags) {\n\tLOG(\"core.batch_alloc.entry\",\n\t \"ptrs: %p, num: %zu, size: %zu, flags: %d\", ptrs, num, size, flags);\n\n\ttsd_t *tsd = tsd_fetch();\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\n\tsize_t filled = 0;\n\n\tif (unlikely(tsd == NULL || tsd_reentrancy_level_get(tsd) > 0)) {\n\t\tgoto label_done;\n\t}\n\n\tsize_t alignment = MALLOCX_ALIGN_GET(flags);\n\tsize_t usize;\n\tif (aligned_usize_get(size, alignment, &usize, NULL, false)) {\n\t\tgoto label_done;\n\t}\n\tszind_t ind = sz_size2index(usize);\n\tbool zero = zero_get(MALLOCX_ZERO_GET(flags), /* slow */ true);\n\n\t/*\n\t * The cache bin and arena will be lazily initialized; it's hard to\n\t * know in advance whether each of them needs to be initialized.\n\t */\n\tcache_bin_t *bin = NULL;\n\tarena_t *arena = NULL;\n\n\tsize_t nregs = 0;\n\tif (likely(ind < SC_NBINS)) {\n\t\tnregs = bin_infos[ind].nregs;\n\t\tassert(nregs > 0);\n\t}\n\n\twhile (filled < num) {\n\t\tsize_t batch = num - filled;\n\t\tsize_t surplus = SIZE_MAX; /* Dead store. */\n\t\tbool prof_sample_event = config_prof && opt_prof\n\t\t && prof_active_get_unlocked()\n\t\t && te_prof_sample_event_lookahead_surplus(tsd,\n\t\t batch * usize, &surplus);\n\n\t\tif (prof_sample_event) {\n\t\t\t/*\n\t\t\t * Adjust so that the batch does not trigger prof\n\t\t\t * sampling.\n\t\t\t */\n\t\t\tbatch -= surplus / usize + 1;\n\t\t\tbatch_alloc_prof_sample_assert(tsd, batch, usize);\n\t\t}\n\n\t\tsize_t progress = 0;\n\n\t\tif (likely(ind < SC_NBINS) && batch >= nregs) {\n\t\t\tif (arena == NULL) {\n\t\t\t\tunsigned arena_ind = mallocx_arena_get(flags);\n\t\t\t\tif (arena_get_from_ind(tsd, arena_ind,\n\t\t\t\t &arena)) {\n\t\t\t\t\tgoto label_done;\n\t\t\t\t}\n\t\t\t\tif (arena == NULL) {\n\t\t\t\t\tarena = arena_choose(tsd, NULL);\n\t\t\t\t}\n\t\t\t\tif (unlikely(arena == NULL)) {\n\t\t\t\t\tgoto label_done;\n\t\t\t\t}\n\t\t\t}\n\t\t\tsize_t arena_batch = batch - batch % nregs;\n\t\t\tsize_t n = arena_fill_small_fresh(tsd_tsdn(tsd), arena,\n\t\t\t ind, ptrs + filled, arena_batch, zero);\n\t\t\tprogress += n;\n\t\t\tfilled += n;\n\t\t}\n\n\t\tif (likely(ind < nhbins) && progress < batch) {\n\t\t\tif (bin == NULL) {\n\t\t\t\tunsigned tcache_ind = mallocx_tcache_get(flags);\n\t\t\t\ttcache_t *tcache = tcache_get_from_ind(tsd,\n\t\t\t\t tcache_ind, /* slow */ true,\n\t\t\t\t /* is_alloc */ true);\n\t\t\t\tif (tcache != NULL) {\n\t\t\t\t\tbin = &tcache->bins[ind];\n\t\t\t\t}\n\t\t\t}\n\t\t\t/*\n\t\t\t * If we don't have a tcache bin, we don't want to\n\t\t\t * immediately give up, because there's the possibility\n\t\t\t * that the user explicitly requested to bypass the\n\t\t\t * tcache, or that the user explicitly turned off the\n\t\t\t * tcache; in such cases, we go through the slow path,\n\t\t\t * i.e. the mallocx() call at the end of the while loop.\n\t\t\t */\n\t\t\tif (bin != NULL) {\n\t\t\t\tsize_t bin_batch = batch - progress;\n\t\t\t\t/*\n\t\t\t\t * n can be less than bin_batch, meaning that\n\t\t\t\t * the cache bin does not have enough memory.\n\t\t\t\t * In such cases, we rely on the slow path,\n\t\t\t\t * i.e. the mallocx() call at the end of the\n\t\t\t\t * while loop, to fill in the cache, and in the\n\t\t\t\t * next iteration of the while loop, the tcache\n\t\t\t\t * will contain a lot of memory, and we can\n\t\t\t\t * harvest them here. Compared to the\n\t\t\t\t * alternative approach where we directly go to\n\t\t\t\t * the arena bins here, the overhead of our\n\t\t\t\t * current approach should usually be minimal,\n\t\t\t\t * since we never try to fetch more memory than\n\t\t\t\t * what a slab contains via the tcache. An\n\t\t\t\t * additional benefit is that the tcache will\n\t\t\t\t * not be empty for the next allocation request.\n\t\t\t\t */\n\t\t\t\tsize_t n = cache_bin_alloc_batch(bin, bin_batch,\n\t\t\t\t ptrs + filled);\n\t\t\t\tif (config_stats) {\n\t\t\t\t\tbin->tstats.nrequests += n;\n\t\t\t\t}\n\t\t\t\tif (zero) {\n\t\t\t\t\tfor (size_t i = 0; i < n; ++i) {\n\t\t\t\t\t\tmemset(ptrs[filled + i], 0,\n\t\t\t\t\t\t usize);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (config_prof && opt_prof\n\t\t\t\t && unlikely(ind >= SC_NBINS)) {\n\t\t\t\t\tfor (size_t i = 0; i < n; ++i) {\n\t\t\t\t\t\tprof_tctx_reset_sampled(tsd,\n\t\t\t\t\t\t ptrs[filled + i]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tprogress += n;\n\t\t\t\tfilled += n;\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * For thread events other than prof sampling, trigger them as\n\t\t * if there's a single allocation of size (n * usize). This is\n\t\t * fine because:\n\t\t * (a) these events do not alter the allocation itself, and\n\t\t * (b) it's possible that some event would have been triggered\n\t\t * multiple times, instead of only once, if the allocations\n\t\t * were handled individually, but it would do no harm (or\n\t\t * even be beneficial) to coalesce the triggerings.\n\t\t */\n\t\tthread_alloc_event(tsd, progress * usize);\n\n\t\tif (progress < batch || prof_sample_event) {\n\t\t\tvoid *p = je_mallocx(size, flags);\n\t\t\tif (p == NULL) { /* OOM */\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (progress == batch) {\n\t\t\t\tassert(prof_sampled(tsd, p));\n\t\t\t}\n\t\t\tptrs[filled++] = p;\n\t\t}\n\t}\n\nlabel_done:\n\tcheck_entry_exit_locking(tsd_tsdn(tsd));\n\tLOG(\"core.batch_alloc.exit\", \"result: %zu\", filled);\n\treturn filled;\n}\n\n/*\n * End non-standard functions.\n */\n/******************************************************************************/\n/*\n * The following functions are used by threading libraries for protection of\n * malloc during fork().\n */\n\n/*\n * If an application creates a thread before doing any allocation in the main\n * thread, then calls fork(2) in the main thread followed by memory allocation\n * in the child process, a race can occur that results in deadlock within the\n * child: the main thread may have forked while the created thread had\n * partially initialized the allocator. Ordinarily jemalloc prevents\n * fork/malloc races via the following functions it registers during\n * initialization using pthread_atfork(), but of course that does no good if\n * the allocator isn't fully initialized at fork time. The following library\n * constructor is a partial solution to this problem. It may still be possible\n * to trigger the deadlock described above, but doing so would involve forking\n * via a library constructor that runs before jemalloc's runs.\n */\n#ifndef JEMALLOC_JET\nJEMALLOC_ATTR(constructor)\nstatic void\njemalloc_constructor(void) {\n\tmalloc_init();\n}\n#endif\n\n#ifndef JEMALLOC_MUTEX_INIT_CB\nvoid\njemalloc_prefork(void)\n#else\nJEMALLOC_EXPORT void\n_malloc_prefork(void)\n#endif\n{\n\ttsd_t *tsd;\n\tunsigned i, j, narenas;\n\tarena_t *arena;\n\n#ifdef JEMALLOC_MUTEX_INIT_CB\n\tif (!malloc_initialized()) {\n\t\treturn;\n\t}\n#endif\n\tassert(malloc_initialized());\n\n\ttsd = tsd_fetch();\n\n\tnarenas = narenas_total_get();\n\n\twitness_prefork(tsd_witness_tsdp_get(tsd));\n\t/* Acquire all mutexes in a safe order. */\n\tctl_prefork(tsd_tsdn(tsd));\n\ttcache_prefork(tsd_tsdn(tsd));\n\tmalloc_mutex_prefork(tsd_tsdn(tsd), &arenas_lock);\n\tif (have_background_thread) {\n\t\tbackground_thread_prefork0(tsd_tsdn(tsd));\n\t}\n\tprof_prefork0(tsd_tsdn(tsd));\n\tif (have_background_thread) {\n\t\tbackground_thread_prefork1(tsd_tsdn(tsd));\n\t}\n\t/* Break arena prefork into stages to preserve lock order. */\n\tfor (i = 0; i < 9; i++) {\n\t\tfor (j = 0; j < narenas; j++) {\n\t\t\tif ((arena = arena_get(tsd_tsdn(tsd), j, false)) !=\n\t\t\t NULL) {\n\t\t\t\tswitch (i) {\n\t\t\t\tcase 0:\n\t\t\t\t\tarena_prefork0(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 1:\n\t\t\t\t\tarena_prefork1(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tarena_prefork2(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 3:\n\t\t\t\t\tarena_prefork3(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 4:\n\t\t\t\t\tarena_prefork4(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 5:\n\t\t\t\t\tarena_prefork5(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 6:\n\t\t\t\t\tarena_prefork6(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 7:\n\t\t\t\t\tarena_prefork7(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 8:\n\t\t\t\t\tarena_prefork8(tsd_tsdn(tsd), arena);\n\t\t\t\t\tbreak;\n\t\t\t\tdefault: not_reached();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t}\n\tprof_prefork1(tsd_tsdn(tsd));\n\tstats_prefork(tsd_tsdn(tsd));\n\ttsd_prefork(tsd);\n}\n\n#ifndef JEMALLOC_MUTEX_INIT_CB\nvoid\njemalloc_postfork_parent(void)\n#else\nJEMALLOC_EXPORT void\n_malloc_postfork(void)\n#endif\n{\n\ttsd_t *tsd;\n\tunsigned i, narenas;\n\n#ifdef JEMALLOC_MUTEX_INIT_CB\n\tif (!malloc_initialized()) {\n\t\treturn;\n\t}\n#endif\n\tassert(malloc_initialized());\n\n\ttsd = tsd_fetch();\n\n\ttsd_postfork_parent(tsd);\n\n\twitness_postfork_parent(tsd_witness_tsdp_get(tsd));\n\t/* Release all mutexes, now that fork() has completed. */\n\tstats_postfork_parent(tsd_tsdn(tsd));\n\tfor (i = 0, narenas = narenas_total_get(); i < narenas; i++) {\n\t\tarena_t *arena;\n\n\t\tif ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL) {\n\t\t\tarena_postfork_parent(tsd_tsdn(tsd), arena);\n\t\t}\n\t}\n\tprof_postfork_parent(tsd_tsdn(tsd));\n\tif (have_background_thread) {\n\t\tbackground_thread_postfork_parent(tsd_tsdn(tsd));\n\t}\n\tmalloc_mutex_postfork_parent(tsd_tsdn(tsd), &arenas_lock);\n\ttcache_postfork_parent(tsd_tsdn(tsd));\n\tctl_postfork_parent(tsd_tsdn(tsd));\n}\n\nvoid\njemalloc_postfork_child(void) {\n\ttsd_t *tsd;\n\tunsigned i, narenas;\n\n\tassert(malloc_initialized());\n\n\ttsd = tsd_fetch();\n\n\ttsd_postfork_child(tsd);\n\n\twitness_postfork_child(tsd_witness_tsdp_get(tsd));\n\t/* Release all mutexes, now that fork() has completed. */\n\tstats_postfork_child(tsd_tsdn(tsd));\n\tfor (i = 0, narenas = narenas_total_get(); i < narenas; i++) {\n\t\tarena_t *arena;\n\n\t\tif ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL) {\n\t\t\tarena_postfork_child(tsd_tsdn(tsd), arena);\n\t\t}\n\t}\n\tprof_postfork_child(tsd_tsdn(tsd));\n\tif (have_background_thread) {\n\t\tbackground_thread_postfork_child(tsd_tsdn(tsd));\n\t}\n\tmalloc_mutex_postfork_child(tsd_tsdn(tsd), &arenas_lock);\n\ttcache_postfork_child(tsd_tsdn(tsd));\n\tctl_postfork_child(tsd_tsdn(tsd));\n}\n\n/******************************************************************************/\n\n/* Helps the application decide if a pointer is worth re-allocating in order to reduce fragmentation.\n * returns 1 if the allocation should be moved, and 0 if the allocation be kept.\n * If the application decides to re-allocate it should use MALLOCX_TCACHE_NONE when doing so. */\nJEMALLOC_EXPORT int JEMALLOC_NOTHROW\nget_defrag_hint(void* ptr) {\n\tassert(ptr != NULL);\n\treturn iget_defrag_hint(TSDN_NULL, ptr);\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE(1)\nmalloc_with_usize(size_t size, size_t *usize) {\n\treturn je_malloc_internal(size, usize);\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ATTR(malloc) JEMALLOC_ALLOC_SIZE2(1, 2)\ncalloc_with_usize(size_t num, size_t size, size_t *usize) {\n\treturn je_calloc_internal(num, size, usize);\n}\n\nJEMALLOC_EXPORT JEMALLOC_ALLOCATOR JEMALLOC_RESTRICT_RETURN\nvoid JEMALLOC_NOTHROW *\nJEMALLOC_ALLOC_SIZE(2)\nrealloc_with_usize(void *ptr, size_t size, size_t *old_usize, size_t *new_usize) {\n\treturn je_realloc_internal(ptr, size, old_usize, new_usize);\n}\n\nJEMALLOC_EXPORT void JEMALLOC_NOTHROW\nfree_with_usize(void *ptr, size_t *usize) {\n\tje_free_internal(ptr, usize);\n}\n" }, { "path": "deps/jemalloc/src/jemalloc_cpp.cpp", "content": "#include \n#include \n\n#define JEMALLOC_CPP_CPP_\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#ifdef __cplusplus\n}\n#endif\n\n// All operators in this file are exported.\n\n// Possibly alias hidden versions of malloc and sdallocx to avoid an extra plt\n// thunk?\n//\n// extern __typeof (sdallocx) sdallocx_int\n// __attribute ((alias (\"sdallocx\"),\n//\t\tvisibility (\"hidden\")));\n//\n// ... but it needs to work with jemalloc namespaces.\n\nvoid\t*operator new(std::size_t size);\nvoid\t*operator new[](std::size_t size);\nvoid\t*operator new(std::size_t size, const std::nothrow_t &) noexcept;\nvoid\t*operator new[](std::size_t size, const std::nothrow_t &) noexcept;\nvoid\toperator delete(void *ptr) noexcept;\nvoid\toperator delete[](void *ptr) noexcept;\nvoid\toperator delete(void *ptr, const std::nothrow_t &) noexcept;\nvoid\toperator delete[](void *ptr, const std::nothrow_t &) noexcept;\n\n#if __cpp_sized_deallocation >= 201309\n/* C++14's sized-delete operators. */\nvoid\toperator delete(void *ptr, std::size_t size) noexcept;\nvoid\toperator delete[](void *ptr, std::size_t size) noexcept;\n#endif\n\n#if __cpp_aligned_new >= 201606\n/* C++17's over-aligned operators. */\nvoid\t*operator new(std::size_t size, std::align_val_t);\nvoid\t*operator new(std::size_t size, std::align_val_t, const std::nothrow_t &) noexcept;\nvoid\t*operator new[](std::size_t size, std::align_val_t);\nvoid\t*operator new[](std::size_t size, std::align_val_t, const std::nothrow_t &) noexcept;\nvoid\toperator delete(void* ptr, std::align_val_t) noexcept;\nvoid\toperator delete(void* ptr, std::align_val_t, const std::nothrow_t &) noexcept;\nvoid\toperator delete(void* ptr, std::size_t size, std::align_val_t al) noexcept;\nvoid\toperator delete[](void* ptr, std::align_val_t) noexcept;\nvoid\toperator delete[](void* ptr, std::align_val_t, const std::nothrow_t &) noexcept;\nvoid\toperator delete[](void* ptr, std::size_t size, std::align_val_t al) noexcept;\n#endif\n\nJEMALLOC_NOINLINE\nstatic void *\nhandleOOM(std::size_t size, bool nothrow) {\n\tif (opt_experimental_infallible_new) {\n\t\tsafety_check_fail(\": Allocation failed and \"\n\t\t \"opt.experimental_infallible_new is true. Aborting.\\n\");\n\t\treturn nullptr;\n\t}\n\n\tvoid *ptr = nullptr;\n\n\twhile (ptr == nullptr) {\n\t\tstd::new_handler handler;\n\t\t// GCC-4.8 and clang 4.0 do not have std::get_new_handler.\n\t\t{\n\t\t\tstatic std::mutex mtx;\n\t\t\tstd::lock_guard lock(mtx);\n\n\t\t\thandler = std::set_new_handler(nullptr);\n\t\t\tstd::set_new_handler(handler);\n\t\t}\n\t\tif (handler == nullptr)\n\t\t\tbreak;\n\n\t\ttry {\n\t\t\thandler();\n\t\t} catch (const std::bad_alloc &) {\n\t\t\tbreak;\n\t\t}\n\n\t\tptr = je_malloc(size);\n\t}\n\n\tif (ptr == nullptr && !nothrow)\n\t\tstd::__throw_bad_alloc();\n\treturn ptr;\n}\n\ntemplate \nJEMALLOC_NOINLINE\nstatic void *\nfallback_impl(std::size_t size, std::size_t *usize) noexcept(IsNoExcept) {\n\tvoid *ptr = malloc_default(size, NULL);\n\tif (likely(ptr != nullptr)) {\n\t\treturn ptr;\n\t}\n\treturn handleOOM(size, IsNoExcept);\n}\n\ntemplate \nJEMALLOC_ALWAYS_INLINE\nvoid *\nnewImpl(std::size_t size) noexcept(IsNoExcept) {\n\treturn imalloc_fastpath(size, &fallback_impl, NULL);\n}\n\nvoid *\noperator new(std::size_t size) {\n\treturn newImpl(size);\n}\n\nvoid *\noperator new[](std::size_t size) {\n\treturn newImpl(size);\n}\n\nvoid *\noperator new(std::size_t size, const std::nothrow_t &) noexcept {\n\treturn newImpl(size);\n}\n\nvoid *\noperator new[](std::size_t size, const std::nothrow_t &) noexcept {\n\treturn newImpl(size);\n}\n\n#if __cpp_aligned_new >= 201606\n\ntemplate \nJEMALLOC_ALWAYS_INLINE\nvoid *\nalignedNewImpl(std::size_t size, std::align_val_t alignment) noexcept(IsNoExcept) {\n\tvoid *ptr = je_aligned_alloc(static_cast(alignment), size);\n\tif (likely(ptr != nullptr)) {\n\t\treturn ptr;\n\t}\n\n\treturn handleOOM(size, IsNoExcept);\n}\n\nvoid *\noperator new(std::size_t size, std::align_val_t alignment) {\n\treturn alignedNewImpl(size, alignment);\n}\n\nvoid *\noperator new[](std::size_t size, std::align_val_t alignment) {\n\treturn alignedNewImpl(size, alignment);\n}\n\nvoid *\noperator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t &) noexcept {\n\treturn alignedNewImpl(size, alignment);\n}\n\nvoid *\noperator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t &) noexcept {\n\treturn alignedNewImpl(size, alignment);\n}\n\n#endif // __cpp_aligned_new\n\nvoid\noperator delete(void *ptr) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete[](void *ptr) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete(void *ptr, const std::nothrow_t &) noexcept {\n\tje_free(ptr);\n}\n\nvoid operator delete[](void *ptr, const std::nothrow_t &) noexcept {\n\tje_free(ptr);\n}\n\n#if __cpp_sized_deallocation >= 201309\n\nJEMALLOC_ALWAYS_INLINE\nvoid\nsizedDeleteImpl(void* ptr, std::size_t size) noexcept {\n\tif (unlikely(ptr == nullptr)) {\n\t\treturn;\n\t}\n\tje_sdallocx_noflags(ptr, size);\n}\n\nvoid\noperator delete(void *ptr, std::size_t size) noexcept {\n\tsizedDeleteImpl(ptr, size);\n}\n\nvoid\noperator delete[](void *ptr, std::size_t size) noexcept {\n\tsizedDeleteImpl(ptr, size);\n}\n\n#endif // __cpp_sized_deallocation\n\n#if __cpp_aligned_new >= 201606\n\nJEMALLOC_ALWAYS_INLINE\nvoid\nalignedSizedDeleteImpl(void* ptr, std::size_t size, std::align_val_t alignment) noexcept {\n\tif (config_debug) {\n\t\tassert(((size_t)alignment & ((size_t)alignment - 1)) == 0);\n\t}\n\tif (unlikely(ptr == nullptr)) {\n\t\treturn;\n\t}\n\tje_sdallocx(ptr, size, MALLOCX_ALIGN(alignment));\n}\n\nvoid\noperator delete(void* ptr, std::align_val_t) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete[](void* ptr, std::align_val_t) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete(void* ptr, std::align_val_t, const std::nothrow_t&) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete[](void* ptr, std::align_val_t, const std::nothrow_t&) noexcept {\n\tje_free(ptr);\n}\n\nvoid\noperator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept {\n\talignedSizedDeleteImpl(ptr, size, alignment);\n}\n\nvoid\noperator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept {\n\talignedSizedDeleteImpl(ptr, size, alignment);\n}\n\n#endif // __cpp_aligned_new\n" }, { "path": "deps/jemalloc/src/large.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/emap.h\"\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/prof_recent.h\"\n#include \"jemalloc/internal/util.h\"\n\n/******************************************************************************/\n\nvoid *\nlarge_malloc(tsdn_t *tsdn, arena_t *arena, size_t usize, bool zero) {\n\tassert(usize == sz_s2u(usize));\n\n\treturn large_palloc(tsdn, arena, usize, CACHELINE, zero);\n}\n\nvoid *\nlarge_palloc(tsdn_t *tsdn, arena_t *arena, size_t usize, size_t alignment,\n bool zero) {\n\tsize_t ausize;\n\tedata_t *edata;\n\tUNUSED bool idump JEMALLOC_CC_SILENCE_INIT(false);\n\n\tassert(!tsdn_null(tsdn) || arena != NULL);\n\n\tausize = sz_sa2u(usize, alignment);\n\tif (unlikely(ausize == 0 || ausize > SC_LARGE_MAXCLASS)) {\n\t\treturn NULL;\n\t}\n\n\tif (likely(!tsdn_null(tsdn))) {\n\t\tarena = arena_choose_maybe_huge(tsdn_tsd(tsdn), arena, usize);\n\t}\n\tif (unlikely(arena == NULL) || (edata = arena_extent_alloc_large(tsdn,\n\t arena, usize, alignment, zero)) == NULL) {\n\t\treturn NULL;\n\t}\n\n\t/* See comments in arena_bin_slabs_full_insert(). */\n\tif (!arena_is_auto(arena)) {\n\t\t/* Insert edata into large. */\n\t\tmalloc_mutex_lock(tsdn, &arena->large_mtx);\n\t\tedata_list_active_append(&arena->large, edata);\n\t\tmalloc_mutex_unlock(tsdn, &arena->large_mtx);\n\t}\n\n\tarena_decay_tick(tsdn, arena);\n\treturn edata_addr_get(edata);\n}\n\nstatic bool\nlarge_ralloc_no_move_shrink(tsdn_t *tsdn, edata_t *edata, size_t usize) {\n\tarena_t *arena = arena_get_from_edata(edata);\n\tehooks_t *ehooks = arena_get_ehooks(arena);\n\tsize_t old_size = edata_size_get(edata);\n\tsize_t old_usize = edata_usize_get(edata);\n\n\tassert(old_usize > usize);\n\n\tif (ehooks_split_will_fail(ehooks)) {\n\t\treturn true;\n\t}\n\n\tbool deferred_work_generated = false;\n\tbool err = pa_shrink(tsdn, &arena->pa_shard, edata, old_size,\n\t usize + sz_large_pad, sz_size2index(usize),\n\t &deferred_work_generated);\n\tif (err) {\n\t\treturn true;\n\t}\n\tif (deferred_work_generated) {\n\t\tarena_handle_deferred_work(tsdn, arena);\n\t}\n\tarena_extent_ralloc_large_shrink(tsdn, arena, edata, old_usize);\n\n\treturn false;\n}\n\nstatic bool\nlarge_ralloc_no_move_expand(tsdn_t *tsdn, edata_t *edata, size_t usize,\n bool zero) {\n\tarena_t *arena = arena_get_from_edata(edata);\n\n\tsize_t old_size = edata_size_get(edata);\n\tsize_t old_usize = edata_usize_get(edata);\n\tsize_t new_size = usize + sz_large_pad;\n\n\tszind_t szind = sz_size2index(usize);\n\n\tbool deferred_work_generated = false;\n\tbool err = pa_expand(tsdn, &arena->pa_shard, edata, old_size, new_size,\n\t szind, zero, &deferred_work_generated);\n\n\tif (deferred_work_generated) {\n\t\tarena_handle_deferred_work(tsdn, arena);\n\t}\n\n\tif (err) {\n\t\treturn true;\n\t}\n\n\tif (zero) {\n\t\tif (opt_cache_oblivious) {\n\t\t\tassert(sz_large_pad == PAGE);\n\t\t\t/*\n\t\t\t * Zero the trailing bytes of the original allocation's\n\t\t\t * last page, since they are in an indeterminate state.\n\t\t\t * There will always be trailing bytes, because ptr's\n\t\t\t * offset from the beginning of the extent is a multiple\n\t\t\t * of CACHELINE in [0 .. PAGE).\n\t\t\t */\n\t\t\tvoid *zbase = (void *)\n\t\t\t ((uintptr_t)edata_addr_get(edata) + old_usize);\n\t\t\tvoid *zpast = PAGE_ADDR2BASE((void *)((uintptr_t)zbase +\n\t\t\t PAGE));\n\t\t\tsize_t nzero = (uintptr_t)zpast - (uintptr_t)zbase;\n\t\t\tassert(nzero > 0);\n\t\t\tmemset(zbase, 0, nzero);\n\t\t}\n\t}\n\tarena_extent_ralloc_large_expand(tsdn, arena, edata, old_usize);\n\n\treturn false;\n}\n\nbool\nlarge_ralloc_no_move(tsdn_t *tsdn, edata_t *edata, size_t usize_min,\n size_t usize_max, bool zero) {\n\tsize_t oldusize = edata_usize_get(edata);\n\n\t/* The following should have been caught by callers. */\n\tassert(usize_min > 0 && usize_max <= SC_LARGE_MAXCLASS);\n\t/* Both allocation sizes must be large to avoid a move. */\n\tassert(oldusize >= SC_LARGE_MINCLASS\n\t && usize_max >= SC_LARGE_MINCLASS);\n\n\tif (usize_max > oldusize) {\n\t\t/* Attempt to expand the allocation in-place. */\n\t\tif (!large_ralloc_no_move_expand(tsdn, edata, usize_max,\n\t\t zero)) {\n\t\t\tarena_decay_tick(tsdn, arena_get_from_edata(edata));\n\t\t\treturn false;\n\t\t}\n\t\t/* Try again, this time with usize_min. */\n\t\tif (usize_min < usize_max && usize_min > oldusize &&\n\t\t large_ralloc_no_move_expand(tsdn, edata, usize_min, zero)) {\n\t\t\tarena_decay_tick(tsdn, arena_get_from_edata(edata));\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/*\n\t * Avoid moving the allocation if the existing extent size accommodates\n\t * the new size.\n\t */\n\tif (oldusize >= usize_min && oldusize <= usize_max) {\n\t\tarena_decay_tick(tsdn, arena_get_from_edata(edata));\n\t\treturn false;\n\t}\n\n\t/* Attempt to shrink the allocation in-place. */\n\tif (oldusize > usize_max) {\n\t\tif (!large_ralloc_no_move_shrink(tsdn, edata, usize_max)) {\n\t\t\tarena_decay_tick(tsdn, arena_get_from_edata(edata));\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\nstatic void *\nlarge_ralloc_move_helper(tsdn_t *tsdn, arena_t *arena, size_t usize,\n size_t alignment, bool zero) {\n\tif (alignment <= CACHELINE) {\n\t\treturn large_malloc(tsdn, arena, usize, zero);\n\t}\n\treturn large_palloc(tsdn, arena, usize, alignment, zero);\n}\n\nvoid *\nlarge_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t usize,\n size_t alignment, bool zero, tcache_t *tcache,\n hook_ralloc_args_t *hook_args) {\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\n\tsize_t oldusize = edata_usize_get(edata);\n\t/* The following should have been caught by callers. */\n\tassert(usize > 0 && usize <= SC_LARGE_MAXCLASS);\n\t/* Both allocation sizes must be large to avoid a move. */\n\tassert(oldusize >= SC_LARGE_MINCLASS\n\t && usize >= SC_LARGE_MINCLASS);\n\n\t/* Try to avoid moving the allocation. */\n\tif (!large_ralloc_no_move(tsdn, edata, usize, usize, zero)) {\n\t\thook_invoke_expand(hook_args->is_realloc\n\t\t ? hook_expand_realloc : hook_expand_rallocx, ptr, oldusize,\n\t\t usize, (uintptr_t)ptr, hook_args->args);\n\t\treturn edata_addr_get(edata);\n\t}\n\n\t/*\n\t * usize and old size are different enough that we need to use a\n\t * different size class. In that case, fall back to allocating new\n\t * space and copying.\n\t */\n\tvoid *ret = large_ralloc_move_helper(tsdn, arena, usize, alignment,\n\t zero);\n\tif (ret == NULL) {\n\t\treturn NULL;\n\t}\n\n\thook_invoke_alloc(hook_args->is_realloc\n\t ? hook_alloc_realloc : hook_alloc_rallocx, ret, (uintptr_t)ret,\n\t hook_args->args);\n\thook_invoke_dalloc(hook_args->is_realloc\n\t ? hook_dalloc_realloc : hook_dalloc_rallocx, ptr, hook_args->args);\n\n\tsize_t copysize = (usize < oldusize) ? usize : oldusize;\n\tmemcpy(ret, edata_addr_get(edata), copysize);\n\tisdalloct(tsdn, edata_addr_get(edata), oldusize, tcache, NULL, true);\n\treturn ret;\n}\n\n/*\n * locked indicates whether the arena's large_mtx is currently held.\n */\nstatic void\nlarge_dalloc_prep_impl(tsdn_t *tsdn, arena_t *arena, edata_t *edata,\n bool locked) {\n\tif (!locked) {\n\t\t/* See comments in arena_bin_slabs_full_insert(). */\n\t\tif (!arena_is_auto(arena)) {\n\t\t\tmalloc_mutex_lock(tsdn, &arena->large_mtx);\n\t\t\tedata_list_active_remove(&arena->large, edata);\n\t\t\tmalloc_mutex_unlock(tsdn, &arena->large_mtx);\n\t\t}\n\t} else {\n\t\t/* Only hold the large_mtx if necessary. */\n\t\tif (!arena_is_auto(arena)) {\n\t\t\tmalloc_mutex_assert_owner(tsdn, &arena->large_mtx);\n\t\t\tedata_list_active_remove(&arena->large, edata);\n\t\t}\n\t}\n\tarena_extent_dalloc_large_prep(tsdn, arena, edata);\n}\n\nstatic void\nlarge_dalloc_finish_impl(tsdn_t *tsdn, arena_t *arena, edata_t *edata) {\n\tbool deferred_work_generated = false;\n\tpa_dalloc(tsdn, &arena->pa_shard, edata, &deferred_work_generated);\n\tif (deferred_work_generated) {\n\t\tarena_handle_deferred_work(tsdn, arena);\n\t}\n}\n\nvoid\nlarge_dalloc_prep_locked(tsdn_t *tsdn, edata_t *edata) {\n\tlarge_dalloc_prep_impl(tsdn, arena_get_from_edata(edata), edata, true);\n}\n\nvoid\nlarge_dalloc_finish(tsdn_t *tsdn, edata_t *edata) {\n\tlarge_dalloc_finish_impl(tsdn, arena_get_from_edata(edata), edata);\n}\n\nvoid\nlarge_dalloc(tsdn_t *tsdn, edata_t *edata) {\n\tarena_t *arena = arena_get_from_edata(edata);\n\tlarge_dalloc_prep_impl(tsdn, arena, edata, false);\n\tlarge_dalloc_finish_impl(tsdn, arena, edata);\n\tarena_decay_tick(tsdn, arena);\n}\n\nsize_t\nlarge_salloc(tsdn_t *tsdn, const edata_t *edata) {\n\treturn edata_usize_get(edata);\n}\n\nvoid\nlarge_prof_info_get(tsd_t *tsd, edata_t *edata, prof_info_t *prof_info,\n bool reset_recent) {\n\tassert(prof_info != NULL);\n\n\tprof_tctx_t *alloc_tctx = edata_prof_tctx_get(edata);\n\tprof_info->alloc_tctx = alloc_tctx;\n\n\tif ((uintptr_t)alloc_tctx > (uintptr_t)1U) {\n\t\tnstime_copy(&prof_info->alloc_time,\n\t\t edata_prof_alloc_time_get(edata));\n\t\tprof_info->alloc_size = edata_prof_alloc_size_get(edata);\n\t\tif (reset_recent) {\n\t\t\t/*\n\t\t\t * Reset the pointer on the recent allocation record,\n\t\t\t * so that this allocation is recorded as released.\n\t\t\t */\n\t\t\tprof_recent_alloc_reset(tsd, edata);\n\t\t}\n\t}\n}\n\nstatic void\nlarge_prof_tctx_set(edata_t *edata, prof_tctx_t *tctx) {\n\tedata_prof_tctx_set(edata, tctx);\n}\n\nvoid\nlarge_prof_tctx_reset(edata_t *edata) {\n\tlarge_prof_tctx_set(edata, (prof_tctx_t *)(uintptr_t)1U);\n}\n\nvoid\nlarge_prof_info_set(edata_t *edata, prof_tctx_t *tctx, size_t size) {\n\tnstime_t t;\n\tnstime_prof_init_update(&t);\n\tedata_prof_alloc_time_set(edata, &t);\n\tedata_prof_alloc_size_set(edata, size);\n\tedata_prof_recent_alloc_init(edata);\n\tlarge_prof_tctx_set(edata, tctx);\n}\n" }, { "path": "deps/jemalloc/src/log.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/log.h\"\n\nchar log_var_names[JEMALLOC_LOG_VAR_BUFSIZE];\natomic_b_t log_init_done = ATOMIC_INIT(false);\n\n/*\n * Returns true if we were able to pick out a segment. Fills in r_segment_end\n * with a pointer to the first character after the end of the string.\n */\nstatic const char *\nlog_var_extract_segment(const char* segment_begin) {\n\tconst char *end;\n\tfor (end = segment_begin; *end != '\\0' && *end != '|'; end++) {\n\t}\n\treturn end;\n}\n\nstatic bool\nlog_var_matches_segment(const char *segment_begin, const char *segment_end,\n const char *log_var_begin, const char *log_var_end) {\n\tassert(segment_begin <= segment_end);\n\tassert(log_var_begin < log_var_end);\n\n\tptrdiff_t segment_len = segment_end - segment_begin;\n\tptrdiff_t log_var_len = log_var_end - log_var_begin;\n\t/* The special '.' segment matches everything. */\n\tif (segment_len == 1 && *segment_begin == '.') {\n\t\treturn true;\n\t}\n if (segment_len == log_var_len) {\n\t\treturn strncmp(segment_begin, log_var_begin, segment_len) == 0;\n\t} else if (segment_len < log_var_len) {\n\t\treturn strncmp(segment_begin, log_var_begin, segment_len) == 0\n\t\t && log_var_begin[segment_len] == '.';\n } else {\n\t\treturn false;\n\t}\n}\n\nunsigned\nlog_var_update_state(log_var_t *log_var) {\n\tconst char *log_var_begin = log_var->name;\n\tconst char *log_var_end = log_var->name + strlen(log_var->name);\n\n\t/* Pointer to one before the beginning of the current segment. */\n\tconst char *segment_begin = log_var_names;\n\n\t/*\n\t * If log_init done is false, we haven't parsed the malloc conf yet. To\n\t * avoid log-spew, we default to not displaying anything.\n\t */\n\tif (!atomic_load_b(&log_init_done, ATOMIC_ACQUIRE)) {\n\t\treturn LOG_INITIALIZED_NOT_ENABLED;\n\t}\n\n\twhile (true) {\n\t\tconst char *segment_end = log_var_extract_segment(\n\t\t segment_begin);\n\t\tassert(segment_end < log_var_names + JEMALLOC_LOG_VAR_BUFSIZE);\n\t\tif (log_var_matches_segment(segment_begin, segment_end,\n\t\t log_var_begin, log_var_end)) {\n\t\t\tatomic_store_u(&log_var->state, LOG_ENABLED,\n\t\t\t ATOMIC_RELAXED);\n\t\t\treturn LOG_ENABLED;\n\t\t}\n\t\tif (*segment_end == '\\0') {\n\t\t\t/* Hit the end of the segment string with no match. */\n\t\t\tatomic_store_u(&log_var->state,\n\t\t\t LOG_INITIALIZED_NOT_ENABLED, ATOMIC_RELAXED);\n\t\t\treturn LOG_INITIALIZED_NOT_ENABLED;\n\t\t}\n\t\t/* Otherwise, skip the delimiter and continue. */\n\t\tsegment_begin = segment_end + 1;\n\t}\n}\n" }, { "path": "deps/jemalloc/src/malloc_io.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/util.h\"\n\n#ifdef assert\n# undef assert\n#endif\n#ifdef not_reached\n# undef not_reached\n#endif\n#ifdef not_implemented\n# undef not_implemented\n#endif\n#ifdef assert_not_implemented\n# undef assert_not_implemented\n#endif\n\n/*\n * Define simple versions of assertion macros that won't recurse in case\n * of assertion failures in malloc_*printf().\n */\n#define assert(e) do {\t\t\t\t\t\t\t\\\n\tif (config_debug && !(e)) {\t\t\t\t\t\\\n\t\tmalloc_write(\": Failed assertion\\n\");\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define not_reached() do {\t\t\t\t\t\t\\\n\tif (config_debug) {\t\t\t\t\t\t\\\n\t\tmalloc_write(\": Unreachable code reached\\n\");\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tunreachable();\t\t\t\t\t\t\t\\\n} while (0)\n\n#define not_implemented() do {\t\t\t\t\t\t\\\n\tif (config_debug) {\t\t\t\t\t\t\\\n\t\tmalloc_write(\": Not implemented\\n\");\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define assert_not_implemented(e) do {\t\t\t\t\t\\\n\tif (unlikely(config_debug && !(e))) {\t\t\t\t\\\n\t\tnot_implemented();\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n/******************************************************************************/\n/* Function prototypes for non-inline static functions. */\n\n#define U2S_BUFSIZE ((1U << (LG_SIZEOF_INTMAX_T + 3)) + 1)\nstatic char *u2s(uintmax_t x, unsigned base, bool uppercase, char *s,\n size_t *slen_p);\n#define D2S_BUFSIZE (1 + U2S_BUFSIZE)\nstatic char *d2s(intmax_t x, char sign, char *s, size_t *slen_p);\n#define O2S_BUFSIZE (1 + U2S_BUFSIZE)\nstatic char *o2s(uintmax_t x, bool alt_form, char *s, size_t *slen_p);\n#define X2S_BUFSIZE (2 + U2S_BUFSIZE)\nstatic char *x2s(uintmax_t x, bool alt_form, bool uppercase, char *s,\n size_t *slen_p);\n\n/******************************************************************************/\n\n/* malloc_message() setup. */\nvoid\nwrtmessage(void *cbopaque, const char *s) {\n\tmalloc_write_fd(STDERR_FILENO, s, strlen(s));\n}\n\nJEMALLOC_EXPORT void\t(*je_malloc_message)(void *, const char *s);\n\n/*\n * Wrapper around malloc_message() that avoids the need for\n * je_malloc_message(...) throughout the code.\n */\nvoid\nmalloc_write(const char *s) {\n\tif (je_malloc_message != NULL) {\n\t\tje_malloc_message(NULL, s);\n\t} else {\n\t\twrtmessage(NULL, s);\n\t}\n}\n\n/*\n * glibc provides a non-standard strerror_r() when _GNU_SOURCE is defined, so\n * provide a wrapper.\n */\nint\nbuferror(int err, char *buf, size_t buflen) {\n#ifdef _WIN32\n\tFormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0,\n\t (LPSTR)buf, (DWORD)buflen, NULL);\n\treturn 0;\n#elif defined(JEMALLOC_STRERROR_R_RETURNS_CHAR_WITH_GNU_SOURCE) && defined(_GNU_SOURCE)\n\tchar *b = strerror_r(err, buf, buflen);\n\tif (b != buf) {\n\t\tstrncpy(buf, b, buflen);\n\t\tbuf[buflen-1] = '\\0';\n\t}\n\treturn 0;\n#else\n\treturn strerror_r(err, buf, buflen);\n#endif\n}\n\nuintmax_t\nmalloc_strtoumax(const char *restrict nptr, char **restrict endptr, int base) {\n\tuintmax_t ret, digit;\n\tunsigned b;\n\tbool neg;\n\tconst char *p, *ns;\n\n\tp = nptr;\n\tif (base < 0 || base == 1 || base > 36) {\n\t\tns = p;\n\t\tset_errno(EINVAL);\n\t\tret = UINTMAX_MAX;\n\t\tgoto label_return;\n\t}\n\tb = base;\n\n\t/* Swallow leading whitespace and get sign, if any. */\n\tneg = false;\n\twhile (true) {\n\t\tswitch (*p) {\n\t\tcase '\\t': case '\\n': case '\\v': case '\\f': case '\\r': case ' ':\n\t\t\tp++;\n\t\t\tbreak;\n\t\tcase '-':\n\t\t\tneg = true;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase '+':\n\t\t\tp++;\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tdefault:\n\t\t\tgoto label_prefix;\n\t\t}\n\t}\n\n\t/* Get prefix, if any. */\n\tlabel_prefix:\n\t/*\n\t * Note where the first non-whitespace/sign character is so that it is\n\t * possible to tell whether any digits are consumed (e.g., \" 0\" vs.\n\t * \" -x\").\n\t */\n\tns = p;\n\tif (*p == '0') {\n\t\tswitch (p[1]) {\n\t\tcase '0': case '1': case '2': case '3': case '4': case '5':\n\t\tcase '6': case '7':\n\t\t\tif (b == 0) {\n\t\t\t\tb = 8;\n\t\t\t}\n\t\t\tif (b == 8) {\n\t\t\t\tp++;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase 'X': case 'x':\n\t\t\tswitch (p[2]) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\tcase 'A': case 'B': case 'C': case 'D': case 'E':\n\t\t\tcase 'F':\n\t\t\tcase 'a': case 'b': case 'c': case 'd': case 'e':\n\t\t\tcase 'f':\n\t\t\t\tif (b == 0) {\n\t\t\t\t\tb = 16;\n\t\t\t\t}\n\t\t\t\tif (b == 16) {\n\t\t\t\t\tp += 2;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tp++;\n\t\t\tret = 0;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\tif (b == 0) {\n\t\tb = 10;\n\t}\n\n\t/* Convert. */\n\tret = 0;\n\twhile ((*p >= '0' && *p <= '9' && (digit = *p - '0') < b)\n\t || (*p >= 'A' && *p <= 'Z' && (digit = 10 + *p - 'A') < b)\n\t || (*p >= 'a' && *p <= 'z' && (digit = 10 + *p - 'a') < b)) {\n\t\tuintmax_t pret = ret;\n\t\tret *= b;\n\t\tret += digit;\n\t\tif (ret < pret) {\n\t\t\t/* Overflow. */\n\t\t\tset_errno(ERANGE);\n\t\t\tret = UINTMAX_MAX;\n\t\t\tgoto label_return;\n\t\t}\n\t\tp++;\n\t}\n\tif (neg) {\n\t\tret = (uintmax_t)(-((intmax_t)ret));\n\t}\n\n\tif (p == ns) {\n\t\t/* No conversion performed. */\n\t\tset_errno(EINVAL);\n\t\tret = UINTMAX_MAX;\n\t\tgoto label_return;\n\t}\n\nlabel_return:\n\tif (endptr != NULL) {\n\t\tif (p == ns) {\n\t\t\t/* No characters were converted. */\n\t\t\t*endptr = (char *)nptr;\n\t\t} else {\n\t\t\t*endptr = (char *)p;\n\t\t}\n\t}\n\treturn ret;\n}\n\nstatic char *\nu2s(uintmax_t x, unsigned base, bool uppercase, char *s, size_t *slen_p) {\n\tunsigned i;\n\n\ti = U2S_BUFSIZE - 1;\n\ts[i] = '\\0';\n\tswitch (base) {\n\tcase 10:\n\t\tdo {\n\t\t\ti--;\n\t\t\ts[i] = \"0123456789\"[x % (uint64_t)10];\n\t\t\tx /= (uint64_t)10;\n\t\t} while (x > 0);\n\t\tbreak;\n\tcase 16: {\n\t\tconst char *digits = (uppercase)\n\t\t ? \"0123456789ABCDEF\"\n\t\t : \"0123456789abcdef\";\n\n\t\tdo {\n\t\t\ti--;\n\t\t\ts[i] = digits[x & 0xf];\n\t\t\tx >>= 4;\n\t\t} while (x > 0);\n\t\tbreak;\n\t} default: {\n\t\tconst char *digits = (uppercase)\n\t\t ? \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n\t\t : \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n\t\tassert(base >= 2 && base <= 36);\n\t\tdo {\n\t\t\ti--;\n\t\t\ts[i] = digits[x % (uint64_t)base];\n\t\t\tx /= (uint64_t)base;\n\t\t} while (x > 0);\n\t}}\n\n\t*slen_p = U2S_BUFSIZE - 1 - i;\n\treturn &s[i];\n}\n\nstatic char *\nd2s(intmax_t x, char sign, char *s, size_t *slen_p) {\n\tbool neg;\n\n\tif ((neg = (x < 0))) {\n\t\tx = -x;\n\t}\n\ts = u2s(x, 10, false, s, slen_p);\n\tif (neg) {\n\t\tsign = '-';\n\t}\n\tswitch (sign) {\n\tcase '-':\n\t\tif (!neg) {\n\t\t\tbreak;\n\t\t}\n\t\tJEMALLOC_FALLTHROUGH;\n\tcase ' ':\n\tcase '+':\n\t\ts--;\n\t\t(*slen_p)++;\n\t\t*s = sign;\n\t\tbreak;\n\tdefault: not_reached();\n\t}\n\treturn s;\n}\n\nstatic char *\no2s(uintmax_t x, bool alt_form, char *s, size_t *slen_p) {\n\ts = u2s(x, 8, false, s, slen_p);\n\tif (alt_form && *s != '0') {\n\t\ts--;\n\t\t(*slen_p)++;\n\t\t*s = '0';\n\t}\n\treturn s;\n}\n\nstatic char *\nx2s(uintmax_t x, bool alt_form, bool uppercase, char *s, size_t *slen_p) {\n\ts = u2s(x, 16, uppercase, s, slen_p);\n\tif (alt_form) {\n\t\ts -= 2;\n\t\t(*slen_p) += 2;\n\t\tmemcpy(s, uppercase ? \"0X\" : \"0x\", 2);\n\t}\n\treturn s;\n}\n\nJEMALLOC_COLD\nsize_t\nmalloc_vsnprintf(char *str, size_t size, const char *format, va_list ap) {\n\tsize_t i;\n\tconst char *f;\n\n#define APPEND_C(c) do {\t\t\t\t\t\t\\\n\tif (i < size) {\t\t\t\t\t\t\t\\\n\t\tstr[i] = (c);\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ti++;\t\t\t\t\t\t\t\t\\\n} while (0)\n#define APPEND_S(s, slen) do {\t\t\t\t\t\t\\\n\tif (i < size) {\t\t\t\t\t\t\t\\\n\t\tsize_t cpylen = (slen <= size - i) ? slen : size - i;\t\\\n\t\tmemcpy(&str[i], s, cpylen);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\ti += slen;\t\t\t\t\t\t\t\\\n} while (0)\n#define APPEND_PADDED_S(s, slen, width, left_justify) do {\t\t\\\n\t/* Left padding. */\t\t\t\t\t\t\\\n\tsize_t pad_len = (width == -1) ? 0 : ((slen < (size_t)width) ?\t\\\n\t (size_t)width - slen : 0);\t\t\t\t\t\\\n\tif (!left_justify && pad_len != 0) {\t\t\t\t\\\n\t\tsize_t j;\t\t\t\t\t\t\\\n\t\tfor (j = 0; j < pad_len; j++) {\t\t\t\t\\\n\t\t\tif (pad_zero) {\t\t\t\t\t\\\n\t\t\t\tAPPEND_C('0');\t\t\t\t\\\n\t\t\t} else {\t\t\t\t\t\\\n\t\t\t\tAPPEND_C(' ');\t\t\t\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t/* Value. */\t\t\t\t\t\t\t\\\n\tAPPEND_S(s, slen);\t\t\t\t\t\t\\\n\t/* Right padding. */\t\t\t\t\t\t\\\n\tif (left_justify && pad_len != 0) {\t\t\t\t\\\n\t\tsize_t j;\t\t\t\t\t\t\\\n\t\tfor (j = 0; j < pad_len; j++) {\t\t\t\t\\\n\t\t\tAPPEND_C(' ');\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n#define GET_ARG_NUMERIC(val, len) do {\t\t\t\t\t\\\n\tswitch ((unsigned char)len) {\t\t\t\t\t\\\n\tcase '?':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, int);\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase '?' | 0x80:\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, unsigned int);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'l':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, long);\t\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'l' | 0x80:\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, unsigned long);\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'q':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, long long);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'q' | 0x80:\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, unsigned long long);\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'j':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, intmax_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'j' | 0x80:\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, uintmax_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 't':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, ptrdiff_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'z':\t\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, ssize_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'z' | 0x80:\t\t\t\t\t\t\\\n\t\tval = va_arg(ap, size_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tcase 'p': /* Synthetic; used for %p. */\t\t\t\t\\\n\t\tval = va_arg(ap, uintptr_t);\t\t\t\t\\\n\t\tbreak;\t\t\t\t\t\t\t\\\n\tdefault:\t\t\t\t\t\t\t\\\n\t\tnot_reached();\t\t\t\t\t\t\\\n\t\tval = 0;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n\ti = 0;\n\tf = format;\n\twhile (true) {\n\t\tswitch (*f) {\n\t\tcase '\\0': goto label_out;\n\t\tcase '%': {\n\t\t\tbool alt_form = false;\n\t\t\tbool left_justify = false;\n\t\t\tbool plus_space = false;\n\t\t\tbool plus_plus = false;\n\t\t\tint prec = -1;\n\t\t\tint width = -1;\n\t\t\tunsigned char len = '?';\n\t\t\tchar *s;\n\t\t\tsize_t slen;\n\t\t\tbool first_width_digit = true;\n\t\t\tbool pad_zero = false;\n\n\t\t\tf++;\n\t\t\t/* Flags. */\n\t\t\twhile (true) {\n\t\t\t\tswitch (*f) {\n\t\t\t\tcase '#':\n\t\t\t\t\tassert(!alt_form);\n\t\t\t\t\talt_form = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '-':\n\t\t\t\t\tassert(!left_justify);\n\t\t\t\t\tleft_justify = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ' ':\n\t\t\t\t\tassert(!plus_space);\n\t\t\t\t\tplus_space = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '+':\n\t\t\t\t\tassert(!plus_plus);\n\t\t\t\t\tplus_plus = true;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault: goto label_width;\n\t\t\t\t}\n\t\t\t\tf++;\n\t\t\t}\n\t\t\t/* Width. */\n\t\t\tlabel_width:\n\t\t\tswitch (*f) {\n\t\t\tcase '*':\n\t\t\t\twidth = va_arg(ap, int);\n\t\t\t\tf++;\n\t\t\t\tif (width < 0) {\n\t\t\t\t\tleft_justify = true;\n\t\t\t\t\twidth = -width;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase '0':\n\t\t\t\tif (first_width_digit) {\n\t\t\t\t\tpad_zero = true;\n\t\t\t\t}\n\t\t\t\tJEMALLOC_FALLTHROUGH;\n\t\t\tcase '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9': {\n\t\t\t\tuintmax_t uwidth;\n\t\t\t\tset_errno(0);\n\t\t\t\tuwidth = malloc_strtoumax(f, (char **)&f, 10);\n\t\t\t\tassert(uwidth != UINTMAX_MAX || get_errno() !=\n\t\t\t\t ERANGE);\n\t\t\t\twidth = (int)uwidth;\n\t\t\t\tfirst_width_digit = false;\n\t\t\t\tbreak;\n\t\t\t} default:\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/* Width/precision separator. */\n\t\t\tif (*f == '.') {\n\t\t\t\tf++;\n\t\t\t} else {\n\t\t\t\tgoto label_length;\n\t\t\t}\n\t\t\t/* Precision. */\n\t\t\tswitch (*f) {\n\t\t\tcase '*':\n\t\t\t\tprec = va_arg(ap, int);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9': {\n\t\t\t\tuintmax_t uprec;\n\t\t\t\tset_errno(0);\n\t\t\t\tuprec = malloc_strtoumax(f, (char **)&f, 10);\n\t\t\t\tassert(uprec != UINTMAX_MAX || get_errno() !=\n\t\t\t\t ERANGE);\n\t\t\t\tprec = (int)uprec;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault: break;\n\t\t\t}\n\t\t\t/* Length. */\n\t\t\tlabel_length:\n\t\t\tswitch (*f) {\n\t\t\tcase 'l':\n\t\t\t\tf++;\n\t\t\t\tif (*f == 'l') {\n\t\t\t\t\tlen = 'q';\n\t\t\t\t\tf++;\n\t\t\t\t} else {\n\t\t\t\t\tlen = 'l';\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'q': case 'j': case 't': case 'z':\n\t\t\t\tlen = *f;\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\tdefault: break;\n\t\t\t}\n\t\t\t/* Conversion specifier. */\n\t\t\tswitch (*f) {\n\t\t\tcase '%':\n\t\t\t\t/* %% */\n\t\t\t\tAPPEND_C(*f);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\tcase 'd': case 'i': {\n\t\t\t\tintmax_t val JEMALLOC_CC_SILENCE_INIT(0);\n\t\t\t\tchar buf[D2S_BUFSIZE];\n\n\t\t\t\t/*\n\t\t\t\t * Outputting negative, zero-padded numbers\n\t\t\t\t * would require a nontrivial rework of the\n\t\t\t\t * interaction between the width and padding\n\t\t\t\t * (since 0 padding goes between the '-' and the\n\t\t\t\t * number, while ' ' padding goes either before\n\t\t\t\t * the - or after the number. Since we\n\t\t\t\t * currently don't ever need 0-padded negative\n\t\t\t\t * numbers, just don't bother supporting it.\n\t\t\t\t */\n\t\t\t\tassert(!pad_zero);\n\n\t\t\t\tGET_ARG_NUMERIC(val, len);\n\t\t\t\ts = d2s(val, (plus_plus ? '+' : (plus_space ?\n\t\t\t\t ' ' : '-')), buf, &slen);\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} case 'o': {\n\t\t\t\tuintmax_t val JEMALLOC_CC_SILENCE_INIT(0);\n\t\t\t\tchar buf[O2S_BUFSIZE];\n\n\t\t\t\tGET_ARG_NUMERIC(val, len | 0x80);\n\t\t\t\ts = o2s(val, alt_form, buf, &slen);\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} case 'u': {\n\t\t\t\tuintmax_t val JEMALLOC_CC_SILENCE_INIT(0);\n\t\t\t\tchar buf[U2S_BUFSIZE];\n\n\t\t\t\tGET_ARG_NUMERIC(val, len | 0x80);\n\t\t\t\ts = u2s(val, 10, false, buf, &slen);\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} case 'x': case 'X': {\n\t\t\t\tuintmax_t val JEMALLOC_CC_SILENCE_INIT(0);\n\t\t\t\tchar buf[X2S_BUFSIZE];\n\n\t\t\t\tGET_ARG_NUMERIC(val, len | 0x80);\n\t\t\t\ts = x2s(val, alt_form, *f == 'X', buf, &slen);\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} case 'c': {\n\t\t\t\tunsigned char val;\n\t\t\t\tchar buf[2];\n\n\t\t\t\tassert(len == '?' || len == 'l');\n\t\t\t\tassert_not_implemented(len != 'l');\n\t\t\t\tval = va_arg(ap, int);\n\t\t\t\tbuf[0] = val;\n\t\t\t\tbuf[1] = '\\0';\n\t\t\t\tAPPEND_PADDED_S(buf, 1, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} case 's':\n\t\t\t\tassert(len == '?' || len == 'l');\n\t\t\t\tassert_not_implemented(len != 'l');\n\t\t\t\ts = va_arg(ap, char *);\n\t\t\t\tslen = (prec < 0) ? strlen(s) : (size_t)prec;\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\tcase 'p': {\n\t\t\t\tuintmax_t val;\n\t\t\t\tchar buf[X2S_BUFSIZE];\n\n\t\t\t\tGET_ARG_NUMERIC(val, 'p');\n\t\t\t\ts = x2s(val, true, false, buf, &slen);\n\t\t\t\tAPPEND_PADDED_S(s, slen, width, left_justify);\n\t\t\t\tf++;\n\t\t\t\tbreak;\n\t\t\t} default: not_reached();\n\t\t\t}\n\t\t\tbreak;\n\t\t} default: {\n\t\t\tAPPEND_C(*f);\n\t\t\tf++;\n\t\t\tbreak;\n\t\t}}\n\t}\n\tlabel_out:\n\tif (i < size) {\n\t\tstr[i] = '\\0';\n\t} else {\n\t\tstr[size - 1] = '\\0';\n\t}\n\n#undef APPEND_C\n#undef APPEND_S\n#undef APPEND_PADDED_S\n#undef GET_ARG_NUMERIC\n\treturn i;\n}\n\nJEMALLOC_FORMAT_PRINTF(3, 4)\nsize_t\nmalloc_snprintf(char *str, size_t size, const char *format, ...) {\n\tsize_t ret;\n\tva_list ap;\n\n\tva_start(ap, format);\n\tret = malloc_vsnprintf(str, size, format, ap);\n\tva_end(ap);\n\n\treturn ret;\n}\n\nvoid\nmalloc_vcprintf(write_cb_t *write_cb, void *cbopaque, const char *format,\n va_list ap) {\n\tchar buf[MALLOC_PRINTF_BUFSIZE];\n\n\tif (write_cb == NULL) {\n\t\t/*\n\t\t * The caller did not provide an alternate write_cb callback\n\t\t * function, so use the default one. malloc_write() is an\n\t\t * inline function, so use malloc_message() directly here.\n\t\t */\n\t\twrite_cb = (je_malloc_message != NULL) ? je_malloc_message :\n\t\t wrtmessage;\n\t}\n\n\tmalloc_vsnprintf(buf, sizeof(buf), format, ap);\n\twrite_cb(cbopaque, buf);\n}\n\n/*\n * Print to a callback function in such a way as to (hopefully) avoid memory\n * allocation.\n */\nJEMALLOC_FORMAT_PRINTF(3, 4)\nvoid\nmalloc_cprintf(write_cb_t *write_cb, void *cbopaque, const char *format, ...) {\n\tva_list ap;\n\n\tva_start(ap, format);\n\tmalloc_vcprintf(write_cb, cbopaque, format, ap);\n\tva_end(ap);\n}\n\n/* Print to stderr in such a way as to avoid memory allocation. */\nJEMALLOC_FORMAT_PRINTF(1, 2)\nvoid\nmalloc_printf(const char *format, ...) {\n\tva_list ap;\n\n\tva_start(ap, format);\n\tmalloc_vcprintf(NULL, NULL, format, ap);\n\tva_end(ap);\n}\n\n/*\n * Restore normal assertion macros, in order to make it possible to compile all\n * C files as a single concatenation.\n */\n#undef assert\n#undef not_reached\n#undef not_implemented\n#undef assert_not_implemented\n#include \"jemalloc/internal/assert.h\"\n" }, { "path": "deps/jemalloc/src/mutex.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/spin.h\"\n\n#ifndef _CRT_SPINCOUNT\n#define _CRT_SPINCOUNT 4000\n#endif\n\n/*\n * Based on benchmark results, a fixed spin with this amount of retries works\n * well for our critical sections.\n */\nint64_t opt_mutex_max_spin = 600;\n\n/******************************************************************************/\n/* Data. */\n\n#ifdef JEMALLOC_LAZY_LOCK\nbool isthreaded = false;\n#endif\n#ifdef JEMALLOC_MUTEX_INIT_CB\nstatic bool\t\tpostpone_init = true;\nstatic malloc_mutex_t\t*postponed_mutexes = NULL;\n#endif\n\n/******************************************************************************/\n/*\n * We intercept pthread_create() calls in order to toggle isthreaded if the\n * process goes multi-threaded.\n */\n\n#if defined(JEMALLOC_LAZY_LOCK) && !defined(_WIN32)\nJEMALLOC_EXPORT int\npthread_create(pthread_t *__restrict thread,\n const pthread_attr_t *__restrict attr, void *(*start_routine)(void *),\n void *__restrict arg) {\n\treturn pthread_create_wrapper(thread, attr, start_routine, arg);\n}\n#endif\n\n/******************************************************************************/\n\n#ifdef JEMALLOC_MUTEX_INIT_CB\nJEMALLOC_EXPORT int\t_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,\n void *(calloc_cb)(size_t, size_t));\n#endif\n\nvoid\nmalloc_mutex_lock_slow(malloc_mutex_t *mutex) {\n\tmutex_prof_data_t *data = &mutex->prof_data;\n\tnstime_t before;\n\n\tif (ncpus == 1) {\n\t\tgoto label_spin_done;\n\t}\n\n\tint cnt = 0;\n\tdo {\n\t\tspin_cpu_spinwait();\n\t\tif (!atomic_load_b(&mutex->locked, ATOMIC_RELAXED)\n && !malloc_mutex_trylock_final(mutex)) {\n\t\t\tdata->n_spin_acquired++;\n\t\t\treturn;\n\t\t}\n\t} while (cnt++ < opt_mutex_max_spin || opt_mutex_max_spin == -1);\n\n\tif (!config_stats) {\n\t\t/* Only spin is useful when stats is off. */\n\t\tmalloc_mutex_lock_final(mutex);\n\t\treturn;\n\t}\nlabel_spin_done:\n\tnstime_init_update(&before);\n\t/* Copy before to after to avoid clock skews. */\n\tnstime_t after;\n\tnstime_copy(&after, &before);\n\tuint32_t n_thds = atomic_fetch_add_u32(&data->n_waiting_thds, 1,\n\t ATOMIC_RELAXED) + 1;\n\t/* One last try as above two calls may take quite some cycles. */\n\tif (!malloc_mutex_trylock_final(mutex)) {\n\t\tatomic_fetch_sub_u32(&data->n_waiting_thds, 1, ATOMIC_RELAXED);\n\t\tdata->n_spin_acquired++;\n\t\treturn;\n\t}\n\n\t/* True slow path. */\n\tmalloc_mutex_lock_final(mutex);\n\t/* Update more slow-path only counters. */\n\tatomic_fetch_sub_u32(&data->n_waiting_thds, 1, ATOMIC_RELAXED);\n\tnstime_update(&after);\n\n\tnstime_t delta;\n\tnstime_copy(&delta, &after);\n\tnstime_subtract(&delta, &before);\n\n\tdata->n_wait_times++;\n\tnstime_add(&data->tot_wait_time, &delta);\n\tif (nstime_compare(&data->max_wait_time, &delta) < 0) {\n\t\tnstime_copy(&data->max_wait_time, &delta);\n\t}\n\tif (n_thds > data->max_n_thds) {\n\t\tdata->max_n_thds = n_thds;\n\t}\n}\n\nstatic void\nmutex_prof_data_init(mutex_prof_data_t *data) {\n\tmemset(data, 0, sizeof(mutex_prof_data_t));\n\tnstime_init_zero(&data->max_wait_time);\n\tnstime_init_zero(&data->tot_wait_time);\n\tdata->prev_owner = NULL;\n}\n\nvoid\nmalloc_mutex_prof_data_reset(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\tmalloc_mutex_assert_owner(tsdn, mutex);\n\tmutex_prof_data_init(&mutex->prof_data);\n}\n\nstatic int\nmutex_addr_comp(const witness_t *witness1, void *mutex1,\n const witness_t *witness2, void *mutex2) {\n\tassert(mutex1 != NULL);\n\tassert(mutex2 != NULL);\n\tuintptr_t mu1int = (uintptr_t)mutex1;\n\tuintptr_t mu2int = (uintptr_t)mutex2;\n\tif (mu1int < mu2int) {\n\t\treturn -1;\n\t} else if (mu1int == mu2int) {\n\t\treturn 0;\n\t} else {\n\t\treturn 1;\n\t}\n}\n\nbool\nmalloc_mutex_init(malloc_mutex_t *mutex, const char *name,\n witness_rank_t rank, malloc_mutex_lock_order_t lock_order) {\n\tmutex_prof_data_init(&mutex->prof_data);\n#ifdef _WIN32\n# if _WIN32_WINNT >= 0x0600\n\tInitializeSRWLock(&mutex->lock);\n# else\n\tif (!InitializeCriticalSectionAndSpinCount(&mutex->lock,\n\t _CRT_SPINCOUNT)) {\n\t\treturn true;\n\t}\n# endif\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n mutex->lock = OS_UNFAIR_LOCK_INIT;\n#elif (defined(JEMALLOC_MUTEX_INIT_CB))\n\tif (postpone_init) {\n\t\tmutex->postponed_next = postponed_mutexes;\n\t\tpostponed_mutexes = mutex;\n\t} else {\n\t\tif (_pthread_mutex_init_calloc_cb(&mutex->lock,\n\t\t bootstrap_calloc) != 0) {\n\t\t\treturn true;\n\t\t}\n\t}\n#else\n\tpthread_mutexattr_t attr;\n\n\tif (pthread_mutexattr_init(&attr) != 0) {\n\t\treturn true;\n\t}\n\tpthread_mutexattr_settype(&attr, MALLOC_MUTEX_TYPE);\n\tif (pthread_mutex_init(&mutex->lock, &attr) != 0) {\n\t\tpthread_mutexattr_destroy(&attr);\n\t\treturn true;\n\t}\n\tpthread_mutexattr_destroy(&attr);\n#endif\n\tif (config_debug) {\n\t\tmutex->lock_order = lock_order;\n\t\tif (lock_order == malloc_mutex_address_ordered) {\n\t\t\twitness_init(&mutex->witness, name, rank,\n\t\t\t mutex_addr_comp, mutex);\n\t\t} else {\n\t\t\twitness_init(&mutex->witness, name, rank, NULL, NULL);\n\t\t}\n\t}\n\treturn false;\n}\n\nvoid\nmalloc_mutex_prefork(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\tmalloc_mutex_lock(tsdn, mutex);\n}\n\nvoid\nmalloc_mutex_postfork_parent(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n\tmalloc_mutex_unlock(tsdn, mutex);\n}\n\nvoid\nmalloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex) {\n#ifdef JEMALLOC_MUTEX_INIT_CB\n\tmalloc_mutex_unlock(tsdn, mutex);\n#else\n\tif (malloc_mutex_init(mutex, mutex->witness.name,\n\t mutex->witness.rank, mutex->lock_order)) {\n\t\tmalloc_printf(\": Error re-initializing mutex in \"\n\t\t \"child\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n#endif\n}\n\nbool\nmalloc_mutex_boot(void) {\n#ifdef JEMALLOC_MUTEX_INIT_CB\n\tpostpone_init = false;\n\twhile (postponed_mutexes != NULL) {\n\t\tif (_pthread_mutex_init_calloc_cb(&postponed_mutexes->lock,\n\t\t bootstrap_calloc) != 0) {\n\t\t\treturn true;\n\t\t}\n\t\tpostponed_mutexes = postponed_mutexes->postponed_next;\n\t}\n#endif\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/nstime.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/nstime.h\"\n\n#include \"jemalloc/internal/assert.h\"\n\n#define BILLION\tUINT64_C(1000000000)\n#define MILLION\tUINT64_C(1000000)\n\nstatic void\nnstime_set_initialized(nstime_t *time) {\n#ifdef JEMALLOC_DEBUG\n\ttime->magic = NSTIME_MAGIC;\n#endif\n}\n\nstatic void\nnstime_assert_initialized(const nstime_t *time) {\n#ifdef JEMALLOC_DEBUG\n\t/*\n\t * Some parts (e.g. stats) rely on memset to zero initialize. Treat\n\t * these as valid initialization.\n\t */\n\tassert(time->magic == NSTIME_MAGIC ||\n\t (time->magic == 0 && time->ns == 0));\n#endif\n}\n\nstatic void\nnstime_pair_assert_initialized(const nstime_t *t1, const nstime_t *t2) {\n\tnstime_assert_initialized(t1);\n\tnstime_assert_initialized(t2);\n}\n\nstatic void\nnstime_initialize_operand(nstime_t *time) {\n\t/*\n\t * Operations like nstime_add may have the initial operand being zero\n\t * initialized (covered by the assert below). Full-initialize needed\n\t * before changing it to non-zero.\n\t */\n\tnstime_assert_initialized(time);\n\tnstime_set_initialized(time);\n}\n\nvoid\nnstime_init(nstime_t *time, uint64_t ns) {\n\tnstime_set_initialized(time);\n\ttime->ns = ns;\n}\n\nvoid\nnstime_init2(nstime_t *time, uint64_t sec, uint64_t nsec) {\n\tnstime_set_initialized(time);\n\ttime->ns = sec * BILLION + nsec;\n}\n\nuint64_t\nnstime_ns(const nstime_t *time) {\n\tnstime_assert_initialized(time);\n\treturn time->ns;\n}\n\nuint64_t\nnstime_msec(const nstime_t *time) {\n\tnstime_assert_initialized(time);\n\treturn time->ns / MILLION;\n}\n\nuint64_t\nnstime_sec(const nstime_t *time) {\n\tnstime_assert_initialized(time);\n\treturn time->ns / BILLION;\n}\n\nuint64_t\nnstime_nsec(const nstime_t *time) {\n\tnstime_assert_initialized(time);\n\treturn time->ns % BILLION;\n}\n\nvoid\nnstime_copy(nstime_t *time, const nstime_t *source) {\n\t/* Source is required to be initialized. */\n\tnstime_assert_initialized(source);\n\t*time = *source;\n\tnstime_assert_initialized(time);\n}\n\nint\nnstime_compare(const nstime_t *a, const nstime_t *b) {\n\tnstime_pair_assert_initialized(a, b);\n\treturn (a->ns > b->ns) - (a->ns < b->ns);\n}\n\nvoid\nnstime_add(nstime_t *time, const nstime_t *addend) {\n\tnstime_pair_assert_initialized(time, addend);\n\tassert(UINT64_MAX - time->ns >= addend->ns);\n\n\tnstime_initialize_operand(time);\n\ttime->ns += addend->ns;\n}\n\nvoid\nnstime_iadd(nstime_t *time, uint64_t addend) {\n\tnstime_assert_initialized(time);\n\tassert(UINT64_MAX - time->ns >= addend);\n\n\tnstime_initialize_operand(time);\n\ttime->ns += addend;\n}\n\nvoid\nnstime_subtract(nstime_t *time, const nstime_t *subtrahend) {\n\tnstime_pair_assert_initialized(time, subtrahend);\n\tassert(nstime_compare(time, subtrahend) >= 0);\n\n\t/* No initialize operand -- subtraction must be initialized. */\n\ttime->ns -= subtrahend->ns;\n}\n\nvoid\nnstime_isubtract(nstime_t *time, uint64_t subtrahend) {\n\tnstime_assert_initialized(time);\n\tassert(time->ns >= subtrahend);\n\n\t/* No initialize operand -- subtraction must be initialized. */\n\ttime->ns -= subtrahend;\n}\n\nvoid\nnstime_imultiply(nstime_t *time, uint64_t multiplier) {\n\tnstime_assert_initialized(time);\n\tassert((((time->ns | multiplier) & (UINT64_MAX << (sizeof(uint64_t) <<\n\t 2))) == 0) || ((time->ns * multiplier) / multiplier == time->ns));\n\n\tnstime_initialize_operand(time);\n\ttime->ns *= multiplier;\n}\n\nvoid\nnstime_idivide(nstime_t *time, uint64_t divisor) {\n\tnstime_assert_initialized(time);\n\tassert(divisor != 0);\n\n\tnstime_initialize_operand(time);\n\ttime->ns /= divisor;\n}\n\nuint64_t\nnstime_divide(const nstime_t *time, const nstime_t *divisor) {\n\tnstime_pair_assert_initialized(time, divisor);\n\tassert(divisor->ns != 0);\n\n\t/* No initialize operand -- *time itself remains unchanged. */\n\treturn time->ns / divisor->ns;\n}\n\n/* Returns time since *past, w/o updating *past. */\nuint64_t\nnstime_ns_since(const nstime_t *past) {\n\tnstime_assert_initialized(past);\n\n\tnstime_t now;\n\tnstime_copy(&now, past);\n\tnstime_update(&now);\n\n\tassert(nstime_compare(&now, past) >= 0);\n\treturn now.ns - past->ns;\n}\n\n#ifdef _WIN32\n# define NSTIME_MONOTONIC true\nstatic void\nnstime_get(nstime_t *time) {\n\tFILETIME ft;\n\tuint64_t ticks_100ns;\n\n\tGetSystemTimeAsFileTime(&ft);\n\tticks_100ns = (((uint64_t)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;\n\n\tnstime_init(time, ticks_100ns * 100);\n}\n#elif defined(JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE)\n# define NSTIME_MONOTONIC true\nstatic void\nnstime_get(nstime_t *time) {\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC_COARSE, &ts);\n\tnstime_init2(time, ts.tv_sec, ts.tv_nsec);\n}\n#elif defined(JEMALLOC_HAVE_CLOCK_MONOTONIC)\n# define NSTIME_MONOTONIC true\nstatic void\nnstime_get(nstime_t *time) {\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_MONOTONIC, &ts);\n\tnstime_init2(time, ts.tv_sec, ts.tv_nsec);\n}\n#elif defined(JEMALLOC_HAVE_MACH_ABSOLUTE_TIME)\n# define NSTIME_MONOTONIC true\nstatic void\nnstime_get(nstime_t *time) {\n\tnstime_init(time, mach_absolute_time());\n}\n#else\n# define NSTIME_MONOTONIC false\nstatic void\nnstime_get(nstime_t *time) {\n\tstruct timeval tv;\n\n\tgettimeofday(&tv, NULL);\n\tnstime_init2(time, tv.tv_sec, tv.tv_usec * 1000);\n}\n#endif\n\nstatic bool\nnstime_monotonic_impl(void) {\n\treturn NSTIME_MONOTONIC;\n#undef NSTIME_MONOTONIC\n}\nnstime_monotonic_t *JET_MUTABLE nstime_monotonic = nstime_monotonic_impl;\n\nprof_time_res_t opt_prof_time_res =\n\tprof_time_res_default;\n\nconst char *prof_time_res_mode_names[] = {\n\t\"default\",\n\t\"high\",\n};\n\n\nstatic void\nnstime_get_realtime(nstime_t *time) {\n#if defined(JEMALLOC_HAVE_CLOCK_REALTIME) && !defined(_WIN32)\n\tstruct timespec ts;\n\n\tclock_gettime(CLOCK_REALTIME, &ts);\n\tnstime_init2(time, ts.tv_sec, ts.tv_nsec);\n#else\n\tunreachable();\n#endif\n}\n\nstatic void\nnstime_prof_update_impl(nstime_t *time) {\n\tnstime_t old_time;\n\n\tnstime_copy(&old_time, time);\n\n\tif (opt_prof_time_res == prof_time_res_high) {\n\t\tnstime_get_realtime(time);\n\t} else {\n\t\tnstime_get(time);\n\t}\n}\nnstime_prof_update_t *JET_MUTABLE nstime_prof_update = nstime_prof_update_impl;\n\nstatic void\nnstime_update_impl(nstime_t *time) {\n\tnstime_t old_time;\n\n\tnstime_copy(&old_time, time);\n\tnstime_get(time);\n\n\t/* Handle non-monotonic clocks. */\n\tif (unlikely(nstime_compare(&old_time, time) > 0)) {\n\t\tnstime_copy(time, &old_time);\n\t}\n}\nnstime_update_t *JET_MUTABLE nstime_update = nstime_update_impl;\n\nvoid\nnstime_init_update(nstime_t *time) {\n\tnstime_init_zero(time);\n\tnstime_update(time);\n}\n\nvoid\nnstime_prof_init_update(nstime_t *time) {\n\tnstime_init_zero(time);\n\tnstime_prof_update(time);\n}\n\n\n" }, { "path": "deps/jemalloc/src/pa.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/hpa.h\"\n\nstatic void\npa_nactive_add(pa_shard_t *shard, size_t add_pages) {\n\tatomic_fetch_add_zu(&shard->nactive, add_pages, ATOMIC_RELAXED);\n}\n\nstatic void\npa_nactive_sub(pa_shard_t *shard, size_t sub_pages) {\n\tassert(atomic_load_zu(&shard->nactive, ATOMIC_RELAXED) >= sub_pages);\n\tatomic_fetch_sub_zu(&shard->nactive, sub_pages, ATOMIC_RELAXED);\n}\n\nbool\npa_central_init(pa_central_t *central, base_t *base, bool hpa,\n hpa_hooks_t *hpa_hooks) {\n\tbool err;\n\tif (hpa) {\n\t\terr = hpa_central_init(¢ral->hpa, base, hpa_hooks);\n\t\tif (err) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nbool\npa_shard_init(tsdn_t *tsdn, pa_shard_t *shard, pa_central_t *central,\n emap_t *emap, base_t *base, unsigned ind, pa_shard_stats_t *stats,\n malloc_mutex_t *stats_mtx, nstime_t *cur_time,\n size_t pac_oversize_threshold, ssize_t dirty_decay_ms,\n ssize_t muzzy_decay_ms) {\n\t/* This will change eventually, but for now it should hold. */\n\tassert(base_ind_get(base) == ind);\n\tif (edata_cache_init(&shard->edata_cache, base)) {\n\t\treturn true;\n\t}\n\n\tif (pac_init(tsdn, &shard->pac, base, emap, &shard->edata_cache,\n\t cur_time, pac_oversize_threshold, dirty_decay_ms, muzzy_decay_ms,\n\t &stats->pac_stats, stats_mtx)) {\n\t\treturn true;\n\t}\n\n\tshard->ind = ind;\n\n\tshard->ever_used_hpa = false;\n\tatomic_store_b(&shard->use_hpa, false, ATOMIC_RELAXED);\n\n\tatomic_store_zu(&shard->nactive, 0, ATOMIC_RELAXED);\n\n\tshard->stats_mtx = stats_mtx;\n\tshard->stats = stats;\n\tmemset(shard->stats, 0, sizeof(*shard->stats));\n\n\tshard->central = central;\n\tshard->emap = emap;\n\tshard->base = base;\n\n\treturn false;\n}\n\nbool\npa_shard_enable_hpa(tsdn_t *tsdn, pa_shard_t *shard,\n const hpa_shard_opts_t *hpa_opts, const sec_opts_t *hpa_sec_opts) {\n\tif (hpa_shard_init(&shard->hpa_shard, &shard->central->hpa, shard->emap,\n\t shard->base, &shard->edata_cache, shard->ind, hpa_opts)) {\n\t\treturn true;\n\t}\n\tif (sec_init(tsdn, &shard->hpa_sec, shard->base, &shard->hpa_shard.pai,\n\t hpa_sec_opts)) {\n\t\treturn true;\n\t}\n\tshard->ever_used_hpa = true;\n\tatomic_store_b(&shard->use_hpa, true, ATOMIC_RELAXED);\n\n\treturn false;\n}\n\nvoid\npa_shard_disable_hpa(tsdn_t *tsdn, pa_shard_t *shard) {\n\tatomic_store_b(&shard->use_hpa, false, ATOMIC_RELAXED);\n\tif (shard->ever_used_hpa) {\n\t\tsec_disable(tsdn, &shard->hpa_sec);\n\t\thpa_shard_disable(tsdn, &shard->hpa_shard);\n\t}\n}\n\nvoid\npa_shard_reset(tsdn_t *tsdn, pa_shard_t *shard) {\n\tatomic_store_zu(&shard->nactive, 0, ATOMIC_RELAXED);\n\tif (shard->ever_used_hpa) {\n\t\tsec_flush(tsdn, &shard->hpa_sec);\n\t}\n}\n\nstatic bool\npa_shard_uses_hpa(pa_shard_t *shard) {\n\treturn atomic_load_b(&shard->use_hpa, ATOMIC_RELAXED);\n}\n\nvoid\npa_shard_destroy(tsdn_t *tsdn, pa_shard_t *shard) {\n\tpac_destroy(tsdn, &shard->pac);\n\tif (shard->ever_used_hpa) {\n\t\tsec_flush(tsdn, &shard->hpa_sec);\n\t\thpa_shard_disable(tsdn, &shard->hpa_shard);\n\t}\n}\n\nstatic pai_t *\npa_get_pai(pa_shard_t *shard, edata_t *edata) {\n\treturn (edata_pai_get(edata) == EXTENT_PAI_PAC\n\t ? &shard->pac.pai : &shard->hpa_sec.pai);\n}\n\nedata_t *\npa_alloc(tsdn_t *tsdn, pa_shard_t *shard, size_t size, size_t alignment,\n bool slab, szind_t szind, bool zero, bool guarded,\n bool *deferred_work_generated) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tassert(!guarded || alignment <= PAGE);\n\n\tedata_t *edata = NULL;\n\tif (!guarded && pa_shard_uses_hpa(shard)) {\n\t\tedata = pai_alloc(tsdn, &shard->hpa_sec.pai, size, alignment,\n\t\t zero, /* guarded */ false, slab, deferred_work_generated);\n\t}\n\t/*\n\t * Fall back to the PAC if the HPA is off or couldn't serve the given\n\t * allocation request.\n\t */\n\tif (edata == NULL) {\n\t\tedata = pai_alloc(tsdn, &shard->pac.pai, size, alignment, zero,\n\t\t guarded, slab, deferred_work_generated);\n\t}\n\tif (edata != NULL) {\n\t\tassert(edata_size_get(edata) == size);\n\t\tpa_nactive_add(shard, size >> LG_PAGE);\n\t\temap_remap(tsdn, shard->emap, edata, szind, slab);\n\t\tedata_szind_set(edata, szind);\n\t\tedata_slab_set(edata, slab);\n\t\tif (slab && (size > 2 * PAGE)) {\n\t\t\temap_register_interior(tsdn, shard->emap, edata, szind);\n\t\t}\n\t\tassert(edata_arena_ind_get(edata) == shard->ind);\n\t}\n\treturn edata;\n}\n\nbool\npa_expand(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata, size_t old_size,\n size_t new_size, szind_t szind, bool zero, bool *deferred_work_generated) {\n\tassert(new_size > old_size);\n\tassert(edata_size_get(edata) == old_size);\n\tassert((new_size & PAGE_MASK) == 0);\n\tif (edata_guarded_get(edata)) {\n\t\treturn true;\n\t}\n\tsize_t expand_amount = new_size - old_size;\n\n\tpai_t *pai = pa_get_pai(shard, edata);\n\n\tbool error = pai_expand(tsdn, pai, edata, old_size, new_size, zero,\n\t deferred_work_generated);\n\tif (error) {\n\t\treturn true;\n\t}\n\n\tpa_nactive_add(shard, expand_amount >> LG_PAGE);\n\tedata_szind_set(edata, szind);\n\temap_remap(tsdn, shard->emap, edata, szind, /* slab */ false);\n\treturn false;\n}\n\nbool\npa_shrink(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata, size_t old_size,\n size_t new_size, szind_t szind, bool *deferred_work_generated) {\n\tassert(new_size < old_size);\n\tassert(edata_size_get(edata) == old_size);\n\tassert((new_size & PAGE_MASK) == 0);\n\tif (edata_guarded_get(edata)) {\n\t\treturn true;\n\t}\n\tsize_t shrink_amount = old_size - new_size;\n\n\tpai_t *pai = pa_get_pai(shard, edata);\n\tbool error = pai_shrink(tsdn, pai, edata, old_size, new_size,\n\t deferred_work_generated);\n\tif (error) {\n\t\treturn true;\n\t}\n\tpa_nactive_sub(shard, shrink_amount >> LG_PAGE);\n\n\tedata_szind_set(edata, szind);\n\temap_remap(tsdn, shard->emap, edata, szind, /* slab */ false);\n\treturn false;\n}\n\nvoid\npa_dalloc(tsdn_t *tsdn, pa_shard_t *shard, edata_t *edata,\n bool *deferred_work_generated) {\n\temap_remap(tsdn, shard->emap, edata, SC_NSIZES, /* slab */ false);\n\tif (edata_slab_get(edata)) {\n\t\temap_deregister_interior(tsdn, shard->emap, edata);\n\t\t/*\n\t\t * The slab state of the extent isn't cleared. It may be used\n\t\t * by the pai implementation, e.g. to make caching decisions.\n\t\t */\n\t}\n\tedata_addr_set(edata, edata_base_get(edata));\n\tedata_szind_set(edata, SC_NSIZES);\n\tpa_nactive_sub(shard, edata_size_get(edata) >> LG_PAGE);\n\tpai_t *pai = pa_get_pai(shard, edata);\n\tpai_dalloc(tsdn, pai, edata, deferred_work_generated);\n}\n\nbool\npa_shard_retain_grow_limit_get_set(tsdn_t *tsdn, pa_shard_t *shard,\n size_t *old_limit, size_t *new_limit) {\n\treturn pac_retain_grow_limit_get_set(tsdn, &shard->pac, old_limit,\n\t new_limit);\n}\n\nbool\npa_decay_ms_set(tsdn_t *tsdn, pa_shard_t *shard, extent_state_t state,\n ssize_t decay_ms, pac_purge_eagerness_t eagerness) {\n\treturn pac_decay_ms_set(tsdn, &shard->pac, state, decay_ms, eagerness);\n}\n\nssize_t\npa_decay_ms_get(pa_shard_t *shard, extent_state_t state) {\n\treturn pac_decay_ms_get(&shard->pac, state);\n}\n\nvoid\npa_shard_set_deferral_allowed(tsdn_t *tsdn, pa_shard_t *shard,\n bool deferral_allowed) {\n\tif (pa_shard_uses_hpa(shard)) {\n\t\thpa_shard_set_deferral_allowed(tsdn, &shard->hpa_shard,\n\t\t deferral_allowed);\n\t}\n}\n\nvoid\npa_shard_do_deferred_work(tsdn_t *tsdn, pa_shard_t *shard) {\n\tif (pa_shard_uses_hpa(shard)) {\n\t\thpa_shard_do_deferred_work(tsdn, &shard->hpa_shard);\n\t}\n}\n\n/*\n * Get time until next deferred work ought to happen. If there are multiple\n * things that have been deferred, this function calculates the time until\n * the soonest of those things.\n */\nuint64_t\npa_shard_time_until_deferred_work(tsdn_t *tsdn, pa_shard_t *shard) {\n\tuint64_t time = pai_time_until_deferred_work(tsdn, &shard->pac.pai);\n\tif (time == BACKGROUND_THREAD_DEFERRED_MIN) {\n\t\treturn time;\n\t}\n\n\tif (pa_shard_uses_hpa(shard)) {\n\t\tuint64_t hpa =\n\t\t pai_time_until_deferred_work(tsdn, &shard->hpa_shard.pai);\n\t\tif (hpa < time) {\n\t\t\ttime = hpa;\n\t\t}\n\t}\n\treturn time;\n}\n" }, { "path": "deps/jemalloc/src/pa_extra.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n/*\n * This file is logically part of the PA module. While pa.c contains the core\n * allocator functionality, this file contains boring integration functionality;\n * things like the pre- and post- fork handlers, and stats merging for CTL\n * refreshes.\n */\n\nvoid\npa_shard_prefork0(tsdn_t *tsdn, pa_shard_t *shard) {\n\tmalloc_mutex_prefork(tsdn, &shard->pac.decay_dirty.mtx);\n\tmalloc_mutex_prefork(tsdn, &shard->pac.decay_muzzy.mtx);\n}\n\nvoid\npa_shard_prefork2(tsdn_t *tsdn, pa_shard_t *shard) {\n\tif (shard->ever_used_hpa) {\n\t\tsec_prefork2(tsdn, &shard->hpa_sec);\n\t}\n}\n\nvoid\npa_shard_prefork3(tsdn_t *tsdn, pa_shard_t *shard) {\n\tmalloc_mutex_prefork(tsdn, &shard->pac.grow_mtx);\n\tif (shard->ever_used_hpa) {\n\t\thpa_shard_prefork3(tsdn, &shard->hpa_shard);\n\t}\n}\n\nvoid\npa_shard_prefork4(tsdn_t *tsdn, pa_shard_t *shard) {\n\tecache_prefork(tsdn, &shard->pac.ecache_dirty);\n\tecache_prefork(tsdn, &shard->pac.ecache_muzzy);\n\tecache_prefork(tsdn, &shard->pac.ecache_retained);\n\tif (shard->ever_used_hpa) {\n\t\thpa_shard_prefork4(tsdn, &shard->hpa_shard);\n\t}\n}\n\nvoid\npa_shard_prefork5(tsdn_t *tsdn, pa_shard_t *shard) {\n\tedata_cache_prefork(tsdn, &shard->edata_cache);\n}\n\nvoid\npa_shard_postfork_parent(tsdn_t *tsdn, pa_shard_t *shard) {\n\tedata_cache_postfork_parent(tsdn, &shard->edata_cache);\n\tecache_postfork_parent(tsdn, &shard->pac.ecache_dirty);\n\tecache_postfork_parent(tsdn, &shard->pac.ecache_muzzy);\n\tecache_postfork_parent(tsdn, &shard->pac.ecache_retained);\n\tmalloc_mutex_postfork_parent(tsdn, &shard->pac.grow_mtx);\n\tmalloc_mutex_postfork_parent(tsdn, &shard->pac.decay_dirty.mtx);\n\tmalloc_mutex_postfork_parent(tsdn, &shard->pac.decay_muzzy.mtx);\n\tif (shard->ever_used_hpa) {\n\t\tsec_postfork_parent(tsdn, &shard->hpa_sec);\n\t\thpa_shard_postfork_parent(tsdn, &shard->hpa_shard);\n\t}\n}\n\nvoid\npa_shard_postfork_child(tsdn_t *tsdn, pa_shard_t *shard) {\n\tedata_cache_postfork_child(tsdn, &shard->edata_cache);\n\tecache_postfork_child(tsdn, &shard->pac.ecache_dirty);\n\tecache_postfork_child(tsdn, &shard->pac.ecache_muzzy);\n\tecache_postfork_child(tsdn, &shard->pac.ecache_retained);\n\tmalloc_mutex_postfork_child(tsdn, &shard->pac.grow_mtx);\n\tmalloc_mutex_postfork_child(tsdn, &shard->pac.decay_dirty.mtx);\n\tmalloc_mutex_postfork_child(tsdn, &shard->pac.decay_muzzy.mtx);\n\tif (shard->ever_used_hpa) {\n\t\tsec_postfork_child(tsdn, &shard->hpa_sec);\n\t\thpa_shard_postfork_child(tsdn, &shard->hpa_shard);\n\t}\n}\n\nvoid\npa_shard_basic_stats_merge(pa_shard_t *shard, size_t *nactive, size_t *ndirty,\n size_t *nmuzzy) {\n\t*nactive += atomic_load_zu(&shard->nactive, ATOMIC_RELAXED);\n\t*ndirty += ecache_npages_get(&shard->pac.ecache_dirty);\n\t*nmuzzy += ecache_npages_get(&shard->pac.ecache_muzzy);\n}\n\nvoid\npa_shard_stats_merge(tsdn_t *tsdn, pa_shard_t *shard,\n pa_shard_stats_t *pa_shard_stats_out, pac_estats_t *estats_out,\n hpa_shard_stats_t *hpa_stats_out, sec_stats_t *sec_stats_out,\n size_t *resident) {\n\tcassert(config_stats);\n\n\tpa_shard_stats_out->pac_stats.retained +=\n\t ecache_npages_get(&shard->pac.ecache_retained) << LG_PAGE;\n\tpa_shard_stats_out->edata_avail += atomic_load_zu(\n\t &shard->edata_cache.count, ATOMIC_RELAXED);\n\n\tsize_t resident_pgs = 0;\n\tresident_pgs += atomic_load_zu(&shard->nactive, ATOMIC_RELAXED);\n\tresident_pgs += ecache_npages_get(&shard->pac.ecache_dirty);\n\t*resident += (resident_pgs << LG_PAGE);\n\n\t/* Dirty decay stats */\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_dirty.npurge,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_dirty.npurge));\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_dirty.nmadvise,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_dirty.nmadvise));\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_dirty.purged,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_dirty.purged));\n\n\t/* Muzzy decay stats */\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_muzzy.npurge,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_muzzy.npurge));\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_muzzy.nmadvise,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_muzzy.nmadvise));\n\tlocked_inc_u64_unsynchronized(\n\t &pa_shard_stats_out->pac_stats.decay_muzzy.purged,\n\t locked_read_u64(tsdn, LOCKEDINT_MTX(*shard->stats_mtx),\n\t &shard->pac.stats->decay_muzzy.purged));\n\n\tatomic_load_add_store_zu(&pa_shard_stats_out->pac_stats.abandoned_vm,\n\t atomic_load_zu(&shard->pac.stats->abandoned_vm, ATOMIC_RELAXED));\n\n\tfor (pszind_t i = 0; i < SC_NPSIZES; i++) {\n\t\tsize_t dirty, muzzy, retained, dirty_bytes, muzzy_bytes,\n\t\t retained_bytes;\n\t\tdirty = ecache_nextents_get(&shard->pac.ecache_dirty, i);\n\t\tmuzzy = ecache_nextents_get(&shard->pac.ecache_muzzy, i);\n\t\tretained = ecache_nextents_get(&shard->pac.ecache_retained, i);\n\t\tdirty_bytes = ecache_nbytes_get(&shard->pac.ecache_dirty, i);\n\t\tmuzzy_bytes = ecache_nbytes_get(&shard->pac.ecache_muzzy, i);\n\t\tretained_bytes = ecache_nbytes_get(&shard->pac.ecache_retained,\n\t\t i);\n\n\t\testats_out[i].ndirty = dirty;\n\t\testats_out[i].nmuzzy = muzzy;\n\t\testats_out[i].nretained = retained;\n\t\testats_out[i].dirty_bytes = dirty_bytes;\n\t\testats_out[i].muzzy_bytes = muzzy_bytes;\n\t\testats_out[i].retained_bytes = retained_bytes;\n\t}\n\n\tif (shard->ever_used_hpa) {\n\t\thpa_shard_stats_merge(tsdn, &shard->hpa_shard, hpa_stats_out);\n\t\tsec_stats_merge(tsdn, &shard->hpa_sec, sec_stats_out);\n\t}\n}\n\nstatic void\npa_shard_mtx_stats_read_single(tsdn_t *tsdn, mutex_prof_data_t *mutex_prof_data,\n malloc_mutex_t *mtx, int ind) {\n\tmalloc_mutex_lock(tsdn, mtx);\n\tmalloc_mutex_prof_read(tsdn, &mutex_prof_data[ind], mtx);\n\tmalloc_mutex_unlock(tsdn, mtx);\n}\n\nvoid\npa_shard_mtx_stats_read(tsdn_t *tsdn, pa_shard_t *shard,\n mutex_prof_data_t mutex_prof_data[mutex_prof_num_arena_mutexes]) {\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->edata_cache.mtx, arena_prof_mutex_extent_avail);\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->pac.ecache_dirty.mtx, arena_prof_mutex_extents_dirty);\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->pac.ecache_muzzy.mtx, arena_prof_mutex_extents_muzzy);\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->pac.ecache_retained.mtx, arena_prof_mutex_extents_retained);\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->pac.decay_dirty.mtx, arena_prof_mutex_decay_dirty);\n\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t &shard->pac.decay_muzzy.mtx, arena_prof_mutex_decay_muzzy);\n\n\tif (shard->ever_used_hpa) {\n\t\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t\t &shard->hpa_shard.mtx, arena_prof_mutex_hpa_shard);\n\t\tpa_shard_mtx_stats_read_single(tsdn, mutex_prof_data,\n\t\t &shard->hpa_shard.grow_mtx,\n\t\t arena_prof_mutex_hpa_shard_grow);\n\t\tsec_mutex_stats_read(tsdn, &shard->hpa_sec,\n\t\t &mutex_prof_data[arena_prof_mutex_hpa_sec]);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/pac.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/pac.h\"\n#include \"jemalloc/internal/san.h\"\n\nstatic edata_t *pac_alloc_impl(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t alignment, bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated);\nstatic bool pac_expand_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool zero, bool *deferred_work_generated);\nstatic bool pac_shrink_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool *deferred_work_generated);\nstatic void pac_dalloc_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated);\nstatic uint64_t pac_time_until_deferred_work(tsdn_t *tsdn, pai_t *self);\n\nstatic inline void\npac_decay_data_get(pac_t *pac, extent_state_t state,\n decay_t **r_decay, pac_decay_stats_t **r_decay_stats, ecache_t **r_ecache) {\n\tswitch(state) {\n\tcase extent_state_dirty:\n\t\t*r_decay = &pac->decay_dirty;\n\t\t*r_decay_stats = &pac->stats->decay_dirty;\n\t\t*r_ecache = &pac->ecache_dirty;\n\t\treturn;\n\tcase extent_state_muzzy:\n\t\t*r_decay = &pac->decay_muzzy;\n\t\t*r_decay_stats = &pac->stats->decay_muzzy;\n\t\t*r_ecache = &pac->ecache_muzzy;\n\t\treturn;\n\tdefault:\n\t\tunreachable();\n\t}\n}\n\nbool\npac_init(tsdn_t *tsdn, pac_t *pac, base_t *base, emap_t *emap,\n edata_cache_t *edata_cache, nstime_t *cur_time,\n size_t pac_oversize_threshold, ssize_t dirty_decay_ms,\n ssize_t muzzy_decay_ms, pac_stats_t *pac_stats, malloc_mutex_t *stats_mtx) {\n\tunsigned ind = base_ind_get(base);\n\t/*\n\t * Delay coalescing for dirty extents despite the disruptive effect on\n\t * memory layout for best-fit extent allocation, since cached extents\n\t * are likely to be reused soon after deallocation, and the cost of\n\t * merging/splitting extents is non-trivial.\n\t */\n\tif (ecache_init(tsdn, &pac->ecache_dirty, extent_state_dirty, ind,\n\t /* delay_coalesce */ true)) {\n\t\treturn true;\n\t}\n\t/*\n\t * Coalesce muzzy extents immediately, because operations on them are in\n\t * the critical path much less often than for dirty extents.\n\t */\n\tif (ecache_init(tsdn, &pac->ecache_muzzy, extent_state_muzzy, ind,\n\t /* delay_coalesce */ false)) {\n\t\treturn true;\n\t}\n\t/*\n\t * Coalesce retained extents immediately, in part because they will\n\t * never be evicted (and therefore there's no opportunity for delayed\n\t * coalescing), but also because operations on retained extents are not\n\t * in the critical path.\n\t */\n\tif (ecache_init(tsdn, &pac->ecache_retained, extent_state_retained,\n\t ind, /* delay_coalesce */ false)) {\n\t\treturn true;\n\t}\n\texp_grow_init(&pac->exp_grow);\n\tif (malloc_mutex_init(&pac->grow_mtx, \"extent_grow\",\n\t WITNESS_RANK_EXTENT_GROW, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tatomic_store_zu(&pac->oversize_threshold, pac_oversize_threshold,\n\t ATOMIC_RELAXED);\n\tif (decay_init(&pac->decay_dirty, cur_time, dirty_decay_ms)) {\n\t\treturn true;\n\t}\n\tif (decay_init(&pac->decay_muzzy, cur_time, muzzy_decay_ms)) {\n\t\treturn true;\n\t}\n\tif (san_bump_alloc_init(&pac->sba)) {\n\t\treturn true;\n\t}\n\n\tpac->base = base;\n\tpac->emap = emap;\n\tpac->edata_cache = edata_cache;\n\tpac->stats = pac_stats;\n\tpac->stats_mtx = stats_mtx;\n\tatomic_store_zu(&pac->extent_sn_next, 0, ATOMIC_RELAXED);\n\n\tpac->pai.alloc = &pac_alloc_impl;\n\tpac->pai.alloc_batch = &pai_alloc_batch_default;\n\tpac->pai.expand = &pac_expand_impl;\n\tpac->pai.shrink = &pac_shrink_impl;\n\tpac->pai.dalloc = &pac_dalloc_impl;\n\tpac->pai.dalloc_batch = &pai_dalloc_batch_default;\n\tpac->pai.time_until_deferred_work = &pac_time_until_deferred_work;\n\n\treturn false;\n}\n\nstatic inline bool\npac_may_have_muzzy(pac_t *pac) {\n\treturn pac_decay_ms_get(pac, extent_state_muzzy) != 0;\n}\n\nstatic edata_t *\npac_alloc_real(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, size_t size,\n size_t alignment, bool zero, bool guarded) {\n\tassert(!guarded || alignment <= PAGE);\n\n\tedata_t *edata = ecache_alloc(tsdn, pac, ehooks, &pac->ecache_dirty,\n\t NULL, size, alignment, zero, guarded);\n\n\tif (edata == NULL && pac_may_have_muzzy(pac)) {\n\t\tedata = ecache_alloc(tsdn, pac, ehooks, &pac->ecache_muzzy,\n\t\t NULL, size, alignment, zero, guarded);\n\t}\n\tif (edata == NULL) {\n\t\tedata = ecache_alloc_grow(tsdn, pac, ehooks,\n\t\t &pac->ecache_retained, NULL, size, alignment, zero,\n\t\t guarded);\n\t\tif (config_stats && edata != NULL) {\n\t\t\tatomic_fetch_add_zu(&pac->stats->pac_mapped, size,\n\t\t\t ATOMIC_RELAXED);\n\t\t}\n\t}\n\n\treturn edata;\n}\n\nstatic edata_t *\npac_alloc_new_guarded(tsdn_t *tsdn, pac_t *pac, ehooks_t *ehooks, size_t size,\n size_t alignment, bool zero, bool frequent_reuse) {\n\tassert(alignment <= PAGE);\n\n\tedata_t *edata;\n\tif (san_bump_enabled() && frequent_reuse) {\n\t\tedata = san_bump_alloc(tsdn, &pac->sba, pac, ehooks, size,\n\t\t zero);\n\t} else {\n\t\tsize_t size_with_guards = san_two_side_guarded_sz(size);\n\t\t/* Alloc a non-guarded extent first.*/\n\t\tedata = pac_alloc_real(tsdn, pac, ehooks, size_with_guards,\n\t\t /* alignment */ PAGE, zero, /* guarded */ false);\n\t\tif (edata != NULL) {\n\t\t\t/* Add guards around it. */\n\t\t\tassert(edata_size_get(edata) == size_with_guards);\n\t\t\tsan_guard_pages_two_sided(tsdn, ehooks, edata,\n\t\t\t pac->emap, true);\n\t\t}\n\t}\n\tassert(edata == NULL || (edata_guarded_get(edata) &&\n\t edata_size_get(edata) == size));\n\n\treturn edata;\n}\n\nstatic edata_t *\npac_alloc_impl(tsdn_t *tsdn, pai_t *self, size_t size, size_t alignment,\n bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated) {\n\tpac_t *pac = (pac_t *)self;\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\tedata_t *edata = NULL;\n\t/*\n\t * The condition is an optimization - not frequently reused guarded\n\t * allocations are never put in the ecache. pac_alloc_real also\n\t * doesn't grow retained for guarded allocations. So pac_alloc_real\n\t * for such allocations would always return NULL.\n\t * */\n\tif (!guarded || frequent_reuse) {\n\t\tedata =\tpac_alloc_real(tsdn, pac, ehooks, size, alignment,\n\t\t zero, guarded);\n\t}\n\tif (edata == NULL && guarded) {\n\t\t/* No cached guarded extents; creating a new one. */\n\t\tedata = pac_alloc_new_guarded(tsdn, pac, ehooks, size,\n\t\t alignment, zero, frequent_reuse);\n\t}\n\n\treturn edata;\n}\n\nstatic bool\npac_expand_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool zero, bool *deferred_work_generated) {\n\tpac_t *pac = (pac_t *)self;\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\tsize_t mapped_add = 0;\n\tsize_t expand_amount = new_size - old_size;\n\n\tif (ehooks_merge_will_fail(ehooks)) {\n\t\treturn true;\n\t}\n\tedata_t *trail = ecache_alloc(tsdn, pac, ehooks, &pac->ecache_dirty,\n\t edata, expand_amount, PAGE, zero, /* guarded*/ false);\n\tif (trail == NULL) {\n\t\ttrail = ecache_alloc(tsdn, pac, ehooks, &pac->ecache_muzzy,\n\t\t edata, expand_amount, PAGE, zero, /* guarded*/ false);\n\t}\n\tif (trail == NULL) {\n\t\ttrail = ecache_alloc_grow(tsdn, pac, ehooks,\n\t\t &pac->ecache_retained, edata, expand_amount, PAGE, zero,\n\t\t /* guarded */ false);\n\t\tmapped_add = expand_amount;\n\t}\n\tif (trail == NULL) {\n\t\treturn true;\n\t}\n\tif (extent_merge_wrapper(tsdn, pac, ehooks, edata, trail)) {\n\t\textent_dalloc_wrapper(tsdn, pac, ehooks, trail);\n\t\treturn true;\n\t}\n\tif (config_stats && mapped_add > 0) {\n\t\tatomic_fetch_add_zu(&pac->stats->pac_mapped, mapped_add,\n\t\t ATOMIC_RELAXED);\n\t}\n\treturn false;\n}\n\nstatic bool\npac_shrink_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool *deferred_work_generated) {\n\tpac_t *pac = (pac_t *)self;\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\tsize_t shrink_amount = old_size - new_size;\n\n\tif (ehooks_split_will_fail(ehooks)) {\n\t\treturn true;\n\t}\n\n\tedata_t *trail = extent_split_wrapper(tsdn, pac, ehooks, edata,\n\t new_size, shrink_amount, /* holding_core_locks */ false);\n\tif (trail == NULL) {\n\t\treturn true;\n\t}\n\tecache_dalloc(tsdn, pac, ehooks, &pac->ecache_dirty, trail);\n\t*deferred_work_generated = true;\n\treturn false;\n}\n\nstatic void\npac_dalloc_impl(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated) {\n\tpac_t *pac = (pac_t *)self;\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\tif (edata_guarded_get(edata)) {\n\t\t/*\n\t\t * Because cached guarded extents do exact fit only, large\n\t\t * guarded extents are restored on dalloc eagerly (otherwise\n\t\t * they will not be reused efficiently). Slab sizes have a\n\t\t * limited number of size classes, and tend to cycle faster.\n\t\t *\n\t\t * In the case where coalesce is restrained (VirtualFree on\n\t\t * Windows), guarded extents are also not cached -- otherwise\n\t\t * during arena destroy / reset, the retained extents would not\n\t\t * be whole regions (i.e. they are split between regular and\n\t\t * guarded).\n\t\t */\n\t\tif (!edata_slab_get(edata) || !maps_coalesce) {\n\t\t\tassert(edata_size_get(edata) >= SC_LARGE_MINCLASS ||\n\t\t\t !maps_coalesce);\n\t\t\tsan_unguard_pages_two_sided(tsdn, ehooks, edata,\n\t\t\t pac->emap);\n\t\t}\n\t}\n\n\tecache_dalloc(tsdn, pac, ehooks, &pac->ecache_dirty, edata);\n\t/* Purging of deallocated pages is deferred */\n\t*deferred_work_generated = true;\n}\n\nstatic inline uint64_t\npac_ns_until_purge(tsdn_t *tsdn, decay_t *decay, size_t npages) {\n\tif (malloc_mutex_trylock(tsdn, &decay->mtx)) {\n\t\t/* Use minimal interval if decay is contended. */\n\t\treturn BACKGROUND_THREAD_DEFERRED_MIN;\n\t}\n\tuint64_t result = decay_ns_until_purge(decay, npages,\n\t ARENA_DEFERRED_PURGE_NPAGES_THRESHOLD);\n\n\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\treturn result;\n}\n\nstatic uint64_t\npac_time_until_deferred_work(tsdn_t *tsdn, pai_t *self) {\n\tuint64_t time;\n\tpac_t *pac = (pac_t *)self;\n\n\ttime = pac_ns_until_purge(tsdn,\n\t &pac->decay_dirty,\n\t ecache_npages_get(&pac->ecache_dirty));\n\tif (time == BACKGROUND_THREAD_DEFERRED_MIN) {\n\t\treturn time;\n\t}\n\n\tuint64_t muzzy = pac_ns_until_purge(tsdn,\n\t &pac->decay_muzzy,\n\t ecache_npages_get(&pac->ecache_muzzy));\n\tif (muzzy < time) {\n\t\ttime = muzzy;\n\t}\n\treturn time;\n}\n\nbool\npac_retain_grow_limit_get_set(tsdn_t *tsdn, pac_t *pac, size_t *old_limit,\n size_t *new_limit) {\n\tpszind_t new_ind JEMALLOC_CC_SILENCE_INIT(0);\n\tif (new_limit != NULL) {\n\t\tsize_t limit = *new_limit;\n\t\t/* Grow no more than the new limit. */\n\t\tif ((new_ind = sz_psz2ind(limit + 1) - 1) >= SC_NPSIZES) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\tmalloc_mutex_lock(tsdn, &pac->grow_mtx);\n\tif (old_limit != NULL) {\n\t\t*old_limit = sz_pind2sz(pac->exp_grow.limit);\n\t}\n\tif (new_limit != NULL) {\n\t\tpac->exp_grow.limit = new_ind;\n\t}\n\tmalloc_mutex_unlock(tsdn, &pac->grow_mtx);\n\n\treturn false;\n}\n\nstatic size_t\npac_stash_decayed(tsdn_t *tsdn, pac_t *pac, ecache_t *ecache,\n size_t npages_limit, size_t npages_decay_max,\n edata_list_inactive_t *result) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 0);\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\t/* Stash extents according to npages_limit. */\n\tsize_t nstashed = 0;\n\twhile (nstashed < npages_decay_max) {\n\t\tedata_t *edata = ecache_evict(tsdn, pac, ehooks, ecache,\n\t\t npages_limit);\n\t\tif (edata == NULL) {\n\t\t\tbreak;\n\t\t}\n\t\tedata_list_inactive_append(result, edata);\n\t\tnstashed += edata_size_get(edata) >> LG_PAGE;\n\t}\n\treturn nstashed;\n}\n\nstatic size_t\npac_decay_stashed(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache, bool fully_decay,\n edata_list_inactive_t *decay_extents) {\n\tbool err;\n\n\tsize_t nmadvise = 0;\n\tsize_t nunmapped = 0;\n\tsize_t npurged = 0;\n\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\n\tbool try_muzzy = !fully_decay\n\t && pac_decay_ms_get(pac, extent_state_muzzy) != 0;\n\n\tfor (edata_t *edata = edata_list_inactive_first(decay_extents); edata !=\n\t NULL; edata = edata_list_inactive_first(decay_extents)) {\n\t\tedata_list_inactive_remove(decay_extents, edata);\n\n\t\tsize_t size = edata_size_get(edata);\n\t\tsize_t npages = size >> LG_PAGE;\n\n\t\tnmadvise++;\n\t\tnpurged += npages;\n\n\t\tswitch (ecache->state) {\n\t\tcase extent_state_active:\n\t\t\tnot_reached();\n\t\tcase extent_state_dirty:\n\t\t\tif (try_muzzy) {\n\t\t\t\terr = extent_purge_lazy_wrapper(tsdn, ehooks,\n\t\t\t\t edata, /* offset */ 0, size);\n\t\t\t\tif (!err) {\n\t\t\t\t\tecache_dalloc(tsdn, pac, ehooks,\n\t\t\t\t\t &pac->ecache_muzzy, edata);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tJEMALLOC_FALLTHROUGH;\n\t\tcase extent_state_muzzy:\n\t\t\textent_dalloc_wrapper(tsdn, pac, ehooks, edata);\n\t\t\tnunmapped += npages;\n\t\t\tbreak;\n\t\tcase extent_state_retained:\n\t\tdefault:\n\t\t\tnot_reached();\n\t\t}\n\t}\n\n\tif (config_stats) {\n\t\tLOCKEDINT_MTX_LOCK(tsdn, *pac->stats_mtx);\n\t\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(*pac->stats_mtx),\n\t\t &decay_stats->npurge, 1);\n\t\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(*pac->stats_mtx),\n\t\t &decay_stats->nmadvise, nmadvise);\n\t\tlocked_inc_u64(tsdn, LOCKEDINT_MTX(*pac->stats_mtx),\n\t\t &decay_stats->purged, npurged);\n\t\tLOCKEDINT_MTX_UNLOCK(tsdn, *pac->stats_mtx);\n\t\tatomic_fetch_sub_zu(&pac->stats->pac_mapped,\n\t\t nunmapped << LG_PAGE, ATOMIC_RELAXED);\n\t}\n\n\treturn npurged;\n}\n\n/*\n * npages_limit: Decay at most npages_decay_max pages without violating the\n * invariant: (ecache_npages_get(ecache) >= npages_limit). We need an upper\n * bound on number of pages in order to prevent unbounded growth (namely in\n * stashed), otherwise unbounded new pages could be added to extents during the\n * current decay run, so that the purging thread never finishes.\n */\nstatic void\npac_decay_to_limit(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache, bool fully_decay,\n size_t npages_limit, size_t npages_decay_max) {\n\twitness_assert_depth_to_rank(tsdn_witness_tsdp_get(tsdn),\n\t WITNESS_RANK_CORE, 1);\n\n\tif (decay->purging || npages_decay_max == 0) {\n\t\treturn;\n\t}\n\tdecay->purging = true;\n\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\n\tedata_list_inactive_t decay_extents;\n\tedata_list_inactive_init(&decay_extents);\n\tsize_t npurge = pac_stash_decayed(tsdn, pac, ecache, npages_limit,\n\t npages_decay_max, &decay_extents);\n\tif (npurge != 0) {\n\t\tsize_t npurged = pac_decay_stashed(tsdn, pac, decay,\n\t\t decay_stats, ecache, fully_decay, &decay_extents);\n\t\tassert(npurged == npurge);\n\t}\n\n\tmalloc_mutex_lock(tsdn, &decay->mtx);\n\tdecay->purging = false;\n}\n\nvoid\npac_decay_all(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache, bool fully_decay) {\n\tmalloc_mutex_assert_owner(tsdn, &decay->mtx);\n\tpac_decay_to_limit(tsdn, pac, decay, decay_stats, ecache, fully_decay,\n\t /* npages_limit */ 0, ecache_npages_get(ecache));\n}\n\nstatic void\npac_decay_try_purge(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache,\n size_t current_npages, size_t npages_limit) {\n\tif (current_npages > npages_limit) {\n\t\tpac_decay_to_limit(tsdn, pac, decay, decay_stats, ecache,\n\t\t /* fully_decay */ false, npages_limit,\n\t\t current_npages - npages_limit);\n\t}\n}\n\nbool\npac_maybe_decay_purge(tsdn_t *tsdn, pac_t *pac, decay_t *decay,\n pac_decay_stats_t *decay_stats, ecache_t *ecache,\n pac_purge_eagerness_t eagerness) {\n\tmalloc_mutex_assert_owner(tsdn, &decay->mtx);\n\n\t/* Purge all or nothing if the option is disabled. */\n\tssize_t decay_ms = decay_ms_read(decay);\n\tif (decay_ms <= 0) {\n\t\tif (decay_ms == 0) {\n\t\t\tpac_decay_to_limit(tsdn, pac, decay, decay_stats,\n\t\t\t ecache, /* fully_decay */ false,\n\t\t\t /* npages_limit */ 0, ecache_npages_get(ecache));\n\t\t}\n\t\treturn false;\n\t}\n\n\t/*\n\t * If the deadline has been reached, advance to the current epoch and\n\t * purge to the new limit if necessary. Note that dirty pages created\n\t * during the current epoch are not subject to purge until a future\n\t * epoch, so as a result purging only happens during epoch advances, or\n\t * being triggered by background threads (scheduled event).\n\t */\n\tnstime_t time;\n\tnstime_init_update(&time);\n\tsize_t npages_current = ecache_npages_get(ecache);\n\tbool epoch_advanced = decay_maybe_advance_epoch(decay, &time,\n\t npages_current);\n\tif (eagerness == PAC_PURGE_ALWAYS\n\t || (epoch_advanced && eagerness == PAC_PURGE_ON_EPOCH_ADVANCE)) {\n\t\tsize_t npages_limit = decay_npages_limit_get(decay);\n\t\tpac_decay_try_purge(tsdn, pac, decay, decay_stats, ecache,\n\t\t npages_current, npages_limit);\n\t}\n\n\treturn epoch_advanced;\n}\n\nbool\npac_decay_ms_set(tsdn_t *tsdn, pac_t *pac, extent_state_t state,\n ssize_t decay_ms, pac_purge_eagerness_t eagerness) {\n\tdecay_t *decay;\n\tpac_decay_stats_t *decay_stats;\n\tecache_t *ecache;\n\tpac_decay_data_get(pac, state, &decay, &decay_stats, &ecache);\n\n\tif (!decay_ms_valid(decay_ms)) {\n\t\treturn true;\n\t}\n\n\tmalloc_mutex_lock(tsdn, &decay->mtx);\n\t/*\n\t * Restart decay backlog from scratch, which may cause many dirty pages\n\t * to be immediately purged. It would conceptually be possible to map\n\t * the old backlog onto the new backlog, but there is no justification\n\t * for such complexity since decay_ms changes are intended to be\n\t * infrequent, either between the {-1, 0, >0} states, or a one-time\n\t * arbitrary change during initial arena configuration.\n\t */\n\tnstime_t cur_time;\n\tnstime_init_update(&cur_time);\n\tdecay_reinit(decay, &cur_time, decay_ms);\n\tpac_maybe_decay_purge(tsdn, pac, decay, decay_stats, ecache, eagerness);\n\tmalloc_mutex_unlock(tsdn, &decay->mtx);\n\n\treturn false;\n}\n\nssize_t\npac_decay_ms_get(pac_t *pac, extent_state_t state) {\n\tdecay_t *decay;\n\tpac_decay_stats_t *decay_stats;\n\tecache_t *ecache;\n\tpac_decay_data_get(pac, state, &decay, &decay_stats, &ecache);\n\treturn decay_ms_read(decay);\n}\n\nvoid\npac_reset(tsdn_t *tsdn, pac_t *pac) {\n\t/*\n\t * No-op for now; purging is still done at the arena-level. It should\n\t * get moved in here, though.\n\t */\n\t(void)tsdn;\n\t(void)pac;\n}\n\nvoid\npac_destroy(tsdn_t *tsdn, pac_t *pac) {\n\tassert(ecache_npages_get(&pac->ecache_dirty) == 0);\n\tassert(ecache_npages_get(&pac->ecache_muzzy) == 0);\n\t/*\n\t * Iterate over the retained extents and destroy them. This gives the\n\t * extent allocator underlying the extent hooks an opportunity to unmap\n\t * all retained memory without having to keep its own metadata\n\t * structures. In practice, virtual memory for dss-allocated extents is\n\t * leaked here, so best practice is to avoid dss for arenas to be\n\t * destroyed, or provide custom extent hooks that track retained\n\t * dss-based extents for later reuse.\n\t */\n\tehooks_t *ehooks = pac_ehooks_get(pac);\n\tedata_t *edata;\n\twhile ((edata = ecache_evict(tsdn, pac, ehooks,\n\t &pac->ecache_retained, 0)) != NULL) {\n\t\textent_destroy_wrapper(tsdn, pac, ehooks, edata);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/pages.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n#include \"jemalloc/internal/pages.h\"\n\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n\n#ifdef JEMALLOC_SYSCTL_VM_OVERCOMMIT\n#include \n#ifdef __FreeBSD__\n#include \n#endif\n#endif\n#ifdef __NetBSD__\n#include \t/* ilog2 */\n#endif\n#ifdef JEMALLOC_HAVE_VM_MAKE_TAG\n#define PAGES_FD_TAG VM_MAKE_TAG(101U)\n#else\n#define PAGES_FD_TAG -1\n#endif\n\n/******************************************************************************/\n/* Data. */\n\n/* Actual operating system page size, detected during bootstrap, <= PAGE. */\nstatic size_t\tos_page;\n\n#ifndef _WIN32\n# define PAGES_PROT_COMMIT (PROT_READ | PROT_WRITE)\n# define PAGES_PROT_DECOMMIT (PROT_NONE)\nstatic int\tmmap_flags;\n#endif\nstatic bool\tos_overcommits;\n\nconst char *thp_mode_names[] = {\n\t\"default\",\n\t\"always\",\n\t\"never\",\n\t\"not supported\"\n};\nthp_mode_t opt_thp = THP_MODE_DEFAULT;\nthp_mode_t init_system_thp_mode;\n\n/* Runtime support for lazy purge. Irrelevant when !pages_can_purge_lazy. */\nstatic bool pages_can_purge_lazy_runtime = true;\n\n#ifdef JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS\nstatic int madvise_dont_need_zeros_is_faulty = -1;\n/**\n * Check that MADV_DONTNEED will actually zero pages on subsequent access.\n *\n * Since qemu does not support this, yet [1], and you can get very tricky\n * assert if you will run program with jemalloc in use under qemu:\n *\n * : ../contrib/jemalloc/src/extent.c:1195: Failed assertion: \"p[i] == 0\"\n *\n * [1]: https://patchwork.kernel.org/patch/10576637/\n */\nstatic int madvise_MADV_DONTNEED_zeroes_pages()\n{\n\tint works = -1;\n\tsize_t size = PAGE;\n\n\tvoid * addr = mmap(NULL, size, PROT_READ|PROT_WRITE,\n\t MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);\n\n\tif (addr == MAP_FAILED) {\n\t\tmalloc_write(\": Cannot allocate memory for \"\n\t\t \"MADV_DONTNEED check\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n\n\tmemset(addr, 'A', size);\n\tif (madvise(addr, size, MADV_DONTNEED) == 0) {\n\t\tworks = memchr(addr, 'A', size) == NULL;\n\t} else {\n\t\t/*\n\t\t * If madvise() does not support MADV_DONTNEED, then we can\n\t\t * call it anyway, and use it's return code.\n\t\t */\n\t\tworks = 1;\n\t}\n\n\tif (munmap(addr, size) != 0) {\n\t\tmalloc_write(\": Cannot deallocate memory for \"\n\t\t \"MADV_DONTNEED check\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n\n\treturn works;\n}\n#endif\n\n/******************************************************************************/\n/*\n * Function prototypes for static functions that are referenced prior to\n * definition.\n */\n\nstatic void os_pages_unmap(void *addr, size_t size);\n\n/******************************************************************************/\n\nstatic void *\nos_pages_map(void *addr, size_t size, size_t alignment, bool *commit) {\n\tassert(ALIGNMENT_ADDR2BASE(addr, os_page) == addr);\n\tassert(ALIGNMENT_CEILING(size, os_page) == size);\n\tassert(size != 0);\n\n\tif (os_overcommits) {\n\t\t*commit = true;\n\t}\n\n\tvoid *ret;\n#ifdef _WIN32\n\t/*\n\t * If VirtualAlloc can't allocate at the given address when one is\n\t * given, it fails and returns NULL.\n\t */\n\tret = VirtualAlloc(addr, size, MEM_RESERVE | (*commit ? MEM_COMMIT : 0),\n\t PAGE_READWRITE);\n#else\n\t/*\n\t * We don't use MAP_FIXED here, because it can cause the *replacement*\n\t * of existing mappings, and we only want to create new mappings.\n\t */\n\t{\n#ifdef __NetBSD__\n\t\t/*\n\t\t * On NetBSD PAGE for a platform is defined to the\n\t\t * maximum page size of all machine architectures\n\t\t * for that platform, so that we can use the same\n\t\t * binaries across all machine architectures.\n\t\t */\n\t\tif (alignment > os_page || PAGE > os_page) {\n\t\t\tunsigned int a = ilog2(MAX(alignment, PAGE));\n\t\t\tmmap_flags |= MAP_ALIGNED(a);\n\t\t}\n#endif\n\t\tint prot = *commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT;\n\n\t\tret = mmap(addr, size, prot, mmap_flags, PAGES_FD_TAG, 0);\n\t}\n\tassert(ret != NULL);\n\n\tif (ret == MAP_FAILED) {\n\t\tret = NULL;\n\t} else if (addr != NULL && ret != addr) {\n\t\t/*\n\t\t * We succeeded in mapping memory, but not in the right place.\n\t\t */\n\t\tos_pages_unmap(ret, size);\n\t\tret = NULL;\n\t}\n#endif\n\tassert(ret == NULL || (addr == NULL && ret != addr) || (addr != NULL &&\n\t ret == addr));\n\treturn ret;\n}\n\nstatic void *\nos_pages_trim(void *addr, size_t alloc_size, size_t leadsize, size_t size,\n bool *commit) {\n\tvoid *ret = (void *)((uintptr_t)addr + leadsize);\n\n\tassert(alloc_size >= leadsize + size);\n#ifdef _WIN32\n\tos_pages_unmap(addr, alloc_size);\n\tvoid *new_addr = os_pages_map(ret, size, PAGE, commit);\n\tif (new_addr == ret) {\n\t\treturn ret;\n\t}\n\tif (new_addr != NULL) {\n\t\tos_pages_unmap(new_addr, size);\n\t}\n\treturn NULL;\n#else\n\tsize_t trailsize = alloc_size - leadsize - size;\n\n\tif (leadsize != 0) {\n\t\tos_pages_unmap(addr, leadsize);\n\t}\n\tif (trailsize != 0) {\n\t\tos_pages_unmap((void *)((uintptr_t)ret + size), trailsize);\n\t}\n\treturn ret;\n#endif\n}\n\nstatic void\nos_pages_unmap(void *addr, size_t size) {\n\tassert(ALIGNMENT_ADDR2BASE(addr, os_page) == addr);\n\tassert(ALIGNMENT_CEILING(size, os_page) == size);\n\n#ifdef _WIN32\n\tif (VirtualFree(addr, 0, MEM_RELEASE) == 0)\n#else\n\tif (munmap(addr, size) == -1)\n#endif\n\t{\n\t\tchar buf[BUFERROR_BUF];\n\n\t\tbuferror(get_errno(), buf, sizeof(buf));\n\t\tmalloc_printf(\": Error in \"\n#ifdef _WIN32\n\t\t \"VirtualFree\"\n#else\n\t\t \"munmap\"\n#endif\n\t\t \"(): %s\\n\", buf);\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t}\n}\n\nstatic void *\npages_map_slow(size_t size, size_t alignment, bool *commit) {\n\tsize_t alloc_size = size + alignment - os_page;\n\t/* Beware size_t wrap-around. */\n\tif (alloc_size < size) {\n\t\treturn NULL;\n\t}\n\n\tvoid *ret;\n\tdo {\n\t\tvoid *pages = os_pages_map(NULL, alloc_size, alignment, commit);\n\t\tif (pages == NULL) {\n\t\t\treturn NULL;\n\t\t}\n\t\tsize_t leadsize = ALIGNMENT_CEILING((uintptr_t)pages, alignment)\n\t\t - (uintptr_t)pages;\n\t\tret = os_pages_trim(pages, alloc_size, leadsize, size, commit);\n\t} while (ret == NULL);\n\n\tassert(ret != NULL);\n\tassert(PAGE_ADDR2BASE(ret) == ret);\n\treturn ret;\n}\n\nvoid *\npages_map(void *addr, size_t size, size_t alignment, bool *commit) {\n\tassert(alignment >= PAGE);\n\tassert(ALIGNMENT_ADDR2BASE(addr, alignment) == addr);\n\n#if defined(__FreeBSD__) && defined(MAP_EXCL)\n\t/*\n\t * FreeBSD has mechanisms both to mmap at specific address without\n\t * touching existing mappings, and to mmap with specific alignment.\n\t */\n\t{\n\t\tif (os_overcommits) {\n\t\t\t*commit = true;\n\t\t}\n\n\t\tint prot = *commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT;\n\t\tint flags = mmap_flags;\n\n\t\tif (addr != NULL) {\n\t\t\tflags |= MAP_FIXED | MAP_EXCL;\n\t\t} else {\n\t\t\tunsigned alignment_bits = ffs_zu(alignment);\n\t\t\tassert(alignment_bits > 0);\n\t\t\tflags |= MAP_ALIGNED(alignment_bits);\n\t\t}\n\n\t\tvoid *ret = mmap(addr, size, prot, flags, -1, 0);\n\t\tif (ret == MAP_FAILED) {\n\t\t\tret = NULL;\n\t\t}\n\n\t\treturn ret;\n\t}\n#endif\n\t/*\n\t * Ideally, there would be a way to specify alignment to mmap() (like\n\t * NetBSD has), but in the absence of such a feature, we have to work\n\t * hard to efficiently create aligned mappings. The reliable, but\n\t * slow method is to create a mapping that is over-sized, then trim the\n\t * excess. However, that always results in one or two calls to\n\t * os_pages_unmap(), and it can leave holes in the process's virtual\n\t * memory map if memory grows downward.\n\t *\n\t * Optimistically try mapping precisely the right amount before falling\n\t * back to the slow method, with the expectation that the optimistic\n\t * approach works most of the time.\n\t */\n\n\tvoid *ret = os_pages_map(addr, size, os_page, commit);\n\tif (ret == NULL || ret == addr) {\n\t\treturn ret;\n\t}\n\tassert(addr == NULL);\n\tif (ALIGNMENT_ADDR2OFFSET(ret, alignment) != 0) {\n\t\tos_pages_unmap(ret, size);\n\t\treturn pages_map_slow(size, alignment, commit);\n\t}\n\n\tassert(PAGE_ADDR2BASE(ret) == ret);\n\treturn ret;\n}\n\nvoid\npages_unmap(void *addr, size_t size) {\n\tassert(PAGE_ADDR2BASE(addr) == addr);\n\tassert(PAGE_CEILING(size) == size);\n\n\tos_pages_unmap(addr, size);\n}\n\nstatic bool\nos_pages_commit(void *addr, size_t size, bool commit) {\n\tassert(PAGE_ADDR2BASE(addr) == addr);\n\tassert(PAGE_CEILING(size) == size);\n\n#ifdef _WIN32\n\treturn (commit ? (addr != VirtualAlloc(addr, size, MEM_COMMIT,\n\t PAGE_READWRITE)) : (!VirtualFree(addr, size, MEM_DECOMMIT)));\n#else\n\t{\n\t\tint prot = commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT;\n\t\tvoid *result = mmap(addr, size, prot, mmap_flags | MAP_FIXED,\n\t\t PAGES_FD_TAG, 0);\n\t\tif (result == MAP_FAILED) {\n\t\t\treturn true;\n\t\t}\n\t\tif (result != addr) {\n\t\t\t/*\n\t\t\t * We succeeded in mapping memory, but not in the right\n\t\t\t * place.\n\t\t\t */\n\t\t\tos_pages_unmap(result, size);\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n#endif\n}\n\nstatic bool\npages_commit_impl(void *addr, size_t size, bool commit) {\n\tif (os_overcommits) {\n\t\treturn true;\n\t}\n\n\treturn os_pages_commit(addr, size, commit);\n}\n\nbool\npages_commit(void *addr, size_t size) {\n\treturn pages_commit_impl(addr, size, true);\n}\n\nbool\npages_decommit(void *addr, size_t size) {\n\treturn pages_commit_impl(addr, size, false);\n}\n\nvoid\npages_mark_guards(void *head, void *tail) {\n\tassert(head != NULL || tail != NULL);\n\tassert(head == NULL || tail == NULL ||\n\t (uintptr_t)head < (uintptr_t)tail);\n#ifdef JEMALLOC_HAVE_MPROTECT\n\tif (head != NULL) {\n\t\tmprotect(head, PAGE, PROT_NONE);\n\t}\n\tif (tail != NULL) {\n\t\tmprotect(tail, PAGE, PROT_NONE);\n\t}\n#else\n\t/* Decommit sets to PROT_NONE / MEM_DECOMMIT. */\n\tif (head != NULL) {\n\t\tos_pages_commit(head, PAGE, false);\n\t}\n\tif (tail != NULL) {\n\t\tos_pages_commit(tail, PAGE, false);\n\t}\n#endif\n}\n\nvoid\npages_unmark_guards(void *head, void *tail) {\n\tassert(head != NULL || tail != NULL);\n\tassert(head == NULL || tail == NULL ||\n\t (uintptr_t)head < (uintptr_t)tail);\n#ifdef JEMALLOC_HAVE_MPROTECT\n\tbool head_and_tail = (head != NULL) && (tail != NULL);\n\tsize_t range = head_and_tail ?\n\t (uintptr_t)tail - (uintptr_t)head + PAGE :\n\t SIZE_T_MAX;\n\t/*\n\t * The amount of work that the kernel does in mprotect depends on the\n\t * range argument. SC_LARGE_MINCLASS is an arbitrary threshold chosen\n\t * to prevent kernel from doing too much work that would outweigh the\n\t * savings of performing one less system call.\n\t */\n\tbool ranged_mprotect = head_and_tail && range <= SC_LARGE_MINCLASS;\n\tif (ranged_mprotect) {\n\t\tmprotect(head, range, PROT_READ | PROT_WRITE);\n\t} else {\n\t\tif (head != NULL) {\n\t\t\tmprotect(head, PAGE, PROT_READ | PROT_WRITE);\n\t\t}\n\t\tif (tail != NULL) {\n\t\t\tmprotect(tail, PAGE, PROT_READ | PROT_WRITE);\n\t\t}\n\t}\n#else\n\tif (head != NULL) {\n\t\tos_pages_commit(head, PAGE, true);\n\t}\n\tif (tail != NULL) {\n\t\tos_pages_commit(tail, PAGE, true);\n\t}\n#endif\n}\n\nbool\npages_purge_lazy(void *addr, size_t size) {\n\tassert(ALIGNMENT_ADDR2BASE(addr, os_page) == addr);\n\tassert(PAGE_CEILING(size) == size);\n\n\tif (!pages_can_purge_lazy) {\n\t\treturn true;\n\t}\n\tif (!pages_can_purge_lazy_runtime) {\n\t\t/*\n\t\t * Built with lazy purge enabled, but detected it was not\n\t\t * supported on the current system.\n\t\t */\n\t\treturn true;\n\t}\n\n#ifdef _WIN32\n\tVirtualAlloc(addr, size, MEM_RESET, PAGE_READWRITE);\n\treturn false;\n#elif defined(JEMALLOC_PURGE_MADVISE_FREE)\n\treturn (madvise(addr, size,\n# ifdef MADV_FREE\n\t MADV_FREE\n# else\n\t JEMALLOC_MADV_FREE\n# endif\n\t ) != 0);\n#elif defined(JEMALLOC_PURGE_MADVISE_DONTNEED) && \\\n !defined(JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS)\n\treturn (madvise(addr, size, MADV_DONTNEED) != 0);\n#elif defined(JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED) && \\\n !defined(JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED_ZEROS)\n\treturn (posix_madvise(addr, size, POSIX_MADV_DONTNEED) != 0);\n#else\n\tnot_reached();\n#endif\n}\n\nbool\npages_purge_forced(void *addr, size_t size) {\n\tassert(PAGE_ADDR2BASE(addr) == addr);\n\tassert(PAGE_CEILING(size) == size);\n\n\tif (!pages_can_purge_forced) {\n\t\treturn true;\n\t}\n\n#if defined(JEMALLOC_PURGE_MADVISE_DONTNEED) && \\\n defined(JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS)\n\treturn (unlikely(madvise_dont_need_zeros_is_faulty) ||\n\t madvise(addr, size, MADV_DONTNEED) != 0);\n#elif defined(JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED) && \\\n defined(JEMALLOC_PURGE_POSIX_MADVISE_DONTNEED_ZEROS)\n\treturn (unlikely(madvise_dont_need_zeros_is_faulty) ||\n\t posix_madvise(addr, size, POSIX_MADV_DONTNEED) != 0);\n#elif defined(JEMALLOC_MAPS_COALESCE)\n\t/* Try to overlay a new demand-zeroed mapping. */\n\treturn pages_commit(addr, size);\n#else\n\tnot_reached();\n#endif\n}\n\nstatic bool\npages_huge_impl(void *addr, size_t size, bool aligned) {\n\tif (aligned) {\n\t\tassert(HUGEPAGE_ADDR2BASE(addr) == addr);\n\t\tassert(HUGEPAGE_CEILING(size) == size);\n\t}\n#if defined(JEMALLOC_HAVE_MADVISE_HUGE)\n\treturn (madvise(addr, size, MADV_HUGEPAGE) != 0);\n#elif defined(JEMALLOC_HAVE_MEMCNTL)\n\tstruct memcntl_mha m = {0};\n\tm.mha_cmd = MHA_MAPSIZE_VA;\n\tm.mha_pagesize = HUGEPAGE;\n\treturn (memcntl(addr, size, MC_HAT_ADVISE, (caddr_t)&m, 0, 0) == 0);\n#else\n\treturn true;\n#endif\n}\n\nbool\npages_huge(void *addr, size_t size) {\n\treturn pages_huge_impl(addr, size, true);\n}\n\nstatic bool\npages_huge_unaligned(void *addr, size_t size) {\n\treturn pages_huge_impl(addr, size, false);\n}\n\nstatic bool\npages_nohuge_impl(void *addr, size_t size, bool aligned) {\n\tif (aligned) {\n\t\tassert(HUGEPAGE_ADDR2BASE(addr) == addr);\n\t\tassert(HUGEPAGE_CEILING(size) == size);\n\t}\n\n#ifdef JEMALLOC_HAVE_MADVISE_HUGE\n\treturn (madvise(addr, size, MADV_NOHUGEPAGE) != 0);\n#else\n\treturn false;\n#endif\n}\n\nbool\npages_nohuge(void *addr, size_t size) {\n\treturn pages_nohuge_impl(addr, size, true);\n}\n\nstatic bool\npages_nohuge_unaligned(void *addr, size_t size) {\n\treturn pages_nohuge_impl(addr, size, false);\n}\n\nbool\npages_dontdump(void *addr, size_t size) {\n\tassert(PAGE_ADDR2BASE(addr) == addr);\n\tassert(PAGE_CEILING(size) == size);\n#if defined(JEMALLOC_MADVISE_DONTDUMP)\n\treturn madvise(addr, size, MADV_DONTDUMP) != 0;\n#elif defined(JEMALLOC_MADVISE_NOCORE)\n\treturn madvise(addr, size, MADV_NOCORE) != 0;\n#else\n\treturn false;\n#endif\n}\n\nbool\npages_dodump(void *addr, size_t size) {\n\tassert(PAGE_ADDR2BASE(addr) == addr);\n\tassert(PAGE_CEILING(size) == size);\n#if defined(JEMALLOC_MADVISE_DONTDUMP)\n\treturn madvise(addr, size, MADV_DODUMP) != 0;\n#elif defined(JEMALLOC_MADVISE_NOCORE)\n\treturn madvise(addr, size, MADV_CORE) != 0;\n#else\n\treturn false;\n#endif\n}\n\n\nstatic size_t\nos_page_detect(void) {\n#ifdef _WIN32\n\tSYSTEM_INFO si;\n\tGetSystemInfo(&si);\n\treturn si.dwPageSize;\n#elif defined(__FreeBSD__)\n\t/*\n\t * This returns the value obtained from\n\t * the auxv vector, avoiding a syscall.\n\t */\n\treturn getpagesize();\n#else\n\tlong result = sysconf(_SC_PAGESIZE);\n\tif (result == -1) {\n\t\treturn LG_PAGE;\n\t}\n\treturn (size_t)result;\n#endif\n}\n\n#ifdef JEMALLOC_SYSCTL_VM_OVERCOMMIT\nstatic bool\nos_overcommits_sysctl(void) {\n\tint vm_overcommit;\n\tsize_t sz;\n\n\tsz = sizeof(vm_overcommit);\n#if defined(__FreeBSD__) && defined(VM_OVERCOMMIT)\n\tint mib[2];\n\n\tmib[0] = CTL_VM;\n\tmib[1] = VM_OVERCOMMIT;\n\tif (sysctl(mib, 2, &vm_overcommit, &sz, NULL, 0) != 0) {\n\t\treturn false; /* Error. */\n\t}\n#else\n\tif (sysctlbyname(\"vm.overcommit\", &vm_overcommit, &sz, NULL, 0) != 0) {\n\t\treturn false; /* Error. */\n\t}\n#endif\n\n\treturn ((vm_overcommit & 0x3) == 0);\n}\n#endif\n\n#ifdef JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY\n/*\n * Use syscall(2) rather than {open,read,close}(2) when possible to avoid\n * reentry during bootstrapping if another library has interposed system call\n * wrappers.\n */\nstatic bool\nos_overcommits_proc(void) {\n\tint fd;\n\tchar buf[1];\n\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_open)\n\t#if defined(O_CLOEXEC)\n\t\tfd = (int)syscall(SYS_open, \"/proc/sys/vm/overcommit_memory\", O_RDONLY |\n\t\t\tO_CLOEXEC);\n\t#else\n\t\tfd = (int)syscall(SYS_open, \"/proc/sys/vm/overcommit_memory\", O_RDONLY);\n\t\tif (fd != -1) {\n\t\t\tfcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);\n\t\t}\n\t#endif\n#elif defined(JEMALLOC_USE_SYSCALL) && defined(SYS_openat)\n\t#if defined(O_CLOEXEC)\n\t\tfd = (int)syscall(SYS_openat,\n\t\t\tAT_FDCWD, \"/proc/sys/vm/overcommit_memory\", O_RDONLY | O_CLOEXEC);\n\t#else\n\t\tfd = (int)syscall(SYS_openat,\n\t\t\tAT_FDCWD, \"/proc/sys/vm/overcommit_memory\", O_RDONLY);\n\t\tif (fd != -1) {\n\t\t\tfcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);\n\t\t}\n\t#endif\n#else\n\t#if defined(O_CLOEXEC)\n\t\tfd = open(\"/proc/sys/vm/overcommit_memory\", O_RDONLY | O_CLOEXEC);\n\t#else\n\t\tfd = open(\"/proc/sys/vm/overcommit_memory\", O_RDONLY);\n\t\tif (fd != -1) {\n\t\t\tfcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);\n\t\t}\n\t#endif\n#endif\n\n\tif (fd == -1) {\n\t\treturn false; /* Error. */\n\t}\n\n\tssize_t nread = malloc_read_fd(fd, &buf, sizeof(buf));\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_close)\n\tsyscall(SYS_close, fd);\n#else\n\tclose(fd);\n#endif\n\n\tif (nread < 1) {\n\t\treturn false; /* Error. */\n\t}\n\t/*\n\t * /proc/sys/vm/overcommit_memory meanings:\n\t * 0: Heuristic overcommit.\n\t * 1: Always overcommit.\n\t * 2: Never overcommit.\n\t */\n\treturn (buf[0] == '0' || buf[0] == '1');\n}\n#endif\n\nvoid\npages_set_thp_state (void *ptr, size_t size) {\n\tif (opt_thp == thp_mode_default || opt_thp == init_system_thp_mode) {\n\t\treturn;\n\t}\n\tassert(opt_thp != thp_mode_not_supported &&\n\t init_system_thp_mode != thp_mode_not_supported);\n\n\tif (opt_thp == thp_mode_always\n\t && init_system_thp_mode != thp_mode_never) {\n\t\tassert(init_system_thp_mode == thp_mode_default);\n\t\tpages_huge_unaligned(ptr, size);\n\t} else if (opt_thp == thp_mode_never) {\n\t\tassert(init_system_thp_mode == thp_mode_default ||\n\t\t init_system_thp_mode == thp_mode_always);\n\t\tpages_nohuge_unaligned(ptr, size);\n\t}\n}\n\nstatic void\ninit_thp_state(void) {\n\tif (!have_madvise_huge && !have_memcntl) {\n\t\tif (metadata_thp_enabled() && opt_abort) {\n\t\t\tmalloc_write(\": no MADV_HUGEPAGE support\\n\");\n\t\t\tabort();\n\t\t}\n\t\tgoto label_error;\n\t}\n#if defined(JEMALLOC_HAVE_MADVISE_HUGE)\n\tstatic const char sys_state_madvise[] = \"always [madvise] never\\n\";\n\tstatic const char sys_state_always[] = \"[always] madvise never\\n\";\n\tstatic const char sys_state_never[] = \"always madvise [never]\\n\";\n\tchar buf[sizeof(sys_state_madvise)];\n\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_open)\n\tint fd = (int)syscall(SYS_open,\n\t \"/sys/kernel/mm/transparent_hugepage/enabled\", O_RDONLY);\n#elif defined(JEMALLOC_USE_SYSCALL) && defined(SYS_openat)\n\tint fd = (int)syscall(SYS_openat,\n\t\t AT_FDCWD, \"/sys/kernel/mm/transparent_hugepage/enabled\", O_RDONLY);\n#else\n\tint fd = open(\"/sys/kernel/mm/transparent_hugepage/enabled\", O_RDONLY);\n#endif\n\tif (fd == -1) {\n\t\tgoto label_error;\n\t}\n\n\tssize_t nread = malloc_read_fd(fd, &buf, sizeof(buf));\n#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_close)\n\tsyscall(SYS_close, fd);\n#else\n\tclose(fd);\n#endif\n\n if (nread < 0) {\n\t\tgoto label_error;\n }\n\n\tif (strncmp(buf, sys_state_madvise, (size_t)nread) == 0) {\n\t\tinit_system_thp_mode = thp_mode_default;\n\t} else if (strncmp(buf, sys_state_always, (size_t)nread) == 0) {\n\t\tinit_system_thp_mode = thp_mode_always;\n\t} else if (strncmp(buf, sys_state_never, (size_t)nread) == 0) {\n\t\tinit_system_thp_mode = thp_mode_never;\n\t} else {\n\t\tgoto label_error;\n\t}\n\treturn;\n#elif defined(JEMALLOC_HAVE_MEMCNTL)\n\tinit_system_thp_mode = thp_mode_default;\n\treturn;\n#endif\nlabel_error:\n\topt_thp = init_system_thp_mode = thp_mode_not_supported;\n}\n\nbool\npages_boot(void) {\n\tos_page = os_page_detect();\n\tif (os_page > PAGE) {\n\t\tmalloc_write(\": Unsupported system page size\\n\");\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t\treturn true;\n\t}\n\n#ifdef JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS\n\tif (!opt_trust_madvise) {\n\t\tmadvise_dont_need_zeros_is_faulty = !madvise_MADV_DONTNEED_zeroes_pages();\n\t\tif (madvise_dont_need_zeros_is_faulty) {\n\t\t\tmalloc_write(\": MADV_DONTNEED does not work (memset will be used instead)\\n\");\n\t\t\tmalloc_write(\": (This is the expected behaviour if you are running under QEMU)\\n\");\n\t\t}\n\t} else {\n\t\t/* In case opt_trust_madvise is disable,\n\t\t * do not do runtime check */\n\t\tmadvise_dont_need_zeros_is_faulty = 0;\n\t}\n#endif\n\n#ifndef _WIN32\n\tmmap_flags = MAP_PRIVATE | MAP_ANON;\n#endif\n\n#ifdef JEMALLOC_SYSCTL_VM_OVERCOMMIT\n\tos_overcommits = os_overcommits_sysctl();\n#elif defined(JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY)\n\tos_overcommits = os_overcommits_proc();\n# ifdef MAP_NORESERVE\n\tif (os_overcommits) {\n\t\tmmap_flags |= MAP_NORESERVE;\n\t}\n# endif\n#elif defined(__NetBSD__)\n\tos_overcommits = true;\n#else\n\tos_overcommits = false;\n#endif\n\n\tinit_thp_state();\n\n#ifdef __FreeBSD__\n\t/*\n\t * FreeBSD doesn't need the check; madvise(2) is known to work.\n\t */\n#else\n\t/* Detect lazy purge runtime support. */\n\tif (pages_can_purge_lazy) {\n\t\tbool committed = false;\n\t\tvoid *madv_free_page = os_pages_map(NULL, PAGE, PAGE, &committed);\n\t\tif (madv_free_page == NULL) {\n\t\t\treturn true;\n\t\t}\n\t\tassert(pages_can_purge_lazy_runtime);\n\t\tif (pages_purge_lazy(madv_free_page, PAGE)) {\n\t\t\tpages_can_purge_lazy_runtime = false;\n\t\t}\n\t\tos_pages_unmap(madv_free_page, PAGE);\n\t}\n#endif\n\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/pai.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nsize_t\npai_alloc_batch_default(tsdn_t *tsdn, pai_t *self, size_t size, size_t nallocs,\n edata_list_active_t *results, bool *deferred_work_generated) {\n\tfor (size_t i = 0; i < nallocs; i++) {\n\t\tbool deferred_by_alloc = false;\n\t\tedata_t *edata = pai_alloc(tsdn, self, size, PAGE,\n\t\t /* zero */ false, /* guarded */ false,\n\t\t /* frequent_reuse */ false, &deferred_by_alloc);\n\t\t*deferred_work_generated |= deferred_by_alloc;\n\t\tif (edata == NULL) {\n\t\t\treturn i;\n\t\t}\n\t\tedata_list_active_append(results, edata);\n\t}\n\treturn nallocs;\n}\n\nvoid\npai_dalloc_batch_default(tsdn_t *tsdn, pai_t *self,\n edata_list_active_t *list, bool *deferred_work_generated) {\n\tedata_t *edata;\n\twhile ((edata = edata_list_active_first(list)) != NULL) {\n\t\tbool deferred_by_dalloc = false;\n\t\tedata_list_active_remove(list, edata);\n\t\tpai_dalloc(tsdn, self, edata, &deferred_by_dalloc);\n\t\t*deferred_work_generated |= deferred_by_dalloc;\n\t}\n}\n" }, { "path": "deps/jemalloc/src/peak_event.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/peak_event.h\"\n\n#include \"jemalloc/internal/activity_callback.h\"\n#include \"jemalloc/internal/peak.h\"\n\n/*\n * Update every 64K by default. We're not exposing this as a configuration\n * option for now; we don't want to bind ourselves too tightly to any particular\n * performance requirements for small values, or guarantee that we'll even be\n * able to provide fine-grained accuracy.\n */\n#define PEAK_EVENT_WAIT (64 * 1024)\n\n/* Update the peak with current tsd state. */\nvoid\npeak_event_update(tsd_t *tsd) {\n\tuint64_t alloc = tsd_thread_allocated_get(tsd);\n\tuint64_t dalloc = tsd_thread_deallocated_get(tsd);\n\tpeak_t *peak = tsd_peakp_get(tsd);\n\tpeak_update(peak, alloc, dalloc);\n}\n\nstatic void\npeak_event_activity_callback(tsd_t *tsd) {\n\tactivity_callback_thunk_t *thunk = tsd_activity_callback_thunkp_get(\n\t tsd);\n\tuint64_t alloc = tsd_thread_allocated_get(tsd);\n\tuint64_t dalloc = tsd_thread_deallocated_get(tsd);\n\tif (thunk->callback != NULL) {\n\t\tthunk->callback(thunk->uctx, alloc, dalloc);\n\t}\n}\n\n/* Set current state to zero. */\nvoid\npeak_event_zero(tsd_t *tsd) {\n\tuint64_t alloc = tsd_thread_allocated_get(tsd);\n\tuint64_t dalloc = tsd_thread_deallocated_get(tsd);\n\tpeak_t *peak = tsd_peakp_get(tsd);\n\tpeak_set_zero(peak, alloc, dalloc);\n}\n\nuint64_t\npeak_event_max(tsd_t *tsd) {\n\tpeak_t *peak = tsd_peakp_get(tsd);\n\treturn peak_max(peak);\n}\n\nuint64_t\npeak_alloc_new_event_wait(tsd_t *tsd) {\n\treturn PEAK_EVENT_WAIT;\n}\n\nuint64_t\npeak_alloc_postponed_event_wait(tsd_t *tsd) {\n\treturn TE_MIN_START_WAIT;\n}\n\nvoid\npeak_alloc_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tpeak_event_update(tsd);\n\tpeak_event_activity_callback(tsd);\n}\n\nuint64_t\npeak_dalloc_new_event_wait(tsd_t *tsd) {\n\treturn PEAK_EVENT_WAIT;\n}\n\nuint64_t\npeak_dalloc_postponed_event_wait(tsd_t *tsd) {\n\treturn TE_MIN_START_WAIT;\n}\n\nvoid\npeak_dalloc_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tpeak_event_update(tsd);\n\tpeak_event_activity_callback(tsd);\n}\n" }, { "path": "deps/jemalloc/src/prof.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/counter.h\"\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_log.h\"\n#include \"jemalloc/internal/prof_recent.h\"\n#include \"jemalloc/internal/prof_stats.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n#include \"jemalloc/internal/prof_hook.h\"\n#include \"jemalloc/internal/thread_event.h\"\n\n/*\n * This file implements the profiling \"APIs\" needed by other parts of jemalloc,\n * and also manages the relevant \"operational\" data, mainly options and mutexes;\n * the core profiling data structures are encapsulated in prof_data.c.\n */\n\n/******************************************************************************/\n\n/* Data. */\n\nbool opt_prof = false;\nbool opt_prof_active = true;\nbool opt_prof_thread_active_init = true;\nsize_t opt_lg_prof_sample = LG_PROF_SAMPLE_DEFAULT;\nssize_t opt_lg_prof_interval = LG_PROF_INTERVAL_DEFAULT;\nbool opt_prof_gdump = false;\nbool opt_prof_final = false;\nbool opt_prof_leak = false;\nbool opt_prof_leak_error = false;\nbool opt_prof_accum = false;\nchar opt_prof_prefix[PROF_DUMP_FILENAME_LEN];\nbool opt_prof_sys_thread_name = false;\nbool opt_prof_unbias = true;\n\n/* Accessed via prof_sample_event_handler(). */\nstatic counter_accum_t prof_idump_accumulated;\n\n/*\n * Initialized as opt_prof_active, and accessed via\n * prof_active_[gs]et{_unlocked,}().\n */\nbool prof_active_state;\nstatic malloc_mutex_t prof_active_mtx;\n\n/*\n * Initialized as opt_prof_thread_active_init, and accessed via\n * prof_thread_active_init_[gs]et().\n */\nstatic bool prof_thread_active_init;\nstatic malloc_mutex_t prof_thread_active_init_mtx;\n\n/*\n * Initialized as opt_prof_gdump, and accessed via\n * prof_gdump_[gs]et{_unlocked,}().\n */\nbool prof_gdump_val;\nstatic malloc_mutex_t prof_gdump_mtx;\n\nuint64_t prof_interval = 0;\n\nsize_t lg_prof_sample;\n\nstatic uint64_t next_thr_uid;\nstatic malloc_mutex_t next_thr_uid_mtx;\n\n/* Do not dump any profiles until bootstrapping is complete. */\nbool prof_booted = false;\n\n/* Logically a prof_backtrace_hook_t. */\natomic_p_t prof_backtrace_hook;\n\n/* Logically a prof_dump_hook_t. */\natomic_p_t prof_dump_hook;\n\n/******************************************************************************/\n\nvoid\nprof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx) {\n\tcassert(config_prof);\n\n\tif (tsd_reentrancy_level_get(tsd) > 0) {\n\t\tassert((uintptr_t)tctx == (uintptr_t)1U);\n\t\treturn;\n\t}\n\n\tif ((uintptr_t)tctx > (uintptr_t)1U) {\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);\n\t\ttctx->prepared = false;\n\t\tprof_tctx_try_destroy(tsd, tctx);\n\t}\n}\n\nvoid\nprof_malloc_sample_object(tsd_t *tsd, const void *ptr, size_t size,\n size_t usize, prof_tctx_t *tctx) {\n\tcassert(config_prof);\n\n\tif (opt_prof_sys_thread_name) {\n\t\tprof_sys_thread_name_fetch(tsd);\n\t}\n\n\tedata_t *edata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global,\n\t ptr);\n\tprof_info_set(tsd, edata, tctx, size);\n\n\tszind_t szind = sz_size2index(usize);\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);\n\t/*\n\t * We need to do these map lookups while holding the lock, to avoid the\n\t * possibility of races with prof_reset calls, which update the map and\n\t * then acquire the lock. This actually still leaves a data race on the\n\t * contents of the unbias map, but we have not yet gone through and\n\t * atomic-ified the prof module, and compilers are not yet causing us\n\t * issues. The key thing is to make sure that, if we read garbage data,\n\t * the prof_reset call is about to mark our tctx as expired before any\n\t * dumping of our corrupted output is attempted.\n\t */\n\tsize_t shifted_unbiased_cnt = prof_shifted_unbiased_cnt[szind];\n\tsize_t unbiased_bytes = prof_unbiased_sz[szind];\n\ttctx->cnts.curobjs++;\n\ttctx->cnts.curobjs_shifted_unbiased += shifted_unbiased_cnt;\n\ttctx->cnts.curbytes += usize;\n\ttctx->cnts.curbytes_unbiased += unbiased_bytes;\n\tif (opt_prof_accum) {\n\t\ttctx->cnts.accumobjs++;\n\t\ttctx->cnts.accumobjs_shifted_unbiased += shifted_unbiased_cnt;\n\t\ttctx->cnts.accumbytes += usize;\n\t\ttctx->cnts.accumbytes_unbiased += unbiased_bytes;\n\t}\n\tbool record_recent = prof_recent_alloc_prepare(tsd, tctx);\n\ttctx->prepared = false;\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock);\n\tif (record_recent) {\n\t\tassert(tctx == edata_prof_tctx_get(edata));\n\t\tprof_recent_alloc(tsd, edata, size, usize);\n\t}\n\n\tif (opt_prof_stats) {\n\t\tprof_stats_inc(tsd, szind, size);\n\t}\n}\n\nvoid\nprof_free_sampled_object(tsd_t *tsd, size_t usize, prof_info_t *prof_info) {\n\tcassert(config_prof);\n\n\tassert(prof_info != NULL);\n\tprof_tctx_t *tctx = prof_info->alloc_tctx;\n\tassert((uintptr_t)tctx > (uintptr_t)1U);\n\n\tszind_t szind = sz_size2index(usize);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);\n\n\tassert(tctx->cnts.curobjs > 0);\n\tassert(tctx->cnts.curbytes >= usize);\n\t/*\n\t * It's not correct to do equivalent asserts for unbiased bytes, because\n\t * of the potential for races with prof.reset calls. The map contents\n\t * should really be atomic, but we have not atomic-ified the prof module\n\t * yet.\n\t */\n\ttctx->cnts.curobjs--;\n\ttctx->cnts.curobjs_shifted_unbiased -= prof_shifted_unbiased_cnt[szind];\n\ttctx->cnts.curbytes -= usize;\n\ttctx->cnts.curbytes_unbiased -= prof_unbiased_sz[szind];\n\n\tprof_try_log(tsd, usize, prof_info);\n\n\tprof_tctx_try_destroy(tsd, tctx);\n\n\tif (opt_prof_stats) {\n\t\tprof_stats_dec(tsd, szind, prof_info->alloc_size);\n\t}\n}\n\nprof_tctx_t *\nprof_tctx_create(tsd_t *tsd) {\n\tif (!tsd_nominal(tsd) || tsd_reentrancy_level_get(tsd) > 0) {\n\t\treturn NULL;\n\t}\n\n\tprof_tdata_t *tdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn NULL;\n\t}\n\n\tprof_bt_t bt;\n\tbt_init(&bt, tdata->vec);\n\tprof_backtrace(tsd, &bt);\n\treturn prof_lookup(tsd, &bt);\n}\n\n/*\n * The bodies of this function and prof_leakcheck() are compiled out unless heap\n * profiling is enabled, so that it is possible to compile jemalloc with\n * floating point support completely disabled. Avoiding floating point code is\n * important on memory-constrained systems, but it also enables a workaround for\n * versions of glibc that don't properly save/restore floating point registers\n * during dynamic lazy symbol loading (which internally calls into whatever\n * malloc implementation happens to be integrated into the application). Note\n * that some compilers (e.g. gcc 4.8) may use floating point registers for fast\n * memory moves, so jemalloc must be compiled with such optimizations disabled\n * (e.g.\n * -mno-sse) in order for the workaround to be complete.\n */\nuint64_t\nprof_sample_new_event_wait(tsd_t *tsd) {\n#ifdef JEMALLOC_PROF\n\tif (lg_prof_sample == 0) {\n\t\treturn TE_MIN_START_WAIT;\n\t}\n\n\t/*\n\t * Compute sample interval as a geometrically distributed random\n\t * variable with mean (2^lg_prof_sample).\n\t *\n\t * __ __\n\t * | log(u) | 1\n\t * bytes_until_sample = | -------- |, where p = ---------------\n\t * | log(1-p) | lg_prof_sample\n\t * 2\n\t *\n\t * For more information on the math, see:\n\t *\n\t * Non-Uniform Random Variate Generation\n\t * Luc Devroye\n\t * Springer-Verlag, New York, 1986\n\t * pp 500\n\t * (http://luc.devroye.org/rnbookindex.html)\n\t *\n\t * In the actual computation, there's a non-zero probability that our\n\t * pseudo random number generator generates an exact 0, and to avoid\n\t * log(0), we set u to 1.0 in case r is 0. Therefore u effectively is\n\t * uniformly distributed in (0, 1] instead of [0, 1). Further, rather\n\t * than taking the ceiling, we take the floor and then add 1, since\n\t * otherwise bytes_until_sample would be 0 if u is exactly 1.0.\n\t */\n\tuint64_t r = prng_lg_range_u64(tsd_prng_statep_get(tsd), 53);\n\tdouble u = (r == 0U) ? 1.0 : (double)r * (1.0/9007199254740992.0L);\n\treturn (uint64_t)(log(u) /\n\t log(1.0 - (1.0 / (double)((uint64_t)1U << lg_prof_sample))))\n\t + (uint64_t)1U;\n#else\n\tnot_reached();\n\treturn TE_MAX_START_WAIT;\n#endif\n}\n\nuint64_t\nprof_sample_postponed_event_wait(tsd_t *tsd) {\n\t/*\n\t * The postponed wait time for prof sample event is computed as if we\n\t * want a new wait time (i.e. as if the event were triggered). If we\n\t * instead postpone to the immediate next allocation, like how we're\n\t * handling the other events, then we can have sampling bias, if e.g.\n\t * the allocation immediately following a reentrancy always comes from\n\t * the same stack trace.\n\t */\n\treturn prof_sample_new_event_wait(tsd);\n}\n\nvoid\nprof_sample_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tcassert(config_prof);\n\tassert(elapsed > 0 && elapsed != TE_INVALID_ELAPSED);\n\tif (prof_interval == 0 || !prof_active_get_unlocked()) {\n\t\treturn;\n\t}\n\tif (counter_accum(tsd_tsdn(tsd), &prof_idump_accumulated, elapsed)) {\n\t\tprof_idump(tsd_tsdn(tsd));\n\t}\n}\n\nstatic void\nprof_fdump(void) {\n\ttsd_t *tsd;\n\n\tcassert(config_prof);\n\tassert(opt_prof_final);\n\n\tif (!prof_booted) {\n\t\treturn;\n\t}\n\ttsd = tsd_fetch();\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_fdump_impl(tsd);\n}\n\nstatic bool\nprof_idump_accum_init(void) {\n\tcassert(config_prof);\n\n\treturn counter_accum_init(&prof_idump_accumulated, prof_interval);\n}\n\nvoid\nprof_idump(tsdn_t *tsdn) {\n\ttsd_t *tsd;\n\tprof_tdata_t *tdata;\n\n\tcassert(config_prof);\n\n\tif (!prof_booted || tsdn_null(tsdn) || !prof_active_get_unlocked()) {\n\t\treturn;\n\t}\n\ttsd = tsdn_tsd(tsdn);\n\tif (tsd_reentrancy_level_get(tsd) > 0) {\n\t\treturn;\n\t}\n\n\ttdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn;\n\t}\n\tif (tdata->enq) {\n\t\ttdata->enq_idump = true;\n\t\treturn;\n\t}\n\n\tprof_idump_impl(tsd);\n}\n\nbool\nprof_mdump(tsd_t *tsd, const char *filename) {\n\tcassert(config_prof);\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tif (!opt_prof || !prof_booted) {\n\t\treturn true;\n\t}\n\n\treturn prof_mdump_impl(tsd, filename);\n}\n\nvoid\nprof_gdump(tsdn_t *tsdn) {\n\ttsd_t *tsd;\n\tprof_tdata_t *tdata;\n\n\tcassert(config_prof);\n\n\tif (!prof_booted || tsdn_null(tsdn) || !prof_active_get_unlocked()) {\n\t\treturn;\n\t}\n\ttsd = tsdn_tsd(tsdn);\n\tif (tsd_reentrancy_level_get(tsd) > 0) {\n\t\treturn;\n\t}\n\n\ttdata = prof_tdata_get(tsd, false);\n\tif (tdata == NULL) {\n\t\treturn;\n\t}\n\tif (tdata->enq) {\n\t\ttdata->enq_gdump = true;\n\t\treturn;\n\t}\n\n\tprof_gdump_impl(tsd);\n}\n\nstatic uint64_t\nprof_thr_uid_alloc(tsdn_t *tsdn) {\n\tuint64_t thr_uid;\n\n\tmalloc_mutex_lock(tsdn, &next_thr_uid_mtx);\n\tthr_uid = next_thr_uid;\n\tnext_thr_uid++;\n\tmalloc_mutex_unlock(tsdn, &next_thr_uid_mtx);\n\n\treturn thr_uid;\n}\n\nprof_tdata_t *\nprof_tdata_init(tsd_t *tsd) {\n\treturn prof_tdata_init_impl(tsd, prof_thr_uid_alloc(tsd_tsdn(tsd)), 0,\n\t NULL, prof_thread_active_init_get(tsd_tsdn(tsd)));\n}\n\nprof_tdata_t *\nprof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata) {\n\tuint64_t thr_uid = tdata->thr_uid;\n\tuint64_t thr_discrim = tdata->thr_discrim + 1;\n\tchar *thread_name = (tdata->thread_name != NULL) ?\n\t prof_thread_name_alloc(tsd, tdata->thread_name) : NULL;\n\tbool active = tdata->active;\n\n\tprof_tdata_detach(tsd, tdata);\n\treturn prof_tdata_init_impl(tsd, thr_uid, thr_discrim, thread_name,\n\t active);\n}\n\nvoid\nprof_tdata_cleanup(tsd_t *tsd) {\n\tprof_tdata_t *tdata;\n\n\tif (!config_prof) {\n\t\treturn;\n\t}\n\n\ttdata = tsd_prof_tdata_get(tsd);\n\tif (tdata != NULL) {\n\t\tprof_tdata_detach(tsd, tdata);\n\t}\n}\n\nbool\nprof_active_get(tsdn_t *tsdn) {\n\tbool prof_active_current;\n\n\tprof_active_assert();\n\tmalloc_mutex_lock(tsdn, &prof_active_mtx);\n\tprof_active_current = prof_active_state;\n\tmalloc_mutex_unlock(tsdn, &prof_active_mtx);\n\treturn prof_active_current;\n}\n\nbool\nprof_active_set(tsdn_t *tsdn, bool active) {\n\tbool prof_active_old;\n\n\tprof_active_assert();\n\tmalloc_mutex_lock(tsdn, &prof_active_mtx);\n\tprof_active_old = prof_active_state;\n\tprof_active_state = active;\n\tmalloc_mutex_unlock(tsdn, &prof_active_mtx);\n\tprof_active_assert();\n\treturn prof_active_old;\n}\n\nconst char *\nprof_thread_name_get(tsd_t *tsd) {\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata;\n\n\ttdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn \"\";\n\t}\n\treturn (tdata->thread_name != NULL ? tdata->thread_name : \"\");\n}\n\nint\nprof_thread_name_set(tsd_t *tsd, const char *thread_name) {\n\tif (opt_prof_sys_thread_name) {\n\t\treturn ENOENT;\n\t} else {\n\t\treturn prof_thread_name_set_impl(tsd, thread_name);\n\t}\n}\n\nbool\nprof_thread_active_get(tsd_t *tsd) {\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata;\n\n\ttdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn false;\n\t}\n\treturn tdata->active;\n}\n\nbool\nprof_thread_active_set(tsd_t *tsd, bool active) {\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata;\n\n\ttdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn true;\n\t}\n\ttdata->active = active;\n\treturn false;\n}\n\nbool\nprof_thread_active_init_get(tsdn_t *tsdn) {\n\tbool active_init;\n\n\tmalloc_mutex_lock(tsdn, &prof_thread_active_init_mtx);\n\tactive_init = prof_thread_active_init;\n\tmalloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx);\n\treturn active_init;\n}\n\nbool\nprof_thread_active_init_set(tsdn_t *tsdn, bool active_init) {\n\tbool active_init_old;\n\n\tmalloc_mutex_lock(tsdn, &prof_thread_active_init_mtx);\n\tactive_init_old = prof_thread_active_init;\n\tprof_thread_active_init = active_init;\n\tmalloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx);\n\treturn active_init_old;\n}\n\nbool\nprof_gdump_get(tsdn_t *tsdn) {\n\tbool prof_gdump_current;\n\n\tmalloc_mutex_lock(tsdn, &prof_gdump_mtx);\n\tprof_gdump_current = prof_gdump_val;\n\tmalloc_mutex_unlock(tsdn, &prof_gdump_mtx);\n\treturn prof_gdump_current;\n}\n\nbool\nprof_gdump_set(tsdn_t *tsdn, bool gdump) {\n\tbool prof_gdump_old;\n\n\tmalloc_mutex_lock(tsdn, &prof_gdump_mtx);\n\tprof_gdump_old = prof_gdump_val;\n\tprof_gdump_val = gdump;\n\tmalloc_mutex_unlock(tsdn, &prof_gdump_mtx);\n\treturn prof_gdump_old;\n}\n\nvoid\nprof_backtrace_hook_set(prof_backtrace_hook_t hook) {\n\tatomic_store_p(&prof_backtrace_hook, hook, ATOMIC_RELEASE);\n}\n\nprof_backtrace_hook_t\nprof_backtrace_hook_get() {\n\treturn (prof_backtrace_hook_t)atomic_load_p(&prof_backtrace_hook,\n\t ATOMIC_ACQUIRE);\n}\n\nvoid\nprof_dump_hook_set(prof_dump_hook_t hook) {\n\tatomic_store_p(&prof_dump_hook, hook, ATOMIC_RELEASE);\n}\n\nprof_dump_hook_t\nprof_dump_hook_get() {\n\treturn (prof_dump_hook_t)atomic_load_p(&prof_dump_hook,\n\t ATOMIC_ACQUIRE);\n}\n\nvoid\nprof_boot0(void) {\n\tcassert(config_prof);\n\n\tmemcpy(opt_prof_prefix, PROF_PREFIX_DEFAULT,\n\t sizeof(PROF_PREFIX_DEFAULT));\n}\n\nvoid\nprof_boot1(void) {\n\tcassert(config_prof);\n\n\t/*\n\t * opt_prof must be in its final state before any arenas are\n\t * initialized, so this function must be executed early.\n\t */\n\tif (opt_prof_leak_error && !opt_prof_leak) {\n\t\topt_prof_leak = true;\n\t}\n\n\tif (opt_prof_leak && !opt_prof) {\n\t\t/*\n\t\t * Enable opt_prof, but in such a way that profiles are never\n\t\t * automatically dumped.\n\t\t */\n\t\topt_prof = true;\n\t\topt_prof_gdump = false;\n\t} else if (opt_prof) {\n\t\tif (opt_lg_prof_interval >= 0) {\n\t\t\tprof_interval = (((uint64_t)1U) <<\n\t\t\t opt_lg_prof_interval);\n\t\t}\n\t}\n}\n\nbool\nprof_boot2(tsd_t *tsd, base_t *base) {\n\tcassert(config_prof);\n\n\t/*\n\t * Initialize the global mutexes unconditionally to maintain correct\n\t * stats when opt_prof is false.\n\t */\n\tif (malloc_mutex_init(&prof_active_mtx, \"prof_active\",\n\t WITNESS_RANK_PROF_ACTIVE, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&prof_gdump_mtx, \"prof_gdump\",\n\t WITNESS_RANK_PROF_GDUMP, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&prof_thread_active_init_mtx,\n\t \"prof_thread_active_init\", WITNESS_RANK_PROF_THREAD_ACTIVE_INIT,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&bt2gctx_mtx, \"prof_bt2gctx\",\n\t WITNESS_RANK_PROF_BT2GCTX, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&tdatas_mtx, \"prof_tdatas\",\n\t WITNESS_RANK_PROF_TDATAS, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&next_thr_uid_mtx, \"prof_next_thr_uid\",\n\t WITNESS_RANK_PROF_NEXT_THR_UID, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&prof_stats_mtx, \"prof_stats\",\n\t WITNESS_RANK_PROF_STATS, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&prof_dump_filename_mtx,\n\t \"prof_dump_filename\", WITNESS_RANK_PROF_DUMP_FILENAME,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\tif (malloc_mutex_init(&prof_dump_mtx, \"prof_dump\",\n\t WITNESS_RANK_PROF_DUMP, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tif (opt_prof) {\n\t\tlg_prof_sample = opt_lg_prof_sample;\n\t\tprof_unbias_map_init();\n\t\tprof_active_state = opt_prof_active;\n\t\tprof_gdump_val = opt_prof_gdump;\n\t\tprof_thread_active_init = opt_prof_thread_active_init;\n\n\t\tif (prof_data_init(tsd)) {\n\t\t\treturn true;\n\t\t}\n\n\t\tnext_thr_uid = 0;\n\t\tif (prof_idump_accum_init()) {\n\t\t\treturn true;\n\t\t}\n\n\t\tif (opt_prof_final && opt_prof_prefix[0] != '\\0' &&\n\t\t atexit(prof_fdump) != 0) {\n\t\t\tmalloc_write(\": Error in atexit()\\n\");\n\t\t\tif (opt_abort) {\n\t\t\t\tabort();\n\t\t\t}\n\t\t}\n\n\t\tif (prof_log_init(tsd)) {\n\t\t\treturn true;\n\t\t}\n\n\t\tif (prof_recent_init()) {\n\t\t\treturn true;\n\t\t}\n\n\t\tprof_base = base;\n\n\t\tgctx_locks = (malloc_mutex_t *)base_alloc(tsd_tsdn(tsd), base,\n\t\t PROF_NCTX_LOCKS * sizeof(malloc_mutex_t), CACHELINE);\n\t\tif (gctx_locks == NULL) {\n\t\t\treturn true;\n\t\t}\n\t\tfor (unsigned i = 0; i < PROF_NCTX_LOCKS; i++) {\n\t\t\tif (malloc_mutex_init(&gctx_locks[i], \"prof_gctx\",\n\t\t\t WITNESS_RANK_PROF_GCTX,\n\t\t\t malloc_mutex_rank_exclusive)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\ttdata_locks = (malloc_mutex_t *)base_alloc(tsd_tsdn(tsd), base,\n\t\t PROF_NTDATA_LOCKS * sizeof(malloc_mutex_t), CACHELINE);\n\t\tif (tdata_locks == NULL) {\n\t\t\treturn true;\n\t\t}\n\t\tfor (unsigned i = 0; i < PROF_NTDATA_LOCKS; i++) {\n\t\t\tif (malloc_mutex_init(&tdata_locks[i], \"prof_tdata\",\n\t\t\t WITNESS_RANK_PROF_TDATA,\n\t\t\t malloc_mutex_rank_exclusive)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\tprof_unwind_init();\n\t\tprof_hooks_init();\n\t}\n\tprof_booted = true;\n\n\treturn false;\n}\n\nvoid\nprof_prefork0(tsdn_t *tsdn) {\n\tif (config_prof && opt_prof) {\n\t\tunsigned i;\n\n\t\tmalloc_mutex_prefork(tsdn, &prof_dump_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &bt2gctx_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &tdatas_mtx);\n\t\tfor (i = 0; i < PROF_NTDATA_LOCKS; i++) {\n\t\t\tmalloc_mutex_prefork(tsdn, &tdata_locks[i]);\n\t\t}\n\t\tmalloc_mutex_prefork(tsdn, &log_mtx);\n\t\tfor (i = 0; i < PROF_NCTX_LOCKS; i++) {\n\t\t\tmalloc_mutex_prefork(tsdn, &gctx_locks[i]);\n\t\t}\n\t\tmalloc_mutex_prefork(tsdn, &prof_recent_dump_mtx);\n\t}\n}\n\nvoid\nprof_prefork1(tsdn_t *tsdn) {\n\tif (config_prof && opt_prof) {\n\t\tcounter_prefork(tsdn, &prof_idump_accumulated);\n\t\tmalloc_mutex_prefork(tsdn, &prof_active_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &prof_dump_filename_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &prof_gdump_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &prof_recent_alloc_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &prof_stats_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &next_thr_uid_mtx);\n\t\tmalloc_mutex_prefork(tsdn, &prof_thread_active_init_mtx);\n\t}\n}\n\nvoid\nprof_postfork_parent(tsdn_t *tsdn) {\n\tif (config_prof && opt_prof) {\n\t\tunsigned i;\n\n\t\tmalloc_mutex_postfork_parent(tsdn,\n\t\t &prof_thread_active_init_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &next_thr_uid_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_stats_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_recent_alloc_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_gdump_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_dump_filename_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_active_mtx);\n\t\tcounter_postfork_parent(tsdn, &prof_idump_accumulated);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_recent_dump_mtx);\n\t\tfor (i = 0; i < PROF_NCTX_LOCKS; i++) {\n\t\t\tmalloc_mutex_postfork_parent(tsdn, &gctx_locks[i]);\n\t\t}\n\t\tmalloc_mutex_postfork_parent(tsdn, &log_mtx);\n\t\tfor (i = 0; i < PROF_NTDATA_LOCKS; i++) {\n\t\t\tmalloc_mutex_postfork_parent(tsdn, &tdata_locks[i]);\n\t\t}\n\t\tmalloc_mutex_postfork_parent(tsdn, &tdatas_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &bt2gctx_mtx);\n\t\tmalloc_mutex_postfork_parent(tsdn, &prof_dump_mtx);\n\t}\n}\n\nvoid\nprof_postfork_child(tsdn_t *tsdn) {\n\tif (config_prof && opt_prof) {\n\t\tunsigned i;\n\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_thread_active_init_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &next_thr_uid_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_stats_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_recent_alloc_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_gdump_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_dump_filename_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_active_mtx);\n\t\tcounter_postfork_child(tsdn, &prof_idump_accumulated);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_recent_dump_mtx);\n\t\tfor (i = 0; i < PROF_NCTX_LOCKS; i++) {\n\t\t\tmalloc_mutex_postfork_child(tsdn, &gctx_locks[i]);\n\t\t}\n\t\tmalloc_mutex_postfork_child(tsdn, &log_mtx);\n\t\tfor (i = 0; i < PROF_NTDATA_LOCKS; i++) {\n\t\t\tmalloc_mutex_postfork_child(tsdn, &tdata_locks[i]);\n\t\t}\n\t\tmalloc_mutex_postfork_child(tsdn, &tdatas_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &bt2gctx_mtx);\n\t\tmalloc_mutex_postfork_child(tsdn, &prof_dump_mtx);\n\t}\n}\n\n/******************************************************************************/\n" }, { "path": "deps/jemalloc/src/prof_data.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/ckh.h\"\n#include \"jemalloc/internal/hash.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/prof_data.h\"\n\n/*\n * This file defines and manages the core profiling data structures.\n *\n * Conceptually, profiling data can be imagined as a table with three columns:\n * thread, stack trace, and current allocation size. (When prof_accum is on,\n * there's one additional column which is the cumulative allocation size.)\n *\n * Implementation wise, each thread maintains a hash recording the stack trace\n * to allocation size correspondences, which are basically the individual rows\n * in the table. In addition, two global \"indices\" are built to make data\n * aggregation efficient (for dumping): bt2gctx and tdatas, which are basically\n * the \"grouped by stack trace\" and \"grouped by thread\" views of the same table,\n * respectively. Note that the allocation size is only aggregated to the two\n * indices at dumping time, so as to optimize for performance.\n */\n\n/******************************************************************************/\n\nmalloc_mutex_t bt2gctx_mtx;\nmalloc_mutex_t tdatas_mtx;\nmalloc_mutex_t prof_dump_mtx;\n\n/*\n * Table of mutexes that are shared among gctx's. These are leaf locks, so\n * there is no problem with using them for more than one gctx at the same time.\n * The primary motivation for this sharing though is that gctx's are ephemeral,\n * and destroying mutexes causes complications for systems that allocate when\n * creating/destroying mutexes.\n */\nmalloc_mutex_t *gctx_locks;\nstatic atomic_u_t cum_gctxs; /* Atomic counter. */\n\n/*\n * Table of mutexes that are shared among tdata's. No operations require\n * holding multiple tdata locks, so there is no problem with using them for more\n * than one tdata at the same time, even though a gctx lock may be acquired\n * while holding a tdata lock.\n */\nmalloc_mutex_t *tdata_locks;\n\n/*\n * Global hash of (prof_bt_t *)-->(prof_gctx_t *). This is the master data\n * structure that knows about all backtraces currently captured.\n */\nstatic ckh_t bt2gctx;\n\n/*\n * Tree of all extant prof_tdata_t structures, regardless of state,\n * {attached,detached,expired}.\n */\nstatic prof_tdata_tree_t tdatas;\n\nsize_t prof_unbiased_sz[PROF_SC_NSIZES];\nsize_t prof_shifted_unbiased_cnt[PROF_SC_NSIZES];\n\n/******************************************************************************/\n/* Red-black trees. */\n\nstatic int\nprof_tctx_comp(const prof_tctx_t *a, const prof_tctx_t *b) {\n\tuint64_t a_thr_uid = a->thr_uid;\n\tuint64_t b_thr_uid = b->thr_uid;\n\tint ret = (a_thr_uid > b_thr_uid) - (a_thr_uid < b_thr_uid);\n\tif (ret == 0) {\n\t\tuint64_t a_thr_discrim = a->thr_discrim;\n\t\tuint64_t b_thr_discrim = b->thr_discrim;\n\t\tret = (a_thr_discrim > b_thr_discrim) - (a_thr_discrim <\n\t\t b_thr_discrim);\n\t\tif (ret == 0) {\n\t\t\tuint64_t a_tctx_uid = a->tctx_uid;\n\t\t\tuint64_t b_tctx_uid = b->tctx_uid;\n\t\t\tret = (a_tctx_uid > b_tctx_uid) - (a_tctx_uid <\n\t\t\t b_tctx_uid);\n\t\t}\n\t}\n\treturn ret;\n}\n\nrb_gen(static UNUSED, tctx_tree_, prof_tctx_tree_t, prof_tctx_t,\n tctx_link, prof_tctx_comp)\n\nstatic int\nprof_gctx_comp(const prof_gctx_t *a, const prof_gctx_t *b) {\n\tunsigned a_len = a->bt.len;\n\tunsigned b_len = b->bt.len;\n\tunsigned comp_len = (a_len < b_len) ? a_len : b_len;\n\tint ret = memcmp(a->bt.vec, b->bt.vec, comp_len * sizeof(void *));\n\tif (ret == 0) {\n\t\tret = (a_len > b_len) - (a_len < b_len);\n\t}\n\treturn ret;\n}\n\nrb_gen(static UNUSED, gctx_tree_, prof_gctx_tree_t, prof_gctx_t, dump_link,\n prof_gctx_comp)\n\nstatic int\nprof_tdata_comp(const prof_tdata_t *a, const prof_tdata_t *b) {\n\tint ret;\n\tuint64_t a_uid = a->thr_uid;\n\tuint64_t b_uid = b->thr_uid;\n\n\tret = ((a_uid > b_uid) - (a_uid < b_uid));\n\tif (ret == 0) {\n\t\tuint64_t a_discrim = a->thr_discrim;\n\t\tuint64_t b_discrim = b->thr_discrim;\n\n\t\tret = ((a_discrim > b_discrim) - (a_discrim < b_discrim));\n\t}\n\treturn ret;\n}\n\nrb_gen(static UNUSED, tdata_tree_, prof_tdata_tree_t, prof_tdata_t, tdata_link,\n prof_tdata_comp)\n\n/******************************************************************************/\n\nstatic malloc_mutex_t *\nprof_gctx_mutex_choose(void) {\n\tunsigned ngctxs = atomic_fetch_add_u(&cum_gctxs, 1, ATOMIC_RELAXED);\n\n\treturn &gctx_locks[(ngctxs - 1) % PROF_NCTX_LOCKS];\n}\n\nstatic malloc_mutex_t *\nprof_tdata_mutex_choose(uint64_t thr_uid) {\n\treturn &tdata_locks[thr_uid % PROF_NTDATA_LOCKS];\n}\n\nbool\nprof_data_init(tsd_t *tsd) {\n\ttdata_tree_new(&tdatas);\n\treturn ckh_new(tsd, &bt2gctx, PROF_CKH_MINITEMS,\n\t prof_bt_hash, prof_bt_keycomp);\n}\n\nstatic void\nprof_enter(tsd_t *tsd, prof_tdata_t *tdata) {\n\tcassert(config_prof);\n\tassert(tdata == prof_tdata_get(tsd, false));\n\n\tif (tdata != NULL) {\n\t\tassert(!tdata->enq);\n\t\ttdata->enq = true;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &bt2gctx_mtx);\n}\n\nstatic void\nprof_leave(tsd_t *tsd, prof_tdata_t *tdata) {\n\tcassert(config_prof);\n\tassert(tdata == prof_tdata_get(tsd, false));\n\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bt2gctx_mtx);\n\n\tif (tdata != NULL) {\n\t\tbool idump, gdump;\n\n\t\tassert(tdata->enq);\n\t\ttdata->enq = false;\n\t\tidump = tdata->enq_idump;\n\t\ttdata->enq_idump = false;\n\t\tgdump = tdata->enq_gdump;\n\t\ttdata->enq_gdump = false;\n\n\t\tif (idump) {\n\t\t\tprof_idump(tsd_tsdn(tsd));\n\t\t}\n\t\tif (gdump) {\n\t\t\tprof_gdump(tsd_tsdn(tsd));\n\t\t}\n\t}\n}\n\nstatic prof_gctx_t *\nprof_gctx_create(tsdn_t *tsdn, prof_bt_t *bt) {\n\t/*\n\t * Create a single allocation that has space for vec of length bt->len.\n\t */\n\tsize_t size = offsetof(prof_gctx_t, vec) + (bt->len * sizeof(void *));\n\tprof_gctx_t *gctx = (prof_gctx_t *)iallocztm(tsdn, size,\n\t sz_size2index(size), false, NULL, true, arena_get(TSDN_NULL, 0, true),\n\t true);\n\tif (gctx == NULL) {\n\t\treturn NULL;\n\t}\n\tgctx->lock = prof_gctx_mutex_choose();\n\t/*\n\t * Set nlimbo to 1, in order to avoid a race condition with\n\t * prof_tctx_destroy()/prof_gctx_try_destroy().\n\t */\n\tgctx->nlimbo = 1;\n\ttctx_tree_new(&gctx->tctxs);\n\t/* Duplicate bt. */\n\tmemcpy(gctx->vec, bt->vec, bt->len * sizeof(void *));\n\tgctx->bt.vec = gctx->vec;\n\tgctx->bt.len = bt->len;\n\treturn gctx;\n}\n\nstatic void\nprof_gctx_try_destroy(tsd_t *tsd, prof_tdata_t *tdata_self,\n prof_gctx_t *gctx) {\n\tcassert(config_prof);\n\n\t/*\n\t * Check that gctx is still unused by any thread cache before destroying\n\t * it. prof_lookup() increments gctx->nlimbo in order to avoid a race\n\t * condition with this function, as does prof_tctx_destroy() in order to\n\t * avoid a race between the main body of prof_tctx_destroy() and entry\n\t * into this function.\n\t */\n\tprof_enter(tsd, tdata_self);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), gctx->lock);\n\tassert(gctx->nlimbo != 0);\n\tif (tctx_tree_empty(&gctx->tctxs) && gctx->nlimbo == 1) {\n\t\t/* Remove gctx from bt2gctx. */\n\t\tif (ckh_remove(tsd, &bt2gctx, &gctx->bt, NULL, NULL)) {\n\t\t\tnot_reached();\n\t\t}\n\t\tprof_leave(tsd, tdata_self);\n\t\t/* Destroy gctx. */\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\t\tidalloctm(tsd_tsdn(tsd), gctx, NULL, NULL, true, true);\n\t} else {\n\t\t/*\n\t\t * Compensate for increment in prof_tctx_destroy() or\n\t\t * prof_lookup().\n\t\t */\n\t\tgctx->nlimbo--;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\t\tprof_leave(tsd, tdata_self);\n\t}\n}\n\nstatic bool\nprof_gctx_should_destroy(prof_gctx_t *gctx) {\n\tif (opt_prof_accum) {\n\t\treturn false;\n\t}\n\tif (!tctx_tree_empty(&gctx->tctxs)) {\n\t\treturn false;\n\t}\n\tif (gctx->nlimbo != 0) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nstatic bool\nprof_lookup_global(tsd_t *tsd, prof_bt_t *bt, prof_tdata_t *tdata,\n void **p_btkey, prof_gctx_t **p_gctx, bool *p_new_gctx) {\n\tunion {\n\t\tprof_gctx_t\t*p;\n\t\tvoid\t\t*v;\n\t} gctx, tgctx;\n\tunion {\n\t\tprof_bt_t\t*p;\n\t\tvoid\t\t*v;\n\t} btkey;\n\tbool new_gctx;\n\n\tprof_enter(tsd, tdata);\n\tif (ckh_search(&bt2gctx, bt, &btkey.v, &gctx.v)) {\n\t\t/* bt has never been seen before. Insert it. */\n\t\tprof_leave(tsd, tdata);\n\t\ttgctx.p = prof_gctx_create(tsd_tsdn(tsd), bt);\n\t\tif (tgctx.v == NULL) {\n\t\t\treturn true;\n\t\t}\n\t\tprof_enter(tsd, tdata);\n\t\tif (ckh_search(&bt2gctx, bt, &btkey.v, &gctx.v)) {\n\t\t\tgctx.p = tgctx.p;\n\t\t\tbtkey.p = &gctx.p->bt;\n\t\t\tif (ckh_insert(tsd, &bt2gctx, btkey.v, gctx.v)) {\n\t\t\t\t/* OOM. */\n\t\t\t\tprof_leave(tsd, tdata);\n\t\t\t\tidalloctm(tsd_tsdn(tsd), gctx.v, NULL, NULL,\n\t\t\t\t true, true);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tnew_gctx = true;\n\t\t} else {\n\t\t\tnew_gctx = false;\n\t\t}\n\t} else {\n\t\ttgctx.v = NULL;\n\t\tnew_gctx = false;\n\t}\n\n\tif (!new_gctx) {\n\t\t/*\n\t\t * Increment nlimbo, in order to avoid a race condition with\n\t\t * prof_tctx_destroy()/prof_gctx_try_destroy().\n\t\t */\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), gctx.p->lock);\n\t\tgctx.p->nlimbo++;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx.p->lock);\n\t\tnew_gctx = false;\n\n\t\tif (tgctx.v != NULL) {\n\t\t\t/* Lost race to insert. */\n\t\t\tidalloctm(tsd_tsdn(tsd), tgctx.v, NULL, NULL, true,\n\t\t\t true);\n\t\t}\n\t}\n\tprof_leave(tsd, tdata);\n\n\t*p_btkey = btkey.v;\n\t*p_gctx = gctx.p;\n\t*p_new_gctx = new_gctx;\n\treturn false;\n}\n\nprof_tctx_t *\nprof_lookup(tsd_t *tsd, prof_bt_t *bt) {\n\tunion {\n\t\tprof_tctx_t\t*p;\n\t\tvoid\t\t*v;\n\t} ret;\n\tprof_tdata_t *tdata;\n\tbool not_found;\n\n\tcassert(config_prof);\n\n\ttdata = prof_tdata_get(tsd, false);\n\tassert(tdata != NULL);\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);\n\tnot_found = ckh_search(&tdata->bt2tctx, bt, NULL, &ret.v);\n\tif (!not_found) { /* Note double negative! */\n\t\tret.p->prepared = true;\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);\n\tif (not_found) {\n\t\tvoid *btkey;\n\t\tprof_gctx_t *gctx;\n\t\tbool new_gctx, error;\n\n\t\t/*\n\t\t * This thread's cache lacks bt. Look for it in the global\n\t\t * cache.\n\t\t */\n\t\tif (prof_lookup_global(tsd, bt, tdata, &btkey, &gctx,\n\t\t &new_gctx)) {\n\t\t\treturn NULL;\n\t\t}\n\n\t\t/* Link a prof_tctx_t into gctx for this thread. */\n\t\tret.v = iallocztm(tsd_tsdn(tsd), sizeof(prof_tctx_t),\n\t\t sz_size2index(sizeof(prof_tctx_t)), false, NULL, true,\n\t\t arena_ichoose(tsd, NULL), true);\n\t\tif (ret.p == NULL) {\n\t\t\tif (new_gctx) {\n\t\t\t\tprof_gctx_try_destroy(tsd, tdata, gctx);\n\t\t\t}\n\t\t\treturn NULL;\n\t\t}\n\t\tret.p->tdata = tdata;\n\t\tret.p->thr_uid = tdata->thr_uid;\n\t\tret.p->thr_discrim = tdata->thr_discrim;\n\t\tret.p->recent_count = 0;\n\t\tmemset(&ret.p->cnts, 0, sizeof(prof_cnt_t));\n\t\tret.p->gctx = gctx;\n\t\tret.p->tctx_uid = tdata->tctx_uid_next++;\n\t\tret.p->prepared = true;\n\t\tret.p->state = prof_tctx_state_initializing;\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);\n\t\terror = ckh_insert(tsd, &tdata->bt2tctx, btkey, ret.v);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);\n\t\tif (error) {\n\t\t\tif (new_gctx) {\n\t\t\t\tprof_gctx_try_destroy(tsd, tdata, gctx);\n\t\t\t}\n\t\t\tidalloctm(tsd_tsdn(tsd), ret.v, NULL, NULL, true, true);\n\t\t\treturn NULL;\n\t\t}\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), gctx->lock);\n\t\tret.p->state = prof_tctx_state_nominal;\n\t\ttctx_tree_insert(&gctx->tctxs, ret.p);\n\t\tgctx->nlimbo--;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\t}\n\n\treturn ret.p;\n}\n\n/* Used in unit tests. */\nstatic prof_tdata_t *\nprof_tdata_count_iter(prof_tdata_tree_t *tdatas_ptr, prof_tdata_t *tdata,\n void *arg) {\n\tsize_t *tdata_count = (size_t *)arg;\n\n\t(*tdata_count)++;\n\n\treturn NULL;\n}\n\n/* Used in unit tests. */\nsize_t\nprof_tdata_count(void) {\n\tsize_t tdata_count = 0;\n\ttsdn_t *tsdn;\n\n\ttsdn = tsdn_fetch();\n\tmalloc_mutex_lock(tsdn, &tdatas_mtx);\n\ttdata_tree_iter(&tdatas, NULL, prof_tdata_count_iter,\n\t (void *)&tdata_count);\n\tmalloc_mutex_unlock(tsdn, &tdatas_mtx);\n\n\treturn tdata_count;\n}\n\n/* Used in unit tests. */\nsize_t\nprof_bt_count(void) {\n\tsize_t bt_count;\n\ttsd_t *tsd;\n\tprof_tdata_t *tdata;\n\n\ttsd = tsd_fetch();\n\ttdata = prof_tdata_get(tsd, false);\n\tif (tdata == NULL) {\n\t\treturn 0;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &bt2gctx_mtx);\n\tbt_count = ckh_count(&bt2gctx);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &bt2gctx_mtx);\n\n\treturn bt_count;\n}\n\nchar *\nprof_thread_name_alloc(tsd_t *tsd, const char *thread_name) {\n\tchar *ret;\n\tsize_t size;\n\n\tif (thread_name == NULL) {\n\t\treturn NULL;\n\t}\n\n\tsize = strlen(thread_name) + 1;\n\tif (size == 1) {\n\t\treturn \"\";\n\t}\n\n\tret = iallocztm(tsd_tsdn(tsd), size, sz_size2index(size), false, NULL,\n\t true, arena_get(TSDN_NULL, 0, true), true);\n\tif (ret == NULL) {\n\t\treturn NULL;\n\t}\n\tmemcpy(ret, thread_name, size);\n\treturn ret;\n}\n\nint\nprof_thread_name_set_impl(tsd_t *tsd, const char *thread_name) {\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata;\n\tunsigned i;\n\tchar *s;\n\n\ttdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn EAGAIN;\n\t}\n\n\t/* Validate input. */\n\tif (thread_name == NULL) {\n\t\treturn EFAULT;\n\t}\n\tfor (i = 0; thread_name[i] != '\\0'; i++) {\n\t\tchar c = thread_name[i];\n\t\tif (!isgraph(c) && !isblank(c)) {\n\t\t\treturn EFAULT;\n\t\t}\n\t}\n\n\ts = prof_thread_name_alloc(tsd, thread_name);\n\tif (s == NULL) {\n\t\treturn EAGAIN;\n\t}\n\n\tif (tdata->thread_name != NULL) {\n\t\tidalloctm(tsd_tsdn(tsd), tdata->thread_name, NULL, NULL, true,\n\t\t true);\n\t\ttdata->thread_name = NULL;\n\t}\n\tif (strlen(s) > 0) {\n\t\ttdata->thread_name = s;\n\t}\n\treturn 0;\n}\n\nJEMALLOC_FORMAT_PRINTF(3, 4)\nstatic void\nprof_dump_printf(write_cb_t *prof_dump_write, void *cbopaque,\n const char *format, ...) {\n\tva_list ap;\n\tchar buf[PROF_PRINTF_BUFSIZE];\n\n\tva_start(ap, format);\n\tmalloc_vsnprintf(buf, sizeof(buf), format, ap);\n\tva_end(ap);\n\tprof_dump_write(cbopaque, buf);\n}\n\n/*\n * Casting a double to a uint64_t may not necessarily be in range; this can be\n * UB. I don't think this is practically possible with the cur counters, but\n * plausibly could be with the accum counters.\n */\n#ifdef JEMALLOC_PROF\nstatic uint64_t\nprof_double_uint64_cast(double d) {\n\t/*\n\t * Note: UINT64_MAX + 1 is exactly representable as a double on all\n\t * reasonable platforms (certainly those we'll support). Writing this\n\t * as !(a < b) instead of (a >= b) means that we're NaN-safe.\n\t */\n\tdouble rounded = round(d);\n\tif (!(rounded < (double)UINT64_MAX)) {\n\t\treturn UINT64_MAX;\n\t}\n\treturn (uint64_t)rounded;\n}\n#endif\n\nvoid prof_unbias_map_init() {\n\t/* See the comment in prof_sample_new_event_wait */\n#ifdef JEMALLOC_PROF\n\tfor (szind_t i = 0; i < SC_NSIZES; i++) {\n\t\tdouble sz = (double)sz_index2size(i);\n\t\tdouble rate = (double)(ZU(1) << lg_prof_sample);\n\t\tdouble div_val = 1.0 - exp(-sz / rate);\n\t\tdouble unbiased_sz = sz / div_val;\n\t\t/*\n\t\t * The \"true\" right value for the unbiased count is\n\t\t * 1.0/(1 - exp(-sz/rate)). The problem is, we keep the counts\n\t\t * as integers (for a variety of reasons -- rounding errors\n\t\t * could trigger asserts, and not all libcs can properly handle\n\t\t * floating point arithmetic during malloc calls inside libc).\n\t\t * Rounding to an integer, though, can lead to rounding errors\n\t\t * of over 30% for sizes close to the sampling rate. So\n\t\t * instead, we multiply by a constant, dividing the maximum\n\t\t * possible roundoff error by that constant. To avoid overflow\n\t\t * in summing up size_t values, the largest safe constant we can\n\t\t * pick is the size of the smallest allocation.\n\t\t */\n\t\tdouble cnt_shift = (double)(ZU(1) << SC_LG_TINY_MIN);\n\t\tdouble shifted_unbiased_cnt = cnt_shift / div_val;\n\t\tprof_unbiased_sz[i] = (size_t)round(unbiased_sz);\n\t\tprof_shifted_unbiased_cnt[i] = (size_t)round(\n\t\t shifted_unbiased_cnt);\n\t}\n#else\n\tunreachable();\n#endif\n}\n\n/*\n * The unbiasing story is long. The jeprof unbiasing logic was copied from\n * pprof. Both shared an issue: they unbiased using the average size of the\n * allocations at a particular stack trace. This can work out OK if allocations\n * are mostly of the same size given some stack, but not otherwise. We now\n * internally track what the unbiased results ought to be. We can't just report\n * them as they are though; they'll still go through the jeprof unbiasing\n * process. Instead, we figure out what values we can feed *into* jeprof's\n * unbiasing mechanism that will lead to getting the right values out.\n *\n * It'll unbias count and aggregate size as:\n *\n * c_out = c_in * 1/(1-exp(-s_in/c_in/R)\n * s_out = s_in * 1/(1-exp(-s_in/c_in/R)\n *\n * We want to solve for the values of c_in and s_in that will\n * give the c_out and s_out that we've computed internally.\n *\n * Let's do a change of variables (both to make the math easier and to make it\n * easier to write):\n * x = s_in / c_in\n * y = s_in\n * k = 1/R.\n *\n * Then\n * c_out = y/x * 1/(1-exp(-k*x))\n * s_out = y * 1/(1-exp(-k*x))\n *\n * The first equation gives:\n * y = x * c_out * (1-exp(-k*x))\n * The second gives:\n * y = s_out * (1-exp(-k*x))\n * So we have\n * x = s_out / c_out.\n * And all the other values fall out from that.\n *\n * This is all a fair bit of work. The thing we get out of it is that we don't\n * break backwards compatibility with jeprof (and the various tools that have\n * copied its unbiasing logic). Eventually, we anticipate a v3 heap profile\n * dump format based on JSON, at which point I think much of this logic can get\n * cleaned up (since we'll be taking a compatibility break there anyways).\n */\nstatic void\nprof_do_unbias(uint64_t c_out_shifted_i, uint64_t s_out_i, uint64_t *r_c_in,\n uint64_t *r_s_in) {\n#ifdef JEMALLOC_PROF\n\tif (c_out_shifted_i == 0 || s_out_i == 0) {\n\t\t*r_c_in = 0;\n\t\t*r_s_in = 0;\n\t\treturn;\n\t}\n\t/*\n\t * See the note in prof_unbias_map_init() to see why we take c_out in a\n\t * shifted form.\n\t */\n\tdouble c_out = (double)c_out_shifted_i\n\t / (double)(ZU(1) << SC_LG_TINY_MIN);\n\tdouble s_out = (double)s_out_i;\n\tdouble R = (double)(ZU(1) << lg_prof_sample);\n\n\tdouble x = s_out / c_out;\n\tdouble y = s_out * (1.0 - exp(-x / R));\n\n\tdouble c_in = y / x;\n\tdouble s_in = y;\n\n\t*r_c_in = prof_double_uint64_cast(c_in);\n\t*r_s_in = prof_double_uint64_cast(s_in);\n#else\n\tunreachable();\n#endif\n}\n\nstatic void\nprof_dump_print_cnts(write_cb_t *prof_dump_write, void *cbopaque,\n const prof_cnt_t *cnts) {\n\tuint64_t curobjs;\n\tuint64_t curbytes;\n\tuint64_t accumobjs;\n\tuint64_t accumbytes;\n\tif (opt_prof_unbias) {\n\t\tprof_do_unbias(cnts->curobjs_shifted_unbiased,\n\t\t cnts->curbytes_unbiased, &curobjs, &curbytes);\n\t\tprof_do_unbias(cnts->accumobjs_shifted_unbiased,\n\t\t cnts->accumbytes_unbiased, &accumobjs, &accumbytes);\n\t} else {\n\t\tcurobjs = cnts->curobjs;\n\t\tcurbytes = cnts->curbytes;\n\t\taccumobjs = cnts->accumobjs;\n\t\taccumbytes = cnts->accumbytes;\n\t}\n\tprof_dump_printf(prof_dump_write, cbopaque,\n\t \"%\"FMTu64\": %\"FMTu64\" [%\"FMTu64\": %\"FMTu64\"]\",\n\t curobjs, curbytes, accumobjs, accumbytes);\n}\n\nstatic void\nprof_tctx_merge_tdata(tsdn_t *tsdn, prof_tctx_t *tctx, prof_tdata_t *tdata) {\n\tmalloc_mutex_assert_owner(tsdn, tctx->tdata->lock);\n\n\tmalloc_mutex_lock(tsdn, tctx->gctx->lock);\n\n\tswitch (tctx->state) {\n\tcase prof_tctx_state_initializing:\n\t\tmalloc_mutex_unlock(tsdn, tctx->gctx->lock);\n\t\treturn;\n\tcase prof_tctx_state_nominal:\n\t\ttctx->state = prof_tctx_state_dumping;\n\t\tmalloc_mutex_unlock(tsdn, tctx->gctx->lock);\n\n\t\tmemcpy(&tctx->dump_cnts, &tctx->cnts, sizeof(prof_cnt_t));\n\n\t\ttdata->cnt_summed.curobjs += tctx->dump_cnts.curobjs;\n\t\ttdata->cnt_summed.curobjs_shifted_unbiased\n\t\t += tctx->dump_cnts.curobjs_shifted_unbiased;\n\t\ttdata->cnt_summed.curbytes += tctx->dump_cnts.curbytes;\n\t\ttdata->cnt_summed.curbytes_unbiased\n\t\t += tctx->dump_cnts.curbytes_unbiased;\n\t\tif (opt_prof_accum) {\n\t\t\ttdata->cnt_summed.accumobjs +=\n\t\t\t tctx->dump_cnts.accumobjs;\n\t\t\ttdata->cnt_summed.accumobjs_shifted_unbiased +=\n\t\t\t tctx->dump_cnts.accumobjs_shifted_unbiased;\n\t\t\ttdata->cnt_summed.accumbytes +=\n\t\t\t tctx->dump_cnts.accumbytes;\n\t\t\ttdata->cnt_summed.accumbytes_unbiased +=\n\t\t\t tctx->dump_cnts.accumbytes_unbiased;\n\t\t}\n\t\tbreak;\n\tcase prof_tctx_state_dumping:\n\tcase prof_tctx_state_purgatory:\n\t\tnot_reached();\n\t}\n}\n\nstatic void\nprof_tctx_merge_gctx(tsdn_t *tsdn, prof_tctx_t *tctx, prof_gctx_t *gctx) {\n\tmalloc_mutex_assert_owner(tsdn, gctx->lock);\n\n\tgctx->cnt_summed.curobjs += tctx->dump_cnts.curobjs;\n\tgctx->cnt_summed.curobjs_shifted_unbiased\n\t += tctx->dump_cnts.curobjs_shifted_unbiased;\n\tgctx->cnt_summed.curbytes += tctx->dump_cnts.curbytes;\n\tgctx->cnt_summed.curbytes_unbiased += tctx->dump_cnts.curbytes_unbiased;\n\tif (opt_prof_accum) {\n\t\tgctx->cnt_summed.accumobjs += tctx->dump_cnts.accumobjs;\n\t\tgctx->cnt_summed.accumobjs_shifted_unbiased\n\t\t += tctx->dump_cnts.accumobjs_shifted_unbiased;\n\t\tgctx->cnt_summed.accumbytes += tctx->dump_cnts.accumbytes;\n\t\tgctx->cnt_summed.accumbytes_unbiased\n\t\t += tctx->dump_cnts.accumbytes_unbiased;\n\t}\n}\n\nstatic prof_tctx_t *\nprof_tctx_merge_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg) {\n\ttsdn_t *tsdn = (tsdn_t *)arg;\n\n\tmalloc_mutex_assert_owner(tsdn, tctx->gctx->lock);\n\n\tswitch (tctx->state) {\n\tcase prof_tctx_state_nominal:\n\t\t/* New since dumping started; ignore. */\n\t\tbreak;\n\tcase prof_tctx_state_dumping:\n\tcase prof_tctx_state_purgatory:\n\t\tprof_tctx_merge_gctx(tsdn, tctx, tctx->gctx);\n\t\tbreak;\n\tdefault:\n\t\tnot_reached();\n\t}\n\n\treturn NULL;\n}\n\ntypedef struct prof_dump_iter_arg_s prof_dump_iter_arg_t;\nstruct prof_dump_iter_arg_s {\n\ttsdn_t *tsdn;\n\twrite_cb_t *prof_dump_write;\n\tvoid *cbopaque;\n};\n\nstatic prof_tctx_t *\nprof_tctx_dump_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *opaque) {\n\tprof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;\n\tmalloc_mutex_assert_owner(arg->tsdn, tctx->gctx->lock);\n\n\tswitch (tctx->state) {\n\tcase prof_tctx_state_initializing:\n\tcase prof_tctx_state_nominal:\n\t\t/* Not captured by this dump. */\n\t\tbreak;\n\tcase prof_tctx_state_dumping:\n\tcase prof_tctx_state_purgatory:\n\t\tprof_dump_printf(arg->prof_dump_write, arg->cbopaque,\n\t\t \" t%\"FMTu64\": \", tctx->thr_uid);\n\t\tprof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque,\n\t\t &tctx->dump_cnts);\n\t\targ->prof_dump_write(arg->cbopaque, \"\\n\");\n\t\tbreak;\n\tdefault:\n\t\tnot_reached();\n\t}\n\treturn NULL;\n}\n\nstatic prof_tctx_t *\nprof_tctx_finish_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg) {\n\ttsdn_t *tsdn = (tsdn_t *)arg;\n\tprof_tctx_t *ret;\n\n\tmalloc_mutex_assert_owner(tsdn, tctx->gctx->lock);\n\n\tswitch (tctx->state) {\n\tcase prof_tctx_state_nominal:\n\t\t/* New since dumping started; ignore. */\n\t\tbreak;\n\tcase prof_tctx_state_dumping:\n\t\ttctx->state = prof_tctx_state_nominal;\n\t\tbreak;\n\tcase prof_tctx_state_purgatory:\n\t\tret = tctx;\n\t\tgoto label_return;\n\tdefault:\n\t\tnot_reached();\n\t}\n\n\tret = NULL;\nlabel_return:\n\treturn ret;\n}\n\nstatic void\nprof_dump_gctx_prep(tsdn_t *tsdn, prof_gctx_t *gctx, prof_gctx_tree_t *gctxs) {\n\tcassert(config_prof);\n\n\tmalloc_mutex_lock(tsdn, gctx->lock);\n\n\t/*\n\t * Increment nlimbo so that gctx won't go away before dump.\n\t * Additionally, link gctx into the dump list so that it is included in\n\t * prof_dump()'s second pass.\n\t */\n\tgctx->nlimbo++;\n\tgctx_tree_insert(gctxs, gctx);\n\n\tmemset(&gctx->cnt_summed, 0, sizeof(prof_cnt_t));\n\n\tmalloc_mutex_unlock(tsdn, gctx->lock);\n}\n\ntypedef struct prof_gctx_merge_iter_arg_s prof_gctx_merge_iter_arg_t;\nstruct prof_gctx_merge_iter_arg_s {\n\ttsdn_t *tsdn;\n\tsize_t *leak_ngctx;\n};\n\nstatic prof_gctx_t *\nprof_gctx_merge_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque) {\n\tprof_gctx_merge_iter_arg_t *arg = (prof_gctx_merge_iter_arg_t *)opaque;\n\n\tmalloc_mutex_lock(arg->tsdn, gctx->lock);\n\ttctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter,\n\t (void *)arg->tsdn);\n\tif (gctx->cnt_summed.curobjs != 0) {\n\t\t(*arg->leak_ngctx)++;\n\t}\n\tmalloc_mutex_unlock(arg->tsdn, gctx->lock);\n\n\treturn NULL;\n}\n\nstatic void\nprof_gctx_finish(tsd_t *tsd, prof_gctx_tree_t *gctxs) {\n\tprof_tdata_t *tdata = prof_tdata_get(tsd, false);\n\tprof_gctx_t *gctx;\n\n\t/*\n\t * Standard tree iteration won't work here, because as soon as we\n\t * decrement gctx->nlimbo and unlock gctx, another thread can\n\t * concurrently destroy it, which will corrupt the tree. Therefore,\n\t * tear down the tree one node at a time during iteration.\n\t */\n\twhile ((gctx = gctx_tree_first(gctxs)) != NULL) {\n\t\tgctx_tree_remove(gctxs, gctx);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), gctx->lock);\n\t\t{\n\t\t\tprof_tctx_t *next;\n\n\t\t\tnext = NULL;\n\t\t\tdo {\n\t\t\t\tprof_tctx_t *to_destroy =\n\t\t\t\t tctx_tree_iter(&gctx->tctxs, next,\n\t\t\t\t prof_tctx_finish_iter,\n\t\t\t\t (void *)tsd_tsdn(tsd));\n\t\t\t\tif (to_destroy != NULL) {\n\t\t\t\t\tnext = tctx_tree_next(&gctx->tctxs,\n\t\t\t\t\t to_destroy);\n\t\t\t\t\ttctx_tree_remove(&gctx->tctxs,\n\t\t\t\t\t to_destroy);\n\t\t\t\t\tidalloctm(tsd_tsdn(tsd), to_destroy,\n\t\t\t\t\t NULL, NULL, true, true);\n\t\t\t\t} else {\n\t\t\t\t\tnext = NULL;\n\t\t\t\t}\n\t\t\t} while (next != NULL);\n\t\t}\n\t\tgctx->nlimbo--;\n\t\tif (prof_gctx_should_destroy(gctx)) {\n\t\t\tgctx->nlimbo++;\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\t\t\tprof_gctx_try_destroy(tsd, tdata, gctx);\n\t\t} else {\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\t\t}\n\t}\n}\n\ntypedef struct prof_tdata_merge_iter_arg_s prof_tdata_merge_iter_arg_t;\nstruct prof_tdata_merge_iter_arg_s {\n\ttsdn_t *tsdn;\n\tprof_cnt_t *cnt_all;\n};\n\nstatic prof_tdata_t *\nprof_tdata_merge_iter(prof_tdata_tree_t *tdatas_ptr, prof_tdata_t *tdata,\n void *opaque) {\n\tprof_tdata_merge_iter_arg_t *arg =\n\t (prof_tdata_merge_iter_arg_t *)opaque;\n\n\tmalloc_mutex_lock(arg->tsdn, tdata->lock);\n\tif (!tdata->expired) {\n\t\tsize_t tabind;\n\t\tunion {\n\t\t\tprof_tctx_t\t*p;\n\t\t\tvoid\t\t*v;\n\t\t} tctx;\n\n\t\ttdata->dumping = true;\n\t\tmemset(&tdata->cnt_summed, 0, sizeof(prof_cnt_t));\n\t\tfor (tabind = 0; !ckh_iter(&tdata->bt2tctx, &tabind, NULL,\n\t\t &tctx.v);) {\n\t\t\tprof_tctx_merge_tdata(arg->tsdn, tctx.p, tdata);\n\t\t}\n\n\t\targ->cnt_all->curobjs += tdata->cnt_summed.curobjs;\n\t\targ->cnt_all->curobjs_shifted_unbiased\n\t\t += tdata->cnt_summed.curobjs_shifted_unbiased;\n\t\targ->cnt_all->curbytes += tdata->cnt_summed.curbytes;\n\t\targ->cnt_all->curbytes_unbiased\n\t\t += tdata->cnt_summed.curbytes_unbiased;\n\t\tif (opt_prof_accum) {\n\t\t\targ->cnt_all->accumobjs += tdata->cnt_summed.accumobjs;\n\t\t\targ->cnt_all->accumobjs_shifted_unbiased\n\t\t\t += tdata->cnt_summed.accumobjs_shifted_unbiased;\n\t\t\targ->cnt_all->accumbytes +=\n\t\t\t tdata->cnt_summed.accumbytes;\n\t\t\targ->cnt_all->accumbytes_unbiased +=\n\t\t\t tdata->cnt_summed.accumbytes_unbiased;\n\t\t}\n\t} else {\n\t\ttdata->dumping = false;\n\t}\n\tmalloc_mutex_unlock(arg->tsdn, tdata->lock);\n\n\treturn NULL;\n}\n\nstatic prof_tdata_t *\nprof_tdata_dump_iter(prof_tdata_tree_t *tdatas_ptr, prof_tdata_t *tdata,\n void *opaque) {\n\tif (!tdata->dumping) {\n\t\treturn NULL;\n\t}\n\n\tprof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;\n\tprof_dump_printf(arg->prof_dump_write, arg->cbopaque, \" t%\"FMTu64\": \",\n\t tdata->thr_uid);\n\tprof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque,\n\t &tdata->cnt_summed);\n\tif (tdata->thread_name != NULL) {\n\t\targ->prof_dump_write(arg->cbopaque, \" \");\n\t\targ->prof_dump_write(arg->cbopaque, tdata->thread_name);\n\t}\n\targ->prof_dump_write(arg->cbopaque, \"\\n\");\n\treturn NULL;\n}\n\nstatic void\nprof_dump_header(prof_dump_iter_arg_t *arg, const prof_cnt_t *cnt_all) {\n\tprof_dump_printf(arg->prof_dump_write, arg->cbopaque,\n\t \"heap_v2/%\"FMTu64\"\\n t*: \", ((uint64_t)1U << lg_prof_sample));\n\tprof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque, cnt_all);\n\targ->prof_dump_write(arg->cbopaque, \"\\n\");\n\n\tmalloc_mutex_lock(arg->tsdn, &tdatas_mtx);\n\ttdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter, arg);\n\tmalloc_mutex_unlock(arg->tsdn, &tdatas_mtx);\n}\n\nstatic void\nprof_dump_gctx(prof_dump_iter_arg_t *arg, prof_gctx_t *gctx,\n const prof_bt_t *bt, prof_gctx_tree_t *gctxs) {\n\tcassert(config_prof);\n\tmalloc_mutex_assert_owner(arg->tsdn, gctx->lock);\n\n\t/* Avoid dumping such gctx's that have no useful data. */\n\tif ((!opt_prof_accum && gctx->cnt_summed.curobjs == 0) ||\n\t (opt_prof_accum && gctx->cnt_summed.accumobjs == 0)) {\n\t\tassert(gctx->cnt_summed.curobjs == 0);\n\t\tassert(gctx->cnt_summed.curbytes == 0);\n\t\t/*\n\t\t * These asserts would not be correct -- see the comment on races\n\t\t * in prof.c\n\t\t * assert(gctx->cnt_summed.curobjs_unbiased == 0);\n\t\t * assert(gctx->cnt_summed.curbytes_unbiased == 0);\n\t\t*/\n\t\tassert(gctx->cnt_summed.accumobjs == 0);\n\t\tassert(gctx->cnt_summed.accumobjs_shifted_unbiased == 0);\n\t\tassert(gctx->cnt_summed.accumbytes == 0);\n\t\tassert(gctx->cnt_summed.accumbytes_unbiased == 0);\n\t\treturn;\n\t}\n\n\targ->prof_dump_write(arg->cbopaque, \"@\");\n\tfor (unsigned i = 0; i < bt->len; i++) {\n\t\tprof_dump_printf(arg->prof_dump_write, arg->cbopaque,\n\t\t \" %#\"FMTxPTR, (uintptr_t)bt->vec[i]);\n\t}\n\n\targ->prof_dump_write(arg->cbopaque, \"\\n t*: \");\n\tprof_dump_print_cnts(arg->prof_dump_write, arg->cbopaque,\n\t &gctx->cnt_summed);\n\targ->prof_dump_write(arg->cbopaque, \"\\n\");\n\n\ttctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_dump_iter, arg);\n}\n\n/*\n * See prof_sample_new_event_wait() comment for why the body of this function\n * is conditionally compiled.\n */\nstatic void\nprof_leakcheck(const prof_cnt_t *cnt_all, size_t leak_ngctx) {\n#ifdef JEMALLOC_PROF\n\t/*\n\t * Scaling is equivalent AdjustSamples() in jeprof, but the result may\n\t * differ slightly from what jeprof reports, because here we scale the\n\t * summary values, whereas jeprof scales each context individually and\n\t * reports the sums of the scaled values.\n\t */\n\tif (cnt_all->curbytes != 0) {\n\t\tdouble sample_period = (double)((uint64_t)1 << lg_prof_sample);\n\t\tdouble ratio = (((double)cnt_all->curbytes) /\n\t\t (double)cnt_all->curobjs) / sample_period;\n\t\tdouble scale_factor = 1.0 / (1.0 - exp(-ratio));\n\t\tuint64_t curbytes = (uint64_t)round(((double)cnt_all->curbytes)\n\t\t * scale_factor);\n\t\tuint64_t curobjs = (uint64_t)round(((double)cnt_all->curobjs) *\n\t\t scale_factor);\n\n\t\tmalloc_printf(\": Leak approximation summary: ~%\"FMTu64\n\t\t \" byte%s, ~%\"FMTu64\" object%s, >= %zu context%s\\n\",\n\t\t curbytes, (curbytes != 1) ? \"s\" : \"\", curobjs, (curobjs !=\n\t\t 1) ? \"s\" : \"\", leak_ngctx, (leak_ngctx != 1) ? \"s\" : \"\");\n\t\tmalloc_printf(\n\t\t \": Run jeprof on dump output for leak detail\\n\");\n\t\tif (opt_prof_leak_error) {\n\t\t\tmalloc_printf(\n\t\t\t \": Exiting with error code because memory\"\n\t\t\t \" leaks were detected\\n\");\n\t\t\t/*\n\t\t\t * Use _exit() with underscore to avoid calling atexit()\n\t\t\t * and entering endless cycle.\n\t\t\t */\n\t\t\t_exit(1);\n\t\t}\n\t}\n#endif\n}\n\nstatic prof_gctx_t *\nprof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque) {\n\tprof_dump_iter_arg_t *arg = (prof_dump_iter_arg_t *)opaque;\n\tmalloc_mutex_lock(arg->tsdn, gctx->lock);\n\tprof_dump_gctx(arg, gctx, &gctx->bt, gctxs);\n\tmalloc_mutex_unlock(arg->tsdn, gctx->lock);\n\treturn NULL;\n}\n\nstatic void\nprof_dump_prep(tsd_t *tsd, prof_tdata_t *tdata, prof_cnt_t *cnt_all,\n size_t *leak_ngctx, prof_gctx_tree_t *gctxs) {\n\tsize_t tabind;\n\tunion {\n\t\tprof_gctx_t\t*p;\n\t\tvoid\t\t*v;\n\t} gctx;\n\n\tprof_enter(tsd, tdata);\n\n\t/*\n\t * Put gctx's in limbo and clear their counters in preparation for\n\t * summing.\n\t */\n\tgctx_tree_new(gctxs);\n\tfor (tabind = 0; !ckh_iter(&bt2gctx, &tabind, NULL, &gctx.v);) {\n\t\tprof_dump_gctx_prep(tsd_tsdn(tsd), gctx.p, gctxs);\n\t}\n\n\t/*\n\t * Iterate over tdatas, and for the non-expired ones snapshot their tctx\n\t * stats and merge them into the associated gctx's.\n\t */\n\tmemset(cnt_all, 0, sizeof(prof_cnt_t));\n\tprof_tdata_merge_iter_arg_t prof_tdata_merge_iter_arg = {tsd_tsdn(tsd),\n\t cnt_all};\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);\n\ttdata_tree_iter(&tdatas, NULL, prof_tdata_merge_iter,\n\t &prof_tdata_merge_iter_arg);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);\n\n\t/* Merge tctx stats into gctx's. */\n\t*leak_ngctx = 0;\n\tprof_gctx_merge_iter_arg_t prof_gctx_merge_iter_arg = {tsd_tsdn(tsd),\n\t leak_ngctx};\n\tgctx_tree_iter(gctxs, NULL, prof_gctx_merge_iter,\n\t &prof_gctx_merge_iter_arg);\n\n\tprof_leave(tsd, tdata);\n}\n\nvoid\nprof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,\n prof_tdata_t *tdata, bool leakcheck) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_dump_mtx);\n\tprof_cnt_t cnt_all;\n\tsize_t leak_ngctx;\n\tprof_gctx_tree_t gctxs;\n\tprof_dump_prep(tsd, tdata, &cnt_all, &leak_ngctx, &gctxs);\n\tprof_dump_iter_arg_t prof_dump_iter_arg = {tsd_tsdn(tsd),\n\t prof_dump_write, cbopaque};\n\tprof_dump_header(&prof_dump_iter_arg, &cnt_all);\n\tgctx_tree_iter(&gctxs, NULL, prof_gctx_dump_iter, &prof_dump_iter_arg);\n\tprof_gctx_finish(tsd, &gctxs);\n\tif (leakcheck) {\n\t\tprof_leakcheck(&cnt_all, leak_ngctx);\n\t}\n}\n\n/* Used in unit tests. */\nvoid\nprof_cnt_all(prof_cnt_t *cnt_all) {\n\ttsd_t *tsd = tsd_fetch();\n\tprof_tdata_t *tdata = prof_tdata_get(tsd, false);\n\tif (tdata == NULL) {\n\t\tmemset(cnt_all, 0, sizeof(prof_cnt_t));\n\t} else {\n\t\tsize_t leak_ngctx;\n\t\tprof_gctx_tree_t gctxs;\n\t\tprof_dump_prep(tsd, tdata, cnt_all, &leak_ngctx, &gctxs);\n\t\tprof_gctx_finish(tsd, &gctxs);\n\t}\n}\n\nvoid\nprof_bt_hash(const void *key, size_t r_hash[2]) {\n\tprof_bt_t *bt = (prof_bt_t *)key;\n\n\tcassert(config_prof);\n\n\thash(bt->vec, bt->len * sizeof(void *), 0x94122f33U, r_hash);\n}\n\nbool\nprof_bt_keycomp(const void *k1, const void *k2) {\n\tconst prof_bt_t *bt1 = (prof_bt_t *)k1;\n\tconst prof_bt_t *bt2 = (prof_bt_t *)k2;\n\n\tcassert(config_prof);\n\n\tif (bt1->len != bt2->len) {\n\t\treturn false;\n\t}\n\treturn (memcmp(bt1->vec, bt2->vec, bt1->len * sizeof(void *)) == 0);\n}\n\nprof_tdata_t *\nprof_tdata_init_impl(tsd_t *tsd, uint64_t thr_uid, uint64_t thr_discrim,\n char *thread_name, bool active) {\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t *tdata;\n\n\tcassert(config_prof);\n\n\t/* Initialize an empty cache for this thread. */\n\ttdata = (prof_tdata_t *)iallocztm(tsd_tsdn(tsd), sizeof(prof_tdata_t),\n\t sz_size2index(sizeof(prof_tdata_t)), false, NULL, true,\n\t arena_get(TSDN_NULL, 0, true), true);\n\tif (tdata == NULL) {\n\t\treturn NULL;\n\t}\n\n\ttdata->lock = prof_tdata_mutex_choose(thr_uid);\n\ttdata->thr_uid = thr_uid;\n\ttdata->thr_discrim = thr_discrim;\n\ttdata->thread_name = thread_name;\n\ttdata->attached = true;\n\ttdata->expired = false;\n\ttdata->tctx_uid_next = 0;\n\n\tif (ckh_new(tsd, &tdata->bt2tctx, PROF_CKH_MINITEMS, prof_bt_hash,\n\t prof_bt_keycomp)) {\n\t\tidalloctm(tsd_tsdn(tsd), tdata, NULL, NULL, true, true);\n\t\treturn NULL;\n\t}\n\n\ttdata->enq = false;\n\ttdata->enq_idump = false;\n\ttdata->enq_gdump = false;\n\n\ttdata->dumping = false;\n\ttdata->active = active;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);\n\ttdata_tree_insert(&tdatas, tdata);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);\n\n\treturn tdata;\n}\n\nstatic bool\nprof_tdata_should_destroy_unlocked(prof_tdata_t *tdata, bool even_if_attached) {\n\tif (tdata->attached && !even_if_attached) {\n\t\treturn false;\n\t}\n\tif (ckh_count(&tdata->bt2tctx) != 0) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nstatic bool\nprof_tdata_should_destroy(tsdn_t *tsdn, prof_tdata_t *tdata,\n bool even_if_attached) {\n\tmalloc_mutex_assert_owner(tsdn, tdata->lock);\n\n\treturn prof_tdata_should_destroy_unlocked(tdata, even_if_attached);\n}\n\nstatic void\nprof_tdata_destroy_locked(tsd_t *tsd, prof_tdata_t *tdata,\n bool even_if_attached) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &tdatas_mtx);\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), tdata->lock);\n\n\ttdata_tree_remove(&tdatas, tdata);\n\n\tassert(prof_tdata_should_destroy_unlocked(tdata, even_if_attached));\n\n\tif (tdata->thread_name != NULL) {\n\t\tidalloctm(tsd_tsdn(tsd), tdata->thread_name, NULL, NULL, true,\n\t\t true);\n\t}\n\tckh_delete(tsd, &tdata->bt2tctx);\n\tidalloctm(tsd_tsdn(tsd), tdata, NULL, NULL, true, true);\n}\n\nstatic void\nprof_tdata_destroy(tsd_t *tsd, prof_tdata_t *tdata, bool even_if_attached) {\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);\n\tprof_tdata_destroy_locked(tsd, tdata, even_if_attached);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);\n}\n\nvoid\nprof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata) {\n\tbool destroy_tdata;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);\n\tif (tdata->attached) {\n\t\tdestroy_tdata = prof_tdata_should_destroy(tsd_tsdn(tsd), tdata,\n\t\t true);\n\t\t/*\n\t\t * Only detach if !destroy_tdata, because detaching would allow\n\t\t * another thread to win the race to destroy tdata.\n\t\t */\n\t\tif (!destroy_tdata) {\n\t\t\ttdata->attached = false;\n\t\t}\n\t\ttsd_prof_tdata_set(tsd, NULL);\n\t} else {\n\t\tdestroy_tdata = false;\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);\n\tif (destroy_tdata) {\n\t\tprof_tdata_destroy(tsd, tdata, true);\n\t}\n}\n\nstatic bool\nprof_tdata_expire(tsdn_t *tsdn, prof_tdata_t *tdata) {\n\tbool destroy_tdata;\n\n\tmalloc_mutex_lock(tsdn, tdata->lock);\n\tif (!tdata->expired) {\n\t\ttdata->expired = true;\n\t\tdestroy_tdata = prof_tdata_should_destroy(tsdn, tdata, false);\n\t} else {\n\t\tdestroy_tdata = false;\n\t}\n\tmalloc_mutex_unlock(tsdn, tdata->lock);\n\n\treturn destroy_tdata;\n}\n\nstatic prof_tdata_t *\nprof_tdata_reset_iter(prof_tdata_tree_t *tdatas_ptr, prof_tdata_t *tdata,\n void *arg) {\n\ttsdn_t *tsdn = (tsdn_t *)arg;\n\n\treturn (prof_tdata_expire(tsdn, tdata) ? tdata : NULL);\n}\n\nvoid\nprof_reset(tsd_t *tsd, size_t lg_sample) {\n\tprof_tdata_t *next;\n\n\tassert(lg_sample < (sizeof(uint64_t) << 3));\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_mtx);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);\n\n\tlg_prof_sample = lg_sample;\n\tprof_unbias_map_init();\n\n\tnext = NULL;\n\tdo {\n\t\tprof_tdata_t *to_destroy = tdata_tree_iter(&tdatas, next,\n\t\t prof_tdata_reset_iter, (void *)tsd);\n\t\tif (to_destroy != NULL) {\n\t\t\tnext = tdata_tree_next(&tdatas, to_destroy);\n\t\t\tprof_tdata_destroy_locked(tsd, to_destroy, false);\n\t\t} else {\n\t\t\tnext = NULL;\n\t\t}\n\t} while (next != NULL);\n\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_mtx);\n}\n\nstatic bool\nprof_tctx_should_destroy(tsd_t *tsd, prof_tctx_t *tctx) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\n\tif (opt_prof_accum) {\n\t\treturn false;\n\t}\n\tif (tctx->cnts.curobjs != 0) {\n\t\treturn false;\n\t}\n\tif (tctx->prepared) {\n\t\treturn false;\n\t}\n\tif (tctx->recent_count != 0) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nstatic void\nprof_tctx_destroy(tsd_t *tsd, prof_tctx_t *tctx) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\n\tassert(tctx->cnts.curobjs == 0);\n\tassert(tctx->cnts.curbytes == 0);\n\t/*\n\t * These asserts are not correct -- see the comment about races in\n\t * prof.c\n\t *\n\t * assert(tctx->cnts.curobjs_shifted_unbiased == 0);\n\t * assert(tctx->cnts.curbytes_unbiased == 0);\n\t */\n\tassert(!opt_prof_accum);\n\tassert(tctx->cnts.accumobjs == 0);\n\tassert(tctx->cnts.accumbytes == 0);\n\t/*\n\t * These ones are, since accumbyte counts never go down. Either\n\t * prof_accum is off (in which case these should never have changed from\n\t * their initial value of zero), or it's on (in which case we shouldn't\n\t * be destroying this tctx).\n\t */\n\tassert(tctx->cnts.accumobjs_shifted_unbiased == 0);\n\tassert(tctx->cnts.accumbytes_unbiased == 0);\n\n\tprof_gctx_t *gctx = tctx->gctx;\n\n\t{\n\t\tprof_tdata_t *tdata = tctx->tdata;\n\t\ttctx->tdata = NULL;\n\t\tckh_remove(tsd, &tdata->bt2tctx, &gctx->bt, NULL, NULL);\n\t\tbool destroy_tdata = prof_tdata_should_destroy(tsd_tsdn(tsd),\n\t\t tdata, false);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);\n\t\tif (destroy_tdata) {\n\t\t\tprof_tdata_destroy(tsd, tdata, false);\n\t\t}\n\t}\n\n\tbool destroy_tctx, destroy_gctx;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), gctx->lock);\n\tswitch (tctx->state) {\n\tcase prof_tctx_state_nominal:\n\t\ttctx_tree_remove(&gctx->tctxs, tctx);\n\t\tdestroy_tctx = true;\n\t\tif (prof_gctx_should_destroy(gctx)) {\n\t\t\t/*\n\t\t\t * Increment gctx->nlimbo in order to keep another\n\t\t\t * thread from winning the race to destroy gctx while\n\t\t\t * this one has gctx->lock dropped. Without this, it\n\t\t\t * would be possible for another thread to:\n\t\t\t *\n\t\t\t * 1) Sample an allocation associated with gctx.\n\t\t\t * 2) Deallocate the sampled object.\n\t\t\t * 3) Successfully prof_gctx_try_destroy(gctx).\n\t\t\t *\n\t\t\t * The result would be that gctx no longer exists by the\n\t\t\t * time this thread accesses it in\n\t\t\t * prof_gctx_try_destroy().\n\t\t\t */\n\t\t\tgctx->nlimbo++;\n\t\t\tdestroy_gctx = true;\n\t\t} else {\n\t\t\tdestroy_gctx = false;\n\t\t}\n\t\tbreak;\n\tcase prof_tctx_state_dumping:\n\t\t/*\n\t\t * A dumping thread needs tctx to remain valid until dumping\n\t\t * has finished. Change state such that the dumping thread will\n\t\t * complete destruction during a late dump iteration phase.\n\t\t */\n\t\ttctx->state = prof_tctx_state_purgatory;\n\t\tdestroy_tctx = false;\n\t\tdestroy_gctx = false;\n\t\tbreak;\n\tdefault:\n\t\tnot_reached();\n\t\tdestroy_tctx = false;\n\t\tdestroy_gctx = false;\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), gctx->lock);\n\tif (destroy_gctx) {\n\t\tprof_gctx_try_destroy(tsd, prof_tdata_get(tsd, false), gctx);\n\t}\n\tif (destroy_tctx) {\n\t\tidalloctm(tsd_tsdn(tsd), tctx, NULL, NULL, true, true);\n\t}\n}\n\nvoid\nprof_tctx_try_destroy(tsd_t *tsd, prof_tctx_t *tctx) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\tif (prof_tctx_should_destroy(tsd, tctx)) {\n\t\t/* tctx->tdata->lock will be released in prof_tctx_destroy(). */\n\t\tprof_tctx_destroy(tsd, tctx);\n\t} else {\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock);\n\t}\n}\n\n/******************************************************************************/\n" }, { "path": "deps/jemalloc/src/prof_log.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/buf_writer.h\"\n#include \"jemalloc/internal/ckh.h\"\n#include \"jemalloc/internal/emitter.h\"\n#include \"jemalloc/internal/hash.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_log.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n\nbool opt_prof_log = false;\ntypedef enum prof_logging_state_e prof_logging_state_t;\nenum prof_logging_state_e {\n\tprof_logging_state_stopped,\n\tprof_logging_state_started,\n\tprof_logging_state_dumping\n};\n\n/*\n * - stopped: log_start never called, or previous log_stop has completed.\n * - started: log_start called, log_stop not called yet. Allocations are logged.\n * - dumping: log_stop called but not finished; samples are not logged anymore.\n */\nprof_logging_state_t prof_logging_state = prof_logging_state_stopped;\n\n/* Used in unit tests. */\nstatic bool prof_log_dummy = false;\n\n/* Incremented for every log file that is output. */\nstatic uint64_t log_seq = 0;\nstatic char log_filename[\n /* Minimize memory bloat for non-prof builds. */\n#ifdef JEMALLOC_PROF\n PATH_MAX +\n#endif\n 1];\n\n/* Timestamp for most recent call to log_start(). */\nstatic nstime_t log_start_timestamp;\n\n/* Increment these when adding to the log_bt and log_thr linked lists. */\nstatic size_t log_bt_index = 0;\nstatic size_t log_thr_index = 0;\n\n/* Linked list node definitions. These are only used in this file. */\ntypedef struct prof_bt_node_s prof_bt_node_t;\n\nstruct prof_bt_node_s {\n\tprof_bt_node_t *next;\n\tsize_t index;\n\tprof_bt_t bt;\n\t/* Variable size backtrace vector pointed to by bt. */\n\tvoid *vec[1];\n};\n\ntypedef struct prof_thr_node_s prof_thr_node_t;\n\nstruct prof_thr_node_s {\n\tprof_thr_node_t *next;\n\tsize_t index;\n\tuint64_t thr_uid;\n\t/* Variable size based on thr_name_sz. */\n\tchar name[1];\n};\n\ntypedef struct prof_alloc_node_s prof_alloc_node_t;\n\n/* This is output when logging sampled allocations. */\nstruct prof_alloc_node_s {\n\tprof_alloc_node_t *next;\n\t/* Indices into an array of thread data. */\n\tsize_t alloc_thr_ind;\n\tsize_t free_thr_ind;\n\n\t/* Indices into an array of backtraces. */\n\tsize_t alloc_bt_ind;\n\tsize_t free_bt_ind;\n\n\tuint64_t alloc_time_ns;\n\tuint64_t free_time_ns;\n\n\tsize_t usize;\n};\n\n/*\n * Created on the first call to prof_try_log and deleted on prof_log_stop.\n * These are the backtraces and threads that have already been logged by an\n * allocation.\n */\nstatic bool log_tables_initialized = false;\nstatic ckh_t log_bt_node_set;\nstatic ckh_t log_thr_node_set;\n\n/* Store linked lists for logged data. */\nstatic prof_bt_node_t *log_bt_first = NULL;\nstatic prof_bt_node_t *log_bt_last = NULL;\nstatic prof_thr_node_t *log_thr_first = NULL;\nstatic prof_thr_node_t *log_thr_last = NULL;\nstatic prof_alloc_node_t *log_alloc_first = NULL;\nstatic prof_alloc_node_t *log_alloc_last = NULL;\n\n/* Protects the prof_logging_state and any log_{...} variable. */\nmalloc_mutex_t log_mtx;\n\n/******************************************************************************/\n/*\n * Function prototypes for static functions that are referenced prior to\n * definition.\n */\n\n/* Hashtable functions for log_bt_node_set and log_thr_node_set. */\nstatic void prof_thr_node_hash(const void *key, size_t r_hash[2]);\nstatic bool prof_thr_node_keycomp(const void *k1, const void *k2);\nstatic void prof_bt_node_hash(const void *key, size_t r_hash[2]);\nstatic bool prof_bt_node_keycomp(const void *k1, const void *k2);\n\n/******************************************************************************/\n\nstatic size_t\nprof_log_bt_index(tsd_t *tsd, prof_bt_t *bt) {\n\tassert(prof_logging_state == prof_logging_state_started);\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &log_mtx);\n\n\tprof_bt_node_t dummy_node;\n\tdummy_node.bt = *bt;\n\tprof_bt_node_t *node;\n\n\t/* See if this backtrace is already cached in the table. */\n\tif (ckh_search(&log_bt_node_set, (void *)(&dummy_node),\n\t (void **)(&node), NULL)) {\n\t\tsize_t sz = offsetof(prof_bt_node_t, vec) +\n\t\t\t (bt->len * sizeof(void *));\n\t\tprof_bt_node_t *new_node = (prof_bt_node_t *)\n\t\t iallocztm(tsd_tsdn(tsd), sz, sz_size2index(sz), false, NULL,\n\t\t true, arena_get(TSDN_NULL, 0, true), true);\n\t\tif (log_bt_first == NULL) {\n\t\t\tlog_bt_first = new_node;\n\t\t\tlog_bt_last = new_node;\n\t\t} else {\n\t\t\tlog_bt_last->next = new_node;\n\t\t\tlog_bt_last = new_node;\n\t\t}\n\n\t\tnew_node->next = NULL;\n\t\tnew_node->index = log_bt_index;\n\t\t/*\n\t\t * Copy the backtrace: bt is inside a tdata or gctx, which\n\t\t * might die before prof_log_stop is called.\n\t\t */\n\t\tnew_node->bt.len = bt->len;\n\t\tmemcpy(new_node->vec, bt->vec, bt->len * sizeof(void *));\n\t\tnew_node->bt.vec = new_node->vec;\n\n\t\tlog_bt_index++;\n\t\tckh_insert(tsd, &log_bt_node_set, (void *)new_node, NULL);\n\t\treturn new_node->index;\n\t} else {\n\t\treturn node->index;\n\t}\n}\n\nstatic size_t\nprof_log_thr_index(tsd_t *tsd, uint64_t thr_uid, const char *name) {\n\tassert(prof_logging_state == prof_logging_state_started);\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &log_mtx);\n\n\tprof_thr_node_t dummy_node;\n\tdummy_node.thr_uid = thr_uid;\n\tprof_thr_node_t *node;\n\n\t/* See if this thread is already cached in the table. */\n\tif (ckh_search(&log_thr_node_set, (void *)(&dummy_node),\n\t (void **)(&node), NULL)) {\n\t\tsize_t sz = offsetof(prof_thr_node_t, name) + strlen(name) + 1;\n\t\tprof_thr_node_t *new_node = (prof_thr_node_t *)\n\t\t iallocztm(tsd_tsdn(tsd), sz, sz_size2index(sz), false, NULL,\n\t\t true, arena_get(TSDN_NULL, 0, true), true);\n\t\tif (log_thr_first == NULL) {\n\t\t\tlog_thr_first = new_node;\n\t\t\tlog_thr_last = new_node;\n\t\t} else {\n\t\t\tlog_thr_last->next = new_node;\n\t\t\tlog_thr_last = new_node;\n\t\t}\n\n\t\tnew_node->next = NULL;\n\t\tnew_node->index = log_thr_index;\n\t\tnew_node->thr_uid = thr_uid;\n\t\tstrcpy(new_node->name, name);\n\n\t\tlog_thr_index++;\n\t\tckh_insert(tsd, &log_thr_node_set, (void *)new_node, NULL);\n\t\treturn new_node->index;\n\t} else {\n\t\treturn node->index;\n\t}\n}\n\nJEMALLOC_COLD\nvoid\nprof_try_log(tsd_t *tsd, size_t usize, prof_info_t *prof_info) {\n\tcassert(config_prof);\n\tprof_tctx_t *tctx = prof_info->alloc_tctx;\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\n\tprof_tdata_t *cons_tdata = prof_tdata_get(tsd, false);\n\tif (cons_tdata == NULL) {\n\t\t/*\n\t\t * We decide not to log these allocations. cons_tdata will be\n\t\t * NULL only when the current thread is in a weird state (e.g.\n\t\t * it's being destroyed).\n\t\t */\n\t\treturn;\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &log_mtx);\n\n\tif (prof_logging_state != prof_logging_state_started) {\n\t\tgoto label_done;\n\t}\n\n\tif (!log_tables_initialized) {\n\t\tbool err1 = ckh_new(tsd, &log_bt_node_set, PROF_CKH_MINITEMS,\n\t\t\t\tprof_bt_node_hash, prof_bt_node_keycomp);\n\t\tbool err2 = ckh_new(tsd, &log_thr_node_set, PROF_CKH_MINITEMS,\n\t\t\t\tprof_thr_node_hash, prof_thr_node_keycomp);\n\t\tif (err1 || err2) {\n\t\t\tgoto label_done;\n\t\t}\n\t\tlog_tables_initialized = true;\n\t}\n\n\tnstime_t alloc_time = prof_info->alloc_time;\n\tnstime_t free_time;\n\tnstime_prof_init_update(&free_time);\n\n\tsize_t sz = sizeof(prof_alloc_node_t);\n\tprof_alloc_node_t *new_node = (prof_alloc_node_t *)\n\t iallocztm(tsd_tsdn(tsd), sz, sz_size2index(sz), false, NULL, true,\n\t arena_get(TSDN_NULL, 0, true), true);\n\n\tconst char *prod_thr_name = (tctx->tdata->thread_name == NULL)?\n\t\t\t\t \"\" : tctx->tdata->thread_name;\n\tconst char *cons_thr_name = prof_thread_name_get(tsd);\n\n\tprof_bt_t bt;\n\t/* Initialize the backtrace, using the buffer in tdata to store it. */\n\tbt_init(&bt, cons_tdata->vec);\n\tprof_backtrace(tsd, &bt);\n\tprof_bt_t *cons_bt = &bt;\n\n\t/* We haven't destroyed tctx yet, so gctx should be good to read. */\n\tprof_bt_t *prod_bt = &tctx->gctx->bt;\n\n\tnew_node->next = NULL;\n\tnew_node->alloc_thr_ind = prof_log_thr_index(tsd, tctx->tdata->thr_uid,\n\t\t\t\t prod_thr_name);\n\tnew_node->free_thr_ind = prof_log_thr_index(tsd, cons_tdata->thr_uid,\n\t\t\t\t cons_thr_name);\n\tnew_node->alloc_bt_ind = prof_log_bt_index(tsd, prod_bt);\n\tnew_node->free_bt_ind = prof_log_bt_index(tsd, cons_bt);\n\tnew_node->alloc_time_ns = nstime_ns(&alloc_time);\n\tnew_node->free_time_ns = nstime_ns(&free_time);\n\tnew_node->usize = usize;\n\n\tif (log_alloc_first == NULL) {\n\t\tlog_alloc_first = new_node;\n\t\tlog_alloc_last = new_node;\n\t} else {\n\t\tlog_alloc_last->next = new_node;\n\t\tlog_alloc_last = new_node;\n\t}\n\nlabel_done:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &log_mtx);\n}\n\nstatic void\nprof_bt_node_hash(const void *key, size_t r_hash[2]) {\n\tconst prof_bt_node_t *bt_node = (prof_bt_node_t *)key;\n\tprof_bt_hash((void *)(&bt_node->bt), r_hash);\n}\n\nstatic bool\nprof_bt_node_keycomp(const void *k1, const void *k2) {\n\tconst prof_bt_node_t *bt_node1 = (prof_bt_node_t *)k1;\n\tconst prof_bt_node_t *bt_node2 = (prof_bt_node_t *)k2;\n\treturn prof_bt_keycomp((void *)(&bt_node1->bt),\n\t (void *)(&bt_node2->bt));\n}\n\nstatic void\nprof_thr_node_hash(const void *key, size_t r_hash[2]) {\n\tconst prof_thr_node_t *thr_node = (prof_thr_node_t *)key;\n\thash(&thr_node->thr_uid, sizeof(uint64_t), 0x94122f35U, r_hash);\n}\n\nstatic bool\nprof_thr_node_keycomp(const void *k1, const void *k2) {\n\tconst prof_thr_node_t *thr_node1 = (prof_thr_node_t *)k1;\n\tconst prof_thr_node_t *thr_node2 = (prof_thr_node_t *)k2;\n\treturn thr_node1->thr_uid == thr_node2->thr_uid;\n}\n\n/* Used in unit tests. */\nsize_t\nprof_log_bt_count(void) {\n\tcassert(config_prof);\n\tsize_t cnt = 0;\n\tprof_bt_node_t *node = log_bt_first;\n\twhile (node != NULL) {\n\t\tcnt++;\n\t\tnode = node->next;\n\t}\n\treturn cnt;\n}\n\n/* Used in unit tests. */\nsize_t\nprof_log_alloc_count(void) {\n\tcassert(config_prof);\n\tsize_t cnt = 0;\n\tprof_alloc_node_t *node = log_alloc_first;\n\twhile (node != NULL) {\n\t\tcnt++;\n\t\tnode = node->next;\n\t}\n\treturn cnt;\n}\n\n/* Used in unit tests. */\nsize_t\nprof_log_thr_count(void) {\n\tcassert(config_prof);\n\tsize_t cnt = 0;\n\tprof_thr_node_t *node = log_thr_first;\n\twhile (node != NULL) {\n\t\tcnt++;\n\t\tnode = node->next;\n\t}\n\treturn cnt;\n}\n\n/* Used in unit tests. */\nbool\nprof_log_is_logging(void) {\n\tcassert(config_prof);\n\treturn prof_logging_state == prof_logging_state_started;\n}\n\n/* Used in unit tests. */\nbool\nprof_log_rep_check(void) {\n\tcassert(config_prof);\n\tif (prof_logging_state == prof_logging_state_stopped\n\t && log_tables_initialized) {\n\t\treturn true;\n\t}\n\n\tif (log_bt_last != NULL && log_bt_last->next != NULL) {\n\t\treturn true;\n\t}\n\tif (log_thr_last != NULL && log_thr_last->next != NULL) {\n\t\treturn true;\n\t}\n\tif (log_alloc_last != NULL && log_alloc_last->next != NULL) {\n\t\treturn true;\n\t}\n\n\tsize_t bt_count = prof_log_bt_count();\n\tsize_t thr_count = prof_log_thr_count();\n\tsize_t alloc_count = prof_log_alloc_count();\n\n\n\tif (prof_logging_state == prof_logging_state_stopped) {\n\t\tif (bt_count != 0 || thr_count != 0 || alloc_count || 0) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\tprof_alloc_node_t *node = log_alloc_first;\n\twhile (node != NULL) {\n\t\tif (node->alloc_bt_ind >= bt_count) {\n\t\t\treturn true;\n\t\t}\n\t\tif (node->free_bt_ind >= bt_count) {\n\t\t\treturn true;\n\t\t}\n\t\tif (node->alloc_thr_ind >= thr_count) {\n\t\t\treturn true;\n\t\t}\n\t\tif (node->free_thr_ind >= thr_count) {\n\t\t\treturn true;\n\t\t}\n\t\tif (node->alloc_time_ns > node->free_time_ns) {\n\t\t\treturn true;\n\t\t}\n\t\tnode = node->next;\n\t}\n\n\treturn false;\n}\n\n/* Used in unit tests. */\nvoid\nprof_log_dummy_set(bool new_value) {\n\tcassert(config_prof);\n\tprof_log_dummy = new_value;\n}\n\n/* Used as an atexit function to stop logging on exit. */\nstatic void\nprof_log_stop_final(void) {\n\ttsd_t *tsd = tsd_fetch();\n\tprof_log_stop(tsd_tsdn(tsd));\n}\n\nJEMALLOC_COLD\nbool\nprof_log_start(tsdn_t *tsdn, const char *filename) {\n\tcassert(config_prof);\n\n\tif (!opt_prof) {\n\t\treturn true;\n\t}\n\n\tbool ret = false;\n\n\tmalloc_mutex_lock(tsdn, &log_mtx);\n\n\tstatic bool prof_log_atexit_called = false;\n\tif (!prof_log_atexit_called) {\n\t\tprof_log_atexit_called = true;\n\t\tif (atexit(prof_log_stop_final) != 0) {\n\t\t\tmalloc_write(\": Error in atexit() \"\n\t\t\t \"for logging\\n\");\n\t\t\tif (opt_abort) {\n\t\t\t\tabort();\n\t\t\t}\n\t\t\tret = true;\n\t\t\tgoto label_done;\n\t\t}\n\t}\n\n\tif (prof_logging_state != prof_logging_state_stopped) {\n\t\tret = true;\n\t} else if (filename == NULL) {\n\t\t/* Make default name. */\n\t\tprof_get_default_filename(tsdn, log_filename, log_seq);\n\t\tlog_seq++;\n\t\tprof_logging_state = prof_logging_state_started;\n\t} else if (strlen(filename) >= PROF_DUMP_FILENAME_LEN) {\n\t\tret = true;\n\t} else {\n\t\tstrcpy(log_filename, filename);\n\t\tprof_logging_state = prof_logging_state_started;\n\t}\n\n\tif (!ret) {\n\t\tnstime_prof_init_update(&log_start_timestamp);\n\t}\nlabel_done:\n\tmalloc_mutex_unlock(tsdn, &log_mtx);\n\n\treturn ret;\n}\n\nstruct prof_emitter_cb_arg_s {\n\tint fd;\n\tssize_t ret;\n};\n\nstatic void\nprof_emitter_write_cb(void *opaque, const char *to_write) {\n\tstruct prof_emitter_cb_arg_s *arg =\n\t (struct prof_emitter_cb_arg_s *)opaque;\n\tsize_t bytes = strlen(to_write);\n\tif (prof_log_dummy) {\n\t\treturn;\n\t}\n\targ->ret = malloc_write_fd(arg->fd, to_write, bytes);\n}\n\n/*\n * prof_log_emit_{...} goes through the appropriate linked list, emitting each\n * node to the json and deallocating it.\n */\nstatic void\nprof_log_emit_threads(tsd_t *tsd, emitter_t *emitter) {\n\temitter_json_array_kv_begin(emitter, \"threads\");\n\tprof_thr_node_t *thr_node = log_thr_first;\n\tprof_thr_node_t *thr_old_node;\n\twhile (thr_node != NULL) {\n\t\temitter_json_object_begin(emitter);\n\n\t\temitter_json_kv(emitter, \"thr_uid\", emitter_type_uint64,\n\t\t &thr_node->thr_uid);\n\n\t\tchar *thr_name = thr_node->name;\n\n\t\temitter_json_kv(emitter, \"thr_name\", emitter_type_string,\n\t\t &thr_name);\n\n\t\temitter_json_object_end(emitter);\n\t\tthr_old_node = thr_node;\n\t\tthr_node = thr_node->next;\n\t\tidalloctm(tsd_tsdn(tsd), thr_old_node, NULL, NULL, true, true);\n\t}\n\temitter_json_array_end(emitter);\n}\n\nstatic void\nprof_log_emit_traces(tsd_t *tsd, emitter_t *emitter) {\n\temitter_json_array_kv_begin(emitter, \"stack_traces\");\n\tprof_bt_node_t *bt_node = log_bt_first;\n\tprof_bt_node_t *bt_old_node;\n\t/*\n\t * Calculate how many hex digits we need: twice number of bytes, two for\n\t * \"0x\", and then one more for terminating '\\0'.\n\t */\n\tchar buf[2 * sizeof(intptr_t) + 3];\n\tsize_t buf_sz = sizeof(buf);\n\twhile (bt_node != NULL) {\n\t\temitter_json_array_begin(emitter);\n\t\tsize_t i;\n\t\tfor (i = 0; i < bt_node->bt.len; i++) {\n\t\t\tmalloc_snprintf(buf, buf_sz, \"%p\", bt_node->bt.vec[i]);\n\t\t\tchar *trace_str = buf;\n\t\t\temitter_json_value(emitter, emitter_type_string,\n\t\t\t &trace_str);\n\t\t}\n\t\temitter_json_array_end(emitter);\n\n\t\tbt_old_node = bt_node;\n\t\tbt_node = bt_node->next;\n\t\tidalloctm(tsd_tsdn(tsd), bt_old_node, NULL, NULL, true, true);\n\t}\n\temitter_json_array_end(emitter);\n}\n\nstatic void\nprof_log_emit_allocs(tsd_t *tsd, emitter_t *emitter) {\n\temitter_json_array_kv_begin(emitter, \"allocations\");\n\tprof_alloc_node_t *alloc_node = log_alloc_first;\n\tprof_alloc_node_t *alloc_old_node;\n\twhile (alloc_node != NULL) {\n\t\temitter_json_object_begin(emitter);\n\n\t\temitter_json_kv(emitter, \"alloc_thread\", emitter_type_size,\n\t\t &alloc_node->alloc_thr_ind);\n\n\t\temitter_json_kv(emitter, \"free_thread\", emitter_type_size,\n\t\t &alloc_node->free_thr_ind);\n\n\t\temitter_json_kv(emitter, \"alloc_trace\", emitter_type_size,\n\t\t &alloc_node->alloc_bt_ind);\n\n\t\temitter_json_kv(emitter, \"free_trace\", emitter_type_size,\n\t\t &alloc_node->free_bt_ind);\n\n\t\temitter_json_kv(emitter, \"alloc_timestamp\",\n\t\t emitter_type_uint64, &alloc_node->alloc_time_ns);\n\n\t\temitter_json_kv(emitter, \"free_timestamp\", emitter_type_uint64,\n\t\t &alloc_node->free_time_ns);\n\n\t\temitter_json_kv(emitter, \"usize\", emitter_type_uint64,\n\t\t &alloc_node->usize);\n\n\t\temitter_json_object_end(emitter);\n\n\t\talloc_old_node = alloc_node;\n\t\talloc_node = alloc_node->next;\n\t\tidalloctm(tsd_tsdn(tsd), alloc_old_node, NULL, NULL, true,\n\t\t true);\n\t}\n\temitter_json_array_end(emitter);\n}\n\nstatic void\nprof_log_emit_metadata(emitter_t *emitter) {\n\temitter_json_object_kv_begin(emitter, \"info\");\n\n\tnstime_t now;\n\n\tnstime_prof_init_update(&now);\n\tuint64_t ns = nstime_ns(&now) - nstime_ns(&log_start_timestamp);\n\temitter_json_kv(emitter, \"duration\", emitter_type_uint64, &ns);\n\n\tchar *vers = JEMALLOC_VERSION;\n\temitter_json_kv(emitter, \"version\",\n\t emitter_type_string, &vers);\n\n\temitter_json_kv(emitter, \"lg_sample_rate\",\n\t emitter_type_int, &lg_prof_sample);\n\n\tconst char *res_type = prof_time_res_mode_names[opt_prof_time_res];\n\temitter_json_kv(emitter, \"prof_time_resolution\", emitter_type_string,\n\t &res_type);\n\n\tint pid = prof_getpid();\n\temitter_json_kv(emitter, \"pid\", emitter_type_int, &pid);\n\n\temitter_json_object_end(emitter);\n}\n\n#define PROF_LOG_STOP_BUFSIZE PROF_DUMP_BUFSIZE\nJEMALLOC_COLD\nbool\nprof_log_stop(tsdn_t *tsdn) {\n\tcassert(config_prof);\n\tif (!opt_prof || !prof_booted) {\n\t\treturn true;\n\t}\n\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\tmalloc_mutex_lock(tsdn, &log_mtx);\n\n\tif (prof_logging_state != prof_logging_state_started) {\n\t\tmalloc_mutex_unlock(tsdn, &log_mtx);\n\t\treturn true;\n\t}\n\n\t/*\n\t * Set the state to dumping. We'll set it to stopped when we're done.\n\t * Since other threads won't be able to start/stop/log when the state is\n\t * dumping, we don't have to hold the lock during the whole method.\n\t */\n\tprof_logging_state = prof_logging_state_dumping;\n\tmalloc_mutex_unlock(tsdn, &log_mtx);\n\n\n\temitter_t emitter;\n\n\t/* Create a file. */\n\n\tint fd;\n\tif (prof_log_dummy) {\n\t\tfd = 0;\n\t} else {\n\t\tfd = creat(log_filename, 0644);\n\t}\n\n\tif (fd == -1) {\n\t\tmalloc_printf(\": creat() for log file \\\"%s\\\" \"\n\t\t\t \" failed with %d\\n\", log_filename, errno);\n\t\tif (opt_abort) {\n\t\t\tabort();\n\t\t}\n\t\treturn true;\n\t}\n\n\tstruct prof_emitter_cb_arg_s arg;\n\targ.fd = fd;\n\n\tbuf_writer_t buf_writer;\n\tbuf_writer_init(tsdn, &buf_writer, prof_emitter_write_cb, &arg, NULL,\n\t PROF_LOG_STOP_BUFSIZE);\n\temitter_init(&emitter, emitter_output_json_compact, buf_writer_cb,\n\t &buf_writer);\n\n\temitter_begin(&emitter);\n\tprof_log_emit_metadata(&emitter);\n\tprof_log_emit_threads(tsd, &emitter);\n\tprof_log_emit_traces(tsd, &emitter);\n\tprof_log_emit_allocs(tsd, &emitter);\n\temitter_end(&emitter);\n\n\tbuf_writer_terminate(tsdn, &buf_writer);\n\n\t/* Reset global state. */\n\tif (log_tables_initialized) {\n\t\tckh_delete(tsd, &log_bt_node_set);\n\t\tckh_delete(tsd, &log_thr_node_set);\n\t}\n\tlog_tables_initialized = false;\n\tlog_bt_index = 0;\n\tlog_thr_index = 0;\n\tlog_bt_first = NULL;\n\tlog_bt_last = NULL;\n\tlog_thr_first = NULL;\n\tlog_thr_last = NULL;\n\tlog_alloc_first = NULL;\n\tlog_alloc_last = NULL;\n\n\tmalloc_mutex_lock(tsdn, &log_mtx);\n\tprof_logging_state = prof_logging_state_stopped;\n\tmalloc_mutex_unlock(tsdn, &log_mtx);\n\n\tif (prof_log_dummy) {\n\t\treturn false;\n\t}\n\treturn close(fd) || arg.ret == -1;\n}\n#undef PROF_LOG_STOP_BUFSIZE\n\nJEMALLOC_COLD\nbool\nprof_log_init(tsd_t *tsd) {\n\tcassert(config_prof);\n\tif (malloc_mutex_init(&log_mtx, \"prof_log\",\n\t WITNESS_RANK_PROF_LOG, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tif (opt_prof_log) {\n\t\tprof_log_start(tsd_tsdn(tsd), NULL);\n\t}\n\n\treturn false;\n}\n\n/******************************************************************************/\n" }, { "path": "deps/jemalloc/src/prof_recent.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/buf_writer.h\"\n#include \"jemalloc/internal/emitter.h\"\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_recent.h\"\n\nssize_t opt_prof_recent_alloc_max = PROF_RECENT_ALLOC_MAX_DEFAULT;\nmalloc_mutex_t prof_recent_alloc_mtx; /* Protects the fields below */\nstatic atomic_zd_t prof_recent_alloc_max;\nstatic ssize_t prof_recent_alloc_count = 0;\nprof_recent_list_t prof_recent_alloc_list;\n\nmalloc_mutex_t prof_recent_dump_mtx; /* Protects dumping. */\n\nstatic void\nprof_recent_alloc_max_init() {\n\tatomic_store_zd(&prof_recent_alloc_max, opt_prof_recent_alloc_max,\n\t ATOMIC_RELAXED);\n}\n\nstatic inline ssize_t\nprof_recent_alloc_max_get_no_lock() {\n\treturn atomic_load_zd(&prof_recent_alloc_max, ATOMIC_RELAXED);\n}\n\nstatic inline ssize_t\nprof_recent_alloc_max_get(tsd_t *tsd) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\treturn prof_recent_alloc_max_get_no_lock();\n}\n\nstatic inline ssize_t\nprof_recent_alloc_max_update(tsd_t *tsd, ssize_t max) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tssize_t old_max = prof_recent_alloc_max_get(tsd);\n\tatomic_store_zd(&prof_recent_alloc_max, max, ATOMIC_RELAXED);\n\treturn old_max;\n}\n\nstatic prof_recent_t *\nprof_recent_allocate_node(tsdn_t *tsdn) {\n\treturn (prof_recent_t *)iallocztm(tsdn, sizeof(prof_recent_t),\n\t sz_size2index(sizeof(prof_recent_t)), false, NULL, true,\n\t arena_get(tsdn, 0, false), true);\n}\n\nstatic void\nprof_recent_free_node(tsdn_t *tsdn, prof_recent_t *node) {\n\tassert(node != NULL);\n\tassert(isalloc(tsdn, node) == sz_s2u(sizeof(prof_recent_t)));\n\tidalloctm(tsdn, node, NULL, NULL, true, true);\n}\n\nstatic inline void\nincrement_recent_count(tsd_t *tsd, prof_tctx_t *tctx) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\t++tctx->recent_count;\n\tassert(tctx->recent_count > 0);\n}\n\nbool\nprof_recent_alloc_prepare(tsd_t *tsd, prof_tctx_t *tctx) {\n\tcassert(config_prof);\n\tassert(opt_prof && prof_booted);\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\n\t/*\n\t * Check whether last-N mode is turned on without trying to acquire the\n\t * lock, so as to optimize for the following two scenarios:\n\t * (1) Last-N mode is switched off;\n\t * (2) Dumping, during which last-N mode is temporarily turned off so\n\t * as not to block sampled allocations.\n\t */\n\tif (prof_recent_alloc_max_get_no_lock() == 0) {\n\t\treturn false;\n\t}\n\n\t/*\n\t * Increment recent_count to hold the tctx so that it won't be gone\n\t * even after tctx->tdata->lock is released. This acts as a\n\t * \"placeholder\"; the real recording of the allocation requires a lock\n\t * on prof_recent_alloc_mtx and is done in prof_recent_alloc (when\n\t * tctx->tdata->lock has been released).\n\t */\n\tincrement_recent_count(tsd, tctx);\n\treturn true;\n}\n\nstatic void\ndecrement_recent_count(tsd_t *tsd, prof_tctx_t *tctx) {\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tassert(tctx != NULL);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);\n\tassert(tctx->recent_count > 0);\n\t--tctx->recent_count;\n\tprof_tctx_try_destroy(tsd, tctx);\n}\n\nstatic inline edata_t *\nprof_recent_alloc_edata_get_no_lock(const prof_recent_t *n) {\n\treturn (edata_t *)atomic_load_p(&n->alloc_edata, ATOMIC_ACQUIRE);\n}\n\nedata_t *\nprof_recent_alloc_edata_get_no_lock_test(const prof_recent_t *n) {\n\tcassert(config_prof);\n\treturn prof_recent_alloc_edata_get_no_lock(n);\n}\n\nstatic inline edata_t *\nprof_recent_alloc_edata_get(tsd_t *tsd, const prof_recent_t *n) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\treturn prof_recent_alloc_edata_get_no_lock(n);\n}\n\nstatic void\nprof_recent_alloc_edata_set(tsd_t *tsd, prof_recent_t *n, edata_t *edata) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tatomic_store_p(&n->alloc_edata, edata, ATOMIC_RELEASE);\n}\n\nvoid\nedata_prof_recent_alloc_init(edata_t *edata) {\n\tcassert(config_prof);\n\tedata_prof_recent_alloc_set_dont_call_directly(edata, NULL);\n}\n\nstatic inline prof_recent_t *\nedata_prof_recent_alloc_get_no_lock(const edata_t *edata) {\n\tcassert(config_prof);\n\treturn edata_prof_recent_alloc_get_dont_call_directly(edata);\n}\n\nprof_recent_t *\nedata_prof_recent_alloc_get_no_lock_test(const edata_t *edata) {\n\tcassert(config_prof);\n\treturn edata_prof_recent_alloc_get_no_lock(edata);\n}\n\nstatic inline prof_recent_t *\nedata_prof_recent_alloc_get(tsd_t *tsd, const edata_t *edata) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_t *recent_alloc =\n\t edata_prof_recent_alloc_get_no_lock(edata);\n\tassert(recent_alloc == NULL ||\n\t prof_recent_alloc_edata_get(tsd, recent_alloc) == edata);\n\treturn recent_alloc;\n}\n\nstatic prof_recent_t *\nedata_prof_recent_alloc_update_internal(tsd_t *tsd, edata_t *edata,\n prof_recent_t *recent_alloc) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_t *old_recent_alloc =\n\t edata_prof_recent_alloc_get(tsd, edata);\n\tedata_prof_recent_alloc_set_dont_call_directly(edata, recent_alloc);\n\treturn old_recent_alloc;\n}\n\nstatic void\nedata_prof_recent_alloc_set(tsd_t *tsd, edata_t *edata,\n prof_recent_t *recent_alloc) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tassert(recent_alloc != NULL);\n\tprof_recent_t *old_recent_alloc =\n\t edata_prof_recent_alloc_update_internal(tsd, edata, recent_alloc);\n\tassert(old_recent_alloc == NULL);\n\tprof_recent_alloc_edata_set(tsd, recent_alloc, edata);\n}\n\nstatic void\nedata_prof_recent_alloc_reset(tsd_t *tsd, edata_t *edata,\n prof_recent_t *recent_alloc) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tassert(recent_alloc != NULL);\n\tprof_recent_t *old_recent_alloc =\n\t edata_prof_recent_alloc_update_internal(tsd, edata, NULL);\n\tassert(old_recent_alloc == recent_alloc);\n\tassert(edata == prof_recent_alloc_edata_get(tsd, recent_alloc));\n\tprof_recent_alloc_edata_set(tsd, recent_alloc, NULL);\n}\n\n/*\n * This function should be called right before an allocation is released, so\n * that the associated recent allocation record can contain the following\n * information:\n * (1) The allocation is released;\n * (2) The time of the deallocation; and\n * (3) The prof_tctx associated with the deallocation.\n */\nvoid\nprof_recent_alloc_reset(tsd_t *tsd, edata_t *edata) {\n\tcassert(config_prof);\n\t/*\n\t * Check whether the recent allocation record still exists without\n\t * trying to acquire the lock.\n\t */\n\tif (edata_prof_recent_alloc_get_no_lock(edata) == NULL) {\n\t\treturn;\n\t}\n\n\tprof_tctx_t *dalloc_tctx = prof_tctx_create(tsd);\n\t/*\n\t * In case dalloc_tctx is NULL, e.g. due to OOM, we will not record the\n\t * deallocation time / tctx, which is handled later, after we check\n\t * again when holding the lock.\n\t */\n\n\tif (dalloc_tctx != NULL) {\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), dalloc_tctx->tdata->lock);\n\t\tincrement_recent_count(tsd, dalloc_tctx);\n\t\tdalloc_tctx->prepared = false;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), dalloc_tctx->tdata->lock);\n\t}\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\t/* Check again after acquiring the lock. */\n\tprof_recent_t *recent = edata_prof_recent_alloc_get(tsd, edata);\n\tif (recent != NULL) {\n\t\tassert(nstime_equals_zero(&recent->dalloc_time));\n\t\tassert(recent->dalloc_tctx == NULL);\n\t\tif (dalloc_tctx != NULL) {\n\t\t\tnstime_prof_update(&recent->dalloc_time);\n\t\t\trecent->dalloc_tctx = dalloc_tctx;\n\t\t\tdalloc_tctx = NULL;\n\t\t}\n\t\tedata_prof_recent_alloc_reset(tsd, edata, recent);\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\n\tif (dalloc_tctx != NULL) {\n\t\t/* We lost the rase - the allocation record was just gone. */\n\t\tdecrement_recent_count(tsd, dalloc_tctx);\n\t}\n}\n\nstatic void\nprof_recent_alloc_evict_edata(tsd_t *tsd, prof_recent_t *recent_alloc) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tedata_t *edata = prof_recent_alloc_edata_get(tsd, recent_alloc);\n\tif (edata != NULL) {\n\t\tedata_prof_recent_alloc_reset(tsd, edata, recent_alloc);\n\t}\n}\n\nstatic bool\nprof_recent_alloc_is_empty(tsd_t *tsd) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tif (ql_empty(&prof_recent_alloc_list)) {\n\t\tassert(prof_recent_alloc_count == 0);\n\t\treturn true;\n\t} else {\n\t\tassert(prof_recent_alloc_count > 0);\n\t\treturn false;\n\t}\n}\n\nstatic void\nprof_recent_alloc_assert_count(tsd_t *tsd) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\tssize_t count = 0;\n\tprof_recent_t *n;\n\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t++count;\n\t}\n\tassert(count == prof_recent_alloc_count);\n\tassert(prof_recent_alloc_max_get(tsd) == -1 ||\n\t count <= prof_recent_alloc_max_get(tsd));\n}\n\nvoid\nprof_recent_alloc(tsd_t *tsd, edata_t *edata, size_t size, size_t usize) {\n\tcassert(config_prof);\n\tassert(edata != NULL);\n\tprof_tctx_t *tctx = edata_prof_tctx_get(edata);\n\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), tctx->tdata->lock);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_alloc_assert_count(tsd);\n\n\t/*\n\t * Reserve a new prof_recent_t node if needed. If needed, we release\n\t * the prof_recent_alloc_mtx lock and allocate. Then, rather than\n\t * immediately checking for OOM, we regain the lock and try to make use\n\t * of the reserve node if needed. There are six scenarios:\n\t *\n\t * \\ now | no need | need but OOMed | need and allocated\n\t * later \\ | | |\n\t * ------------------------------------------------------------\n\t * no need | (1) | (2) | (3)\n\t * ------------------------------------------------------------\n\t * need | (4) | (5) | (6)\n\t *\n\t * First, \"(4)\" never happens, because we don't release the lock in the\n\t * middle if there's no need for a new node; in such cases \"(1)\" always\n\t * takes place, which is trivial.\n\t *\n\t * Out of the remaining four scenarios, \"(6)\" is the common case and is\n\t * trivial. \"(5)\" is also trivial, in which case we'll rollback the\n\t * effect of prof_recent_alloc_prepare() as expected.\n\t *\n\t * \"(2)\" / \"(3)\" occurs when the need for a new node is gone after we\n\t * regain the lock. If the new node is successfully allocated, i.e. in\n\t * the case of \"(3)\", we'll release it in the end; otherwise, i.e. in\n\t * the case of \"(2)\", we do nothing - we're lucky that the OOM ends up\n\t * doing no harm at all.\n\t *\n\t * Therefore, the only performance cost of the \"release lock\" ->\n\t * \"allocate\" -> \"regain lock\" design is the \"(3)\" case, but it happens\n\t * very rarely, so the cost is relatively small compared to the gain of\n\t * not having to have the lock order of prof_recent_alloc_mtx above all\n\t * the allocation locks.\n\t */\n\tprof_recent_t *reserve = NULL;\n\tif (prof_recent_alloc_max_get(tsd) == -1 ||\n\t prof_recent_alloc_count < prof_recent_alloc_max_get(tsd)) {\n\t\tassert(prof_recent_alloc_max_get(tsd) != 0);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\t\treserve = prof_recent_allocate_node(tsd_tsdn(tsd));\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\t\tprof_recent_alloc_assert_count(tsd);\n\t}\n\n\tif (prof_recent_alloc_max_get(tsd) == 0) {\n\t\tassert(prof_recent_alloc_is_empty(tsd));\n\t\tgoto label_rollback;\n\t}\n\n\tprof_tctx_t *old_alloc_tctx, *old_dalloc_tctx;\n\tif (prof_recent_alloc_count == prof_recent_alloc_max_get(tsd)) {\n\t\t/* If upper limit is reached, rotate the head. */\n\t\tassert(prof_recent_alloc_max_get(tsd) != -1);\n\t\tassert(!prof_recent_alloc_is_empty(tsd));\n\t\tprof_recent_t *head = ql_first(&prof_recent_alloc_list);\n\t\told_alloc_tctx = head->alloc_tctx;\n\t\tassert(old_alloc_tctx != NULL);\n\t\told_dalloc_tctx = head->dalloc_tctx;\n\t\tprof_recent_alloc_evict_edata(tsd, head);\n\t\tql_rotate(&prof_recent_alloc_list, link);\n\t} else {\n\t\t/* Otherwise make use of the new node. */\n\t\tassert(prof_recent_alloc_max_get(tsd) == -1 ||\n\t\t prof_recent_alloc_count < prof_recent_alloc_max_get(tsd));\n\t\tif (reserve == NULL) {\n\t\t\tgoto label_rollback;\n\t\t}\n\t\tql_elm_new(reserve, link);\n\t\tql_tail_insert(&prof_recent_alloc_list, reserve, link);\n\t\treserve = NULL;\n\t\told_alloc_tctx = NULL;\n\t\told_dalloc_tctx = NULL;\n\t\t++prof_recent_alloc_count;\n\t}\n\n\t/* Fill content into the tail node. */\n\tprof_recent_t *tail = ql_last(&prof_recent_alloc_list, link);\n\tassert(tail != NULL);\n\ttail->size = size;\n\ttail->usize = usize;\n\tnstime_copy(&tail->alloc_time, edata_prof_alloc_time_get(edata));\n\ttail->alloc_tctx = tctx;\n\tnstime_init_zero(&tail->dalloc_time);\n\ttail->dalloc_tctx = NULL;\n\tedata_prof_recent_alloc_set(tsd, edata, tail);\n\n\tassert(!prof_recent_alloc_is_empty(tsd));\n\tprof_recent_alloc_assert_count(tsd);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\n\tif (reserve != NULL) {\n\t\tprof_recent_free_node(tsd_tsdn(tsd), reserve);\n\t}\n\n\t/*\n\t * Asynchronously handle the tctx of the old node, so that there's no\n\t * simultaneous holdings of prof_recent_alloc_mtx and tdata->lock.\n\t * In the worst case this may delay the tctx release but it's better\n\t * than holding prof_recent_alloc_mtx for longer.\n\t */\n\tif (old_alloc_tctx != NULL) {\n\t\tdecrement_recent_count(tsd, old_alloc_tctx);\n\t}\n\tif (old_dalloc_tctx != NULL) {\n\t\tdecrement_recent_count(tsd, old_dalloc_tctx);\n\t}\n\treturn;\n\nlabel_rollback:\n\tassert(edata_prof_recent_alloc_get(tsd, edata) == NULL);\n\tprof_recent_alloc_assert_count(tsd);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tif (reserve != NULL) {\n\t\tprof_recent_free_node(tsd_tsdn(tsd), reserve);\n\t}\n\tdecrement_recent_count(tsd, tctx);\n}\n\nssize_t\nprof_recent_alloc_max_ctl_read() {\n\tcassert(config_prof);\n\t/* Don't bother to acquire the lock. */\n\treturn prof_recent_alloc_max_get_no_lock();\n}\n\nstatic void\nprof_recent_alloc_restore_locked(tsd_t *tsd, prof_recent_list_t *to_delete) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tssize_t max = prof_recent_alloc_max_get(tsd);\n\tif (max == -1 || prof_recent_alloc_count <= max) {\n\t\t/* Easy case - no need to alter the list. */\n\t\tql_new(to_delete);\n\t\tprof_recent_alloc_assert_count(tsd);\n\t\treturn;\n\t}\n\n\tprof_recent_t *node;\n\tql_foreach(node, &prof_recent_alloc_list, link) {\n\t\tif (prof_recent_alloc_count == max) {\n\t\t\tbreak;\n\t\t}\n\t\tprof_recent_alloc_evict_edata(tsd, node);\n\t\t--prof_recent_alloc_count;\n\t}\n\tassert(prof_recent_alloc_count == max);\n\n\tql_move(to_delete, &prof_recent_alloc_list);\n\tif (max == 0) {\n\t\tassert(node == NULL);\n\t} else {\n\t\tassert(node != NULL);\n\t\tql_split(to_delete, node, &prof_recent_alloc_list, link);\n\t}\n\tassert(!ql_empty(to_delete));\n\tprof_recent_alloc_assert_count(tsd);\n}\n\nstatic void\nprof_recent_alloc_async_cleanup(tsd_t *tsd, prof_recent_list_t *to_delete) {\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), &prof_recent_dump_mtx);\n\tmalloc_mutex_assert_not_owner(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\twhile (!ql_empty(to_delete)) {\n\t\tprof_recent_t *node = ql_first(to_delete);\n\t\tql_remove(to_delete, node, link);\n\t\tdecrement_recent_count(tsd, node->alloc_tctx);\n\t\tif (node->dalloc_tctx != NULL) {\n\t\t\tdecrement_recent_count(tsd, node->dalloc_tctx);\n\t\t}\n\t\tprof_recent_free_node(tsd_tsdn(tsd), node);\n\t}\n}\n\nssize_t\nprof_recent_alloc_max_ctl_write(tsd_t *tsd, ssize_t max) {\n\tcassert(config_prof);\n\tassert(max >= -1);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_alloc_assert_count(tsd);\n\tconst ssize_t old_max = prof_recent_alloc_max_update(tsd, max);\n\tprof_recent_list_t to_delete;\n\tprof_recent_alloc_restore_locked(tsd, &to_delete);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_alloc_async_cleanup(tsd, &to_delete);\n\treturn old_max;\n}\n\nstatic void\nprof_recent_alloc_dump_bt(emitter_t *emitter, prof_tctx_t *tctx) {\n\tchar bt_buf[2 * sizeof(intptr_t) + 3];\n\tchar *s = bt_buf;\n\tassert(tctx != NULL);\n\tprof_bt_t *bt = &tctx->gctx->bt;\n\tfor (size_t i = 0; i < bt->len; ++i) {\n\t\tmalloc_snprintf(bt_buf, sizeof(bt_buf), \"%p\", bt->vec[i]);\n\t\temitter_json_value(emitter, emitter_type_string, &s);\n\t}\n}\n\nstatic void\nprof_recent_alloc_dump_node(emitter_t *emitter, prof_recent_t *node) {\n\temitter_json_object_begin(emitter);\n\n\temitter_json_kv(emitter, \"size\", emitter_type_size, &node->size);\n\temitter_json_kv(emitter, \"usize\", emitter_type_size, &node->usize);\n\tbool released = prof_recent_alloc_edata_get_no_lock(node) == NULL;\n\temitter_json_kv(emitter, \"released\", emitter_type_bool, &released);\n\n\temitter_json_kv(emitter, \"alloc_thread_uid\", emitter_type_uint64,\n\t &node->alloc_tctx->thr_uid);\n\tprof_tdata_t *alloc_tdata = node->alloc_tctx->tdata;\n\tassert(alloc_tdata != NULL);\n\tif (alloc_tdata->thread_name != NULL) {\n\t\temitter_json_kv(emitter, \"alloc_thread_name\",\n\t\t emitter_type_string, &alloc_tdata->thread_name);\n\t}\n\tuint64_t alloc_time_ns = nstime_ns(&node->alloc_time);\n\temitter_json_kv(emitter, \"alloc_time\", emitter_type_uint64,\n\t &alloc_time_ns);\n\temitter_json_array_kv_begin(emitter, \"alloc_trace\");\n\tprof_recent_alloc_dump_bt(emitter, node->alloc_tctx);\n\temitter_json_array_end(emitter);\n\n\tif (released && node->dalloc_tctx != NULL) {\n\t\temitter_json_kv(emitter, \"dalloc_thread_uid\",\n\t\t emitter_type_uint64, &node->dalloc_tctx->thr_uid);\n\t\tprof_tdata_t *dalloc_tdata = node->dalloc_tctx->tdata;\n\t\tassert(dalloc_tdata != NULL);\n\t\tif (dalloc_tdata->thread_name != NULL) {\n\t\t\temitter_json_kv(emitter, \"dalloc_thread_name\",\n\t\t\t emitter_type_string, &dalloc_tdata->thread_name);\n\t\t}\n\t\tassert(!nstime_equals_zero(&node->dalloc_time));\n\t\tuint64_t dalloc_time_ns = nstime_ns(&node->dalloc_time);\n\t\temitter_json_kv(emitter, \"dalloc_time\", emitter_type_uint64,\n\t\t &dalloc_time_ns);\n\t\temitter_json_array_kv_begin(emitter, \"dalloc_trace\");\n\t\tprof_recent_alloc_dump_bt(emitter, node->dalloc_tctx);\n\t\temitter_json_array_end(emitter);\n\t}\n\n\temitter_json_object_end(emitter);\n}\n\n#define PROF_RECENT_PRINT_BUFSIZE 65536\nJEMALLOC_COLD\nvoid\nprof_recent_alloc_dump(tsd_t *tsd, write_cb_t *write_cb, void *cbopaque) {\n\tcassert(config_prof);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_dump_mtx);\n\tbuf_writer_t buf_writer;\n\tbuf_writer_init(tsd_tsdn(tsd), &buf_writer, write_cb, cbopaque, NULL,\n\t PROF_RECENT_PRINT_BUFSIZE);\n\temitter_t emitter;\n\temitter_init(&emitter, emitter_output_json_compact, buf_writer_cb,\n\t &buf_writer);\n\tprof_recent_list_t temp_list;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_alloc_assert_count(tsd);\n\tssize_t dump_max = prof_recent_alloc_max_get(tsd);\n\tql_move(&temp_list, &prof_recent_alloc_list);\n\tssize_t dump_count = prof_recent_alloc_count;\n\tprof_recent_alloc_count = 0;\n\tprof_recent_alloc_assert_count(tsd);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\n\temitter_begin(&emitter);\n\tuint64_t sample_interval = (uint64_t)1U << lg_prof_sample;\n\temitter_json_kv(&emitter, \"sample_interval\", emitter_type_uint64,\n\t &sample_interval);\n\temitter_json_kv(&emitter, \"recent_alloc_max\", emitter_type_ssize,\n\t &dump_max);\n\temitter_json_array_kv_begin(&emitter, \"recent_alloc\");\n\tprof_recent_t *node;\n\tql_foreach(node, &temp_list, link) {\n\t\tprof_recent_alloc_dump_node(&emitter, node);\n\t}\n\temitter_json_array_end(&emitter);\n\temitter_end(&emitter);\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\tprof_recent_alloc_assert_count(tsd);\n\tql_concat(&temp_list, &prof_recent_alloc_list, link);\n\tql_move(&prof_recent_alloc_list, &temp_list);\n\tprof_recent_alloc_count += dump_count;\n\tprof_recent_alloc_restore_locked(tsd, &temp_list);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_alloc_mtx);\n\n\tbuf_writer_terminate(tsd_tsdn(tsd), &buf_writer);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_recent_dump_mtx);\n\n\tprof_recent_alloc_async_cleanup(tsd, &temp_list);\n}\n#undef PROF_RECENT_PRINT_BUFSIZE\n\nbool\nprof_recent_init() {\n\tcassert(config_prof);\n\tprof_recent_alloc_max_init();\n\n\tif (malloc_mutex_init(&prof_recent_alloc_mtx, \"prof_recent_alloc\",\n\t WITNESS_RANK_PROF_RECENT_ALLOC, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tif (malloc_mutex_init(&prof_recent_dump_mtx, \"prof_recent_dump\",\n\t WITNESS_RANK_PROF_RECENT_DUMP, malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\tql_new(&prof_recent_alloc_list);\n\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/prof_stats.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/prof_stats.h\"\n\nbool opt_prof_stats = false;\nmalloc_mutex_t prof_stats_mtx;\nstatic prof_stats_t prof_stats_live[PROF_SC_NSIZES];\nstatic prof_stats_t prof_stats_accum[PROF_SC_NSIZES];\n\nstatic void\nprof_stats_enter(tsd_t *tsd, szind_t ind) {\n\tassert(opt_prof && opt_prof_stats);\n\tassert(ind < SC_NSIZES);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_stats_mtx);\n}\n\nstatic void\nprof_stats_leave(tsd_t *tsd) {\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_stats_mtx);\n}\n\nvoid\nprof_stats_inc(tsd_t *tsd, szind_t ind, size_t size) {\n\tcassert(config_prof);\n\tprof_stats_enter(tsd, ind);\n\tprof_stats_live[ind].req_sum += size;\n\tprof_stats_live[ind].count++;\n\tprof_stats_accum[ind].req_sum += size;\n\tprof_stats_accum[ind].count++;\n\tprof_stats_leave(tsd);\n}\n\nvoid\nprof_stats_dec(tsd_t *tsd, szind_t ind, size_t size) {\n\tcassert(config_prof);\n\tprof_stats_enter(tsd, ind);\n\tprof_stats_live[ind].req_sum -= size;\n\tprof_stats_live[ind].count--;\n\tprof_stats_leave(tsd);\n}\n\nvoid\nprof_stats_get_live(tsd_t *tsd, szind_t ind, prof_stats_t *stats) {\n\tcassert(config_prof);\n\tprof_stats_enter(tsd, ind);\n\tmemcpy(stats, &prof_stats_live[ind], sizeof(prof_stats_t));\n\tprof_stats_leave(tsd);\n}\n\nvoid\nprof_stats_get_accum(tsd_t *tsd, szind_t ind, prof_stats_t *stats) {\n\tcassert(config_prof);\n\tprof_stats_enter(tsd, ind);\n\tmemcpy(stats, &prof_stats_accum[ind], sizeof(prof_stats_t));\n\tprof_stats_leave(tsd);\n}\n" }, { "path": "deps/jemalloc/src/prof_sys.c", "content": "#define JEMALLOC_PROF_SYS_C_\n#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/buf_writer.h\"\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n\n#ifdef JEMALLOC_PROF_LIBUNWIND\n#define UNW_LOCAL_ONLY\n#include \n#endif\n\n#ifdef JEMALLOC_PROF_LIBGCC\n/*\n * We have a circular dependency -- jemalloc_internal.h tells us if we should\n * use libgcc's unwinding functionality, but after we've included that, we've\n * already hooked _Unwind_Backtrace. We'll temporarily disable hooking.\n */\n#undef _Unwind_Backtrace\n#include \n#define _Unwind_Backtrace JEMALLOC_TEST_HOOK(_Unwind_Backtrace, test_hooks_libc_hook)\n#endif\n\n/******************************************************************************/\n\nmalloc_mutex_t prof_dump_filename_mtx;\n\nbool prof_do_mock = false;\n\nstatic uint64_t prof_dump_seq;\nstatic uint64_t prof_dump_iseq;\nstatic uint64_t prof_dump_mseq;\nstatic uint64_t prof_dump_useq;\n\nstatic char *prof_prefix = NULL;\n\n/* The fallback allocator profiling functionality will use. */\nbase_t *prof_base;\n\nvoid\nbt_init(prof_bt_t *bt, void **vec) {\n\tcassert(config_prof);\n\n\tbt->vec = vec;\n\tbt->len = 0;\n}\n\n#ifdef JEMALLOC_PROF_LIBUNWIND\nstatic void\nprof_backtrace_impl(void **vec, unsigned *len, unsigned max_len) {\n\tint nframes;\n\n\tcassert(config_prof);\n\tassert(*len == 0);\n\tassert(vec != NULL);\n\tassert(max_len == PROF_BT_MAX);\n\n\tnframes = unw_backtrace(vec, PROF_BT_MAX);\n\tif (nframes <= 0) {\n\t\treturn;\n\t}\n\t*len = nframes;\n}\n#elif (defined(JEMALLOC_PROF_LIBGCC))\nstatic _Unwind_Reason_Code\nprof_unwind_init_callback(struct _Unwind_Context *context, void *arg) {\n\tcassert(config_prof);\n\n\treturn _URC_NO_REASON;\n}\n\nstatic _Unwind_Reason_Code\nprof_unwind_callback(struct _Unwind_Context *context, void *arg) {\n\tprof_unwind_data_t *data = (prof_unwind_data_t *)arg;\n\tvoid *ip;\n\n\tcassert(config_prof);\n\n\tip = (void *)_Unwind_GetIP(context);\n\tif (ip == NULL) {\n\t\treturn _URC_END_OF_STACK;\n\t}\n\tdata->vec[*data->len] = ip;\n\t(*data->len)++;\n\tif (*data->len == data->max) {\n\t\treturn _URC_END_OF_STACK;\n\t}\n\n\treturn _URC_NO_REASON;\n}\n\nstatic void\nprof_backtrace_impl(void **vec, unsigned *len, unsigned max_len) {\n\tprof_unwind_data_t data = {vec, len, max_len};\n\n\tcassert(config_prof);\n\tassert(vec != NULL);\n\tassert(max_len == PROF_BT_MAX);\n\n\t_Unwind_Backtrace(prof_unwind_callback, &data);\n}\n#elif (defined(JEMALLOC_PROF_GCC))\nstatic void\nprof_backtrace_impl(void **vec, unsigned *len, unsigned max_len) {\n#define BT_FRAME(i)\t\t\t\t\t\t\t\\\n\tif ((i) < max_len) {\t\t\t\t\t\t\\\n\t\tvoid *p;\t\t\t\t\t\t\\\n\t\tif (__builtin_frame_address(i) == 0) {\t\t\t\\\n\t\t\treturn;\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tp = __builtin_return_address(i);\t\t\t\\\n\t\tif (p == NULL) {\t\t\t\t\t\\\n\t\t\treturn;\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tvec[(i)] = p;\t\t\t\t\t\t\\\n\t\t*len = (i) + 1;\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\treturn;\t\t\t\t\t\t\t\\\n\t}\n\n\tcassert(config_prof);\n\tassert(vec != NULL);\n\tassert(max_len == PROF_BT_MAX);\n\n\tBT_FRAME(0)\n\tBT_FRAME(1)\n\tBT_FRAME(2)\n\tBT_FRAME(3)\n\tBT_FRAME(4)\n\tBT_FRAME(5)\n\tBT_FRAME(6)\n\tBT_FRAME(7)\n\tBT_FRAME(8)\n\tBT_FRAME(9)\n\n\tBT_FRAME(10)\n\tBT_FRAME(11)\n\tBT_FRAME(12)\n\tBT_FRAME(13)\n\tBT_FRAME(14)\n\tBT_FRAME(15)\n\tBT_FRAME(16)\n\tBT_FRAME(17)\n\tBT_FRAME(18)\n\tBT_FRAME(19)\n\n\tBT_FRAME(20)\n\tBT_FRAME(21)\n\tBT_FRAME(22)\n\tBT_FRAME(23)\n\tBT_FRAME(24)\n\tBT_FRAME(25)\n\tBT_FRAME(26)\n\tBT_FRAME(27)\n\tBT_FRAME(28)\n\tBT_FRAME(29)\n\n\tBT_FRAME(30)\n\tBT_FRAME(31)\n\tBT_FRAME(32)\n\tBT_FRAME(33)\n\tBT_FRAME(34)\n\tBT_FRAME(35)\n\tBT_FRAME(36)\n\tBT_FRAME(37)\n\tBT_FRAME(38)\n\tBT_FRAME(39)\n\n\tBT_FRAME(40)\n\tBT_FRAME(41)\n\tBT_FRAME(42)\n\tBT_FRAME(43)\n\tBT_FRAME(44)\n\tBT_FRAME(45)\n\tBT_FRAME(46)\n\tBT_FRAME(47)\n\tBT_FRAME(48)\n\tBT_FRAME(49)\n\n\tBT_FRAME(50)\n\tBT_FRAME(51)\n\tBT_FRAME(52)\n\tBT_FRAME(53)\n\tBT_FRAME(54)\n\tBT_FRAME(55)\n\tBT_FRAME(56)\n\tBT_FRAME(57)\n\tBT_FRAME(58)\n\tBT_FRAME(59)\n\n\tBT_FRAME(60)\n\tBT_FRAME(61)\n\tBT_FRAME(62)\n\tBT_FRAME(63)\n\tBT_FRAME(64)\n\tBT_FRAME(65)\n\tBT_FRAME(66)\n\tBT_FRAME(67)\n\tBT_FRAME(68)\n\tBT_FRAME(69)\n\n\tBT_FRAME(70)\n\tBT_FRAME(71)\n\tBT_FRAME(72)\n\tBT_FRAME(73)\n\tBT_FRAME(74)\n\tBT_FRAME(75)\n\tBT_FRAME(76)\n\tBT_FRAME(77)\n\tBT_FRAME(78)\n\tBT_FRAME(79)\n\n\tBT_FRAME(80)\n\tBT_FRAME(81)\n\tBT_FRAME(82)\n\tBT_FRAME(83)\n\tBT_FRAME(84)\n\tBT_FRAME(85)\n\tBT_FRAME(86)\n\tBT_FRAME(87)\n\tBT_FRAME(88)\n\tBT_FRAME(89)\n\n\tBT_FRAME(90)\n\tBT_FRAME(91)\n\tBT_FRAME(92)\n\tBT_FRAME(93)\n\tBT_FRAME(94)\n\tBT_FRAME(95)\n\tBT_FRAME(96)\n\tBT_FRAME(97)\n\tBT_FRAME(98)\n\tBT_FRAME(99)\n\n\tBT_FRAME(100)\n\tBT_FRAME(101)\n\tBT_FRAME(102)\n\tBT_FRAME(103)\n\tBT_FRAME(104)\n\tBT_FRAME(105)\n\tBT_FRAME(106)\n\tBT_FRAME(107)\n\tBT_FRAME(108)\n\tBT_FRAME(109)\n\n\tBT_FRAME(110)\n\tBT_FRAME(111)\n\tBT_FRAME(112)\n\tBT_FRAME(113)\n\tBT_FRAME(114)\n\tBT_FRAME(115)\n\tBT_FRAME(116)\n\tBT_FRAME(117)\n\tBT_FRAME(118)\n\tBT_FRAME(119)\n\n\tBT_FRAME(120)\n\tBT_FRAME(121)\n\tBT_FRAME(122)\n\tBT_FRAME(123)\n\tBT_FRAME(124)\n\tBT_FRAME(125)\n\tBT_FRAME(126)\n\tBT_FRAME(127)\n#undef BT_FRAME\n}\n#else\nstatic void\nprof_backtrace_impl(void **vec, unsigned *len, unsigned max_len) {\n\tcassert(config_prof);\n\tnot_reached();\n}\n#endif\n\nvoid\nprof_backtrace(tsd_t *tsd, prof_bt_t *bt) {\n\tcassert(config_prof);\n\tprof_backtrace_hook_t prof_backtrace_hook = prof_backtrace_hook_get();\n\tassert(prof_backtrace_hook != NULL);\n\n\tpre_reentrancy(tsd, NULL);\n\tprof_backtrace_hook(bt->vec, &bt->len, PROF_BT_MAX);\n\tpost_reentrancy(tsd);\n}\n\nvoid\nprof_hooks_init() {\n\tprof_backtrace_hook_set(&prof_backtrace_impl);\n\tprof_dump_hook_set(NULL);\n}\n\nvoid\nprof_unwind_init() {\n#ifdef JEMALLOC_PROF_LIBGCC\n\t/*\n\t * Cause the backtracing machinery to allocate its internal\n\t * state before enabling profiling.\n\t */\n\t_Unwind_Backtrace(prof_unwind_init_callback, NULL);\n#endif\n}\n\nstatic int\nprof_sys_thread_name_read_impl(char *buf, size_t limit) {\n#if defined(JEMALLOC_HAVE_PTHREAD_GETNAME_NP)\n\treturn pthread_getname_np(pthread_self(), buf, limit);\n#elif defined(JEMALLOC_HAVE_PTHREAD_GET_NAME_NP)\n\tpthread_get_name_np(pthread_self(), buf, limit);\n\treturn 0;\n#else\n\treturn ENOSYS;\n#endif\n}\nprof_sys_thread_name_read_t *JET_MUTABLE prof_sys_thread_name_read =\n prof_sys_thread_name_read_impl;\n\nvoid\nprof_sys_thread_name_fetch(tsd_t *tsd) {\n#define THREAD_NAME_MAX_LEN 16\n\tchar buf[THREAD_NAME_MAX_LEN];\n\tif (!prof_sys_thread_name_read(buf, THREAD_NAME_MAX_LEN)) {\n\t\tprof_thread_name_set_impl(tsd, buf);\n\t}\n#undef THREAD_NAME_MAX_LEN\n}\n\nint\nprof_getpid(void) {\n#ifdef _WIN32\n\treturn GetCurrentProcessId();\n#else\n\treturn getpid();\n#endif\n}\n\n/*\n * This buffer is rather large for stack allocation, so use a single buffer for\n * all profile dumps; protected by prof_dump_mtx.\n */\nstatic char prof_dump_buf[PROF_DUMP_BUFSIZE];\n\ntypedef struct prof_dump_arg_s prof_dump_arg_t;\nstruct prof_dump_arg_s {\n\t/*\n\t * Whether error should be handled locally: if true, then we print out\n\t * error message as well as abort (if opt_abort is true) when an error\n\t * occurred, and we also report the error back to the caller in the end;\n\t * if false, then we only report the error back to the caller in the\n\t * end.\n\t */\n\tconst bool handle_error_locally;\n\t/*\n\t * Whether there has been an error in the dumping process, which could\n\t * have happened either in file opening or in file writing. When an\n\t * error has already occurred, we will stop further writing to the file.\n\t */\n\tbool error;\n\t/* File descriptor of the dump file. */\n\tint prof_dump_fd;\n};\n\nstatic void\nprof_dump_check_possible_error(prof_dump_arg_t *arg, bool err_cond,\n const char *format, ...) {\n\tassert(!arg->error);\n\tif (!err_cond) {\n\t\treturn;\n\t}\n\n\targ->error = true;\n\tif (!arg->handle_error_locally) {\n\t\treturn;\n\t}\n\n\tva_list ap;\n\tchar buf[PROF_PRINTF_BUFSIZE];\n\tva_start(ap, format);\n\tmalloc_vsnprintf(buf, sizeof(buf), format, ap);\n\tva_end(ap);\n\tmalloc_write(buf);\n\n\tif (opt_abort) {\n\t\tabort();\n\t}\n}\n\nstatic int\nprof_dump_open_file_impl(const char *filename, int mode) {\n\treturn creat(filename, mode);\n}\nprof_dump_open_file_t *JET_MUTABLE prof_dump_open_file =\n prof_dump_open_file_impl;\n\nstatic void\nprof_dump_open(prof_dump_arg_t *arg, const char *filename) {\n\targ->prof_dump_fd = prof_dump_open_file(filename, 0644);\n\tprof_dump_check_possible_error(arg, arg->prof_dump_fd == -1,\n\t \": failed to open \\\"%s\\\"\\n\", filename);\n}\n\nprof_dump_write_file_t *JET_MUTABLE prof_dump_write_file = malloc_write_fd;\n\nstatic void\nprof_dump_flush(void *opaque, const char *s) {\n\tcassert(config_prof);\n\tprof_dump_arg_t *arg = (prof_dump_arg_t *)opaque;\n\tif (!arg->error) {\n\t\tssize_t err = prof_dump_write_file(arg->prof_dump_fd, s,\n\t\t strlen(s));\n\t\tprof_dump_check_possible_error(arg, err == -1,\n\t\t \": failed to write during heap profile flush\\n\");\n\t}\n}\n\nstatic void\nprof_dump_close(prof_dump_arg_t *arg) {\n\tif (arg->prof_dump_fd != -1) {\n\t\tclose(arg->prof_dump_fd);\n\t}\n}\n\n#ifndef _WIN32\nJEMALLOC_FORMAT_PRINTF(1, 2)\nstatic int\nprof_open_maps_internal(const char *format, ...) {\n\tint mfd;\n\tva_list ap;\n\tchar filename[PATH_MAX + 1];\n\n\tva_start(ap, format);\n\tmalloc_vsnprintf(filename, sizeof(filename), format, ap);\n\tva_end(ap);\n\n#if defined(O_CLOEXEC)\n\tmfd = open(filename, O_RDONLY | O_CLOEXEC);\n#else\n\tmfd = open(filename, O_RDONLY);\n\tif (mfd != -1) {\n\t\tfcntl(mfd, F_SETFD, fcntl(mfd, F_GETFD) | FD_CLOEXEC);\n\t}\n#endif\n\n\treturn mfd;\n}\n#endif\n\nstatic int\nprof_dump_open_maps_impl() {\n\tint mfd;\n\n\tcassert(config_prof);\n#if defined(__FreeBSD__) || defined(__DragonFly__)\n\tmfd = prof_open_maps_internal(\"/proc/curproc/map\");\n#elif defined(_WIN32)\n\tmfd = -1; // Not implemented\n#else\n\tint pid = prof_getpid();\n\n\tmfd = prof_open_maps_internal(\"/proc/%d/task/%d/maps\", pid, pid);\n\tif (mfd == -1) {\n\t\tmfd = prof_open_maps_internal(\"/proc/%d/maps\", pid);\n\t}\n#endif\n\treturn mfd;\n}\nprof_dump_open_maps_t *JET_MUTABLE prof_dump_open_maps =\n prof_dump_open_maps_impl;\n\nstatic ssize_t\nprof_dump_read_maps_cb(void *read_cbopaque, void *buf, size_t limit) {\n\tint mfd = *(int *)read_cbopaque;\n\tassert(mfd != -1);\n\treturn malloc_read_fd(mfd, buf, limit);\n}\n\nstatic void\nprof_dump_maps(buf_writer_t *buf_writer) {\n\tint mfd = prof_dump_open_maps();\n\tif (mfd == -1) {\n\t\treturn;\n\t}\n\n\tbuf_writer_cb(buf_writer, \"\\nMAPPED_LIBRARIES:\\n\");\n\tbuf_writer_pipe(buf_writer, prof_dump_read_maps_cb, &mfd);\n\tclose(mfd);\n}\n\nstatic bool\nprof_dump(tsd_t *tsd, bool propagate_err, const char *filename,\n bool leakcheck) {\n\tcassert(config_prof);\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\n\tprof_tdata_t * tdata = prof_tdata_get(tsd, true);\n\tif (tdata == NULL) {\n\t\treturn true;\n\t}\n\n\tprof_dump_arg_t arg = {/* handle_error_locally */ !propagate_err,\n\t /* error */ false, /* prof_dump_fd */ -1};\n\n\tpre_reentrancy(tsd, NULL);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_mtx);\n\n\tprof_dump_open(&arg, filename);\n\tbuf_writer_t buf_writer;\n\tbool err = buf_writer_init(tsd_tsdn(tsd), &buf_writer, prof_dump_flush,\n\t &arg, prof_dump_buf, PROF_DUMP_BUFSIZE);\n\tassert(!err);\n\tprof_dump_impl(tsd, buf_writer_cb, &buf_writer, tdata, leakcheck);\n\tprof_dump_maps(&buf_writer);\n\tbuf_writer_terminate(tsd_tsdn(tsd), &buf_writer);\n\tprof_dump_close(&arg);\n\n\tprof_dump_hook_t dump_hook = prof_dump_hook_get();\n\tif (dump_hook != NULL) {\n\t\tdump_hook(filename);\n\t}\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_mtx);\n\tpost_reentrancy(tsd);\n\n\treturn arg.error;\n}\n\n/*\n * If profiling is off, then PROF_DUMP_FILENAME_LEN is 1, so we'll end up\n * calling strncpy with a size of 0, which triggers a -Wstringop-truncation\n * warning (strncpy can never actually be called in this case, since we bail out\n * much earlier when config_prof is false). This function works around the\n * warning to let us leave the warning on.\n */\nstatic inline void\nprof_strncpy(char *UNUSED dest, const char *UNUSED src, size_t UNUSED size) {\n\tcassert(config_prof);\n#ifdef JEMALLOC_PROF\n\tstrncpy(dest, src, size);\n#endif\n}\n\nstatic const char *\nprof_prefix_get(tsdn_t* tsdn) {\n\tmalloc_mutex_assert_owner(tsdn, &prof_dump_filename_mtx);\n\n\treturn prof_prefix == NULL ? opt_prof_prefix : prof_prefix;\n}\n\nstatic bool\nprof_prefix_is_empty(tsdn_t *tsdn) {\n\tmalloc_mutex_lock(tsdn, &prof_dump_filename_mtx);\n\tbool ret = (prof_prefix_get(tsdn)[0] == '\\0');\n\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n\treturn ret;\n}\n\n#define DUMP_FILENAME_BUFSIZE (PATH_MAX + 1)\n#define VSEQ_INVALID UINT64_C(0xffffffffffffffff)\nstatic void\nprof_dump_filename(tsd_t *tsd, char *filename, char v, uint64_t vseq) {\n\tcassert(config_prof);\n\n\tassert(tsd_reentrancy_level_get(tsd) == 0);\n\tconst char *prefix = prof_prefix_get(tsd_tsdn(tsd));\n\n\tif (vseq != VSEQ_INVALID) {\n\t /* \"...v.heap\" */\n\t\tmalloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,\n\t\t \"%s.%d.%\"FMTu64\".%c%\"FMTu64\".heap\", prefix, prof_getpid(),\n\t\t prof_dump_seq, v, vseq);\n\t} else {\n\t /* \"....heap\" */\n\t\tmalloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,\n\t\t \"%s.%d.%\"FMTu64\".%c.heap\", prefix, prof_getpid(),\n\t\t prof_dump_seq, v);\n\t}\n\tprof_dump_seq++;\n}\n\nvoid\nprof_get_default_filename(tsdn_t *tsdn, char *filename, uint64_t ind) {\n\tmalloc_mutex_lock(tsdn, &prof_dump_filename_mtx);\n\tmalloc_snprintf(filename, PROF_DUMP_FILENAME_LEN,\n\t \"%s.%d.%\"FMTu64\".json\", prof_prefix_get(tsdn), prof_getpid(), ind);\n\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n}\n\nvoid\nprof_fdump_impl(tsd_t *tsd) {\n\tchar filename[DUMP_FILENAME_BUFSIZE];\n\n\tassert(!prof_prefix_is_empty(tsd_tsdn(tsd)));\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\tprof_dump_filename(tsd, filename, 'f', VSEQ_INVALID);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\tprof_dump(tsd, false, filename, opt_prof_leak);\n}\n\nbool\nprof_prefix_set(tsdn_t *tsdn, const char *prefix) {\n\tcassert(config_prof);\n\tctl_mtx_assert_held(tsdn);\n\tmalloc_mutex_lock(tsdn, &prof_dump_filename_mtx);\n\tif (prof_prefix == NULL) {\n\t\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n\t\t/* Everything is still guarded by ctl_mtx. */\n\t\tchar *buffer = base_alloc(tsdn, prof_base,\n\t\t PROF_DUMP_FILENAME_LEN, QUANTUM);\n\t\tif (buffer == NULL) {\n\t\t\treturn true;\n\t\t}\n\t\tmalloc_mutex_lock(tsdn, &prof_dump_filename_mtx);\n\t\tprof_prefix = buffer;\n\t}\n\tassert(prof_prefix != NULL);\n\n\tprof_strncpy(prof_prefix, prefix, PROF_DUMP_FILENAME_LEN - 1);\n\tprof_prefix[PROF_DUMP_FILENAME_LEN - 1] = '\\0';\n\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n\n\treturn false;\n}\n\nvoid\nprof_idump_impl(tsd_t *tsd) {\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\tif (prof_prefix_get(tsd_tsdn(tsd))[0] == '\\0') {\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\t\treturn;\n\t}\n\tchar filename[PATH_MAX + 1];\n\tprof_dump_filename(tsd, filename, 'i', prof_dump_iseq);\n\tprof_dump_iseq++;\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\tprof_dump(tsd, false, filename, false);\n}\n\nbool\nprof_mdump_impl(tsd_t *tsd, const char *filename) {\n\tchar filename_buf[DUMP_FILENAME_BUFSIZE];\n\tif (filename == NULL) {\n\t\t/* No filename specified, so automatically generate one. */\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\t\tif (prof_prefix_get(tsd_tsdn(tsd))[0] == '\\0') {\n\t\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\t\t\treturn true;\n\t\t}\n\t\tprof_dump_filename(tsd, filename_buf, 'm', prof_dump_mseq);\n\t\tprof_dump_mseq++;\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_filename_mtx);\n\t\tfilename = filename_buf;\n\t}\n\treturn prof_dump(tsd, true, filename, false);\n}\n\nvoid\nprof_gdump_impl(tsd_t *tsd) {\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\tmalloc_mutex_lock(tsdn, &prof_dump_filename_mtx);\n\tif (prof_prefix_get(tsdn)[0] == '\\0') {\n\t\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n\t\treturn;\n\t}\n\tchar filename[DUMP_FILENAME_BUFSIZE];\n\tprof_dump_filename(tsd, filename, 'u', prof_dump_useq);\n\tprof_dump_useq++;\n\tmalloc_mutex_unlock(tsdn, &prof_dump_filename_mtx);\n\tprof_dump(tsd, false, filename, false);\n}\n" }, { "path": "deps/jemalloc/src/psset.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/psset.h\"\n\n#include \"jemalloc/internal/fb.h\"\n\nvoid\npsset_init(psset_t *psset) {\n\tfor (unsigned i = 0; i < PSSET_NPSIZES; i++) {\n\t\thpdata_age_heap_new(&psset->pageslabs[i]);\n\t}\n\tfb_init(psset->pageslab_bitmap, PSSET_NPSIZES);\n\tmemset(&psset->merged_stats, 0, sizeof(psset->merged_stats));\n\tmemset(&psset->stats, 0, sizeof(psset->stats));\n\thpdata_empty_list_init(&psset->empty);\n\tfor (int i = 0; i < PSSET_NPURGE_LISTS; i++) {\n\t\thpdata_purge_list_init(&psset->to_purge[i]);\n\t}\n\tfb_init(psset->purge_bitmap, PSSET_NPURGE_LISTS);\n\thpdata_hugify_list_init(&psset->to_hugify);\n}\n\nstatic void\npsset_bin_stats_accum(psset_bin_stats_t *dst, psset_bin_stats_t *src) {\n\tdst->npageslabs += src->npageslabs;\n\tdst->nactive += src->nactive;\n\tdst->ndirty += src->ndirty;\n}\n\nvoid\npsset_stats_accum(psset_stats_t *dst, psset_stats_t *src) {\n\tpsset_bin_stats_accum(&dst->full_slabs[0], &src->full_slabs[0]);\n\tpsset_bin_stats_accum(&dst->full_slabs[1], &src->full_slabs[1]);\n\tpsset_bin_stats_accum(&dst->empty_slabs[0], &src->empty_slabs[0]);\n\tpsset_bin_stats_accum(&dst->empty_slabs[1], &src->empty_slabs[1]);\n\tfor (pszind_t i = 0; i < PSSET_NPSIZES; i++) {\n\t\tpsset_bin_stats_accum(&dst->nonfull_slabs[i][0],\n\t\t &src->nonfull_slabs[i][0]);\n\t\tpsset_bin_stats_accum(&dst->nonfull_slabs[i][1],\n\t\t &src->nonfull_slabs[i][1]);\n\t}\n}\n\n/*\n * The stats maintenance strategy is to remove a pageslab's contribution to the\n * stats when we call psset_update_begin, and re-add it (to a potentially new\n * bin) when we call psset_update_end.\n */\nJEMALLOC_ALWAYS_INLINE void\npsset_bin_stats_insert_remove(psset_t *psset, psset_bin_stats_t *binstats,\n hpdata_t *ps, bool insert) {\n\tsize_t mul = insert ? (size_t)1 : (size_t)-1;\n\tsize_t huge_idx = (size_t)hpdata_huge_get(ps);\n\n\tbinstats[huge_idx].npageslabs += mul * 1;\n\tbinstats[huge_idx].nactive += mul * hpdata_nactive_get(ps);\n\tbinstats[huge_idx].ndirty += mul * hpdata_ndirty_get(ps);\n\n\tpsset->merged_stats.npageslabs += mul * 1;\n\tpsset->merged_stats.nactive += mul * hpdata_nactive_get(ps);\n\tpsset->merged_stats.ndirty += mul * hpdata_ndirty_get(ps);\n\n\tif (config_debug) {\n\t\tpsset_bin_stats_t check_stats = {0};\n\t\tfor (size_t huge = 0; huge <= 1; huge++) {\n\t\t\tpsset_bin_stats_accum(&check_stats,\n\t\t\t &psset->stats.full_slabs[huge]);\n\t\t\tpsset_bin_stats_accum(&check_stats,\n\t\t\t &psset->stats.empty_slabs[huge]);\n\t\t\tfor (pszind_t pind = 0; pind < PSSET_NPSIZES; pind++) {\n\t\t\t\tpsset_bin_stats_accum(&check_stats,\n\t\t\t\t &psset->stats.nonfull_slabs[pind][huge]);\n\t\t\t}\n\t\t}\n\t\tassert(psset->merged_stats.npageslabs\n\t\t == check_stats.npageslabs);\n\t\tassert(psset->merged_stats.nactive == check_stats.nactive);\n\t\tassert(psset->merged_stats.ndirty == check_stats.ndirty);\n\t}\n}\n\nstatic void\npsset_bin_stats_insert(psset_t *psset, psset_bin_stats_t *binstats,\n hpdata_t *ps) {\n\tpsset_bin_stats_insert_remove(psset, binstats, ps, true);\n}\n\nstatic void\npsset_bin_stats_remove(psset_t *psset, psset_bin_stats_t *binstats,\n hpdata_t *ps) {\n\tpsset_bin_stats_insert_remove(psset, binstats, ps, false);\n}\n\nstatic void\npsset_hpdata_heap_remove(psset_t *psset, pszind_t pind, hpdata_t *ps) {\n\thpdata_age_heap_remove(&psset->pageslabs[pind], ps);\n\tif (hpdata_age_heap_empty(&psset->pageslabs[pind])) {\n\t\tfb_unset(psset->pageslab_bitmap, PSSET_NPSIZES, (size_t)pind);\n\t}\n}\n\nstatic void\npsset_hpdata_heap_insert(psset_t *psset, pszind_t pind, hpdata_t *ps) {\n\tif (hpdata_age_heap_empty(&psset->pageslabs[pind])) {\n\t\tfb_set(psset->pageslab_bitmap, PSSET_NPSIZES, (size_t)pind);\n\t}\n\thpdata_age_heap_insert(&psset->pageslabs[pind], ps);\n}\n\nstatic void\npsset_stats_insert(psset_t* psset, hpdata_t *ps) {\n\tif (hpdata_empty(ps)) {\n\t\tpsset_bin_stats_insert(psset, psset->stats.empty_slabs, ps);\n\t} else if (hpdata_full(ps)) {\n\t\tpsset_bin_stats_insert(psset, psset->stats.full_slabs, ps);\n\t} else {\n\t\tsize_t longest_free_range = hpdata_longest_free_range_get(ps);\n\n\t\tpszind_t pind = sz_psz2ind(sz_psz_quantize_floor(\n\t\t longest_free_range << LG_PAGE));\n\t\tassert(pind < PSSET_NPSIZES);\n\n\t\tpsset_bin_stats_insert(psset, psset->stats.nonfull_slabs[pind],\n\t\t ps);\n\t}\n}\n\nstatic void\npsset_stats_remove(psset_t *psset, hpdata_t *ps) {\n\tif (hpdata_empty(ps)) {\n\t\tpsset_bin_stats_remove(psset, psset->stats.empty_slabs, ps);\n\t} else if (hpdata_full(ps)) {\n\t\tpsset_bin_stats_remove(psset, psset->stats.full_slabs, ps);\n\t} else {\n\t\tsize_t longest_free_range = hpdata_longest_free_range_get(ps);\n\n\t\tpszind_t pind = sz_psz2ind(sz_psz_quantize_floor(\n\t\t longest_free_range << LG_PAGE));\n\t\tassert(pind < PSSET_NPSIZES);\n\n\t\tpsset_bin_stats_remove(psset, psset->stats.nonfull_slabs[pind],\n\t\t ps);\n\t}\n}\n\n/*\n * Put ps into some container so that it can be found during future allocation\n * requests.\n */\nstatic void\npsset_alloc_container_insert(psset_t *psset, hpdata_t *ps) {\n\tassert(!hpdata_in_psset_alloc_container_get(ps));\n\thpdata_in_psset_alloc_container_set(ps, true);\n\tif (hpdata_empty(ps)) {\n\t\t/*\n\t\t * This prepend, paired with popping the head in psset_fit,\n\t\t * means we implement LIFO ordering for the empty slabs set,\n\t\t * which seems reasonable.\n\t\t */\n\t\thpdata_empty_list_prepend(&psset->empty, ps);\n\t} else if (hpdata_full(ps)) {\n\t\t/*\n\t\t * We don't need to keep track of the full slabs; we're never\n\t\t * going to return them from a psset_pick_alloc call.\n\t\t */\n\t} else {\n\t\tsize_t longest_free_range = hpdata_longest_free_range_get(ps);\n\n\t\tpszind_t pind = sz_psz2ind(sz_psz_quantize_floor(\n\t\t longest_free_range << LG_PAGE));\n\t\tassert(pind < PSSET_NPSIZES);\n\n\t\tpsset_hpdata_heap_insert(psset, pind, ps);\n\t}\n}\n\n/* Remove ps from those collections. */\nstatic void\npsset_alloc_container_remove(psset_t *psset, hpdata_t *ps) {\n\tassert(hpdata_in_psset_alloc_container_get(ps));\n\thpdata_in_psset_alloc_container_set(ps, false);\n\n\tif (hpdata_empty(ps)) {\n\t\thpdata_empty_list_remove(&psset->empty, ps);\n\t} else if (hpdata_full(ps)) {\n\t\t/* Same as above -- do nothing in this case. */\n\t} else {\n\t\tsize_t longest_free_range = hpdata_longest_free_range_get(ps);\n\n\t\tpszind_t pind = sz_psz2ind(sz_psz_quantize_floor(\n\t\t longest_free_range << LG_PAGE));\n\t\tassert(pind < PSSET_NPSIZES);\n\n\t\tpsset_hpdata_heap_remove(psset, pind, ps);\n\t}\n}\n\nstatic size_t\npsset_purge_list_ind(hpdata_t *ps) {\n\tsize_t ndirty = hpdata_ndirty_get(ps);\n\t/* Shouldn't have something with no dirty pages purgeable. */\n\tassert(ndirty > 0);\n\t/*\n\t * Higher indices correspond to lists we'd like to purge earlier; make\n\t * the two highest indices correspond to empty lists, which we attempt\n\t * to purge before purging any non-empty list. This has two advantages:\n\t * - Empty page slabs are the least likely to get reused (we'll only\n\t * pick them for an allocation if we have no other choice).\n\t * - Empty page slabs can purge every dirty page they contain in a\n\t * single call, which is not usually the case.\n\t *\n\t * We purge hugeified empty slabs before nonhugeified ones, on the basis\n\t * that they are fully dirty, while nonhugified slabs might not be, so\n\t * we free up more pages more easily.\n\t */\n\tif (hpdata_nactive_get(ps) == 0) {\n\t\tif (hpdata_huge_get(ps)) {\n\t\t\treturn PSSET_NPURGE_LISTS - 1;\n\t\t} else {\n\t\t\treturn PSSET_NPURGE_LISTS - 2;\n\t\t}\n\t}\n\n\tpszind_t pind = sz_psz2ind(sz_psz_quantize_floor(ndirty << LG_PAGE));\n\t/*\n\t * For non-empty slabs, we may reuse them again. Prefer purging\n\t * non-hugeified slabs before hugeified ones then, among pages of\n\t * similar dirtiness. We still get some benefit from the hugification.\n\t */\n\treturn (size_t)pind * 2 + (hpdata_huge_get(ps) ? 0 : 1);\n}\n\nstatic void\npsset_maybe_remove_purge_list(psset_t *psset, hpdata_t *ps) {\n\t/*\n\t * Remove the hpdata from its purge list (if it's in one). Even if it's\n\t * going to stay in the same one, by appending it during\n\t * psset_update_end, we move it to the end of its queue, so that we\n\t * purge LRU within a given dirtiness bucket.\n\t */\n\tif (hpdata_purge_allowed_get(ps)) {\n\t\tsize_t ind = psset_purge_list_ind(ps);\n\t\thpdata_purge_list_t *purge_list = &psset->to_purge[ind];\n\t\thpdata_purge_list_remove(purge_list, ps);\n\t\tif (hpdata_purge_list_empty(purge_list)) {\n\t\t\tfb_unset(psset->purge_bitmap, PSSET_NPURGE_LISTS, ind);\n\t\t}\n\t}\n}\n\nstatic void\npsset_maybe_insert_purge_list(psset_t *psset, hpdata_t *ps) {\n\tif (hpdata_purge_allowed_get(ps)) {\n\t\tsize_t ind = psset_purge_list_ind(ps);\n\t\thpdata_purge_list_t *purge_list = &psset->to_purge[ind];\n\t\tif (hpdata_purge_list_empty(purge_list)) {\n\t\t\tfb_set(psset->purge_bitmap, PSSET_NPURGE_LISTS, ind);\n\t\t}\n\t\thpdata_purge_list_append(purge_list, ps);\n\t}\n\n}\n\nvoid\npsset_update_begin(psset_t *psset, hpdata_t *ps) {\n\thpdata_assert_consistent(ps);\n\tassert(hpdata_in_psset_get(ps));\n\thpdata_updating_set(ps, true);\n\tpsset_stats_remove(psset, ps);\n\tif (hpdata_in_psset_alloc_container_get(ps)) {\n\t\t/*\n\t\t * Some metadata updates can break alloc container invariants\n\t\t * (e.g. the longest free range determines the hpdata_heap_t the\n\t\t * pageslab lives in).\n\t\t */\n\t\tassert(hpdata_alloc_allowed_get(ps));\n\t\tpsset_alloc_container_remove(psset, ps);\n\t}\n\tpsset_maybe_remove_purge_list(psset, ps);\n\t/*\n\t * We don't update presence in the hugify list; we try to keep it FIFO,\n\t * even in the presence of other metadata updates. We'll update\n\t * presence at the end of the metadata update if necessary.\n\t */\n}\n\nvoid\npsset_update_end(psset_t *psset, hpdata_t *ps) {\n\tassert(hpdata_in_psset_get(ps));\n\thpdata_updating_set(ps, false);\n\tpsset_stats_insert(psset, ps);\n\n\t/*\n\t * The update begin should have removed ps from whatever alloc container\n\t * it was in.\n\t */\n\tassert(!hpdata_in_psset_alloc_container_get(ps));\n\tif (hpdata_alloc_allowed_get(ps)) {\n\t\tpsset_alloc_container_insert(psset, ps);\n\t}\n\tpsset_maybe_insert_purge_list(psset, ps);\n\n\tif (hpdata_hugify_allowed_get(ps)\n\t && !hpdata_in_psset_hugify_container_get(ps)) {\n\t\thpdata_in_psset_hugify_container_set(ps, true);\n\t\thpdata_hugify_list_append(&psset->to_hugify, ps);\n\t} else if (!hpdata_hugify_allowed_get(ps)\n\t && hpdata_in_psset_hugify_container_get(ps)) {\n\t\thpdata_in_psset_hugify_container_set(ps, false);\n\t\thpdata_hugify_list_remove(&psset->to_hugify, ps);\n\t}\n\thpdata_assert_consistent(ps);\n}\n\nhpdata_t *\npsset_pick_alloc(psset_t *psset, size_t size) {\n\tassert((size & PAGE_MASK) == 0);\n\tassert(size <= HUGEPAGE);\n\n\tpszind_t min_pind = sz_psz2ind(sz_psz_quantize_ceil(size));\n\tpszind_t pind = (pszind_t)fb_ffs(psset->pageslab_bitmap, PSSET_NPSIZES,\n\t (size_t)min_pind);\n\tif (pind == PSSET_NPSIZES) {\n\t\treturn hpdata_empty_list_first(&psset->empty);\n\t}\n\thpdata_t *ps = hpdata_age_heap_first(&psset->pageslabs[pind]);\n\tif (ps == NULL) {\n\t\treturn NULL;\n\t}\n\n\thpdata_assert_consistent(ps);\n\n\treturn ps;\n}\n\nhpdata_t *\npsset_pick_purge(psset_t *psset) {\n\tssize_t ind_ssz = fb_fls(psset->purge_bitmap, PSSET_NPURGE_LISTS,\n\t PSSET_NPURGE_LISTS - 1);\n\tif (ind_ssz < 0) {\n\t\treturn NULL;\n\t}\n\tpszind_t ind = (pszind_t)ind_ssz;\n\tassert(ind < PSSET_NPURGE_LISTS);\n\thpdata_t *ps = hpdata_purge_list_first(&psset->to_purge[ind]);\n\tassert(ps != NULL);\n\treturn ps;\n}\n\nhpdata_t *\npsset_pick_hugify(psset_t *psset) {\n\treturn hpdata_hugify_list_first(&psset->to_hugify);\n}\n\nvoid\npsset_insert(psset_t *psset, hpdata_t *ps) {\n\thpdata_in_psset_set(ps, true);\n\n\tpsset_stats_insert(psset, ps);\n\tif (hpdata_alloc_allowed_get(ps)) {\n\t\tpsset_alloc_container_insert(psset, ps);\n\t}\n\tpsset_maybe_insert_purge_list(psset, ps);\n\n\tif (hpdata_hugify_allowed_get(ps)) {\n\t\thpdata_in_psset_hugify_container_set(ps, true);\n\t\thpdata_hugify_list_append(&psset->to_hugify, ps);\n\t}\n}\n\nvoid\npsset_remove(psset_t *psset, hpdata_t *ps) {\n\thpdata_in_psset_set(ps, false);\n\n\tpsset_stats_remove(psset, ps);\n\tif (hpdata_in_psset_alloc_container_get(ps)) {\n\t\tpsset_alloc_container_remove(psset, ps);\n\t}\n\tpsset_maybe_remove_purge_list(psset, ps);\n\tif (hpdata_in_psset_hugify_container_get(ps)) {\n\t\thpdata_in_psset_hugify_container_set(ps, false);\n\t\thpdata_hugify_list_remove(&psset->to_hugify, ps);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/rtree.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/mutex.h\"\n\n/*\n * Only the most significant bits of keys passed to rtree_{read,write}() are\n * used.\n */\nbool\nrtree_new(rtree_t *rtree, base_t *base, bool zeroed) {\n#ifdef JEMALLOC_JET\n\tif (!zeroed) {\n\t\tmemset(rtree, 0, sizeof(rtree_t)); /* Clear root. */\n\t}\n#else\n\tassert(zeroed);\n#endif\n\trtree->base = base;\n\n\tif (malloc_mutex_init(&rtree->init_lock, \"rtree\", WITNESS_RANK_RTREE,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nstatic rtree_node_elm_t *\nrtree_node_alloc(tsdn_t *tsdn, rtree_t *rtree, size_t nelms) {\n\treturn (rtree_node_elm_t *)base_alloc(tsdn, rtree->base,\n\t nelms * sizeof(rtree_node_elm_t), CACHELINE);\n}\n\nstatic rtree_leaf_elm_t *\nrtree_leaf_alloc(tsdn_t *tsdn, rtree_t *rtree, size_t nelms) {\n\treturn (rtree_leaf_elm_t *)base_alloc(tsdn, rtree->base,\n\t nelms * sizeof(rtree_leaf_elm_t), CACHELINE);\n}\n\nstatic rtree_node_elm_t *\nrtree_node_init(tsdn_t *tsdn, rtree_t *rtree, unsigned level,\n atomic_p_t *elmp) {\n\tmalloc_mutex_lock(tsdn, &rtree->init_lock);\n\t/*\n\t * If *elmp is non-null, then it was initialized with the init lock\n\t * held, so we can get by with 'relaxed' here.\n\t */\n\trtree_node_elm_t *node = atomic_load_p(elmp, ATOMIC_RELAXED);\n\tif (node == NULL) {\n\t\tnode = rtree_node_alloc(tsdn, rtree, ZU(1) <<\n\t\t rtree_levels[level].bits);\n\t\tif (node == NULL) {\n\t\t\tmalloc_mutex_unlock(tsdn, &rtree->init_lock);\n\t\t\treturn NULL;\n\t\t}\n\t\t/*\n\t\t * Even though we hold the lock, a later reader might not; we\n\t\t * need release semantics.\n\t\t */\n\t\tatomic_store_p(elmp, node, ATOMIC_RELEASE);\n\t}\n\tmalloc_mutex_unlock(tsdn, &rtree->init_lock);\n\n\treturn node;\n}\n\nstatic rtree_leaf_elm_t *\nrtree_leaf_init(tsdn_t *tsdn, rtree_t *rtree, atomic_p_t *elmp) {\n\tmalloc_mutex_lock(tsdn, &rtree->init_lock);\n\t/*\n\t * If *elmp is non-null, then it was initialized with the init lock\n\t * held, so we can get by with 'relaxed' here.\n\t */\n\trtree_leaf_elm_t *leaf = atomic_load_p(elmp, ATOMIC_RELAXED);\n\tif (leaf == NULL) {\n\t\tleaf = rtree_leaf_alloc(tsdn, rtree, ZU(1) <<\n\t\t rtree_levels[RTREE_HEIGHT-1].bits);\n\t\tif (leaf == NULL) {\n\t\t\tmalloc_mutex_unlock(tsdn, &rtree->init_lock);\n\t\t\treturn NULL;\n\t\t}\n\t\t/*\n\t\t * Even though we hold the lock, a later reader might not; we\n\t\t * need release semantics.\n\t\t */\n\t\tatomic_store_p(elmp, leaf, ATOMIC_RELEASE);\n\t}\n\tmalloc_mutex_unlock(tsdn, &rtree->init_lock);\n\n\treturn leaf;\n}\n\nstatic bool\nrtree_node_valid(rtree_node_elm_t *node) {\n\treturn ((uintptr_t)node != (uintptr_t)0);\n}\n\nstatic bool\nrtree_leaf_valid(rtree_leaf_elm_t *leaf) {\n\treturn ((uintptr_t)leaf != (uintptr_t)0);\n}\n\nstatic rtree_node_elm_t *\nrtree_child_node_tryread(rtree_node_elm_t *elm, bool dependent) {\n\trtree_node_elm_t *node;\n\n\tif (dependent) {\n\t\tnode = (rtree_node_elm_t *)atomic_load_p(&elm->child,\n\t\t ATOMIC_RELAXED);\n\t} else {\n\t\tnode = (rtree_node_elm_t *)atomic_load_p(&elm->child,\n\t\t ATOMIC_ACQUIRE);\n\t}\n\n\tassert(!dependent || node != NULL);\n\treturn node;\n}\n\nstatic rtree_node_elm_t *\nrtree_child_node_read(tsdn_t *tsdn, rtree_t *rtree, rtree_node_elm_t *elm,\n unsigned level, bool dependent) {\n\trtree_node_elm_t *node;\n\n\tnode = rtree_child_node_tryread(elm, dependent);\n\tif (!dependent && unlikely(!rtree_node_valid(node))) {\n\t\tnode = rtree_node_init(tsdn, rtree, level + 1, &elm->child);\n\t}\n\tassert(!dependent || node != NULL);\n\treturn node;\n}\n\nstatic rtree_leaf_elm_t *\nrtree_child_leaf_tryread(rtree_node_elm_t *elm, bool dependent) {\n\trtree_leaf_elm_t *leaf;\n\n\tif (dependent) {\n\t\tleaf = (rtree_leaf_elm_t *)atomic_load_p(&elm->child,\n\t\t ATOMIC_RELAXED);\n\t} else {\n\t\tleaf = (rtree_leaf_elm_t *)atomic_load_p(&elm->child,\n\t\t ATOMIC_ACQUIRE);\n\t}\n\n\tassert(!dependent || leaf != NULL);\n\treturn leaf;\n}\n\nstatic rtree_leaf_elm_t *\nrtree_child_leaf_read(tsdn_t *tsdn, rtree_t *rtree, rtree_node_elm_t *elm,\n unsigned level, bool dependent) {\n\trtree_leaf_elm_t *leaf;\n\n\tleaf = rtree_child_leaf_tryread(elm, dependent);\n\tif (!dependent && unlikely(!rtree_leaf_valid(leaf))) {\n\t\tleaf = rtree_leaf_init(tsdn, rtree, &elm->child);\n\t}\n\tassert(!dependent || leaf != NULL);\n\treturn leaf;\n}\n\nrtree_leaf_elm_t *\nrtree_leaf_elm_lookup_hard(tsdn_t *tsdn, rtree_t *rtree, rtree_ctx_t *rtree_ctx,\n uintptr_t key, bool dependent, bool init_missing) {\n\trtree_node_elm_t *node;\n\trtree_leaf_elm_t *leaf;\n#if RTREE_HEIGHT > 1\n\tnode = rtree->root;\n#else\n\tleaf = rtree->root;\n#endif\n\n\tif (config_debug) {\n\t\tuintptr_t leafkey = rtree_leafkey(key);\n\t\tfor (unsigned i = 0; i < RTREE_CTX_NCACHE; i++) {\n\t\t\tassert(rtree_ctx->cache[i].leafkey != leafkey);\n\t\t}\n\t\tfor (unsigned i = 0; i < RTREE_CTX_NCACHE_L2; i++) {\n\t\t\tassert(rtree_ctx->l2_cache[i].leafkey != leafkey);\n\t\t}\n\t}\n\n#define RTREE_GET_CHILD(level) {\t\t\t\t\t\\\n\t\tassert(level < RTREE_HEIGHT-1);\t\t\t\t\\\n\t\tif (level != 0 && !dependent &&\t\t\t\t\\\n\t\t unlikely(!rtree_node_valid(node))) {\t\t\\\n\t\t\treturn NULL;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tuintptr_t subkey = rtree_subkey(key, level);\t\t\\\n\t\tif (level + 2 < RTREE_HEIGHT) {\t\t\t\t\\\n\t\t\tnode = init_missing ?\t\t\t\t\\\n\t\t\t rtree_child_node_read(tsdn, rtree,\t\t\\\n\t\t\t &node[subkey], level, dependent) :\t\t\\\n\t\t\t rtree_child_node_tryread(&node[subkey],\t\\\n\t\t\t dependent);\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tleaf = init_missing ?\t\t\t\t\\\n\t\t\t rtree_child_leaf_read(tsdn, rtree,\t\t\\\n\t\t\t &node[subkey], level, dependent) :\t\t\\\n\t\t\t rtree_child_leaf_tryread(&node[subkey],\t\\\n\t\t\t dependent);\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\n\t/*\n\t * Cache replacement upon hard lookup (i.e. L1 & L2 rtree cache miss):\n\t * (1) evict last entry in L2 cache; (2) move the collision slot from L1\n\t * cache down to L2; and 3) fill L1.\n\t */\n#define RTREE_GET_LEAF(level) {\t\t\t\t\t\t\\\n\t\tassert(level == RTREE_HEIGHT-1);\t\t\t\\\n\t\tif (!dependent && unlikely(!rtree_leaf_valid(leaf))) {\t\\\n\t\t\treturn NULL;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tif (RTREE_CTX_NCACHE_L2 > 1) {\t\t\t\t\\\n\t\t\tmemmove(&rtree_ctx->l2_cache[1],\t\t\\\n\t\t\t &rtree_ctx->l2_cache[0],\t\t\t\\\n\t\t\t sizeof(rtree_ctx_cache_elm_t) *\t\t\\\n\t\t\t (RTREE_CTX_NCACHE_L2 - 1));\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tsize_t slot = rtree_cache_direct_map(key);\t\t\\\n\t\trtree_ctx->l2_cache[0].leafkey =\t\t\t\\\n\t\t rtree_ctx->cache[slot].leafkey;\t\t\t\\\n\t\trtree_ctx->l2_cache[0].leaf =\t\t\t\t\\\n\t\t rtree_ctx->cache[slot].leaf;\t\t\t\\\n\t\tuintptr_t leafkey = rtree_leafkey(key);\t\t\t\\\n\t\trtree_ctx->cache[slot].leafkey = leafkey;\t\t\\\n\t\trtree_ctx->cache[slot].leaf = leaf;\t\t\t\\\n\t\tuintptr_t subkey = rtree_subkey(key, level);\t\t\\\n\t\treturn &leaf[subkey];\t\t\t\t\t\\\n\t}\n\tif (RTREE_HEIGHT > 1) {\n\t\tRTREE_GET_CHILD(0)\n\t}\n\tif (RTREE_HEIGHT > 2) {\n\t\tRTREE_GET_CHILD(1)\n\t}\n\tif (RTREE_HEIGHT > 3) {\n\t\tfor (unsigned i = 2; i < RTREE_HEIGHT-1; i++) {\n\t\t\tRTREE_GET_CHILD(i)\n\t\t}\n\t}\n\tRTREE_GET_LEAF(RTREE_HEIGHT-1)\n#undef RTREE_GET_CHILD\n#undef RTREE_GET_LEAF\n\tnot_reached();\n}\n\nvoid\nrtree_ctx_data_init(rtree_ctx_t *ctx) {\n\tfor (unsigned i = 0; i < RTREE_CTX_NCACHE; i++) {\n\t\trtree_ctx_cache_elm_t *cache = &ctx->cache[i];\n\t\tcache->leafkey = RTREE_LEAFKEY_INVALID;\n\t\tcache->leaf = NULL;\n\t}\n\tfor (unsigned i = 0; i < RTREE_CTX_NCACHE_L2; i++) {\n\t\trtree_ctx_cache_elm_t *cache = &ctx->l2_cache[i];\n\t\tcache->leafkey = RTREE_LEAFKEY_INVALID;\n\t\tcache->leaf = NULL;\n\t}\n}\n" }, { "path": "deps/jemalloc/src/safety_check.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\nstatic safety_check_abort_hook_t safety_check_abort;\n\nvoid safety_check_fail_sized_dealloc(bool current_dealloc, const void *ptr,\n size_t true_size, size_t input_size) {\n\tchar *src = current_dealloc ? \"the current pointer being freed\" :\n\t \"in thread cache, possibly from previous deallocations\";\n\n\tsafety_check_fail(\": size mismatch detected (true size %zu \"\n\t \"vs input size %zu), likely caused by application sized \"\n\t \"deallocation bugs (source address: %p, %s). Suggest building with \"\n\t \"--enable-debug or address sanitizer for debugging. Abort.\\n\",\n\t true_size, input_size, ptr, src);\n}\n\nvoid safety_check_set_abort(safety_check_abort_hook_t abort_fn) {\n\tsafety_check_abort = abort_fn;\n}\n\nvoid safety_check_fail(const char *format, ...) {\n\tchar buf[MALLOC_PRINTF_BUFSIZE];\n\n\tva_list ap;\n\tva_start(ap, format);\n\tmalloc_vsnprintf(buf, MALLOC_PRINTF_BUFSIZE, format, ap);\n\tva_end(ap);\n\n\tif (safety_check_abort == NULL) {\n\t\tmalloc_write(buf);\n\t\tabort();\n\t} else {\n\t\tsafety_check_abort(buf);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/san.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/tsd.h\"\n\n/* The sanitizer options. */\nsize_t opt_san_guard_large = SAN_GUARD_LARGE_EVERY_N_EXTENTS_DEFAULT;\nsize_t opt_san_guard_small = SAN_GUARD_SMALL_EVERY_N_EXTENTS_DEFAULT;\n\n/* Aligned (-1 is off) ptrs will be junked & stashed on dealloc. */\nssize_t opt_lg_san_uaf_align = SAN_LG_UAF_ALIGN_DEFAULT;\n\n/*\n * Initialized in san_init(). When disabled, the mask is set to (uintptr_t)-1\n * to always fail the nonfast_align check.\n */\nuintptr_t san_cache_bin_nonfast_mask = SAN_CACHE_BIN_NONFAST_MASK_DEFAULT;\n\nstatic inline void\nsan_find_guarded_addr(edata_t *edata, uintptr_t *guard1, uintptr_t *guard2,\n uintptr_t *addr, size_t size, bool left, bool right) {\n\tassert(!edata_guarded_get(edata));\n\tassert(size % PAGE == 0);\n\t*addr = (uintptr_t)edata_base_get(edata);\n\tif (left) {\n\t\t*guard1 = *addr;\n\t\t*addr += SAN_PAGE_GUARD;\n\t} else {\n\t\t*guard1 = 0;\n\t}\n\n\tif (right) {\n\t\t*guard2 = *addr + size;\n\t} else {\n\t\t*guard2 = 0;\n\t}\n}\n\nstatic inline void\nsan_find_unguarded_addr(edata_t *edata, uintptr_t *guard1, uintptr_t *guard2,\n uintptr_t *addr, size_t size, bool left, bool right) {\n\tassert(edata_guarded_get(edata));\n\tassert(size % PAGE == 0);\n\t*addr = (uintptr_t)edata_base_get(edata);\n\tif (right) {\n\t\t*guard2 = *addr + size;\n\t} else {\n\t\t*guard2 = 0;\n\t}\n\n\tif (left) {\n\t\t*guard1 = *addr - SAN_PAGE_GUARD;\n\t\tassert(*guard1 != 0);\n\t\t*addr = *guard1;\n\t} else {\n\t\t*guard1 = 0;\n\t}\n}\n\nvoid\nsan_guard_pages(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata, emap_t *emap,\n bool left, bool right, bool remap) {\n\tassert(left || right);\n\tif (remap) {\n\t\temap_deregister_boundary(tsdn, emap, edata);\n\t}\n\n\tsize_t size_with_guards = edata_size_get(edata);\n\tsize_t usize = (left && right)\n\t ? san_two_side_unguarded_sz(size_with_guards)\n\t : san_one_side_unguarded_sz(size_with_guards);\n\n\tuintptr_t guard1, guard2, addr;\n\tsan_find_guarded_addr(edata, &guard1, &guard2, &addr, usize, left,\n\t right);\n\n\tassert(edata_state_get(edata) == extent_state_active);\n\tehooks_guard(tsdn, ehooks, (void *)guard1, (void *)guard2);\n\n\t/* Update the guarded addr and usable size of the edata. */\n\tedata_size_set(edata, usize);\n\tedata_addr_set(edata, (void *)addr);\n\tedata_guarded_set(edata, true);\n\n\tif (remap) {\n\t\temap_register_boundary(tsdn, emap, edata, SC_NSIZES,\n\t\t /* slab */ false);\n\t}\n}\n\nstatic void\nsan_unguard_pages_impl(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap, bool left, bool right, bool remap) {\n\tassert(left || right);\n\t/* Remove the inner boundary which no longer exists. */\n\tif (remap) {\n\t\tassert(edata_state_get(edata) == extent_state_active);\n\t\temap_deregister_boundary(tsdn, emap, edata);\n\t} else {\n\t\tassert(edata_state_get(edata) == extent_state_retained);\n\t}\n\n\tsize_t size = edata_size_get(edata);\n\tsize_t size_with_guards = (left && right)\n\t ? san_two_side_guarded_sz(size)\n\t : san_one_side_guarded_sz(size);\n\n\tuintptr_t guard1, guard2, addr;\n\tsan_find_unguarded_addr(edata, &guard1, &guard2, &addr, size, left,\n\t right);\n\n\tehooks_unguard(tsdn, ehooks, (void *)guard1, (void *)guard2);\n\n\t/* Update the true addr and usable size of the edata. */\n\tedata_size_set(edata, size_with_guards);\n\tedata_addr_set(edata, (void *)addr);\n\tedata_guarded_set(edata, false);\n\n\t/*\n\t * Then re-register the outer boundary including the guards, if\n\t * requested.\n\t */\n\tif (remap) {\n\t\temap_register_boundary(tsdn, emap, edata, SC_NSIZES,\n\t\t /* slab */ false);\n\t}\n}\n\nvoid\nsan_unguard_pages(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap, bool left, bool right) {\n\tsan_unguard_pages_impl(tsdn, ehooks, edata, emap, left, right,\n\t /* remap */ true);\n}\n\nvoid\nsan_unguard_pages_pre_destroy(tsdn_t *tsdn, ehooks_t *ehooks, edata_t *edata,\n emap_t *emap) {\n\temap_assert_not_mapped(tsdn, emap, edata);\n\t/*\n\t * We don't want to touch the emap of about to be destroyed extents, as\n\t * they have been unmapped upon eviction from the retained ecache. Also,\n\t * we unguard the extents to the right, because retained extents only\n\t * own their right guard page per san_bump_alloc's logic.\n\t */\n\t san_unguard_pages_impl(tsdn, ehooks, edata, emap, /* left */ false,\n\t /* right */ true, /* remap */ false);\n}\n\nstatic bool\nsan_stashed_corrupted(void *ptr, size_t size) {\n\tif (san_junk_ptr_should_slow()) {\n\t\tfor (size_t i = 0; i < size; i++) {\n\t\t\tif (((char *)ptr)[i] != (char)uaf_detect_junk) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\tvoid *first, *mid, *last;\n\tsan_junk_ptr_locations(ptr, size, &first, &mid, &last);\n\tif (*(uintptr_t *)first != uaf_detect_junk ||\n\t *(uintptr_t *)mid != uaf_detect_junk ||\n\t *(uintptr_t *)last != uaf_detect_junk) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nvoid\nsan_check_stashed_ptrs(void **ptrs, size_t nstashed, size_t usize) {\n\t/*\n\t * Verify that the junked-filled & stashed pointers remain unchanged, to\n\t * detect write-after-free.\n\t */\n\tfor (size_t n = 0; n < nstashed; n++) {\n\t\tvoid *stashed = ptrs[n];\n\t\tassert(stashed != NULL);\n\t\tassert(cache_bin_nonfast_aligned(stashed));\n\t\tif (unlikely(san_stashed_corrupted(stashed, usize))) {\n\t\t\tsafety_check_fail(\": Write-after-free \"\n\t\t\t \"detected on deallocated pointer %p (size %zu).\\n\",\n\t\t\t stashed, usize);\n\t\t}\n\t}\n}\n\nvoid\ntsd_san_init(tsd_t *tsd) {\n\t*tsd_san_extents_until_guard_smallp_get(tsd) = opt_san_guard_small;\n\t*tsd_san_extents_until_guard_largep_get(tsd) = opt_san_guard_large;\n}\n\nvoid\nsan_init(ssize_t lg_san_uaf_align) {\n\tassert(lg_san_uaf_align == -1 || lg_san_uaf_align >= LG_PAGE);\n\tif (lg_san_uaf_align == -1) {\n\t\tsan_cache_bin_nonfast_mask = (uintptr_t)-1;\n\t\treturn;\n\t}\n\n\tsan_cache_bin_nonfast_mask = ((uintptr_t)1 << lg_san_uaf_align) - 1;\n}\n" }, { "path": "deps/jemalloc/src/san_bump.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/san_bump.h\"\n#include \"jemalloc/internal/pac.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/ehooks.h\"\n#include \"jemalloc/internal/edata_cache.h\"\n\nstatic bool\nsan_bump_grow_locked(tsdn_t *tsdn, san_bump_alloc_t *sba, pac_t *pac,\n ehooks_t *ehooks, size_t size);\n\nedata_t *\nsan_bump_alloc(tsdn_t *tsdn, san_bump_alloc_t* sba, pac_t *pac,\n ehooks_t *ehooks, size_t size, bool zero) {\n\tassert(san_bump_enabled());\n\n\tedata_t* to_destroy;\n\tsize_t guarded_size = san_one_side_guarded_sz(size);\n\n\tmalloc_mutex_lock(tsdn, &sba->mtx);\n\n\tif (sba->curr_reg == NULL ||\n\t edata_size_get(sba->curr_reg) < guarded_size) {\n\t\t/*\n\t\t * If the current region can't accommodate the allocation,\n\t\t * try replacing it with a larger one and destroy current if the\n\t\t * replacement succeeds.\n\t\t */\n\t\tto_destroy = sba->curr_reg;\n\t\tbool err = san_bump_grow_locked(tsdn, sba, pac, ehooks,\n\t\t guarded_size);\n\t\tif (err) {\n\t\t\tgoto label_err;\n\t\t}\n\t} else {\n\t\tto_destroy = NULL;\n\t}\n\tassert(guarded_size <= edata_size_get(sba->curr_reg));\n\tsize_t trail_size = edata_size_get(sba->curr_reg) - guarded_size;\n\n\tedata_t* edata;\n\tif (trail_size != 0) {\n\t\tedata_t* curr_reg_trail = extent_split_wrapper(tsdn, pac,\n\t\t ehooks, sba->curr_reg, guarded_size, trail_size,\n\t\t /* holding_core_locks */ true);\n\t\tif (curr_reg_trail == NULL) {\n\t\t\tgoto label_err;\n\t\t}\n\t\tedata = sba->curr_reg;\n\t\tsba->curr_reg = curr_reg_trail;\n\t} else {\n\t\tedata = sba->curr_reg;\n\t\tsba->curr_reg = NULL;\n\t}\n\n\tmalloc_mutex_unlock(tsdn, &sba->mtx);\n\n\tassert(!edata_guarded_get(edata));\n\tassert(sba->curr_reg == NULL || !edata_guarded_get(sba->curr_reg));\n\tassert(to_destroy == NULL || !edata_guarded_get(to_destroy));\n\n\tif (to_destroy != NULL) {\n\t\textent_destroy_wrapper(tsdn, pac, ehooks, to_destroy);\n\t}\n\n\tsan_guard_pages(tsdn, ehooks, edata, pac->emap, /* left */ false,\n\t /* right */ true, /* remap */ true);\n\n\tif (extent_commit_zero(tsdn, ehooks, edata, /* commit */ true, zero,\n\t /* growing_retained */ false)) {\n\t\textent_record(tsdn, pac, ehooks, &pac->ecache_retained,\n\t\t edata);\n\t\treturn NULL;\n\t}\n\n\tif (config_prof) {\n\t\textent_gdump_add(tsdn, edata);\n\t}\n\n\treturn edata;\nlabel_err:\n\tmalloc_mutex_unlock(tsdn, &sba->mtx);\n\treturn NULL;\n}\n\nstatic bool\nsan_bump_grow_locked(tsdn_t *tsdn, san_bump_alloc_t *sba, pac_t *pac,\n ehooks_t *ehooks, size_t size) {\n\tmalloc_mutex_assert_owner(tsdn, &sba->mtx);\n\n\tbool committed = false, zeroed = false;\n\tsize_t alloc_size = size > SBA_RETAINED_ALLOC_SIZE ? size :\n\t SBA_RETAINED_ALLOC_SIZE;\n\tassert((alloc_size & PAGE_MASK) == 0);\n\tsba->curr_reg = extent_alloc_wrapper(tsdn, pac, ehooks, NULL,\n\t alloc_size, PAGE, zeroed, &committed,\n\t /* growing_retained */ true);\n\tif (sba->curr_reg == NULL) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n" }, { "path": "deps/jemalloc/src/sc.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/bit_util.h\"\n#include \"jemalloc/internal/bitmap.h\"\n#include \"jemalloc/internal/pages.h\"\n#include \"jemalloc/internal/sc.h\"\n\n/*\n * This module computes the size classes used to satisfy allocations. The logic\n * here was ported more or less line-by-line from a shell script, and because of\n * that is not the most idiomatic C. Eventually we should fix this, but for now\n * at least the damage is compartmentalized to this file.\n */\n\nsize_t\nreg_size_compute(int lg_base, int lg_delta, int ndelta) {\n\treturn (ZU(1) << lg_base) + (ZU(ndelta) << lg_delta);\n}\n\n/* Returns the number of pages in the slab. */\nstatic int\nslab_size(int lg_page, int lg_base, int lg_delta, int ndelta) {\n\tsize_t page = (ZU(1) << lg_page);\n\tsize_t reg_size = reg_size_compute(lg_base, lg_delta, ndelta);\n\n\tsize_t try_slab_size = page;\n\tsize_t try_nregs = try_slab_size / reg_size;\n\tsize_t perfect_slab_size = 0;\n\tbool perfect = false;\n\t/*\n\t * This loop continues until we find the least common multiple of the\n\t * page size and size class size. Size classes are all of the form\n\t * base + ndelta * delta == (ndelta + base/ndelta) * delta, which is\n\t * (ndelta + ngroup) * delta. The way we choose slabbing strategies\n\t * means that delta is at most the page size and ndelta < ngroup. So\n\t * the loop executes for at most 2 * ngroup - 1 iterations, which is\n\t * also the bound on the number of pages in a slab chosen by default.\n\t * With the current default settings, this is at most 7.\n\t */\n\twhile (!perfect) {\n\t\tperfect_slab_size = try_slab_size;\n\t\tsize_t perfect_nregs = try_nregs;\n\t\ttry_slab_size += page;\n\t\ttry_nregs = try_slab_size / reg_size;\n\t\tif (perfect_slab_size == perfect_nregs * reg_size) {\n\t\t\tperfect = true;\n\t\t}\n\t}\n\treturn (int)(perfect_slab_size / page);\n}\n\nstatic void\nsize_class(\n /* Output. */\n sc_t *sc,\n /* Configuration decisions. */\n int lg_max_lookup, int lg_page, int lg_ngroup,\n /* Inputs specific to the size class. */\n int index, int lg_base, int lg_delta, int ndelta) {\n\tsc->index = index;\n\tsc->lg_base = lg_base;\n\tsc->lg_delta = lg_delta;\n\tsc->ndelta = ndelta;\n\tsize_t size = reg_size_compute(lg_base, lg_delta, ndelta);\n\tsc->psz = (size % (ZU(1) << lg_page) == 0);\n\tif (index == 0) {\n\t\tassert(!sc->psz);\n\t}\n\tif (size < (ZU(1) << (lg_page + lg_ngroup))) {\n\t\tsc->bin = true;\n\t\tsc->pgs = slab_size(lg_page, lg_base, lg_delta, ndelta);\n\t} else {\n\t\tsc->bin = false;\n\t\tsc->pgs = 0;\n\t}\n\tif (size <= (ZU(1) << lg_max_lookup)) {\n\t\tsc->lg_delta_lookup = lg_delta;\n\t} else {\n\t\tsc->lg_delta_lookup = 0;\n\t}\n}\n\nstatic void\nsize_classes(\n /* Output. */\n sc_data_t *sc_data,\n /* Determined by the system. */\n size_t lg_ptr_size, int lg_quantum,\n /* Configuration decisions. */\n int lg_tiny_min, int lg_max_lookup, int lg_page, int lg_ngroup) {\n\tint ptr_bits = (1 << lg_ptr_size) * 8;\n\tint ngroup = (1 << lg_ngroup);\n\tint ntiny = 0;\n\tint nlbins = 0;\n\tint lg_tiny_maxclass = (unsigned)-1;\n\tint nbins = 0;\n\tint npsizes = 0;\n\n\tint index = 0;\n\n\tint ndelta = 0;\n\tint lg_base = lg_tiny_min;\n\tint lg_delta = lg_base;\n\n\t/* Outputs that we update as we go. */\n\tsize_t lookup_maxclass = 0;\n\tsize_t small_maxclass = 0;\n\tint lg_large_minclass = 0;\n\tsize_t large_maxclass = 0;\n\n\t/* Tiny size classes. */\n\twhile (lg_base < lg_quantum) {\n\t\tsc_t *sc = &sc_data->sc[index];\n\t\tsize_class(sc, lg_max_lookup, lg_page, lg_ngroup, index,\n\t\t lg_base, lg_delta, ndelta);\n\t\tif (sc->lg_delta_lookup != 0) {\n\t\t\tnlbins = index + 1;\n\t\t}\n\t\tif (sc->psz) {\n\t\t\tnpsizes++;\n\t\t}\n\t\tif (sc->bin) {\n\t\t\tnbins++;\n\t\t}\n\t\tntiny++;\n\t\t/* Final written value is correct. */\n\t\tlg_tiny_maxclass = lg_base;\n\t\tindex++;\n\t\tlg_delta = lg_base;\n\t\tlg_base++;\n\t}\n\n\t/* First non-tiny (pseudo) group. */\n\tif (ntiny != 0) {\n\t\tsc_t *sc = &sc_data->sc[index];\n\t\t/*\n\t\t * See the note in sc.h; the first non-tiny size class has an\n\t\t * unusual encoding.\n\t\t */\n\t\tlg_base--;\n\t\tndelta = 1;\n\t\tsize_class(sc, lg_max_lookup, lg_page, lg_ngroup, index,\n\t\t lg_base, lg_delta, ndelta);\n\t\tindex++;\n\t\tlg_base++;\n\t\tlg_delta++;\n\t\tif (sc->psz) {\n\t\t\tnpsizes++;\n\t\t}\n\t\tif (sc->bin) {\n\t\t\tnbins++;\n\t\t}\n\t}\n\twhile (ndelta < ngroup) {\n\t\tsc_t *sc = &sc_data->sc[index];\n\t\tsize_class(sc, lg_max_lookup, lg_page, lg_ngroup, index,\n\t\t lg_base, lg_delta, ndelta);\n\t\tindex++;\n\t\tndelta++;\n\t\tif (sc->psz) {\n\t\t\tnpsizes++;\n\t\t}\n\t\tif (sc->bin) {\n\t\t\tnbins++;\n\t\t}\n\t}\n\n\t/* All remaining groups. */\n\tlg_base = lg_base + lg_ngroup;\n\twhile (lg_base < ptr_bits - 1) {\n\t\tndelta = 1;\n\t\tint ndelta_limit;\n\t\tif (lg_base == ptr_bits - 2) {\n\t\t\tndelta_limit = ngroup - 1;\n\t\t} else {\n\t\t\tndelta_limit = ngroup;\n\t\t}\n\t\twhile (ndelta <= ndelta_limit) {\n\t\t\tsc_t *sc = &sc_data->sc[index];\n\t\t\tsize_class(sc, lg_max_lookup, lg_page, lg_ngroup, index,\n\t\t\t lg_base, lg_delta, ndelta);\n\t\t\tif (sc->lg_delta_lookup != 0) {\n\t\t\t\tnlbins = index + 1;\n\t\t\t\t/* Final written value is correct. */\n\t\t\t\tlookup_maxclass = (ZU(1) << lg_base)\n\t\t\t\t + (ZU(ndelta) << lg_delta);\n\t\t\t}\n\t\t\tif (sc->psz) {\n\t\t\t\tnpsizes++;\n\t\t\t}\n\t\t\tif (sc->bin) {\n\t\t\t\tnbins++;\n\t\t\t\t/* Final written value is correct. */\n\t\t\t\tsmall_maxclass = (ZU(1) << lg_base)\n\t\t\t\t + (ZU(ndelta) << lg_delta);\n\t\t\t\tif (lg_ngroup > 0) {\n\t\t\t\t\tlg_large_minclass = lg_base + 1;\n\t\t\t\t} else {\n\t\t\t\t\tlg_large_minclass = lg_base + 2;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlarge_maxclass = (ZU(1) << lg_base)\n\t\t\t + (ZU(ndelta) << lg_delta);\n\t\t\tindex++;\n\t\t\tndelta++;\n\t\t}\n\t\tlg_base++;\n\t\tlg_delta++;\n\t}\n\t/* Additional outputs. */\n\tint nsizes = index;\n\tunsigned lg_ceil_nsizes = lg_ceil(nsizes);\n\n\t/* Fill in the output data. */\n\tsc_data->ntiny = ntiny;\n\tsc_data->nlbins = nlbins;\n\tsc_data->nbins = nbins;\n\tsc_data->nsizes = nsizes;\n\tsc_data->lg_ceil_nsizes = lg_ceil_nsizes;\n\tsc_data->npsizes = npsizes;\n\tsc_data->lg_tiny_maxclass = lg_tiny_maxclass;\n\tsc_data->lookup_maxclass = lookup_maxclass;\n\tsc_data->small_maxclass = small_maxclass;\n\tsc_data->lg_large_minclass = lg_large_minclass;\n\tsc_data->large_minclass = (ZU(1) << lg_large_minclass);\n\tsc_data->large_maxclass = large_maxclass;\n\n\t/*\n\t * We compute these values in two ways:\n\t * - Incrementally, as above.\n\t * - In macros, in sc.h.\n\t * The computation is easier when done incrementally, but putting it in\n\t * a constant makes it available to the fast paths without having to\n\t * touch the extra global cacheline. We assert, however, that the two\n\t * computations are equivalent.\n\t */\n\tassert(sc_data->npsizes == SC_NPSIZES);\n\tassert(sc_data->lg_tiny_maxclass == SC_LG_TINY_MAXCLASS);\n\tassert(sc_data->small_maxclass == SC_SMALL_MAXCLASS);\n\tassert(sc_data->large_minclass == SC_LARGE_MINCLASS);\n\tassert(sc_data->lg_large_minclass == SC_LG_LARGE_MINCLASS);\n\tassert(sc_data->large_maxclass == SC_LARGE_MAXCLASS);\n\n\t/*\n\t * In the allocation fastpath, we want to assume that we can\n\t * unconditionally subtract the requested allocation size from\n\t * a ssize_t, and detect passing through 0 correctly. This\n\t * results in optimal generated code. For this to work, the\n\t * maximum allocation size must be less than SSIZE_MAX.\n\t */\n\tassert(SC_LARGE_MAXCLASS < SSIZE_MAX);\n}\n\nvoid\nsc_data_init(sc_data_t *sc_data) {\n\tsize_classes(sc_data, LG_SIZEOF_PTR, LG_QUANTUM, SC_LG_TINY_MIN,\n\t SC_LG_MAX_LOOKUP, LG_PAGE, SC_LG_NGROUP);\n\n\tsc_data->initialized = true;\n}\n\nstatic void\nsc_data_update_sc_slab_size(sc_t *sc, size_t reg_size, size_t pgs_guess) {\n\tsize_t min_pgs = reg_size / PAGE;\n\tif (reg_size % PAGE != 0) {\n\t\tmin_pgs++;\n\t}\n\t/*\n\t * BITMAP_MAXBITS is actually determined by putting the smallest\n\t * possible size-class on one page, so this can never be 0.\n\t */\n\tsize_t max_pgs = BITMAP_MAXBITS * reg_size / PAGE;\n\n\tassert(min_pgs <= max_pgs);\n\tassert(min_pgs > 0);\n\tassert(max_pgs >= 1);\n\tif (pgs_guess < min_pgs) {\n\t\tsc->pgs = (int)min_pgs;\n\t} else if (pgs_guess > max_pgs) {\n\t\tsc->pgs = (int)max_pgs;\n\t} else {\n\t\tsc->pgs = (int)pgs_guess;\n\t}\n}\n\nvoid\nsc_data_update_slab_size(sc_data_t *data, size_t begin, size_t end, int pgs) {\n\tassert(data->initialized);\n\tfor (int i = 0; i < data->nsizes; i++) {\n\t\tsc_t *sc = &data->sc[i];\n\t\tif (!sc->bin) {\n\t\t\tbreak;\n\t\t}\n\t\tsize_t reg_size = reg_size_compute(sc->lg_base, sc->lg_delta,\n\t\t sc->ndelta);\n\t\tif (begin <= reg_size && reg_size <= end) {\n\t\t\tsc_data_update_sc_slab_size(sc, reg_size, pgs);\n\t\t}\n\t}\n}\n\nvoid\nsc_boot(sc_data_t *data) {\n\tsc_data_init(data);\n}\n" }, { "path": "deps/jemalloc/src/sec.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/sec.h\"\n\nstatic edata_t *sec_alloc(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t alignment, bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated);\nstatic bool sec_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool zero, bool *deferred_work_generated);\nstatic bool sec_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool *deferred_work_generated);\nstatic void sec_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated);\n\nstatic void\nsec_bin_init(sec_bin_t *bin) {\n\tbin->being_batch_filled = false;\n\tbin->bytes_cur = 0;\n\tedata_list_active_init(&bin->freelist);\n}\n\nbool\nsec_init(tsdn_t *tsdn, sec_t *sec, base_t *base, pai_t *fallback,\n const sec_opts_t *opts) {\n\tassert(opts->max_alloc >= PAGE);\n\n\tsize_t max_alloc = PAGE_FLOOR(opts->max_alloc);\n\tpszind_t npsizes = sz_psz2ind(max_alloc) + 1;\n\n\tsize_t sz_shards = opts->nshards * sizeof(sec_shard_t);\n\tsize_t sz_bins = opts->nshards * (size_t)npsizes * sizeof(sec_bin_t);\n\tsize_t sz_alloc = sz_shards + sz_bins;\n\tvoid *dynalloc = base_alloc(tsdn, base, sz_alloc, CACHELINE);\n\tif (dynalloc == NULL) {\n\t\treturn true;\n\t}\n\tsec_shard_t *shard_cur = (sec_shard_t *)dynalloc;\n\tsec->shards = shard_cur;\n\tsec_bin_t *bin_cur = (sec_bin_t *)&shard_cur[opts->nshards];\n\t/* Just for asserts, below. */\n\tsec_bin_t *bin_start = bin_cur;\n\n\tfor (size_t i = 0; i < opts->nshards; i++) {\n\t\tsec_shard_t *shard = shard_cur;\n\t\tshard_cur++;\n\t\tbool err = malloc_mutex_init(&shard->mtx, \"sec_shard\",\n\t\t WITNESS_RANK_SEC_SHARD, malloc_mutex_rank_exclusive);\n\t\tif (err) {\n\t\t\treturn true;\n\t\t}\n\t\tshard->enabled = true;\n\t\tshard->bins = bin_cur;\n\t\tfor (pszind_t j = 0; j < npsizes; j++) {\n\t\t\tsec_bin_init(&shard->bins[j]);\n\t\t\tbin_cur++;\n\t\t}\n\t\tshard->bytes_cur = 0;\n\t\tshard->to_flush_next = 0;\n\t}\n\t/*\n\t * Should have exactly matched the bin_start to the first unused byte\n\t * after the shards.\n\t */\n\tassert((void *)shard_cur == (void *)bin_start);\n\t/* And the last bin to use up the last bytes of the allocation. */\n\tassert((char *)bin_cur == ((char *)dynalloc + sz_alloc));\n\tsec->fallback = fallback;\n\n\n\tsec->opts = *opts;\n\tsec->npsizes = npsizes;\n\n\t/*\n\t * Initialize these last so that an improper use of an SEC whose\n\t * initialization failed will segfault in an easy-to-spot way.\n\t */\n\tsec->pai.alloc = &sec_alloc;\n\tsec->pai.alloc_batch = &pai_alloc_batch_default;\n\tsec->pai.expand = &sec_expand;\n\tsec->pai.shrink = &sec_shrink;\n\tsec->pai.dalloc = &sec_dalloc;\n\tsec->pai.dalloc_batch = &pai_dalloc_batch_default;\n\n\treturn false;\n}\n\nstatic sec_shard_t *\nsec_shard_pick(tsdn_t *tsdn, sec_t *sec) {\n\t/*\n\t * Eventually, we should implement affinity, tracking source shard using\n\t * the edata_t's newly freed up fields. For now, just randomly\n\t * distribute across all shards.\n\t */\n\tif (tsdn_null(tsdn)) {\n\t\treturn &sec->shards[0];\n\t}\n\ttsd_t *tsd = tsdn_tsd(tsdn);\n\tuint8_t *idxp = tsd_sec_shardp_get(tsd);\n\tif (*idxp == (uint8_t)-1) {\n\t\t/*\n\t\t * First use; initialize using the trick from Daniel Lemire's\n\t\t * \"A fast alternative to the modulo reduction. Use a 64 bit\n\t\t * number to store 32 bits, since we'll deliberately overflow\n\t\t * when we multiply by the number of shards.\n\t\t */\n\t\tuint64_t rand32 = prng_lg_range_u64(tsd_prng_statep_get(tsd), 32);\n\t\tuint32_t idx =\n\t\t (uint32_t)((rand32 * (uint64_t)sec->opts.nshards) >> 32);\n\t\tassert(idx < (uint32_t)sec->opts.nshards);\n\t\t*idxp = (uint8_t)idx;\n\t}\n\treturn &sec->shards[*idxp];\n}\n\n/*\n * Perhaps surprisingly, this can be called on the alloc pathways; if we hit an\n * empty cache, we'll try to fill it, which can push the shard over it's limit.\n */\nstatic void\nsec_flush_some_and_unlock(tsdn_t *tsdn, sec_t *sec, sec_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tedata_list_active_t to_flush;\n\tedata_list_active_init(&to_flush);\n\twhile (shard->bytes_cur > sec->opts.bytes_after_flush) {\n\t\t/* Pick a victim. */\n\t\tsec_bin_t *bin = &shard->bins[shard->to_flush_next];\n\n\t\t/* Update our victim-picking state. */\n\t\tshard->to_flush_next++;\n\t\tif (shard->to_flush_next == sec->npsizes) {\n\t\t\tshard->to_flush_next = 0;\n\t\t}\n\n\t\tassert(shard->bytes_cur >= bin->bytes_cur);\n\t\tif (bin->bytes_cur != 0) {\n\t\t\tshard->bytes_cur -= bin->bytes_cur;\n\t\t\tbin->bytes_cur = 0;\n\t\t\tedata_list_active_concat(&to_flush, &bin->freelist);\n\t\t}\n\t\t/*\n\t\t * Either bin->bytes_cur was 0, in which case we didn't touch\n\t\t * the bin list but it should be empty anyways (or else we\n\t\t * missed a bytes_cur update on a list modification), or it\n\t\t * *was* 0 and we emptied it ourselves. Either way, it should\n\t\t * be empty now.\n\t\t */\n\t\tassert(edata_list_active_empty(&bin->freelist));\n\t}\n\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\tbool deferred_work_generated = false;\n\tpai_dalloc_batch(tsdn, sec->fallback, &to_flush,\n\t &deferred_work_generated);\n}\n\nstatic edata_t *\nsec_shard_alloc_locked(tsdn_t *tsdn, sec_t *sec, sec_shard_t *shard,\n sec_bin_t *bin) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tif (!shard->enabled) {\n\t\treturn NULL;\n\t}\n\tedata_t *edata = edata_list_active_first(&bin->freelist);\n\tif (edata != NULL) {\n\t\tedata_list_active_remove(&bin->freelist, edata);\n\t\tassert(edata_size_get(edata) <= bin->bytes_cur);\n\t\tbin->bytes_cur -= edata_size_get(edata);\n\t\tassert(edata_size_get(edata) <= shard->bytes_cur);\n\t\tshard->bytes_cur -= edata_size_get(edata);\n\t}\n\treturn edata;\n}\n\nstatic edata_t *\nsec_batch_fill_and_alloc(tsdn_t *tsdn, sec_t *sec, sec_shard_t *shard,\n sec_bin_t *bin, size_t size) {\n\tmalloc_mutex_assert_not_owner(tsdn, &shard->mtx);\n\n\tedata_list_active_t result;\n\tedata_list_active_init(&result);\n\tbool deferred_work_generated = false;\n\tsize_t nalloc = pai_alloc_batch(tsdn, sec->fallback, size,\n\t 1 + sec->opts.batch_fill_extra, &result, &deferred_work_generated);\n\n\tedata_t *ret = edata_list_active_first(&result);\n\tif (ret != NULL) {\n\t\tedata_list_active_remove(&result, ret);\n\t}\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tbin->being_batch_filled = false;\n\t/*\n\t * Handle the easy case first: nothing to cache. Note that this can\n\t * only happen in case of OOM, since sec_alloc checks the expected\n\t * number of allocs, and doesn't bother going down the batch_fill\n\t * pathway if there won't be anything left to cache. So to be in this\n\t * code path, we must have asked for > 1 alloc, but only gotten 1 back.\n\t */\n\tif (nalloc <= 1) {\n\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t\treturn ret;\n\t}\n\n\tsize_t new_cached_bytes = (nalloc - 1) * size;\n\n\tedata_list_active_concat(&bin->freelist, &result);\n\tbin->bytes_cur += new_cached_bytes;\n\tshard->bytes_cur += new_cached_bytes;\n\n\tif (shard->bytes_cur > sec->opts.max_bytes) {\n\t\tsec_flush_some_and_unlock(tsdn, sec, shard);\n\t} else {\n\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t}\n\n\treturn ret;\n}\n\nstatic edata_t *\nsec_alloc(tsdn_t *tsdn, pai_t *self, size_t size, size_t alignment, bool zero,\n bool guarded, bool frequent_reuse, bool *deferred_work_generated) {\n\tassert((size & PAGE_MASK) == 0);\n\tassert(!guarded);\n\n\tsec_t *sec = (sec_t *)self;\n\n\tif (zero || alignment > PAGE || sec->opts.nshards == 0\n\t || size > sec->opts.max_alloc) {\n\t\treturn pai_alloc(tsdn, sec->fallback, size, alignment, zero,\n\t\t /* guarded */ false, frequent_reuse,\n\t\t deferred_work_generated);\n\t}\n\tpszind_t pszind = sz_psz2ind(size);\n\tassert(pszind < sec->npsizes);\n\n\tsec_shard_t *shard = sec_shard_pick(tsdn, sec);\n\tsec_bin_t *bin = &shard->bins[pszind];\n\tbool do_batch_fill = false;\n\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tedata_t *edata = sec_shard_alloc_locked(tsdn, sec, shard, bin);\n\tif (edata == NULL) {\n\t\tif (!bin->being_batch_filled\n\t\t && sec->opts.batch_fill_extra > 0) {\n\t\t\tbin->being_batch_filled = true;\n\t\t\tdo_batch_fill = true;\n\t\t}\n\t}\n\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\tif (edata == NULL) {\n\t\tif (do_batch_fill) {\n\t\t\tedata = sec_batch_fill_and_alloc(tsdn, sec, shard, bin,\n\t\t\t size);\n\t\t} else {\n\t\t\tedata = pai_alloc(tsdn, sec->fallback, size, alignment,\n\t\t\t zero, /* guarded */ false, frequent_reuse,\n\t\t\t deferred_work_generated);\n\t\t}\n\t}\n\treturn edata;\n}\n\nstatic bool\nsec_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool zero, bool *deferred_work_generated) {\n\tsec_t *sec = (sec_t *)self;\n\treturn pai_expand(tsdn, sec->fallback, edata, old_size, new_size, zero,\n\t deferred_work_generated);\n}\n\nstatic bool\nsec_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata, size_t old_size,\n size_t new_size, bool *deferred_work_generated) {\n\tsec_t *sec = (sec_t *)self;\n\treturn pai_shrink(tsdn, sec->fallback, edata, old_size, new_size,\n\t deferred_work_generated);\n}\n\nstatic void\nsec_flush_all_locked(tsdn_t *tsdn, sec_t *sec, sec_shard_t *shard) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tshard->bytes_cur = 0;\n\tedata_list_active_t to_flush;\n\tedata_list_active_init(&to_flush);\n\tfor (pszind_t i = 0; i < sec->npsizes; i++) {\n\t\tsec_bin_t *bin = &shard->bins[i];\n\t\tbin->bytes_cur = 0;\n\t\tedata_list_active_concat(&to_flush, &bin->freelist);\n\t}\n\n\t/*\n\t * Ordinarily we would try to avoid doing the batch deallocation while\n\t * holding the shard mutex, but the flush_all pathways only happen when\n\t * we're disabling the HPA or resetting the arena, both of which are\n\t * rare pathways.\n\t */\n\tbool deferred_work_generated = false;\n\tpai_dalloc_batch(tsdn, sec->fallback, &to_flush,\n\t &deferred_work_generated);\n}\n\nstatic void\nsec_shard_dalloc_and_unlock(tsdn_t *tsdn, sec_t *sec, sec_shard_t *shard,\n edata_t *edata) {\n\tmalloc_mutex_assert_owner(tsdn, &shard->mtx);\n\tassert(shard->bytes_cur <= sec->opts.max_bytes);\n\tsize_t size = edata_size_get(edata);\n\tpszind_t pszind = sz_psz2ind(size);\n\tassert(pszind < sec->npsizes);\n\t/*\n\t * Prepending here results in LIFO allocation per bin, which seems\n\t * reasonable.\n\t */\n\tsec_bin_t *bin = &shard->bins[pszind];\n\tedata_list_active_prepend(&bin->freelist, edata);\n\tbin->bytes_cur += size;\n\tshard->bytes_cur += size;\n\tif (shard->bytes_cur > sec->opts.max_bytes) {\n\t\t/*\n\t\t * We've exceeded the shard limit. We make two nods in the\n\t\t * direction of fragmentation avoidance: we flush everything in\n\t\t * the shard, rather than one particular bin, and we hold the\n\t\t * lock while flushing (in case one of the extents we flush is\n\t\t * highly preferred from a fragmentation-avoidance perspective\n\t\t * in the backing allocator). This has the extra advantage of\n\t\t * not requiring advanced cache balancing strategies.\n\t\t */\n\t\tsec_flush_some_and_unlock(tsdn, sec, shard);\n\t\tmalloc_mutex_assert_not_owner(tsdn, &shard->mtx);\n\t} else {\n\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t}\n}\n\nstatic void\nsec_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated) {\n\tsec_t *sec = (sec_t *)self;\n\tif (sec->opts.nshards == 0\n\t || edata_size_get(edata) > sec->opts.max_alloc) {\n\t\tpai_dalloc(tsdn, sec->fallback, edata,\n\t\t deferred_work_generated);\n\t\treturn;\n\t}\n\tsec_shard_t *shard = sec_shard_pick(tsdn, sec);\n\tmalloc_mutex_lock(tsdn, &shard->mtx);\n\tif (shard->enabled) {\n\t\tsec_shard_dalloc_and_unlock(tsdn, sec, shard, edata);\n\t} else {\n\t\tmalloc_mutex_unlock(tsdn, &shard->mtx);\n\t\tpai_dalloc(tsdn, sec->fallback, edata,\n\t\t deferred_work_generated);\n\t}\n}\n\nvoid\nsec_flush(tsdn_t *tsdn, sec_t *sec) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_lock(tsdn, &sec->shards[i].mtx);\n\t\tsec_flush_all_locked(tsdn, sec, &sec->shards[i]);\n\t\tmalloc_mutex_unlock(tsdn, &sec->shards[i].mtx);\n\t}\n}\n\nvoid\nsec_disable(tsdn_t *tsdn, sec_t *sec) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_lock(tsdn, &sec->shards[i].mtx);\n\t\tsec->shards[i].enabled = false;\n\t\tsec_flush_all_locked(tsdn, sec, &sec->shards[i]);\n\t\tmalloc_mutex_unlock(tsdn, &sec->shards[i].mtx);\n\t}\n}\n\nvoid\nsec_stats_merge(tsdn_t *tsdn, sec_t *sec, sec_stats_t *stats) {\n\tsize_t sum = 0;\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\t/*\n\t\t * We could save these lock acquisitions by making bytes_cur\n\t\t * atomic, but stats collection is rare anyways and we expect\n\t\t * the number and type of stats to get more interesting.\n\t\t */\n\t\tmalloc_mutex_lock(tsdn, &sec->shards[i].mtx);\n\t\tsum += sec->shards[i].bytes_cur;\n\t\tmalloc_mutex_unlock(tsdn, &sec->shards[i].mtx);\n\t}\n\tstats->bytes += sum;\n}\n\nvoid\nsec_mutex_stats_read(tsdn_t *tsdn, sec_t *sec,\n mutex_prof_data_t *mutex_prof_data) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_lock(tsdn, &sec->shards[i].mtx);\n\t\tmalloc_mutex_prof_accum(tsdn, mutex_prof_data,\n\t\t &sec->shards[i].mtx);\n\t\tmalloc_mutex_unlock(tsdn, &sec->shards[i].mtx);\n\t}\n}\n\nvoid\nsec_prefork2(tsdn_t *tsdn, sec_t *sec) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_prefork(tsdn, &sec->shards[i].mtx);\n\t}\n}\n\nvoid\nsec_postfork_parent(tsdn_t *tsdn, sec_t *sec) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_postfork_parent(tsdn, &sec->shards[i].mtx);\n\t}\n}\n\nvoid\nsec_postfork_child(tsdn_t *tsdn, sec_t *sec) {\n\tfor (size_t i = 0; i < sec->opts.nshards; i++) {\n\t\tmalloc_mutex_postfork_child(tsdn, &sec->shards[i].mtx);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/stats.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/emitter.h\"\n#include \"jemalloc/internal/fxp.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/mutex_prof.h\"\n#include \"jemalloc/internal/prof_stats.h\"\n\nconst char *global_mutex_names[mutex_prof_num_global_mutexes] = {\n#define OP(mtx) #mtx,\n\tMUTEX_PROF_GLOBAL_MUTEXES\n#undef OP\n};\n\nconst char *arena_mutex_names[mutex_prof_num_arena_mutexes] = {\n#define OP(mtx) #mtx,\n\tMUTEX_PROF_ARENA_MUTEXES\n#undef OP\n};\n\n#define CTL_GET(n, v, t) do {\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\txmallctl(n, (void *)v, &sz, NULL, 0);\t\t\t\t\\\n} while (0)\n\n#define CTL_LEAF_PREPARE(mib, miblen, name) do {\t\t\t\\\n\tassert(miblen < CTL_MAX_DEPTH);\t\t\t\t\t\\\n\tsize_t miblen_new = CTL_MAX_DEPTH;\t\t\t\t\\\n\txmallctlmibnametomib(mib, miblen, name, &miblen_new);\t\t\\\n\tassert(miblen_new > miblen);\t\t\t\t\t\\\n} while (0)\n\n#define CTL_LEAF(mib, miblen, leaf, v, t) do {\t\t\t\\\n\tassert(miblen < CTL_MAX_DEPTH);\t\t\t\t\t\\\n\tsize_t miblen_new = CTL_MAX_DEPTH;\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\txmallctlbymibname(mib, miblen, leaf, &miblen_new, (void *)v,\t\\\n\t &sz, NULL, 0);\t\t\t\t\t\t\\\n\tassert(miblen_new == miblen + 1);\t\t\t\t\\\n} while (0)\n\n#define CTL_M2_GET(n, i, v, t) do {\t\t\t\t\t\\\n\tsize_t mib[CTL_MAX_DEPTH];\t\t\t\t\t\\\n\tsize_t miblen = sizeof(mib) / sizeof(size_t);\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\txmallctlnametomib(n, mib, &miblen);\t\t\t\t\\\n\tmib[2] = (i);\t\t\t\t\t\t\t\\\n\txmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0);\t\t\\\n} while (0)\n\n/******************************************************************************/\n/* Data. */\n\nbool opt_stats_print = false;\nchar opt_stats_print_opts[stats_print_tot_num_options+1] = \"\";\n\nint64_t opt_stats_interval = STATS_INTERVAL_DEFAULT;\nchar opt_stats_interval_opts[stats_print_tot_num_options+1] = \"\";\n\nstatic counter_accum_t stats_interval_accumulated;\n/* Per thread batch accum size for stats_interval. */\nstatic uint64_t stats_interval_accum_batch;\n\n/******************************************************************************/\n\nstatic uint64_t\nrate_per_second(uint64_t value, uint64_t uptime_ns) {\n\tuint64_t billion = 1000000000;\n\tif (uptime_ns == 0 || value == 0) {\n\t\treturn 0;\n\t}\n\tif (uptime_ns < billion) {\n\t\treturn value;\n\t} else {\n\t\tuint64_t uptime_s = uptime_ns / billion;\n\t\treturn value / uptime_s;\n\t}\n}\n\n/* Calculate x.yyy and output a string (takes a fixed sized char array). */\nstatic bool\nget_rate_str(uint64_t dividend, uint64_t divisor, char str[6]) {\n\tif (divisor == 0 || dividend > divisor) {\n\t\t/* The rate is not supposed to be greater than 1. */\n\t\treturn true;\n\t}\n\tif (dividend > 0) {\n\t\tassert(UINT64_MAX / dividend >= 1000);\n\t}\n\n\tunsigned n = (unsigned)((dividend * 1000) / divisor);\n\tif (n < 10) {\n\t\tmalloc_snprintf(str, 6, \"0.00%u\", n);\n\t} else if (n < 100) {\n\t\tmalloc_snprintf(str, 6, \"0.0%u\", n);\n\t} else if (n < 1000) {\n\t\tmalloc_snprintf(str, 6, \"0.%u\", n);\n\t} else {\n\t\tmalloc_snprintf(str, 6, \"1\");\n\t}\n\n\treturn false;\n}\n\nstatic void\nmutex_stats_init_cols(emitter_row_t *row, const char *table_name,\n emitter_col_t *name,\n emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],\n emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {\n\tmutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;\n\tmutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;\n\n\temitter_col_t *col;\n\n\tif (name != NULL) {\n\t\temitter_col_init(name, row);\n\t\tname->justify = emitter_justify_left;\n\t\tname->width = 21;\n\t\tname->type = emitter_type_title;\n\t\tname->str_val = table_name;\n\t}\n\n#define WIDTH_uint32_t 12\n#define WIDTH_uint64_t 16\n#define OP(counter, counter_type, human, derived, base_counter)\t\t\\\n\tcol = &col_##counter_type[k_##counter_type];\t\t\t\\\n\t++k_##counter_type;\t\t\t\t\t\t\\\n\temitter_col_init(col, row);\t\t\t\t\t\\\n\tcol->justify = emitter_justify_right;\t\t\t\t\\\n\tcol->width = derived ? 8 : WIDTH_##counter_type;\t\t\\\n\tcol->type = emitter_type_title;\t\t\t\t\t\\\n\tcol->str_val = human;\n\tMUTEX_PROF_COUNTERS\n#undef OP\n#undef WIDTH_uint32_t\n#undef WIDTH_uint64_t\n\tcol_uint64_t[mutex_counter_total_wait_time_ps].width = 10;\n}\n\nstatic void\nmutex_stats_read_global(size_t mib[], size_t miblen, const char *name,\n emitter_col_t *col_name,\n emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],\n emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],\n uint64_t uptime) {\n\tCTL_LEAF_PREPARE(mib, miblen, name);\n\tsize_t miblen_name = miblen + 1;\n\n\tcol_name->str_val = name;\n\n\temitter_col_t *dst;\n#define EMITTER_TYPE_uint32_t emitter_type_uint32\n#define EMITTER_TYPE_uint64_t emitter_type_uint64\n#define OP(counter, counter_type, human, derived, base_counter)\t\t\\\n\tdst = &col_##counter_type[mutex_counter_##counter];\t\t\\\n\tdst->type = EMITTER_TYPE_##counter_type;\t\t\t\\\n\tif (!derived) {\t\t\t\t\t\t\t\\\n\t\tCTL_LEAF(mib, miblen_name, #counter,\t\t\t\\\n\t\t (counter_type *)&dst->bool_val, counter_type);\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\temitter_col_t *base =\t\t\t\t\t\\\n\t\t &col_##counter_type[mutex_counter_##base_counter];\t\\\n\t\tdst->counter_type##_val =\t\t\t\t\\\n\t\t (counter_type)rate_per_second(\t\t\t\\\n\t\t base->counter_type##_val, uptime);\t\t\t\\\n\t}\n\tMUTEX_PROF_COUNTERS\n#undef OP\n#undef EMITTER_TYPE_uint32_t\n#undef EMITTER_TYPE_uint64_t\n}\n\nstatic void\nmutex_stats_read_arena(size_t mib[], size_t miblen, const char *name,\n emitter_col_t *col_name,\n emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],\n emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],\n uint64_t uptime) {\n\tCTL_LEAF_PREPARE(mib, miblen, name);\n\tsize_t miblen_name = miblen + 1;\n\n\tcol_name->str_val = name;\n\n\temitter_col_t *dst;\n#define EMITTER_TYPE_uint32_t emitter_type_uint32\n#define EMITTER_TYPE_uint64_t emitter_type_uint64\n#define OP(counter, counter_type, human, derived, base_counter)\t\t\\\n\tdst = &col_##counter_type[mutex_counter_##counter];\t\t\\\n\tdst->type = EMITTER_TYPE_##counter_type;\t\t\t\\\n\tif (!derived) {\t\t\t\t\t\t\t\\\n\t\tCTL_LEAF(mib, miblen_name, #counter,\t\t\t\\\n\t\t (counter_type *)&dst->bool_val, counter_type);\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\temitter_col_t *base =\t\t\t\t\t\\\n\t\t &col_##counter_type[mutex_counter_##base_counter];\t\\\n\t\tdst->counter_type##_val =\t\t\t\t\\\n\t\t (counter_type)rate_per_second(\t\t\t\\\n\t\t base->counter_type##_val, uptime);\t\t\t\\\n\t}\n\tMUTEX_PROF_COUNTERS\n#undef OP\n#undef EMITTER_TYPE_uint32_t\n#undef EMITTER_TYPE_uint64_t\n}\n\nstatic void\nmutex_stats_read_arena_bin(size_t mib[], size_t miblen,\n emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],\n emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],\n uint64_t uptime) {\n\tCTL_LEAF_PREPARE(mib, miblen, \"mutex\");\n\tsize_t miblen_mutex = miblen + 1;\n\n\temitter_col_t *dst;\n\n#define EMITTER_TYPE_uint32_t emitter_type_uint32\n#define EMITTER_TYPE_uint64_t emitter_type_uint64\n#define OP(counter, counter_type, human, derived, base_counter)\t\t\\\n\tdst = &col_##counter_type[mutex_counter_##counter];\t\t\\\n\tdst->type = EMITTER_TYPE_##counter_type;\t\t\t\\\n\tif (!derived) {\t\t\t\t\t\t\t\\\n\t\tCTL_LEAF(mib, miblen_mutex, #counter,\t\t\t\\\n\t\t (counter_type *)&dst->bool_val, counter_type);\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\temitter_col_t *base =\t\t\t\t\t\\\n\t\t &col_##counter_type[mutex_counter_##base_counter];\t\\\n\t\tdst->counter_type##_val =\t\t\t\t\\\n\t\t (counter_type)rate_per_second(\t\t\t\\\n\t\t base->counter_type##_val, uptime);\t\t\t\\\n\t}\n\tMUTEX_PROF_COUNTERS\n#undef OP\n#undef EMITTER_TYPE_uint32_t\n#undef EMITTER_TYPE_uint64_t\n}\n\n/* \"row\" can be NULL to avoid emitting in table mode. */\nstatic void\nmutex_stats_emit(emitter_t *emitter, emitter_row_t *row,\n emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],\n emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {\n\tif (row != NULL) {\n\t\temitter_table_row(emitter, row);\n\t}\n\n\tmutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;\n\tmutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;\n\n\temitter_col_t *col;\n\n#define EMITTER_TYPE_uint32_t emitter_type_uint32\n#define EMITTER_TYPE_uint64_t emitter_type_uint64\n#define OP(counter, type, human, derived, base_counter)\t\t\\\n\tif (!derived) { \\\n\t\tcol = &col_##type[k_##type]; \\\n\t\t++k_##type; \\\n\t\temitter_json_kv(emitter, #counter, EMITTER_TYPE_##type, \\\n\t\t (const void *)&col->bool_val); \\\n\t}\n\tMUTEX_PROF_COUNTERS;\n#undef OP\n#undef EMITTER_TYPE_uint32_t\n#undef EMITTER_TYPE_uint64_t\n}\n\n#define COL_DECLARE(column_name)\t\t\t\t\t\\\n\temitter_col_t col_##column_name;\n\n#define COL_INIT(row_name, column_name, left_or_right, col_width, etype)\\\n\temitter_col_init(&col_##column_name, &row_name);\t\t\\\n\tcol_##column_name.justify = emitter_justify_##left_or_right;\t\\\n\tcol_##column_name.width = col_width;\t\t\t\t\\\n\tcol_##column_name.type = emitter_type_##etype;\n\n#define COL(row_name, column_name, left_or_right, col_width, etype)\t\\\n\tCOL_DECLARE(column_name);\t\t\t\t\t\\\n\tCOL_INIT(row_name, column_name, left_or_right, col_width, etype)\n\n#define COL_HDR_DECLARE(column_name)\t\t\t\t\t\\\n\tCOL_DECLARE(column_name);\t\t\t\t\t\\\n\temitter_col_t header_##column_name;\n\n#define COL_HDR_INIT(row_name, column_name, human, left_or_right,\t\\\n\tcol_width, etype)\t\t\t\t\t\t\\\n\tCOL_INIT(row_name, column_name, left_or_right, col_width, etype)\\\n\temitter_col_init(&header_##column_name, &header_##row_name);\t\\\n\theader_##column_name.justify = emitter_justify_##left_or_right;\t\\\n\theader_##column_name.width = col_width;\t\t\t\t\\\n\theader_##column_name.type = emitter_type_title;\t\t\t\\\n\theader_##column_name.str_val = human ? human : #column_name;\n\n#define COL_HDR(row_name, column_name, human, left_or_right, col_width,\t\\\n etype)\t\t\t\t\t\t\t\t\\\n\tCOL_HDR_DECLARE(column_name)\t\t\t\t\t\\\n\tCOL_HDR_INIT(row_name, column_name, human, left_or_right,\t\\\n\t col_width, etype)\n\nJEMALLOC_COLD\nstatic void\nstats_arena_bins_print(emitter_t *emitter, bool mutex, unsigned i,\n uint64_t uptime) {\n\tsize_t page;\n\tbool in_gap, in_gap_prev;\n\tunsigned nbins, j;\n\n\tCTL_GET(\"arenas.page\", &page, size_t);\n\n\tCTL_GET(\"arenas.nbins\", &nbins, unsigned);\n\n\temitter_row_t header_row;\n\temitter_row_init(&header_row);\n\n\temitter_row_t row;\n\temitter_row_init(&row);\n\n\tbool prof_stats_on = config_prof && opt_prof && opt_prof_stats\n\t && i == MALLCTL_ARENAS_ALL;\n\n\tCOL_HDR(row, size, NULL, right, 20, size)\n\tCOL_HDR(row, ind, NULL, right, 4, unsigned)\n\tCOL_HDR(row, allocated, NULL, right, 13, uint64)\n\tCOL_HDR(row, nmalloc, NULL, right, 13, uint64)\n\tCOL_HDR(row, nmalloc_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, ndalloc, NULL, right, 13, uint64)\n\tCOL_HDR(row, ndalloc_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, nrequests, NULL, right, 13, uint64)\n\tCOL_HDR(row, nrequests_ps, \"(#/sec)\", right, 10, uint64)\n\tCOL_HDR_DECLARE(prof_live_requested);\n\tCOL_HDR_DECLARE(prof_live_count);\n\tCOL_HDR_DECLARE(prof_accum_requested);\n\tCOL_HDR_DECLARE(prof_accum_count);\n\tif (prof_stats_on) {\n\t\tCOL_HDR_INIT(row, prof_live_requested, NULL, right, 21, uint64)\n\t\tCOL_HDR_INIT(row, prof_live_count, NULL, right, 17, uint64)\n\t\tCOL_HDR_INIT(row, prof_accum_requested, NULL, right, 21, uint64)\n\t\tCOL_HDR_INIT(row, prof_accum_count, NULL, right, 17, uint64)\n\t}\n\tCOL_HDR(row, nshards, NULL, right, 9, unsigned)\n\tCOL_HDR(row, curregs, NULL, right, 13, size)\n\tCOL_HDR(row, curslabs, NULL, right, 13, size)\n\tCOL_HDR(row, nonfull_slabs, NULL, right, 15, size)\n\tCOL_HDR(row, regs, NULL, right, 5, unsigned)\n\tCOL_HDR(row, pgs, NULL, right, 4, size)\n\t/* To buffer a right- and left-justified column. */\n\tCOL_HDR(row, justify_spacer, NULL, right, 1, title)\n\tCOL_HDR(row, util, NULL, right, 6, title)\n\tCOL_HDR(row, nfills, NULL, right, 13, uint64)\n\tCOL_HDR(row, nfills_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, nflushes, NULL, right, 13, uint64)\n\tCOL_HDR(row, nflushes_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, nslabs, NULL, right, 13, uint64)\n\tCOL_HDR(row, nreslabs, NULL, right, 13, uint64)\n\tCOL_HDR(row, nreslabs_ps, \"(#/sec)\", right, 8, uint64)\n\n\t/* Don't want to actually print the name. */\n\theader_justify_spacer.str_val = \" \";\n\tcol_justify_spacer.str_val = \" \";\n\n\temitter_col_t col_mutex64[mutex_prof_num_uint64_t_counters];\n\temitter_col_t col_mutex32[mutex_prof_num_uint32_t_counters];\n\n\temitter_col_t header_mutex64[mutex_prof_num_uint64_t_counters];\n\temitter_col_t header_mutex32[mutex_prof_num_uint32_t_counters];\n\n\tif (mutex) {\n\t\tmutex_stats_init_cols(&row, NULL, NULL, col_mutex64,\n\t\t col_mutex32);\n\t\tmutex_stats_init_cols(&header_row, NULL, NULL, header_mutex64,\n\t\t header_mutex32);\n\t}\n\n\t/*\n\t * We print a \"bins:\" header as part of the table row; we need to adjust\n\t * the header size column to compensate.\n\t */\n\theader_size.width -=5;\n\temitter_table_printf(emitter, \"bins:\");\n\temitter_table_row(emitter, &header_row);\n\temitter_json_array_kv_begin(emitter, \"bins\");\n\n\tsize_t stats_arenas_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 0, \"stats.arenas\");\n\tstats_arenas_mib[2] = i;\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 3, \"bins\");\n\n\tsize_t arenas_bin_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(arenas_bin_mib, 0, \"arenas.bin\");\n\n\tsize_t prof_stats_mib[CTL_MAX_DEPTH];\n\tif (prof_stats_on) {\n\t\tCTL_LEAF_PREPARE(prof_stats_mib, 0, \"prof.stats.bins\");\n\t}\n\n\tfor (j = 0, in_gap = false; j < nbins; j++) {\n\t\tuint64_t nslabs;\n\t\tsize_t reg_size, slab_size, curregs;\n\t\tsize_t curslabs;\n\t\tsize_t nonfull_slabs;\n\t\tuint32_t nregs, nshards;\n\t\tuint64_t nmalloc, ndalloc, nrequests, nfills, nflushes;\n\t\tuint64_t nreslabs;\n\t\tprof_stats_t prof_live;\n\t\tprof_stats_t prof_accum;\n\n\t\tstats_arenas_mib[4] = j;\n\t\tarenas_bin_mib[2] = j;\n\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nslabs\", &nslabs, uint64_t);\n\n\t\tif (prof_stats_on) {\n\t\t\tprof_stats_mib[3] = j;\n\t\t\tCTL_LEAF(prof_stats_mib, 4, \"live\", &prof_live,\n\t\t\t prof_stats_t);\n\t\t\tCTL_LEAF(prof_stats_mib, 4, \"accum\", &prof_accum,\n\t\t\t prof_stats_t);\n\t\t}\n\n\t\tin_gap_prev = in_gap;\n\t\tif (prof_stats_on) {\n\t\t\tin_gap = (nslabs == 0 && prof_accum.count == 0);\n\t\t} else {\n\t\t\tin_gap = (nslabs == 0);\n\t\t}\n\n\t\tif (in_gap_prev && !in_gap) {\n\t\t\temitter_table_printf(emitter,\n\t\t\t \" ---\\n\");\n\t\t}\n\n\t\tif (in_gap && !emitter_outputs_json(emitter)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tCTL_LEAF(arenas_bin_mib, 3, \"size\", ®_size, size_t);\n\t\tCTL_LEAF(arenas_bin_mib, 3, \"nregs\", &nregs, uint32_t);\n\t\tCTL_LEAF(arenas_bin_mib, 3, \"slab_size\", &slab_size, size_t);\n\t\tCTL_LEAF(arenas_bin_mib, 3, \"nshards\", &nshards, uint32_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nmalloc\", &nmalloc, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"ndalloc\", &ndalloc, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"curregs\", &curregs, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nrequests\", &nrequests,\n\t\t uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nfills\", &nfills, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nflushes\", &nflushes, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nreslabs\", &nreslabs, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"curslabs\", &curslabs, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nonfull_slabs\", &nonfull_slabs,\n\t\t size_t);\n\n\t\tif (mutex) {\n\t\t\tmutex_stats_read_arena_bin(stats_arenas_mib, 5,\n\t\t\t col_mutex64, col_mutex32, uptime);\n\t\t}\n\n\t\temitter_json_object_begin(emitter);\n\t\temitter_json_kv(emitter, \"nmalloc\", emitter_type_uint64,\n\t\t &nmalloc);\n\t\temitter_json_kv(emitter, \"ndalloc\", emitter_type_uint64,\n\t\t &ndalloc);\n\t\temitter_json_kv(emitter, \"curregs\", emitter_type_size,\n\t\t &curregs);\n\t\temitter_json_kv(emitter, \"nrequests\", emitter_type_uint64,\n\t\t &nrequests);\n\t\tif (prof_stats_on) {\n\t\t\temitter_json_kv(emitter, \"prof_live_requested\",\n\t\t\t emitter_type_uint64, &prof_live.req_sum);\n\t\t\temitter_json_kv(emitter, \"prof_live_count\",\n\t\t\t emitter_type_uint64, &prof_live.count);\n\t\t\temitter_json_kv(emitter, \"prof_accum_requested\",\n\t\t\t emitter_type_uint64, &prof_accum.req_sum);\n\t\t\temitter_json_kv(emitter, \"prof_accum_count\",\n\t\t\t emitter_type_uint64, &prof_accum.count);\n\t\t}\n\t\temitter_json_kv(emitter, \"nfills\", emitter_type_uint64,\n\t\t &nfills);\n\t\temitter_json_kv(emitter, \"nflushes\", emitter_type_uint64,\n\t\t &nflushes);\n\t\temitter_json_kv(emitter, \"nreslabs\", emitter_type_uint64,\n\t\t &nreslabs);\n\t\temitter_json_kv(emitter, \"curslabs\", emitter_type_size,\n\t\t &curslabs);\n\t\temitter_json_kv(emitter, \"nonfull_slabs\", emitter_type_size,\n\t\t &nonfull_slabs);\n\t\tif (mutex) {\n\t\t\temitter_json_object_kv_begin(emitter, \"mutex\");\n\t\t\tmutex_stats_emit(emitter, NULL, col_mutex64,\n\t\t\t col_mutex32);\n\t\t\temitter_json_object_end(emitter);\n\t\t}\n\t\temitter_json_object_end(emitter);\n\n\t\tsize_t availregs = nregs * curslabs;\n\t\tchar util[6];\n\t\tif (get_rate_str((uint64_t)curregs, (uint64_t)availregs, util))\n\t\t{\n\t\t\tif (availregs == 0) {\n\t\t\t\tmalloc_snprintf(util, sizeof(util), \"1\");\n\t\t\t} else if (curregs > availregs) {\n\t\t\t\t/*\n\t\t\t\t * Race detected: the counters were read in\n\t\t\t\t * separate mallctl calls and concurrent\n\t\t\t\t * operations happened in between. In this case\n\t\t\t\t * no meaningful utilization can be computed.\n\t\t\t\t */\n\t\t\t\tmalloc_snprintf(util, sizeof(util), \" race\");\n\t\t\t} else {\n\t\t\t\tnot_reached();\n\t\t\t}\n\t\t}\n\n\t\tcol_size.size_val = reg_size;\n\t\tcol_ind.unsigned_val = j;\n\t\tcol_allocated.size_val = curregs * reg_size;\n\t\tcol_nmalloc.uint64_val = nmalloc;\n\t\tcol_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);\n\t\tcol_ndalloc.uint64_val = ndalloc;\n\t\tcol_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);\n\t\tcol_nrequests.uint64_val = nrequests;\n\t\tcol_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);\n\t\tif (prof_stats_on) {\n\t\t\tcol_prof_live_requested.uint64_val = prof_live.req_sum;\n\t\t\tcol_prof_live_count.uint64_val = prof_live.count;\n\t\t\tcol_prof_accum_requested.uint64_val =\n\t\t\t prof_accum.req_sum;\n\t\t\tcol_prof_accum_count.uint64_val = prof_accum.count;\n\t\t}\n\t\tcol_nshards.unsigned_val = nshards;\n\t\tcol_curregs.size_val = curregs;\n\t\tcol_curslabs.size_val = curslabs;\n\t\tcol_nonfull_slabs.size_val = nonfull_slabs;\n\t\tcol_regs.unsigned_val = nregs;\n\t\tcol_pgs.size_val = slab_size / page;\n\t\tcol_util.str_val = util;\n\t\tcol_nfills.uint64_val = nfills;\n\t\tcol_nfills_ps.uint64_val = rate_per_second(nfills, uptime);\n\t\tcol_nflushes.uint64_val = nflushes;\n\t\tcol_nflushes_ps.uint64_val = rate_per_second(nflushes, uptime);\n\t\tcol_nslabs.uint64_val = nslabs;\n\t\tcol_nreslabs.uint64_val = nreslabs;\n\t\tcol_nreslabs_ps.uint64_val = rate_per_second(nreslabs, uptime);\n\n\t\t/*\n\t\t * Note that mutex columns were initialized above, if mutex ==\n\t\t * true.\n\t\t */\n\n\t\temitter_table_row(emitter, &row);\n\t}\n\temitter_json_array_end(emitter); /* Close \"bins\". */\n\n\tif (in_gap) {\n\t\temitter_table_printf(emitter, \" ---\\n\");\n\t}\n}\n\nJEMALLOC_COLD\nstatic void\nstats_arena_lextents_print(emitter_t *emitter, unsigned i, uint64_t uptime) {\n\tunsigned nbins, nlextents, j;\n\tbool in_gap, in_gap_prev;\n\n\tCTL_GET(\"arenas.nbins\", &nbins, unsigned);\n\tCTL_GET(\"arenas.nlextents\", &nlextents, unsigned);\n\n\temitter_row_t header_row;\n\temitter_row_init(&header_row);\n\temitter_row_t row;\n\temitter_row_init(&row);\n\n\tbool prof_stats_on = config_prof && opt_prof && opt_prof_stats\n\t && i == MALLCTL_ARENAS_ALL;\n\n\tCOL_HDR(row, size, NULL, right, 20, size)\n\tCOL_HDR(row, ind, NULL, right, 4, unsigned)\n\tCOL_HDR(row, allocated, NULL, right, 13, size)\n\tCOL_HDR(row, nmalloc, NULL, right, 13, uint64)\n\tCOL_HDR(row, nmalloc_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, ndalloc, NULL, right, 13, uint64)\n\tCOL_HDR(row, ndalloc_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR(row, nrequests, NULL, right, 13, uint64)\n\tCOL_HDR(row, nrequests_ps, \"(#/sec)\", right, 8, uint64)\n\tCOL_HDR_DECLARE(prof_live_requested)\n\tCOL_HDR_DECLARE(prof_live_count)\n\tCOL_HDR_DECLARE(prof_accum_requested)\n\tCOL_HDR_DECLARE(prof_accum_count)\n\tif (prof_stats_on) {\n\t\tCOL_HDR_INIT(row, prof_live_requested, NULL, right, 21, uint64)\n\t\tCOL_HDR_INIT(row, prof_live_count, NULL, right, 17, uint64)\n\t\tCOL_HDR_INIT(row, prof_accum_requested, NULL, right, 21, uint64)\n\t\tCOL_HDR_INIT(row, prof_accum_count, NULL, right, 17, uint64)\n\t}\n\tCOL_HDR(row, curlextents, NULL, right, 13, size)\n\n\t/* As with bins, we label the large extents table. */\n\theader_size.width -= 6;\n\temitter_table_printf(emitter, \"large:\");\n\temitter_table_row(emitter, &header_row);\n\temitter_json_array_kv_begin(emitter, \"lextents\");\n\n\tsize_t stats_arenas_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 0, \"stats.arenas\");\n\tstats_arenas_mib[2] = i;\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 3, \"lextents\");\n\n\tsize_t arenas_lextent_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(arenas_lextent_mib, 0, \"arenas.lextent\");\n\n\tsize_t prof_stats_mib[CTL_MAX_DEPTH];\n\tif (prof_stats_on) {\n\t\tCTL_LEAF_PREPARE(prof_stats_mib, 0, \"prof.stats.lextents\");\n\t}\n\n\tfor (j = 0, in_gap = false; j < nlextents; j++) {\n\t\tuint64_t nmalloc, ndalloc, nrequests;\n\t\tsize_t lextent_size, curlextents;\n\t\tprof_stats_t prof_live;\n\t\tprof_stats_t prof_accum;\n\n\t\tstats_arenas_mib[4] = j;\n\t\tarenas_lextent_mib[2] = j;\n\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nmalloc\", &nmalloc, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"ndalloc\", &ndalloc, uint64_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nrequests\", &nrequests,\n\t\t uint64_t);\n\n\t\tin_gap_prev = in_gap;\n\t\tin_gap = (nrequests == 0);\n\n\t\tif (in_gap_prev && !in_gap) {\n\t\t\temitter_table_printf(emitter,\n\t\t\t \" ---\\n\");\n\t\t}\n\n\t\tCTL_LEAF(arenas_lextent_mib, 3, \"size\", &lextent_size, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"curlextents\", &curlextents,\n\t\t size_t);\n\n\t\tif (prof_stats_on) {\n\t\t\tprof_stats_mib[3] = j;\n\t\t\tCTL_LEAF(prof_stats_mib, 4, \"live\", &prof_live,\n\t\t\t prof_stats_t);\n\t\t\tCTL_LEAF(prof_stats_mib, 4, \"accum\", &prof_accum,\n\t\t\t prof_stats_t);\n\t\t}\n\n\t\temitter_json_object_begin(emitter);\n\t\tif (prof_stats_on) {\n\t\t\temitter_json_kv(emitter, \"prof_live_requested\",\n\t\t\t emitter_type_uint64, &prof_live.req_sum);\n\t\t\temitter_json_kv(emitter, \"prof_live_count\",\n\t\t\t emitter_type_uint64, &prof_live.count);\n\t\t\temitter_json_kv(emitter, \"prof_accum_requested\",\n\t\t\t emitter_type_uint64, &prof_accum.req_sum);\n\t\t\temitter_json_kv(emitter, \"prof_accum_count\",\n\t\t\t emitter_type_uint64, &prof_accum.count);\n\t\t}\n\t\temitter_json_kv(emitter, \"curlextents\", emitter_type_size,\n\t\t &curlextents);\n\t\temitter_json_object_end(emitter);\n\n\t\tcol_size.size_val = lextent_size;\n\t\tcol_ind.unsigned_val = nbins + j;\n\t\tcol_allocated.size_val = curlextents * lextent_size;\n\t\tcol_nmalloc.uint64_val = nmalloc;\n\t\tcol_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);\n\t\tcol_ndalloc.uint64_val = ndalloc;\n\t\tcol_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);\n\t\tcol_nrequests.uint64_val = nrequests;\n\t\tcol_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);\n\t\tif (prof_stats_on) {\n\t\t\tcol_prof_live_requested.uint64_val = prof_live.req_sum;\n\t\t\tcol_prof_live_count.uint64_val = prof_live.count;\n\t\t\tcol_prof_accum_requested.uint64_val =\n\t\t\t prof_accum.req_sum;\n\t\t\tcol_prof_accum_count.uint64_val = prof_accum.count;\n\t\t}\n\t\tcol_curlextents.size_val = curlextents;\n\n\t\tif (!in_gap) {\n\t\t\temitter_table_row(emitter, &row);\n\t\t}\n\t}\n\temitter_json_array_end(emitter); /* Close \"lextents\". */\n\tif (in_gap) {\n\t\temitter_table_printf(emitter, \" ---\\n\");\n\t}\n}\n\nJEMALLOC_COLD\nstatic void\nstats_arena_extents_print(emitter_t *emitter, unsigned i) {\n\tunsigned j;\n\tbool in_gap, in_gap_prev;\n\temitter_row_t header_row;\n\temitter_row_init(&header_row);\n\temitter_row_t row;\n\temitter_row_init(&row);\n\n\tCOL_HDR(row, size, NULL, right, 20, size)\n\tCOL_HDR(row, ind, NULL, right, 4, unsigned)\n\tCOL_HDR(row, ndirty, NULL, right, 13, size)\n\tCOL_HDR(row, dirty, NULL, right, 13, size)\n\tCOL_HDR(row, nmuzzy, NULL, right, 13, size)\n\tCOL_HDR(row, muzzy, NULL, right, 13, size)\n\tCOL_HDR(row, nretained, NULL, right, 13, size)\n\tCOL_HDR(row, retained, NULL, right, 13, size)\n\tCOL_HDR(row, ntotal, NULL, right, 13, size)\n\tCOL_HDR(row, total, NULL, right, 13, size)\n\n\t/* Label this section. */\n\theader_size.width -= 8;\n\temitter_table_printf(emitter, \"extents:\");\n\temitter_table_row(emitter, &header_row);\n\temitter_json_array_kv_begin(emitter, \"extents\");\n\n\tsize_t stats_arenas_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 0, \"stats.arenas\");\n\tstats_arenas_mib[2] = i;\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 3, \"extents\");\n\n\tin_gap = false;\n\tfor (j = 0; j < SC_NPSIZES; j++) {\n\t\tsize_t ndirty, nmuzzy, nretained, total, dirty_bytes,\n\t\t muzzy_bytes, retained_bytes, total_bytes;\n\t\tstats_arenas_mib[4] = j;\n\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"ndirty\", &ndirty, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nmuzzy\", &nmuzzy, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"nretained\", &nretained, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"dirty_bytes\", &dirty_bytes,\n\t\t size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"muzzy_bytes\", &muzzy_bytes,\n\t\t size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 5, \"retained_bytes\",\n\t\t &retained_bytes, size_t);\n\n\t\ttotal = ndirty + nmuzzy + nretained;\n\t\ttotal_bytes = dirty_bytes + muzzy_bytes + retained_bytes;\n\n\t\tin_gap_prev = in_gap;\n\t\tin_gap = (total == 0);\n\n\t\tif (in_gap_prev && !in_gap) {\n\t\t\temitter_table_printf(emitter,\n\t\t\t \" ---\\n\");\n\t\t}\n\n\t\temitter_json_object_begin(emitter);\n\t\temitter_json_kv(emitter, \"ndirty\", emitter_type_size, &ndirty);\n\t\temitter_json_kv(emitter, \"nmuzzy\", emitter_type_size, &nmuzzy);\n\t\temitter_json_kv(emitter, \"nretained\", emitter_type_size,\n\t\t &nretained);\n\n\t\temitter_json_kv(emitter, \"dirty_bytes\", emitter_type_size,\n\t\t &dirty_bytes);\n\t\temitter_json_kv(emitter, \"muzzy_bytes\", emitter_type_size,\n\t\t &muzzy_bytes);\n\t\temitter_json_kv(emitter, \"retained_bytes\", emitter_type_size,\n\t\t &retained_bytes);\n\t\temitter_json_object_end(emitter);\n\n\t\tcol_size.size_val = sz_pind2sz(j);\n\t\tcol_ind.size_val = j;\n\t\tcol_ndirty.size_val = ndirty;\n\t\tcol_dirty.size_val = dirty_bytes;\n\t\tcol_nmuzzy.size_val = nmuzzy;\n\t\tcol_muzzy.size_val = muzzy_bytes;\n\t\tcol_nretained.size_val = nretained;\n\t\tcol_retained.size_val = retained_bytes;\n\t\tcol_ntotal.size_val = total;\n\t\tcol_total.size_val = total_bytes;\n\n\t\tif (!in_gap) {\n\t\t\temitter_table_row(emitter, &row);\n\t\t}\n\t}\n\temitter_json_array_end(emitter); /* Close \"extents\". */\n\tif (in_gap) {\n\t\temitter_table_printf(emitter, \" ---\\n\");\n\t}\n}\n\nstatic void\nstats_arena_hpa_shard_print(emitter_t *emitter, unsigned i, uint64_t uptime) {\n\temitter_row_t header_row;\n\temitter_row_init(&header_row);\n\temitter_row_t row;\n\temitter_row_init(&row);\n\n\tuint64_t npurge_passes;\n\tuint64_t npurges;\n\tuint64_t nhugifies;\n\tuint64_t ndehugifies;\n\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.npurge_passes\",\n\t i, &npurge_passes, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.npurges\",\n\t i, &npurges, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.nhugifies\",\n\t i, &nhugifies, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.ndehugifies\",\n\t i, &ndehugifies, uint64_t);\n\n\tsize_t npageslabs_huge;\n\tsize_t nactive_huge;\n\tsize_t ndirty_huge;\n\n\tsize_t npageslabs_nonhuge;\n\tsize_t nactive_nonhuge;\n\tsize_t ndirty_nonhuge;\n\tsize_t nretained_nonhuge;\n\n\tsize_t sec_bytes;\n\tCTL_M2_GET(\"stats.arenas.0.hpa_sec_bytes\", i, &sec_bytes, size_t);\n\temitter_kv(emitter, \"sec_bytes\", \"Bytes in small extent cache\",\n\t emitter_type_size, &sec_bytes);\n\n\t/* First, global stats. */\n\temitter_table_printf(emitter,\n\t \"HPA shard stats:\\n\"\n\t \" Purge passes: %\" FMTu64 \" (%\" FMTu64 \" / sec)\\n\"\n\t \" Purges: %\" FMTu64 \" (%\" FMTu64 \" / sec)\\n\"\n\t \" Hugeifies: %\" FMTu64 \" (%\" FMTu64 \" / sec)\\n\"\n\t \" Dehugifies: %\" FMTu64 \" (%\" FMTu64 \" / sec)\\n\"\n\t \"\\n\",\n\t npurge_passes, rate_per_second(npurge_passes, uptime),\n\t npurges, rate_per_second(npurges, uptime),\n\t nhugifies, rate_per_second(nhugifies, uptime),\n\t ndehugifies, rate_per_second(ndehugifies, uptime));\n\n\temitter_json_object_kv_begin(emitter, \"hpa_shard\");\n\temitter_json_kv(emitter, \"npurge_passes\", emitter_type_uint64,\n\t &npurge_passes);\n\temitter_json_kv(emitter, \"npurges\", emitter_type_uint64,\n\t &npurges);\n\temitter_json_kv(emitter, \"nhugifies\", emitter_type_uint64,\n\t &nhugifies);\n\temitter_json_kv(emitter, \"ndehugifies\", emitter_type_uint64,\n\t &ndehugifies);\n\n\t/* Next, full slab stats. */\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.npageslabs_huge\",\n\t i, &npageslabs_huge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.nactive_huge\",\n\t i, &nactive_huge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.ndirty_huge\",\n\t i, &ndirty_huge, size_t);\n\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.npageslabs_nonhuge\",\n\t i, &npageslabs_nonhuge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.nactive_nonhuge\",\n\t i, &nactive_nonhuge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.full_slabs.ndirty_nonhuge\",\n\t i, &ndirty_nonhuge, size_t);\n\tnretained_nonhuge = npageslabs_nonhuge * HUGEPAGE_PAGES\n\t - nactive_nonhuge - ndirty_nonhuge;\n\n\temitter_table_printf(emitter,\n\t \" In full slabs:\\n\"\n\t \" npageslabs: %zu huge, %zu nonhuge\\n\"\n\t \" nactive: %zu huge, %zu nonhuge \\n\"\n\t \" ndirty: %zu huge, %zu nonhuge \\n\"\n\t \" nretained: 0 huge, %zu nonhuge \\n\",\n\t npageslabs_huge, npageslabs_nonhuge,\n\t nactive_huge, nactive_nonhuge,\n\t ndirty_huge, ndirty_nonhuge,\n\t nretained_nonhuge);\n\n\temitter_json_object_kv_begin(emitter, \"full_slabs\");\n\temitter_json_kv(emitter, \"npageslabs_huge\", emitter_type_size,\n\t &npageslabs_huge);\n\temitter_json_kv(emitter, \"nactive_huge\", emitter_type_size,\n\t &nactive_huge);\n\temitter_json_kv(emitter, \"nactive_huge\", emitter_type_size,\n\t &nactive_huge);\n\temitter_json_kv(emitter, \"npageslabs_nonhuge\", emitter_type_size,\n\t &npageslabs_nonhuge);\n\temitter_json_kv(emitter, \"nactive_nonhuge\", emitter_type_size,\n\t &nactive_nonhuge);\n\temitter_json_kv(emitter, \"ndirty_nonhuge\", emitter_type_size,\n\t &ndirty_nonhuge);\n\temitter_json_object_end(emitter); /* End \"full_slabs\" */\n\n\t/* Next, empty slab stats. */\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.npageslabs_huge\",\n\t i, &npageslabs_huge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.nactive_huge\",\n\t i, &nactive_huge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.ndirty_huge\",\n\t i, &ndirty_huge, size_t);\n\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.npageslabs_nonhuge\",\n\t i, &npageslabs_nonhuge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.nactive_nonhuge\",\n\t i, &nactive_nonhuge, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.hpa_shard.empty_slabs.ndirty_nonhuge\",\n\t i, &ndirty_nonhuge, size_t);\n\tnretained_nonhuge = npageslabs_nonhuge * HUGEPAGE_PAGES\n\t - nactive_nonhuge - ndirty_nonhuge;\n\n\temitter_table_printf(emitter,\n\t \" In empty slabs:\\n\"\n\t \" npageslabs: %zu huge, %zu nonhuge\\n\"\n\t \" nactive: %zu huge, %zu nonhuge \\n\"\n\t \" ndirty: %zu huge, %zu nonhuge \\n\"\n\t \" nretained: 0 huge, %zu nonhuge \\n\"\n\t \"\\n\",\n\t npageslabs_huge, npageslabs_nonhuge,\n\t nactive_huge, nactive_nonhuge,\n\t ndirty_huge, ndirty_nonhuge,\n\t nretained_nonhuge);\n\n\temitter_json_object_kv_begin(emitter, \"empty_slabs\");\n\temitter_json_kv(emitter, \"npageslabs_huge\", emitter_type_size,\n\t &npageslabs_huge);\n\temitter_json_kv(emitter, \"nactive_huge\", emitter_type_size,\n\t &nactive_huge);\n\temitter_json_kv(emitter, \"nactive_huge\", emitter_type_size,\n\t &nactive_huge);\n\temitter_json_kv(emitter, \"npageslabs_nonhuge\", emitter_type_size,\n\t &npageslabs_nonhuge);\n\temitter_json_kv(emitter, \"nactive_nonhuge\", emitter_type_size,\n\t &nactive_nonhuge);\n\temitter_json_kv(emitter, \"ndirty_nonhuge\", emitter_type_size,\n\t &ndirty_nonhuge);\n\temitter_json_object_end(emitter); /* End \"empty_slabs\" */\n\n\tCOL_HDR(row, size, NULL, right, 20, size)\n\tCOL_HDR(row, ind, NULL, right, 4, unsigned)\n\tCOL_HDR(row, npageslabs_huge, NULL, right, 16, size)\n\tCOL_HDR(row, nactive_huge, NULL, right, 16, size)\n\tCOL_HDR(row, ndirty_huge, NULL, right, 16, size)\n\tCOL_HDR(row, npageslabs_nonhuge, NULL, right, 20, size)\n\tCOL_HDR(row, nactive_nonhuge, NULL, right, 20, size)\n\tCOL_HDR(row, ndirty_nonhuge, NULL, right, 20, size)\n\tCOL_HDR(row, nretained_nonhuge, NULL, right, 20, size)\n\n\tsize_t stats_arenas_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 0, \"stats.arenas\");\n\tstats_arenas_mib[2] = i;\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 3, \"hpa_shard.nonfull_slabs\");\n\n\temitter_table_row(emitter, &header_row);\n\temitter_json_array_kv_begin(emitter, \"nonfull_slabs\");\n\tbool in_gap = false;\n\tfor (pszind_t j = 0; j < PSSET_NPSIZES && j < SC_NPSIZES; j++) {\n\t\tstats_arenas_mib[5] = j;\n\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"npageslabs_huge\",\n\t\t &npageslabs_huge, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"nactive_huge\",\n\t\t &nactive_huge, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"ndirty_huge\",\n\t\t &ndirty_huge, size_t);\n\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"npageslabs_nonhuge\",\n\t\t &npageslabs_nonhuge, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"nactive_nonhuge\",\n\t\t &nactive_nonhuge, size_t);\n\t\tCTL_LEAF(stats_arenas_mib, 6, \"ndirty_nonhuge\",\n\t\t &ndirty_nonhuge, size_t);\n\t\tnretained_nonhuge = npageslabs_nonhuge * HUGEPAGE_PAGES\n\t\t - nactive_nonhuge - ndirty_nonhuge;\n\n\t\tbool in_gap_prev = in_gap;\n\t\tin_gap = (npageslabs_huge == 0 && npageslabs_nonhuge == 0);\n\t\tif (in_gap_prev && !in_gap) {\n\t\t\temitter_table_printf(emitter,\n\t\t\t \" ---\\n\");\n\t\t}\n\n\t\tcol_size.size_val = sz_pind2sz(j);\n\t\tcol_ind.size_val = j;\n\t\tcol_npageslabs_huge.size_val = npageslabs_huge;\n\t\tcol_nactive_huge.size_val = nactive_huge;\n\t\tcol_ndirty_huge.size_val = ndirty_huge;\n\t\tcol_npageslabs_nonhuge.size_val = npageslabs_nonhuge;\n\t\tcol_nactive_nonhuge.size_val = nactive_nonhuge;\n\t\tcol_ndirty_nonhuge.size_val = ndirty_nonhuge;\n\t\tcol_nretained_nonhuge.size_val = nretained_nonhuge;\n\t\tif (!in_gap) {\n\t\t\temitter_table_row(emitter, &row);\n\t\t}\n\n\t\temitter_json_object_begin(emitter);\n\t\temitter_json_kv(emitter, \"npageslabs_huge\", emitter_type_size,\n\t\t &npageslabs_huge);\n\t\temitter_json_kv(emitter, \"nactive_huge\", emitter_type_size,\n\t\t &nactive_huge);\n\t\temitter_json_kv(emitter, \"ndirty_huge\", emitter_type_size,\n\t\t &ndirty_huge);\n\t\temitter_json_kv(emitter, \"npageslabs_nonhuge\", emitter_type_size,\n\t\t &npageslabs_nonhuge);\n\t\temitter_json_kv(emitter, \"nactive_nonhuge\", emitter_type_size,\n\t\t &nactive_nonhuge);\n\t\temitter_json_kv(emitter, \"ndirty_nonhuge\", emitter_type_size,\n\t\t &ndirty_nonhuge);\n\t\temitter_json_object_end(emitter);\n\t}\n\temitter_json_array_end(emitter); /* End \"nonfull_slabs\" */\n\temitter_json_object_end(emitter); /* End \"hpa_shard\" */\n\tif (in_gap) {\n\t\temitter_table_printf(emitter, \" ---\\n\");\n\t}\n}\n\nstatic void\nstats_arena_mutexes_print(emitter_t *emitter, unsigned arena_ind, uint64_t uptime) {\n\temitter_row_t row;\n\temitter_col_t col_name;\n\temitter_col_t col64[mutex_prof_num_uint64_t_counters];\n\temitter_col_t col32[mutex_prof_num_uint32_t_counters];\n\n\temitter_row_init(&row);\n\tmutex_stats_init_cols(&row, \"\", &col_name, col64, col32);\n\n\temitter_json_object_kv_begin(emitter, \"mutexes\");\n\temitter_table_row(emitter, &row);\n\n\tsize_t stats_arenas_mib[CTL_MAX_DEPTH];\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 0, \"stats.arenas\");\n\tstats_arenas_mib[2] = arena_ind;\n\tCTL_LEAF_PREPARE(stats_arenas_mib, 3, \"mutexes\");\n\n\tfor (mutex_prof_arena_ind_t i = 0; i < mutex_prof_num_arena_mutexes;\n\t i++) {\n\t\tconst char *name = arena_mutex_names[i];\n\t\temitter_json_object_kv_begin(emitter, name);\n\t\tmutex_stats_read_arena(stats_arenas_mib, 4, name, &col_name,\n\t\t col64, col32, uptime);\n\t\tmutex_stats_emit(emitter, &row, col64, col32);\n\t\temitter_json_object_end(emitter); /* Close the mutex dict. */\n\t}\n\temitter_json_object_end(emitter); /* End \"mutexes\". */\n}\n\nJEMALLOC_COLD\nstatic void\nstats_arena_print(emitter_t *emitter, unsigned i, bool bins, bool large,\n bool mutex, bool extents, bool hpa) {\n\tunsigned nthreads;\n\tconst char *dss;\n\tssize_t dirty_decay_ms, muzzy_decay_ms;\n\tsize_t page, pactive, pdirty, pmuzzy, mapped, retained;\n\tsize_t base, internal, resident, metadata_thp, extent_avail;\n\tuint64_t dirty_npurge, dirty_nmadvise, dirty_purged;\n\tuint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;\n\tsize_t small_allocated;\n\tuint64_t small_nmalloc, small_ndalloc, small_nrequests, small_nfills,\n\t small_nflushes;\n\tsize_t large_allocated;\n\tuint64_t large_nmalloc, large_ndalloc, large_nrequests, large_nfills,\n\t large_nflushes;\n\tsize_t tcache_bytes, tcache_stashed_bytes, abandoned_vm;\n\tuint64_t uptime;\n\n\tCTL_GET(\"arenas.page\", &page, size_t);\n\n\tCTL_M2_GET(\"stats.arenas.0.nthreads\", i, &nthreads, unsigned);\n\temitter_kv(emitter, \"nthreads\", \"assigned threads\",\n\t emitter_type_unsigned, &nthreads);\n\n\tCTL_M2_GET(\"stats.arenas.0.uptime\", i, &uptime, uint64_t);\n\temitter_kv(emitter, \"uptime_ns\", \"uptime\", emitter_type_uint64,\n\t &uptime);\n\n\tCTL_M2_GET(\"stats.arenas.0.dss\", i, &dss, const char *);\n\temitter_kv(emitter, \"dss\", \"dss allocation precedence\",\n\t emitter_type_string, &dss);\n\n\tCTL_M2_GET(\"stats.arenas.0.dirty_decay_ms\", i, &dirty_decay_ms,\n\t ssize_t);\n\tCTL_M2_GET(\"stats.arenas.0.muzzy_decay_ms\", i, &muzzy_decay_ms,\n\t ssize_t);\n\tCTL_M2_GET(\"stats.arenas.0.pactive\", i, &pactive, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.pdirty\", i, &pdirty, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.pmuzzy\", i, &pmuzzy, size_t);\n\tCTL_M2_GET(\"stats.arenas.0.dirty_npurge\", i, &dirty_npurge, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.dirty_nmadvise\", i, &dirty_nmadvise,\n\t uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.dirty_purged\", i, &dirty_purged, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.muzzy_npurge\", i, &muzzy_npurge, uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.muzzy_nmadvise\", i, &muzzy_nmadvise,\n\t uint64_t);\n\tCTL_M2_GET(\"stats.arenas.0.muzzy_purged\", i, &muzzy_purged, uint64_t);\n\n\temitter_row_t decay_row;\n\temitter_row_init(&decay_row);\n\n\t/* JSON-style emission. */\n\temitter_json_kv(emitter, \"dirty_decay_ms\", emitter_type_ssize,\n\t &dirty_decay_ms);\n\temitter_json_kv(emitter, \"muzzy_decay_ms\", emitter_type_ssize,\n\t &muzzy_decay_ms);\n\n\temitter_json_kv(emitter, \"pactive\", emitter_type_size, &pactive);\n\temitter_json_kv(emitter, \"pdirty\", emitter_type_size, &pdirty);\n\temitter_json_kv(emitter, \"pmuzzy\", emitter_type_size, &pmuzzy);\n\n\temitter_json_kv(emitter, \"dirty_npurge\", emitter_type_uint64,\n\t &dirty_npurge);\n\temitter_json_kv(emitter, \"dirty_nmadvise\", emitter_type_uint64,\n\t &dirty_nmadvise);\n\temitter_json_kv(emitter, \"dirty_purged\", emitter_type_uint64,\n\t &dirty_purged);\n\n\temitter_json_kv(emitter, \"muzzy_npurge\", emitter_type_uint64,\n\t &muzzy_npurge);\n\temitter_json_kv(emitter, \"muzzy_nmadvise\", emitter_type_uint64,\n\t &muzzy_nmadvise);\n\temitter_json_kv(emitter, \"muzzy_purged\", emitter_type_uint64,\n\t &muzzy_purged);\n\n\t/* Table-style emission. */\n\tCOL(decay_row, decay_type, right, 9, title);\n\tcol_decay_type.str_val = \"decaying:\";\n\n\tCOL(decay_row, decay_time, right, 6, title);\n\tcol_decay_time.str_val = \"time\";\n\n\tCOL(decay_row, decay_npages, right, 13, title);\n\tcol_decay_npages.str_val = \"npages\";\n\n\tCOL(decay_row, decay_sweeps, right, 13, title);\n\tcol_decay_sweeps.str_val = \"sweeps\";\n\n\tCOL(decay_row, decay_madvises, right, 13, title);\n\tcol_decay_madvises.str_val = \"madvises\";\n\n\tCOL(decay_row, decay_purged, right, 13, title);\n\tcol_decay_purged.str_val = \"purged\";\n\n\t/* Title row. */\n\temitter_table_row(emitter, &decay_row);\n\n\t/* Dirty row. */\n\tcol_decay_type.str_val = \"dirty:\";\n\n\tif (dirty_decay_ms >= 0) {\n\t\tcol_decay_time.type = emitter_type_ssize;\n\t\tcol_decay_time.ssize_val = dirty_decay_ms;\n\t} else {\n\t\tcol_decay_time.type = emitter_type_title;\n\t\tcol_decay_time.str_val = \"N/A\";\n\t}\n\n\tcol_decay_npages.type = emitter_type_size;\n\tcol_decay_npages.size_val = pdirty;\n\n\tcol_decay_sweeps.type = emitter_type_uint64;\n\tcol_decay_sweeps.uint64_val = dirty_npurge;\n\n\tcol_decay_madvises.type = emitter_type_uint64;\n\tcol_decay_madvises.uint64_val = dirty_nmadvise;\n\n\tcol_decay_purged.type = emitter_type_uint64;\n\tcol_decay_purged.uint64_val = dirty_purged;\n\n\temitter_table_row(emitter, &decay_row);\n\n\t/* Muzzy row. */\n\tcol_decay_type.str_val = \"muzzy:\";\n\n\tif (muzzy_decay_ms >= 0) {\n\t\tcol_decay_time.type = emitter_type_ssize;\n\t\tcol_decay_time.ssize_val = muzzy_decay_ms;\n\t} else {\n\t\tcol_decay_time.type = emitter_type_title;\n\t\tcol_decay_time.str_val = \"N/A\";\n\t}\n\n\tcol_decay_npages.type = emitter_type_size;\n\tcol_decay_npages.size_val = pmuzzy;\n\n\tcol_decay_sweeps.type = emitter_type_uint64;\n\tcol_decay_sweeps.uint64_val = muzzy_npurge;\n\n\tcol_decay_madvises.type = emitter_type_uint64;\n\tcol_decay_madvises.uint64_val = muzzy_nmadvise;\n\n\tcol_decay_purged.type = emitter_type_uint64;\n\tcol_decay_purged.uint64_val = muzzy_purged;\n\n\temitter_table_row(emitter, &decay_row);\n\n\t/* Small / large / total allocation counts. */\n\temitter_row_t alloc_count_row;\n\temitter_row_init(&alloc_count_row);\n\n\tCOL(alloc_count_row, count_title, left, 21, title);\n\tcol_count_title.str_val = \"\";\n\n\tCOL(alloc_count_row, count_allocated, right, 16, title);\n\tcol_count_allocated.str_val = \"allocated\";\n\n\tCOL(alloc_count_row, count_nmalloc, right, 16, title);\n\tcol_count_nmalloc.str_val = \"nmalloc\";\n\tCOL(alloc_count_row, count_nmalloc_ps, right, 10, title);\n\tcol_count_nmalloc_ps.str_val = \"(#/sec)\";\n\n\tCOL(alloc_count_row, count_ndalloc, right, 16, title);\n\tcol_count_ndalloc.str_val = \"ndalloc\";\n\tCOL(alloc_count_row, count_ndalloc_ps, right, 10, title);\n\tcol_count_ndalloc_ps.str_val = \"(#/sec)\";\n\n\tCOL(alloc_count_row, count_nrequests, right, 16, title);\n\tcol_count_nrequests.str_val = \"nrequests\";\n\tCOL(alloc_count_row, count_nrequests_ps, right, 10, title);\n\tcol_count_nrequests_ps.str_val = \"(#/sec)\";\n\n\tCOL(alloc_count_row, count_nfills, right, 16, title);\n\tcol_count_nfills.str_val = \"nfill\";\n\tCOL(alloc_count_row, count_nfills_ps, right, 10, title);\n\tcol_count_nfills_ps.str_val = \"(#/sec)\";\n\n\tCOL(alloc_count_row, count_nflushes, right, 16, title);\n\tcol_count_nflushes.str_val = \"nflush\";\n\tCOL(alloc_count_row, count_nflushes_ps, right, 10, title);\n\tcol_count_nflushes_ps.str_val = \"(#/sec)\";\n\n\temitter_table_row(emitter, &alloc_count_row);\n\n\tcol_count_nmalloc_ps.type = emitter_type_uint64;\n\tcol_count_ndalloc_ps.type = emitter_type_uint64;\n\tcol_count_nrequests_ps.type = emitter_type_uint64;\n\tcol_count_nfills_ps.type = emitter_type_uint64;\n\tcol_count_nflushes_ps.type = emitter_type_uint64;\n\n#define GET_AND_EMIT_ALLOC_STAT(small_or_large, name, valtype)\t\t\\\n\tCTL_M2_GET(\"stats.arenas.0.\" #small_or_large \".\" #name, i,\t\\\n\t &small_or_large##_##name, valtype##_t);\t\t\t\\\n\temitter_json_kv(emitter, #name, emitter_type_##valtype,\t\t\\\n\t &small_or_large##_##name);\t\t\t\t\t\\\n\tcol_count_##name.type = emitter_type_##valtype;\t\t\\\n\tcol_count_##name.valtype##_val = small_or_large##_##name;\n\n\temitter_json_object_kv_begin(emitter, \"small\");\n\tcol_count_title.str_val = \"small:\";\n\n\tGET_AND_EMIT_ALLOC_STAT(small, allocated, size)\n\tGET_AND_EMIT_ALLOC_STAT(small, nmalloc, uint64)\n\tcol_count_nmalloc_ps.uint64_val =\n\t rate_per_second(col_count_nmalloc.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(small, ndalloc, uint64)\n\tcol_count_ndalloc_ps.uint64_val =\n\t rate_per_second(col_count_ndalloc.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(small, nrequests, uint64)\n\tcol_count_nrequests_ps.uint64_val =\n\t rate_per_second(col_count_nrequests.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(small, nfills, uint64)\n\tcol_count_nfills_ps.uint64_val =\n\t rate_per_second(col_count_nfills.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(small, nflushes, uint64)\n\tcol_count_nflushes_ps.uint64_val =\n\t rate_per_second(col_count_nflushes.uint64_val, uptime);\n\n\temitter_table_row(emitter, &alloc_count_row);\n\temitter_json_object_end(emitter); /* Close \"small\". */\n\n\temitter_json_object_kv_begin(emitter, \"large\");\n\tcol_count_title.str_val = \"large:\";\n\n\tGET_AND_EMIT_ALLOC_STAT(large, allocated, size)\n\tGET_AND_EMIT_ALLOC_STAT(large, nmalloc, uint64)\n\tcol_count_nmalloc_ps.uint64_val =\n\t rate_per_second(col_count_nmalloc.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(large, ndalloc, uint64)\n\tcol_count_ndalloc_ps.uint64_val =\n\t rate_per_second(col_count_ndalloc.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(large, nrequests, uint64)\n\tcol_count_nrequests_ps.uint64_val =\n\t rate_per_second(col_count_nrequests.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(large, nfills, uint64)\n\tcol_count_nfills_ps.uint64_val =\n\t rate_per_second(col_count_nfills.uint64_val, uptime);\n\tGET_AND_EMIT_ALLOC_STAT(large, nflushes, uint64)\n\tcol_count_nflushes_ps.uint64_val =\n\t rate_per_second(col_count_nflushes.uint64_val, uptime);\n\n\temitter_table_row(emitter, &alloc_count_row);\n\temitter_json_object_end(emitter); /* Close \"large\". */\n\n#undef GET_AND_EMIT_ALLOC_STAT\n\n\t/* Aggregated small + large stats are emitter only in table mode. */\n\tcol_count_title.str_val = \"total:\";\n\tcol_count_allocated.size_val = small_allocated + large_allocated;\n\tcol_count_nmalloc.uint64_val = small_nmalloc + large_nmalloc;\n\tcol_count_ndalloc.uint64_val = small_ndalloc + large_ndalloc;\n\tcol_count_nrequests.uint64_val = small_nrequests + large_nrequests;\n\tcol_count_nfills.uint64_val = small_nfills + large_nfills;\n\tcol_count_nflushes.uint64_val = small_nflushes + large_nflushes;\n\tcol_count_nmalloc_ps.uint64_val =\n\t rate_per_second(col_count_nmalloc.uint64_val, uptime);\n\tcol_count_ndalloc_ps.uint64_val =\n\t rate_per_second(col_count_ndalloc.uint64_val, uptime);\n\tcol_count_nrequests_ps.uint64_val =\n\t rate_per_second(col_count_nrequests.uint64_val, uptime);\n\tcol_count_nfills_ps.uint64_val =\n\t rate_per_second(col_count_nfills.uint64_val, uptime);\n\tcol_count_nflushes_ps.uint64_val =\n\t rate_per_second(col_count_nflushes.uint64_val, uptime);\n\temitter_table_row(emitter, &alloc_count_row);\n\n\temitter_row_t mem_count_row;\n\temitter_row_init(&mem_count_row);\n\n\temitter_col_t mem_count_title;\n\temitter_col_init(&mem_count_title, &mem_count_row);\n\tmem_count_title.justify = emitter_justify_left;\n\tmem_count_title.width = 21;\n\tmem_count_title.type = emitter_type_title;\n\tmem_count_title.str_val = \"\";\n\n\temitter_col_t mem_count_val;\n\temitter_col_init(&mem_count_val, &mem_count_row);\n\tmem_count_val.justify = emitter_justify_right;\n\tmem_count_val.width = 16;\n\tmem_count_val.type = emitter_type_title;\n\tmem_count_val.str_val = \"\";\n\n\temitter_table_row(emitter, &mem_count_row);\n\tmem_count_val.type = emitter_type_size;\n\n\t/* Active count in bytes is emitted only in table mode. */\n\tmem_count_title.str_val = \"active:\";\n\tmem_count_val.size_val = pactive * page;\n\temitter_table_row(emitter, &mem_count_row);\n\n#define GET_AND_EMIT_MEM_STAT(stat)\t\t\t\t\t\\\n\tCTL_M2_GET(\"stats.arenas.0.\"#stat, i, &stat, size_t);\t\t\\\n\temitter_json_kv(emitter, #stat, emitter_type_size, &stat);\t\\\n\tmem_count_title.str_val = #stat\":\";\t\t\t\t\\\n\tmem_count_val.size_val = stat;\t\t\t\t\t\\\n\temitter_table_row(emitter, &mem_count_row);\n\n\tGET_AND_EMIT_MEM_STAT(mapped)\n\tGET_AND_EMIT_MEM_STAT(retained)\n\tGET_AND_EMIT_MEM_STAT(base)\n\tGET_AND_EMIT_MEM_STAT(internal)\n\tGET_AND_EMIT_MEM_STAT(metadata_thp)\n\tGET_AND_EMIT_MEM_STAT(tcache_bytes)\n\tGET_AND_EMIT_MEM_STAT(tcache_stashed_bytes)\n\tGET_AND_EMIT_MEM_STAT(resident)\n\tGET_AND_EMIT_MEM_STAT(abandoned_vm)\n\tGET_AND_EMIT_MEM_STAT(extent_avail)\n#undef GET_AND_EMIT_MEM_STAT\n\n\tif (mutex) {\n\t\tstats_arena_mutexes_print(emitter, i, uptime);\n\t}\n\tif (bins) {\n\t\tstats_arena_bins_print(emitter, mutex, i, uptime);\n\t}\n\tif (large) {\n\t\tstats_arena_lextents_print(emitter, i, uptime);\n\t}\n\tif (extents) {\n\t\tstats_arena_extents_print(emitter, i);\n\t}\n\tif (hpa) {\n\t\tstats_arena_hpa_shard_print(emitter, i, uptime);\n\t}\n}\n\nJEMALLOC_COLD\nstatic void\nstats_general_print(emitter_t *emitter) {\n\tconst char *cpv;\n\tbool bv, bv2;\n\tunsigned uv;\n\tuint32_t u32v;\n\tuint64_t u64v;\n\tint64_t i64v;\n\tssize_t ssv, ssv2;\n\tsize_t sv, bsz, usz, u32sz, u64sz, i64sz, ssz, sssz, cpsz;\n\n\tbsz = sizeof(bool);\n\tusz = sizeof(unsigned);\n\tssz = sizeof(size_t);\n\tsssz = sizeof(ssize_t);\n\tcpsz = sizeof(const char *);\n\tu32sz = sizeof(uint32_t);\n\ti64sz = sizeof(int64_t);\n\tu64sz = sizeof(uint64_t);\n\n\tCTL_GET(\"version\", &cpv, const char *);\n\temitter_kv(emitter, \"version\", \"Version\", emitter_type_string, &cpv);\n\n\t/* config. */\n\temitter_dict_begin(emitter, \"config\", \"Build-time option settings\");\n#define CONFIG_WRITE_BOOL(name)\t\t\t\t\t\t\\\n\tdo {\t\t\t\t\t\t\t\t\\\n\t\tCTL_GET(\"config.\"#name, &bv, bool);\t\t\t\\\n\t\temitter_kv(emitter, #name, \"config.\"#name,\t\t\\\n\t\t emitter_type_bool, &bv);\t\t\t\t\\\n\t} while (0)\n\n\tCONFIG_WRITE_BOOL(cache_oblivious);\n\tCONFIG_WRITE_BOOL(debug);\n\tCONFIG_WRITE_BOOL(fill);\n\tCONFIG_WRITE_BOOL(lazy_lock);\n\temitter_kv(emitter, \"malloc_conf\", \"config.malloc_conf\",\n\t emitter_type_string, &config_malloc_conf);\n\n\tCONFIG_WRITE_BOOL(opt_safety_checks);\n\tCONFIG_WRITE_BOOL(prof);\n\tCONFIG_WRITE_BOOL(prof_libgcc);\n\tCONFIG_WRITE_BOOL(prof_libunwind);\n\tCONFIG_WRITE_BOOL(stats);\n\tCONFIG_WRITE_BOOL(utrace);\n\tCONFIG_WRITE_BOOL(xmalloc);\n#undef CONFIG_WRITE_BOOL\n\temitter_dict_end(emitter); /* Close \"config\" dict. */\n\n\t/* opt. */\n#define OPT_WRITE(name, var, size, emitter_type)\t\t\t\\\n\tif (je_mallctl(\"opt.\"name, (void *)&var, &size, NULL, 0) ==\t\\\n\t 0) {\t\t\t\t\t\t\t\\\n\t\temitter_kv(emitter, name, \"opt.\"name, emitter_type,\t\\\n\t\t &var);\t\t\t\t\t\t\\\n\t}\n\n#define OPT_WRITE_MUTABLE(name, var1, var2, size, emitter_type,\t\t\\\n altname)\t\t\t\t\t\t\t\t\\\n\tif (je_mallctl(\"opt.\"name, (void *)&var1, &size, NULL, 0) ==\t\\\n\t 0 && je_mallctl(altname, (void *)&var2, &size, NULL, 0)\t\\\n\t == 0) {\t\t\t\t\t\t\t\\\n\t\temitter_kv_note(emitter, name, \"opt.\"name,\t\t\\\n\t\t emitter_type, &var1, altname, emitter_type,\t\t\\\n\t\t &var2);\t\t\t\t\t\t\\\n\t}\n\n#define OPT_WRITE_BOOL(name) OPT_WRITE(name, bv, bsz, emitter_type_bool)\n#define OPT_WRITE_BOOL_MUTABLE(name, altname)\t\t\t\t\\\n\tOPT_WRITE_MUTABLE(name, bv, bv2, bsz, emitter_type_bool, altname)\n\n#define OPT_WRITE_UNSIGNED(name)\t\t\t\t\t\\\n\tOPT_WRITE(name, uv, usz, emitter_type_unsigned)\n\n#define OPT_WRITE_INT64(name)\t\t\t\t\t\t\\\n\tOPT_WRITE(name, i64v, i64sz, emitter_type_int64)\n#define OPT_WRITE_UINT64(name)\t\t\t\t\t\t\\\n\tOPT_WRITE(name, u64v, u64sz, emitter_type_uint64)\n\n#define OPT_WRITE_SIZE_T(name)\t\t\t\t\t\t\\\n\tOPT_WRITE(name, sv, ssz, emitter_type_size)\n#define OPT_WRITE_SSIZE_T(name)\t\t\t\t\t\t\\\n\tOPT_WRITE(name, ssv, sssz, emitter_type_ssize)\n#define OPT_WRITE_SSIZE_T_MUTABLE(name, altname)\t\t\t\\\n\tOPT_WRITE_MUTABLE(name, ssv, ssv2, sssz, emitter_type_ssize,\t\\\n\t altname)\n\n#define OPT_WRITE_CHAR_P(name)\t\t\t\t\t\t\\\n\tOPT_WRITE(name, cpv, cpsz, emitter_type_string)\n\n\temitter_dict_begin(emitter, \"opt\", \"Run-time option settings\");\n\n\tOPT_WRITE_BOOL(\"abort\")\n\tOPT_WRITE_BOOL(\"abort_conf\")\n\tOPT_WRITE_BOOL(\"cache_oblivious\")\n\tOPT_WRITE_BOOL(\"confirm_conf\")\n\tOPT_WRITE_BOOL(\"retain\")\n\tOPT_WRITE_CHAR_P(\"dss\")\n\tOPT_WRITE_UNSIGNED(\"narenas\")\n\tOPT_WRITE_CHAR_P(\"percpu_arena\")\n\tOPT_WRITE_SIZE_T(\"oversize_threshold\")\n\tOPT_WRITE_BOOL(\"hpa\")\n\tOPT_WRITE_SIZE_T(\"hpa_slab_max_alloc\")\n\tOPT_WRITE_SIZE_T(\"hpa_hugification_threshold\")\n\tOPT_WRITE_UINT64(\"hpa_hugify_delay_ms\")\n\tOPT_WRITE_UINT64(\"hpa_min_purge_interval_ms\")\n\tif (je_mallctl(\"opt.hpa_dirty_mult\", (void *)&u32v, &u32sz, NULL, 0)\n\t == 0) {\n\t\t/*\n\t\t * We cheat a little and \"know\" the secret meaning of this\n\t\t * representation.\n\t\t */\n\t\tif (u32v == (uint32_t)-1) {\n\t\t\tconst char *neg1 = \"-1\";\n\t\t\temitter_kv(emitter, \"hpa_dirty_mult\",\n\t\t\t \"opt.hpa_dirty_mult\", emitter_type_string, &neg1);\n\t\t} else {\n\t\t\tchar buf[FXP_BUF_SIZE];\n\t\t\tfxp_print(u32v, buf);\n\t\t\tconst char *bufp = buf;\n\t\t\temitter_kv(emitter, \"hpa_dirty_mult\",\n\t\t\t \"opt.hpa_dirty_mult\", emitter_type_string, &bufp);\n\t\t}\n\t}\n\tOPT_WRITE_SIZE_T(\"hpa_sec_nshards\")\n\tOPT_WRITE_SIZE_T(\"hpa_sec_max_alloc\")\n\tOPT_WRITE_SIZE_T(\"hpa_sec_max_bytes\")\n\tOPT_WRITE_SIZE_T(\"hpa_sec_bytes_after_flush\")\n\tOPT_WRITE_SIZE_T(\"hpa_sec_batch_fill_extra\")\n\tOPT_WRITE_CHAR_P(\"metadata_thp\")\n\tOPT_WRITE_INT64(\"mutex_max_spin\")\n\tOPT_WRITE_BOOL_MUTABLE(\"background_thread\", \"background_thread\")\n\tOPT_WRITE_SSIZE_T_MUTABLE(\"dirty_decay_ms\", \"arenas.dirty_decay_ms\")\n\tOPT_WRITE_SSIZE_T_MUTABLE(\"muzzy_decay_ms\", \"arenas.muzzy_decay_ms\")\n\tOPT_WRITE_SIZE_T(\"lg_extent_max_active_fit\")\n\tOPT_WRITE_CHAR_P(\"junk\")\n\tOPT_WRITE_BOOL(\"zero\")\n\tOPT_WRITE_BOOL(\"utrace\")\n\tOPT_WRITE_BOOL(\"xmalloc\")\n\tOPT_WRITE_BOOL(\"experimental_infallible_new\")\n\tOPT_WRITE_BOOL(\"tcache\")\n\tOPT_WRITE_SIZE_T(\"tcache_max\")\n\tOPT_WRITE_UNSIGNED(\"tcache_nslots_small_min\")\n\tOPT_WRITE_UNSIGNED(\"tcache_nslots_small_max\")\n\tOPT_WRITE_UNSIGNED(\"tcache_nslots_large\")\n\tOPT_WRITE_SSIZE_T(\"lg_tcache_nslots_mul\")\n\tOPT_WRITE_SIZE_T(\"tcache_gc_incr_bytes\")\n\tOPT_WRITE_SIZE_T(\"tcache_gc_delay_bytes\")\n\tOPT_WRITE_UNSIGNED(\"lg_tcache_flush_small_div\")\n\tOPT_WRITE_UNSIGNED(\"lg_tcache_flush_large_div\")\n\tOPT_WRITE_CHAR_P(\"thp\")\n\tOPT_WRITE_BOOL(\"prof\")\n\tOPT_WRITE_CHAR_P(\"prof_prefix\")\n\tOPT_WRITE_BOOL_MUTABLE(\"prof_active\", \"prof.active\")\n\tOPT_WRITE_BOOL_MUTABLE(\"prof_thread_active_init\",\n\t \"prof.thread_active_init\")\n\tOPT_WRITE_SSIZE_T_MUTABLE(\"lg_prof_sample\", \"prof.lg_sample\")\n\tOPT_WRITE_BOOL(\"prof_accum\")\n\tOPT_WRITE_SSIZE_T(\"lg_prof_interval\")\n\tOPT_WRITE_BOOL(\"prof_gdump\")\n\tOPT_WRITE_BOOL(\"prof_final\")\n\tOPT_WRITE_BOOL(\"prof_leak\")\n\tOPT_WRITE_BOOL(\"prof_leak_error\")\n\tOPT_WRITE_BOOL(\"stats_print\")\n\tOPT_WRITE_CHAR_P(\"stats_print_opts\")\n\tOPT_WRITE_BOOL(\"stats_print\")\n\tOPT_WRITE_CHAR_P(\"stats_print_opts\")\n\tOPT_WRITE_INT64(\"stats_interval\")\n\tOPT_WRITE_CHAR_P(\"stats_interval_opts\")\n\tOPT_WRITE_CHAR_P(\"zero_realloc\")\n\n\temitter_dict_end(emitter);\n\n#undef OPT_WRITE\n#undef OPT_WRITE_MUTABLE\n#undef OPT_WRITE_BOOL\n#undef OPT_WRITE_BOOL_MUTABLE\n#undef OPT_WRITE_UNSIGNED\n#undef OPT_WRITE_SSIZE_T\n#undef OPT_WRITE_SSIZE_T_MUTABLE\n#undef OPT_WRITE_CHAR_P\n\n\t/* prof. */\n\tif (config_prof) {\n\t\temitter_dict_begin(emitter, \"prof\", \"Profiling settings\");\n\n\t\tCTL_GET(\"prof.thread_active_init\", &bv, bool);\n\t\temitter_kv(emitter, \"thread_active_init\",\n\t\t \"prof.thread_active_init\", emitter_type_bool, &bv);\n\n\t\tCTL_GET(\"prof.active\", &bv, bool);\n\t\temitter_kv(emitter, \"active\", \"prof.active\", emitter_type_bool,\n\t\t &bv);\n\n\t\tCTL_GET(\"prof.gdump\", &bv, bool);\n\t\temitter_kv(emitter, \"gdump\", \"prof.gdump\", emitter_type_bool,\n\t\t &bv);\n\n\t\tCTL_GET(\"prof.interval\", &u64v, uint64_t);\n\t\temitter_kv(emitter, \"interval\", \"prof.interval\",\n\t\t emitter_type_uint64, &u64v);\n\n\t\tCTL_GET(\"prof.lg_sample\", &ssv, ssize_t);\n\t\temitter_kv(emitter, \"lg_sample\", \"prof.lg_sample\",\n\t\t emitter_type_ssize, &ssv);\n\n\t\temitter_dict_end(emitter); /* Close \"prof\". */\n\t}\n\n\t/* arenas. */\n\t/*\n\t * The json output sticks arena info into an \"arenas\" dict; the table\n\t * output puts them at the top-level.\n\t */\n\temitter_json_object_kv_begin(emitter, \"arenas\");\n\n\tCTL_GET(\"arenas.narenas\", &uv, unsigned);\n\temitter_kv(emitter, \"narenas\", \"Arenas\", emitter_type_unsigned, &uv);\n\n\t/*\n\t * Decay settings are emitted only in json mode; in table mode, they're\n\t * emitted as notes with the opt output, above.\n\t */\n\tCTL_GET(\"arenas.dirty_decay_ms\", &ssv, ssize_t);\n\temitter_json_kv(emitter, \"dirty_decay_ms\", emitter_type_ssize, &ssv);\n\n\tCTL_GET(\"arenas.muzzy_decay_ms\", &ssv, ssize_t);\n\temitter_json_kv(emitter, \"muzzy_decay_ms\", emitter_type_ssize, &ssv);\n\n\tCTL_GET(\"arenas.quantum\", &sv, size_t);\n\temitter_kv(emitter, \"quantum\", \"Quantum size\", emitter_type_size, &sv);\n\n\tCTL_GET(\"arenas.page\", &sv, size_t);\n\temitter_kv(emitter, \"page\", \"Page size\", emitter_type_size, &sv);\n\n\tif (je_mallctl(\"arenas.tcache_max\", (void *)&sv, &ssz, NULL, 0) == 0) {\n\t\temitter_kv(emitter, \"tcache_max\",\n\t\t \"Maximum thread-cached size class\", emitter_type_size, &sv);\n\t}\n\n\tunsigned arenas_nbins;\n\tCTL_GET(\"arenas.nbins\", &arenas_nbins, unsigned);\n\temitter_kv(emitter, \"nbins\", \"Number of bin size classes\",\n\t emitter_type_unsigned, &arenas_nbins);\n\n\tunsigned arenas_nhbins;\n\tCTL_GET(\"arenas.nhbins\", &arenas_nhbins, unsigned);\n\temitter_kv(emitter, \"nhbins\", \"Number of thread-cache bin size classes\",\n\t emitter_type_unsigned, &arenas_nhbins);\n\n\t/*\n\t * We do enough mallctls in a loop that we actually want to omit them\n\t * (not just omit the printing).\n\t */\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_array_kv_begin(emitter, \"bin\");\n\t\tsize_t arenas_bin_mib[CTL_MAX_DEPTH];\n\t\tCTL_LEAF_PREPARE(arenas_bin_mib, 0, \"arenas.bin\");\n\t\tfor (unsigned i = 0; i < arenas_nbins; i++) {\n\t\t\tarenas_bin_mib[2] = i;\n\t\t\temitter_json_object_begin(emitter);\n\n\t\t\tCTL_LEAF(arenas_bin_mib, 3, \"size\", &sv, size_t);\n\t\t\temitter_json_kv(emitter, \"size\", emitter_type_size,\n\t\t\t &sv);\n\n\t\t\tCTL_LEAF(arenas_bin_mib, 3, \"nregs\", &u32v, uint32_t);\n\t\t\temitter_json_kv(emitter, \"nregs\", emitter_type_uint32,\n\t\t\t &u32v);\n\n\t\t\tCTL_LEAF(arenas_bin_mib, 3, \"slab_size\", &sv, size_t);\n\t\t\temitter_json_kv(emitter, \"slab_size\", emitter_type_size,\n\t\t\t &sv);\n\n\t\t\tCTL_LEAF(arenas_bin_mib, 3, \"nshards\", &u32v, uint32_t);\n\t\t\temitter_json_kv(emitter, \"nshards\", emitter_type_uint32,\n\t\t\t &u32v);\n\n\t\t\temitter_json_object_end(emitter);\n\t\t}\n\t\temitter_json_array_end(emitter); /* Close \"bin\". */\n\t}\n\n\tunsigned nlextents;\n\tCTL_GET(\"arenas.nlextents\", &nlextents, unsigned);\n\temitter_kv(emitter, \"nlextents\", \"Number of large size classes\",\n\t emitter_type_unsigned, &nlextents);\n\n\tif (emitter_outputs_json(emitter)) {\n\t\temitter_json_array_kv_begin(emitter, \"lextent\");\n\t\tsize_t arenas_lextent_mib[CTL_MAX_DEPTH];\n\t\tCTL_LEAF_PREPARE(arenas_lextent_mib, 0, \"arenas.lextent\");\n\t\tfor (unsigned i = 0; i < nlextents; i++) {\n\t\t\tarenas_lextent_mib[2] = i;\n\t\t\temitter_json_object_begin(emitter);\n\n\t\t\tCTL_LEAF(arenas_lextent_mib, 3, \"size\", &sv, size_t);\n\t\t\temitter_json_kv(emitter, \"size\", emitter_type_size,\n\t\t\t &sv);\n\n\t\t\temitter_json_object_end(emitter);\n\t\t}\n\t\temitter_json_array_end(emitter); /* Close \"lextent\". */\n\t}\n\n\temitter_json_object_end(emitter); /* Close \"arenas\" */\n}\n\nJEMALLOC_COLD\nstatic void\nstats_print_helper(emitter_t *emitter, bool merged, bool destroyed,\n bool unmerged, bool bins, bool large, bool mutex, bool extents, bool hpa) {\n\t/*\n\t * These should be deleted. We keep them around for a while, to aid in\n\t * the transition to the emitter code.\n\t */\n\tsize_t allocated, active, metadata, metadata_thp, resident, mapped,\n\t retained;\n\tsize_t num_background_threads;\n\tsize_t zero_reallocs;\n\tuint64_t background_thread_num_runs, background_thread_run_interval;\n\n\tCTL_GET(\"stats.allocated\", &allocated, size_t);\n\tCTL_GET(\"stats.active\", &active, size_t);\n\tCTL_GET(\"stats.metadata\", &metadata, size_t);\n\tCTL_GET(\"stats.metadata_thp\", &metadata_thp, size_t);\n\tCTL_GET(\"stats.resident\", &resident, size_t);\n\tCTL_GET(\"stats.mapped\", &mapped, size_t);\n\tCTL_GET(\"stats.retained\", &retained, size_t);\n\n\tCTL_GET(\"stats.zero_reallocs\", &zero_reallocs, size_t);\n\n\tif (have_background_thread) {\n\t\tCTL_GET(\"stats.background_thread.num_threads\",\n\t\t &num_background_threads, size_t);\n\t\tCTL_GET(\"stats.background_thread.num_runs\",\n\t\t &background_thread_num_runs, uint64_t);\n\t\tCTL_GET(\"stats.background_thread.run_interval\",\n\t\t &background_thread_run_interval, uint64_t);\n\t} else {\n\t\tnum_background_threads = 0;\n\t\tbackground_thread_num_runs = 0;\n\t\tbackground_thread_run_interval = 0;\n\t}\n\n\t/* Generic global stats. */\n\temitter_json_object_kv_begin(emitter, \"stats\");\n\temitter_json_kv(emitter, \"allocated\", emitter_type_size, &allocated);\n\temitter_json_kv(emitter, \"active\", emitter_type_size, &active);\n\temitter_json_kv(emitter, \"metadata\", emitter_type_size, &metadata);\n\temitter_json_kv(emitter, \"metadata_thp\", emitter_type_size,\n\t &metadata_thp);\n\temitter_json_kv(emitter, \"resident\", emitter_type_size, &resident);\n\temitter_json_kv(emitter, \"mapped\", emitter_type_size, &mapped);\n\temitter_json_kv(emitter, \"retained\", emitter_type_size, &retained);\n\temitter_json_kv(emitter, \"zero_reallocs\", emitter_type_size,\n\t &zero_reallocs);\n\n\temitter_table_printf(emitter, \"Allocated: %zu, active: %zu, \"\n\t \"metadata: %zu (n_thp %zu), resident: %zu, mapped: %zu, \"\n\t \"retained: %zu\\n\", allocated, active, metadata, metadata_thp,\n\t resident, mapped, retained);\n\n\t/* Strange behaviors */\n\temitter_table_printf(emitter,\n\t \"Count of realloc(non-null-ptr, 0) calls: %zu\\n\", zero_reallocs);\n\n\t/* Background thread stats. */\n\temitter_json_object_kv_begin(emitter, \"background_thread\");\n\temitter_json_kv(emitter, \"num_threads\", emitter_type_size,\n\t &num_background_threads);\n\temitter_json_kv(emitter, \"num_runs\", emitter_type_uint64,\n\t &background_thread_num_runs);\n\temitter_json_kv(emitter, \"run_interval\", emitter_type_uint64,\n\t &background_thread_run_interval);\n\temitter_json_object_end(emitter); /* Close \"background_thread\". */\n\n\temitter_table_printf(emitter, \"Background threads: %zu, \"\n\t \"num_runs: %\"FMTu64\", run_interval: %\"FMTu64\" ns\\n\",\n\t num_background_threads, background_thread_num_runs,\n\t background_thread_run_interval);\n\n\tif (mutex) {\n\t\temitter_row_t row;\n\t\temitter_col_t name;\n\t\temitter_col_t col64[mutex_prof_num_uint64_t_counters];\n\t\temitter_col_t col32[mutex_prof_num_uint32_t_counters];\n\t\tuint64_t uptime;\n\n\t\temitter_row_init(&row);\n\t\tmutex_stats_init_cols(&row, \"\", &name, col64, col32);\n\n\t\temitter_table_row(emitter, &row);\n\t\temitter_json_object_kv_begin(emitter, \"mutexes\");\n\n\t\tCTL_M2_GET(\"stats.arenas.0.uptime\", 0, &uptime, uint64_t);\n\n\t\tsize_t stats_mutexes_mib[CTL_MAX_DEPTH];\n\t\tCTL_LEAF_PREPARE(stats_mutexes_mib, 0, \"stats.mutexes\");\n\t\tfor (int i = 0; i < mutex_prof_num_global_mutexes; i++) {\n\t\t\tmutex_stats_read_global(stats_mutexes_mib, 2,\n\t\t\t global_mutex_names[i], &name, col64, col32, uptime);\n\t\t\temitter_json_object_kv_begin(emitter, global_mutex_names[i]);\n\t\t\tmutex_stats_emit(emitter, &row, col64, col32);\n\t\t\temitter_json_object_end(emitter);\n\t\t}\n\n\t\temitter_json_object_end(emitter); /* Close \"mutexes\". */\n\t}\n\n\temitter_json_object_end(emitter); /* Close \"stats\". */\n\n\tif (merged || destroyed || unmerged) {\n\t\tunsigned narenas;\n\n\t\temitter_json_object_kv_begin(emitter, \"stats.arenas\");\n\n\t\tCTL_GET(\"arenas.narenas\", &narenas, unsigned);\n\t\tsize_t mib[3];\n\t\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\t\tsize_t sz;\n\t\tVARIABLE_ARRAY(bool, initialized, narenas);\n\t\tbool destroyed_initialized;\n\t\tunsigned i, j, ninitialized;\n\n\t\txmallctlnametomib(\"arena.0.initialized\", mib, &miblen);\n\t\tfor (i = ninitialized = 0; i < narenas; i++) {\n\t\t\tmib[1] = i;\n\t\t\tsz = sizeof(bool);\n\t\t\txmallctlbymib(mib, miblen, &initialized[i], &sz,\n\t\t\t NULL, 0);\n\t\t\tif (initialized[i]) {\n\t\t\t\tninitialized++;\n\t\t\t}\n\t\t}\n\t\tmib[1] = MALLCTL_ARENAS_DESTROYED;\n\t\tsz = sizeof(bool);\n\t\txmallctlbymib(mib, miblen, &destroyed_initialized, &sz,\n\t\t NULL, 0);\n\n\t\t/* Merged stats. */\n\t\tif (merged && (ninitialized > 1 || !unmerged)) {\n\t\t\t/* Print merged arena stats. */\n\t\t\temitter_table_printf(emitter, \"Merged arenas stats:\\n\");\n\t\t\temitter_json_object_kv_begin(emitter, \"merged\");\n\t\t\tstats_arena_print(emitter, MALLCTL_ARENAS_ALL, bins,\n\t\t\t large, mutex, extents, hpa);\n\t\t\temitter_json_object_end(emitter); /* Close \"merged\". */\n\t\t}\n\n\t\t/* Destroyed stats. */\n\t\tif (destroyed_initialized && destroyed) {\n\t\t\t/* Print destroyed arena stats. */\n\t\t\temitter_table_printf(emitter,\n\t\t\t \"Destroyed arenas stats:\\n\");\n\t\t\temitter_json_object_kv_begin(emitter, \"destroyed\");\n\t\t\tstats_arena_print(emitter, MALLCTL_ARENAS_DESTROYED,\n\t\t\t bins, large, mutex, extents, hpa);\n\t\t\temitter_json_object_end(emitter); /* Close \"destroyed\". */\n\t\t}\n\n\t\t/* Unmerged stats. */\n\t\tif (unmerged) {\n\t\t\tfor (i = j = 0; i < narenas; i++) {\n\t\t\t\tif (initialized[i]) {\n\t\t\t\t\tchar arena_ind_str[20];\n\t\t\t\t\tmalloc_snprintf(arena_ind_str,\n\t\t\t\t\t sizeof(arena_ind_str), \"%u\", i);\n\t\t\t\t\temitter_json_object_kv_begin(emitter,\n\t\t\t\t\t arena_ind_str);\n\t\t\t\t\temitter_table_printf(emitter,\n\t\t\t\t\t \"arenas[%s]:\\n\", arena_ind_str);\n\t\t\t\t\tstats_arena_print(emitter, i, bins,\n\t\t\t\t\t large, mutex, extents, hpa);\n\t\t\t\t\t/* Close \"\". */\n\t\t\t\t\temitter_json_object_end(emitter);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\temitter_json_object_end(emitter); /* Close \"stats.arenas\". */\n\t}\n}\n\nvoid\nstats_print(write_cb_t *write_cb, void *cbopaque, const char *opts) {\n\tint err;\n\tuint64_t epoch;\n\tsize_t u64sz;\n#define OPTION(o, v, d, s) bool v = d;\n\tSTATS_PRINT_OPTIONS\n#undef OPTION\n\n\t/*\n\t * Refresh stats, in case mallctl() was called by the application.\n\t *\n\t * Check for OOM here, since refreshing the ctl cache can trigger\n\t * allocation. In practice, none of the subsequent mallctl()-related\n\t * calls in this function will cause OOM if this one succeeds.\n\t * */\n\tepoch = 1;\n\tu64sz = sizeof(uint64_t);\n\terr = je_mallctl(\"epoch\", (void *)&epoch, &u64sz, (void *)&epoch,\n\t sizeof(uint64_t));\n\tif (err != 0) {\n\t\tif (err == EAGAIN) {\n\t\t\tmalloc_write(\": Memory allocation failure in \"\n\t\t\t \"mallctl(\\\"epoch\\\", ...)\\n\");\n\t\t\treturn;\n\t\t}\n\t\tmalloc_write(\": Failure in mallctl(\\\"epoch\\\", \"\n\t\t \"...)\\n\");\n\t\tabort();\n\t}\n\n\tif (opts != NULL) {\n\t\tfor (unsigned i = 0; opts[i] != '\\0'; i++) {\n\t\t\tswitch (opts[i]) {\n#define OPTION(o, v, d, s) case o: v = s; break;\n\t\t\t\tSTATS_PRINT_OPTIONS\n#undef OPTION\n\t\t\tdefault:;\n\t\t\t}\n\t\t}\n\t}\n\n\temitter_t emitter;\n\temitter_init(&emitter,\n\t json ? emitter_output_json_compact : emitter_output_table,\n\t write_cb, cbopaque);\n\temitter_begin(&emitter);\n\temitter_table_printf(&emitter, \"___ Begin jemalloc statistics ___\\n\");\n\temitter_json_object_kv_begin(&emitter, \"jemalloc\");\n\n\tif (general) {\n\t\tstats_general_print(&emitter);\n\t}\n\tif (config_stats) {\n\t\tstats_print_helper(&emitter, merged, destroyed, unmerged,\n\t\t bins, large, mutex, extents, hpa);\n\t}\n\n\temitter_json_object_end(&emitter); /* Closes the \"jemalloc\" dict. */\n\temitter_table_printf(&emitter, \"--- End jemalloc statistics ---\\n\");\n\temitter_end(&emitter);\n}\n\nuint64_t\nstats_interval_new_event_wait(tsd_t *tsd) {\n\treturn stats_interval_accum_batch;\n}\n\nuint64_t\nstats_interval_postponed_event_wait(tsd_t *tsd) {\n\treturn TE_MIN_START_WAIT;\n}\n\nvoid\nstats_interval_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tassert(elapsed > 0 && elapsed != TE_INVALID_ELAPSED);\n\tif (counter_accum(tsd_tsdn(tsd), &stats_interval_accumulated,\n\t elapsed)) {\n\t\tje_malloc_stats_print(NULL, NULL, opt_stats_interval_opts);\n\t}\n}\n\nbool\nstats_boot(void) {\n\tuint64_t stats_interval;\n\tif (opt_stats_interval < 0) {\n\t\tassert(opt_stats_interval == -1);\n\t\tstats_interval = 0;\n\t\tstats_interval_accum_batch = 0;\n\t} else{\n\t\t/* See comments in stats.h */\n\t\tstats_interval = (opt_stats_interval > 0) ?\n\t\t opt_stats_interval : 1;\n\t\tuint64_t batch = stats_interval >>\n\t\t STATS_INTERVAL_ACCUM_LG_BATCH_SIZE;\n\t\tif (batch > STATS_INTERVAL_ACCUM_BATCH_MAX) {\n\t\t\tbatch = STATS_INTERVAL_ACCUM_BATCH_MAX;\n\t\t} else if (batch == 0) {\n\t\t\tbatch = 1;\n\t\t}\n\t\tstats_interval_accum_batch = batch;\n\t}\n\n\treturn counter_accum_init(&stats_interval_accumulated, stats_interval);\n}\n\nvoid\nstats_prefork(tsdn_t *tsdn) {\n\tcounter_prefork(tsdn, &stats_interval_accumulated);\n}\n\nvoid\nstats_postfork_parent(tsdn_t *tsdn) {\n\tcounter_postfork_parent(tsdn, &stats_interval_accumulated);\n}\n\nvoid\nstats_postfork_child(tsdn_t *tsdn) {\n\tcounter_postfork_child(tsdn, &stats_interval_accumulated);\n}\n" }, { "path": "deps/jemalloc/src/sz.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n#include \"jemalloc/internal/sz.h\"\n\nJEMALLOC_ALIGNED(CACHELINE)\nsize_t sz_pind2sz_tab[SC_NPSIZES+1];\nsize_t sz_large_pad;\n\nsize_t\nsz_psz_quantize_floor(size_t size) {\n\tsize_t ret;\n\tpszind_t pind;\n\n\tassert(size > 0);\n\tassert((size & PAGE_MASK) == 0);\n\n\tpind = sz_psz2ind(size - sz_large_pad + 1);\n\tif (pind == 0) {\n\t\t/*\n\t\t * Avoid underflow. This short-circuit would also do the right\n\t\t * thing for all sizes in the range for which there are\n\t\t * PAGE-spaced size classes, but it's simplest to just handle\n\t\t * the one case that would cause erroneous results.\n\t\t */\n\t\treturn size;\n\t}\n\tret = sz_pind2sz(pind - 1) + sz_large_pad;\n\tassert(ret <= size);\n\treturn ret;\n}\n\nsize_t\nsz_psz_quantize_ceil(size_t size) {\n\tsize_t ret;\n\n\tassert(size > 0);\n\tassert(size - sz_large_pad <= SC_LARGE_MAXCLASS);\n\tassert((size & PAGE_MASK) == 0);\n\n\tret = sz_psz_quantize_floor(size);\n\tif (ret < size) {\n\t\t/*\n\t\t * Skip a quantization that may have an adequately large extent,\n\t\t * because under-sized extents may be mixed in. This only\n\t\t * happens when an unusual size is requested, i.e. for aligned\n\t\t * allocation, and is just one of several places where linear\n\t\t * search would potentially find sufficiently aligned available\n\t\t * memory somewhere lower.\n\t\t */\n\t\tret = sz_pind2sz(sz_psz2ind(ret - sz_large_pad + 1)) +\n\t\t sz_large_pad;\n\t}\n\treturn ret;\n}\n\nstatic void\nsz_boot_pind2sz_tab(const sc_data_t *sc_data) {\n\tint pind = 0;\n\tfor (unsigned i = 0; i < SC_NSIZES; i++) {\n\t\tconst sc_t *sc = &sc_data->sc[i];\n\t\tif (sc->psz) {\n\t\t\tsz_pind2sz_tab[pind] = (ZU(1) << sc->lg_base)\n\t\t\t + (ZU(sc->ndelta) << sc->lg_delta);\n\t\t\tpind++;\n\t\t}\n\t}\n\tfor (int i = pind; i <= (int)SC_NPSIZES; i++) {\n\t\tsz_pind2sz_tab[pind] = sc_data->large_maxclass + PAGE;\n\t}\n}\n\nJEMALLOC_ALIGNED(CACHELINE)\nsize_t sz_index2size_tab[SC_NSIZES];\n\nstatic void\nsz_boot_index2size_tab(const sc_data_t *sc_data) {\n\tfor (unsigned i = 0; i < SC_NSIZES; i++) {\n\t\tconst sc_t *sc = &sc_data->sc[i];\n\t\tsz_index2size_tab[i] = (ZU(1) << sc->lg_base)\n\t\t + (ZU(sc->ndelta) << (sc->lg_delta));\n\t}\n}\n\n/*\n * To keep this table small, we divide sizes by the tiny min size, which gives\n * the smallest interval for which the result can change.\n */\nJEMALLOC_ALIGNED(CACHELINE)\nuint8_t sz_size2index_tab[(SC_LOOKUP_MAXCLASS >> SC_LG_TINY_MIN) + 1];\n\nstatic void\nsz_boot_size2index_tab(const sc_data_t *sc_data) {\n\tsize_t dst_max = (SC_LOOKUP_MAXCLASS >> SC_LG_TINY_MIN) + 1;\n\tsize_t dst_ind = 0;\n\tfor (unsigned sc_ind = 0; sc_ind < SC_NSIZES && dst_ind < dst_max;\n\t sc_ind++) {\n\t\tconst sc_t *sc = &sc_data->sc[sc_ind];\n\t\tsize_t sz = (ZU(1) << sc->lg_base)\n\t\t + (ZU(sc->ndelta) << sc->lg_delta);\n\t\tsize_t max_ind = ((sz + (ZU(1) << SC_LG_TINY_MIN) - 1)\n\t\t\t\t >> SC_LG_TINY_MIN);\n\t\tfor (; dst_ind <= max_ind && dst_ind < dst_max; dst_ind++) {\n\t\t\tsz_size2index_tab[dst_ind] = sc_ind;\n\t\t}\n\t}\n}\n\nvoid\nsz_boot(const sc_data_t *sc_data, bool cache_oblivious) {\n\tsz_large_pad = cache_oblivious ? PAGE : 0;\n\tsz_boot_pind2sz_tab(sc_data);\n\tsz_boot_index2size_tab(sc_data);\n\tsz_boot_size2index_tab(sc_data);\n}\n" }, { "path": "deps/jemalloc/src/tcache.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/safety_check.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/sc.h\"\n\n/******************************************************************************/\n/* Data. */\n\nbool opt_tcache = true;\n\n/* tcache_maxclass is set to 32KB by default. */\nsize_t opt_tcache_max = ((size_t)1) << 15;\n\n/* Reasonable defaults for min and max values. */\nunsigned opt_tcache_nslots_small_min = 20;\nunsigned opt_tcache_nslots_small_max = 200;\nunsigned opt_tcache_nslots_large = 20;\n\n/*\n * We attempt to make the number of slots in a tcache bin for a given size class\n * equal to the number of objects in a slab times some multiplier. By default,\n * the multiplier is 2 (i.e. we set the maximum number of objects in the tcache\n * to twice the number of objects in a slab).\n * This is bounded by some other constraints as well, like the fact that it\n * must be even, must be less than opt_tcache_nslots_small_max, etc..\n */\nssize_t\topt_lg_tcache_nslots_mul = 1;\n\n/*\n * Number of allocation bytes between tcache incremental GCs. Again, this\n * default just seems to work well; more tuning is possible.\n */\nsize_t opt_tcache_gc_incr_bytes = 65536;\n\n/*\n * With default settings, we may end up flushing small bins frequently with\n * small flush amounts. To limit this tendency, we can set a number of bytes to\n * \"delay\" by. If we try to flush N M-byte items, we decrease that size-class's\n * delay by N * M. So, if delay is 1024 and we're looking at the 64-byte size\n * class, we won't do any flushing until we've been asked to flush 1024/64 == 16\n * items. This can happen in any configuration (i.e. being asked to flush 16\n * items once, or 4 items 4 times).\n *\n * Practically, this is stored as a count of items in a uint8_t, so the\n * effective maximum value for a size class is 255 * sz.\n */\nsize_t opt_tcache_gc_delay_bytes = 0;\n\n/*\n * When a cache bin is flushed because it's full, how much of it do we flush?\n * By default, we flush half the maximum number of items.\n */\nunsigned opt_lg_tcache_flush_small_div = 1;\nunsigned opt_lg_tcache_flush_large_div = 1;\n\ncache_bin_info_t\t*tcache_bin_info;\n\n/* Total stack size required (per tcache). Include the padding above. */\nstatic size_t tcache_bin_alloc_size;\nstatic size_t tcache_bin_alloc_alignment;\n\n/* Number of cache bins enabled, including both large and small. */\nunsigned\t\tnhbins;\n/* Max size class to be cached (can be small or large). */\nsize_t\t\t\ttcache_maxclass;\n\ntcaches_t\t\t*tcaches;\n\n/* Index of first element within tcaches that has never been used. */\nstatic unsigned\t\ttcaches_past;\n\n/* Head of singly linked list tracking available tcaches elements. */\nstatic tcaches_t\t*tcaches_avail;\n\n/* Protects tcaches{,_past,_avail}. */\nstatic malloc_mutex_t\ttcaches_mtx;\n\n/******************************************************************************/\n\nsize_t\ntcache_salloc(tsdn_t *tsdn, const void *ptr) {\n\treturn arena_salloc(tsdn, ptr);\n}\n\nuint64_t\ntcache_gc_new_event_wait(tsd_t *tsd) {\n\treturn opt_tcache_gc_incr_bytes;\n}\n\nuint64_t\ntcache_gc_postponed_event_wait(tsd_t *tsd) {\n\treturn TE_MIN_START_WAIT;\n}\n\nuint64_t\ntcache_gc_dalloc_new_event_wait(tsd_t *tsd) {\n\treturn opt_tcache_gc_incr_bytes;\n}\n\nuint64_t\ntcache_gc_dalloc_postponed_event_wait(tsd_t *tsd) {\n\treturn TE_MIN_START_WAIT;\n}\n\nstatic uint8_t\ntcache_gc_item_delay_compute(szind_t szind) {\n\tassert(szind < SC_NBINS);\n\tsize_t sz = sz_index2size(szind);\n\tsize_t item_delay = opt_tcache_gc_delay_bytes / sz;\n\tsize_t delay_max = ZU(1)\n\t << (sizeof(((tcache_slow_t *)NULL)->bin_flush_delay_items[0]) * 8);\n\tif (item_delay >= delay_max) {\n\t\titem_delay = delay_max - 1;\n\t}\n\treturn (uint8_t)item_delay;\n}\n\nstatic void\ntcache_gc_small(tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache,\n szind_t szind) {\n\t/* Aim to flush 3/4 of items below low-water. */\n\tassert(szind < SC_NBINS);\n\n\tcache_bin_t *cache_bin = &tcache->bins[szind];\n\tcache_bin_sz_t ncached = cache_bin_ncached_get_local(cache_bin,\n\t &tcache_bin_info[szind]);\n\tcache_bin_sz_t low_water = cache_bin_low_water_get(cache_bin,\n\t &tcache_bin_info[szind]);\n\tassert(!tcache_slow->bin_refilled[szind]);\n\n\tsize_t nflush = low_water - (low_water >> 2);\n\tif (nflush < tcache_slow->bin_flush_delay_items[szind]) {\n\t\t/* Workaround for a conversion warning. */\n\t\tuint8_t nflush_uint8 = (uint8_t)nflush;\n\t\tassert(sizeof(tcache_slow->bin_flush_delay_items[0]) ==\n\t\t sizeof(nflush_uint8));\n\t\ttcache_slow->bin_flush_delay_items[szind] -= nflush_uint8;\n\t\treturn;\n\t} else {\n\t\ttcache_slow->bin_flush_delay_items[szind]\n\t\t = tcache_gc_item_delay_compute(szind);\n\t}\n\n\ttcache_bin_flush_small(tsd, tcache, cache_bin, szind,\n\t (unsigned)(ncached - nflush));\n\n\t/*\n\t * Reduce fill count by 2X. Limit lg_fill_div such that\n\t * the fill count is always at least 1.\n\t */\n\tif ((cache_bin_info_ncached_max(&tcache_bin_info[szind])\n\t >> (tcache_slow->lg_fill_div[szind] + 1)) >= 1) {\n\t\ttcache_slow->lg_fill_div[szind]++;\n\t}\n}\n\nstatic void\ntcache_gc_large(tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache,\n szind_t szind) {\n\t/* Like the small GC; flush 3/4 of untouched items. */\n\tassert(szind >= SC_NBINS);\n\tcache_bin_t *cache_bin = &tcache->bins[szind];\n\tcache_bin_sz_t ncached = cache_bin_ncached_get_local(cache_bin,\n\t &tcache_bin_info[szind]);\n\tcache_bin_sz_t low_water = cache_bin_low_water_get(cache_bin,\n\t &tcache_bin_info[szind]);\n\ttcache_bin_flush_large(tsd, tcache, cache_bin, szind,\n\t (unsigned)(ncached - low_water + (low_water >> 2)));\n}\n\nstatic void\ntcache_event(tsd_t *tsd) {\n\ttcache_t *tcache = tcache_get(tsd);\n\tif (tcache == NULL) {\n\t\treturn;\n\t}\n\n\ttcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);\n\tszind_t szind = tcache_slow->next_gc_bin;\n\tbool is_small = (szind < SC_NBINS);\n\tcache_bin_t *cache_bin = &tcache->bins[szind];\n\n\ttcache_bin_flush_stashed(tsd, tcache, cache_bin, szind, is_small);\n\n\tcache_bin_sz_t low_water = cache_bin_low_water_get(cache_bin,\n\t &tcache_bin_info[szind]);\n\tif (low_water > 0) {\n\t\tif (is_small) {\n\t\t\ttcache_gc_small(tsd, tcache_slow, tcache, szind);\n\t\t} else {\n\t\t\ttcache_gc_large(tsd, tcache_slow, tcache, szind);\n\t\t}\n\t} else if (is_small && tcache_slow->bin_refilled[szind]) {\n\t\tassert(low_water == 0);\n\t\t/*\n\t\t * Increase fill count by 2X for small bins. Make sure\n\t\t * lg_fill_div stays greater than 0.\n\t\t */\n\t\tif (tcache_slow->lg_fill_div[szind] > 1) {\n\t\t\ttcache_slow->lg_fill_div[szind]--;\n\t\t}\n\t\ttcache_slow->bin_refilled[szind] = false;\n\t}\n\tcache_bin_low_water_set(cache_bin);\n\n\ttcache_slow->next_gc_bin++;\n\tif (tcache_slow->next_gc_bin == nhbins) {\n\t\ttcache_slow->next_gc_bin = 0;\n\t}\n}\n\nvoid\ntcache_gc_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tassert(elapsed == TE_INVALID_ELAPSED);\n\ttcache_event(tsd);\n}\n\nvoid\ntcache_gc_dalloc_event_handler(tsd_t *tsd, uint64_t elapsed) {\n\tassert(elapsed == TE_INVALID_ELAPSED);\n\ttcache_event(tsd);\n}\n\nvoid *\ntcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena,\n tcache_t *tcache, cache_bin_t *cache_bin, szind_t binind,\n bool *tcache_success) {\n\ttcache_slow_t *tcache_slow = tcache->tcache_slow;\n\tvoid *ret;\n\n\tassert(tcache_slow->arena != NULL);\n\tunsigned nfill = cache_bin_info_ncached_max(&tcache_bin_info[binind])\n\t >> tcache_slow->lg_fill_div[binind];\n\tarena_cache_bin_fill_small(tsdn, arena, cache_bin,\n\t &tcache_bin_info[binind], binind, nfill);\n\ttcache_slow->bin_refilled[binind] = true;\n\tret = cache_bin_alloc(cache_bin, tcache_success);\n\n\treturn ret;\n}\n\nstatic const void *\ntcache_bin_flush_ptr_getter(void *arr_ctx, size_t ind) {\n\tcache_bin_ptr_array_t *arr = (cache_bin_ptr_array_t *)arr_ctx;\n\treturn arr->ptr[ind];\n}\n\nstatic void\ntcache_bin_flush_metadata_visitor(void *szind_sum_ctx,\n emap_full_alloc_ctx_t *alloc_ctx) {\n\tsize_t *szind_sum = (size_t *)szind_sum_ctx;\n\t*szind_sum -= alloc_ctx->szind;\n\tutil_prefetch_write_range(alloc_ctx->edata, sizeof(edata_t));\n}\n\nJEMALLOC_NOINLINE static void\ntcache_bin_flush_size_check_fail(cache_bin_ptr_array_t *arr, szind_t szind,\n size_t nptrs, emap_batch_lookup_result_t *edatas) {\n\tbool found_mismatch = false;\n\tfor (size_t i = 0; i < nptrs; i++) {\n\t\tszind_t true_szind = edata_szind_get(edatas[i].edata);\n\t\tif (true_szind != szind) {\n\t\t\tfound_mismatch = true;\n\t\t\tsafety_check_fail_sized_dealloc(\n\t\t\t /* current_dealloc */ false,\n\t\t\t /* ptr */ tcache_bin_flush_ptr_getter(arr, i),\n\t\t\t /* true_size */ sz_index2size(true_szind),\n\t\t\t /* input_size */ sz_index2size(szind));\n\t\t}\n\t}\n\tassert(found_mismatch);\n}\n\nstatic void\ntcache_bin_flush_edatas_lookup(tsd_t *tsd, cache_bin_ptr_array_t *arr,\n szind_t binind, size_t nflush, emap_batch_lookup_result_t *edatas) {\n\n\t/*\n\t * This gets compiled away when config_opt_safety_checks is false.\n\t * Checks for sized deallocation bugs, failing early rather than\n\t * corrupting metadata.\n\t */\n\tsize_t szind_sum = binind * nflush;\n\temap_edata_lookup_batch(tsd, &arena_emap_global, nflush,\n\t &tcache_bin_flush_ptr_getter, (void *)arr,\n\t &tcache_bin_flush_metadata_visitor, (void *)&szind_sum,\n\t edatas);\n\tif (config_opt_safety_checks && unlikely(szind_sum != 0)) {\n\t\ttcache_bin_flush_size_check_fail(arr, binind, nflush, edatas);\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE bool\ntcache_bin_flush_match(edata_t *edata, unsigned cur_arena_ind,\n unsigned cur_binshard, bool small) {\n\tif (small) {\n\t\treturn edata_arena_ind_get(edata) == cur_arena_ind\n\t\t && edata_binshard_get(edata) == cur_binshard;\n\t} else {\n\t\treturn edata_arena_ind_get(edata) == cur_arena_ind;\n\t}\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntcache_bin_flush_impl(tsd_t *tsd, tcache_t *tcache, cache_bin_t *cache_bin,\n szind_t binind, cache_bin_ptr_array_t *ptrs, unsigned nflush, bool small) {\n\ttcache_slow_t *tcache_slow = tcache->tcache_slow;\n\t/*\n\t * A couple lookup calls take tsdn; declare it once for convenience\n\t * instead of calling tsd_tsdn(tsd) all the time.\n\t */\n\ttsdn_t *tsdn = tsd_tsdn(tsd);\n\n\tif (small) {\n\t\tassert(binind < SC_NBINS);\n\t} else {\n\t\tassert(binind < nhbins);\n\t}\n\tarena_t *tcache_arena = tcache_slow->arena;\n\tassert(tcache_arena != NULL);\n\n\t/*\n\t * Variable length array must have > 0 length; the last element is never\n\t * touched (it's just included to satisfy the no-zero-length rule).\n\t */\n\tVARIABLE_ARRAY(emap_batch_lookup_result_t, item_edata, nflush + 1);\n\ttcache_bin_flush_edatas_lookup(tsd, ptrs, binind, nflush, item_edata);\n\n\t/*\n\t * The slabs where we freed the last remaining object in the slab (and\n\t * so need to free the slab itself).\n\t * Used only if small == true.\n\t */\n\tunsigned dalloc_count = 0;\n\tVARIABLE_ARRAY(edata_t *, dalloc_slabs, nflush + 1);\n\n\t/*\n\t * We're about to grab a bunch of locks. If one of them happens to be\n\t * the one guarding the arena-level stats counters we flush our\n\t * thread-local ones to, we do so under one critical section.\n\t */\n\tbool merged_stats = false;\n\twhile (nflush > 0) {\n\t\t/* Lock the arena, or bin, associated with the first object. */\n\t\tedata_t *edata = item_edata[0].edata;\n\t\tunsigned cur_arena_ind = edata_arena_ind_get(edata);\n\t\tarena_t *cur_arena = arena_get(tsdn, cur_arena_ind, false);\n\n\t\t/*\n\t\t * These assignments are always overwritten when small is true,\n\t\t * and their values are always ignored when small is false, but\n\t\t * to avoid the technical UB when we pass them as parameters, we\n\t\t * need to intialize them.\n\t\t */\n\t\tunsigned cur_binshard = 0;\n\t\tbin_t *cur_bin = NULL;\n\t\tif (small) {\n\t\t\tcur_binshard = edata_binshard_get(edata);\n\t\t\tcur_bin = arena_get_bin(cur_arena, binind,\n\t\t\t cur_binshard);\n\t\t\tassert(cur_binshard < bin_infos[binind].n_shards);\n\t\t\t/*\n\t\t\t * If you're looking at profiles, you might think this\n\t\t\t * is a good place to prefetch the bin stats, which are\n\t\t\t * often a cache miss. This turns out not to be\n\t\t\t * helpful on the workloads we've looked at, with moving\n\t\t\t * the bin stats next to the lock seeming to do better.\n\t\t\t */\n\t\t}\n\n\t\tif (small) {\n\t\t\tmalloc_mutex_lock(tsdn, &cur_bin->lock);\n\t\t}\n\t\tif (!small && !arena_is_auto(cur_arena)) {\n\t\t\tmalloc_mutex_lock(tsdn, &cur_arena->large_mtx);\n\t\t}\n\n\t\t/*\n\t\t * If we acquired the right lock and have some stats to flush,\n\t\t * flush them.\n\t\t */\n\t\tif (config_stats && tcache_arena == cur_arena\n\t\t && !merged_stats) {\n\t\t\tmerged_stats = true;\n\t\t\tif (small) {\n\t\t\t\tcur_bin->stats.nflushes++;\n\t\t\t\tcur_bin->stats.nrequests +=\n\t\t\t\t cache_bin->tstats.nrequests;\n\t\t\t\tcache_bin->tstats.nrequests = 0;\n\t\t\t} else {\n\t\t\t\tarena_stats_large_flush_nrequests_add(tsdn,\n\t\t\t\t &tcache_arena->stats, binind,\n\t\t\t\t cache_bin->tstats.nrequests);\n\t\t\t\tcache_bin->tstats.nrequests = 0;\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * Large allocations need special prep done. Afterwards, we can\n\t\t * drop the large lock.\n\t\t */\n\t\tif (!small) {\n\t\t\tfor (unsigned i = 0; i < nflush; i++) {\n\t\t\t\tvoid *ptr = ptrs->ptr[i];\n\t\t\t\tedata = item_edata[i].edata;\n\t\t\t\tassert(ptr != NULL && edata != NULL);\n\n\t\t\t\tif (tcache_bin_flush_match(edata, cur_arena_ind,\n\t\t\t\t cur_binshard, small)) {\n\t\t\t\t\tlarge_dalloc_prep_locked(tsdn,\n\t\t\t\t\t edata);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!small && !arena_is_auto(cur_arena)) {\n\t\t\tmalloc_mutex_unlock(tsdn, &cur_arena->large_mtx);\n\t\t}\n\n\t\t/* Deallocate whatever we can. */\n\t\tunsigned ndeferred = 0;\n\t\t/* Init only to avoid used-uninitialized warning. */\n\t\tarena_dalloc_bin_locked_info_t dalloc_bin_info = {0};\n\t\tif (small) {\n\t\t\tarena_dalloc_bin_locked_begin(&dalloc_bin_info, binind);\n\t\t}\n\t\tfor (unsigned i = 0; i < nflush; i++) {\n\t\t\tvoid *ptr = ptrs->ptr[i];\n\t\t\tedata = item_edata[i].edata;\n\t\t\tassert(ptr != NULL && edata != NULL);\n\t\t\tif (!tcache_bin_flush_match(edata, cur_arena_ind,\n\t\t\t cur_binshard, small)) {\n\t\t\t\t/*\n\t\t\t\t * The object was allocated either via a\n\t\t\t\t * different arena, or a different bin in this\n\t\t\t\t * arena. Either way, stash the object so that\n\t\t\t\t * it can be handled in a future pass.\n\t\t\t\t */\n\t\t\t\tptrs->ptr[ndeferred] = ptr;\n\t\t\t\titem_edata[ndeferred].edata = edata;\n\t\t\t\tndeferred++;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (small) {\n\t\t\t\tif (arena_dalloc_bin_locked_step(tsdn,\n\t\t\t\t cur_arena, cur_bin, &dalloc_bin_info,\n\t\t\t\t binind, edata, ptr)) {\n\t\t\t\t\tdalloc_slabs[dalloc_count] = edata;\n\t\t\t\t\tdalloc_count++;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (large_dalloc_safety_checks(edata, ptr,\n\t\t\t\t binind)) {\n\t\t\t\t\t/* See the comment in isfree. */\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tlarge_dalloc_finish(tsdn, edata);\n\t\t\t}\n\t\t}\n\n\t\tif (small) {\n\t\t\tarena_dalloc_bin_locked_finish(tsdn, cur_arena, cur_bin,\n\t\t\t &dalloc_bin_info);\n\t\t\tmalloc_mutex_unlock(tsdn, &cur_bin->lock);\n\t\t}\n\t\tarena_decay_ticks(tsdn, cur_arena, nflush - ndeferred);\n\t\tnflush = ndeferred;\n\t}\n\n\t/* Handle all deferred slab dalloc. */\n\tassert(small || dalloc_count == 0);\n\tfor (unsigned i = 0; i < dalloc_count; i++) {\n\t\tedata_t *slab = dalloc_slabs[i];\n\t\tarena_slab_dalloc(tsdn, arena_get_from_edata(slab), slab);\n\n\t}\n\n\tif (config_stats && !merged_stats) {\n\t\tif (small) {\n\t\t\t/*\n\t\t\t * The flush loop didn't happen to flush to this\n\t\t\t * thread's arena, so the stats didn't get merged.\n\t\t\t * Manually do so now.\n\t\t\t */\n\t\t\tbin_t *bin = arena_bin_choose(tsdn, tcache_arena,\n\t\t\t binind, NULL);\n\t\t\tmalloc_mutex_lock(tsdn, &bin->lock);\n\t\t\tbin->stats.nflushes++;\n\t\t\tbin->stats.nrequests += cache_bin->tstats.nrequests;\n\t\t\tcache_bin->tstats.nrequests = 0;\n\t\t\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\t\t} else {\n\t\t\tarena_stats_large_flush_nrequests_add(tsdn,\n\t\t\t &tcache_arena->stats, binind,\n\t\t\t cache_bin->tstats.nrequests);\n\t\t\tcache_bin->tstats.nrequests = 0;\n\t\t}\n\t}\n\n}\n\nJEMALLOC_ALWAYS_INLINE void\ntcache_bin_flush_bottom(tsd_t *tsd, tcache_t *tcache, cache_bin_t *cache_bin,\n szind_t binind, unsigned rem, bool small) {\n\ttcache_bin_flush_stashed(tsd, tcache, cache_bin, binind, small);\n\n\tcache_bin_sz_t ncached = cache_bin_ncached_get_local(cache_bin,\n\t &tcache_bin_info[binind]);\n\tassert((cache_bin_sz_t)rem <= ncached);\n\tunsigned nflush = ncached - rem;\n\n\tCACHE_BIN_PTR_ARRAY_DECLARE(ptrs, nflush);\n\tcache_bin_init_ptr_array_for_flush(cache_bin, &tcache_bin_info[binind],\n\t &ptrs, nflush);\n\n\ttcache_bin_flush_impl(tsd, tcache, cache_bin, binind, &ptrs, nflush,\n\t small);\n\n\tcache_bin_finish_flush(cache_bin, &tcache_bin_info[binind], &ptrs,\n\t ncached - rem);\n}\n\nvoid\ntcache_bin_flush_small(tsd_t *tsd, tcache_t *tcache, cache_bin_t *cache_bin,\n szind_t binind, unsigned rem) {\n\ttcache_bin_flush_bottom(tsd, tcache, cache_bin, binind, rem, true);\n}\n\nvoid\ntcache_bin_flush_large(tsd_t *tsd, tcache_t *tcache, cache_bin_t *cache_bin,\n szind_t binind, unsigned rem) {\n\ttcache_bin_flush_bottom(tsd, tcache, cache_bin, binind, rem, false);\n}\n\n/*\n * Flushing stashed happens when 1) tcache fill, 2) tcache flush, or 3) tcache\n * GC event. This makes sure that the stashed items do not hold memory for too\n * long, and new buffers can only be allocated when nothing is stashed.\n *\n * The downside is, the time between stash and flush may be relatively short,\n * especially when the request rate is high. It lowers the chance of detecting\n * write-after-free -- however that is a delayed detection anyway, and is less\n * of a focus than the memory overhead.\n */\nvoid\ntcache_bin_flush_stashed(tsd_t *tsd, tcache_t *tcache, cache_bin_t *cache_bin,\n szind_t binind, bool is_small) {\n\tcache_bin_info_t *info = &tcache_bin_info[binind];\n\t/*\n\t * The two below are for assertion only. The content of original cached\n\t * items remain unchanged -- the stashed items reside on the other end\n\t * of the stack. Checking the stack head and ncached to verify.\n\t */\n\tvoid *head_content = *cache_bin->stack_head;\n\tcache_bin_sz_t orig_cached = cache_bin_ncached_get_local(cache_bin,\n\t info);\n\n\tcache_bin_sz_t nstashed = cache_bin_nstashed_get_local(cache_bin, info);\n\tassert(orig_cached + nstashed <= cache_bin_info_ncached_max(info));\n\tif (nstashed == 0) {\n\t\treturn;\n\t}\n\n\tCACHE_BIN_PTR_ARRAY_DECLARE(ptrs, nstashed);\n\tcache_bin_init_ptr_array_for_stashed(cache_bin, binind, info, &ptrs,\n\t nstashed);\n\tsan_check_stashed_ptrs(ptrs.ptr, nstashed, sz_index2size(binind));\n\ttcache_bin_flush_impl(tsd, tcache, cache_bin, binind, &ptrs, nstashed,\n\t is_small);\n\tcache_bin_finish_flush_stashed(cache_bin, info);\n\n\tassert(cache_bin_nstashed_get_local(cache_bin, info) == 0);\n\tassert(cache_bin_ncached_get_local(cache_bin, info) == orig_cached);\n\tassert(head_content == *cache_bin->stack_head);\n}\n\nvoid\ntcache_arena_associate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,\n tcache_t *tcache, arena_t *arena) {\n\tassert(tcache_slow->arena == NULL);\n\ttcache_slow->arena = arena;\n\n\tif (config_stats) {\n\t\t/* Link into list of extant tcaches. */\n\t\tmalloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);\n\n\t\tql_elm_new(tcache_slow, link);\n\t\tql_tail_insert(&arena->tcache_ql, tcache_slow, link);\n\t\tcache_bin_array_descriptor_init(\n\t\t &tcache_slow->cache_bin_array_descriptor, tcache->bins);\n\t\tql_tail_insert(&arena->cache_bin_array_descriptor_ql,\n\t\t &tcache_slow->cache_bin_array_descriptor, link);\n\n\t\tmalloc_mutex_unlock(tsdn, &arena->tcache_ql_mtx);\n\t}\n}\n\nstatic void\ntcache_arena_dissociate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,\n tcache_t *tcache) {\n\tarena_t *arena = tcache_slow->arena;\n\tassert(arena != NULL);\n\tif (config_stats) {\n\t\t/* Unlink from list of extant tcaches. */\n\t\tmalloc_mutex_lock(tsdn, &arena->tcache_ql_mtx);\n\t\tif (config_debug) {\n\t\t\tbool in_ql = false;\n\t\t\ttcache_slow_t *iter;\n\t\t\tql_foreach(iter, &arena->tcache_ql, link) {\n\t\t\t\tif (iter == tcache_slow) {\n\t\t\t\t\tin_ql = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tassert(in_ql);\n\t\t}\n\t\tql_remove(&arena->tcache_ql, tcache_slow, link);\n\t\tql_remove(&arena->cache_bin_array_descriptor_ql,\n\t\t &tcache_slow->cache_bin_array_descriptor, link);\n\t\ttcache_stats_merge(tsdn, tcache_slow->tcache, arena);\n\t\tmalloc_mutex_unlock(tsdn, &arena->tcache_ql_mtx);\n\t}\n\ttcache_slow->arena = NULL;\n}\n\nvoid\ntcache_arena_reassociate(tsdn_t *tsdn, tcache_slow_t *tcache_slow,\n tcache_t *tcache, arena_t *arena) {\n\ttcache_arena_dissociate(tsdn, tcache_slow, tcache);\n\ttcache_arena_associate(tsdn, tcache_slow, tcache, arena);\n}\n\nbool\ntsd_tcache_enabled_data_init(tsd_t *tsd) {\n\t/* Called upon tsd initialization. */\n\ttsd_tcache_enabled_set(tsd, opt_tcache);\n\ttsd_slow_update(tsd);\n\n\tif (opt_tcache) {\n\t\t/* Trigger tcache init. */\n\t\ttsd_tcache_data_init(tsd);\n\t}\n\n\treturn false;\n}\n\nstatic void\ntcache_init(tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache,\n void *mem) {\n\ttcache->tcache_slow = tcache_slow;\n\ttcache_slow->tcache = tcache;\n\n\tmemset(&tcache_slow->link, 0, sizeof(ql_elm(tcache_t)));\n\ttcache_slow->next_gc_bin = 0;\n\ttcache_slow->arena = NULL;\n\ttcache_slow->dyn_alloc = mem;\n\n\t/*\n\t * We reserve cache bins for all small size classes, even if some may\n\t * not get used (i.e. bins higher than nhbins). This allows the fast\n\t * and common paths to access cache bin metadata safely w/o worrying\n\t * about which ones are disabled.\n\t */\n\tunsigned n_reserved_bins = nhbins < SC_NBINS ? SC_NBINS : nhbins;\n\tmemset(tcache->bins, 0, sizeof(cache_bin_t) * n_reserved_bins);\n\n\tsize_t cur_offset = 0;\n\tcache_bin_preincrement(tcache_bin_info, nhbins, mem,\n\t &cur_offset);\n\tfor (unsigned i = 0; i < nhbins; i++) {\n\t\tif (i < SC_NBINS) {\n\t\t\ttcache_slow->lg_fill_div[i] = 1;\n\t\t\ttcache_slow->bin_refilled[i] = false;\n\t\t\ttcache_slow->bin_flush_delay_items[i]\n\t\t\t = tcache_gc_item_delay_compute(i);\n\t\t}\n\t\tcache_bin_t *cache_bin = &tcache->bins[i];\n\t\tcache_bin_init(cache_bin, &tcache_bin_info[i], mem,\n\t\t &cur_offset);\n\t}\n\t/*\n\t * For small size classes beyond tcache_maxclass (i.e. nhbins < NBINS),\n\t * their cache bins are initialized to a state to safely and efficiently\n\t * fail all fastpath alloc / free, so that no additional check around\n\t * nhbins is needed on fastpath.\n\t */\n\tfor (unsigned i = nhbins; i < SC_NBINS; i++) {\n\t\t/* Disabled small bins. */\n\t\tcache_bin_t *cache_bin = &tcache->bins[i];\n\t\tvoid *fake_stack = mem;\n\t\tsize_t fake_offset = 0;\n\n\t\tcache_bin_init(cache_bin, &tcache_bin_info[i], fake_stack,\n\t\t &fake_offset);\n\t\tassert(tcache_small_bin_disabled(i, cache_bin));\n\t}\n\n\tcache_bin_postincrement(tcache_bin_info, nhbins, mem,\n\t &cur_offset);\n\t/* Sanity check that the whole stack is used. */\n\tassert(cur_offset == tcache_bin_alloc_size);\n}\n\n/* Initialize auto tcache (embedded in TSD). */\nbool\ntsd_tcache_data_init(tsd_t *tsd) {\n\ttcache_slow_t *tcache_slow = tsd_tcache_slowp_get_unsafe(tsd);\n\ttcache_t *tcache = tsd_tcachep_get_unsafe(tsd);\n\n\tassert(cache_bin_still_zero_initialized(&tcache->bins[0]));\n\tsize_t alignment = tcache_bin_alloc_alignment;\n\tsize_t size = sz_sa2u(tcache_bin_alloc_size, alignment);\n\n\tvoid *mem = ipallocztm(tsd_tsdn(tsd), size, alignment, true, NULL,\n\t true, arena_get(TSDN_NULL, 0, true));\n\tif (mem == NULL) {\n\t\treturn true;\n\t}\n\n\ttcache_init(tsd, tcache_slow, tcache, mem);\n\t/*\n\t * Initialization is a bit tricky here. After malloc init is done, all\n\t * threads can rely on arena_choose and associate tcache accordingly.\n\t * However, the thread that does actual malloc bootstrapping relies on\n\t * functional tsd, and it can only rely on a0. In that case, we\n\t * associate its tcache to a0 temporarily, and later on\n\t * arena_choose_hard() will re-associate properly.\n\t */\n\ttcache_slow->arena = NULL;\n\tarena_t *arena;\n\tif (!malloc_initialized()) {\n\t\t/* If in initialization, assign to a0. */\n\t\tarena = arena_get(tsd_tsdn(tsd), 0, false);\n\t\ttcache_arena_associate(tsd_tsdn(tsd), tcache_slow, tcache,\n\t\t arena);\n\t} else {\n\t\tarena = arena_choose(tsd, NULL);\n\t\t/* This may happen if thread.tcache.enabled is used. */\n\t\tif (tcache_slow->arena == NULL) {\n\t\t\ttcache_arena_associate(tsd_tsdn(tsd), tcache_slow,\n\t\t\t tcache, arena);\n\t\t}\n\t}\n\tassert(arena == tcache_slow->arena);\n\n\treturn false;\n}\n\n/* Created manual tcache for tcache.create mallctl. */\ntcache_t *\ntcache_create_explicit(tsd_t *tsd) {\n\t/*\n\t * We place the cache bin stacks, then the tcache_t, then a pointer to\n\t * the beginning of the whole allocation (for freeing). The makes sure\n\t * the cache bins have the requested alignment.\n\t */\n\tsize_t size = tcache_bin_alloc_size + sizeof(tcache_t)\n\t + sizeof(tcache_slow_t);\n\t/* Naturally align the pointer stacks. */\n\tsize = PTR_CEILING(size);\n\tsize = sz_sa2u(size, tcache_bin_alloc_alignment);\n\n\tvoid *mem = ipallocztm(tsd_tsdn(tsd), size, tcache_bin_alloc_alignment,\n\t true, NULL, true, arena_get(TSDN_NULL, 0, true));\n\tif (mem == NULL) {\n\t\treturn NULL;\n\t}\n\ttcache_t *tcache = (void *)((uintptr_t)mem + tcache_bin_alloc_size);\n\ttcache_slow_t *tcache_slow =\n\t (void *)((uintptr_t)mem + tcache_bin_alloc_size + sizeof(tcache_t));\n\ttcache_init(tsd, tcache_slow, tcache, mem);\n\n\ttcache_arena_associate(tsd_tsdn(tsd), tcache_slow, tcache,\n\t arena_ichoose(tsd, NULL));\n\n\treturn tcache;\n}\n\nstatic void\ntcache_flush_cache(tsd_t *tsd, tcache_t *tcache) {\n\ttcache_slow_t *tcache_slow = tcache->tcache_slow;\n\tassert(tcache_slow->arena != NULL);\n\n\tfor (unsigned i = 0; i < nhbins; i++) {\n\t\tcache_bin_t *cache_bin = &tcache->bins[i];\n\t\tif (i < SC_NBINS) {\n\t\t\ttcache_bin_flush_small(tsd, tcache, cache_bin, i, 0);\n\t\t} else {\n\t\t\ttcache_bin_flush_large(tsd, tcache, cache_bin, i, 0);\n\t\t}\n\t\tif (config_stats) {\n\t\t\tassert(cache_bin->tstats.nrequests == 0);\n\t\t}\n\t}\n}\n\nvoid\ntcache_flush(tsd_t *tsd) {\n\tassert(tcache_available(tsd));\n\ttcache_flush_cache(tsd, tsd_tcachep_get(tsd));\n}\n\nstatic void\ntcache_destroy(tsd_t *tsd, tcache_t *tcache, bool tsd_tcache) {\n\ttcache_slow_t *tcache_slow = tcache->tcache_slow;\n\ttcache_flush_cache(tsd, tcache);\n\tarena_t *arena = tcache_slow->arena;\n\ttcache_arena_dissociate(tsd_tsdn(tsd), tcache_slow, tcache);\n\n\tif (tsd_tcache) {\n\t\tcache_bin_t *cache_bin = &tcache->bins[0];\n\t\tcache_bin_assert_empty(cache_bin, &tcache_bin_info[0]);\n\t}\n\tidalloctm(tsd_tsdn(tsd), tcache_slow->dyn_alloc, NULL, NULL, true,\n\t true);\n\n\t/*\n\t * The deallocation and tcache flush above may not trigger decay since\n\t * we are on the tcache shutdown path (potentially with non-nominal\n\t * tsd). Manually trigger decay to avoid pathological cases. Also\n\t * include arena 0 because the tcache array is allocated from it.\n\t */\n\tarena_decay(tsd_tsdn(tsd), arena_get(tsd_tsdn(tsd), 0, false),\n\t false, false);\n\n\tif (arena_nthreads_get(arena, false) == 0 &&\n\t !background_thread_enabled()) {\n\t\t/* Force purging when no threads assigned to the arena anymore. */\n\t\tarena_decay(tsd_tsdn(tsd), arena,\n\t\t /* is_background_thread */ false, /* all */ true);\n\t} else {\n\t\tarena_decay(tsd_tsdn(tsd), arena,\n\t\t /* is_background_thread */ false, /* all */ false);\n\t}\n}\n\n/* For auto tcache (embedded in TSD) only. */\nvoid\ntcache_cleanup(tsd_t *tsd) {\n\ttcache_t *tcache = tsd_tcachep_get(tsd);\n\tif (!tcache_available(tsd)) {\n\t\tassert(tsd_tcache_enabled_get(tsd) == false);\n\t\tassert(cache_bin_still_zero_initialized(&tcache->bins[0]));\n\t\treturn;\n\t}\n\tassert(tsd_tcache_enabled_get(tsd));\n\tassert(!cache_bin_still_zero_initialized(&tcache->bins[0]));\n\n\ttcache_destroy(tsd, tcache, true);\n\tif (config_debug) {\n\t\t/*\n\t\t * For debug testing only, we want to pretend we're still in the\n\t\t * zero-initialized state.\n\t\t */\n\t\tmemset(tcache->bins, 0, sizeof(cache_bin_t) * nhbins);\n\t}\n}\n\nvoid\ntcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena) {\n\tcassert(config_stats);\n\n\t/* Merge and reset tcache stats. */\n\tfor (unsigned i = 0; i < nhbins; i++) {\n\t\tcache_bin_t *cache_bin = &tcache->bins[i];\n\t\tif (i < SC_NBINS) {\n\t\t\tbin_t *bin = arena_bin_choose(tsdn, arena, i, NULL);\n\t\t\tmalloc_mutex_lock(tsdn, &bin->lock);\n\t\t\tbin->stats.nrequests += cache_bin->tstats.nrequests;\n\t\t\tmalloc_mutex_unlock(tsdn, &bin->lock);\n\t\t} else {\n\t\t\tarena_stats_large_flush_nrequests_add(tsdn,\n\t\t\t &arena->stats, i, cache_bin->tstats.nrequests);\n\t\t}\n\t\tcache_bin->tstats.nrequests = 0;\n\t}\n}\n\nstatic bool\ntcaches_create_prep(tsd_t *tsd, base_t *base) {\n\tbool err;\n\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &tcaches_mtx);\n\n\tif (tcaches == NULL) {\n\t\ttcaches = base_alloc(tsd_tsdn(tsd), base,\n\t\t sizeof(tcache_t *) * (MALLOCX_TCACHE_MAX+1), CACHELINE);\n\t\tif (tcaches == NULL) {\n\t\t\terr = true;\n\t\t\tgoto label_return;\n\t\t}\n\t}\n\n\tif (tcaches_avail == NULL && tcaches_past > MALLOCX_TCACHE_MAX) {\n\t\terr = true;\n\t\tgoto label_return;\n\t}\n\n\terr = false;\nlabel_return:\n\treturn err;\n}\n\nbool\ntcaches_create(tsd_t *tsd, base_t *base, unsigned *r_ind) {\n\twitness_assert_depth(tsdn_witness_tsdp_get(tsd_tsdn(tsd)), 0);\n\n\tbool err;\n\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);\n\n\tif (tcaches_create_prep(tsd, base)) {\n\t\terr = true;\n\t\tgoto label_return;\n\t}\n\n\ttcache_t *tcache = tcache_create_explicit(tsd);\n\tif (tcache == NULL) {\n\t\terr = true;\n\t\tgoto label_return;\n\t}\n\n\ttcaches_t *elm;\n\tif (tcaches_avail != NULL) {\n\t\telm = tcaches_avail;\n\t\ttcaches_avail = tcaches_avail->next;\n\t\telm->tcache = tcache;\n\t\t*r_ind = (unsigned)(elm - tcaches);\n\t} else {\n\t\telm = &tcaches[tcaches_past];\n\t\telm->tcache = tcache;\n\t\t*r_ind = tcaches_past;\n\t\ttcaches_past++;\n\t}\n\n\terr = false;\nlabel_return:\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);\n\twitness_assert_depth(tsdn_witness_tsdp_get(tsd_tsdn(tsd)), 0);\n\treturn err;\n}\n\nstatic tcache_t *\ntcaches_elm_remove(tsd_t *tsd, tcaches_t *elm, bool allow_reinit) {\n\tmalloc_mutex_assert_owner(tsd_tsdn(tsd), &tcaches_mtx);\n\n\tif (elm->tcache == NULL) {\n\t\treturn NULL;\n\t}\n\ttcache_t *tcache = elm->tcache;\n\tif (allow_reinit) {\n\t\telm->tcache = TCACHES_ELM_NEED_REINIT;\n\t} else {\n\t\telm->tcache = NULL;\n\t}\n\n\tif (tcache == TCACHES_ELM_NEED_REINIT) {\n\t\treturn NULL;\n\t}\n\treturn tcache;\n}\n\nvoid\ntcaches_flush(tsd_t *tsd, unsigned ind) {\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);\n\ttcache_t *tcache = tcaches_elm_remove(tsd, &tcaches[ind], true);\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);\n\tif (tcache != NULL) {\n\t\t/* Destroy the tcache; recreate in tcaches_get() if needed. */\n\t\ttcache_destroy(tsd, tcache, false);\n\t}\n}\n\nvoid\ntcaches_destroy(tsd_t *tsd, unsigned ind) {\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tcaches_mtx);\n\ttcaches_t *elm = &tcaches[ind];\n\ttcache_t *tcache = tcaches_elm_remove(tsd, elm, false);\n\telm->next = tcaches_avail;\n\ttcaches_avail = elm;\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tcaches_mtx);\n\tif (tcache != NULL) {\n\t\ttcache_destroy(tsd, tcache, false);\n\t}\n}\n\nstatic unsigned\ntcache_ncached_max_compute(szind_t szind) {\n\tif (szind >= SC_NBINS) {\n\t\tassert(szind < nhbins);\n\t\treturn opt_tcache_nslots_large;\n\t}\n\tunsigned slab_nregs = bin_infos[szind].nregs;\n\n\t/* We may modify these values; start with the opt versions. */\n\tunsigned nslots_small_min = opt_tcache_nslots_small_min;\n\tunsigned nslots_small_max = opt_tcache_nslots_small_max;\n\n\t/*\n\t * Clamp values to meet our constraints -- even, nonzero, min < max, and\n\t * suitable for a cache bin size.\n\t */\n\tif (opt_tcache_nslots_small_max > CACHE_BIN_NCACHED_MAX) {\n\t\tnslots_small_max = CACHE_BIN_NCACHED_MAX;\n\t}\n\tif (nslots_small_min % 2 != 0) {\n\t\tnslots_small_min++;\n\t}\n\tif (nslots_small_max % 2 != 0) {\n\t\tnslots_small_max--;\n\t}\n\tif (nslots_small_min < 2) {\n\t\tnslots_small_min = 2;\n\t}\n\tif (nslots_small_max < 2) {\n\t\tnslots_small_max = 2;\n\t}\n\tif (nslots_small_min > nslots_small_max) {\n\t\tnslots_small_min = nslots_small_max;\n\t}\n\n\tunsigned candidate;\n\tif (opt_lg_tcache_nslots_mul < 0) {\n\t\tcandidate = slab_nregs >> (-opt_lg_tcache_nslots_mul);\n\t} else {\n\t\tcandidate = slab_nregs << opt_lg_tcache_nslots_mul;\n\t}\n\tif (candidate % 2 != 0) {\n\t\t/*\n\t\t * We need the candidate size to be even -- we assume that we\n\t\t * can divide by two and get a positive number (e.g. when\n\t\t * flushing).\n\t\t */\n\t\t++candidate;\n\t}\n\tif (candidate <= nslots_small_min) {\n\t\treturn nslots_small_min;\n\t} else if (candidate <= nslots_small_max) {\n\t\treturn candidate;\n\t} else {\n\t\treturn nslots_small_max;\n\t}\n}\n\nbool\ntcache_boot(tsdn_t *tsdn, base_t *base) {\n\ttcache_maxclass = sz_s2u(opt_tcache_max);\n\tassert(tcache_maxclass <= TCACHE_MAXCLASS_LIMIT);\n\tnhbins = sz_size2index(tcache_maxclass) + 1;\n\n\tif (malloc_mutex_init(&tcaches_mtx, \"tcaches\", WITNESS_RANK_TCACHES,\n\t malloc_mutex_rank_exclusive)) {\n\t\treturn true;\n\t}\n\n\t/* Initialize tcache_bin_info. See comments in tcache_init(). */\n\tunsigned n_reserved_bins = nhbins < SC_NBINS ? SC_NBINS : nhbins;\n\tsize_t size = n_reserved_bins * sizeof(cache_bin_info_t);\n\ttcache_bin_info = (cache_bin_info_t *)base_alloc(tsdn, base, size,\n\t CACHELINE);\n\tif (tcache_bin_info == NULL) {\n\t\treturn true;\n\t}\n\n\tfor (szind_t i = 0; i < nhbins; i++) {\n\t\tunsigned ncached_max = tcache_ncached_max_compute(i);\n\t\tcache_bin_info_init(&tcache_bin_info[i], ncached_max);\n\t}\n\tfor (szind_t i = nhbins; i < SC_NBINS; i++) {\n\t\t/* Disabled small bins. */\n\t\tcache_bin_info_init(&tcache_bin_info[i], 0);\n\t\tassert(tcache_small_bin_disabled(i, NULL));\n\t}\n\n\tcache_bin_info_compute_alloc(tcache_bin_info, nhbins,\n\t &tcache_bin_alloc_size, &tcache_bin_alloc_alignment);\n\n\treturn false;\n}\n\nvoid\ntcache_prefork(tsdn_t *tsdn) {\n\tmalloc_mutex_prefork(tsdn, &tcaches_mtx);\n}\n\nvoid\ntcache_postfork_parent(tsdn_t *tsdn) {\n\tmalloc_mutex_postfork_parent(tsdn, &tcaches_mtx);\n}\n\nvoid\ntcache_postfork_child(tsdn_t *tsdn) {\n\tmalloc_mutex_postfork_child(tsdn, &tcaches_mtx);\n}\n\nvoid tcache_assert_initialized(tcache_t *tcache) {\n\tassert(!cache_bin_still_zero_initialized(&tcache->bins[0]));\n}\n" }, { "path": "deps/jemalloc/src/test_hooks.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n\n/*\n * The hooks are a little bit screwy -- they're not genuinely exported in the\n * sense that we want them available to end-users, but we do want them visible\n * from outside the generated library, so that we can use them in test code.\n */\nJEMALLOC_EXPORT\nvoid (*test_hooks_arena_new_hook)() = NULL;\n\nJEMALLOC_EXPORT\nvoid (*test_hooks_libc_hook)() = NULL;\n" }, { "path": "deps/jemalloc/src/thread_event.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/thread_event.h\"\n\n/*\n * Signatures for event specific functions. These functions should be defined\n * by the modules owning each event. The signatures here verify that the\n * definitions follow the right format.\n *\n * The first two are functions computing new / postponed event wait time. New\n * event wait time is the time till the next event if an event is currently\n * being triggered; postponed event wait time is the time till the next event\n * if an event should be triggered but needs to be postponed, e.g. when the TSD\n * is not nominal or during reentrancy.\n *\n * The third is the event handler function, which is called whenever an event\n * is triggered. The parameter is the elapsed time since the last time an\n * event of the same type was triggered.\n */\n#define E(event, condition_unused, is_alloc_event_unused)\t\t\\\nuint64_t event##_new_event_wait(tsd_t *tsd);\t\t\t\t\\\nuint64_t event##_postponed_event_wait(tsd_t *tsd);\t\t\t\\\nvoid event##_event_handler(tsd_t *tsd, uint64_t elapsed);\n\nITERATE_OVER_ALL_EVENTS\n#undef E\n\n/* Signatures for internal functions fetching elapsed time. */\n#define E(event, condition_unused, is_alloc_event_unused)\t\t\\\nstatic uint64_t event##_fetch_elapsed(tsd_t *tsd);\n\nITERATE_OVER_ALL_EVENTS\n#undef E\n\nstatic uint64_t\ntcache_gc_fetch_elapsed(tsd_t *tsd) {\n\treturn TE_INVALID_ELAPSED;\n}\n\nstatic uint64_t\ntcache_gc_dalloc_fetch_elapsed(tsd_t *tsd) {\n\treturn TE_INVALID_ELAPSED;\n}\n\nstatic uint64_t\nprof_sample_fetch_elapsed(tsd_t *tsd) {\n\tuint64_t last_event = thread_allocated_last_event_get(tsd);\n\tuint64_t last_sample_event = prof_sample_last_event_get(tsd);\n\tprof_sample_last_event_set(tsd, last_event);\n\treturn last_event - last_sample_event;\n}\n\nstatic uint64_t\nstats_interval_fetch_elapsed(tsd_t *tsd) {\n\tuint64_t last_event = thread_allocated_last_event_get(tsd);\n\tuint64_t last_stats_event = stats_interval_last_event_get(tsd);\n\tstats_interval_last_event_set(tsd, last_event);\n\treturn last_event - last_stats_event;\n}\n\nstatic uint64_t\npeak_alloc_fetch_elapsed(tsd_t *tsd) {\n\treturn TE_INVALID_ELAPSED;\n}\n\nstatic uint64_t\npeak_dalloc_fetch_elapsed(tsd_t *tsd) {\n\treturn TE_INVALID_ELAPSED;\n}\n\n/* Per event facilities done. */\n\nstatic bool\nte_ctx_has_active_events(te_ctx_t *ctx) {\n\tassert(config_debug);\n#define E(event, condition, alloc_event)\t\t\t \\\n\tif (condition && alloc_event == ctx->is_alloc) {\t \\\n\t\treturn true;\t\t\t\t\t \\\n\t}\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\treturn false;\n}\n\nstatic uint64_t\nte_next_event_compute(tsd_t *tsd, bool is_alloc) {\n\tuint64_t wait = TE_MAX_START_WAIT;\n#define E(event, condition, alloc_event)\t\t\t\t\\\n\tif (is_alloc == alloc_event && condition) {\t\t\t\\\n\t\tuint64_t event_wait =\t\t\t\t\t\\\n\t\t event##_event_wait_get(tsd);\t\t\t\\\n\t\tassert(event_wait <= TE_MAX_START_WAIT);\t\t\\\n\t\tif (event_wait > 0U && event_wait < wait) {\t\t\\\n\t\t\twait = event_wait;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\n\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\tassert(wait <= TE_MAX_START_WAIT);\n\treturn wait;\n}\n\nstatic void\nte_assert_invariants_impl(tsd_t *tsd, te_ctx_t *ctx) {\n\tuint64_t current_bytes = te_ctx_current_bytes_get(ctx);\n\tuint64_t last_event = te_ctx_last_event_get(ctx);\n\tuint64_t next_event = te_ctx_next_event_get(ctx);\n\tuint64_t next_event_fast = te_ctx_next_event_fast_get(ctx);\n\n\tassert(last_event != next_event);\n\tif (next_event > TE_NEXT_EVENT_FAST_MAX || !tsd_fast(tsd)) {\n\t\tassert(next_event_fast == 0U);\n\t} else {\n\t\tassert(next_event_fast == next_event);\n\t}\n\n\t/* The subtraction is intentionally susceptible to underflow. */\n\tuint64_t interval = next_event - last_event;\n\n\t/* The subtraction is intentionally susceptible to underflow. */\n\tassert(current_bytes - last_event < interval);\n\tuint64_t min_wait = te_next_event_compute(tsd, te_ctx_is_alloc(ctx));\n\t/*\n\t * next_event should have been pushed up only except when no event is\n\t * on and the TSD is just initialized. The last_event == 0U guard\n\t * below is stronger than needed, but having an exactly accurate guard\n\t * is more complicated to implement.\n\t */\n\tassert((!te_ctx_has_active_events(ctx) && last_event == 0U) ||\n\t interval == min_wait ||\n\t (interval < min_wait && interval == TE_MAX_INTERVAL));\n}\n\nvoid\nte_assert_invariants_debug(tsd_t *tsd) {\n\tte_ctx_t ctx;\n\tte_ctx_get(tsd, &ctx, true);\n\tte_assert_invariants_impl(tsd, &ctx);\n\n\tte_ctx_get(tsd, &ctx, false);\n\tte_assert_invariants_impl(tsd, &ctx);\n}\n\n/*\n * Synchronization around the fast threshold in tsd --\n * There are two threads to consider in the synchronization here:\n * - The owner of the tsd being updated by a slow path change\n * - The remote thread, doing that slow path change.\n *\n * As a design constraint, we want to ensure that a slow-path transition cannot\n * be ignored for arbitrarily long, and that if the remote thread causes a\n * slow-path transition and then communicates with the owner thread that it has\n * occurred, then the owner will go down the slow path on the next allocator\n * operation (so that we don't want to just wait until the owner hits its slow\n * path reset condition on its own).\n *\n * Here's our strategy to do that:\n *\n * The remote thread will update the slow-path stores to TSD variables, issue a\n * SEQ_CST fence, and then update the TSD next_event_fast counter. The owner\n * thread will update next_event_fast, issue an SEQ_CST fence, and then check\n * its TSD to see if it's on the slow path.\n\n * This is fairly straightforward when 64-bit atomics are supported. Assume that\n * the remote fence is sandwiched between two owner fences in the reset pathway.\n * The case where there is no preceding or trailing owner fence (i.e. because\n * the owner thread is near the beginning or end of its life) can be analyzed\n * similarly. The owner store to next_event_fast preceding the earlier owner\n * fence will be earlier in coherence order than the remote store to it, so that\n * the owner thread will go down the slow path once the store becomes visible to\n * it, which is no later than the time of the second fence.\n\n * The case where we don't support 64-bit atomics is trickier, since word\n * tearing is possible. We'll repeat the same analysis, and look at the two\n * owner fences sandwiching the remote fence. The next_event_fast stores done\n * alongside the earlier owner fence cannot overwrite any of the remote stores\n * (since they precede the earlier owner fence in sb, which precedes the remote\n * fence in sc, which precedes the remote stores in sb). After the second owner\n * fence there will be a re-check of the slow-path variables anyways, so the\n * \"owner will notice that it's on the slow path eventually\" guarantee is\n * satisfied. To make sure that the out-of-band-messaging constraint is as well,\n * note that either the message passing is sequenced before the second owner\n * fence (in which case the remote stores happen before the second set of owner\n * stores, so malloc sees a value of zero for next_event_fast and goes down the\n * slow path), or it is not (in which case the owner sees the tsd slow-path\n * writes on its previous update). This leaves open the possibility that the\n * remote thread will (at some arbitrary point in the future) zero out one half\n * of the owner thread's next_event_fast, but that's always safe (it just sends\n * it down the slow path earlier).\n */\nstatic void\nte_ctx_next_event_fast_update(te_ctx_t *ctx) {\n\tuint64_t next_event = te_ctx_next_event_get(ctx);\n\tuint64_t next_event_fast = (next_event <= TE_NEXT_EVENT_FAST_MAX) ?\n\t next_event : 0U;\n\tte_ctx_next_event_fast_set(ctx, next_event_fast);\n}\n\nvoid\nte_recompute_fast_threshold(tsd_t *tsd) {\n\tif (tsd_state_get(tsd) != tsd_state_nominal) {\n\t\t/* Check first because this is also called on purgatory. */\n\t\tte_next_event_fast_set_non_nominal(tsd);\n\t\treturn;\n\t}\n\n\tte_ctx_t ctx;\n\tte_ctx_get(tsd, &ctx, true);\n\tte_ctx_next_event_fast_update(&ctx);\n\tte_ctx_get(tsd, &ctx, false);\n\tte_ctx_next_event_fast_update(&ctx);\n\n\tatomic_fence(ATOMIC_SEQ_CST);\n\tif (tsd_state_get(tsd) != tsd_state_nominal) {\n\t\tte_next_event_fast_set_non_nominal(tsd);\n\t}\n}\n\nstatic void\nte_adjust_thresholds_helper(tsd_t *tsd, te_ctx_t *ctx,\n uint64_t wait) {\n\t/*\n\t * The next threshold based on future events can only be adjusted after\n\t * progressing the last_event counter (which is set to current).\n\t */\n\tassert(te_ctx_current_bytes_get(ctx) == te_ctx_last_event_get(ctx));\n\tassert(wait <= TE_MAX_START_WAIT);\n\n\tuint64_t next_event = te_ctx_last_event_get(ctx) + (wait <=\n\t TE_MAX_INTERVAL ? wait : TE_MAX_INTERVAL);\n\tte_ctx_next_event_set(tsd, ctx, next_event);\n}\n\nstatic uint64_t\nte_clip_event_wait(uint64_t event_wait) {\n\tassert(event_wait > 0U);\n\tif (TE_MIN_START_WAIT > 1U &&\n\t unlikely(event_wait < TE_MIN_START_WAIT)) {\n\t\tevent_wait = TE_MIN_START_WAIT;\n\t}\n\tif (TE_MAX_START_WAIT < UINT64_MAX &&\n\t unlikely(event_wait > TE_MAX_START_WAIT)) {\n\t\tevent_wait = TE_MAX_START_WAIT;\n\t}\n\treturn event_wait;\n}\n\nvoid\nte_event_trigger(tsd_t *tsd, te_ctx_t *ctx) {\n\t/* usize has already been added to thread_allocated. */\n\tuint64_t bytes_after = te_ctx_current_bytes_get(ctx);\n\t/* The subtraction is intentionally susceptible to underflow. */\n\tuint64_t accumbytes = bytes_after - te_ctx_last_event_get(ctx);\n\n\tte_ctx_last_event_set(ctx, bytes_after);\n\n\tbool allow_event_trigger = tsd_nominal(tsd) &&\n\t tsd_reentrancy_level_get(tsd) == 0;\n\tbool is_alloc = ctx->is_alloc;\n\tuint64_t wait = TE_MAX_START_WAIT;\n\n#define E(event, condition, alloc_event)\t\t\t\t\\\n\tbool is_##event##_triggered = false;\t\t\t\t\\\n\tif (is_alloc == alloc_event && condition) {\t\t\t\\\n\t\tuint64_t event_wait = event##_event_wait_get(tsd);\t\\\n\t\tassert(event_wait <= TE_MAX_START_WAIT);\t\t\\\n\t\tif (event_wait > accumbytes) {\t\t\t\t\\\n\t\t\tevent_wait -= accumbytes;\t\t\t\\\n\t\t} else if (!allow_event_trigger) {\t\t\t\\\n\t\t\tevent_wait = event##_postponed_event_wait(tsd);\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tis_##event##_triggered = true;\t\t\t\\\n\t\t\tevent_wait = event##_new_event_wait(tsd);\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tevent_wait = te_clip_event_wait(event_wait);\t\t\\\n\t\tevent##_event_wait_set(tsd, event_wait);\t\t\\\n\t\tif (event_wait < wait) {\t\t\t\t\\\n\t\t\twait = event_wait;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\n\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\n\tassert(wait <= TE_MAX_START_WAIT);\n\tte_adjust_thresholds_helper(tsd, ctx, wait);\n\tte_assert_invariants(tsd);\n\n#define E(event, condition, alloc_event)\t\t\t\t\\\n\tif (is_alloc == alloc_event && condition &&\t\t\t\\\n\t is_##event##_triggered) {\t\t\t\t\t\\\n\t\tassert(allow_event_trigger);\t\t\t\t\\\n\t\tuint64_t elapsed = event##_fetch_elapsed(tsd);\t\t\\\n\t\tevent##_event_handler(tsd, elapsed);\t\t\t\\\n\t}\n\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\n\tte_assert_invariants(tsd);\n}\n\nstatic void\nte_init(tsd_t *tsd, bool is_alloc) {\n\tte_ctx_t ctx;\n\tte_ctx_get(tsd, &ctx, is_alloc);\n\t/*\n\t * Reset the last event to current, which starts the events from a clean\n\t * state. This is necessary when re-init the tsd event counters.\n\t *\n\t * The event counters maintain a relationship with the current bytes:\n\t * last_event <= current < next_event. When a reinit happens (e.g.\n\t * reincarnated tsd), the last event needs progressing because all\n\t * events start fresh from the current bytes.\n\t */\n\tte_ctx_last_event_set(&ctx, te_ctx_current_bytes_get(&ctx));\n\n\tuint64_t wait = TE_MAX_START_WAIT;\n#define E(event, condition, alloc_event)\t\t\t\t\\\n\tif (is_alloc == alloc_event && condition) {\t\t\t\\\n\t\tuint64_t event_wait = event##_new_event_wait(tsd);\t\\\n\t\tevent_wait = te_clip_event_wait(event_wait);\t\t\\\n\t\tevent##_event_wait_set(tsd, event_wait);\t\t\\\n\t\tif (event_wait < wait) {\t\t\t\t\\\n\t\t\twait = event_wait;\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\n\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\tte_adjust_thresholds_helper(tsd, &ctx, wait);\n}\n\nvoid\ntsd_te_init(tsd_t *tsd) {\n\t/* Make sure no overflow for the bytes accumulated on event_trigger. */\n\tassert(TE_MAX_INTERVAL <= UINT64_MAX - SC_LARGE_MAXCLASS + 1);\n\tte_init(tsd, true);\n\tte_init(tsd, false);\n\tte_assert_invariants(tsd);\n}\n" }, { "path": "deps/jemalloc/src/ticker.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n/*\n * To avoid using floating point math down core paths (still necessary because\n * versions of the glibc dynamic loader that did not preserve xmm registers are\n * still somewhat common, requiring us to be compilable with -mno-sse), and also\n * to avoid generally expensive library calls, we use a precomputed table of\n * values. We want to sample U uniformly on [0, 1], and then compute\n * ceil(log(u)/log(1-1/nticks)). We're mostly interested in the case where\n * nticks is reasonably big, so 1/log(1-1/nticks) is well-approximated by\n * -nticks.\n *\n * To compute log(u), we sample an integer in [1, 64] and divide, then just look\n * up results in a table. As a space-compression mechanism, we store these as\n * uint8_t by dividing the range (255) by the highest-magnitude value the log\n * can take on, and using that as a multiplier. We then have to divide by that\n * multiplier at the end of the computation.\n *\n * The values here are computed in src/ticker.py\n */\n\nconst uint8_t ticker_geom_table[1 << TICKER_GEOM_NBITS] = {\n\t254, 211, 187, 169, 156, 144, 135, 127,\n\t120, 113, 107, 102, 97, 93, 89, 85,\n\t81, 77, 74, 71, 68, 65, 62, 60,\n\t57, 55, 53, 50, 48, 46, 44, 42,\n\t40, 39, 37, 35, 33, 32, 30, 29,\n\t27, 26, 24, 23, 21, 20, 19, 18,\n\t16, 15, 14, 13, 12, 10, 9, 8,\n\t7, 6, 5, 4, 3, 2, 1, 0\n};\n" }, { "path": "deps/jemalloc/src/ticker.py", "content": "#!/usr/bin/env python3\n\nimport math\n\n# Must match TICKER_GEOM_NBITS\nlg_table_size = 6\ntable_size = 2**lg_table_size\nbyte_max = 255\nmul = math.floor(-byte_max/math.log(1 / table_size))\nvalues = [round(-mul * math.log(i / table_size))\n\tfor i in range(1, table_size+1)]\nprint(\"mul =\", mul)\nprint(\"values:\")\nfor i in range(table_size // 8):\n\tprint(\", \".join((str(x) for x in values[i*8 : i*8 + 8])))\n" }, { "path": "deps/jemalloc/src/tsd.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/mutex.h\"\n#include \"jemalloc/internal/rtree.h\"\n\n/******************************************************************************/\n/* Data. */\n\n/* TSD_INITIALIZER triggers \"-Wmissing-field-initializer\" */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_MISSING_STRUCT_FIELD_INITIALIZERS\n\n#ifdef JEMALLOC_MALLOC_THREAD_CLEANUP\nJEMALLOC_TSD_TYPE_ATTR(tsd_t) tsd_tls = TSD_INITIALIZER;\nJEMALLOC_TSD_TYPE_ATTR(bool) JEMALLOC_TLS_MODEL tsd_initialized = false;\nbool tsd_booted = false;\n#elif (defined(JEMALLOC_TLS))\nJEMALLOC_TSD_TYPE_ATTR(tsd_t) tsd_tls = TSD_INITIALIZER;\npthread_key_t tsd_tsd;\nbool tsd_booted = false;\n#elif (defined(_WIN32))\nDWORD tsd_tsd;\ntsd_wrapper_t tsd_boot_wrapper = {false, TSD_INITIALIZER};\nbool tsd_booted = false;\n#else\n\n/*\n * This contains a mutex, but it's pretty convenient to allow the mutex code to\n * have a dependency on tsd. So we define the struct here, and only refer to it\n * by pointer in the header.\n */\nstruct tsd_init_head_s {\n\tql_head(tsd_init_block_t) blocks;\n\tmalloc_mutex_t lock;\n};\n\npthread_key_t tsd_tsd;\ntsd_init_head_t\ttsd_init_head = {\n\tql_head_initializer(blocks),\n\tMALLOC_MUTEX_INITIALIZER\n};\n\ntsd_wrapper_t tsd_boot_wrapper = {\n\tfalse,\n\tTSD_INITIALIZER\n};\nbool tsd_booted = false;\n#endif\n\nJEMALLOC_DIAGNOSTIC_POP\n\n/******************************************************************************/\n\n/* A list of all the tsds in the nominal state. */\ntypedef ql_head(tsd_t) tsd_list_t;\nstatic tsd_list_t tsd_nominal_tsds = ql_head_initializer(tsd_nominal_tsds);\nstatic malloc_mutex_t tsd_nominal_tsds_lock;\n\n/* How many slow-path-enabling features are turned on. */\nstatic atomic_u32_t tsd_global_slow_count = ATOMIC_INIT(0);\n\nstatic bool\ntsd_in_nominal_list(tsd_t *tsd) {\n\ttsd_t *tsd_list;\n\tbool found = false;\n\t/*\n\t * We don't know that tsd is nominal; it might not be safe to get data\n\t * out of it here.\n\t */\n\tmalloc_mutex_lock(TSDN_NULL, &tsd_nominal_tsds_lock);\n\tql_foreach(tsd_list, &tsd_nominal_tsds, TSD_MANGLE(tsd_link)) {\n\t\tif (tsd == tsd_list) {\n\t\t\tfound = true;\n\t\t\tbreak;\n\t\t}\n\t}\n\tmalloc_mutex_unlock(TSDN_NULL, &tsd_nominal_tsds_lock);\n\treturn found;\n}\n\nstatic void\ntsd_add_nominal(tsd_t *tsd) {\n\tassert(!tsd_in_nominal_list(tsd));\n\tassert(tsd_state_get(tsd) <= tsd_state_nominal_max);\n\tql_elm_new(tsd, TSD_MANGLE(tsd_link));\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n\tql_tail_insert(&tsd_nominal_tsds, tsd, TSD_MANGLE(tsd_link));\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n}\n\nstatic void\ntsd_remove_nominal(tsd_t *tsd) {\n\tassert(tsd_in_nominal_list(tsd));\n\tassert(tsd_state_get(tsd) <= tsd_state_nominal_max);\n\tmalloc_mutex_lock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n\tql_remove(&tsd_nominal_tsds, tsd, TSD_MANGLE(tsd_link));\n\tmalloc_mutex_unlock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n}\n\nstatic void\ntsd_force_recompute(tsdn_t *tsdn) {\n\t/*\n\t * The stores to tsd->state here need to synchronize with the exchange\n\t * in tsd_slow_update.\n\t */\n\tatomic_fence(ATOMIC_RELEASE);\n\tmalloc_mutex_lock(tsdn, &tsd_nominal_tsds_lock);\n\ttsd_t *remote_tsd;\n\tql_foreach(remote_tsd, &tsd_nominal_tsds, TSD_MANGLE(tsd_link)) {\n\t\tassert(tsd_atomic_load(&remote_tsd->state, ATOMIC_RELAXED)\n\t\t <= tsd_state_nominal_max);\n\t\ttsd_atomic_store(&remote_tsd->state,\n\t\t tsd_state_nominal_recompute, ATOMIC_RELAXED);\n\t\t/* See comments in te_recompute_fast_threshold(). */\n\t\tatomic_fence(ATOMIC_SEQ_CST);\n\t\tte_next_event_fast_set_non_nominal(remote_tsd);\n\t}\n\tmalloc_mutex_unlock(tsdn, &tsd_nominal_tsds_lock);\n}\n\nvoid\ntsd_global_slow_inc(tsdn_t *tsdn) {\n\tatomic_fetch_add_u32(&tsd_global_slow_count, 1, ATOMIC_RELAXED);\n\t/*\n\t * We unconditionally force a recompute, even if the global slow count\n\t * was already positive. If we didn't, then it would be possible for us\n\t * to return to the user, have the user synchronize externally with some\n\t * other thread, and then have that other thread not have picked up the\n\t * update yet (since the original incrementing thread might still be\n\t * making its way through the tsd list).\n\t */\n\ttsd_force_recompute(tsdn);\n}\n\nvoid tsd_global_slow_dec(tsdn_t *tsdn) {\n\tatomic_fetch_sub_u32(&tsd_global_slow_count, 1, ATOMIC_RELAXED);\n\t/* See the note in ..._inc(). */\n\ttsd_force_recompute(tsdn);\n}\n\nstatic bool\ntsd_local_slow(tsd_t *tsd) {\n\treturn !tsd_tcache_enabled_get(tsd)\n\t || tsd_reentrancy_level_get(tsd) > 0;\n}\n\nbool\ntsd_global_slow() {\n\treturn atomic_load_u32(&tsd_global_slow_count, ATOMIC_RELAXED) > 0;\n}\n\n/******************************************************************************/\n\nstatic uint8_t\ntsd_state_compute(tsd_t *tsd) {\n\tif (!tsd_nominal(tsd)) {\n\t\treturn tsd_state_get(tsd);\n\t}\n\t/* We're in *a* nominal state; but which one? */\n\tif (malloc_slow || tsd_local_slow(tsd) || tsd_global_slow()) {\n\t\treturn tsd_state_nominal_slow;\n\t} else {\n\t\treturn tsd_state_nominal;\n\t}\n}\n\nvoid\ntsd_slow_update(tsd_t *tsd) {\n\tuint8_t old_state;\n\tdo {\n\t\tuint8_t new_state = tsd_state_compute(tsd);\n\t\told_state = tsd_atomic_exchange(&tsd->state, new_state,\n\t\t ATOMIC_ACQUIRE);\n\t} while (old_state == tsd_state_nominal_recompute);\n\n\tte_recompute_fast_threshold(tsd);\n}\n\nvoid\ntsd_state_set(tsd_t *tsd, uint8_t new_state) {\n\t/* Only the tsd module can change the state *to* recompute. */\n\tassert(new_state != tsd_state_nominal_recompute);\n\tuint8_t old_state = tsd_atomic_load(&tsd->state, ATOMIC_RELAXED);\n\tif (old_state > tsd_state_nominal_max) {\n\t\t/*\n\t\t * Not currently in the nominal list, but it might need to be\n\t\t * inserted there.\n\t\t */\n\t\tassert(!tsd_in_nominal_list(tsd));\n\t\ttsd_atomic_store(&tsd->state, new_state, ATOMIC_RELAXED);\n\t\tif (new_state <= tsd_state_nominal_max) {\n\t\t\ttsd_add_nominal(tsd);\n\t\t}\n\t} else {\n\t\t/*\n\t\t * We're currently nominal. If the new state is non-nominal,\n\t\t * great; we take ourselves off the list and just enter the new\n\t\t * state.\n\t\t */\n\t\tassert(tsd_in_nominal_list(tsd));\n\t\tif (new_state > tsd_state_nominal_max) {\n\t\t\ttsd_remove_nominal(tsd);\n\t\t\ttsd_atomic_store(&tsd->state, new_state,\n\t\t\t ATOMIC_RELAXED);\n\t\t} else {\n\t\t\t/*\n\t\t\t * This is the tricky case. We're transitioning from\n\t\t\t * one nominal state to another. The caller can't know\n\t\t\t * about any races that are occurring at the same time,\n\t\t\t * so we always have to recompute no matter what.\n\t\t\t */\n\t\t\ttsd_slow_update(tsd);\n\t\t}\n\t}\n\tte_recompute_fast_threshold(tsd);\n}\n\nstatic void\ntsd_prng_state_init(tsd_t *tsd) {\n\t/*\n\t * A nondeterministic seed based on the address of tsd reduces\n\t * the likelihood of lockstep non-uniform cache index\n\t * utilization among identical concurrent processes, but at the\n\t * cost of test repeatability. For debug builds, instead use a\n\t * deterministic seed.\n\t */\n\t*tsd_prng_statep_get(tsd) = config_debug ? 0 :\n\t (uint64_t)(uintptr_t)tsd;\n}\n\nstatic bool\ntsd_data_init(tsd_t *tsd) {\n\t/*\n\t * We initialize the rtree context first (before the tcache), since the\n\t * tcache initialization depends on it.\n\t */\n\trtree_ctx_data_init(tsd_rtree_ctxp_get_unsafe(tsd));\n\ttsd_prng_state_init(tsd);\n\ttsd_te_init(tsd); /* event_init may use the prng state above. */\n\ttsd_san_init(tsd);\n\treturn tsd_tcache_enabled_data_init(tsd);\n}\n\nstatic void\nassert_tsd_data_cleanup_done(tsd_t *tsd) {\n\tassert(!tsd_nominal(tsd));\n\tassert(!tsd_in_nominal_list(tsd));\n\tassert(*tsd_arenap_get_unsafe(tsd) == NULL);\n\tassert(*tsd_iarenap_get_unsafe(tsd) == NULL);\n\tassert(*tsd_tcache_enabledp_get_unsafe(tsd) == false);\n\tassert(*tsd_prof_tdatap_get_unsafe(tsd) == NULL);\n}\n\nstatic bool\ntsd_data_init_nocleanup(tsd_t *tsd) {\n\tassert(tsd_state_get(tsd) == tsd_state_reincarnated ||\n\t tsd_state_get(tsd) == tsd_state_minimal_initialized);\n\t/*\n\t * During reincarnation, there is no guarantee that the cleanup function\n\t * will be called (deallocation may happen after all tsd destructors).\n\t * We set up tsd in a way that no cleanup is needed.\n\t */\n\trtree_ctx_data_init(tsd_rtree_ctxp_get_unsafe(tsd));\n\t*tsd_tcache_enabledp_get_unsafe(tsd) = false;\n\t*tsd_reentrancy_levelp_get(tsd) = 1;\n\ttsd_prng_state_init(tsd);\n\ttsd_te_init(tsd); /* event_init may use the prng state above. */\n\ttsd_san_init(tsd);\n\tassert_tsd_data_cleanup_done(tsd);\n\n\treturn false;\n}\n\ntsd_t *\ntsd_fetch_slow(tsd_t *tsd, bool minimal) {\n\tassert(!tsd_fast(tsd));\n\n\tif (tsd_state_get(tsd) == tsd_state_nominal_slow) {\n\t\t/*\n\t\t * On slow path but no work needed. Note that we can't\n\t\t * necessarily *assert* that we're slow, because we might be\n\t\t * slow because of an asynchronous modification to global state,\n\t\t * which might be asynchronously modified *back*.\n\t\t */\n\t} else if (tsd_state_get(tsd) == tsd_state_nominal_recompute) {\n\t\ttsd_slow_update(tsd);\n\t} else if (tsd_state_get(tsd) == tsd_state_uninitialized) {\n\t\tif (!minimal) {\n\t\t\tif (tsd_booted) {\n\t\t\t\ttsd_state_set(tsd, tsd_state_nominal);\n\t\t\t\ttsd_slow_update(tsd);\n\t\t\t\t/* Trigger cleanup handler registration. */\n\t\t\t\ttsd_set(tsd);\n\t\t\t\ttsd_data_init(tsd);\n\t\t\t}\n\t\t} else {\n\t\t\ttsd_state_set(tsd, tsd_state_minimal_initialized);\n\t\t\ttsd_set(tsd);\n\t\t\ttsd_data_init_nocleanup(tsd);\n\t\t}\n\t} else if (tsd_state_get(tsd) == tsd_state_minimal_initialized) {\n\t\tif (!minimal) {\n\t\t\t/* Switch to fully initialized. */\n\t\t\ttsd_state_set(tsd, tsd_state_nominal);\n\t\t\tassert(*tsd_reentrancy_levelp_get(tsd) >= 1);\n\t\t\t(*tsd_reentrancy_levelp_get(tsd))--;\n\t\t\ttsd_slow_update(tsd);\n\t\t\ttsd_data_init(tsd);\n\t\t} else {\n\t\t\tassert_tsd_data_cleanup_done(tsd);\n\t\t}\n\t} else if (tsd_state_get(tsd) == tsd_state_purgatory) {\n\t\ttsd_state_set(tsd, tsd_state_reincarnated);\n\t\ttsd_set(tsd);\n\t\ttsd_data_init_nocleanup(tsd);\n\t} else {\n\t\tassert(tsd_state_get(tsd) == tsd_state_reincarnated);\n\t}\n\n\treturn tsd;\n}\n\nvoid *\nmalloc_tsd_malloc(size_t size) {\n\treturn a0malloc(CACHELINE_CEILING(size));\n}\n\nvoid\nmalloc_tsd_dalloc(void *wrapper) {\n\ta0dalloc(wrapper);\n}\n\n#if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32)\nstatic unsigned ncleanups;\nstatic malloc_tsd_cleanup_t cleanups[MALLOC_TSD_CLEANUPS_MAX];\n\n#ifndef _WIN32\nJEMALLOC_EXPORT\n#endif\nvoid\n_malloc_thread_cleanup(void) {\n\tbool pending[MALLOC_TSD_CLEANUPS_MAX], again;\n\tunsigned i;\n\n\tfor (i = 0; i < ncleanups; i++) {\n\t\tpending[i] = true;\n\t}\n\n\tdo {\n\t\tagain = false;\n\t\tfor (i = 0; i < ncleanups; i++) {\n\t\t\tif (pending[i]) {\n\t\t\t\tpending[i] = cleanups[i]();\n\t\t\t\tif (pending[i]) {\n\t\t\t\t\tagain = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} while (again);\n}\n\n#ifndef _WIN32\nJEMALLOC_EXPORT\n#endif\nvoid\n_malloc_tsd_cleanup_register(bool (*f)(void)) {\n\tassert(ncleanups < MALLOC_TSD_CLEANUPS_MAX);\n\tcleanups[ncleanups] = f;\n\tncleanups++;\n}\n\n#endif\n\nstatic void\ntsd_do_data_cleanup(tsd_t *tsd) {\n\tprof_tdata_cleanup(tsd);\n\tiarena_cleanup(tsd);\n\tarena_cleanup(tsd);\n\ttcache_cleanup(tsd);\n\twitnesses_cleanup(tsd_witness_tsdp_get_unsafe(tsd));\n\t*tsd_reentrancy_levelp_get(tsd) = 1;\n}\n\nvoid\ntsd_cleanup(void *arg) {\n\ttsd_t *tsd = (tsd_t *)arg;\n\n\tswitch (tsd_state_get(tsd)) {\n\tcase tsd_state_uninitialized:\n\t\t/* Do nothing. */\n\t\tbreak;\n\tcase tsd_state_minimal_initialized:\n\t\t/* This implies the thread only did free() in its life time. */\n\t\t/* Fall through. */\n\tcase tsd_state_reincarnated:\n\t\t/*\n\t\t * Reincarnated means another destructor deallocated memory\n\t\t * after the destructor was called. Cleanup isn't required but\n\t\t * is still called for testing and completeness.\n\t\t */\n\t\tassert_tsd_data_cleanup_done(tsd);\n\t\tJEMALLOC_FALLTHROUGH;\n\tcase tsd_state_nominal:\n\tcase tsd_state_nominal_slow:\n\t\ttsd_do_data_cleanup(tsd);\n\t\ttsd_state_set(tsd, tsd_state_purgatory);\n\t\ttsd_set(tsd);\n\t\tbreak;\n\tcase tsd_state_purgatory:\n\t\t/*\n\t\t * The previous time this destructor was called, we set the\n\t\t * state to tsd_state_purgatory so that other destructors\n\t\t * wouldn't cause re-creation of the tsd. This time, do\n\t\t * nothing, and do not request another callback.\n\t\t */\n\t\tbreak;\n\tdefault:\n\t\tnot_reached();\n\t}\n#ifdef JEMALLOC_JET\n\ttest_callback_t test_callback = *tsd_test_callbackp_get_unsafe(tsd);\n\tint *data = tsd_test_datap_get_unsafe(tsd);\n\tif (test_callback != NULL) {\n\t\ttest_callback(data);\n\t}\n#endif\n}\n\ntsd_t *\nmalloc_tsd_boot0(void) {\n\ttsd_t *tsd;\n\n#if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32)\n\tncleanups = 0;\n#endif\n\tif (malloc_mutex_init(&tsd_nominal_tsds_lock, \"tsd_nominal_tsds_lock\",\n\t WITNESS_RANK_OMIT, malloc_mutex_rank_exclusive)) {\n\t\treturn NULL;\n\t}\n\tif (tsd_boot0()) {\n\t\treturn NULL;\n\t}\n\ttsd = tsd_fetch();\n\treturn tsd;\n}\n\nvoid\nmalloc_tsd_boot1(void) {\n\ttsd_boot1();\n\ttsd_t *tsd = tsd_fetch();\n\t/* malloc_slow has been set properly. Update tsd_slow. */\n\ttsd_slow_update(tsd);\n}\n\n#ifdef _WIN32\nstatic BOOL WINAPI\n_tls_callback(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {\n\tswitch (fdwReason) {\n#ifdef JEMALLOC_LAZY_LOCK\n\tcase DLL_THREAD_ATTACH:\n\t\tisthreaded = true;\n\t\tbreak;\n#endif\n\tcase DLL_THREAD_DETACH:\n\t\t_malloc_thread_cleanup();\n\t\tbreak;\n\tdefault:\n\t\tbreak;\n\t}\n\treturn true;\n}\n\n/*\n * We need to be able to say \"read\" here (in the \"pragma section\"), but have\n * hooked \"read\". We won't read for the rest of the file, so we can get away\n * with unhooking.\n */\n#ifdef read\n# undef read\n#endif\n\n#ifdef _MSC_VER\n# ifdef _M_IX86\n# pragma comment(linker, \"/INCLUDE:__tls_used\")\n# pragma comment(linker, \"/INCLUDE:_tls_callback\")\n# else\n# pragma comment(linker, \"/INCLUDE:_tls_used\")\n# pragma comment(linker, \"/INCLUDE:\" STRINGIFY(tls_callback) )\n# endif\n# pragma section(\".CRT$XLY\",long,read)\n#endif\nJEMALLOC_SECTION(\".CRT$XLY\") JEMALLOC_ATTR(used)\nBOOL\t(WINAPI *const tls_callback)(HINSTANCE hinstDLL,\n DWORD fdwReason, LPVOID lpvReserved) = _tls_callback;\n#endif\n\n#if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \\\n !defined(_WIN32))\nvoid *\ntsd_init_check_recursion(tsd_init_head_t *head, tsd_init_block_t *block) {\n\tpthread_t self = pthread_self();\n\ttsd_init_block_t *iter;\n\n\t/* Check whether this thread has already inserted into the list. */\n\tmalloc_mutex_lock(TSDN_NULL, &head->lock);\n\tql_foreach(iter, &head->blocks, link) {\n\t\tif (iter->thread == self) {\n\t\t\tmalloc_mutex_unlock(TSDN_NULL, &head->lock);\n\t\t\treturn iter->data;\n\t\t}\n\t}\n\t/* Insert block into list. */\n\tql_elm_new(block, link);\n\tblock->thread = self;\n\tql_tail_insert(&head->blocks, block, link);\n\tmalloc_mutex_unlock(TSDN_NULL, &head->lock);\n\treturn NULL;\n}\n\nvoid\ntsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block) {\n\tmalloc_mutex_lock(TSDN_NULL, &head->lock);\n\tql_remove(&head->blocks, block, link);\n\tmalloc_mutex_unlock(TSDN_NULL, &head->lock);\n}\n#endif\n\nvoid\ntsd_prefork(tsd_t *tsd) {\n\tmalloc_mutex_prefork(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n}\n\nvoid\ntsd_postfork_parent(tsd_t *tsd) {\n\tmalloc_mutex_postfork_parent(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n}\n\nvoid\ntsd_postfork_child(tsd_t *tsd) {\n\tmalloc_mutex_postfork_child(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);\n\tql_new(&tsd_nominal_tsds);\n\n\tif (tsd_state_get(tsd) <= tsd_state_nominal_max) {\n\t\ttsd_add_nominal(tsd);\n\t}\n}\n" }, { "path": "deps/jemalloc/src/witness.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n#include \"jemalloc/internal/malloc_io.h\"\n\nvoid\nwitness_init(witness_t *witness, const char *name, witness_rank_t rank,\n witness_comp_t *comp, void *opaque) {\n\twitness->name = name;\n\twitness->rank = rank;\n\twitness->comp = comp;\n\twitness->opaque = opaque;\n}\n\nstatic void\nwitness_print_witness(witness_t *w, unsigned n) {\n\tassert(n > 0);\n\tif (n == 1) {\n\t\tmalloc_printf(\" %s(%u)\", w->name, w->rank);\n\t} else {\n\t\tmalloc_printf(\" %s(%u)X%u\", w->name, w->rank, n);\n\t}\n}\n\nstatic void\nwitness_print_witnesses(const witness_list_t *witnesses) {\n\twitness_t *w, *last = NULL;\n\tunsigned n = 0;\n\tql_foreach(w, witnesses, link) {\n\t\tif (last != NULL && w->rank > last->rank) {\n\t\t\tassert(w->name != last->name);\n\t\t\twitness_print_witness(last, n);\n\t\t\tn = 0;\n\t\t} else if (last != NULL) {\n\t\t\tassert(w->rank == last->rank);\n\t\t\tassert(w->name == last->name);\n\t\t}\n\t\tlast = w;\n\t\t++n;\n\t}\n\tif (last != NULL) {\n\t\twitness_print_witness(last, n);\n\t}\n}\n\nstatic void\nwitness_lock_error_impl(const witness_list_t *witnesses,\n const witness_t *witness) {\n\tmalloc_printf(\": Lock rank order reversal:\");\n\twitness_print_witnesses(witnesses);\n\tmalloc_printf(\" %s(%u)\\n\", witness->name, witness->rank);\n\tabort();\n}\nwitness_lock_error_t *JET_MUTABLE witness_lock_error = witness_lock_error_impl;\n\nstatic void\nwitness_owner_error_impl(const witness_t *witness) {\n\tmalloc_printf(\": Should own %s(%u)\\n\", witness->name,\n\t witness->rank);\n\tabort();\n}\nwitness_owner_error_t *JET_MUTABLE witness_owner_error =\n witness_owner_error_impl;\n\nstatic void\nwitness_not_owner_error_impl(const witness_t *witness) {\n\tmalloc_printf(\": Should not own %s(%u)\\n\", witness->name,\n\t witness->rank);\n\tabort();\n}\nwitness_not_owner_error_t *JET_MUTABLE witness_not_owner_error =\n witness_not_owner_error_impl;\n\nstatic void\nwitness_depth_error_impl(const witness_list_t *witnesses,\n witness_rank_t rank_inclusive, unsigned depth) {\n\tmalloc_printf(\": Should own %u lock%s of rank >= %u:\", depth,\n\t (depth != 1) ? \"s\" : \"\", rank_inclusive);\n\twitness_print_witnesses(witnesses);\n\tmalloc_printf(\"\\n\");\n\tabort();\n}\nwitness_depth_error_t *JET_MUTABLE witness_depth_error =\n witness_depth_error_impl;\n\nvoid\nwitnesses_cleanup(witness_tsd_t *witness_tsd) {\n\twitness_assert_lockless(witness_tsd_tsdn(witness_tsd));\n\n\t/* Do nothing. */\n}\n\nvoid\nwitness_prefork(witness_tsd_t *witness_tsd) {\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\twitness_tsd->forking = true;\n}\n\nvoid\nwitness_postfork_parent(witness_tsd_t *witness_tsd) {\n\tif (!config_debug) {\n\t\treturn;\n\t}\n\twitness_tsd->forking = false;\n}\n\nvoid\nwitness_postfork_child(witness_tsd_t *witness_tsd) {\n\tif (!config_debug) {\n\t\treturn;\n\t}\n#ifndef JEMALLOC_MUTEX_INIT_CB\n\twitness_list_t *witnesses;\n\n\twitnesses = &witness_tsd->witnesses;\n\tql_new(witnesses);\n#endif\n\twitness_tsd->forking = false;\n}\n" }, { "path": "deps/jemalloc/src/zone.c", "content": "#include \"jemalloc/internal/jemalloc_preamble.h\"\n#include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n#include \"jemalloc/internal/assert.h\"\n\n#ifndef JEMALLOC_ZONE\n# error \"This source file is for zones on Darwin (OS X).\"\n#endif\n\n/* Definitions of the following structs in malloc/malloc.h might be too old\n * for the built binary to run on newer versions of OSX. So use the newest\n * possible version of those structs.\n */\ntypedef struct _malloc_zone_t {\n\tvoid *reserved1;\n\tvoid *reserved2;\n\tsize_t (*size)(struct _malloc_zone_t *, const void *);\n\tvoid *(*malloc)(struct _malloc_zone_t *, size_t);\n\tvoid *(*calloc)(struct _malloc_zone_t *, size_t, size_t);\n\tvoid *(*valloc)(struct _malloc_zone_t *, size_t);\n\tvoid (*free)(struct _malloc_zone_t *, void *);\n\tvoid *(*realloc)(struct _malloc_zone_t *, void *, size_t);\n\tvoid (*destroy)(struct _malloc_zone_t *);\n\tconst char *zone_name;\n\tunsigned (*batch_malloc)(struct _malloc_zone_t *, size_t, void **, unsigned);\n\tvoid (*batch_free)(struct _malloc_zone_t *, void **, unsigned);\n\tstruct malloc_introspection_t *introspect;\n\tunsigned version;\n\tvoid *(*memalign)(struct _malloc_zone_t *, size_t, size_t);\n\tvoid (*free_definite_size)(struct _malloc_zone_t *, void *, size_t);\n\tsize_t (*pressure_relief)(struct _malloc_zone_t *, size_t);\n} malloc_zone_t;\n\ntypedef struct {\n\tvm_address_t address;\n\tvm_size_t size;\n} vm_range_t;\n\ntypedef struct malloc_statistics_t {\n\tunsigned blocks_in_use;\n\tsize_t size_in_use;\n\tsize_t max_size_in_use;\n\tsize_t size_allocated;\n} malloc_statistics_t;\n\ntypedef kern_return_t memory_reader_t(task_t, vm_address_t, vm_size_t, void **);\n\ntypedef void vm_range_recorder_t(task_t, void *, unsigned type, vm_range_t *, unsigned);\n\ntypedef struct malloc_introspection_t {\n\tkern_return_t (*enumerator)(task_t, void *, unsigned, vm_address_t, memory_reader_t, vm_range_recorder_t);\n\tsize_t (*good_size)(malloc_zone_t *, size_t);\n\tboolean_t (*check)(malloc_zone_t *);\n\tvoid (*print)(malloc_zone_t *, boolean_t);\n\tvoid (*log)(malloc_zone_t *, void *);\n\tvoid (*force_lock)(malloc_zone_t *);\n\tvoid (*force_unlock)(malloc_zone_t *);\n\tvoid (*statistics)(malloc_zone_t *, malloc_statistics_t *);\n\tboolean_t (*zone_locked)(malloc_zone_t *);\n\tboolean_t (*enable_discharge_checking)(malloc_zone_t *);\n\tboolean_t (*disable_discharge_checking)(malloc_zone_t *);\n\tvoid (*discharge)(malloc_zone_t *, void *);\n#ifdef __BLOCKS__\n\tvoid (*enumerate_discharged_pointers)(malloc_zone_t *, void (^)(void *, void *));\n#else\n\tvoid *enumerate_unavailable_without_blocks;\n#endif\n\tvoid (*reinit_lock)(malloc_zone_t *);\n} malloc_introspection_t;\n\nextern kern_return_t malloc_get_all_zones(task_t, memory_reader_t, vm_address_t **, unsigned *);\n\nextern malloc_zone_t *malloc_default_zone(void);\n\nextern void malloc_zone_register(malloc_zone_t *zone);\n\nextern void malloc_zone_unregister(malloc_zone_t *zone);\n\n/*\n * The malloc_default_purgeable_zone() function is only available on >= 10.6.\n * We need to check whether it is present at runtime, thus the weak_import.\n */\nextern malloc_zone_t *malloc_default_purgeable_zone(void)\nJEMALLOC_ATTR(weak_import);\n\n/******************************************************************************/\n/* Data. */\n\nstatic malloc_zone_t *default_zone, *purgeable_zone;\nstatic malloc_zone_t jemalloc_zone;\nstatic struct malloc_introspection_t jemalloc_zone_introspect;\nstatic pid_t zone_force_lock_pid = -1;\n\n/******************************************************************************/\n/* Function prototypes for non-inline static functions. */\n\nstatic size_t\tzone_size(malloc_zone_t *zone, const void *ptr);\nstatic void\t*zone_malloc(malloc_zone_t *zone, size_t size);\nstatic void\t*zone_calloc(malloc_zone_t *zone, size_t num, size_t size);\nstatic void\t*zone_valloc(malloc_zone_t *zone, size_t size);\nstatic void\tzone_free(malloc_zone_t *zone, void *ptr);\nstatic void\t*zone_realloc(malloc_zone_t *zone, void *ptr, size_t size);\nstatic void\t*zone_memalign(malloc_zone_t *zone, size_t alignment,\n size_t size);\nstatic void\tzone_free_definite_size(malloc_zone_t *zone, void *ptr,\n size_t size);\nstatic void\tzone_destroy(malloc_zone_t *zone);\nstatic unsigned\tzone_batch_malloc(struct _malloc_zone_t *zone, size_t size,\n void **results, unsigned num_requested);\nstatic void\tzone_batch_free(struct _malloc_zone_t *zone,\n void **to_be_freed, unsigned num_to_be_freed);\nstatic size_t\tzone_pressure_relief(struct _malloc_zone_t *zone, size_t goal);\nstatic size_t\tzone_good_size(malloc_zone_t *zone, size_t size);\nstatic kern_return_t\tzone_enumerator(task_t task, void *data, unsigned type_mask,\n vm_address_t zone_address, memory_reader_t reader,\n vm_range_recorder_t recorder);\nstatic boolean_t\tzone_check(malloc_zone_t *zone);\nstatic void\tzone_print(malloc_zone_t *zone, boolean_t verbose);\nstatic void\tzone_log(malloc_zone_t *zone, void *address);\nstatic void\tzone_force_lock(malloc_zone_t *zone);\nstatic void\tzone_force_unlock(malloc_zone_t *zone);\nstatic void\tzone_statistics(malloc_zone_t *zone,\n malloc_statistics_t *stats);\nstatic boolean_t\tzone_locked(malloc_zone_t *zone);\nstatic void\tzone_reinit_lock(malloc_zone_t *zone);\n\n/******************************************************************************/\n/*\n * Functions.\n */\n\nstatic size_t\nzone_size(malloc_zone_t *zone, const void *ptr) {\n\t/*\n\t * There appear to be places within Darwin (such as setenv(3)) that\n\t * cause calls to this function with pointers that *no* zone owns. If\n\t * we knew that all pointers were owned by *some* zone, we could split\n\t * our zone into two parts, and use one as the default allocator and\n\t * the other as the default deallocator/reallocator. Since that will\n\t * not work in practice, we must check all pointers to assure that they\n\t * reside within a mapped extent before determining size.\n\t */\n\treturn ivsalloc(tsdn_fetch(), ptr);\n}\n\nstatic void *\nzone_malloc(malloc_zone_t *zone, size_t size) {\n\treturn je_malloc(size);\n}\n\nstatic void *\nzone_calloc(malloc_zone_t *zone, size_t num, size_t size) {\n\treturn je_calloc(num, size);\n}\n\nstatic void *\nzone_valloc(malloc_zone_t *zone, size_t size) {\n\tvoid *ret = NULL; /* Assignment avoids useless compiler warning. */\n\n\tje_posix_memalign(&ret, PAGE, size);\n\n\treturn ret;\n}\n\nstatic void\nzone_free(malloc_zone_t *zone, void *ptr) {\n\tif (ivsalloc(tsdn_fetch(), ptr) != 0) {\n\t\tje_free(ptr);\n\t\treturn;\n\t}\n\n\tfree(ptr);\n}\n\nstatic void *\nzone_realloc(malloc_zone_t *zone, void *ptr, size_t size) {\n\tif (ivsalloc(tsdn_fetch(), ptr) != 0) {\n\t\treturn je_realloc(ptr, size);\n\t}\n\n\treturn realloc(ptr, size);\n}\n\nstatic void *\nzone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) {\n\tvoid *ret = NULL; /* Assignment avoids useless compiler warning. */\n\n\tje_posix_memalign(&ret, alignment, size);\n\n\treturn ret;\n}\n\nstatic void\nzone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size) {\n\tsize_t alloc_size;\n\n\talloc_size = ivsalloc(tsdn_fetch(), ptr);\n\tif (alloc_size != 0) {\n\t\tassert(alloc_size == size);\n\t\tje_free(ptr);\n\t\treturn;\n\t}\n\n\tfree(ptr);\n}\n\nstatic void\nzone_destroy(malloc_zone_t *zone) {\n\t/* This function should never be called. */\n\tnot_reached();\n}\n\nstatic unsigned\nzone_batch_malloc(struct _malloc_zone_t *zone, size_t size, void **results,\n unsigned num_requested) {\n\tunsigned i;\n\n\tfor (i = 0; i < num_requested; i++) {\n\t\tresults[i] = je_malloc(size);\n\t\tif (!results[i])\n\t\t\tbreak;\n\t}\n\n\treturn i;\n}\n\nstatic void\nzone_batch_free(struct _malloc_zone_t *zone, void **to_be_freed,\n unsigned num_to_be_freed) {\n\tunsigned i;\n\n\tfor (i = 0; i < num_to_be_freed; i++) {\n\t\tzone_free(zone, to_be_freed[i]);\n\t\tto_be_freed[i] = NULL;\n\t}\n}\n\nstatic size_t\nzone_pressure_relief(struct _malloc_zone_t *zone, size_t goal) {\n\treturn 0;\n}\n\nstatic size_t\nzone_good_size(malloc_zone_t *zone, size_t size) {\n\tif (size == 0) {\n\t\tsize = 1;\n\t}\n\treturn sz_s2u(size);\n}\n\nstatic kern_return_t\nzone_enumerator(task_t task, void *data, unsigned type_mask,\n vm_address_t zone_address, memory_reader_t reader,\n vm_range_recorder_t recorder) {\n\treturn KERN_SUCCESS;\n}\n\nstatic boolean_t\nzone_check(malloc_zone_t *zone) {\n\treturn true;\n}\n\nstatic void\nzone_print(malloc_zone_t *zone, boolean_t verbose) {\n}\n\nstatic void\nzone_log(malloc_zone_t *zone, void *address) {\n}\n\nstatic void\nzone_force_lock(malloc_zone_t *zone) {\n\tif (isthreaded) {\n\t\t/*\n\t\t * See the note in zone_force_unlock, below, to see why we need\n\t\t * this.\n\t\t */\n\t\tassert(zone_force_lock_pid == -1);\n\t\tzone_force_lock_pid = getpid();\n\t\tjemalloc_prefork();\n\t}\n}\n\nstatic void\nzone_force_unlock(malloc_zone_t *zone) {\n\t/*\n\t * zone_force_lock and zone_force_unlock are the entry points to the\n\t * forking machinery on OS X. The tricky thing is, the child is not\n\t * allowed to unlock mutexes locked in the parent, even if owned by the\n\t * forking thread (and the mutex type we use in OS X will fail an assert\n\t * if we try). In the child, we can get away with reinitializing all\n\t * the mutexes, which has the effect of unlocking them. In the parent,\n\t * doing this would mean we wouldn't wake any waiters blocked on the\n\t * mutexes we unlock. So, we record the pid of the current thread in\n\t * zone_force_lock, and use that to detect if we're in the parent or\n\t * child here, to decide which unlock logic we need.\n\t */\n\tif (isthreaded) {\n\t\tassert(zone_force_lock_pid != -1);\n\t\tif (getpid() == zone_force_lock_pid) {\n\t\t\tjemalloc_postfork_parent();\n\t\t} else {\n\t\t\tjemalloc_postfork_child();\n\t\t}\n\t\tzone_force_lock_pid = -1;\n\t}\n}\n\nstatic void\nzone_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) {\n\t/* We make no effort to actually fill the values */\n\tstats->blocks_in_use = 0;\n\tstats->size_in_use = 0;\n\tstats->max_size_in_use = 0;\n\tstats->size_allocated = 0;\n}\n\nstatic boolean_t\nzone_locked(malloc_zone_t *zone) {\n\t/* Pretend no lock is being held */\n\treturn false;\n}\n\nstatic void\nzone_reinit_lock(malloc_zone_t *zone) {\n\t/* As of OSX 10.12, this function is only used when force_unlock would\n\t * be used if the zone version were < 9. So just use force_unlock. */\n\tzone_force_unlock(zone);\n}\n\nstatic void\nzone_init(void) {\n\tjemalloc_zone.size = zone_size;\n\tjemalloc_zone.malloc = zone_malloc;\n\tjemalloc_zone.calloc = zone_calloc;\n\tjemalloc_zone.valloc = zone_valloc;\n\tjemalloc_zone.free = zone_free;\n\tjemalloc_zone.realloc = zone_realloc;\n\tjemalloc_zone.destroy = zone_destroy;\n\tjemalloc_zone.zone_name = \"jemalloc_zone\";\n\tjemalloc_zone.batch_malloc = zone_batch_malloc;\n\tjemalloc_zone.batch_free = zone_batch_free;\n\tjemalloc_zone.introspect = &jemalloc_zone_introspect;\n\tjemalloc_zone.version = 9;\n\tjemalloc_zone.memalign = zone_memalign;\n\tjemalloc_zone.free_definite_size = zone_free_definite_size;\n\tjemalloc_zone.pressure_relief = zone_pressure_relief;\n\n\tjemalloc_zone_introspect.enumerator = zone_enumerator;\n\tjemalloc_zone_introspect.good_size = zone_good_size;\n\tjemalloc_zone_introspect.check = zone_check;\n\tjemalloc_zone_introspect.print = zone_print;\n\tjemalloc_zone_introspect.log = zone_log;\n\tjemalloc_zone_introspect.force_lock = zone_force_lock;\n\tjemalloc_zone_introspect.force_unlock = zone_force_unlock;\n\tjemalloc_zone_introspect.statistics = zone_statistics;\n\tjemalloc_zone_introspect.zone_locked = zone_locked;\n\tjemalloc_zone_introspect.enable_discharge_checking = NULL;\n\tjemalloc_zone_introspect.disable_discharge_checking = NULL;\n\tjemalloc_zone_introspect.discharge = NULL;\n#ifdef __BLOCKS__\n\tjemalloc_zone_introspect.enumerate_discharged_pointers = NULL;\n#else\n\tjemalloc_zone_introspect.enumerate_unavailable_without_blocks = NULL;\n#endif\n\tjemalloc_zone_introspect.reinit_lock = zone_reinit_lock;\n}\n\nstatic malloc_zone_t *\nzone_default_get(void) {\n\tmalloc_zone_t **zones = NULL;\n\tunsigned int num_zones = 0;\n\n\t/*\n\t * On OSX 10.12, malloc_default_zone returns a special zone that is not\n\t * present in the list of registered zones. That zone uses a \"lite zone\"\n\t * if one is present (apparently enabled when malloc stack logging is\n\t * enabled), or the first registered zone otherwise. In practice this\n\t * means unless malloc stack logging is enabled, the first registered\n\t * zone is the default. So get the list of zones to get the first one,\n\t * instead of relying on malloc_default_zone.\n\t */\n\tif (KERN_SUCCESS != malloc_get_all_zones(0, NULL,\n\t (vm_address_t**)&zones, &num_zones)) {\n\t\t/*\n\t\t * Reset the value in case the failure happened after it was\n\t\t * set.\n\t\t */\n\t\tnum_zones = 0;\n\t}\n\n\tif (num_zones) {\n\t\treturn zones[0];\n\t}\n\n\treturn malloc_default_zone();\n}\n\n/* As written, this function can only promote jemalloc_zone. */\nstatic void\nzone_promote(void) {\n\tmalloc_zone_t *zone;\n\n\tdo {\n\t\t/*\n\t\t * Unregister and reregister the default zone. On OSX >= 10.6,\n\t\t * unregistering takes the last registered zone and places it\n\t\t * at the location of the specified zone. Unregistering the\n\t\t * default zone thus makes the last registered one the default.\n\t\t * On OSX < 10.6, unregistering shifts all registered zones.\n\t\t * The first registered zone then becomes the default.\n\t\t */\n\t\tmalloc_zone_unregister(default_zone);\n\t\tmalloc_zone_register(default_zone);\n\n\t\t/*\n\t\t * On OSX 10.6, having the default purgeable zone appear before\n\t\t * the default zone makes some things crash because it thinks it\n\t\t * owns the default zone allocated pointers. We thus\n\t\t * unregister/re-register it in order to ensure it's always\n\t\t * after the default zone. On OSX < 10.6, there is no purgeable\n\t\t * zone, so this does nothing. On OSX >= 10.6, unregistering\n\t\t * replaces the purgeable zone with the last registered zone\n\t\t * above, i.e. the default zone. Registering it again then puts\n\t\t * it at the end, obviously after the default zone.\n\t\t */\n\t\tif (purgeable_zone != NULL) {\n\t\t\tmalloc_zone_unregister(purgeable_zone);\n\t\t\tmalloc_zone_register(purgeable_zone);\n\t\t}\n\n\t\tzone = zone_default_get();\n\t} while (zone != &jemalloc_zone);\n}\n\nJEMALLOC_ATTR(constructor)\nvoid\nzone_register(void) {\n\t/*\n\t * If something else replaced the system default zone allocator, don't\n\t * register jemalloc's.\n\t */\n\tdefault_zone = zone_default_get();\n\tif (!default_zone->zone_name || strcmp(default_zone->zone_name,\n\t \"DefaultMallocZone\") != 0) {\n\t\treturn;\n\t}\n\n\t/*\n\t * The default purgeable zone is created lazily by OSX's libc. It uses\n\t * the default zone when it is created for \"small\" allocations\n\t * (< 15 KiB), but assumes the default zone is a scalable_zone. This\n\t * obviously fails when the default zone is the jemalloc zone, so\n\t * malloc_default_purgeable_zone() is called beforehand so that the\n\t * default purgeable zone is created when the default zone is still\n\t * a scalable_zone. As purgeable zones only exist on >= 10.6, we need\n\t * to check for the existence of malloc_default_purgeable_zone() at\n\t * run time.\n\t */\n\tpurgeable_zone = (malloc_default_purgeable_zone == NULL) ? NULL :\n\t malloc_default_purgeable_zone();\n\n\t/* Register the custom zone. At this point it won't be the default. */\n\tzone_init();\n\tmalloc_zone_register(&jemalloc_zone);\n\n\t/* Promote the custom zone to be default. */\n\tzone_promote();\n}\n" }, { "path": "deps/jemalloc/test/analyze/prof_bias.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * This is a helper utility, only meant to be run manually (and, for example,\n * doesn't check for failures, try to skip execution in non-prof modes, etc.).\n * It runs, allocates objects of two different sizes from the same stack trace,\n * and exits.\n *\n * The idea is that some human operator will run it like:\n * MALLOC_CONF=\"prof:true,prof_final:true\" test/analyze/prof_bias\n * and manually inspect the results.\n *\n * The results should be:\n * jeprof --text test/analyze/prof_bias --inuse_space jeprof..0.f.heap:\n * \taround 1024 MB\n * jeprof --text test/analyze/prof_bias --inuse_objects jeprof..0.f.heap:\n * \taround 33554448 = 16 + 32 * 1024 * 1024\n *\n * And, if prof_accum is on:\n * jeprof --text test/analyze/prof_bias --alloc_space jeprof..0.f.heap:\n * around 2048 MB\n * jeprof --text test/analyze/prof_bias --alloc_objects jeprof..0.f.heap:\n * \taround 67108896 = 2 * (16 + 32 * 1024 * 1024)\n */\n\nstatic void\nmock_backtrace(void **vec, unsigned *len, unsigned max_len) {\n\t*len = 4;\n\tvec[0] = (void *)0x111;\n\tvec[1] = (void *)0x222;\n\tvec[2] = (void *)0x333;\n\tvec[3] = (void *)0x444;\n}\n\nstatic void\ndo_allocs(size_t sz, size_t cnt, bool do_frees) {\n\tfor (size_t i = 0; i < cnt; i++) {\n\t\tvoid *ptr = mallocx(sz, 0);\n\t\tassert_ptr_not_null(ptr, \"Unexpected mallocx failure\");\n\t\tif (do_frees) {\n\t\t\tdallocx(ptr, 0);\n\t\t}\n\t}\n}\n\nint\nmain(void) {\n\tsize_t lg_prof_sample_local = 19;\n\tint err = mallctl(\"prof.reset\", NULL, NULL,\n\t (void *)&lg_prof_sample_local, sizeof(lg_prof_sample_local));\n\tassert(err == 0);\n\n\tprof_backtrace_hook_set(mock_backtrace);\n\tdo_allocs(16, 32 * 1024 * 1024, /* do_frees */ true);\n\tdo_allocs(32 * 1024* 1024, 16, /* do_frees */ true);\n\tdo_allocs(16, 32 * 1024 * 1024, /* do_frees */ false);\n\tdo_allocs(32 * 1024* 1024, 16, /* do_frees */ false);\n\n\treturn 0;\n}\n" }, { "path": "deps/jemalloc/test/analyze/rand.c", "content": "#include \"test/jemalloc_test.h\"\n\n/******************************************************************************/\n\n/*\n * General purpose tool for examining random number distributions.\n *\n * Input -\n * (a) a random number generator, and\n * (b) the buckets:\n * (1) number of buckets,\n * (2) width of each bucket, in log scale,\n * (3) expected mean and stddev of the count of random numbers in each\n * bucket, and\n * (c) number of iterations to invoke the generator.\n *\n * The program generates the specified amount of random numbers, and assess how\n * well they conform to the expectations: for each bucket, output -\n * (a) the (given) expected mean and stddev,\n * (b) the actual count and any interesting level of deviation:\n * (1) ~68% buckets should show no interesting deviation, meaning a\n * deviation less than stddev from the expectation;\n * (2) ~27% buckets should show '+' / '-', meaning a deviation in the range\n * of [stddev, 2 * stddev) from the expectation;\n * (3) ~4% buckets should show '++' / '--', meaning a deviation in the\n * range of [2 * stddev, 3 * stddev) from the expectation; and\n * (4) less than 0.3% buckets should show more than two '+'s / '-'s.\n *\n * Technical remarks:\n * (a) The generator is expected to output uint64_t numbers, so you might need\n * to define a wrapper.\n * (b) The buckets must be of equal width and the lowest bucket starts at\n * [0, 2^lg_bucket_width - 1).\n * (c) Any generated number >= n_bucket * 2^lg_bucket_width will be counted\n * towards the last bucket; the expected mean and stddev provided should\n * also reflect that.\n * (d) The number of iterations is advised to be determined so that the bucket\n * with the minimal expected proportion gets a sufficient count.\n */\n\nstatic void\nfill(size_t a[], const size_t n, const size_t k) {\n\tfor (size_t i = 0; i < n; ++i) {\n\t\ta[i] = k;\n\t}\n}\n\nstatic void\ncollect_buckets(uint64_t (*gen)(void *), void *opaque, size_t buckets[],\n const size_t n_bucket, const size_t lg_bucket_width, const size_t n_iter) {\n\tfor (size_t i = 0; i < n_iter; ++i) {\n\t\tuint64_t num = gen(opaque);\n\t\tuint64_t bucket_id = num >> lg_bucket_width;\n\t\tif (bucket_id >= n_bucket) {\n\t\t\tbucket_id = n_bucket - 1;\n\t\t}\n\t\t++buckets[bucket_id];\n\t}\n}\n\nstatic void\nprint_buckets(const size_t buckets[], const size_t means[],\n const size_t stddevs[], const size_t n_bucket) {\n\tfor (size_t i = 0; i < n_bucket; ++i) {\n\t\tmalloc_printf(\"%zu:\\tmean = %zu,\\tstddev = %zu,\\tbucket = %zu\",\n\t\t i, means[i], stddevs[i], buckets[i]);\n\n\t\t/* Make sure there's no overflow. */\n\t\tassert(buckets[i] + stddevs[i] >= stddevs[i]);\n\t\tassert(means[i] + stddevs[i] >= stddevs[i]);\n\n\t\tif (buckets[i] + stddevs[i] <= means[i]) {\n\t\t\tmalloc_write(\" \");\n\t\t\tfor (size_t t = means[i] - buckets[i]; t >= stddevs[i];\n\t\t\t t -= stddevs[i]) {\n\t\t\t\tmalloc_write(\"-\");\n\t\t\t}\n\t\t} else if (buckets[i] >= means[i] + stddevs[i]) {\n\t\t\tmalloc_write(\" \");\n\t\t\tfor (size_t t = buckets[i] - means[i]; t >= stddevs[i];\n\t\t\t t -= stddevs[i]) {\n\t\t\t\tmalloc_write(\"+\");\n\t\t\t}\n\t\t}\n\t\tmalloc_write(\"\\n\");\n\t}\n}\n\nstatic void\nbucket_analysis(uint64_t (*gen)(void *), void *opaque, size_t buckets[],\n const size_t means[], const size_t stddevs[], const size_t n_bucket,\n const size_t lg_bucket_width, const size_t n_iter) {\n\tfor (size_t i = 1; i <= 3; ++i) {\n\t\tmalloc_printf(\"round %zu\\n\", i);\n\t\tfill(buckets, n_bucket, 0);\n\t\tcollect_buckets(gen, opaque, buckets, n_bucket,\n\t\t lg_bucket_width, n_iter);\n\t\tprint_buckets(buckets, means, stddevs, n_bucket);\n\t}\n}\n\n/* (Recommended) minimal bucket mean. */\n#define MIN_BUCKET_MEAN 10000\n\n/******************************************************************************/\n\n/* Uniform random number generator. */\n\ntypedef struct uniform_gen_arg_s uniform_gen_arg_t;\nstruct uniform_gen_arg_s {\n\tuint64_t state;\n\tconst unsigned lg_range;\n};\n\nstatic uint64_t\nuniform_gen(void *opaque) {\n\tuniform_gen_arg_t *arg = (uniform_gen_arg_t *)opaque;\n\treturn prng_lg_range_u64(&arg->state, arg->lg_range);\n}\n\nTEST_BEGIN(test_uniform) {\n#define LG_N_BUCKET 5\n#define N_BUCKET (1 << LG_N_BUCKET)\n\n#define QUOTIENT_CEIL(n, d) (((n) - 1) / (d) + 1)\n\n\tconst unsigned lg_range_test = 25;\n\n\t/*\n\t * Mathematical tricks to guarantee that both mean and stddev are\n\t * integers, and that the minimal bucket mean is at least\n\t * MIN_BUCKET_MEAN.\n\t */\n\tconst size_t q = 1 << QUOTIENT_CEIL(LG_CEIL(QUOTIENT_CEIL(\n\t MIN_BUCKET_MEAN, N_BUCKET * (N_BUCKET - 1))), 2);\n\tconst size_t stddev = (N_BUCKET - 1) * q;\n\tconst size_t mean = N_BUCKET * stddev * q;\n\tconst size_t n_iter = N_BUCKET * mean;\n\n\tsize_t means[N_BUCKET];\n\tfill(means, N_BUCKET, mean);\n\tsize_t stddevs[N_BUCKET];\n\tfill(stddevs, N_BUCKET, stddev);\n\n\tuniform_gen_arg_t arg = {(uint64_t)(uintptr_t)&lg_range_test,\n\t lg_range_test};\n\tsize_t buckets[N_BUCKET];\n\tassert_zu_ge(lg_range_test, LG_N_BUCKET, \"\");\n\tconst size_t lg_bucket_width = lg_range_test - LG_N_BUCKET;\n\n\tbucket_analysis(uniform_gen, &arg, buckets, means, stddevs,\n\t N_BUCKET, lg_bucket_width, n_iter);\n\n#undef LG_N_BUCKET\n#undef N_BUCKET\n#undef QUOTIENT_CEIL\n}\nTEST_END\n\n/******************************************************************************/\n\n/* Geometric random number generator; compiled only when prof is on. */\n\n#ifdef JEMALLOC_PROF\n\n/*\n * Fills geometric proportions and returns the minimal proportion. See\n * comments in test_prof_sample for explanations for n_divide.\n */\nstatic double\nfill_geometric_proportions(double proportions[], const size_t n_bucket,\n const size_t n_divide) {\n\tassert(n_bucket > 0);\n\tassert(n_divide > 0);\n\tdouble x = 1.;\n\tfor (size_t i = 0; i < n_bucket; ++i) {\n\t\tif (i == n_bucket - 1) {\n\t\t\tproportions[i] = x;\n\t\t} else {\n\t\t\tdouble y = x * exp(-1. / n_divide);\n\t\t\tproportions[i] = x - y;\n\t\t\tx = y;\n\t\t}\n\t}\n\t/*\n\t * The minimal proportion is the smaller one of the last two\n\t * proportions for geometric distribution.\n\t */\n\tdouble min_proportion = proportions[n_bucket - 1];\n\tif (n_bucket >= 2 && proportions[n_bucket - 2] < min_proportion) {\n\t\tmin_proportion = proportions[n_bucket - 2];\n\t}\n\treturn min_proportion;\n}\n\nstatic size_t\nround_to_nearest(const double x) {\n\treturn (size_t)(x + .5);\n}\n\nstatic void\nfill_references(size_t means[], size_t stddevs[], const double proportions[],\n const size_t n_bucket, const size_t n_iter) {\n\tfor (size_t i = 0; i < n_bucket; ++i) {\n\t\tdouble x = n_iter * proportions[i];\n\t\tmeans[i] = round_to_nearest(x);\n\t\tstddevs[i] = round_to_nearest(sqrt(x * (1. - proportions[i])));\n\t}\n}\n\nstatic uint64_t\nprof_sample_gen(void *opaque) {\n\treturn prof_sample_new_event_wait((tsd_t *)opaque) - 1;\n}\n\n#endif /* JEMALLOC_PROF */\n\nTEST_BEGIN(test_prof_sample) {\n\ttest_skip_if(!config_prof);\n#ifdef JEMALLOC_PROF\n\n/* Number of divisions within [0, mean). */\n#define LG_N_DIVIDE 3\n#define N_DIVIDE (1 << LG_N_DIVIDE)\n\n/* Coverage of buckets in terms of multiples of mean. */\n#define LG_N_MULTIPLY 2\n#define N_GEO_BUCKET (N_DIVIDE << LG_N_MULTIPLY)\n\n\ttest_skip_if(!opt_prof);\n\n\tsize_t lg_prof_sample_test = 25;\n\n\tsize_t lg_prof_sample_orig = lg_prof_sample;\n\tassert_d_eq(mallctl(\"prof.reset\", NULL, NULL, &lg_prof_sample_test,\n\t sizeof(size_t)), 0, \"\");\n\tmalloc_printf(\"lg_prof_sample = %zu\\n\", lg_prof_sample_test);\n\n\tdouble proportions[N_GEO_BUCKET + 1];\n\tconst double min_proportion = fill_geometric_proportions(proportions,\n\t N_GEO_BUCKET + 1, N_DIVIDE);\n\tconst size_t n_iter = round_to_nearest(MIN_BUCKET_MEAN /\n\t min_proportion);\n\tsize_t means[N_GEO_BUCKET + 1];\n\tsize_t stddevs[N_GEO_BUCKET + 1];\n\tfill_references(means, stddevs, proportions, N_GEO_BUCKET + 1, n_iter);\n\n\ttsd_t *tsd = tsd_fetch();\n\tassert_ptr_not_null(tsd, \"\");\n\tsize_t buckets[N_GEO_BUCKET + 1];\n\tassert_zu_ge(lg_prof_sample, LG_N_DIVIDE, \"\");\n\tconst size_t lg_bucket_width = lg_prof_sample - LG_N_DIVIDE;\n\n\tbucket_analysis(prof_sample_gen, tsd, buckets, means, stddevs,\n\t N_GEO_BUCKET + 1, lg_bucket_width, n_iter);\n\n\tassert_d_eq(mallctl(\"prof.reset\", NULL, NULL, &lg_prof_sample_orig,\n\t sizeof(size_t)), 0, \"\");\n\n#undef LG_N_DIVIDE\n#undef N_DIVIDE\n#undef LG_N_MULTIPLY\n#undef N_GEO_BUCKET\n\n#endif /* JEMALLOC_PROF */\n}\nTEST_END\n\n/******************************************************************************/\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_uniform,\n\t test_prof_sample);\n}\n" }, { "path": "deps/jemalloc/test/analyze/sizes.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \n\n/*\n * Print the sizes of various important core data structures. OK, I guess this\n * isn't really a \"stress\" test, but it does give useful information about\n * low-level performance characteristics, as the other things in this directory\n * do.\n */\n\nstatic void\ndo_print(const char *name, size_t sz_bytes) {\n\tconst char *sizes[] = {\"bytes\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\",\n\t\t\"ZB\"};\n\tsize_t sizes_max = sizeof(sizes)/sizeof(sizes[0]);\n\n\tsize_t ind = 0;\n\tdouble sz = sz_bytes;\n\twhile (sz >= 1024 && ind < sizes_max - 1) {\n\t\tsz /= 1024;\n\t\tind++;\n\t}\n\tif (ind == 0) {\n\t\tprintf(\"%-20s: %zu bytes\\n\", name, sz_bytes);\n\t} else {\n\t\tprintf(\"%-20s: %f %s\\n\", name, sz, sizes[ind]);\n\t}\n}\n\nint\nmain() {\n#define P(type)\t\t\t\t\t\t\t\t\\\n\tdo_print(#type, sizeof(type))\n\tP(arena_t);\n\tP(arena_stats_t);\n\tP(base_t);\n\tP(decay_t);\n\tP(edata_t);\n\tP(ecache_t);\n\tP(eset_t);\n\tP(malloc_mutex_t);\n\tP(prof_tctx_t);\n\tP(prof_gctx_t);\n\tP(prof_tdata_t);\n\tP(rtree_t);\n\tP(rtree_leaf_elm_t);\n\tP(slab_data_t);\n\tP(tcache_t);\n\tP(tcache_slow_t);\n\tP(tsd_t);\n#undef P\n}\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-alti.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n/**\n * @file SFMT-alti.h\n *\n * @brief SIMD oriented Fast Mersenne Twister(SFMT)\n * pseudorandom number generator\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * Copyright (C) 2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * The new BSD License is applied to this software.\n * see LICENSE.txt\n */\n\n#ifndef SFMT_ALTI_H\n#define SFMT_ALTI_H\n\n/**\n * This function represents the recursion formula in AltiVec and BIG ENDIAN.\n * @param a a 128-bit part of the interal state array\n * @param b a 128-bit part of the interal state array\n * @param c a 128-bit part of the interal state array\n * @param d a 128-bit part of the interal state array\n * @return output\n */\nJEMALLOC_ALWAYS_INLINE\nvector unsigned int vec_recursion(vector unsigned int a,\n\t\t\t\t\t\tvector unsigned int b,\n\t\t\t\t\t\tvector unsigned int c,\n\t\t\t\t\t\tvector unsigned int d) {\n\n const vector unsigned int sl1 = ALTI_SL1;\n const vector unsigned int sr1 = ALTI_SR1;\n#ifdef ONLY64\n const vector unsigned int mask = ALTI_MSK64;\n const vector unsigned char perm_sl = ALTI_SL2_PERM64;\n const vector unsigned char perm_sr = ALTI_SR2_PERM64;\n#else\n const vector unsigned int mask = ALTI_MSK;\n const vector unsigned char perm_sl = ALTI_SL2_PERM;\n const vector unsigned char perm_sr = ALTI_SR2_PERM;\n#endif\n vector unsigned int v, w, x, y, z;\n x = vec_perm(a, (vector unsigned int)perm_sl, perm_sl);\n v = a;\n y = vec_sr(b, sr1);\n z = vec_perm(c, (vector unsigned int)perm_sr, perm_sr);\n w = vec_sl(d, sl1);\n z = vec_xor(z, w);\n y = vec_and(y, mask);\n v = vec_xor(v, x);\n z = vec_xor(z, y);\n z = vec_xor(z, v);\n return z;\n}\n\n/**\n * This function fills the internal state array with pseudorandom\n * integers.\n */\nstatic inline void gen_rand_all(sfmt_t *ctx) {\n int i;\n vector unsigned int r, r1, r2;\n\n r1 = ctx->sfmt[N - 2].s;\n r2 = ctx->sfmt[N - 1].s;\n for (i = 0; i < N - POS1; i++) {\n\tr = vec_recursion(ctx->sfmt[i].s, ctx->sfmt[i + POS1].s, r1, r2);\n\tctx->sfmt[i].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n for (; i < N; i++) {\n\tr = vec_recursion(ctx->sfmt[i].s, ctx->sfmt[i + POS1 - N].s, r1, r2);\n\tctx->sfmt[i].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n}\n\n/**\n * This function fills the user-specified array with pseudorandom\n * integers.\n *\n * @param array an 128-bit array to be filled by pseudorandom numbers.\n * @param size number of 128-bit pesudorandom numbers to be generated.\n */\nstatic inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {\n int i, j;\n vector unsigned int r, r1, r2;\n\n r1 = ctx->sfmt[N - 2].s;\n r2 = ctx->sfmt[N - 1].s;\n for (i = 0; i < N - POS1; i++) {\n\tr = vec_recursion(ctx->sfmt[i].s, ctx->sfmt[i + POS1].s, r1, r2);\n\tarray[i].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n for (; i < N; i++) {\n\tr = vec_recursion(ctx->sfmt[i].s, array[i + POS1 - N].s, r1, r2);\n\tarray[i].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n /* main loop */\n for (; i < size - N; i++) {\n\tr = vec_recursion(array[i - N].s, array[i + POS1 - N].s, r1, r2);\n\tarray[i].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n for (j = 0; j < 2 * N - size; j++) {\n\tctx->sfmt[j].s = array[j + size - N].s;\n }\n for (; i < size; i++) {\n\tr = vec_recursion(array[i - N].s, array[i + POS1 - N].s, r1, r2);\n\tarray[i].s = r;\n\tctx->sfmt[j++].s = r;\n\tr1 = r2;\n\tr2 = r;\n }\n}\n\n#ifndef ONLY64\n#if defined(__APPLE__)\n#define ALTI_SWAP (vector unsigned char) \\\n\t(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11)\n#else\n#define ALTI_SWAP {4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11}\n#endif\n/**\n * This function swaps high and low 32-bit of 64-bit integers in user\n * specified array.\n *\n * @param array an 128-bit array to be swaped.\n * @param size size of 128-bit array.\n */\nstatic inline void swap(w128_t *array, int size) {\n int i;\n const vector unsigned char perm = ALTI_SWAP;\n\n for (i = 0; i < size; i++) {\n\tarray[i].s = vec_perm(array[i].s, (vector unsigned int)perm, perm);\n }\n}\n#endif\n\n#endif\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS_H\n#define SFMT_PARAMS_H\n\n#if !defined(MEXP)\n#ifdef __GNUC__\n #warning \"MEXP is not defined. I assume MEXP is 19937.\"\n#endif\n #define MEXP 19937\n#endif\n/*-----------------\n BASIC DEFINITIONS\n -----------------*/\n/** Mersenne Exponent. The period of the sequence \n * is a multiple of 2^MEXP-1.\n * #define MEXP 19937 */\n/** SFMT generator has an internal state array of 128-bit integers,\n * and N is its size. */\n#define N (MEXP / 128 + 1)\n/** N32 is the size of internal state array when regarded as an array\n * of 32-bit integers.*/\n#define N32 (N * 4)\n/** N64 is the size of internal state array when regarded as an array\n * of 64-bit integers.*/\n#define N64 (N * 2)\n\n/*----------------------\n the parameters of SFMT\n following definitions are in paramsXXXX.h file.\n ----------------------*/\n/** the pick up position of the array.\n#define POS1 122 \n*/\n\n/** the parameter of shift left as four 32-bit registers.\n#define SL1 18\n */\n\n/** the parameter of shift left as one 128-bit register. \n * The 128-bit integer is shifted by (SL2 * 8) bits. \n#define SL2 1 \n*/\n\n/** the parameter of shift right as four 32-bit registers.\n#define SR1 11\n*/\n\n/** the parameter of shift right as one 128-bit register. \n * The 128-bit integer is shifted by (SL2 * 8) bits. \n#define SR2 1 \n*/\n\n/** A bitmask, used in the recursion. These parameters are introduced\n * to break symmetry of SIMD.\n#define MSK1 0xdfffffefU\n#define MSK2 0xddfecb7fU\n#define MSK3 0xbffaffffU\n#define MSK4 0xbffffff6U \n*/\n\n/** These definitions are part of a 128-bit period certification vector.\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0xc98e126aU\n*/\n\n#if MEXP == 607\n #include \"test/SFMT-params607.h\"\n#elif MEXP == 1279\n #include \"test/SFMT-params1279.h\"\n#elif MEXP == 2281\n #include \"test/SFMT-params2281.h\"\n#elif MEXP == 4253\n #include \"test/SFMT-params4253.h\"\n#elif MEXP == 11213\n #include \"test/SFMT-params11213.h\"\n#elif MEXP == 19937\n #include \"test/SFMT-params19937.h\"\n#elif MEXP == 44497\n #include \"test/SFMT-params44497.h\"\n#elif MEXP == 86243\n #include \"test/SFMT-params86243.h\"\n#elif MEXP == 132049\n #include \"test/SFMT-params132049.h\"\n#elif MEXP == 216091\n #include \"test/SFMT-params216091.h\"\n#else\n#ifdef __GNUC__\n #error \"MEXP is not valid.\"\n #undef MEXP\n#else\n #undef MEXP\n#endif\n\n#endif\n\n#endif /* SFMT_PARAMS_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params11213.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS11213_H\n#define SFMT_PARAMS11213_H\n\n#define POS1\t68\n#define SL1\t14\n#define SL2\t3\n#define SR1\t7\n#define SR2\t3\n#define MSK1\t0xeffff7fbU\n#define MSK2\t0xffffffefU\n#define MSK3\t0xdfdfbfffU\n#define MSK4\t0x7fffdbfdU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0xe8148000U\n#define PARITY4\t0xd0c7afa3U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10}\n #define ALTI_SL2_PERM64\t{3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2}\n #define ALTI_SR2_PERM\t{5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12}\n #define ALTI_SR2_PERM64\t{13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-11213:68-14-3-7-3:effff7fb-ffffffef-dfdfbfff-7fffdbfd\"\n\n#endif /* SFMT_PARAMS11213_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params1279.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS1279_H\n#define SFMT_PARAMS1279_H\n\n#define POS1\t7\n#define SL1\t14\n#define SL2\t3\n#define SR1\t5\n#define SR2\t1\n#define MSK1\t0xf7fefffdU\n#define MSK2\t0x7fefcfffU\n#define MSK3\t0xaff3ef3fU\n#define MSK4\t0xb5ffff7fU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0x20000000U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10}\n #define ALTI_SL2_PERM64\t{3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-1279:7-14-3-5-1:f7fefffd-7fefcfff-aff3ef3f-b5ffff7f\"\n\n#endif /* SFMT_PARAMS1279_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params132049.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS132049_H\n#define SFMT_PARAMS132049_H\n\n#define POS1\t110\n#define SL1\t19\n#define SL2\t1\n#define SR1\t21\n#define SR2\t1\n#define MSK1\t0xffffbb5fU\n#define MSK2\t0xfb6ebf95U\n#define MSK3\t0xfffefffaU\n#define MSK4\t0xcff77fffU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0xcb520000U\n#define PARITY4\t0xc7e91c7dU\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8}\n #define ALTI_SL2_PERM64\t{1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-132049:110-19-1-21-1:ffffbb5f-fb6ebf95-fffefffa-cff77fff\"\n\n#endif /* SFMT_PARAMS132049_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params19937.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS19937_H\n#define SFMT_PARAMS19937_H\n\n#define POS1\t122\n#define SL1\t18\n#define SL2\t1\n#define SR1\t11\n#define SR2\t1\n#define MSK1\t0xdfffffefU\n#define MSK2\t0xddfecb7fU\n#define MSK3\t0xbffaffffU\n#define MSK4\t0xbffffff6U\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0x13c9e684U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8}\n #define ALTI_SL2_PERM64\t{1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-19937:122-18-1-11-1:dfffffef-ddfecb7f-bffaffff-bffffff6\"\n\n#endif /* SFMT_PARAMS19937_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params216091.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS216091_H\n#define SFMT_PARAMS216091_H\n\n#define POS1\t627\n#define SL1\t11\n#define SL2\t3\n#define SR1\t10\n#define SR2\t1\n#define MSK1\t0xbff7bff7U\n#define MSK2\t0xbfffffffU\n#define MSK3\t0xbffffa7fU\n#define MSK4\t0xffddfbfbU\n#define PARITY1\t0xf8000001U\n#define PARITY2\t0x89e80709U\n#define PARITY3\t0x3bd2b64bU\n#define PARITY4\t0x0c64b1e4U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10}\n #define ALTI_SL2_PERM64\t{3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-216091:627-11-3-10-1:bff7bff7-bfffffff-bffffa7f-ffddfbfb\"\n\n#endif /* SFMT_PARAMS216091_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params2281.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS2281_H\n#define SFMT_PARAMS2281_H\n\n#define POS1\t12\n#define SL1\t19\n#define SL2\t1\n#define SR1\t5\n#define SR2\t1\n#define MSK1\t0xbff7ffbfU\n#define MSK2\t0xfdfffffeU\n#define MSK3\t0xf7ffef7fU\n#define MSK4\t0xf2f7cbbfU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0x41dfa600U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8}\n #define ALTI_SL2_PERM64\t{1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-2281:12-19-1-5-1:bff7ffbf-fdfffffe-f7ffef7f-f2f7cbbf\"\n\n#endif /* SFMT_PARAMS2281_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params4253.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS4253_H\n#define SFMT_PARAMS4253_H\n\n#define POS1\t17\n#define SL1\t20\n#define SL2\t1\n#define SR1\t7\n#define SR2\t1\n#define MSK1\t0x9f7bffffU\n#define MSK2\t0x9fffff5fU\n#define MSK3\t0x3efffffbU\n#define MSK4\t0xfffff7bbU\n#define PARITY1\t0xa8000001U\n#define PARITY2\t0xaf5390a3U\n#define PARITY3\t0xb740b3f8U\n#define PARITY4\t0x6c11486dU\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{1,2,3,23,5,6,7,0,9,10,11,4,13,14,15,8}\n #define ALTI_SL2_PERM64\t{1,2,3,4,5,6,7,31,9,10,11,12,13,14,15,0}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-4253:17-20-1-7-1:9f7bffff-9fffff5f-3efffffb-fffff7bb\"\n\n#endif /* SFMT_PARAMS4253_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params44497.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS44497_H\n#define SFMT_PARAMS44497_H\n\n#define POS1\t330\n#define SL1\t5\n#define SL2\t3\n#define SR1\t9\n#define SR2\t3\n#define MSK1\t0xeffffffbU\n#define MSK2\t0xdfbebfffU\n#define MSK3\t0xbfbf7befU\n#define MSK4\t0x9ffd7bffU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0xa3ac4000U\n#define PARITY4\t0xecc1327aU\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10}\n #define ALTI_SL2_PERM64\t{3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2}\n #define ALTI_SR2_PERM\t{5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12}\n #define ALTI_SR2_PERM64\t{13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-44497:330-5-3-9-3:effffffb-dfbebfff-bfbf7bef-9ffd7bff\"\n\n#endif /* SFMT_PARAMS44497_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params607.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS607_H\n#define SFMT_PARAMS607_H\n\n#define POS1\t2\n#define SL1\t15\n#define SL2\t3\n#define SR1\t13\n#define SR2\t3\n#define MSK1\t0xfdff37ffU\n#define MSK2\t0xef7f3f7dU\n#define MSK3\t0xff777b7dU\n#define MSK4\t0x7ff7fb2fU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0x5986f054U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{3,21,21,21,7,0,1,2,11,4,5,6,15,8,9,10}\n #define ALTI_SL2_PERM64\t{3,4,5,6,7,29,29,29,11,12,13,14,15,0,1,2}\n #define ALTI_SR2_PERM\t{5,6,7,0,9,10,11,4,13,14,15,8,19,19,19,12}\n #define ALTI_SR2_PERM64\t{13,14,15,0,1,2,3,4,19,19,19,8,9,10,11,12}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-607:2-15-3-13-3:fdff37ff-ef7f3f7d-ff777b7d-7ff7fb2f\"\n\n#endif /* SFMT_PARAMS607_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-params86243.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#ifndef SFMT_PARAMS86243_H\n#define SFMT_PARAMS86243_H\n\n#define POS1\t366\n#define SL1\t6\n#define SL2\t7\n#define SR1\t19\n#define SR2\t1\n#define MSK1\t0xfdbffbffU\n#define MSK2\t0xbff7ff3fU\n#define MSK3\t0xfd77efffU\n#define MSK4\t0xbf9ff3ffU\n#define PARITY1\t0x00000001U\n#define PARITY2\t0x00000000U\n#define PARITY3\t0x00000000U\n#define PARITY4\t0xe9528d85U\n\n\n/* PARAMETERS FOR ALTIVEC */\n#if defined(__APPLE__)\t/* For OSX */\n #define ALTI_SL1\t(vector unsigned int)(SL1, SL1, SL1, SL1)\n #define ALTI_SR1\t(vector unsigned int)(SR1, SR1, SR1, SR1)\n #define ALTI_MSK\t(vector unsigned int)(MSK1, MSK2, MSK3, MSK4)\n #define ALTI_MSK64 \\\n\t(vector unsigned int)(MSK2, MSK1, MSK4, MSK3)\n #define ALTI_SL2_PERM \\\n\t(vector unsigned char)(25,25,25,25,3,25,25,25,7,0,1,2,11,4,5,6)\n #define ALTI_SL2_PERM64 \\\n\t(vector unsigned char)(7,25,25,25,25,25,25,25,15,0,1,2,3,4,5,6)\n #define ALTI_SR2_PERM \\\n\t(vector unsigned char)(7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14)\n #define ALTI_SR2_PERM64 \\\n\t(vector unsigned char)(15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14)\n#else\t/* For OTHER OSs(Linux?) */\n #define ALTI_SL1\t{SL1, SL1, SL1, SL1}\n #define ALTI_SR1\t{SR1, SR1, SR1, SR1}\n #define ALTI_MSK\t{MSK1, MSK2, MSK3, MSK4}\n #define ALTI_MSK64\t{MSK2, MSK1, MSK4, MSK3}\n #define ALTI_SL2_PERM\t{25,25,25,25,3,25,25,25,7,0,1,2,11,4,5,6}\n #define ALTI_SL2_PERM64\t{7,25,25,25,25,25,25,25,15,0,1,2,3,4,5,6}\n #define ALTI_SR2_PERM\t{7,0,1,2,11,4,5,6,15,8,9,10,17,12,13,14}\n #define ALTI_SR2_PERM64\t{15,0,1,2,3,4,5,6,17,8,9,10,11,12,13,14}\n#endif\t/* For OSX */\n#define IDSTR\t\"SFMT-86243:366-6-7-19-1:fdbffbff-bff7ff3f-fd77efff-bf9ff3ff\"\n\n#endif /* SFMT_PARAMS86243_H */\n" }, { "path": "deps/jemalloc/test/include/test/SFMT-sse2.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n/**\n * @file SFMT-sse2.h\n * @brief SIMD oriented Fast Mersenne Twister(SFMT) for Intel SSE2\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * @note We assume LITTLE ENDIAN in this file\n *\n * Copyright (C) 2006, 2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * The new BSD License is applied to this software, see LICENSE.txt\n */\n\n#ifndef SFMT_SSE2_H\n#define SFMT_SSE2_H\n\n/**\n * This function represents the recursion formula.\n * @param a a 128-bit part of the interal state array\n * @param b a 128-bit part of the interal state array\n * @param c a 128-bit part of the interal state array\n * @param d a 128-bit part of the interal state array\n * @param mask 128-bit mask\n * @return output\n */\nJEMALLOC_ALWAYS_INLINE __m128i mm_recursion(__m128i *a, __m128i *b,\n\t\t\t\t __m128i c, __m128i d, __m128i mask) {\n __m128i v, x, y, z;\n\n x = _mm_load_si128(a);\n y = _mm_srli_epi32(*b, SR1);\n z = _mm_srli_si128(c, SR2);\n v = _mm_slli_epi32(d, SL1);\n z = _mm_xor_si128(z, x);\n z = _mm_xor_si128(z, v);\n x = _mm_slli_si128(x, SL2);\n y = _mm_and_si128(y, mask);\n z = _mm_xor_si128(z, x);\n z = _mm_xor_si128(z, y);\n return z;\n}\n\n/**\n * This function fills the internal state array with pseudorandom\n * integers.\n */\nstatic inline void gen_rand_all(sfmt_t *ctx) {\n int i;\n __m128i r, r1, r2, mask;\n mask = _mm_set_epi32(MSK4, MSK3, MSK2, MSK1);\n\n r1 = _mm_load_si128(&ctx->sfmt[N - 2].si);\n r2 = _mm_load_si128(&ctx->sfmt[N - 1].si);\n for (i = 0; i < N - POS1; i++) {\n\tr = mm_recursion(&ctx->sfmt[i].si, &ctx->sfmt[i + POS1].si, r1, r2,\n\t mask);\n\t_mm_store_si128(&ctx->sfmt[i].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n for (; i < N; i++) {\n\tr = mm_recursion(&ctx->sfmt[i].si, &ctx->sfmt[i + POS1 - N].si, r1, r2,\n\t mask);\n\t_mm_store_si128(&ctx->sfmt[i].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n}\n\n/**\n * This function fills the user-specified array with pseudorandom\n * integers.\n *\n * @param array an 128-bit array to be filled by pseudorandom numbers.\n * @param size number of 128-bit pesudorandom numbers to be generated.\n */\nstatic inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {\n int i, j;\n __m128i r, r1, r2, mask;\n mask = _mm_set_epi32(MSK4, MSK3, MSK2, MSK1);\n\n r1 = _mm_load_si128(&ctx->sfmt[N - 2].si);\n r2 = _mm_load_si128(&ctx->sfmt[N - 1].si);\n for (i = 0; i < N - POS1; i++) {\n\tr = mm_recursion(&ctx->sfmt[i].si, &ctx->sfmt[i + POS1].si, r1, r2,\n\t mask);\n\t_mm_store_si128(&array[i].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n for (; i < N; i++) {\n\tr = mm_recursion(&ctx->sfmt[i].si, &array[i + POS1 - N].si, r1, r2,\n\t mask);\n\t_mm_store_si128(&array[i].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n /* main loop */\n for (; i < size - N; i++) {\n\tr = mm_recursion(&array[i - N].si, &array[i + POS1 - N].si, r1, r2,\n\t\t\t mask);\n\t_mm_store_si128(&array[i].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n for (j = 0; j < 2 * N - size; j++) {\n\tr = _mm_load_si128(&array[j + size - N].si);\n\t_mm_store_si128(&ctx->sfmt[j].si, r);\n }\n for (; i < size; i++) {\n\tr = mm_recursion(&array[i - N].si, &array[i + POS1 - N].si, r1, r2,\n\t\t\t mask);\n\t_mm_store_si128(&array[i].si, r);\n\t_mm_store_si128(&ctx->sfmt[j++].si, r);\n\tr1 = r2;\n\tr2 = r;\n }\n}\n\n#endif\n" }, { "path": "deps/jemalloc/test/include/test/SFMT.h", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n/** \n * @file SFMT.h \n *\n * @brief SIMD oriented Fast Mersenne Twister(SFMT) pseudorandom\n * number generator\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * Copyright (C) 2006, 2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * The new BSD License is applied to this software.\n * see LICENSE.txt\n *\n * @note We assume that your system has inttypes.h. If your system\n * doesn't have inttypes.h, you have to typedef uint32_t and uint64_t,\n * and you have to define PRIu64 and PRIx64 in this file as follows:\n * @verbatim\n typedef unsigned int uint32_t\n typedef unsigned long long uint64_t \n #define PRIu64 \"llu\"\n #define PRIx64 \"llx\"\n@endverbatim\n * uint32_t must be exactly 32-bit unsigned integer type (no more, no\n * less), and uint64_t must be exactly 64-bit unsigned integer type.\n * PRIu64 and PRIx64 are used for printf function to print 64-bit\n * unsigned int and 64-bit unsigned int in hexadecimal format.\n */\n\n#ifndef SFMT_H\n#define SFMT_H\n\ntypedef struct sfmt_s sfmt_t;\n\nuint32_t gen_rand32(sfmt_t *ctx);\nuint32_t gen_rand32_range(sfmt_t *ctx, uint32_t limit);\nuint64_t gen_rand64(sfmt_t *ctx);\nuint64_t gen_rand64_range(sfmt_t *ctx, uint64_t limit);\nvoid fill_array32(sfmt_t *ctx, uint32_t *array, int size);\nvoid fill_array64(sfmt_t *ctx, uint64_t *array, int size);\nsfmt_t *init_gen_rand(uint32_t seed);\nsfmt_t *init_by_array(uint32_t *init_key, int key_length);\nvoid fini_gen_rand(sfmt_t *ctx);\nconst char *get_idstring(void);\nint get_min_array_size32(void);\nint get_min_array_size64(void);\n\n/* These real versions are due to Isaku Wada */\n/** generates a random number on [0,1]-real-interval */\nstatic inline double to_real1(uint32_t v) {\n return v * (1.0/4294967295.0); \n /* divided by 2^32-1 */ \n}\n\n/** generates a random number on [0,1]-real-interval */\nstatic inline double genrand_real1(sfmt_t *ctx) {\n return to_real1(gen_rand32(ctx));\n}\n\n/** generates a random number on [0,1)-real-interval */\nstatic inline double to_real2(uint32_t v) {\n return v * (1.0/4294967296.0); \n /* divided by 2^32 */\n}\n\n/** generates a random number on [0,1)-real-interval */\nstatic inline double genrand_real2(sfmt_t *ctx) {\n return to_real2(gen_rand32(ctx));\n}\n\n/** generates a random number on (0,1)-real-interval */\nstatic inline double to_real3(uint32_t v) {\n return (((double)v) + 0.5)*(1.0/4294967296.0); \n /* divided by 2^32 */\n}\n\n/** generates a random number on (0,1)-real-interval */\nstatic inline double genrand_real3(sfmt_t *ctx) {\n return to_real3(gen_rand32(ctx));\n}\n/** These real versions are due to Isaku Wada */\n\n/** generates a random number on [0,1) with 53-bit resolution*/\nstatic inline double to_res53(uint64_t v) {\n return v * (1.0/18446744073709551616.0L);\n}\n\n/** generates a random number on [0,1) with 53-bit resolution from two\n * 32 bit integers */\nstatic inline double to_res53_mix(uint32_t x, uint32_t y) {\n return to_res53(x | ((uint64_t)y << 32));\n}\n\n/** generates a random number on [0,1) with 53-bit resolution\n */\nstatic inline double genrand_res53(sfmt_t *ctx) {\n return to_res53(gen_rand64(ctx));\n}\n\n/** generates a random number on [0,1) with 53-bit resolution\n using 32bit integer.\n */\nstatic inline double genrand_res53_mix(sfmt_t *ctx) {\n uint32_t x, y;\n\n x = gen_rand32(ctx);\n y = gen_rand32(ctx);\n return to_res53_mix(x, y);\n}\n#endif\n" }, { "path": "deps/jemalloc/test/include/test/arena_util.h", "content": "static inline unsigned\ndo_arena_create(ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms) {\n\tunsigned arena_ind;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\n\texpect_d_eq(mallctlnametomib(\"arena.0.dirty_decay_ms\", mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL,\n\t (void *)&dirty_decay_ms, sizeof(dirty_decay_ms)), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\n\texpect_d_eq(mallctlnametomib(\"arena.0.muzzy_decay_ms\", mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL,\n\t (void *)&muzzy_decay_ms, sizeof(muzzy_decay_ms)), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\n\treturn arena_ind;\n}\n\nstatic inline void\ndo_arena_destroy(unsigned arena_ind) {\n\t/* \n\t * For convenience, flush tcache in case there are cached items.\n\t * However not assert success since the tcache may be disabled.\n\t */\n\tmallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0);\n\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.destroy\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nstatic inline void\ndo_epoch(void) {\n\tuint64_t epoch = 1;\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n}\n\nstatic inline void\ndo_purge(unsigned arena_ind) {\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.purge\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nstatic inline void\ndo_decay(unsigned arena_ind) {\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.decay\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nstatic inline uint64_t\nget_arena_npurge_impl(const char *mibname, unsigned arena_ind) {\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(mibname, mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[2] = (size_t)arena_ind;\n\tuint64_t npurge = 0;\n\tsize_t sz = sizeof(npurge);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&npurge, &sz, NULL, 0),\n\t config_stats ? 0 : ENOENT, \"Unexpected mallctlbymib() failure\");\n\treturn npurge;\n}\n\nstatic inline uint64_t\nget_arena_dirty_npurge(unsigned arena_ind) {\n\tdo_epoch();\n\treturn get_arena_npurge_impl(\"stats.arenas.0.dirty_npurge\", arena_ind);\n}\n\nstatic inline uint64_t\nget_arena_dirty_purged(unsigned arena_ind) {\n\tdo_epoch();\n\treturn get_arena_npurge_impl(\"stats.arenas.0.dirty_purged\", arena_ind);\n}\n\nstatic inline uint64_t\nget_arena_muzzy_npurge(unsigned arena_ind) {\n\tdo_epoch();\n\treturn get_arena_npurge_impl(\"stats.arenas.0.muzzy_npurge\", arena_ind);\n}\n\nstatic inline uint64_t\nget_arena_npurge(unsigned arena_ind) {\n\tdo_epoch();\n\treturn get_arena_npurge_impl(\"stats.arenas.0.dirty_npurge\", arena_ind) +\n\t get_arena_npurge_impl(\"stats.arenas.0.muzzy_npurge\", arena_ind);\n}\n\nstatic inline size_t\nget_arena_pdirty(unsigned arena_ind) {\n\tdo_epoch();\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"stats.arenas.0.pdirty\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[2] = (size_t)arena_ind;\n\tsize_t pdirty;\n\tsize_t sz = sizeof(pdirty);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&pdirty, &sz, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\treturn pdirty;\n}\n\nstatic inline size_t\nget_arena_pmuzzy(unsigned arena_ind) {\n\tdo_epoch();\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"stats.arenas.0.pmuzzy\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[2] = (size_t)arena_ind;\n\tsize_t pmuzzy;\n\tsize_t sz = sizeof(pmuzzy);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&pmuzzy, &sz, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\treturn pmuzzy;\n}\n\nstatic inline void *\ndo_mallocx(size_t size, int flags) {\n\tvoid *p = mallocx(size, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\treturn p;\n}\n\nstatic inline void\ngenerate_dirty(unsigned arena_ind, size_t size) {\n\tint flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\tvoid *p = do_mallocx(size, flags);\n\tdallocx(p, flags);\n}\n\n" }, { "path": "deps/jemalloc/test/include/test/bench.h", "content": "static inline void\ntime_func(timedelta_t *timer, uint64_t nwarmup, uint64_t niter,\n void (*func)(void)) {\n\tuint64_t i;\n\n\tfor (i = 0; i < nwarmup; i++) {\n\t\tfunc();\n\t}\n\ttimer_start(timer);\n\tfor (i = 0; i < niter; i++) {\n\t\tfunc();\n\t}\n\ttimer_stop(timer);\n}\n\n#define FMT_NSECS_BUF_SIZE 100\n/* Print nanoseconds / iter into the buffer \"buf\". */\nstatic inline void\nfmt_nsecs(uint64_t usec, uint64_t iters, char *buf) {\n\tuint64_t nsec = usec * 1000;\n\t/* We'll display 3 digits after the decimal point. */\n\tuint64_t nsec1000 = nsec * 1000;\n\tuint64_t nsecs_per_iter1000 = nsec1000 / iters;\n\tuint64_t intpart = nsecs_per_iter1000 / 1000;\n\tuint64_t fracpart = nsecs_per_iter1000 % 1000;\n\tmalloc_snprintf(buf, FMT_NSECS_BUF_SIZE, \"%\"FMTu64\".%03\"FMTu64, intpart,\n\t fracpart);\n}\n\nstatic inline void\ncompare_funcs(uint64_t nwarmup, uint64_t niter, const char *name_a,\n void (*func_a), const char *name_b, void (*func_b)) {\n\ttimedelta_t timer_a, timer_b;\n\tchar ratio_buf[6];\n\tvoid *p;\n\n\tp = mallocx(1, 0);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected mallocx() failure\");\n\t\treturn;\n\t}\n\n\ttime_func(&timer_a, nwarmup, niter, func_a);\n\ttime_func(&timer_b, nwarmup, niter, func_b);\n\n\tuint64_t usec_a = timer_usec(&timer_a);\n\tchar buf_a[FMT_NSECS_BUF_SIZE];\n\tfmt_nsecs(usec_a, niter, buf_a);\n\n\tuint64_t usec_b = timer_usec(&timer_b);\n\tchar buf_b[FMT_NSECS_BUF_SIZE];\n\tfmt_nsecs(usec_b, niter, buf_b);\n\n\ttimer_ratio(&timer_a, &timer_b, ratio_buf, sizeof(ratio_buf));\n\tmalloc_printf(\"%\"FMTu64\" iterations, %s=%\"FMTu64\"us (%s ns/iter), \"\n\t \"%s=%\"FMTu64\"us (%s ns/iter), ratio=1:%s\\n\",\n\t niter, name_a, usec_a, buf_a, name_b, usec_b, buf_b, ratio_buf);\n\n\tdallocx(p, 0);\n}\n" }, { "path": "deps/jemalloc/test/include/test/bgthd.h", "content": "/*\n * Shared utility for checking if background_thread is enabled, which affects\n * the purging behavior and assumptions in some tests.\n */\n\nstatic inline bool\nis_background_thread_enabled(void) {\n\tbool enabled;\n\tsize_t sz = sizeof(bool);\n\tint ret = mallctl(\"background_thread\", (void *)&enabled, &sz, NULL,0);\n\tif (ret == ENOENT) {\n\t\treturn false;\n\t}\n\tassert_d_eq(ret, 0, \"Unexpected mallctl error\");\n\n\treturn enabled;\n}\n" }, { "path": "deps/jemalloc/test/include/test/btalloc.h", "content": "/* btalloc() provides a mechanism for allocating via permuted backtraces. */\nvoid\t*btalloc(size_t size, unsigned bits);\n\n#define btalloc_n_proto(n)\t\t\t\t\t\t\\\nvoid\t*btalloc_##n(size_t size, unsigned bits);\nbtalloc_n_proto(0)\nbtalloc_n_proto(1)\n\n#define btalloc_n_gen(n)\t\t\t\t\t\t\\\nvoid *\t\t\t\t\t\t\t\t\t\\\nbtalloc_##n(size_t size, unsigned bits) {\t\t\t\t\\\n\tvoid *p;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tif (bits == 0) {\t\t\t\t\t\t\\\n\t\tp = mallocx(size, 0);\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tswitch (bits & 0x1U) {\t\t\t\t\t\\\n\t\tcase 0:\t\t\t\t\t\t\t\\\n\t\t\tp = (btalloc_0(size, bits >> 1));\t\t\\\n\t\t\tbreak;\t\t\t\t\t\t\\\n\t\tcase 1:\t\t\t\t\t\t\t\\\n\t\t\tp = (btalloc_1(size, bits >> 1));\t\t\\\n\t\t\tbreak;\t\t\t\t\t\t\\\n\t\tdefault: not_reached();\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t/* Intentionally sabotage tail call optimization. */\t\t\\\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\t\t\\\n\treturn p;\t\t\t\t\t\t\t\\\n}\n" }, { "path": "deps/jemalloc/test/include/test/extent_hooks.h", "content": "/*\n * Boilerplate code used for testing extent hooks via interception and\n * passthrough.\n */\n\nstatic void\t*extent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr,\n size_t size, size_t alignment, bool *zero, bool *commit,\n unsigned arena_ind);\nstatic bool\textent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, bool committed, unsigned arena_ind);\nstatic void\textent_destroy_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, bool committed, unsigned arena_ind);\nstatic bool\textent_commit_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, size_t offset, size_t length, unsigned arena_ind);\nstatic bool\textent_decommit_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, size_t offset, size_t length, unsigned arena_ind);\nstatic bool\textent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, size_t offset, size_t length, unsigned arena_ind);\nstatic bool\textent_purge_forced_hook(extent_hooks_t *extent_hooks,\n void *addr, size_t size, size_t offset, size_t length, unsigned arena_ind);\nstatic bool\textent_split_hook(extent_hooks_t *extent_hooks, void *addr,\n size_t size, size_t size_a, size_t size_b, bool committed,\n unsigned arena_ind);\nstatic bool\textent_merge_hook(extent_hooks_t *extent_hooks, void *addr_a,\n size_t size_a, void *addr_b, size_t size_b, bool committed,\n unsigned arena_ind);\n\nstatic extent_hooks_t *default_hooks;\nstatic extent_hooks_t hooks = {\n\textent_alloc_hook,\n\textent_dalloc_hook,\n\textent_destroy_hook,\n\textent_commit_hook,\n\textent_decommit_hook,\n\textent_purge_lazy_hook,\n\textent_purge_forced_hook,\n\textent_split_hook,\n\textent_merge_hook\n};\n\n/* Control whether hook functions pass calls through to default hooks. */\nstatic bool try_alloc = true;\nstatic bool try_dalloc = true;\nstatic bool try_destroy = true;\nstatic bool try_commit = true;\nstatic bool try_decommit = true;\nstatic bool try_purge_lazy = true;\nstatic bool try_purge_forced = true;\nstatic bool try_split = true;\nstatic bool try_merge = true;\n\n/* Set to false prior to operations, then introspect after operations. */\nstatic bool called_alloc;\nstatic bool called_dalloc;\nstatic bool called_destroy;\nstatic bool called_commit;\nstatic bool called_decommit;\nstatic bool called_purge_lazy;\nstatic bool called_purge_forced;\nstatic bool called_split;\nstatic bool called_merge;\n\n/* Set to false prior to operations, then introspect after operations. */\nstatic bool did_alloc;\nstatic bool did_dalloc;\nstatic bool did_destroy;\nstatic bool did_commit;\nstatic bool did_decommit;\nstatic bool did_purge_lazy;\nstatic bool did_purge_forced;\nstatic bool did_split;\nstatic bool did_merge;\n\n#if 0\n# define TRACE_HOOK(fmt, ...) malloc_printf(fmt, __VA_ARGS__)\n#else\n# define TRACE_HOOK(fmt, ...)\n#endif\n\nstatic void *\nextent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, unsigned arena_ind) {\n\tvoid *ret;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, new_addr=%p, size=%zu, alignment=%zu, \"\n\t \"*zero=%s, *commit=%s, arena_ind=%u)\\n\", __func__, extent_hooks,\n\t new_addr, size, alignment, *zero ? \"true\" : \"false\", *commit ?\n\t \"true\" : \"false\", arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->alloc, extent_alloc_hook,\n\t \"Wrong hook function\");\n\tcalled_alloc = true;\n\tif (!try_alloc) {\n\t\treturn NULL;\n\t}\n\tret = default_hooks->alloc(default_hooks, new_addr, size, alignment,\n\t zero, commit, 0);\n\tdid_alloc = (ret != NULL);\n\treturn ret;\n}\n\nstatic bool\nextent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n bool committed, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, \"\n\t \"arena_ind=%u)\\n\", __func__, extent_hooks, addr, size, committed ?\n\t \"true\" : \"false\", arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->dalloc, extent_dalloc_hook,\n\t \"Wrong hook function\");\n\tcalled_dalloc = true;\n\tif (!try_dalloc) {\n\t\treturn true;\n\t}\n\terr = default_hooks->dalloc(default_hooks, addr, size, committed, 0);\n\tdid_dalloc = !err;\n\treturn err;\n}\n\nstatic void\nextent_destroy_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n bool committed, unsigned arena_ind) {\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, \"\n\t \"arena_ind=%u)\\n\", __func__, extent_hooks, addr, size, committed ?\n\t \"true\" : \"false\", arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->destroy, extent_destroy_hook,\n\t \"Wrong hook function\");\n\tcalled_destroy = true;\n\tif (!try_destroy) {\n\t\treturn;\n\t}\n\tdefault_hooks->destroy(default_hooks, addr, size, committed, 0);\n\tdid_destroy = true;\n}\n\nstatic bool\nextent_commit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, \"\n\t \"length=%zu, arena_ind=%u)\\n\", __func__, extent_hooks, addr, size,\n\t offset, length, arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->commit, extent_commit_hook,\n\t \"Wrong hook function\");\n\tcalled_commit = true;\n\tif (!try_commit) {\n\t\treturn true;\n\t}\n\terr = default_hooks->commit(default_hooks, addr, size, offset, length,\n\t 0);\n\tdid_commit = !err;\n\treturn err;\n}\n\nstatic bool\nextent_decommit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, \"\n\t \"length=%zu, arena_ind=%u)\\n\", __func__, extent_hooks, addr, size,\n\t offset, length, arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->decommit, extent_decommit_hook,\n\t \"Wrong hook function\");\n\tcalled_decommit = true;\n\tif (!try_decommit) {\n\t\treturn true;\n\t}\n\terr = default_hooks->decommit(default_hooks, addr, size, offset, length,\n\t 0);\n\tdid_decommit = !err;\n\treturn err;\n}\n\nstatic bool\nextent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, \"\n\t \"length=%zu arena_ind=%u)\\n\", __func__, extent_hooks, addr, size,\n\t offset, length, arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->purge_lazy, extent_purge_lazy_hook,\n\t \"Wrong hook function\");\n\tcalled_purge_lazy = true;\n\tif (!try_purge_lazy) {\n\t\treturn true;\n\t}\n\terr = default_hooks->purge_lazy == NULL ||\n\t default_hooks->purge_lazy(default_hooks, addr, size, offset, length,\n\t 0);\n\tdid_purge_lazy = !err;\n\treturn err;\n}\n\nstatic bool\nextent_purge_forced_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t offset, size_t length, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, \"\n\t \"length=%zu arena_ind=%u)\\n\", __func__, extent_hooks, addr, size,\n\t offset, length, arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->purge_forced, extent_purge_forced_hook,\n\t \"Wrong hook function\");\n\tcalled_purge_forced = true;\n\tif (!try_purge_forced) {\n\t\treturn true;\n\t}\n\terr = default_hooks->purge_forced == NULL ||\n\t default_hooks->purge_forced(default_hooks, addr, size, offset,\n\t length, 0);\n\tdid_purge_forced = !err;\n\treturn err;\n}\n\nstatic bool\nextent_split_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t size_a, size_t size_b, bool committed, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, size_a=%zu, \"\n\t \"size_b=%zu, committed=%s, arena_ind=%u)\\n\", __func__, extent_hooks,\n\t addr, size, size_a, size_b, committed ? \"true\" : \"false\",\n\t arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->split, extent_split_hook,\n\t \"Wrong hook function\");\n\tcalled_split = true;\n\tif (!try_split) {\n\t\treturn true;\n\t}\n\terr = (default_hooks->split == NULL ||\n\t default_hooks->split(default_hooks, addr, size, size_a, size_b,\n\t committed, 0));\n\tdid_split = !err;\n\treturn err;\n}\n\nstatic bool\nextent_merge_hook(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a,\n void *addr_b, size_t size_b, bool committed, unsigned arena_ind) {\n\tbool err;\n\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr_a=%p, size_a=%zu, addr_b=%p \"\n\t \"size_b=%zu, committed=%s, arena_ind=%u)\\n\", __func__, extent_hooks,\n\t addr_a, size_a, addr_b, size_b, committed ? \"true\" : \"false\",\n\t arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->merge, extent_merge_hook,\n\t \"Wrong hook function\");\n\texpect_ptr_eq((void *)((uintptr_t)addr_a + size_a), addr_b,\n\t \"Extents not mergeable\");\n\tcalled_merge = true;\n\tif (!try_merge) {\n\t\treturn true;\n\t}\n\terr = (default_hooks->merge == NULL ||\n\t default_hooks->merge(default_hooks, addr_a, size_a, addr_b, size_b,\n\t committed, 0));\n\tdid_merge = !err;\n\treturn err;\n}\n\nstatic void\nextent_hooks_prep(void) {\n\tsize_t sz;\n\n\tsz = sizeof(default_hooks);\n\texpect_d_eq(mallctl(\"arena.0.extent_hooks\", (void *)&default_hooks, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl() error\");\n}\n" }, { "path": "deps/jemalloc/test/include/test/jemalloc_test.h.in", "content": "#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n#ifndef SIZE_T_MAX\n# define SIZE_T_MAX\tSIZE_MAX\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#ifdef _WIN32\n# include \"msvc_compat/strings.h\"\n#endif\n\n#ifdef _WIN32\n# include \n# include \"msvc_compat/windows_extra.h\"\n#else\n# include \n#endif\n\n#include \"test/jemalloc_test_defs.h\"\n\n#if defined(JEMALLOC_OSATOMIC)\n# include \n#endif\n\n#if defined(HAVE_ALTIVEC) && !defined(__APPLE__)\n# include \n#endif\n#ifdef HAVE_SSE2\n# include \n#endif\n\n/******************************************************************************/\n/*\n * For unit tests and analytics tests, expose all public and private interfaces.\n */\n#if defined(JEMALLOC_UNIT_TEST) || defined (JEMALLOC_ANALYZE_TEST)\n# define JEMALLOC_JET\n# define JEMALLOC_MANGLE\n# include \"jemalloc/internal/jemalloc_preamble.h\"\n# include \"jemalloc/internal/jemalloc_internal_includes.h\"\n\n/******************************************************************************/\n/*\n * For integration tests, expose the public jemalloc interfaces, but only\n * expose the minimum necessary internal utility code (to avoid re-implementing\n * essentially identical code within the test infrastructure).\n */\n#elif defined(JEMALLOC_INTEGRATION_TEST) || \\\n defined(JEMALLOC_INTEGRATION_CPP_TEST)\n# define JEMALLOC_MANGLE\n# include \"jemalloc/jemalloc@install_suffix@.h\"\n# include \"jemalloc/internal/jemalloc_internal_defs.h\"\n# include \"jemalloc/internal/jemalloc_internal_macros.h\"\n\nstatic const bool config_debug =\n#ifdef JEMALLOC_DEBUG\n true\n#else\n false\n#endif\n ;\n\n# define JEMALLOC_N(n) @private_namespace@##n\n# include \"jemalloc/internal/private_namespace.h\"\n# include \"jemalloc/internal/test_hooks.h\"\n\n/* Hermetic headers. */\n# include \"jemalloc/internal/assert.h\"\n# include \"jemalloc/internal/malloc_io.h\"\n# include \"jemalloc/internal/nstime.h\"\n# include \"jemalloc/internal/util.h\"\n\n/* Non-hermetic headers. */\n# include \"jemalloc/internal/qr.h\"\n# include \"jemalloc/internal/ql.h\"\n\n/******************************************************************************/\n/*\n * For stress tests, expose the public jemalloc interfaces with name mangling\n * so that they can be tested as e.g. malloc() and free(). Also expose the\n * public jemalloc interfaces with jet_ prefixes, so that stress tests can use\n * a separate allocator for their internal data structures.\n */\n#elif defined(JEMALLOC_STRESS_TEST)\n# include \"jemalloc/jemalloc@install_suffix@.h\"\n\n# include \"jemalloc/jemalloc_protos_jet.h\"\n\n# define JEMALLOC_JET\n# include \"jemalloc/internal/jemalloc_preamble.h\"\n# include \"jemalloc/internal/jemalloc_internal_includes.h\"\n# include \"jemalloc/internal/public_unnamespace.h\"\n# undef JEMALLOC_JET\n\n# include \"jemalloc/jemalloc_rename.h\"\n# define JEMALLOC_MANGLE\n# ifdef JEMALLOC_STRESS_TESTLIB\n# include \"jemalloc/jemalloc_mangle_jet.h\"\n# else\n# include \"jemalloc/jemalloc_mangle.h\"\n# endif\n\n/******************************************************************************/\n/*\n * This header does dangerous things, the effects of which only test code\n * should be subject to.\n */\n#else\n# error \"This header cannot be included outside a testing context\"\n#endif\n\n/******************************************************************************/\n/*\n * Common test utilities.\n */\n#include \"test/btalloc.h\"\n#include \"test/math.h\"\n#include \"test/mtx.h\"\n#include \"test/mq.h\"\n#include \"test/sleep.h\"\n#include \"test/test.h\"\n#include \"test/timer.h\"\n#include \"test/thd.h\"\n#include \"test/bgthd.h\"\n#define MEXP 19937\n#include \"test/SFMT.h\"\n\n#ifndef JEMALLOC_HAVE_MALLOC_SIZE\n#define TEST_MALLOC_SIZE malloc_usable_size\n#else\n#define TEST_MALLOC_SIZE malloc_size\n#endif\n/******************************************************************************/\n/*\n * Define always-enabled assertion macros, so that test assertions execute even\n * if assertions are disabled in the library code.\n */\n#undef assert\n#undef not_reached\n#undef not_implemented\n#undef expect_not_implemented\n\n#define assert(e) do {\t\t\t\t\t\t\t\\\n\tif (!(e)) {\t\t\t\t\t\t\t\\\n\t\tmalloc_printf(\t\t\t\t\t\t\\\n\t\t \": %s:%d: Failed assertion: \\\"%s\\\"\\n\",\t\\\n\t\t __FILE__, __LINE__, #e);\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define not_reached() do {\t\t\t\t\t\t\\\n\tmalloc_printf(\t\t\t\t\t\t\t\\\n\t \": %s:%d: Unreachable code reached\\n\",\t\t\\\n\t __FILE__, __LINE__);\t\t\t\t\t\\\n\tabort();\t\t\t\t\t\t\t\\\n} while (0)\n\n#define not_implemented() do {\t\t\t\t\t\t\\\n\tmalloc_printf(\": %s:%d: Not implemented\\n\",\t\t\\\n\t __FILE__, __LINE__);\t\t\t\t\t\\\n\tabort();\t\t\t\t\t\t\t\\\n} while (0)\n\n#define expect_not_implemented(e) do {\t\t\t\t\t\\\n\tif (!(e)) {\t\t\t\t\t\t\t\\\n\t\tnot_implemented();\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#ifdef __cplusplus\n}\n#endif\n" }, { "path": "deps/jemalloc/test/include/test/jemalloc_test_defs.h.in", "content": "#include \"jemalloc/internal/jemalloc_internal_defs.h\"\n#include \"jemalloc/internal/jemalloc_internal_decls.h\"\n\n/*\n * For use by SFMT. configure.ac doesn't actually define HAVE_SSE2 because its\n * dependencies are notoriously unportable in practice.\n */\n#undef HAVE_SSE2\n#undef HAVE_ALTIVEC\n" }, { "path": "deps/jemalloc/test/include/test/math.h", "content": "/*\n * Compute the natural log of Gamma(x), accurate to 10 decimal places.\n *\n * This implementation is based on:\n *\n * Pike, M.C., I.D. Hill (1966) Algorithm 291: Logarithm of Gamma function\n * [S14]. Communications of the ACM 9(9):684.\n */\nstatic inline double\nln_gamma(double x) {\n\tdouble f, z;\n\n\tassert(x > 0.0);\n\n\tif (x < 7.0) {\n\t\tf = 1.0;\n\t\tz = x;\n\t\twhile (z < 7.0) {\n\t\t\tf *= z;\n\t\t\tz += 1.0;\n\t\t}\n\t\tx = z;\n\t\tf = -log(f);\n\t} else {\n\t\tf = 0.0;\n\t}\n\n\tz = 1.0 / (x * x);\n\n\treturn f + (x-0.5) * log(x) - x + 0.918938533204673 +\n\t (((-0.000595238095238 * z + 0.000793650793651) * z -\n\t 0.002777777777778) * z + 0.083333333333333) / x;\n}\n\n/*\n * Compute the incomplete Gamma ratio for [0..x], where p is the shape\n * parameter, and ln_gamma_p is ln_gamma(p).\n *\n * This implementation is based on:\n *\n * Bhattacharjee, G.P. (1970) Algorithm AS 32: The incomplete Gamma integral.\n * Applied Statistics 19:285-287.\n */\nstatic inline double\ni_gamma(double x, double p, double ln_gamma_p) {\n\tdouble acu, factor, oflo, gin, term, rn, a, b, an, dif;\n\tdouble pn[6];\n\tunsigned i;\n\n\tassert(p > 0.0);\n\tassert(x >= 0.0);\n\n\tif (x == 0.0) {\n\t\treturn 0.0;\n\t}\n\n\tacu = 1.0e-10;\n\toflo = 1.0e30;\n\tgin = 0.0;\n\tfactor = exp(p * log(x) - x - ln_gamma_p);\n\n\tif (x <= 1.0 || x < p) {\n\t\t/* Calculation by series expansion. */\n\t\tgin = 1.0;\n\t\tterm = 1.0;\n\t\trn = p;\n\n\t\twhile (true) {\n\t\t\trn += 1.0;\n\t\t\tterm *= x / rn;\n\t\t\tgin += term;\n\t\t\tif (term <= acu) {\n\t\t\t\tgin *= factor / p;\n\t\t\t\treturn gin;\n\t\t\t}\n\t\t}\n\t} else {\n\t\t/* Calculation by continued fraction. */\n\t\ta = 1.0 - p;\n\t\tb = a + x + 1.0;\n\t\tterm = 0.0;\n\t\tpn[0] = 1.0;\n\t\tpn[1] = x;\n\t\tpn[2] = x + 1.0;\n\t\tpn[3] = x * b;\n\t\tgin = pn[2] / pn[3];\n\n\t\twhile (true) {\n\t\t\ta += 1.0;\n\t\t\tb += 2.0;\n\t\t\tterm += 1.0;\n\t\t\tan = a * term;\n\t\t\tfor (i = 0; i < 2; i++) {\n\t\t\t\tpn[i+4] = b * pn[i+2] - an * pn[i];\n\t\t\t}\n\t\t\tif (pn[5] != 0.0) {\n\t\t\t\trn = pn[4] / pn[5];\n\t\t\t\tdif = fabs(gin - rn);\n\t\t\t\tif (dif <= acu && dif <= acu * rn) {\n\t\t\t\t\tgin = 1.0 - factor * gin;\n\t\t\t\t\treturn gin;\n\t\t\t\t}\n\t\t\t\tgin = rn;\n\t\t\t}\n\t\t\tfor (i = 0; i < 4; i++) {\n\t\t\t\tpn[i] = pn[i+2];\n\t\t\t}\n\n\t\t\tif (fabs(pn[4]) >= oflo) {\n\t\t\t\tfor (i = 0; i < 4; i++) {\n\t\t\t\t\tpn[i] /= oflo;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/*\n * Given a value p in [0..1] of the lower tail area of the normal distribution,\n * compute the limit on the definite integral from [-inf..z] that satisfies p,\n * accurate to 16 decimal places.\n *\n * This implementation is based on:\n *\n * Wichura, M.J. (1988) Algorithm AS 241: The percentage points of the normal\n * distribution. Applied Statistics 37(3):477-484.\n */\nstatic inline double\npt_norm(double p) {\n\tdouble q, r, ret;\n\n\tassert(p > 0.0 && p < 1.0);\n\n\tq = p - 0.5;\n\tif (fabs(q) <= 0.425) {\n\t\t/* p close to 1/2. */\n\t\tr = 0.180625 - q * q;\n\t\treturn q * (((((((2.5090809287301226727e3 * r +\n\t\t 3.3430575583588128105e4) * r + 6.7265770927008700853e4) * r\n\t\t + 4.5921953931549871457e4) * r + 1.3731693765509461125e4) *\n\t\t r + 1.9715909503065514427e3) * r + 1.3314166789178437745e2)\n\t\t * r + 3.3871328727963666080e0) /\n\t\t (((((((5.2264952788528545610e3 * r +\n\t\t 2.8729085735721942674e4) * r + 3.9307895800092710610e4) * r\n\t\t + 2.1213794301586595867e4) * r + 5.3941960214247511077e3) *\n\t\t r + 6.8718700749205790830e2) * r + 4.2313330701600911252e1)\n\t\t * r + 1.0);\n\t} else {\n\t\tif (q < 0.0) {\n\t\t\tr = p;\n\t\t} else {\n\t\t\tr = 1.0 - p;\n\t\t}\n\t\tassert(r > 0.0);\n\n\t\tr = sqrt(-log(r));\n\t\tif (r <= 5.0) {\n\t\t\t/* p neither close to 1/2 nor 0 or 1. */\n\t\t\tr -= 1.6;\n\t\t\tret = ((((((((7.74545014278341407640e-4 * r +\n\t\t\t 2.27238449892691845833e-2) * r +\n\t\t\t 2.41780725177450611770e-1) * r +\n\t\t\t 1.27045825245236838258e0) * r +\n\t\t\t 3.64784832476320460504e0) * r +\n\t\t\t 5.76949722146069140550e0) * r +\n\t\t\t 4.63033784615654529590e0) * r +\n\t\t\t 1.42343711074968357734e0) /\n\t\t\t (((((((1.05075007164441684324e-9 * r +\n\t\t\t 5.47593808499534494600e-4) * r +\n\t\t\t 1.51986665636164571966e-2)\n\t\t\t * r + 1.48103976427480074590e-1) * r +\n\t\t\t 6.89767334985100004550e-1) * r +\n\t\t\t 1.67638483018380384940e0) * r +\n\t\t\t 2.05319162663775882187e0) * r + 1.0));\n\t\t} else {\n\t\t\t/* p near 0 or 1. */\n\t\t\tr -= 5.0;\n\t\t\tret = ((((((((2.01033439929228813265e-7 * r +\n\t\t\t 2.71155556874348757815e-5) * r +\n\t\t\t 1.24266094738807843860e-3) * r +\n\t\t\t 2.65321895265761230930e-2) * r +\n\t\t\t 2.96560571828504891230e-1) * r +\n\t\t\t 1.78482653991729133580e0) * r +\n\t\t\t 5.46378491116411436990e0) * r +\n\t\t\t 6.65790464350110377720e0) /\n\t\t\t (((((((2.04426310338993978564e-15 * r +\n\t\t\t 1.42151175831644588870e-7) * r +\n\t\t\t 1.84631831751005468180e-5) * r +\n\t\t\t 7.86869131145613259100e-4) * r +\n\t\t\t 1.48753612908506148525e-2) * r +\n\t\t\t 1.36929880922735805310e-1) * r +\n\t\t\t 5.99832206555887937690e-1)\n\t\t\t * r + 1.0));\n\t\t}\n\t\tif (q < 0.0) {\n\t\t\tret = -ret;\n\t\t}\n\t\treturn ret;\n\t}\n}\n\n/*\n * Given a value p in [0..1] of the lower tail area of the Chi^2 distribution\n * with df degrees of freedom, where ln_gamma_df_2 is ln_gamma(df/2.0), compute\n * the upper limit on the definite integral from [0..z] that satisfies p,\n * accurate to 12 decimal places.\n *\n * This implementation is based on:\n *\n * Best, D.J., D.E. Roberts (1975) Algorithm AS 91: The percentage points of\n * the Chi^2 distribution. Applied Statistics 24(3):385-388.\n *\n * Shea, B.L. (1991) Algorithm AS R85: A remark on AS 91: The percentage\n * points of the Chi^2 distribution. Applied Statistics 40(1):233-235.\n */\nstatic inline double\npt_chi2(double p, double df, double ln_gamma_df_2) {\n\tdouble e, aa, xx, c, ch, a, q, p1, p2, t, x, b, s1, s2, s3, s4, s5, s6;\n\tunsigned i;\n\n\tassert(p >= 0.0 && p < 1.0);\n\tassert(df > 0.0);\n\n\te = 5.0e-7;\n\taa = 0.6931471805;\n\n\txx = 0.5 * df;\n\tc = xx - 1.0;\n\n\tif (df < -1.24 * log(p)) {\n\t\t/* Starting approximation for small Chi^2. */\n\t\tch = pow(p * xx * exp(ln_gamma_df_2 + xx * aa), 1.0 / xx);\n\t\tif (ch - e < 0.0) {\n\t\t\treturn ch;\n\t\t}\n\t} else {\n\t\tif (df > 0.32) {\n\t\t\tx = pt_norm(p);\n\t\t\t/*\n\t\t\t * Starting approximation using Wilson and Hilferty\n\t\t\t * estimate.\n\t\t\t */\n\t\t\tp1 = 0.222222 / df;\n\t\t\tch = df * pow(x * sqrt(p1) + 1.0 - p1, 3.0);\n\t\t\t/* Starting approximation for p tending to 1. */\n\t\t\tif (ch > 2.2 * df + 6.0) {\n\t\t\t\tch = -2.0 * (log(1.0 - p) - c * log(0.5 * ch) +\n\t\t\t\t ln_gamma_df_2);\n\t\t\t}\n\t\t} else {\n\t\t\tch = 0.4;\n\t\t\ta = log(1.0 - p);\n\t\t\twhile (true) {\n\t\t\t\tq = ch;\n\t\t\t\tp1 = 1.0 + ch * (4.67 + ch);\n\t\t\t\tp2 = ch * (6.73 + ch * (6.66 + ch));\n\t\t\t\tt = -0.5 + (4.67 + 2.0 * ch) / p1 - (6.73 + ch\n\t\t\t\t * (13.32 + 3.0 * ch)) / p2;\n\t\t\t\tch -= (1.0 - exp(a + ln_gamma_df_2 + 0.5 * ch +\n\t\t\t\t c * aa) * p2 / p1) / t;\n\t\t\t\tif (fabs(q / ch - 1.0) - 0.01 <= 0.0) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tfor (i = 0; i < 20; i++) {\n\t\t/* Calculation of seven-term Taylor series. */\n\t\tq = ch;\n\t\tp1 = 0.5 * ch;\n\t\tif (p1 < 0.0) {\n\t\t\treturn -1.0;\n\t\t}\n\t\tp2 = p - i_gamma(p1, xx, ln_gamma_df_2);\n\t\tt = p2 * exp(xx * aa + ln_gamma_df_2 + p1 - c * log(ch));\n\t\tb = t / ch;\n\t\ta = 0.5 * t - b * c;\n\t\ts1 = (210.0 + a * (140.0 + a * (105.0 + a * (84.0 + a * (70.0 +\n\t\t 60.0 * a))))) / 420.0;\n\t\ts2 = (420.0 + a * (735.0 + a * (966.0 + a * (1141.0 + 1278.0 *\n\t\t a)))) / 2520.0;\n\t\ts3 = (210.0 + a * (462.0 + a * (707.0 + 932.0 * a))) / 2520.0;\n\t\ts4 = (252.0 + a * (672.0 + 1182.0 * a) + c * (294.0 + a *\n\t\t (889.0 + 1740.0 * a))) / 5040.0;\n\t\ts5 = (84.0 + 264.0 * a + c * (175.0 + 606.0 * a)) / 2520.0;\n\t\ts6 = (120.0 + c * (346.0 + 127.0 * c)) / 5040.0;\n\t\tch += t * (1.0 + 0.5 * t * s1 - b * c * (s1 - b * (s2 - b * (s3\n\t\t - b * (s4 - b * (s5 - b * s6))))));\n\t\tif (fabs(q / ch - 1.0) <= e) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn ch;\n}\n\n/*\n * Given a value p in [0..1] and Gamma distribution shape and scale parameters,\n * compute the upper limit on the definite integral from [0..z] that satisfies\n * p.\n */\nstatic inline double\npt_gamma(double p, double shape, double scale, double ln_gamma_shape) {\n\treturn pt_chi2(p, shape * 2.0, ln_gamma_shape) * 0.5 * scale;\n}\n" }, { "path": "deps/jemalloc/test/include/test/mq.h", "content": "#include \"test/sleep.h\"\n\n/*\n * Simple templated message queue implementation that relies on only mutexes for\n * synchronization (which reduces portability issues). Given the following\n * setup:\n *\n * typedef struct mq_msg_s mq_msg_t;\n * struct mq_msg_s {\n * mq_msg(mq_msg_t) link;\n * [message data]\n * };\n * mq_gen(, mq_, mq_t, mq_msg_t, link)\n *\n * The API is as follows:\n *\n * bool mq_init(mq_t *mq);\n * void mq_fini(mq_t *mq);\n * unsigned mq_count(mq_t *mq);\n * mq_msg_t *mq_tryget(mq_t *mq);\n * mq_msg_t *mq_get(mq_t *mq);\n * void mq_put(mq_t *mq, mq_msg_t *msg);\n *\n * The message queue linkage embedded in each message is to be treated as\n * externally opaque (no need to initialize or clean up externally). mq_fini()\n * does not perform any cleanup of messages, since it knows nothing of their\n * payloads.\n */\n#define mq_msg(a_mq_msg_type)\tql_elm(a_mq_msg_type)\n\n#define mq_gen(a_attr, a_prefix, a_mq_type, a_mq_msg_type, a_field)\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tmtx_t\t\t\tlock;\t\t\t\t\t\\\n\tql_head(a_mq_msg_type)\tmsgs;\t\t\t\t\t\\\n\tunsigned\t\tcount;\t\t\t\t\t\\\n} a_mq_type;\t\t\t\t\t\t\t\t\\\na_attr bool\t\t\t\t\t\t\t\t\\\na_prefix##init(a_mq_type *mq) {\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tif (mtx_init(&mq->lock)) {\t\t\t\t\t\\\n\t\treturn true;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tql_new(&mq->msgs);\t\t\t\t\t\t\\\n\tmq->count = 0;\t\t\t\t\t\t\t\\\n\treturn false;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##fini(a_mq_type *mq) {\t\t\t\t\t\t\\\n\tmtx_fini(&mq->lock);\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr unsigned\t\t\t\t\t\t\t\t\\\na_prefix##count(a_mq_type *mq) {\t\t\t\t\t\\\n\tunsigned count;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tmtx_lock(&mq->lock);\t\t\t\t\t\t\\\n\tcount = mq->count;\t\t\t\t\t\t\\\n\tmtx_unlock(&mq->lock);\t\t\t\t\t\t\\\n\treturn count;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_mq_msg_type *\t\t\t\t\t\t\t\\\na_prefix##tryget(a_mq_type *mq) {\t\t\t\t\t\\\n\ta_mq_msg_type *msg;\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tmtx_lock(&mq->lock);\t\t\t\t\t\t\\\n\tmsg = ql_first(&mq->msgs);\t\t\t\t\t\\\n\tif (msg != NULL) {\t\t\t\t\t\t\\\n\t\tql_head_remove(&mq->msgs, a_mq_msg_type, a_field);\t\\\n\t\tmq->count--;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\tmtx_unlock(&mq->lock);\t\t\t\t\t\t\\\n\treturn msg;\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr a_mq_msg_type *\t\t\t\t\t\t\t\\\na_prefix##get(a_mq_type *mq) {\t\t\t\t\t\t\\\n\ta_mq_msg_type *msg;\t\t\t\t\t\t\\\n\tunsigned ns;\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tmsg = a_prefix##tryget(mq);\t\t\t\t\t\\\n\tif (msg != NULL) {\t\t\t\t\t\t\\\n\t\treturn msg;\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tns = 1;\t\t\t\t\t\t\t\t\\\n\twhile (true) {\t\t\t\t\t\t\t\\\n\t\tsleep_ns(ns);\t\t\t\t\t\t\\\n\t\tmsg = a_prefix##tryget(mq);\t\t\t\t\\\n\t\tif (msg != NULL) {\t\t\t\t\t\\\n\t\t\treturn msg;\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t\tif (ns < 1000*1000*1000) {\t\t\t\t\\\n\t\t\t/* Double sleep time, up to max 1 second. */\t\\\n\t\t\tns <<= 1;\t\t\t\t\t\\\n\t\t\tif (ns > 1000*1000*1000) {\t\t\t\\\n\t\t\t\tns = 1000*1000*1000;\t\t\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n}\t\t\t\t\t\t\t\t\t\\\na_attr void\t\t\t\t\t\t\t\t\\\na_prefix##put(a_mq_type *mq, a_mq_msg_type *msg) {\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tmtx_lock(&mq->lock);\t\t\t\t\t\t\\\n\tql_elm_new(msg, a_field);\t\t\t\t\t\\\n\tql_tail_insert(&mq->msgs, msg, a_field);\t\t\t\\\n\tmq->count++;\t\t\t\t\t\t\t\\\n\tmtx_unlock(&mq->lock);\t\t\t\t\t\t\\\n}\n" }, { "path": "deps/jemalloc/test/include/test/mtx.h", "content": "/*\n * mtx is a slightly simplified version of malloc_mutex. This code duplication\n * is unfortunate, but there are allocator bootstrapping considerations that\n * would leak into the test infrastructure if malloc_mutex were used directly\n * in tests.\n */\n\ntypedef struct {\n#ifdef _WIN32\n\tCRITICAL_SECTION\tlock;\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n\tos_unfair_lock\t\tlock;\n#else\n\tpthread_mutex_t\t\tlock;\n#endif\n} mtx_t;\n\nbool\tmtx_init(mtx_t *mtx);\nvoid\tmtx_fini(mtx_t *mtx);\nvoid\tmtx_lock(mtx_t *mtx);\nvoid\tmtx_unlock(mtx_t *mtx);\n" }, { "path": "deps/jemalloc/test/include/test/nbits.h", "content": "#ifndef TEST_NBITS_H\n#define TEST_NBITS_H\n\n/* Interesting bitmap counts to test. */\n\n#define NBITS_TAB \\\n NB( 1) \\\n NB( 2) \\\n NB( 3) \\\n NB( 4) \\\n NB( 5) \\\n NB( 6) \\\n NB( 7) \\\n NB( 8) \\\n NB( 9) \\\n NB(10) \\\n NB(11) \\\n NB(12) \\\n NB(13) \\\n NB(14) \\\n NB(15) \\\n NB(16) \\\n NB(17) \\\n NB(18) \\\n NB(19) \\\n NB(20) \\\n NB(21) \\\n NB(22) \\\n NB(23) \\\n NB(24) \\\n NB(25) \\\n NB(26) \\\n NB(27) \\\n NB(28) \\\n NB(29) \\\n NB(30) \\\n NB(31) \\\n NB(32) \\\n \\\n NB(33) \\\n NB(34) \\\n NB(35) \\\n NB(36) \\\n NB(37) \\\n NB(38) \\\n NB(39) \\\n NB(40) \\\n NB(41) \\\n NB(42) \\\n NB(43) \\\n NB(44) \\\n NB(45) \\\n NB(46) \\\n NB(47) \\\n NB(48) \\\n NB(49) \\\n NB(50) \\\n NB(51) \\\n NB(52) \\\n NB(53) \\\n NB(54) \\\n NB(55) \\\n NB(56) \\\n NB(57) \\\n NB(58) \\\n NB(59) \\\n NB(60) \\\n NB(61) \\\n NB(62) \\\n NB(63) \\\n NB(64) \\\n NB(65) \\\n NB(66) \\\n NB(67) \\\n \\\n NB(126) \\\n NB(127) \\\n NB(128) \\\n NB(129) \\\n NB(130) \\\n \\\n NB(254) \\\n NB(255) \\\n NB(256) \\\n NB(257) \\\n NB(258) \\\n \\\n NB(510) \\\n NB(511) \\\n NB(512) \\\n NB(513) \\\n NB(514) \\\n \\\n NB(1022) \\\n NB(1023) \\\n NB(1024) \\\n NB(1025) \\\n NB(1026) \\\n \\\n NB(2048) \\\n \\\n NB(4094) \\\n NB(4095) \\\n NB(4096) \\\n NB(4097) \\\n NB(4098) \\\n \\\n NB(8192) \\\n NB(16384)\n\n#endif /* TEST_NBITS_H */\n" }, { "path": "deps/jemalloc/test/include/test/san.h", "content": "#if defined(JEMALLOC_UAF_DETECTION) || defined(JEMALLOC_DEBUG)\n# define TEST_SAN_UAF_ALIGN_ENABLE \"lg_san_uaf_align:12\"\n# define TEST_SAN_UAF_ALIGN_DISABLE \"lg_san_uaf_align:-1\"\n#else\n# define TEST_SAN_UAF_ALIGN_ENABLE \"\"\n# define TEST_SAN_UAF_ALIGN_DISABLE \"\"\n#endif\n\nstatic inline bool\nextent_is_guarded(tsdn_t *tsdn, void *ptr) {\n\tedata_t *edata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\treturn edata_guarded_get(edata);\n}\n\n" }, { "path": "deps/jemalloc/test/include/test/sleep.h", "content": "void sleep_ns(unsigned ns);\n" }, { "path": "deps/jemalloc/test/include/test/test.h", "content": "#define ASSERT_BUFSIZE\t256\n\n#define verify_cmp(may_abort, t, a, b, cmp, neg_cmp, pri, ...) do {\t\\\n\tconst t a_ = (a);\t\t\t\t\t\t\\\n\tconst t b_ = (b);\t\t\t\t\t\t\\\n\tif (!(a_ cmp b_)) {\t\t\t\t\t\t\\\n\t\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tchar message[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\\\n\t\t \"%s:%s:%d: Failed assertion: \"\t\t\t\\\n\t\t \"(%s) \" #cmp \" (%s) --> \"\t\t\t\t\\\n\t\t \"%\" pri \" \" #neg_cmp \" %\" pri \": \",\t\t\t\\\n\t\t __func__, __FILE__, __LINE__,\t\t\t\\\n\t\t #a, #b, a_, b_);\t\t\t\t\t\\\n\t\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\\\n\t\tif (may_abort) {\t\t\t\t\t\\\n\t\t\tabort();\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tp_test_fail(prefix, message);\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define expect_cmp(t, a, b, cmp, neg_cmp, pri, ...) verify_cmp(false,\t\\\n t, a, b, cmp, neg_cmp, pri, __VA_ARGS__)\n\n#define expect_ptr_eq(a, b, ...)\texpect_cmp(void *, a, b, ==,\t\\\n !=, \"p\", __VA_ARGS__)\n#define expect_ptr_ne(a, b, ...)\texpect_cmp(void *, a, b, !=,\t\\\n ==, \"p\", __VA_ARGS__)\n#define expect_ptr_null(a, ...)\t\texpect_cmp(void *, a, NULL, ==,\t\\\n !=, \"p\", __VA_ARGS__)\n#define expect_ptr_not_null(a, ...)\texpect_cmp(void *, a, NULL, !=,\t\\\n ==, \"p\", __VA_ARGS__)\n\n#define expect_c_eq(a, b, ...)\texpect_cmp(char, a, b, ==, !=, \"c\", __VA_ARGS__)\n#define expect_c_ne(a, b, ...)\texpect_cmp(char, a, b, !=, ==, \"c\", __VA_ARGS__)\n#define expect_c_lt(a, b, ...)\texpect_cmp(char, a, b, <, >=, \"c\", __VA_ARGS__)\n#define expect_c_le(a, b, ...)\texpect_cmp(char, a, b, <=, >, \"c\", __VA_ARGS__)\n#define expect_c_ge(a, b, ...)\texpect_cmp(char, a, b, >=, <, \"c\", __VA_ARGS__)\n#define expect_c_gt(a, b, ...)\texpect_cmp(char, a, b, >, <=, \"c\", __VA_ARGS__)\n\n#define expect_x_eq(a, b, ...)\texpect_cmp(int, a, b, ==, !=, \"#x\", __VA_ARGS__)\n#define expect_x_ne(a, b, ...)\texpect_cmp(int, a, b, !=, ==, \"#x\", __VA_ARGS__)\n#define expect_x_lt(a, b, ...)\texpect_cmp(int, a, b, <, >=, \"#x\", __VA_ARGS__)\n#define expect_x_le(a, b, ...)\texpect_cmp(int, a, b, <=, >, \"#x\", __VA_ARGS__)\n#define expect_x_ge(a, b, ...)\texpect_cmp(int, a, b, >=, <, \"#x\", __VA_ARGS__)\n#define expect_x_gt(a, b, ...)\texpect_cmp(int, a, b, >, <=, \"#x\", __VA_ARGS__)\n\n#define expect_d_eq(a, b, ...)\texpect_cmp(int, a, b, ==, !=, \"d\", __VA_ARGS__)\n#define expect_d_ne(a, b, ...)\texpect_cmp(int, a, b, !=, ==, \"d\", __VA_ARGS__)\n#define expect_d_lt(a, b, ...)\texpect_cmp(int, a, b, <, >=, \"d\", __VA_ARGS__)\n#define expect_d_le(a, b, ...)\texpect_cmp(int, a, b, <=, >, \"d\", __VA_ARGS__)\n#define expect_d_ge(a, b, ...)\texpect_cmp(int, a, b, >=, <, \"d\", __VA_ARGS__)\n#define expect_d_gt(a, b, ...)\texpect_cmp(int, a, b, >, <=, \"d\", __VA_ARGS__)\n\n#define expect_u_eq(a, b, ...)\texpect_cmp(int, a, b, ==, !=, \"u\", __VA_ARGS__)\n#define expect_u_ne(a, b, ...)\texpect_cmp(int, a, b, !=, ==, \"u\", __VA_ARGS__)\n#define expect_u_lt(a, b, ...)\texpect_cmp(int, a, b, <, >=, \"u\", __VA_ARGS__)\n#define expect_u_le(a, b, ...)\texpect_cmp(int, a, b, <=, >, \"u\", __VA_ARGS__)\n#define expect_u_ge(a, b, ...)\texpect_cmp(int, a, b, >=, <, \"u\", __VA_ARGS__)\n#define expect_u_gt(a, b, ...)\texpect_cmp(int, a, b, >, <=, \"u\", __VA_ARGS__)\n\n#define expect_ld_eq(a, b, ...)\texpect_cmp(long, a, b, ==,\t\\\n !=, \"ld\", __VA_ARGS__)\n#define expect_ld_ne(a, b, ...)\texpect_cmp(long, a, b, !=,\t\\\n ==, \"ld\", __VA_ARGS__)\n#define expect_ld_lt(a, b, ...)\texpect_cmp(long, a, b, <,\t\\\n >=, \"ld\", __VA_ARGS__)\n#define expect_ld_le(a, b, ...)\texpect_cmp(long, a, b, <=,\t\\\n >, \"ld\", __VA_ARGS__)\n#define expect_ld_ge(a, b, ...)\texpect_cmp(long, a, b, >=,\t\\\n <, \"ld\", __VA_ARGS__)\n#define expect_ld_gt(a, b, ...)\texpect_cmp(long, a, b, >,\t\\\n <=, \"ld\", __VA_ARGS__)\n\n#define expect_lu_eq(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, ==, !=, \"lu\", __VA_ARGS__)\n#define expect_lu_ne(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, !=, ==, \"lu\", __VA_ARGS__)\n#define expect_lu_lt(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, <, >=, \"lu\", __VA_ARGS__)\n#define expect_lu_le(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, <=, >, \"lu\", __VA_ARGS__)\n#define expect_lu_ge(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, >=, <, \"lu\", __VA_ARGS__)\n#define expect_lu_gt(a, b, ...)\texpect_cmp(unsigned long,\t\\\n a, b, >, <=, \"lu\", __VA_ARGS__)\n\n#define expect_qd_eq(a, b, ...)\texpect_cmp(long long, a, b, ==,\t\\\n !=, \"qd\", __VA_ARGS__)\n#define expect_qd_ne(a, b, ...)\texpect_cmp(long long, a, b, !=,\t\\\n ==, \"qd\", __VA_ARGS__)\n#define expect_qd_lt(a, b, ...)\texpect_cmp(long long, a, b, <,\t\\\n >=, \"qd\", __VA_ARGS__)\n#define expect_qd_le(a, b, ...)\texpect_cmp(long long, a, b, <=,\t\\\n >, \"qd\", __VA_ARGS__)\n#define expect_qd_ge(a, b, ...)\texpect_cmp(long long, a, b, >=,\t\\\n <, \"qd\", __VA_ARGS__)\n#define expect_qd_gt(a, b, ...)\texpect_cmp(long long, a, b, >,\t\\\n <=, \"qd\", __VA_ARGS__)\n\n#define expect_qu_eq(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, ==, !=, \"qu\", __VA_ARGS__)\n#define expect_qu_ne(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, !=, ==, \"qu\", __VA_ARGS__)\n#define expect_qu_lt(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, <, >=, \"qu\", __VA_ARGS__)\n#define expect_qu_le(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, <=, >, \"qu\", __VA_ARGS__)\n#define expect_qu_ge(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, >=, <, \"qu\", __VA_ARGS__)\n#define expect_qu_gt(a, b, ...)\texpect_cmp(unsigned long long,\t\\\n a, b, >, <=, \"qu\", __VA_ARGS__)\n\n#define expect_jd_eq(a, b, ...)\texpect_cmp(intmax_t, a, b, ==,\t\\\n !=, \"jd\", __VA_ARGS__)\n#define expect_jd_ne(a, b, ...)\texpect_cmp(intmax_t, a, b, !=,\t\\\n ==, \"jd\", __VA_ARGS__)\n#define expect_jd_lt(a, b, ...)\texpect_cmp(intmax_t, a, b, <,\t\\\n >=, \"jd\", __VA_ARGS__)\n#define expect_jd_le(a, b, ...)\texpect_cmp(intmax_t, a, b, <=,\t\\\n >, \"jd\", __VA_ARGS__)\n#define expect_jd_ge(a, b, ...)\texpect_cmp(intmax_t, a, b, >=,\t\\\n <, \"jd\", __VA_ARGS__)\n#define expect_jd_gt(a, b, ...)\texpect_cmp(intmax_t, a, b, >,\t\\\n <=, \"jd\", __VA_ARGS__)\n\n#define expect_ju_eq(a, b, ...)\texpect_cmp(uintmax_t, a, b, ==,\t\\\n !=, \"ju\", __VA_ARGS__)\n#define expect_ju_ne(a, b, ...)\texpect_cmp(uintmax_t, a, b, !=,\t\\\n ==, \"ju\", __VA_ARGS__)\n#define expect_ju_lt(a, b, ...)\texpect_cmp(uintmax_t, a, b, <,\t\\\n >=, \"ju\", __VA_ARGS__)\n#define expect_ju_le(a, b, ...)\texpect_cmp(uintmax_t, a, b, <=,\t\\\n >, \"ju\", __VA_ARGS__)\n#define expect_ju_ge(a, b, ...)\texpect_cmp(uintmax_t, a, b, >=,\t\\\n <, \"ju\", __VA_ARGS__)\n#define expect_ju_gt(a, b, ...)\texpect_cmp(uintmax_t, a, b, >,\t\\\n <=, \"ju\", __VA_ARGS__)\n\n#define expect_zd_eq(a, b, ...)\texpect_cmp(ssize_t, a, b, ==,\t\\\n !=, \"zd\", __VA_ARGS__)\n#define expect_zd_ne(a, b, ...)\texpect_cmp(ssize_t, a, b, !=,\t\\\n ==, \"zd\", __VA_ARGS__)\n#define expect_zd_lt(a, b, ...)\texpect_cmp(ssize_t, a, b, <,\t\\\n >=, \"zd\", __VA_ARGS__)\n#define expect_zd_le(a, b, ...)\texpect_cmp(ssize_t, a, b, <=,\t\\\n >, \"zd\", __VA_ARGS__)\n#define expect_zd_ge(a, b, ...)\texpect_cmp(ssize_t, a, b, >=,\t\\\n <, \"zd\", __VA_ARGS__)\n#define expect_zd_gt(a, b, ...)\texpect_cmp(ssize_t, a, b, >,\t\\\n <=, \"zd\", __VA_ARGS__)\n\n#define expect_zu_eq(a, b, ...)\texpect_cmp(size_t, a, b, ==,\t\\\n !=, \"zu\", __VA_ARGS__)\n#define expect_zu_ne(a, b, ...)\texpect_cmp(size_t, a, b, !=,\t\\\n ==, \"zu\", __VA_ARGS__)\n#define expect_zu_lt(a, b, ...)\texpect_cmp(size_t, a, b, <,\t\\\n >=, \"zu\", __VA_ARGS__)\n#define expect_zu_le(a, b, ...)\texpect_cmp(size_t, a, b, <=,\t\\\n >, \"zu\", __VA_ARGS__)\n#define expect_zu_ge(a, b, ...)\texpect_cmp(size_t, a, b, >=,\t\\\n <, \"zu\", __VA_ARGS__)\n#define expect_zu_gt(a, b, ...)\texpect_cmp(size_t, a, b, >,\t\\\n <=, \"zu\", __VA_ARGS__)\n\n#define expect_d32_eq(a, b, ...)\texpect_cmp(int32_t, a, b, ==,\t\\\n !=, FMTd32, __VA_ARGS__)\n#define expect_d32_ne(a, b, ...)\texpect_cmp(int32_t, a, b, !=,\t\\\n ==, FMTd32, __VA_ARGS__)\n#define expect_d32_lt(a, b, ...)\texpect_cmp(int32_t, a, b, <,\t\\\n >=, FMTd32, __VA_ARGS__)\n#define expect_d32_le(a, b, ...)\texpect_cmp(int32_t, a, b, <=,\t\\\n >, FMTd32, __VA_ARGS__)\n#define expect_d32_ge(a, b, ...)\texpect_cmp(int32_t, a, b, >=,\t\\\n <, FMTd32, __VA_ARGS__)\n#define expect_d32_gt(a, b, ...)\texpect_cmp(int32_t, a, b, >,\t\\\n <=, FMTd32, __VA_ARGS__)\n\n#define expect_u32_eq(a, b, ...)\texpect_cmp(uint32_t, a, b, ==,\t\\\n !=, FMTu32, __VA_ARGS__)\n#define expect_u32_ne(a, b, ...)\texpect_cmp(uint32_t, a, b, !=,\t\\\n ==, FMTu32, __VA_ARGS__)\n#define expect_u32_lt(a, b, ...)\texpect_cmp(uint32_t, a, b, <,\t\\\n >=, FMTu32, __VA_ARGS__)\n#define expect_u32_le(a, b, ...)\texpect_cmp(uint32_t, a, b, <=,\t\\\n >, FMTu32, __VA_ARGS__)\n#define expect_u32_ge(a, b, ...)\texpect_cmp(uint32_t, a, b, >=,\t\\\n <, FMTu32, __VA_ARGS__)\n#define expect_u32_gt(a, b, ...)\texpect_cmp(uint32_t, a, b, >,\t\\\n <=, FMTu32, __VA_ARGS__)\n\n#define expect_d64_eq(a, b, ...)\texpect_cmp(int64_t, a, b, ==,\t\\\n !=, FMTd64, __VA_ARGS__)\n#define expect_d64_ne(a, b, ...)\texpect_cmp(int64_t, a, b, !=,\t\\\n ==, FMTd64, __VA_ARGS__)\n#define expect_d64_lt(a, b, ...)\texpect_cmp(int64_t, a, b, <,\t\\\n >=, FMTd64, __VA_ARGS__)\n#define expect_d64_le(a, b, ...)\texpect_cmp(int64_t, a, b, <=,\t\\\n >, FMTd64, __VA_ARGS__)\n#define expect_d64_ge(a, b, ...)\texpect_cmp(int64_t, a, b, >=,\t\\\n <, FMTd64, __VA_ARGS__)\n#define expect_d64_gt(a, b, ...)\texpect_cmp(int64_t, a, b, >,\t\\\n <=, FMTd64, __VA_ARGS__)\n\n#define expect_u64_eq(a, b, ...)\texpect_cmp(uint64_t, a, b, ==,\t\\\n !=, FMTu64, __VA_ARGS__)\n#define expect_u64_ne(a, b, ...)\texpect_cmp(uint64_t, a, b, !=,\t\\\n ==, FMTu64, __VA_ARGS__)\n#define expect_u64_lt(a, b, ...)\texpect_cmp(uint64_t, a, b, <,\t\\\n >=, FMTu64, __VA_ARGS__)\n#define expect_u64_le(a, b, ...)\texpect_cmp(uint64_t, a, b, <=,\t\\\n >, FMTu64, __VA_ARGS__)\n#define expect_u64_ge(a, b, ...)\texpect_cmp(uint64_t, a, b, >=,\t\\\n <, FMTu64, __VA_ARGS__)\n#define expect_u64_gt(a, b, ...)\texpect_cmp(uint64_t, a, b, >,\t\\\n <=, FMTu64, __VA_ARGS__)\n\n#define verify_b_eq(may_abort, a, b, ...) do {\t\t\t\t\\\n\tbool a_ = (a);\t\t\t\t\t\t\t\\\n\tbool b_ = (b);\t\t\t\t\t\t\t\\\n\tif (!(a_ == b_)) {\t\t\t\t\t\t\\\n\t\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tchar message[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\\\n\t\t \"%s:%s:%d: Failed assertion: \"\t\t\t\\\n\t\t \"(%s) == (%s) --> %s != %s: \",\t\t\t\\\n\t\t __func__, __FILE__, __LINE__,\t\t\t\\\n\t\t #a, #b, a_ ? \"true\" : \"false\",\t\t\t\\\n\t\t b_ ? \"true\" : \"false\");\t\t\t\t\\\n\t\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\\\n\t\tif (may_abort) {\t\t\t\t\t\\\n\t\t\tabort();\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tp_test_fail(prefix, message);\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define verify_b_ne(may_abort, a, b, ...) do {\t\t\t\t\\\n\tbool a_ = (a);\t\t\t\t\t\t\t\\\n\tbool b_ = (b);\t\t\t\t\t\t\t\\\n\tif (!(a_ != b_)) {\t\t\t\t\t\t\\\n\t\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tchar message[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\\\n\t\t \"%s:%s:%d: Failed assertion: \"\t\t\t\\\n\t\t \"(%s) != (%s) --> %s == %s: \",\t\t\t\\\n\t\t __func__, __FILE__, __LINE__,\t\t\t\\\n\t\t #a, #b, a_ ? \"true\" : \"false\",\t\t\t\\\n\t\t b_ ? \"true\" : \"false\");\t\t\t\t\\\n\t\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\\\n\t\tif (may_abort) {\t\t\t\t\t\\\n\t\t\tabort();\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tp_test_fail(prefix, message);\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define expect_b_eq(a, b, ...)\tverify_b_eq(false, a, b, __VA_ARGS__)\n#define expect_b_ne(a, b, ...)\tverify_b_ne(false, a, b, __VA_ARGS__)\n\n#define expect_true(a, ...)\texpect_b_eq(a, true, __VA_ARGS__)\n#define expect_false(a, ...)\texpect_b_eq(a, false, __VA_ARGS__)\n\n#define verify_str_eq(may_abort, a, b, ...) do {\t\t\t\\\n\tif (strcmp((a), (b))) {\t\t\t\t\t\t\\\n\t\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tchar message[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\\\n\t\t \"%s:%s:%d: Failed assertion: \"\t\t\t\\\n\t\t \"(%s) same as (%s) --> \"\t\t\t\t\\\n\t\t \"\\\"%s\\\" differs from \\\"%s\\\": \",\t\t\t\\\n\t\t __func__, __FILE__, __LINE__, #a, #b, a, b);\t\\\n\t\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\\\n\t\tif (may_abort) {\t\t\t\t\t\\\n\t\t\tabort();\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tp_test_fail(prefix, message);\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define verify_str_ne(may_abort, a, b, ...) do {\t\t\t\\\n\tif (!strcmp((a), (b))) {\t\t\t\t\t\\\n\t\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tchar message[ASSERT_BUFSIZE];\t\t\t\t\\\n\t\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\\\n\t\t \"%s:%s:%d: Failed assertion: \"\t\t\t\\\n\t\t \"(%s) differs from (%s) --> \"\t\t\t\\\n\t\t \"\\\"%s\\\" same as \\\"%s\\\": \",\t\t\t\t\\\n\t\t __func__, __FILE__, __LINE__, #a, #b, a, b);\t\\\n\t\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\\\n\t\tif (may_abort) {\t\t\t\t\t\\\n\t\t\tabort();\t\t\t\t\t\\\n\t\t} else {\t\t\t\t\t\t\\\n\t\t\tp_test_fail(prefix, message);\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define expect_str_eq(a, b, ...) verify_str_eq(false, a, b, __VA_ARGS__)\n#define expect_str_ne(a, b, ...) verify_str_ne(false, a, b, __VA_ARGS__)\n\n#define verify_not_reached(may_abort, ...) do {\t\t\t\t\\\n\tchar prefix[ASSERT_BUFSIZE];\t\t\t\t\t\\\n\tchar message[ASSERT_BUFSIZE];\t\t\t\t\t\\\n\tmalloc_snprintf(prefix, sizeof(prefix),\t\t\t\t\\\n\t \"%s:%s:%d: Unreachable code reached: \",\t\t\t\\\n\t __func__, __FILE__, __LINE__);\t\t\t\t\\\n\tmalloc_snprintf(message, sizeof(message), __VA_ARGS__);\t\t\\\n\tif (may_abort) {\t\t\t\t\t\t\\\n\t\tabort();\t\t\t\t\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\tp_test_fail(prefix, message);\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define expect_not_reached(...) verify_not_reached(false, __VA_ARGS__)\n\n#define assert_cmp(t, a, b, cmp, neg_cmp, pri, ...) verify_cmp(true,\t\\\n t, a, b, cmp, neg_cmp, pri, __VA_ARGS__)\n\n#define assert_ptr_eq(a, b, ...)\tassert_cmp(void *, a, b, ==,\t\\\n !=, \"p\", __VA_ARGS__)\n#define assert_ptr_ne(a, b, ...)\tassert_cmp(void *, a, b, !=,\t\\\n ==, \"p\", __VA_ARGS__)\n#define assert_ptr_null(a, ...)\t\tassert_cmp(void *, a, NULL, ==,\t\\\n !=, \"p\", __VA_ARGS__)\n#define assert_ptr_not_null(a, ...)\tassert_cmp(void *, a, NULL, !=,\t\\\n ==, \"p\", __VA_ARGS__)\n\n#define assert_c_eq(a, b, ...)\tassert_cmp(char, a, b, ==, !=, \"c\", __VA_ARGS__)\n#define assert_c_ne(a, b, ...)\tassert_cmp(char, a, b, !=, ==, \"c\", __VA_ARGS__)\n#define assert_c_lt(a, b, ...)\tassert_cmp(char, a, b, <, >=, \"c\", __VA_ARGS__)\n#define assert_c_le(a, b, ...)\tassert_cmp(char, a, b, <=, >, \"c\", __VA_ARGS__)\n#define assert_c_ge(a, b, ...)\tassert_cmp(char, a, b, >=, <, \"c\", __VA_ARGS__)\n#define assert_c_gt(a, b, ...)\tassert_cmp(char, a, b, >, <=, \"c\", __VA_ARGS__)\n\n#define assert_x_eq(a, b, ...)\tassert_cmp(int, a, b, ==, !=, \"#x\", __VA_ARGS__)\n#define assert_x_ne(a, b, ...)\tassert_cmp(int, a, b, !=, ==, \"#x\", __VA_ARGS__)\n#define assert_x_lt(a, b, ...)\tassert_cmp(int, a, b, <, >=, \"#x\", __VA_ARGS__)\n#define assert_x_le(a, b, ...)\tassert_cmp(int, a, b, <=, >, \"#x\", __VA_ARGS__)\n#define assert_x_ge(a, b, ...)\tassert_cmp(int, a, b, >=, <, \"#x\", __VA_ARGS__)\n#define assert_x_gt(a, b, ...)\tassert_cmp(int, a, b, >, <=, \"#x\", __VA_ARGS__)\n\n#define assert_d_eq(a, b, ...)\tassert_cmp(int, a, b, ==, !=, \"d\", __VA_ARGS__)\n#define assert_d_ne(a, b, ...)\tassert_cmp(int, a, b, !=, ==, \"d\", __VA_ARGS__)\n#define assert_d_lt(a, b, ...)\tassert_cmp(int, a, b, <, >=, \"d\", __VA_ARGS__)\n#define assert_d_le(a, b, ...)\tassert_cmp(int, a, b, <=, >, \"d\", __VA_ARGS__)\n#define assert_d_ge(a, b, ...)\tassert_cmp(int, a, b, >=, <, \"d\", __VA_ARGS__)\n#define assert_d_gt(a, b, ...)\tassert_cmp(int, a, b, >, <=, \"d\", __VA_ARGS__)\n\n#define assert_u_eq(a, b, ...)\tassert_cmp(int, a, b, ==, !=, \"u\", __VA_ARGS__)\n#define assert_u_ne(a, b, ...)\tassert_cmp(int, a, b, !=, ==, \"u\", __VA_ARGS__)\n#define assert_u_lt(a, b, ...)\tassert_cmp(int, a, b, <, >=, \"u\", __VA_ARGS__)\n#define assert_u_le(a, b, ...)\tassert_cmp(int, a, b, <=, >, \"u\", __VA_ARGS__)\n#define assert_u_ge(a, b, ...)\tassert_cmp(int, a, b, >=, <, \"u\", __VA_ARGS__)\n#define assert_u_gt(a, b, ...)\tassert_cmp(int, a, b, >, <=, \"u\", __VA_ARGS__)\n\n#define assert_ld_eq(a, b, ...)\tassert_cmp(long, a, b, ==,\t\\\n !=, \"ld\", __VA_ARGS__)\n#define assert_ld_ne(a, b, ...)\tassert_cmp(long, a, b, !=,\t\\\n ==, \"ld\", __VA_ARGS__)\n#define assert_ld_lt(a, b, ...)\tassert_cmp(long, a, b, <,\t\\\n >=, \"ld\", __VA_ARGS__)\n#define assert_ld_le(a, b, ...)\tassert_cmp(long, a, b, <=,\t\\\n >, \"ld\", __VA_ARGS__)\n#define assert_ld_ge(a, b, ...)\tassert_cmp(long, a, b, >=,\t\\\n <, \"ld\", __VA_ARGS__)\n#define assert_ld_gt(a, b, ...)\tassert_cmp(long, a, b, >,\t\\\n <=, \"ld\", __VA_ARGS__)\n\n#define assert_lu_eq(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, ==, !=, \"lu\", __VA_ARGS__)\n#define assert_lu_ne(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, !=, ==, \"lu\", __VA_ARGS__)\n#define assert_lu_lt(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, <, >=, \"lu\", __VA_ARGS__)\n#define assert_lu_le(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, <=, >, \"lu\", __VA_ARGS__)\n#define assert_lu_ge(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, >=, <, \"lu\", __VA_ARGS__)\n#define assert_lu_gt(a, b, ...)\tassert_cmp(unsigned long,\t\\\n a, b, >, <=, \"lu\", __VA_ARGS__)\n\n#define assert_qd_eq(a, b, ...)\tassert_cmp(long long, a, b, ==,\t\\\n !=, \"qd\", __VA_ARGS__)\n#define assert_qd_ne(a, b, ...)\tassert_cmp(long long, a, b, !=,\t\\\n ==, \"qd\", __VA_ARGS__)\n#define assert_qd_lt(a, b, ...)\tassert_cmp(long long, a, b, <,\t\\\n >=, \"qd\", __VA_ARGS__)\n#define assert_qd_le(a, b, ...)\tassert_cmp(long long, a, b, <=,\t\\\n >, \"qd\", __VA_ARGS__)\n#define assert_qd_ge(a, b, ...)\tassert_cmp(long long, a, b, >=,\t\\\n <, \"qd\", __VA_ARGS__)\n#define assert_qd_gt(a, b, ...)\tassert_cmp(long long, a, b, >,\t\\\n <=, \"qd\", __VA_ARGS__)\n\n#define assert_qu_eq(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, ==, !=, \"qu\", __VA_ARGS__)\n#define assert_qu_ne(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, !=, ==, \"qu\", __VA_ARGS__)\n#define assert_qu_lt(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, <, >=, \"qu\", __VA_ARGS__)\n#define assert_qu_le(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, <=, >, \"qu\", __VA_ARGS__)\n#define assert_qu_ge(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, >=, <, \"qu\", __VA_ARGS__)\n#define assert_qu_gt(a, b, ...)\tassert_cmp(unsigned long long,\t\\\n a, b, >, <=, \"qu\", __VA_ARGS__)\n\n#define assert_jd_eq(a, b, ...)\tassert_cmp(intmax_t, a, b, ==,\t\\\n !=, \"jd\", __VA_ARGS__)\n#define assert_jd_ne(a, b, ...)\tassert_cmp(intmax_t, a, b, !=,\t\\\n ==, \"jd\", __VA_ARGS__)\n#define assert_jd_lt(a, b, ...)\tassert_cmp(intmax_t, a, b, <,\t\\\n >=, \"jd\", __VA_ARGS__)\n#define assert_jd_le(a, b, ...)\tassert_cmp(intmax_t, a, b, <=,\t\\\n >, \"jd\", __VA_ARGS__)\n#define assert_jd_ge(a, b, ...)\tassert_cmp(intmax_t, a, b, >=,\t\\\n <, \"jd\", __VA_ARGS__)\n#define assert_jd_gt(a, b, ...)\tassert_cmp(intmax_t, a, b, >,\t\\\n <=, \"jd\", __VA_ARGS__)\n\n#define assert_ju_eq(a, b, ...)\tassert_cmp(uintmax_t, a, b, ==,\t\\\n !=, \"ju\", __VA_ARGS__)\n#define assert_ju_ne(a, b, ...)\tassert_cmp(uintmax_t, a, b, !=,\t\\\n ==, \"ju\", __VA_ARGS__)\n#define assert_ju_lt(a, b, ...)\tassert_cmp(uintmax_t, a, b, <,\t\\\n >=, \"ju\", __VA_ARGS__)\n#define assert_ju_le(a, b, ...)\tassert_cmp(uintmax_t, a, b, <=,\t\\\n >, \"ju\", __VA_ARGS__)\n#define assert_ju_ge(a, b, ...)\tassert_cmp(uintmax_t, a, b, >=,\t\\\n <, \"ju\", __VA_ARGS__)\n#define assert_ju_gt(a, b, ...)\tassert_cmp(uintmax_t, a, b, >,\t\\\n <=, \"ju\", __VA_ARGS__)\n\n#define assert_zd_eq(a, b, ...)\tassert_cmp(ssize_t, a, b, ==,\t\\\n !=, \"zd\", __VA_ARGS__)\n#define assert_zd_ne(a, b, ...)\tassert_cmp(ssize_t, a, b, !=,\t\\\n ==, \"zd\", __VA_ARGS__)\n#define assert_zd_lt(a, b, ...)\tassert_cmp(ssize_t, a, b, <,\t\\\n >=, \"zd\", __VA_ARGS__)\n#define assert_zd_le(a, b, ...)\tassert_cmp(ssize_t, a, b, <=,\t\\\n >, \"zd\", __VA_ARGS__)\n#define assert_zd_ge(a, b, ...)\tassert_cmp(ssize_t, a, b, >=,\t\\\n <, \"zd\", __VA_ARGS__)\n#define assert_zd_gt(a, b, ...)\tassert_cmp(ssize_t, a, b, >,\t\\\n <=, \"zd\", __VA_ARGS__)\n\n#define assert_zu_eq(a, b, ...)\tassert_cmp(size_t, a, b, ==,\t\\\n !=, \"zu\", __VA_ARGS__)\n#define assert_zu_ne(a, b, ...)\tassert_cmp(size_t, a, b, !=,\t\\\n ==, \"zu\", __VA_ARGS__)\n#define assert_zu_lt(a, b, ...)\tassert_cmp(size_t, a, b, <,\t\\\n >=, \"zu\", __VA_ARGS__)\n#define assert_zu_le(a, b, ...)\tassert_cmp(size_t, a, b, <=,\t\\\n >, \"zu\", __VA_ARGS__)\n#define assert_zu_ge(a, b, ...)\tassert_cmp(size_t, a, b, >=,\t\\\n <, \"zu\", __VA_ARGS__)\n#define assert_zu_gt(a, b, ...)\tassert_cmp(size_t, a, b, >,\t\\\n <=, \"zu\", __VA_ARGS__)\n\n#define assert_d32_eq(a, b, ...)\tassert_cmp(int32_t, a, b, ==,\t\\\n !=, FMTd32, __VA_ARGS__)\n#define assert_d32_ne(a, b, ...)\tassert_cmp(int32_t, a, b, !=,\t\\\n ==, FMTd32, __VA_ARGS__)\n#define assert_d32_lt(a, b, ...)\tassert_cmp(int32_t, a, b, <,\t\\\n >=, FMTd32, __VA_ARGS__)\n#define assert_d32_le(a, b, ...)\tassert_cmp(int32_t, a, b, <=,\t\\\n >, FMTd32, __VA_ARGS__)\n#define assert_d32_ge(a, b, ...)\tassert_cmp(int32_t, a, b, >=,\t\\\n <, FMTd32, __VA_ARGS__)\n#define assert_d32_gt(a, b, ...)\tassert_cmp(int32_t, a, b, >,\t\\\n <=, FMTd32, __VA_ARGS__)\n\n#define assert_u32_eq(a, b, ...)\tassert_cmp(uint32_t, a, b, ==,\t\\\n !=, FMTu32, __VA_ARGS__)\n#define assert_u32_ne(a, b, ...)\tassert_cmp(uint32_t, a, b, !=,\t\\\n ==, FMTu32, __VA_ARGS__)\n#define assert_u32_lt(a, b, ...)\tassert_cmp(uint32_t, a, b, <,\t\\\n >=, FMTu32, __VA_ARGS__)\n#define assert_u32_le(a, b, ...)\tassert_cmp(uint32_t, a, b, <=,\t\\\n >, FMTu32, __VA_ARGS__)\n#define assert_u32_ge(a, b, ...)\tassert_cmp(uint32_t, a, b, >=,\t\\\n <, FMTu32, __VA_ARGS__)\n#define assert_u32_gt(a, b, ...)\tassert_cmp(uint32_t, a, b, >,\t\\\n <=, FMTu32, __VA_ARGS__)\n\n#define assert_d64_eq(a, b, ...)\tassert_cmp(int64_t, a, b, ==,\t\\\n !=, FMTd64, __VA_ARGS__)\n#define assert_d64_ne(a, b, ...)\tassert_cmp(int64_t, a, b, !=,\t\\\n ==, FMTd64, __VA_ARGS__)\n#define assert_d64_lt(a, b, ...)\tassert_cmp(int64_t, a, b, <,\t\\\n >=, FMTd64, __VA_ARGS__)\n#define assert_d64_le(a, b, ...)\tassert_cmp(int64_t, a, b, <=,\t\\\n >, FMTd64, __VA_ARGS__)\n#define assert_d64_ge(a, b, ...)\tassert_cmp(int64_t, a, b, >=,\t\\\n <, FMTd64, __VA_ARGS__)\n#define assert_d64_gt(a, b, ...)\tassert_cmp(int64_t, a, b, >,\t\\\n <=, FMTd64, __VA_ARGS__)\n\n#define assert_u64_eq(a, b, ...)\tassert_cmp(uint64_t, a, b, ==,\t\\\n !=, FMTu64, __VA_ARGS__)\n#define assert_u64_ne(a, b, ...)\tassert_cmp(uint64_t, a, b, !=,\t\\\n ==, FMTu64, __VA_ARGS__)\n#define assert_u64_lt(a, b, ...)\tassert_cmp(uint64_t, a, b, <,\t\\\n >=, FMTu64, __VA_ARGS__)\n#define assert_u64_le(a, b, ...)\tassert_cmp(uint64_t, a, b, <=,\t\\\n >, FMTu64, __VA_ARGS__)\n#define assert_u64_ge(a, b, ...)\tassert_cmp(uint64_t, a, b, >=,\t\\\n <, FMTu64, __VA_ARGS__)\n#define assert_u64_gt(a, b, ...)\tassert_cmp(uint64_t, a, b, >,\t\\\n <=, FMTu64, __VA_ARGS__)\n\n#define assert_b_eq(a, b, ...)\tverify_b_eq(true, a, b, __VA_ARGS__)\n#define assert_b_ne(a, b, ...)\tverify_b_ne(true, a, b, __VA_ARGS__)\n\n#define assert_true(a, ...)\tassert_b_eq(a, true, __VA_ARGS__)\n#define assert_false(a, ...)\tassert_b_eq(a, false, __VA_ARGS__)\n\n#define assert_str_eq(a, b, ...) verify_str_eq(true, a, b, __VA_ARGS__)\n#define assert_str_ne(a, b, ...) verify_str_ne(true, a, b, __VA_ARGS__)\n\n#define assert_not_reached(...) verify_not_reached(true, __VA_ARGS__)\n\n/*\n * If this enum changes, corresponding changes in test/test.sh.in are also\n * necessary.\n */\ntypedef enum {\n\ttest_status_pass = 0,\n\ttest_status_skip = 1,\n\ttest_status_fail = 2,\n\n\ttest_status_count = 3\n} test_status_t;\n\ntypedef void (test_t)(void);\n\n#define TEST_BEGIN(f)\t\t\t\t\t\t\t\\\nstatic void\t\t\t\t\t\t\t\t\\\nf(void) {\t\t\t\t\t\t\t\t\\\n\tp_test_init(#f);\n\n#define TEST_END\t\t\t\t\t\t\t\\\n\tgoto label_test_end;\t\t\t\t\t\t\\\nlabel_test_end:\t\t\t\t\t\t\t\t\\\n\tp_test_fini();\t\t\t\t\t\t\t\\\n}\n\n#define test(...)\t\t\t\t\t\t\t\\\n\tp_test(__VA_ARGS__, NULL)\n\n#define test_no_reentrancy(...)\t\t\t\t\t\t\t\\\n\tp_test_no_reentrancy(__VA_ARGS__, NULL)\n\n#define test_no_malloc_init(...)\t\t\t\t\t\\\n\tp_test_no_malloc_init(__VA_ARGS__, NULL)\n\n#define test_skip_if(e) do {\t\t\t\t\t\t\\\n\tif (e) {\t\t\t\t\t\t\t\\\n\t\ttest_skip(\"%s:%s:%d: Test skipped: (%s)\",\t\t\\\n\t\t __func__, __FILE__, __LINE__, #e);\t\t\t\\\n\t\tgoto label_test_end;\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\nbool test_is_reentrant();\n\nvoid\ttest_skip(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);\nvoid\ttest_fail(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);\n\n/* For private use by macros. */\ntest_status_t\tp_test(test_t *t, ...);\ntest_status_t\tp_test_no_reentrancy(test_t *t, ...);\ntest_status_t\tp_test_no_malloc_init(test_t *t, ...);\nvoid\tp_test_init(const char *name);\nvoid\tp_test_fini(void);\nvoid\tp_test_fail(const char *prefix, const char *message);\n" }, { "path": "deps/jemalloc/test/include/test/thd.h", "content": "/* Abstraction layer for threading in tests. */\n#ifdef _WIN32\ntypedef HANDLE thd_t;\n#else\ntypedef pthread_t thd_t;\n#endif\n\nvoid\tthd_create(thd_t *thd, void *(*proc)(void *), void *arg);\nvoid\tthd_join(thd_t thd, void **ret);\n" }, { "path": "deps/jemalloc/test/include/test/timer.h", "content": "/* Simple timer, for use in benchmark reporting. */\n\ntypedef struct {\n\tnstime_t t0;\n\tnstime_t t1;\n} timedelta_t;\n\nvoid\ttimer_start(timedelta_t *timer);\nvoid\ttimer_stop(timedelta_t *timer);\nuint64_t\ttimer_usec(const timedelta_t *timer);\nvoid\ttimer_ratio(timedelta_t *a, timedelta_t *b, char *buf, size_t buflen);\n" }, { "path": "deps/jemalloc/test/integration/MALLOCX_ARENA.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define NTHREADS 10\n\nstatic bool have_dss =\n#ifdef JEMALLOC_DSS\n true\n#else\n false\n#endif\n ;\n\nvoid *\nthd_start(void *arg) {\n\tunsigned thread_ind = (unsigned)(uintptr_t)arg;\n\tunsigned arena_ind;\n\tvoid *p;\n\tsize_t sz;\n\n\tsz = sizeof(arena_ind);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Error in arenas.create\");\n\n\tif (thread_ind % 4 != 3) {\n\t\tsize_t mib[3];\n\t\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\t\tconst char *dss_precs[] = {\"disabled\", \"primary\", \"secondary\"};\n\t\tunsigned prec_ind = thread_ind %\n\t\t (sizeof(dss_precs)/sizeof(char*));\n\t\tconst char *dss = dss_precs[prec_ind];\n\t\tint expected_err = (have_dss || prec_ind == 0) ? 0 : EFAULT;\n\t\texpect_d_eq(mallctlnametomib(\"arena.0.dss\", mib, &miblen), 0,\n\t\t \"Error in mallctlnametomib()\");\n\t\tmib[1] = arena_ind;\n\t\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, (void *)&dss,\n\t\t sizeof(const char *)), expected_err,\n\t\t \"Error in mallctlbymib()\");\n\t}\n\n\tp = mallocx(1, MALLOCX_ARENA(arena_ind));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tdallocx(p, 0);\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_MALLOCX_ARENA) {\n\tthd_t thds[NTHREADS];\n\tunsigned i;\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_create(&thds[i], thd_start,\n\t\t (void *)(uintptr_t)i);\n\t}\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_MALLOCX_ARENA);\n}\n" }, { "path": "deps/jemalloc/test/integration/aligned_alloc.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define MAXALIGN (((size_t)1) << 23)\n\n/*\n * On systems which can't merge extents, tests that call this function generate\n * a lot of dirty memory very quickly. Purging between cycles mitigates\n * potential OOM on e.g. 32-bit Windows.\n */\nstatic void\npurge(void) {\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl error\");\n}\n\nTEST_BEGIN(test_alignment_errors) {\n\tsize_t alignment;\n\tvoid *p;\n\n\talignment = 0;\n\tset_errno(0);\n\tp = aligned_alloc(alignment, 1);\n\texpect_false(p != NULL || get_errno() != EINVAL,\n\t \"Expected error for invalid alignment %zu\", alignment);\n\n\tfor (alignment = sizeof(size_t); alignment < MAXALIGN;\n\t alignment <<= 1) {\n\t\tset_errno(0);\n\t\tp = aligned_alloc(alignment + 1, 1);\n\t\texpect_false(p != NULL || get_errno() != EINVAL,\n\t\t \"Expected error for invalid alignment %zu\",\n\t\t alignment + 1);\n\t}\n}\nTEST_END\n\n\n/*\n * GCC \"-Walloc-size-larger-than\" warning detects when one of the memory\n * allocation functions is called with a size larger than the maximum size that\n * they support. Here we want to explicitly test that the allocation functions\n * do indeed fail properly when this is the case, which triggers the warning.\n * Therefore we disable the warning for these tests.\n */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n\nTEST_BEGIN(test_oom_errors) {\n\tsize_t alignment, size;\n\tvoid *p;\n\n#if LG_SIZEOF_PTR == 3\n\talignment = UINT64_C(0x8000000000000000);\n\tsize = UINT64_C(0x8000000000000000);\n#else\n\talignment = 0x80000000LU;\n\tsize = 0x80000000LU;\n#endif\n\tset_errno(0);\n\tp = aligned_alloc(alignment, size);\n\texpect_false(p != NULL || get_errno() != ENOMEM,\n\t \"Expected error for aligned_alloc(%zu, %zu)\",\n\t alignment, size);\n\n#if LG_SIZEOF_PTR == 3\n\talignment = UINT64_C(0x4000000000000000);\n\tsize = UINT64_C(0xc000000000000001);\n#else\n\talignment = 0x40000000LU;\n\tsize = 0xc0000001LU;\n#endif\n\tset_errno(0);\n\tp = aligned_alloc(alignment, size);\n\texpect_false(p != NULL || get_errno() != ENOMEM,\n\t \"Expected error for aligned_alloc(%zu, %zu)\",\n\t alignment, size);\n\n\talignment = 0x10LU;\n#if LG_SIZEOF_PTR == 3\n\tsize = UINT64_C(0xfffffffffffffff0);\n#else\n\tsize = 0xfffffff0LU;\n#endif\n\tset_errno(0);\n\tp = aligned_alloc(alignment, size);\n\texpect_false(p != NULL || get_errno() != ENOMEM,\n\t \"Expected error for aligned_alloc(&p, %zu, %zu)\",\n\t alignment, size);\n}\nTEST_END\n\n/* Re-enable the \"-Walloc-size-larger-than=\" warning */\nJEMALLOC_DIAGNOSTIC_POP\n\nTEST_BEGIN(test_alignment_and_size) {\n#define NITER 4\n\tsize_t alignment, size, total;\n\tunsigned i;\n\tvoid *ps[NITER];\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tps[i] = NULL;\n\t}\n\n\tfor (alignment = 8;\n\t alignment <= MAXALIGN;\n\t alignment <<= 1) {\n\t\ttotal = 0;\n\t\tfor (size = 1;\n\t\t size < 3 * alignment && size < (1U << 31);\n\t\t size += (alignment >> (LG_SIZEOF_PTR-1)) - 1) {\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tps[i] = aligned_alloc(alignment, size);\n\t\t\t\tif (ps[i] == NULL) {\n\t\t\t\t\tchar buf[BUFERROR_BUF];\n\n\t\t\t\t\tbuferror(get_errno(), buf, sizeof(buf));\n\t\t\t\t\ttest_fail(\n\t\t\t\t\t \"Error for alignment=%zu, \"\n\t\t\t\t\t \"size=%zu (%#zx): %s\",\n\t\t\t\t\t alignment, size, size, buf);\n\t\t\t\t}\n\t\t\t\ttotal += TEST_MALLOC_SIZE(ps[i]);\n\t\t\t\tif (total >= (MAXALIGN << 1)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tif (ps[i] != NULL) {\n\t\t\t\t\tfree(ps[i]);\n\t\t\t\t\tps[i] = NULL;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpurge();\n\t}\n#undef NITER\n}\nTEST_END\n\nTEST_BEGIN(test_zero_alloc) {\n\tvoid *res = aligned_alloc(8, 0);\n\tassert(res);\n\tsize_t usable = TEST_MALLOC_SIZE(res);\n\tassert(usable > 0);\n\tfree(res);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_alignment_errors,\n\t test_oom_errors,\n\t test_alignment_and_size,\n\t test_zero_alloc);\n}\n" }, { "path": "deps/jemalloc/test/integration/allocated.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic const bool config_stats =\n#ifdef JEMALLOC_STATS\n true\n#else\n false\n#endif\n ;\n\nvoid *\nthd_start(void *arg) {\n\tint err;\n\tvoid *p;\n\tuint64_t a0, a1, d0, d1;\n\tuint64_t *ap0, *ap1, *dp0, *dp1;\n\tsize_t sz, usize;\n\n\tsz = sizeof(a0);\n\tif ((err = mallctl(\"thread.allocated\", (void *)&a0, &sz, NULL, 0))) {\n\t\tif (err == ENOENT) {\n\t\t\tgoto label_ENOENT;\n\t\t}\n\t\ttest_fail(\"%s(): Error in mallctl(): %s\", __func__,\n\t\t strerror(err));\n\t}\n\tsz = sizeof(ap0);\n\tif ((err = mallctl(\"thread.allocatedp\", (void *)&ap0, &sz, NULL, 0))) {\n\t\tif (err == ENOENT) {\n\t\t\tgoto label_ENOENT;\n\t\t}\n\t\ttest_fail(\"%s(): Error in mallctl(): %s\", __func__,\n\t\t strerror(err));\n\t}\n\texpect_u64_eq(*ap0, a0,\n\t \"\\\"thread.allocatedp\\\" should provide a pointer to internal \"\n\t \"storage\");\n\n\tsz = sizeof(d0);\n\tif ((err = mallctl(\"thread.deallocated\", (void *)&d0, &sz, NULL, 0))) {\n\t\tif (err == ENOENT) {\n\t\t\tgoto label_ENOENT;\n\t\t}\n\t\ttest_fail(\"%s(): Error in mallctl(): %s\", __func__,\n\t\t strerror(err));\n\t}\n\tsz = sizeof(dp0);\n\tif ((err = mallctl(\"thread.deallocatedp\", (void *)&dp0, &sz, NULL,\n\t 0))) {\n\t\tif (err == ENOENT) {\n\t\t\tgoto label_ENOENT;\n\t\t}\n\t\ttest_fail(\"%s(): Error in mallctl(): %s\", __func__,\n\t\t strerror(err));\n\t}\n\texpect_u64_eq(*dp0, d0,\n\t \"\\\"thread.deallocatedp\\\" should provide a pointer to internal \"\n\t \"storage\");\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected malloc() error\");\n\n\tsz = sizeof(a1);\n\tmallctl(\"thread.allocated\", (void *)&a1, &sz, NULL, 0);\n\tsz = sizeof(ap1);\n\tmallctl(\"thread.allocatedp\", (void *)&ap1, &sz, NULL, 0);\n\texpect_u64_eq(*ap1, a1,\n\t \"Dereferenced \\\"thread.allocatedp\\\" value should equal \"\n\t \"\\\"thread.allocated\\\" value\");\n\texpect_ptr_eq(ap0, ap1,\n\t \"Pointer returned by \\\"thread.allocatedp\\\" should not change\");\n\n\tusize = TEST_MALLOC_SIZE(p);\n\texpect_u64_le(a0 + usize, a1,\n\t \"Allocated memory counter should increase by at least the amount \"\n\t \"explicitly allocated\");\n\n\tfree(p);\n\n\tsz = sizeof(d1);\n\tmallctl(\"thread.deallocated\", (void *)&d1, &sz, NULL, 0);\n\tsz = sizeof(dp1);\n\tmallctl(\"thread.deallocatedp\", (void *)&dp1, &sz, NULL, 0);\n\texpect_u64_eq(*dp1, d1,\n\t \"Dereferenced \\\"thread.deallocatedp\\\" value should equal \"\n\t \"\\\"thread.deallocated\\\" value\");\n\texpect_ptr_eq(dp0, dp1,\n\t \"Pointer returned by \\\"thread.deallocatedp\\\" should not change\");\n\n\texpect_u64_le(d0 + usize, d1,\n\t \"Deallocated memory counter should increase by at least the amount \"\n\t \"explicitly deallocated\");\n\n\treturn NULL;\nlabel_ENOENT:\n\texpect_false(config_stats,\n\t \"ENOENT should only be returned if stats are disabled\");\n\ttest_skip(\"\\\"thread.allocated\\\" mallctl not available\");\n\treturn NULL;\n}\n\nTEST_BEGIN(test_main_thread) {\n\tthd_start(NULL);\n}\nTEST_END\n\nTEST_BEGIN(test_subthread) {\n\tthd_t thd;\n\n\tthd_create(&thd, thd_start, NULL);\n\tthd_join(thd, NULL);\n}\nTEST_END\n\nint\nmain(void) {\n\t/* Run tests multiple times to check for bad interactions. */\n\treturn test(\n\t test_main_thread,\n\t test_subthread,\n\t test_main_thread,\n\t test_subthread,\n\t test_main_thread);\n}\n" }, { "path": "deps/jemalloc/test/integration/cpp/basic.cpp", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_basic) {\n\tauto foo = new long(4);\n\texpect_ptr_not_null(foo, \"Unexpected new[] failure\");\n\tdelete foo;\n\t// Test nullptr handling.\n\tfoo = nullptr;\n\tdelete foo;\n\n\tauto bar = new long;\n\texpect_ptr_not_null(bar, \"Unexpected new failure\");\n\tdelete bar;\n\t// Test nullptr handling.\n\tbar = nullptr;\n\tdelete bar;\n}\nTEST_END\n\nint\nmain() {\n\treturn test(\n\t test_basic);\n}\n" }, { "path": "deps/jemalloc/test/integration/cpp/infallible_new_false.cpp", "content": "#include \n\n#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_failing_alloc) {\n\tbool saw_exception = false;\n\ttry {\n\t\t/* Too big of an allocation to succeed. */\n\t\tvoid *volatile ptr = ::operator new((size_t)-1);\n\t\t(void)ptr;\n\t} catch (...) {\n\t\tsaw_exception = true;\n\t}\n\texpect_true(saw_exception, \"Didn't get a failure\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_failing_alloc);\n}\n\n" }, { "path": "deps/jemalloc/test/integration/cpp/infallible_new_false.sh", "content": "#!/bin/sh\n\nXMALLOC_STR=\"\"\nif [ \"x${enable_xmalloc}\" = \"x1\" ] ; then\n XMALLOC_STR=\"xmalloc:false,\"\nfi\n\nexport MALLOC_CONF=\"${XMALLOC_STR}experimental_infallible_new:false\"\n" }, { "path": "deps/jemalloc/test/integration/cpp/infallible_new_true.cpp", "content": "#include \n\n#include \"test/jemalloc_test.h\"\n\n/*\n * We can't test C++ in unit tests. In order to intercept abort, use a secret\n * safety check abort hook in integration tests.\n */\ntypedef void (*abort_hook_t)(const char *message);\nbool fake_abort_called;\nvoid fake_abort(const char *message) {\n\tif (strcmp(message, \": Allocation failed and \"\n\t \"opt.experimental_infallible_new is true. Aborting.\\n\") != 0) {\n\t\tabort();\n\t}\n\tfake_abort_called = true;\n}\n\nstatic bool\nown_operator_new(void) {\n\tuint64_t before, after;\n\tsize_t sz = sizeof(before);\n\n\t/* thread.allocated is always available, even w/o config_stats. */\n\texpect_d_eq(mallctl(\"thread.allocated\", (void *)&before, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl failure reading stats\");\n\tvoid *volatile ptr = ::operator new((size_t)8);\n\texpect_ptr_not_null(ptr, \"Unexpected allocation failure\");\n\texpect_d_eq(mallctl(\"thread.allocated\", (void *)&after, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl failure reading stats\");\n\n\treturn (after != before);\n}\n\nTEST_BEGIN(test_failing_alloc) {\n\tabort_hook_t abort_hook = &fake_abort;\n\texpect_d_eq(mallctl(\"experimental.hooks.safety_check_abort\", NULL, NULL,\n\t (void *)&abort_hook, sizeof(abort_hook)), 0,\n\t \"Unexpected mallctl failure setting abort hook\");\n\n\t/*\n\t * Not owning operator new is only expected to happen on MinGW which\n\t * does not support operator new / delete replacement.\n\t */\n#ifdef _WIN32\n\ttest_skip_if(!own_operator_new());\n#else\n\texpect_true(own_operator_new(), \"No operator new overload\");\n#endif\n\tvoid *volatile ptr = (void *)1;\n\ttry {\n\t\t/* Too big of an allocation to succeed. */\n\t\tptr = ::operator new((size_t)-1);\n\t} catch (...) {\n\t\tabort();\n\t}\n\texpect_ptr_null(ptr, \"Allocation should have failed\");\n\texpect_b_eq(fake_abort_called, true, \"Abort hook not invoked\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_failing_alloc);\n}\n\n" }, { "path": "deps/jemalloc/test/integration/cpp/infallible_new_true.sh", "content": "#!/bin/sh\n\nXMALLOC_STR=\"\"\nif [ \"x${enable_xmalloc}\" = \"x1\" ] ; then\n XMALLOC_STR=\"xmalloc:false,\"\nfi\n\nexport MALLOC_CONF=\"${XMALLOC_STR}experimental_infallible_new:true\"\n" }, { "path": "deps/jemalloc/test/integration/extent.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"test/extent_hooks.h\"\n\n#include \"jemalloc/internal/arena_types.h\"\n\nstatic void\ntest_extent_body(unsigned arena_ind) {\n\tvoid *p;\n\tsize_t large0, large1, large2, sz;\n\tsize_t purge_mib[3];\n\tsize_t purge_miblen;\n\tint flags;\n\tbool xallocx_success_a, xallocx_success_b, xallocx_success_c;\n\n\tflags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\n\t/* Get large size classes. */\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large0, &sz, NULL,\n\t 0), 0, \"Unexpected arenas.lextent.0.size failure\");\n\texpect_d_eq(mallctl(\"arenas.lextent.1.size\", (void *)&large1, &sz, NULL,\n\t 0), 0, \"Unexpected arenas.lextent.1.size failure\");\n\texpect_d_eq(mallctl(\"arenas.lextent.2.size\", (void *)&large2, &sz, NULL,\n\t 0), 0, \"Unexpected arenas.lextent.2.size failure\");\n\n\t/* Test dalloc/decommit/purge cascade. */\n\tpurge_miblen = sizeof(purge_mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.purge\", purge_mib, &purge_miblen),\n\t 0, \"Unexpected mallctlnametomib() failure\");\n\tpurge_mib[1] = (size_t)arena_ind;\n\tcalled_alloc = false;\n\ttry_alloc = true;\n\ttry_dalloc = false;\n\ttry_decommit = false;\n\tp = mallocx(large0 * 2, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\texpect_true(called_alloc, \"Expected alloc call\");\n\tcalled_dalloc = false;\n\tcalled_decommit = false;\n\tdid_purge_lazy = false;\n\tdid_purge_forced = false;\n\tcalled_split = false;\n\txallocx_success_a = (xallocx(p, large0, 0, flags) == large0);\n\texpect_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),\n\t 0, \"Unexpected arena.%u.purge error\", arena_ind);\n\tif (xallocx_success_a) {\n\t\texpect_true(called_dalloc, \"Expected dalloc call\");\n\t\texpect_true(called_decommit, \"Expected decommit call\");\n\t\texpect_true(did_purge_lazy || did_purge_forced,\n\t\t \"Expected purge\");\n\t\texpect_true(called_split, \"Expected split call\");\n\t}\n\tdallocx(p, flags);\n\ttry_dalloc = true;\n\n\t/* Test decommit/commit and observe split/merge. */\n\ttry_dalloc = false;\n\ttry_decommit = true;\n\tp = mallocx(large0 * 2, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tdid_decommit = false;\n\tdid_commit = false;\n\tcalled_split = false;\n\tdid_split = false;\n\tdid_merge = false;\n\txallocx_success_b = (xallocx(p, large0, 0, flags) == large0);\n\texpect_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),\n\t 0, \"Unexpected arena.%u.purge error\", arena_ind);\n\tif (xallocx_success_b) {\n\t\texpect_true(did_split, \"Expected split\");\n\t}\n\txallocx_success_c = (xallocx(p, large0 * 2, 0, flags) == large0 * 2);\n\tif (did_split) {\n\t\texpect_b_eq(did_decommit, did_commit,\n\t\t \"Expected decommit/commit match\");\n\t}\n\tif (xallocx_success_b && xallocx_success_c) {\n\t\texpect_true(did_merge, \"Expected merge\");\n\t}\n\tdallocx(p, flags);\n\ttry_dalloc = true;\n\ttry_decommit = false;\n\n\t/* Make sure non-large allocation succeeds. */\n\tp = mallocx(42, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tdallocx(p, flags);\n}\n\nstatic void\ntest_manual_hook_auto_arena(void) {\n\tunsigned narenas;\n\tsize_t old_size, new_size, sz;\n\tsize_t hooks_mib[3];\n\tsize_t hooks_miblen;\n\textent_hooks_t *new_hooks, *old_hooks;\n\n\textent_hooks_prep();\n\n\tsz = sizeof(unsigned);\n\t/* Get number of auto arenas. */\n\texpect_d_eq(mallctl(\"opt.narenas\", (void *)&narenas, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\tif (narenas == 1) {\n\t\treturn;\n\t}\n\n\t/* Install custom extent hooks on arena 1 (might not be initialized). */\n\thooks_miblen = sizeof(hooks_mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.extent_hooks\", hooks_mib,\n\t &hooks_miblen), 0, \"Unexpected mallctlnametomib() failure\");\n\thooks_mib[1] = 1;\n\told_size = sizeof(extent_hooks_t *);\n\tnew_hooks = &hooks;\n\tnew_size = sizeof(extent_hooks_t *);\n\texpect_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,\n\t &old_size, (void *)&new_hooks, new_size), 0,\n\t \"Unexpected extent_hooks error\");\n\tstatic bool auto_arena_created = false;\n\tif (old_hooks != &hooks) {\n\t\texpect_b_eq(auto_arena_created, false,\n\t\t \"Expected auto arena 1 created only once.\");\n\t\tauto_arena_created = true;\n\t}\n}\n\nstatic void\ntest_manual_hook_body(void) {\n\tunsigned arena_ind;\n\tsize_t old_size, new_size, sz;\n\tsize_t hooks_mib[3];\n\tsize_t hooks_miblen;\n\textent_hooks_t *new_hooks, *old_hooks;\n\n\textent_hooks_prep();\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\n\t/* Install custom extent hooks. */\n\thooks_miblen = sizeof(hooks_mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.extent_hooks\", hooks_mib,\n\t &hooks_miblen), 0, \"Unexpected mallctlnametomib() failure\");\n\thooks_mib[1] = (size_t)arena_ind;\n\told_size = sizeof(extent_hooks_t *);\n\tnew_hooks = &hooks;\n\tnew_size = sizeof(extent_hooks_t *);\n\texpect_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,\n\t &old_size, (void *)&new_hooks, new_size), 0,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->alloc, extent_alloc_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->dalloc, extent_dalloc_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->commit, extent_commit_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->decommit, extent_decommit_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->purge_lazy, extent_purge_lazy_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->purge_forced, extent_purge_forced_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->split, extent_split_hook,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_ne(old_hooks->merge, extent_merge_hook,\n\t \"Unexpected extent_hooks error\");\n\n\tif (!is_background_thread_enabled()) {\n\t\ttest_extent_body(arena_ind);\n\t}\n\n\t/* Restore extent hooks. */\n\texpect_d_eq(mallctlbymib(hooks_mib, hooks_miblen, NULL, NULL,\n\t (void *)&old_hooks, new_size), 0, \"Unexpected extent_hooks error\");\n\texpect_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,\n\t &old_size, NULL, 0), 0, \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks, default_hooks, \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->alloc, default_hooks->alloc,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->dalloc, default_hooks->dalloc,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->commit, default_hooks->commit,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->decommit, default_hooks->decommit,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->purge_lazy, default_hooks->purge_lazy,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->purge_forced, default_hooks->purge_forced,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->split, default_hooks->split,\n\t \"Unexpected extent_hooks error\");\n\texpect_ptr_eq(old_hooks->merge, default_hooks->merge,\n\t \"Unexpected extent_hooks error\");\n}\n\nTEST_BEGIN(test_extent_manual_hook) {\n\ttest_manual_hook_auto_arena();\n\ttest_manual_hook_body();\n\n\t/* Test failure paths. */\n\ttry_split = false;\n\ttest_manual_hook_body();\n\ttry_merge = false;\n\ttest_manual_hook_body();\n\ttry_purge_lazy = false;\n\ttry_purge_forced = false;\n\ttest_manual_hook_body();\n\n\ttry_split = try_merge = try_purge_lazy = try_purge_forced = true;\n}\nTEST_END\n\nTEST_BEGIN(test_extent_auto_hook) {\n\tunsigned arena_ind;\n\tsize_t new_size, sz;\n\textent_hooks_t *new_hooks;\n\n\textent_hooks_prep();\n\n\tsz = sizeof(unsigned);\n\tnew_hooks = &hooks;\n\tnew_size = sizeof(extent_hooks_t *);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz,\n\t (void *)&new_hooks, new_size), 0, \"Unexpected mallctl() failure\");\n\n\ttest_skip_if(is_background_thread_enabled());\n\ttest_extent_body(arena_ind);\n}\nTEST_END\n\nstatic void\ntest_arenas_create_ext_base(arena_config_t config,\n\tbool expect_hook_data, bool expect_hook_metadata)\n{\n\tunsigned arena, arena1;\n\tvoid *ptr;\n\tsize_t sz = sizeof(unsigned);\n\n\textent_hooks_prep();\n\n\tcalled_alloc = false;\n\texpect_d_eq(mallctl(\"experimental.arenas_create_ext\",\n\t (void *)&arena, &sz, &config, sizeof(arena_config_t)), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_b_eq(called_alloc, expect_hook_metadata,\n\t \"expected hook metadata alloc mismatch\");\n\n\tcalled_alloc = false;\n\tptr = mallocx(42, MALLOCX_ARENA(arena) | MALLOCX_TCACHE_NONE);\n\texpect_b_eq(called_alloc, expect_hook_data,\n\t \"expected hook data alloc mismatch\");\n\n\texpect_ptr_not_null(ptr, \"Unexpected mallocx() failure\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena1, &sz, &ptr, sizeof(ptr)),\n\t 0, \"Unexpected mallctl() failure\");\n\texpect_u_eq(arena, arena1, \"Unexpected arena index\");\n\tdallocx(ptr, 0);\n}\n\nTEST_BEGIN(test_arenas_create_ext_with_ehooks_no_metadata) {\n\tarena_config_t config;\n\tconfig.extent_hooks = &hooks;\n\tconfig.metadata_use_hooks = false;\n\n\ttest_arenas_create_ext_base(config, true, false);\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_create_ext_with_ehooks_with_metadata) {\n\tarena_config_t config;\n\tconfig.extent_hooks = &hooks;\n\tconfig.metadata_use_hooks = true;\n\n\ttest_arenas_create_ext_base(config, true, true);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_extent_manual_hook,\n\t test_extent_auto_hook,\n\t test_arenas_create_ext_with_ehooks_no_metadata,\n\t test_arenas_create_ext_with_ehooks_with_metadata);\n}\n" }, { "path": "deps/jemalloc/test/integration/extent.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"junk:false\"\nfi\n" }, { "path": "deps/jemalloc/test/integration/malloc.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_zero_alloc) {\n\tvoid *res = malloc(0);\n\tassert(res);\n\tsize_t usable = TEST_MALLOC_SIZE(res);\n\tassert(usable > 0);\n\tfree(res);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_zero_alloc);\n}\n" }, { "path": "deps/jemalloc/test/integration/mallocx.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic unsigned\nget_nsizes_impl(const char *cmd) {\n\tunsigned ret;\n\tsize_t z;\n\n\tz = sizeof(unsigned);\n\texpect_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,\n\t \"Unexpected mallctl(\\\"%s\\\", ...) failure\", cmd);\n\n\treturn ret;\n}\n\nstatic unsigned\nget_nlarge(void) {\n\treturn get_nsizes_impl(\"arenas.nlextents\");\n}\n\nstatic size_t\nget_size_impl(const char *cmd, size_t ind) {\n\tsize_t ret;\n\tsize_t z;\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\", %zu], ...) failure\", cmd, ind);\n\n\treturn ret;\n}\n\nstatic size_t\nget_large_size(size_t ind) {\n\treturn get_size_impl(\"arenas.lextent.0.size\", ind);\n}\n\n/*\n * On systems which can't merge extents, tests that call this function generate\n * a lot of dirty memory very quickly. Purging between cycles mitigates\n * potential OOM on e.g. 32-bit Windows.\n */\nstatic void\npurge(void) {\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl error\");\n}\n\n/*\n * GCC \"-Walloc-size-larger-than\" warning detects when one of the memory\n * allocation functions is called with a size larger than the maximum size that\n * they support. Here we want to explicitly test that the allocation functions\n * do indeed fail properly when this is the case, which triggers the warning.\n * Therefore we disable the warning for these tests.\n */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n\nTEST_BEGIN(test_overflow) {\n\tsize_t largemax;\n\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\texpect_ptr_null(mallocx(largemax+1, 0),\n\t \"Expected OOM for mallocx(size=%#zx, 0)\", largemax+1);\n\n\texpect_ptr_null(mallocx(ZU(PTRDIFF_MAX)+1, 0),\n\t \"Expected OOM for mallocx(size=%#zx, 0)\", ZU(PTRDIFF_MAX)+1);\n\n\texpect_ptr_null(mallocx(SIZE_T_MAX, 0),\n\t \"Expected OOM for mallocx(size=%#zx, 0)\", SIZE_T_MAX);\n\n\texpect_ptr_null(mallocx(1, MALLOCX_ALIGN(ZU(PTRDIFF_MAX)+1)),\n\t \"Expected OOM for mallocx(size=1, MALLOCX_ALIGN(%#zx))\",\n\t ZU(PTRDIFF_MAX)+1);\n}\nTEST_END\n\nstatic void *\nremote_alloc(void *arg) {\n\tunsigned arena;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\tsize_t large_sz;\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large_sz, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\n\tvoid *ptr = mallocx(large_sz, MALLOCX_ARENA(arena)\n\t | MALLOCX_TCACHE_NONE);\n\tvoid **ret = (void **)arg;\n\t*ret = ptr;\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_remote_free) {\n\tthd_t thd;\n\tvoid *ret;\n\tthd_create(&thd, remote_alloc, (void *)&ret);\n\tthd_join(thd, NULL);\n\texpect_ptr_not_null(ret, \"Unexpected mallocx failure\");\n\n\t/* Avoid TCACHE_NONE to explicitly test tcache_flush(). */\n\tdallocx(ret, 0);\n\tmallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_oom) {\n\tsize_t largemax;\n\tbool oom;\n\tvoid *ptrs[3];\n\tunsigned i;\n\n\t/*\n\t * It should be impossible to allocate three objects that each consume\n\t * nearly half the virtual address space.\n\t */\n\tlargemax = get_large_size(get_nlarge()-1);\n\toom = false;\n\tfor (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {\n\t\tptrs[i] = mallocx(largemax, MALLOCX_ARENA(0));\n\t\tif (ptrs[i] == NULL) {\n\t\t\toom = true;\n\t\t}\n\t}\n\texpect_true(oom,\n\t \"Expected OOM during series of calls to mallocx(size=%zu, 0)\",\n\t largemax);\n\tfor (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {\n\t\tif (ptrs[i] != NULL) {\n\t\t\tdallocx(ptrs[i], 0);\n\t\t}\n\t}\n\tpurge();\n\n#if LG_SIZEOF_PTR == 3\n\texpect_ptr_null(mallocx(0x8000000000000000ULL,\n\t MALLOCX_ALIGN(0x8000000000000000ULL)),\n\t \"Expected OOM for mallocx()\");\n\texpect_ptr_null(mallocx(0x8000000000000000ULL,\n\t MALLOCX_ALIGN(0x80000000)),\n\t \"Expected OOM for mallocx()\");\n#else\n\texpect_ptr_null(mallocx(0x80000000UL, MALLOCX_ALIGN(0x80000000UL)),\n\t \"Expected OOM for mallocx()\");\n#endif\n}\nTEST_END\n\n/* Re-enable the \"-Walloc-size-larger-than=\" warning */\nJEMALLOC_DIAGNOSTIC_POP\n\nTEST_BEGIN(test_basic) {\n#define MAXSZ (((size_t)1) << 23)\n\tsize_t sz;\n\n\tfor (sz = 1; sz < MAXSZ; sz = nallocx(sz, 0) + 1) {\n\t\tsize_t nsz, rsz;\n\t\tvoid *p;\n\t\tnsz = nallocx(sz, 0);\n\t\texpect_zu_ne(nsz, 0, \"Unexpected nallocx() error\");\n\t\tp = mallocx(sz, 0);\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected mallocx(size=%zx, flags=0) error\", sz);\n\t\trsz = sallocx(p, 0);\n\t\texpect_zu_ge(rsz, sz, \"Real size smaller than expected\");\n\t\texpect_zu_eq(nsz, rsz, \"nallocx()/sallocx() size mismatch\");\n\t\tdallocx(p, 0);\n\n\t\tp = mallocx(sz, 0);\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected mallocx(size=%zx, flags=0) error\", sz);\n\t\tdallocx(p, 0);\n\n\t\tnsz = nallocx(sz, MALLOCX_ZERO);\n\t\texpect_zu_ne(nsz, 0, \"Unexpected nallocx() error\");\n\t\tp = mallocx(sz, MALLOCX_ZERO);\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected mallocx(size=%zx, flags=MALLOCX_ZERO) error\",\n\t\t nsz);\n\t\trsz = sallocx(p, 0);\n\t\texpect_zu_eq(nsz, rsz, \"nallocx()/sallocx() rsize mismatch\");\n\t\tdallocx(p, 0);\n\t\tpurge();\n\t}\n#undef MAXSZ\n}\nTEST_END\n\nTEST_BEGIN(test_alignment_and_size) {\n\tconst char *percpu_arena;\n\tsize_t sz = sizeof(percpu_arena);\n\n\tif(mallctl(\"opt.percpu_arena\", (void *)&percpu_arena, &sz, NULL, 0) ||\n\t strcmp(percpu_arena, \"disabled\") != 0) {\n\t\ttest_skip(\"test_alignment_and_size skipped: \"\n\t\t \"not working with percpu arena.\");\n\t};\n#define MAXALIGN (((size_t)1) << 23)\n#define NITER 4\n\tsize_t nsz, rsz, alignment, total;\n\tunsigned i;\n\tvoid *ps[NITER];\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tps[i] = NULL;\n\t}\n\n\tfor (alignment = 8;\n\t alignment <= MAXALIGN;\n\t alignment <<= 1) {\n\t\ttotal = 0;\n\t\tfor (sz = 1;\n\t\t sz < 3 * alignment && sz < (1U << 31);\n\t\t sz += (alignment >> (LG_SIZEOF_PTR-1)) - 1) {\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tnsz = nallocx(sz, MALLOCX_ALIGN(alignment) |\n\t\t\t\t MALLOCX_ZERO | MALLOCX_ARENA(0));\n\t\t\t\texpect_zu_ne(nsz, 0,\n\t\t\t\t \"nallocx() error for alignment=%zu, \"\n\t\t\t\t \"size=%zu (%#zx)\", alignment, sz, sz);\n\t\t\t\tps[i] = mallocx(sz, MALLOCX_ALIGN(alignment) |\n\t\t\t\t MALLOCX_ZERO | MALLOCX_ARENA(0));\n\t\t\t\texpect_ptr_not_null(ps[i],\n\t\t\t\t \"mallocx() error for alignment=%zu, \"\n\t\t\t\t \"size=%zu (%#zx)\", alignment, sz, sz);\n\t\t\t\trsz = sallocx(ps[i], 0);\n\t\t\t\texpect_zu_ge(rsz, sz,\n\t\t\t\t \"Real size smaller than expected for \"\n\t\t\t\t \"alignment=%zu, size=%zu\", alignment, sz);\n\t\t\t\texpect_zu_eq(nsz, rsz,\n\t\t\t\t \"nallocx()/sallocx() size mismatch for \"\n\t\t\t\t \"alignment=%zu, size=%zu\", alignment, sz);\n\t\t\t\texpect_ptr_null(\n\t\t\t\t (void *)((uintptr_t)ps[i] & (alignment-1)),\n\t\t\t\t \"%p inadequately aligned for\"\n\t\t\t\t \" alignment=%zu, size=%zu\", ps[i],\n\t\t\t\t alignment, sz);\n\t\t\t\ttotal += rsz;\n\t\t\t\tif (total >= (MAXALIGN << 1)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tif (ps[i] != NULL) {\n\t\t\t\t\tdallocx(ps[i], 0);\n\t\t\t\t\tps[i] = NULL;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpurge();\n\t}\n#undef MAXALIGN\n#undef NITER\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_overflow,\n\t test_oom,\n\t test_remote_free,\n\t test_basic,\n\t test_alignment_and_size);\n}\n" }, { "path": "deps/jemalloc/test/integration/mallocx.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"junk:false\"\nfi\n" }, { "path": "deps/jemalloc/test/integration/overflow.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * GCC \"-Walloc-size-larger-than\" warning detects when one of the memory\n * allocation functions is called with a size larger than the maximum size that\n * they support. Here we want to explicitly test that the allocation functions\n * do indeed fail properly when this is the case, which triggers the warning.\n * Therefore we disable the warning for these tests.\n */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n\nTEST_BEGIN(test_overflow) {\n\tunsigned nlextents;\n\tsize_t mib[4];\n\tsize_t sz, miblen, max_size_class;\n\tvoid *p;\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.nlextents\", (void *)&nlextents, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() error\");\n\n\tmiblen = sizeof(mib) / sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arenas.lextent.0.size\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() error\");\n\tmib[2] = nlextents - 1;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,\n\t NULL, 0), 0, \"Unexpected mallctlbymib() error\");\n\n\texpect_ptr_null(malloc(max_size_class + 1),\n\t \"Expected OOM due to over-sized allocation request\");\n\texpect_ptr_null(malloc(SIZE_T_MAX),\n\t \"Expected OOM due to over-sized allocation request\");\n\n\texpect_ptr_null(calloc(1, max_size_class + 1),\n\t \"Expected OOM due to over-sized allocation request\");\n\texpect_ptr_null(calloc(1, SIZE_T_MAX),\n\t \"Expected OOM due to over-sized allocation request\");\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected malloc() OOM\");\n\texpect_ptr_null(realloc(p, max_size_class + 1),\n\t \"Expected OOM due to over-sized allocation request\");\n\texpect_ptr_null(realloc(p, SIZE_T_MAX),\n\t \"Expected OOM due to over-sized allocation request\");\n\tfree(p);\n}\nTEST_END\n\n/* Re-enable the \"-Walloc-size-larger-than=\" warning */\nJEMALLOC_DIAGNOSTIC_POP\n\nint\nmain(void) {\n\treturn test(\n\t test_overflow);\n}\n" }, { "path": "deps/jemalloc/test/integration/posix_memalign.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define MAXALIGN (((size_t)1) << 23)\n\n/*\n * On systems which can't merge extents, tests that call this function generate\n * a lot of dirty memory very quickly. Purging between cycles mitigates\n * potential OOM on e.g. 32-bit Windows.\n */\nstatic void\npurge(void) {\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl error\");\n}\n\nTEST_BEGIN(test_alignment_errors) {\n\tsize_t alignment;\n\tvoid *p;\n\n\tfor (alignment = 0; alignment < sizeof(void *); alignment++) {\n\t\texpect_d_eq(posix_memalign(&p, alignment, 1), EINVAL,\n\t\t \"Expected error for invalid alignment %zu\",\n\t\t alignment);\n\t}\n\n\tfor (alignment = sizeof(size_t); alignment < MAXALIGN;\n\t alignment <<= 1) {\n\t\texpect_d_ne(posix_memalign(&p, alignment + 1, 1), 0,\n\t\t \"Expected error for invalid alignment %zu\",\n\t\t alignment + 1);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_oom_errors) {\n\tsize_t alignment, size;\n\tvoid *p;\n\n#if LG_SIZEOF_PTR == 3\n\talignment = UINT64_C(0x8000000000000000);\n\tsize = UINT64_C(0x8000000000000000);\n#else\n\talignment = 0x80000000LU;\n\tsize = 0x80000000LU;\n#endif\n\texpect_d_ne(posix_memalign(&p, alignment, size), 0,\n\t \"Expected error for posix_memalign(&p, %zu, %zu)\",\n\t alignment, size);\n\n#if LG_SIZEOF_PTR == 3\n\talignment = UINT64_C(0x4000000000000000);\n\tsize = UINT64_C(0xc000000000000001);\n#else\n\talignment = 0x40000000LU;\n\tsize = 0xc0000001LU;\n#endif\n\texpect_d_ne(posix_memalign(&p, alignment, size), 0,\n\t \"Expected error for posix_memalign(&p, %zu, %zu)\",\n\t alignment, size);\n\n\talignment = 0x10LU;\n#if LG_SIZEOF_PTR == 3\n\tsize = UINT64_C(0xfffffffffffffff0);\n#else\n\tsize = 0xfffffff0LU;\n#endif\n\texpect_d_ne(posix_memalign(&p, alignment, size), 0,\n\t \"Expected error for posix_memalign(&p, %zu, %zu)\",\n\t alignment, size);\n}\nTEST_END\n\nTEST_BEGIN(test_alignment_and_size) {\n#define NITER 4\n\tsize_t alignment, size, total;\n\tunsigned i;\n\tint err;\n\tvoid *ps[NITER];\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tps[i] = NULL;\n\t}\n\n\tfor (alignment = 8;\n\t alignment <= MAXALIGN;\n\t alignment <<= 1) {\n\t\ttotal = 0;\n\t\tfor (size = 0;\n\t\t size < 3 * alignment && size < (1U << 31);\n\t\t size += ((size == 0) ? 1 :\n\t\t (alignment >> (LG_SIZEOF_PTR-1)) - 1)) {\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\terr = posix_memalign(&ps[i],\n\t\t\t\t alignment, size);\n\t\t\t\tif (err) {\n\t\t\t\t\tchar buf[BUFERROR_BUF];\n\n\t\t\t\t\tbuferror(get_errno(), buf, sizeof(buf));\n\t\t\t\t\ttest_fail(\n\t\t\t\t\t \"Error for alignment=%zu, \"\n\t\t\t\t\t \"size=%zu (%#zx): %s\",\n\t\t\t\t\t alignment, size, size, buf);\n\t\t\t\t}\n\t\t\t\ttotal += TEST_MALLOC_SIZE(ps[i]);\n\t\t\t\tif (total >= (MAXALIGN << 1)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tif (ps[i] != NULL) {\n\t\t\t\t\tfree(ps[i]);\n\t\t\t\t\tps[i] = NULL;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpurge();\n\t}\n#undef NITER\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_alignment_errors,\n\t test_oom_errors,\n\t test_alignment_and_size);\n}\n" }, { "path": "deps/jemalloc/test/integration/rallocx.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic unsigned\nget_nsizes_impl(const char *cmd) {\n\tunsigned ret;\n\tsize_t z;\n\n\tz = sizeof(unsigned);\n\texpect_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,\n\t \"Unexpected mallctl(\\\"%s\\\", ...) failure\", cmd);\n\n\treturn ret;\n}\n\nstatic unsigned\nget_nlarge(void) {\n\treturn get_nsizes_impl(\"arenas.nlextents\");\n}\n\nstatic size_t\nget_size_impl(const char *cmd, size_t ind) {\n\tsize_t ret;\n\tsize_t z;\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\", %zu], ...) failure\", cmd, ind);\n\n\treturn ret;\n}\n\nstatic size_t\nget_large_size(size_t ind) {\n\treturn get_size_impl(\"arenas.lextent.0.size\", ind);\n}\n\nTEST_BEGIN(test_grow_and_shrink) {\n\t/*\n\t * Use volatile to workaround buffer overflow false positives\n\t * (-D_FORTIFY_SOURCE=3).\n\t */\n\tvoid *volatile p, *volatile q;\n\tsize_t tsz;\n#define NCYCLES 3\n\tunsigned i, j;\n#define NSZS 1024\n\tsize_t szs[NSZS];\n#define MAXSZ ZU(12 * 1024 * 1024)\n\n\tp = mallocx(1, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tszs[0] = sallocx(p, 0);\n\n\tfor (i = 0; i < NCYCLES; i++) {\n\t\tfor (j = 1; j < NSZS && szs[j-1] < MAXSZ; j++) {\n\t\t\tq = rallocx(p, szs[j-1]+1, 0);\n\t\t\texpect_ptr_not_null(q,\n\t\t\t \"Unexpected rallocx() error for size=%zu-->%zu\",\n\t\t\t szs[j-1], szs[j-1]+1);\n\t\t\tszs[j] = sallocx(q, 0);\n\t\t\texpect_zu_ne(szs[j], szs[j-1]+1,\n\t\t\t \"Expected size to be at least: %zu\", szs[j-1]+1);\n\t\t\tp = q;\n\t\t}\n\n\t\tfor (j--; j > 0; j--) {\n\t\t\tq = rallocx(p, szs[j-1], 0);\n\t\t\texpect_ptr_not_null(q,\n\t\t\t \"Unexpected rallocx() error for size=%zu-->%zu\",\n\t\t\t szs[j], szs[j-1]);\n\t\t\ttsz = sallocx(q, 0);\n\t\t\texpect_zu_eq(tsz, szs[j-1],\n\t\t\t \"Expected size=%zu, got size=%zu\", szs[j-1], tsz);\n\t\t\tp = q;\n\t\t}\n\t}\n\n\tdallocx(p, 0);\n#undef MAXSZ\n#undef NSZS\n#undef NCYCLES\n}\nTEST_END\n\nstatic bool\nvalidate_fill(void *p, uint8_t c, size_t offset, size_t len) {\n\tbool ret = false;\n\t/*\n\t * Use volatile to workaround buffer overflow false positives\n\t * (-D_FORTIFY_SOURCE=3).\n\t */\n\tuint8_t *volatile buf = (uint8_t *)p;\n\tsize_t i;\n\n\tfor (i = 0; i < len; i++) {\n\t\tuint8_t b = buf[offset+i];\n\t\tif (b != c) {\n\t\t\ttest_fail(\"Allocation at %p (len=%zu) contains %#x \"\n\t\t\t \"rather than %#x at offset %zu\", p, len, b, c,\n\t\t\t offset+i);\n\t\t\tret = true;\n\t\t}\n\t}\n\n\treturn ret;\n}\n\nTEST_BEGIN(test_zero) {\n\t/*\n\t * Use volatile to workaround buffer overflow false positives\n\t * (-D_FORTIFY_SOURCE=3).\n\t */\n\tvoid *volatile p, *volatile q;\n\tsize_t psz, qsz, i, j;\n\tsize_t start_sizes[] = {1, 3*1024, 63*1024, 4095*1024};\n#define FILL_BYTE 0xaaU\n#define RANGE 2048\n\n\tfor (i = 0; i < sizeof(start_sizes)/sizeof(size_t); i++) {\n\t\tsize_t start_size = start_sizes[i];\n\t\tp = mallocx(start_size, MALLOCX_ZERO);\n\t\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\t\tpsz = sallocx(p, 0);\n\n\t\texpect_false(validate_fill(p, 0, 0, psz),\n\t\t \"Expected zeroed memory\");\n\t\tmemset(p, FILL_BYTE, psz);\n\t\texpect_false(validate_fill(p, FILL_BYTE, 0, psz),\n\t\t \"Expected filled memory\");\n\n\t\tfor (j = 1; j < RANGE; j++) {\n\t\t\tq = rallocx(p, start_size+j, MALLOCX_ZERO);\n\t\t\texpect_ptr_not_null(q, \"Unexpected rallocx() error\");\n\t\t\tqsz = sallocx(q, 0);\n\t\t\tif (q != p || qsz != psz) {\n\t\t\t\texpect_false(validate_fill(q, FILL_BYTE, 0,\n\t\t\t\t psz), \"Expected filled memory\");\n\t\t\t\texpect_false(validate_fill(q, 0, psz, qsz-psz),\n\t\t\t\t \"Expected zeroed memory\");\n\t\t\t}\n\t\t\tif (psz != qsz) {\n\t\t\t\tmemset((void *)((uintptr_t)q+psz), FILL_BYTE,\n\t\t\t\t qsz-psz);\n\t\t\t\tpsz = qsz;\n\t\t\t}\n\t\t\tp = q;\n\t\t}\n\t\texpect_false(validate_fill(p, FILL_BYTE, 0, psz),\n\t\t \"Expected filled memory\");\n\t\tdallocx(p, 0);\n\t}\n#undef FILL_BYTE\n}\nTEST_END\n\nTEST_BEGIN(test_align) {\n\tvoid *p, *q;\n\tsize_t align;\n#define MAX_ALIGN (ZU(1) << 25)\n\n\talign = ZU(1);\n\tp = mallocx(1, MALLOCX_ALIGN(align));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\tfor (align <<= 1; align <= MAX_ALIGN; align <<= 1) {\n\t\tq = rallocx(p, 1, MALLOCX_ALIGN(align));\n\t\texpect_ptr_not_null(q,\n\t\t \"Unexpected rallocx() error for align=%zu\", align);\n\t\texpect_ptr_null(\n\t\t (void *)((uintptr_t)q & (align-1)),\n\t\t \"%p inadequately aligned for align=%zu\",\n\t\t q, align);\n\t\tp = q;\n\t}\n\tdallocx(p, 0);\n#undef MAX_ALIGN\n}\nTEST_END\n\nTEST_BEGIN(test_align_enum) {\n/* Span both small sizes and large sizes. */\n#define LG_MIN 12\n#define LG_MAX 15\n\tfor (size_t lg_align = LG_MIN; lg_align <= LG_MAX; ++lg_align) {\n\t\tfor (size_t lg_size = LG_MIN; lg_size <= LG_MAX; ++lg_size) {\n\t\t\tsize_t size = 1 << lg_size;\n\t\t\tfor (size_t lg_align_next = LG_MIN;\n\t\t\t lg_align_next <= LG_MAX; ++lg_align_next) {\n\t\t\t\tint flags = MALLOCX_LG_ALIGN(lg_align);\n\t\t\t\tvoid *p = mallocx(1, flags);\n\t\t\t\tassert_ptr_not_null(p,\n\t\t\t\t \"Unexpected mallocx() error\");\n\t\t\t\tassert_zu_eq(nallocx(1, flags),\n\t\t\t\t TEST_MALLOC_SIZE(p),\n\t\t\t\t \"Wrong mallocx() usable size\");\n\t\t\t\tint flags_next =\n\t\t\t\t MALLOCX_LG_ALIGN(lg_align_next);\n\t\t\t\tp = rallocx(p, size, flags_next);\n\t\t\t\tassert_ptr_not_null(p,\n\t\t\t\t \"Unexpected rallocx() error\");\n\t\t\t\texpect_zu_eq(nallocx(size, flags_next),\n\t\t\t\t TEST_MALLOC_SIZE(p),\n\t\t\t\t \"Wrong rallocx() usable size\");\n\t\t\t\tfree(p);\n\t\t\t}\n\t\t}\n\t}\n#undef LG_MAX\n#undef LG_MIN\n}\nTEST_END\n\nTEST_BEGIN(test_lg_align_and_zero) {\n\t/*\n\t * Use volatile to workaround buffer overflow false positives\n\t * (-D_FORTIFY_SOURCE=3).\n\t */\n\tvoid *volatile p, *volatile q;\n\tunsigned lg_align;\n\tsize_t sz;\n#define MAX_LG_ALIGN 25\n#define MAX_VALIDATE (ZU(1) << 22)\n\n\tlg_align = 0;\n\tp = mallocx(1, MALLOCX_LG_ALIGN(lg_align)|MALLOCX_ZERO);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\tfor (lg_align++; lg_align <= MAX_LG_ALIGN; lg_align++) {\n\t\tq = rallocx(p, 1, MALLOCX_LG_ALIGN(lg_align)|MALLOCX_ZERO);\n\t\texpect_ptr_not_null(q,\n\t\t \"Unexpected rallocx() error for lg_align=%u\", lg_align);\n\t\texpect_ptr_null(\n\t\t (void *)((uintptr_t)q & ((ZU(1) << lg_align)-1)),\n\t\t \"%p inadequately aligned for lg_align=%u\", q, lg_align);\n\t\tsz = sallocx(q, 0);\n\t\tif ((sz << 1) <= MAX_VALIDATE) {\n\t\t\texpect_false(validate_fill(q, 0, 0, sz),\n\t\t\t \"Expected zeroed memory\");\n\t\t} else {\n\t\t\texpect_false(validate_fill(q, 0, 0, MAX_VALIDATE),\n\t\t\t \"Expected zeroed memory\");\n\t\t\texpect_false(validate_fill(\n\t\t\t (void *)((uintptr_t)q+sz-MAX_VALIDATE),\n\t\t\t 0, 0, MAX_VALIDATE), \"Expected zeroed memory\");\n\t\t}\n\t\tp = q;\n\t}\n\tdallocx(p, 0);\n#undef MAX_VALIDATE\n#undef MAX_LG_ALIGN\n}\nTEST_END\n\n/*\n * GCC \"-Walloc-size-larger-than\" warning detects when one of the memory\n * allocation functions is called with a size larger than the maximum size that\n * they support. Here we want to explicitly test that the allocation functions\n * do indeed fail properly when this is the case, which triggers the warning.\n * Therefore we disable the warning for these tests.\n */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n\nTEST_BEGIN(test_overflow) {\n\tsize_t largemax;\n\tvoid *p;\n\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\tp = mallocx(1, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\texpect_ptr_null(rallocx(p, largemax+1, 0),\n\t \"Expected OOM for rallocx(p, size=%#zx, 0)\", largemax+1);\n\n\texpect_ptr_null(rallocx(p, ZU(PTRDIFF_MAX)+1, 0),\n\t \"Expected OOM for rallocx(p, size=%#zx, 0)\", ZU(PTRDIFF_MAX)+1);\n\n\texpect_ptr_null(rallocx(p, SIZE_T_MAX, 0),\n\t \"Expected OOM for rallocx(p, size=%#zx, 0)\", SIZE_T_MAX);\n\n\texpect_ptr_null(rallocx(p, 1, MALLOCX_ALIGN(ZU(PTRDIFF_MAX)+1)),\n\t \"Expected OOM for rallocx(p, size=1, MALLOCX_ALIGN(%#zx))\",\n\t ZU(PTRDIFF_MAX)+1);\n\n\tdallocx(p, 0);\n}\nTEST_END\n\n/* Re-enable the \"-Walloc-size-larger-than=\" warning */\nJEMALLOC_DIAGNOSTIC_POP\n\nint\nmain(void) {\n\treturn test(\n\t test_grow_and_shrink,\n\t test_zero,\n\t test_align,\n\t test_align_enum,\n\t test_lg_align_and_zero,\n\t test_overflow);\n}\n" }, { "path": "deps/jemalloc/test/integration/sdallocx.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define MAXALIGN (((size_t)1) << 22)\n#define NITER 3\n\nTEST_BEGIN(test_basic) {\n\tvoid *ptr = mallocx(64, 0);\n\tsdallocx(ptr, 64, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_alignment_and_size) {\n\tsize_t nsz, sz, alignment, total;\n\tunsigned i;\n\tvoid *ps[NITER];\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tps[i] = NULL;\n\t}\n\n\tfor (alignment = 8;\n\t alignment <= MAXALIGN;\n\t alignment <<= 1) {\n\t\ttotal = 0;\n\t\tfor (sz = 1;\n\t\t sz < 3 * alignment && sz < (1U << 31);\n\t\t sz += (alignment >> (LG_SIZEOF_PTR-1)) - 1) {\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tnsz = nallocx(sz, MALLOCX_ALIGN(alignment) |\n\t\t\t\t MALLOCX_ZERO);\n\t\t\t\tps[i] = mallocx(sz, MALLOCX_ALIGN(alignment) |\n\t\t\t\t MALLOCX_ZERO);\n\t\t\t\ttotal += nsz;\n\t\t\t\tif (total >= (MAXALIGN << 1)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tif (ps[i] != NULL) {\n\t\t\t\t\tsdallocx(ps[i], sz,\n\t\t\t\t\t MALLOCX_ALIGN(alignment));\n\t\t\t\t\tps[i] = NULL;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_basic,\n\t test_alignment_and_size);\n}\n" }, { "path": "deps/jemalloc/test/integration/slab_sizes.c", "content": "#include \"test/jemalloc_test.h\"\n\n/* Note that this test relies on the unusual slab sizes set in slab_sizes.sh. */\n\nTEST_BEGIN(test_slab_sizes) {\n\tunsigned nbins;\n\tsize_t page;\n\tsize_t sizemib[4];\n\tsize_t slabmib[4];\n\tsize_t len;\n\n\tlen = sizeof(nbins);\n\texpect_d_eq(mallctl(\"arenas.nbins\", &nbins, &len, NULL, 0), 0,\n\t \"nbins mallctl failure\");\n\n\tlen = sizeof(page);\n\texpect_d_eq(mallctl(\"arenas.page\", &page, &len, NULL, 0), 0,\n\t \"page mallctl failure\");\n\n\tlen = 4;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.size\", sizemib, &len), 0,\n\t \"bin size mallctlnametomib failure\");\n\n\tlen = 4;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.slab_size\", slabmib, &len),\n\t 0, \"slab size mallctlnametomib failure\");\n\n\tsize_t biggest_slab_seen = 0;\n\n\tfor (unsigned i = 0; i < nbins; i++) {\n\t\tsize_t bin_size;\n\t\tsize_t slab_size;\n\t\tlen = sizeof(size_t);\n\t\tsizemib[2] = i;\n\t\tslabmib[2] = i;\n\t\texpect_d_eq(mallctlbymib(sizemib, 4, (void *)&bin_size, &len,\n\t\t NULL, 0), 0, \"bin size mallctlbymib failure\");\n\n\t\tlen = sizeof(size_t);\n\t\texpect_d_eq(mallctlbymib(slabmib, 4, (void *)&slab_size, &len,\n\t\t NULL, 0), 0, \"slab size mallctlbymib failure\");\n\n\t\tif (bin_size < 100) {\n\t\t\t/*\n\t\t\t * Then we should be as close to 17 as possible. Since\n\t\t\t * not all page sizes are valid (because of bitmap\n\t\t\t * limitations on the number of items in a slab), we\n\t\t\t * should at least make sure that the number of pages\n\t\t\t * goes up.\n\t\t\t */\n\t\t\texpect_zu_ge(slab_size, biggest_slab_seen,\n\t\t\t \"Slab sizes should go up\");\n\t\t\tbiggest_slab_seen = slab_size;\n\t\t} else if (\n\t\t (100 <= bin_size && bin_size < 128)\n\t\t || (128 < bin_size && bin_size <= 200)) {\n\t\t\texpect_zu_eq(slab_size, page,\n\t\t\t \"Forced-small slabs should be small\");\n\t\t} else if (bin_size == 128) {\n\t\t\texpect_zu_eq(slab_size, 2 * page,\n\t\t\t \"Forced-2-page slab should be 2 pages\");\n\t\t} else if (200 < bin_size && bin_size <= 4096) {\n\t\t\texpect_zu_ge(slab_size, biggest_slab_seen,\n\t\t\t \"Slab sizes should go up\");\n\t\t\tbiggest_slab_seen = slab_size;\n\t\t}\n\t}\n\t/*\n\t * For any reasonable configuration, 17 pages should be a valid slab\n\t * size for 4096-byte items.\n\t */\n\texpect_zu_eq(biggest_slab_seen, 17 * page, \"Didn't hit page target\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_slab_sizes);\n}\n" }, { "path": "deps/jemalloc/test/integration/slab_sizes.sh", "content": "#!/bin/sh\n\n# Some screwy-looking slab sizes.\nexport MALLOC_CONF=\"slab_sizes:1-4096:17|100-200:1|128-128:2\"\n" }, { "path": "deps/jemalloc/test/integration/smallocx.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"jemalloc/jemalloc_macros.h\"\n\n#define STR_HELPER(x) #x\n#define STR(x) STR_HELPER(x)\n\n#ifndef JEMALLOC_VERSION_GID_IDENT\n #error \"JEMALLOC_VERSION_GID_IDENT not defined\"\n#endif\n\n#define JOIN(x, y) x ## y\n#define JOIN2(x, y) JOIN(x, y)\n#define smallocx JOIN2(smallocx_, JEMALLOC_VERSION_GID_IDENT)\n\ntypedef struct {\n\tvoid *ptr;\n\tsize_t size;\n} smallocx_return_t;\n\nextern smallocx_return_t\nsmallocx(size_t size, int flags);\n\nstatic unsigned\nget_nsizes_impl(const char *cmd) {\n\tunsigned ret;\n\tsize_t z;\n\n\tz = sizeof(unsigned);\n\texpect_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,\n\t \"Unexpected mallctl(\\\"%s\\\", ...) failure\", cmd);\n\n\treturn ret;\n}\n\nstatic unsigned\nget_nlarge(void) {\n\treturn get_nsizes_impl(\"arenas.nlextents\");\n}\n\nstatic size_t\nget_size_impl(const char *cmd, size_t ind) {\n\tsize_t ret;\n\tsize_t z;\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\", %zu], ...) failure\", cmd, ind);\n\n\treturn ret;\n}\n\nstatic size_t\nget_large_size(size_t ind) {\n\treturn get_size_impl(\"arenas.lextent.0.size\", ind);\n}\n\n/*\n * On systems which can't merge extents, tests that call this function generate\n * a lot of dirty memory very quickly. Purging between cycles mitigates\n * potential OOM on e.g. 32-bit Windows.\n */\nstatic void\npurge(void) {\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl error\");\n}\n\n/*\n * GCC \"-Walloc-size-larger-than\" warning detects when one of the memory\n * allocation functions is called with a size larger than the maximum size that\n * they support. Here we want to explicitly test that the allocation functions\n * do indeed fail properly when this is the case, which triggers the warning.\n * Therefore we disable the warning for these tests.\n */\nJEMALLOC_DIAGNOSTIC_PUSH\nJEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN\n\nTEST_BEGIN(test_overflow) {\n\tsize_t largemax;\n\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\texpect_ptr_null(smallocx(largemax+1, 0).ptr,\n\t \"Expected OOM for smallocx(size=%#zx, 0)\", largemax+1);\n\n\texpect_ptr_null(smallocx(ZU(PTRDIFF_MAX)+1, 0).ptr,\n\t \"Expected OOM for smallocx(size=%#zx, 0)\", ZU(PTRDIFF_MAX)+1);\n\n\texpect_ptr_null(smallocx(SIZE_T_MAX, 0).ptr,\n\t \"Expected OOM for smallocx(size=%#zx, 0)\", SIZE_T_MAX);\n\n\texpect_ptr_null(smallocx(1, MALLOCX_ALIGN(ZU(PTRDIFF_MAX)+1)).ptr,\n\t \"Expected OOM for smallocx(size=1, MALLOCX_ALIGN(%#zx))\",\n\t ZU(PTRDIFF_MAX)+1);\n}\nTEST_END\n\nstatic void *\nremote_alloc(void *arg) {\n\tunsigned arena;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\tsize_t large_sz;\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large_sz, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\n\tsmallocx_return_t r\n\t = smallocx(large_sz, MALLOCX_ARENA(arena) | MALLOCX_TCACHE_NONE);\n\tvoid *ptr = r.ptr;\n\texpect_zu_eq(r.size,\n\t nallocx(large_sz, MALLOCX_ARENA(arena) | MALLOCX_TCACHE_NONE),\n\t \"Expected smalloc(size,flags).size == nallocx(size,flags)\");\n\tvoid **ret = (void **)arg;\n\t*ret = ptr;\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_remote_free) {\n\tthd_t thd;\n\tvoid *ret;\n\tthd_create(&thd, remote_alloc, (void *)&ret);\n\tthd_join(thd, NULL);\n\texpect_ptr_not_null(ret, \"Unexpected smallocx failure\");\n\n\t/* Avoid TCACHE_NONE to explicitly test tcache_flush(). */\n\tdallocx(ret, 0);\n\tmallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_oom) {\n\tsize_t largemax;\n\tbool oom;\n\tvoid *ptrs[3];\n\tunsigned i;\n\n\t/*\n\t * It should be impossible to allocate three objects that each consume\n\t * nearly half the virtual address space.\n\t */\n\tlargemax = get_large_size(get_nlarge()-1);\n\toom = false;\n\tfor (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {\n\t\tptrs[i] = smallocx(largemax, 0).ptr;\n\t\tif (ptrs[i] == NULL) {\n\t\t\toom = true;\n\t\t}\n\t}\n\texpect_true(oom,\n\t \"Expected OOM during series of calls to smallocx(size=%zu, 0)\",\n\t largemax);\n\tfor (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {\n\t\tif (ptrs[i] != NULL) {\n\t\t\tdallocx(ptrs[i], 0);\n\t\t}\n\t}\n\tpurge();\n\n#if LG_SIZEOF_PTR == 3\n\texpect_ptr_null(smallocx(0x8000000000000000ULL,\n\t MALLOCX_ALIGN(0x8000000000000000ULL)).ptr,\n\t \"Expected OOM for smallocx()\");\n\texpect_ptr_null(smallocx(0x8000000000000000ULL,\n\t MALLOCX_ALIGN(0x80000000)).ptr,\n\t \"Expected OOM for smallocx()\");\n#else\n\texpect_ptr_null(smallocx(0x80000000UL, MALLOCX_ALIGN(0x80000000UL)).ptr,\n\t \"Expected OOM for smallocx()\");\n#endif\n}\nTEST_END\n\n/* Re-enable the \"-Walloc-size-larger-than=\" warning */\nJEMALLOC_DIAGNOSTIC_POP\n\nTEST_BEGIN(test_basic) {\n#define MAXSZ (((size_t)1) << 23)\n\tsize_t sz;\n\n\tfor (sz = 1; sz < MAXSZ; sz = nallocx(sz, 0) + 1) {\n\t\tsmallocx_return_t ret;\n\t\tsize_t nsz, rsz, smz;\n\t\tvoid *p;\n\t\tnsz = nallocx(sz, 0);\n\t\texpect_zu_ne(nsz, 0, \"Unexpected nallocx() error\");\n\t\tret = smallocx(sz, 0);\n\t\tp = ret.ptr;\n\t\tsmz = ret.size;\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected smallocx(size=%zx, flags=0) error\", sz);\n\t\trsz = sallocx(p, 0);\n\t\texpect_zu_ge(rsz, sz, \"Real size smaller than expected\");\n\t\texpect_zu_eq(nsz, rsz, \"nallocx()/sallocx() size mismatch\");\n\t\texpect_zu_eq(nsz, smz, \"nallocx()/smallocx() size mismatch\");\n\t\tdallocx(p, 0);\n\n\t\tret = smallocx(sz, 0);\n\t\tp = ret.ptr;\n\t\tsmz = ret.size;\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected smallocx(size=%zx, flags=0) error\", sz);\n\t\tdallocx(p, 0);\n\n\t\tnsz = nallocx(sz, MALLOCX_ZERO);\n\t\texpect_zu_ne(nsz, 0, \"Unexpected nallocx() error\");\n\t\texpect_zu_ne(smz, 0, \"Unexpected smallocx() error\");\n\t\tret = smallocx(sz, MALLOCX_ZERO);\n\t\tp = ret.ptr;\n\t\texpect_ptr_not_null(p,\n\t\t \"Unexpected smallocx(size=%zx, flags=MALLOCX_ZERO) error\",\n\t\t nsz);\n\t\trsz = sallocx(p, 0);\n\t\texpect_zu_eq(nsz, rsz, \"nallocx()/sallocx() rsize mismatch\");\n\t\texpect_zu_eq(nsz, smz, \"nallocx()/smallocx() size mismatch\");\n\t\tdallocx(p, 0);\n\t\tpurge();\n\t}\n#undef MAXSZ\n}\nTEST_END\n\nTEST_BEGIN(test_alignment_and_size) {\n\tconst char *percpu_arena;\n\tsize_t sz = sizeof(percpu_arena);\n\n\tif(mallctl(\"opt.percpu_arena\", (void *)&percpu_arena, &sz, NULL, 0) ||\n\t strcmp(percpu_arena, \"disabled\") != 0) {\n\t\ttest_skip(\"test_alignment_and_size skipped: \"\n\t\t \"not working with percpu arena.\");\n\t};\n#define MAXALIGN (((size_t)1) << 23)\n#define NITER 4\n\tsize_t nsz, rsz, smz, alignment, total;\n\tunsigned i;\n\tvoid *ps[NITER];\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tps[i] = NULL;\n\t}\n\n\tfor (alignment = 8;\n\t alignment <= MAXALIGN;\n\t alignment <<= 1) {\n\t\ttotal = 0;\n\t\tfor (sz = 1;\n\t\t sz < 3 * alignment && sz < (1U << 31);\n\t\t sz += (alignment >> (LG_SIZEOF_PTR-1)) - 1) {\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tnsz = nallocx(sz, MALLOCX_ALIGN(alignment) |\n\t\t\t\t MALLOCX_ZERO);\n\t\t\t\texpect_zu_ne(nsz, 0,\n\t\t\t\t \"nallocx() error for alignment=%zu, \"\n\t\t\t\t \"size=%zu (%#zx)\", alignment, sz, sz);\n\t\t\t\tsmallocx_return_t ret\n\t\t\t\t = smallocx(sz, MALLOCX_ALIGN(alignment) | MALLOCX_ZERO);\n\t\t\t\tps[i] = ret.ptr;\n\t\t\t\texpect_ptr_not_null(ps[i],\n\t\t\t\t \"smallocx() error for alignment=%zu, \"\n\t\t\t\t \"size=%zu (%#zx)\", alignment, sz, sz);\n\t\t\t\trsz = sallocx(ps[i], 0);\n\t\t\t\tsmz = ret.size;\n\t\t\t\texpect_zu_ge(rsz, sz,\n\t\t\t\t \"Real size smaller than expected for \"\n\t\t\t\t \"alignment=%zu, size=%zu\", alignment, sz);\n\t\t\t\texpect_zu_eq(nsz, rsz,\n\t\t\t\t \"nallocx()/sallocx() size mismatch for \"\n\t\t\t\t \"alignment=%zu, size=%zu\", alignment, sz);\n\t\t\t\texpect_zu_eq(nsz, smz,\n\t\t\t\t \"nallocx()/smallocx() size mismatch for \"\n\t\t\t\t \"alignment=%zu, size=%zu\", alignment, sz);\n\t\t\t\texpect_ptr_null(\n\t\t\t\t (void *)((uintptr_t)ps[i] & (alignment-1)),\n\t\t\t\t \"%p inadequately aligned for\"\n\t\t\t\t \" alignment=%zu, size=%zu\", ps[i],\n\t\t\t\t alignment, sz);\n\t\t\t\ttotal += rsz;\n\t\t\t\tif (total >= (MAXALIGN << 1)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (i = 0; i < NITER; i++) {\n\t\t\t\tif (ps[i] != NULL) {\n\t\t\t\t\tdallocx(ps[i], 0);\n\t\t\t\t\tps[i] = NULL;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpurge();\n\t}\n#undef MAXALIGN\n#undef NITER\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_overflow,\n\t test_oom,\n\t test_remote_free,\n\t test_basic,\n\t test_alignment_and_size);\n}\n" }, { "path": "deps/jemalloc/test/integration/smallocx.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"junk:false\"\nfi\n" }, { "path": "deps/jemalloc/test/integration/thread_arena.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define NTHREADS 10\n\nvoid *\nthd_start(void *arg) {\n\tunsigned main_arena_ind = *(unsigned *)arg;\n\tvoid *p;\n\tunsigned arena_ind;\n\tsize_t size;\n\tint err;\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Error in malloc()\");\n\tfree(p);\n\n\tsize = sizeof(arena_ind);\n\tif ((err = mallctl(\"thread.arena\", (void *)&arena_ind, &size,\n\t (void *)&main_arena_ind, sizeof(main_arena_ind)))) {\n\t\tchar buf[BUFERROR_BUF];\n\n\t\tbuferror(err, buf, sizeof(buf));\n\t\ttest_fail(\"Error in mallctl(): %s\", buf);\n\t}\n\n\tsize = sizeof(arena_ind);\n\tif ((err = mallctl(\"thread.arena\", (void *)&arena_ind, &size, NULL,\n\t 0))) {\n\t\tchar buf[BUFERROR_BUF];\n\n\t\tbuferror(err, buf, sizeof(buf));\n\t\ttest_fail(\"Error in mallctl(): %s\", buf);\n\t}\n\texpect_u_eq(arena_ind, main_arena_ind,\n\t \"Arena index should be same as for main thread\");\n\n\treturn NULL;\n}\n\nstatic void\nmallctl_failure(int err) {\n\tchar buf[BUFERROR_BUF];\n\n\tbuferror(err, buf, sizeof(buf));\n\ttest_fail(\"Error in mallctl(): %s\", buf);\n}\n\nTEST_BEGIN(test_thread_arena) {\n\tvoid *p;\n\tint err;\n\tthd_t thds[NTHREADS];\n\tunsigned i;\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Error in malloc()\");\n\n\tunsigned arena_ind, old_arena_ind;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Arena creation failure\");\n\n\tsize_t size = sizeof(arena_ind);\n\tif ((err = mallctl(\"thread.arena\", (void *)&old_arena_ind, &size,\n\t (void *)&arena_ind, sizeof(arena_ind))) != 0) {\n\t\tmallctl_failure(err);\n\t}\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_create(&thds[i], thd_start,\n\t\t (void *)&arena_ind);\n\t}\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tintptr_t join_ret;\n\t\tthd_join(thds[i], (void *)&join_ret);\n\t\texpect_zd_eq(join_ret, 0, \"Unexpected thread join error\");\n\t}\n\tfree(p);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_thread_arena);\n}\n" }, { "path": "deps/jemalloc/test/integration/thread_tcache_enabled.c", "content": "#include \"test/jemalloc_test.h\"\n\nvoid *\nthd_start(void *arg) {\n\tbool e0, e1;\n\tsize_t sz = sizeof(bool);\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\n\tif (e0) {\n\t\te1 = false;\n\t\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\t\texpect_true(e0, \"tcache should be enabled\");\n\t}\n\n\te1 = true;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_false(e0, \"tcache should be disabled\");\n\n\te1 = true;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_true(e0, \"tcache should be enabled\");\n\n\te1 = false;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_true(e0, \"tcache should be enabled\");\n\n\te1 = false;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_false(e0, \"tcache should be disabled\");\n\n\tfree(malloc(1));\n\te1 = true;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_false(e0, \"tcache should be disabled\");\n\n\tfree(malloc(1));\n\te1 = true;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_true(e0, \"tcache should be enabled\");\n\n\tfree(malloc(1));\n\te1 = false;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_true(e0, \"tcache should be enabled\");\n\n\tfree(malloc(1));\n\te1 = false;\n\texpect_d_eq(mallctl(\"thread.tcache.enabled\", (void *)&e0, &sz,\n\t (void *)&e1, sz), 0, \"Unexpected mallctl() error\");\n\texpect_false(e0, \"tcache should be disabled\");\n\n\tfree(malloc(1));\n\treturn NULL;\n}\n\nTEST_BEGIN(test_main_thread) {\n\tthd_start(NULL);\n}\nTEST_END\n\nTEST_BEGIN(test_subthread) {\n\tthd_t thd;\n\n\tthd_create(&thd, thd_start, NULL);\n\tthd_join(thd, NULL);\n}\nTEST_END\n\nint\nmain(void) {\n\t/* Run tests multiple times to check for bad interactions. */\n\treturn test(\n\t test_main_thread,\n\t test_subthread,\n\t test_main_thread,\n\t test_subthread,\n\t test_main_thread);\n}\n" }, { "path": "deps/jemalloc/test/integration/xallocx.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * Use a separate arena for xallocx() extension/contraction tests so that\n * internal allocation e.g. by heap profiling can't interpose allocations where\n * xallocx() would ordinarily be able to extend.\n */\nstatic unsigned\narena_ind(void) {\n\tstatic unsigned ind = 0;\n\n\tif (ind == 0) {\n\t\tsize_t sz = sizeof(ind);\n\t\texpect_d_eq(mallctl(\"arenas.create\", (void *)&ind, &sz, NULL,\n\t\t 0), 0, \"Unexpected mallctl failure creating arena\");\n\t}\n\n\treturn ind;\n}\n\nTEST_BEGIN(test_same_size) {\n\tvoid *p;\n\tsize_t sz, tsz;\n\n\tp = mallocx(42, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tsz = sallocx(p, 0);\n\n\ttsz = xallocx(p, sz, 0, 0);\n\texpect_zu_eq(tsz, sz, \"Unexpected size change: %zu --> %zu\", sz, tsz);\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_extra_no_move) {\n\tvoid *p;\n\tsize_t sz, tsz;\n\n\tp = mallocx(42, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tsz = sallocx(p, 0);\n\n\ttsz = xallocx(p, sz, sz-42, 0);\n\texpect_zu_eq(tsz, sz, \"Unexpected size change: %zu --> %zu\", sz, tsz);\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_no_move_fail) {\n\tvoid *p;\n\tsize_t sz, tsz;\n\n\tp = mallocx(42, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\tsz = sallocx(p, 0);\n\n\ttsz = xallocx(p, sz + 5, 0, 0);\n\texpect_zu_eq(tsz, sz, \"Unexpected size change: %zu --> %zu\", sz, tsz);\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nstatic unsigned\nget_nsizes_impl(const char *cmd) {\n\tunsigned ret;\n\tsize_t z;\n\n\tz = sizeof(unsigned);\n\texpect_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,\n\t \"Unexpected mallctl(\\\"%s\\\", ...) failure\", cmd);\n\n\treturn ret;\n}\n\nstatic unsigned\nget_nsmall(void) {\n\treturn get_nsizes_impl(\"arenas.nbins\");\n}\n\nstatic unsigned\nget_nlarge(void) {\n\treturn get_nsizes_impl(\"arenas.nlextents\");\n}\n\nstatic size_t\nget_size_impl(const char *cmd, size_t ind) {\n\tsize_t ret;\n\tsize_t z;\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\", %zu], ...) failure\", cmd, ind);\n\n\treturn ret;\n}\n\nstatic size_t\nget_small_size(size_t ind) {\n\treturn get_size_impl(\"arenas.bin.0.size\", ind);\n}\n\nstatic size_t\nget_large_size(size_t ind) {\n\treturn get_size_impl(\"arenas.lextent.0.size\", ind);\n}\n\nTEST_BEGIN(test_size) {\n\tsize_t small0, largemax;\n\tvoid *p;\n\n\t/* Get size classes. */\n\tsmall0 = get_small_size(0);\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\tp = mallocx(small0, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\t/* Test smallest supported size. */\n\texpect_zu_eq(xallocx(p, 1, 0, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\n\t/* Test largest supported size. */\n\texpect_zu_le(xallocx(p, largemax, 0, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\t/* Test size overflow. */\n\texpect_zu_le(xallocx(p, largemax+1, 0, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, SIZE_T_MAX, 0, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_size_extra_overflow) {\n\tsize_t small0, largemax;\n\tvoid *p;\n\n\t/* Get size classes. */\n\tsmall0 = get_small_size(0);\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\tp = mallocx(small0, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\t/* Test overflows that can be resolved by clamping extra. */\n\texpect_zu_le(xallocx(p, largemax-1, 2, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, largemax, 1, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\t/* Test overflow such that largemax-size underflows. */\n\texpect_zu_le(xallocx(p, largemax+1, 2, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, largemax+2, 3, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, SIZE_T_MAX-2, 2, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, SIZE_T_MAX-1, 1, 0), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_extra_small) {\n\tsize_t small0, small1, largemax;\n\tvoid *p;\n\n\t/* Get size classes. */\n\tsmall0 = get_small_size(0);\n\tsmall1 = get_small_size(1);\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\tp = mallocx(small0, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\texpect_zu_eq(xallocx(p, small1, 0, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\n\texpect_zu_eq(xallocx(p, small1, 0, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\n\texpect_zu_eq(xallocx(p, small0, small1 - small0, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\n\t/* Test size+extra overflow. */\n\texpect_zu_eq(xallocx(p, small0, largemax - small0 + 1, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_eq(xallocx(p, small0, SIZE_T_MAX - small0, 0), small0,\n\t \"Unexpected xallocx() behavior\");\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_extra_large) {\n\tint flags = MALLOCX_ARENA(arena_ind());\n\tsize_t smallmax, large1, large2, large3, largemax;\n\tvoid *p;\n\n\t/* Get size classes. */\n\tsmallmax = get_small_size(get_nsmall()-1);\n\tlarge1 = get_large_size(1);\n\tlarge2 = get_large_size(2);\n\tlarge3 = get_large_size(3);\n\tlargemax = get_large_size(get_nlarge()-1);\n\n\tp = mallocx(large3, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\n\texpect_zu_eq(xallocx(p, large3, 0, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\t/* Test size decrease with zero extra. */\n\texpect_zu_ge(xallocx(p, large1, 0, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_ge(xallocx(p, smallmax, 0, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\n\tif (xallocx(p, large3, 0, flags) != large3) {\n\t\tp = rallocx(p, large3, flags);\n\t\texpect_ptr_not_null(p, \"Unexpected rallocx() failure\");\n\t}\n\t/* Test size decrease with non-zero extra. */\n\texpect_zu_eq(xallocx(p, large1, large3 - large1, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_eq(xallocx(p, large2, large3 - large2, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_ge(xallocx(p, large1, large2 - large1, flags), large2,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_ge(xallocx(p, smallmax, large1 - smallmax, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\n\texpect_zu_ge(xallocx(p, large1, 0, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\t/* Test size increase with zero extra. */\n\texpect_zu_le(xallocx(p, large3, 0, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\texpect_zu_le(xallocx(p, largemax+1, 0, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\n\texpect_zu_ge(xallocx(p, large1, 0, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\t/* Test size increase with non-zero extra. */\n\texpect_zu_le(xallocx(p, large1, SIZE_T_MAX - large1, flags), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\texpect_zu_ge(xallocx(p, large1, 0, flags), large1,\n\t \"Unexpected xallocx() behavior\");\n\t/* Test size increase with non-zero extra. */\n\texpect_zu_le(xallocx(p, large1, large3 - large1, flags), large3,\n\t \"Unexpected xallocx() behavior\");\n\n\tif (xallocx(p, large3, 0, flags) != large3) {\n\t\tp = rallocx(p, large3, flags);\n\t\texpect_ptr_not_null(p, \"Unexpected rallocx() failure\");\n\t}\n\t/* Test size+extra overflow. */\n\texpect_zu_le(xallocx(p, large3, largemax - large3 + 1, flags), largemax,\n\t \"Unexpected xallocx() behavior\");\n\n\tdallocx(p, flags);\n}\nTEST_END\n\nstatic void\nprint_filled_extents(const void *p, uint8_t c, size_t len) {\n\tconst uint8_t *pc = (const uint8_t *)p;\n\tsize_t i, range0;\n\tuint8_t c0;\n\n\tmalloc_printf(\" p=%p, c=%#x, len=%zu:\", p, c, len);\n\trange0 = 0;\n\tc0 = pc[0];\n\tfor (i = 0; i < len; i++) {\n\t\tif (pc[i] != c0) {\n\t\t\tmalloc_printf(\" %#x[%zu..%zu)\", c0, range0, i);\n\t\t\trange0 = i;\n\t\t\tc0 = pc[i];\n\t\t}\n\t}\n\tmalloc_printf(\" %#x[%zu..%zu)\\n\", c0, range0, i);\n}\n\nstatic bool\nvalidate_fill(const void *p, uint8_t c, size_t offset, size_t len) {\n\tconst uint8_t *pc = (const uint8_t *)p;\n\tbool err;\n\tsize_t i;\n\n\tfor (i = offset, err = false; i < offset+len; i++) {\n\t\tif (pc[i] != c) {\n\t\t\terr = true;\n\t\t}\n\t}\n\n\tif (err) {\n\t\tprint_filled_extents(p, c, offset + len);\n\t}\n\n\treturn err;\n}\n\nstatic void\ntest_zero(size_t szmin, size_t szmax) {\n\tint flags = MALLOCX_ARENA(arena_ind()) | MALLOCX_ZERO;\n\tsize_t sz, nsz;\n\tvoid *p;\n#define FILL_BYTE 0x7aU\n\n\tsz = szmax;\n\tp = mallocx(sz, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() error\");\n\texpect_false(validate_fill(p, 0x00, 0, sz), \"Memory not filled: sz=%zu\",\n\t sz);\n\n\t/*\n\t * Fill with non-zero so that non-debug builds are more likely to detect\n\t * errors.\n\t */\n\tmemset(p, FILL_BYTE, sz);\n\texpect_false(validate_fill(p, FILL_BYTE, 0, sz),\n\t \"Memory not filled: sz=%zu\", sz);\n\n\t/* Shrink in place so that we can expect growing in place to succeed. */\n\tsz = szmin;\n\tif (xallocx(p, sz, 0, flags) != sz) {\n\t\tp = rallocx(p, sz, flags);\n\t\texpect_ptr_not_null(p, \"Unexpected rallocx() failure\");\n\t}\n\texpect_false(validate_fill(p, FILL_BYTE, 0, sz),\n\t \"Memory not filled: sz=%zu\", sz);\n\n\tfor (sz = szmin; sz < szmax; sz = nsz) {\n\t\tnsz = nallocx(sz+1, flags);\n\t\tif (xallocx(p, sz+1, 0, flags) != nsz) {\n\t\t\tp = rallocx(p, sz+1, flags);\n\t\t\texpect_ptr_not_null(p, \"Unexpected rallocx() failure\");\n\t\t}\n\t\texpect_false(validate_fill(p, FILL_BYTE, 0, sz),\n\t\t \"Memory not filled: sz=%zu\", sz);\n\t\texpect_false(validate_fill(p, 0x00, sz, nsz-sz),\n\t\t \"Memory not filled: sz=%zu, nsz-sz=%zu\", sz, nsz-sz);\n\t\tmemset((void *)((uintptr_t)p + sz), FILL_BYTE, nsz-sz);\n\t\texpect_false(validate_fill(p, FILL_BYTE, 0, nsz),\n\t\t \"Memory not filled: nsz=%zu\", nsz);\n\t}\n\n\tdallocx(p, flags);\n}\n\nTEST_BEGIN(test_zero_large) {\n\tsize_t large0, large1;\n\n\t/* Get size classes. */\n\tlarge0 = get_large_size(0);\n\tlarge1 = get_large_size(1);\n\n\ttest_zero(large1, large0 * 2);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_same_size,\n\t test_extra_no_move,\n\t test_no_move_fail,\n\t test_size,\n\t test_size_extra_overflow,\n\t test_extra_small,\n\t test_extra_large,\n\t test_zero_large);\n}\n" }, { "path": "deps/jemalloc/test/integration/xallocx.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"junk:false\"\nfi\n" }, { "path": "deps/jemalloc/test/src/SFMT.c", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n/**\n * @file SFMT.c\n * @brief SIMD oriented Fast Mersenne Twister(SFMT)\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * Copyright (C) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * The new BSD License is applied to this software, see LICENSE.txt\n */\n#define SFMT_C_\n#include \"test/jemalloc_test.h\"\n#include \"test/SFMT-params.h\"\n\n#if defined(JEMALLOC_BIG_ENDIAN) && !defined(BIG_ENDIAN64)\n#define BIG_ENDIAN64 1\n#endif\n#if defined(__BIG_ENDIAN__) && !defined(__amd64) && !defined(BIG_ENDIAN64)\n#define BIG_ENDIAN64 1\n#endif\n#if defined(HAVE_ALTIVEC) && !defined(BIG_ENDIAN64)\n#define BIG_ENDIAN64 1\n#endif\n#if defined(ONLY64) && !defined(BIG_ENDIAN64)\n #if defined(__GNUC__)\n #error \"-DONLY64 must be specified with -DBIG_ENDIAN64\"\n #endif\n#undef ONLY64\n#endif\n/*------------------------------------------------------\n 128-bit SIMD data type for Altivec, SSE2 or standard C\n ------------------------------------------------------*/\n#if defined(HAVE_ALTIVEC)\n/** 128-bit data structure */\nunion W128_T {\n vector unsigned int s;\n uint32_t u[4];\n};\n/** 128-bit data type */\ntypedef union W128_T w128_t;\n\n#elif defined(HAVE_SSE2)\n/** 128-bit data structure */\nunion W128_T {\n __m128i si;\n uint32_t u[4];\n};\n/** 128-bit data type */\ntypedef union W128_T w128_t;\n\n#else\n\n/** 128-bit data structure */\nstruct W128_T {\n uint32_t u[4];\n};\n/** 128-bit data type */\ntypedef struct W128_T w128_t;\n\n#endif\n\nstruct sfmt_s {\n /** the 128-bit internal state array */\n w128_t sfmt[N];\n /** index counter to the 32-bit internal state array */\n int idx;\n /** a flag: it is 0 if and only if the internal state is not yet\n * initialized. */\n int initialized;\n};\n\n/*--------------------------------------\n FILE GLOBAL VARIABLES\n internal state, index counter and flag\n --------------------------------------*/\n\n/** a parity check vector which certificate the period of 2^{MEXP} */\nstatic uint32_t parity[4] = {PARITY1, PARITY2, PARITY3, PARITY4};\n\n/*----------------\n STATIC FUNCTIONS\n ----------------*/\nstatic inline int idxof(int i);\n#if (!defined(HAVE_ALTIVEC)) && (!defined(HAVE_SSE2))\nstatic inline void rshift128(w128_t *out, w128_t const *in, int shift);\nstatic inline void lshift128(w128_t *out, w128_t const *in, int shift);\n#endif\nstatic inline void gen_rand_all(sfmt_t *ctx);\nstatic inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size);\nstatic inline uint32_t func1(uint32_t x);\nstatic inline uint32_t func2(uint32_t x);\nstatic void period_certification(sfmt_t *ctx);\n#if defined(BIG_ENDIAN64) && !defined(ONLY64)\nstatic inline void swap(w128_t *array, int size);\n#endif\n\n#if defined(HAVE_ALTIVEC)\n #include \"test/SFMT-alti.h\"\n#elif defined(HAVE_SSE2)\n #include \"test/SFMT-sse2.h\"\n#endif\n\n/**\n * This function simulate a 64-bit index of LITTLE ENDIAN\n * in BIG ENDIAN machine.\n */\n#ifdef ONLY64\nstatic inline int idxof(int i) {\n return i ^ 1;\n}\n#else\nstatic inline int idxof(int i) {\n return i;\n}\n#endif\n/**\n * This function simulates SIMD 128-bit right shift by the standard C.\n * The 128-bit integer given in in is shifted by (shift * 8) bits.\n * This function simulates the LITTLE ENDIAN SIMD.\n * @param out the output of this function\n * @param in the 128-bit data to be shifted\n * @param shift the shift value\n */\n#if (!defined(HAVE_ALTIVEC)) && (!defined(HAVE_SSE2))\n#ifdef ONLY64\nstatic inline void rshift128(w128_t *out, w128_t const *in, int shift) {\n uint64_t th, tl, oh, ol;\n\n th = ((uint64_t)in->u[2] << 32) | ((uint64_t)in->u[3]);\n tl = ((uint64_t)in->u[0] << 32) | ((uint64_t)in->u[1]);\n\n oh = th >> (shift * 8);\n ol = tl >> (shift * 8);\n ol |= th << (64 - shift * 8);\n out->u[0] = (uint32_t)(ol >> 32);\n out->u[1] = (uint32_t)ol;\n out->u[2] = (uint32_t)(oh >> 32);\n out->u[3] = (uint32_t)oh;\n}\n#else\nstatic inline void rshift128(w128_t *out, w128_t const *in, int shift) {\n uint64_t th, tl, oh, ol;\n\n th = ((uint64_t)in->u[3] << 32) | ((uint64_t)in->u[2]);\n tl = ((uint64_t)in->u[1] << 32) | ((uint64_t)in->u[0]);\n\n oh = th >> (shift * 8);\n ol = tl >> (shift * 8);\n ol |= th << (64 - shift * 8);\n out->u[1] = (uint32_t)(ol >> 32);\n out->u[0] = (uint32_t)ol;\n out->u[3] = (uint32_t)(oh >> 32);\n out->u[2] = (uint32_t)oh;\n}\n#endif\n/**\n * This function simulates SIMD 128-bit left shift by the standard C.\n * The 128-bit integer given in in is shifted by (shift * 8) bits.\n * This function simulates the LITTLE ENDIAN SIMD.\n * @param out the output of this function\n * @param in the 128-bit data to be shifted\n * @param shift the shift value\n */\n#ifdef ONLY64\nstatic inline void lshift128(w128_t *out, w128_t const *in, int shift) {\n uint64_t th, tl, oh, ol;\n\n th = ((uint64_t)in->u[2] << 32) | ((uint64_t)in->u[3]);\n tl = ((uint64_t)in->u[0] << 32) | ((uint64_t)in->u[1]);\n\n oh = th << (shift * 8);\n ol = tl << (shift * 8);\n oh |= tl >> (64 - shift * 8);\n out->u[0] = (uint32_t)(ol >> 32);\n out->u[1] = (uint32_t)ol;\n out->u[2] = (uint32_t)(oh >> 32);\n out->u[3] = (uint32_t)oh;\n}\n#else\nstatic inline void lshift128(w128_t *out, w128_t const *in, int shift) {\n uint64_t th, tl, oh, ol;\n\n th = ((uint64_t)in->u[3] << 32) | ((uint64_t)in->u[2]);\n tl = ((uint64_t)in->u[1] << 32) | ((uint64_t)in->u[0]);\n\n oh = th << (shift * 8);\n ol = tl << (shift * 8);\n oh |= tl >> (64 - shift * 8);\n out->u[1] = (uint32_t)(ol >> 32);\n out->u[0] = (uint32_t)ol;\n out->u[3] = (uint32_t)(oh >> 32);\n out->u[2] = (uint32_t)oh;\n}\n#endif\n#endif\n\n/**\n * This function represents the recursion formula.\n * @param r output\n * @param a a 128-bit part of the internal state array\n * @param b a 128-bit part of the internal state array\n * @param c a 128-bit part of the internal state array\n * @param d a 128-bit part of the internal state array\n */\n#if (!defined(HAVE_ALTIVEC)) && (!defined(HAVE_SSE2))\n#ifdef ONLY64\nstatic inline void do_recursion(w128_t *r, w128_t *a, w128_t *b, w128_t *c,\n\t\t\t\tw128_t *d) {\n w128_t x;\n w128_t y;\n\n lshift128(&x, a, SL2);\n rshift128(&y, c, SR2);\n r->u[0] = a->u[0] ^ x.u[0] ^ ((b->u[0] >> SR1) & MSK2) ^ y.u[0]\n\t^ (d->u[0] << SL1);\n r->u[1] = a->u[1] ^ x.u[1] ^ ((b->u[1] >> SR1) & MSK1) ^ y.u[1]\n\t^ (d->u[1] << SL1);\n r->u[2] = a->u[2] ^ x.u[2] ^ ((b->u[2] >> SR1) & MSK4) ^ y.u[2]\n\t^ (d->u[2] << SL1);\n r->u[3] = a->u[3] ^ x.u[3] ^ ((b->u[3] >> SR1) & MSK3) ^ y.u[3]\n\t^ (d->u[3] << SL1);\n}\n#else\nstatic inline void do_recursion(w128_t *r, w128_t *a, w128_t *b, w128_t *c,\n\t\t\t\tw128_t *d) {\n w128_t x;\n w128_t y;\n\n lshift128(&x, a, SL2);\n rshift128(&y, c, SR2);\n r->u[0] = a->u[0] ^ x.u[0] ^ ((b->u[0] >> SR1) & MSK1) ^ y.u[0]\n\t^ (d->u[0] << SL1);\n r->u[1] = a->u[1] ^ x.u[1] ^ ((b->u[1] >> SR1) & MSK2) ^ y.u[1]\n\t^ (d->u[1] << SL1);\n r->u[2] = a->u[2] ^ x.u[2] ^ ((b->u[2] >> SR1) & MSK3) ^ y.u[2]\n\t^ (d->u[2] << SL1);\n r->u[3] = a->u[3] ^ x.u[3] ^ ((b->u[3] >> SR1) & MSK4) ^ y.u[3]\n\t^ (d->u[3] << SL1);\n}\n#endif\n#endif\n\n#if (!defined(HAVE_ALTIVEC)) && (!defined(HAVE_SSE2))\n/**\n * This function fills the internal state array with pseudorandom\n * integers.\n */\nstatic inline void gen_rand_all(sfmt_t *ctx) {\n int i;\n w128_t *r1, *r2;\n\n r1 = &ctx->sfmt[N - 2];\n r2 = &ctx->sfmt[N - 1];\n for (i = 0; i < N - POS1; i++) {\n\tdo_recursion(&ctx->sfmt[i], &ctx->sfmt[i], &ctx->sfmt[i + POS1], r1,\n\t r2);\n\tr1 = r2;\n\tr2 = &ctx->sfmt[i];\n }\n for (; i < N; i++) {\n\tdo_recursion(&ctx->sfmt[i], &ctx->sfmt[i], &ctx->sfmt[i + POS1 - N], r1,\n\t r2);\n\tr1 = r2;\n\tr2 = &ctx->sfmt[i];\n }\n}\n\n/**\n * This function fills the user-specified array with pseudorandom\n * integers.\n *\n * @param array an 128-bit array to be filled by pseudorandom numbers.\n * @param size number of 128-bit pseudorandom numbers to be generated.\n */\nstatic inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {\n int i, j;\n w128_t *r1, *r2;\n\n r1 = &ctx->sfmt[N - 2];\n r2 = &ctx->sfmt[N - 1];\n for (i = 0; i < N - POS1; i++) {\n\tdo_recursion(&array[i], &ctx->sfmt[i], &ctx->sfmt[i + POS1], r1, r2);\n\tr1 = r2;\n\tr2 = &array[i];\n }\n for (; i < N; i++) {\n\tdo_recursion(&array[i], &ctx->sfmt[i], &array[i + POS1 - N], r1, r2);\n\tr1 = r2;\n\tr2 = &array[i];\n }\n for (; i < size - N; i++) {\n\tdo_recursion(&array[i], &array[i - N], &array[i + POS1 - N], r1, r2);\n\tr1 = r2;\n\tr2 = &array[i];\n }\n for (j = 0; j < 2 * N - size; j++) {\n\tctx->sfmt[j] = array[j + size - N];\n }\n for (; i < size; i++, j++) {\n\tdo_recursion(&array[i], &array[i - N], &array[i + POS1 - N], r1, r2);\n\tr1 = r2;\n\tr2 = &array[i];\n\tctx->sfmt[j] = array[i];\n }\n}\n#endif\n\n#if defined(BIG_ENDIAN64) && !defined(ONLY64) && !defined(HAVE_ALTIVEC)\nstatic inline void swap(w128_t *array, int size) {\n int i;\n uint32_t x, y;\n\n for (i = 0; i < size; i++) {\n\tx = array[i].u[0];\n\ty = array[i].u[2];\n\tarray[i].u[0] = array[i].u[1];\n\tarray[i].u[2] = array[i].u[3];\n\tarray[i].u[1] = x;\n\tarray[i].u[3] = y;\n }\n}\n#endif\n/**\n * This function represents a function used in the initialization\n * by init_by_array\n * @param x 32-bit integer\n * @return 32-bit integer\n */\nstatic uint32_t func1(uint32_t x) {\n return (x ^ (x >> 27)) * (uint32_t)1664525UL;\n}\n\n/**\n * This function represents a function used in the initialization\n * by init_by_array\n * @param x 32-bit integer\n * @return 32-bit integer\n */\nstatic uint32_t func2(uint32_t x) {\n return (x ^ (x >> 27)) * (uint32_t)1566083941UL;\n}\n\n/**\n * This function certificate the period of 2^{MEXP}\n */\nstatic void period_certification(sfmt_t *ctx) {\n int inner = 0;\n int i, j;\n uint32_t work;\n uint32_t *psfmt32 = &ctx->sfmt[0].u[0];\n\n for (i = 0; i < 4; i++)\n\tinner ^= psfmt32[idxof(i)] & parity[i];\n for (i = 16; i > 0; i >>= 1)\n\tinner ^= inner >> i;\n inner &= 1;\n /* check OK */\n if (inner == 1) {\n\treturn;\n }\n /* check NG, and modification */\n for (i = 0; i < 4; i++) {\n\twork = 1;\n\tfor (j = 0; j < 32; j++) {\n\t if ((work & parity[i]) != 0) {\n\t\tpsfmt32[idxof(i)] ^= work;\n\t\treturn;\n\t }\n\t work = work << 1;\n\t}\n }\n}\n\n/*----------------\n PUBLIC FUNCTIONS\n ----------------*/\n/**\n * This function returns the identification string.\n * The string shows the word size, the Mersenne exponent,\n * and all parameters of this generator.\n */\nconst char *get_idstring(void) {\n return IDSTR;\n}\n\n/**\n * This function returns the minimum size of array used for \\b\n * fill_array32() function.\n * @return minimum size of array used for fill_array32() function.\n */\nint get_min_array_size32(void) {\n return N32;\n}\n\n/**\n * This function returns the minimum size of array used for \\b\n * fill_array64() function.\n * @return minimum size of array used for fill_array64() function.\n */\nint get_min_array_size64(void) {\n return N64;\n}\n\n#ifndef ONLY64\n/**\n * This function generates and returns 32-bit pseudorandom number.\n * init_gen_rand or init_by_array must be called before this function.\n * @return 32-bit pseudorandom number\n */\nuint32_t gen_rand32(sfmt_t *ctx) {\n uint32_t r;\n uint32_t *psfmt32 = &ctx->sfmt[0].u[0];\n\n assert(ctx->initialized);\n if (ctx->idx >= N32) {\n\tgen_rand_all(ctx);\n\tctx->idx = 0;\n }\n r = psfmt32[ctx->idx++];\n return r;\n}\n\n/* Generate a random integer in [0..limit). */\nuint32_t gen_rand32_range(sfmt_t *ctx, uint32_t limit) {\n uint32_t ret, above;\n\n above = 0xffffffffU - (0xffffffffU % limit);\n while (1) {\n\tret = gen_rand32(ctx);\n\tif (ret < above) {\n\t ret %= limit;\n\t break;\n\t}\n }\n return ret;\n}\n#endif\n/**\n * This function generates and returns 64-bit pseudorandom number.\n * init_gen_rand or init_by_array must be called before this function.\n * The function gen_rand64 should not be called after gen_rand32,\n * unless an initialization is again executed.\n * @return 64-bit pseudorandom number\n */\nuint64_t gen_rand64(sfmt_t *ctx) {\n#if defined(BIG_ENDIAN64) && !defined(ONLY64)\n uint32_t r1, r2;\n uint32_t *psfmt32 = &ctx->sfmt[0].u[0];\n#else\n uint64_t r;\n uint64_t *psfmt64 = (uint64_t *)&ctx->sfmt[0].u[0];\n#endif\n\n assert(ctx->initialized);\n assert(ctx->idx % 2 == 0);\n\n if (ctx->idx >= N32) {\n\tgen_rand_all(ctx);\n\tctx->idx = 0;\n }\n#if defined(BIG_ENDIAN64) && !defined(ONLY64)\n r1 = psfmt32[ctx->idx];\n r2 = psfmt32[ctx->idx + 1];\n ctx->idx += 2;\n return ((uint64_t)r2 << 32) | r1;\n#else\n r = psfmt64[ctx->idx / 2];\n ctx->idx += 2;\n return r;\n#endif\n}\n\n/* Generate a random integer in [0..limit). */\nuint64_t gen_rand64_range(sfmt_t *ctx, uint64_t limit) {\n uint64_t ret, above;\n\n above = KQU(0xffffffffffffffff) - (KQU(0xffffffffffffffff) % limit);\n while (1) {\n\tret = gen_rand64(ctx);\n\tif (ret < above) {\n\t ret %= limit;\n\t break;\n\t}\n }\n return ret;\n}\n\n#ifndef ONLY64\n/**\n * This function generates pseudorandom 32-bit integers in the\n * specified array[] by one call. The number of pseudorandom integers\n * is specified by the argument size, which must be at least 624 and a\n * multiple of four. The generation by this function is much faster\n * than the following gen_rand function.\n *\n * For initialization, init_gen_rand or init_by_array must be called\n * before the first call of this function. This function can not be\n * used after calling gen_rand function, without initialization.\n *\n * @param array an array where pseudorandom 32-bit integers are filled\n * by this function. The pointer to the array must be \\b \"aligned\"\n * (namely, must be a multiple of 16) in the SIMD version, since it\n * refers to the address of a 128-bit integer. In the standard C\n * version, the pointer is arbitrary.\n *\n * @param size the number of 32-bit pseudorandom integers to be\n * generated. size must be a multiple of 4, and greater than or equal\n * to (MEXP / 128 + 1) * 4.\n *\n * @note \\b memalign or \\b posix_memalign is available to get aligned\n * memory. Mac OSX doesn't have these functions, but \\b malloc of OSX\n * returns the pointer to the aligned memory block.\n */\nvoid fill_array32(sfmt_t *ctx, uint32_t *array, int size) {\n assert(ctx->initialized);\n assert(ctx->idx == N32);\n assert(size % 4 == 0);\n assert(size >= N32);\n\n gen_rand_array(ctx, (w128_t *)array, size / 4);\n ctx->idx = N32;\n}\n#endif\n\n/**\n * This function generates pseudorandom 64-bit integers in the\n * specified array[] by one call. The number of pseudorandom integers\n * is specified by the argument size, which must be at least 312 and a\n * multiple of two. The generation by this function is much faster\n * than the following gen_rand function.\n *\n * For initialization, init_gen_rand or init_by_array must be called\n * before the first call of this function. This function can not be\n * used after calling gen_rand function, without initialization.\n *\n * @param array an array where pseudorandom 64-bit integers are filled\n * by this function. The pointer to the array must be \"aligned\"\n * (namely, must be a multiple of 16) in the SIMD version, since it\n * refers to the address of a 128-bit integer. In the standard C\n * version, the pointer is arbitrary.\n *\n * @param size the number of 64-bit pseudorandom integers to be\n * generated. size must be a multiple of 2, and greater than or equal\n * to (MEXP / 128 + 1) * 2\n *\n * @note \\b memalign or \\b posix_memalign is available to get aligned\n * memory. Mac OSX doesn't have these functions, but \\b malloc of OSX\n * returns the pointer to the aligned memory block.\n */\nvoid fill_array64(sfmt_t *ctx, uint64_t *array, int size) {\n assert(ctx->initialized);\n assert(ctx->idx == N32);\n assert(size % 2 == 0);\n assert(size >= N64);\n\n gen_rand_array(ctx, (w128_t *)array, size / 2);\n ctx->idx = N32;\n\n#if defined(BIG_ENDIAN64) && !defined(ONLY64)\n swap((w128_t *)array, size /2);\n#endif\n}\n\n/**\n * This function initializes the internal state array with a 32-bit\n * integer seed.\n *\n * @param seed a 32-bit integer used as the seed.\n */\nsfmt_t *init_gen_rand(uint32_t seed) {\n void *p;\n sfmt_t *ctx;\n int i;\n uint32_t *psfmt32;\n\n if (posix_memalign(&p, sizeof(w128_t), sizeof(sfmt_t)) != 0) {\n\treturn NULL;\n }\n ctx = (sfmt_t *)p;\n psfmt32 = &ctx->sfmt[0].u[0];\n\n psfmt32[idxof(0)] = seed;\n for (i = 1; i < N32; i++) {\n\tpsfmt32[idxof(i)] = 1812433253UL * (psfmt32[idxof(i - 1)]\n\t\t\t\t\t ^ (psfmt32[idxof(i - 1)] >> 30))\n\t + i;\n }\n ctx->idx = N32;\n period_certification(ctx);\n ctx->initialized = 1;\n\n return ctx;\n}\n\n/**\n * This function initializes the internal state array,\n * with an array of 32-bit integers used as the seeds\n * @param init_key the array of 32-bit integers, used as a seed.\n * @param key_length the length of init_key.\n */\nsfmt_t *init_by_array(uint32_t *init_key, int key_length) {\n void *p;\n sfmt_t *ctx;\n int i, j, count;\n uint32_t r;\n int lag;\n int mid;\n int size = N * 4;\n uint32_t *psfmt32;\n\n if (posix_memalign(&p, sizeof(w128_t), sizeof(sfmt_t)) != 0) {\n\treturn NULL;\n }\n ctx = (sfmt_t *)p;\n psfmt32 = &ctx->sfmt[0].u[0];\n\n if (size >= 623) {\n\tlag = 11;\n } else if (size >= 68) {\n\tlag = 7;\n } else if (size >= 39) {\n\tlag = 5;\n } else {\n\tlag = 3;\n }\n mid = (size - lag) / 2;\n\n memset(ctx->sfmt, 0x8b, sizeof(ctx->sfmt));\n if (key_length + 1 > N32) {\n\tcount = key_length + 1;\n } else {\n\tcount = N32;\n }\n r = func1(psfmt32[idxof(0)] ^ psfmt32[idxof(mid)]\n\t ^ psfmt32[idxof(N32 - 1)]);\n psfmt32[idxof(mid)] += r;\n r += key_length;\n psfmt32[idxof(mid + lag)] += r;\n psfmt32[idxof(0)] = r;\n\n count--;\n for (i = 1, j = 0; (j < count) && (j < key_length); j++) {\n\tr = func1(psfmt32[idxof(i)] ^ psfmt32[idxof((i + mid) % N32)]\n\t\t ^ psfmt32[idxof((i + N32 - 1) % N32)]);\n\tpsfmt32[idxof((i + mid) % N32)] += r;\n\tr += init_key[j] + i;\n\tpsfmt32[idxof((i + mid + lag) % N32)] += r;\n\tpsfmt32[idxof(i)] = r;\n\ti = (i + 1) % N32;\n }\n for (; j < count; j++) {\n\tr = func1(psfmt32[idxof(i)] ^ psfmt32[idxof((i + mid) % N32)]\n\t\t ^ psfmt32[idxof((i + N32 - 1) % N32)]);\n\tpsfmt32[idxof((i + mid) % N32)] += r;\n\tr += i;\n\tpsfmt32[idxof((i + mid + lag) % N32)] += r;\n\tpsfmt32[idxof(i)] = r;\n\ti = (i + 1) % N32;\n }\n for (j = 0; j < N32; j++) {\n\tr = func2(psfmt32[idxof(i)] + psfmt32[idxof((i + mid) % N32)]\n\t\t + psfmt32[idxof((i + N32 - 1) % N32)]);\n\tpsfmt32[idxof((i + mid) % N32)] ^= r;\n\tr -= i;\n\tpsfmt32[idxof((i + mid + lag) % N32)] ^= r;\n\tpsfmt32[idxof(i)] = r;\n\ti = (i + 1) % N32;\n }\n\n ctx->idx = N32;\n period_certification(ctx);\n ctx->initialized = 1;\n\n return ctx;\n}\n\nvoid fini_gen_rand(sfmt_t *ctx) {\n assert(ctx != NULL);\n\n ctx->initialized = 0;\n free(ctx);\n}\n" }, { "path": "deps/jemalloc/test/src/btalloc.c", "content": "#include \"test/jemalloc_test.h\"\n\nvoid *\nbtalloc(size_t size, unsigned bits) {\n\treturn btalloc_0(size, bits);\n}\n" }, { "path": "deps/jemalloc/test/src/btalloc_0.c", "content": "#include \"test/jemalloc_test.h\"\n\nbtalloc_n_gen(0)\n" }, { "path": "deps/jemalloc/test/src/btalloc_1.c", "content": "#include \"test/jemalloc_test.h\"\n\nbtalloc_n_gen(1)\n" }, { "path": "deps/jemalloc/test/src/math.c", "content": "#define MATH_C_\n#include \"test/jemalloc_test.h\"\n" }, { "path": "deps/jemalloc/test/src/mtx.c", "content": "#include \"test/jemalloc_test.h\"\n\n#ifndef _CRT_SPINCOUNT\n#define _CRT_SPINCOUNT 4000\n#endif\n\nbool\nmtx_init(mtx_t *mtx) {\n#ifdef _WIN32\n\tif (!InitializeCriticalSectionAndSpinCount(&mtx->lock,\n\t _CRT_SPINCOUNT)) {\n\t\treturn true;\n\t}\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n\tmtx->lock = OS_UNFAIR_LOCK_INIT;\n#else\n\tpthread_mutexattr_t attr;\n\n\tif (pthread_mutexattr_init(&attr) != 0) {\n\t\treturn true;\n\t}\n\tpthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);\n\tif (pthread_mutex_init(&mtx->lock, &attr) != 0) {\n\t\tpthread_mutexattr_destroy(&attr);\n\t\treturn true;\n\t}\n\tpthread_mutexattr_destroy(&attr);\n#endif\n\treturn false;\n}\n\nvoid\nmtx_fini(mtx_t *mtx) {\n#ifdef _WIN32\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n#else\n\tpthread_mutex_destroy(&mtx->lock);\n#endif\n}\n\nvoid\nmtx_lock(mtx_t *mtx) {\n#ifdef _WIN32\n\tEnterCriticalSection(&mtx->lock);\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n\tos_unfair_lock_lock(&mtx->lock);\n#else\n\tpthread_mutex_lock(&mtx->lock);\n#endif\n}\n\nvoid\nmtx_unlock(mtx_t *mtx) {\n#ifdef _WIN32\n\tLeaveCriticalSection(&mtx->lock);\n#elif (defined(JEMALLOC_OS_UNFAIR_LOCK))\n\tos_unfair_lock_unlock(&mtx->lock);\n#else\n\tpthread_mutex_unlock(&mtx->lock);\n#endif\n}\n" }, { "path": "deps/jemalloc/test/src/sleep.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * Sleep for approximately ns nanoseconds. No lower *nor* upper bound on sleep\n * time is guaranteed.\n */\nvoid\nsleep_ns(unsigned ns) {\n\tassert(ns <= 1000*1000*1000);\n\n#ifdef _WIN32\n\tSleep(ns / 1000 / 1000);\n#else\n\t{\n\t\tstruct timespec timeout;\n\n\t\tif (ns < 1000*1000*1000) {\n\t\t\ttimeout.tv_sec = 0;\n\t\t\ttimeout.tv_nsec = ns;\n\t\t} else {\n\t\t\ttimeout.tv_sec = 1;\n\t\t\ttimeout.tv_nsec = 0;\n\t\t}\n\t\tnanosleep(&timeout, NULL);\n\t}\n#endif\n}\n" }, { "path": "deps/jemalloc/test/src/test.c", "content": "#include \"test/jemalloc_test.h\"\n\n/* Test status state. */\n\nstatic unsigned\t\ttest_count = 0;\nstatic test_status_t\ttest_counts[test_status_count] = {0, 0, 0};\nstatic test_status_t\ttest_status = test_status_pass;\nstatic const char *\ttest_name = \"\";\n\n/* Reentrancy testing helpers. */\n\n#define NUM_REENTRANT_ALLOCS 20\ntypedef enum {\n\tnon_reentrant = 0,\n\tlibc_reentrant = 1,\n\tarena_new_reentrant = 2\n} reentrancy_t;\nstatic reentrancy_t reentrancy;\n\nstatic bool libc_hook_ran = false;\nstatic bool arena_new_hook_ran = false;\n\nstatic const char *\nreentrancy_t_str(reentrancy_t r) {\n\tswitch (r) {\n\tcase non_reentrant:\n\t\treturn \"non-reentrant\";\n\tcase libc_reentrant:\n\t\treturn \"libc-reentrant\";\n\tcase arena_new_reentrant:\n\t\treturn \"arena_new-reentrant\";\n\tdefault:\n\t\tunreachable();\n\t}\n}\n\nstatic void\ndo_hook(bool *hook_ran, void (**hook)()) {\n\t*hook_ran = true;\n\t*hook = NULL;\n\n\tsize_t alloc_size = 1;\n\tfor (int i = 0; i < NUM_REENTRANT_ALLOCS; i++) {\n\t\tfree(malloc(alloc_size));\n\t\talloc_size *= 2;\n\t}\n}\n\nstatic void\nlibc_reentrancy_hook() {\n\tdo_hook(&libc_hook_ran, &test_hooks_libc_hook);\n}\n\nstatic void\narena_new_reentrancy_hook() {\n\tdo_hook(&arena_new_hook_ran, &test_hooks_arena_new_hook);\n}\n\n/* Actual test infrastructure. */\nbool\ntest_is_reentrant() {\n\treturn reentrancy != non_reentrant;\n}\n\nJEMALLOC_FORMAT_PRINTF(1, 2)\nvoid\ntest_skip(const char *format, ...) {\n\tva_list ap;\n\n\tva_start(ap, format);\n\tmalloc_vcprintf(NULL, NULL, format, ap);\n\tva_end(ap);\n\tmalloc_printf(\"\\n\");\n\ttest_status = test_status_skip;\n}\n\nJEMALLOC_FORMAT_PRINTF(1, 2)\nvoid\ntest_fail(const char *format, ...) {\n\tva_list ap;\n\n\tva_start(ap, format);\n\tmalloc_vcprintf(NULL, NULL, format, ap);\n\tva_end(ap);\n\tmalloc_printf(\"\\n\");\n\ttest_status = test_status_fail;\n}\n\nstatic const char *\ntest_status_string(test_status_t current_status) {\n\tswitch (current_status) {\n\tcase test_status_pass: return \"pass\";\n\tcase test_status_skip: return \"skip\";\n\tcase test_status_fail: return \"fail\";\n\tdefault: not_reached();\n\t}\n}\n\nvoid\np_test_init(const char *name) {\n\ttest_count++;\n\ttest_status = test_status_pass;\n\ttest_name = name;\n}\n\nvoid\np_test_fini(void) {\n\ttest_counts[test_status]++;\n\tmalloc_printf(\"%s (%s): %s\\n\", test_name, reentrancy_t_str(reentrancy),\n\t test_status_string(test_status));\n}\n\nstatic void\ncheck_global_slow(test_status_t *status) {\n#ifdef JEMALLOC_UNIT_TEST\n\t/*\n\t * This check needs to peek into tsd internals, which is why it's only\n\t * exposed in unit tests.\n\t */\n\tif (tsd_global_slow()) {\n\t\tmalloc_printf(\"Testing increased global slow count\\n\");\n\t\t*status = test_status_fail;\n\t}\n#endif\n}\n\nstatic test_status_t\np_test_impl(bool do_malloc_init, bool do_reentrant, test_t *t, va_list ap) {\n\ttest_status_t ret;\n\n\tif (do_malloc_init) {\n\t\t/*\n\t\t * Make sure initialization occurs prior to running tests.\n\t\t * Tests are special because they may use internal facilities\n\t\t * prior to triggering initialization as a side effect of\n\t\t * calling into the public API.\n\t\t */\n\t\tif (nallocx(1, 0) == 0) {\n\t\t\tmalloc_printf(\"Initialization error\");\n\t\t\treturn test_status_fail;\n\t\t}\n\t}\n\n\tret = test_status_pass;\n\tfor (; t != NULL; t = va_arg(ap, test_t *)) {\n\t\t/* Non-reentrant run. */\n\t\treentrancy = non_reentrant;\n\t\ttest_hooks_arena_new_hook = test_hooks_libc_hook = NULL;\n\t\tt();\n\t\tif (test_status > ret) {\n\t\t\tret = test_status;\n\t\t}\n\t\tcheck_global_slow(&ret);\n\t\t/* Reentrant run. */\n\t\tif (do_reentrant) {\n\t\t\treentrancy = libc_reentrant;\n\t\t\ttest_hooks_arena_new_hook = NULL;\n\t\t\ttest_hooks_libc_hook = &libc_reentrancy_hook;\n\t\t\tt();\n\t\t\tif (test_status > ret) {\n\t\t\t\tret = test_status;\n\t\t\t}\n\t\t\tcheck_global_slow(&ret);\n\n\t\t\treentrancy = arena_new_reentrant;\n\t\t\ttest_hooks_libc_hook = NULL;\n\t\t\ttest_hooks_arena_new_hook = &arena_new_reentrancy_hook;\n\t\t\tt();\n\t\t\tif (test_status > ret) {\n\t\t\t\tret = test_status;\n\t\t\t}\n\t\t\tcheck_global_slow(&ret);\n\t\t}\n\t}\n\n\tmalloc_printf(\"--- %s: %u/%u, %s: %u/%u, %s: %u/%u ---\\n\",\n\t test_status_string(test_status_pass),\n\t test_counts[test_status_pass], test_count,\n\t test_status_string(test_status_skip),\n\t test_counts[test_status_skip], test_count,\n\t test_status_string(test_status_fail),\n\t test_counts[test_status_fail], test_count);\n\n\treturn ret;\n}\n\ntest_status_t\np_test(test_t *t, ...) {\n\ttest_status_t ret;\n\tva_list ap;\n\n\tret = test_status_pass;\n\tva_start(ap, t);\n\tret = p_test_impl(true, true, t, ap);\n\tva_end(ap);\n\n\treturn ret;\n}\n\ntest_status_t\np_test_no_reentrancy(test_t *t, ...) {\n\ttest_status_t ret;\n\tva_list ap;\n\n\tret = test_status_pass;\n\tva_start(ap, t);\n\tret = p_test_impl(true, false, t, ap);\n\tva_end(ap);\n\n\treturn ret;\n}\n\ntest_status_t\np_test_no_malloc_init(test_t *t, ...) {\n\ttest_status_t ret;\n\tva_list ap;\n\n\tret = test_status_pass;\n\tva_start(ap, t);\n\t/*\n\t * We also omit reentrancy from bootstrapping tests, since we don't\n\t * (yet) care about general reentrancy during bootstrapping.\n\t */\n\tret = p_test_impl(false, false, t, ap);\n\tva_end(ap);\n\n\treturn ret;\n}\n\nvoid\np_test_fail(const char *prefix, const char *message) {\n\tmalloc_cprintf(NULL, NULL, \"%s%s\\n\", prefix, message);\n\ttest_status = test_status_fail;\n}\n" }, { "path": "deps/jemalloc/test/src/thd.c", "content": "#include \"test/jemalloc_test.h\"\n\n#ifdef _WIN32\nvoid\nthd_create(thd_t *thd, void *(*proc)(void *), void *arg) {\n\tLPTHREAD_START_ROUTINE routine = (LPTHREAD_START_ROUTINE)proc;\n\t*thd = CreateThread(NULL, 0, routine, arg, 0, NULL);\n\tif (*thd == NULL) {\n\t\ttest_fail(\"Error in CreateThread()\\n\");\n\t}\n}\n\nvoid\nthd_join(thd_t thd, void **ret) {\n\tif (WaitForSingleObject(thd, INFINITE) == WAIT_OBJECT_0 && ret) {\n\t\tDWORD exit_code;\n\t\tGetExitCodeThread(thd, (LPDWORD) &exit_code);\n\t\t*ret = (void *)(uintptr_t)exit_code;\n\t}\n}\n\n#else\nvoid\nthd_create(thd_t *thd, void *(*proc)(void *), void *arg) {\n\tif (pthread_create(thd, NULL, proc, arg) != 0) {\n\t\ttest_fail(\"Error in pthread_create()\\n\");\n\t}\n}\n\nvoid\nthd_join(thd_t thd, void **ret) {\n\tpthread_join(thd, ret);\n}\n#endif\n" }, { "path": "deps/jemalloc/test/src/timer.c", "content": "#include \"test/jemalloc_test.h\"\n\nvoid\ntimer_start(timedelta_t *timer) {\n\tnstime_init_update(&timer->t0);\n}\n\nvoid\ntimer_stop(timedelta_t *timer) {\n\tnstime_copy(&timer->t1, &timer->t0);\n\tnstime_update(&timer->t1);\n}\n\nuint64_t\ntimer_usec(const timedelta_t *timer) {\n\tnstime_t delta;\n\n\tnstime_copy(&delta, &timer->t1);\n\tnstime_subtract(&delta, &timer->t0);\n\treturn nstime_ns(&delta) / 1000;\n}\n\nvoid\ntimer_ratio(timedelta_t *a, timedelta_t *b, char *buf, size_t buflen) {\n\tuint64_t t0 = timer_usec(a);\n\tuint64_t t1 = timer_usec(b);\n\tuint64_t mult;\n\tsize_t i = 0;\n\tsize_t j, n;\n\n\t/* Whole. */\n\tn = malloc_snprintf(&buf[i], buflen-i, \"%\"FMTu64, t0 / t1);\n\ti += n;\n\tif (i >= buflen) {\n\t\treturn;\n\t}\n\tmult = 1;\n\tfor (j = 0; j < n; j++) {\n\t\tmult *= 10;\n\t}\n\n\t/* Decimal. */\n\tn = malloc_snprintf(&buf[i], buflen-i, \".\");\n\ti += n;\n\n\t/* Fraction. */\n\twhile (i < buflen-1) {\n\t\tuint64_t round = (i+1 == buflen-1 && ((t0 * mult * 10 / t1) % 10\n\t\t >= 5)) ? 1 : 0;\n\t\tn = malloc_snprintf(&buf[i], buflen-i,\n\t\t \"%\"FMTu64, (t0 * mult / t1) % 10 + round);\n\t\ti += n;\n\t\tmult *= 10;\n\t}\n}\n" }, { "path": "deps/jemalloc/test/stress/batch_alloc.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/bench.h\"\n\n#define MIBLEN 8\nstatic size_t mib[MIBLEN];\nstatic size_t miblen = MIBLEN;\n\n#define TINY_BATCH 10\n#define TINY_BATCH_ITER (10 * 1000 * 1000)\n#define HUGE_BATCH (1000 * 1000)\n#define HUGE_BATCH_ITER 100\n#define LEN (100 * 1000 * 1000)\nstatic void *batch_ptrs[LEN];\nstatic size_t batch_ptrs_next = 0;\nstatic void *item_ptrs[LEN];\nstatic size_t item_ptrs_next = 0;\n\n#define SIZE 7\n\ntypedef struct batch_alloc_packet_s batch_alloc_packet_t;\nstruct batch_alloc_packet_s {\n\tvoid **ptrs;\n\tsize_t num;\n\tsize_t size;\n\tint flags;\n};\n\nstatic void\nbatch_alloc_wrapper(size_t batch) {\n\tbatch_alloc_packet_t batch_alloc_packet =\n\t {batch_ptrs + batch_ptrs_next, batch, SIZE, 0};\n\tsize_t filled;\n\tsize_t len = sizeof(size_t);\n\tassert_d_eq(mallctlbymib(mib, miblen, &filled, &len,\n\t &batch_alloc_packet, sizeof(batch_alloc_packet)), 0, \"\");\n\tassert_zu_eq(filled, batch, \"\");\n}\n\nstatic void\nitem_alloc_wrapper(size_t batch) {\n\tfor (size_t i = item_ptrs_next, end = i + batch; i < end; ++i) {\n\t\titem_ptrs[i] = malloc(SIZE);\n\t}\n}\n\nstatic void\nrelease_and_clear(void **ptrs, size_t len) {\n\tfor (size_t i = 0; i < len; ++i) {\n\t\tvoid *p = ptrs[i];\n\t\tassert_ptr_not_null(p, \"allocation failed\");\n\t\tsdallocx(p, SIZE, 0);\n\t\tptrs[i] = NULL;\n\t}\n}\n\nstatic void\nbatch_alloc_without_free(size_t batch) {\n\tbatch_alloc_wrapper(batch);\n\tbatch_ptrs_next += batch;\n}\n\nstatic void\nitem_alloc_without_free(size_t batch) {\n\titem_alloc_wrapper(batch);\n\titem_ptrs_next += batch;\n}\n\nstatic void\nbatch_alloc_with_free(size_t batch) {\n\tbatch_alloc_wrapper(batch);\n\trelease_and_clear(batch_ptrs + batch_ptrs_next, batch);\n\tbatch_ptrs_next += batch;\n}\n\nstatic void\nitem_alloc_with_free(size_t batch) {\n\titem_alloc_wrapper(batch);\n\trelease_and_clear(item_ptrs + item_ptrs_next, batch);\n\titem_ptrs_next += batch;\n}\n\nstatic void\ncompare_without_free(size_t batch, size_t iter,\n void (*batch_alloc_without_free_func)(void),\n void (*item_alloc_without_free_func)(void)) {\n\tassert(batch_ptrs_next == 0);\n\tassert(item_ptrs_next == 0);\n\tassert(batch * iter <= LEN);\n\tfor (size_t i = 0; i < iter; ++i) {\n\t\tbatch_alloc_without_free_func();\n\t\titem_alloc_without_free_func();\n\t}\n\trelease_and_clear(batch_ptrs, batch_ptrs_next);\n\tbatch_ptrs_next = 0;\n\trelease_and_clear(item_ptrs, item_ptrs_next);\n\titem_ptrs_next = 0;\n\tcompare_funcs(0, iter,\n\t \"batch allocation\", batch_alloc_without_free_func,\n\t \"item allocation\", item_alloc_without_free_func);\n\trelease_and_clear(batch_ptrs, batch_ptrs_next);\n\tbatch_ptrs_next = 0;\n\trelease_and_clear(item_ptrs, item_ptrs_next);\n\titem_ptrs_next = 0;\n}\n\nstatic void\ncompare_with_free(size_t batch, size_t iter,\n void (*batch_alloc_with_free_func)(void),\n void (*item_alloc_with_free_func)(void)) {\n\tassert(batch_ptrs_next == 0);\n\tassert(item_ptrs_next == 0);\n\tassert(batch * iter <= LEN);\n\tfor (size_t i = 0; i < iter; ++i) {\n\t\tbatch_alloc_with_free_func();\n\t\titem_alloc_with_free_func();\n\t}\n\tbatch_ptrs_next = 0;\n\titem_ptrs_next = 0;\n\tcompare_funcs(0, iter,\n\t \"batch allocation\", batch_alloc_with_free_func,\n\t \"item allocation\", item_alloc_with_free_func);\n\tbatch_ptrs_next = 0;\n\titem_ptrs_next = 0;\n}\n\nstatic void\nbatch_alloc_without_free_tiny() {\n\tbatch_alloc_without_free(TINY_BATCH);\n}\n\nstatic void\nitem_alloc_without_free_tiny() {\n\titem_alloc_without_free(TINY_BATCH);\n}\n\nTEST_BEGIN(test_tiny_batch_without_free) {\n\tcompare_without_free(TINY_BATCH, TINY_BATCH_ITER,\n\t batch_alloc_without_free_tiny, item_alloc_without_free_tiny);\n}\nTEST_END\n\nstatic void\nbatch_alloc_with_free_tiny() {\n\tbatch_alloc_with_free(TINY_BATCH);\n}\n\nstatic void\nitem_alloc_with_free_tiny() {\n\titem_alloc_with_free(TINY_BATCH);\n}\n\nTEST_BEGIN(test_tiny_batch_with_free) {\n\tcompare_with_free(TINY_BATCH, TINY_BATCH_ITER,\n\t batch_alloc_with_free_tiny, item_alloc_with_free_tiny);\n}\nTEST_END\n\nstatic void\nbatch_alloc_without_free_huge() {\n\tbatch_alloc_without_free(HUGE_BATCH);\n}\n\nstatic void\nitem_alloc_without_free_huge() {\n\titem_alloc_without_free(HUGE_BATCH);\n}\n\nTEST_BEGIN(test_huge_batch_without_free) {\n\tcompare_without_free(HUGE_BATCH, HUGE_BATCH_ITER,\n\t batch_alloc_without_free_huge, item_alloc_without_free_huge);\n}\nTEST_END\n\nstatic void\nbatch_alloc_with_free_huge() {\n\tbatch_alloc_with_free(HUGE_BATCH);\n}\n\nstatic void\nitem_alloc_with_free_huge() {\n\titem_alloc_with_free(HUGE_BATCH);\n}\n\nTEST_BEGIN(test_huge_batch_with_free) {\n\tcompare_with_free(HUGE_BATCH, HUGE_BATCH_ITER,\n\t batch_alloc_with_free_huge, item_alloc_with_free_huge);\n}\nTEST_END\n\nint main(void) {\n\tassert_d_eq(mallctlnametomib(\"experimental.batch_alloc\", mib, &miblen),\n\t 0, \"\");\n\treturn test_no_reentrancy(\n\t test_tiny_batch_without_free,\n\t test_tiny_batch_with_free,\n\t test_huge_batch_without_free,\n\t test_huge_batch_with_free);\n}\n" }, { "path": "deps/jemalloc/test/stress/fill_flush.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/bench.h\"\n\n#define SMALL_ALLOC_SIZE 128\n#define LARGE_ALLOC_SIZE SC_LARGE_MINCLASS\n#define NALLOCS 1000\n\n/*\n * We make this volatile so the 1-at-a-time variants can't leave the allocation\n * in a register, just to try to get the cache behavior closer.\n */\nvoid *volatile allocs[NALLOCS];\n\nstatic void\narray_alloc_dalloc_small(void) {\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tvoid *p = mallocx(SMALL_ALLOC_SIZE, 0);\n\t\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\t\tallocs[i] = p;\n\t}\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tsdallocx(allocs[i], SMALL_ALLOC_SIZE, 0);\n\t}\n}\n\nstatic void\nitem_alloc_dalloc_small(void) {\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tvoid *p = mallocx(SMALL_ALLOC_SIZE, 0);\n\t\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\t\tallocs[i] = p;\n\t\tsdallocx(allocs[i], SMALL_ALLOC_SIZE, 0);\n\t}\n}\n\nTEST_BEGIN(test_array_vs_item_small) {\n\tcompare_funcs(1 * 1000, 10 * 1000,\n\t \"array of small allocations\", array_alloc_dalloc_small,\n\t \"small item allocation\", item_alloc_dalloc_small);\n}\nTEST_END\n\nstatic void\narray_alloc_dalloc_large(void) {\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tvoid *p = mallocx(LARGE_ALLOC_SIZE, 0);\n\t\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\t\tallocs[i] = p;\n\t}\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tsdallocx(allocs[i], LARGE_ALLOC_SIZE, 0);\n\t}\n}\n\nstatic void\nitem_alloc_dalloc_large(void) {\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tvoid *p = mallocx(LARGE_ALLOC_SIZE, 0);\n\t\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\t\tallocs[i] = p;\n\t\tsdallocx(allocs[i], LARGE_ALLOC_SIZE, 0);\n\t}\n}\n\nTEST_BEGIN(test_array_vs_item_large) {\n\tcompare_funcs(100, 1000,\n\t \"array of large allocations\", array_alloc_dalloc_large,\n\t \"large item allocation\", item_alloc_dalloc_large);\n}\nTEST_END\n\nint main(void) {\n\treturn test_no_reentrancy(\n\t test_array_vs_item_small,\n\t test_array_vs_item_large);\n}\n" }, { "path": "deps/jemalloc/test/stress/hookbench.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic void\nnoop_alloc_hook(void *extra, hook_alloc_t type, void *result,\n uintptr_t result_raw, uintptr_t args_raw[3]) {\n}\n\nstatic void\nnoop_dalloc_hook(void *extra, hook_dalloc_t type, void *address,\n uintptr_t args_raw[3]) {\n}\n\nstatic void\nnoop_expand_hook(void *extra, hook_expand_t type, void *address,\n size_t old_usize, size_t new_usize, uintptr_t result_raw,\n uintptr_t args_raw[4]) {\n}\n\nstatic void\nmalloc_free_loop(int iters) {\n\tfor (int i = 0; i < iters; i++) {\n\t\tvoid *p = mallocx(1, 0);\n\t\tfree(p);\n\t}\n}\n\nstatic void\ntest_hooked(int iters) {\n\thooks_t hooks = {&noop_alloc_hook, &noop_dalloc_hook, &noop_expand_hook,\n\t\tNULL};\n\n\tint err;\n\tvoid *handles[HOOK_MAX];\n\tsize_t sz = sizeof(handles[0]);\n\n\tfor (int i = 0; i < HOOK_MAX; i++) {\n\t\terr = mallctl(\"experimental.hooks.install\", &handles[i],\n\t\t &sz, &hooks, sizeof(hooks));\n\t\tassert(err == 0);\n\n\t\ttimedelta_t timer;\n\t\ttimer_start(&timer);\n\t\tmalloc_free_loop(iters);\n\t\ttimer_stop(&timer);\n\t\tmalloc_printf(\"With %d hook%s: %\"FMTu64\"us\\n\", i + 1,\n\t\t i + 1 == 1 ? \"\" : \"s\", timer_usec(&timer));\n\t}\n\tfor (int i = 0; i < HOOK_MAX; i++) {\n\t\terr = mallctl(\"experimental.hooks.remove\", NULL, NULL,\n\t\t &handles[i], sizeof(handles[i]));\n\t\tassert(err == 0);\n\t}\n}\n\nstatic void\ntest_unhooked(int iters) {\n\ttimedelta_t timer;\n\ttimer_start(&timer);\n\tmalloc_free_loop(iters);\n\ttimer_stop(&timer);\n\n\tmalloc_printf(\"Without hooks: %\"FMTu64\"us\\n\", timer_usec(&timer));\n}\n\nint\nmain(void) {\n\t/* Initialize */\n\tfree(mallocx(1, 0));\n\tint iters = 10 * 1000 * 1000;\n\tmalloc_printf(\"Benchmarking hooks with %d iterations:\\n\", iters);\n\ttest_hooked(iters);\n\ttest_unhooked(iters);\n}\n" }, { "path": "deps/jemalloc/test/stress/large_microbench.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/bench.h\"\n\nstatic void\nlarge_mallocx_free(void) {\n\t/*\n\t * We go a bit larger than the large minclass on its own to better\n\t * expose costs from things like zeroing.\n\t */\n\tvoid *p = mallocx(SC_LARGE_MINCLASS, MALLOCX_TCACHE_NONE);\n\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\tfree(p);\n}\n\nstatic void\nsmall_mallocx_free(void) {\n\tvoid *p = mallocx(16, 0);\n\tassert_ptr_not_null(p, \"mallocx shouldn't fail\");\n\tfree(p);\n}\n\nTEST_BEGIN(test_large_vs_small) {\n\tcompare_funcs(100*1000, 1*1000*1000, \"large mallocx\",\n\t large_mallocx_free, \"small mallocx\", small_mallocx_free);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_large_vs_small);\n}\n\n" }, { "path": "deps/jemalloc/test/stress/mallctl.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/bench.h\"\n\nstatic void\nmallctl_short(void) {\n\tconst char *version;\n\tsize_t sz = sizeof(version);\n\tint err = mallctl(\"version\", &version, &sz, NULL, 0);\n\tassert_d_eq(err, 0, \"mallctl failure\");\n}\n\nsize_t mib_short[1];\n\nstatic void\nmallctlbymib_short(void) {\n\tsize_t miblen = sizeof(mib_short)/sizeof(mib_short[0]);\n\tconst char *version;\n\tsize_t sz = sizeof(version);\n\tint err = mallctlbymib(mib_short, miblen, &version, &sz, NULL, 0);\n\tassert_d_eq(err, 0, \"mallctlbymib failure\");\n}\n\nTEST_BEGIN(test_mallctl_vs_mallctlbymib_short) {\n\tsize_t miblen = sizeof(mib_short)/sizeof(mib_short[0]);\n\n\tint err = mallctlnametomib(\"version\", mib_short, &miblen);\n\tassert_d_eq(err, 0, \"mallctlnametomib failure\");\n\tcompare_funcs(10*1000*1000, 10*1000*1000, \"mallctl_short\",\n\t mallctl_short, \"mallctlbymib_short\", mallctlbymib_short);\n}\nTEST_END\n\nstatic void\nmallctl_long(void) {\n\tuint64_t nmalloc;\n\tsize_t sz = sizeof(nmalloc);\n\tint err = mallctl(\"stats.arenas.0.bins.0.nmalloc\", &nmalloc, &sz, NULL,\n\t 0);\n\tassert_d_eq(err, 0, \"mallctl failure\");\n}\n\nsize_t mib_long[6];\n\nstatic void\nmallctlbymib_long(void) {\n\tsize_t miblen = sizeof(mib_long)/sizeof(mib_long[0]);\n\tuint64_t nmalloc;\n\tsize_t sz = sizeof(nmalloc);\n\tint err = mallctlbymib(mib_long, miblen, &nmalloc, &sz, NULL, 0);\n\tassert_d_eq(err, 0, \"mallctlbymib failure\");\n}\n\nTEST_BEGIN(test_mallctl_vs_mallctlbymib_long) {\n\t/*\n\t * We want to use the longest mallctl we have; that needs stats support\n\t * to be allowed.\n\t */\n\ttest_skip_if(!config_stats);\n\n\tsize_t miblen = sizeof(mib_long)/sizeof(mib_long[0]);\n\tint err = mallctlnametomib(\"stats.arenas.0.bins.0.nmalloc\", mib_long,\n\t &miblen);\n\tassert_d_eq(err, 0, \"mallctlnametomib failure\");\n\tcompare_funcs(10*1000*1000, 10*1000*1000, \"mallctl_long\",\n\t mallctl_long, \"mallctlbymib_long\", mallctlbymib_long);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_mallctl_vs_mallctlbymib_short,\n\t test_mallctl_vs_mallctlbymib_long);\n}\n" }, { "path": "deps/jemalloc/test/stress/microbench.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/bench.h\"\n\nstatic void\nmalloc_free(void) {\n\t/* The compiler can optimize away free(malloc(1))! */\n\tvoid *p = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tfree(p);\n}\n\nstatic void\nmallocx_free(void) {\n\tvoid *p = mallocx(1, 0);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected mallocx() failure\");\n\t\treturn;\n\t}\n\tfree(p);\n}\n\nTEST_BEGIN(test_malloc_vs_mallocx) {\n\tcompare_funcs(10*1000*1000, 100*1000*1000, \"malloc\",\n\t malloc_free, \"mallocx\", mallocx_free);\n}\nTEST_END\n\nstatic void\nmalloc_dallocx(void) {\n\tvoid *p = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tdallocx(p, 0);\n}\n\nstatic void\nmalloc_sdallocx(void) {\n\tvoid *p = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tsdallocx(p, 1, 0);\n}\n\nTEST_BEGIN(test_free_vs_dallocx) {\n\tcompare_funcs(10*1000*1000, 100*1000*1000, \"free\", malloc_free,\n\t \"dallocx\", malloc_dallocx);\n}\nTEST_END\n\nTEST_BEGIN(test_dallocx_vs_sdallocx) {\n\tcompare_funcs(10*1000*1000, 100*1000*1000, \"dallocx\", malloc_dallocx,\n\t \"sdallocx\", malloc_sdallocx);\n}\nTEST_END\n\nstatic void\nmalloc_mus_free(void) {\n\tvoid *p;\n\n\tp = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tTEST_MALLOC_SIZE(p);\n\tfree(p);\n}\n\nstatic void\nmalloc_sallocx_free(void) {\n\tvoid *p;\n\n\tp = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tif (sallocx(p, 0) < 1) {\n\t\ttest_fail(\"Unexpected sallocx() failure\");\n\t}\n\tfree(p);\n}\n\nTEST_BEGIN(test_mus_vs_sallocx) {\n\tcompare_funcs(10*1000*1000, 100*1000*1000, \"malloc_usable_size\",\n\t malloc_mus_free, \"sallocx\", malloc_sallocx_free);\n}\nTEST_END\n\nstatic void\nmalloc_nallocx_free(void) {\n\tvoid *p;\n\n\tp = malloc(1);\n\tif (p == NULL) {\n\t\ttest_fail(\"Unexpected malloc() failure\");\n\t\treturn;\n\t}\n\tif (nallocx(1, 0) < 1) {\n\t\ttest_fail(\"Unexpected nallocx() failure\");\n\t}\n\tfree(p);\n}\n\nTEST_BEGIN(test_sallocx_vs_nallocx) {\n\tcompare_funcs(10*1000*1000, 100*1000*1000, \"sallocx\",\n\t malloc_sallocx_free, \"nallocx\", malloc_nallocx_free);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_malloc_vs_mallocx,\n\t test_free_vs_dallocx,\n\t test_dallocx_vs_sdallocx,\n\t test_mus_vs_sallocx,\n\t test_sallocx_vs_nallocx);\n}\n" }, { "path": "deps/jemalloc/test/test.sh.in", "content": "#!/bin/sh\n\ncase @abi@ in\n macho)\n export DYLD_FALLBACK_LIBRARY_PATH=\"@objroot@lib\"\n ;;\n pecoff)\n export PATH=\"${PATH}:@objroot@lib\"\n ;;\n *)\n ;;\nesac\n\n# Make a copy of the @JEMALLOC_CPREFIX@MALLOC_CONF passed in to this script, so\n# it can be repeatedly concatenated with per test settings.\nexport MALLOC_CONF_ALL=${@JEMALLOC_CPREFIX@MALLOC_CONF}\n# Concatenate the individual test's MALLOC_CONF and MALLOC_CONF_ALL.\nexport_malloc_conf() {\n if [ \"x${MALLOC_CONF}\" != \"x\" -a \"x${MALLOC_CONF_ALL}\" != \"x\" ] ; then\n export @JEMALLOC_CPREFIX@MALLOC_CONF=\"${MALLOC_CONF},${MALLOC_CONF_ALL}\"\n else\n export @JEMALLOC_CPREFIX@MALLOC_CONF=\"${MALLOC_CONF}${MALLOC_CONF_ALL}\"\n fi\n}\n\n# Corresponds to test_status_t.\npass_code=0\nskip_code=1\nfail_code=2\n\npass_count=0\nskip_count=0\nfail_count=0\nfor t in $@; do\n if [ $pass_count -ne 0 -o $skip_count -ne 0 -o $fail_count != 0 ] ; then\n echo\n fi\n echo \"=== ${t} ===\"\n if [ -e \"@srcroot@${t}.sh\" ] ; then\n # Source the shell script corresponding to the test in a subshell and\n # execute the test. This allows the shell script to set MALLOC_CONF, which\n # is then used to set @JEMALLOC_CPREFIX@MALLOC_CONF (thus allowing the\n # per test shell script to ignore the @JEMALLOC_CPREFIX@ detail).\n enable_fill=@enable_fill@ \\\n enable_prof=@enable_prof@ \\\n . @srcroot@${t}.sh && \\\n export_malloc_conf && \\\n $JEMALLOC_TEST_PREFIX ${t}@exe@ @abs_srcroot@ @abs_objroot@\n else\n export MALLOC_CONF= && \\\n export_malloc_conf && \\\n $JEMALLOC_TEST_PREFIX ${t}@exe@ @abs_srcroot@ @abs_objroot@\n fi\n result_code=$?\n case ${result_code} in\n ${pass_code})\n pass_count=$((pass_count+1))\n ;;\n ${skip_code})\n skip_count=$((skip_count+1))\n ;;\n ${fail_code})\n fail_count=$((fail_count+1))\n ;;\n *)\n echo \"Test harness error: ${t} w/ MALLOC_CONF=\\\"${MALLOC_CONF}\\\"\" 1>&2\n echo \"Use prefix to debug, e.g. JEMALLOC_TEST_PREFIX=\\\"gdb --args\\\" sh test/test.sh ${t}\" 1>&2\n exit 1\n esac\ndone\n\ntotal_count=`expr ${pass_count} + ${skip_count} + ${fail_count}`\necho\necho \"Test suite summary: pass: ${pass_count}/${total_count}, skip: ${skip_count}/${total_count}, fail: ${fail_count}/${total_count}\"\n\nif [ ${fail_count} -eq 0 ] ; then\n exit 0\nelse\n exit 1\nfi\n" }, { "path": "deps/jemalloc/test/unit/SFMT.c", "content": "/*\n * This file derives from SFMT 1.3.3\n * (http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html), which was\n * released under the terms of the following license:\n *\n * Copyright (c) 2006,2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima\n * University. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Hiroshima University nor the names of\n * its contributors may be used to endorse or promote products\n * derived from this software without specific prior written\n * permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n#include \"test/jemalloc_test.h\"\n\n#define BLOCK_SIZE 10000\n#define BLOCK_SIZE64 (BLOCK_SIZE / 2)\n#define COUNT_1 1000\n#define COUNT_2 700\n\nstatic const uint32_t init_gen_rand_32_expected[] = {\n\t3440181298U, 1564997079U, 1510669302U, 2930277156U, 1452439940U,\n\t3796268453U, 423124208U, 2143818589U, 3827219408U, 2987036003U,\n\t2674978610U, 1536842514U, 2027035537U, 2534897563U, 1686527725U,\n\t 545368292U, 1489013321U, 1370534252U, 4231012796U, 3994803019U,\n\t1764869045U, 824597505U, 862581900U, 2469764249U, 812862514U,\n\t 359318673U, 116957936U, 3367389672U, 2327178354U, 1898245200U,\n\t3206507879U, 2378925033U, 1040214787U, 2524778605U, 3088428700U,\n\t1417665896U, 964324147U, 2282797708U, 2456269299U, 313400376U,\n\t2245093271U, 1015729427U, 2694465011U, 3246975184U, 1992793635U,\n\t 463679346U, 3721104591U, 3475064196U, 856141236U, 1499559719U,\n\t3522818941U, 3721533109U, 1954826617U, 1282044024U, 1543279136U,\n\t1301863085U, 2669145051U, 4221477354U, 3896016841U, 3392740262U,\n\t 462466863U, 1037679449U, 1228140306U, 922298197U, 1205109853U,\n\t1872938061U, 3102547608U, 2742766808U, 1888626088U, 4028039414U,\n\t 157593879U, 1136901695U, 4038377686U, 3572517236U, 4231706728U,\n\t2997311961U, 1189931652U, 3981543765U, 2826166703U, 87159245U,\n\t1721379072U, 3897926942U, 1790395498U, 2569178939U, 1047368729U,\n\t2340259131U, 3144212906U, 2301169789U, 2442885464U, 3034046771U,\n\t3667880593U, 3935928400U, 2372805237U, 1666397115U, 2460584504U,\n\t 513866770U, 3810869743U, 2147400037U, 2792078025U, 2941761810U,\n\t3212265810U, 984692259U, 346590253U, 1804179199U, 3298543443U,\n\t 750108141U, 2880257022U, 243310542U, 1869036465U, 1588062513U,\n\t2983949551U, 1931450364U, 4034505847U, 2735030199U, 1628461061U,\n\t2539522841U, 127965585U, 3992448871U, 913388237U, 559130076U,\n\t1202933193U, 4087643167U, 2590021067U, 2256240196U, 1746697293U,\n\t1013913783U, 1155864921U, 2715773730U, 915061862U, 1948766573U,\n\t2322882854U, 3761119102U, 1343405684U, 3078711943U, 3067431651U,\n\t3245156316U, 3588354584U, 3484623306U, 3899621563U, 4156689741U,\n\t3237090058U, 3880063844U, 862416318U, 4039923869U, 2303788317U,\n\t3073590536U, 701653667U, 2131530884U, 3169309950U, 2028486980U,\n\t 747196777U, 3620218225U, 432016035U, 1449580595U, 2772266392U,\n\t 444224948U, 1662832057U, 3184055582U, 3028331792U, 1861686254U,\n\t1104864179U, 342430307U, 1350510923U, 3024656237U, 1028417492U,\n\t2870772950U, 290847558U, 3675663500U, 508431529U, 4264340390U,\n\t2263569913U, 1669302976U, 519511383U, 2706411211U, 3764615828U,\n\t3883162495U, 4051445305U, 2412729798U, 3299405164U, 3991911166U,\n\t2348767304U, 2664054906U, 3763609282U, 593943581U, 3757090046U,\n\t2075338894U, 2020550814U, 4287452920U, 4290140003U, 1422957317U,\n\t2512716667U, 2003485045U, 2307520103U, 2288472169U, 3940751663U,\n\t4204638664U, 2892583423U, 1710068300U, 3904755993U, 2363243951U,\n\t3038334120U, 547099465U, 771105860U, 3199983734U, 4282046461U,\n\t2298388363U, 934810218U, 2837827901U, 3952500708U, 2095130248U,\n\t3083335297U, 26885281U, 3932155283U, 1531751116U, 1425227133U,\n\t 495654159U, 3279634176U, 3855562207U, 3957195338U, 4159985527U,\n\t 893375062U, 1875515536U, 1327247422U, 3754140693U, 1028923197U,\n\t1729880440U, 805571298U, 448971099U, 2726757106U, 2749436461U,\n\t2485987104U, 175337042U, 3235477922U, 3882114302U, 2020970972U,\n\t 943926109U, 2762587195U, 1904195558U, 3452650564U, 108432281U,\n\t3893463573U, 3977583081U, 2636504348U, 1110673525U, 3548479841U,\n\t4258854744U, 980047703U, 4057175418U, 3890008292U, 145653646U,\n\t3141868989U, 3293216228U, 1194331837U, 1254570642U, 3049934521U,\n\t2868313360U, 2886032750U, 1110873820U, 279553524U, 3007258565U,\n\t1104807822U, 3186961098U, 315764646U, 2163680838U, 3574508994U,\n\t3099755655U, 191957684U, 3642656737U, 3317946149U, 3522087636U,\n\t 444526410U, 779157624U, 1088229627U, 1092460223U, 1856013765U,\n\t3659877367U, 368270451U, 503570716U, 3000984671U, 2742789647U,\n\t 928097709U, 2914109539U, 308843566U, 2816161253U, 3667192079U,\n\t2762679057U, 3395240989U, 2928925038U, 1491465914U, 3458702834U,\n\t3787782576U, 2894104823U, 1296880455U, 1253636503U, 989959407U,\n\t2291560361U, 2776790436U, 1913178042U, 1584677829U, 689637520U,\n\t1898406878U, 688391508U, 3385234998U, 845493284U, 1943591856U,\n\t2720472050U, 222695101U, 1653320868U, 2904632120U, 4084936008U,\n\t1080720688U, 3938032556U, 387896427U, 2650839632U, 99042991U,\n\t1720913794U, 1047186003U, 1877048040U, 2090457659U, 517087501U,\n\t4172014665U, 2129713163U, 2413533132U, 2760285054U, 4129272496U,\n\t1317737175U, 2309566414U, 2228873332U, 3889671280U, 1110864630U,\n\t3576797776U, 2074552772U, 832002644U, 3097122623U, 2464859298U,\n\t2679603822U, 1667489885U, 3237652716U, 1478413938U, 1719340335U,\n\t2306631119U, 639727358U, 3369698270U, 226902796U, 2099920751U,\n\t1892289957U, 2201594097U, 3508197013U, 3495811856U, 3900381493U,\n\t 841660320U, 3974501451U, 3360949056U, 1676829340U, 728899254U,\n\t2047809627U, 2390948962U, 670165943U, 3412951831U, 4189320049U,\n\t1911595255U, 2055363086U, 507170575U, 418219594U, 4141495280U,\n\t2692088692U, 4203630654U, 3540093932U, 791986533U, 2237921051U,\n\t2526864324U, 2956616642U, 1394958700U, 1983768223U, 1893373266U,\n\t 591653646U, 228432437U, 1611046598U, 3007736357U, 1040040725U,\n\t2726180733U, 2789804360U, 4263568405U, 829098158U, 3847722805U,\n\t1123578029U, 1804276347U, 997971319U, 4203797076U, 4185199713U,\n\t2811733626U, 2343642194U, 2985262313U, 1417930827U, 3759587724U,\n\t1967077982U, 1585223204U, 1097475516U, 1903944948U, 740382444U,\n\t1114142065U, 1541796065U, 1718384172U, 1544076191U, 1134682254U,\n\t3519754455U, 2866243923U, 341865437U, 645498576U, 2690735853U,\n\t1046963033U, 2493178460U, 1187604696U, 1619577821U, 488503634U,\n\t3255768161U, 2306666149U, 1630514044U, 2377698367U, 2751503746U,\n\t3794467088U, 1796415981U, 3657173746U, 409136296U, 1387122342U,\n\t1297726519U, 219544855U, 4270285558U, 437578827U, 1444698679U,\n\t2258519491U, 963109892U, 3982244073U, 3351535275U, 385328496U,\n\t1804784013U, 698059346U, 3920535147U, 708331212U, 784338163U,\n\t 785678147U, 1238376158U, 1557298846U, 2037809321U, 271576218U,\n\t4145155269U, 1913481602U, 2763691931U, 588981080U, 1201098051U,\n\t3717640232U, 1509206239U, 662536967U, 3180523616U, 1133105435U,\n\t2963500837U, 2253971215U, 3153642623U, 1066925709U, 2582781958U,\n\t3034720222U, 1090798544U, 2942170004U, 4036187520U, 686972531U,\n\t2610990302U, 2641437026U, 1837562420U, 722096247U, 1315333033U,\n\t2102231203U, 3402389208U, 3403698140U, 1312402831U, 2898426558U,\n\t 814384596U, 385649582U, 1916643285U, 1924625106U, 2512905582U,\n\t2501170304U, 4275223366U, 2841225246U, 1467663688U, 3563567847U,\n\t2969208552U, 884750901U, 102992576U, 227844301U, 3681442994U,\n\t3502881894U, 4034693299U, 1166727018U, 1697460687U, 1737778332U,\n\t1787161139U, 1053003655U, 1215024478U, 2791616766U, 2525841204U,\n\t1629323443U, 3233815U, 2003823032U, 3083834263U, 2379264872U,\n\t3752392312U, 1287475550U, 3770904171U, 3004244617U, 1502117784U,\n\t 918698423U, 2419857538U, 3864502062U, 1751322107U, 2188775056U,\n\t4018728324U, 983712955U, 440071928U, 3710838677U, 2001027698U,\n\t3994702151U, 22493119U, 3584400918U, 3446253670U, 4254789085U,\n\t1405447860U, 1240245579U, 1800644159U, 1661363424U, 3278326132U,\n\t3403623451U, 67092802U, 2609352193U, 3914150340U, 1814842761U,\n\t3610830847U, 591531412U, 3880232807U, 1673505890U, 2585326991U,\n\t1678544474U, 3148435887U, 3457217359U, 1193226330U, 2816576908U,\n\t 154025329U, 121678860U, 1164915738U, 973873761U, 269116100U,\n\t 52087970U, 744015362U, 498556057U, 94298882U, 1563271621U,\n\t2383059628U, 4197367290U, 3958472990U, 2592083636U, 2906408439U,\n\t1097742433U, 3924840517U, 264557272U, 2292287003U, 3203307984U,\n\t4047038857U, 3820609705U, 2333416067U, 1839206046U, 3600944252U,\n\t3412254904U, 583538222U, 2390557166U, 4140459427U, 2810357445U,\n\t 226777499U, 2496151295U, 2207301712U, 3283683112U, 611630281U,\n\t1933218215U, 3315610954U, 3889441987U, 3719454256U, 3957190521U,\n\t1313998161U, 2365383016U, 3146941060U, 1801206260U, 796124080U,\n\t2076248581U, 1747472464U, 3254365145U, 595543130U, 3573909503U,\n\t3758250204U, 2020768540U, 2439254210U, 93368951U, 3155792250U,\n\t2600232980U, 3709198295U, 3894900440U, 2971850836U, 1578909644U,\n\t1443493395U, 2581621665U, 3086506297U, 2443465861U, 558107211U,\n\t1519367835U, 249149686U, 908102264U, 2588765675U, 1232743965U,\n\t1001330373U, 3561331654U, 2259301289U, 1564977624U, 3835077093U,\n\t 727244906U, 4255738067U, 1214133513U, 2570786021U, 3899704621U,\n\t1633861986U, 1636979509U, 1438500431U, 58463278U, 2823485629U,\n\t2297430187U, 2926781924U, 3371352948U, 1864009023U, 2722267973U,\n\t1444292075U, 437703973U, 1060414512U, 189705863U, 910018135U,\n\t4077357964U, 884213423U, 2644986052U, 3973488374U, 1187906116U,\n\t2331207875U, 780463700U, 3713351662U, 3854611290U, 412805574U,\n\t2978462572U, 2176222820U, 829424696U, 2790788332U, 2750819108U,\n\t1594611657U, 3899878394U, 3032870364U, 1702887682U, 1948167778U,\n\t 14130042U, 192292500U, 947227076U, 90719497U, 3854230320U,\n\t 784028434U, 2142399787U, 1563449646U, 2844400217U, 819143172U,\n\t2883302356U, 2328055304U, 1328532246U, 2603885363U, 3375188924U,\n\t 933941291U, 3627039714U, 2129697284U, 2167253953U, 2506905438U,\n\t1412424497U, 2981395985U, 1418359660U, 2925902456U, 52752784U,\n\t3713667988U, 3924669405U, 648975707U, 1145520213U, 4018650664U,\n\t3805915440U, 2380542088U, 2013260958U, 3262572197U, 2465078101U,\n\t1114540067U, 3728768081U, 2396958768U, 590672271U, 904818725U,\n\t4263660715U, 700754408U, 1042601829U, 4094111823U, 4274838909U,\n\t2512692617U, 2774300207U, 2057306915U, 3470942453U, 99333088U,\n\t1142661026U, 2889931380U, 14316674U, 2201179167U, 415289459U,\n\t 448265759U, 3515142743U, 3254903683U, 246633281U, 1184307224U,\n\t2418347830U, 2092967314U, 2682072314U, 2558750234U, 2000352263U,\n\t1544150531U, 399010405U, 1513946097U, 499682937U, 461167460U,\n\t3045570638U, 1633669705U, 851492362U, 4052801922U, 2055266765U,\n\t 635556996U, 368266356U, 2385737383U, 3218202352U, 2603772408U,\n\t 349178792U, 226482567U, 3102426060U, 3575998268U, 2103001871U,\n\t3243137071U, 225500688U, 1634718593U, 4283311431U, 4292122923U,\n\t3842802787U, 811735523U, 105712518U, 663434053U, 1855889273U,\n\t2847972595U, 1196355421U, 2552150115U, 4254510614U, 3752181265U,\n\t3430721819U, 3828705396U, 3436287905U, 3441964937U, 4123670631U,\n\t 353001539U, 459496439U, 3799690868U, 1293777660U, 2761079737U,\n\t 498096339U, 3398433374U, 4080378380U, 2304691596U, 2995729055U,\n\t4134660419U, 3903444024U, 3576494993U, 203682175U, 3321164857U,\n\t2747963611U, 79749085U, 2992890370U, 1240278549U, 1772175713U,\n\t2111331972U, 2655023449U, 1683896345U, 2836027212U, 3482868021U,\n\t2489884874U, 756853961U, 2298874501U, 4013448667U, 4143996022U,\n\t2948306858U, 4132920035U, 1283299272U, 995592228U, 3450508595U,\n\t1027845759U, 1766942720U, 3861411826U, 1446861231U, 95974993U,\n\t3502263554U, 1487532194U, 601502472U, 4129619129U, 250131773U,\n\t2050079547U, 3198903947U, 3105589778U, 4066481316U, 3026383978U,\n\t2276901713U, 365637751U, 2260718426U, 1394775634U, 1791172338U,\n\t2690503163U, 2952737846U, 1568710462U, 732623190U, 2980358000U,\n\t1053631832U, 1432426951U, 3229149635U, 1854113985U, 3719733532U,\n\t3204031934U, 735775531U, 107468620U, 3734611984U, 631009402U,\n\t3083622457U, 4109580626U, 159373458U, 1301970201U, 4132389302U,\n\t1293255004U, 847182752U, 4170022737U, 96712900U, 2641406755U,\n\t1381727755U, 405608287U, 4287919625U, 1703554290U, 3589580244U,\n\t2911403488U, 2166565U, 2647306451U, 2330535117U, 1200815358U,\n\t1165916754U, 245060911U, 4040679071U, 3684908771U, 2452834126U,\n\t2486872773U, 2318678365U, 2940627908U, 1837837240U, 3447897409U,\n\t4270484676U, 1495388728U, 3754288477U, 4204167884U, 1386977705U,\n\t2692224733U, 3076249689U, 4109568048U, 4170955115U, 4167531356U,\n\t4020189950U, 4261855038U, 3036907575U, 3410399885U, 3076395737U,\n\t1046178638U, 144496770U, 230725846U, 3349637149U, 17065717U,\n\t2809932048U, 2054581785U, 3608424964U, 3259628808U, 134897388U,\n\t3743067463U, 257685904U, 3795656590U, 1562468719U, 3589103904U,\n\t3120404710U, 254684547U, 2653661580U, 3663904795U, 2631942758U,\n\t1063234347U, 2609732900U, 2332080715U, 3521125233U, 1180599599U,\n\t1935868586U, 4110970440U, 296706371U, 2128666368U, 1319875791U,\n\t1570900197U, 3096025483U, 1799882517U, 1928302007U, 1163707758U,\n\t1244491489U, 3533770203U, 567496053U, 2757924305U, 2781639343U,\n\t2818420107U, 560404889U, 2619609724U, 4176035430U, 2511289753U,\n\t2521842019U, 3910553502U, 2926149387U, 3302078172U, 4237118867U,\n\t 330725126U, 367400677U, 888239854U, 545570454U, 4259590525U,\n\t 134343617U, 1102169784U, 1647463719U, 3260979784U, 1518840883U,\n\t3631537963U, 3342671457U, 1301549147U, 2083739356U, 146593792U,\n\t3217959080U, 652755743U, 2032187193U, 3898758414U, 1021358093U,\n\t4037409230U, 2176407931U, 3427391950U, 2883553603U, 985613827U,\n\t3105265092U, 3423168427U, 3387507672U, 467170288U, 2141266163U,\n\t3723870208U, 916410914U, 1293987799U, 2652584950U, 769160137U,\n\t3205292896U, 1561287359U, 1684510084U, 3136055621U, 3765171391U,\n\t 639683232U, 2639569327U, 1218546948U, 4263586685U, 3058215773U,\n\t2352279820U, 401870217U, 2625822463U, 1529125296U, 2981801895U,\n\t1191285226U, 4027725437U, 3432700217U, 4098835661U, 971182783U,\n\t2443861173U, 3881457123U, 3874386651U, 457276199U, 2638294160U,\n\t4002809368U, 421169044U, 1112642589U, 3076213779U, 3387033971U,\n\t2499610950U, 3057240914U, 1662679783U, 461224431U, 1168395933U\n};\nstatic const uint32_t init_by_array_32_expected[] = {\n\t2920711183U, 3885745737U, 3501893680U, 856470934U, 1421864068U,\n\t 277361036U, 1518638004U, 2328404353U, 3355513634U, 64329189U,\n\t1624587673U, 3508467182U, 2481792141U, 3706480799U, 1925859037U,\n\t2913275699U, 882658412U, 384641219U, 422202002U, 1873384891U,\n\t2006084383U, 3924929912U, 1636718106U, 3108838742U, 1245465724U,\n\t4195470535U, 779207191U, 1577721373U, 1390469554U, 2928648150U,\n\t 121399709U, 3170839019U, 4044347501U, 953953814U, 3821710850U,\n\t3085591323U, 3666535579U, 3577837737U, 2012008410U, 3565417471U,\n\t4044408017U, 433600965U, 1637785608U, 1798509764U, 860770589U,\n\t3081466273U, 3982393409U, 2451928325U, 3437124742U, 4093828739U,\n\t3357389386U, 2154596123U, 496568176U, 2650035164U, 2472361850U,\n\t 3438299U, 2150366101U, 1577256676U, 3802546413U, 1787774626U,\n\t4078331588U, 3706103141U, 170391138U, 3806085154U, 1680970100U,\n\t1961637521U, 3316029766U, 890610272U, 1453751581U, 1430283664U,\n\t3051057411U, 3597003186U, 542563954U, 3796490244U, 1690016688U,\n\t3448752238U, 440702173U, 347290497U, 1121336647U, 2540588620U,\n\t 280881896U, 2495136428U, 213707396U, 15104824U, 2946180358U,\n\t 659000016U, 566379385U, 2614030979U, 2855760170U, 334526548U,\n\t2315569495U, 2729518615U, 564745877U, 1263517638U, 3157185798U,\n\t1604852056U, 1011639885U, 2950579535U, 2524219188U, 312951012U,\n\t1528896652U, 1327861054U, 2846910138U, 3966855905U, 2536721582U,\n\t 855353911U, 1685434729U, 3303978929U, 1624872055U, 4020329649U,\n\t3164802143U, 1642802700U, 1957727869U, 1792352426U, 3334618929U,\n\t2631577923U, 3027156164U, 842334259U, 3353446843U, 1226432104U,\n\t1742801369U, 3552852535U, 3471698828U, 1653910186U, 3380330939U,\n\t2313782701U, 3351007196U, 2129839995U, 1800682418U, 4085884420U,\n\t1625156629U, 3669701987U, 615211810U, 3294791649U, 4131143784U,\n\t2590843588U, 3207422808U, 3275066464U, 561592872U, 3957205738U,\n\t3396578098U, 48410678U, 3505556445U, 1005764855U, 3920606528U,\n\t2936980473U, 2378918600U, 2404449845U, 1649515163U, 701203563U,\n\t3705256349U, 83714199U, 3586854132U, 922978446U, 2863406304U,\n\t3523398907U, 2606864832U, 2385399361U, 3171757816U, 4262841009U,\n\t3645837721U, 1169579486U, 3666433897U, 3174689479U, 1457866976U,\n\t3803895110U, 3346639145U, 1907224409U, 1978473712U, 1036712794U,\n\t 980754888U, 1302782359U, 1765252468U, 459245755U, 3728923860U,\n\t1512894209U, 2046491914U, 207860527U, 514188684U, 2288713615U,\n\t1597354672U, 3349636117U, 2357291114U, 3995796221U, 945364213U,\n\t1893326518U, 3770814016U, 1691552714U, 2397527410U, 967486361U,\n\t 776416472U, 4197661421U, 951150819U, 1852770983U, 4044624181U,\n\t1399439738U, 4194455275U, 2284037669U, 1550734958U, 3321078108U,\n\t1865235926U, 2912129961U, 2664980877U, 1357572033U, 2600196436U,\n\t2486728200U, 2372668724U, 1567316966U, 2374111491U, 1839843570U,\n\t 20815612U, 3727008608U, 3871996229U, 824061249U, 1932503978U,\n\t3404541726U, 758428924U, 2609331364U, 1223966026U, 1299179808U,\n\t 648499352U, 2180134401U, 880821170U, 3781130950U, 113491270U,\n\t1032413764U, 4185884695U, 2490396037U, 1201932817U, 4060951446U,\n\t4165586898U, 1629813212U, 2887821158U, 415045333U, 628926856U,\n\t2193466079U, 3391843445U, 2227540681U, 1907099846U, 2848448395U,\n\t1717828221U, 1372704537U, 1707549841U, 2294058813U, 2101214437U,\n\t2052479531U, 1695809164U, 3176587306U, 2632770465U, 81634404U,\n\t1603220563U, 644238487U, 302857763U, 897352968U, 2613146653U,\n\t1391730149U, 4245717312U, 4191828749U, 1948492526U, 2618174230U,\n\t3992984522U, 2178852787U, 3596044509U, 3445573503U, 2026614616U,\n\t 915763564U, 3415689334U, 2532153403U, 3879661562U, 2215027417U,\n\t3111154986U, 2929478371U, 668346391U, 1152241381U, 2632029711U,\n\t3004150659U, 2135025926U, 948690501U, 2799119116U, 4228829406U,\n\t1981197489U, 4209064138U, 684318751U, 3459397845U, 201790843U,\n\t4022541136U, 3043635877U, 492509624U, 3263466772U, 1509148086U,\n\t 921459029U, 3198857146U, 705479721U, 3835966910U, 3603356465U,\n\t 576159741U, 1742849431U, 594214882U, 2055294343U, 3634861861U,\n\t 449571793U, 3246390646U, 3868232151U, 1479156585U, 2900125656U,\n\t2464815318U, 3960178104U, 1784261920U, 18311476U, 3627135050U,\n\t 644609697U, 424968996U, 919890700U, 2986824110U, 816423214U,\n\t4003562844U, 1392714305U, 1757384428U, 2569030598U, 995949559U,\n\t3875659880U, 2933807823U, 2752536860U, 2993858466U, 4030558899U,\n\t2770783427U, 2775406005U, 2777781742U, 1931292655U, 472147933U,\n\t3865853827U, 2726470545U, 2668412860U, 2887008249U, 408979190U,\n\t3578063323U, 3242082049U, 1778193530U, 27981909U, 2362826515U,\n\t 389875677U, 1043878156U, 581653903U, 3830568952U, 389535942U,\n\t3713523185U, 2768373359U, 2526101582U, 1998618197U, 1160859704U,\n\t3951172488U, 1098005003U, 906275699U, 3446228002U, 2220677963U,\n\t2059306445U, 132199571U, 476838790U, 1868039399U, 3097344807U,\n\t 857300945U, 396345050U, 2835919916U, 1782168828U, 1419519470U,\n\t4288137521U, 819087232U, 596301494U, 872823172U, 1526888217U,\n\t 805161465U, 1116186205U, 2829002754U, 2352620120U, 620121516U,\n\t 354159268U, 3601949785U, 209568138U, 1352371732U, 2145977349U,\n\t4236871834U, 1539414078U, 3558126206U, 3224857093U, 4164166682U,\n\t3817553440U, 3301780278U, 2682696837U, 3734994768U, 1370950260U,\n\t1477421202U, 2521315749U, 1330148125U, 1261554731U, 2769143688U,\n\t3554756293U, 4235882678U, 3254686059U, 3530579953U, 1215452615U,\n\t3574970923U, 4057131421U, 589224178U, 1000098193U, 171190718U,\n\t2521852045U, 2351447494U, 2284441580U, 2646685513U, 3486933563U,\n\t3789864960U, 1190528160U, 1702536782U, 1534105589U, 4262946827U,\n\t2726686826U, 3584544841U, 2348270128U, 2145092281U, 2502718509U,\n\t1027832411U, 3571171153U, 1287361161U, 4011474411U, 3241215351U,\n\t2419700818U, 971242709U, 1361975763U, 1096842482U, 3271045537U,\n\t 81165449U, 612438025U, 3912966678U, 1356929810U, 733545735U,\n\t 537003843U, 1282953084U, 884458241U, 588930090U, 3930269801U,\n\t2961472450U, 1219535534U, 3632251943U, 268183903U, 1441240533U,\n\t3653903360U, 3854473319U, 2259087390U, 2548293048U, 2022641195U,\n\t2105543911U, 1764085217U, 3246183186U, 482438805U, 888317895U,\n\t2628314765U, 2466219854U, 717546004U, 2322237039U, 416725234U,\n\t1544049923U, 1797944973U, 3398652364U, 3111909456U, 485742908U,\n\t2277491072U, 1056355088U, 3181001278U, 129695079U, 2693624550U,\n\t1764438564U, 3797785470U, 195503713U, 3266519725U, 2053389444U,\n\t1961527818U, 3400226523U, 3777903038U, 2597274307U, 4235851091U,\n\t4094406648U, 2171410785U, 1781151386U, 1378577117U, 654643266U,\n\t3424024173U, 3385813322U, 679385799U, 479380913U, 681715441U,\n\t3096225905U, 276813409U, 3854398070U, 2721105350U, 831263315U,\n\t3276280337U, 2628301522U, 3984868494U, 1466099834U, 2104922114U,\n\t1412672743U, 820330404U, 3491501010U, 942735832U, 710652807U,\n\t3972652090U, 679881088U, 40577009U, 3705286397U, 2815423480U,\n\t3566262429U, 663396513U, 3777887429U, 4016670678U, 404539370U,\n\t1142712925U, 1140173408U, 2913248352U, 2872321286U, 263751841U,\n\t3175196073U, 3162557581U, 2878996619U, 75498548U, 3836833140U,\n\t3284664959U, 1157523805U, 112847376U, 207855609U, 1337979698U,\n\t1222578451U, 157107174U, 901174378U, 3883717063U, 1618632639U,\n\t1767889440U, 4264698824U, 1582999313U, 884471997U, 2508825098U,\n\t3756370771U, 2457213553U, 3565776881U, 3709583214U, 915609601U,\n\t 460833524U, 1091049576U, 85522880U, 2553251U, 132102809U,\n\t2429882442U, 2562084610U, 1386507633U, 4112471229U, 21965213U,\n\t1981516006U, 2418435617U, 3054872091U, 4251511224U, 2025783543U,\n\t1916911512U, 2454491136U, 3938440891U, 3825869115U, 1121698605U,\n\t3463052265U, 802340101U, 1912886800U, 4031997367U, 3550640406U,\n\t1596096923U, 610150600U, 431464457U, 2541325046U, 486478003U,\n\t 739704936U, 2862696430U, 3037903166U, 1129749694U, 2611481261U,\n\t1228993498U, 510075548U, 3424962587U, 2458689681U, 818934833U,\n\t4233309125U, 1608196251U, 3419476016U, 1858543939U, 2682166524U,\n\t3317854285U, 631986188U, 3008214764U, 613826412U, 3567358221U,\n\t3512343882U, 1552467474U, 3316162670U, 1275841024U, 4142173454U,\n\t 565267881U, 768644821U, 198310105U, 2396688616U, 1837659011U,\n\t 203429334U, 854539004U, 4235811518U, 3338304926U, 3730418692U,\n\t3852254981U, 3032046452U, 2329811860U, 2303590566U, 2696092212U,\n\t3894665932U, 145835667U, 249563655U, 1932210840U, 2431696407U,\n\t3312636759U, 214962629U, 2092026914U, 3020145527U, 4073039873U,\n\t2739105705U, 1308336752U, 855104522U, 2391715321U, 67448785U,\n\t 547989482U, 854411802U, 3608633740U, 431731530U, 537375589U,\n\t3888005760U, 696099141U, 397343236U, 1864511780U, 44029739U,\n\t1729526891U, 1993398655U, 2010173426U, 2591546756U, 275223291U,\n\t1503900299U, 4217765081U, 2185635252U, 1122436015U, 3550155364U,\n\t 681707194U, 3260479338U, 933579397U, 2983029282U, 2505504587U,\n\t2667410393U, 2962684490U, 4139721708U, 2658172284U, 2452602383U,\n\t2607631612U, 1344296217U, 3075398709U, 2949785295U, 1049956168U,\n\t3917185129U, 2155660174U, 3280524475U, 1503827867U, 674380765U,\n\t1918468193U, 3843983676U, 634358221U, 2538335643U, 1873351298U,\n\t3368723763U, 2129144130U, 3203528633U, 3087174986U, 2691698871U,\n\t2516284287U, 24437745U, 1118381474U, 2816314867U, 2448576035U,\n\t4281989654U, 217287825U, 165872888U, 2628995722U, 3533525116U,\n\t2721669106U, 872340568U, 3429930655U, 3309047304U, 3916704967U,\n\t3270160355U, 1348884255U, 1634797670U, 881214967U, 4259633554U,\n\t 174613027U, 1103974314U, 1625224232U, 2678368291U, 1133866707U,\n\t3853082619U, 4073196549U, 1189620777U, 637238656U, 930241537U,\n\t4042750792U, 3842136042U, 2417007212U, 2524907510U, 1243036827U,\n\t1282059441U, 3764588774U, 1394459615U, 2323620015U, 1166152231U,\n\t3307479609U, 3849322257U, 3507445699U, 4247696636U, 758393720U,\n\t 967665141U, 1095244571U, 1319812152U, 407678762U, 2640605208U,\n\t2170766134U, 3663594275U, 4039329364U, 2512175520U, 725523154U,\n\t2249807004U, 3312617979U, 2414634172U, 1278482215U, 349206484U,\n\t1573063308U, 1196429124U, 3873264116U, 2400067801U, 268795167U,\n\t 226175489U, 2961367263U, 1968719665U, 42656370U, 1010790699U,\n\t 561600615U, 2422453992U, 3082197735U, 1636700484U, 3977715296U,\n\t3125350482U, 3478021514U, 2227819446U, 1540868045U, 3061908980U,\n\t1087362407U, 3625200291U, 361937537U, 580441897U, 1520043666U,\n\t2270875402U, 1009161260U, 2502355842U, 4278769785U, 473902412U,\n\t1057239083U, 1905829039U, 1483781177U, 2080011417U, 1207494246U,\n\t1806991954U, 2194674403U, 3455972205U, 807207678U, 3655655687U,\n\t 674112918U, 195425752U, 3917890095U, 1874364234U, 1837892715U,\n\t3663478166U, 1548892014U, 2570748714U, 2049929836U, 2167029704U,\n\t 697543767U, 3499545023U, 3342496315U, 1725251190U, 3561387469U,\n\t2905606616U, 1580182447U, 3934525927U, 4103172792U, 1365672522U,\n\t1534795737U, 3308667416U, 2841911405U, 3943182730U, 4072020313U,\n\t3494770452U, 3332626671U, 55327267U, 478030603U, 411080625U,\n\t3419529010U, 1604767823U, 3513468014U, 570668510U, 913790824U,\n\t2283967995U, 695159462U, 3825542932U, 4150698144U, 1829758699U,\n\t 202895590U, 1609122645U, 1267651008U, 2910315509U, 2511475445U,\n\t2477423819U, 3932081579U, 900879979U, 2145588390U, 2670007504U,\n\t 580819444U, 1864996828U, 2526325979U, 1019124258U, 815508628U,\n\t2765933989U, 1277301341U, 3006021786U, 855540956U, 288025710U,\n\t1919594237U, 2331223864U, 177452412U, 2475870369U, 2689291749U,\n\t 865194284U, 253432152U, 2628531804U, 2861208555U, 2361597573U,\n\t1653952120U, 1039661024U, 2159959078U, 3709040440U, 3564718533U,\n\t2596878672U, 2041442161U, 31164696U, 2662962485U, 3665637339U,\n\t1678115244U, 2699839832U, 3651968520U, 3521595541U, 458433303U,\n\t2423096824U, 21831741U, 380011703U, 2498168716U, 861806087U,\n\t1673574843U, 4188794405U, 2520563651U, 2632279153U, 2170465525U,\n\t4171949898U, 3886039621U, 1661344005U, 3424285243U, 992588372U,\n\t2500984144U, 2993248497U, 3590193895U, 1535327365U, 515645636U,\n\t 131633450U, 3729760261U, 1613045101U, 3254194278U, 15889678U,\n\t1493590689U, 244148718U, 2991472662U, 1401629333U, 777349878U,\n\t2501401703U, 4285518317U, 3794656178U, 955526526U, 3442142820U,\n\t3970298374U, 736025417U, 2737370764U, 1271509744U, 440570731U,\n\t 136141826U, 1596189518U, 923399175U, 257541519U, 3505774281U,\n\t2194358432U, 2518162991U, 1379893637U, 2667767062U, 3748146247U,\n\t1821712620U, 3923161384U, 1947811444U, 2392527197U, 4127419685U,\n\t1423694998U, 4156576871U, 1382885582U, 3420127279U, 3617499534U,\n\t2994377493U, 4038063986U, 1918458672U, 2983166794U, 4200449033U,\n\t 353294540U, 1609232588U, 243926648U, 2332803291U, 507996832U,\n\t2392838793U, 4075145196U, 2060984340U, 4287475136U, 88232602U,\n\t2491531140U, 4159725633U, 2272075455U, 759298618U, 201384554U,\n\t 838356250U, 1416268324U, 674476934U, 90795364U, 141672229U,\n\t3660399588U, 4196417251U, 3249270244U, 3774530247U, 59587265U,\n\t3683164208U, 19392575U, 1463123697U, 1882205379U, 293780489U,\n\t2553160622U, 2933904694U, 675638239U, 2851336944U, 1435238743U,\n\t2448730183U, 804436302U, 2119845972U, 322560608U, 4097732704U,\n\t2987802540U, 641492617U, 2575442710U, 4217822703U, 3271835300U,\n\t2836418300U, 3739921620U, 2138378768U, 2879771855U, 4294903423U,\n\t3121097946U, 2603440486U, 2560820391U, 1012930944U, 2313499967U,\n\t 584489368U, 3431165766U, 897384869U, 2062537737U, 2847889234U,\n\t3742362450U, 2951174585U, 4204621084U, 1109373893U, 3668075775U,\n\t2750138839U, 3518055702U, 733072558U, 4169325400U, 788493625U\n};\nstatic const uint64_t init_gen_rand_64_expected[] = {\n\tKQU(16924766246869039260), KQU( 8201438687333352714),\n\tKQU( 2265290287015001750), KQU(18397264611805473832),\n\tKQU( 3375255223302384358), KQU( 6345559975416828796),\n\tKQU(18229739242790328073), KQU( 7596792742098800905),\n\tKQU( 255338647169685981), KQU( 2052747240048610300),\n\tKQU(18328151576097299343), KQU(12472905421133796567),\n\tKQU(11315245349717600863), KQU(16594110197775871209),\n\tKQU(15708751964632456450), KQU(10452031272054632535),\n\tKQU(11097646720811454386), KQU( 4556090668445745441),\n\tKQU(17116187693090663106), KQU(14931526836144510645),\n\tKQU( 9190752218020552591), KQU( 9625800285771901401),\n\tKQU(13995141077659972832), KQU( 5194209094927829625),\n\tKQU( 4156788379151063303), KQU( 8523452593770139494),\n\tKQU(14082382103049296727), KQU( 2462601863986088483),\n\tKQU( 3030583461592840678), KQU( 5221622077872827681),\n\tKQU( 3084210671228981236), KQU(13956758381389953823),\n\tKQU(13503889856213423831), KQU(15696904024189836170),\n\tKQU( 4612584152877036206), KQU( 6231135538447867881),\n\tKQU(10172457294158869468), KQU( 6452258628466708150),\n\tKQU(14044432824917330221), KQU( 370168364480044279),\n\tKQU(10102144686427193359), KQU( 667870489994776076),\n\tKQU( 2732271956925885858), KQU(18027788905977284151),\n\tKQU(15009842788582923859), KQU( 7136357960180199542),\n\tKQU(15901736243475578127), KQU(16951293785352615701),\n\tKQU(10551492125243691632), KQU(17668869969146434804),\n\tKQU(13646002971174390445), KQU( 9804471050759613248),\n\tKQU( 5511670439655935493), KQU(18103342091070400926),\n\tKQU(17224512747665137533), KQU(15534627482992618168),\n\tKQU( 1423813266186582647), KQU(15821176807932930024),\n\tKQU( 30323369733607156), KQU(11599382494723479403),\n\tKQU( 653856076586810062), KQU( 3176437395144899659),\n\tKQU(14028076268147963917), KQU(16156398271809666195),\n\tKQU( 3166955484848201676), KQU( 5746805620136919390),\n\tKQU(17297845208891256593), KQU(11691653183226428483),\n\tKQU(17900026146506981577), KQU(15387382115755971042),\n\tKQU(16923567681040845943), KQU( 8039057517199388606),\n\tKQU(11748409241468629263), KQU( 794358245539076095),\n\tKQU(13438501964693401242), KQU(14036803236515618962),\n\tKQU( 5252311215205424721), KQU(17806589612915509081),\n\tKQU( 6802767092397596006), KQU(14212120431184557140),\n\tKQU( 1072951366761385712), KQU(13098491780722836296),\n\tKQU( 9466676828710797353), KQU(12673056849042830081),\n\tKQU(12763726623645357580), KQU(16468961652999309493),\n\tKQU(15305979875636438926), KQU(17444713151223449734),\n\tKQU( 5692214267627883674), KQU(13049589139196151505),\n\tKQU( 880115207831670745), KQU( 1776529075789695498),\n\tKQU(16695225897801466485), KQU(10666901778795346845),\n\tKQU( 6164389346722833869), KQU( 2863817793264300475),\n\tKQU( 9464049921886304754), KQU( 3993566636740015468),\n\tKQU( 9983749692528514136), KQU(16375286075057755211),\n\tKQU(16042643417005440820), KQU(11445419662923489877),\n\tKQU( 7999038846885158836), KQU( 6721913661721511535),\n\tKQU( 5363052654139357320), KQU( 1817788761173584205),\n\tKQU(13290974386445856444), KQU( 4650350818937984680),\n\tKQU( 8219183528102484836), KQU( 1569862923500819899),\n\tKQU( 4189359732136641860), KQU(14202822961683148583),\n\tKQU( 4457498315309429058), KQU(13089067387019074834),\n\tKQU(11075517153328927293), KQU(10277016248336668389),\n\tKQU( 7070509725324401122), KQU(17808892017780289380),\n\tKQU(13143367339909287349), KQU( 1377743745360085151),\n\tKQU( 5749341807421286485), KQU(14832814616770931325),\n\tKQU( 7688820635324359492), KQU(10960474011539770045),\n\tKQU( 81970066653179790), KQU(12619476072607878022),\n\tKQU( 4419566616271201744), KQU(15147917311750568503),\n\tKQU( 5549739182852706345), KQU( 7308198397975204770),\n\tKQU(13580425496671289278), KQU(17070764785210130301),\n\tKQU( 8202832846285604405), KQU( 6873046287640887249),\n\tKQU( 6927424434308206114), KQU( 6139014645937224874),\n\tKQU(10290373645978487639), KQU(15904261291701523804),\n\tKQU( 9628743442057826883), KQU(18383429096255546714),\n\tKQU( 4977413265753686967), KQU( 7714317492425012869),\n\tKQU( 9025232586309926193), KQU(14627338359776709107),\n\tKQU(14759849896467790763), KQU(10931129435864423252),\n\tKQU( 4588456988775014359), KQU(10699388531797056724),\n\tKQU( 468652268869238792), KQU( 5755943035328078086),\n\tKQU( 2102437379988580216), KQU( 9986312786506674028),\n\tKQU( 2654207180040945604), KQU( 8726634790559960062),\n\tKQU( 100497234871808137), KQU( 2800137176951425819),\n\tKQU( 6076627612918553487), KQU( 5780186919186152796),\n\tKQU( 8179183595769929098), KQU( 6009426283716221169),\n\tKQU( 2796662551397449358), KQU( 1756961367041986764),\n\tKQU( 6972897917355606205), KQU(14524774345368968243),\n\tKQU( 2773529684745706940), KQU( 4853632376213075959),\n\tKQU( 4198177923731358102), KQU( 8271224913084139776),\n\tKQU( 2741753121611092226), KQU(16782366145996731181),\n\tKQU(15426125238972640790), KQU(13595497100671260342),\n\tKQU( 3173531022836259898), KQU( 6573264560319511662),\n\tKQU(18041111951511157441), KQU( 2351433581833135952),\n\tKQU( 3113255578908173487), KQU( 1739371330877858784),\n\tKQU(16046126562789165480), KQU( 8072101652214192925),\n\tKQU(15267091584090664910), KQU( 9309579200403648940),\n\tKQU( 5218892439752408722), KQU(14492477246004337115),\n\tKQU(17431037586679770619), KQU( 7385248135963250480),\n\tKQU( 9580144956565560660), KQU( 4919546228040008720),\n\tKQU(15261542469145035584), KQU(18233297270822253102),\n\tKQU( 5453248417992302857), KQU( 9309519155931460285),\n\tKQU(10342813012345291756), KQU(15676085186784762381),\n\tKQU(15912092950691300645), KQU( 9371053121499003195),\n\tKQU( 9897186478226866746), KQU(14061858287188196327),\n\tKQU( 122575971620788119), KQU(12146750969116317754),\n\tKQU( 4438317272813245201), KQU( 8332576791009527119),\n\tKQU(13907785691786542057), KQU(10374194887283287467),\n\tKQU( 2098798755649059566), KQU( 3416235197748288894),\n\tKQU( 8688269957320773484), KQU( 7503964602397371571),\n\tKQU(16724977015147478236), KQU( 9461512855439858184),\n\tKQU(13259049744534534727), KQU( 3583094952542899294),\n\tKQU( 8764245731305528292), KQU(13240823595462088985),\n\tKQU(13716141617617910448), KQU(18114969519935960955),\n\tKQU( 2297553615798302206), KQU( 4585521442944663362),\n\tKQU(17776858680630198686), KQU( 4685873229192163363),\n\tKQU( 152558080671135627), KQU(15424900540842670088),\n\tKQU(13229630297130024108), KQU(17530268788245718717),\n\tKQU(16675633913065714144), KQU( 3158912717897568068),\n\tKQU(15399132185380087288), KQU( 7401418744515677872),\n\tKQU(13135412922344398535), KQU( 6385314346100509511),\n\tKQU(13962867001134161139), KQU(10272780155442671999),\n\tKQU(12894856086597769142), KQU(13340877795287554994),\n\tKQU(12913630602094607396), KQU(12543167911119793857),\n\tKQU(17343570372251873096), KQU(10959487764494150545),\n\tKQU( 6966737953093821128), KQU(13780699135496988601),\n\tKQU( 4405070719380142046), KQU(14923788365607284982),\n\tKQU( 2869487678905148380), KQU( 6416272754197188403),\n\tKQU(15017380475943612591), KQU( 1995636220918429487),\n\tKQU( 3402016804620122716), KQU(15800188663407057080),\n\tKQU(11362369990390932882), KQU(15262183501637986147),\n\tKQU(10239175385387371494), KQU( 9352042420365748334),\n\tKQU( 1682457034285119875), KQU( 1724710651376289644),\n\tKQU( 2038157098893817966), KQU( 9897825558324608773),\n\tKQU( 1477666236519164736), KQU(16835397314511233640),\n\tKQU(10370866327005346508), KQU(10157504370660621982),\n\tKQU(12113904045335882069), KQU(13326444439742783008),\n\tKQU(11302769043000765804), KQU(13594979923955228484),\n\tKQU(11779351762613475968), KQU( 3786101619539298383),\n\tKQU( 8021122969180846063), KQU(15745904401162500495),\n\tKQU(10762168465993897267), KQU(13552058957896319026),\n\tKQU(11200228655252462013), KQU( 5035370357337441226),\n\tKQU( 7593918984545500013), KQU( 5418554918361528700),\n\tKQU( 4858270799405446371), KQU( 9974659566876282544),\n\tKQU(18227595922273957859), KQU( 2772778443635656220),\n\tKQU(14285143053182085385), KQU( 9939700992429600469),\n\tKQU(12756185904545598068), KQU( 2020783375367345262),\n\tKQU( 57026775058331227), KQU( 950827867930065454),\n\tKQU( 6602279670145371217), KQU( 2291171535443566929),\n\tKQU( 5832380724425010313), KQU( 1220343904715982285),\n\tKQU(17045542598598037633), KQU(15460481779702820971),\n\tKQU(13948388779949365130), KQU(13975040175430829518),\n\tKQU(17477538238425541763), KQU(11104663041851745725),\n\tKQU(15860992957141157587), KQU(14529434633012950138),\n\tKQU( 2504838019075394203), KQU( 7512113882611121886),\n\tKQU( 4859973559980886617), KQU( 1258601555703250219),\n\tKQU(15594548157514316394), KQU( 4516730171963773048),\n\tKQU(11380103193905031983), KQU( 6809282239982353344),\n\tKQU(18045256930420065002), KQU( 2453702683108791859),\n\tKQU( 977214582986981460), KQU( 2006410402232713466),\n\tKQU( 6192236267216378358), KQU( 3429468402195675253),\n\tKQU(18146933153017348921), KQU(17369978576367231139),\n\tKQU( 1246940717230386603), KQU(11335758870083327110),\n\tKQU(14166488801730353682), KQU( 9008573127269635732),\n\tKQU(10776025389820643815), KQU(15087605441903942962),\n\tKQU( 1359542462712147922), KQU(13898874411226454206),\n\tKQU(17911176066536804411), KQU( 9435590428600085274),\n\tKQU( 294488509967864007), KQU( 8890111397567922046),\n\tKQU( 7987823476034328778), KQU(13263827582440967651),\n\tKQU( 7503774813106751573), KQU(14974747296185646837),\n\tKQU( 8504765037032103375), KQU(17340303357444536213),\n\tKQU( 7704610912964485743), KQU( 8107533670327205061),\n\tKQU( 9062969835083315985), KQU(16968963142126734184),\n\tKQU(12958041214190810180), KQU( 2720170147759570200),\n\tKQU( 2986358963942189566), KQU(14884226322219356580),\n\tKQU( 286224325144368520), KQU(11313800433154279797),\n\tKQU(18366849528439673248), KQU(17899725929482368789),\n\tKQU( 3730004284609106799), KQU( 1654474302052767205),\n\tKQU( 5006698007047077032), KQU( 8196893913601182838),\n\tKQU(15214541774425211640), KQU(17391346045606626073),\n\tKQU( 8369003584076969089), KQU( 3939046733368550293),\n\tKQU(10178639720308707785), KQU( 2180248669304388697),\n\tKQU( 62894391300126322), KQU( 9205708961736223191),\n\tKQU( 6837431058165360438), KQU( 3150743890848308214),\n\tKQU(17849330658111464583), KQU(12214815643135450865),\n\tKQU(13410713840519603402), KQU( 3200778126692046802),\n\tKQU(13354780043041779313), KQU( 800850022756886036),\n\tKQU(15660052933953067433), KQU( 6572823544154375676),\n\tKQU(11030281857015819266), KQU(12682241941471433835),\n\tKQU(11654136407300274693), KQU( 4517795492388641109),\n\tKQU( 9757017371504524244), KQU(17833043400781889277),\n\tKQU(12685085201747792227), KQU(10408057728835019573),\n\tKQU( 98370418513455221), KQU( 6732663555696848598),\n\tKQU(13248530959948529780), KQU( 3530441401230622826),\n\tKQU(18188251992895660615), KQU( 1847918354186383756),\n\tKQU( 1127392190402660921), KQU(11293734643143819463),\n\tKQU( 3015506344578682982), KQU(13852645444071153329),\n\tKQU( 2121359659091349142), KQU( 1294604376116677694),\n\tKQU( 5616576231286352318), KQU( 7112502442954235625),\n\tKQU(11676228199551561689), KQU(12925182803007305359),\n\tKQU( 7852375518160493082), KQU( 1136513130539296154),\n\tKQU( 5636923900916593195), KQU( 3221077517612607747),\n\tKQU(17784790465798152513), KQU( 3554210049056995938),\n\tKQU(17476839685878225874), KQU( 3206836372585575732),\n\tKQU( 2765333945644823430), KQU(10080070903718799528),\n\tKQU( 5412370818878286353), KQU( 9689685887726257728),\n\tKQU( 8236117509123533998), KQU( 1951139137165040214),\n\tKQU( 4492205209227980349), KQU(16541291230861602967),\n\tKQU( 1424371548301437940), KQU( 9117562079669206794),\n\tKQU(14374681563251691625), KQU(13873164030199921303),\n\tKQU( 6680317946770936731), KQU(15586334026918276214),\n\tKQU(10896213950976109802), KQU( 9506261949596413689),\n\tKQU( 9903949574308040616), KQU( 6038397344557204470),\n\tKQU( 174601465422373648), KQU(15946141191338238030),\n\tKQU(17142225620992044937), KQU( 7552030283784477064),\n\tKQU( 2947372384532947997), KQU( 510797021688197711),\n\tKQU( 4962499439249363461), KQU( 23770320158385357),\n\tKQU( 959774499105138124), KQU( 1468396011518788276),\n\tKQU( 2015698006852312308), KQU( 4149400718489980136),\n\tKQU( 5992916099522371188), KQU(10819182935265531076),\n\tKQU(16189787999192351131), KQU( 342833961790261950),\n\tKQU(12470830319550495336), KQU(18128495041912812501),\n\tKQU( 1193600899723524337), KQU( 9056793666590079770),\n\tKQU( 2154021227041669041), KQU( 4963570213951235735),\n\tKQU( 4865075960209211409), KQU( 2097724599039942963),\n\tKQU( 2024080278583179845), KQU(11527054549196576736),\n\tKQU(10650256084182390252), KQU( 4808408648695766755),\n\tKQU( 1642839215013788844), KQU(10607187948250398390),\n\tKQU( 7076868166085913508), KQU( 730522571106887032),\n\tKQU(12500579240208524895), KQU( 4484390097311355324),\n\tKQU(15145801330700623870), KQU( 8055827661392944028),\n\tKQU( 5865092976832712268), KQU(15159212508053625143),\n\tKQU( 3560964582876483341), KQU( 4070052741344438280),\n\tKQU( 6032585709886855634), KQU(15643262320904604873),\n\tKQU( 2565119772293371111), KQU( 318314293065348260),\n\tKQU(15047458749141511872), KQU( 7772788389811528730),\n\tKQU( 7081187494343801976), KQU( 6465136009467253947),\n\tKQU(10425940692543362069), KQU( 554608190318339115),\n\tKQU(14796699860302125214), KQU( 1638153134431111443),\n\tKQU(10336967447052276248), KQU( 8412308070396592958),\n\tKQU( 4004557277152051226), KQU( 8143598997278774834),\n\tKQU(16413323996508783221), KQU(13139418758033994949),\n\tKQU( 9772709138335006667), KQU( 2818167159287157659),\n\tKQU(17091740573832523669), KQU(14629199013130751608),\n\tKQU(18268322711500338185), KQU( 8290963415675493063),\n\tKQU( 8830864907452542588), KQU( 1614839084637494849),\n\tKQU(14855358500870422231), KQU( 3472996748392519937),\n\tKQU(15317151166268877716), KQU( 5825895018698400362),\n\tKQU(16730208429367544129), KQU(10481156578141202800),\n\tKQU( 4746166512382823750), KQU(12720876014472464998),\n\tKQU( 8825177124486735972), KQU(13733447296837467838),\n\tKQU( 6412293741681359625), KQU( 8313213138756135033),\n\tKQU(11421481194803712517), KQU( 7997007691544174032),\n\tKQU( 6812963847917605930), KQU( 9683091901227558641),\n\tKQU(14703594165860324713), KQU( 1775476144519618309),\n\tKQU( 2724283288516469519), KQU( 717642555185856868),\n\tKQU( 8736402192215092346), KQU(11878800336431381021),\n\tKQU( 4348816066017061293), KQU( 6115112756583631307),\n\tKQU( 9176597239667142976), KQU(12615622714894259204),\n\tKQU(10283406711301385987), KQU( 5111762509485379420),\n\tKQU( 3118290051198688449), KQU( 7345123071632232145),\n\tKQU( 9176423451688682359), KQU( 4843865456157868971),\n\tKQU(12008036363752566088), KQU(12058837181919397720),\n\tKQU( 2145073958457347366), KQU( 1526504881672818067),\n\tKQU( 3488830105567134848), KQU(13208362960674805143),\n\tKQU( 4077549672899572192), KQU( 7770995684693818365),\n\tKQU( 1398532341546313593), KQU(12711859908703927840),\n\tKQU( 1417561172594446813), KQU(17045191024194170604),\n\tKQU( 4101933177604931713), KQU(14708428834203480320),\n\tKQU(17447509264469407724), KQU(14314821973983434255),\n\tKQU(17990472271061617265), KQU( 5087756685841673942),\n\tKQU(12797820586893859939), KQU( 1778128952671092879),\n\tKQU( 3535918530508665898), KQU( 9035729701042481301),\n\tKQU(14808661568277079962), KQU(14587345077537747914),\n\tKQU(11920080002323122708), KQU( 6426515805197278753),\n\tKQU( 3295612216725984831), KQU(11040722532100876120),\n\tKQU(12305952936387598754), KQU(16097391899742004253),\n\tKQU( 4908537335606182208), KQU(12446674552196795504),\n\tKQU(16010497855816895177), KQU( 9194378874788615551),\n\tKQU( 3382957529567613384), KQU( 5154647600754974077),\n\tKQU( 9801822865328396141), KQU( 9023662173919288143),\n\tKQU(17623115353825147868), KQU( 8238115767443015816),\n\tKQU(15811444159859002560), KQU( 9085612528904059661),\n\tKQU( 6888601089398614254), KQU( 258252992894160189),\n\tKQU( 6704363880792428622), KQU( 6114966032147235763),\n\tKQU(11075393882690261875), KQU( 8797664238933620407),\n\tKQU( 5901892006476726920), KQU( 5309780159285518958),\n\tKQU(14940808387240817367), KQU(14642032021449656698),\n\tKQU( 9808256672068504139), KQU( 3670135111380607658),\n\tKQU(11211211097845960152), KQU( 1474304506716695808),\n\tKQU(15843166204506876239), KQU( 7661051252471780561),\n\tKQU(10170905502249418476), KQU( 7801416045582028589),\n\tKQU( 2763981484737053050), KQU( 9491377905499253054),\n\tKQU(16201395896336915095), KQU( 9256513756442782198),\n\tKQU( 5411283157972456034), KQU( 5059433122288321676),\n\tKQU( 4327408006721123357), KQU( 9278544078834433377),\n\tKQU( 7601527110882281612), KQU(11848295896975505251),\n\tKQU(12096998801094735560), KQU(14773480339823506413),\n\tKQU(15586227433895802149), KQU(12786541257830242872),\n\tKQU( 6904692985140503067), KQU( 5309011515263103959),\n\tKQU(12105257191179371066), KQU(14654380212442225037),\n\tKQU( 2556774974190695009), KQU( 4461297399927600261),\n\tKQU(14888225660915118646), KQU(14915459341148291824),\n\tKQU( 2738802166252327631), KQU( 6047155789239131512),\n\tKQU(12920545353217010338), KQU(10697617257007840205),\n\tKQU( 2751585253158203504), KQU(13252729159780047496),\n\tKQU(14700326134672815469), KQU(14082527904374600529),\n\tKQU(16852962273496542070), KQU(17446675504235853907),\n\tKQU(15019600398527572311), KQU(12312781346344081551),\n\tKQU(14524667935039810450), KQU( 5634005663377195738),\n\tKQU(11375574739525000569), KQU( 2423665396433260040),\n\tKQU( 5222836914796015410), KQU( 4397666386492647387),\n\tKQU( 4619294441691707638), KQU( 665088602354770716),\n\tKQU(13246495665281593610), KQU( 6564144270549729409),\n\tKQU(10223216188145661688), KQU( 3961556907299230585),\n\tKQU(11543262515492439914), KQU(16118031437285993790),\n\tKQU( 7143417964520166465), KQU(13295053515909486772),\n\tKQU( 40434666004899675), KQU(17127804194038347164),\n\tKQU( 8599165966560586269), KQU( 8214016749011284903),\n\tKQU(13725130352140465239), KQU( 5467254474431726291),\n\tKQU( 7748584297438219877), KQU(16933551114829772472),\n\tKQU( 2169618439506799400), KQU( 2169787627665113463),\n\tKQU(17314493571267943764), KQU(18053575102911354912),\n\tKQU(11928303275378476973), KQU(11593850925061715550),\n\tKQU(17782269923473589362), KQU( 3280235307704747039),\n\tKQU( 6145343578598685149), KQU(17080117031114086090),\n\tKQU(18066839902983594755), KQU( 6517508430331020706),\n\tKQU( 8092908893950411541), KQU(12558378233386153732),\n\tKQU( 4476532167973132976), KQU(16081642430367025016),\n\tKQU( 4233154094369139361), KQU( 8693630486693161027),\n\tKQU(11244959343027742285), KQU(12273503967768513508),\n\tKQU(14108978636385284876), KQU( 7242414665378826984),\n\tKQU( 6561316938846562432), KQU( 8601038474994665795),\n\tKQU(17532942353612365904), KQU(17940076637020912186),\n\tKQU( 7340260368823171304), KQU( 7061807613916067905),\n\tKQU(10561734935039519326), KQU(17990796503724650862),\n\tKQU( 6208732943911827159), KQU( 359077562804090617),\n\tKQU(14177751537784403113), KQU(10659599444915362902),\n\tKQU(15081727220615085833), KQU(13417573895659757486),\n\tKQU(15513842342017811524), KQU(11814141516204288231),\n\tKQU( 1827312513875101814), KQU( 2804611699894603103),\n\tKQU(17116500469975602763), KQU(12270191815211952087),\n\tKQU(12256358467786024988), KQU(18435021722453971267),\n\tKQU( 671330264390865618), KQU( 476504300460286050),\n\tKQU(16465470901027093441), KQU( 4047724406247136402),\n\tKQU( 1322305451411883346), KQU( 1388308688834322280),\n\tKQU( 7303989085269758176), KQU( 9323792664765233642),\n\tKQU( 4542762575316368936), KQU(17342696132794337618),\n\tKQU( 4588025054768498379), KQU(13415475057390330804),\n\tKQU(17880279491733405570), KQU(10610553400618620353),\n\tKQU( 3180842072658960139), KQU(13002966655454270120),\n\tKQU( 1665301181064982826), KQU( 7083673946791258979),\n\tKQU( 190522247122496820), KQU(17388280237250677740),\n\tKQU( 8430770379923642945), KQU(12987180971921668584),\n\tKQU( 2311086108365390642), KQU( 2870984383579822345),\n\tKQU(14014682609164653318), KQU(14467187293062251484),\n\tKQU( 192186361147413298), KQU(15171951713531796524),\n\tKQU( 9900305495015948728), KQU(17958004775615466344),\n\tKQU(14346380954498606514), KQU(18040047357617407096),\n\tKQU( 5035237584833424532), KQU(15089555460613972287),\n\tKQU( 4131411873749729831), KQU( 1329013581168250330),\n\tKQU(10095353333051193949), KQU(10749518561022462716),\n\tKQU( 9050611429810755847), KQU(15022028840236655649),\n\tKQU( 8775554279239748298), KQU(13105754025489230502),\n\tKQU(15471300118574167585), KQU( 89864764002355628),\n\tKQU( 8776416323420466637), KQU( 5280258630612040891),\n\tKQU( 2719174488591862912), KQU( 7599309137399661994),\n\tKQU(15012887256778039979), KQU(14062981725630928925),\n\tKQU(12038536286991689603), KQU( 7089756544681775245),\n\tKQU(10376661532744718039), KQU( 1265198725901533130),\n\tKQU(13807996727081142408), KQU( 2935019626765036403),\n\tKQU( 7651672460680700141), KQU( 3644093016200370795),\n\tKQU( 2840982578090080674), KQU(17956262740157449201),\n\tKQU(18267979450492880548), KQU(11799503659796848070),\n\tKQU( 9942537025669672388), KQU(11886606816406990297),\n\tKQU( 5488594946437447576), KQU( 7226714353282744302),\n\tKQU( 3784851653123877043), KQU( 878018453244803041),\n\tKQU(12110022586268616085), KQU( 734072179404675123),\n\tKQU(11869573627998248542), KQU( 469150421297783998),\n\tKQU( 260151124912803804), KQU(11639179410120968649),\n\tKQU( 9318165193840846253), KQU(12795671722734758075),\n\tKQU(15318410297267253933), KQU( 691524703570062620),\n\tKQU( 5837129010576994601), KQU(15045963859726941052),\n\tKQU( 5850056944932238169), KQU(12017434144750943807),\n\tKQU( 7447139064928956574), KQU( 3101711812658245019),\n\tKQU(16052940704474982954), KQU(18195745945986994042),\n\tKQU( 8932252132785575659), KQU(13390817488106794834),\n\tKQU(11582771836502517453), KQU( 4964411326683611686),\n\tKQU( 2195093981702694011), KQU(14145229538389675669),\n\tKQU(16459605532062271798), KQU( 866316924816482864),\n\tKQU( 4593041209937286377), KQU( 8415491391910972138),\n\tKQU( 4171236715600528969), KQU(16637569303336782889),\n\tKQU( 2002011073439212680), KQU(17695124661097601411),\n\tKQU( 4627687053598611702), KQU( 7895831936020190403),\n\tKQU( 8455951300917267802), KQU( 2923861649108534854),\n\tKQU( 8344557563927786255), KQU( 6408671940373352556),\n\tKQU(12210227354536675772), KQU(14294804157294222295),\n\tKQU(10103022425071085127), KQU(10092959489504123771),\n\tKQU( 6554774405376736268), KQU(12629917718410641774),\n\tKQU( 6260933257596067126), KQU( 2460827021439369673),\n\tKQU( 2541962996717103668), KQU( 597377203127351475),\n\tKQU( 5316984203117315309), KQU( 4811211393563241961),\n\tKQU(13119698597255811641), KQU( 8048691512862388981),\n\tKQU(10216818971194073842), KQU( 4612229970165291764),\n\tKQU(10000980798419974770), KQU( 6877640812402540687),\n\tKQU( 1488727563290436992), KQU( 2227774069895697318),\n\tKQU(11237754507523316593), KQU(13478948605382290972),\n\tKQU( 1963583846976858124), KQU( 5512309205269276457),\n\tKQU( 3972770164717652347), KQU( 3841751276198975037),\n\tKQU(10283343042181903117), KQU( 8564001259792872199),\n\tKQU(16472187244722489221), KQU( 8953493499268945921),\n\tKQU( 3518747340357279580), KQU( 4003157546223963073),\n\tKQU( 3270305958289814590), KQU( 3966704458129482496),\n\tKQU( 8122141865926661939), KQU(14627734748099506653),\n\tKQU(13064426990862560568), KQU( 2414079187889870829),\n\tKQU( 5378461209354225306), KQU(10841985740128255566),\n\tKQU( 538582442885401738), KQU( 7535089183482905946),\n\tKQU(16117559957598879095), KQU( 8477890721414539741),\n\tKQU( 1459127491209533386), KQU(17035126360733620462),\n\tKQU( 8517668552872379126), KQU(10292151468337355014),\n\tKQU(17081267732745344157), KQU(13751455337946087178),\n\tKQU(14026945459523832966), KQU( 6653278775061723516),\n\tKQU(10619085543856390441), KQU( 2196343631481122885),\n\tKQU(10045966074702826136), KQU(10082317330452718282),\n\tKQU( 5920859259504831242), KQU( 9951879073426540617),\n\tKQU( 7074696649151414158), KQU(15808193543879464318),\n\tKQU( 7385247772746953374), KQU( 3192003544283864292),\n\tKQU(18153684490917593847), KQU(12423498260668568905),\n\tKQU(10957758099756378169), KQU(11488762179911016040),\n\tKQU( 2099931186465333782), KQU(11180979581250294432),\n\tKQU( 8098916250668367933), KQU( 3529200436790763465),\n\tKQU(12988418908674681745), KQU( 6147567275954808580),\n\tKQU( 3207503344604030989), KQU(10761592604898615360),\n\tKQU( 229854861031893504), KQU( 8809853962667144291),\n\tKQU(13957364469005693860), KQU( 7634287665224495886),\n\tKQU(12353487366976556874), KQU( 1134423796317152034),\n\tKQU( 2088992471334107068), KQU( 7393372127190799698),\n\tKQU( 1845367839871058391), KQU( 207922563987322884),\n\tKQU(11960870813159944976), KQU(12182120053317317363),\n\tKQU(17307358132571709283), KQU(13871081155552824936),\n\tKQU(18304446751741566262), KQU( 7178705220184302849),\n\tKQU(10929605677758824425), KQU(16446976977835806844),\n\tKQU(13723874412159769044), KQU( 6942854352100915216),\n\tKQU( 1726308474365729390), KQU( 2150078766445323155),\n\tKQU(15345558947919656626), KQU(12145453828874527201),\n\tKQU( 2054448620739726849), KQU( 2740102003352628137),\n\tKQU(11294462163577610655), KQU( 756164283387413743),\n\tKQU(17841144758438810880), KQU(10802406021185415861),\n\tKQU( 8716455530476737846), KQU( 6321788834517649606),\n\tKQU(14681322910577468426), KQU(17330043563884336387),\n\tKQU(12701802180050071614), KQU(14695105111079727151),\n\tKQU( 5112098511654172830), KQU( 4957505496794139973),\n\tKQU( 8270979451952045982), KQU(12307685939199120969),\n\tKQU(12425799408953443032), KQU( 8376410143634796588),\n\tKQU(16621778679680060464), KQU( 3580497854566660073),\n\tKQU( 1122515747803382416), KQU( 857664980960597599),\n\tKQU( 6343640119895925918), KQU(12878473260854462891),\n\tKQU(10036813920765722626), KQU(14451335468363173812),\n\tKQU( 5476809692401102807), KQU(16442255173514366342),\n\tKQU(13060203194757167104), KQU(14354124071243177715),\n\tKQU(15961249405696125227), KQU(13703893649690872584),\n\tKQU( 363907326340340064), KQU( 6247455540491754842),\n\tKQU(12242249332757832361), KQU( 156065475679796717),\n\tKQU( 9351116235749732355), KQU( 4590350628677701405),\n\tKQU( 1671195940982350389), KQU(13501398458898451905),\n\tKQU( 6526341991225002255), KQU( 1689782913778157592),\n\tKQU( 7439222350869010334), KQU(13975150263226478308),\n\tKQU(11411961169932682710), KQU(17204271834833847277),\n\tKQU( 541534742544435367), KQU( 6591191931218949684),\n\tKQU( 2645454775478232486), KQU( 4322857481256485321),\n\tKQU( 8477416487553065110), KQU(12902505428548435048),\n\tKQU( 971445777981341415), KQU(14995104682744976712),\n\tKQU( 4243341648807158063), KQU( 8695061252721927661),\n\tKQU( 5028202003270177222), KQU( 2289257340915567840),\n\tKQU(13870416345121866007), KQU(13994481698072092233),\n\tKQU( 6912785400753196481), KQU( 2278309315841980139),\n\tKQU( 4329765449648304839), KQU( 5963108095785485298),\n\tKQU( 4880024847478722478), KQU(16015608779890240947),\n\tKQU( 1866679034261393544), KQU( 914821179919731519),\n\tKQU( 9643404035648760131), KQU( 2418114953615593915),\n\tKQU( 944756836073702374), KQU(15186388048737296834),\n\tKQU( 7723355336128442206), KQU( 7500747479679599691),\n\tKQU(18013961306453293634), KQU( 2315274808095756456),\n\tKQU(13655308255424029566), KQU(17203800273561677098),\n\tKQU( 1382158694422087756), KQU( 5090390250309588976),\n\tKQU( 517170818384213989), KQU( 1612709252627729621),\n\tKQU( 1330118955572449606), KQU( 300922478056709885),\n\tKQU(18115693291289091987), KQU(13491407109725238321),\n\tKQU(15293714633593827320), KQU( 5151539373053314504),\n\tKQU( 5951523243743139207), KQU(14459112015249527975),\n\tKQU( 5456113959000700739), KQU( 3877918438464873016),\n\tKQU(12534071654260163555), KQU(15871678376893555041),\n\tKQU(11005484805712025549), KQU(16353066973143374252),\n\tKQU( 4358331472063256685), KQU( 8268349332210859288),\n\tKQU(12485161590939658075), KQU(13955993592854471343),\n\tKQU( 5911446886848367039), KQU(14925834086813706974),\n\tKQU( 6590362597857994805), KQU( 1280544923533661875),\n\tKQU( 1637756018947988164), KQU( 4734090064512686329),\n\tKQU(16693705263131485912), KQU( 6834882340494360958),\n\tKQU( 8120732176159658505), KQU( 2244371958905329346),\n\tKQU(10447499707729734021), KQU( 7318742361446942194),\n\tKQU( 8032857516355555296), KQU(14023605983059313116),\n\tKQU( 1032336061815461376), KQU( 9840995337876562612),\n\tKQU( 9869256223029203587), KQU(12227975697177267636),\n\tKQU(12728115115844186033), KQU( 7752058479783205470),\n\tKQU( 729733219713393087), KQU(12954017801239007622)\n};\nstatic const uint64_t init_by_array_64_expected[] = {\n\tKQU( 2100341266307895239), KQU( 8344256300489757943),\n\tKQU(15687933285484243894), KQU( 8268620370277076319),\n\tKQU(12371852309826545459), KQU( 8800491541730110238),\n\tKQU(18113268950100835773), KQU( 2886823658884438119),\n\tKQU( 3293667307248180724), KQU( 9307928143300172731),\n\tKQU( 7688082017574293629), KQU( 900986224735166665),\n\tKQU( 9977972710722265039), KQU( 6008205004994830552),\n\tKQU( 546909104521689292), KQU( 7428471521869107594),\n\tKQU(14777563419314721179), KQU(16116143076567350053),\n\tKQU( 5322685342003142329), KQU( 4200427048445863473),\n\tKQU( 4693092150132559146), KQU(13671425863759338582),\n\tKQU( 6747117460737639916), KQU( 4732666080236551150),\n\tKQU( 5912839950611941263), KQU( 3903717554504704909),\n\tKQU( 2615667650256786818), KQU(10844129913887006352),\n\tKQU(13786467861810997820), KQU(14267853002994021570),\n\tKQU(13767807302847237439), KQU(16407963253707224617),\n\tKQU( 4802498363698583497), KQU( 2523802839317209764),\n\tKQU( 3822579397797475589), KQU( 8950320572212130610),\n\tKQU( 3745623504978342534), KQU(16092609066068482806),\n\tKQU( 9817016950274642398), KQU(10591660660323829098),\n\tKQU(11751606650792815920), KQU( 5122873818577122211),\n\tKQU(17209553764913936624), KQU( 6249057709284380343),\n\tKQU(15088791264695071830), KQU(15344673071709851930),\n\tKQU( 4345751415293646084), KQU( 2542865750703067928),\n\tKQU(13520525127852368784), KQU(18294188662880997241),\n\tKQU( 3871781938044881523), KQU( 2873487268122812184),\n\tKQU(15099676759482679005), KQU(15442599127239350490),\n\tKQU( 6311893274367710888), KQU( 3286118760484672933),\n\tKQU( 4146067961333542189), KQU(13303942567897208770),\n\tKQU( 8196013722255630418), KQU( 4437815439340979989),\n\tKQU(15433791533450605135), KQU( 4254828956815687049),\n\tKQU( 1310903207708286015), KQU(10529182764462398549),\n\tKQU(14900231311660638810), KQU( 9727017277104609793),\n\tKQU( 1821308310948199033), KQU(11628861435066772084),\n\tKQU( 9469019138491546924), KQU( 3145812670532604988),\n\tKQU( 9938468915045491919), KQU( 1562447430672662142),\n\tKQU(13963995266697989134), KQU( 3356884357625028695),\n\tKQU( 4499850304584309747), KQU( 8456825817023658122),\n\tKQU(10859039922814285279), KQU( 8099512337972526555),\n\tKQU( 348006375109672149), KQU(11919893998241688603),\n\tKQU( 1104199577402948826), KQU(16689191854356060289),\n\tKQU(10992552041730168078), KQU( 7243733172705465836),\n\tKQU( 5668075606180319560), KQU(18182847037333286970),\n\tKQU( 4290215357664631322), KQU( 4061414220791828613),\n\tKQU(13006291061652989604), KQU( 7140491178917128798),\n\tKQU(12703446217663283481), KQU( 5500220597564558267),\n\tKQU(10330551509971296358), KQU(15958554768648714492),\n\tKQU( 5174555954515360045), KQU( 1731318837687577735),\n\tKQU( 3557700801048354857), KQU(13764012341928616198),\n\tKQU(13115166194379119043), KQU( 7989321021560255519),\n\tKQU( 2103584280905877040), KQU( 9230788662155228488),\n\tKQU(16396629323325547654), KQU( 657926409811318051),\n\tKQU(15046700264391400727), KQU( 5120132858771880830),\n\tKQU( 7934160097989028561), KQU( 6963121488531976245),\n\tKQU(17412329602621742089), KQU(15144843053931774092),\n\tKQU(17204176651763054532), KQU(13166595387554065870),\n\tKQU( 8590377810513960213), KQU( 5834365135373991938),\n\tKQU( 7640913007182226243), KQU( 3479394703859418425),\n\tKQU(16402784452644521040), KQU( 4993979809687083980),\n\tKQU(13254522168097688865), KQU(15643659095244365219),\n\tKQU( 5881437660538424982), KQU(11174892200618987379),\n\tKQU( 254409966159711077), KQU(17158413043140549909),\n\tKQU( 3638048789290376272), KQU( 1376816930299489190),\n\tKQU( 4622462095217761923), KQU(15086407973010263515),\n\tKQU(13253971772784692238), KQU( 5270549043541649236),\n\tKQU(11182714186805411604), KQU(12283846437495577140),\n\tKQU( 5297647149908953219), KQU(10047451738316836654),\n\tKQU( 4938228100367874746), KQU(12328523025304077923),\n\tKQU( 3601049438595312361), KQU( 9313624118352733770),\n\tKQU(13322966086117661798), KQU(16660005705644029394),\n\tKQU(11337677526988872373), KQU(13869299102574417795),\n\tKQU(15642043183045645437), KQU( 3021755569085880019),\n\tKQU( 4979741767761188161), KQU(13679979092079279587),\n\tKQU( 3344685842861071743), KQU(13947960059899588104),\n\tKQU( 305806934293368007), KQU( 5749173929201650029),\n\tKQU(11123724852118844098), KQU(15128987688788879802),\n\tKQU(15251651211024665009), KQU( 7689925933816577776),\n\tKQU(16732804392695859449), KQU(17087345401014078468),\n\tKQU(14315108589159048871), KQU( 4820700266619778917),\n\tKQU(16709637539357958441), KQU( 4936227875177351374),\n\tKQU( 2137907697912987247), KQU(11628565601408395420),\n\tKQU( 2333250549241556786), KQU( 5711200379577778637),\n\tKQU( 5170680131529031729), KQU(12620392043061335164),\n\tKQU( 95363390101096078), KQU( 5487981914081709462),\n\tKQU( 1763109823981838620), KQU( 3395861271473224396),\n\tKQU( 1300496844282213595), KQU( 6894316212820232902),\n\tKQU(10673859651135576674), KQU( 5911839658857903252),\n\tKQU(17407110743387299102), KQU( 8257427154623140385),\n\tKQU(11389003026741800267), KQU( 4070043211095013717),\n\tKQU(11663806997145259025), KQU(15265598950648798210),\n\tKQU( 630585789434030934), KQU( 3524446529213587334),\n\tKQU( 7186424168495184211), KQU(10806585451386379021),\n\tKQU(11120017753500499273), KQU( 1586837651387701301),\n\tKQU(17530454400954415544), KQU( 9991670045077880430),\n\tKQU( 7550997268990730180), KQU( 8640249196597379304),\n\tKQU( 3522203892786893823), KQU(10401116549878854788),\n\tKQU(13690285544733124852), KQU( 8295785675455774586),\n\tKQU(15535716172155117603), KQU( 3112108583723722511),\n\tKQU(17633179955339271113), KQU(18154208056063759375),\n\tKQU( 1866409236285815666), KQU(13326075895396412882),\n\tKQU( 8756261842948020025), KQU( 6281852999868439131),\n\tKQU(15087653361275292858), KQU(10333923911152949397),\n\tKQU( 5265567645757408500), KQU(12728041843210352184),\n\tKQU( 6347959327507828759), KQU( 154112802625564758),\n\tKQU(18235228308679780218), KQU( 3253805274673352418),\n\tKQU( 4849171610689031197), KQU(17948529398340432518),\n\tKQU(13803510475637409167), KQU(13506570190409883095),\n\tKQU(15870801273282960805), KQU( 8451286481299170773),\n\tKQU( 9562190620034457541), KQU( 8518905387449138364),\n\tKQU(12681306401363385655), KQU( 3788073690559762558),\n\tKQU( 5256820289573487769), KQU( 2752021372314875467),\n\tKQU( 6354035166862520716), KQU( 4328956378309739069),\n\tKQU( 449087441228269600), KQU( 5533508742653090868),\n\tKQU( 1260389420404746988), KQU(18175394473289055097),\n\tKQU( 1535467109660399420), KQU( 8818894282874061442),\n\tKQU(12140873243824811213), KQU(15031386653823014946),\n\tKQU( 1286028221456149232), KQU( 6329608889367858784),\n\tKQU( 9419654354945132725), KQU( 6094576547061672379),\n\tKQU(17706217251847450255), KQU( 1733495073065878126),\n\tKQU(16918923754607552663), KQU( 8881949849954945044),\n\tKQU(12938977706896313891), KQU(14043628638299793407),\n\tKQU(18393874581723718233), KQU( 6886318534846892044),\n\tKQU(14577870878038334081), KQU(13541558383439414119),\n\tKQU(13570472158807588273), KQU(18300760537910283361),\n\tKQU( 818368572800609205), KQU( 1417000585112573219),\n\tKQU(12337533143867683655), KQU(12433180994702314480),\n\tKQU( 778190005829189083), KQU(13667356216206524711),\n\tKQU( 9866149895295225230), KQU(11043240490417111999),\n\tKQU( 1123933826541378598), KQU( 6469631933605123610),\n\tKQU(14508554074431980040), KQU(13918931242962026714),\n\tKQU( 2870785929342348285), KQU(14786362626740736974),\n\tKQU(13176680060902695786), KQU( 9591778613541679456),\n\tKQU( 9097662885117436706), KQU( 749262234240924947),\n\tKQU( 1944844067793307093), KQU( 4339214904577487742),\n\tKQU( 8009584152961946551), KQU(16073159501225501777),\n\tKQU( 3335870590499306217), KQU(17088312653151202847),\n\tKQU( 3108893142681931848), KQU(16636841767202792021),\n\tKQU(10423316431118400637), KQU( 8008357368674443506),\n\tKQU(11340015231914677875), KQU(17687896501594936090),\n\tKQU(15173627921763199958), KQU( 542569482243721959),\n\tKQU(15071714982769812975), KQU( 4466624872151386956),\n\tKQU( 1901780715602332461), KQU( 9822227742154351098),\n\tKQU( 1479332892928648780), KQU( 6981611948382474400),\n\tKQU( 7620824924456077376), KQU(14095973329429406782),\n\tKQU( 7902744005696185404), KQU(15830577219375036920),\n\tKQU(10287076667317764416), KQU(12334872764071724025),\n\tKQU( 4419302088133544331), KQU(14455842851266090520),\n\tKQU(12488077416504654222), KQU( 7953892017701886766),\n\tKQU( 6331484925529519007), KQU( 4902145853785030022),\n\tKQU(17010159216096443073), KQU(11945354668653886087),\n\tKQU(15112022728645230829), KQU(17363484484522986742),\n\tKQU( 4423497825896692887), KQU( 8155489510809067471),\n\tKQU( 258966605622576285), KQU( 5462958075742020534),\n\tKQU( 6763710214913276228), KQU( 2368935183451109054),\n\tKQU(14209506165246453811), KQU( 2646257040978514881),\n\tKQU( 3776001911922207672), KQU( 1419304601390147631),\n\tKQU(14987366598022458284), KQU( 3977770701065815721),\n\tKQU( 730820417451838898), KQU( 3982991703612885327),\n\tKQU( 2803544519671388477), KQU(17067667221114424649),\n\tKQU( 2922555119737867166), KQU( 1989477584121460932),\n\tKQU(15020387605892337354), KQU( 9293277796427533547),\n\tKQU(10722181424063557247), KQU(16704542332047511651),\n\tKQU( 5008286236142089514), KQU(16174732308747382540),\n\tKQU(17597019485798338402), KQU(13081745199110622093),\n\tKQU( 8850305883842258115), KQU(12723629125624589005),\n\tKQU( 8140566453402805978), KQU(15356684607680935061),\n\tKQU(14222190387342648650), KQU(11134610460665975178),\n\tKQU( 1259799058620984266), KQU(13281656268025610041),\n\tKQU( 298262561068153992), KQU(12277871700239212922),\n\tKQU(13911297774719779438), KQU(16556727962761474934),\n\tKQU(17903010316654728010), KQU( 9682617699648434744),\n\tKQU(14757681836838592850), KQU( 1327242446558524473),\n\tKQU(11126645098780572792), KQU( 1883602329313221774),\n\tKQU( 2543897783922776873), KQU(15029168513767772842),\n\tKQU(12710270651039129878), KQU(16118202956069604504),\n\tKQU(15010759372168680524), KQU( 2296827082251923948),\n\tKQU(10793729742623518101), KQU(13829764151845413046),\n\tKQU(17769301223184451213), KQU( 3118268169210783372),\n\tKQU(17626204544105123127), KQU( 7416718488974352644),\n\tKQU(10450751996212925994), KQU( 9352529519128770586),\n\tKQU( 259347569641110140), KQU( 8048588892269692697),\n\tKQU( 1774414152306494058), KQU(10669548347214355622),\n\tKQU(13061992253816795081), KQU(18432677803063861659),\n\tKQU( 8879191055593984333), KQU(12433753195199268041),\n\tKQU(14919392415439730602), KQU( 6612848378595332963),\n\tKQU( 6320986812036143628), KQU(10465592420226092859),\n\tKQU( 4196009278962570808), KQU( 3747816564473572224),\n\tKQU(17941203486133732898), KQU( 2350310037040505198),\n\tKQU( 5811779859134370113), KQU(10492109599506195126),\n\tKQU( 7699650690179541274), KQU( 1954338494306022961),\n\tKQU(14095816969027231152), KQU( 5841346919964852061),\n\tKQU(14945969510148214735), KQU( 3680200305887550992),\n\tKQU( 6218047466131695792), KQU( 8242165745175775096),\n\tKQU(11021371934053307357), KQU( 1265099502753169797),\n\tKQU( 4644347436111321718), KQU( 3609296916782832859),\n\tKQU( 8109807992218521571), KQU(18387884215648662020),\n\tKQU(14656324896296392902), KQU(17386819091238216751),\n\tKQU(17788300878582317152), KQU( 7919446259742399591),\n\tKQU( 4466613134576358004), KQU(12928181023667938509),\n\tKQU(13147446154454932030), KQU(16552129038252734620),\n\tKQU( 8395299403738822450), KQU(11313817655275361164),\n\tKQU( 434258809499511718), KQU( 2074882104954788676),\n\tKQU( 7929892178759395518), KQU( 9006461629105745388),\n\tKQU( 5176475650000323086), KQU(11128357033468341069),\n\tKQU(12026158851559118955), KQU(14699716249471156500),\n\tKQU( 448982497120206757), KQU( 4156475356685519900),\n\tKQU( 6063816103417215727), KQU(10073289387954971479),\n\tKQU( 8174466846138590962), KQU( 2675777452363449006),\n\tKQU( 9090685420572474281), KQU( 6659652652765562060),\n\tKQU(12923120304018106621), KQU(11117480560334526775),\n\tKQU( 937910473424587511), KQU( 1838692113502346645),\n\tKQU(11133914074648726180), KQU( 7922600945143884053),\n\tKQU(13435287702700959550), KQU( 5287964921251123332),\n\tKQU(11354875374575318947), KQU(17955724760748238133),\n\tKQU(13728617396297106512), KQU( 4107449660118101255),\n\tKQU( 1210269794886589623), KQU(11408687205733456282),\n\tKQU( 4538354710392677887), KQU(13566803319341319267),\n\tKQU(17870798107734050771), KQU( 3354318982568089135),\n\tKQU( 9034450839405133651), KQU(13087431795753424314),\n\tKQU( 950333102820688239), KQU( 1968360654535604116),\n\tKQU(16840551645563314995), KQU( 8867501803892924995),\n\tKQU(11395388644490626845), KQU( 1529815836300732204),\n\tKQU(13330848522996608842), KQU( 1813432878817504265),\n\tKQU( 2336867432693429560), KQU(15192805445973385902),\n\tKQU( 2528593071076407877), KQU( 128459777936689248),\n\tKQU( 9976345382867214866), KQU( 6208885766767996043),\n\tKQU(14982349522273141706), KQU( 3099654362410737822),\n\tKQU(13776700761947297661), KQU( 8806185470684925550),\n\tKQU( 8151717890410585321), KQU( 640860591588072925),\n\tKQU(14592096303937307465), KQU( 9056472419613564846),\n\tKQU(14861544647742266352), KQU(12703771500398470216),\n\tKQU( 3142372800384138465), KQU( 6201105606917248196),\n\tKQU(18337516409359270184), KQU(15042268695665115339),\n\tKQU(15188246541383283846), KQU(12800028693090114519),\n\tKQU( 5992859621101493472), KQU(18278043971816803521),\n\tKQU( 9002773075219424560), KQU( 7325707116943598353),\n\tKQU( 7930571931248040822), KQU( 5645275869617023448),\n\tKQU( 7266107455295958487), KQU( 4363664528273524411),\n\tKQU(14313875763787479809), KQU(17059695613553486802),\n\tKQU( 9247761425889940932), KQU(13704726459237593128),\n\tKQU( 2701312427328909832), KQU(17235532008287243115),\n\tKQU(14093147761491729538), KQU( 6247352273768386516),\n\tKQU( 8268710048153268415), KQU( 7985295214477182083),\n\tKQU(15624495190888896807), KQU( 3772753430045262788),\n\tKQU( 9133991620474991698), KQU( 5665791943316256028),\n\tKQU( 7551996832462193473), KQU(13163729206798953877),\n\tKQU( 9263532074153846374), KQU( 1015460703698618353),\n\tKQU(17929874696989519390), KQU(18257884721466153847),\n\tKQU(16271867543011222991), KQU( 3905971519021791941),\n\tKQU(16814488397137052085), KQU( 1321197685504621613),\n\tKQU( 2870359191894002181), KQU(14317282970323395450),\n\tKQU(13663920845511074366), KQU( 2052463995796539594),\n\tKQU(14126345686431444337), KQU( 1727572121947022534),\n\tKQU(17793552254485594241), KQU( 6738857418849205750),\n\tKQU( 1282987123157442952), KQU(16655480021581159251),\n\tKQU( 6784587032080183866), KQU(14726758805359965162),\n\tKQU( 7577995933961987349), KQU(12539609320311114036),\n\tKQU(10789773033385439494), KQU( 8517001497411158227),\n\tKQU(10075543932136339710), KQU(14838152340938811081),\n\tKQU( 9560840631794044194), KQU(17445736541454117475),\n\tKQU(10633026464336393186), KQU(15705729708242246293),\n\tKQU( 1117517596891411098), KQU( 4305657943415886942),\n\tKQU( 4948856840533979263), KQU(16071681989041789593),\n\tKQU(13723031429272486527), KQU( 7639567622306509462),\n\tKQU(12670424537483090390), KQU( 9715223453097197134),\n\tKQU( 5457173389992686394), KQU( 289857129276135145),\n\tKQU(17048610270521972512), KQU( 692768013309835485),\n\tKQU(14823232360546632057), KQU(18218002361317895936),\n\tKQU( 3281724260212650204), KQU(16453957266549513795),\n\tKQU( 8592711109774511881), KQU( 929825123473369579),\n\tKQU(15966784769764367791), KQU( 9627344291450607588),\n\tKQU(10849555504977813287), KQU( 9234566913936339275),\n\tKQU( 6413807690366911210), KQU(10862389016184219267),\n\tKQU(13842504799335374048), KQU( 1531994113376881174),\n\tKQU( 2081314867544364459), KQU(16430628791616959932),\n\tKQU( 8314714038654394368), KQU( 9155473892098431813),\n\tKQU(12577843786670475704), KQU( 4399161106452401017),\n\tKQU( 1668083091682623186), KQU( 1741383777203714216),\n\tKQU( 2162597285417794374), KQU(15841980159165218736),\n\tKQU( 1971354603551467079), KQU( 1206714764913205968),\n\tKQU( 4790860439591272330), KQU(14699375615594055799),\n\tKQU( 8374423871657449988), KQU(10950685736472937738),\n\tKQU( 697344331343267176), KQU(10084998763118059810),\n\tKQU(12897369539795983124), KQU(12351260292144383605),\n\tKQU( 1268810970176811234), KQU( 7406287800414582768),\n\tKQU( 516169557043807831), KQU( 5077568278710520380),\n\tKQU( 3828791738309039304), KQU( 7721974069946943610),\n\tKQU( 3534670260981096460), KQU( 4865792189600584891),\n\tKQU(16892578493734337298), KQU( 9161499464278042590),\n\tKQU(11976149624067055931), KQU(13219479887277343990),\n\tKQU(14161556738111500680), KQU(14670715255011223056),\n\tKQU( 4671205678403576558), KQU(12633022931454259781),\n\tKQU(14821376219869187646), KQU( 751181776484317028),\n\tKQU( 2192211308839047070), KQU(11787306362361245189),\n\tKQU(10672375120744095707), KQU( 4601972328345244467),\n\tKQU(15457217788831125879), KQU( 8464345256775460809),\n\tKQU(10191938789487159478), KQU( 6184348739615197613),\n\tKQU(11425436778806882100), KQU( 2739227089124319793),\n\tKQU( 461464518456000551), KQU( 4689850170029177442),\n\tKQU( 6120307814374078625), KQU(11153579230681708671),\n\tKQU( 7891721473905347926), KQU(10281646937824872400),\n\tKQU( 3026099648191332248), KQU( 8666750296953273818),\n\tKQU(14978499698844363232), KQU(13303395102890132065),\n\tKQU( 8182358205292864080), KQU(10560547713972971291),\n\tKQU(11981635489418959093), KQU( 3134621354935288409),\n\tKQU(11580681977404383968), KQU(14205530317404088650),\n\tKQU( 5997789011854923157), KQU(13659151593432238041),\n\tKQU(11664332114338865086), KQU( 7490351383220929386),\n\tKQU( 7189290499881530378), KQU(15039262734271020220),\n\tKQU( 2057217285976980055), KQU( 555570804905355739),\n\tKQU(11235311968348555110), KQU(13824557146269603217),\n\tKQU(16906788840653099693), KQU( 7222878245455661677),\n\tKQU( 5245139444332423756), KQU( 4723748462805674292),\n\tKQU(12216509815698568612), KQU(17402362976648951187),\n\tKQU(17389614836810366768), KQU( 4880936484146667711),\n\tKQU( 9085007839292639880), KQU(13837353458498535449),\n\tKQU(11914419854360366677), KQU(16595890135313864103),\n\tKQU( 6313969847197627222), KQU(18296909792163910431),\n\tKQU(10041780113382084042), KQU( 2499478551172884794),\n\tKQU(11057894246241189489), KQU( 9742243032389068555),\n\tKQU(12838934582673196228), KQU(13437023235248490367),\n\tKQU(13372420669446163240), KQU( 6752564244716909224),\n\tKQU( 7157333073400313737), KQU(12230281516370654308),\n\tKQU( 1182884552219419117), KQU( 2955125381312499218),\n\tKQU(10308827097079443249), KQU( 1337648572986534958),\n\tKQU(16378788590020343939), KQU( 108619126514420935),\n\tKQU( 3990981009621629188), KQU( 5460953070230946410),\n\tKQU( 9703328329366531883), KQU(13166631489188077236),\n\tKQU( 1104768831213675170), KQU( 3447930458553877908),\n\tKQU( 8067172487769945676), KQU( 5445802098190775347),\n\tKQU( 3244840981648973873), KQU(17314668322981950060),\n\tKQU( 5006812527827763807), KQU(18158695070225526260),\n\tKQU( 2824536478852417853), KQU(13974775809127519886),\n\tKQU( 9814362769074067392), KQU(17276205156374862128),\n\tKQU(11361680725379306967), KQU( 3422581970382012542),\n\tKQU(11003189603753241266), KQU(11194292945277862261),\n\tKQU( 6839623313908521348), KQU(11935326462707324634),\n\tKQU( 1611456788685878444), KQU(13112620989475558907),\n\tKQU( 517659108904450427), KQU(13558114318574407624),\n\tKQU(15699089742731633077), KQU( 4988979278862685458),\n\tKQU( 8111373583056521297), KQU( 3891258746615399627),\n\tKQU( 8137298251469718086), KQU(12748663295624701649),\n\tKQU( 4389835683495292062), KQU( 5775217872128831729),\n\tKQU( 9462091896405534927), KQU( 8498124108820263989),\n\tKQU( 8059131278842839525), KQU(10503167994254090892),\n\tKQU(11613153541070396656), KQU(18069248738504647790),\n\tKQU( 570657419109768508), KQU( 3950574167771159665),\n\tKQU( 5514655599604313077), KQU( 2908460854428484165),\n\tKQU(10777722615935663114), KQU(12007363304839279486),\n\tKQU( 9800646187569484767), KQU( 8795423564889864287),\n\tKQU(14257396680131028419), KQU( 6405465117315096498),\n\tKQU( 7939411072208774878), KQU(17577572378528990006),\n\tKQU(14785873806715994850), KQU(16770572680854747390),\n\tKQU(18127549474419396481), KQU(11637013449455757750),\n\tKQU(14371851933996761086), KQU( 3601181063650110280),\n\tKQU( 4126442845019316144), KQU(10198287239244320669),\n\tKQU(18000169628555379659), KQU(18392482400739978269),\n\tKQU( 6219919037686919957), KQU( 3610085377719446052),\n\tKQU( 2513925039981776336), KQU(16679413537926716955),\n\tKQU(12903302131714909434), KQU( 5581145789762985009),\n\tKQU(12325955044293303233), KQU(17216111180742141204),\n\tKQU( 6321919595276545740), KQU( 3507521147216174501),\n\tKQU( 9659194593319481840), KQU(11473976005975358326),\n\tKQU(14742730101435987026), KQU( 492845897709954780),\n\tKQU(16976371186162599676), KQU(17712703422837648655),\n\tKQU( 9881254778587061697), KQU( 8413223156302299551),\n\tKQU( 1563841828254089168), KQU( 9996032758786671975),\n\tKQU( 138877700583772667), KQU(13003043368574995989),\n\tKQU( 4390573668650456587), KQU( 8610287390568126755),\n\tKQU(15126904974266642199), KQU( 6703637238986057662),\n\tKQU( 2873075592956810157), KQU( 6035080933946049418),\n\tKQU(13382846581202353014), KQU( 7303971031814642463),\n\tKQU(18418024405307444267), KQU( 5847096731675404647),\n\tKQU( 4035880699639842500), KQU(11525348625112218478),\n\tKQU( 3041162365459574102), KQU( 2604734487727986558),\n\tKQU(15526341771636983145), KQU(14556052310697370254),\n\tKQU(12997787077930808155), KQU( 9601806501755554499),\n\tKQU(11349677952521423389), KQU(14956777807644899350),\n\tKQU(16559736957742852721), KQU(12360828274778140726),\n\tKQU( 6685373272009662513), KQU(16932258748055324130),\n\tKQU(15918051131954158508), KQU( 1692312913140790144),\n\tKQU( 546653826801637367), KQU( 5341587076045986652),\n\tKQU(14975057236342585662), KQU(12374976357340622412),\n\tKQU(10328833995181940552), KQU(12831807101710443149),\n\tKQU(10548514914382545716), KQU( 2217806727199715993),\n\tKQU(12627067369242845138), KQU( 4598965364035438158),\n\tKQU( 150923352751318171), KQU(14274109544442257283),\n\tKQU( 4696661475093863031), KQU( 1505764114384654516),\n\tKQU(10699185831891495147), KQU( 2392353847713620519),\n\tKQU( 3652870166711788383), KQU( 8640653276221911108),\n\tKQU( 3894077592275889704), KQU( 4918592872135964845),\n\tKQU(16379121273281400789), KQU(12058465483591683656),\n\tKQU(11250106829302924945), KQU( 1147537556296983005),\n\tKQU( 6376342756004613268), KQU(14967128191709280506),\n\tKQU(18007449949790627628), KQU( 9497178279316537841),\n\tKQU( 7920174844809394893), KQU(10037752595255719907),\n\tKQU(15875342784985217697), KQU(15311615921712850696),\n\tKQU( 9552902652110992950), KQU(14054979450099721140),\n\tKQU( 5998709773566417349), KQU(18027910339276320187),\n\tKQU( 8223099053868585554), KQU( 7842270354824999767),\n\tKQU( 4896315688770080292), KQU(12969320296569787895),\n\tKQU( 2674321489185759961), KQU( 4053615936864718439),\n\tKQU(11349775270588617578), KQU( 4743019256284553975),\n\tKQU( 5602100217469723769), KQU(14398995691411527813),\n\tKQU( 7412170493796825470), KQU( 836262406131744846),\n\tKQU( 8231086633845153022), KQU( 5161377920438552287),\n\tKQU( 8828731196169924949), KQU(16211142246465502680),\n\tKQU( 3307990879253687818), KQU( 5193405406899782022),\n\tKQU( 8510842117467566693), KQU( 6070955181022405365),\n\tKQU(14482950231361409799), KQU(12585159371331138077),\n\tKQU( 3511537678933588148), KQU( 2041849474531116417),\n\tKQU(10944936685095345792), KQU(18303116923079107729),\n\tKQU( 2720566371239725320), KQU( 4958672473562397622),\n\tKQU( 3032326668253243412), KQU(13689418691726908338),\n\tKQU( 1895205511728843996), KQU( 8146303515271990527),\n\tKQU(16507343500056113480), KQU( 473996939105902919),\n\tKQU( 9897686885246881481), KQU(14606433762712790575),\n\tKQU( 6732796251605566368), KQU( 1399778120855368916),\n\tKQU( 935023885182833777), KQU(16066282816186753477),\n\tKQU( 7291270991820612055), KQU(17530230393129853844),\n\tKQU(10223493623477451366), KQU(15841725630495676683),\n\tKQU(17379567246435515824), KQU( 8588251429375561971),\n\tKQU(18339511210887206423), KQU(17349587430725976100),\n\tKQU(12244876521394838088), KQU( 6382187714147161259),\n\tKQU(12335807181848950831), KQU(16948885622305460665),\n\tKQU(13755097796371520506), KQU(14806740373324947801),\n\tKQU( 4828699633859287703), KQU( 8209879281452301604),\n\tKQU(12435716669553736437), KQU(13970976859588452131),\n\tKQU( 6233960842566773148), KQU(12507096267900505759),\n\tKQU( 1198713114381279421), KQU(14989862731124149015),\n\tKQU(15932189508707978949), KQU( 2526406641432708722),\n\tKQU( 29187427817271982), KQU( 1499802773054556353),\n\tKQU(10816638187021897173), KQU( 5436139270839738132),\n\tKQU( 6659882287036010082), KQU( 2154048955317173697),\n\tKQU(10887317019333757642), KQU(16281091802634424955),\n\tKQU(10754549879915384901), KQU(10760611745769249815),\n\tKQU( 2161505946972504002), KQU( 5243132808986265107),\n\tKQU(10129852179873415416), KQU( 710339480008649081),\n\tKQU( 7802129453068808528), KQU(17967213567178907213),\n\tKQU(15730859124668605599), KQU(13058356168962376502),\n\tKQU( 3701224985413645909), KQU(14464065869149109264),\n\tKQU( 9959272418844311646), KQU(10157426099515958752),\n\tKQU(14013736814538268528), KQU(17797456992065653951),\n\tKQU(17418878140257344806), KQU(15457429073540561521),\n\tKQU( 2184426881360949378), KQU( 2062193041154712416),\n\tKQU( 8553463347406931661), KQU( 4913057625202871854),\n\tKQU( 2668943682126618425), KQU(17064444737891172288),\n\tKQU( 4997115903913298637), KQU(12019402608892327416),\n\tKQU(17603584559765897352), KQU(11367529582073647975),\n\tKQU( 8211476043518436050), KQU( 8676849804070323674),\n\tKQU(18431829230394475730), KQU(10490177861361247904),\n\tKQU( 9508720602025651349), KQU( 7409627448555722700),\n\tKQU( 5804047018862729008), KQU(11943858176893142594),\n\tKQU(11908095418933847092), KQU( 5415449345715887652),\n\tKQU( 1554022699166156407), KQU( 9073322106406017161),\n\tKQU( 7080630967969047082), KQU(18049736940860732943),\n\tKQU(12748714242594196794), KQU( 1226992415735156741),\n\tKQU(17900981019609531193), KQU(11720739744008710999),\n\tKQU( 3006400683394775434), KQU(11347974011751996028),\n\tKQU( 3316999628257954608), KQU( 8384484563557639101),\n\tKQU(18117794685961729767), KQU( 1900145025596618194),\n\tKQU(17459527840632892676), KQU( 5634784101865710994),\n\tKQU( 7918619300292897158), KQU( 3146577625026301350),\n\tKQU( 9955212856499068767), KQU( 1873995843681746975),\n\tKQU( 1561487759967972194), KQU( 8322718804375878474),\n\tKQU(11300284215327028366), KQU( 4667391032508998982),\n\tKQU( 9820104494306625580), KQU(17922397968599970610),\n\tKQU( 1784690461886786712), KQU(14940365084341346821),\n\tKQU( 5348719575594186181), KQU(10720419084507855261),\n\tKQU(14210394354145143274), KQU( 2426468692164000131),\n\tKQU(16271062114607059202), KQU(14851904092357070247),\n\tKQU( 6524493015693121897), KQU( 9825473835127138531),\n\tKQU(14222500616268569578), KQU(15521484052007487468),\n\tKQU(14462579404124614699), KQU(11012375590820665520),\n\tKQU(11625327350536084927), KQU(14452017765243785417),\n\tKQU( 9989342263518766305), KQU( 3640105471101803790),\n\tKQU( 4749866455897513242), KQU(13963064946736312044),\n\tKQU(10007416591973223791), KQU(18314132234717431115),\n\tKQU( 3286596588617483450), KQU( 7726163455370818765),\n\tKQU( 7575454721115379328), KQU( 5308331576437663422),\n\tKQU(18288821894903530934), KQU( 8028405805410554106),\n\tKQU(15744019832103296628), KQU( 149765559630932100),\n\tKQU( 6137705557200071977), KQU(14513416315434803615),\n\tKQU(11665702820128984473), KQU( 218926670505601386),\n\tKQU( 6868675028717769519), KQU(15282016569441512302),\n\tKQU( 5707000497782960236), KQU( 6671120586555079567),\n\tKQU( 2194098052618985448), KQU(16849577895477330978),\n\tKQU(12957148471017466283), KQU( 1997805535404859393),\n\tKQU( 1180721060263860490), KQU(13206391310193756958),\n\tKQU(12980208674461861797), KQU( 3825967775058875366),\n\tKQU(17543433670782042631), KQU( 1518339070120322730),\n\tKQU(16344584340890991669), KQU( 2611327165318529819),\n\tKQU(11265022723283422529), KQU( 4001552800373196817),\n\tKQU(14509595890079346161), KQU( 3528717165416234562),\n\tKQU(18153222571501914072), KQU( 9387182977209744425),\n\tKQU(10064342315985580021), KQU(11373678413215253977),\n\tKQU( 2308457853228798099), KQU( 9729042942839545302),\n\tKQU( 7833785471140127746), KQU( 6351049900319844436),\n\tKQU(14454610627133496067), KQU(12533175683634819111),\n\tKQU(15570163926716513029), KQU(13356980519185762498)\n};\n\nTEST_BEGIN(test_gen_rand_32) {\n\tuint32_t array32[BLOCK_SIZE] JEMALLOC_ATTR(aligned(16));\n\tuint32_t array32_2[BLOCK_SIZE] JEMALLOC_ATTR(aligned(16));\n\tint i;\n\tuint32_t r32;\n\tsfmt_t *ctx;\n\n\texpect_d_le(get_min_array_size32(), BLOCK_SIZE,\n\t \"Array size too small\");\n\tctx = init_gen_rand(1234);\n\tfill_array32(ctx, array32, BLOCK_SIZE);\n\tfill_array32(ctx, array32_2, BLOCK_SIZE);\n\tfini_gen_rand(ctx);\n\n\tctx = init_gen_rand(1234);\n\tfor (i = 0; i < BLOCK_SIZE; i++) {\n\t\tif (i < COUNT_1) {\n\t\t\texpect_u32_eq(array32[i], init_gen_rand_32_expected[i],\n\t\t\t \"Output mismatch for i=%d\", i);\n\t\t}\n\t\tr32 = gen_rand32(ctx);\n\t\texpect_u32_eq(r32, array32[i],\n\t\t \"Mismatch at array32[%d]=%x, gen=%x\", i, array32[i], r32);\n\t}\n\tfor (i = 0; i < COUNT_2; i++) {\n\t\tr32 = gen_rand32(ctx);\n\t\texpect_u32_eq(r32, array32_2[i],\n\t\t \"Mismatch at array32_2[%d]=%x, gen=%x\", i, array32_2[i],\n\t\t r32);\n\t}\n\tfini_gen_rand(ctx);\n}\nTEST_END\n\nTEST_BEGIN(test_by_array_32) {\n\tuint32_t array32[BLOCK_SIZE] JEMALLOC_ATTR(aligned(16));\n\tuint32_t array32_2[BLOCK_SIZE] JEMALLOC_ATTR(aligned(16));\n\tint i;\n\tuint32_t ini[4] = {0x1234, 0x5678, 0x9abc, 0xdef0};\n\tuint32_t r32;\n\tsfmt_t *ctx;\n\n\texpect_d_le(get_min_array_size32(), BLOCK_SIZE,\n\t \"Array size too small\");\n\tctx = init_by_array(ini, 4);\n\tfill_array32(ctx, array32, BLOCK_SIZE);\n\tfill_array32(ctx, array32_2, BLOCK_SIZE);\n\tfini_gen_rand(ctx);\n\n\tctx = init_by_array(ini, 4);\n\tfor (i = 0; i < BLOCK_SIZE; i++) {\n\t\tif (i < COUNT_1) {\n\t\t\texpect_u32_eq(array32[i], init_by_array_32_expected[i],\n\t\t\t \"Output mismatch for i=%d\", i);\n\t\t}\n\t\tr32 = gen_rand32(ctx);\n\t\texpect_u32_eq(r32, array32[i],\n\t\t \"Mismatch at array32[%d]=%x, gen=%x\", i, array32[i], r32);\n\t}\n\tfor (i = 0; i < COUNT_2; i++) {\n\t\tr32 = gen_rand32(ctx);\n\t\texpect_u32_eq(r32, array32_2[i],\n\t\t \"Mismatch at array32_2[%d]=%x, gen=%x\", i, array32_2[i],\n\t\t r32);\n\t}\n\tfini_gen_rand(ctx);\n}\nTEST_END\n\nTEST_BEGIN(test_gen_rand_64) {\n\tuint64_t array64[BLOCK_SIZE64] JEMALLOC_ATTR(aligned(16));\n\tuint64_t array64_2[BLOCK_SIZE64] JEMALLOC_ATTR(aligned(16));\n\tint i;\n\tuint64_t r;\n\tsfmt_t *ctx;\n\n\texpect_d_le(get_min_array_size64(), BLOCK_SIZE64,\n\t \"Array size too small\");\n\tctx = init_gen_rand(4321);\n\tfill_array64(ctx, array64, BLOCK_SIZE64);\n\tfill_array64(ctx, array64_2, BLOCK_SIZE64);\n\tfini_gen_rand(ctx);\n\n\tctx = init_gen_rand(4321);\n\tfor (i = 0; i < BLOCK_SIZE64; i++) {\n\t\tif (i < COUNT_1) {\n\t\t\texpect_u64_eq(array64[i], init_gen_rand_64_expected[i],\n\t\t\t \"Output mismatch for i=%d\", i);\n\t\t}\n\t\tr = gen_rand64(ctx);\n\t\texpect_u64_eq(r, array64[i],\n\t\t \"Mismatch at array64[%d]=%\"FMTx64\", gen=%\"FMTx64, i,\n\t\t array64[i], r);\n\t}\n\tfor (i = 0; i < COUNT_2; i++) {\n\t\tr = gen_rand64(ctx);\n\t\texpect_u64_eq(r, array64_2[i],\n\t\t \"Mismatch at array64_2[%d]=%\"FMTx64\" gen=%\"FMTx64\"\", i,\n\t\t array64_2[i], r);\n\t}\n\tfini_gen_rand(ctx);\n}\nTEST_END\n\nTEST_BEGIN(test_by_array_64) {\n\tuint64_t array64[BLOCK_SIZE64] JEMALLOC_ATTR(aligned(16));\n\tuint64_t array64_2[BLOCK_SIZE64] JEMALLOC_ATTR(aligned(16));\n\tint i;\n\tuint64_t r;\n\tuint32_t ini[] = {5, 4, 3, 2, 1};\n\tsfmt_t *ctx;\n\n\texpect_d_le(get_min_array_size64(), BLOCK_SIZE64,\n\t \"Array size too small\");\n\tctx = init_by_array(ini, 5);\n\tfill_array64(ctx, array64, BLOCK_SIZE64);\n\tfill_array64(ctx, array64_2, BLOCK_SIZE64);\n\tfini_gen_rand(ctx);\n\n\tctx = init_by_array(ini, 5);\n\tfor (i = 0; i < BLOCK_SIZE64; i++) {\n\t\tif (i < COUNT_1) {\n\t\t\texpect_u64_eq(array64[i], init_by_array_64_expected[i],\n\t\t\t \"Output mismatch for i=%d\", i);\n\t\t}\n\t\tr = gen_rand64(ctx);\n\t\texpect_u64_eq(r, array64[i],\n\t\t \"Mismatch at array64[%d]=%\"FMTx64\" gen=%\"FMTx64, i,\n\t\t array64[i], r);\n\t}\n\tfor (i = 0; i < COUNT_2; i++) {\n\t\tr = gen_rand64(ctx);\n\t\texpect_u64_eq(r, array64_2[i],\n\t\t \"Mismatch at array64_2[%d]=%\"FMTx64\" gen=%\"FMTx64, i,\n\t\t array64_2[i], r);\n\t}\n\tfini_gen_rand(ctx);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_gen_rand_32,\n\t test_by_array_32,\n\t test_gen_rand_64,\n\t test_by_array_64);\n}\n" }, { "path": "deps/jemalloc/test/unit/a0.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_a0) {\n\tvoid *p;\n\n\tp = a0malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected a0malloc() error\");\n\ta0dalloc(p);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_malloc_init(\n\t test_a0);\n}\n" }, { "path": "deps/jemalloc/test/unit/arena_decay.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/arena_util.h\"\n\n#include \"jemalloc/internal/ticker.h\"\n\nstatic nstime_monotonic_t *nstime_monotonic_orig;\nstatic nstime_update_t *nstime_update_orig;\n\nstatic unsigned nupdates_mock;\nstatic nstime_t time_mock;\nstatic bool monotonic_mock;\n\nstatic bool\nnstime_monotonic_mock(void) {\n\treturn monotonic_mock;\n}\n\nstatic void\nnstime_update_mock(nstime_t *time) {\n\tnupdates_mock++;\n\tif (monotonic_mock) {\n\t\tnstime_copy(time, &time_mock);\n\t}\n}\n\nTEST_BEGIN(test_decay_ticks) {\n\ttest_skip_if(is_background_thread_enabled());\n\ttest_skip_if(opt_hpa);\n\n\tticker_geom_t *decay_ticker;\n\tunsigned tick0, tick1, arena_ind;\n\tsize_t sz, large0;\n\tvoid *p;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large0, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\n\t/* Set up a manually managed arena for test. */\n\tarena_ind = do_arena_create(0, 0);\n\n\t/* Migrate to the new arena, and get the ticker. */\n\tunsigned old_arena_ind;\n\tsize_t sz_arena_ind = sizeof(old_arena_ind);\n\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind,\n\t &sz_arena_ind, (void *)&arena_ind, sizeof(arena_ind)), 0,\n\t \"Unexpected mallctl() failure\");\n\tdecay_ticker = tsd_arena_decay_tickerp_get(tsd_fetch());\n\texpect_ptr_not_null(decay_ticker,\n\t \"Unexpected failure getting decay ticker\");\n\n\t/*\n\t * Test the standard APIs using a large size class, since we can't\n\t * control tcache interactions for small size classes (except by\n\t * completely disabling tcache for the entire test program).\n\t */\n\n\t/* malloc(). */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tp = malloc(large0);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during malloc()\");\n\t/* free(). */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tfree(p);\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during free()\");\n\n\t/* calloc(). */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tp = calloc(1, large0);\n\texpect_ptr_not_null(p, \"Unexpected calloc() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during calloc()\");\n\tfree(p);\n\n\t/* posix_memalign(). */\n\ttick0 = ticker_geom_read(decay_ticker);\n\texpect_d_eq(posix_memalign(&p, sizeof(size_t), large0), 0,\n\t \"Unexpected posix_memalign() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0,\n\t \"Expected ticker to tick during posix_memalign()\");\n\tfree(p);\n\n\t/* aligned_alloc(). */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tp = aligned_alloc(sizeof(size_t), large0);\n\texpect_ptr_not_null(p, \"Unexpected aligned_alloc() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0,\n\t \"Expected ticker to tick during aligned_alloc()\");\n\tfree(p);\n\n\t/* realloc(). */\n\t/* Allocate. */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tp = realloc(NULL, large0);\n\texpect_ptr_not_null(p, \"Unexpected realloc() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during realloc()\");\n\t/* Reallocate. */\n\ttick0 = ticker_geom_read(decay_ticker);\n\tp = realloc(p, large0);\n\texpect_ptr_not_null(p, \"Unexpected realloc() failure\");\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during realloc()\");\n\t/* Deallocate. */\n\ttick0 = ticker_geom_read(decay_ticker);\n\trealloc(p, 0);\n\ttick1 = ticker_geom_read(decay_ticker);\n\texpect_u32_ne(tick1, tick0, \"Expected ticker to tick during realloc()\");\n\n\t/*\n\t * Test the *allocx() APIs using large and small size classes, with\n\t * tcache explicitly disabled.\n\t */\n\t{\n\t\tunsigned i;\n\t\tsize_t allocx_sizes[2];\n\t\tallocx_sizes[0] = large0;\n\t\tallocx_sizes[1] = 1;\n\n\t\tfor (i = 0; i < sizeof(allocx_sizes) / sizeof(size_t); i++) {\n\t\t\tsz = allocx_sizes[i];\n\n\t\t\t/* mallocx(). */\n\t\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\t\tp = mallocx(sz, MALLOCX_TCACHE_NONE);\n\t\t\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\t\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\t\texpect_u32_ne(tick1, tick0,\n\t\t\t \"Expected ticker to tick during mallocx() (sz=%zu)\",\n\t\t\t sz);\n\t\t\t/* rallocx(). */\n\t\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\t\tp = rallocx(p, sz, MALLOCX_TCACHE_NONE);\n\t\t\texpect_ptr_not_null(p, \"Unexpected rallocx() failure\");\n\t\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\t\texpect_u32_ne(tick1, tick0,\n\t\t\t \"Expected ticker to tick during rallocx() (sz=%zu)\",\n\t\t\t sz);\n\t\t\t/* xallocx(). */\n\t\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\t\txallocx(p, sz, 0, MALLOCX_TCACHE_NONE);\n\t\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\t\texpect_u32_ne(tick1, tick0,\n\t\t\t \"Expected ticker to tick during xallocx() (sz=%zu)\",\n\t\t\t sz);\n\t\t\t/* dallocx(). */\n\t\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\t\tdallocx(p, MALLOCX_TCACHE_NONE);\n\t\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\t\texpect_u32_ne(tick1, tick0,\n\t\t\t \"Expected ticker to tick during dallocx() (sz=%zu)\",\n\t\t\t sz);\n\t\t\t/* sdallocx(). */\n\t\t\tp = mallocx(sz, MALLOCX_TCACHE_NONE);\n\t\t\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\t\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\t\tsdallocx(p, sz, MALLOCX_TCACHE_NONE);\n\t\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\t\texpect_u32_ne(tick1, tick0,\n\t\t\t \"Expected ticker to tick during sdallocx() \"\n\t\t\t \"(sz=%zu)\", sz);\n\t\t}\n\t}\n\n\t/*\n\t * Test tcache fill/flush interactions for large and small size classes,\n\t * using an explicit tcache.\n\t */\n\tunsigned tcache_ind, i;\n\tsize_t tcache_sizes[2];\n\ttcache_sizes[0] = large0;\n\ttcache_sizes[1] = 1;\n\n\tsize_t tcache_max, sz_tcache_max;\n\tsz_tcache_max = sizeof(tcache_max);\n\texpect_d_eq(mallctl(\"arenas.tcache_max\", (void *)&tcache_max,\n\t &sz_tcache_max, NULL, 0), 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"tcache.create\", (void *)&tcache_ind, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\n\tfor (i = 0; i < sizeof(tcache_sizes) / sizeof(size_t); i++) {\n\t\tsz = tcache_sizes[i];\n\n\t\t/* tcache fill. */\n\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\tp = mallocx(sz, MALLOCX_TCACHE(tcache_ind));\n\t\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\t\ttick1 = ticker_geom_read(decay_ticker);\n\t\texpect_u32_ne(tick1, tick0,\n\t\t \"Expected ticker to tick during tcache fill \"\n\t\t \"(sz=%zu)\", sz);\n\t\t/* tcache flush. */\n\t\tdallocx(p, MALLOCX_TCACHE(tcache_ind));\n\t\ttick0 = ticker_geom_read(decay_ticker);\n\t\texpect_d_eq(mallctl(\"tcache.flush\", NULL, NULL,\n\t\t (void *)&tcache_ind, sizeof(unsigned)), 0,\n\t\t \"Unexpected mallctl failure\");\n\t\ttick1 = ticker_geom_read(decay_ticker);\n\n\t\t/* Will only tick if it's in tcache. */\n\t\texpect_u32_ne(tick1, tick0,\n\t\t \"Expected ticker to tick during tcache flush (sz=%zu)\", sz);\n\t}\n}\nTEST_END\n\nstatic void\ndecay_ticker_helper(unsigned arena_ind, int flags, bool dirty, ssize_t dt,\n uint64_t dirty_npurge0, uint64_t muzzy_npurge0, bool terminate_asap) {\n#define NINTERVALS 101\n\tnstime_t time, update_interval, decay_ms, deadline;\n\n\tnstime_init_update(&time);\n\n\tnstime_init2(&decay_ms, dt, 0);\n\tnstime_copy(&deadline, &time);\n\tnstime_add(&deadline, &decay_ms);\n\n\tnstime_init2(&update_interval, dt, 0);\n\tnstime_idivide(&update_interval, NINTERVALS);\n\n\t/*\n\t * Keep q's slab from being deallocated during the looping below. If a\n\t * cached slab were to repeatedly come and go during looping, it could\n\t * prevent the decay backlog ever becoming empty.\n\t */\n\tvoid *p = do_mallocx(1, flags);\n\tuint64_t dirty_npurge1, muzzy_npurge1;\n\tdo {\n\t\tfor (unsigned i = 0; i < ARENA_DECAY_NTICKS_PER_UPDATE / 2;\n\t\t i++) {\n\t\t\tvoid *q = do_mallocx(1, flags);\n\t\t\tdallocx(q, flags);\n\t\t}\n\t\tdirty_npurge1 = get_arena_dirty_npurge(arena_ind);\n\t\tmuzzy_npurge1 = get_arena_muzzy_npurge(arena_ind);\n\n\t\tnstime_add(&time_mock, &update_interval);\n\t\tnstime_update(&time);\n\t} while (nstime_compare(&time, &deadline) <= 0 && ((dirty_npurge1 ==\n\t dirty_npurge0 && muzzy_npurge1 == muzzy_npurge0) ||\n\t !terminate_asap));\n\tdallocx(p, flags);\n\n\tif (config_stats) {\n\t\texpect_u64_gt(dirty_npurge1 + muzzy_npurge1, dirty_npurge0 +\n\t\t muzzy_npurge0, \"Expected purging to occur\");\n\t}\n#undef NINTERVALS\n}\n\nTEST_BEGIN(test_decay_ticker) {\n\ttest_skip_if(is_background_thread_enabled());\n\ttest_skip_if(opt_hpa);\n#define NPS 2048\n\tssize_t ddt = opt_dirty_decay_ms;\n\tssize_t mdt = opt_muzzy_decay_ms;\n\tunsigned arena_ind = do_arena_create(ddt, mdt);\n\tint flags = (MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE);\n\tvoid *ps[NPS];\n\n\t/*\n\t * Allocate a bunch of large objects, pause the clock, deallocate every\n\t * other object (to fragment virtual memory), restore the clock, then\n\t * [md]allocx() in a tight loop while advancing time rapidly to verify\n\t * the ticker triggers purging.\n\t */\n\tsize_t large;\n\tsize_t sz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\n\tdo_purge(arena_ind);\n\tuint64_t dirty_npurge0 = get_arena_dirty_npurge(arena_ind);\n\tuint64_t muzzy_npurge0 = get_arena_muzzy_npurge(arena_ind);\n\n\tfor (unsigned i = 0; i < NPS; i++) {\n\t\tps[i] = do_mallocx(large, flags);\n\t}\n\n\tnupdates_mock = 0;\n\tnstime_init_update(&time_mock);\n\tmonotonic_mock = true;\n\n\tnstime_monotonic_orig = nstime_monotonic;\n\tnstime_update_orig = nstime_update;\n\tnstime_monotonic = nstime_monotonic_mock;\n\tnstime_update = nstime_update_mock;\n\n\tfor (unsigned i = 0; i < NPS; i += 2) {\n\t\tdallocx(ps[i], flags);\n\t\tunsigned nupdates0 = nupdates_mock;\n\t\tdo_decay(arena_ind);\n\t\texpect_u_gt(nupdates_mock, nupdates0,\n\t\t \"Expected nstime_update() to be called\");\n\t}\n\n\tdecay_ticker_helper(arena_ind, flags, true, ddt, dirty_npurge0,\n\t muzzy_npurge0, true);\n\tdecay_ticker_helper(arena_ind, flags, false, ddt+mdt, dirty_npurge0,\n\t muzzy_npurge0, false);\n\n\tdo_arena_destroy(arena_ind);\n\n\tnstime_monotonic = nstime_monotonic_orig;\n\tnstime_update = nstime_update_orig;\n#undef NPS\n}\nTEST_END\n\nTEST_BEGIN(test_decay_nonmonotonic) {\n\ttest_skip_if(is_background_thread_enabled());\n\ttest_skip_if(opt_hpa);\n#define NPS (SMOOTHSTEP_NSTEPS + 1)\n\tint flags = (MALLOCX_ARENA(0) | MALLOCX_TCACHE_NONE);\n\tvoid *ps[NPS];\n\tuint64_t npurge0 = 0;\n\tuint64_t npurge1 = 0;\n\tsize_t sz, large0;\n\tunsigned i, nupdates0;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large0, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\tdo_epoch();\n\tsz = sizeof(uint64_t);\n\tnpurge0 = get_arena_npurge(0);\n\n\tnupdates_mock = 0;\n\tnstime_init_update(&time_mock);\n\tmonotonic_mock = false;\n\n\tnstime_monotonic_orig = nstime_monotonic;\n\tnstime_update_orig = nstime_update;\n\tnstime_monotonic = nstime_monotonic_mock;\n\tnstime_update = nstime_update_mock;\n\n\tfor (i = 0; i < NPS; i++) {\n\t\tps[i] = mallocx(large0, flags);\n\t\texpect_ptr_not_null(ps[i], \"Unexpected mallocx() failure\");\n\t}\n\n\tfor (i = 0; i < NPS; i++) {\n\t\tdallocx(ps[i], flags);\n\t\tnupdates0 = nupdates_mock;\n\t\texpect_d_eq(mallctl(\"arena.0.decay\", NULL, NULL, NULL, 0), 0,\n\t\t \"Unexpected arena.0.decay failure\");\n\t\texpect_u_gt(nupdates_mock, nupdates0,\n\t\t \"Expected nstime_update() to be called\");\n\t}\n\n\tdo_epoch();\n\tsz = sizeof(uint64_t);\n\tnpurge1 = get_arena_npurge(0);\n\n\tif (config_stats) {\n\t\texpect_u64_eq(npurge0, npurge1, \"Unexpected purging occurred\");\n\t}\n\n\tnstime_monotonic = nstime_monotonic_orig;\n\tnstime_update = nstime_update_orig;\n#undef NPS\n}\nTEST_END\n\nTEST_BEGIN(test_decay_now) {\n\ttest_skip_if(is_background_thread_enabled());\n\ttest_skip_if(opt_hpa);\n\n\tunsigned arena_ind = do_arena_create(0, 0);\n\texpect_zu_eq(get_arena_pdirty(arena_ind), 0, \"Unexpected dirty pages\");\n\texpect_zu_eq(get_arena_pmuzzy(arena_ind), 0, \"Unexpected muzzy pages\");\n\tsize_t sizes[] = {16, PAGE<<2, HUGEPAGE<<2};\n\t/* Verify that dirty/muzzy pages never linger after deallocation. */\n\tfor (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {\n\t\tsize_t size = sizes[i];\n\t\tgenerate_dirty(arena_ind, size);\n\t\texpect_zu_eq(get_arena_pdirty(arena_ind), 0,\n\t\t \"Unexpected dirty pages\");\n\t\texpect_zu_eq(get_arena_pmuzzy(arena_ind), 0,\n\t\t \"Unexpected muzzy pages\");\n\t}\n\tdo_arena_destroy(arena_ind);\n}\nTEST_END\n\nTEST_BEGIN(test_decay_never) {\n\ttest_skip_if(is_background_thread_enabled() || !config_stats);\n\ttest_skip_if(opt_hpa);\n\n\tunsigned arena_ind = do_arena_create(-1, -1);\n\tint flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\texpect_zu_eq(get_arena_pdirty(arena_ind), 0, \"Unexpected dirty pages\");\n\texpect_zu_eq(get_arena_pmuzzy(arena_ind), 0, \"Unexpected muzzy pages\");\n\tsize_t sizes[] = {16, PAGE<<2, HUGEPAGE<<2};\n\tvoid *ptrs[sizeof(sizes)/sizeof(size_t)];\n\tfor (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {\n\t\tptrs[i] = do_mallocx(sizes[i], flags);\n\t}\n\t/* Verify that each deallocation generates additional dirty pages. */\n\tsize_t pdirty_prev = get_arena_pdirty(arena_ind);\n\tsize_t pmuzzy_prev = get_arena_pmuzzy(arena_ind);\n\texpect_zu_eq(pdirty_prev, 0, \"Unexpected dirty pages\");\n\texpect_zu_eq(pmuzzy_prev, 0, \"Unexpected muzzy pages\");\n\tfor (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {\n\t\tdallocx(ptrs[i], flags);\n\t\tsize_t pdirty = get_arena_pdirty(arena_ind);\n\t\tsize_t pmuzzy = get_arena_pmuzzy(arena_ind);\n\t\texpect_zu_gt(pdirty + (size_t)get_arena_dirty_purged(arena_ind),\n\t\t pdirty_prev, \"Expected dirty pages to increase.\");\n\t\texpect_zu_eq(pmuzzy, 0, \"Unexpected muzzy pages\");\n\t\tpdirty_prev = pdirty;\n\t}\n\tdo_arena_destroy(arena_ind);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_decay_ticks,\n\t test_decay_ticker,\n\t test_decay_nonmonotonic,\n\t test_decay_now,\n\t test_decay_never);\n}\n" }, { "path": "deps/jemalloc/test/unit/arena_decay.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"dirty_decay_ms:1000,muzzy_decay_ms:1000,tcache_max:1024\"\n" }, { "path": "deps/jemalloc/test/unit/arena_reset.c", "content": "#ifndef ARENA_RESET_PROF_C_\n#include \"test/jemalloc_test.h\"\n#endif\n\n#include \"jemalloc/internal/extent_mmap.h\"\n#include \"jemalloc/internal/rtree.h\"\n\n#include \"test/extent_hooks.h\"\n\nstatic unsigned\nget_nsizes_impl(const char *cmd) {\n\tunsigned ret;\n\tsize_t z;\n\n\tz = sizeof(unsigned);\n\texpect_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,\n\t \"Unexpected mallctl(\\\"%s\\\", ...) failure\", cmd);\n\n\treturn ret;\n}\n\nstatic unsigned\nget_nsmall(void) {\n\treturn get_nsizes_impl(\"arenas.nbins\");\n}\n\nstatic unsigned\nget_nlarge(void) {\n\treturn get_nsizes_impl(\"arenas.nlextents\");\n}\n\nstatic size_t\nget_size_impl(const char *cmd, size_t ind) {\n\tsize_t ret;\n\tsize_t z;\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\", %zu], ...) failure\", cmd, ind);\n\n\treturn ret;\n}\n\nstatic size_t\nget_small_size(size_t ind) {\n\treturn get_size_impl(\"arenas.bin.0.size\", ind);\n}\n\nstatic size_t\nget_large_size(size_t ind) {\n\treturn get_size_impl(\"arenas.lextent.0.size\", ind);\n}\n\n/* Like ivsalloc(), but safe to call on discarded allocations. */\nstatic size_t\nvsalloc(tsdn_t *tsdn, const void *ptr) {\n\temap_full_alloc_ctx_t full_alloc_ctx;\n\tbool missing = emap_full_alloc_ctx_try_lookup(tsdn, &arena_emap_global,\n\t ptr, &full_alloc_ctx);\n\tif (missing) {\n\t\treturn 0;\n\t}\n\n\tif (full_alloc_ctx.edata == NULL) {\n\t\treturn 0;\n\t}\n\tif (edata_state_get(full_alloc_ctx.edata) != extent_state_active) {\n\t\treturn 0;\n\t}\n\n\tif (full_alloc_ctx.szind == SC_NSIZES) {\n\t\treturn 0;\n\t}\n\n\treturn sz_index2size(full_alloc_ctx.szind);\n}\n\nstatic unsigned\ndo_arena_create(extent_hooks_t *h) {\n\tunsigned arena_ind;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz,\n\t (void *)(h != NULL ? &h : NULL), (h != NULL ? sizeof(h) : 0)), 0,\n\t \"Unexpected mallctl() failure\");\n\treturn arena_ind;\n}\n\nstatic void\ndo_arena_reset_pre(unsigned arena_ind, void ***ptrs, unsigned *nptrs) {\n#define NLARGE\t32\n\tunsigned nsmall, nlarge, i;\n\tsize_t sz;\n\tint flags;\n\ttsdn_t *tsdn;\n\n\tflags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\n\tnsmall = get_nsmall();\n\tnlarge = get_nlarge() > NLARGE ? NLARGE : get_nlarge();\n\t*nptrs = nsmall + nlarge;\n\t*ptrs = (void **)malloc(*nptrs * sizeof(void *));\n\texpect_ptr_not_null(*ptrs, \"Unexpected malloc() failure\");\n\n\t/* Allocate objects with a wide range of sizes. */\n\tfor (i = 0; i < nsmall; i++) {\n\t\tsz = get_small_size(i);\n\t\t(*ptrs)[i] = mallocx(sz, flags);\n\t\texpect_ptr_not_null((*ptrs)[i],\n\t\t \"Unexpected mallocx(%zu, %#x) failure\", sz, flags);\n\t}\n\tfor (i = 0; i < nlarge; i++) {\n\t\tsz = get_large_size(i);\n\t\t(*ptrs)[nsmall + i] = mallocx(sz, flags);\n\t\texpect_ptr_not_null((*ptrs)[i],\n\t\t \"Unexpected mallocx(%zu, %#x) failure\", sz, flags);\n\t}\n\n\ttsdn = tsdn_fetch();\n\n\t/* Verify allocations. */\n\tfor (i = 0; i < *nptrs; i++) {\n\t\texpect_zu_gt(ivsalloc(tsdn, (*ptrs)[i]), 0,\n\t\t \"Allocation should have queryable size\");\n\t}\n}\n\nstatic void\ndo_arena_reset_post(void **ptrs, unsigned nptrs, unsigned arena_ind) {\n\ttsdn_t *tsdn;\n\tunsigned i;\n\n\ttsdn = tsdn_fetch();\n\n\tif (have_background_thread) {\n\t\tmalloc_mutex_lock(tsdn,\n\t\t &background_thread_info_get(arena_ind)->mtx);\n\t}\n\t/* Verify allocations no longer exist. */\n\tfor (i = 0; i < nptrs; i++) {\n\t\texpect_zu_eq(vsalloc(tsdn, ptrs[i]), 0,\n\t\t \"Allocation should no longer exist\");\n\t}\n\tif (have_background_thread) {\n\t\tmalloc_mutex_unlock(tsdn,\n\t\t &background_thread_info_get(arena_ind)->mtx);\n\t}\n\n\tfree(ptrs);\n}\n\nstatic void\ndo_arena_reset_destroy(const char *name, unsigned arena_ind) {\n\tsize_t mib[3];\n\tsize_t miblen;\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(name, mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nstatic void\ndo_arena_reset(unsigned arena_ind) {\n\tdo_arena_reset_destroy(\"arena.0.reset\", arena_ind);\n}\n\nstatic void\ndo_arena_destroy(unsigned arena_ind) {\n\tdo_arena_reset_destroy(\"arena.0.destroy\", arena_ind);\n}\n\nTEST_BEGIN(test_arena_reset) {\n\tunsigned arena_ind;\n\tvoid **ptrs;\n\tunsigned nptrs;\n\n\tarena_ind = do_arena_create(NULL);\n\tdo_arena_reset_pre(arena_ind, &ptrs, &nptrs);\n\tdo_arena_reset(arena_ind);\n\tdo_arena_reset_post(ptrs, nptrs, arena_ind);\n}\nTEST_END\n\nstatic bool\narena_i_initialized(unsigned arena_ind, bool refresh) {\n\tbool initialized;\n\tsize_t mib[3];\n\tsize_t miblen, sz;\n\n\tif (refresh) {\n\t\tuint64_t epoch = 1;\n\t\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch,\n\t\t sizeof(epoch)), 0, \"Unexpected mallctl() failure\");\n\t}\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.initialized\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\tsz = sizeof(initialized);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&initialized, &sz, NULL,\n\t 0), 0, \"Unexpected mallctlbymib() failure\");\n\n\treturn initialized;\n}\n\nTEST_BEGIN(test_arena_destroy_initial) {\n\texpect_false(arena_i_initialized(MALLCTL_ARENAS_DESTROYED, false),\n\t \"Destroyed arena stats should not be initialized\");\n}\nTEST_END\n\nTEST_BEGIN(test_arena_destroy_hooks_default) {\n\tunsigned arena_ind, arena_ind_another, arena_ind_prev;\n\tvoid **ptrs;\n\tunsigned nptrs;\n\n\tarena_ind = do_arena_create(NULL);\n\tdo_arena_reset_pre(arena_ind, &ptrs, &nptrs);\n\n\texpect_false(arena_i_initialized(arena_ind, false),\n\t \"Arena stats should not be initialized\");\n\texpect_true(arena_i_initialized(arena_ind, true),\n\t \"Arena stats should be initialized\");\n\n\t/*\n\t * Create another arena before destroying one, to better verify arena\n\t * index reuse.\n\t */\n\tarena_ind_another = do_arena_create(NULL);\n\n\tdo_arena_destroy(arena_ind);\n\n\texpect_false(arena_i_initialized(arena_ind, true),\n\t \"Arena stats should not be initialized\");\n\texpect_true(arena_i_initialized(MALLCTL_ARENAS_DESTROYED, false),\n\t \"Destroyed arena stats should be initialized\");\n\n\tdo_arena_reset_post(ptrs, nptrs, arena_ind);\n\n\tarena_ind_prev = arena_ind;\n\tarena_ind = do_arena_create(NULL);\n\tdo_arena_reset_pre(arena_ind, &ptrs, &nptrs);\n\texpect_u_eq(arena_ind, arena_ind_prev,\n\t \"Arena index should have been recycled\");\n\tdo_arena_destroy(arena_ind);\n\tdo_arena_reset_post(ptrs, nptrs, arena_ind);\n\n\tdo_arena_destroy(arena_ind_another);\n\n\t/* Try arena.create with custom hooks. */\n\tsize_t sz = sizeof(extent_hooks_t *);\n\textent_hooks_t *a0_default_hooks;\n\texpect_d_eq(mallctl(\"arena.0.extent_hooks\", (void *)&a0_default_hooks,\n\t &sz, NULL, 0), 0, \"Unexpected mallctlnametomib() failure\");\n\n\t/* Default impl; but wrapped as \"customized\". */\n\textent_hooks_t new_hooks = *a0_default_hooks;\n\textent_hooks_t *hook = &new_hooks;\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz,\n\t (void *)&hook, sizeof(void *)), 0,\n\t \"Unexpected mallctl() failure\");\n\tdo_arena_destroy(arena_ind);\n}\nTEST_END\n\n/*\n * Actually unmap extents, regardless of opt_retain, so that attempts to access\n * a destroyed arena's memory will segfault.\n */\nstatic bool\nextent_dalloc_unmap(extent_hooks_t *extent_hooks, void *addr, size_t size,\n bool committed, unsigned arena_ind) {\n\tTRACE_HOOK(\"%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, \"\n\t \"arena_ind=%u)\\n\", __func__, extent_hooks, addr, size, committed ?\n\t \"true\" : \"false\", arena_ind);\n\texpect_ptr_eq(extent_hooks, &hooks,\n\t \"extent_hooks should be same as pointer used to set hooks\");\n\texpect_ptr_eq(extent_hooks->dalloc, extent_dalloc_unmap,\n\t \"Wrong hook function\");\n\tcalled_dalloc = true;\n\tif (!try_dalloc) {\n\t\treturn true;\n\t}\n\tdid_dalloc = true;\n\tif (!maps_coalesce && opt_retain) {\n\t\treturn true;\n\t}\n\tpages_unmap(addr, size);\n\treturn false;\n}\n\nstatic extent_hooks_t hooks_orig;\n\nstatic extent_hooks_t hooks_unmap = {\n\textent_alloc_hook,\n\textent_dalloc_unmap, /* dalloc */\n\textent_destroy_hook,\n\textent_commit_hook,\n\textent_decommit_hook,\n\textent_purge_lazy_hook,\n\textent_purge_forced_hook,\n\textent_split_hook,\n\textent_merge_hook\n};\n\nTEST_BEGIN(test_arena_destroy_hooks_unmap) {\n\tunsigned arena_ind;\n\tvoid **ptrs;\n\tunsigned nptrs;\n\n\textent_hooks_prep();\n\tif (maps_coalesce) {\n\t\ttry_decommit = false;\n\t}\n\tmemcpy(&hooks_orig, &hooks, sizeof(extent_hooks_t));\n\tmemcpy(&hooks, &hooks_unmap, sizeof(extent_hooks_t));\n\n\tdid_alloc = false;\n\tarena_ind = do_arena_create(&hooks);\n\tdo_arena_reset_pre(arena_ind, &ptrs, &nptrs);\n\n\texpect_true(did_alloc, \"Expected alloc\");\n\n\texpect_false(arena_i_initialized(arena_ind, false),\n\t \"Arena stats should not be initialized\");\n\texpect_true(arena_i_initialized(arena_ind, true),\n\t \"Arena stats should be initialized\");\n\n\tdid_dalloc = false;\n\tdo_arena_destroy(arena_ind);\n\texpect_true(did_dalloc, \"Expected dalloc\");\n\n\texpect_false(arena_i_initialized(arena_ind, true),\n\t \"Arena stats should not be initialized\");\n\texpect_true(arena_i_initialized(MALLCTL_ARENAS_DESTROYED, false),\n\t \"Destroyed arena stats should be initialized\");\n\n\tdo_arena_reset_post(ptrs, nptrs, arena_ind);\n\n\tmemcpy(&hooks, &hooks_orig, sizeof(extent_hooks_t));\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_arena_reset,\n\t test_arena_destroy_initial,\n\t test_arena_destroy_hooks_default,\n\t test_arena_destroy_hooks_unmap);\n}\n" }, { "path": "deps/jemalloc/test/unit/arena_reset_prof.c", "content": "#include \"test/jemalloc_test.h\"\n#define ARENA_RESET_PROF_C_\n\n#include \"arena_reset.c\"\n" }, { "path": "deps/jemalloc/test/unit/arena_reset_prof.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"prof:true,lg_prof_sample:0\"\n" }, { "path": "deps/jemalloc/test/unit/atomic.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * We *almost* have consistent short names (e.g. \"u32\" for uint32_t, \"b\" for\n * bool, etc. The one exception is that the short name for void * is \"p\" in\n * some places and \"ptr\" in others. In the long run it would be nice to unify\n * these, but in the short run we'll use this shim.\n */\n#define expect_p_eq expect_ptr_eq\n\n/*\n * t: the non-atomic type, like \"uint32_t\".\n * ta: the short name for the type, like \"u32\".\n * val[1,2,3]: Values of the given type. The CAS tests use val2 for expected,\n * and val3 for desired.\n */\n\n#define DO_TESTS(t, ta, val1, val2, val3) do {\t\t\t\t\\\n\tt val;\t\t\t\t\t\t\t\t\\\n\tt expected;\t\t\t\t\t\t\t\\\n\tbool success;\t\t\t\t\t\t\t\\\n\t/* This (along with the load below) also tests ATOMIC_LOAD. */\t\\\n\tatomic_##ta##_t atom = ATOMIC_INIT(val1);\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* ATOMIC_INIT and load. */\t\t\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1, val, \"Load or init failed\");\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Store. */\t\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tatomic_store_##ta(&atom, val2, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val2, val, \"Store failed\");\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Exchange. */\t\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_exchange_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val, \"Exchange returned invalid value\");\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val2, val, \"Exchange store invalid value\");\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* \t\t\t\t\t\t\t\t\\\n\t * Weak CAS. Spurious failures are allowed, so we loop a few\t\\\n\t * times.\t\t\t\t\t\t\t\\\n\t */\t\t\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tsuccess = false;\t\t\t\t\t\t\\\n\tfor (int retry = 0; retry < 10 && !success; retry++) {\t\t\\\n\t\texpected = val2;\t\t\t\t\t\\\n\t\tsuccess = atomic_compare_exchange_weak_##ta(&atom,\t\\\n\t\t &expected, val3, ATOMIC_RELAXED, ATOMIC_RELAXED);\t\\\n\t\texpect_##ta##_eq(val1, expected, \t\t\t\\\n\t\t \"CAS should update expected\");\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\texpect_b_eq(val1 == val2, success,\t\t\t\t\\\n\t \"Weak CAS did the wrong state update\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\tif (success) {\t\t\t\t\t\t\t\\\n\t\texpect_##ta##_eq(val3, val,\t\t\t\t\\\n\t\t \"Successful CAS should update atomic\");\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\texpect_##ta##_eq(val1, val,\t\t\t\t\\\n\t\t \"Unsuccessful CAS should not update atomic\");\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Strong CAS. */\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\texpected = val2;\t\t\t\t\t\t\\\n\tsuccess = atomic_compare_exchange_strong_##ta(&atom, &expected,\t\\\n\t val3, ATOMIC_RELAXED, ATOMIC_RELAXED);\t\t\t\\\n\texpect_b_eq(val1 == val2, success,\t\t\t\t\\\n\t \"Strong CAS did the wrong state update\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\tif (success) {\t\t\t\t\t\t\t\\\n\t\texpect_##ta##_eq(val3, val,\t\t\t\t\\\n\t\t \"Successful CAS should update atomic\");\t\t\\\n\t} else {\t\t\t\t\t\t\t\\\n\t\texpect_##ta##_eq(val1, val,\t\t\t\t\\\n\t\t \"Unsuccessful CAS should not update atomic\");\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define DO_INTEGER_TESTS(t, ta, val1, val2) do {\t\t\t\\\n\tatomic_##ta##_t atom;\t\t\t\t\t\t\\\n\tt val;\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Fetch-add. */\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_fetch_add_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val,\t\t\t\t\t\\\n\t \"Fetch-add should return previous value\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1 + val2, val,\t\t\t\t\\\n\t \"Fetch-add should update atomic\");\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Fetch-sub. */\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_fetch_sub_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val,\t\t\t\t\t\\\n\t \"Fetch-sub should return previous value\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1 - val2, val,\t\t\t\t\\\n\t \"Fetch-sub should update atomic\");\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Fetch-and. */\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_fetch_and_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val,\t\t\t\t\t\\\n\t \"Fetch-and should return previous value\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1 & val2, val,\t\t\t\t\\\n\t \"Fetch-and should update atomic\");\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Fetch-or. */\t\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_fetch_or_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val,\t\t\t\t\t\\\n\t \"Fetch-or should return previous value\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1 | val2, val,\t\t\t\t\\\n\t \"Fetch-or should update atomic\");\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t/* Fetch-xor. */\t\t\t\t\t\t\\\n\tatomic_store_##ta(&atom, val1, ATOMIC_RELAXED);\t\t\t\\\n\tval = atomic_fetch_xor_##ta(&atom, val2, ATOMIC_RELAXED);\t\\\n\texpect_##ta##_eq(val1, val,\t\t\t\t\t\\\n\t \"Fetch-xor should return previous value\");\t\t\t\\\n\tval = atomic_load_##ta(&atom, ATOMIC_RELAXED);\t\t\t\\\n\texpect_##ta##_eq(val1 ^ val2, val,\t\t\t\t\\\n\t \"Fetch-xor should update atomic\");\t\t\t\t\\\n} while (0)\n\n#define TEST_STRUCT(t, ta)\t\t\t\t\t\t\\\ntypedef struct {\t\t\t\t\t\t\t\\\n\tt val1;\t\t\t\t\t\t\t\t\\\n\tt val2;\t\t\t\t\t\t\t\t\\\n\tt val3;\t\t\t\t\t\t\t\t\\\n} ta##_test_t;\n\n#define TEST_CASES(t) {\t\t\t\t\t\t\t\\\n\t{(t)-1, (t)-1, (t)-2},\t\t\t\t\t\t\\\n\t{(t)-1, (t) 0, (t)-2},\t\t\t\t\t\t\\\n\t{(t)-1, (t) 1, (t)-2},\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t{(t) 0, (t)-1, (t)-2},\t\t\t\t\t\t\\\n\t{(t) 0, (t) 0, (t)-2},\t\t\t\t\t\t\\\n\t{(t) 0, (t) 1, (t)-2},\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t{(t) 1, (t)-1, (t)-2},\t\t\t\t\t\t\\\n\t{(t) 1, (t) 0, (t)-2},\t\t\t\t\t\t\\\n\t{(t) 1, (t) 1, (t)-2},\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\t{(t)0, (t)-(1 << 22), (t)-2},\t\t\t\t\t\\\n\t{(t)0, (t)(1 << 22), (t)-2},\t\t\t\t\t\\\n\t{(t)(1 << 22), (t)-(1 << 22), (t)-2},\t\t\t\t\\\n\t{(t)(1 << 22), (t)(1 << 22), (t)-2}\t\t\t\t\\\n}\n\n#define TEST_BODY(t, ta) do {\t\t\t\t\t\t\\\n\tconst ta##_test_t tests[] = TEST_CASES(t);\t\t\t\\\n\tfor (unsigned i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {\t\\\n\t\tta##_test_t test = tests[i];\t\t\t\t\\\n\t\tDO_TESTS(t, ta, test.val1, test.val2, test.val3);\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\n#define INTEGER_TEST_BODY(t, ta) do {\t\t\t\t\t\\\n\tconst ta##_test_t tests[] = TEST_CASES(t);\t\t\t\\\n\tfor (unsigned i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {\t\\\n\t\tta##_test_t test = tests[i];\t\t\t\t\\\n\t\tDO_TESTS(t, ta, test.val1, test.val2, test.val3);\t\\\n\t\tDO_INTEGER_TESTS(t, ta, test.val1, test.val2);\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\nTEST_STRUCT(uint64_t, u64);\nTEST_BEGIN(test_atomic_u64) {\n#if !(LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3)\n\ttest_skip(\"64-bit atomic operations not supported\");\n#else\n\tINTEGER_TEST_BODY(uint64_t, u64);\n#endif\n}\nTEST_END\n\n\nTEST_STRUCT(uint32_t, u32);\nTEST_BEGIN(test_atomic_u32) {\n\tINTEGER_TEST_BODY(uint32_t, u32);\n}\nTEST_END\n\nTEST_STRUCT(void *, p);\nTEST_BEGIN(test_atomic_p) {\n\tTEST_BODY(void *, p);\n}\nTEST_END\n\nTEST_STRUCT(size_t, zu);\nTEST_BEGIN(test_atomic_zu) {\n\tINTEGER_TEST_BODY(size_t, zu);\n}\nTEST_END\n\nTEST_STRUCT(ssize_t, zd);\nTEST_BEGIN(test_atomic_zd) {\n\tINTEGER_TEST_BODY(ssize_t, zd);\n}\nTEST_END\n\n\nTEST_STRUCT(unsigned, u);\nTEST_BEGIN(test_atomic_u) {\n\tINTEGER_TEST_BODY(unsigned, u);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_atomic_u64,\n\t test_atomic_u32,\n\t test_atomic_p,\n\t test_atomic_zu,\n\t test_atomic_zd,\n\t test_atomic_u);\n}\n" }, { "path": "deps/jemalloc/test/unit/background_thread.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/util.h\"\n\nstatic void\ntest_switch_background_thread_ctl(bool new_val) {\n\tbool e0, e1;\n\tsize_t sz = sizeof(bool);\n\n\te1 = new_val;\n\texpect_d_eq(mallctl(\"background_thread\", (void *)&e0, &sz,\n\t &e1, sz), 0, \"Unexpected mallctl() failure\");\n\texpect_b_eq(e0, !e1,\n\t \"background_thread should be %d before.\\n\", !e1);\n\tif (e1) {\n\t\texpect_zu_gt(n_background_threads, 0,\n\t\t \"Number of background threads should be non zero.\\n\");\n\t} else {\n\t\texpect_zu_eq(n_background_threads, 0,\n\t\t \"Number of background threads should be zero.\\n\");\n\t}\n}\n\nstatic void\ntest_repeat_background_thread_ctl(bool before) {\n\tbool e0, e1;\n\tsize_t sz = sizeof(bool);\n\n\te1 = before;\n\texpect_d_eq(mallctl(\"background_thread\", (void *)&e0, &sz,\n\t &e1, sz), 0, \"Unexpected mallctl() failure\");\n\texpect_b_eq(e0, before,\n\t \"background_thread should be %d.\\n\", before);\n\tif (e1) {\n\t\texpect_zu_gt(n_background_threads, 0,\n\t\t \"Number of background threads should be non zero.\\n\");\n\t} else {\n\t\texpect_zu_eq(n_background_threads, 0,\n\t\t \"Number of background threads should be zero.\\n\");\n\t}\n}\n\nTEST_BEGIN(test_background_thread_ctl) {\n\ttest_skip_if(!have_background_thread);\n\n\tbool e0, e1;\n\tsize_t sz = sizeof(bool);\n\n\texpect_d_eq(mallctl(\"opt.background_thread\", (void *)&e0, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctl(\"background_thread\", (void *)&e1, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\texpect_b_eq(e0, e1,\n\t \"Default and opt.background_thread does not match.\\n\");\n\tif (e0) {\n\t\ttest_switch_background_thread_ctl(false);\n\t}\n\texpect_zu_eq(n_background_threads, 0,\n\t \"Number of background threads should be 0.\\n\");\n\n\tfor (unsigned i = 0; i < 4; i++) {\n\t\ttest_switch_background_thread_ctl(true);\n\t\ttest_repeat_background_thread_ctl(true);\n\t\ttest_repeat_background_thread_ctl(true);\n\n\t\ttest_switch_background_thread_ctl(false);\n\t\ttest_repeat_background_thread_ctl(false);\n\t\ttest_repeat_background_thread_ctl(false);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_background_thread_running) {\n\ttest_skip_if(!have_background_thread);\n\ttest_skip_if(!config_stats);\n\n#if defined(JEMALLOC_BACKGROUND_THREAD)\n\ttsd_t *tsd = tsd_fetch();\n\tbackground_thread_info_t *info = &background_thread_info[0];\n\n\ttest_repeat_background_thread_ctl(false);\n\ttest_switch_background_thread_ctl(true);\n\texpect_b_eq(info->state, background_thread_started,\n\t \"Background_thread did not start.\\n\");\n\n\tnstime_t start;\n\tnstime_init_update(&start);\n\n\tbool ran = false;\n\twhile (true) {\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\tif (info->tot_n_runs > 0) {\n\t\t\tran = true;\n\t\t}\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\tif (ran) {\n\t\t\tbreak;\n\t\t}\n\n\t\tnstime_t now;\n\t\tnstime_init_update(&now);\n\t\tnstime_subtract(&now, &start);\n\t\texpect_u64_lt(nstime_sec(&now), 1000,\n\t\t \"Background threads did not run for 1000 seconds.\");\n\t\tsleep(1);\n\t}\n\ttest_switch_background_thread_ctl(false);\n#endif\n}\nTEST_END\n\nint\nmain(void) {\n\t/* Background_thread creation tests reentrancy naturally. */\n\treturn test_no_reentrancy(\n\t test_background_thread_ctl,\n\t test_background_thread_running);\n}\n" }, { "path": "deps/jemalloc/test/unit/background_thread_enable.c", "content": "#include \"test/jemalloc_test.h\"\n\nconst char *malloc_conf = \"background_thread:false,narenas:1,max_background_threads:20\";\n\nstatic unsigned\nmax_test_narenas(void) {\n\t/*\n\t * 10 here is somewhat arbitrary, except insofar as we want to ensure\n\t * that the number of background threads is smaller than the number of\n\t * arenas. I'll ragequit long before we have to spin up 10 threads per\n\t * cpu to handle background purging, so this is a conservative\n\t * approximation.\n\t */\n\tunsigned ret = 10 * ncpus;\n\t/* Limit the max to avoid VM exhaustion on 32-bit . */\n\tif (ret > 512) {\n\t\tret = 512;\n\t}\n\n\treturn ret;\n}\n\nTEST_BEGIN(test_deferred) {\n\ttest_skip_if(!have_background_thread);\n\n\tunsigned id;\n\tsize_t sz_u = sizeof(unsigned);\n\n\tfor (unsigned i = 0; i < max_test_narenas(); i++) {\n\t\texpect_d_eq(mallctl(\"arenas.create\", &id, &sz_u, NULL, 0), 0,\n\t\t \"Failed to create arena\");\n\t}\n\n\tbool enable = true;\n\tsize_t sz_b = sizeof(bool);\n\texpect_d_eq(mallctl(\"background_thread\", NULL, NULL, &enable, sz_b), 0,\n\t \"Failed to enable background threads\");\n\tenable = false;\n\texpect_d_eq(mallctl(\"background_thread\", NULL, NULL, &enable, sz_b), 0,\n\t \"Failed to disable background threads\");\n}\nTEST_END\n\nTEST_BEGIN(test_max_background_threads) {\n\ttest_skip_if(!have_background_thread);\n\n\tsize_t max_n_thds;\n\tsize_t opt_max_n_thds;\n\tsize_t sz_m = sizeof(max_n_thds);\n\texpect_d_eq(mallctl(\"opt.max_background_threads\",\n\t &opt_max_n_thds, &sz_m, NULL, 0), 0,\n\t \"Failed to get opt.max_background_threads\");\n\texpect_d_eq(mallctl(\"max_background_threads\", &max_n_thds, &sz_m, NULL,\n\t 0), 0, \"Failed to get max background threads\");\n\texpect_zu_eq(opt_max_n_thds, max_n_thds,\n\t \"max_background_threads and \"\n\t \"opt.max_background_threads should match\");\n\texpect_d_eq(mallctl(\"max_background_threads\", NULL, NULL, &max_n_thds,\n\t sz_m), 0, \"Failed to set max background threads\");\n\n\tunsigned id;\n\tsize_t sz_u = sizeof(unsigned);\n\n\tfor (unsigned i = 0; i < max_test_narenas(); i++) {\n\t\texpect_d_eq(mallctl(\"arenas.create\", &id, &sz_u, NULL, 0), 0,\n\t\t \"Failed to create arena\");\n\t}\n\n\tbool enable = true;\n\tsize_t sz_b = sizeof(bool);\n\texpect_d_eq(mallctl(\"background_thread\", NULL, NULL, &enable, sz_b), 0,\n\t \"Failed to enable background threads\");\n\texpect_zu_eq(n_background_threads, max_n_thds,\n\t \"Number of background threads should not change.\\n\");\n\tsize_t new_max_thds = max_n_thds - 1;\n\tif (new_max_thds > 0) {\n\t\texpect_d_eq(mallctl(\"max_background_threads\", NULL, NULL,\n\t\t &new_max_thds, sz_m), 0,\n\t\t \"Failed to set max background threads\");\n\t\texpect_zu_eq(n_background_threads, new_max_thds,\n\t\t \"Number of background threads should decrease by 1.\\n\");\n\t}\n\tnew_max_thds = 1;\n\texpect_d_eq(mallctl(\"max_background_threads\", NULL, NULL, &new_max_thds,\n\t sz_m), 0, \"Failed to set max background threads\");\n\texpect_zu_eq(n_background_threads, new_max_thds,\n\t \"Number of background threads should be 1.\\n\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t\ttest_deferred,\n\t\ttest_max_background_threads);\n}\n" }, { "path": "deps/jemalloc/test/unit/base.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"test/extent_hooks.h\"\n\nstatic extent_hooks_t hooks_null = {\n\textent_alloc_hook,\n\tNULL, /* dalloc */\n\tNULL, /* destroy */\n\tNULL, /* commit */\n\tNULL, /* decommit */\n\tNULL, /* purge_lazy */\n\tNULL, /* purge_forced */\n\tNULL, /* split */\n\tNULL /* merge */\n};\n\nstatic extent_hooks_t hooks_not_null = {\n\textent_alloc_hook,\n\textent_dalloc_hook,\n\textent_destroy_hook,\n\tNULL, /* commit */\n\textent_decommit_hook,\n\textent_purge_lazy_hook,\n\textent_purge_forced_hook,\n\tNULL, /* split */\n\tNULL /* merge */\n};\n\nTEST_BEGIN(test_base_hooks_default) {\n\tbase_t *base;\n\tsize_t allocated0, allocated1, resident, mapped, n_thp;\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tbase = base_new(tsdn, 0,\n\t (extent_hooks_t *)&ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\n\tif (config_stats) {\n\t\tbase_stats_get(tsdn, base, &allocated0, &resident, &mapped,\n\t\t &n_thp);\n\t\texpect_zu_ge(allocated0, sizeof(base_t),\n\t\t \"Base header should count as allocated\");\n\t\tif (opt_metadata_thp == metadata_thp_always) {\n\t\t\texpect_zu_gt(n_thp, 0,\n\t\t\t \"Base should have 1 THP at least.\");\n\t\t}\n\t}\n\n\texpect_ptr_not_null(base_alloc(tsdn, base, 42, 1),\n\t \"Unexpected base_alloc() failure\");\n\n\tif (config_stats) {\n\t\tbase_stats_get(tsdn, base, &allocated1, &resident, &mapped,\n\t\t &n_thp);\n\t\texpect_zu_ge(allocated1 - allocated0, 42,\n\t\t \"At least 42 bytes were allocated by base_alloc()\");\n\t}\n\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\nTEST_BEGIN(test_base_hooks_null) {\n\textent_hooks_t hooks_orig;\n\tbase_t *base;\n\tsize_t allocated0, allocated1, resident, mapped, n_thp;\n\n\textent_hooks_prep();\n\ttry_dalloc = false;\n\ttry_destroy = true;\n\ttry_decommit = false;\n\ttry_purge_lazy = false;\n\ttry_purge_forced = false;\n\tmemcpy(&hooks_orig, &hooks, sizeof(extent_hooks_t));\n\tmemcpy(&hooks, &hooks_null, sizeof(extent_hooks_t));\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tbase = base_new(tsdn, 0, &hooks, /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new() failure\");\n\n\tif (config_stats) {\n\t\tbase_stats_get(tsdn, base, &allocated0, &resident, &mapped,\n\t\t &n_thp);\n\t\texpect_zu_ge(allocated0, sizeof(base_t),\n\t\t \"Base header should count as allocated\");\n\t\tif (opt_metadata_thp == metadata_thp_always) {\n\t\t\texpect_zu_gt(n_thp, 0,\n\t\t\t \"Base should have 1 THP at least.\");\n\t\t}\n\t}\n\n\texpect_ptr_not_null(base_alloc(tsdn, base, 42, 1),\n\t \"Unexpected base_alloc() failure\");\n\n\tif (config_stats) {\n\t\tbase_stats_get(tsdn, base, &allocated1, &resident, &mapped,\n\t\t &n_thp);\n\t\texpect_zu_ge(allocated1 - allocated0, 42,\n\t\t \"At least 42 bytes were allocated by base_alloc()\");\n\t}\n\n\tbase_delete(tsdn, base);\n\n\tmemcpy(&hooks, &hooks_orig, sizeof(extent_hooks_t));\n}\nTEST_END\n\nTEST_BEGIN(test_base_hooks_not_null) {\n\textent_hooks_t hooks_orig;\n\tbase_t *base;\n\tvoid *p, *q, *r, *r_exp;\n\n\textent_hooks_prep();\n\ttry_dalloc = false;\n\ttry_destroy = true;\n\ttry_decommit = false;\n\ttry_purge_lazy = false;\n\ttry_purge_forced = false;\n\tmemcpy(&hooks_orig, &hooks, sizeof(extent_hooks_t));\n\tmemcpy(&hooks, &hooks_not_null, sizeof(extent_hooks_t));\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tdid_alloc = false;\n\tbase = base_new(tsdn, 0, &hooks, /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new() failure\");\n\texpect_true(did_alloc, \"Expected alloc\");\n\n\t/*\n\t * Check for tight packing at specified alignment under simple\n\t * conditions.\n\t */\n\t{\n\t\tconst size_t alignments[] = {\n\t\t\t1,\n\t\t\tQUANTUM,\n\t\t\tQUANTUM << 1,\n\t\t\tCACHELINE,\n\t\t\tCACHELINE << 1,\n\t\t};\n\t\tunsigned i;\n\n\t\tfor (i = 0; i < sizeof(alignments) / sizeof(size_t); i++) {\n\t\t\tsize_t alignment = alignments[i];\n\t\t\tsize_t align_ceil = ALIGNMENT_CEILING(alignment,\n\t\t\t QUANTUM);\n\t\t\tp = base_alloc(tsdn, base, 1, alignment);\n\t\t\texpect_ptr_not_null(p,\n\t\t\t \"Unexpected base_alloc() failure\");\n\t\t\texpect_ptr_eq(p,\n\t\t\t (void *)(ALIGNMENT_CEILING((uintptr_t)p,\n\t\t\t alignment)), \"Expected quantum alignment\");\n\t\t\tq = base_alloc(tsdn, base, alignment, alignment);\n\t\t\texpect_ptr_not_null(q,\n\t\t\t \"Unexpected base_alloc() failure\");\n\t\t\texpect_ptr_eq((void *)((uintptr_t)p + align_ceil), q,\n\t\t\t \"Minimal allocation should take up %zu bytes\",\n\t\t\t align_ceil);\n\t\t\tr = base_alloc(tsdn, base, 1, alignment);\n\t\t\texpect_ptr_not_null(r,\n\t\t\t \"Unexpected base_alloc() failure\");\n\t\t\texpect_ptr_eq((void *)((uintptr_t)q + align_ceil), r,\n\t\t\t \"Minimal allocation should take up %zu bytes\",\n\t\t\t align_ceil);\n\t\t}\n\t}\n\n\t/*\n\t * Allocate an object that cannot fit in the first block, then verify\n\t * that the first block's remaining space is considered for subsequent\n\t * allocation.\n\t */\n\texpect_zu_ge(edata_bsize_get(&base->blocks->edata), QUANTUM,\n\t \"Remainder insufficient for test\");\n\t/* Use up all but one quantum of block. */\n\twhile (edata_bsize_get(&base->blocks->edata) > QUANTUM) {\n\t\tp = base_alloc(tsdn, base, QUANTUM, QUANTUM);\n\t\texpect_ptr_not_null(p, \"Unexpected base_alloc() failure\");\n\t}\n\tr_exp = edata_addr_get(&base->blocks->edata);\n\texpect_zu_eq(base->extent_sn_next, 1, \"One extant block expected\");\n\tq = base_alloc(tsdn, base, QUANTUM + 1, QUANTUM);\n\texpect_ptr_not_null(q, \"Unexpected base_alloc() failure\");\n\texpect_ptr_ne(q, r_exp, \"Expected allocation from new block\");\n\texpect_zu_eq(base->extent_sn_next, 2, \"Two extant blocks expected\");\n\tr = base_alloc(tsdn, base, QUANTUM, QUANTUM);\n\texpect_ptr_not_null(r, \"Unexpected base_alloc() failure\");\n\texpect_ptr_eq(r, r_exp, \"Expected allocation from first block\");\n\texpect_zu_eq(base->extent_sn_next, 2, \"Two extant blocks expected\");\n\n\t/*\n\t * Check for proper alignment support when normal blocks are too small.\n\t */\n\t{\n\t\tconst size_t alignments[] = {\n\t\t\tHUGEPAGE,\n\t\t\tHUGEPAGE << 1\n\t\t};\n\t\tunsigned i;\n\n\t\tfor (i = 0; i < sizeof(alignments) / sizeof(size_t); i++) {\n\t\t\tsize_t alignment = alignments[i];\n\t\t\tp = base_alloc(tsdn, base, QUANTUM, alignment);\n\t\t\texpect_ptr_not_null(p,\n\t\t\t \"Unexpected base_alloc() failure\");\n\t\t\texpect_ptr_eq(p,\n\t\t\t (void *)(ALIGNMENT_CEILING((uintptr_t)p,\n\t\t\t alignment)), \"Expected %zu-byte alignment\",\n\t\t\t alignment);\n\t\t}\n\t}\n\n\tcalled_dalloc = called_destroy = called_decommit = called_purge_lazy =\n\t called_purge_forced = false;\n\tbase_delete(tsdn, base);\n\texpect_true(called_dalloc, \"Expected dalloc call\");\n\texpect_true(!called_destroy, \"Unexpected destroy call\");\n\texpect_true(called_decommit, \"Expected decommit call\");\n\texpect_true(called_purge_lazy, \"Expected purge_lazy call\");\n\texpect_true(called_purge_forced, \"Expected purge_forced call\");\n\n\ttry_dalloc = true;\n\ttry_destroy = true;\n\ttry_decommit = true;\n\ttry_purge_lazy = true;\n\ttry_purge_forced = true;\n\tmemcpy(&hooks, &hooks_orig, sizeof(extent_hooks_t));\n}\nTEST_END\n\nTEST_BEGIN(test_base_ehooks_get_for_metadata_default_hook) {\n\textent_hooks_prep();\n\tmemcpy(&hooks, &hooks_not_null, sizeof(extent_hooks_t));\n\tbase_t *base;\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tbase = base_new(tsdn, 0, &hooks, /* metadata_use_hooks */ false);\n\tehooks_t *ehooks = base_ehooks_get_for_metadata(base);\n\texpect_true(ehooks_are_default(ehooks),\n\t\t\"Expected default extent hook functions pointer\");\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\n\nTEST_BEGIN(test_base_ehooks_get_for_metadata_custom_hook) {\n\textent_hooks_prep();\n\tmemcpy(&hooks, &hooks_not_null, sizeof(extent_hooks_t));\n\tbase_t *base;\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tbase = base_new(tsdn, 0, &hooks, /* metadata_use_hooks */ true);\n\tehooks_t *ehooks = base_ehooks_get_for_metadata(base);\n\texpect_ptr_eq(&hooks, ehooks_get_extent_hooks_ptr(ehooks),\n\t\t\"Expected user-specified extend hook functions pointer\");\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_base_hooks_default,\n\t test_base_hooks_null,\n\t test_base_hooks_not_null,\n test_base_ehooks_get_for_metadata_default_hook,\n test_base_ehooks_get_for_metadata_custom_hook);\n}\n" }, { "path": "deps/jemalloc/test/unit/batch_alloc.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define BATCH_MAX ((1U << 16) + 1024)\nstatic void *global_ptrs[BATCH_MAX];\n\n#define PAGE_ALIGNED(ptr) (((uintptr_t)ptr & PAGE_MASK) == 0)\n\nstatic void\nverify_batch_basic(tsd_t *tsd, void **ptrs, size_t batch, size_t usize,\n bool zero) {\n\tfor (size_t i = 0; i < batch; ++i) {\n\t\tvoid *p = ptrs[i];\n\t\texpect_zu_eq(isalloc(tsd_tsdn(tsd), p), usize, \"\");\n\t\tif (zero) {\n\t\t\tfor (size_t k = 0; k < usize; ++k) {\n\t\t\t\texpect_true(*((unsigned char *)p + k) == 0, \"\");\n\t\t\t}\n\t\t}\n\t}\n}\n\nstatic void\nverify_batch_locality(tsd_t *tsd, void **ptrs, size_t batch, size_t usize,\n arena_t *arena, unsigned nregs) {\n\tif (config_prof && opt_prof) {\n\t\t/*\n\t\t * Checking batch locality when prof is on is feasible but\n\t\t * complicated, while checking the non-prof case suffices for\n\t\t * unit-test purpose.\n\t\t */\n\t\treturn;\n\t}\n\tfor (size_t i = 0, j = 0; i < batch; ++i, ++j) {\n\t\tif (j == nregs) {\n\t\t\tj = 0;\n\t\t}\n\t\tif (j == 0 && batch - i < nregs) {\n\t\t\tbreak;\n\t\t}\n\t\tvoid *p = ptrs[i];\n\t\texpect_ptr_eq(iaalloc(tsd_tsdn(tsd), p), arena, \"\");\n\t\tif (j == 0) {\n\t\t\texpect_true(PAGE_ALIGNED(p), \"\");\n\t\t\tcontinue;\n\t\t}\n\t\tassert(i > 0);\n\t\tvoid *q = ptrs[i - 1];\n\t\texpect_true((uintptr_t)p > (uintptr_t)q\n\t\t && (size_t)((uintptr_t)p - (uintptr_t)q) == usize, \"\");\n\t}\n}\n\nstatic void\nrelease_batch(void **ptrs, size_t batch, size_t size) {\n\tfor (size_t i = 0; i < batch; ++i) {\n\t\tsdallocx(ptrs[i], size, 0);\n\t}\n}\n\ntypedef struct batch_alloc_packet_s batch_alloc_packet_t;\nstruct batch_alloc_packet_s {\n\tvoid **ptrs;\n\tsize_t num;\n\tsize_t size;\n\tint flags;\n};\n\nstatic size_t\nbatch_alloc_wrapper(void **ptrs, size_t num, size_t size, int flags) {\n\tbatch_alloc_packet_t batch_alloc_packet = {ptrs, num, size, flags};\n\tsize_t filled;\n\tsize_t len = sizeof(size_t);\n\tassert_d_eq(mallctl(\"experimental.batch_alloc\", &filled, &len,\n\t &batch_alloc_packet, sizeof(batch_alloc_packet)), 0, \"\");\n\treturn filled;\n}\n\nstatic void\ntest_wrapper(size_t size, size_t alignment, bool zero, unsigned arena_flag) {\n\ttsd_t *tsd = tsd_fetch();\n\tassert(tsd != NULL);\n\tconst size_t usize =\n\t (alignment != 0 ? sz_sa2u(size, alignment) : sz_s2u(size));\n\tconst szind_t ind = sz_size2index(usize);\n\tconst bin_info_t *bin_info = &bin_infos[ind];\n\tconst unsigned nregs = bin_info->nregs;\n\tassert(nregs > 0);\n\tarena_t *arena;\n\tif (arena_flag != 0) {\n\t\tarena = arena_get(tsd_tsdn(tsd), MALLOCX_ARENA_GET(arena_flag),\n\t\t false);\n\t} else {\n\t\tarena = arena_choose(tsd, NULL);\n\t}\n\tassert(arena != NULL);\n\tint flags = arena_flag;\n\tif (alignment != 0) {\n\t\tflags |= MALLOCX_ALIGN(alignment);\n\t}\n\tif (zero) {\n\t\tflags |= MALLOCX_ZERO;\n\t}\n\n\t/*\n\t * Allocate for the purpose of bootstrapping arena_tdata, so that the\n\t * change in bin stats won't contaminate the stats to be verified below.\n\t */\n\tvoid *p = mallocx(size, flags | MALLOCX_TCACHE_NONE);\n\n\tfor (size_t i = 0; i < 4; ++i) {\n\t\tsize_t base = 0;\n\t\tif (i == 1) {\n\t\t\tbase = nregs;\n\t\t} else if (i == 2) {\n\t\t\tbase = nregs * 2;\n\t\t} else if (i == 3) {\n\t\t\tbase = (1 << 16);\n\t\t}\n\t\tfor (int j = -1; j <= 1; ++j) {\n\t\t\tif (base == 0 && j == -1) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tsize_t batch = base + (size_t)j;\n\t\t\tassert(batch < BATCH_MAX);\n\t\t\tsize_t filled = batch_alloc_wrapper(global_ptrs, batch,\n\t\t\t size, flags);\n\t\t\tassert_zu_eq(filled, batch, \"\");\n\t\t\tverify_batch_basic(tsd, global_ptrs, batch, usize,\n\t\t\t zero);\n\t\t\tverify_batch_locality(tsd, global_ptrs, batch, usize,\n\t\t\t arena, nregs);\n\t\t\trelease_batch(global_ptrs, batch, usize);\n\t\t}\n\t}\n\n\tfree(p);\n}\n\nTEST_BEGIN(test_batch_alloc) {\n\ttest_wrapper(11, 0, false, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_batch_alloc_zero) {\n\ttest_wrapper(11, 0, true, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_batch_alloc_aligned) {\n\ttest_wrapper(7, 16, false, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_batch_alloc_manual_arena) {\n\tunsigned arena_ind;\n\tsize_t len_unsigned = sizeof(unsigned);\n\tassert_d_eq(mallctl(\"arenas.create\", &arena_ind, &len_unsigned, NULL,\n\t 0), 0, \"\");\n\ttest_wrapper(11, 0, false, MALLOCX_ARENA(arena_ind));\n}\nTEST_END\n\nTEST_BEGIN(test_batch_alloc_large) {\n\tsize_t size = SC_LARGE_MINCLASS;\n\tfor (size_t batch = 0; batch < 4; ++batch) {\n\t\tassert(batch < BATCH_MAX);\n\t\tsize_t filled = batch_alloc(global_ptrs, batch, size, 0);\n\t\tassert_zu_eq(filled, batch, \"\");\n\t\trelease_batch(global_ptrs, batch, size);\n\t}\n\tsize = tcache_maxclass + 1;\n\tfor (size_t batch = 0; batch < 4; ++batch) {\n\t\tassert(batch < BATCH_MAX);\n\t\tsize_t filled = batch_alloc(global_ptrs, batch, size, 0);\n\t\tassert_zu_eq(filled, batch, \"\");\n\t\trelease_batch(global_ptrs, batch, size);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_batch_alloc,\n\t test_batch_alloc_zero,\n\t test_batch_alloc_aligned,\n\t test_batch_alloc_manual_arena,\n\t test_batch_alloc_large);\n}\n" }, { "path": "deps/jemalloc/test/unit/batch_alloc.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"tcache_gc_incr_bytes:2147483648\"\n" }, { "path": "deps/jemalloc/test/unit/batch_alloc_prof.c", "content": "#include \"batch_alloc.c\"\n" }, { "path": "deps/jemalloc/test/unit/batch_alloc_prof.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"prof:true,lg_prof_sample:14\"\n" }, { "path": "deps/jemalloc/test/unit/binshard.c", "content": "#include \"test/jemalloc_test.h\"\n\n/* Config -- \"narenas:1,bin_shards:1-160:16|129-512:4|256-256:8\" */\n\n#define NTHREADS 16\n#define REMOTE_NALLOC 256\n\nstatic void *\nthd_producer(void *varg) {\n\tvoid **mem = varg;\n\tunsigned arena, i;\n\tsize_t sz;\n\n\tsz = sizeof(arena);\n\t/* Remote arena. */\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\tfor (i = 0; i < REMOTE_NALLOC / 2; i++) {\n\t\tmem[i] = mallocx(1, MALLOCX_TCACHE_NONE | MALLOCX_ARENA(arena));\n\t}\n\n\t/* Remote bin. */\n\tfor (; i < REMOTE_NALLOC; i++) {\n\t\tmem[i] = mallocx(1, MALLOCX_TCACHE_NONE | MALLOCX_ARENA(0));\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_producer_consumer) {\n\tthd_t thds[NTHREADS];\n\tvoid *mem[NTHREADS][REMOTE_NALLOC];\n\tunsigned i;\n\n\t/* Create producer threads to allocate. */\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_create(&thds[i], thd_producer, mem[i]);\n\t}\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n\t/* Remote deallocation by the current thread. */\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tfor (unsigned j = 0; j < REMOTE_NALLOC; j++) {\n\t\t\texpect_ptr_not_null(mem[i][j],\n\t\t\t \"Unexpected remote allocation failure\");\n\t\t\tdallocx(mem[i][j], 0);\n\t\t}\n\t}\n}\nTEST_END\n\nstatic void *\nthd_start(void *varg) {\n\tvoid *ptr, *ptr2;\n\tedata_t *edata;\n\tunsigned shard1, shard2;\n\n\ttsdn_t *tsdn = tsdn_fetch();\n\t/* Try triggering allocations from sharded bins. */\n\tfor (unsigned i = 0; i < 1024; i++) {\n\t\tptr = mallocx(1, MALLOCX_TCACHE_NONE);\n\t\tptr2 = mallocx(129, MALLOCX_TCACHE_NONE);\n\n\t\tedata = emap_edata_lookup(tsdn, &arena_emap_global, ptr);\n\t\tshard1 = edata_binshard_get(edata);\n\t\tdallocx(ptr, 0);\n\t\texpect_u_lt(shard1, 16, \"Unexpected bin shard used\");\n\n\t\tedata = emap_edata_lookup(tsdn, &arena_emap_global, ptr2);\n\t\tshard2 = edata_binshard_get(edata);\n\t\tdallocx(ptr2, 0);\n\t\texpect_u_lt(shard2, 4, \"Unexpected bin shard used\");\n\n\t\tif (shard1 > 0 || shard2 > 0) {\n\t\t\t/* Triggered sharded bin usage. */\n\t\t\treturn (void *)(uintptr_t)shard1;\n\t\t}\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_bin_shard_mt) {\n\ttest_skip_if(have_percpu_arena &&\n\t PERCPU_ARENA_ENABLED(opt_percpu_arena));\n\n\tthd_t thds[NTHREADS];\n\tunsigned i;\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_create(&thds[i], thd_start, NULL);\n\t}\n\tbool sharded = false;\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tvoid *ret;\n\t\tthd_join(thds[i], &ret);\n\t\tif (ret != NULL) {\n\t\t\tsharded = true;\n\t\t}\n\t}\n\texpect_b_eq(sharded, true, \"Did not find sharded bins\");\n}\nTEST_END\n\nTEST_BEGIN(test_bin_shard) {\n\tunsigned nbins, i;\n\tsize_t mib[4], mib2[4];\n\tsize_t miblen, miblen2, len;\n\n\tlen = sizeof(nbins);\n\texpect_d_eq(mallctl(\"arenas.nbins\", (void *)&nbins, &len, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tmiblen = 4;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.nshards\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmiblen2 = 4;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.size\", mib2, &miblen2), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\n\tfor (i = 0; i < nbins; i++) {\n\t\tuint32_t nshards;\n\t\tsize_t size, sz1, sz2;\n\n\t\tmib[2] = i;\n\t\tsz1 = sizeof(nshards);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&nshards, &sz1,\n\t\t NULL, 0), 0, \"Unexpected mallctlbymib() failure\");\n\n\t\tmib2[2] = i;\n\t\tsz2 = sizeof(size);\n\t\texpect_d_eq(mallctlbymib(mib2, miblen2, (void *)&size, &sz2,\n\t\t NULL, 0), 0, \"Unexpected mallctlbymib() failure\");\n\n\t\tif (size >= 1 && size <= 128) {\n\t\t\texpect_u_eq(nshards, 16, \"Unexpected nshards\");\n\t\t} else if (size == 256) {\n\t\t\texpect_u_eq(nshards, 8, \"Unexpected nshards\");\n\t\t} else if (size > 128 && size <= 512) {\n\t\t\texpect_u_eq(nshards, 4, \"Unexpected nshards\");\n\t\t} else {\n\t\t\texpect_u_eq(nshards, 1, \"Unexpected nshards\");\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_bin_shard,\n\t test_bin_shard_mt,\n\t test_producer_consumer);\n}\n" }, { "path": "deps/jemalloc/test/unit/binshard.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"narenas:1,bin_shards:1-160:16|129-512:4|256-256:8\"\n" }, { "path": "deps/jemalloc/test/unit/bit_util.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/bit_util.h\"\n\n#define TEST_POW2_CEIL(t, suf, pri) do {\t\t\t\t\\\n\tunsigned i, pow2;\t\t\t\t\t\t\\\n\tt x;\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\texpect_##suf##_eq(pow2_ceil_##suf(0), 0, \"Unexpected result\");\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tfor (i = 0; i < sizeof(t) * 8; i++) {\t\t\t\t\\\n\t\texpect_##suf##_eq(pow2_ceil_##suf(((t)1) << i), ((t)1)\t\\\n\t\t << i, \"Unexpected result\");\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tfor (i = 2; i < sizeof(t) * 8; i++) {\t\t\t\t\\\n\t\texpect_##suf##_eq(pow2_ceil_##suf((((t)1) << i) - 1),\t\\\n\t\t ((t)1) << i, \"Unexpected result\");\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tfor (i = 0; i < sizeof(t) * 8 - 1; i++) {\t\t\t\\\n\t\texpect_##suf##_eq(pow2_ceil_##suf((((t)1) << i) + 1),\t\\\n\t\t ((t)1) << (i+1), \"Unexpected result\");\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n\t\t\t\t\t\t\t\t\t\\\n\tfor (pow2 = 1; pow2 < 25; pow2++) {\t\t\t\t\\\n\t\tfor (x = (((t)1) << (pow2-1)) + 1; x <= ((t)1) << pow2;\t\\\n\t\t x++) {\t\t\t\t\t\t\\\n\t\t\texpect_##suf##_eq(pow2_ceil_##suf(x),\t\t\\\n\t\t\t ((t)1) << pow2,\t\t\t\t\\\n\t\t\t \"Unexpected result, x=%\"pri, x);\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\nTEST_BEGIN(test_pow2_ceil_u64) {\n\tTEST_POW2_CEIL(uint64_t, u64, FMTu64);\n}\nTEST_END\n\nTEST_BEGIN(test_pow2_ceil_u32) {\n\tTEST_POW2_CEIL(uint32_t, u32, FMTu32);\n}\nTEST_END\n\nTEST_BEGIN(test_pow2_ceil_zu) {\n\tTEST_POW2_CEIL(size_t, zu, \"zu\");\n}\nTEST_END\n\nvoid\nexpect_lg_ceil_range(size_t input, unsigned answer) {\n\tif (input == 1) {\n\t\texpect_u_eq(0, answer, \"Got %u as lg_ceil of 1\", answer);\n\t\treturn;\n\t}\n\texpect_zu_le(input, (ZU(1) << answer),\n\t \"Got %u as lg_ceil of %zu\", answer, input);\n\texpect_zu_gt(input, (ZU(1) << (answer - 1)),\n\t \"Got %u as lg_ceil of %zu\", answer, input);\n}\n\nvoid\nexpect_lg_floor_range(size_t input, unsigned answer) {\n\tif (input == 1) {\n\t\texpect_u_eq(0, answer, \"Got %u as lg_floor of 1\", answer);\n\t\treturn;\n\t}\n\texpect_zu_ge(input, (ZU(1) << answer),\n\t \"Got %u as lg_floor of %zu\", answer, input);\n\texpect_zu_lt(input, (ZU(1) << (answer + 1)),\n\t \"Got %u as lg_floor of %zu\", answer, input);\n}\n\nTEST_BEGIN(test_lg_ceil_floor) {\n\tfor (size_t i = 1; i < 10 * 1000 * 1000; i++) {\n\t\texpect_lg_ceil_range(i, lg_ceil(i));\n\t\texpect_lg_ceil_range(i, LG_CEIL(i));\n\t\texpect_lg_floor_range(i, lg_floor(i));\n\t\texpect_lg_floor_range(i, LG_FLOOR(i));\n\t}\n\tfor (int i = 10; i < 8 * (1 << LG_SIZEOF_PTR) - 5; i++) {\n\t\tfor (size_t j = 0; j < (1 << 4); j++) {\n\t\t\tsize_t num1 = ((size_t)1 << i)\n\t\t\t - j * ((size_t)1 << (i - 4));\n\t\t\tsize_t num2 = ((size_t)1 << i)\n\t\t\t + j * ((size_t)1 << (i - 4));\n\t\t\texpect_zu_ne(num1, 0, \"Invalid lg argument\");\n\t\t\texpect_zu_ne(num2, 0, \"Invalid lg argument\");\n\t\t\texpect_lg_ceil_range(num1, lg_ceil(num1));\n\t\t\texpect_lg_ceil_range(num1, LG_CEIL(num1));\n\t\t\texpect_lg_ceil_range(num2, lg_ceil(num2));\n\t\t\texpect_lg_ceil_range(num2, LG_CEIL(num2));\n\n\t\t\texpect_lg_floor_range(num1, lg_floor(num1));\n\t\t\texpect_lg_floor_range(num1, LG_FLOOR(num1));\n\t\t\texpect_lg_floor_range(num2, lg_floor(num2));\n\t\t\texpect_lg_floor_range(num2, LG_FLOOR(num2));\n\t\t}\n\t}\n}\nTEST_END\n\n#define TEST_FFS(t, suf, test_suf, pri) do {\t\t\t\t\\\n\tfor (unsigned i = 0; i < sizeof(t) * 8; i++) {\t\t\t\\\n\t\tfor (unsigned j = 0; j <= i; j++) {\t\t\t\\\n\t\t\tfor (unsigned k = 0; k <= j; k++) {\t\t\\\n\t\t\t\tt x = (t)1 << i;\t\t\t\\\n\t\t\t\tx |= (t)1 << j;\t\t\t\t\\\n\t\t\t\tx |= (t)1 << k;\t\t\t\t\\\n\t\t\t\texpect_##test_suf##_eq(ffs_##suf(x), k,\t\\\n\t\t\t\t \"Unexpected result, x=%\"pri, x);\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while(0)\n\nTEST_BEGIN(test_ffs_u) {\n\tTEST_FFS(unsigned, u, u,\"u\");\n}\nTEST_END\n\nTEST_BEGIN(test_ffs_lu) {\n\tTEST_FFS(unsigned long, lu, lu, \"lu\");\n}\nTEST_END\n\nTEST_BEGIN(test_ffs_llu) {\n\tTEST_FFS(unsigned long long, llu, qd, \"llu\");\n}\nTEST_END\n\nTEST_BEGIN(test_ffs_u32) {\n\tTEST_FFS(uint32_t, u32, u32, FMTu32);\n}\nTEST_END\n\nTEST_BEGIN(test_ffs_u64) {\n\tTEST_FFS(uint64_t, u64, u64, FMTu64);\n}\nTEST_END\n\nTEST_BEGIN(test_ffs_zu) {\n\tTEST_FFS(size_t, zu, zu, \"zu\");\n}\nTEST_END\n\n#define TEST_FLS(t, suf, test_suf, pri) do {\t\t\t\t\\\n\tfor (unsigned i = 0; i < sizeof(t) * 8; i++) {\t\t\t\\\n\t\tfor (unsigned j = 0; j <= i; j++) {\t\t\t\\\n\t\t\tfor (unsigned k = 0; k <= j; k++) {\t\t\\\n\t\t\t\tt x = (t)1 << i;\t\t\t\\\n\t\t\t\tx |= (t)1 << j;\t\t\t\t\\\n\t\t\t\tx |= (t)1 << k;\t\t\t\t\\\n\t\t\t\texpect_##test_suf##_eq(fls_##suf(x), i,\t\\\n\t\t\t\t \"Unexpected result, x=%\"pri, x);\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while(0)\n\nTEST_BEGIN(test_fls_u) {\n\tTEST_FLS(unsigned, u, u,\"u\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_lu) {\n\tTEST_FLS(unsigned long, lu, lu, \"lu\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_llu) {\n\tTEST_FLS(unsigned long long, llu, qd, \"llu\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_u32) {\n\tTEST_FLS(uint32_t, u32, u32, FMTu32);\n}\nTEST_END\n\nTEST_BEGIN(test_fls_u64) {\n\tTEST_FLS(uint64_t, u64, u64, FMTu64);\n}\nTEST_END\n\nTEST_BEGIN(test_fls_zu) {\n\tTEST_FLS(size_t, zu, zu, \"zu\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_u_slow) {\n\tTEST_FLS(unsigned, u_slow, u,\"u\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_lu_slow) {\n\tTEST_FLS(unsigned long, lu_slow, lu, \"lu\");\n}\nTEST_END\n\nTEST_BEGIN(test_fls_llu_slow) {\n\tTEST_FLS(unsigned long long, llu_slow, qd, \"llu\");\n}\nTEST_END\n\nstatic unsigned\npopcount_byte(unsigned byte) {\n\tint count = 0;\n\tfor (int i = 0; i < 8; i++) {\n\t\tif ((byte & (1 << i)) != 0) {\n\t\t\tcount++;\n\t\t}\n\t}\n\treturn count;\n}\n\nstatic uint64_t\nexpand_byte_to_mask(unsigned byte) {\n\tuint64_t result = 0;\n\tfor (int i = 0; i < 8; i++) {\n\t\tif ((byte & (1 << i)) != 0) {\n\t\t\tresult |= ((uint64_t)0xFF << (i * 8));\n\t\t}\n\t}\n\treturn result;\n}\n\n#define TEST_POPCOUNT(t, suf, pri_hex) do {\t\t\t\t\\\n\tt bmul = (t)0x0101010101010101ULL;\t\t\t\t\\\n\tfor (unsigned i = 0; i < (1 << sizeof(t)); i++) {\t\t\\\n\t\tfor (unsigned j = 0; j < 256; j++) {\t\t\t\\\n\t\t\t/*\t\t\t\t\t\t\\\n\t\t\t * Replicate the byte j into various\t\t\\\n\t\t\t * bytes of the integer (as indicated by the\t\\\n\t\t\t * mask in i), and ensure that the popcount of\t\\\n\t\t\t * the result is popcount(i) * popcount(j)\t\\\n\t\t\t */\t\t\t\t\t\t\\\n\t\t\tt mask = (t)expand_byte_to_mask(i);\t\t\\\n\t\t\tt x = (bmul * j) & mask;\t\t\t\\\n\t\t\texpect_u_eq(\t\t\t\t\t\\\n\t\t\t popcount_byte(i) * popcount_byte(j),\t\\\n\t\t\t popcount_##suf(x),\t\t\t\t\\\n\t\t\t \"Unexpected result, x=0x%\"pri_hex, x);\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\nTEST_BEGIN(test_popcount_u) {\n\tTEST_POPCOUNT(unsigned, u, \"x\");\n}\nTEST_END\n\nTEST_BEGIN(test_popcount_u_slow) {\n\tTEST_POPCOUNT(unsigned, u_slow, \"x\");\n}\nTEST_END\n\nTEST_BEGIN(test_popcount_lu) {\n\tTEST_POPCOUNT(unsigned long, lu, \"lx\");\n}\nTEST_END\n\nTEST_BEGIN(test_popcount_lu_slow) {\n\tTEST_POPCOUNT(unsigned long, lu_slow, \"lx\");\n}\nTEST_END\n\nTEST_BEGIN(test_popcount_llu) {\n\tTEST_POPCOUNT(unsigned long long, llu, \"llx\");\n}\nTEST_END\n\nTEST_BEGIN(test_popcount_llu_slow) {\n\tTEST_POPCOUNT(unsigned long long, llu_slow, \"llx\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_pow2_ceil_u64,\n\t test_pow2_ceil_u32,\n\t test_pow2_ceil_zu,\n\t test_lg_ceil_floor,\n\t test_ffs_u,\n\t test_ffs_lu,\n\t test_ffs_llu,\n\t test_ffs_u32,\n\t test_ffs_u64,\n\t test_ffs_zu,\n\t test_fls_u,\n\t test_fls_lu,\n\t test_fls_llu,\n\t test_fls_u32,\n\t test_fls_u64,\n\t test_fls_zu,\n\t test_fls_u_slow,\n\t test_fls_lu_slow,\n\t test_fls_llu_slow,\n\t test_popcount_u,\n\t test_popcount_u_slow,\n\t test_popcount_lu,\n\t test_popcount_lu_slow,\n\t test_popcount_llu,\n\t test_popcount_llu_slow);\n}\n" }, { "path": "deps/jemalloc/test/unit/bitmap.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"test/nbits.h\"\n\nstatic void\ntest_bitmap_initializer_body(const bitmap_info_t *binfo, size_t nbits) {\n\tbitmap_info_t binfo_dyn;\n\tbitmap_info_init(&binfo_dyn, nbits);\n\n\texpect_zu_eq(bitmap_size(binfo), bitmap_size(&binfo_dyn),\n\t \"Unexpected difference between static and dynamic initialization, \"\n\t \"nbits=%zu\", nbits);\n\texpect_zu_eq(binfo->nbits, binfo_dyn.nbits,\n\t \"Unexpected difference between static and dynamic initialization, \"\n\t \"nbits=%zu\", nbits);\n#ifdef BITMAP_USE_TREE\n\texpect_u_eq(binfo->nlevels, binfo_dyn.nlevels,\n\t \"Unexpected difference between static and dynamic initialization, \"\n\t \"nbits=%zu\", nbits);\n\t{\n\t\tunsigned i;\n\n\t\tfor (i = 0; i < binfo->nlevels; i++) {\n\t\t\texpect_zu_eq(binfo->levels[i].group_offset,\n\t\t\t binfo_dyn.levels[i].group_offset,\n\t\t\t \"Unexpected difference between static and dynamic \"\n\t\t\t \"initialization, nbits=%zu, level=%u\", nbits, i);\n\t\t}\n\t}\n#else\n\texpect_zu_eq(binfo->ngroups, binfo_dyn.ngroups,\n\t \"Unexpected difference between static and dynamic initialization\");\n#endif\n}\n\nTEST_BEGIN(test_bitmap_initializer) {\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tif (nbits <= BITMAP_MAXBITS) {\t\t\t\t\\\n\t\t\tbitmap_info_t binfo =\t\t\t\t\\\n\t\t\t BITMAP_INFO_INITIALIZER(nbits);\t\t\\\n\t\t\ttest_bitmap_initializer_body(&binfo, nbits);\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic size_t\ntest_bitmap_size_body(const bitmap_info_t *binfo, size_t nbits,\n size_t prev_size) {\n\tsize_t size = bitmap_size(binfo);\n\texpect_zu_ge(size, (nbits >> 3),\n\t \"Bitmap size is smaller than expected\");\n\texpect_zu_ge(size, prev_size, \"Bitmap size is smaller than expected\");\n\treturn size;\n}\n\nTEST_BEGIN(test_bitmap_size) {\n\tsize_t nbits, prev_size;\n\n\tprev_size = 0;\n\tfor (nbits = 1; nbits <= BITMAP_MAXBITS; nbits++) {\n\t\tbitmap_info_t binfo;\n\t\tbitmap_info_init(&binfo, nbits);\n\t\tprev_size = test_bitmap_size_body(&binfo, nbits, prev_size);\n\t}\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tbitmap_info_t binfo = BITMAP_INFO_INITIALIZER(nbits);\t\\\n\t\tprev_size = test_bitmap_size_body(&binfo, nbits,\t\\\n\t\t prev_size);\t\t\t\t\t\t\\\n\t}\n\tprev_size = 0;\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ntest_bitmap_init_body(const bitmap_info_t *binfo, size_t nbits) {\n\tsize_t i;\n\tbitmap_t *bitmap = (bitmap_t *)malloc(bitmap_size(binfo));\n\texpect_ptr_not_null(bitmap, \"Unexpected malloc() failure\");\n\n\tbitmap_init(bitmap, binfo, false);\n\tfor (i = 0; i < nbits; i++) {\n\t\texpect_false(bitmap_get(bitmap, binfo, i),\n\t\t \"Bit should be unset\");\n\t}\n\n\tbitmap_init(bitmap, binfo, true);\n\tfor (i = 0; i < nbits; i++) {\n\t\texpect_true(bitmap_get(bitmap, binfo, i), \"Bit should be set\");\n\t}\n\n\tfree(bitmap);\n}\n\nTEST_BEGIN(test_bitmap_init) {\n\tsize_t nbits;\n\n\tfor (nbits = 1; nbits <= BITMAP_MAXBITS; nbits++) {\n\t\tbitmap_info_t binfo;\n\t\tbitmap_info_init(&binfo, nbits);\n\t\ttest_bitmap_init_body(&binfo, nbits);\n\t}\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tbitmap_info_t binfo = BITMAP_INFO_INITIALIZER(nbits);\t\\\n\t\ttest_bitmap_init_body(&binfo, nbits);\t\t\t\\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ntest_bitmap_set_body(const bitmap_info_t *binfo, size_t nbits) {\n\tsize_t i;\n\tbitmap_t *bitmap = (bitmap_t *)malloc(bitmap_size(binfo));\n\texpect_ptr_not_null(bitmap, \"Unexpected malloc() failure\");\n\tbitmap_init(bitmap, binfo, false);\n\n\tfor (i = 0; i < nbits; i++) {\n\t\tbitmap_set(bitmap, binfo, i);\n\t}\n\texpect_true(bitmap_full(bitmap, binfo), \"All bits should be set\");\n\tfree(bitmap);\n}\n\nTEST_BEGIN(test_bitmap_set) {\n\tsize_t nbits;\n\n\tfor (nbits = 1; nbits <= BITMAP_MAXBITS; nbits++) {\n\t\tbitmap_info_t binfo;\n\t\tbitmap_info_init(&binfo, nbits);\n\t\ttest_bitmap_set_body(&binfo, nbits);\n\t}\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tbitmap_info_t binfo = BITMAP_INFO_INITIALIZER(nbits);\t\\\n\t\ttest_bitmap_set_body(&binfo, nbits);\t\t\t\\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ntest_bitmap_unset_body(const bitmap_info_t *binfo, size_t nbits) {\n\tsize_t i;\n\tbitmap_t *bitmap = (bitmap_t *)malloc(bitmap_size(binfo));\n\texpect_ptr_not_null(bitmap, \"Unexpected malloc() failure\");\n\tbitmap_init(bitmap, binfo, false);\n\n\tfor (i = 0; i < nbits; i++) {\n\t\tbitmap_set(bitmap, binfo, i);\n\t}\n\texpect_true(bitmap_full(bitmap, binfo), \"All bits should be set\");\n\tfor (i = 0; i < nbits; i++) {\n\t\tbitmap_unset(bitmap, binfo, i);\n\t}\n\tfor (i = 0; i < nbits; i++) {\n\t\tbitmap_set(bitmap, binfo, i);\n\t}\n\texpect_true(bitmap_full(bitmap, binfo), \"All bits should be set\");\n\tfree(bitmap);\n}\n\nTEST_BEGIN(test_bitmap_unset) {\n\tsize_t nbits;\n\n\tfor (nbits = 1; nbits <= BITMAP_MAXBITS; nbits++) {\n\t\tbitmap_info_t binfo;\n\t\tbitmap_info_init(&binfo, nbits);\n\t\ttest_bitmap_unset_body(&binfo, nbits);\n\t}\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tbitmap_info_t binfo = BITMAP_INFO_INITIALIZER(nbits);\t\\\n\t\ttest_bitmap_unset_body(&binfo, nbits);\t\t\t\\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ntest_bitmap_xfu_body(const bitmap_info_t *binfo, size_t nbits) {\n\tbitmap_t *bitmap = (bitmap_t *)malloc(bitmap_size(binfo));\n\texpect_ptr_not_null(bitmap, \"Unexpected malloc() failure\");\n\tbitmap_init(bitmap, binfo, false);\n\n\t/* Iteratively set bits starting at the beginning. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, 0), i,\n\t\t \"First unset bit should be just after previous first unset \"\n\t\t \"bit\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, (i > 0) ? i-1 : i), i,\n\t\t \"First unset bit should be just after previous first unset \"\n\t\t \"bit\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i), i,\n\t\t \"First unset bit should be just after previous first unset \"\n\t\t \"bit\");\n\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i,\n\t\t \"First unset bit should be just after previous first unset \"\n\t\t \"bit\");\n\t}\n\texpect_true(bitmap_full(bitmap, binfo), \"All bits should be set\");\n\n\t/*\n\t * Iteratively unset bits starting at the end, and verify that\n\t * bitmap_sfu() reaches the unset bits.\n\t */\n\tfor (size_t i = nbits - 1; i < nbits; i--) { /* (nbits..0] */\n\t\tbitmap_unset(bitmap, binfo, i);\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, 0), i,\n\t\t \"First unset bit should the bit previously unset\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, (i > 0) ? i-1 : i), i,\n\t\t \"First unset bit should the bit previously unset\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i), i,\n\t\t \"First unset bit should the bit previously unset\");\n\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i,\n\t\t \"First unset bit should the bit previously unset\");\n\t\tbitmap_unset(bitmap, binfo, i);\n\t}\n\texpect_false(bitmap_get(bitmap, binfo, 0), \"Bit should be unset\");\n\n\t/*\n\t * Iteratively set bits starting at the beginning, and verify that\n\t * bitmap_sfu() looks past them.\n\t */\n\tfor (size_t i = 1; i < nbits; i++) {\n\t\tbitmap_set(bitmap, binfo, i - 1);\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, 0), i,\n\t\t \"First unset bit should be just after the bit previously \"\n\t\t \"set\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, (i > 0) ? i-1 : i), i,\n\t\t \"First unset bit should be just after the bit previously \"\n\t\t \"set\");\n\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i), i,\n\t\t \"First unset bit should be just after the bit previously \"\n\t\t \"set\");\n\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i,\n\t\t \"First unset bit should be just after the bit previously \"\n\t\t \"set\");\n\t\tbitmap_unset(bitmap, binfo, i);\n\t}\n\texpect_zu_eq(bitmap_ffu(bitmap, binfo, 0), nbits - 1,\n\t \"First unset bit should be the last bit\");\n\texpect_zu_eq(bitmap_ffu(bitmap, binfo, (nbits > 1) ? nbits-2 : nbits-1),\n\t nbits - 1, \"First unset bit should be the last bit\");\n\texpect_zu_eq(bitmap_ffu(bitmap, binfo, nbits - 1), nbits - 1,\n\t \"First unset bit should be the last bit\");\n\texpect_zu_eq(bitmap_sfu(bitmap, binfo), nbits - 1,\n\t \"First unset bit should be the last bit\");\n\texpect_true(bitmap_full(bitmap, binfo), \"All bits should be set\");\n\n\t/*\n\t * Bubble a \"usu\" pattern through the bitmap and verify that\n\t * bitmap_ffu() finds the correct bit for all five min_bit cases.\n\t */\n\tif (nbits >= 3) {\n\t\tfor (size_t i = 0; i < nbits-2; i++) {\n\t\t\tbitmap_unset(bitmap, binfo, i);\n\t\t\tbitmap_unset(bitmap, binfo, i+2);\n\t\t\tif (i > 0) {\n\t\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i-1), i,\n\t\t\t\t \"Unexpected first unset bit\");\n\t\t\t}\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i), i,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i+1), i+2,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i+2), i+2,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\tif (i + 3 < nbits) {\n\t\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i+3),\n\t\t\t\t nbits, \"Unexpected first unset bit\");\n\t\t\t}\n\t\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i+2,\n\t\t\t \"Unexpected first unset bit\");\n\t\t}\n\t}\n\n\t/*\n\t * Unset the last bit, bubble another unset bit through the bitmap, and\n\t * verify that bitmap_ffu() finds the correct bit for all four min_bit\n\t * cases.\n\t */\n\tif (nbits >= 3) {\n\t\tbitmap_unset(bitmap, binfo, nbits-1);\n\t\tfor (size_t i = 0; i < nbits-1; i++) {\n\t\t\tbitmap_unset(bitmap, binfo, i);\n\t\t\tif (i > 0) {\n\t\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i-1), i,\n\t\t\t\t \"Unexpected first unset bit\");\n\t\t\t}\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i), i,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, i+1), nbits-1,\n\t\t\t \"Unexpected first unset bit\");\n\t\t\texpect_zu_eq(bitmap_ffu(bitmap, binfo, nbits-1),\n\t\t\t nbits-1, \"Unexpected first unset bit\");\n\n\t\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), i,\n\t\t\t \"Unexpected first unset bit\");\n\t\t}\n\t\texpect_zu_eq(bitmap_sfu(bitmap, binfo), nbits-1,\n\t\t \"Unexpected first unset bit\");\n\t}\n\n\tfree(bitmap);\n}\n\nTEST_BEGIN(test_bitmap_xfu) {\n\tsize_t nbits, nbits_max;\n\n\t/* The test is O(n^2); large page sizes may slow down too much. */\n\tnbits_max = BITMAP_MAXBITS > 512 ? 512 : BITMAP_MAXBITS;\n\tfor (nbits = 1; nbits <= nbits_max; nbits++) {\n\t\tbitmap_info_t binfo;\n\t\tbitmap_info_init(&binfo, nbits);\n\t\ttest_bitmap_xfu_body(&binfo, nbits);\n\t}\n#define NB(nbits) {\t\t\t\t\t\t\t\\\n\t\tbitmap_info_t binfo = BITMAP_INFO_INITIALIZER(nbits);\t\\\n\t\ttest_bitmap_xfu_body(&binfo, nbits);\t\t\t\\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_bitmap_initializer,\n\t test_bitmap_size,\n\t test_bitmap_init,\n\t test_bitmap_set,\n\t test_bitmap_unset,\n\t test_bitmap_xfu);\n}\n" }, { "path": "deps/jemalloc/test/unit/buf_writer.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/buf_writer.h\"\n\n#define TEST_BUF_SIZE 16\n#define UNIT_MAX (TEST_BUF_SIZE * 3)\n\nstatic size_t test_write_len;\nstatic char test_buf[TEST_BUF_SIZE];\nstatic uint64_t arg;\nstatic uint64_t arg_store;\n\nstatic void\ntest_write_cb(void *cbopaque, const char *s) {\n\tsize_t prev_test_write_len = test_write_len;\n\ttest_write_len += strlen(s); /* only increase the length */\n\targ_store = *(uint64_t *)cbopaque; /* only pass along the argument */\n\tassert_zu_le(prev_test_write_len, test_write_len,\n\t \"Test write overflowed\");\n}\n\nstatic void\ntest_buf_writer_body(tsdn_t *tsdn, buf_writer_t *buf_writer) {\n\tchar s[UNIT_MAX + 1];\n\tsize_t n_unit, remain, i;\n\tssize_t unit;\n\n\tassert(buf_writer->buf != NULL);\n\tmemset(s, 'a', UNIT_MAX);\n\targ = 4; /* Starting value of random argument. */\n\targ_store = arg;\n\tfor (unit = UNIT_MAX; unit >= 0; --unit) {\n\t\t/* unit keeps decreasing, so strlen(s) is always unit. */\n\t\ts[unit] = '\\0';\n\t\tfor (n_unit = 1; n_unit <= 3; ++n_unit) {\n\t\t\ttest_write_len = 0;\n\t\t\tremain = 0;\n\t\t\tfor (i = 1; i <= n_unit; ++i) {\n\t\t\t\targ = prng_lg_range_u64(&arg, 64);\n\t\t\t\tbuf_writer_cb(buf_writer, s);\n\t\t\t\tremain += unit;\n\t\t\t\tif (remain > buf_writer->buf_size) {\n\t\t\t\t\t/* Flushes should have happened. */\n\t\t\t\t\tassert_u64_eq(arg_store, arg, \"Call \"\n\t\t\t\t\t \"back argument didn't get through\");\n\t\t\t\t\tremain %= buf_writer->buf_size;\n\t\t\t\t\tif (remain == 0) {\n\t\t\t\t\t\t/* Last flush should be lazy. */\n\t\t\t\t\t\tremain += buf_writer->buf_size;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tassert_zu_eq(test_write_len + remain, i * unit,\n\t\t\t\t \"Incorrect length after writing %zu strings\"\n\t\t\t\t \" of length %zu\", i, unit);\n\t\t\t}\n\t\t\tbuf_writer_flush(buf_writer);\n\t\t\texpect_zu_eq(test_write_len, n_unit * unit,\n\t\t\t \"Incorrect length after flushing at the end of\"\n\t\t\t \" writing %zu strings of length %zu\", n_unit, unit);\n\t\t}\n\t}\n\tbuf_writer_terminate(tsdn, buf_writer);\n}\n\nTEST_BEGIN(test_buf_write_static) {\n\tbuf_writer_t buf_writer;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tassert_false(buf_writer_init(tsdn, &buf_writer, test_write_cb, &arg,\n\t test_buf, TEST_BUF_SIZE),\n\t \"buf_writer_init() should not encounter error on static buffer\");\n\ttest_buf_writer_body(tsdn, &buf_writer);\n}\nTEST_END\n\nTEST_BEGIN(test_buf_write_dynamic) {\n\tbuf_writer_t buf_writer;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tassert_false(buf_writer_init(tsdn, &buf_writer, test_write_cb, &arg,\n\t NULL, TEST_BUF_SIZE), \"buf_writer_init() should not OOM\");\n\ttest_buf_writer_body(tsdn, &buf_writer);\n}\nTEST_END\n\nTEST_BEGIN(test_buf_write_oom) {\n\tbuf_writer_t buf_writer;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tassert_true(buf_writer_init(tsdn, &buf_writer, test_write_cb, &arg,\n\t NULL, SC_LARGE_MAXCLASS + 1), \"buf_writer_init() should OOM\");\n\tassert(buf_writer.buf == NULL);\n\n\tchar s[UNIT_MAX + 1];\n\tsize_t n_unit, i;\n\tssize_t unit;\n\n\tmemset(s, 'a', UNIT_MAX);\n\targ = 4; /* Starting value of random argument. */\n\targ_store = arg;\n\tfor (unit = UNIT_MAX; unit >= 0; unit -= UNIT_MAX / 4) {\n\t\t/* unit keeps decreasing, so strlen(s) is always unit. */\n\t\ts[unit] = '\\0';\n\t\tfor (n_unit = 1; n_unit <= 3; ++n_unit) {\n\t\t\ttest_write_len = 0;\n\t\t\tfor (i = 1; i <= n_unit; ++i) {\n\t\t\t\targ = prng_lg_range_u64(&arg, 64);\n\t\t\t\tbuf_writer_cb(&buf_writer, s);\n\t\t\t\tassert_u64_eq(arg_store, arg,\n\t\t\t\t \"Call back argument didn't get through\");\n\t\t\t\tassert_zu_eq(test_write_len, i * unit,\n\t\t\t\t \"Incorrect length after writing %zu strings\"\n\t\t\t\t \" of length %zu\", i, unit);\n\t\t\t}\n\t\t\tbuf_writer_flush(&buf_writer);\n\t\t\texpect_zu_eq(test_write_len, n_unit * unit,\n\t\t\t \"Incorrect length after flushing at the end of\"\n\t\t\t \" writing %zu strings of length %zu\", n_unit, unit);\n\t\t}\n\t}\n\tbuf_writer_terminate(tsdn, &buf_writer);\n}\nTEST_END\n\nstatic int test_read_count;\nstatic size_t test_read_len;\nstatic uint64_t arg_sum;\n\nssize_t\ntest_read_cb(void *cbopaque, void *buf, size_t limit) {\n\tstatic uint64_t rand = 4;\n\n\targ_sum += *(uint64_t *)cbopaque;\n\tassert_zu_gt(limit, 0, \"Limit for read_cb must be positive\");\n\t--test_read_count;\n\tif (test_read_count == 0) {\n\t\treturn -1;\n\t} else {\n\t\tsize_t read_len = limit;\n\t\tif (limit > 1) {\n\t\t\trand = prng_range_u64(&rand, (uint64_t)limit);\n\t\t\tread_len -= (size_t)rand;\n\t\t}\n\t\tassert(read_len > 0);\n\t\tmemset(buf, 'a', read_len);\n\t\tsize_t prev_test_read_len = test_read_len;\n\t\ttest_read_len += read_len;\n\t\tassert_zu_le(prev_test_read_len, test_read_len,\n\t\t \"Test read overflowed\");\n\t\treturn read_len;\n\t}\n}\n\nstatic void\ntest_buf_writer_pipe_body(tsdn_t *tsdn, buf_writer_t *buf_writer) {\n\targ = 4; /* Starting value of random argument. */\n\tfor (int count = 5; count > 0; --count) {\n\t\targ = prng_lg_range_u64(&arg, 64);\n\t\targ_sum = 0;\n\t\ttest_read_count = count;\n\t\ttest_read_len = 0;\n\t\ttest_write_len = 0;\n\t\tbuf_writer_pipe(buf_writer, test_read_cb, &arg);\n\t\tassert(test_read_count == 0);\n\t\texpect_u64_eq(arg_sum, arg * count, \"\");\n\t\texpect_zu_eq(test_write_len, test_read_len,\n\t\t \"Write length should be equal to read length\");\n\t}\n\tbuf_writer_terminate(tsdn, buf_writer);\n}\n\nTEST_BEGIN(test_buf_write_pipe) {\n\tbuf_writer_t buf_writer;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tassert_false(buf_writer_init(tsdn, &buf_writer, test_write_cb, &arg,\n\t test_buf, TEST_BUF_SIZE),\n\t \"buf_writer_init() should not encounter error on static buffer\");\n\ttest_buf_writer_pipe_body(tsdn, &buf_writer);\n}\nTEST_END\n\nTEST_BEGIN(test_buf_write_pipe_oom) {\n\tbuf_writer_t buf_writer;\n\ttsdn_t *tsdn = tsdn_fetch();\n\tassert_true(buf_writer_init(tsdn, &buf_writer, test_write_cb, &arg,\n\t NULL, SC_LARGE_MAXCLASS + 1), \"buf_writer_init() should OOM\");\n\ttest_buf_writer_pipe_body(tsdn, &buf_writer);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_buf_write_static,\n\t test_buf_write_dynamic,\n\t test_buf_write_oom,\n\t test_buf_write_pipe,\n\t test_buf_write_pipe_oom);\n}\n" }, { "path": "deps/jemalloc/test/unit/cache_bin.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic void\ndo_fill_test(cache_bin_t *bin, cache_bin_info_t *info, void **ptrs,\n cache_bin_sz_t ncached_max, cache_bin_sz_t nfill_attempt,\n cache_bin_sz_t nfill_succeed) {\n\tbool success;\n\tvoid *ptr;\n\tassert_true(cache_bin_ncached_get_local(bin, info) == 0, \"\");\n\tCACHE_BIN_PTR_ARRAY_DECLARE(arr, nfill_attempt);\n\tcache_bin_init_ptr_array_for_fill(bin, info, &arr, nfill_attempt);\n\tfor (cache_bin_sz_t i = 0; i < nfill_succeed; i++) {\n\t\tarr.ptr[i] = &ptrs[i];\n\t}\n\tcache_bin_finish_fill(bin, info, &arr, nfill_succeed);\n\texpect_true(cache_bin_ncached_get_local(bin, info) == nfill_succeed,\n\t \"\");\n\tcache_bin_low_water_set(bin);\n\n\tfor (cache_bin_sz_t i = 0; i < nfill_succeed; i++) {\n\t\tptr = cache_bin_alloc(bin, &success);\n\t\texpect_true(success, \"\");\n\t\texpect_ptr_eq(ptr, (void *)&ptrs[i],\n\t\t \"Should pop in order filled\");\n\t\texpect_true(cache_bin_low_water_get(bin, info)\n\t\t == nfill_succeed - i - 1, \"\");\n\t}\n\texpect_true(cache_bin_ncached_get_local(bin, info) == 0, \"\");\n\texpect_true(cache_bin_low_water_get(bin, info) == 0, \"\");\n}\n\nstatic void\ndo_flush_test(cache_bin_t *bin, cache_bin_info_t *info, void **ptrs,\n cache_bin_sz_t nfill, cache_bin_sz_t nflush) {\n\tbool success;\n\tassert_true(cache_bin_ncached_get_local(bin, info) == 0, \"\");\n\n\tfor (cache_bin_sz_t i = 0; i < nfill; i++) {\n\t\tsuccess = cache_bin_dalloc_easy(bin, &ptrs[i]);\n\t\texpect_true(success, \"\");\n\t}\n\n\tCACHE_BIN_PTR_ARRAY_DECLARE(arr, nflush);\n\tcache_bin_init_ptr_array_for_flush(bin, info, &arr, nflush);\n\tfor (cache_bin_sz_t i = 0; i < nflush; i++) {\n\t\texpect_ptr_eq(arr.ptr[i], &ptrs[nflush - i - 1], \"\");\n\t}\n\tcache_bin_finish_flush(bin, info, &arr, nflush);\n\n\texpect_true(cache_bin_ncached_get_local(bin, info) == nfill - nflush,\n\t \"\");\n\twhile (cache_bin_ncached_get_local(bin, info) > 0) {\n\t\tcache_bin_alloc(bin, &success);\n\t}\n}\n\nstatic void\ndo_batch_alloc_test(cache_bin_t *bin, cache_bin_info_t *info, void **ptrs,\n cache_bin_sz_t nfill, size_t batch) {\n\tassert_true(cache_bin_ncached_get_local(bin, info) == 0, \"\");\n\tCACHE_BIN_PTR_ARRAY_DECLARE(arr, nfill);\n\tcache_bin_init_ptr_array_for_fill(bin, info, &arr, nfill);\n\tfor (cache_bin_sz_t i = 0; i < nfill; i++) {\n\t\tarr.ptr[i] = &ptrs[i];\n\t}\n\tcache_bin_finish_fill(bin, info, &arr, nfill);\n\tassert_true(cache_bin_ncached_get_local(bin, info) == nfill, \"\");\n\tcache_bin_low_water_set(bin);\n\n\tvoid **out = malloc((batch + 1) * sizeof(void *));\n\tsize_t n = cache_bin_alloc_batch(bin, batch, out);\n\tassert_true(n == ((size_t)nfill < batch ? (size_t)nfill : batch), \"\");\n\tfor (cache_bin_sz_t i = 0; i < (cache_bin_sz_t)n; i++) {\n\t\texpect_ptr_eq(out[i], &ptrs[i], \"\");\n\t}\n\texpect_true(cache_bin_low_water_get(bin, info) == nfill -\n\t (cache_bin_sz_t)n, \"\");\n\twhile (cache_bin_ncached_get_local(bin, info) > 0) {\n\t\tbool success;\n\t\tcache_bin_alloc(bin, &success);\n\t}\n\tfree(out);\n}\n\nstatic void\ntest_bin_init(cache_bin_t *bin, cache_bin_info_t *info) {\n\tsize_t size;\n\tsize_t alignment;\n\tcache_bin_info_compute_alloc(info, 1, &size, &alignment);\n\tvoid *mem = mallocx(size, MALLOCX_ALIGN(alignment));\n\tassert_ptr_not_null(mem, \"Unexpected mallocx failure\");\n\n\tsize_t cur_offset = 0;\n\tcache_bin_preincrement(info, 1, mem, &cur_offset);\n\tcache_bin_init(bin, info, mem, &cur_offset);\n\tcache_bin_postincrement(info, 1, mem, &cur_offset);\n\tassert_zu_eq(cur_offset, size, \"Should use all requested memory\");\n}\n\nTEST_BEGIN(test_cache_bin) {\n\tconst int ncached_max = 100;\n\tbool success;\n\tvoid *ptr;\n\n\tcache_bin_info_t info;\n\tcache_bin_info_init(&info, ncached_max);\n\tcache_bin_t bin;\n\ttest_bin_init(&bin, &info);\n\n\t/* Initialize to empty; should then have 0 elements. */\n\texpect_d_eq(ncached_max, cache_bin_info_ncached_max(&info), \"\");\n\texpect_true(cache_bin_ncached_get_local(&bin, &info) == 0, \"\");\n\texpect_true(cache_bin_low_water_get(&bin, &info) == 0, \"\");\n\n\tptr = cache_bin_alloc_easy(&bin, &success);\n\texpect_false(success, \"Shouldn't successfully allocate when empty\");\n\texpect_ptr_null(ptr, \"Shouldn't get a non-null pointer on failure\");\n\n\tptr = cache_bin_alloc(&bin, &success);\n\texpect_false(success, \"Shouldn't successfully allocate when empty\");\n\texpect_ptr_null(ptr, \"Shouldn't get a non-null pointer on failure\");\n\n\t/*\n\t * We allocate one more item than ncached_max, so we can test cache bin\n\t * exhaustion.\n\t */\n\tvoid **ptrs = mallocx(sizeof(void *) * (ncached_max + 1), 0);\n\tassert_ptr_not_null(ptrs, \"Unexpected mallocx failure\");\n\tfor (cache_bin_sz_t i = 0; i < ncached_max; i++) {\n\t\texpect_true(cache_bin_ncached_get_local(&bin, &info) == i, \"\");\n\t\tsuccess = cache_bin_dalloc_easy(&bin, &ptrs[i]);\n\t\texpect_true(success,\n\t\t \"Should be able to dalloc into a non-full cache bin.\");\n\t\texpect_true(cache_bin_low_water_get(&bin, &info) == 0,\n\t\t \"Pushes and pops shouldn't change low water of zero.\");\n\t}\n\texpect_true(cache_bin_ncached_get_local(&bin, &info) == ncached_max,\n\t \"\");\n\tsuccess = cache_bin_dalloc_easy(&bin, &ptrs[ncached_max]);\n\texpect_false(success, \"Shouldn't be able to dalloc into a full bin.\");\n\n\tcache_bin_low_water_set(&bin);\n\n\tfor (cache_bin_sz_t i = 0; i < ncached_max; i++) {\n\t\texpect_true(cache_bin_low_water_get(&bin, &info)\n\t\t == ncached_max - i, \"\");\n\t\texpect_true(cache_bin_ncached_get_local(&bin, &info)\n\t\t == ncached_max - i, \"\");\n\t\t/*\n\t\t * This should fail -- the easy variant can't change the low\n\t\t * water mark.\n\t\t */\n\t\tptr = cache_bin_alloc_easy(&bin, &success);\n\t\texpect_ptr_null(ptr, \"\");\n\t\texpect_false(success, \"\");\n\t\texpect_true(cache_bin_low_water_get(&bin, &info)\n\t\t == ncached_max - i, \"\");\n\t\texpect_true(cache_bin_ncached_get_local(&bin, &info)\n\t\t == ncached_max - i, \"\");\n\n\t\t/* This should succeed, though. */\n\t\tptr = cache_bin_alloc(&bin, &success);\n\t\texpect_true(success, \"\");\n\t\texpect_ptr_eq(ptr, &ptrs[ncached_max - i - 1],\n\t\t \"Alloc should pop in stack order\");\n\t\texpect_true(cache_bin_low_water_get(&bin, &info)\n\t\t == ncached_max - i - 1, \"\");\n\t\texpect_true(cache_bin_ncached_get_local(&bin, &info)\n\t\t == ncached_max - i - 1, \"\");\n\t}\n\t/* Now we're empty -- all alloc attempts should fail. */\n\texpect_true(cache_bin_ncached_get_local(&bin, &info) == 0, \"\");\n\tptr = cache_bin_alloc_easy(&bin, &success);\n\texpect_ptr_null(ptr, \"\");\n\texpect_false(success, \"\");\n\tptr = cache_bin_alloc(&bin, &success);\n\texpect_ptr_null(ptr, \"\");\n\texpect_false(success, \"\");\n\n\tfor (cache_bin_sz_t i = 0; i < ncached_max / 2; i++) {\n\t\tcache_bin_dalloc_easy(&bin, &ptrs[i]);\n\t}\n\tcache_bin_low_water_set(&bin);\n\n\tfor (cache_bin_sz_t i = ncached_max / 2; i < ncached_max; i++) {\n\t\tcache_bin_dalloc_easy(&bin, &ptrs[i]);\n\t}\n\texpect_true(cache_bin_ncached_get_local(&bin, &info) == ncached_max,\n\t \"\");\n\tfor (cache_bin_sz_t i = ncached_max - 1; i >= ncached_max / 2; i--) {\n\t\t/*\n\t\t * Size is bigger than low water -- the reduced version should\n\t\t * succeed.\n\t\t */\n\t\tptr = cache_bin_alloc_easy(&bin, &success);\n\t\texpect_true(success, \"\");\n\t\texpect_ptr_eq(ptr, &ptrs[i], \"\");\n\t}\n\t/* But now, we've hit low-water. */\n\tptr = cache_bin_alloc_easy(&bin, &success);\n\texpect_false(success, \"\");\n\texpect_ptr_null(ptr, \"\");\n\n\t/* We're going to test filling -- we must be empty to start. */\n\twhile (cache_bin_ncached_get_local(&bin, &info)) {\n\t\tcache_bin_alloc(&bin, &success);\n\t\texpect_true(success, \"\");\n\t}\n\n\t/* Test fill. */\n\t/* Try to fill all, succeed fully. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max, ncached_max);\n\t/* Try to fill all, succeed partially. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max,\n\t ncached_max / 2);\n\t/* Try to fill all, fail completely. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max, 0);\n\n\t/* Try to fill some, succeed fully. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max / 2,\n\t ncached_max / 2);\n\t/* Try to fill some, succeed partially. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max / 2,\n\t ncached_max / 4);\n\t/* Try to fill some, fail completely. */\n\tdo_fill_test(&bin, &info, ptrs, ncached_max, ncached_max / 2, 0);\n\n\tdo_flush_test(&bin, &info, ptrs, ncached_max, ncached_max);\n\tdo_flush_test(&bin, &info, ptrs, ncached_max, ncached_max / 2);\n\tdo_flush_test(&bin, &info, ptrs, ncached_max, 0);\n\tdo_flush_test(&bin, &info, ptrs, ncached_max / 2, ncached_max / 2);\n\tdo_flush_test(&bin, &info, ptrs, ncached_max / 2, ncached_max / 4);\n\tdo_flush_test(&bin, &info, ptrs, ncached_max / 2, 0);\n\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, ncached_max);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, ncached_max * 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, ncached_max / 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, 1);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max, 0);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2,\n\t ncached_max / 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2, ncached_max);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2,\n\t ncached_max / 4);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2, 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2, 1);\n\tdo_batch_alloc_test(&bin, &info, ptrs, ncached_max / 2, 0);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 2, ncached_max);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 2, 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 2, 1);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 2, 0);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 1, 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 1, 1);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 1, 0);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 0, 2);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 0, 1);\n\tdo_batch_alloc_test(&bin, &info, ptrs, 0, 0);\n\n\tfree(ptrs);\n}\nTEST_END\n\nstatic void\ndo_flush_stashed_test(cache_bin_t *bin, cache_bin_info_t *info, void **ptrs,\n cache_bin_sz_t nfill, cache_bin_sz_t nstash) {\n\texpect_true(cache_bin_ncached_get_local(bin, info) == 0,\n\t \"Bin not empty\");\n\texpect_true(cache_bin_nstashed_get_local(bin, info) == 0,\n\t \"Bin not empty\");\n\texpect_true(nfill + nstash <= info->ncached_max, \"Exceeded max\");\n\n\tbool ret;\n\t/* Fill */\n\tfor (cache_bin_sz_t i = 0; i < nfill; i++) {\n\t\tret = cache_bin_dalloc_easy(bin, &ptrs[i]);\n\t\texpect_true(ret, \"Unexpected fill failure\");\n\t}\n\texpect_true(cache_bin_ncached_get_local(bin, info) == nfill,\n\t \"Wrong cached count\");\n\n\t/* Stash */\n\tfor (cache_bin_sz_t i = 0; i < nstash; i++) {\n\t\tret = cache_bin_stash(bin, &ptrs[i + nfill]);\n\t\texpect_true(ret, \"Unexpected stash failure\");\n\t}\n\texpect_true(cache_bin_nstashed_get_local(bin, info) == nstash,\n\t \"Wrong stashed count\");\n\n\tif (nfill + nstash == info->ncached_max) {\n\t\tret = cache_bin_dalloc_easy(bin, &ptrs[0]);\n\t\texpect_false(ret, \"Should not dalloc into a full bin\");\n\t\tret = cache_bin_stash(bin, &ptrs[0]);\n\t\texpect_false(ret, \"Should not stash into a full bin\");\n\t}\n\n\t/* Alloc filled ones */\n\tfor (cache_bin_sz_t i = 0; i < nfill; i++) {\n\t\tvoid *ptr = cache_bin_alloc(bin, &ret);\n\t\texpect_true(ret, \"Unexpected alloc failure\");\n\t\t/* Verify it's not from the stashed range. */\n\t\texpect_true((uintptr_t)ptr < (uintptr_t)&ptrs[nfill],\n\t\t \"Should not alloc stashed ptrs\");\n\t}\n\texpect_true(cache_bin_ncached_get_local(bin, info) == 0,\n\t \"Wrong cached count\");\n\texpect_true(cache_bin_nstashed_get_local(bin, info) == nstash,\n\t \"Wrong stashed count\");\n\n\tcache_bin_alloc(bin, &ret);\n\texpect_false(ret, \"Should not alloc stashed\");\n\n\t/* Clear stashed ones */\n\tcache_bin_finish_flush_stashed(bin, info);\n\texpect_true(cache_bin_ncached_get_local(bin, info) == 0,\n\t \"Wrong cached count\");\n\texpect_true(cache_bin_nstashed_get_local(bin, info) == 0,\n\t \"Wrong stashed count\");\n\n\tcache_bin_alloc(bin, &ret);\n\texpect_false(ret, \"Should not alloc from empty bin\");\n}\n\nTEST_BEGIN(test_cache_bin_stash) {\n\tconst int ncached_max = 100;\n\n\tcache_bin_t bin;\n\tcache_bin_info_t info;\n\tcache_bin_info_init(&info, ncached_max);\n\ttest_bin_init(&bin, &info);\n\n\t/*\n\t * The content of this array is not accessed; instead the interior\n\t * addresses are used to insert / stash into the bins as test pointers.\n\t */\n\tvoid **ptrs = mallocx(sizeof(void *) * (ncached_max + 1), 0);\n\tassert_ptr_not_null(ptrs, \"Unexpected mallocx failure\");\n\tbool ret;\n\tfor (cache_bin_sz_t i = 0; i < ncached_max; i++) {\n\t\texpect_true(cache_bin_ncached_get_local(&bin, &info) ==\n\t\t (i / 2 + i % 2), \"Wrong ncached value\");\n\t\texpect_true(cache_bin_nstashed_get_local(&bin, &info) == i / 2,\n\t\t \"Wrong nstashed value\");\n\t\tif (i % 2 == 0) {\n\t\t\tcache_bin_dalloc_easy(&bin, &ptrs[i]);\n\t\t} else {\n\t\t\tret = cache_bin_stash(&bin, &ptrs[i]);\n\t\t\texpect_true(ret, \"Should be able to stash into a \"\n\t\t\t \"non-full cache bin\");\n\t\t}\n\t}\n\tret = cache_bin_dalloc_easy(&bin, &ptrs[0]);\n\texpect_false(ret, \"Should not dalloc into a full cache bin\");\n\tret = cache_bin_stash(&bin, &ptrs[0]);\n\texpect_false(ret, \"Should not stash into a full cache bin\");\n\tfor (cache_bin_sz_t i = 0; i < ncached_max; i++) {\n\t\tvoid *ptr = cache_bin_alloc(&bin, &ret);\n\t\tif (i < ncached_max / 2) {\n\t\t\texpect_true(ret, \"Should be able to alloc\");\n\t\t\tuintptr_t diff = ((uintptr_t)ptr - (uintptr_t)&ptrs[0])\n\t\t\t / sizeof(void *);\n\t\t\texpect_true(diff % 2 == 0, \"Should be able to alloc\");\n\t\t} else {\n\t\t\texpect_false(ret, \"Should not alloc stashed\");\n\t\t\texpect_true(cache_bin_nstashed_get_local(&bin, &info) ==\n\t\t\t ncached_max / 2, \"Wrong nstashed value\");\n\t\t}\n\t}\n\n\ttest_bin_init(&bin, &info);\n\tdo_flush_stashed_test(&bin, &info, ptrs, ncached_max, 0);\n\tdo_flush_stashed_test(&bin, &info, ptrs, 0, ncached_max);\n\tdo_flush_stashed_test(&bin, &info, ptrs, ncached_max / 2, ncached_max / 2);\n\tdo_flush_stashed_test(&bin, &info, ptrs, ncached_max / 4, ncached_max / 2);\n\tdo_flush_stashed_test(&bin, &info, ptrs, ncached_max / 2, ncached_max / 4);\n\tdo_flush_stashed_test(&bin, &info, ptrs, ncached_max / 4, ncached_max / 4);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(test_cache_bin,\n\t\ttest_cache_bin_stash);\n}\n" }, { "path": "deps/jemalloc/test/unit/ckh.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_new_delete) {\n\ttsd_t *tsd;\n\tckh_t ckh;\n\n\ttsd = tsd_fetch();\n\n\texpect_false(ckh_new(tsd, &ckh, 2, ckh_string_hash,\n\t ckh_string_keycomp), \"Unexpected ckh_new() error\");\n\tckh_delete(tsd, &ckh);\n\n\texpect_false(ckh_new(tsd, &ckh, 3, ckh_pointer_hash,\n\t ckh_pointer_keycomp), \"Unexpected ckh_new() error\");\n\tckh_delete(tsd, &ckh);\n}\nTEST_END\n\nTEST_BEGIN(test_count_insert_search_remove) {\n\ttsd_t *tsd;\n\tckh_t ckh;\n\tconst char *strs[] = {\n\t \"a string\",\n\t \"A string\",\n\t \"a string.\",\n\t \"A string.\"\n\t};\n\tconst char *missing = \"A string not in the hash table.\";\n\tsize_t i;\n\n\ttsd = tsd_fetch();\n\n\texpect_false(ckh_new(tsd, &ckh, 2, ckh_string_hash,\n\t ckh_string_keycomp), \"Unexpected ckh_new() error\");\n\texpect_zu_eq(ckh_count(&ckh), 0,\n\t \"ckh_count() should return %zu, but it returned %zu\", ZU(0),\n\t ckh_count(&ckh));\n\n\t/* Insert. */\n\tfor (i = 0; i < sizeof(strs)/sizeof(const char *); i++) {\n\t\tckh_insert(tsd, &ckh, strs[i], strs[i]);\n\t\texpect_zu_eq(ckh_count(&ckh), i+1,\n\t\t \"ckh_count() should return %zu, but it returned %zu\", i+1,\n\t\t ckh_count(&ckh));\n\t}\n\n\t/* Search. */\n\tfor (i = 0; i < sizeof(strs)/sizeof(const char *); i++) {\n\t\tunion {\n\t\t\tvoid *p;\n\t\t\tconst char *s;\n\t\t} k, v;\n\t\tvoid **kp, **vp;\n\t\tconst char *ks, *vs;\n\n\t\tkp = (i & 1) ? &k.p : NULL;\n\t\tvp = (i & 2) ? &v.p : NULL;\n\t\tk.p = NULL;\n\t\tv.p = NULL;\n\t\texpect_false(ckh_search(&ckh, strs[i], kp, vp),\n\t\t \"Unexpected ckh_search() error\");\n\n\t\tks = (i & 1) ? strs[i] : (const char *)NULL;\n\t\tvs = (i & 2) ? strs[i] : (const char *)NULL;\n\t\texpect_ptr_eq((void *)ks, (void *)k.s, \"Key mismatch, i=%zu\",\n\t\t i);\n\t\texpect_ptr_eq((void *)vs, (void *)v.s, \"Value mismatch, i=%zu\",\n\t\t i);\n\t}\n\texpect_true(ckh_search(&ckh, missing, NULL, NULL),\n\t \"Unexpected ckh_search() success\");\n\n\t/* Remove. */\n\tfor (i = 0; i < sizeof(strs)/sizeof(const char *); i++) {\n\t\tunion {\n\t\t\tvoid *p;\n\t\t\tconst char *s;\n\t\t} k, v;\n\t\tvoid **kp, **vp;\n\t\tconst char *ks, *vs;\n\n\t\tkp = (i & 1) ? &k.p : NULL;\n\t\tvp = (i & 2) ? &v.p : NULL;\n\t\tk.p = NULL;\n\t\tv.p = NULL;\n\t\texpect_false(ckh_remove(tsd, &ckh, strs[i], kp, vp),\n\t\t \"Unexpected ckh_remove() error\");\n\n\t\tks = (i & 1) ? strs[i] : (const char *)NULL;\n\t\tvs = (i & 2) ? strs[i] : (const char *)NULL;\n\t\texpect_ptr_eq((void *)ks, (void *)k.s, \"Key mismatch, i=%zu\",\n\t\t i);\n\t\texpect_ptr_eq((void *)vs, (void *)v.s, \"Value mismatch, i=%zu\",\n\t\t i);\n\t\texpect_zu_eq(ckh_count(&ckh),\n\t\t sizeof(strs)/sizeof(const char *) - i - 1,\n\t\t \"ckh_count() should return %zu, but it returned %zu\",\n\t\t sizeof(strs)/sizeof(const char *) - i - 1,\n\t\t ckh_count(&ckh));\n\t}\n\n\tckh_delete(tsd, &ckh);\n}\nTEST_END\n\nTEST_BEGIN(test_insert_iter_remove) {\n#define NITEMS ZU(1000)\n\ttsd_t *tsd;\n\tckh_t ckh;\n\tvoid **p[NITEMS];\n\tvoid *q, *r;\n\tsize_t i;\n\n\ttsd = tsd_fetch();\n\n\texpect_false(ckh_new(tsd, &ckh, 2, ckh_pointer_hash,\n\t ckh_pointer_keycomp), \"Unexpected ckh_new() error\");\n\n\tfor (i = 0; i < NITEMS; i++) {\n\t\tp[i] = mallocx(i+1, 0);\n\t\texpect_ptr_not_null(p[i], \"Unexpected mallocx() failure\");\n\t}\n\n\tfor (i = 0; i < NITEMS; i++) {\n\t\tsize_t j;\n\n\t\tfor (j = i; j < NITEMS; j++) {\n\t\t\texpect_false(ckh_insert(tsd, &ckh, p[j], p[j]),\n\t\t\t \"Unexpected ckh_insert() failure\");\n\t\t\texpect_false(ckh_search(&ckh, p[j], &q, &r),\n\t\t\t \"Unexpected ckh_search() failure\");\n\t\t\texpect_ptr_eq(p[j], q, \"Key pointer mismatch\");\n\t\t\texpect_ptr_eq(p[j], r, \"Value pointer mismatch\");\n\t\t}\n\n\t\texpect_zu_eq(ckh_count(&ckh), NITEMS,\n\t\t \"ckh_count() should return %zu, but it returned %zu\",\n\t\t NITEMS, ckh_count(&ckh));\n\n\t\tfor (j = i + 1; j < NITEMS; j++) {\n\t\t\texpect_false(ckh_search(&ckh, p[j], NULL, NULL),\n\t\t\t \"Unexpected ckh_search() failure\");\n\t\t\texpect_false(ckh_remove(tsd, &ckh, p[j], &q, &r),\n\t\t\t \"Unexpected ckh_remove() failure\");\n\t\t\texpect_ptr_eq(p[j], q, \"Key pointer mismatch\");\n\t\t\texpect_ptr_eq(p[j], r, \"Value pointer mismatch\");\n\t\t\texpect_true(ckh_search(&ckh, p[j], NULL, NULL),\n\t\t\t \"Unexpected ckh_search() success\");\n\t\t\texpect_true(ckh_remove(tsd, &ckh, p[j], &q, &r),\n\t\t\t \"Unexpected ckh_remove() success\");\n\t\t}\n\n\t\t{\n\t\t\tbool seen[NITEMS];\n\t\t\tsize_t tabind;\n\n\t\t\tmemset(seen, 0, sizeof(seen));\n\n\t\t\tfor (tabind = 0; !ckh_iter(&ckh, &tabind, &q, &r);) {\n\t\t\t\tsize_t k;\n\n\t\t\t\texpect_ptr_eq(q, r, \"Key and val not equal\");\n\n\t\t\t\tfor (k = 0; k < NITEMS; k++) {\n\t\t\t\t\tif (p[k] == q) {\n\t\t\t\t\t\texpect_false(seen[k],\n\t\t\t\t\t\t \"Item %zu already seen\", k);\n\t\t\t\t\t\tseen[k] = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (j = 0; j < i + 1; j++) {\n\t\t\t\texpect_true(seen[j], \"Item %zu not seen\", j);\n\t\t\t}\n\t\t\tfor (; j < NITEMS; j++) {\n\t\t\t\texpect_false(seen[j], \"Item %zu seen\", j);\n\t\t\t}\n\t\t}\n\t}\n\n\tfor (i = 0; i < NITEMS; i++) {\n\t\texpect_false(ckh_search(&ckh, p[i], NULL, NULL),\n\t\t \"Unexpected ckh_search() failure\");\n\t\texpect_false(ckh_remove(tsd, &ckh, p[i], &q, &r),\n\t\t \"Unexpected ckh_remove() failure\");\n\t\texpect_ptr_eq(p[i], q, \"Key pointer mismatch\");\n\t\texpect_ptr_eq(p[i], r, \"Value pointer mismatch\");\n\t\texpect_true(ckh_search(&ckh, p[i], NULL, NULL),\n\t\t \"Unexpected ckh_search() success\");\n\t\texpect_true(ckh_remove(tsd, &ckh, p[i], &q, &r),\n\t\t \"Unexpected ckh_remove() success\");\n\t\tdallocx(p[i], 0);\n\t}\n\n\texpect_zu_eq(ckh_count(&ckh), 0,\n\t \"ckh_count() should return %zu, but it returned %zu\",\n\t ZU(0), ckh_count(&ckh));\n\tckh_delete(tsd, &ckh);\n#undef NITEMS\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_new_delete,\n\t test_count_insert_search_remove,\n\t test_insert_iter_remove);\n}\n" }, { "path": "deps/jemalloc/test/unit/counter.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic const uint64_t interval = 1 << 20;\n\nTEST_BEGIN(test_counter_accum) {\n\tuint64_t increment = interval >> 4;\n\tunsigned n = interval / increment;\n\tuint64_t accum = 0;\n\n\tcounter_accum_t c;\n\tcounter_accum_init(&c, interval);\n\n\ttsd_t *tsd = tsd_fetch();\n\tbool trigger;\n\tfor (unsigned i = 0; i < n; i++) {\n\t\ttrigger = counter_accum(tsd_tsdn(tsd), &c, increment);\n\t\taccum += increment;\n\t\tif (accum < interval) {\n\t\t\texpect_b_eq(trigger, false, \"Should not trigger\");\n\t\t} else {\n\t\t\texpect_b_eq(trigger, true, \"Should have triggered\");\n\t\t}\n\t}\n\texpect_b_eq(trigger, true, \"Should have triggered\");\n}\nTEST_END\n\nvoid\nexpect_counter_value(counter_accum_t *c, uint64_t v) {\n\tuint64_t accum = locked_read_u64_unsynchronized(&c->accumbytes);\n\texpect_u64_eq(accum, v, \"Counter value mismatch\");\n}\n\n#define N_THDS (16)\n#define N_ITER_THD (1 << 12)\n#define ITER_INCREMENT (interval >> 4)\n\nstatic void *\nthd_start(void *varg) {\n\tcounter_accum_t *c = (counter_accum_t *)varg;\n\n\ttsd_t *tsd = tsd_fetch();\n\tbool trigger;\n\tuintptr_t n_triggered = 0;\n\tfor (unsigned i = 0; i < N_ITER_THD; i++) {\n\t\ttrigger = counter_accum(tsd_tsdn(tsd), c, ITER_INCREMENT);\n\t\tn_triggered += trigger ? 1 : 0;\n\t}\n\n\treturn (void *)n_triggered;\n}\n\n\nTEST_BEGIN(test_counter_mt) {\n\tcounter_accum_t shared_c;\n\tcounter_accum_init(&shared_c, interval);\n\n\tthd_t thds[N_THDS];\n\tunsigned i;\n\tfor (i = 0; i < N_THDS; i++) {\n\t\tthd_create(&thds[i], thd_start, (void *)&shared_c);\n\t}\n\n\tuint64_t sum = 0;\n\tfor (i = 0; i < N_THDS; i++) {\n\t\tvoid *ret;\n\t\tthd_join(thds[i], &ret);\n\t\tsum += (uintptr_t)ret;\n\t}\n\texpect_u64_eq(sum, N_THDS * N_ITER_THD / (interval / ITER_INCREMENT),\n\t \"Incorrect number of triggers\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_counter_accum,\n\t test_counter_mt);\n}\n" }, { "path": "deps/jemalloc/test/unit/decay.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/decay.h\"\n\nTEST_BEGIN(test_decay_init) {\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tssize_t decay_ms = 1000;\n\tassert_true(decay_ms_valid(decay_ms), \"\");\n\n\texpect_false(decay_init(&decay, &curtime, decay_ms),\n\t \"Failed to initialize decay\");\n\texpect_zd_eq(decay_ms_read(&decay), decay_ms,\n\t \"Decay_ms was initialized incorrectly\");\n\texpect_u64_ne(decay_epoch_duration_ns(&decay), 0,\n\t \"Epoch duration was initialized incorrectly\");\n}\nTEST_END\n\nTEST_BEGIN(test_decay_ms_valid) {\n\texpect_false(decay_ms_valid(-7),\n\t \"Misclassified negative decay as valid\");\n\texpect_true(decay_ms_valid(-1),\n\t \"Misclassified -1 (never decay) as invalid decay\");\n\texpect_true(decay_ms_valid(8943),\n\t \"Misclassified valid decay\");\n\tif (SSIZE_MAX > NSTIME_SEC_MAX) {\n\t\texpect_false(\n\t\t decay_ms_valid((ssize_t)(NSTIME_SEC_MAX * KQU(1000) + 39)),\n\t\t \"Misclassified too large decay\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_decay_npages_purge_in) {\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tuint64_t decay_ms = 1000;\n\tnstime_t decay_nstime;\n\tnstime_init(&decay_nstime, decay_ms * 1000 * 1000);\n\texpect_false(decay_init(&decay, &curtime, (ssize_t)decay_ms),\n\t \"Failed to initialize decay\");\n\n\tsize_t new_pages = 100;\n\n\tnstime_t time;\n\tnstime_copy(&time, &decay_nstime);\n\texpect_u64_eq(decay_npages_purge_in(&decay, &time, new_pages),\n\t new_pages, \"Not all pages are expected to decay in decay_ms\");\n\n\tnstime_init(&time, 0);\n\texpect_u64_eq(decay_npages_purge_in(&decay, &time, new_pages), 0,\n\t \"More than zero pages are expected to instantly decay\");\n\n\tnstime_copy(&time, &decay_nstime);\n\tnstime_idivide(&time, 2);\n\texpect_u64_eq(decay_npages_purge_in(&decay, &time, new_pages),\n\t new_pages / 2, \"Not half of pages decay in half the decay period\");\n}\nTEST_END\n\nTEST_BEGIN(test_decay_maybe_advance_epoch) {\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tuint64_t decay_ms = 1000;\n\n\tbool err = decay_init(&decay, &curtime, (ssize_t)decay_ms);\n\texpect_false(err, \"\");\n\n\tbool advanced;\n\tadvanced = decay_maybe_advance_epoch(&decay, &curtime, 0);\n\texpect_false(advanced, \"Epoch advanced while time didn't\");\n\n\tnstime_t interval;\n\tnstime_init(&interval, decay_epoch_duration_ns(&decay));\n\n\tnstime_add(&curtime, &interval);\n\tadvanced = decay_maybe_advance_epoch(&decay, &curtime, 0);\n\texpect_false(advanced, \"Epoch advanced after first interval\");\n\n\tnstime_add(&curtime, &interval);\n\tadvanced = decay_maybe_advance_epoch(&decay, &curtime, 0);\n\texpect_true(advanced, \"Epoch didn't advance after two intervals\");\n}\nTEST_END\n\nTEST_BEGIN(test_decay_empty) {\n\t/* If we never have any decaying pages, npages_limit should be 0. */\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tuint64_t decay_ms = 1000;\n\tuint64_t decay_ns = decay_ms * 1000 * 1000;\n\n\tbool err = decay_init(&decay, &curtime, (ssize_t)decay_ms);\n\tassert_false(err, \"\");\n\n\tuint64_t time_between_calls = decay_epoch_duration_ns(&decay) / 5;\n\tint nepochs = 0;\n\tfor (uint64_t i = 0; i < decay_ns / time_between_calls * 10; i++) {\n\t\tsize_t dirty_pages = 0;\n\t\tnstime_init(&curtime, i * time_between_calls);\n\t\tbool epoch_advanced = decay_maybe_advance_epoch(&decay,\n\t\t &curtime, dirty_pages);\n\t\tif (epoch_advanced) {\n\t\t\tnepochs++;\n\t\t\texpect_zu_eq(decay_npages_limit_get(&decay), 0,\n\t\t\t \"Unexpectedly increased npages_limit\");\n\t\t}\n\t}\n\texpect_d_gt(nepochs, 0, \"Epochs never advanced\");\n}\nTEST_END\n\n/*\n * Verify that npages_limit correctly decays as the time goes.\n *\n * During first 'nepoch_init' epochs, add new dirty pages.\n * After that, let them decay and verify npages_limit decreases.\n * Then proceed with another 'nepoch_init' epochs and check that\n * all dirty pages are flushed out of backlog, bringing npages_limit\n * down to zero.\n */\nTEST_BEGIN(test_decay) {\n\tconst uint64_t nepoch_init = 10;\n\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tuint64_t decay_ms = 1000;\n\tuint64_t decay_ns = decay_ms * 1000 * 1000;\n\n\tbool err = decay_init(&decay, &curtime, (ssize_t)decay_ms);\n\tassert_false(err, \"\");\n\n\texpect_zu_eq(decay_npages_limit_get(&decay), 0,\n\t \"Empty decay returned nonzero npages_limit\");\n\n\tnstime_t epochtime;\n\tnstime_init(&epochtime, decay_epoch_duration_ns(&decay));\n\n\tconst size_t dirty_pages_per_epoch = 1000;\n\tsize_t dirty_pages = 0;\n\tuint64_t epoch_ns = decay_epoch_duration_ns(&decay);\n\tbool epoch_advanced = false;\n\n\t/* Populate backlog with some dirty pages */\n\tfor (uint64_t i = 0; i < nepoch_init; i++) {\n\t\tnstime_add(&curtime, &epochtime);\n\t\tdirty_pages += dirty_pages_per_epoch;\n\t\tepoch_advanced |= decay_maybe_advance_epoch(&decay, &curtime,\n\t\t dirty_pages);\n\t}\n\texpect_true(epoch_advanced, \"Epoch never advanced\");\n\n\tsize_t npages_limit = decay_npages_limit_get(&decay);\n\texpect_zu_gt(npages_limit, 0, \"npages_limit is incorrectly equal \"\n\t \"to zero after dirty pages have been added\");\n\n\t/* Keep dirty pages unchanged and verify that npages_limit decreases */\n\tfor (uint64_t i = nepoch_init; i * epoch_ns < decay_ns; ++i) {\n\t\tnstime_add(&curtime, &epochtime);\n\t\tepoch_advanced = decay_maybe_advance_epoch(&decay, &curtime,\n\t\t\t\t dirty_pages);\n\t\tif (epoch_advanced) {\n\t\t\tsize_t npages_limit_new = decay_npages_limit_get(&decay);\n\t\t\texpect_zu_lt(npages_limit_new, npages_limit,\n\t\t\t \"napges_limit failed to decay\");\n\n\t\t\tnpages_limit = npages_limit_new;\n\t\t}\n\t}\n\n\texpect_zu_gt(npages_limit, 0, \"npages_limit decayed to zero earlier \"\n\t \"than decay_ms since last dirty page was added\");\n\n\t/* Completely push all dirty pages out of the backlog */\n\tepoch_advanced = false;\n\tfor (uint64_t i = 0; i < nepoch_init; i++) {\n\t\tnstime_add(&curtime, &epochtime);\n\t\tepoch_advanced |= decay_maybe_advance_epoch(&decay, &curtime,\n\t\t dirty_pages);\n\t}\n\texpect_true(epoch_advanced, \"Epoch never advanced\");\n\n\tnpages_limit = decay_npages_limit_get(&decay);\n\texpect_zu_eq(npages_limit, 0, \"npages_limit didn't decay to 0 after \"\n\t \"decay_ms since last bump in dirty pages\");\n}\nTEST_END\n\nTEST_BEGIN(test_decay_ns_until_purge) {\n\tconst uint64_t nepoch_init = 10;\n\n\tdecay_t decay;\n\tmemset(&decay, 0, sizeof(decay));\n\n\tnstime_t curtime;\n\tnstime_init(&curtime, 0);\n\n\tuint64_t decay_ms = 1000;\n\tuint64_t decay_ns = decay_ms * 1000 * 1000;\n\n\tbool err = decay_init(&decay, &curtime, (ssize_t)decay_ms);\n\tassert_false(err, \"\");\n\n\tnstime_t epochtime;\n\tnstime_init(&epochtime, decay_epoch_duration_ns(&decay));\n\n\tuint64_t ns_until_purge_empty = decay_ns_until_purge(&decay, 0, 0);\n\texpect_u64_eq(ns_until_purge_empty, DECAY_UNBOUNDED_TIME_TO_PURGE,\n\t \"Failed to return unbounded wait time for zero threshold\");\n\n\tconst size_t dirty_pages_per_epoch = 1000;\n\tsize_t dirty_pages = 0;\n\tbool epoch_advanced = false;\n\tfor (uint64_t i = 0; i < nepoch_init; i++) {\n\t\tnstime_add(&curtime, &epochtime);\n\t\tdirty_pages += dirty_pages_per_epoch;\n\t\tepoch_advanced |= decay_maybe_advance_epoch(&decay, &curtime,\n\t\t dirty_pages);\n\t}\n\texpect_true(epoch_advanced, \"Epoch never advanced\");\n\n\tuint64_t ns_until_purge_all = decay_ns_until_purge(&decay,\n\t dirty_pages, dirty_pages);\n\texpect_u64_ge(ns_until_purge_all, decay_ns,\n\t \"Incorrectly calculated time to purge all pages\");\n\n\tuint64_t ns_until_purge_none = decay_ns_until_purge(&decay,\n\t dirty_pages, 0);\n\texpect_u64_eq(ns_until_purge_none, decay_epoch_duration_ns(&decay) * 2,\n\t \"Incorrectly calculated time to purge 0 pages\");\n\n\tuint64_t npages_threshold = dirty_pages / 2;\n\tuint64_t ns_until_purge_half = decay_ns_until_purge(&decay,\n\t dirty_pages, npages_threshold);\n\n\tnstime_t waittime;\n\tnstime_init(&waittime, ns_until_purge_half);\n\tnstime_add(&curtime, &waittime);\n\n\tdecay_maybe_advance_epoch(&decay, &curtime, dirty_pages);\n\tsize_t npages_limit = decay_npages_limit_get(&decay);\n\texpect_zu_lt(npages_limit, dirty_pages,\n\t \"npages_limit failed to decrease after waiting\");\n\tsize_t expected = dirty_pages - npages_limit;\n\tint deviation = abs((int)expected - (int)(npages_threshold));\n\texpect_d_lt(deviation, (int)(npages_threshold / 2),\n\t \"After waiting, number of pages is out of the expected interval \"\n\t \"[0.5 * npages_threshold .. 1.5 * npages_threshold]\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_decay_init,\n\t test_decay_ms_valid,\n\t test_decay_npages_purge_in,\n\t test_decay_maybe_advance_epoch,\n\t test_decay_empty,\n\t test_decay,\n\t test_decay_ns_until_purge);\n}\n" }, { "path": "deps/jemalloc/test/unit/div.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/div.h\"\n\nTEST_BEGIN(test_div_exhaustive) {\n\tfor (size_t divisor = 2; divisor < 1000 * 1000; ++divisor) {\n\t\tdiv_info_t div_info;\n\t\tdiv_init(&div_info, divisor);\n\t\tsize_t max = 1000 * divisor;\n\t\tif (max < 1000 * 1000) {\n\t\t\tmax = 1000 * 1000;\n\t\t}\n\t\tfor (size_t dividend = 0; dividend < 1000 * divisor;\n\t\t dividend += divisor) {\n\t\t\tsize_t quotient = div_compute(\n\t\t\t &div_info, dividend);\n\t\t\texpect_zu_eq(dividend, quotient * divisor,\n\t\t\t \"With divisor = %zu, dividend = %zu, \"\n\t\t\t \"got quotient %zu\", divisor, dividend, quotient);\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_div_exhaustive);\n}\n" }, { "path": "deps/jemalloc/test/unit/double_free.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/san.h\"\n\n#include \"jemalloc/internal/safety_check.h\"\n\nbool fake_abort_called;\nvoid fake_abort(const char *message) {\n\t(void)message;\n\tfake_abort_called = true;\n}\n\nvoid\ntest_large_double_free_pre(void) {\n\tsafety_check_set_abort(&fake_abort);\n\tfake_abort_called = false;\n}\n\nvoid\ntest_large_double_free_post() {\n\texpect_b_eq(fake_abort_called, true, \"Double-free check didn't fire.\");\n\tsafety_check_set_abort(NULL);\n}\n\nTEST_BEGIN(test_large_double_free_tcache) {\n\ttest_skip_if(!config_opt_safety_checks);\n\t/*\n\t * Skip debug builds, since too many assertions will be triggered with\n\t * double-free before hitting the one we are interested in.\n\t */\n\ttest_skip_if(config_debug);\n\n\ttest_large_double_free_pre();\n\tchar *ptr = malloc(SC_LARGE_MINCLASS);\n\tbool guarded = extent_is_guarded(tsdn_fetch(), ptr);\n\tfree(ptr);\n\tif (!guarded) {\n\t\tfree(ptr);\n\t} else {\n\t\t/*\n\t\t * Skip because guarded extents may unguard immediately on\n\t\t * deallocation, in which case the second free will crash before\n\t\t * reaching the intended safety check.\n\t\t */\n\t\tfake_abort_called = true;\n\t}\n\tmallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0);\n\ttest_large_double_free_post();\n}\nTEST_END\n\nTEST_BEGIN(test_large_double_free_no_tcache) {\n\ttest_skip_if(!config_opt_safety_checks);\n\ttest_skip_if(config_debug);\n\n\ttest_large_double_free_pre();\n\tchar *ptr = mallocx(SC_LARGE_MINCLASS, MALLOCX_TCACHE_NONE);\n\tbool guarded = extent_is_guarded(tsdn_fetch(), ptr);\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\tif (!guarded) {\n\t\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\t} else {\n\t\t/*\n\t\t * Skip because guarded extents may unguard immediately on\n\t\t * deallocation, in which case the second free will crash before\n\t\t * reaching the intended safety check.\n\t\t */\n\t\tfake_abort_called = true;\n\t}\n\ttest_large_double_free_post();\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(test_large_double_free_no_tcache,\n\t test_large_double_free_tcache);\n}\n" }, { "path": "deps/jemalloc/test/unit/double_free.h", "content": "\n" }, { "path": "deps/jemalloc/test/unit/edata_cache.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/edata_cache.h\"\n\nstatic void\ntest_edata_cache_init(edata_cache_t *edata_cache) {\n\tbase_t *base = base_new(TSDN_NULL, /* ind */ 1,\n\t &ehooks_default_extent_hooks, /* metadata_use_hooks */ true);\n\tassert_ptr_not_null(base, \"\");\n\tbool err = edata_cache_init(edata_cache, base);\n\tassert_false(err, \"\");\n}\n\nstatic void\ntest_edata_cache_destroy(edata_cache_t *edata_cache) {\n\tbase_delete(TSDN_NULL, edata_cache->base);\n}\n\nTEST_BEGIN(test_edata_cache) {\n\tedata_cache_t ec;\n\ttest_edata_cache_init(&ec);\n\n\t/* Get one */\n\tedata_t *ed1 = edata_cache_get(TSDN_NULL, &ec);\n\tassert_ptr_not_null(ed1, \"\");\n\n\t/* Cache should be empty */\n\tassert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\t/* Get another */\n\tedata_t *ed2 = edata_cache_get(TSDN_NULL, &ec);\n\tassert_ptr_not_null(ed2, \"\");\n\n\t/* Still empty */\n\tassert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\t/* Put one back, and the cache should now have one item */\n\tedata_cache_put(TSDN_NULL, &ec, ed1);\n\tassert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 1, \"\");\n\n\t/* Reallocating should reuse the item, and leave an empty cache. */\n\tedata_t *ed1_again = edata_cache_get(TSDN_NULL, &ec);\n\tassert_ptr_eq(ed1, ed1_again, \"\");\n\tassert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\ttest_edata_cache_destroy(&ec);\n}\nTEST_END\n\nstatic size_t\necf_count(edata_cache_fast_t *ecf) {\n\tsize_t count = 0;\n\tedata_t *cur;\n\tql_foreach(cur, &ecf->list.head, ql_link_inactive) {\n\t\tcount++;\n\t}\n\treturn count;\n}\n\nTEST_BEGIN(test_edata_cache_fast_simple) {\n\tedata_cache_t ec;\n\tedata_cache_fast_t ecf;\n\n\ttest_edata_cache_init(&ec);\n\tedata_cache_fast_init(&ecf, &ec);\n\n\tedata_t *ed1 = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_ptr_not_null(ed1, \"\");\n\texpect_zu_eq(ecf_count(&ecf), 0, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\tedata_t *ed2 = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_ptr_not_null(ed2, \"\");\n\texpect_zu_eq(ecf_count(&ecf), 0, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\tedata_cache_fast_put(TSDN_NULL, &ecf, ed1);\n\texpect_zu_eq(ecf_count(&ecf), 1, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\tedata_cache_fast_put(TSDN_NULL, &ecf, ed2);\n\texpect_zu_eq(ecf_count(&ecf), 2, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\t/* LIFO ordering. */\n\texpect_ptr_eq(ed2, edata_cache_fast_get(TSDN_NULL, &ecf), \"\");\n\texpect_zu_eq(ecf_count(&ecf), 1, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\texpect_ptr_eq(ed1, edata_cache_fast_get(TSDN_NULL, &ecf), \"\");\n\texpect_zu_eq(ecf_count(&ecf), 0, \"\");\n\texpect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, \"\");\n\n\ttest_edata_cache_destroy(&ec);\n}\nTEST_END\n\nTEST_BEGIN(test_edata_cache_fill) {\n\tedata_cache_t ec;\n\tedata_cache_fast_t ecf;\n\n\ttest_edata_cache_init(&ec);\n\tedata_cache_fast_init(&ecf, &ec);\n\n\tedata_t *allocs[EDATA_CACHE_FAST_FILL * 2];\n\n\t/*\n\t * If the fallback cache can't satisfy the request, we shouldn't do\n\t * extra allocations until compelled to. Put half the fill goal in the\n\t * fallback.\n\t */\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL / 2; i++) {\n\t\tallocs[i] = edata_cache_get(TSDN_NULL, &ec);\n\t}\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL / 2; i++) {\n\t\tedata_cache_put(TSDN_NULL, &ec, allocs[i]);\n\t}\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL / 2,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\n\tallocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL / 2 - 1, ecf_count(&ecf),\n\t \"Should have grabbed all edatas available but no more.\");\n\n\tfor (int i = 1; i < EDATA_CACHE_FAST_FILL / 2; i++) {\n\t\tallocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\t\texpect_ptr_not_null(allocs[i], \"\");\n\t}\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\n\t/* When forced, we should alloc from the base. */\n\tedata_t *edata = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_ptr_not_null(edata, \"\");\n\texpect_zu_eq(0, ecf_count(&ecf), \"Allocated more than necessary\");\n\texpect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED),\n\t \"Allocated more than necessary\");\n\n\t/*\n\t * We should correctly fill in the common case where the fallback isn't\n\t * exhausted, too.\n\t */\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL * 2; i++) {\n\t\tallocs[i] = edata_cache_get(TSDN_NULL, &ec);\n\t\texpect_ptr_not_null(allocs[i], \"\");\n\t}\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL * 2; i++) {\n\t\tedata_cache_put(TSDN_NULL, &ec, allocs[i]);\n\t}\n\n\tallocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL - 1, ecf_count(&ecf), \"\");\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\tfor (int i = 1; i < EDATA_CACHE_FAST_FILL; i++) {\n\t\texpect_zu_eq(EDATA_CACHE_FAST_FILL - i, ecf_count(&ecf), \"\");\n\t\texpect_zu_eq(EDATA_CACHE_FAST_FILL,\n\t\t atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\t\tallocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\t\texpect_ptr_not_null(allocs[i], \"\");\n\t}\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\n\tallocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL - 1, ecf_count(&ecf), \"\");\n\texpect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\tfor (int i = 1; i < EDATA_CACHE_FAST_FILL; i++) {\n\t\texpect_zu_eq(EDATA_CACHE_FAST_FILL - i, ecf_count(&ecf), \"\");\n\t\texpect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\t\tallocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);\n\t\texpect_ptr_not_null(allocs[i], \"\");\n\t}\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\texpect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\n\ttest_edata_cache_destroy(&ec);\n}\nTEST_END\n\nTEST_BEGIN(test_edata_cache_disable) {\n\tedata_cache_t ec;\n\tedata_cache_fast_t ecf;\n\n\ttest_edata_cache_init(&ec);\n\tedata_cache_fast_init(&ecf, &ec);\n\n\tfor (int i = 0; i < EDATA_CACHE_FAST_FILL; i++) {\n\t\tedata_t *edata = edata_cache_get(TSDN_NULL, &ec);\n\t\texpect_ptr_not_null(edata, \"\");\n\t\tedata_cache_fast_put(TSDN_NULL, &ecf, edata);\n\t}\n\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL, ecf_count(&ecf), \"\");\n\texpect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"\");\n\n\tedata_cache_fast_disable(TSDN_NULL, &ecf);\n\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED), \"Disabling should flush\");\n\n\tedata_t *edata = edata_cache_fast_get(TSDN_NULL, &ecf);\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL - 1,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED),\n\t \"Disabled ecf should forward on get\");\n\n\tedata_cache_fast_put(TSDN_NULL, &ecf, edata);\n\texpect_zu_eq(0, ecf_count(&ecf), \"\");\n\texpect_zu_eq(EDATA_CACHE_FAST_FILL,\n\t atomic_load_zu(&ec.count, ATOMIC_RELAXED),\n\t \"Disabled ecf should forward on put\");\n\n\ttest_edata_cache_destroy(&ec);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_edata_cache,\n\t test_edata_cache_fast_simple,\n\t test_edata_cache_fill,\n\t test_edata_cache_disable);\n}\n" }, { "path": "deps/jemalloc/test/unit/emitter.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"jemalloc/internal/emitter.h\"\n\n/*\n * This is so useful for debugging and feature work, we'll leave printing\n * functionality committed but disabled by default.\n */\n/* Print the text as it will appear. */\nstatic bool print_raw = false;\n/* Print the text escaped, so it can be copied back into the test case. */\nstatic bool print_escaped = false;\n\ntypedef struct buf_descriptor_s buf_descriptor_t;\nstruct buf_descriptor_s {\n\tchar *buf;\n\tsize_t len;\n\tbool mid_quote;\n};\n\n/*\n * Forwards all writes to the passed-in buf_v (which should be cast from a\n * buf_descriptor_t *).\n */\nstatic void\nforwarding_cb(void *buf_descriptor_v, const char *str) {\n\tbuf_descriptor_t *buf_descriptor = (buf_descriptor_t *)buf_descriptor_v;\n\n\tif (print_raw) {\n\t\tmalloc_printf(\"%s\", str);\n\t}\n\tif (print_escaped) {\n\t\tconst char *it = str;\n\t\twhile (*it != '\\0') {\n\t\t\tif (!buf_descriptor->mid_quote) {\n\t\t\t\tmalloc_printf(\"\\\"\");\n\t\t\t\tbuf_descriptor->mid_quote = true;\n\t\t\t}\n\t\t\tswitch (*it) {\n\t\t\tcase '\\\\':\n\t\t\t\tmalloc_printf(\"\\\\\");\n\t\t\t\tbreak;\n\t\t\tcase '\\\"':\n\t\t\t\tmalloc_printf(\"\\\\\\\"\");\n\t\t\t\tbreak;\n\t\t\tcase '\\t':\n\t\t\t\tmalloc_printf(\"\\\\t\");\n\t\t\t\tbreak;\n\t\t\tcase '\\n':\n\t\t\t\tmalloc_printf(\"\\\\n\\\"\\n\");\n\t\t\t\tbuf_descriptor->mid_quote = false;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tmalloc_printf(\"%c\", *it);\n\t\t\t}\n\t\t\tit++;\n\t\t}\n\t}\n\n\tsize_t written = malloc_snprintf(buf_descriptor->buf,\n\t buf_descriptor->len, \"%s\", str);\n\texpect_zu_eq(written, strlen(str), \"Buffer overflow!\");\n\tbuf_descriptor->buf += written;\n\tbuf_descriptor->len -= written;\n\texpect_zu_gt(buf_descriptor->len, 0, \"Buffer out of space!\");\n}\n\nstatic void\nexpect_emit_output(void (*emit_fn)(emitter_t *),\n const char *expected_json_output,\n const char *expected_json_compact_output,\n const char *expected_table_output) {\n\temitter_t emitter;\n\tchar buf[MALLOC_PRINTF_BUFSIZE];\n\tbuf_descriptor_t buf_descriptor;\n\n\tbuf_descriptor.buf = buf;\n\tbuf_descriptor.len = MALLOC_PRINTF_BUFSIZE;\n\tbuf_descriptor.mid_quote = false;\n\n\temitter_init(&emitter, emitter_output_json, &forwarding_cb,\n\t &buf_descriptor);\n\t(*emit_fn)(&emitter);\n\texpect_str_eq(expected_json_output, buf, \"json output failure\");\n\n\tbuf_descriptor.buf = buf;\n\tbuf_descriptor.len = MALLOC_PRINTF_BUFSIZE;\n\tbuf_descriptor.mid_quote = false;\n\n\temitter_init(&emitter, emitter_output_json_compact, &forwarding_cb,\n\t &buf_descriptor);\n\t(*emit_fn)(&emitter);\n\texpect_str_eq(expected_json_compact_output, buf,\n\t \"compact json output failure\");\n\n\tbuf_descriptor.buf = buf;\n\tbuf_descriptor.len = MALLOC_PRINTF_BUFSIZE;\n\tbuf_descriptor.mid_quote = false;\n\n\temitter_init(&emitter, emitter_output_table, &forwarding_cb,\n\t &buf_descriptor);\n\t(*emit_fn)(&emitter);\n\texpect_str_eq(expected_table_output, buf, \"table output failure\");\n}\n\nstatic void\nemit_dict(emitter_t *emitter) {\n\tbool b_false = false;\n\tbool b_true = true;\n\tint i_123 = 123;\n\tconst char *str = \"a string\";\n\n\temitter_begin(emitter);\n\temitter_dict_begin(emitter, \"foo\", \"This is the foo table:\");\n\temitter_kv(emitter, \"abc\", \"ABC\", emitter_type_bool, &b_false);\n\temitter_kv(emitter, \"def\", \"DEF\", emitter_type_bool, &b_true);\n\temitter_kv_note(emitter, \"ghi\", \"GHI\", emitter_type_int, &i_123,\n\t \"note_key1\", emitter_type_string, &str);\n\temitter_kv_note(emitter, \"jkl\", \"JKL\", emitter_type_string, &str,\n\t \"note_key2\", emitter_type_bool, &b_false);\n\temitter_dict_end(emitter);\n\temitter_end(emitter);\n}\n\nstatic const char *dict_json =\n\"{\\n\"\n\"\\t\\\"foo\\\": {\\n\"\n\"\\t\\t\\\"abc\\\": false,\\n\"\n\"\\t\\t\\\"def\\\": true,\\n\"\n\"\\t\\t\\\"ghi\\\": 123,\\n\"\n\"\\t\\t\\\"jkl\\\": \\\"a string\\\"\\n\"\n\"\\t}\\n\"\n\"}\\n\";\nstatic const char *dict_json_compact =\n\"{\"\n\t\"\\\"foo\\\":{\"\n\t\t\"\\\"abc\\\":false,\"\n\t\t\"\\\"def\\\":true,\"\n\t\t\"\\\"ghi\\\":123,\"\n\t\t\"\\\"jkl\\\":\\\"a string\\\"\"\n\t\"}\"\n\"}\";\nstatic const char *dict_table =\n\"This is the foo table:\\n\"\n\" ABC: false\\n\"\n\" DEF: true\\n\"\n\" GHI: 123 (note_key1: \\\"a string\\\")\\n\"\n\" JKL: \\\"a string\\\" (note_key2: false)\\n\";\n\nstatic void\nemit_table_printf(emitter_t *emitter) {\n\temitter_begin(emitter);\n\temitter_table_printf(emitter, \"Table note 1\\n\");\n\temitter_table_printf(emitter, \"Table note 2 %s\\n\",\n\t \"with format string\");\n\temitter_end(emitter);\n}\n\nstatic const char *table_printf_json =\n\"{\\n\"\n\"}\\n\";\nstatic const char *table_printf_json_compact = \"{}\";\nstatic const char *table_printf_table =\n\"Table note 1\\n\"\n\"Table note 2 with format string\\n\";\n\nstatic void emit_nested_dict(emitter_t *emitter) {\n\tint val = 123;\n\temitter_begin(emitter);\n\temitter_dict_begin(emitter, \"json1\", \"Dict 1\");\n\temitter_dict_begin(emitter, \"json2\", \"Dict 2\");\n\temitter_kv(emitter, \"primitive\", \"A primitive\", emitter_type_int, &val);\n\temitter_dict_end(emitter); /* Close 2 */\n\temitter_dict_begin(emitter, \"json3\", \"Dict 3\");\n\temitter_dict_end(emitter); /* Close 3 */\n\temitter_dict_end(emitter); /* Close 1 */\n\temitter_dict_begin(emitter, \"json4\", \"Dict 4\");\n\temitter_kv(emitter, \"primitive\", \"Another primitive\",\n\t emitter_type_int, &val);\n\temitter_dict_end(emitter); /* Close 4 */\n\temitter_end(emitter);\n}\n\nstatic const char *nested_dict_json =\n\"{\\n\"\n\"\\t\\\"json1\\\": {\\n\"\n\"\\t\\t\\\"json2\\\": {\\n\"\n\"\\t\\t\\t\\\"primitive\\\": 123\\n\"\n\"\\t\\t},\\n\"\n\"\\t\\t\\\"json3\\\": {\\n\"\n\"\\t\\t}\\n\"\n\"\\t},\\n\"\n\"\\t\\\"json4\\\": {\\n\"\n\"\\t\\t\\\"primitive\\\": 123\\n\"\n\"\\t}\\n\"\n\"}\\n\";\nstatic const char *nested_dict_json_compact =\n\"{\"\n\t\"\\\"json1\\\":{\"\n\t\t\"\\\"json2\\\":{\"\n\t\t\t\"\\\"primitive\\\":123\"\n\t\t\"},\"\n\t\t\"\\\"json3\\\":{\"\n\t\t\"}\"\n\t\"},\"\n\t\"\\\"json4\\\":{\"\n\t\t\"\\\"primitive\\\":123\"\n\t\"}\"\n\"}\";\nstatic const char *nested_dict_table =\n\"Dict 1\\n\"\n\" Dict 2\\n\"\n\" A primitive: 123\\n\"\n\" Dict 3\\n\"\n\"Dict 4\\n\"\n\" Another primitive: 123\\n\";\n\nstatic void\nemit_types(emitter_t *emitter) {\n\tbool b = false;\n\tint i = -123;\n\tunsigned u = 123;\n\tssize_t zd = -456;\n\tsize_t zu = 456;\n\tconst char *str = \"string\";\n\tuint32_t u32 = 789;\n\tuint64_t u64 = 10000000000ULL;\n\n\temitter_begin(emitter);\n\temitter_kv(emitter, \"k1\", \"K1\", emitter_type_bool, &b);\n\temitter_kv(emitter, \"k2\", \"K2\", emitter_type_int, &i);\n\temitter_kv(emitter, \"k3\", \"K3\", emitter_type_unsigned, &u);\n\temitter_kv(emitter, \"k4\", \"K4\", emitter_type_ssize, &zd);\n\temitter_kv(emitter, \"k5\", \"K5\", emitter_type_size, &zu);\n\temitter_kv(emitter, \"k6\", \"K6\", emitter_type_string, &str);\n\temitter_kv(emitter, \"k7\", \"K7\", emitter_type_uint32, &u32);\n\temitter_kv(emitter, \"k8\", \"K8\", emitter_type_uint64, &u64);\n\t/*\n\t * We don't test the title type, since it's only used for tables. It's\n\t * tested in the emitter_table_row tests.\n\t */\n\temitter_end(emitter);\n}\n\nstatic const char *types_json =\n\"{\\n\"\n\"\\t\\\"k1\\\": false,\\n\"\n\"\\t\\\"k2\\\": -123,\\n\"\n\"\\t\\\"k3\\\": 123,\\n\"\n\"\\t\\\"k4\\\": -456,\\n\"\n\"\\t\\\"k5\\\": 456,\\n\"\n\"\\t\\\"k6\\\": \\\"string\\\",\\n\"\n\"\\t\\\"k7\\\": 789,\\n\"\n\"\\t\\\"k8\\\": 10000000000\\n\"\n\"}\\n\";\nstatic const char *types_json_compact =\n\"{\"\n\t\"\\\"k1\\\":false,\"\n\t\"\\\"k2\\\":-123,\"\n\t\"\\\"k3\\\":123,\"\n\t\"\\\"k4\\\":-456,\"\n\t\"\\\"k5\\\":456,\"\n\t\"\\\"k6\\\":\\\"string\\\",\"\n\t\"\\\"k7\\\":789,\"\n\t\"\\\"k8\\\":10000000000\"\n\"}\";\nstatic const char *types_table =\n\"K1: false\\n\"\n\"K2: -123\\n\"\n\"K3: 123\\n\"\n\"K4: -456\\n\"\n\"K5: 456\\n\"\n\"K6: \\\"string\\\"\\n\"\n\"K7: 789\\n\"\n\"K8: 10000000000\\n\";\n\nstatic void\nemit_modal(emitter_t *emitter) {\n\tint val = 123;\n\temitter_begin(emitter);\n\temitter_dict_begin(emitter, \"j0\", \"T0\");\n\temitter_json_key(emitter, \"j1\");\n\temitter_json_object_begin(emitter);\n\temitter_kv(emitter, \"i1\", \"I1\", emitter_type_int, &val);\n\temitter_json_kv(emitter, \"i2\", emitter_type_int, &val);\n\temitter_table_kv(emitter, \"I3\", emitter_type_int, &val);\n\temitter_table_dict_begin(emitter, \"T1\");\n\temitter_kv(emitter, \"i4\", \"I4\", emitter_type_int, &val);\n\temitter_json_object_end(emitter); /* Close j1 */\n\temitter_kv(emitter, \"i5\", \"I5\", emitter_type_int, &val);\n\temitter_table_dict_end(emitter); /* Close T1 */\n\temitter_kv(emitter, \"i6\", \"I6\", emitter_type_int, &val);\n\temitter_dict_end(emitter); /* Close j0 / T0 */\n\temitter_end(emitter);\n}\n\nconst char *modal_json =\n\"{\\n\"\n\"\\t\\\"j0\\\": {\\n\"\n\"\\t\\t\\\"j1\\\": {\\n\"\n\"\\t\\t\\t\\\"i1\\\": 123,\\n\"\n\"\\t\\t\\t\\\"i2\\\": 123,\\n\"\n\"\\t\\t\\t\\\"i4\\\": 123\\n\"\n\"\\t\\t},\\n\"\n\"\\t\\t\\\"i5\\\": 123,\\n\"\n\"\\t\\t\\\"i6\\\": 123\\n\"\n\"\\t}\\n\"\n\"}\\n\";\nconst char *modal_json_compact =\n\"{\"\n\t\"\\\"j0\\\":{\"\n\t\t\"\\\"j1\\\":{\"\n\t\t\t\"\\\"i1\\\":123,\"\n\t\t\t\"\\\"i2\\\":123,\"\n\t\t\t\"\\\"i4\\\":123\"\n\t\t\"},\"\n\t\t\"\\\"i5\\\":123,\"\n\t\t\"\\\"i6\\\":123\"\n\t\"}\"\n\"}\";\nconst char *modal_table =\n\"T0\\n\"\n\" I1: 123\\n\"\n\" I3: 123\\n\"\n\" T1\\n\"\n\" I4: 123\\n\"\n\" I5: 123\\n\"\n\" I6: 123\\n\";\n\nstatic void\nemit_json_array(emitter_t *emitter) {\n\tint ival = 123;\n\n\temitter_begin(emitter);\n\temitter_json_key(emitter, \"dict\");\n\temitter_json_object_begin(emitter);\n\temitter_json_key(emitter, \"arr\");\n\temitter_json_array_begin(emitter);\n\temitter_json_object_begin(emitter);\n\temitter_json_kv(emitter, \"foo\", emitter_type_int, &ival);\n\temitter_json_object_end(emitter); /* Close arr[0] */\n\t/* arr[1] and arr[2] are primitives. */\n\temitter_json_value(emitter, emitter_type_int, &ival);\n\temitter_json_value(emitter, emitter_type_int, &ival);\n\temitter_json_object_begin(emitter);\n\temitter_json_kv(emitter, \"bar\", emitter_type_int, &ival);\n\temitter_json_kv(emitter, \"baz\", emitter_type_int, &ival);\n\temitter_json_object_end(emitter); /* Close arr[3]. */\n\temitter_json_array_end(emitter); /* Close arr. */\n\temitter_json_object_end(emitter); /* Close dict. */\n\temitter_end(emitter);\n}\n\nstatic const char *json_array_json =\n\"{\\n\"\n\"\\t\\\"dict\\\": {\\n\"\n\"\\t\\t\\\"arr\\\": [\\n\"\n\"\\t\\t\\t{\\n\"\n\"\\t\\t\\t\\t\\\"foo\\\": 123\\n\"\n\"\\t\\t\\t},\\n\"\n\"\\t\\t\\t123,\\n\"\n\"\\t\\t\\t123,\\n\"\n\"\\t\\t\\t{\\n\"\n\"\\t\\t\\t\\t\\\"bar\\\": 123,\\n\"\n\"\\t\\t\\t\\t\\\"baz\\\": 123\\n\"\n\"\\t\\t\\t}\\n\"\n\"\\t\\t]\\n\"\n\"\\t}\\n\"\n\"}\\n\";\nstatic const char *json_array_json_compact =\n\"{\"\n\t\"\\\"dict\\\":{\"\n\t\t\"\\\"arr\\\":[\"\n\t\t\t\"{\"\n\t\t\t\t\"\\\"foo\\\":123\"\n\t\t\t\"},\"\n\t\t\t\"123,\"\n\t\t\t\"123,\"\n\t\t\t\"{\"\n\t\t\t\t\"\\\"bar\\\":123,\"\n\t\t\t\t\"\\\"baz\\\":123\"\n\t\t\t\"}\"\n\t\t\"]\"\n\t\"}\"\n\"}\";\nstatic const char *json_array_table = \"\";\n\nstatic void\nemit_json_nested_array(emitter_t *emitter) {\n\tint ival = 123;\n\tchar *sval = \"foo\";\n\temitter_begin(emitter);\n\temitter_json_array_begin(emitter);\n\t\temitter_json_array_begin(emitter);\n\t\temitter_json_value(emitter, emitter_type_int, &ival);\n\t\temitter_json_value(emitter, emitter_type_string, &sval);\n\t\temitter_json_value(emitter, emitter_type_int, &ival);\n\t\temitter_json_value(emitter, emitter_type_string, &sval);\n\t\temitter_json_array_end(emitter);\n\t\temitter_json_array_begin(emitter);\n\t\temitter_json_value(emitter, emitter_type_int, &ival);\n\t\temitter_json_array_end(emitter);\n\t\temitter_json_array_begin(emitter);\n\t\temitter_json_value(emitter, emitter_type_string, &sval);\n\t\temitter_json_value(emitter, emitter_type_int, &ival);\n\t\temitter_json_array_end(emitter);\n\t\temitter_json_array_begin(emitter);\n\t\temitter_json_array_end(emitter);\n\temitter_json_array_end(emitter);\n\temitter_end(emitter);\n}\n\nstatic const char *json_nested_array_json =\n\"{\\n\"\n\"\\t[\\n\"\n\"\\t\\t[\\n\"\n\"\\t\\t\\t123,\\n\"\n\"\\t\\t\\t\\\"foo\\\",\\n\"\n\"\\t\\t\\t123,\\n\"\n\"\\t\\t\\t\\\"foo\\\"\\n\"\n\"\\t\\t],\\n\"\n\"\\t\\t[\\n\"\n\"\\t\\t\\t123\\n\"\n\"\\t\\t],\\n\"\n\"\\t\\t[\\n\"\n\"\\t\\t\\t\\\"foo\\\",\\n\"\n\"\\t\\t\\t123\\n\"\n\"\\t\\t],\\n\"\n\"\\t\\t[\\n\"\n\"\\t\\t]\\n\"\n\"\\t]\\n\"\n\"}\\n\";\nstatic const char *json_nested_array_json_compact =\n\"{\"\n\t\"[\"\n\t\t\"[\"\n\t\t\t\"123,\"\n\t\t\t\"\\\"foo\\\",\"\n\t\t\t\"123,\"\n\t\t\t\"\\\"foo\\\"\"\n\t\t\"],\"\n\t\t\"[\"\n\t\t\t\"123\"\n\t\t\"],\"\n\t\t\"[\"\n\t\t\t\"\\\"foo\\\",\"\n\t\t\t\"123\"\n\t\t\"],\"\n\t\t\"[\"\n\t\t\"]\"\n\t\"]\"\n\"}\";\nstatic const char *json_nested_array_table = \"\";\n\nstatic void\nemit_table_row(emitter_t *emitter) {\n\temitter_begin(emitter);\n\temitter_row_t row;\n\temitter_col_t abc = {emitter_justify_left, 10, emitter_type_title, {0}, {0, 0}};\n\tabc.str_val = \"ABC title\";\n\temitter_col_t def = {emitter_justify_right, 15, emitter_type_title, {0}, {0, 0}};\n\tdef.str_val = \"DEF title\";\n\temitter_col_t ghi = {emitter_justify_right, 5, emitter_type_title, {0}, {0, 0}};\n\tghi.str_val = \"GHI\";\n\n\temitter_row_init(&row);\n\temitter_col_init(&abc, &row);\n\temitter_col_init(&def, &row);\n\temitter_col_init(&ghi, &row);\n\n\temitter_table_row(emitter, &row);\n\n\tabc.type = emitter_type_int;\n\tdef.type = emitter_type_bool;\n\tghi.type = emitter_type_int;\n\n\tabc.int_val = 123;\n\tdef.bool_val = true;\n\tghi.int_val = 456;\n\temitter_table_row(emitter, &row);\n\n\tabc.int_val = 789;\n\tdef.bool_val = false;\n\tghi.int_val = 1011;\n\temitter_table_row(emitter, &row);\n\n\tabc.type = emitter_type_string;\n\tabc.str_val = \"a string\";\n\tdef.bool_val = false;\n\tghi.type = emitter_type_title;\n\tghi.str_val = \"ghi\";\n\temitter_table_row(emitter, &row);\n\n\temitter_end(emitter);\n}\n\nstatic const char *table_row_json =\n\"{\\n\"\n\"}\\n\";\nstatic const char *table_row_json_compact = \"{}\";\nstatic const char *table_row_table =\n\"ABC title DEF title GHI\\n\"\n\"123 true 456\\n\"\n\"789 false 1011\\n\"\n\"\\\"a string\\\" false ghi\\n\";\n\n#define GENERATE_TEST(feature)\t\t\t\t\t\\\nTEST_BEGIN(test_##feature) {\t\t\t\t\t\\\n\texpect_emit_output(emit_##feature, feature##_json,\t\\\n\t feature##_json_compact, feature##_table);\t\t\\\n}\t\t\t\t\t\t\t\t\\\nTEST_END\n\nGENERATE_TEST(dict)\nGENERATE_TEST(table_printf)\nGENERATE_TEST(nested_dict)\nGENERATE_TEST(types)\nGENERATE_TEST(modal)\nGENERATE_TEST(json_array)\nGENERATE_TEST(json_nested_array)\nGENERATE_TEST(table_row)\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_dict,\n\t test_table_printf,\n\t test_nested_dict,\n\t test_types,\n\t test_modal,\n\t test_json_array,\n\t test_json_nested_array,\n\t test_table_row);\n}\n" }, { "path": "deps/jemalloc/test/unit/extent_quantize.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_small_extent_size) {\n\tunsigned nbins, i;\n\tsize_t sz, extent_size;\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\n\t/*\n\t * Iterate over all small size classes, get their extent sizes, and\n\t * verify that the quantized size is the same as the extent size.\n\t */\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.nbins\", (void *)&nbins, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.slab_size\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib failure\");\n\tfor (i = 0; i < nbins; i++) {\n\t\tmib[2] = i;\n\t\tsz = sizeof(size_t);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&extent_size, &sz,\n\t\t NULL, 0), 0, \"Unexpected mallctlbymib failure\");\n\t\texpect_zu_eq(extent_size,\n\t\t sz_psz_quantize_floor(extent_size),\n\t\t \"Small extent quantization should be a no-op \"\n\t\t \"(extent_size=%zu)\", extent_size);\n\t\texpect_zu_eq(extent_size,\n\t\t sz_psz_quantize_ceil(extent_size),\n\t\t \"Small extent quantization should be a no-op \"\n\t\t \"(extent_size=%zu)\", extent_size);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_large_extent_size) {\n\tbool cache_oblivious;\n\tunsigned nlextents, i;\n\tsize_t sz, extent_size_prev, ceil_prev;\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\n\t/*\n\t * Iterate over all large size classes, get their extent sizes, and\n\t * verify that the quantized size is the same as the extent size.\n\t */\n\n\tsz = sizeof(bool);\n\texpect_d_eq(mallctl(\"opt.cache_oblivious\", (void *)&cache_oblivious,\n\t &sz, NULL, 0), 0, \"Unexpected mallctl failure\");\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.nlextents\", (void *)&nlextents, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\n\texpect_d_eq(mallctlnametomib(\"arenas.lextent.0.size\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib failure\");\n\tfor (i = 0; i < nlextents; i++) {\n\t\tsize_t lextent_size, extent_size, floor, ceil;\n\n\t\tmib[2] = i;\n\t\tsz = sizeof(size_t);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&lextent_size,\n\t\t &sz, NULL, 0), 0, \"Unexpected mallctlbymib failure\");\n\t\textent_size = cache_oblivious ? lextent_size + PAGE :\n\t\t lextent_size;\n\t\tfloor = sz_psz_quantize_floor(extent_size);\n\t\tceil = sz_psz_quantize_ceil(extent_size);\n\n\t\texpect_zu_eq(extent_size, floor,\n\t\t \"Extent quantization should be a no-op for precise size \"\n\t\t \"(lextent_size=%zu, extent_size=%zu)\", lextent_size,\n\t\t extent_size);\n\t\texpect_zu_eq(extent_size, ceil,\n\t\t \"Extent quantization should be a no-op for precise size \"\n\t\t \"(lextent_size=%zu, extent_size=%zu)\", lextent_size,\n\t\t extent_size);\n\n\t\tif (i > 0) {\n\t\t\texpect_zu_eq(extent_size_prev,\n\t\t\t sz_psz_quantize_floor(extent_size - PAGE),\n\t\t\t \"Floor should be a precise size\");\n\t\t\tif (extent_size_prev < ceil_prev) {\n\t\t\t\texpect_zu_eq(ceil_prev, extent_size,\n\t\t\t\t \"Ceiling should be a precise size \"\n\t\t\t\t \"(extent_size_prev=%zu, ceil_prev=%zu, \"\n\t\t\t\t \"extent_size=%zu)\", extent_size_prev,\n\t\t\t\t ceil_prev, extent_size);\n\t\t\t}\n\t\t}\n\t\tif (i + 1 < nlextents) {\n\t\t\textent_size_prev = floor;\n\t\t\tceil_prev = sz_psz_quantize_ceil(extent_size +\n\t\t\t PAGE);\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_monotonic) {\n#define SZ_MAX\tZU(4 * 1024 * 1024)\n\tunsigned i;\n\tsize_t floor_prev, ceil_prev;\n\n\tfloor_prev = 0;\n\tceil_prev = 0;\n\tfor (i = 1; i <= SZ_MAX >> LG_PAGE; i++) {\n\t\tsize_t extent_size, floor, ceil;\n\n\t\textent_size = i << LG_PAGE;\n\t\tfloor = sz_psz_quantize_floor(extent_size);\n\t\tceil = sz_psz_quantize_ceil(extent_size);\n\n\t\texpect_zu_le(floor, extent_size,\n\t\t \"Floor should be <= (floor=%zu, extent_size=%zu, ceil=%zu)\",\n\t\t floor, extent_size, ceil);\n\t\texpect_zu_ge(ceil, extent_size,\n\t\t \"Ceiling should be >= (floor=%zu, extent_size=%zu, \"\n\t\t \"ceil=%zu)\", floor, extent_size, ceil);\n\n\t\texpect_zu_le(floor_prev, floor, \"Floor should be monotonic \"\n\t\t \"(floor_prev=%zu, floor=%zu, extent_size=%zu, ceil=%zu)\",\n\t\t floor_prev, floor, extent_size, ceil);\n\t\texpect_zu_le(ceil_prev, ceil, \"Ceiling should be monotonic \"\n\t\t \"(floor=%zu, extent_size=%zu, ceil_prev=%zu, ceil=%zu)\",\n\t\t floor, extent_size, ceil_prev, ceil);\n\n\t\tfloor_prev = floor;\n\t\tceil_prev = ceil;\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_small_extent_size,\n\t test_large_extent_size,\n\t test_monotonic);\n}\n" }, { "path": "deps/jemalloc/test/unit/fb.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/fb.h\"\n#include \"test/nbits.h\"\n\nstatic void\ndo_test_init(size_t nbits) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb = malloc(sz);\n\t/* Junk fb's contents. */\n\tmemset(fb, 99, sz);\n\tfb_init(fb, nbits);\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_false(fb_get(fb, nbits, i),\n\t\t \"bitmap should start empty\");\n\t}\n\tfree(fb);\n}\n\nTEST_BEGIN(test_fb_init) {\n#define NB(nbits) \\\n\tdo_test_init(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ndo_test_get_set_unset(size_t nbits) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb = malloc(sz);\n\tfb_init(fb, nbits);\n\t/* Set the bits divisible by 3. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif (i % 3 == 0) {\n\t\t\tfb_set(fb, nbits, i);\n\t\t}\n\t}\n\t/* Check them. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_b_eq(i % 3 == 0, fb_get(fb, nbits, i),\n\t\t \"Unexpected bit at position %zu\", i);\n\t}\n\t/* Unset those divisible by 5. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif (i % 5 == 0) {\n\t\t\tfb_unset(fb, nbits, i);\n\t\t}\n\t}\n\t/* Check them. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_b_eq(i % 3 == 0 && i % 5 != 0, fb_get(fb, nbits, i),\n\t\t \"Unexpected bit at position %zu\", i);\n\t}\n\tfree(fb);\n}\n\nTEST_BEGIN(test_get_set_unset) {\n#define NB(nbits) \\\n\tdo_test_get_set_unset(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic ssize_t\nfind_3_5_compute(ssize_t i, size_t nbits, bool bit, bool forward) {\n\tfor(; i < (ssize_t)nbits && i >= 0; i += (forward ? 1 : -1)) {\n\t\tbool expected_bit = i % 3 == 0 || i % 5 == 0;\n\t\tif (expected_bit == bit) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn forward ? (ssize_t)nbits : (ssize_t)-1;\n}\n\nstatic void\ndo_test_search_simple(size_t nbits) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb = malloc(sz);\n\tfb_init(fb, nbits);\n\n\t/* We pick multiples of 3 or 5. */\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif (i % 3 == 0) {\n\t\t\tfb_set(fb, nbits, i);\n\t\t}\n\t\t/* This tests double-setting a little, too. */\n\t\tif (i % 5 == 0) {\n\t\t\tfb_set(fb, nbits, i);\n\t\t}\n\t}\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tsize_t ffs_compute = find_3_5_compute(i, nbits, true, true);\n\t\tsize_t ffs_search = fb_ffs(fb, nbits, i);\n\t\texpect_zu_eq(ffs_compute, ffs_search, \"ffs mismatch at %zu\", i);\n\n\t\tssize_t fls_compute = find_3_5_compute(i, nbits, true, false);\n\t\tsize_t fls_search = fb_fls(fb, nbits, i);\n\t\texpect_zu_eq(fls_compute, fls_search, \"fls mismatch at %zu\", i);\n\n\t\tsize_t ffu_compute = find_3_5_compute(i, nbits, false, true);\n\t\tsize_t ffu_search = fb_ffu(fb, nbits, i);\n\t\texpect_zu_eq(ffu_compute, ffu_search, \"ffu mismatch at %zu\", i);\n\n\t\tsize_t flu_compute = find_3_5_compute(i, nbits, false, false);\n\t\tsize_t flu_search = fb_flu(fb, nbits, i);\n\t\texpect_zu_eq(flu_compute, flu_search, \"flu mismatch at %zu\", i);\n\t}\n\n\tfree(fb);\n}\n\nTEST_BEGIN(test_search_simple) {\n#define NB(nbits) \\\n\tdo_test_search_simple(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\nexpect_exhaustive_results(fb_group_t *mostly_full, fb_group_t *mostly_empty,\n size_t nbits, size_t special_bit, size_t position) {\n\tif (position < special_bit) {\n\t\texpect_zu_eq(special_bit, fb_ffs(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(-1, fb_fls(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(position, fb_ffu(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position, fb_flu(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\n\t\texpect_zu_eq(position, fb_ffs(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position, fb_fls(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(special_bit, fb_ffu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(-1, fb_flu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t} else if (position == special_bit) {\n\t\texpect_zu_eq(special_bit, fb_ffs(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(special_bit, fb_fls(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(position + 1, fb_ffu(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position - 1, fb_flu(mostly_empty, nbits,\n\t\t position), \"mismatch at %zu, %zu\", position, special_bit);\n\n\t\texpect_zu_eq(position + 1, fb_ffs(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position - 1, fb_fls(mostly_full, nbits,\n\t\t position), \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(position, fb_ffu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position, fb_flu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t} else {\n\t\t/* position > special_bit. */\n\t\texpect_zu_eq(nbits, fb_ffs(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(special_bit, fb_fls(mostly_empty, nbits,\n\t\t position), \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(position, fb_ffu(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position, fb_flu(mostly_empty, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\n\t\texpect_zu_eq(position, fb_ffs(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(position, fb_fls(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zu_eq(nbits, fb_ffu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t\texpect_zd_eq(special_bit, fb_flu(mostly_full, nbits, position),\n\t\t \"mismatch at %zu, %zu\", position, special_bit);\n\t}\n}\n\nstatic void\ndo_test_search_exhaustive(size_t nbits) {\n\t/* This test is quadratic; let's not get too big. */\n\tif (nbits > 1000) {\n\t\treturn;\n\t}\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *empty = malloc(sz);\n\tfb_init(empty, nbits);\n\tfb_group_t *full = malloc(sz);\n\tfb_init(full, nbits);\n\tfb_set_range(full, nbits, 0, nbits);\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfb_set(empty, nbits, i);\n\t\tfb_unset(full, nbits, i);\n\n\t\tfor (size_t j = 0; j < nbits; j++) {\n\t\t\texpect_exhaustive_results(full, empty, nbits, i, j);\n\t\t}\n\t\tfb_unset(empty, nbits, i);\n\t\tfb_set(full, nbits, i);\n\t}\n\n\tfree(empty);\n\tfree(full);\n}\n\nTEST_BEGIN(test_search_exhaustive) {\n#define NB(nbits) \\\n\tdo_test_search_exhaustive(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nTEST_BEGIN(test_range_simple) {\n\t/*\n\t * Just pick a constant big enough to have nontrivial middle sizes, and\n\t * big enough that usages of things like weirdnum (below) near the\n\t * beginning fit comfortably into the beginning of the bitmap.\n\t */\n\tsize_t nbits = 64 * 10;\n\tsize_t ngroups = FB_NGROUPS(nbits);\n\tfb_group_t *fb = malloc(sizeof(fb_group_t) * ngroups);\n\tfb_init(fb, nbits);\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif (i % 2 == 0) {\n\t\t\tfb_set_range(fb, nbits, i, 1);\n\t\t}\n\t}\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_b_eq(i % 2 == 0, fb_get(fb, nbits, i),\n\t\t \"mismatch at position %zu\", i);\n\t}\n\tfb_set_range(fb, nbits, 0, nbits / 2);\n\tfb_unset_range(fb, nbits, nbits / 2, nbits / 2);\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_b_eq(i < nbits / 2, fb_get(fb, nbits, i),\n\t\t \"mismatch at position %zu\", i);\n\t}\n\n\tstatic const size_t weirdnum = 7;\n\tfb_set_range(fb, nbits, 0, nbits);\n\tfb_unset_range(fb, nbits, weirdnum, FB_GROUP_BITS + weirdnum);\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_b_eq(7 <= i && i <= 2 * weirdnum + FB_GROUP_BITS - 1,\n\t\t !fb_get(fb, nbits, i), \"mismatch at position %zu\", i);\n\t}\n\tfree(fb);\n}\nTEST_END\n\nstatic void\ndo_test_empty_full_exhaustive(size_t nbits) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *empty = malloc(sz);\n\tfb_init(empty, nbits);\n\tfb_group_t *full = malloc(sz);\n\tfb_init(full, nbits);\n\tfb_set_range(full, nbits, 0, nbits);\n\n\texpect_true(fb_full(full, nbits), \"\");\n\texpect_false(fb_empty(full, nbits), \"\");\n\texpect_false(fb_full(empty, nbits), \"\");\n\texpect_true(fb_empty(empty, nbits), \"\");\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfb_set(empty, nbits, i);\n\t\tfb_unset(full, nbits, i);\n\n\t\texpect_false(fb_empty(empty, nbits), \"error at bit %zu\", i);\n\t\tif (nbits != 1) {\n\t\t\texpect_false(fb_full(empty, nbits),\n\t\t\t \"error at bit %zu\", i);\n\t\t\texpect_false(fb_empty(full, nbits),\n\t\t\t \"error at bit %zu\", i);\n\t\t} else {\n\t\t\texpect_true(fb_full(empty, nbits),\n\t\t\t \"error at bit %zu\", i);\n\t\t\texpect_true(fb_empty(full, nbits),\n\t\t\t \"error at bit %zu\", i);\n\t\t}\n\t\texpect_false(fb_full(full, nbits), \"error at bit %zu\", i);\n\n\t\tfb_unset(empty, nbits, i);\n\t\tfb_set(full, nbits, i);\n\t}\n\n\tfree(empty);\n\tfree(full);\n}\n\nTEST_BEGIN(test_empty_full) {\n#define NB(nbits) \\\n\tdo_test_empty_full_exhaustive(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\n/*\n * This tests both iter_range and the longest range functionality, which is\n * built closely on top of it.\n */\nTEST_BEGIN(test_iter_range_simple) {\n\tsize_t set_limit = 30;\n\tsize_t nbits = 100;\n\tfb_group_t fb[FB_NGROUPS(100)];\n\n\tfb_init(fb, nbits);\n\n\t/*\n\t * Failing to initialize these can lead to build failures with -Wall;\n\t * the compiler can't prove that they're set.\n\t */\n\tsize_t begin = (size_t)-1;\n\tsize_t len = (size_t)-1;\n\tbool result;\n\n\t/* A set of checks with only the first set_limit bits *set*. */\n\tfb_set_range(fb, nbits, 0, set_limit);\n\texpect_zu_eq(set_limit, fb_srange_longest(fb, nbits),\n\t \"Incorrect longest set range\");\n\texpect_zu_eq(nbits - set_limit, fb_urange_longest(fb, nbits),\n\t \"Incorrect longest unset range\");\n\tfor (size_t i = 0; i < set_limit; i++) {\n\t\tresult = fb_srange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(i, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(set_limit - i, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(set_limit, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(nbits - set_limit, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_srange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(0, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(i + 1, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_false(result, \"Should not have found a range at %zu\", i);\n\t}\n\tfor (size_t i = set_limit; i < nbits; i++) {\n\t\tresult = fb_srange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_false(result, \"Should not have found a range at %zu\", i);\n\n\t\tresult = fb_urange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(i, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(nbits - i, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_srange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(0, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(set_limit, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(set_limit, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(i - set_limit + 1, len, \"Incorrect len at %zu\", i);\n\t}\n\n\t/* A set of checks with only the first set_limit bits *unset*. */\n\tfb_unset_range(fb, nbits, 0, set_limit);\n\tfb_set_range(fb, nbits, set_limit, nbits - set_limit);\n\texpect_zu_eq(nbits - set_limit, fb_srange_longest(fb, nbits),\n\t \"Incorrect longest set range\");\n\texpect_zu_eq(set_limit, fb_urange_longest(fb, nbits),\n\t \"Incorrect longest unset range\");\n\tfor (size_t i = 0; i < set_limit; i++) {\n\t\tresult = fb_srange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(set_limit, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(nbits - set_limit, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(i, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(set_limit - i, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_srange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_false(result, \"Should not have found a range at %zu\", i);\n\n\t\tresult = fb_urange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should not have found a range at %zu\", i);\n\t\texpect_zu_eq(0, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(i + 1, len, \"Incorrect len at %zu\", i);\n\t}\n\tfor (size_t i = set_limit; i < nbits; i++) {\n\t\tresult = fb_srange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(i, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(nbits - i, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_iter(fb, nbits, i, &begin, &len);\n\t\texpect_false(result, \"Should not have found a range at %zu\", i);\n\n\t\tresult = fb_srange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(set_limit, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(i - set_limit + 1, len, \"Incorrect len at %zu\", i);\n\n\t\tresult = fb_urange_riter(fb, nbits, i, &begin, &len);\n\t\texpect_true(result, \"Should have found a range at %zu\", i);\n\t\texpect_zu_eq(0, begin, \"Incorrect begin at %zu\", i);\n\t\texpect_zu_eq(set_limit, len, \"Incorrect len at %zu\", i);\n\t}\n\n}\nTEST_END\n\n/*\n * Doing this bit-by-bit is too slow for a real implementation, but for testing\n * code, it's easy to get right. In the exhaustive tests, we'll compare the\n * (fast but tricky) real implementation against the (slow but simple) testing\n * one.\n */\nstatic bool\nfb_iter_simple(fb_group_t *fb, size_t nbits, size_t start, size_t *r_begin,\n size_t *r_len, bool val, bool forward) {\n\tssize_t stride = (forward ? (ssize_t)1 : (ssize_t)-1);\n\tssize_t range_begin = (ssize_t)start;\n\tfor (; range_begin != (ssize_t)nbits && range_begin != -1;\n\t range_begin += stride) {\n\t\tif (fb_get(fb, nbits, range_begin) == val) {\n\t\t\tssize_t range_end = range_begin;\n\t\t\tfor (; range_end != (ssize_t)nbits && range_end != -1;\n\t\t\t range_end += stride) {\n\t\t\t\tif (fb_get(fb, nbits, range_end) != val) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (forward) {\n\t\t\t\t*r_begin = range_begin;\n\t\t\t\t*r_len = range_end - range_begin;\n\t\t\t} else {\n\t\t\t\t*r_begin = range_end + 1;\n\t\t\t\t*r_len = range_begin - range_end;\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/* Similar, but for finding longest ranges. */\nstatic size_t\nfb_range_longest_simple(fb_group_t *fb, size_t nbits, bool val) {\n\tsize_t longest_so_far = 0;\n\tfor (size_t begin = 0; begin < nbits; begin++) {\n\t\tif (fb_get(fb, nbits, begin) != val) {\n\t\t\tcontinue;\n\t\t}\n\t\tsize_t end = begin + 1;\n\t\tfor (; end < nbits; end++) {\n\t\t\tif (fb_get(fb, nbits, end) != val) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (end - begin > longest_so_far) {\n\t\t\tlongest_so_far = end - begin;\n\t\t}\n\t}\n\treturn longest_so_far;\n}\n\nstatic void\nexpect_iter_results_at(fb_group_t *fb, size_t nbits, size_t pos,\n bool val, bool forward) {\n\tbool iter_res;\n\tsize_t iter_begin JEMALLOC_CC_SILENCE_INIT(0);\n\tsize_t iter_len JEMALLOC_CC_SILENCE_INIT(0);\n\tif (val) {\n\t\tif (forward) {\n\t\t\titer_res = fb_srange_iter(fb, nbits, pos,\n\t\t\t &iter_begin, &iter_len);\n\t\t} else {\n\t\t\titer_res = fb_srange_riter(fb, nbits, pos,\n\t\t\t &iter_begin, &iter_len);\n\t\t}\n\t} else {\n\t\tif (forward) {\n\t\t\titer_res = fb_urange_iter(fb, nbits, pos,\n\t\t\t &iter_begin, &iter_len);\n\t\t} else {\n\t\t\titer_res = fb_urange_riter(fb, nbits, pos,\n\t\t\t &iter_begin, &iter_len);\n\t\t}\n\t}\n\n\tbool simple_iter_res;\n\t/*\n\t * These are dead stores, but the compiler can't always figure that out\n\t * statically, and warns on the uninitialized variable.\n\t */\n\tsize_t simple_iter_begin = 0;\n\tsize_t simple_iter_len = 0;\n\tsimple_iter_res = fb_iter_simple(fb, nbits, pos, &simple_iter_begin,\n\t &simple_iter_len, val, forward);\n\n\texpect_b_eq(iter_res, simple_iter_res, \"Result mismatch at %zu\", pos);\n\tif (iter_res && simple_iter_res) {\n\t\tassert_zu_eq(iter_begin, simple_iter_begin,\n\t\t \"Begin mismatch at %zu\", pos);\n\t\texpect_zu_eq(iter_len, simple_iter_len,\n\t\t \"Length mismatch at %zu\", pos);\n\t}\n}\n\nstatic void\nexpect_iter_results(fb_group_t *fb, size_t nbits) {\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\texpect_iter_results_at(fb, nbits, i, false, false);\n\t\texpect_iter_results_at(fb, nbits, i, false, true);\n\t\texpect_iter_results_at(fb, nbits, i, true, false);\n\t\texpect_iter_results_at(fb, nbits, i, true, true);\n\t}\n\texpect_zu_eq(fb_range_longest_simple(fb, nbits, true),\n\t fb_srange_longest(fb, nbits), \"Longest range mismatch\");\n\texpect_zu_eq(fb_range_longest_simple(fb, nbits, false),\n\t fb_urange_longest(fb, nbits), \"Longest range mismatch\");\n}\n\nstatic void\nset_pattern_3(fb_group_t *fb, size_t nbits, bool zero_val) {\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif ((i % 6 < 3 && zero_val) || (i % 6 >= 3 && !zero_val)) {\n\t\t\tfb_set(fb, nbits, i);\n\t\t} else {\n\t\t\tfb_unset(fb, nbits, i);\n\t\t}\n\t}\n}\n\nstatic void\ndo_test_iter_range_exhaustive(size_t nbits) {\n\t/* This test is also pretty slow. */\n\tif (nbits > 1000) {\n\t\treturn;\n\t}\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb = malloc(sz);\n\tfb_init(fb, nbits);\n\n\tset_pattern_3(fb, nbits, /* zero_val */ true);\n\texpect_iter_results(fb, nbits);\n\n\tset_pattern_3(fb, nbits, /* zero_val */ false);\n\texpect_iter_results(fb, nbits);\n\n\tfb_set_range(fb, nbits, 0, nbits);\n\tfb_unset_range(fb, nbits, 0, nbits / 2 == 0 ? 1 : nbits / 2);\n\texpect_iter_results(fb, nbits);\n\n\tfb_unset_range(fb, nbits, 0, nbits);\n\tfb_set_range(fb, nbits, 0, nbits / 2 == 0 ? 1: nbits / 2);\n\texpect_iter_results(fb, nbits);\n\n\tfree(fb);\n}\n\n/*\n * Like test_iter_range_simple, this tests both iteration and longest-range\n * computation.\n */\nTEST_BEGIN(test_iter_range_exhaustive) {\n#define NB(nbits) \\\n\tdo_test_iter_range_exhaustive(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\n/*\n * If all set bits in the bitmap are contiguous, in [set_start, set_end),\n * returns the number of set bits in [scount_start, scount_end).\n */\nstatic size_t\nscount_contiguous(size_t set_start, size_t set_end, size_t scount_start,\n size_t scount_end) {\n\t/* No overlap. */\n\tif (set_end <= scount_start || scount_end <= set_start) {\n\t\treturn 0;\n\t}\n\t/* set range contains scount range */\n\tif (set_start <= scount_start && set_end >= scount_end) {\n\t\treturn scount_end - scount_start;\n\t}\n\t/* scount range contains set range. */\n\tif (scount_start <= set_start && scount_end >= set_end) {\n\t\treturn set_end - set_start;\n\t}\n\t/* Partial overlap, with set range starting first. */\n\tif (set_start < scount_start && set_end < scount_end) {\n\t\treturn set_end - scount_start;\n\t}\n\t/* Partial overlap, with scount range starting first. */\n\tif (scount_start < set_start && scount_end < set_end) {\n\t\treturn scount_end - set_start;\n\t}\n\t/*\n\t * Trigger an assert failure; the above list should have been\n\t * exhaustive.\n\t */\n\tunreachable();\n}\n\nstatic size_t\nucount_contiguous(size_t set_start, size_t set_end, size_t ucount_start,\n size_t ucount_end) {\n\t/* No overlap. */\n\tif (set_end <= ucount_start || ucount_end <= set_start) {\n\t\treturn ucount_end - ucount_start;\n\t}\n\t/* set range contains ucount range */\n\tif (set_start <= ucount_start && set_end >= ucount_end) {\n\t\treturn 0;\n\t}\n\t/* ucount range contains set range. */\n\tif (ucount_start <= set_start && ucount_end >= set_end) {\n\t\treturn (ucount_end - ucount_start) - (set_end - set_start);\n\t}\n\t/* Partial overlap, with set range starting first. */\n\tif (set_start < ucount_start && set_end < ucount_end) {\n\t\treturn ucount_end - set_end;\n\t}\n\t/* Partial overlap, with ucount range starting first. */\n\tif (ucount_start < set_start && ucount_end < set_end) {\n\t\treturn set_start - ucount_start;\n\t}\n\t/*\n\t * Trigger an assert failure; the above list should have been\n\t * exhaustive.\n\t */\n\tunreachable();\n}\n\nstatic void\nexpect_count_match_contiguous(fb_group_t *fb, size_t nbits, size_t set_start,\n size_t set_end) {\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfor (size_t j = i + 1; j <= nbits; j++) {\n\t\t\tsize_t cnt = j - i;\n\t\t\tsize_t scount_expected = scount_contiguous(set_start,\n\t\t\t set_end, i, j);\n\t\t\tsize_t scount_computed = fb_scount(fb, nbits, i, cnt);\n\t\t\texpect_zu_eq(scount_expected, scount_computed,\n\t\t\t \"fb_scount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with bits set in [%zu, %zu)\",\n\t\t\t nbits, i, cnt, set_start, set_end);\n\n\t\t\tsize_t ucount_expected = ucount_contiguous(set_start,\n\t\t\t set_end, i, j);\n\t\t\tsize_t ucount_computed = fb_ucount(fb, nbits, i, cnt);\n\t\t\tassert_zu_eq(ucount_expected, ucount_computed,\n\t\t\t \"fb_ucount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with bits set in [%zu, %zu)\",\n\t\t\t nbits, i, cnt, set_start, set_end);\n\n\t\t}\n\t}\n}\n\nstatic void\ndo_test_count_contiguous(size_t nbits) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb = malloc(sz);\n\n\tfb_init(fb, nbits);\n\n\texpect_count_match_contiguous(fb, nbits, 0, 0);\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfb_set(fb, nbits, i);\n\t\texpect_count_match_contiguous(fb, nbits, 0, i + 1);\n\t}\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfb_unset(fb, nbits, i);\n\t\texpect_count_match_contiguous(fb, nbits, i + 1, nbits);\n\t}\n\n\tfree(fb);\n}\n\nTEST_BEGIN(test_count_contiguous_simple) {\n\tenum {nbits = 300};\n\tfb_group_t fb[FB_NGROUPS(nbits)];\n\tfb_init(fb, nbits);\n\t/* Just an arbitrary number. */\n\tsize_t start = 23;\n\n\tfb_set_range(fb, nbits, start, 30 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 30);\n\n\tfb_set_range(fb, nbits, start, 40 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 40);\n\n\tfb_set_range(fb, nbits, start, 70 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 70);\n\n\tfb_set_range(fb, nbits, start, 120 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 120);\n\n\tfb_set_range(fb, nbits, start, 150 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 150);\n\n\tfb_set_range(fb, nbits, start, 200 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 200);\n\n\tfb_set_range(fb, nbits, start, 290 - start);\n\texpect_count_match_contiguous(fb, nbits, start, 290);\n}\nTEST_END\n\nTEST_BEGIN(test_count_contiguous) {\n#define NB(nbits) \\\n\t/* This test is *particularly* slow in debug builds. */ \\\n\tif ((!config_debug && nbits < 300) || nbits < 150) { \\\n\t\tdo_test_count_contiguous(nbits); \\\n\t}\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\nexpect_count_match_alternating(fb_group_t *fb_even, fb_group_t *fb_odd,\n size_t nbits) {\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tfor (size_t j = i + 1; j <= nbits; j++) {\n\t\t\tsize_t cnt = j - i;\n\t\t\tsize_t odd_scount = cnt / 2\n\t\t\t + (size_t)(cnt % 2 == 1 && i % 2 == 1);\n\t\t\tsize_t odd_scount_computed = fb_scount(fb_odd, nbits,\n\t\t\t i, j - i);\n\t\t\tassert_zu_eq(odd_scount, odd_scount_computed,\n\t\t\t \"fb_scount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with alternating bits set.\",\n\t\t\t nbits, i, j - i);\n\n\t\t\tsize_t odd_ucount = cnt / 2\n\t\t\t + (size_t)(cnt % 2 == 1 && i % 2 == 0);\n\t\t\tsize_t odd_ucount_computed = fb_ucount(fb_odd, nbits,\n\t\t\t i, j - i);\n\t\t\tassert_zu_eq(odd_ucount, odd_ucount_computed,\n\t\t\t \"fb_ucount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with alternating bits set.\",\n\t\t\t nbits, i, j - i);\n\n\t\t\tsize_t even_scount = cnt / 2\n\t\t\t + (size_t)(cnt % 2 == 1 && i % 2 == 0);\n\t\t\tsize_t even_scount_computed = fb_scount(fb_even, nbits,\n\t\t\t i, j - i);\n\t\t\tassert_zu_eq(even_scount, even_scount_computed,\n\t\t\t \"fb_scount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with alternating bits set.\",\n\t\t\t nbits, i, j - i);\n\n\t\t\tsize_t even_ucount = cnt / 2\n\t\t\t + (size_t)(cnt % 2 == 1 && i % 2 == 1);\n\t\t\tsize_t even_ucount_computed = fb_ucount(fb_even, nbits,\n\t\t\t i, j - i);\n\t\t\tassert_zu_eq(even_ucount, even_ucount_computed,\n\t\t\t \"fb_ucount error with nbits=%zu, start=%zu, \"\n\t\t\t \"cnt=%zu, with alternating bits set.\",\n\t\t\t nbits, i, j - i);\n\t\t}\n\t}\n}\n\nstatic void\ndo_test_count_alternating(size_t nbits) {\n\tif (nbits > 1000) {\n\t\treturn;\n\t}\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb_even = malloc(sz);\n\tfb_group_t *fb_odd = malloc(sz);\n\n\tfb_init(fb_even, nbits);\n\tfb_init(fb_odd, nbits);\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tif (i % 2 == 0) {\n\t\t\tfb_set(fb_even, nbits, i);\n\t\t} else {\n\t\t\tfb_set(fb_odd, nbits, i);\n\t\t}\n\t}\n\n\texpect_count_match_alternating(fb_even, fb_odd, nbits);\n\n\tfree(fb_even);\n\tfree(fb_odd);\n}\n\nTEST_BEGIN(test_count_alternating) {\n#define NB(nbits) \\\n\tdo_test_count_alternating(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic void\ndo_test_bit_op(size_t nbits, bool (*op)(bool a, bool b),\n void (*fb_op)(fb_group_t *dst, fb_group_t *src1, fb_group_t *src2, size_t nbits)) {\n\tsize_t sz = FB_NGROUPS(nbits) * sizeof(fb_group_t);\n\tfb_group_t *fb1 = malloc(sz);\n\tfb_group_t *fb2 = malloc(sz);\n\tfb_group_t *fb_result = malloc(sz);\n\tfb_init(fb1, nbits);\n\tfb_init(fb2, nbits);\n\tfb_init(fb_result, nbits);\n\n\t/* Just two random numbers. */\n\tconst uint64_t prng_init1 = (uint64_t)0X4E9A9DE6A35691CDULL;\n\tconst uint64_t prng_init2 = (uint64_t)0X7856E396B063C36EULL;\n\n\tuint64_t prng1 = prng_init1;\n\tuint64_t prng2 = prng_init2;\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tbool bit1 = ((prng1 & (1ULL << (i % 64))) != 0);\n\t\tbool bit2 = ((prng2 & (1ULL << (i % 64))) != 0);\n\n\t\tif (bit1) {\n\t\t\tfb_set(fb1, nbits, i);\n\t\t}\n\t\tif (bit2) {\n\t\t\tfb_set(fb2, nbits, i);\n\t\t}\n\n\t\tif (i % 64 == 0) {\n\t\t\tprng1 = prng_state_next_u64(prng1);\n\t\t\tprng2 = prng_state_next_u64(prng2);\n\t\t}\n\t}\n\n\tfb_op(fb_result, fb1, fb2, nbits);\n\n\t/* Reset the prngs to replay them. */\n\tprng1 = prng_init1;\n\tprng2 = prng_init2;\n\n\tfor (size_t i = 0; i < nbits; i++) {\n\t\tbool bit1 = ((prng1 & (1ULL << (i % 64))) != 0);\n\t\tbool bit2 = ((prng2 & (1ULL << (i % 64))) != 0);\n\n\t\t/* Original bitmaps shouldn't change. */\n\t\texpect_b_eq(bit1, fb_get(fb1, nbits, i), \"difference at bit %zu\", i);\n\t\texpect_b_eq(bit2, fb_get(fb2, nbits, i), \"difference at bit %zu\", i);\n\n\t\t/* New one should be bitwise and. */\n\t\texpect_b_eq(op(bit1, bit2), fb_get(fb_result, nbits, i),\n\t\t \"difference at bit %zu\", i);\n\n\t\t/* Update the same way we did last time. */\n\t\tif (i % 64 == 0) {\n\t\t\tprng1 = prng_state_next_u64(prng1);\n\t\t\tprng2 = prng_state_next_u64(prng2);\n\t\t}\n\t}\n\n\tfree(fb1);\n\tfree(fb2);\n\tfree(fb_result);\n}\n\nstatic bool\nbinary_and(bool a, bool b) {\n\treturn a & b;\n}\n\nstatic void\ndo_test_bit_and(size_t nbits) {\n\tdo_test_bit_op(nbits, &binary_and, &fb_bit_and);\n}\n\nTEST_BEGIN(test_bit_and) {\n#define NB(nbits) \\\n\tdo_test_bit_and(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic bool\nbinary_or(bool a, bool b) {\n\treturn a | b;\n}\n\nstatic void\ndo_test_bit_or(size_t nbits) {\n\tdo_test_bit_op(nbits, &binary_or, &fb_bit_or);\n}\n\nTEST_BEGIN(test_bit_or) {\n#define NB(nbits) \\\n\tdo_test_bit_or(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nstatic bool\nbinary_not(bool a, bool b) {\n\t(void)b;\n\treturn !a;\n}\n\nstatic void\nfb_bit_not_shim(fb_group_t *dst, fb_group_t *src1, fb_group_t *src2,\n size_t nbits) {\n\t(void)src2;\n\tfb_bit_not(dst, src1, nbits);\n}\n\nstatic void\ndo_test_bit_not(size_t nbits) {\n\tdo_test_bit_op(nbits, &binary_not, &fb_bit_not_shim);\n}\n\nTEST_BEGIN(test_bit_not) {\n#define NB(nbits) \\\n\tdo_test_bit_not(nbits);\n\tNBITS_TAB\n#undef NB\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_fb_init,\n\t test_get_set_unset,\n\t test_search_simple,\n\t test_search_exhaustive,\n\t test_range_simple,\n\t test_empty_full,\n\t test_iter_range_simple,\n\t test_iter_range_exhaustive,\n\t test_count_contiguous_simple,\n\t test_count_contiguous,\n\t test_count_alternating,\n\t test_bit_and,\n\t test_bit_or,\n\t test_bit_not);\n}\n" }, { "path": "deps/jemalloc/test/unit/fork.c", "content": "#include \"test/jemalloc_test.h\"\n\n#ifndef _WIN32\n#include \n#endif\n\n#ifndef _WIN32\nstatic void\nwait_for_child_exit(int pid) {\n\tint status;\n\twhile (true) {\n\t\tif (waitpid(pid, &status, 0) == -1) {\n\t\t\ttest_fail(\"Unexpected waitpid() failure.\");\n\t\t}\n\t\tif (WIFSIGNALED(status)) {\n\t\t\ttest_fail(\"Unexpected child termination due to \"\n\t\t\t \"signal %d\", WTERMSIG(status));\n\t\t\tbreak;\n\t\t}\n\t\tif (WIFEXITED(status)) {\n\t\t\tif (WEXITSTATUS(status) != 0) {\n\t\t\t\ttest_fail(\"Unexpected child exit value %d\",\n\t\t\t\t WEXITSTATUS(status));\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t}\n}\n#endif\n\nTEST_BEGIN(test_fork) {\n#ifndef _WIN32\n\tvoid *p;\n\tpid_t pid;\n\n\t/* Set up a manually managed arena for test. */\n\tunsigned arena_ind;\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\n\t/* Migrate to the new arena. */\n\tunsigned old_arena_ind;\n\tsz = sizeof(old_arena_ind);\n\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind, &sz,\n\t (void *)&arena_ind, sizeof(arena_ind)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\n\tpid = fork();\n\n\tfree(p);\n\n\tp = malloc(64);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\tfree(p);\n\n\tif (pid == -1) {\n\t\t/* Error. */\n\t\ttest_fail(\"Unexpected fork() failure\");\n\t} else if (pid == 0) {\n\t\t/* Child. */\n\t\t_exit(0);\n\t} else {\n\t\twait_for_child_exit(pid);\n\t}\n#else\n\ttest_skip(\"fork(2) is irrelevant to Windows\");\n#endif\n}\nTEST_END\n\n#ifndef _WIN32\nstatic void *\ndo_fork_thd(void *arg) {\n\tmalloc(1);\n\tint pid = fork();\n\tif (pid == -1) {\n\t\t/* Error. */\n\t\ttest_fail(\"Unexpected fork() failure\");\n\t} else if (pid == 0) {\n\t\t/* Child. */\n\t\tchar *args[] = {\"true\", NULL};\n\t\texecvp(args[0], args);\n\t\ttest_fail(\"Exec failed\");\n\t} else {\n\t\t/* Parent */\n\t\twait_for_child_exit(pid);\n\t}\n\treturn NULL;\n}\n#endif\n\n#ifndef _WIN32\nstatic void\ndo_test_fork_multithreaded() {\n\tthd_t child;\n\tthd_create(&child, do_fork_thd, NULL);\n\tdo_fork_thd(NULL);\n\tthd_join(child, NULL);\n}\n#endif\n\nTEST_BEGIN(test_fork_multithreaded) {\n#ifndef _WIN32\n\t/*\n\t * We've seen bugs involving hanging on arenas_lock (though the same\n\t * class of bugs can happen on any mutex). The bugs are intermittent\n\t * though, so we want to run the test multiple times. Since we hold the\n\t * arenas lock only early in the process lifetime, we can't just run\n\t * this test in a loop (since, after all the arenas are initialized, we\n\t * won't acquire arenas_lock any further). We therefore repeat the test\n\t * with multiple processes.\n\t */\n\tfor (int i = 0; i < 100; i++) {\n\t\tint pid = fork();\n\t\tif (pid == -1) {\n\t\t\t/* Error. */\n\t\t\ttest_fail(\"Unexpected fork() failure,\");\n\t\t} else if (pid == 0) {\n\t\t\t/* Child. */\n\t\t\tdo_test_fork_multithreaded();\n\t\t\t_exit(0);\n\t\t} else {\n\t\t\twait_for_child_exit(pid);\n\t\t}\n\t}\n#else\n\ttest_skip(\"fork(2) is irrelevant to Windows\");\n#endif\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_fork,\n\t test_fork_multithreaded);\n}\n" }, { "path": "deps/jemalloc/test/unit/fxp.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/fxp.h\"\n\nstatic double\nfxp2double(fxp_t a) {\n\tdouble intpart = (double)(a >> 16);\n\tdouble fracpart = (double)(a & ((1U << 16) - 1)) / (1U << 16);\n\treturn intpart + fracpart;\n}\n\n/* Is a close to b? */\nstatic bool\ndouble_close(double a, double b) {\n\t/*\n\t * Our implementation doesn't try for precision. Correspondingly, don't\n\t * enforce it too strenuously here; accept values that are close in\n\t * either relative or absolute terms.\n\t */\n\treturn fabs(a - b) < 0.01 || fabs(a - b) / a < 0.01;\n}\n\nstatic bool\nfxp_close(fxp_t a, fxp_t b) {\n\treturn double_close(fxp2double(a), fxp2double(b));\n}\n\nstatic fxp_t\nxparse_fxp(const char *str) {\n\tfxp_t result;\n\tbool err = fxp_parse(&result, str, NULL);\n\tassert_false(err, \"Invalid fxp string: %s\", str);\n\treturn result;\n}\n\nstatic void\nexpect_parse_accurate(const char *str, const char *parse_str) {\n\tdouble true_val = strtod(str, NULL);\n\tfxp_t fxp_val;\n\tchar *end;\n\tbool err = fxp_parse(&fxp_val, parse_str, &end);\n\texpect_false(err, \"Unexpected parse failure\");\n\texpect_ptr_eq(parse_str + strlen(str), end,\n\t \"Didn't parse whole string\");\n\texpect_true(double_close(fxp2double(fxp_val), true_val),\n\t \"Misparsed %s\", str);\n}\n\nstatic void\nparse_valid_trial(const char *str) {\n\t/* The value it parses should be correct. */\n\texpect_parse_accurate(str, str);\n\tchar buf[100];\n\tsnprintf(buf, sizeof(buf), \"%swith_some_trailing_text\", str);\n\texpect_parse_accurate(str, buf);\n\tsnprintf(buf, sizeof(buf), \"%s with a space\", str);\n\texpect_parse_accurate(str, buf);\n\tsnprintf(buf, sizeof(buf), \"%s,in_a_malloc_conf_string:1\", str);\n\texpect_parse_accurate(str, buf);\n}\n\nTEST_BEGIN(test_parse_valid) {\n\tparse_valid_trial(\"0\");\n\tparse_valid_trial(\"1\");\n\tparse_valid_trial(\"2\");\n\tparse_valid_trial(\"100\");\n\tparse_valid_trial(\"345\");\n\tparse_valid_trial(\"00000000123\");\n\tparse_valid_trial(\"00000000987\");\n\n\tparse_valid_trial(\"0.0\");\n\tparse_valid_trial(\"0.00000000000456456456\");\n\tparse_valid_trial(\"100.00000000000456456456\");\n\n\tparse_valid_trial(\"123.1\");\n\tparse_valid_trial(\"123.01\");\n\tparse_valid_trial(\"123.001\");\n\tparse_valid_trial(\"123.0001\");\n\tparse_valid_trial(\"123.00001\");\n\tparse_valid_trial(\"123.000001\");\n\tparse_valid_trial(\"123.0000001\");\n\n\tparse_valid_trial(\".0\");\n\tparse_valid_trial(\".1\");\n\tparse_valid_trial(\".01\");\n\tparse_valid_trial(\".001\");\n\tparse_valid_trial(\".0001\");\n\tparse_valid_trial(\".00001\");\n\tparse_valid_trial(\".000001\");\n\n\tparse_valid_trial(\".1\");\n\tparse_valid_trial(\".10\");\n\tparse_valid_trial(\".100\");\n\tparse_valid_trial(\".1000\");\n\tparse_valid_trial(\".100000\");\n}\nTEST_END\n\nstatic void\nexpect_parse_failure(const char *str) {\n\tfxp_t result = FXP_INIT_INT(333);\n\tchar *end = (void *)0x123;\n\tbool err = fxp_parse(&result, str, &end);\n\texpect_true(err, \"Expected a parse error on: %s\", str);\n\texpect_ptr_eq((void *)0x123, end,\n\t \"Parse error shouldn't change results\");\n\texpect_u32_eq(result, FXP_INIT_INT(333),\n\t \"Parse error shouldn't change results\");\n}\n\nTEST_BEGIN(test_parse_invalid) {\n\texpect_parse_failure(\"123.\");\n\texpect_parse_failure(\"3.a\");\n\texpect_parse_failure(\".a\");\n\texpect_parse_failure(\"a.1\");\n\texpect_parse_failure(\"a\");\n\t/* A valid string, but one that overflows. */\n\texpect_parse_failure(\"123456789\");\n\texpect_parse_failure(\"0000000123456789\");\n\texpect_parse_failure(\"1000000\");\n}\nTEST_END\n\nstatic void\nexpect_init_percent(unsigned percent, const char *str) {\n\tfxp_t result_init = FXP_INIT_PERCENT(percent);\n\tfxp_t result_parse = xparse_fxp(str);\n\texpect_u32_eq(result_init, result_parse,\n\t \"Expect representations of FXP_INIT_PERCENT(%u) and \"\n\t \"fxp_parse(\\\"%s\\\") to be equal; got %x and %x\",\n\t percent, str, result_init, result_parse);\n\n}\n\n/*\n * Every other test uses either parsing or FXP_INIT_INT; it gets tested in those\n * ways. We need a one-off for the percent-based initialization, though.\n */\nTEST_BEGIN(test_init_percent) {\n\texpect_init_percent(100, \"1\");\n\texpect_init_percent(75, \".75\");\n\texpect_init_percent(1, \".01\");\n\texpect_init_percent(50, \".5\");\n}\nTEST_END\n\nstatic void\nexpect_add(const char *astr, const char *bstr, const char* resultstr) {\n\tfxp_t a = xparse_fxp(astr);\n\tfxp_t b = xparse_fxp(bstr);\n\tfxp_t result = xparse_fxp(resultstr);\n\texpect_true(fxp_close(fxp_add(a, b), result),\n\t \"Expected %s + %s == %s\", astr, bstr, resultstr);\n}\n\nTEST_BEGIN(test_add_simple) {\n\texpect_add(\"0\", \"0\", \"0\");\n\texpect_add(\"0\", \"1\", \"1\");\n\texpect_add(\"1\", \"1\", \"2\");\n\texpect_add(\"1.5\", \"1.5\", \"3\");\n\texpect_add(\"0.1\", \"0.1\", \"0.2\");\n\texpect_add(\"123\", \"456\", \"579\");\n}\nTEST_END\n\nstatic void\nexpect_sub(const char *astr, const char *bstr, const char* resultstr) {\n\tfxp_t a = xparse_fxp(astr);\n\tfxp_t b = xparse_fxp(bstr);\n\tfxp_t result = xparse_fxp(resultstr);\n\texpect_true(fxp_close(fxp_sub(a, b), result),\n\t \"Expected %s - %s == %s\", astr, bstr, resultstr);\n}\n\nTEST_BEGIN(test_sub_simple) {\n\texpect_sub(\"0\", \"0\", \"0\");\n\texpect_sub(\"1\", \"0\", \"1\");\n\texpect_sub(\"1\", \"1\", \"0\");\n\texpect_sub(\"3.5\", \"1.5\", \"2\");\n\texpect_sub(\"0.3\", \"0.1\", \"0.2\");\n\texpect_sub(\"456\", \"123\", \"333\");\n}\nTEST_END\n\nstatic void\nexpect_mul(const char *astr, const char *bstr, const char* resultstr) {\n\tfxp_t a = xparse_fxp(astr);\n\tfxp_t b = xparse_fxp(bstr);\n\tfxp_t result = xparse_fxp(resultstr);\n\texpect_true(fxp_close(fxp_mul(a, b), result),\n\t \"Expected %s * %s == %s\", astr, bstr, resultstr);\n}\n\nTEST_BEGIN(test_mul_simple) {\n\texpect_mul(\"0\", \"0\", \"0\");\n\texpect_mul(\"1\", \"0\", \"0\");\n\texpect_mul(\"1\", \"1\", \"1\");\n\texpect_mul(\"1.5\", \"1.5\", \"2.25\");\n\texpect_mul(\"100.0\", \"10\", \"1000\");\n\texpect_mul(\".1\", \"10\", \"1\");\n}\nTEST_END\n\nstatic void\nexpect_div(const char *astr, const char *bstr, const char* resultstr) {\n\tfxp_t a = xparse_fxp(astr);\n\tfxp_t b = xparse_fxp(bstr);\n\tfxp_t result = xparse_fxp(resultstr);\n\texpect_true(fxp_close(fxp_div(a, b), result),\n\t \"Expected %s / %s == %s\", astr, bstr, resultstr);\n}\n\nTEST_BEGIN(test_div_simple) {\n\texpect_div(\"1\", \"1\", \"1\");\n\texpect_div(\"0\", \"1\", \"0\");\n\texpect_div(\"2\", \"1\", \"2\");\n\texpect_div(\"3\", \"2\", \"1.5\");\n\texpect_div(\"3\", \"1.5\", \"2\");\n\texpect_div(\"10\", \".1\", \"100\");\n\texpect_div(\"123\", \"456\", \".2697368421\");\n}\nTEST_END\n\nstatic void\nexpect_round(const char *str, uint32_t rounded_down, uint32_t rounded_nearest) {\n\tfxp_t fxp = xparse_fxp(str);\n\tuint32_t fxp_rounded_down = fxp_round_down(fxp);\n\tuint32_t fxp_rounded_nearest = fxp_round_nearest(fxp);\n\texpect_u32_eq(rounded_down, fxp_rounded_down,\n\t \"Mistake rounding %s down\", str);\n\texpect_u32_eq(rounded_nearest, fxp_rounded_nearest,\n\t \"Mistake rounding %s to nearest\", str);\n}\n\nTEST_BEGIN(test_round_simple) {\n\texpect_round(\"1.5\", 1, 2);\n\texpect_round(\"0\", 0, 0);\n\texpect_round(\"0.1\", 0, 0);\n\texpect_round(\"0.4\", 0, 0);\n\texpect_round(\"0.40000\", 0, 0);\n\texpect_round(\"0.5\", 0, 1);\n\texpect_round(\"0.6\", 0, 1);\n\texpect_round(\"123\", 123, 123);\n\texpect_round(\"123.4\", 123, 123);\n\texpect_round(\"123.5\", 123, 124);\n}\nTEST_END\n\nstatic void\nexpect_mul_frac(size_t a, const char *fracstr, size_t expected) {\n\tfxp_t frac = xparse_fxp(fracstr);\n\tsize_t result = fxp_mul_frac(a, frac);\n\texpect_true(double_close(expected, result),\n\t \"Expected %zu * %s == %zu (fracmul); got %zu\", a, fracstr,\n\t expected, result);\n}\n\nTEST_BEGIN(test_mul_frac_simple) {\n\texpect_mul_frac(SIZE_MAX, \"1.0\", SIZE_MAX);\n\texpect_mul_frac(SIZE_MAX, \".75\", SIZE_MAX / 4 * 3);\n\texpect_mul_frac(SIZE_MAX, \".5\", SIZE_MAX / 2);\n\texpect_mul_frac(SIZE_MAX, \".25\", SIZE_MAX / 4);\n\texpect_mul_frac(1U << 16, \"1.0\", 1U << 16);\n\texpect_mul_frac(1U << 30, \"0.5\", 1U << 29);\n\texpect_mul_frac(1U << 30, \"0.25\", 1U << 28);\n\texpect_mul_frac(1U << 30, \"0.125\", 1U << 27);\n\texpect_mul_frac((1U << 30) + 1, \"0.125\", 1U << 27);\n\texpect_mul_frac(100, \"0.25\", 25);\n\texpect_mul_frac(1000 * 1000, \"0.001\", 1000);\n}\nTEST_END\n\nstatic void\nexpect_print(const char *str) {\n\tfxp_t fxp = xparse_fxp(str);\n\tchar buf[FXP_BUF_SIZE];\n\tfxp_print(fxp, buf);\n\texpect_d_eq(0, strcmp(str, buf), \"Couldn't round-trip print %s\", str);\n}\n\nTEST_BEGIN(test_print_simple) {\n\texpect_print(\"0.0\");\n\texpect_print(\"1.0\");\n\texpect_print(\"2.0\");\n\texpect_print(\"123.0\");\n\t/*\n\t * We hit the possibility of roundoff errors whenever the fractional\n\t * component isn't a round binary number; only check these here (we\n\t * round-trip properly in the stress test).\n\t */\n\texpect_print(\"1.5\");\n\texpect_print(\"3.375\");\n\texpect_print(\"0.25\");\n\texpect_print(\"0.125\");\n\t/* 1 / 2**14 */\n\texpect_print(\"0.00006103515625\");\n}\nTEST_END\n\nTEST_BEGIN(test_stress) {\n\tconst char *numbers[] = {\n\t\t\"0.0\", \"0.1\", \"0.2\", \"0.3\", \"0.4\",\n\t\t\"0.5\", \"0.6\", \"0.7\", \"0.8\", \"0.9\",\n\n\t\t\"1.0\", \"1.1\", \"1.2\", \"1.3\", \"1.4\",\n\t\t\"1.5\", \"1.6\", \"1.7\", \"1.8\", \"1.9\",\n\n\t\t\"2.0\", \"2.1\", \"2.2\", \"2.3\", \"2.4\",\n\t\t\"2.5\", \"2.6\", \"2.7\", \"2.8\", \"2.9\",\n\n\t\t\"17.0\", \"17.1\", \"17.2\", \"17.3\", \"17.4\",\n\t\t\"17.5\", \"17.6\", \"17.7\", \"17.8\", \"17.9\",\n\n\t\t\"18.0\", \"18.1\", \"18.2\", \"18.3\", \"18.4\",\n\t\t\"18.5\", \"18.6\", \"18.7\", \"18.8\", \"18.9\",\n\n\t\t\"123.0\", \"123.1\", \"123.2\", \"123.3\", \"123.4\",\n\t\t\"123.5\", \"123.6\", \"123.7\", \"123.8\", \"123.9\",\n\n\t\t\"124.0\", \"124.1\", \"124.2\", \"124.3\", \"124.4\",\n\t\t\"124.5\", \"124.6\", \"124.7\", \"124.8\", \"124.9\",\n\n\t\t\"125.0\", \"125.1\", \"125.2\", \"125.3\", \"125.4\",\n\t\t\"125.5\", \"125.6\", \"125.7\", \"125.8\", \"125.9\"};\n\tsize_t numbers_len = sizeof(numbers)/sizeof(numbers[0]);\n\tfor (size_t i = 0; i < numbers_len; i++) {\n\t\tfxp_t fxp_a = xparse_fxp(numbers[i]);\n\t\tdouble double_a = strtod(numbers[i], NULL);\n\n\t\tuint32_t fxp_rounded_down = fxp_round_down(fxp_a);\n\t\tuint32_t fxp_rounded_nearest = fxp_round_nearest(fxp_a);\n\t\tuint32_t double_rounded_down = (uint32_t)double_a;\n\t\tuint32_t double_rounded_nearest = (uint32_t)round(double_a);\n\n\t\texpect_u32_eq(double_rounded_down, fxp_rounded_down,\n\t\t \"Incorrectly rounded down %s\", numbers[i]);\n\t\texpect_u32_eq(double_rounded_nearest, fxp_rounded_nearest,\n\t\t \"Incorrectly rounded-to-nearest %s\", numbers[i]);\n\n\t\tfor (size_t j = 0; j < numbers_len; j++) {\n\t\t\tfxp_t fxp_b = xparse_fxp(numbers[j]);\n\t\t\tdouble double_b = strtod(numbers[j], NULL);\n\n\t\t\tfxp_t fxp_sum = fxp_add(fxp_a, fxp_b);\n\t\t\tdouble double_sum = double_a + double_b;\n\t\t\texpect_true(\n\t\t\t double_close(fxp2double(fxp_sum), double_sum),\n\t\t\t \"Miscomputed %s + %s\", numbers[i], numbers[j]);\n\n\t\t\tif (double_a > double_b) {\n\t\t\t\tfxp_t fxp_diff = fxp_sub(fxp_a, fxp_b);\n\t\t\t\tdouble double_diff = double_a - double_b;\n\t\t\t\texpect_true(\n\t\t\t\t double_close(fxp2double(fxp_diff),\n\t\t\t\t double_diff),\n\t\t\t\t \"Miscomputed %s - %s\", numbers[i],\n\t\t\t\t numbers[j]);\n\t\t\t}\n\n\t\t\tfxp_t fxp_prod = fxp_mul(fxp_a, fxp_b);\n\t\t\tdouble double_prod = double_a * double_b;\n\t\t\texpect_true(\n\t\t\t double_close(fxp2double(fxp_prod), double_prod),\n\t\t\t \"Miscomputed %s * %s\", numbers[i], numbers[j]);\n\n\t\t\tif (double_b != 0.0) {\n\t\t\t\tfxp_t fxp_quot = fxp_div(fxp_a, fxp_b);\n\t\t\t\tdouble double_quot = double_a / double_b;\n\t\t\t\texpect_true(\n\t\t\t\t double_close(fxp2double(fxp_quot),\n\t\t\t\t double_quot),\n\t\t\t\t \"Miscomputed %s / %s\", numbers[i],\n\t\t\t\t numbers[j]);\n\t\t\t}\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_parse_valid,\n\t test_parse_invalid,\n\t test_init_percent,\n\t test_add_simple,\n\t test_sub_simple,\n\t test_mul_simple,\n\t test_div_simple,\n\t test_round_simple,\n\t test_mul_frac_simple,\n\t test_print_simple,\n\t test_stress);\n}\n" }, { "path": "deps/jemalloc/test/unit/hash.c", "content": "/*\n * This file is based on code that is part of SMHasher\n * (https://code.google.com/p/smhasher/), and is subject to the MIT license\n * (http://www.opensource.org/licenses/mit-license.php). Both email addresses\n * associated with the source code's revision history belong to Austin Appleby,\n * and the revision history ranges from 2010 to 2012. Therefore the copyright\n * and license are here taken to be:\n *\n * Copyright (c) 2010-2012 Austin Appleby\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n#include \"test/jemalloc_test.h\"\n#include \"jemalloc/internal/hash.h\"\n\ntypedef enum {\n\thash_variant_x86_32,\n\thash_variant_x86_128,\n\thash_variant_x64_128\n} hash_variant_t;\n\nstatic int\nhash_variant_bits(hash_variant_t variant) {\n\tswitch (variant) {\n\tcase hash_variant_x86_32: return 32;\n\tcase hash_variant_x86_128: return 128;\n\tcase hash_variant_x64_128: return 128;\n\tdefault: not_reached();\n\t}\n}\n\nstatic const char *\nhash_variant_string(hash_variant_t variant) {\n\tswitch (variant) {\n\tcase hash_variant_x86_32: return \"hash_x86_32\";\n\tcase hash_variant_x86_128: return \"hash_x86_128\";\n\tcase hash_variant_x64_128: return \"hash_x64_128\";\n\tdefault: not_reached();\n\t}\n}\n\n#define KEY_SIZE\t256\nstatic void\nhash_variant_verify_key(hash_variant_t variant, uint8_t *key) {\n\tconst int hashbytes = hash_variant_bits(variant) / 8;\n\tconst int hashes_size = hashbytes * 256;\n\tVARIABLE_ARRAY(uint8_t, hashes, hashes_size);\n\tVARIABLE_ARRAY(uint8_t, final, hashbytes);\n\tunsigned i;\n\tuint32_t computed, expected;\n\n\tmemset(key, 0, KEY_SIZE);\n\tmemset(hashes, 0, hashes_size);\n\tmemset(final, 0, hashbytes);\n\n\t/*\n\t * Hash keys of the form {0}, {0,1}, {0,1,2}, ..., {0,1,...,255} as the\n\t * seed.\n\t */\n\tfor (i = 0; i < 256; i++) {\n\t\tkey[i] = (uint8_t)i;\n\t\tswitch (variant) {\n\t\tcase hash_variant_x86_32: {\n\t\t\tuint32_t out;\n\t\t\tout = hash_x86_32(key, i, 256-i);\n\t\t\tmemcpy(&hashes[i*hashbytes], &out, hashbytes);\n\t\t\tbreak;\n\t\t} case hash_variant_x86_128: {\n\t\t\tuint64_t out[2];\n\t\t\thash_x86_128(key, i, 256-i, out);\n\t\t\tmemcpy(&hashes[i*hashbytes], out, hashbytes);\n\t\t\tbreak;\n\t\t} case hash_variant_x64_128: {\n\t\t\tuint64_t out[2];\n\t\t\thash_x64_128(key, i, 256-i, out);\n\t\t\tmemcpy(&hashes[i*hashbytes], out, hashbytes);\n\t\t\tbreak;\n\t\t} default: not_reached();\n\t\t}\n\t}\n\n\t/* Hash the result array. */\n\tswitch (variant) {\n\tcase hash_variant_x86_32: {\n\t\tuint32_t out = hash_x86_32(hashes, hashes_size, 0);\n\t\tmemcpy(final, &out, sizeof(out));\n\t\tbreak;\n\t} case hash_variant_x86_128: {\n\t\tuint64_t out[2];\n\t\thash_x86_128(hashes, hashes_size, 0, out);\n\t\tmemcpy(final, out, sizeof(out));\n\t\tbreak;\n\t} case hash_variant_x64_128: {\n\t\tuint64_t out[2];\n\t\thash_x64_128(hashes, hashes_size, 0, out);\n\t\tmemcpy(final, out, sizeof(out));\n\t\tbreak;\n\t} default: not_reached();\n\t}\n\n\tcomputed = (final[0] << 0) | (final[1] << 8) | (final[2] << 16) |\n\t (final[3] << 24);\n\n\tswitch (variant) {\n#ifdef JEMALLOC_BIG_ENDIAN\n\tcase hash_variant_x86_32: expected = 0x6213303eU; break;\n\tcase hash_variant_x86_128: expected = 0x266820caU; break;\n\tcase hash_variant_x64_128: expected = 0xcc622b6fU; break;\n#else\n\tcase hash_variant_x86_32: expected = 0xb0f57ee3U; break;\n\tcase hash_variant_x86_128: expected = 0xb3ece62aU; break;\n\tcase hash_variant_x64_128: expected = 0x6384ba69U; break;\n#endif\n\tdefault: not_reached();\n\t}\n\n\texpect_u32_eq(computed, expected,\n\t \"Hash mismatch for %s(): expected %#x but got %#x\",\n\t hash_variant_string(variant), expected, computed);\n}\n\nstatic void\nhash_variant_verify(hash_variant_t variant) {\n#define MAX_ALIGN\t16\n\tuint8_t key[KEY_SIZE + (MAX_ALIGN - 1)];\n\tunsigned i;\n\n\tfor (i = 0; i < MAX_ALIGN; i++) {\n\t\thash_variant_verify_key(variant, &key[i]);\n\t}\n#undef MAX_ALIGN\n}\n#undef KEY_SIZE\n\nTEST_BEGIN(test_hash_x86_32) {\n\thash_variant_verify(hash_variant_x86_32);\n}\nTEST_END\n\nTEST_BEGIN(test_hash_x86_128) {\n\thash_variant_verify(hash_variant_x86_128);\n}\nTEST_END\n\nTEST_BEGIN(test_hash_x64_128) {\n\thash_variant_verify(hash_variant_x64_128);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_hash_x86_32,\n\t test_hash_x86_128,\n\t test_hash_x64_128);\n}\n" }, { "path": "deps/jemalloc/test/unit/hook.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/hook.h\"\n\nstatic void *arg_extra;\nstatic int arg_type;\nstatic void *arg_result;\nstatic void *arg_address;\nstatic size_t arg_old_usize;\nstatic size_t arg_new_usize;\nstatic uintptr_t arg_result_raw;\nstatic uintptr_t arg_args_raw[4];\n\nstatic int call_count = 0;\n\nstatic void\nreset_args() {\n\targ_extra = NULL;\n\targ_type = 12345;\n\targ_result = NULL;\n\targ_address = NULL;\n\targ_old_usize = 0;\n\targ_new_usize = 0;\n\targ_result_raw = 0;\n\tmemset(arg_args_raw, 77, sizeof(arg_args_raw));\n}\n\nstatic void\nalloc_free_size(size_t sz) {\n\tvoid *ptr = mallocx(1, 0);\n\tfree(ptr);\n\tptr = mallocx(1, 0);\n\tfree(ptr);\n\tptr = mallocx(1, MALLOCX_TCACHE_NONE);\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n}\n\n/*\n * We want to support a degree of user reentrancy. This tests a variety of\n * allocation scenarios.\n */\nstatic void\nbe_reentrant() {\n\t/* Let's make sure the tcache is non-empty if enabled. */\n\talloc_free_size(1);\n\talloc_free_size(1024);\n\talloc_free_size(64 * 1024);\n\talloc_free_size(256 * 1024);\n\talloc_free_size(1024 * 1024);\n\n\t/* Some reallocation. */\n\tvoid *ptr = mallocx(129, 0);\n\tptr = rallocx(ptr, 130, 0);\n\tfree(ptr);\n\n\tptr = mallocx(2 * 1024 * 1024, 0);\n\tfree(ptr);\n\tptr = mallocx(1 * 1024 * 1024, 0);\n\tptr = rallocx(ptr, 2 * 1024 * 1024, 0);\n\tfree(ptr);\n\n\tptr = mallocx(1, 0);\n\tptr = rallocx(ptr, 1000, 0);\n\tfree(ptr);\n}\n\nstatic void\nset_args_raw(uintptr_t *args_raw, int nargs) {\n\tmemcpy(arg_args_raw, args_raw, sizeof(uintptr_t) * nargs);\n}\n\nstatic void\nexpect_args_raw(uintptr_t *args_raw_expected, int nargs) {\n\tint cmp = memcmp(args_raw_expected, arg_args_raw,\n\t sizeof(uintptr_t) * nargs);\n\texpect_d_eq(cmp, 0, \"Raw args mismatch\");\n}\n\nstatic void\nreset() {\n\tcall_count = 0;\n\treset_args();\n}\n\nstatic void\ntest_alloc_hook(void *extra, hook_alloc_t type, void *result,\n uintptr_t result_raw, uintptr_t args_raw[3]) {\n\tcall_count++;\n\targ_extra = extra;\n\targ_type = (int)type;\n\targ_result = result;\n\targ_result_raw = result_raw;\n\tset_args_raw(args_raw, 3);\n\tbe_reentrant();\n}\n\nstatic void\ntest_dalloc_hook(void *extra, hook_dalloc_t type, void *address,\n uintptr_t args_raw[3]) {\n\tcall_count++;\n\targ_extra = extra;\n\targ_type = (int)type;\n\targ_address = address;\n\tset_args_raw(args_raw, 3);\n\tbe_reentrant();\n}\n\nstatic void\ntest_expand_hook(void *extra, hook_expand_t type, void *address,\n size_t old_usize, size_t new_usize, uintptr_t result_raw,\n uintptr_t args_raw[4]) {\n\tcall_count++;\n\targ_extra = extra;\n\targ_type = (int)type;\n\targ_address = address;\n\targ_old_usize = old_usize;\n\targ_new_usize = new_usize;\n\targ_result_raw = result_raw;\n\tset_args_raw(args_raw, 4);\n\tbe_reentrant();\n}\n\nTEST_BEGIN(test_hooks_basic) {\n\t/* Just verify that the record their arguments correctly. */\n\thooks_t hooks = {\n\t\t&test_alloc_hook, &test_dalloc_hook, &test_expand_hook,\n\t\t(void *)111};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\tuintptr_t args_raw[4] = {10, 20, 30, 40};\n\n\t/* Alloc */\n\treset_args();\n\thook_invoke_alloc(hook_alloc_posix_memalign, (void *)222, 333,\n\t args_raw);\n\texpect_ptr_eq(arg_extra, (void *)111, \"Passed wrong user pointer\");\n\texpect_d_eq((int)hook_alloc_posix_memalign, arg_type,\n\t \"Passed wrong alloc type\");\n\texpect_ptr_eq((void *)222, arg_result, \"Passed wrong result address\");\n\texpect_u64_eq(333, arg_result_raw, \"Passed wrong result\");\n\texpect_args_raw(args_raw, 3);\n\n\t/* Dalloc */\n\treset_args();\n\thook_invoke_dalloc(hook_dalloc_sdallocx, (void *)222, args_raw);\n\texpect_d_eq((int)hook_dalloc_sdallocx, arg_type,\n\t \"Passed wrong dalloc type\");\n\texpect_ptr_eq((void *)111, arg_extra, \"Passed wrong user pointer\");\n\texpect_ptr_eq((void *)222, arg_address, \"Passed wrong address\");\n\texpect_args_raw(args_raw, 3);\n\n\t/* Expand */\n\treset_args();\n\thook_invoke_expand(hook_expand_xallocx, (void *)222, 333, 444, 555,\n\t args_raw);\n\texpect_d_eq((int)hook_expand_xallocx, arg_type,\n\t \"Passed wrong expand type\");\n\texpect_ptr_eq((void *)111, arg_extra, \"Passed wrong user pointer\");\n\texpect_ptr_eq((void *)222, arg_address, \"Passed wrong address\");\n\texpect_zu_eq(333, arg_old_usize, \"Passed wrong old usize\");\n\texpect_zu_eq(444, arg_new_usize, \"Passed wrong new usize\");\n\texpect_zu_eq(555, arg_result_raw, \"Passed wrong result\");\n\texpect_args_raw(args_raw, 4);\n\n\thook_remove(TSDN_NULL, handle);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_null) {\n\t/* Null hooks should be ignored, not crash. */\n\thooks_t hooks1 = {NULL, NULL, NULL, NULL};\n\thooks_t hooks2 = {&test_alloc_hook, NULL, NULL, NULL};\n\thooks_t hooks3 = {NULL, &test_dalloc_hook, NULL, NULL};\n\thooks_t hooks4 = {NULL, NULL, &test_expand_hook, NULL};\n\n\tvoid *handle1 = hook_install(TSDN_NULL, &hooks1);\n\tvoid *handle2 = hook_install(TSDN_NULL, &hooks2);\n\tvoid *handle3 = hook_install(TSDN_NULL, &hooks3);\n\tvoid *handle4 = hook_install(TSDN_NULL, &hooks4);\n\n\texpect_ptr_ne(handle1, NULL, \"Hook installation failed\");\n\texpect_ptr_ne(handle2, NULL, \"Hook installation failed\");\n\texpect_ptr_ne(handle3, NULL, \"Hook installation failed\");\n\texpect_ptr_ne(handle4, NULL, \"Hook installation failed\");\n\n\tuintptr_t args_raw[4] = {10, 20, 30, 40};\n\n\tcall_count = 0;\n\thook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);\n\texpect_d_eq(call_count, 1, \"Called wrong number of times\");\n\n\tcall_count = 0;\n\thook_invoke_dalloc(hook_dalloc_free, NULL, args_raw);\n\texpect_d_eq(call_count, 1, \"Called wrong number of times\");\n\n\tcall_count = 0;\n\thook_invoke_expand(hook_expand_realloc, NULL, 0, 0, 0, args_raw);\n\texpect_d_eq(call_count, 1, \"Called wrong number of times\");\n\n\thook_remove(TSDN_NULL, handle1);\n\thook_remove(TSDN_NULL, handle2);\n\thook_remove(TSDN_NULL, handle3);\n\thook_remove(TSDN_NULL, handle4);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_remove) {\n\thooks_t hooks = {&test_alloc_hook, NULL, NULL, NULL};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\tcall_count = 0;\n\tuintptr_t args_raw[4] = {10, 20, 30, 40};\n\thook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);\n\texpect_d_eq(call_count, 1, \"Hook not invoked\");\n\n\tcall_count = 0;\n\thook_remove(TSDN_NULL, handle);\n\thook_invoke_alloc(hook_alloc_malloc, NULL, 0, NULL);\n\texpect_d_eq(call_count, 0, \"Hook invoked after removal\");\n\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_alloc_simple) {\n\t/* \"Simple\" in the sense that we're not in a realloc variant. */\n\thooks_t hooks = {&test_alloc_hook, NULL, NULL, (void *)123};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\n\t/* Stop malloc from being optimized away. */\n\tvolatile int err;\n\tvoid *volatile ptr;\n\n\t/* malloc */\n\treset();\n\tptr = malloc(1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_malloc, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[0], \"Wrong argument\");\n\tfree(ptr);\n\n\t/* posix_memalign */\n\treset();\n\terr = posix_memalign((void **)&ptr, 1024, 1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_posix_memalign,\n\t \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)err, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)&ptr, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)1024, arg_args_raw[1], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[2], \"Wrong argument\");\n\tfree(ptr);\n\n\t/* aligned_alloc */\n\treset();\n\tptr = aligned_alloc(1024, 1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_aligned_alloc,\n\t \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)1024, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n\n\t/* calloc */\n\treset();\n\tptr = calloc(11, 13);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_calloc, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)11, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)13, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n\n\t/* memalign */\n#ifdef JEMALLOC_OVERRIDE_MEMALIGN\n\treset();\n\tptr = memalign(1024, 1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_memalign, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)1024, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n#endif /* JEMALLOC_OVERRIDE_MEMALIGN */\n\n\t/* valloc */\n#ifdef JEMALLOC_OVERRIDE_VALLOC\n\treset();\n\tptr = valloc(1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_valloc, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[0], \"Wrong argument\");\n\tfree(ptr);\n#endif /* JEMALLOC_OVERRIDE_VALLOC */\n\n\t/* mallocx */\n\treset();\n\tptr = mallocx(1, MALLOCX_LG_ALIGN(10));\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_mallocx, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)MALLOCX_LG_ALIGN(10), arg_args_raw[1],\n\t \"Wrong flags\");\n\tfree(ptr);\n\n\thook_remove(TSDN_NULL, handle);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_dalloc_simple) {\n\t/* \"Simple\" in the sense that we're not in a realloc variant. */\n\thooks_t hooks = {NULL, &test_dalloc_hook, NULL, (void *)123};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\n\tvoid *volatile ptr;\n\n\t/* free() */\n\treset();\n\tptr = malloc(1);\n\tfree(ptr);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_dalloc_free, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong pointer freed\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong raw arg\");\n\n\t/* dallocx() */\n\treset();\n\tptr = malloc(1);\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_dalloc_dallocx, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong pointer freed\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong raw arg\");\n\texpect_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[1],\n\t \"Wrong raw arg\");\n\n\t/* sdallocx() */\n\treset();\n\tptr = malloc(1);\n\tsdallocx(ptr, 1, MALLOCX_TCACHE_NONE);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_dalloc_sdallocx, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong pointer freed\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong raw arg\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[1], \"Wrong raw arg\");\n\texpect_u64_eq((uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[2],\n\t \"Wrong raw arg\");\n\n\thook_remove(TSDN_NULL, handle);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_expand_simple) {\n\t/* \"Simple\" in the sense that we're not in a realloc variant. */\n\thooks_t hooks = {NULL, NULL, &test_expand_hook, (void *)123};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\n\tvoid *volatile ptr;\n\n\t/* xallocx() */\n\treset();\n\tptr = malloc(1);\n\tsize_t new_usize = xallocx(ptr, 100, 200, MALLOCX_TCACHE_NONE);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_expand_xallocx, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong pointer expanded\");\n\texpect_u64_eq(arg_old_usize, nallocx(1, 0), \"Wrong old usize\");\n\texpect_u64_eq(arg_new_usize, sallocx(ptr, 0), \"Wrong new usize\");\n\texpect_u64_eq(new_usize, arg_result_raw, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong arg\");\n\texpect_u64_eq(100, arg_args_raw[1], \"Wrong arg\");\n\texpect_u64_eq(200, arg_args_raw[2], \"Wrong arg\");\n\texpect_u64_eq(MALLOCX_TCACHE_NONE, arg_args_raw[3], \"Wrong arg\");\n\n\thook_remove(TSDN_NULL, handle);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_realloc_as_malloc_or_free) {\n\thooks_t hooks = {&test_alloc_hook, &test_dalloc_hook,\n\t\t&test_expand_hook, (void *)123};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\n\tvoid *volatile ptr;\n\n\t/* realloc(NULL, size) as malloc */\n\treset();\n\tptr = realloc(NULL, 1);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_realloc, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)NULL, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)1, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n\n\t/* realloc(ptr, 0) as free */\n\tif (opt_zero_realloc_action == zero_realloc_action_free) {\n\t\tptr = malloc(1);\n\t\treset();\n\t\trealloc(ptr, 0);\n\t\texpect_d_eq(call_count, 1, \"Hook not called\");\n\t\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\t\texpect_d_eq(arg_type, (int)hook_dalloc_realloc,\n\t\t \"Wrong hook type\");\n\t\texpect_ptr_eq(ptr, arg_address,\n\t\t \"Wrong pointer freed\");\n\t\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0],\n\t\t \"Wrong raw arg\");\n\t\texpect_u64_eq((uintptr_t)0, arg_args_raw[1],\n\t\t \"Wrong raw arg\");\n\t}\n\n\t/* realloc(NULL, 0) as malloc(0) */\n\treset();\n\tptr = realloc(NULL, 0);\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, (int)hook_alloc_realloc, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_result, \"Wrong result\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)NULL, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)0, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n\n\thook_remove(TSDN_NULL, handle);\n}\nTEST_END\n\nstatic void\ndo_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,\n int expand_type, int dalloc_type) {\n\thooks_t hooks = {&test_alloc_hook, &test_dalloc_hook,\n\t\t&test_expand_hook, (void *)123};\n\tvoid *handle = hook_install(TSDN_NULL, &hooks);\n\texpect_ptr_ne(handle, NULL, \"Hook installation failed\");\n\n\tvoid *volatile ptr;\n\tvoid *volatile ptr2;\n\n\t/* Realloc in-place, small. */\n\tptr = malloc(129);\n\treset();\n\tptr2 = ralloc(ptr, 130, flags);\n\texpect_ptr_eq(ptr, ptr2, \"Small realloc moved\");\n\n\texpect_d_eq(call_count, 1, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, expand_type, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong address\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)130, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr);\n\n\t/*\n\t * Realloc in-place, large. Since we can't guarantee the large case\n\t * across all platforms, we stay resilient to moving results.\n\t */\n\tptr = malloc(2 * 1024 * 1024);\n\tfree(ptr);\n\tptr2 = malloc(1 * 1024 * 1024);\n\treset();\n\tptr = ralloc(ptr2, 2 * 1024 * 1024, flags);\n\t/* ptr is the new address, ptr2 is the old address. */\n\tif (ptr == ptr2) {\n\t\texpect_d_eq(call_count, 1, \"Hook not called\");\n\t\texpect_d_eq(arg_type, expand_type, \"Wrong hook type\");\n\t} else {\n\t\texpect_d_eq(call_count, 2, \"Wrong hooks called\");\n\t\texpect_ptr_eq(ptr, arg_result, \"Wrong address\");\n\t\texpect_d_eq(arg_type, dalloc_type, \"Wrong hook type\");\n\t}\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_ptr_eq(ptr2, arg_address, \"Wrong address\");\n\texpect_u64_eq((uintptr_t)ptr, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)ptr2, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],\n\t \"Wrong argument\");\n\tfree(ptr);\n\n\t/* Realloc with move, small. */\n\tptr = malloc(8);\n\treset();\n\tptr2 = ralloc(ptr, 128, flags);\n\texpect_ptr_ne(ptr, ptr2, \"Small realloc didn't move\");\n\n\texpect_d_eq(call_count, 2, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, dalloc_type, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong address\");\n\texpect_ptr_eq(ptr2, arg_result, \"Wrong address\");\n\texpect_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)128, arg_args_raw[1], \"Wrong argument\");\n\tfree(ptr2);\n\n\t/* Realloc with move, large. */\n\tptr = malloc(1);\n\treset();\n\tptr2 = ralloc(ptr, 2 * 1024 * 1024, flags);\n\texpect_ptr_ne(ptr, ptr2, \"Large realloc didn't move\");\n\n\texpect_d_eq(call_count, 2, \"Hook not called\");\n\texpect_ptr_eq(arg_extra, (void *)123, \"Wrong extra\");\n\texpect_d_eq(arg_type, dalloc_type, \"Wrong hook type\");\n\texpect_ptr_eq(ptr, arg_address, \"Wrong address\");\n\texpect_ptr_eq(ptr2, arg_result, \"Wrong address\");\n\texpect_u64_eq((uintptr_t)ptr2, (uintptr_t)arg_result_raw,\n\t \"Wrong raw result\");\n\texpect_u64_eq((uintptr_t)ptr, arg_args_raw[0], \"Wrong argument\");\n\texpect_u64_eq((uintptr_t)2 * 1024 * 1024, arg_args_raw[1],\n\t \"Wrong argument\");\n\tfree(ptr2);\n\n\thook_remove(TSDN_NULL, handle);\n}\n\nstatic void *\nrealloc_wrapper(void *ptr, size_t size, UNUSED int flags) {\n\treturn realloc(ptr, size);\n}\n\nTEST_BEGIN(test_hooks_realloc) {\n\tdo_realloc_test(&realloc_wrapper, 0, hook_expand_realloc,\n\t hook_dalloc_realloc);\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_rallocx) {\n\tdo_realloc_test(&rallocx, MALLOCX_TCACHE_NONE, hook_expand_rallocx,\n\t hook_dalloc_rallocx);\n}\nTEST_END\n\nint\nmain(void) {\n\t/* We assert on call counts. */\n\treturn test_no_reentrancy(\n\t test_hooks_basic,\n\t test_hooks_null,\n\t test_hooks_remove,\n\t test_hooks_alloc_simple,\n\t test_hooks_dalloc_simple,\n\t test_hooks_expand_simple,\n\t test_hooks_realloc_as_malloc_or_free,\n\t test_hooks_realloc,\n\t test_hooks_rallocx);\n}\n" }, { "path": "deps/jemalloc/test/unit/hpa.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/hpa.h\"\n#include \"jemalloc/internal/nstime.h\"\n\n#define SHARD_IND 111\n\n#define ALLOC_MAX (HUGEPAGE / 4)\n\ntypedef struct test_data_s test_data_t;\nstruct test_data_s {\n\t/*\n\t * Must be the first member -- we convert back and forth between the\n\t * test_data_t and the hpa_shard_t;\n\t */\n\thpa_shard_t shard;\n\thpa_central_t central;\n\tbase_t *base;\n\tedata_cache_t shard_edata_cache;\n\n\temap_t emap;\n};\n\nstatic hpa_shard_opts_t test_hpa_shard_opts_default = {\n\t/* slab_max_alloc */\n\tALLOC_MAX,\n\t/* hugification threshold */\n\tHUGEPAGE,\n\t/* dirty_mult */\n\tFXP_INIT_PERCENT(25),\n\t/* deferral_allowed */\n\tfalse,\n\t/* hugify_delay_ms */\n\t10 * 1000,\n};\n\nstatic hpa_shard_t *\ncreate_test_data(hpa_hooks_t *hooks, hpa_shard_opts_t *opts) {\n\tbool err;\n\tbase_t *base = base_new(TSDN_NULL, /* ind */ SHARD_IND,\n\t &ehooks_default_extent_hooks, /* metadata_use_hooks */ true);\n\tassert_ptr_not_null(base, \"\");\n\n\ttest_data_t *test_data = malloc(sizeof(test_data_t));\n\tassert_ptr_not_null(test_data, \"\");\n\n\ttest_data->base = base;\n\n\terr = edata_cache_init(&test_data->shard_edata_cache, base);\n\tassert_false(err, \"\");\n\n\terr = emap_init(&test_data->emap, test_data->base, /* zeroed */ false);\n\tassert_false(err, \"\");\n\n\terr = hpa_central_init(&test_data->central, test_data->base, hooks);\n\tassert_false(err, \"\");\n\n\terr = hpa_shard_init(&test_data->shard, &test_data->central,\n\t &test_data->emap, test_data->base, &test_data->shard_edata_cache,\n\t SHARD_IND, opts);\n\tassert_false(err, \"\");\n\n\treturn (hpa_shard_t *)test_data;\n}\n\nstatic void\ndestroy_test_data(hpa_shard_t *shard) {\n\ttest_data_t *test_data = (test_data_t *)shard;\n\tbase_delete(TSDN_NULL, test_data->base);\n\tfree(test_data);\n}\n\nTEST_BEGIN(test_alloc_max) {\n\ttest_skip_if(!hpa_supported());\n\n\thpa_shard_t *shard = create_test_data(&hpa_hooks_default,\n\t &test_hpa_shard_opts_default);\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\n\tedata_t *edata;\n\n\t/* Small max */\n\tbool deferred_work_generated = false;\n\tedata = pai_alloc(tsdn, &shard->pai, ALLOC_MAX, PAGE, false, false,\n\t false, &deferred_work_generated);\n\texpect_ptr_not_null(edata, \"Allocation of small max failed\");\n\tedata = pai_alloc(tsdn, &shard->pai, ALLOC_MAX + PAGE, PAGE, false,\n\t false, false, &deferred_work_generated);\n\texpect_ptr_null(edata, \"Allocation of larger than small max succeeded\");\n\n\tdestroy_test_data(shard);\n}\nTEST_END\n\ntypedef struct mem_contents_s mem_contents_t;\nstruct mem_contents_s {\n\tuintptr_t my_addr;\n\tsize_t size;\n\tedata_t *my_edata;\n\trb_node(mem_contents_t) link;\n};\n\nstatic int\nmem_contents_cmp(const mem_contents_t *a, const mem_contents_t *b) {\n\treturn (a->my_addr > b->my_addr) - (a->my_addr < b->my_addr);\n}\n\ntypedef rb_tree(mem_contents_t) mem_tree_t;\nrb_gen(static, mem_tree_, mem_tree_t, mem_contents_t, link,\n mem_contents_cmp);\n\nstatic void\nnode_assert_ordered(mem_contents_t *a, mem_contents_t *b) {\n\tassert_zu_lt(a->my_addr, a->my_addr + a->size, \"Overflow\");\n\tassert_zu_le(a->my_addr + a->size, b->my_addr, \"\");\n}\n\nstatic void\nnode_check(mem_tree_t *tree, mem_contents_t *contents) {\n\tedata_t *edata = contents->my_edata;\n\tassert_ptr_eq(contents, (void *)contents->my_addr, \"\");\n\tassert_ptr_eq(contents, edata_base_get(edata), \"\");\n\tassert_zu_eq(contents->size, edata_size_get(edata), \"\");\n\tassert_ptr_eq(contents->my_edata, edata, \"\");\n\n\tmem_contents_t *next = mem_tree_next(tree, contents);\n\tif (next != NULL) {\n\t\tnode_assert_ordered(contents, next);\n\t}\n\tmem_contents_t *prev = mem_tree_prev(tree, contents);\n\tif (prev != NULL) {\n\t\tnode_assert_ordered(prev, contents);\n\t}\n}\n\nstatic void\nnode_insert(mem_tree_t *tree, edata_t *edata, size_t npages) {\n\tmem_contents_t *contents = (mem_contents_t *)edata_base_get(edata);\n\tcontents->my_addr = (uintptr_t)edata_base_get(edata);\n\tcontents->size = edata_size_get(edata);\n\tcontents->my_edata = edata;\n\tmem_tree_insert(tree, contents);\n\tnode_check(tree, contents);\n}\n\nstatic void\nnode_remove(mem_tree_t *tree, edata_t *edata) {\n\tmem_contents_t *contents = (mem_contents_t *)edata_base_get(edata);\n\tnode_check(tree, contents);\n\tmem_tree_remove(tree, contents);\n}\n\nTEST_BEGIN(test_stress) {\n\ttest_skip_if(!hpa_supported());\n\n\thpa_shard_t *shard = create_test_data(&hpa_hooks_default,\n\t &test_hpa_shard_opts_default);\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\n\tconst size_t nlive_edatas_max = 500;\n\tsize_t nlive_edatas = 0;\n\tedata_t **live_edatas = calloc(nlive_edatas_max, sizeof(edata_t *));\n\t/*\n\t * Nothing special about this constant; we're only fixing it for\n\t * consistency across runs.\n\t */\n\tsize_t prng_state = (size_t)0x76999ffb014df07c;\n\n\tmem_tree_t tree;\n\tmem_tree_new(&tree);\n\n\tbool deferred_work_generated = false;\n\n\tfor (size_t i = 0; i < 100 * 1000; i++) {\n\t\tsize_t operation = prng_range_zu(&prng_state, 2);\n\t\tif (operation == 0) {\n\t\t\t/* Alloc */\n\t\t\tif (nlive_edatas == nlive_edatas_max) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t/*\n\t\t\t * We make sure to get an even balance of small and\n\t\t\t * large allocations.\n\t\t\t */\n\t\t\tsize_t npages_min = 1;\n\t\t\tsize_t npages_max = ALLOC_MAX / PAGE;\n\t\t\tsize_t npages = npages_min + prng_range_zu(&prng_state,\n\t\t\t npages_max - npages_min);\n\t\t\tedata_t *edata = pai_alloc(tsdn, &shard->pai,\n\t\t\t npages * PAGE, PAGE, false, false, false,\n\t\t\t &deferred_work_generated);\n\t\t\tassert_ptr_not_null(edata,\n\t\t\t \"Unexpected allocation failure\");\n\t\t\tlive_edatas[nlive_edatas] = edata;\n\t\t\tnlive_edatas++;\n\t\t\tnode_insert(&tree, edata, npages);\n\t\t} else {\n\t\t\t/* Free. */\n\t\t\tif (nlive_edatas == 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tsize_t victim = prng_range_zu(&prng_state, nlive_edatas);\n\t\t\tedata_t *to_free = live_edatas[victim];\n\t\t\tlive_edatas[victim] = live_edatas[nlive_edatas - 1];\n\t\t\tnlive_edatas--;\n\t\t\tnode_remove(&tree, to_free);\n\t\t\tpai_dalloc(tsdn, &shard->pai, to_free,\n\t\t\t &deferred_work_generated);\n\t\t}\n\t}\n\n\tsize_t ntreenodes = 0;\n\tfor (mem_contents_t *contents = mem_tree_first(&tree); contents != NULL;\n\t contents = mem_tree_next(&tree, contents)) {\n\t\tntreenodes++;\n\t\tnode_check(&tree, contents);\n\t}\n\texpect_zu_eq(ntreenodes, nlive_edatas, \"\");\n\n\t/*\n\t * Test hpa_shard_destroy, which requires as a precondition that all its\n\t * extents have been deallocated.\n\t */\n\tfor (size_t i = 0; i < nlive_edatas; i++) {\n\t\tedata_t *to_free = live_edatas[i];\n\t\tnode_remove(&tree, to_free);\n\t\tpai_dalloc(tsdn, &shard->pai, to_free,\n\t\t &deferred_work_generated);\n\t}\n\thpa_shard_destroy(tsdn, shard);\n\n\tfree(live_edatas);\n\tdestroy_test_data(shard);\n}\nTEST_END\n\nstatic void\nexpect_contiguous(edata_t **edatas, size_t nedatas) {\n\tfor (size_t i = 0; i < nedatas; i++) {\n\t\tsize_t expected = (size_t)edata_base_get(edatas[0])\n\t\t + i * PAGE;\n\t\texpect_zu_eq(expected, (size_t)edata_base_get(edatas[i]),\n\t\t \"Mismatch at index %zu\", i);\n\t}\n}\n\nTEST_BEGIN(test_alloc_dalloc_batch) {\n\ttest_skip_if(!hpa_supported());\n\n\thpa_shard_t *shard = create_test_data(&hpa_hooks_default,\n\t &test_hpa_shard_opts_default);\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\n\tbool deferred_work_generated = false;\n\n\tenum {NALLOCS = 8};\n\n\tedata_t *allocs[NALLOCS];\n\t/*\n\t * Allocate a mix of ways; first half from regular alloc, second half\n\t * from alloc_batch.\n\t */\n\tfor (size_t i = 0; i < NALLOCS / 2; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &shard->pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false,\n\t\t /* frequent_reuse */ false, &deferred_work_generated);\n\t\texpect_ptr_not_null(allocs[i], \"Unexpected alloc failure\");\n\t}\n\tedata_list_active_t allocs_list;\n\tedata_list_active_init(&allocs_list);\n\tsize_t nsuccess = pai_alloc_batch(tsdn, &shard->pai, PAGE, NALLOCS / 2,\n\t &allocs_list, &deferred_work_generated);\n\texpect_zu_eq(NALLOCS / 2, nsuccess, \"Unexpected oom\");\n\tfor (size_t i = NALLOCS / 2; i < NALLOCS; i++) {\n\t\tallocs[i] = edata_list_active_first(&allocs_list);\n\t\tedata_list_active_remove(&allocs_list, allocs[i]);\n\t}\n\n\t/*\n\t * Should have allocated them contiguously, despite the differing\n\t * methods used.\n\t */\n\tvoid *orig_base = edata_base_get(allocs[0]);\n\texpect_contiguous(allocs, NALLOCS);\n\n\t/*\n\t * Batch dalloc the first half, individually deallocate the second half.\n\t */\n\tfor (size_t i = 0; i < NALLOCS / 2; i++) {\n\t\tedata_list_active_append(&allocs_list, allocs[i]);\n\t}\n\tpai_dalloc_batch(tsdn, &shard->pai, &allocs_list,\n\t &deferred_work_generated);\n\tfor (size_t i = NALLOCS / 2; i < NALLOCS; i++) {\n\t\tpai_dalloc(tsdn, &shard->pai, allocs[i],\n\t\t &deferred_work_generated);\n\t}\n\n\t/* Reallocate (individually), and ensure reuse and contiguity. */\n\tfor (size_t i = 0; i < NALLOCS; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &shard->pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_not_null(allocs[i], \"Unexpected alloc failure.\");\n\t}\n\tvoid *new_base = edata_base_get(allocs[0]);\n\texpect_ptr_eq(orig_base, new_base,\n\t \"Failed to reuse the allocated memory.\");\n\texpect_contiguous(allocs, NALLOCS);\n\n\tdestroy_test_data(shard);\n}\nTEST_END\n\nstatic uintptr_t defer_bump_ptr = HUGEPAGE * 123;\nstatic void *\ndefer_test_map(size_t size) {\n\tvoid *result = (void *)defer_bump_ptr;\n\tdefer_bump_ptr += size;\n\treturn result;\n}\n\nstatic void\ndefer_test_unmap(void *ptr, size_t size) {\n\t(void)ptr;\n\t(void)size;\n}\n\nstatic bool defer_purge_called = false;\nstatic void\ndefer_test_purge(void *ptr, size_t size) {\n\t(void)ptr;\n\t(void)size;\n\tdefer_purge_called = true;\n}\n\nstatic bool defer_hugify_called = false;\nstatic void\ndefer_test_hugify(void *ptr, size_t size) {\n\tdefer_hugify_called = true;\n}\n\nstatic bool defer_dehugify_called = false;\nstatic void\ndefer_test_dehugify(void *ptr, size_t size) {\n\tdefer_dehugify_called = true;\n}\n\nstatic nstime_t defer_curtime;\nstatic void\ndefer_test_curtime(nstime_t *r_time, bool first_reading) {\n\t*r_time = defer_curtime;\n}\n\nstatic uint64_t\ndefer_test_ms_since(nstime_t *past_time) {\n\treturn (nstime_ns(&defer_curtime) - nstime_ns(past_time)) / 1000 / 1000;\n}\n\nTEST_BEGIN(test_defer_time) {\n\ttest_skip_if(!hpa_supported());\n\n\thpa_hooks_t hooks;\n\thooks.map = &defer_test_map;\n\thooks.unmap = &defer_test_unmap;\n\thooks.purge = &defer_test_purge;\n\thooks.hugify = &defer_test_hugify;\n\thooks.dehugify = &defer_test_dehugify;\n\thooks.curtime = &defer_test_curtime;\n\thooks.ms_since = &defer_test_ms_since;\n\n\thpa_shard_opts_t opts = test_hpa_shard_opts_default;\n\topts.deferral_allowed = true;\n\n\thpa_shard_t *shard = create_test_data(&hooks, &opts);\n\n\tbool deferred_work_generated = false;\n\n\tnstime_init(&defer_curtime, 0);\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tedata_t *edatas[HUGEPAGE_PAGES];\n\tfor (int i = 0; i < (int)HUGEPAGE_PAGES; i++) {\n\t\tedatas[i] = pai_alloc(tsdn, &shard->pai, PAGE, PAGE, false,\n\t\t false, false, &deferred_work_generated);\n\t\texpect_ptr_not_null(edatas[i], \"Unexpected null edata\");\n\t}\n\thpa_shard_do_deferred_work(tsdn, shard);\n\texpect_false(defer_hugify_called, \"Hugified too early\");\n\n\t/* Hugification delay is set to 10 seconds in options. */\n\tnstime_init2(&defer_curtime, 11, 0);\n\thpa_shard_do_deferred_work(tsdn, shard);\n\texpect_true(defer_hugify_called, \"Failed to hugify\");\n\n\tdefer_hugify_called = false;\n\n\t/* Purge. Recall that dirty_mult is .25. */\n\tfor (int i = 0; i < (int)HUGEPAGE_PAGES / 2; i++) {\n\t\tpai_dalloc(tsdn, &shard->pai, edatas[i],\n\t\t &deferred_work_generated);\n\t}\n\n\thpa_shard_do_deferred_work(tsdn, shard);\n\n\texpect_false(defer_hugify_called, \"Hugified too early\");\n\texpect_true(defer_dehugify_called, \"Should have dehugified\");\n\texpect_true(defer_purge_called, \"Should have purged\");\n\tdefer_hugify_called = false;\n\tdefer_dehugify_called = false;\n\tdefer_purge_called = false;\n\n\t/*\n\t * Refill the page. We now meet the hugification threshold; we should\n\t * be marked for pending hugify.\n\t */\n\tfor (int i = 0; i < (int)HUGEPAGE_PAGES / 2; i++) {\n\t\tedatas[i] = pai_alloc(tsdn, &shard->pai, PAGE, PAGE, false,\n\t\t false, false, &deferred_work_generated);\n\t\texpect_ptr_not_null(edatas[i], \"Unexpected null edata\");\n\t}\n\t/*\n\t * We would be ineligible for hugification, had we not already met the\n\t * threshold before dipping below it.\n\t */\n\tpai_dalloc(tsdn, &shard->pai, edatas[0],\n\t &deferred_work_generated);\n\t/* Wait for the threshold again. */\n\tnstime_init2(&defer_curtime, 22, 0);\n\thpa_shard_do_deferred_work(tsdn, shard);\n\texpect_true(defer_hugify_called, \"Hugified too early\");\n\texpect_false(defer_dehugify_called, \"Unexpected dehugify\");\n\texpect_false(defer_purge_called, \"Unexpected purge\");\n\n\tdestroy_test_data(shard);\n}\nTEST_END\n\nint\nmain(void) {\n\t/*\n\t * These trigger unused-function warnings on CI runs, even if declared\n\t * with static inline.\n\t */\n\t(void)mem_tree_empty;\n\t(void)mem_tree_last;\n\t(void)mem_tree_search;\n\t(void)mem_tree_nsearch;\n\t(void)mem_tree_psearch;\n\t(void)mem_tree_iter;\n\t(void)mem_tree_reverse_iter;\n\t(void)mem_tree_destroy;\n\treturn test_no_reentrancy(\n\t test_alloc_max,\n\t test_stress,\n\t test_alloc_dalloc_batch,\n\t test_defer_time);\n}\n" }, { "path": "deps/jemalloc/test/unit/hpa_background_thread.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/sleep.h\"\n\nstatic void\nsleep_for_background_thread_interval() {\n\t/*\n\t * The sleep interval set in our .sh file is 50ms. So it likely will\n\t * run if we sleep for four times that.\n\t */\n\tsleep_ns(200 * 1000 * 1000);\n}\n\nstatic unsigned\ncreate_arena() {\n\tunsigned arena_ind;\n\tsize_t sz;\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 2),\n\t 0, \"Unexpected mallctl() failure\");\n\treturn arena_ind;\n}\n\nstatic size_t\nget_empty_ndirty(unsigned arena_ind) {\n\tint err;\n\tsize_t ndirty_huge;\n\tsize_t ndirty_nonhuge;\n\tuint64_t epoch = 1;\n\tsize_t sz = sizeof(epoch);\n\terr = je_mallctl(\"epoch\", (void *)&epoch, &sz, (void *)&epoch,\n\t sizeof(epoch));\n\texpect_d_eq(0, err, \"Unexpected mallctl() failure\");\n\n\tsize_t mib[6];\n\tsize_t miblen = sizeof(mib)/sizeof(mib[0]);\n\terr = mallctlnametomib(\n\t \"stats.arenas.0.hpa_shard.empty_slabs.ndirty_nonhuge\", mib,\n\t &miblen);\n\texpect_d_eq(0, err, \"Unexpected mallctlnametomib() failure\");\n\n\tsz = sizeof(ndirty_nonhuge);\n\tmib[2] = arena_ind;\n\terr = mallctlbymib(mib, miblen, &ndirty_nonhuge, &sz, NULL, 0);\n\texpect_d_eq(0, err, \"Unexpected mallctlbymib() failure\");\n\n\terr = mallctlnametomib(\n\t \"stats.arenas.0.hpa_shard.empty_slabs.ndirty_huge\", mib,\n\t &miblen);\n\texpect_d_eq(0, err, \"Unexpected mallctlnametomib() failure\");\n\n\tsz = sizeof(ndirty_huge);\n\tmib[2] = arena_ind;\n\terr = mallctlbymib(mib, miblen, &ndirty_huge, &sz, NULL, 0);\n\texpect_d_eq(0, err, \"Unexpected mallctlbymib() failure\");\n\n\treturn ndirty_huge + ndirty_nonhuge;\n}\n\nstatic void\nset_background_thread_enabled(bool enabled) {\n\tint err;\n\terr = je_mallctl(\"background_thread\", NULL, NULL, &enabled,\n\t sizeof(enabled));\n\texpect_d_eq(0, err, \"Unexpected mallctl failure\");\n}\n\nstatic void\nwait_until_thread_is_enabled(unsigned arena_id) {\n\ttsd_t* tsd = tsd_fetch();\n\n\tbool sleeping = false;\n\tint iterations = 0;\n\tdo {\n\t\tbackground_thread_info_t *info =\n\t\t background_thread_info_get(arena_id);\n\t\tmalloc_mutex_lock(tsd_tsdn(tsd), &info->mtx);\n\t\tmalloc_mutex_unlock(tsd_tsdn(tsd), &info->mtx);\n\t\tsleeping = background_thread_indefinite_sleep(info);\n\t\tassert_d_lt(iterations, UINT64_C(1000000),\n\t\t \"Waiting for a thread to start for too long\");\n\t} while (!sleeping);\n}\n\nstatic void\nexpect_purging(unsigned arena_ind, bool expect_deferred) {\n\tsize_t empty_ndirty;\n\n\tempty_ndirty = get_empty_ndirty(arena_ind);\n\texpect_zu_eq(0, empty_ndirty, \"Expected arena to start unused.\");\n\n\t/*\n\t * It's possible that we get unlucky with our stats collection timing,\n\t * and the background thread runs in between the deallocation and the\n\t * stats collection. So we retry 10 times, and see if we *ever* see\n\t * deferred reclamation.\n\t */\n\tbool observed_dirty_page = false;\n\tfor (int i = 0; i < 10; i++) {\n\t\tvoid *ptr = mallocx(PAGE,\n\t\t MALLOCX_TCACHE_NONE | MALLOCX_ARENA(arena_ind));\n\t\tempty_ndirty = get_empty_ndirty(arena_ind);\n\t\texpect_zu_eq(0, empty_ndirty, \"All pages should be active\");\n\t\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\t\tempty_ndirty = get_empty_ndirty(arena_ind);\n\t\tif (expect_deferred) {\n\t\t\texpect_true(empty_ndirty == 0 || empty_ndirty == 1 ||\n\t\t\t opt_prof, \"Unexpected extra dirty page count: %zu\",\n\t\t\t empty_ndirty);\n\t\t} else {\n\t\t\tassert_zu_eq(0, empty_ndirty,\n\t\t\t \"Saw dirty pages without deferred purging\");\n\t\t}\n\t\tif (empty_ndirty > 0) {\n\t\t\tobserved_dirty_page = true;\n\t\t\tbreak;\n\t\t}\n\t}\n\texpect_b_eq(expect_deferred, observed_dirty_page, \"\");\n\n\t/*\n\t * Under high concurrency / heavy test load (e.g. using run_test.sh),\n\t * the background thread may not get scheduled for a longer period of\n\t * time. Retry 100 times max before bailing out.\n\t */\n\tunsigned retry = 0;\n\twhile ((empty_ndirty = get_empty_ndirty(arena_ind)) > 0 &&\n\t expect_deferred && (retry++ < 100)) {\n\t\tsleep_for_background_thread_interval();\n\t}\n\n\texpect_zu_eq(0, empty_ndirty, \"Should have seen a background purge\");\n}\n\nTEST_BEGIN(test_hpa_background_thread_purges) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(!hpa_supported());\n\ttest_skip_if(!have_background_thread);\n\t/* Skip since guarded pages cannot be allocated from hpa. */\n\ttest_skip_if(san_guard_enabled());\n\n\tunsigned arena_ind = create_arena();\n\t/*\n\t * Our .sh sets dirty mult to 0, so all dirty pages should get purged\n\t * any time any thread frees.\n\t */\n\texpect_purging(arena_ind, /* expect_deferred */ true);\n}\nTEST_END\n\nTEST_BEGIN(test_hpa_background_thread_enable_disable) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(!hpa_supported());\n\ttest_skip_if(!have_background_thread);\n\t/* Skip since guarded pages cannot be allocated from hpa. */\n\ttest_skip_if(san_guard_enabled());\n\n\tunsigned arena_ind = create_arena();\n\n\tset_background_thread_enabled(false);\n\texpect_purging(arena_ind, false);\n\n\tset_background_thread_enabled(true);\n\twait_until_thread_is_enabled(arena_ind);\n\texpect_purging(arena_ind, true);\n}\nTEST_END\n\nint\nmain(void) {\n\t/*\n\t * OK, this is a sort of nasty hack. We don't want to add *another*\n\t * config option for HPA (the intent is that it becomes available on\n\t * more platforms over time, and we're trying to prune back config\n\t * options generally. But we'll get initialization errors on other\n\t * platforms if we set hpa:true in the MALLOC_CONF (even if we set\n\t * abort_conf:false as well). So we reach into the internals and set\n\t * them directly, but only if we know that we're actually going to do\n\t * something nontrivial in the tests.\n\t */\n\tif (config_stats && hpa_supported() && have_background_thread) {\n\t\topt_hpa = true;\n\t\topt_background_thread = true;\n\t}\n\treturn test_no_reentrancy(\n\t test_hpa_background_thread_purges,\n\t test_hpa_background_thread_enable_disable);\n}\n" }, { "path": "deps/jemalloc/test/unit/hpa_background_thread.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"hpa_dirty_mult:0,hpa_min_purge_interval_ms:50,hpa_sec_nshards:0\"\n\n" }, { "path": "deps/jemalloc/test/unit/hpdata.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define HPDATA_ADDR ((void *)(10 * HUGEPAGE))\n#define HPDATA_AGE 123\n\nTEST_BEGIN(test_reserve_alloc) {\n\thpdata_t hpdata;\n\thpdata_init(&hpdata, HPDATA_ADDR, HPDATA_AGE);\n\n\t/* Allocating a page at a time, we should do first fit. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\texpect_true(hpdata_consistent(&hpdata), \"\");\n\t\texpect_zu_eq(HUGEPAGE_PAGES - i,\n\t\t hpdata_longest_free_range_get(&hpdata), \"\");\n\t\tvoid *alloc = hpdata_reserve_alloc(&hpdata, PAGE);\n\t\texpect_ptr_eq((char *)HPDATA_ADDR + i * PAGE, alloc, \"\");\n\t\texpect_true(hpdata_consistent(&hpdata), \"\");\n\t}\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(0, hpdata_longest_free_range_get(&hpdata), \"\");\n\n\t/*\n\t * Build up a bigger free-range, 2 pages at a time, until we've got 6\n\t * adjacent free pages total. Pages 8-13 should be unreserved after\n\t * this.\n\t */\n\thpdata_unreserve(&hpdata, (char *)HPDATA_ADDR + 10 * PAGE, 2 * PAGE);\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(2, hpdata_longest_free_range_get(&hpdata), \"\");\n\n\thpdata_unreserve(&hpdata, (char *)HPDATA_ADDR + 12 * PAGE, 2 * PAGE);\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(4, hpdata_longest_free_range_get(&hpdata), \"\");\n\n\thpdata_unreserve(&hpdata, (char *)HPDATA_ADDR + 8 * PAGE, 2 * PAGE);\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(6, hpdata_longest_free_range_get(&hpdata), \"\");\n\n\t/*\n\t * Leave page 14 reserved, but free page 15 (this test the case where\n\t * unreserving combines two ranges).\n\t */\n\thpdata_unreserve(&hpdata, (char *)HPDATA_ADDR + 15 * PAGE, PAGE);\n\t/*\n\t * Longest free range shouldn't change; we've got a free range of size\n\t * 6, then a reserved page, then another free range.\n\t */\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(6, hpdata_longest_free_range_get(&hpdata), \"\");\n\n\t/* After freeing page 14, the two ranges get combined. */\n\thpdata_unreserve(&hpdata, (char *)HPDATA_ADDR + 14 * PAGE, PAGE);\n\texpect_true(hpdata_consistent(&hpdata), \"\");\n\texpect_zu_eq(8, hpdata_longest_free_range_get(&hpdata), \"\");\n}\nTEST_END\n\nTEST_BEGIN(test_purge_simple) {\n\thpdata_t hpdata;\n\thpdata_init(&hpdata, HPDATA_ADDR, HPDATA_AGE);\n\n\tvoid *alloc = hpdata_reserve_alloc(&hpdata, HUGEPAGE_PAGES / 2 * PAGE);\n\texpect_ptr_eq(alloc, HPDATA_ADDR, \"\");\n\n\t/* Create HUGEPAGE_PAGES / 4 dirty inactive pages at the beginning. */\n\thpdata_unreserve(&hpdata, alloc, HUGEPAGE_PAGES / 4 * PAGE);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), HUGEPAGE_PAGES / 2, \"\");\n\n\thpdata_alloc_allowed_set(&hpdata, false);\n\thpdata_purge_state_t purge_state;\n\tsize_t to_purge = hpdata_purge_begin(&hpdata, &purge_state);\n\texpect_zu_eq(HUGEPAGE_PAGES / 4, to_purge, \"\");\n\n\tvoid *purge_addr;\n\tsize_t purge_size;\n\tbool got_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_true(got_result, \"\");\n\texpect_ptr_eq(HPDATA_ADDR, purge_addr, \"\");\n\texpect_zu_eq(HUGEPAGE_PAGES / 4 * PAGE, purge_size, \"\");\n\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_false(got_result, \"Unexpected additional purge range: \"\n\t \"extent at %p of size %zu\", purge_addr, purge_size);\n\n\thpdata_purge_end(&hpdata, &purge_state);\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), HUGEPAGE_PAGES / 4, \"\");\n}\nTEST_END\n\n/*\n * We only test intervening dalloc's not intervening allocs; the latter are\n * disallowed as a purging precondition (because they interfere with purging\n * across a retained extent, saving a purge call).\n */\nTEST_BEGIN(test_purge_intervening_dalloc) {\n\thpdata_t hpdata;\n\thpdata_init(&hpdata, HPDATA_ADDR, HPDATA_AGE);\n\n\t/* Allocate the first 3/4 of the pages. */\n\tvoid *alloc = hpdata_reserve_alloc(&hpdata, 3 * HUGEPAGE_PAGES / 4 * PAGE);\n\texpect_ptr_eq(alloc, HPDATA_ADDR, \"\");\n\n\t/* Free the first 1/4 and the third 1/4 of the pages. */\n\thpdata_unreserve(&hpdata, alloc, HUGEPAGE_PAGES / 4 * PAGE);\n\thpdata_unreserve(&hpdata,\n\t (void *)((uintptr_t)alloc + 2 * HUGEPAGE_PAGES / 4 * PAGE),\n\t HUGEPAGE_PAGES / 4 * PAGE);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), 3 * HUGEPAGE_PAGES / 4, \"\");\n\n\thpdata_alloc_allowed_set(&hpdata, false);\n\thpdata_purge_state_t purge_state;\n\tsize_t to_purge = hpdata_purge_begin(&hpdata, &purge_state);\n\texpect_zu_eq(HUGEPAGE_PAGES / 2, to_purge, \"\");\n\n\tvoid *purge_addr;\n\tsize_t purge_size;\n\t/* First purge. */\n\tbool got_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_true(got_result, \"\");\n\texpect_ptr_eq(HPDATA_ADDR, purge_addr, \"\");\n\texpect_zu_eq(HUGEPAGE_PAGES / 4 * PAGE, purge_size, \"\");\n\n\t/* Deallocate the second 1/4 before the second purge occurs. */\n\thpdata_unreserve(&hpdata,\n\t (void *)((uintptr_t)alloc + 1 * HUGEPAGE_PAGES / 4 * PAGE),\n\t HUGEPAGE_PAGES / 4 * PAGE);\n\n\t/* Now continue purging. */\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_true(got_result, \"\");\n\texpect_ptr_eq(\n\t (void *)((uintptr_t)alloc + 2 * HUGEPAGE_PAGES / 4 * PAGE),\n\t purge_addr, \"\");\n\texpect_zu_ge(HUGEPAGE_PAGES / 4 * PAGE, purge_size, \"\");\n\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_false(got_result, \"Unexpected additional purge range: \"\n\t \"extent at %p of size %zu\", purge_addr, purge_size);\n\n\thpdata_purge_end(&hpdata, &purge_state);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), HUGEPAGE_PAGES / 4, \"\");\n}\nTEST_END\n\nTEST_BEGIN(test_purge_over_retained) {\n\tvoid *purge_addr;\n\tsize_t purge_size;\n\n\thpdata_t hpdata;\n\thpdata_init(&hpdata, HPDATA_ADDR, HPDATA_AGE);\n\n\t/* Allocate the first 3/4 of the pages. */\n\tvoid *alloc = hpdata_reserve_alloc(&hpdata, 3 * HUGEPAGE_PAGES / 4 * PAGE);\n\texpect_ptr_eq(alloc, HPDATA_ADDR, \"\");\n\n\t/* Free the second quarter. */\n\tvoid *second_quarter =\n\t (void *)((uintptr_t)alloc + HUGEPAGE_PAGES / 4 * PAGE);\n\thpdata_unreserve(&hpdata, second_quarter, HUGEPAGE_PAGES / 4 * PAGE);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), 3 * HUGEPAGE_PAGES / 4, \"\");\n\n\t/* Purge the second quarter. */\n\thpdata_alloc_allowed_set(&hpdata, false);\n\thpdata_purge_state_t purge_state;\n\tsize_t to_purge_dirty = hpdata_purge_begin(&hpdata, &purge_state);\n\texpect_zu_eq(HUGEPAGE_PAGES / 4, to_purge_dirty, \"\");\n\n\tbool got_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_true(got_result, \"\");\n\texpect_ptr_eq(second_quarter, purge_addr, \"\");\n\texpect_zu_eq(HUGEPAGE_PAGES / 4 * PAGE, purge_size, \"\");\n\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_false(got_result, \"Unexpected additional purge range: \"\n\t \"extent at %p of size %zu\", purge_addr, purge_size);\n\thpdata_purge_end(&hpdata, &purge_state);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), HUGEPAGE_PAGES / 2, \"\");\n\n\t/* Free the first and third quarter. */\n\thpdata_unreserve(&hpdata, HPDATA_ADDR, HUGEPAGE_PAGES / 4 * PAGE);\n\thpdata_unreserve(&hpdata,\n\t (void *)((uintptr_t)alloc + 2 * HUGEPAGE_PAGES / 4 * PAGE),\n\t HUGEPAGE_PAGES / 4 * PAGE);\n\n\t/*\n\t * Purge again. The second quarter is retained, so we can safely\n\t * re-purge it. We expect a single purge of 3/4 of the hugepage,\n\t * purging half its pages.\n\t */\n\tto_purge_dirty = hpdata_purge_begin(&hpdata, &purge_state);\n\texpect_zu_eq(HUGEPAGE_PAGES / 2, to_purge_dirty, \"\");\n\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_true(got_result, \"\");\n\texpect_ptr_eq(HPDATA_ADDR, purge_addr, \"\");\n\texpect_zu_eq(3 * HUGEPAGE_PAGES / 4 * PAGE, purge_size, \"\");\n\n\tgot_result = hpdata_purge_next(&hpdata, &purge_state, &purge_addr,\n\t &purge_size);\n\texpect_false(got_result, \"Unexpected additional purge range: \"\n\t \"extent at %p of size %zu\", purge_addr, purge_size);\n\thpdata_purge_end(&hpdata, &purge_state);\n\n\texpect_zu_eq(hpdata_ntouched_get(&hpdata), 0, \"\");\n}\nTEST_END\n\nTEST_BEGIN(test_hugify) {\n\thpdata_t hpdata;\n\thpdata_init(&hpdata, HPDATA_ADDR, HPDATA_AGE);\n\n\tvoid *alloc = hpdata_reserve_alloc(&hpdata, HUGEPAGE / 2);\n\texpect_ptr_eq(alloc, HPDATA_ADDR, \"\");\n\n\texpect_zu_eq(HUGEPAGE_PAGES / 2, hpdata_ntouched_get(&hpdata), \"\");\n\n\thpdata_hugify(&hpdata);\n\n\t/* Hugeifying should have increased the dirty page count. */\n\texpect_zu_eq(HUGEPAGE_PAGES, hpdata_ntouched_get(&hpdata), \"\");\n}\nTEST_END\n\nint main(void) {\n\treturn test_no_reentrancy(\n\t test_reserve_alloc,\n\t test_purge_simple,\n\t test_purge_intervening_dalloc,\n\t test_purge_over_retained,\n\t test_hugify);\n}\n" }, { "path": "deps/jemalloc/test/unit/huge.c", "content": "#include \"test/jemalloc_test.h\"\n\n/* Threshold: 2 << 20 = 2097152. */\nconst char *malloc_conf = \"oversize_threshold:2097152\";\n\n#define HUGE_SZ (2 << 20)\n#define SMALL_SZ (8)\n\nTEST_BEGIN(huge_bind_thread) {\n\tunsigned arena1, arena2;\n\tsize_t sz = sizeof(unsigned);\n\n\t/* Bind to a manual arena. */\n\texpect_d_eq(mallctl(\"arenas.create\", &arena1, &sz, NULL, 0), 0,\n\t \"Failed to create arena\");\n\texpect_d_eq(mallctl(\"thread.arena\", NULL, NULL, &arena1,\n\t sizeof(arena1)), 0, \"Fail to bind thread\");\n\n\tvoid *ptr = mallocx(HUGE_SZ, 0);\n\texpect_ptr_not_null(ptr, \"Fail to allocate huge size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &ptr,\n\t sizeof(ptr)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_eq(arena1, arena2, \"Wrong arena used after binding\");\n\tdallocx(ptr, 0);\n\n\t/* Switch back to arena 0. */\n\ttest_skip_if(have_percpu_arena &&\n\t PERCPU_ARENA_ENABLED(opt_percpu_arena));\n\tarena2 = 0;\n\texpect_d_eq(mallctl(\"thread.arena\", NULL, NULL, &arena2,\n\t sizeof(arena2)), 0, \"Fail to bind thread\");\n\tptr = mallocx(SMALL_SZ, MALLOCX_TCACHE_NONE);\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &ptr,\n\t sizeof(ptr)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_eq(arena2, 0, \"Wrong arena used after binding\");\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\n\t/* Then huge allocation should use the huge arena. */\n\tptr = mallocx(HUGE_SZ, 0);\n\texpect_ptr_not_null(ptr, \"Fail to allocate huge size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &ptr,\n\t sizeof(ptr)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_ne(arena2, 0, \"Wrong arena used after binding\");\n\texpect_u_ne(arena1, arena2, \"Wrong arena used after binding\");\n\tdallocx(ptr, 0);\n}\nTEST_END\n\nTEST_BEGIN(huge_mallocx) {\n\tunsigned arena1, arena2;\n\tsize_t sz = sizeof(unsigned);\n\n\texpect_d_eq(mallctl(\"arenas.create\", &arena1, &sz, NULL, 0), 0,\n\t \"Failed to create arena\");\n\tvoid *huge = mallocx(HUGE_SZ, MALLOCX_ARENA(arena1));\n\texpect_ptr_not_null(huge, \"Fail to allocate huge size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &huge,\n\t sizeof(huge)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_eq(arena1, arena2, \"Wrong arena used for mallocx\");\n\tdallocx(huge, MALLOCX_ARENA(arena1));\n\n\tvoid *huge2 = mallocx(HUGE_SZ, 0);\n\texpect_ptr_not_null(huge, \"Fail to allocate huge size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &huge2,\n\t sizeof(huge2)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_ne(arena1, arena2,\n\t \"Huge allocation should not come from the manual arena.\");\n\texpect_u_ne(arena2, 0,\n\t \"Huge allocation should not come from the arena 0.\");\n\tdallocx(huge2, 0);\n}\nTEST_END\n\nTEST_BEGIN(huge_allocation) {\n\tunsigned arena1, arena2;\n\n\tvoid *ptr = mallocx(HUGE_SZ, 0);\n\texpect_ptr_not_null(ptr, \"Fail to allocate huge size\");\n\tsize_t sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena1, &sz, &ptr, sizeof(ptr)),\n\t 0, \"Unexpected mallctl() failure\");\n\texpect_u_gt(arena1, 0, \"Huge allocation should not come from arena 0\");\n\tdallocx(ptr, 0);\n\n\tptr = mallocx(HUGE_SZ >> 1, 0);\n\texpect_ptr_not_null(ptr, \"Fail to allocate half huge size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &ptr,\n\t sizeof(ptr)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_ne(arena1, arena2, \"Wrong arena used for half huge\");\n\tdallocx(ptr, 0);\n\n\tptr = mallocx(SMALL_SZ, MALLOCX_TCACHE_NONE);\n\texpect_ptr_not_null(ptr, \"Fail to allocate small size\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena2, &sz, &ptr,\n\t sizeof(ptr)), 0, \"Unexpected mallctl() failure\");\n\texpect_u_ne(arena1, arena2,\n\t \"Huge and small should be from different arenas\");\n\tdallocx(ptr, 0);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t huge_allocation,\n\t huge_mallocx,\n\t huge_bind_thread);\n}\n" }, { "path": "deps/jemalloc/test/unit/inspect.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define TEST_UTIL_EINVAL(node, a, b, c, d, why_inval) do {\t\t\\\n\tassert_d_eq(mallctl(\"experimental.utilization.\" node,\t\t\\\n\t a, b, c, d), EINVAL, \"Should fail when \" why_inval);\t\\\n\tassert_zu_eq(out_sz, out_sz_ref,\t\t\t\t\\\n\t \"Output size touched when given invalid arguments\");\t\\\n\tassert_d_eq(memcmp(out, out_ref, out_sz_ref), 0,\t\t\\\n\t \"Output content touched when given invalid arguments\");\t\\\n} while (0)\n\n#define TEST_UTIL_QUERY_EINVAL(a, b, c, d, why_inval)\t\t\t\\\n\tTEST_UTIL_EINVAL(\"query\", a, b, c, d, why_inval)\n#define TEST_UTIL_BATCH_EINVAL(a, b, c, d, why_inval)\t\t\t\\\n\tTEST_UTIL_EINVAL(\"batch_query\", a, b, c, d, why_inval)\n\n#define TEST_UTIL_VALID(node) do {\t\t\t\t\t\\\n assert_d_eq(mallctl(\"experimental.utilization.\" node,\t\t\\\n\t out, &out_sz, in, in_sz), 0,\t\t\t\t\\\n\t \"Should return 0 on correct arguments\");\t\t\t\\\n expect_zu_eq(out_sz, out_sz_ref, \"incorrect output size\");\t\\\n\texpect_d_ne(memcmp(out, out_ref, out_sz_ref), 0,\t\t\\\n\t \"Output content should be changed\");\t\t\t\\\n} while (0)\n\n#define TEST_UTIL_BATCH_VALID TEST_UTIL_VALID(\"batch_query\")\n\n#define TEST_MAX_SIZE (1 << 20)\n\nTEST_BEGIN(test_query) {\n\tsize_t sz;\n\t/*\n\t * Select some sizes that can span both small and large sizes, and are\n\t * numerically unrelated to any size boundaries.\n\t */\n\tfor (sz = 7; sz <= TEST_MAX_SIZE && sz <= SC_LARGE_MAXCLASS;\n\t sz += (sz <= SC_SMALL_MAXCLASS ? 1009 : 99989)) {\n\t\tvoid *p = mallocx(sz, 0);\n\t\tvoid **in = &p;\n\t\tsize_t in_sz = sizeof(const void *);\n\t\tsize_t out_sz = sizeof(void *) + sizeof(size_t) * 5;\n\t\tvoid *out = mallocx(out_sz, 0);\n\t\tvoid *out_ref = mallocx(out_sz, 0);\n\t\tsize_t out_sz_ref = out_sz;\n\n\t\tassert_ptr_not_null(p,\n\t\t \"test pointer allocation failed\");\n\t\tassert_ptr_not_null(out,\n\t\t \"test output allocation failed\");\n\t\tassert_ptr_not_null(out_ref,\n\t\t \"test reference output allocation failed\");\n\n#define SLABCUR_READ(out) (*(void **)out)\n#define COUNTS(out) ((size_t *)((void **)out + 1))\n#define NFREE_READ(out) COUNTS(out)[0]\n#define NREGS_READ(out) COUNTS(out)[1]\n#define SIZE_READ(out) COUNTS(out)[2]\n#define BIN_NFREE_READ(out) COUNTS(out)[3]\n#define BIN_NREGS_READ(out) COUNTS(out)[4]\n\n\t\tSLABCUR_READ(out) = NULL;\n\t\tNFREE_READ(out) = NREGS_READ(out) = SIZE_READ(out) = -1;\n\t\tBIN_NFREE_READ(out) = BIN_NREGS_READ(out) = -1;\n\t\tmemcpy(out_ref, out, out_sz);\n\n\t\t/* Test invalid argument(s) errors */\n\t\tTEST_UTIL_QUERY_EINVAL(NULL, &out_sz, in, in_sz,\n\t\t \"old is NULL\");\n\t\tTEST_UTIL_QUERY_EINVAL(out, NULL, in, in_sz,\n\t\t \"oldlenp is NULL\");\n\t\tTEST_UTIL_QUERY_EINVAL(out, &out_sz, NULL, in_sz,\n\t\t \"newp is NULL\");\n\t\tTEST_UTIL_QUERY_EINVAL(out, &out_sz, in, 0,\n\t\t \"newlen is zero\");\n\t\tin_sz -= 1;\n\t\tTEST_UTIL_QUERY_EINVAL(out, &out_sz, in, in_sz,\n\t\t \"invalid newlen\");\n\t\tin_sz += 1;\n\t\tout_sz_ref = out_sz -= 2 * sizeof(size_t);\n\t\tTEST_UTIL_QUERY_EINVAL(out, &out_sz, in, in_sz,\n\t\t \"invalid *oldlenp\");\n\t\tout_sz_ref = out_sz += 2 * sizeof(size_t);\n\n\t\t/* Examine output for valid call */\n\t\tTEST_UTIL_VALID(\"query\");\n\t\texpect_zu_le(sz, SIZE_READ(out),\n\t\t \"Extent size should be at least allocation size\");\n\t\texpect_zu_eq(SIZE_READ(out) & (PAGE - 1), 0,\n\t\t \"Extent size should be a multiple of page size\");\n\n\t\t/*\n\t\t * We don't do much bin checking if prof is on, since profiling\n\t\t * can produce extents that are for small size classes but not\n\t\t * slabs, which interferes with things like region counts.\n\t\t */\n\t\tif (!opt_prof && sz <= SC_SMALL_MAXCLASS) {\n\t\t\texpect_zu_le(NFREE_READ(out), NREGS_READ(out),\n\t\t\t \"Extent free count exceeded region count\");\n\t\t\texpect_zu_le(NREGS_READ(out), SIZE_READ(out),\n\t\t\t \"Extent region count exceeded size\");\n\t\t\texpect_zu_ne(NREGS_READ(out), 0,\n\t\t\t \"Extent region count must be positive\");\n\t\t\texpect_true(NFREE_READ(out) == 0 || (SLABCUR_READ(out)\n\t\t\t != NULL && SLABCUR_READ(out) <= p),\n\t\t\t \"Allocation should follow first fit principle\");\n\n\t\t\tif (config_stats) {\n\t\t\t\texpect_zu_le(BIN_NFREE_READ(out),\n\t\t\t\t BIN_NREGS_READ(out),\n\t\t\t\t \"Bin free count exceeded region count\");\n\t\t\t\texpect_zu_ne(BIN_NREGS_READ(out), 0,\n\t\t\t\t \"Bin region count must be positive\");\n\t\t\t\texpect_zu_le(NFREE_READ(out),\n\t\t\t\t BIN_NFREE_READ(out),\n\t\t\t\t \"Extent free count exceeded bin free count\");\n\t\t\t\texpect_zu_le(NREGS_READ(out),\n\t\t\t\t BIN_NREGS_READ(out),\n\t\t\t\t \"Extent region count exceeded \"\n\t\t\t\t \"bin region count\");\n\t\t\t\texpect_zu_eq(BIN_NREGS_READ(out)\n\t\t\t\t % NREGS_READ(out), 0,\n\t\t\t\t \"Bin region count isn't a multiple of \"\n\t\t\t\t \"extent region count\");\n\t\t\t\texpect_zu_le(\n\t\t\t\t BIN_NFREE_READ(out) - NFREE_READ(out),\n\t\t\t\t BIN_NREGS_READ(out) - NREGS_READ(out),\n\t\t\t\t \"Free count in other extents in the bin \"\n\t\t\t\t \"exceeded region count in other extents \"\n\t\t\t\t \"in the bin\");\n\t\t\t\texpect_zu_le(NREGS_READ(out) - NFREE_READ(out),\n\t\t\t\t BIN_NREGS_READ(out) - BIN_NFREE_READ(out),\n\t\t\t\t \"Extent utilized count exceeded \"\n\t\t\t\t \"bin utilized count\");\n\t\t\t}\n\t\t} else if (sz > SC_SMALL_MAXCLASS) {\n\t\t\texpect_zu_eq(NFREE_READ(out), 0,\n\t\t\t \"Extent free count should be zero\");\n\t\t\texpect_zu_eq(NREGS_READ(out), 1,\n\t\t\t \"Extent region count should be one\");\n\t\t\texpect_ptr_null(SLABCUR_READ(out),\n\t\t\t \"Current slab must be null for large size classes\");\n\t\t\tif (config_stats) {\n\t\t\t\texpect_zu_eq(BIN_NFREE_READ(out), 0,\n\t\t\t\t \"Bin free count must be zero for \"\n\t\t\t\t \"large sizes\");\n\t\t\t\texpect_zu_eq(BIN_NREGS_READ(out), 0,\n\t\t\t\t \"Bin region count must be zero for \"\n\t\t\t\t \"large sizes\");\n\t\t\t}\n\t\t}\n\n#undef BIN_NREGS_READ\n#undef BIN_NFREE_READ\n#undef SIZE_READ\n#undef NREGS_READ\n#undef NFREE_READ\n#undef COUNTS\n#undef SLABCUR_READ\n\n\t\tfree(out_ref);\n\t\tfree(out);\n\t\tfree(p);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_batch) {\n\tsize_t sz;\n\t/*\n\t * Select some sizes that can span both small and large sizes, and are\n\t * numerically unrelated to any size boundaries.\n\t */\n\tfor (sz = 17; sz <= TEST_MAX_SIZE && sz <= SC_LARGE_MAXCLASS;\n\t sz += (sz <= SC_SMALL_MAXCLASS ? 1019 : 99991)) {\n\t\tvoid *p = mallocx(sz, 0);\n\t\tvoid *q = mallocx(sz, 0);\n\t\tvoid *in[] = {p, q};\n\t\tsize_t in_sz = sizeof(const void *) * 2;\n\t\tsize_t out[] = {-1, -1, -1, -1, -1, -1};\n\t\tsize_t out_sz = sizeof(size_t) * 6;\n\t\tsize_t out_ref[] = {-1, -1, -1, -1, -1, -1};\n\t\tsize_t out_sz_ref = out_sz;\n\n\t\tassert_ptr_not_null(p, \"test pointer allocation failed\");\n\t\tassert_ptr_not_null(q, \"test pointer allocation failed\");\n\n\t\t/* Test invalid argument(s) errors */\n\t\tTEST_UTIL_BATCH_EINVAL(NULL, &out_sz, in, in_sz,\n\t\t \"old is NULL\");\n\t\tTEST_UTIL_BATCH_EINVAL(out, NULL, in, in_sz,\n\t\t \"oldlenp is NULL\");\n\t\tTEST_UTIL_BATCH_EINVAL(out, &out_sz, NULL, in_sz,\n\t\t \"newp is NULL\");\n\t\tTEST_UTIL_BATCH_EINVAL(out, &out_sz, in, 0,\n\t\t \"newlen is zero\");\n\t\tin_sz -= 1;\n\t\tTEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,\n\t\t \"newlen is not an exact multiple\");\n\t\tin_sz += 1;\n\t\tout_sz_ref = out_sz -= 2 * sizeof(size_t);\n\t\tTEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,\n\t\t \"*oldlenp is not an exact multiple\");\n\t\tout_sz_ref = out_sz += 2 * sizeof(size_t);\n\t\tin_sz -= sizeof(const void *);\n\t\tTEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,\n\t\t \"*oldlenp and newlen do not match\");\n\t\tin_sz += sizeof(const void *);\n\n\t/* Examine output for valid calls */\n#define TEST_EQUAL_REF(i, message) \\\n\tassert_d_eq(memcmp(out + (i) * 3, out_ref + (i) * 3, 3), 0, message)\n\n#define NFREE_READ(out, i) out[(i) * 3]\n#define NREGS_READ(out, i) out[(i) * 3 + 1]\n#define SIZE_READ(out, i) out[(i) * 3 + 2]\n\n\t\tout_sz_ref = out_sz /= 2;\n\t\tin_sz /= 2;\n\t\tTEST_UTIL_BATCH_VALID;\n\t\texpect_zu_le(sz, SIZE_READ(out, 0),\n\t\t \"Extent size should be at least allocation size\");\n\t\texpect_zu_eq(SIZE_READ(out, 0) & (PAGE - 1), 0,\n\t\t \"Extent size should be a multiple of page size\");\n\t\t/*\n\t\t * See the corresponding comment in test_query; profiling breaks\n\t\t * our slab count expectations.\n\t\t */\n\t\tif (sz <= SC_SMALL_MAXCLASS && !opt_prof) {\n\t\t\texpect_zu_le(NFREE_READ(out, 0), NREGS_READ(out, 0),\n\t\t\t \"Extent free count exceeded region count\");\n\t\t\texpect_zu_le(NREGS_READ(out, 0), SIZE_READ(out, 0),\n\t\t\t \"Extent region count exceeded size\");\n\t\t\texpect_zu_ne(NREGS_READ(out, 0), 0,\n\t\t\t \"Extent region count must be positive\");\n\t\t} else if (sz > SC_SMALL_MAXCLASS) {\n\t\t\texpect_zu_eq(NFREE_READ(out, 0), 0,\n\t\t\t \"Extent free count should be zero\");\n\t\t\texpect_zu_eq(NREGS_READ(out, 0), 1,\n\t\t\t \"Extent region count should be one\");\n\t\t}\n\t\tTEST_EQUAL_REF(1,\n\t\t \"Should not overwrite content beyond what's needed\");\n\t\tin_sz *= 2;\n\t\tout_sz_ref = out_sz *= 2;\n\n\t\tmemcpy(out_ref, out, 3 * sizeof(size_t));\n\t\tTEST_UTIL_BATCH_VALID;\n\t\tTEST_EQUAL_REF(0, \"Statistics should be stable across calls\");\n\t\tif (sz <= SC_SMALL_MAXCLASS) {\n\t\t\texpect_zu_le(NFREE_READ(out, 1), NREGS_READ(out, 1),\n\t\t\t \"Extent free count exceeded region count\");\n\t\t} else {\n\t\t\texpect_zu_eq(NFREE_READ(out, 0), 0,\n\t\t\t \"Extent free count should be zero\");\n\t\t}\n\t\texpect_zu_eq(NREGS_READ(out, 0), NREGS_READ(out, 1),\n\t\t \"Extent region count should be same for same region size\");\n\t\texpect_zu_eq(SIZE_READ(out, 0), SIZE_READ(out, 1),\n\t\t \"Extent size should be same for same region size\");\n\n#undef SIZE_READ\n#undef NREGS_READ\n#undef NFREE_READ\n\n#undef TEST_EQUAL_REF\n\n\t\tfree(q);\n\t\tfree(p);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\tassert_zu_lt(SC_SMALL_MAXCLASS + 100000, TEST_MAX_SIZE,\n\t \"Test case cannot cover large classes\");\n\treturn test(test_query, test_batch);\n}\n" }, { "path": "deps/jemalloc/test/unit/inspect.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:false\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/junk.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define arraylen(arr) (sizeof(arr)/sizeof(arr[0]))\nstatic size_t ptr_ind;\nstatic void *volatile ptrs[100];\nstatic void *last_junked_ptr;\nstatic size_t last_junked_usize;\n\nstatic void\nreset() {\n\tptr_ind = 0;\n\tlast_junked_ptr = NULL;\n\tlast_junked_usize = 0;\n}\n\nstatic void\ntest_junk(void *ptr, size_t usize) {\n\tlast_junked_ptr = ptr;\n\tlast_junked_usize = usize;\n}\n\nstatic void\ndo_allocs(size_t size, bool zero, size_t lg_align) {\n#define JUNK_ALLOC(...)\t\t\t\t\t\t\t\\\n\tdo {\t\t\t\t\t\t\t\t\\\n\t\tassert(ptr_ind + 1 < arraylen(ptrs));\t\t\t\\\n\t\tvoid *ptr = __VA_ARGS__;\t\t\t\t\\\n\t\tassert_ptr_not_null(ptr, \"\");\t\t\t\t\\\n\t\tptrs[ptr_ind++] = ptr;\t\t\t\t\t\\\n\t\tif (opt_junk_alloc && !zero) {\t\t\t\t\\\n\t\t\texpect_ptr_eq(ptr, last_junked_ptr, \"\");\t\\\n\t\t\texpect_zu_eq(last_junked_usize,\t\t\t\\\n\t\t\t TEST_MALLOC_SIZE(ptr), \"\");\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t} while (0)\n\tif (!zero && lg_align == 0) {\n\t\tJUNK_ALLOC(malloc(size));\n\t}\n\tif (!zero) {\n\t\tJUNK_ALLOC(aligned_alloc(1 << lg_align, size));\n\t}\n#ifdef JEMALLOC_OVERRIDE_MEMALIGN\n\tif (!zero) {\n\t\tJUNK_ALLOC(je_memalign(1 << lg_align, size));\n\t}\n#endif\n#ifdef JEMALLOC_OVERRIDE_VALLOC\n\tif (!zero && lg_align == LG_PAGE) {\n\t\tJUNK_ALLOC(je_valloc(size));\n\t}\n#endif\n\tint zero_flag = zero ? MALLOCX_ZERO : 0;\n\tJUNK_ALLOC(mallocx(size, zero_flag | MALLOCX_LG_ALIGN(lg_align)));\n\tJUNK_ALLOC(mallocx(size, zero_flag | MALLOCX_LG_ALIGN(lg_align)\n\t | MALLOCX_TCACHE_NONE));\n\tif (lg_align >= LG_SIZEOF_PTR) {\n\t\tvoid *memalign_result;\n\t\tint err = posix_memalign(&memalign_result, (1 << lg_align),\n\t\t size);\n\t\tassert_d_eq(err, 0, \"\");\n\t\tJUNK_ALLOC(memalign_result);\n\t}\n}\n\nTEST_BEGIN(test_junk_alloc_free) {\n\tbool zerovals[] = {false, true};\n\tsize_t sizevals[] = {\n\t\t1, 8, 100, 1000, 100*1000\n\t/*\n\t * Memory allocation failure is a real possibility in 32-bit mode.\n\t * Rather than try to check in the face of resource exhaustion, we just\n\t * rely more on the 64-bit tests. This is a little bit white-box-y in\n\t * the sense that this is only a good test strategy if we know that the\n\t * junk pathways don't touch interact with the allocation selection\n\t * mechanisms; but this is in fact the case.\n\t */\n#if LG_SIZEOF_PTR == 3\n\t\t , 10 * 1000 * 1000\n#endif\n\t};\n\tsize_t lg_alignvals[] = {\n\t\t0, 4, 10, 15, 16, LG_PAGE\n#if LG_SIZEOF_PTR == 3\n\t\t , 20, 24\n#endif\n\t};\n\n#define JUNK_FREE(...)\t\t\t\t\t\t\t\\\n\tdo {\t\t\t\t\t\t\t\t\\\n\t\tdo_allocs(size, zero, lg_align);\t\t\t\\\n\t\tfor (size_t n = 0; n < ptr_ind; n++) {\t\t\t\\\n\t\t\tvoid *ptr = ptrs[n];\t\t\t\t\\\n\t\t\t__VA_ARGS__;\t\t\t\t\t\\\n\t\t\tif (opt_junk_free) {\t\t\t\t\\\n\t\t\t\tassert_ptr_eq(ptr, last_junked_ptr,\t\\\n\t\t\t\t \"\");\t\t\t\t\\\n\t\t\t\tassert_zu_eq(usize, last_junked_usize,\t\\\n\t\t\t\t \"\");\t\t\t\t\\\n\t\t\t}\t\t\t\t\t\t\\\n\t\t\treset();\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t} while (0)\n\tfor (size_t i = 0; i < arraylen(zerovals); i++) {\n\t\tfor (size_t j = 0; j < arraylen(sizevals); j++) {\n\t\t\tfor (size_t k = 0; k < arraylen(lg_alignvals); k++) {\n\t\t\t\tbool zero = zerovals[i];\n\t\t\t\tsize_t size = sizevals[j];\n\t\t\t\tsize_t lg_align = lg_alignvals[k];\n\t\t\t\tsize_t usize = nallocx(size,\n\t\t\t\t MALLOCX_LG_ALIGN(lg_align));\n\n\t\t\t\tJUNK_FREE(free(ptr));\n\t\t\t\tJUNK_FREE(dallocx(ptr, 0));\n\t\t\t\tJUNK_FREE(dallocx(ptr, MALLOCX_TCACHE_NONE));\n\t\t\t\tJUNK_FREE(dallocx(ptr, MALLOCX_LG_ALIGN(\n\t\t\t\t lg_align)));\n\t\t\t\tJUNK_FREE(sdallocx(ptr, usize, MALLOCX_LG_ALIGN(\n\t\t\t\t lg_align)));\n\t\t\t\tJUNK_FREE(sdallocx(ptr, usize,\n\t\t\t\t MALLOCX_TCACHE_NONE | MALLOCX_LG_ALIGN(lg_align)));\n\t\t\t\tif (opt_zero_realloc_action\n\t\t\t\t == zero_realloc_action_free) {\n\t\t\t\t\tJUNK_FREE(realloc(ptr, 0));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_realloc_expand) {\n\tchar *volatile ptr;\n\tchar *volatile expanded;\n\n\ttest_skip_if(!opt_junk_alloc);\n\n\t/* Realloc */\n\tptr = malloc(SC_SMALL_MAXCLASS);\n\texpanded = realloc(ptr, SC_LARGE_MINCLASS);\n\texpect_ptr_eq(last_junked_ptr, &expanded[SC_SMALL_MAXCLASS], \"\");\n\texpect_zu_eq(last_junked_usize,\n\t SC_LARGE_MINCLASS - SC_SMALL_MAXCLASS, \"\");\n\tfree(expanded);\n\n\t/* rallocx(..., 0) */\n\tptr = malloc(SC_SMALL_MAXCLASS);\n\texpanded = rallocx(ptr, SC_LARGE_MINCLASS, 0);\n\texpect_ptr_eq(last_junked_ptr, &expanded[SC_SMALL_MAXCLASS], \"\");\n\texpect_zu_eq(last_junked_usize,\n\t SC_LARGE_MINCLASS - SC_SMALL_MAXCLASS, \"\");\n\tfree(expanded);\n\n\t/* rallocx(..., nonzero) */\n\tptr = malloc(SC_SMALL_MAXCLASS);\n\texpanded = rallocx(ptr, SC_LARGE_MINCLASS, MALLOCX_TCACHE_NONE);\n\texpect_ptr_eq(last_junked_ptr, &expanded[SC_SMALL_MAXCLASS], \"\");\n\texpect_zu_eq(last_junked_usize,\n\t SC_LARGE_MINCLASS - SC_SMALL_MAXCLASS, \"\");\n\tfree(expanded);\n\n\t/* rallocx(..., MALLOCX_ZERO) */\n\tptr = malloc(SC_SMALL_MAXCLASS);\n\tlast_junked_ptr = (void *)-1;\n\tlast_junked_usize = (size_t)-1;\n\texpanded = rallocx(ptr, SC_LARGE_MINCLASS, MALLOCX_ZERO);\n\texpect_ptr_eq(last_junked_ptr, (void *)-1, \"\");\n\texpect_zu_eq(last_junked_usize, (size_t)-1, \"\");\n\tfree(expanded);\n\n\t/*\n\t * Unfortunately, testing xallocx reliably is difficult to do portably\n\t * (since allocations can be expanded / not expanded differently on\n\t * different platforms. We rely on manual inspection there -- the\n\t * xallocx pathway is easy to inspect, though.\n\t *\n\t * Likewise, we don't test the shrinking pathways. It's difficult to do\n\t * so consistently (because of the risk of split failure or memory\n\t * exhaustion, in which case no junking should happen). This is fine\n\t * -- junking is a best-effort debug mechanism in the first place.\n\t */\n}\nTEST_END\n\nint\nmain(void) {\n\tjunk_alloc_callback = &test_junk;\n\tjunk_free_callback = &test_junk;\n\t/*\n\t * We check the last pointer junked. If a reentrant call happens, that\n\t * might be an internal allocation.\n\t */\n\treturn test_no_reentrancy(\n\t test_junk_alloc_free,\n\t test_realloc_expand);\n}\n" }, { "path": "deps/jemalloc/test/unit/junk.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"abort:false,zero:false,junk:true\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/junk_alloc.c", "content": "#include \"junk.c\"\n" }, { "path": "deps/jemalloc/test/unit/junk_alloc.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"abort:false,zero:false,junk:alloc\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/junk_free.c", "content": "#include \"junk.c\"\n" }, { "path": "deps/jemalloc/test/unit/junk_free.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"abort:false,zero:false,junk:free\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/log.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/log.h\"\n\nstatic void\nupdate_log_var_names(const char *names) {\n\tstrncpy(log_var_names, names, sizeof(log_var_names));\n}\n\nstatic void\nexpect_no_logging(const char *names) {\n\tlog_var_t log_l1 = LOG_VAR_INIT(\"l1\");\n\tlog_var_t log_l2 = LOG_VAR_INIT(\"l2\");\n\tlog_var_t log_l2_a = LOG_VAR_INIT(\"l2.a\");\n\n\tupdate_log_var_names(names);\n\n\tint count = 0;\n\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1)\n\n\t\tlog_do_begin(log_l2)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2)\n\n\t\tlog_do_begin(log_l2_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2_a)\n\t}\n\texpect_d_eq(count, 0, \"Disabled logging not ignored!\");\n}\n\nTEST_BEGIN(test_log_disabled) {\n\ttest_skip_if(!config_log);\n\tatomic_store_b(&log_init_done, true, ATOMIC_RELAXED);\n\texpect_no_logging(\"\");\n\texpect_no_logging(\"abc\");\n\texpect_no_logging(\"a.b.c\");\n\texpect_no_logging(\"l12\");\n\texpect_no_logging(\"l123|a456|b789\");\n\texpect_no_logging(\"|||\");\n}\nTEST_END\n\nTEST_BEGIN(test_log_enabled_direct) {\n\ttest_skip_if(!config_log);\n\tatomic_store_b(&log_init_done, true, ATOMIC_RELAXED);\n\tlog_var_t log_l1 = LOG_VAR_INIT(\"l1\");\n\tlog_var_t log_l1_a = LOG_VAR_INIT(\"l1.a\");\n\tlog_var_t log_l2 = LOG_VAR_INIT(\"l2\");\n\n\tint count;\n\n\tcount = 0;\n\tupdate_log_var_names(\"l1\");\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1)\n\t}\n\texpect_d_eq(count, 10, \"Mis-logged!\");\n\n\tcount = 0;\n\tupdate_log_var_names(\"l1.a\");\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1_a)\n\t}\n\texpect_d_eq(count, 10, \"Mis-logged!\");\n\n\tcount = 0;\n\tupdate_log_var_names(\"l1.a|abc|l2|def\");\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1_a)\n\n\t\tlog_do_begin(log_l2)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2)\n\t}\n\texpect_d_eq(count, 20, \"Mis-logged!\");\n}\nTEST_END\n\nTEST_BEGIN(test_log_enabled_indirect) {\n\ttest_skip_if(!config_log);\n\tatomic_store_b(&log_init_done, true, ATOMIC_RELAXED);\n\tupdate_log_var_names(\"l0|l1|abc|l2.b|def\");\n\n\t/* On. */\n\tlog_var_t log_l1 = LOG_VAR_INIT(\"l1\");\n\t/* Off. */\n\tlog_var_t log_l1a = LOG_VAR_INIT(\"l1a\");\n\t/* On. */\n\tlog_var_t log_l1_a = LOG_VAR_INIT(\"l1.a\");\n\t/* Off. */\n\tlog_var_t log_l2_a = LOG_VAR_INIT(\"l2.a\");\n\t/* On. */\n\tlog_var_t log_l2_b_a = LOG_VAR_INIT(\"l2.b.a\");\n\t/* On. */\n\tlog_var_t log_l2_b_b = LOG_VAR_INIT(\"l2.b.b\");\n\n\t/* 4 are on total, so should sum to 40. */\n\tint count = 0;\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1)\n\n\t\tlog_do_begin(log_l1a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1a)\n\n\t\tlog_do_begin(log_l1_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l1_a)\n\n\t\tlog_do_begin(log_l2_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2_a)\n\n\t\tlog_do_begin(log_l2_b_a)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2_b_a)\n\n\t\tlog_do_begin(log_l2_b_b)\n\t\t\tcount++;\n\t\tlog_do_end(log_l2_b_b)\n\t}\n\n\texpect_d_eq(count, 40, \"Mis-logged!\");\n}\nTEST_END\n\nTEST_BEGIN(test_log_enabled_global) {\n\ttest_skip_if(!config_log);\n\tatomic_store_b(&log_init_done, true, ATOMIC_RELAXED);\n\tupdate_log_var_names(\"abc|.|def\");\n\n\tlog_var_t log_l1 = LOG_VAR_INIT(\"l1\");\n\tlog_var_t log_l2_a_a = LOG_VAR_INIT(\"l2.a.a\");\n\n\tint count = 0;\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(log_l1)\n\t\t count++;\n\t\tlog_do_end(log_l1)\n\n\t\tlog_do_begin(log_l2_a_a)\n\t\t count++;\n\t\tlog_do_end(log_l2_a_a)\n\t}\n\texpect_d_eq(count, 20, \"Mis-logged!\");\n}\nTEST_END\n\nTEST_BEGIN(test_logs_if_no_init) {\n\ttest_skip_if(!config_log);\n\tatomic_store_b(&log_init_done, false, ATOMIC_RELAXED);\n\n\tlog_var_t l = LOG_VAR_INIT(\"definitely.not.enabled\");\n\n\tint count = 0;\n\tfor (int i = 0; i < 10; i++) {\n\t\tlog_do_begin(l)\n\t\t\tcount++;\n\t\tlog_do_end(l)\n\t}\n\texpect_d_eq(count, 0, \"Logging shouldn't happen if not initialized.\");\n}\nTEST_END\n\n/*\n * This really just checks to make sure that this usage compiles; we don't have\n * any test code to run.\n */\nTEST_BEGIN(test_log_only_format_string) {\n\tif (false) {\n\t\tLOG(\"log_str\", \"No arguments follow this format string.\");\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_log_disabled,\n\t test_log_enabled_direct,\n\t test_log_enabled_indirect,\n\t test_log_enabled_global,\n\t test_logs_if_no_init,\n\t test_log_only_format_string);\n}\n" }, { "path": "deps/jemalloc/test/unit/mallctl.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/ctl.h\"\n#include \"jemalloc/internal/hook.h\"\n#include \"jemalloc/internal/util.h\"\n\nTEST_BEGIN(test_mallctl_errors) {\n\tuint64_t epoch;\n\tsize_t sz;\n\n\texpect_d_eq(mallctl(\"no_such_name\", NULL, NULL, NULL, 0), ENOENT,\n\t \"mallctl() should return ENOENT for non-existent names\");\n\n\texpect_d_eq(mallctl(\"version\", NULL, NULL, \"0.0.0\", strlen(\"0.0.0\")),\n\t EPERM, \"mallctl() should return EPERM on attempt to write \"\n\t \"read-only value\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch,\n\t sizeof(epoch)-1), EINVAL,\n\t \"mallctl() should return EINVAL for input size mismatch\");\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch,\n\t sizeof(epoch)+1), EINVAL,\n\t \"mallctl() should return EINVAL for input size mismatch\");\n\n\tsz = sizeof(epoch)-1;\n\texpect_d_eq(mallctl(\"epoch\", (void *)&epoch, &sz, NULL, 0), EINVAL,\n\t \"mallctl() should return EINVAL for output size mismatch\");\n\tsz = sizeof(epoch)+1;\n\texpect_d_eq(mallctl(\"epoch\", (void *)&epoch, &sz, NULL, 0), EINVAL,\n\t \"mallctl() should return EINVAL for output size mismatch\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlnametomib_errors) {\n\tsize_t mib[1];\n\tsize_t miblen;\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"no_such_name\", mib, &miblen), ENOENT,\n\t \"mallctlnametomib() should return ENOENT for non-existent names\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlbymib_errors) {\n\tuint64_t epoch;\n\tsize_t sz;\n\tsize_t mib[1];\n\tsize_t miblen;\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"version\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, \"0.0.0\",\n\t strlen(\"0.0.0\")), EPERM, \"mallctl() should return EPERM on \"\n\t \"attempt to write read-only value\");\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"epoch\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, (void *)&epoch,\n\t sizeof(epoch)-1), EINVAL,\n\t \"mallctlbymib() should return EINVAL for input size mismatch\");\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, (void *)&epoch,\n\t sizeof(epoch)+1), EINVAL,\n\t \"mallctlbymib() should return EINVAL for input size mismatch\");\n\n\tsz = sizeof(epoch)-1;\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&epoch, &sz, NULL, 0),\n\t EINVAL,\n\t \"mallctlbymib() should return EINVAL for output size mismatch\");\n\tsz = sizeof(epoch)+1;\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&epoch, &sz, NULL, 0),\n\t EINVAL,\n\t \"mallctlbymib() should return EINVAL for output size mismatch\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctl_read_write) {\n\tuint64_t old_epoch, new_epoch;\n\tsize_t sz = sizeof(old_epoch);\n\n\t/* Blind. */\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(sz, sizeof(old_epoch), \"Unexpected output size\");\n\n\t/* Read. */\n\texpect_d_eq(mallctl(\"epoch\", (void *)&old_epoch, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(sz, sizeof(old_epoch), \"Unexpected output size\");\n\n\t/* Write. */\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&new_epoch,\n\t sizeof(new_epoch)), 0, \"Unexpected mallctl() failure\");\n\texpect_zu_eq(sz, sizeof(old_epoch), \"Unexpected output size\");\n\n\t/* Read+write. */\n\texpect_d_eq(mallctl(\"epoch\", (void *)&old_epoch, &sz,\n\t (void *)&new_epoch, sizeof(new_epoch)), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(sz, sizeof(old_epoch), \"Unexpected output size\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlnametomib_short_mib) {\n\tsize_t mib[4];\n\tsize_t miblen;\n\n\tmiblen = 3;\n\tmib[3] = 42;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.nregs\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\texpect_zu_eq(miblen, 3, \"Unexpected mib output length\");\n\texpect_zu_eq(mib[3], 42,\n\t \"mallctlnametomib() wrote past the end of the input mib\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlnametomib_short_name) {\n\tsize_t mib[4];\n\tsize_t miblen;\n\n\tmiblen = 4;\n\tmib[3] = 42;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\texpect_zu_eq(miblen, 3, \"Unexpected mib output length\");\n\texpect_zu_eq(mib[3], 42,\n\t \"mallctlnametomib() wrote past the end of the input mib\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlmibnametomib) {\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\tuint32_t result, result_ref;\n\tsize_t len_result = sizeof(uint32_t);\n\n\ttsd_t *tsd = tsd_fetch();\n\n\t/* Error cases */\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 0, \"bob\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 0, \"9999\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\n\t/* Valid case. */\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 0, \"arenas\", &miblen), 0, \"\");\n\tassert_zu_eq(miblen, 1, \"\");\n\tmiblen = 4;\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 1, \"bin\", &miblen), 0, \"\");\n\tassert_zu_eq(miblen, 2, \"\");\n\texpect_d_eq(mallctlbymib(mib, miblen, &result, &len_result, NULL, 0),\n\t ENOENT, \"mallctlbymib() should fail on partial path\");\n\n\t/* Error cases. */\n\tmiblen = 4;\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 2, \"bob\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 2, \"9999\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\n\t/* Valid case. */\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 2, \"0\", &miblen), 0, \"\");\n\tassert_zu_eq(miblen, 3, \"\");\n\texpect_d_eq(mallctlbymib(mib, miblen, &result, &len_result, NULL, 0),\n\t ENOENT, \"mallctlbymib() should fail on partial path\");\n\n\t/* Error cases. */\n\tmiblen = 4;\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 3, \"bob\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 3, \"9999\", &miblen), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\n\t/* Valid case. */\n\tassert_d_eq(ctl_mibnametomib(tsd, mib, 3, \"nregs\", &miblen), 0, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\tassert_d_eq(mallctlbymib(mib, miblen, &result, &len_result, NULL, 0),\n\t 0, \"Unexpected mallctlbymib() failure\");\n\tassert_d_eq(mallctl(\"arenas.bin.0.nregs\", &result_ref, &len_result,\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\texpect_zu_eq(result, result_ref,\n\t \"mallctlbymib() and mallctl() returned different result\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctlbymibname) {\n\tsize_t mib[4];\n\tsize_t miblen = 4;\n\tuint32_t result, result_ref;\n\tsize_t len_result = sizeof(uint32_t);\n\n\ttsd_t *tsd = tsd_fetch();\n\n\t/* Error cases. */\n\n\tassert_d_eq(mallctlnametomib(\"arenas\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tassert_zu_eq(miblen, 1, \"\");\n\n\tmiblen = 4;\n\tassert_d_eq(ctl_bymibname(tsd, mib, 1, \"bin.0\", &miblen,\n\t &result, &len_result, NULL, 0), ENOENT, \"\");\n\tmiblen = 4;\n\tassert_d_eq(ctl_bymibname(tsd, mib, 1, \"bin.0.bob\", &miblen,\n\t &result, &len_result, NULL, 0), ENOENT, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\n\t/* Valid cases. */\n\n\tassert_d_eq(mallctl(\"arenas.bin.0.nregs\", &result_ref, &len_result,\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\tmiblen = 4;\n\n\tassert_d_eq(ctl_bymibname(tsd, mib, 0, \"arenas.bin.0.nregs\", &miblen,\n\t &result, &len_result, NULL, 0), 0, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\texpect_zu_eq(result, result_ref, \"Unexpected result\");\n\n\tassert_d_eq(ctl_bymibname(tsd, mib, 1, \"bin.0.nregs\", &miblen, &result,\n\t &len_result, NULL, 0), 0, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\texpect_zu_eq(result, result_ref, \"Unexpected result\");\n\n\tassert_d_eq(ctl_bymibname(tsd, mib, 2, \"0.nregs\", &miblen, &result,\n\t &len_result, NULL, 0), 0, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\texpect_zu_eq(result, result_ref, \"Unexpected result\");\n\n\tassert_d_eq(ctl_bymibname(tsd, mib, 3, \"nregs\", &miblen, &result,\n\t &len_result, NULL, 0), 0, \"\");\n\tassert_zu_eq(miblen, 4, \"\");\n\texpect_zu_eq(result, result_ref, \"Unexpected result\");\n}\nTEST_END\n\nTEST_BEGIN(test_mallctl_config) {\n#define TEST_MALLCTL_CONFIG(config, t) do {\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(oldval);\t\t\t\t\t\\\n\texpect_d_eq(mallctl(\"config.\"#config, (void *)&oldval, &sz,\t\\\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\t\t\\\n\texpect_b_eq(oldval, config_##config, \"Incorrect config value\");\t\\\n\texpect_zu_eq(sz, sizeof(oldval), \"Unexpected output size\");\t\\\n} while (0)\n\n\tTEST_MALLCTL_CONFIG(cache_oblivious, bool);\n\tTEST_MALLCTL_CONFIG(debug, bool);\n\tTEST_MALLCTL_CONFIG(fill, bool);\n\tTEST_MALLCTL_CONFIG(lazy_lock, bool);\n\tTEST_MALLCTL_CONFIG(malloc_conf, const char *);\n\tTEST_MALLCTL_CONFIG(prof, bool);\n\tTEST_MALLCTL_CONFIG(prof_libgcc, bool);\n\tTEST_MALLCTL_CONFIG(prof_libunwind, bool);\n\tTEST_MALLCTL_CONFIG(stats, bool);\n\tTEST_MALLCTL_CONFIG(utrace, bool);\n\tTEST_MALLCTL_CONFIG(xmalloc, bool);\n\n#undef TEST_MALLCTL_CONFIG\n}\nTEST_END\n\nTEST_BEGIN(test_mallctl_opt) {\n\tbool config_always = true;\n\n#define TEST_MALLCTL_OPT(t, opt, config) do {\t\t\t\t\\\n\tt oldval;\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(oldval);\t\t\t\t\t\\\n\tint expected = config_##config ? 0 : ENOENT;\t\t\t\\\n\tint result = mallctl(\"opt.\"#opt, (void *)&oldval, &sz, NULL,\t\\\n\t 0);\t\t\t\t\t\t\t\t\\\n\texpect_d_eq(result, expected,\t\t\t\t\t\\\n\t \"Unexpected mallctl() result for opt.\"#opt);\t\t\\\n\texpect_zu_eq(sz, sizeof(oldval), \"Unexpected output size\");\t\\\n} while (0)\n\n\tTEST_MALLCTL_OPT(bool, abort, always);\n\tTEST_MALLCTL_OPT(bool, abort_conf, always);\n\tTEST_MALLCTL_OPT(bool, cache_oblivious, always);\n\tTEST_MALLCTL_OPT(bool, trust_madvise, always);\n\tTEST_MALLCTL_OPT(bool, confirm_conf, always);\n\tTEST_MALLCTL_OPT(const char *, metadata_thp, always);\n\tTEST_MALLCTL_OPT(bool, retain, always);\n\tTEST_MALLCTL_OPT(const char *, dss, always);\n\tTEST_MALLCTL_OPT(bool, hpa, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_slab_max_alloc, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_sec_nshards, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_sec_max_alloc, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_sec_max_bytes, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_sec_bytes_after_flush, always);\n\tTEST_MALLCTL_OPT(size_t, hpa_sec_batch_fill_extra, always);\n\tTEST_MALLCTL_OPT(unsigned, narenas, always);\n\tTEST_MALLCTL_OPT(const char *, percpu_arena, always);\n\tTEST_MALLCTL_OPT(size_t, oversize_threshold, always);\n\tTEST_MALLCTL_OPT(bool, background_thread, always);\n\tTEST_MALLCTL_OPT(ssize_t, dirty_decay_ms, always);\n\tTEST_MALLCTL_OPT(ssize_t, muzzy_decay_ms, always);\n\tTEST_MALLCTL_OPT(bool, stats_print, always);\n\tTEST_MALLCTL_OPT(const char *, stats_print_opts, always);\n\tTEST_MALLCTL_OPT(int64_t, stats_interval, always);\n\tTEST_MALLCTL_OPT(const char *, stats_interval_opts, always);\n\tTEST_MALLCTL_OPT(const char *, junk, fill);\n\tTEST_MALLCTL_OPT(bool, zero, fill);\n\tTEST_MALLCTL_OPT(bool, utrace, utrace);\n\tTEST_MALLCTL_OPT(bool, xmalloc, xmalloc);\n\tTEST_MALLCTL_OPT(bool, tcache, always);\n\tTEST_MALLCTL_OPT(size_t, lg_extent_max_active_fit, always);\n\tTEST_MALLCTL_OPT(size_t, tcache_max, always);\n\tTEST_MALLCTL_OPT(const char *, thp, always);\n\tTEST_MALLCTL_OPT(const char *, zero_realloc, always);\n\tTEST_MALLCTL_OPT(bool, prof, prof);\n\tTEST_MALLCTL_OPT(const char *, prof_prefix, prof);\n\tTEST_MALLCTL_OPT(bool, prof_active, prof);\n\tTEST_MALLCTL_OPT(ssize_t, lg_prof_sample, prof);\n\tTEST_MALLCTL_OPT(bool, prof_accum, prof);\n\tTEST_MALLCTL_OPT(ssize_t, lg_prof_interval, prof);\n\tTEST_MALLCTL_OPT(bool, prof_gdump, prof);\n\tTEST_MALLCTL_OPT(bool, prof_final, prof);\n\tTEST_MALLCTL_OPT(bool, prof_leak, prof);\n\tTEST_MALLCTL_OPT(bool, prof_leak_error, prof);\n\tTEST_MALLCTL_OPT(ssize_t, prof_recent_alloc_max, prof);\n\tTEST_MALLCTL_OPT(bool, prof_stats, prof);\n\tTEST_MALLCTL_OPT(bool, prof_sys_thread_name, prof);\n\tTEST_MALLCTL_OPT(ssize_t, lg_san_uaf_align, uaf_detection);\n\n#undef TEST_MALLCTL_OPT\n}\nTEST_END\n\nTEST_BEGIN(test_manpage_example) {\n\tunsigned nbins, i;\n\tsize_t mib[4];\n\tsize_t len, miblen;\n\n\tlen = sizeof(nbins);\n\texpect_d_eq(mallctl(\"arenas.nbins\", (void *)&nbins, &len, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tmiblen = 4;\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.size\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tfor (i = 0; i < nbins; i++) {\n\t\tsize_t bin_size;\n\n\t\tmib[2] = i;\n\t\tlen = sizeof(bin_size);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&bin_size, &len,\n\t\t NULL, 0), 0, \"Unexpected mallctlbymib() failure\");\n\t\t/* Do something with bin_size... */\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_tcache_none) {\n\ttest_skip_if(!opt_tcache);\n\n\t/* Allocate p and q. */\n\tvoid *p0 = mallocx(42, 0);\n\texpect_ptr_not_null(p0, \"Unexpected mallocx() failure\");\n\tvoid *q = mallocx(42, 0);\n\texpect_ptr_not_null(q, \"Unexpected mallocx() failure\");\n\n\t/* Deallocate p and q, but bypass the tcache for q. */\n\tdallocx(p0, 0);\n\tdallocx(q, MALLOCX_TCACHE_NONE);\n\n\t/* Make sure that tcache-based allocation returns p, not q. */\n\tvoid *p1 = mallocx(42, 0);\n\texpect_ptr_not_null(p1, \"Unexpected mallocx() failure\");\n\tif (!opt_prof && !san_uaf_detection_enabled()) {\n\t\texpect_ptr_eq(p0, p1,\n\t\t \"Expected tcache to allocate cached region\");\n\t}\n\n\t/* Clean up. */\n\tdallocx(p1, MALLOCX_TCACHE_NONE);\n}\nTEST_END\n\nTEST_BEGIN(test_tcache) {\n#define NTCACHES\t10\n\tunsigned tis[NTCACHES];\n\tvoid *ps[NTCACHES];\n\tvoid *qs[NTCACHES];\n\tunsigned i;\n\tsize_t sz, psz, qsz;\n\n\tpsz = 42;\n\tqsz = nallocx(psz, 0) + 1;\n\n\t/* Create tcaches. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tsz = sizeof(unsigned);\n\t\texpect_d_eq(mallctl(\"tcache.create\", (void *)&tis[i], &sz, NULL,\n\t\t 0), 0, \"Unexpected mallctl() failure, i=%u\", i);\n\t}\n\n\t/* Exercise tcache ID recycling. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\texpect_d_eq(mallctl(\"tcache.destroy\", NULL, NULL,\n\t\t (void *)&tis[i], sizeof(unsigned)), 0,\n\t\t \"Unexpected mallctl() failure, i=%u\", i);\n\t}\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tsz = sizeof(unsigned);\n\t\texpect_d_eq(mallctl(\"tcache.create\", (void *)&tis[i], &sz, NULL,\n\t\t 0), 0, \"Unexpected mallctl() failure, i=%u\", i);\n\t}\n\n\t/* Flush empty tcaches. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\texpect_d_eq(mallctl(\"tcache.flush\", NULL, NULL, (void *)&tis[i],\n\t\t sizeof(unsigned)), 0, \"Unexpected mallctl() failure, i=%u\",\n\t\t i);\n\t}\n\n\t/* Cache some allocations. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tps[i] = mallocx(psz, MALLOCX_TCACHE(tis[i]));\n\t\texpect_ptr_not_null(ps[i], \"Unexpected mallocx() failure, i=%u\",\n\t\t i);\n\t\tdallocx(ps[i], MALLOCX_TCACHE(tis[i]));\n\n\t\tqs[i] = mallocx(qsz, MALLOCX_TCACHE(tis[i]));\n\t\texpect_ptr_not_null(qs[i], \"Unexpected mallocx() failure, i=%u\",\n\t\t i);\n\t\tdallocx(qs[i], MALLOCX_TCACHE(tis[i]));\n\t}\n\n\t/* Verify that tcaches allocate cached regions. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tvoid *p0 = ps[i];\n\t\tps[i] = mallocx(psz, MALLOCX_TCACHE(tis[i]));\n\t\texpect_ptr_not_null(ps[i], \"Unexpected mallocx() failure, i=%u\",\n\t\t i);\n\t\tif (!san_uaf_detection_enabled()) {\n\t\t\texpect_ptr_eq(ps[i], p0, \"Expected mallocx() to \"\n\t\t\t \"allocate cached region, i=%u\", i);\n\t\t}\n\t}\n\n\t/* Verify that reallocation uses cached regions. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tvoid *q0 = qs[i];\n\t\tqs[i] = rallocx(ps[i], qsz, MALLOCX_TCACHE(tis[i]));\n\t\texpect_ptr_not_null(qs[i], \"Unexpected rallocx() failure, i=%u\",\n\t\t i);\n\t\tif (!san_uaf_detection_enabled()) {\n\t\t\texpect_ptr_eq(qs[i], q0, \"Expected rallocx() to \"\n\t\t\t \"allocate cached region, i=%u\", i);\n\t\t}\n\t\t/* Avoid undefined behavior in case of test failure. */\n\t\tif (qs[i] == NULL) {\n\t\t\tqs[i] = ps[i];\n\t\t}\n\t}\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\tdallocx(qs[i], MALLOCX_TCACHE(tis[i]));\n\t}\n\n\t/* Flush some non-empty tcaches. */\n\tfor (i = 0; i < NTCACHES/2; i++) {\n\t\texpect_d_eq(mallctl(\"tcache.flush\", NULL, NULL, (void *)&tis[i],\n\t\t sizeof(unsigned)), 0, \"Unexpected mallctl() failure, i=%u\",\n\t\t i);\n\t}\n\n\t/* Destroy tcaches. */\n\tfor (i = 0; i < NTCACHES; i++) {\n\t\texpect_d_eq(mallctl(\"tcache.destroy\", NULL, NULL,\n\t\t (void *)&tis[i], sizeof(unsigned)), 0,\n\t\t \"Unexpected mallctl() failure, i=%u\", i);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_thread_arena) {\n\tunsigned old_arena_ind, new_arena_ind, narenas;\n\n\tconst char *opa;\n\tsize_t sz = sizeof(opa);\n\texpect_d_eq(mallctl(\"opt.percpu_arena\", (void *)&opa, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\tif (opt_oversize_threshold != 0) {\n\t\tnarenas--;\n\t}\n\texpect_u_eq(narenas, opt_narenas, \"Number of arenas incorrect\");\n\n\tif (strcmp(opa, \"disabled\") == 0) {\n\t\tnew_arena_ind = narenas - 1;\n\t\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind, &sz,\n\t\t (void *)&new_arena_ind, sizeof(unsigned)), 0,\n\t\t \"Unexpected mallctl() failure\");\n\t\tnew_arena_ind = 0;\n\t\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind, &sz,\n\t\t (void *)&new_arena_ind, sizeof(unsigned)), 0,\n\t\t \"Unexpected mallctl() failure\");\n\t} else {\n\t\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind, &sz,\n\t\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\t\tnew_arena_ind = percpu_arena_ind_limit(opt_percpu_arena) - 1;\n\t\tif (old_arena_ind != new_arena_ind) {\n\t\t\texpect_d_eq(mallctl(\"thread.arena\",\n\t\t\t (void *)&old_arena_ind, &sz, (void *)&new_arena_ind,\n\t\t\t sizeof(unsigned)), EPERM, \"thread.arena ctl \"\n\t\t\t \"should not be allowed with percpu arena\");\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_initialized) {\n\tunsigned narenas, i;\n\tsize_t sz;\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\tbool initialized;\n\n\tsz = sizeof(narenas);\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctlnametomib(\"arena.0.initialized\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tfor (i = 0; i < narenas; i++) {\n\t\tmib[1] = i;\n\t\tsz = sizeof(initialized);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, &initialized, &sz, NULL,\n\t\t 0), 0, \"Unexpected mallctl() failure\");\n\t}\n\n\tmib[1] = MALLCTL_ARENAS_ALL;\n\tsz = sizeof(initialized);\n\texpect_d_eq(mallctlbymib(mib, miblen, &initialized, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_true(initialized,\n\t \"Merged arena statistics should always be initialized\");\n\n\t/* Equivalent to the above but using mallctl() directly. */\n\tsz = sizeof(initialized);\n\texpect_d_eq(mallctl(\n\t \"arena.\" STRINGIFY(MALLCTL_ARENAS_ALL) \".initialized\",\n\t (void *)&initialized, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_true(initialized,\n\t \"Merged arena statistics should always be initialized\");\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_dirty_decay_ms) {\n\tssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms;\n\tsize_t sz = sizeof(ssize_t);\n\n\texpect_d_eq(mallctl(\"arena.0.dirty_decay_ms\",\n\t (void *)&orig_dirty_decay_ms, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tdirty_decay_ms = -2;\n\texpect_d_eq(mallctl(\"arena.0.dirty_decay_ms\", NULL, NULL,\n\t (void *)&dirty_decay_ms, sizeof(ssize_t)), EFAULT,\n\t \"Unexpected mallctl() success\");\n\n\tdirty_decay_ms = 0x7fffffff;\n\texpect_d_eq(mallctl(\"arena.0.dirty_decay_ms\", NULL, NULL,\n\t (void *)&dirty_decay_ms, sizeof(ssize_t)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tfor (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1;\n\t dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms,\n\t dirty_decay_ms++) {\n\t\tssize_t old_dirty_decay_ms;\n\n\t\texpect_d_eq(mallctl(\"arena.0.dirty_decay_ms\",\n\t\t (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms,\n\t\t sizeof(ssize_t)), 0, \"Unexpected mallctl() failure\");\n\t\texpect_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms,\n\t\t \"Unexpected old arena.0.dirty_decay_ms\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_muzzy_decay_ms) {\n\tssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms;\n\tsize_t sz = sizeof(ssize_t);\n\n\texpect_d_eq(mallctl(\"arena.0.muzzy_decay_ms\",\n\t (void *)&orig_muzzy_decay_ms, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tmuzzy_decay_ms = -2;\n\texpect_d_eq(mallctl(\"arena.0.muzzy_decay_ms\", NULL, NULL,\n\t (void *)&muzzy_decay_ms, sizeof(ssize_t)), EFAULT,\n\t \"Unexpected mallctl() success\");\n\n\tmuzzy_decay_ms = 0x7fffffff;\n\texpect_d_eq(mallctl(\"arena.0.muzzy_decay_ms\", NULL, NULL,\n\t (void *)&muzzy_decay_ms, sizeof(ssize_t)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tfor (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1;\n\t muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms,\n\t muzzy_decay_ms++) {\n\t\tssize_t old_muzzy_decay_ms;\n\n\t\texpect_d_eq(mallctl(\"arena.0.muzzy_decay_ms\",\n\t\t (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms,\n\t\t sizeof(ssize_t)), 0, \"Unexpected mallctl() failure\");\n\t\texpect_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms,\n\t\t \"Unexpected old arena.0.muzzy_decay_ms\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_purge) {\n\tunsigned narenas;\n\tsize_t sz = sizeof(unsigned);\n\tsize_t mib[3];\n\tsize_t miblen = 3;\n\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctlnametomib(\"arena.0.purge\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = narenas;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\n\tmib[1] = MALLCTL_ARENAS_ALL;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_decay) {\n\tunsigned narenas;\n\tsize_t sz = sizeof(unsigned);\n\tsize_t mib[3];\n\tsize_t miblen = 3;\n\n\texpect_d_eq(mallctl(\"arena.0.decay\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctlnametomib(\"arena.0.decay\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = narenas;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n\n\tmib[1] = MALLCTL_ARENAS_ALL;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_dss) {\n\tconst char *dss_prec_old, *dss_prec_new;\n\tsize_t sz = sizeof(dss_prec_old);\n\tsize_t mib[3];\n\tsize_t miblen;\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.dss\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() error\");\n\n\tdss_prec_new = \"disabled\";\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_old, &sz,\n\t (void *)&dss_prec_new, sizeof(dss_prec_new)), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_str_ne(dss_prec_old, \"primary\",\n\t \"Unexpected default for dss precedence\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_new, &sz,\n\t (void *)&dss_prec_old, sizeof(dss_prec_old)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_old, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() failure\");\n\texpect_str_ne(dss_prec_old, \"primary\",\n\t \"Unexpected value for dss precedence\");\n\n\tmib[1] = narenas_total_get();\n\tdss_prec_new = \"disabled\";\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_old, &sz,\n\t (void *)&dss_prec_new, sizeof(dss_prec_new)), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_str_ne(dss_prec_old, \"primary\",\n\t \"Unexpected default for dss precedence\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_new, &sz,\n\t (void *)&dss_prec_old, sizeof(dss_prec_new)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&dss_prec_old, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() failure\");\n\texpect_str_ne(dss_prec_old, \"primary\",\n\t \"Unexpected value for dss precedence\");\n}\nTEST_END\n\nTEST_BEGIN(test_arena_i_retain_grow_limit) {\n\tsize_t old_limit, new_limit, default_limit;\n\tsize_t mib[3];\n\tsize_t miblen;\n\n\tbool retain_enabled;\n\tsize_t sz = sizeof(retain_enabled);\n\texpect_d_eq(mallctl(\"opt.retain\", &retain_enabled, &sz, NULL, 0),\n\t 0, \"Unexpected mallctl() failure\");\n\ttest_skip_if(!retain_enabled);\n\n\tsz = sizeof(default_limit);\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.retain_grow_limit\", mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib() error\");\n\n\texpect_d_eq(mallctlbymib(mib, miblen, &default_limit, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(default_limit, SC_LARGE_MAXCLASS,\n\t \"Unexpected default for retain_grow_limit\");\n\n\tnew_limit = PAGE - 1;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, &new_limit,\n\t sizeof(new_limit)), EFAULT, \"Unexpected mallctl() success\");\n\n\tnew_limit = PAGE + 1;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, &new_limit,\n\t sizeof(new_limit)), 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctlbymib(mib, miblen, &old_limit, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(old_limit, PAGE,\n\t \"Unexpected value for retain_grow_limit\");\n\n\t/* Expect grow less than psize class 10. */\n\tnew_limit = sz_pind2sz(10) - 1;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, &new_limit,\n\t sizeof(new_limit)), 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctlbymib(mib, miblen, &old_limit, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_zu_eq(old_limit, sz_pind2sz(9),\n\t \"Unexpected value for retain_grow_limit\");\n\n\t/* Restore to default. */\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, &default_limit,\n\t sizeof(default_limit)), 0, \"Unexpected mallctl() failure\");\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_dirty_decay_ms) {\n\tssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms;\n\tsize_t sz = sizeof(ssize_t);\n\n\texpect_d_eq(mallctl(\"arenas.dirty_decay_ms\",\n\t (void *)&orig_dirty_decay_ms, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tdirty_decay_ms = -2;\n\texpect_d_eq(mallctl(\"arenas.dirty_decay_ms\", NULL, NULL,\n\t (void *)&dirty_decay_ms, sizeof(ssize_t)), EFAULT,\n\t \"Unexpected mallctl() success\");\n\n\tdirty_decay_ms = 0x7fffffff;\n\texpect_d_eq(mallctl(\"arenas.dirty_decay_ms\", NULL, NULL,\n\t (void *)&dirty_decay_ms, sizeof(ssize_t)), 0,\n\t \"Expected mallctl() failure\");\n\n\tfor (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1;\n\t dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms,\n\t dirty_decay_ms++) {\n\t\tssize_t old_dirty_decay_ms;\n\n\t\texpect_d_eq(mallctl(\"arenas.dirty_decay_ms\",\n\t\t (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms,\n\t\t sizeof(ssize_t)), 0, \"Unexpected mallctl() failure\");\n\t\texpect_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms,\n\t\t \"Unexpected old arenas.dirty_decay_ms\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_muzzy_decay_ms) {\n\tssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms;\n\tsize_t sz = sizeof(ssize_t);\n\n\texpect_d_eq(mallctl(\"arenas.muzzy_decay_ms\",\n\t (void *)&orig_muzzy_decay_ms, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tmuzzy_decay_ms = -2;\n\texpect_d_eq(mallctl(\"arenas.muzzy_decay_ms\", NULL, NULL,\n\t (void *)&muzzy_decay_ms, sizeof(ssize_t)), EFAULT,\n\t \"Unexpected mallctl() success\");\n\n\tmuzzy_decay_ms = 0x7fffffff;\n\texpect_d_eq(mallctl(\"arenas.muzzy_decay_ms\", NULL, NULL,\n\t (void *)&muzzy_decay_ms, sizeof(ssize_t)), 0,\n\t \"Expected mallctl() failure\");\n\n\tfor (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1;\n\t muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms,\n\t muzzy_decay_ms++) {\n\t\tssize_t old_muzzy_decay_ms;\n\n\t\texpect_d_eq(mallctl(\"arenas.muzzy_decay_ms\",\n\t\t (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms,\n\t\t sizeof(ssize_t)), 0, \"Unexpected mallctl() failure\");\n\t\texpect_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms,\n\t\t \"Unexpected old arenas.muzzy_decay_ms\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_constants) {\n#define TEST_ARENAS_CONSTANT(t, name, expected) do {\t\t\t\\\n\tt name;\t\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\texpect_d_eq(mallctl(\"arenas.\"#name, (void *)&name, &sz, NULL,\t\\\n\t 0), 0, \"Unexpected mallctl() failure\");\t\t\t\\\n\texpect_zu_eq(name, expected, \"Incorrect \"#name\" size\");\t\t\\\n} while (0)\n\n\tTEST_ARENAS_CONSTANT(size_t, quantum, QUANTUM);\n\tTEST_ARENAS_CONSTANT(size_t, page, PAGE);\n\tTEST_ARENAS_CONSTANT(unsigned, nbins, SC_NBINS);\n\tTEST_ARENAS_CONSTANT(unsigned, nlextents, SC_NSIZES - SC_NBINS);\n\n#undef TEST_ARENAS_CONSTANT\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_bin_constants) {\n#define TEST_ARENAS_BIN_CONSTANT(t, name, expected) do {\t\t\\\n\tt name;\t\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\texpect_d_eq(mallctl(\"arenas.bin.0.\"#name, (void *)&name, &sz,\t\\\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\t\t\\\n\texpect_zu_eq(name, expected, \"Incorrect \"#name\" size\");\t\t\\\n} while (0)\n\n\tTEST_ARENAS_BIN_CONSTANT(size_t, size, bin_infos[0].reg_size);\n\tTEST_ARENAS_BIN_CONSTANT(uint32_t, nregs, bin_infos[0].nregs);\n\tTEST_ARENAS_BIN_CONSTANT(size_t, slab_size,\n\t bin_infos[0].slab_size);\n\tTEST_ARENAS_BIN_CONSTANT(uint32_t, nshards, bin_infos[0].n_shards);\n\n#undef TEST_ARENAS_BIN_CONSTANT\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_lextent_constants) {\n#define TEST_ARENAS_LEXTENT_CONSTANT(t, name, expected) do {\t\t\\\n\tt name;\t\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\texpect_d_eq(mallctl(\"arenas.lextent.0.\"#name, (void *)&name,\t\\\n\t &sz, NULL, 0), 0, \"Unexpected mallctl() failure\");\t\t\\\n\texpect_zu_eq(name, expected, \"Incorrect \"#name\" size\");\t\t\\\n} while (0)\n\n\tTEST_ARENAS_LEXTENT_CONSTANT(size_t, size,\n\t SC_LARGE_MINCLASS);\n\n#undef TEST_ARENAS_LEXTENT_CONSTANT\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_create) {\n\tunsigned narenas_before, arena, narenas_after;\n\tsize_t sz = sizeof(unsigned);\n\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas_before, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\texpect_d_eq(mallctl(\"arenas.narenas\", (void *)&narenas_after, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() failure\");\n\n\texpect_u_eq(narenas_before+1, narenas_after,\n\t \"Unexpected number of arenas before versus after extension\");\n\texpect_u_eq(arena, narenas_after-1, \"Unexpected arena index\");\n}\nTEST_END\n\nTEST_BEGIN(test_arenas_lookup) {\n\tunsigned arena, arena1;\n\tvoid *ptr;\n\tsize_t sz = sizeof(unsigned);\n\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\tptr = mallocx(42, MALLOCX_ARENA(arena) | MALLOCX_TCACHE_NONE);\n\texpect_ptr_not_null(ptr, \"Unexpected mallocx() failure\");\n\texpect_d_eq(mallctl(\"arenas.lookup\", &arena1, &sz, &ptr, sizeof(ptr)),\n\t 0, \"Unexpected mallctl() failure\");\n\texpect_u_eq(arena, arena1, \"Unexpected arena index\");\n\tdallocx(ptr, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_prof_active) {\n\t/*\n\t * If config_prof is off, then the test for prof_active in\n\t * test_mallctl_opt was already enough.\n\t */\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(opt_prof);\n\n\tbool active, old;\n\tsize_t len = sizeof(bool);\n\n\tactive = true;\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, &active, len), ENOENT,\n\t \"Setting prof_active to true should fail when opt_prof is off\");\n\told = true;\n\texpect_d_eq(mallctl(\"prof.active\", &old, &len, &active, len), ENOENT,\n\t \"Setting prof_active to true should fail when opt_prof is off\");\n\texpect_true(old, \"old value should not be touched when mallctl fails\");\n\tactive = false;\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, &active, len), 0,\n\t \"Setting prof_active to false should succeed when opt_prof is off\");\n\texpect_d_eq(mallctl(\"prof.active\", &old, &len, &active, len), 0,\n\t \"Setting prof_active to false should succeed when opt_prof is off\");\n\texpect_false(old, \"prof_active should be false when opt_prof is off\");\n}\nTEST_END\n\nTEST_BEGIN(test_stats_arenas) {\n#define TEST_STATS_ARENAS(t, name) do {\t\t\t\t\t\\\n\tt name;\t\t\t\t\t\t\t\t\\\n\tsize_t sz = sizeof(t);\t\t\t\t\t\t\\\n\texpect_d_eq(mallctl(\"stats.arenas.0.\"#name, (void *)&name, &sz,\t\\\n\t NULL, 0), 0, \"Unexpected mallctl() failure\");\t\t\\\n} while (0)\n\n\tTEST_STATS_ARENAS(unsigned, nthreads);\n\tTEST_STATS_ARENAS(const char *, dss);\n\tTEST_STATS_ARENAS(ssize_t, dirty_decay_ms);\n\tTEST_STATS_ARENAS(ssize_t, muzzy_decay_ms);\n\tTEST_STATS_ARENAS(size_t, pactive);\n\tTEST_STATS_ARENAS(size_t, pdirty);\n\n#undef TEST_STATS_ARENAS\n}\nTEST_END\n\nstatic void\nalloc_hook(void *extra, UNUSED hook_alloc_t type, UNUSED void *result,\n UNUSED uintptr_t result_raw, UNUSED uintptr_t args_raw[3]) {\n\t*(bool *)extra = true;\n}\n\nstatic void\ndalloc_hook(void *extra, UNUSED hook_dalloc_t type,\n UNUSED void *address, UNUSED uintptr_t args_raw[3]) {\n\t*(bool *)extra = true;\n}\n\nTEST_BEGIN(test_hooks) {\n\tbool hook_called = false;\n\thooks_t hooks = {&alloc_hook, &dalloc_hook, NULL, &hook_called};\n\tvoid *handle = NULL;\n\tsize_t sz = sizeof(handle);\n\tint err = mallctl(\"experimental.hooks.install\", &handle, &sz, &hooks,\n\t sizeof(hooks));\n\texpect_d_eq(err, 0, \"Hook installation failed\");\n\texpect_ptr_ne(handle, NULL, \"Hook installation gave null handle\");\n\tvoid *ptr = mallocx(1, 0);\n\texpect_true(hook_called, \"Alloc hook not called\");\n\thook_called = false;\n\tfree(ptr);\n\texpect_true(hook_called, \"Free hook not called\");\n\n\terr = mallctl(\"experimental.hooks.remove\", NULL, NULL, &handle,\n\t sizeof(handle));\n\texpect_d_eq(err, 0, \"Hook removal failed\");\n\thook_called = false;\n\tptr = mallocx(1, 0);\n\tfree(ptr);\n\texpect_false(hook_called, \"Hook called after removal\");\n}\nTEST_END\n\nTEST_BEGIN(test_hooks_exhaustion) {\n\tbool hook_called = false;\n\thooks_t hooks = {&alloc_hook, &dalloc_hook, NULL, &hook_called};\n\n\tvoid *handle;\n\tvoid *handles[HOOK_MAX];\n\tsize_t sz = sizeof(handle);\n\tint err;\n\tfor (int i = 0; i < HOOK_MAX; i++) {\n\t\thandle = NULL;\n\t\terr = mallctl(\"experimental.hooks.install\", &handle, &sz,\n\t\t &hooks, sizeof(hooks));\n\t\texpect_d_eq(err, 0, \"Error installation hooks\");\n\t\texpect_ptr_ne(handle, NULL, \"Got NULL handle\");\n\t\thandles[i] = handle;\n\t}\n\terr = mallctl(\"experimental.hooks.install\", &handle, &sz, &hooks,\n\t sizeof(hooks));\n\texpect_d_eq(err, EAGAIN, \"Should have failed hook installation\");\n\tfor (int i = 0; i < HOOK_MAX; i++) {\n\t\terr = mallctl(\"experimental.hooks.remove\", NULL, NULL,\n\t\t &handles[i], sizeof(handles[i]));\n\t\texpect_d_eq(err, 0, \"Hook removal failed\");\n\t}\n\t/* Insertion failed, but then we removed some; it should work now. */\n\thandle = NULL;\n\terr = mallctl(\"experimental.hooks.install\", &handle, &sz, &hooks,\n\t sizeof(hooks));\n\texpect_d_eq(err, 0, \"Hook insertion failed\");\n\texpect_ptr_ne(handle, NULL, \"Got NULL handle\");\n\terr = mallctl(\"experimental.hooks.remove\", NULL, NULL, &handle,\n\t sizeof(handle));\n\texpect_d_eq(err, 0, \"Hook removal failed\");\n}\nTEST_END\n\nTEST_BEGIN(test_thread_idle) {\n\t/*\n\t * We're cheating a little bit in this test, and inferring things about\n\t * implementation internals (like tcache details). We have to;\n\t * thread.idle has no guaranteed effects. We need stats to make these\n\t * inferences.\n\t */\n\ttest_skip_if(!config_stats);\n\n\tint err;\n\tsize_t sz;\n\tsize_t miblen;\n\n\tbool tcache_enabled = false;\n\tsz = sizeof(tcache_enabled);\n\terr = mallctl(\"thread.tcache.enabled\", &tcache_enabled, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\ttest_skip_if(!tcache_enabled);\n\n\tsize_t tcache_max;\n\tsz = sizeof(tcache_max);\n\terr = mallctl(\"arenas.tcache_max\", &tcache_max, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\ttest_skip_if(tcache_max == 0);\n\n\tunsigned arena_ind;\n\tsz = sizeof(arena_ind);\n\terr = mallctl(\"thread.arena\", &arena_ind, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\n\t/* We're going to do an allocation of size 1, which we know is small. */\n\tsize_t mib[5];\n\tmiblen = sizeof(mib)/sizeof(mib[0]);\n\terr = mallctlnametomib(\"stats.arenas.0.small.ndalloc\", mib, &miblen);\n\texpect_d_eq(err, 0, \"\");\n\tmib[2] = arena_ind;\n\n\t/*\n\t * This alloc and dalloc should leave something in the tcache, in a\n\t * small size's cache bin.\n\t */\n\tvoid *ptr = mallocx(1, 0);\n\tdallocx(ptr, 0);\n\n\tuint64_t epoch;\n\terr = mallctl(\"epoch\", NULL, NULL, &epoch, sizeof(epoch));\n\texpect_d_eq(err, 0, \"\");\n\n\tuint64_t small_dalloc_pre_idle;\n\tsz = sizeof(small_dalloc_pre_idle);\n\terr = mallctlbymib(mib, miblen, &small_dalloc_pre_idle, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\n\terr = mallctl(\"thread.idle\", NULL, NULL, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\n\terr = mallctl(\"epoch\", NULL, NULL, &epoch, sizeof(epoch));\n\texpect_d_eq(err, 0, \"\");\n\n\tuint64_t small_dalloc_post_idle;\n\tsz = sizeof(small_dalloc_post_idle);\n\terr = mallctlbymib(mib, miblen, &small_dalloc_post_idle, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\n\texpect_u64_lt(small_dalloc_pre_idle, small_dalloc_post_idle,\n\t \"Purge didn't flush the tcache\");\n}\nTEST_END\n\nTEST_BEGIN(test_thread_peak) {\n\ttest_skip_if(!config_stats);\n\n\t/*\n\t * We don't commit to any stable amount of accuracy for peak tracking\n\t * (in practice, when this test was written, we made sure to be within\n\t * 100k). But 10MB is big for more or less any definition of big.\n\t */\n\tsize_t big_size = 10 * 1024 * 1024;\n\tsize_t small_size = 256;\n\n\tvoid *ptr;\n\tint err;\n\tsize_t sz;\n\tuint64_t peak;\n\tsz = sizeof(uint64_t);\n\n\terr = mallctl(\"thread.peak.reset\", NULL, NULL, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\tptr = mallocx(SC_SMALL_MAXCLASS, 0);\n\terr = mallctl(\"thread.peak.read\", &peak, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\texpect_u64_eq(peak, SC_SMALL_MAXCLASS, \"Missed an update\");\n\tfree(ptr);\n\terr = mallctl(\"thread.peak.read\", &peak, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\texpect_u64_eq(peak, SC_SMALL_MAXCLASS, \"Freeing changed peak\");\n\tptr = mallocx(big_size, 0);\n\tfree(ptr);\n\t/*\n\t * The peak should have hit big_size in the last two lines, even though\n\t * the net allocated bytes has since dropped back down to zero. We\n\t * should have noticed the peak change without having down any mallctl\n\t * calls while net allocated bytes was high.\n\t */\n\terr = mallctl(\"thread.peak.read\", &peak, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\texpect_u64_ge(peak, big_size, \"Missed a peak change.\");\n\n\t/* Allocate big_size, but using small allocations. */\n\tsize_t nallocs = big_size / small_size;\n\tvoid **ptrs = calloc(nallocs, sizeof(void *));\n\terr = mallctl(\"thread.peak.reset\", NULL, NULL, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\terr = mallctl(\"thread.peak.read\", &peak, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\texpect_u64_eq(0, peak, \"Missed a reset.\");\n\tfor (size_t i = 0; i < nallocs; i++) {\n\t\tptrs[i] = mallocx(small_size, 0);\n\t}\n\tfor (size_t i = 0; i < nallocs; i++) {\n\t\tfree(ptrs[i]);\n\t}\n\terr = mallctl(\"thread.peak.read\", &peak, &sz, NULL, 0);\n\texpect_d_eq(err, 0, \"\");\n\t/*\n\t * We don't guarantee exactness; make sure we're within 10% of the peak,\n\t * though.\n\t */\n\texpect_u64_ge(peak, nallocx(small_size, 0) * nallocs * 9 / 10,\n\t \"Missed some peak changes.\");\n\texpect_u64_le(peak, nallocx(small_size, 0) * nallocs * 11 / 10,\n\t \"Overcounted peak changes.\");\n\tfree(ptrs);\n}\nTEST_END\n\ntypedef struct activity_test_data_s activity_test_data_t;\nstruct activity_test_data_s {\n\tuint64_t obtained_alloc;\n\tuint64_t obtained_dalloc;\n};\n\nstatic void\nactivity_test_callback(void *uctx, uint64_t alloc, uint64_t dalloc) {\n\tactivity_test_data_t *test_data = (activity_test_data_t *)uctx;\n\ttest_data->obtained_alloc = alloc;\n\ttest_data->obtained_dalloc = dalloc;\n}\n\nTEST_BEGIN(test_thread_activity_callback) {\n\ttest_skip_if(!config_stats);\n\n\tconst size_t big_size = 10 * 1024 * 1024;\n\tvoid *ptr;\n\tint err;\n\tsize_t sz;\n\n\tuint64_t *allocatedp;\n\tuint64_t *deallocatedp;\n\tsz = sizeof(allocatedp);\n\terr = mallctl(\"thread.allocatedp\", &allocatedp, &sz, NULL, 0);\n\tassert_d_eq(0, err, \"\");\n\terr = mallctl(\"thread.deallocatedp\", &deallocatedp, &sz, NULL, 0);\n\tassert_d_eq(0, err, \"\");\n\n\tactivity_callback_thunk_t old_thunk = {(activity_callback_t)111,\n\t\t(void *)222};\n\n\tactivity_test_data_t test_data = {333, 444};\n\tactivity_callback_thunk_t new_thunk =\n\t {&activity_test_callback, &test_data};\n\n\tsz = sizeof(old_thunk);\n\terr = mallctl(\"experimental.thread.activity_callback\", &old_thunk, &sz,\n\t &new_thunk, sizeof(new_thunk));\n\tassert_d_eq(0, err, \"\");\n\n\texpect_true(old_thunk.callback == NULL, \"Callback already installed\");\n\texpect_true(old_thunk.uctx == NULL, \"Callback data already installed\");\n\n\tptr = mallocx(big_size, 0);\n\texpect_u64_eq(test_data.obtained_alloc, *allocatedp, \"\");\n\texpect_u64_eq(test_data.obtained_dalloc, *deallocatedp, \"\");\n\n\tfree(ptr);\n\texpect_u64_eq(test_data.obtained_alloc, *allocatedp, \"\");\n\texpect_u64_eq(test_data.obtained_dalloc, *deallocatedp, \"\");\n\n\tsz = sizeof(old_thunk);\n\tnew_thunk = (activity_callback_thunk_t){ NULL, NULL };\n\terr = mallctl(\"experimental.thread.activity_callback\", &old_thunk, &sz,\n\t &new_thunk, sizeof(new_thunk));\n\tassert_d_eq(0, err, \"\");\n\n\texpect_true(old_thunk.callback == &activity_test_callback, \"\");\n\texpect_true(old_thunk.uctx == &test_data, \"\");\n\n\t/* Inserting NULL should have turned off tracking. */\n\ttest_data.obtained_alloc = 333;\n\ttest_data.obtained_dalloc = 444;\n\tptr = mallocx(big_size, 0);\n\tfree(ptr);\n\texpect_u64_eq(333, test_data.obtained_alloc, \"\");\n\texpect_u64_eq(444, test_data.obtained_dalloc, \"\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_mallctl_errors,\n\t test_mallctlnametomib_errors,\n\t test_mallctlbymib_errors,\n\t test_mallctl_read_write,\n\t test_mallctlnametomib_short_mib,\n\t test_mallctlnametomib_short_name,\n\t test_mallctlmibnametomib,\n\t test_mallctlbymibname,\n\t test_mallctl_config,\n\t test_mallctl_opt,\n\t test_manpage_example,\n\t test_tcache_none,\n\t test_tcache,\n\t test_thread_arena,\n\t test_arena_i_initialized,\n\t test_arena_i_dirty_decay_ms,\n\t test_arena_i_muzzy_decay_ms,\n\t test_arena_i_purge,\n\t test_arena_i_decay,\n\t test_arena_i_dss,\n\t test_arena_i_retain_grow_limit,\n\t test_arenas_dirty_decay_ms,\n\t test_arenas_muzzy_decay_ms,\n\t test_arenas_constants,\n\t test_arenas_bin_constants,\n\t test_arenas_lextent_constants,\n\t test_arenas_create,\n\t test_arenas_lookup,\n\t test_prof_active,\n\t test_stats_arenas,\n\t test_hooks,\n\t test_hooks_exhaustion,\n\t test_thread_idle,\n\t test_thread_peak,\n\t test_thread_activity_callback);\n}\n" }, { "path": "deps/jemalloc/test/unit/malloc_conf_2.c", "content": "#include \"test/jemalloc_test.h\"\n\nconst char *malloc_conf = \"dirty_decay_ms:1000\";\nconst char *malloc_conf_2_conf_harder = \"dirty_decay_ms:1234\";\n\nTEST_BEGIN(test_malloc_conf_2) {\n#ifdef _WIN32\n\tbool windows = true;\n#else\n\tbool windows = false;\n#endif\n\t/* Windows doesn't support weak symbol linker trickery. */\n\ttest_skip_if(windows);\n\n\tssize_t dirty_decay_ms;\n\tsize_t sz = sizeof(dirty_decay_ms);\n\n\tint err = mallctl(\"opt.dirty_decay_ms\", &dirty_decay_ms, &sz, NULL, 0);\n\tassert_d_eq(err, 0, \"Unexpected mallctl failure\");\n\texpect_zd_eq(dirty_decay_ms, 1234,\n\t \"malloc_conf_2 setting didn't take effect\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_malloc_conf_2);\n}\n" }, { "path": "deps/jemalloc/test/unit/malloc_conf_2.sh", "content": "export MALLOC_CONF=\"dirty_decay_ms:500\"\n" }, { "path": "deps/jemalloc/test/unit/malloc_io.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_malloc_strtoumax_no_endptr) {\n\tint err;\n\n\tset_errno(0);\n\texpect_ju_eq(malloc_strtoumax(\"0\", NULL, 0), 0, \"Unexpected result\");\n\terr = get_errno();\n\texpect_d_eq(err, 0, \"Unexpected failure\");\n}\nTEST_END\n\nTEST_BEGIN(test_malloc_strtoumax) {\n\tstruct test_s {\n\t\tconst char *input;\n\t\tconst char *expected_remainder;\n\t\tint base;\n\t\tint expected_errno;\n\t\tconst char *expected_errno_name;\n\t\tuintmax_t expected_x;\n\t};\n#define ERR(e)\t\te, #e\n#define KUMAX(x)\t((uintmax_t)x##ULL)\n#define KSMAX(x)\t((uintmax_t)(intmax_t)x##LL)\n\tstruct test_s tests[] = {\n\t\t{\"0\",\t\t\"0\",\t-1,\tERR(EINVAL),\tUINTMAX_MAX},\n\t\t{\"0\",\t\t\"0\",\t1,\tERR(EINVAL),\tUINTMAX_MAX},\n\t\t{\"0\",\t\t\"0\",\t37,\tERR(EINVAL),\tUINTMAX_MAX},\n\n\t\t{\"\",\t\t\"\",\t0,\tERR(EINVAL),\tUINTMAX_MAX},\n\t\t{\"+\",\t\t\"+\",\t0,\tERR(EINVAL),\tUINTMAX_MAX},\n\t\t{\"++3\",\t\t\"++3\",\t0,\tERR(EINVAL),\tUINTMAX_MAX},\n\t\t{\"-\",\t\t\"-\",\t0,\tERR(EINVAL),\tUINTMAX_MAX},\n\n\t\t{\"42\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(42)},\n\t\t{\"+42\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(42)},\n\t\t{\"-42\",\t\t\"\",\t0,\tERR(0),\t\tKSMAX(-42)},\n\t\t{\"042\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(042)},\n\t\t{\"+042\",\t\"\",\t0,\tERR(0),\t\tKUMAX(042)},\n\t\t{\"-042\",\t\"\",\t0,\tERR(0),\t\tKSMAX(-042)},\n\t\t{\"0x42\",\t\"\",\t0,\tERR(0),\t\tKUMAX(0x42)},\n\t\t{\"+0x42\",\t\"\",\t0,\tERR(0),\t\tKUMAX(0x42)},\n\t\t{\"-0x42\",\t\"\",\t0,\tERR(0),\t\tKSMAX(-0x42)},\n\n\t\t{\"0\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"1\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(1)},\n\n\t\t{\"42\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(42)},\n\t\t{\" 42\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(42)},\n\t\t{\"42 \",\t\t\" \",\t0,\tERR(0),\t\tKUMAX(42)},\n\t\t{\"0x\",\t\t\"x\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"42x\",\t\t\"x\",\t0,\tERR(0),\t\tKUMAX(42)},\n\n\t\t{\"07\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(7)},\n\t\t{\"010\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(8)},\n\t\t{\"08\",\t\t\"8\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"0_\",\t\t\"_\",\t0,\tERR(0),\t\tKUMAX(0)},\n\n\t\t{\"0x\",\t\t\"x\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"0X\",\t\t\"X\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"0xg\",\t\t\"xg\",\t0,\tERR(0),\t\tKUMAX(0)},\n\t\t{\"0XA\",\t\t\"\",\t0,\tERR(0),\t\tKUMAX(10)},\n\n\t\t{\"010\",\t\t\"\",\t10,\tERR(0),\t\tKUMAX(10)},\n\t\t{\"0x3\",\t\t\"x3\",\t10,\tERR(0),\t\tKUMAX(0)},\n\n\t\t{\"12\",\t\t\"2\",\t2,\tERR(0),\t\tKUMAX(1)},\n\t\t{\"78\",\t\t\"8\",\t8,\tERR(0),\t\tKUMAX(7)},\n\t\t{\"9a\",\t\t\"a\",\t10,\tERR(0),\t\tKUMAX(9)},\n\t\t{\"9A\",\t\t\"A\",\t10,\tERR(0),\t\tKUMAX(9)},\n\t\t{\"fg\",\t\t\"g\",\t16,\tERR(0),\t\tKUMAX(15)},\n\t\t{\"FG\",\t\t\"G\",\t16,\tERR(0),\t\tKUMAX(15)},\n\t\t{\"0xfg\",\t\"g\",\t16,\tERR(0),\t\tKUMAX(15)},\n\t\t{\"0XFG\",\t\"G\",\t16,\tERR(0),\t\tKUMAX(15)},\n\t\t{\"z_\",\t\t\"_\",\t36,\tERR(0),\t\tKUMAX(35)},\n\t\t{\"Z_\",\t\t\"_\",\t36,\tERR(0),\t\tKUMAX(35)}\n\t};\n#undef ERR\n#undef KUMAX\n#undef KSMAX\n\tunsigned i;\n\n\tfor (i = 0; i < sizeof(tests)/sizeof(struct test_s); i++) {\n\t\tstruct test_s *test = &tests[i];\n\t\tint err;\n\t\tuintmax_t result;\n\t\tchar *remainder;\n\n\t\tset_errno(0);\n\t\tresult = malloc_strtoumax(test->input, &remainder, test->base);\n\t\terr = get_errno();\n\t\texpect_d_eq(err, test->expected_errno,\n\t\t \"Expected errno %s for \\\"%s\\\", base %d\",\n\t\t test->expected_errno_name, test->input, test->base);\n\t\texpect_str_eq(remainder, test->expected_remainder,\n\t\t \"Unexpected remainder for \\\"%s\\\", base %d\",\n\t\t test->input, test->base);\n\t\tif (err == 0) {\n\t\t\texpect_ju_eq(result, test->expected_x,\n\t\t\t \"Unexpected result for \\\"%s\\\", base %d\",\n\t\t\t test->input, test->base);\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_malloc_snprintf_truncated) {\n#define BUFLEN\t15\n\tchar buf[BUFLEN];\n\tsize_t result;\n\tsize_t len;\n#define TEST(expected_str_untruncated, ...) do {\t\t\t\\\n\tresult = malloc_snprintf(buf, len, __VA_ARGS__);\t\t\\\n\texpect_d_eq(strncmp(buf, expected_str_untruncated, len-1), 0,\t\\\n\t \"Unexpected string inequality (\\\"%s\\\" vs \\\"%s\\\")\",\t\t\\\n\t buf, expected_str_untruncated);\t\t\t\t\\\n\texpect_zu_eq(result, strlen(expected_str_untruncated),\t\t\\\n\t \"Unexpected result\");\t\t\t\t\t\\\n} while (0)\n\n\tfor (len = 1; len < BUFLEN; len++) {\n\t\tTEST(\"012346789\",\t\"012346789\");\n\t\tTEST(\"a0123b\",\t\t\"a%sb\", \"0123\");\n\t\tTEST(\"a01234567\",\t\"a%s%s\", \"0123\", \"4567\");\n\t\tTEST(\"a0123 \",\t\t\"a%-6s\", \"0123\");\n\t\tTEST(\"a 0123\",\t\t\"a%6s\", \"0123\");\n\t\tTEST(\"a 012\",\t\t\"a%6.3s\", \"0123\");\n\t\tTEST(\"a 012\",\t\t\"a%*.*s\", 6, 3, \"0123\");\n\t\tTEST(\"a 123b\",\t\t\"a% db\", 123);\n\t\tTEST(\"a123b\",\t\t\"a%-db\", 123);\n\t\tTEST(\"a-123b\",\t\t\"a%-db\", -123);\n\t\tTEST(\"a+123b\",\t\t\"a%+db\", 123);\n\t}\n#undef BUFLEN\n#undef TEST\n}\nTEST_END\n\nTEST_BEGIN(test_malloc_snprintf) {\n#define BUFLEN\t128\n\tchar buf[BUFLEN];\n\tsize_t result;\n#define TEST(expected_str, ...) do {\t\t\t\t\t\\\n\tresult = malloc_snprintf(buf, sizeof(buf), __VA_ARGS__);\t\\\n\texpect_str_eq(buf, expected_str, \"Unexpected output\");\t\t\\\n\texpect_zu_eq(result, strlen(expected_str), \"Unexpected result\");\\\n} while (0)\n\n\tTEST(\"hello\", \"hello\");\n\n\tTEST(\"50%, 100%\", \"50%%, %d%%\", 100);\n\n\tTEST(\"a0123b\", \"a%sb\", \"0123\");\n\n\tTEST(\"a 0123b\", \"a%5sb\", \"0123\");\n\tTEST(\"a 0123b\", \"a%*sb\", 5, \"0123\");\n\n\tTEST(\"a0123 b\", \"a%-5sb\", \"0123\");\n\tTEST(\"a0123b\", \"a%*sb\", -1, \"0123\");\n\tTEST(\"a0123 b\", \"a%*sb\", -5, \"0123\");\n\tTEST(\"a0123 b\", \"a%-*sb\", -5, \"0123\");\n\n\tTEST(\"a012b\", \"a%.3sb\", \"0123\");\n\tTEST(\"a012b\", \"a%.*sb\", 3, \"0123\");\n\tTEST(\"a0123b\", \"a%.*sb\", -3, \"0123\");\n\n\tTEST(\"a 012b\", \"a%5.3sb\", \"0123\");\n\tTEST(\"a 012b\", \"a%5.*sb\", 3, \"0123\");\n\tTEST(\"a 012b\", \"a%*.3sb\", 5, \"0123\");\n\tTEST(\"a 012b\", \"a%*.*sb\", 5, 3, \"0123\");\n\tTEST(\"a 0123b\", \"a%*.*sb\", 5, -3, \"0123\");\n\n\tTEST(\"_abcd_\", \"_%x_\", 0xabcd);\n\tTEST(\"_0xabcd_\", \"_%#x_\", 0xabcd);\n\tTEST(\"_1234_\", \"_%o_\", 01234);\n\tTEST(\"_01234_\", \"_%#o_\", 01234);\n\tTEST(\"_1234_\", \"_%u_\", 1234);\n\tTEST(\"01234\", \"%05u\", 1234);\n\n\tTEST(\"_1234_\", \"_%d_\", 1234);\n\tTEST(\"_ 1234_\", \"_% d_\", 1234);\n\tTEST(\"_+1234_\", \"_%+d_\", 1234);\n\tTEST(\"_-1234_\", \"_%d_\", -1234);\n\tTEST(\"_-1234_\", \"_% d_\", -1234);\n\tTEST(\"_-1234_\", \"_%+d_\", -1234);\n\n\t/*\n\t * Morally, we should test these too, but 0-padded signed types are not\n\t * yet supported.\n\t *\n\t * TEST(\"01234\", \"%05\", 1234);\n\t * TEST(\"-1234\", \"%05d\", -1234);\n\t * TEST(\"-01234\", \"%06d\", -1234);\n\t*/\n\n\tTEST(\"_-1234_\", \"_%d_\", -1234);\n\tTEST(\"_1234_\", \"_%d_\", 1234);\n\tTEST(\"_-1234_\", \"_%i_\", -1234);\n\tTEST(\"_1234_\", \"_%i_\", 1234);\n\tTEST(\"_01234_\", \"_%#o_\", 01234);\n\tTEST(\"_1234_\", \"_%u_\", 1234);\n\tTEST(\"_0x1234abc_\", \"_%#x_\", 0x1234abc);\n\tTEST(\"_0X1234ABC_\", \"_%#X_\", 0x1234abc);\n\tTEST(\"_c_\", \"_%c_\", 'c');\n\tTEST(\"_string_\", \"_%s_\", \"string\");\n\tTEST(\"_0x42_\", \"_%p_\", ((void *)0x42));\n\n\tTEST(\"_-1234_\", \"_%ld_\", ((long)-1234));\n\tTEST(\"_1234_\", \"_%ld_\", ((long)1234));\n\tTEST(\"_-1234_\", \"_%li_\", ((long)-1234));\n\tTEST(\"_1234_\", \"_%li_\", ((long)1234));\n\tTEST(\"_01234_\", \"_%#lo_\", ((long)01234));\n\tTEST(\"_1234_\", \"_%lu_\", ((long)1234));\n\tTEST(\"_0x1234abc_\", \"_%#lx_\", ((long)0x1234abc));\n\tTEST(\"_0X1234ABC_\", \"_%#lX_\", ((long)0x1234ABC));\n\n\tTEST(\"_-1234_\", \"_%lld_\", ((long long)-1234));\n\tTEST(\"_1234_\", \"_%lld_\", ((long long)1234));\n\tTEST(\"_-1234_\", \"_%lli_\", ((long long)-1234));\n\tTEST(\"_1234_\", \"_%lli_\", ((long long)1234));\n\tTEST(\"_01234_\", \"_%#llo_\", ((long long)01234));\n\tTEST(\"_1234_\", \"_%llu_\", ((long long)1234));\n\tTEST(\"_0x1234abc_\", \"_%#llx_\", ((long long)0x1234abc));\n\tTEST(\"_0X1234ABC_\", \"_%#llX_\", ((long long)0x1234ABC));\n\n\tTEST(\"_-1234_\", \"_%qd_\", ((long long)-1234));\n\tTEST(\"_1234_\", \"_%qd_\", ((long long)1234));\n\tTEST(\"_-1234_\", \"_%qi_\", ((long long)-1234));\n\tTEST(\"_1234_\", \"_%qi_\", ((long long)1234));\n\tTEST(\"_01234_\", \"_%#qo_\", ((long long)01234));\n\tTEST(\"_1234_\", \"_%qu_\", ((long long)1234));\n\tTEST(\"_0x1234abc_\", \"_%#qx_\", ((long long)0x1234abc));\n\tTEST(\"_0X1234ABC_\", \"_%#qX_\", ((long long)0x1234ABC));\n\n\tTEST(\"_-1234_\", \"_%jd_\", ((intmax_t)-1234));\n\tTEST(\"_1234_\", \"_%jd_\", ((intmax_t)1234));\n\tTEST(\"_-1234_\", \"_%ji_\", ((intmax_t)-1234));\n\tTEST(\"_1234_\", \"_%ji_\", ((intmax_t)1234));\n\tTEST(\"_01234_\", \"_%#jo_\", ((intmax_t)01234));\n\tTEST(\"_1234_\", \"_%ju_\", ((intmax_t)1234));\n\tTEST(\"_0x1234abc_\", \"_%#jx_\", ((intmax_t)0x1234abc));\n\tTEST(\"_0X1234ABC_\", \"_%#jX_\", ((intmax_t)0x1234ABC));\n\n\tTEST(\"_1234_\", \"_%td_\", ((ptrdiff_t)1234));\n\tTEST(\"_-1234_\", \"_%td_\", ((ptrdiff_t)-1234));\n\tTEST(\"_1234_\", \"_%ti_\", ((ptrdiff_t)1234));\n\tTEST(\"_-1234_\", \"_%ti_\", ((ptrdiff_t)-1234));\n\n\tTEST(\"_-1234_\", \"_%zd_\", ((ssize_t)-1234));\n\tTEST(\"_1234_\", \"_%zd_\", ((ssize_t)1234));\n\tTEST(\"_-1234_\", \"_%zi_\", ((ssize_t)-1234));\n\tTEST(\"_1234_\", \"_%zi_\", ((ssize_t)1234));\n\tTEST(\"_01234_\", \"_%#zo_\", ((ssize_t)01234));\n\tTEST(\"_1234_\", \"_%zu_\", ((ssize_t)1234));\n\tTEST(\"_0x1234abc_\", \"_%#zx_\", ((ssize_t)0x1234abc));\n\tTEST(\"_0X1234ABC_\", \"_%#zX_\", ((ssize_t)0x1234ABC));\n#undef BUFLEN\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_malloc_strtoumax_no_endptr,\n\t test_malloc_strtoumax,\n\t test_malloc_snprintf_truncated,\n\t test_malloc_snprintf);\n}\n" }, { "path": "deps/jemalloc/test/unit/math.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define MAX_REL_ERR 1.0e-9\n#define MAX_ABS_ERR 1.0e-9\n\n#include \n\n#ifdef __PGI\n#undef INFINITY\n#endif\n\n#ifndef INFINITY\n#define INFINITY (DBL_MAX + DBL_MAX)\n#endif\n\nstatic bool\ndouble_eq_rel(double a, double b, double max_rel_err, double max_abs_err) {\n\tdouble rel_err;\n\n\tif (fabs(a - b) < max_abs_err) {\n\t\treturn true;\n\t}\n\trel_err = (fabs(b) > fabs(a)) ? fabs((a-b)/b) : fabs((a-b)/a);\n\treturn (rel_err < max_rel_err);\n}\n\nstatic uint64_t\nfactorial(unsigned x) {\n\tuint64_t ret = 1;\n\tunsigned i;\n\n\tfor (i = 2; i <= x; i++) {\n\t\tret *= (uint64_t)i;\n\t}\n\n\treturn ret;\n}\n\nTEST_BEGIN(test_ln_gamma_factorial) {\n\tunsigned x;\n\n\t/* exp(ln_gamma(x)) == (x-1)! for integer x. */\n\tfor (x = 1; x <= 21; x++) {\n\t\texpect_true(double_eq_rel(exp(ln_gamma(x)),\n\t\t (double)factorial(x-1), MAX_REL_ERR, MAX_ABS_ERR),\n\t\t \"Incorrect factorial result for x=%u\", x);\n\t}\n}\nTEST_END\n\n/* Expected ln_gamma([0.0..100.0] increment=0.25). */\nstatic const double ln_gamma_misc_expected[] = {\n\tINFINITY,\n\t1.28802252469807743, 0.57236494292470008, 0.20328095143129538,\n\t0.00000000000000000, -0.09827183642181320, -0.12078223763524518,\n\t-0.08440112102048555, 0.00000000000000000, 0.12487171489239651,\n\t0.28468287047291918, 0.47521466691493719, 0.69314718055994529,\n\t0.93580193110872523, 1.20097360234707429, 1.48681557859341718,\n\t1.79175946922805496, 2.11445692745037128, 2.45373657084244234,\n\t2.80857141857573644, 3.17805383034794575, 3.56137591038669710,\n\t3.95781396761871651, 4.36671603662228680, 4.78749174278204581,\n\t5.21960398699022932, 5.66256205985714178, 6.11591589143154568,\n\t6.57925121201010121, 7.05218545073853953, 7.53436423675873268,\n\t8.02545839631598312, 8.52516136106541467, 9.03318691960512332,\n\t9.54926725730099690, 10.07315123968123949, 10.60460290274525086,\n\t11.14340011995171231, 11.68933342079726856, 12.24220494005076176,\n\t12.80182748008146909, 13.36802367147604720, 13.94062521940376342,\n\t14.51947222506051816, 15.10441257307551943, 15.69530137706046524,\n\t16.29200047656724237, 16.89437797963419285, 17.50230784587389010,\n\t18.11566950571089407, 18.73434751193644843, 19.35823122022435427,\n\t19.98721449566188468, 20.62119544270163018, 21.26007615624470048,\n\t21.90376249182879320, 22.55216385312342098, 23.20519299513386002,\n\t23.86276584168908954, 24.52480131594137802, 25.19122118273868338,\n\t25.86194990184851861, 26.53691449111561340, 27.21604439872720604,\n\t27.89927138384089389, 28.58652940490193828, 29.27775451504081516,\n\t29.97288476399884871, 30.67186010608067548, 31.37462231367769050,\n\t32.08111489594735843, 32.79128302226991565, 33.50507345013689076,\n\t34.22243445715505317, 34.94331577687681545, 35.66766853819134298,\n\t36.39544520803305261, 37.12659953718355865, 37.86108650896109395,\n\t38.59886229060776230, 39.33988418719949465, 40.08411059791735198,\n\t40.83150097453079752, 41.58201578195490100, 42.33561646075348506,\n\t43.09226539146988699, 43.85192586067515208, 44.61456202863158893,\n\t45.38013889847690052, 46.14862228684032885, 46.91997879580877395,\n\t47.69417578616628361, 48.47118135183522014, 49.25096429545256882,\n\t50.03349410501914463, 50.81874093156324790, 51.60667556776436982,\n\t52.39726942748592364, 53.19049452616926743, 53.98632346204390586,\n\t54.78472939811231157, 55.58568604486942633, 56.38916764371992940,\n\t57.19514895105859864, 58.00360522298051080, 58.81451220059079787,\n\t59.62784609588432261, 60.44358357816834371, 61.26170176100199427,\n\t62.08217818962842927, 62.90499082887649962, 63.73011805151035958,\n\t64.55753862700632340, 65.38723171073768015, 66.21917683354901385,\n\t67.05335389170279825, 67.88974313718154008, 68.72832516833013017,\n\t69.56908092082363737, 70.41199165894616385, 71.25703896716800045,\n\t72.10420474200799390, 72.95347118416940191, 73.80482079093779646,\n\t74.65823634883015814, 75.51370092648485866, 76.37119786778275454,\n\t77.23071078519033961, 78.09222355331530707, 78.95572030266725960,\n\t79.82118541361435859, 80.68860351052903468, 81.55795945611502873,\n\t82.42923834590904164, 83.30242550295004378, 84.17750647261028973,\n\t85.05446701758152983, 85.93329311301090456, 86.81397094178107920,\n\t87.69648688992882057, 88.58082754219766741, 89.46697967771913795,\n\t90.35493026581838194, 91.24466646193963015, 92.13617560368709292,\n\t93.02944520697742803, 93.92446296229978486, 94.82121673107967297,\n\t95.71969454214321615, 96.61988458827809723, 97.52177522288820910,\n\t98.42535495673848800, 99.33061245478741341, 100.23753653310367895,\n\t101.14611615586458981, 102.05634043243354370, 102.96819861451382394,\n\t103.88168009337621811, 104.79677439715833032, 105.71347118823287303,\n\t106.63176026064346047, 107.55163153760463501, 108.47307506906540198,\n\t109.39608102933323153, 110.32063971475740516, 111.24674154146920557,\n\t112.17437704317786995, 113.10353686902013237, 114.03421178146170689,\n\t114.96639265424990128, 115.90007047041454769, 116.83523632031698014,\n\t117.77188139974506953, 118.70999700805310795, 119.64957454634490830,\n\t120.59060551569974962, 121.53308151543865279, 122.47699424143097247,\n\t123.42233548443955726, 124.36909712850338394, 125.31727114935689826,\n\t126.26684961288492559, 127.21782467361175861, 128.17018857322420899,\n\t129.12393363912724453, 130.07905228303084755, 131.03553699956862033,\n\t131.99338036494577864, 132.95257503561629164, 133.91311374698926784,\n\t134.87498931216194364, 135.83819462068046846, 136.80272263732638294,\n\t137.76856640092901785, 138.73571902320256299, 139.70417368760718091,\n\t140.67392364823425055, 141.64496222871400732, 142.61728282114600574,\n\t143.59087888505104047, 144.56574394634486680, 145.54187159633210058,\n\t146.51925549072063859, 147.49788934865566148, 148.47776695177302031,\n\t149.45888214327129617, 150.44122882700193600, 151.42480096657754984,\n\t152.40959258449737490, 153.39559776128982094, 154.38281063467164245,\n\t155.37122539872302696, 156.36083630307879844, 157.35163765213474107,\n\t158.34362380426921391, 159.33678917107920370, 160.33112821663092973,\n\t161.32663545672428995, 162.32330545817117695, 163.32113283808695314,\n\t164.32011226319519892, 165.32023844914485267, 166.32150615984036790,\n\t167.32391020678358018, 168.32744544842768164, 169.33210678954270634,\n\t170.33788918059275375, 171.34478761712384198, 172.35279713916281707,\n\t173.36191283062726143, 174.37212981874515094, 175.38344327348534080,\n\t176.39584840699734514, 177.40934047306160437, 178.42391476654847793,\n\t179.43956662288721304, 180.45629141754378111, 181.47408456550741107,\n\t182.49294152078630304, 183.51285777591152737, 184.53382886144947861,\n\t185.55585034552262869, 186.57891783333786861, 187.60302696672312095,\n\t188.62817342367162610, 189.65435291789341932, 190.68156119837468054,\n\t191.70979404894376330, 192.73904728784492590, 193.76931676731820176,\n\t194.80059837318714244, 195.83288802445184729, 196.86618167288995096,\n\t197.90047530266301123, 198.93576492992946214, 199.97204660246373464,\n\t201.00931639928148797, 202.04757043027063901, 203.08680483582807597,\n\t204.12701578650228385, 205.16819948264117102, 206.21035215404597807,\n\t207.25347005962987623, 208.29754948708190909, 209.34258675253678916,\n\t210.38857820024875878, 211.43552020227099320, 212.48340915813977858,\n\t213.53224149456323744, 214.58201366511514152, 215.63272214993284592,\n\t216.68436345542014010, 217.73693411395422004, 218.79043068359703739,\n\t219.84484974781133815, 220.90018791517996988, 221.95644181913033322,\n\t223.01360811766215875, 224.07168349307951871, 225.13066465172661879,\n\t226.19054832372759734, 227.25133126272962159, 228.31301024565024704,\n\t229.37558207242807384, 230.43904356577689896, 231.50339157094342113,\n\t232.56862295546847008, 233.63473460895144740, 234.70172344281823484,\n\t235.76958639009222907, 236.83832040516844586, 237.90792246359117712,\n\t238.97838956183431947, 240.04971871708477238, 241.12190696702904802,\n\t242.19495136964280846, 243.26884900298270509, 244.34359696498191283,\n\t245.41919237324782443, 246.49563236486270057, 247.57291409618682110,\n\t248.65103474266476269, 249.72999149863338175, 250.80978157713354904,\n\t251.89040220972316320, 252.97185064629374551, 254.05412415488834199,\n\t255.13722002152300661, 256.22113555000953511, 257.30586806178126835,\n\t258.39141489572085675, 259.47777340799029844, 260.56494097186322279,\n\t261.65291497755913497, 262.74169283208021852, 263.83127195904967266,\n\t264.92164979855277807, 266.01282380697938379, 267.10479145686849733,\n\t268.19755023675537586, 269.29109765101975427, 270.38543121973674488,\n\t271.48054847852881721, 272.57644697842033565, 273.67312428569374561,\n\t274.77057798174683967, 275.86880566295326389, 276.96780494052313770,\n\t278.06757344036617496, 279.16810880295668085, 280.26940868320008349,\n\t281.37147075030043197, 282.47429268763045229, 283.57787219260217171,\n\t284.68220697654078322, 285.78729476455760050, 286.89313329542699194,\n\t287.99972032146268930, 289.10705360839756395, 290.21513093526289140,\n\t291.32395009427028754, 292.43350889069523646, 293.54380514276073200,\n\t294.65483668152336350, 295.76660135076059532, 296.87909700685889902,\n\t297.99232151870342022, 299.10627276756946458, 300.22094864701409733,\n\t301.33634706277030091, 302.45246593264130297, 303.56930318639643929,\n\t304.68685676566872189, 305.80512462385280514, 306.92410472600477078,\n\t308.04379504874236773, 309.16419358014690033, 310.28529831966631036,\n\t311.40710727801865687, 312.52961847709792664, 313.65282994987899201,\n\t314.77673974032603610, 315.90134590329950015, 317.02664650446632777,\n\t318.15263962020929966, 319.27932333753892635, 320.40669575400545455,\n\t321.53475497761127144, 322.66349912672620803, 323.79292633000159185,\n\t324.92303472628691452, 326.05382246454587403, 327.18528770377525916,\n\t328.31742861292224234, 329.45024337080525356, 330.58373016603343331,\n\t331.71788719692847280, 332.85271267144611329, 333.98820480709991898,\n\t335.12436183088397001, 336.26118197919845443, 337.39866349777429377,\n\t338.53680464159958774, 339.67560367484657036, 340.81505887079896411,\n\t341.95516851178109619, 343.09593088908627578, 344.23734430290727460,\n\t345.37940706226686416, 346.52211748494903532, 347.66547389743118401,\n\t348.80947463481720661, 349.95411804077025408, 351.09940246744753267,\n\t352.24532627543504759, 353.39188783368263103, 354.53908551944078908,\n\t355.68691771819692349, 356.83538282361303118, 357.98447923746385868,\n\t359.13420536957539753\n};\n\nTEST_BEGIN(test_ln_gamma_misc) {\n\tunsigned i;\n\n\tfor (i = 1; i < sizeof(ln_gamma_misc_expected)/sizeof(double); i++) {\n\t\tdouble x = (double)i * 0.25;\n\t\texpect_true(double_eq_rel(ln_gamma(x),\n\t\t ln_gamma_misc_expected[i], MAX_REL_ERR, MAX_ABS_ERR),\n\t\t \"Incorrect ln_gamma result for i=%u\", i);\n\t}\n}\nTEST_END\n\n/* Expected pt_norm([0.01..0.99] increment=0.01). */\nstatic const double pt_norm_expected[] = {\n\t-INFINITY,\n\t-2.32634787404084076, -2.05374891063182252, -1.88079360815125085,\n\t-1.75068607125216946, -1.64485362695147264, -1.55477359459685305,\n\t-1.47579102817917063, -1.40507156030963221, -1.34075503369021654,\n\t-1.28155156554460081, -1.22652812003661049, -1.17498679206608991,\n\t-1.12639112903880045, -1.08031934081495606, -1.03643338949378938,\n\t-0.99445788320975281, -0.95416525314619416, -0.91536508784281390,\n\t-0.87789629505122846, -0.84162123357291418, -0.80642124701824025,\n\t-0.77219321418868492, -0.73884684918521371, -0.70630256284008752,\n\t-0.67448975019608171, -0.64334540539291685, -0.61281299101662701,\n\t-0.58284150727121620, -0.55338471955567281, -0.52440051270804067,\n\t-0.49585034734745320, -0.46769879911450812, -0.43991316567323380,\n\t-0.41246312944140462, -0.38532046640756751, -0.35845879325119373,\n\t-0.33185334643681652, -0.30548078809939738, -0.27931903444745404,\n\t-0.25334710313579978, -0.22754497664114931, -0.20189347914185077,\n\t-0.17637416478086135, -0.15096921549677725, -0.12566134685507399,\n\t-0.10043372051146975, -0.07526986209982976, -0.05015358346473352,\n\t-0.02506890825871106, 0.00000000000000000, 0.02506890825871106,\n\t0.05015358346473366, 0.07526986209982990, 0.10043372051146990,\n\t0.12566134685507413, 0.15096921549677739, 0.17637416478086146,\n\t0.20189347914185105, 0.22754497664114931, 0.25334710313579978,\n\t0.27931903444745404, 0.30548078809939738, 0.33185334643681652,\n\t0.35845879325119373, 0.38532046640756762, 0.41246312944140484,\n\t0.43991316567323391, 0.46769879911450835, 0.49585034734745348,\n\t0.52440051270804111, 0.55338471955567303, 0.58284150727121620,\n\t0.61281299101662701, 0.64334540539291685, 0.67448975019608171,\n\t0.70630256284008752, 0.73884684918521371, 0.77219321418868492,\n\t0.80642124701824036, 0.84162123357291441, 0.87789629505122879,\n\t0.91536508784281423, 0.95416525314619460, 0.99445788320975348,\n\t1.03643338949378938, 1.08031934081495606, 1.12639112903880045,\n\t1.17498679206608991, 1.22652812003661049, 1.28155156554460081,\n\t1.34075503369021654, 1.40507156030963265, 1.47579102817917085,\n\t1.55477359459685394, 1.64485362695147308, 1.75068607125217102,\n\t1.88079360815125041, 2.05374891063182208, 2.32634787404084076\n};\n\nTEST_BEGIN(test_pt_norm) {\n\tunsigned i;\n\n\tfor (i = 1; i < sizeof(pt_norm_expected)/sizeof(double); i++) {\n\t\tdouble p = (double)i * 0.01;\n\t\texpect_true(double_eq_rel(pt_norm(p), pt_norm_expected[i],\n\t\t MAX_REL_ERR, MAX_ABS_ERR),\n\t\t \"Incorrect pt_norm result for i=%u\", i);\n\t}\n}\nTEST_END\n\n/*\n * Expected pt_chi2(p=[0.01..0.99] increment=0.07,\n * df={0.1, 1.1, 10.1, 100.1, 1000.1}).\n */\nstatic const double pt_chi2_df[] = {0.1, 1.1, 10.1, 100.1, 1000.1};\nstatic const double pt_chi2_expected[] = {\n\t1.168926411457320e-40, 1.347680397072034e-22, 3.886980416666260e-17,\n\t8.245951724356564e-14, 2.068936347497604e-11, 1.562561743309233e-09,\n\t5.459543043426564e-08, 1.114775688149252e-06, 1.532101202364371e-05,\n\t1.553884683726585e-04, 1.239396954915939e-03, 8.153872320255721e-03,\n\t4.631183739647523e-02, 2.473187311701327e-01, 2.175254800183617e+00,\n\n\t0.0003729887888876379, 0.0164409238228929513, 0.0521523015190650113,\n\t0.1064701372271216612, 0.1800913735793082115, 0.2748704281195626931,\n\t0.3939246282787986497, 0.5420727552260817816, 0.7267265822221973259,\n\t0.9596554296000253670, 1.2607440376386165326, 1.6671185084541604304,\n\t2.2604828984738705167, 3.2868613342148607082, 6.9298574921692139839,\n\n\t2.606673548632508, 4.602913725294877, 5.646152813924212,\n\t6.488971315540869, 7.249823275816285, 7.977314231410841,\n\t8.700354939944047, 9.441728024225892, 10.224338321374127,\n\t11.076435368801061, 12.039320937038386, 13.183878752697167,\n\t14.657791935084575, 16.885728216339373, 23.361991680031817,\n\n\t70.14844087392152, 80.92379498849355, 85.53325420085891,\n\t88.94433120715347, 91.83732712857017, 94.46719943606301,\n\t96.96896479994635, 99.43412843510363, 101.94074719829733,\n\t104.57228644307247, 107.43900093448734, 110.71844673417287,\n\t114.76616819871325, 120.57422505959563, 135.92318818757556,\n\n\t899.0072447849649, 937.9271278858220, 953.8117189560207,\n\t965.3079371501154, 974.8974061207954, 983.4936235182347,\n\t991.5691170518946, 999.4334123954690, 1007.3391826856553,\n\t1015.5445154999951, 1024.3777075619569, 1034.3538789836223,\n\t1046.4872561869577, 1063.5717461999654, 1107.0741966053859\n};\n\nTEST_BEGIN(test_pt_chi2) {\n\tunsigned i, j;\n\tunsigned e = 0;\n\n\tfor (i = 0; i < sizeof(pt_chi2_df)/sizeof(double); i++) {\n\t\tdouble df = pt_chi2_df[i];\n\t\tdouble ln_gamma_df = ln_gamma(df * 0.5);\n\t\tfor (j = 1; j < 100; j += 7) {\n\t\t\tdouble p = (double)j * 0.01;\n\t\t\texpect_true(double_eq_rel(pt_chi2(p, df, ln_gamma_df),\n\t\t\t pt_chi2_expected[e], MAX_REL_ERR, MAX_ABS_ERR),\n\t\t\t \"Incorrect pt_chi2 result for i=%u, j=%u\", i, j);\n\t\t\te++;\n\t\t}\n\t}\n}\nTEST_END\n\n/*\n * Expected pt_gamma(p=[0.1..0.99] increment=0.07,\n * shape=[0.5..3.0] increment=0.5).\n */\nstatic const double pt_gamma_shape[] = {0.5, 1.0, 1.5, 2.0, 2.5, 3.0};\nstatic const double pt_gamma_expected[] = {\n\t7.854392895485103e-05, 5.043466107888016e-03, 1.788288957794883e-02,\n\t3.900956150232906e-02, 6.913847560638034e-02, 1.093710833465766e-01,\n\t1.613412523825817e-01, 2.274682115597864e-01, 3.114117323127083e-01,\n\t4.189466220207417e-01, 5.598106789059246e-01, 7.521856146202706e-01,\n\t1.036125427911119e+00, 1.532450860038180e+00, 3.317448300510606e+00,\n\n\t0.01005033585350144, 0.08338160893905107, 0.16251892949777497,\n\t0.24846135929849966, 0.34249030894677596, 0.44628710262841947,\n\t0.56211891815354142, 0.69314718055994529, 0.84397007029452920,\n\t1.02165124753198167, 1.23787435600161766, 1.51412773262977574,\n\t1.89711998488588196, 2.52572864430825783, 4.60517018598809091,\n\n\t0.05741590094955853, 0.24747378084860744, 0.39888572212236084,\n\t0.54394139997444901, 0.69048812513915159, 0.84311389861296104,\n\t1.00580622221479898, 1.18298694218766931, 1.38038096305861213,\n\t1.60627736383027453, 1.87396970522337947, 2.20749220408081070,\n\t2.65852391865854942, 3.37934630984842244, 5.67243336507218476,\n\n\t0.1485547402532659, 0.4657458011640391, 0.6832386130709406,\n\t0.8794297834672100, 1.0700752852474524, 1.2629614217350744,\n\t1.4638400448580779, 1.6783469900166610, 1.9132338090606940,\n\t2.1778589228618777, 2.4868823970010991, 2.8664695666264195,\n\t3.3724415436062114, 4.1682658512758071, 6.6383520679938108,\n\n\t0.2771490383641385, 0.7195001279643727, 0.9969081732265243,\n\t1.2383497880608061, 1.4675206597269927, 1.6953064251816552,\n\t1.9291243435606809, 2.1757300955477641, 2.4428032131216391,\n\t2.7406534569230616, 3.0851445039665513, 3.5043101122033367,\n\t4.0575997065264637, 4.9182956424675286, 7.5431362346944937,\n\n\t0.4360451650782932, 0.9983600902486267, 1.3306365880734528,\n\t1.6129750834753802, 1.8767241606994294, 2.1357032436097660,\n\t2.3988853336865565, 2.6740603137235603, 2.9697561737517959,\n\t3.2971457713883265, 3.6731795898504660, 4.1275751617770631,\n\t4.7230515633946677, 5.6417477865306020, 8.4059469148854635\n};\n\nTEST_BEGIN(test_pt_gamma_shape) {\n\tunsigned i, j;\n\tunsigned e = 0;\n\n\tfor (i = 0; i < sizeof(pt_gamma_shape)/sizeof(double); i++) {\n\t\tdouble shape = pt_gamma_shape[i];\n\t\tdouble ln_gamma_shape = ln_gamma(shape);\n\t\tfor (j = 1; j < 100; j += 7) {\n\t\t\tdouble p = (double)j * 0.01;\n\t\t\texpect_true(double_eq_rel(pt_gamma(p, shape, 1.0,\n\t\t\t ln_gamma_shape), pt_gamma_expected[e], MAX_REL_ERR,\n\t\t\t MAX_ABS_ERR),\n\t\t\t \"Incorrect pt_gamma result for i=%u, j=%u\", i, j);\n\t\t\te++;\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_pt_gamma_scale) {\n\tdouble shape = 1.0;\n\tdouble ln_gamma_shape = ln_gamma(shape);\n\n\texpect_true(double_eq_rel(\n\t pt_gamma(0.5, shape, 1.0, ln_gamma_shape) * 10.0,\n\t pt_gamma(0.5, shape, 10.0, ln_gamma_shape), MAX_REL_ERR,\n\t MAX_ABS_ERR),\n\t \"Scale should be trivially equivalent to external multiplication\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_ln_gamma_factorial,\n\t test_ln_gamma_misc,\n\t test_pt_norm,\n\t test_pt_chi2,\n\t test_pt_gamma_shape,\n\t test_pt_gamma_scale);\n}\n" }, { "path": "deps/jemalloc/test/unit/mpsc_queue.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/mpsc_queue.h\"\n\ntypedef struct elem_s elem_t;\ntypedef ql_head(elem_t) elem_list_t;\ntypedef mpsc_queue(elem_t) elem_mpsc_queue_t;\nstruct elem_s {\n\tint thread;\n\tint idx;\n\tql_elm(elem_t) link;\n};\n\n/* Include both proto and gen to make sure they match up. */\nmpsc_queue_proto(static, elem_mpsc_queue_, elem_mpsc_queue_t, elem_t,\n elem_list_t);\nmpsc_queue_gen(static, elem_mpsc_queue_, elem_mpsc_queue_t, elem_t,\n elem_list_t, link);\n\nstatic void\ninit_elems_simple(elem_t *elems, int nelems, int thread) {\n\tfor (int i = 0; i < nelems; i++) {\n\t\telems[i].thread = thread;\n\t\telems[i].idx = i;\n\t\tql_elm_new(&elems[i], link);\n\t}\n}\n\nstatic void\ncheck_elems_simple(elem_list_t *list, int nelems, int thread) {\n\telem_t *elem;\n\tint next_idx = 0;\n\tql_foreach(elem, list, link) {\n\t\texpect_d_lt(next_idx, nelems, \"Too many list items\");\n\t\texpect_d_eq(thread, elem->thread, \"\");\n\t\texpect_d_eq(next_idx, elem->idx, \"List out of order\");\n\t\tnext_idx++;\n\t}\n}\n\nTEST_BEGIN(test_simple) {\n\tenum {NELEMS = 10};\n\telem_t elems[NELEMS];\n\telem_list_t list;\n\telem_mpsc_queue_t queue;\n\n\t/* Pop empty queue onto empty list -> empty list */\n\tql_new(&list);\n\telem_mpsc_queue_new(&queue);\n\telem_mpsc_queue_pop_batch(&queue, &list);\n\texpect_true(ql_empty(&list), \"\");\n\n\t/* Pop empty queue onto nonempty list -> list unchanged */\n\tql_new(&list);\n\telem_mpsc_queue_new(&queue);\n\tinit_elems_simple(elems, NELEMS, 0);\n\tfor (int i = 0; i < NELEMS; i++) {\n\t\tql_tail_insert(&list, &elems[i], link);\n\t}\n\telem_mpsc_queue_pop_batch(&queue, &list);\n\tcheck_elems_simple(&list, NELEMS, 0);\n\n\t/* Pop nonempty queue onto empty list -> list takes queue contents */\n\tql_new(&list);\n\telem_mpsc_queue_new(&queue);\n\tinit_elems_simple(elems, NELEMS, 0);\n\tfor (int i = 0; i < NELEMS; i++) {\n\t\telem_mpsc_queue_push(&queue, &elems[i]);\n\t}\n\telem_mpsc_queue_pop_batch(&queue, &list);\n\tcheck_elems_simple(&list, NELEMS, 0);\n\n\t/* Pop nonempty queue onto nonempty list -> list gains queue contents */\n\tql_new(&list);\n\telem_mpsc_queue_new(&queue);\n\tinit_elems_simple(elems, NELEMS, 0);\n\tfor (int i = 0; i < NELEMS / 2; i++) {\n\t\tql_tail_insert(&list, &elems[i], link);\n\t}\n\tfor (int i = NELEMS / 2; i < NELEMS; i++) {\n\t\telem_mpsc_queue_push(&queue, &elems[i]);\n\t}\n\telem_mpsc_queue_pop_batch(&queue, &list);\n\tcheck_elems_simple(&list, NELEMS, 0);\n\n}\nTEST_END\n\nTEST_BEGIN(test_push_single_or_batch) {\n\tenum {\n\t\tBATCH_MAX = 10,\n\t\t/*\n\t\t * We'll push i items one-at-a-time, then i items as a batch,\n\t\t * then i items as a batch again, as i ranges from 1 to\n\t\t * BATCH_MAX. So we need 3 times the sum of the numbers from 1\n\t\t * to BATCH_MAX elements total.\n\t\t */\n\t\tNELEMS = 3 * BATCH_MAX * (BATCH_MAX - 1) / 2\n\t};\n\telem_t elems[NELEMS];\n\tinit_elems_simple(elems, NELEMS, 0);\n\telem_list_t list;\n\tql_new(&list);\n\telem_mpsc_queue_t queue;\n\telem_mpsc_queue_new(&queue);\n\tint next_idx = 0;\n\tfor (int i = 1; i < 10; i++) {\n\t\t/* Push i items 1 at a time. */\n\t\tfor (int j = 0; j < i; j++) {\n\t\t\telem_mpsc_queue_push(&queue, &elems[next_idx]);\n\t\t\tnext_idx++;\n\t\t}\n\t\t/* Push i items in batch. */\n\t\tfor (int j = 0; j < i; j++) {\n\t\t\tql_tail_insert(&list, &elems[next_idx], link);\n\t\t\tnext_idx++;\n\t\t}\n\t\telem_mpsc_queue_push_batch(&queue, &list);\n\t\texpect_true(ql_empty(&list), \"Batch push should empty source\");\n\t\t/*\n\t\t * Push i items in batch, again. This tests two batches\n\t\t * proceeding one after the other.\n\t\t */\n\t\tfor (int j = 0; j < i; j++) {\n\t\t\tql_tail_insert(&list, &elems[next_idx], link);\n\t\t\tnext_idx++;\n\t\t}\n\t\telem_mpsc_queue_push_batch(&queue, &list);\n\t\texpect_true(ql_empty(&list), \"Batch push should empty source\");\n\t}\n\texpect_d_eq(NELEMS, next_idx, \"Miscomputed number of elems to push.\");\n\n\texpect_true(ql_empty(&list), \"\");\n\telem_mpsc_queue_pop_batch(&queue, &list);\n\tcheck_elems_simple(&list, NELEMS, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_multi_op) {\n\tenum {NELEMS = 20};\n\telem_t elems[NELEMS];\n\tinit_elems_simple(elems, NELEMS, 0);\n\telem_list_t push_list;\n\tql_new(&push_list);\n\telem_list_t result_list;\n\tql_new(&result_list);\n\telem_mpsc_queue_t queue;\n\telem_mpsc_queue_new(&queue);\n\n\tint next_idx = 0;\n\t/* Push first quarter 1-at-a-time. */\n\tfor (int i = 0; i < NELEMS / 4; i++) {\n\t\telem_mpsc_queue_push(&queue, &elems[next_idx]);\n\t\tnext_idx++;\n\t}\n\t/* Push second quarter in batch. */\n\tfor (int i = NELEMS / 4; i < NELEMS / 2; i++) {\n\t\tql_tail_insert(&push_list, &elems[next_idx], link);\n\t\tnext_idx++;\n\t}\n\telem_mpsc_queue_push_batch(&queue, &push_list);\n\t/* Batch pop all pushed elements. */\n\telem_mpsc_queue_pop_batch(&queue, &result_list);\n\t/* Push third quarter in batch. */\n\tfor (int i = NELEMS / 2; i < 3 * NELEMS / 4; i++) {\n\t\tql_tail_insert(&push_list, &elems[next_idx], link);\n\t\tnext_idx++;\n\t}\n\telem_mpsc_queue_push_batch(&queue, &push_list);\n\t/* Push last quarter one-at-a-time. */\n\tfor (int i = 3 * NELEMS / 4; i < NELEMS; i++) {\n\t\telem_mpsc_queue_push(&queue, &elems[next_idx]);\n\t\tnext_idx++;\n\t}\n\t/* Pop them again. Order of existing list should be preserved. */\n\telem_mpsc_queue_pop_batch(&queue, &result_list);\n\n\tcheck_elems_simple(&result_list, NELEMS, 0);\n\n}\nTEST_END\n\ntypedef struct pusher_arg_s pusher_arg_t;\nstruct pusher_arg_s {\n\telem_mpsc_queue_t *queue;\n\tint thread;\n\telem_t *elems;\n\tint nelems;\n};\n\ntypedef struct popper_arg_s popper_arg_t;\nstruct popper_arg_s {\n\telem_mpsc_queue_t *queue;\n\tint npushers;\n\tint nelems_per_pusher;\n\tint *pusher_counts;\n};\n\nstatic void *\nthd_pusher(void *void_arg) {\n\tpusher_arg_t *arg = (pusher_arg_t *)void_arg;\n\tint next_idx = 0;\n\twhile (next_idx < arg->nelems) {\n\t\t/* Push 10 items in batch. */\n\t\telem_list_t list;\n\t\tql_new(&list);\n\t\tint limit = next_idx + 10;\n\t\twhile (next_idx < arg->nelems && next_idx < limit) {\n\t\t\tql_tail_insert(&list, &arg->elems[next_idx], link);\n\t\t\tnext_idx++;\n\t\t}\n\t\telem_mpsc_queue_push_batch(arg->queue, &list);\n\t\t/* Push 10 items one-at-a-time. */\n\t\tlimit = next_idx + 10;\n\t\twhile (next_idx < arg->nelems && next_idx < limit) {\n\t\t\telem_mpsc_queue_push(arg->queue, &arg->elems[next_idx]);\n\t\t\tnext_idx++;\n\t\t}\n\n\t}\n\treturn NULL;\n}\n\nstatic void *\nthd_popper(void *void_arg) {\n\tpopper_arg_t *arg = (popper_arg_t *)void_arg;\n\tint done_pushers = 0;\n\twhile (done_pushers < arg->npushers) {\n\t\telem_list_t list;\n\t\tql_new(&list);\n\t\telem_mpsc_queue_pop_batch(arg->queue, &list);\n\t\telem_t *elem;\n\t\tql_foreach(elem, &list, link) {\n\t\t\tint thread = elem->thread;\n\t\t\tint idx = elem->idx;\n\t\t\texpect_d_eq(arg->pusher_counts[thread], idx,\n\t\t\t \"Thread's pushes reordered\");\n\t\t\targ->pusher_counts[thread]++;\n\t\t\tif (arg->pusher_counts[thread]\n\t\t\t == arg->nelems_per_pusher) {\n\t\t\t\tdone_pushers++;\n\t\t\t}\n\t\t}\n\t}\n\treturn NULL;\n}\n\nTEST_BEGIN(test_multiple_threads) {\n\tenum {\n\t\tNPUSHERS = 4,\n\t\tNELEMS_PER_PUSHER = 1000*1000,\n\t};\n\tthd_t pushers[NPUSHERS];\n\tpusher_arg_t pusher_arg[NPUSHERS];\n\n\tthd_t popper;\n\tpopper_arg_t popper_arg;\n\n\telem_mpsc_queue_t queue;\n\telem_mpsc_queue_new(&queue);\n\n\telem_t *elems = calloc(NPUSHERS * NELEMS_PER_PUSHER, sizeof(elem_t));\n\telem_t *elem_iter = elems;\n\tfor (int i = 0; i < NPUSHERS; i++) {\n\t\tpusher_arg[i].queue = &queue;\n\t\tpusher_arg[i].thread = i;\n\t\tpusher_arg[i].elems = elem_iter;\n\t\tpusher_arg[i].nelems = NELEMS_PER_PUSHER;\n\n\t\tinit_elems_simple(elem_iter, NELEMS_PER_PUSHER, i);\n\t\telem_iter += NELEMS_PER_PUSHER;\n\t}\n\tpopper_arg.queue = &queue;\n\tpopper_arg.npushers = NPUSHERS;\n\tpopper_arg.nelems_per_pusher = NELEMS_PER_PUSHER;\n\tint pusher_counts[NPUSHERS] = {0};\n\tpopper_arg.pusher_counts = pusher_counts;\n\n\tthd_create(&popper, thd_popper, (void *)&popper_arg);\n\tfor (int i = 0; i < NPUSHERS; i++) {\n\t\tthd_create(&pushers[i], thd_pusher, &pusher_arg[i]);\n\t}\n\n\tthd_join(popper, NULL);\n\tfor (int i = 0; i < NPUSHERS; i++) {\n\t\tthd_join(pushers[i], NULL);\n\t}\n\n\tfor (int i = 0; i < NPUSHERS; i++) {\n\t\texpect_d_eq(NELEMS_PER_PUSHER, pusher_counts[i], \"\");\n\t}\n\n\tfree(elems);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_simple,\n\t test_push_single_or_batch,\n\t test_multi_op,\n\t test_multiple_threads);\n}\n" }, { "path": "deps/jemalloc/test/unit/mq.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define NSENDERS\t3\n#define NMSGS\t\t100000\n\ntypedef struct mq_msg_s mq_msg_t;\nstruct mq_msg_s {\n\tmq_msg(mq_msg_t)\tlink;\n};\nmq_gen(static, mq_, mq_t, mq_msg_t, link)\n\nTEST_BEGIN(test_mq_basic) {\n\tmq_t mq;\n\tmq_msg_t msg;\n\n\texpect_false(mq_init(&mq), \"Unexpected mq_init() failure\");\n\texpect_u_eq(mq_count(&mq), 0, \"mq should be empty\");\n\texpect_ptr_null(mq_tryget(&mq),\n\t \"mq_tryget() should fail when the queue is empty\");\n\n\tmq_put(&mq, &msg);\n\texpect_u_eq(mq_count(&mq), 1, \"mq should contain one message\");\n\texpect_ptr_eq(mq_tryget(&mq), &msg, \"mq_tryget() should return msg\");\n\n\tmq_put(&mq, &msg);\n\texpect_ptr_eq(mq_get(&mq), &msg, \"mq_get() should return msg\");\n\n\tmq_fini(&mq);\n}\nTEST_END\n\nstatic void *\nthd_receiver_start(void *arg) {\n\tmq_t *mq = (mq_t *)arg;\n\tunsigned i;\n\n\tfor (i = 0; i < (NSENDERS * NMSGS); i++) {\n\t\tmq_msg_t *msg = mq_get(mq);\n\t\texpect_ptr_not_null(msg, \"mq_get() should never return NULL\");\n\t\tdallocx(msg, 0);\n\t}\n\treturn NULL;\n}\n\nstatic void *\nthd_sender_start(void *arg) {\n\tmq_t *mq = (mq_t *)arg;\n\tunsigned i;\n\n\tfor (i = 0; i < NMSGS; i++) {\n\t\tmq_msg_t *msg;\n\t\tvoid *p;\n\t\tp = mallocx(sizeof(mq_msg_t), 0);\n\t\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\t\tmsg = (mq_msg_t *)p;\n\t\tmq_put(mq, msg);\n\t}\n\treturn NULL;\n}\n\nTEST_BEGIN(test_mq_threaded) {\n\tmq_t mq;\n\tthd_t receiver;\n\tthd_t senders[NSENDERS];\n\tunsigned i;\n\n\texpect_false(mq_init(&mq), \"Unexpected mq_init() failure\");\n\n\tthd_create(&receiver, thd_receiver_start, (void *)&mq);\n\tfor (i = 0; i < NSENDERS; i++) {\n\t\tthd_create(&senders[i], thd_sender_start, (void *)&mq);\n\t}\n\n\tthd_join(receiver, NULL);\n\tfor (i = 0; i < NSENDERS; i++) {\n\t\tthd_join(senders[i], NULL);\n\t}\n\n\tmq_fini(&mq);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_mq_basic,\n\t test_mq_threaded);\n}\n\n" }, { "path": "deps/jemalloc/test/unit/mtx.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define NTHREADS\t2\n#define NINCRS\t\t2000000\n\nTEST_BEGIN(test_mtx_basic) {\n\tmtx_t mtx;\n\n\texpect_false(mtx_init(&mtx), \"Unexpected mtx_init() failure\");\n\tmtx_lock(&mtx);\n\tmtx_unlock(&mtx);\n\tmtx_fini(&mtx);\n}\nTEST_END\n\ntypedef struct {\n\tmtx_t\t\tmtx;\n\tunsigned\tx;\n} thd_start_arg_t;\n\nstatic void *\nthd_start(void *varg) {\n\tthd_start_arg_t *arg = (thd_start_arg_t *)varg;\n\tunsigned i;\n\n\tfor (i = 0; i < NINCRS; i++) {\n\t\tmtx_lock(&arg->mtx);\n\t\targ->x++;\n\t\tmtx_unlock(&arg->mtx);\n\t}\n\treturn NULL;\n}\n\nTEST_BEGIN(test_mtx_race) {\n\tthd_start_arg_t arg;\n\tthd_t thds[NTHREADS];\n\tunsigned i;\n\n\texpect_false(mtx_init(&arg.mtx), \"Unexpected mtx_init() failure\");\n\targ.x = 0;\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_create(&thds[i], thd_start, (void *)&arg);\n\t}\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n\texpect_u_eq(arg.x, NTHREADS * NINCRS,\n\t \"Race-related counter corruption\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_mtx_basic,\n\t test_mtx_race);\n}\n" }, { "path": "deps/jemalloc/test/unit/nstime.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define BILLION\tUINT64_C(1000000000)\n\nTEST_BEGIN(test_nstime_init) {\n\tnstime_t nst;\n\n\tnstime_init(&nst, 42000000043);\n\texpect_u64_eq(nstime_ns(&nst), 42000000043, \"ns incorrectly read\");\n\texpect_u64_eq(nstime_sec(&nst), 42, \"sec incorrectly read\");\n\texpect_u64_eq(nstime_nsec(&nst), 43, \"nsec incorrectly read\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_init2) {\n\tnstime_t nst;\n\n\tnstime_init2(&nst, 42, 43);\n\texpect_u64_eq(nstime_sec(&nst), 42, \"sec incorrectly read\");\n\texpect_u64_eq(nstime_nsec(&nst), 43, \"nsec incorrectly read\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_copy) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_init_zero(&nstb);\n\tnstime_copy(&nstb, &nsta);\n\texpect_u64_eq(nstime_sec(&nstb), 42, \"sec incorrectly copied\");\n\texpect_u64_eq(nstime_nsec(&nstb), 43, \"nsec incorrectly copied\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_compare) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0, \"Times should be equal\");\n\texpect_d_eq(nstime_compare(&nstb, &nsta), 0, \"Times should be equal\");\n\n\tnstime_init2(&nstb, 42, 42);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 1,\n\t \"nsta should be greater than nstb\");\n\texpect_d_eq(nstime_compare(&nstb, &nsta), -1,\n\t \"nstb should be less than nsta\");\n\n\tnstime_init2(&nstb, 42, 44);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), -1,\n\t \"nsta should be less than nstb\");\n\texpect_d_eq(nstime_compare(&nstb, &nsta), 1,\n\t \"nstb should be greater than nsta\");\n\n\tnstime_init2(&nstb, 41, BILLION - 1);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 1,\n\t \"nsta should be greater than nstb\");\n\texpect_d_eq(nstime_compare(&nstb, &nsta), -1,\n\t \"nstb should be less than nsta\");\n\n\tnstime_init2(&nstb, 43, 0);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), -1,\n\t \"nsta should be less than nstb\");\n\texpect_d_eq(nstime_compare(&nstb, &nsta), 1,\n\t \"nstb should be greater than nsta\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_add) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_add(&nsta, &nstb);\n\tnstime_init2(&nstb, 84, 86);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect addition result\");\n\n\tnstime_init2(&nsta, 42, BILLION - 1);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_add(&nsta, &nstb);\n\tnstime_init2(&nstb, 85, BILLION - 2);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect addition result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_iadd) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, BILLION - 1);\n\tnstime_iadd(&nsta, 1);\n\tnstime_init2(&nstb, 43, 0);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect addition result\");\n\n\tnstime_init2(&nsta, 42, 1);\n\tnstime_iadd(&nsta, BILLION + 1);\n\tnstime_init2(&nstb, 43, 2);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect addition result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_subtract) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_subtract(&nsta, &nstb);\n\tnstime_init_zero(&nstb);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect subtraction result\");\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_init2(&nstb, 41, 44);\n\tnstime_subtract(&nsta, &nstb);\n\tnstime_init2(&nstb, 0, BILLION - 1);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect subtraction result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_isubtract) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_isubtract(&nsta, 42*BILLION + 43);\n\tnstime_init_zero(&nstb);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect subtraction result\");\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_isubtract(&nsta, 41*BILLION + 44);\n\tnstime_init2(&nstb, 0, BILLION - 1);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect subtraction result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_imultiply) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_imultiply(&nsta, 10);\n\tnstime_init2(&nstb, 420, 430);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect multiplication result\");\n\n\tnstime_init2(&nsta, 42, 666666666);\n\tnstime_imultiply(&nsta, 3);\n\tnstime_init2(&nstb, 127, 999999998);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect multiplication result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_idivide) {\n\tnstime_t nsta, nstb;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_imultiply(&nsta, 10);\n\tnstime_idivide(&nsta, 10);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect division result\");\n\n\tnstime_init2(&nsta, 42, 666666666);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_imultiply(&nsta, 3);\n\tnstime_idivide(&nsta, 3);\n\texpect_d_eq(nstime_compare(&nsta, &nstb), 0,\n\t \"Incorrect division result\");\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_divide) {\n\tnstime_t nsta, nstb, nstc;\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_imultiply(&nsta, 10);\n\texpect_u64_eq(nstime_divide(&nsta, &nstb), 10,\n\t \"Incorrect division result\");\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_imultiply(&nsta, 10);\n\tnstime_init(&nstc, 1);\n\tnstime_add(&nsta, &nstc);\n\texpect_u64_eq(nstime_divide(&nsta, &nstb), 10,\n\t \"Incorrect division result\");\n\n\tnstime_init2(&nsta, 42, 43);\n\tnstime_copy(&nstb, &nsta);\n\tnstime_imultiply(&nsta, 10);\n\tnstime_init(&nstc, 1);\n\tnstime_subtract(&nsta, &nstc);\n\texpect_u64_eq(nstime_divide(&nsta, &nstb), 9,\n\t \"Incorrect division result\");\n}\nTEST_END\n\nvoid\ntest_nstime_since_once(nstime_t *t) {\n\tnstime_t old_t;\n\tnstime_copy(&old_t, t);\n\n\tuint64_t ns_since = nstime_ns_since(t);\n\tnstime_update(t);\n\n\tnstime_t new_t;\n\tnstime_copy(&new_t, t);\n\tnstime_subtract(&new_t, &old_t);\n\n\texpect_u64_ge(nstime_ns(&new_t), ns_since,\n\t \"Incorrect time since result\");\n}\n\nTEST_BEGIN(test_nstime_ns_since) {\n\tnstime_t t;\n\n\tnstime_init_update(&t);\n\tfor (uint64_t i = 0; i < 10000; i++) {\n\t\t/* Keeps updating t and verifies ns_since is valid. */\n\t\ttest_nstime_since_once(&t);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_nstime_monotonic) {\n\tnstime_monotonic();\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_nstime_init,\n\t test_nstime_init2,\n\t test_nstime_copy,\n\t test_nstime_compare,\n\t test_nstime_add,\n\t test_nstime_iadd,\n\t test_nstime_subtract,\n\t test_nstime_isubtract,\n\t test_nstime_imultiply,\n\t test_nstime_idivide,\n\t test_nstime_divide,\n\t test_nstime_ns_since,\n\t test_nstime_monotonic);\n}\n" }, { "path": "deps/jemalloc/test/unit/oversize_threshold.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/ctl.h\"\n\nstatic void\narena_mallctl(const char *mallctl_str, unsigned arena, void *oldp,\n size_t *oldlen, void *newp, size_t newlen) {\n\tint err;\n\tchar buf[100];\n\tmalloc_snprintf(buf, sizeof(buf), mallctl_str, arena);\n\n\terr = mallctl(buf, oldp, oldlen, newp, newlen);\n\texpect_d_eq(0, err, \"Mallctl failed; %s\", buf);\n}\n\nTEST_BEGIN(test_oversize_threshold_get_set) {\n\tint err;\n\tsize_t old_threshold;\n\tsize_t new_threshold;\n\tsize_t threshold_sz = sizeof(old_threshold);\n\n\tunsigned arena;\n\tsize_t arena_sz = sizeof(arena);\n\terr = mallctl(\"arenas.create\", (void *)&arena, &arena_sz, NULL, 0);\n\texpect_d_eq(0, err, \"Arena creation failed\");\n\n\t/* Just a write. */\n\tnew_threshold = 1024 * 1024;\n\tarena_mallctl(\"arena.%u.oversize_threshold\", arena, NULL, NULL,\n\t &new_threshold, threshold_sz);\n\n\t/* Read and write */\n\tnew_threshold = 2 * 1024 * 1024;\n\tarena_mallctl(\"arena.%u.oversize_threshold\", arena, &old_threshold,\n\t &threshold_sz, &new_threshold, threshold_sz);\n\texpect_zu_eq(1024 * 1024, old_threshold, \"Should have read old value\");\n\n\t/* Just a read */\n\tarena_mallctl(\"arena.%u.oversize_threshold\", arena, &old_threshold,\n\t &threshold_sz, NULL, 0);\n\texpect_zu_eq(2 * 1024 * 1024, old_threshold, \"Should have read old value\");\n}\nTEST_END\n\nstatic size_t max_purged = 0;\nstatic bool\npurge_forced_record_max(extent_hooks_t* hooks, void *addr, size_t sz,\n size_t offset, size_t length, unsigned arena_ind) {\n\tif (length > max_purged) {\n\t\tmax_purged = length;\n\t}\n\treturn false;\n}\n\nstatic bool\ndalloc_record_max(extent_hooks_t *extent_hooks, void *addr, size_t sz,\n bool comitted, unsigned arena_ind) {\n\tif (sz > max_purged) {\n\t\tmax_purged = sz;\n\t}\n\treturn false;\n}\n\nextent_hooks_t max_recording_extent_hooks;\n\nTEST_BEGIN(test_oversize_threshold) {\n\tmax_recording_extent_hooks = ehooks_default_extent_hooks;\n\tmax_recording_extent_hooks.purge_forced = &purge_forced_record_max;\n\tmax_recording_extent_hooks.dalloc = &dalloc_record_max;\n\n\textent_hooks_t *extent_hooks = &max_recording_extent_hooks;\n\n\tint err;\n\n\tunsigned arena;\n\tsize_t arena_sz = sizeof(arena);\n\terr = mallctl(\"arenas.create\", (void *)&arena, &arena_sz, NULL, 0);\n\texpect_d_eq(0, err, \"Arena creation failed\");\n\tarena_mallctl(\"arena.%u.extent_hooks\", arena, NULL, NULL, &extent_hooks,\n\t sizeof(extent_hooks));\n\n\t/*\n\t * This test will fundamentally race with purging, since we're going to\n\t * check the dirty stats to see if our oversized allocation got purged.\n\t * We don't want other purging to happen accidentally. We can't just\n\t * disable purging entirely, though, since that will also disable\n\t * oversize purging. Just set purging intervals to be very large.\n\t */\n\tssize_t decay_ms = 100 * 1000;\n\tssize_t decay_ms_sz = sizeof(decay_ms);\n\tarena_mallctl(\"arena.%u.dirty_decay_ms\", arena, NULL, NULL, &decay_ms,\n\t decay_ms_sz);\n\tarena_mallctl(\"arena.%u.muzzy_decay_ms\", arena, NULL, NULL, &decay_ms,\n\t decay_ms_sz);\n\n\t/* Clean everything out. */\n\tarena_mallctl(\"arena.%u.purge\", arena, NULL, NULL, NULL, 0);\n\tmax_purged = 0;\n\n\t/* Set threshold to 1MB. */\n\tsize_t threshold = 1024 * 1024;\n\tsize_t threshold_sz = sizeof(threshold);\n\tarena_mallctl(\"arena.%u.oversize_threshold\", arena, NULL, NULL,\n\t &threshold, threshold_sz);\n\n\t/* Allocating and freeing half a megabyte should leave them dirty. */\n\tvoid *ptr = mallocx(512 * 1024, MALLOCX_ARENA(arena));\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\tif (!is_background_thread_enabled()) {\n\t\texpect_zu_lt(max_purged, 512 * 1024, \"Expected no 512k purge\");\n\t}\n\n\t/* Purge again to reset everything out. */\n\tarena_mallctl(\"arena.%u.purge\", arena, NULL, NULL, NULL, 0);\n\tmax_purged = 0;\n\n\t/*\n\t * Allocating and freeing 2 megabytes should have them purged because of\n\t * the oversize threshold.\n\t */\n\tptr = mallocx(2 * 1024 * 1024, MALLOCX_ARENA(arena));\n\tdallocx(ptr, MALLOCX_TCACHE_NONE);\n\texpect_zu_ge(max_purged, 2 * 1024 * 1024, \"Expected a 2MB purge\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_oversize_threshold_get_set,\n\t test_oversize_threshold);\n}\n\n" }, { "path": "deps/jemalloc/test/unit/pa.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/pa.h\"\n\nstatic void *\nalloc_hook(extent_hooks_t *extent_hooks, void *new_addr, size_t size,\n size_t alignment, bool *zero, bool *commit, unsigned arena_ind) {\n\tvoid *ret = pages_map(new_addr, size, alignment, commit);\n\treturn ret;\n}\n\nstatic bool\nmerge_hook(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a,\n void *addr_b, size_t size_b, bool committed, unsigned arena_ind) {\n\treturn !maps_coalesce;\n}\n\nstatic bool\nsplit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,\n size_t size_a, size_t size_b, bool committed, unsigned arena_ind) {\n\treturn !maps_coalesce;\n}\n\nstatic void\ninit_test_extent_hooks(extent_hooks_t *hooks) {\n\t/*\n\t * The default hooks are mostly fine for testing. A few of them,\n\t * though, access globals (alloc for dss setting in an arena, split and\n\t * merge touch the global emap to find head state. The first of these\n\t * can be fixed by keeping that state with the hooks, where it logically\n\t * belongs. The second, though, we can only fix when we use the extent\n\t * hook API.\n\t */\n\tmemcpy(hooks, &ehooks_default_extent_hooks, sizeof(extent_hooks_t));\n\thooks->alloc = &alloc_hook;\n\thooks->merge = &merge_hook;\n\thooks->split = &split_hook;\n}\n\ntypedef struct test_data_s test_data_t;\nstruct test_data_s {\n\tpa_shard_t shard;\n\tpa_central_t central;\n\tbase_t *base;\n\temap_t emap;\n\tpa_shard_stats_t stats;\n\tmalloc_mutex_t stats_mtx;\n\textent_hooks_t hooks;\n};\n\ntest_data_t *init_test_data(ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms) {\n\ttest_data_t *test_data = calloc(1, sizeof(test_data_t));\n\tassert_ptr_not_null(test_data, \"\");\n\tinit_test_extent_hooks(&test_data->hooks);\n\n\tbase_t *base = base_new(TSDN_NULL, /* ind */ 1, &test_data->hooks,\n\t /* metadata_use_hooks */ true);\n\tassert_ptr_not_null(base, \"\");\n\n\ttest_data->base = base;\n\tbool err = emap_init(&test_data->emap, test_data->base,\n\t /* zeroed */ true);\n\tassert_false(err, \"\");\n\n\tnstime_t time;\n\tnstime_init(&time, 0);\n\n\terr = pa_central_init(&test_data->central, base, opt_hpa,\n\t &hpa_hooks_default);\n\tassert_false(err, \"\");\n\n\tconst size_t pa_oversize_threshold = 8 * 1024 * 1024;\n\terr = pa_shard_init(TSDN_NULL, &test_data->shard, &test_data->central,\n\t &test_data->emap, test_data->base, /* ind */ 1, &test_data->stats,\n\t &test_data->stats_mtx, &time, pa_oversize_threshold, dirty_decay_ms,\n\t muzzy_decay_ms);\n\tassert_false(err, \"\");\n\n\treturn test_data;\n}\n\nvoid destroy_test_data(test_data_t *data) {\n\tbase_delete(TSDN_NULL, data->base);\n\tfree(data);\n}\n\nstatic void *\ndo_alloc_free_purge(void *arg) {\n\ttest_data_t *test_data = (test_data_t *)arg;\n\tfor (int i = 0; i < 10 * 1000; i++) {\n\t\tbool deferred_work_generated = false;\n\t\tedata_t *edata = pa_alloc(TSDN_NULL, &test_data->shard, PAGE,\n\t\t PAGE, /* slab */ false, /* szind */ 0, /* zero */ false,\n\t\t /* guarded */ false, &deferred_work_generated);\n\t\tassert_ptr_not_null(edata, \"\");\n\t\tpa_dalloc(TSDN_NULL, &test_data->shard, edata,\n\t\t &deferred_work_generated);\n\t\tmalloc_mutex_lock(TSDN_NULL,\n\t\t &test_data->shard.pac.decay_dirty.mtx);\n\t\tpac_decay_all(TSDN_NULL, &test_data->shard.pac,\n\t\t &test_data->shard.pac.decay_dirty,\n\t\t &test_data->shard.pac.stats->decay_dirty,\n\t\t &test_data->shard.pac.ecache_dirty, true);\n\t\tmalloc_mutex_unlock(TSDN_NULL,\n\t\t &test_data->shard.pac.decay_dirty.mtx);\n\t}\n\treturn NULL;\n}\n\nTEST_BEGIN(test_alloc_free_purge_thds) {\n\ttest_data_t *test_data = init_test_data(0, 0);\n\tthd_t thds[4];\n\tfor (int i = 0; i < 4; i++) {\n\t\tthd_create(&thds[i], do_alloc_free_purge, test_data);\n\t}\n\tfor (int i = 0; i < 4; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_alloc_free_purge_thds);\n}\n" }, { "path": "deps/jemalloc/test/unit/pack.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * Size class that is a divisor of the page size, ideally 4+ regions per run.\n */\n#if LG_PAGE <= 14\n#define SZ\t(ZU(1) << (LG_PAGE - 2))\n#else\n#define SZ\tZU(4096)\n#endif\n\n/*\n * Number of slabs to consume at high water mark. Should be at least 2 so that\n * if mmap()ed memory grows downward, downward growth of mmap()ed memory is\n * tested.\n */\n#define NSLABS\t8\n\nstatic unsigned\nbinind_compute(void) {\n\tsize_t sz;\n\tunsigned nbins, i;\n\n\tsz = sizeof(nbins);\n\texpect_d_eq(mallctl(\"arenas.nbins\", (void *)&nbins, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\n\tfor (i = 0; i < nbins; i++) {\n\t\tsize_t mib[4];\n\t\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\t\tsize_t size;\n\n\t\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.size\", mib,\n\t\t &miblen), 0, \"Unexpected mallctlnametomb failure\");\n\t\tmib[2] = (size_t)i;\n\n\t\tsz = sizeof(size);\n\t\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&size, &sz, NULL,\n\t\t 0), 0, \"Unexpected mallctlbymib failure\");\n\t\tif (size == SZ) {\n\t\t\treturn i;\n\t\t}\n\t}\n\n\ttest_fail(\"Unable to compute nregs_per_run\");\n\treturn 0;\n}\n\nstatic size_t\nnregs_per_run_compute(void) {\n\tuint32_t nregs;\n\tsize_t sz;\n\tunsigned binind = binind_compute();\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\n\texpect_d_eq(mallctlnametomib(\"arenas.bin.0.nregs\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomb failure\");\n\tmib[2] = (size_t)binind;\n\tsz = sizeof(nregs);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&nregs, &sz, NULL,\n\t 0), 0, \"Unexpected mallctlbymib failure\");\n\treturn nregs;\n}\n\nstatic unsigned\narenas_create_mallctl(void) {\n\tunsigned arena_ind;\n\tsize_t sz;\n\n\tsz = sizeof(arena_ind);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Error in arenas.create\");\n\n\treturn arena_ind;\n}\n\nstatic void\narena_reset_mallctl(unsigned arena_ind) {\n\tsize_t mib[3];\n\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\n\texpect_d_eq(mallctlnametomib(\"arena.0.reset\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)arena_ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nTEST_BEGIN(test_pack) {\n\tbool prof_enabled;\n\tsize_t sz = sizeof(prof_enabled);\n\tif (mallctl(\"opt.prof\", (void *)&prof_enabled, &sz, NULL, 0) == 0) {\n\t\ttest_skip_if(prof_enabled);\n\t}\n\n\tunsigned arena_ind = arenas_create_mallctl();\n\tsize_t nregs_per_run = nregs_per_run_compute();\n\tsize_t nregs = nregs_per_run * NSLABS;\n\tVARIABLE_ARRAY(void *, ptrs, nregs);\n\tsize_t i, j, offset;\n\n\t/* Fill matrix. */\n\tfor (i = offset = 0; i < NSLABS; i++) {\n\t\tfor (j = 0; j < nregs_per_run; j++) {\n\t\t\tvoid *p = mallocx(SZ, MALLOCX_ARENA(arena_ind) |\n\t\t\t MALLOCX_TCACHE_NONE);\n\t\t\texpect_ptr_not_null(p,\n\t\t\t \"Unexpected mallocx(%zu, MALLOCX_ARENA(%u) |\"\n\t\t\t \" MALLOCX_TCACHE_NONE) failure, run=%zu, reg=%zu\",\n\t\t\t SZ, arena_ind, i, j);\n\t\t\tptrs[(i * nregs_per_run) + j] = p;\n\t\t}\n\t}\n\n\t/*\n\t * Free all but one region of each run, but rotate which region is\n\t * preserved, so that subsequent allocations exercise the within-run\n\t * layout policy.\n\t */\n\toffset = 0;\n\tfor (i = offset = 0;\n\t i < NSLABS;\n\t i++, offset = (offset + 1) % nregs_per_run) {\n\t\tfor (j = 0; j < nregs_per_run; j++) {\n\t\t\tvoid *p = ptrs[(i * nregs_per_run) + j];\n\t\t\tif (offset == j) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tdallocx(p, MALLOCX_ARENA(arena_ind) |\n\t\t\t MALLOCX_TCACHE_NONE);\n\t\t}\n\t}\n\n\t/*\n\t * Logically refill matrix, skipping preserved regions and verifying\n\t * that the matrix is unmodified.\n\t */\n\toffset = 0;\n\tfor (i = offset = 0;\n\t i < NSLABS;\n\t i++, offset = (offset + 1) % nregs_per_run) {\n\t\tfor (j = 0; j < nregs_per_run; j++) {\n\t\t\tvoid *p;\n\n\t\t\tif (offset == j) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tp = mallocx(SZ, MALLOCX_ARENA(arena_ind) |\n\t\t\t MALLOCX_TCACHE_NONE);\n\t\t\texpect_ptr_eq(p, ptrs[(i * nregs_per_run) + j],\n\t\t\t \"Unexpected refill discrepancy, run=%zu, reg=%zu\\n\",\n\t\t\t i, j);\n\t\t}\n\t}\n\n\t/* Clean up. */\n\tarena_reset_mallctl(arena_ind);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_pack);\n}\n" }, { "path": "deps/jemalloc/test/unit/pack.sh", "content": "#!/bin/sh\n\n# Immediately purge to minimize fragmentation.\nexport MALLOC_CONF=\"dirty_decay_ms:0,muzzy_decay_ms:0\"\n" }, { "path": "deps/jemalloc/test/unit/pages.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_pages_huge) {\n\tsize_t alloc_size;\n\tbool commit;\n\tvoid *pages, *hugepage;\n\n\talloc_size = HUGEPAGE * 2 - PAGE;\n\tcommit = true;\n\tpages = pages_map(NULL, alloc_size, PAGE, &commit);\n\texpect_ptr_not_null(pages, \"Unexpected pages_map() error\");\n\n\tif (init_system_thp_mode == thp_mode_default) {\n\t hugepage = (void *)(ALIGNMENT_CEILING((uintptr_t)pages, HUGEPAGE));\n\t expect_b_ne(pages_huge(hugepage, HUGEPAGE), have_madvise_huge,\n\t \"Unexpected pages_huge() result\");\n\t expect_false(pages_nohuge(hugepage, HUGEPAGE),\n\t \"Unexpected pages_nohuge() result\");\n\t}\n\n\tpages_unmap(pages, alloc_size);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_pages_huge);\n}\n" }, { "path": "deps/jemalloc/test/unit/peak.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/peak.h\"\n\nTEST_BEGIN(test_peak) {\n\tpeak_t peak = PEAK_INITIALIZER;\n\texpect_u64_eq(0, peak_max(&peak),\n\t \"Peak should be zero at initialization\");\n\tpeak_update(&peak, 100, 50);\n\texpect_u64_eq(50, peak_max(&peak),\n\t \"Missed update\");\n\tpeak_update(&peak, 100, 100);\n\texpect_u64_eq(50, peak_max(&peak), \"Dallocs shouldn't change peak\");\n\tpeak_update(&peak, 100, 200);\n\texpect_u64_eq(50, peak_max(&peak), \"Dallocs shouldn't change peak\");\n\tpeak_update(&peak, 200, 200);\n\texpect_u64_eq(50, peak_max(&peak), \"Haven't reached peak again\");\n\tpeak_update(&peak, 300, 200);\n\texpect_u64_eq(100, peak_max(&peak), \"Missed an update.\");\n\tpeak_set_zero(&peak, 300, 200);\n\texpect_u64_eq(0, peak_max(&peak), \"No effect from zeroing\");\n\tpeak_update(&peak, 300, 300);\n\texpect_u64_eq(0, peak_max(&peak), \"Dalloc shouldn't change peak\");\n\tpeak_update(&peak, 400, 300);\n\texpect_u64_eq(0, peak_max(&peak), \"Should still be net negative\");\n\tpeak_update(&peak, 500, 300);\n\texpect_u64_eq(100, peak_max(&peak), \"Missed an update.\");\n\t/*\n\t * Above, we set to zero while a net allocator; let's try as a\n\t * net-deallocator.\n\t */\n\tpeak_set_zero(&peak, 600, 700);\n\texpect_u64_eq(0, peak_max(&peak), \"No effect from zeroing.\");\n\tpeak_update(&peak, 600, 800);\n\texpect_u64_eq(0, peak_max(&peak), \"Dalloc shouldn't change peak.\");\n\tpeak_update(&peak, 700, 800);\n\texpect_u64_eq(0, peak_max(&peak), \"Should still be net negative.\");\n\tpeak_update(&peak, 800, 800);\n\texpect_u64_eq(100, peak_max(&peak), \"Missed an update.\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_peak);\n}\n" }, { "path": "deps/jemalloc/test/unit/ph.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/ph.h\"\n\ntypedef struct node_s node_t;\nph_structs(heap, node_t);\n\nstruct node_s {\n#define NODE_MAGIC 0x9823af7e\n\tuint32_t magic;\n\theap_link_t link;\n\tuint64_t key;\n};\n\nstatic int\nnode_cmp(const node_t *a, const node_t *b) {\n\tint ret;\n\n\tret = (a->key > b->key) - (a->key < b->key);\n\tif (ret == 0) {\n\t\t/*\n\t\t * Duplicates are not allowed in the heap, so force an\n\t\t * arbitrary ordering for non-identical items with equal keys.\n\t\t */\n\t\tret = (((uintptr_t)a) > ((uintptr_t)b))\n\t\t - (((uintptr_t)a) < ((uintptr_t)b));\n\t}\n\treturn ret;\n}\n\nstatic int\nnode_cmp_magic(const node_t *a, const node_t *b) {\n\n\texpect_u32_eq(a->magic, NODE_MAGIC, \"Bad magic\");\n\texpect_u32_eq(b->magic, NODE_MAGIC, \"Bad magic\");\n\n\treturn node_cmp(a, b);\n}\n\nph_gen(static, heap, node_t, link, node_cmp_magic);\n\nstatic node_t *\nnode_next_get(const node_t *node) {\n\treturn phn_next_get((node_t *)node, offsetof(node_t, link));\n}\n\nstatic node_t *\nnode_prev_get(const node_t *node) {\n\treturn phn_prev_get((node_t *)node, offsetof(node_t, link));\n}\n\nstatic node_t *\nnode_lchild_get(const node_t *node) {\n\treturn phn_lchild_get((node_t *)node, offsetof(node_t, link));\n}\n\nstatic void\nnode_print(const node_t *node, unsigned depth) {\n\tunsigned i;\n\tnode_t *leftmost_child, *sibling;\n\n\tfor (i = 0; i < depth; i++) {\n\t\tmalloc_printf(\"\\t\");\n\t}\n\tmalloc_printf(\"%2\"FMTu64\"\\n\", node->key);\n\n\tleftmost_child = node_lchild_get(node);\n\tif (leftmost_child == NULL) {\n\t\treturn;\n\t}\n\tnode_print(leftmost_child, depth + 1);\n\n\tfor (sibling = node_next_get(leftmost_child); sibling !=\n\t NULL; sibling = node_next_get(sibling)) {\n\t\tnode_print(sibling, depth + 1);\n\t}\n}\n\nstatic void\nheap_print(const heap_t *heap) {\n\tnode_t *auxelm;\n\n\tmalloc_printf(\"vvv heap %p vvv\\n\", heap);\n\tif (heap->ph.root == NULL) {\n\t\tgoto label_return;\n\t}\n\n\tnode_print(heap->ph.root, 0);\n\n\tfor (auxelm = node_next_get(heap->ph.root); auxelm != NULL;\n\t auxelm = node_next_get(auxelm)) {\n\t\texpect_ptr_eq(node_next_get(node_prev_get(auxelm)), auxelm,\n\t\t \"auxelm's prev doesn't link to auxelm\");\n\t\tnode_print(auxelm, 0);\n\t}\n\nlabel_return:\n\tmalloc_printf(\"^^^ heap %p ^^^\\n\", heap);\n}\n\nstatic unsigned\nnode_validate(const node_t *node, const node_t *parent) {\n\tunsigned nnodes = 1;\n\tnode_t *leftmost_child, *sibling;\n\n\tif (parent != NULL) {\n\t\texpect_d_ge(node_cmp_magic(node, parent), 0,\n\t\t \"Child is less than parent\");\n\t}\n\n\tleftmost_child = node_lchild_get(node);\n\tif (leftmost_child == NULL) {\n\t\treturn nnodes;\n\t}\n\texpect_ptr_eq(node_prev_get(leftmost_child),\n\t (void *)node, \"Leftmost child does not link to node\");\n\tnnodes += node_validate(leftmost_child, node);\n\n\tfor (sibling = node_next_get(leftmost_child); sibling !=\n\t NULL; sibling = node_next_get(sibling)) {\n\t\texpect_ptr_eq(node_next_get(node_prev_get(sibling)), sibling,\n\t\t \"sibling's prev doesn't link to sibling\");\n\t\tnnodes += node_validate(sibling, node);\n\t}\n\treturn nnodes;\n}\n\nstatic unsigned\nheap_validate(const heap_t *heap) {\n\tunsigned nnodes = 0;\n\tnode_t *auxelm;\n\n\tif (heap->ph.root == NULL) {\n\t\tgoto label_return;\n\t}\n\n\tnnodes += node_validate(heap->ph.root, NULL);\n\n\tfor (auxelm = node_next_get(heap->ph.root); auxelm != NULL;\n\t auxelm = node_next_get(auxelm)) {\n\t\texpect_ptr_eq(node_next_get(node_prev_get(auxelm)), auxelm,\n\t\t \"auxelm's prev doesn't link to auxelm\");\n\t\tnnodes += node_validate(auxelm, NULL);\n\t}\n\nlabel_return:\n\tif (false) {\n\t\theap_print(heap);\n\t}\n\treturn nnodes;\n}\n\nTEST_BEGIN(test_ph_empty) {\n\theap_t heap;\n\n\theap_new(&heap);\n\texpect_true(heap_empty(&heap), \"Heap should be empty\");\n\texpect_ptr_null(heap_first(&heap), \"Unexpected node\");\n\texpect_ptr_null(heap_any(&heap), \"Unexpected node\");\n}\nTEST_END\n\nstatic void\nnode_remove(heap_t *heap, node_t *node) {\n\theap_remove(heap, node);\n\n\tnode->magic = 0;\n}\n\nstatic node_t *\nnode_remove_first(heap_t *heap) {\n\tnode_t *node = heap_remove_first(heap);\n\tnode->magic = 0;\n\treturn node;\n}\n\nstatic node_t *\nnode_remove_any(heap_t *heap) {\n\tnode_t *node = heap_remove_any(heap);\n\tnode->magic = 0;\n\treturn node;\n}\n\nTEST_BEGIN(test_ph_random) {\n#define NNODES 25\n#define NBAGS 250\n#define SEED 42\n\tsfmt_t *sfmt;\n\tuint64_t bag[NNODES];\n\theap_t heap;\n\tnode_t nodes[NNODES];\n\tunsigned i, j, k;\n\n\tsfmt = init_gen_rand(SEED);\n\tfor (i = 0; i < NBAGS; i++) {\n\t\tswitch (i) {\n\t\tcase 0:\n\t\t\t/* Insert in order. */\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = j;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase 1:\n\t\t\t/* Insert in reverse order. */\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = NNODES - j - 1;\n\t\t\t}\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = gen_rand64_range(sfmt, NNODES);\n\t\t\t}\n\t\t}\n\n\t\tfor (j = 1; j <= NNODES; j++) {\n\t\t\t/* Initialize heap and nodes. */\n\t\t\theap_new(&heap);\n\t\t\texpect_u_eq(heap_validate(&heap), 0,\n\t\t\t \"Incorrect node count\");\n\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\tnodes[k].magic = NODE_MAGIC;\n\t\t\t\tnodes[k].key = bag[k];\n\t\t\t}\n\n\t\t\t/* Insert nodes. */\n\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\theap_insert(&heap, &nodes[k]);\n\t\t\t\tif (i % 13 == 12) {\n\t\t\t\t\texpect_ptr_not_null(heap_any(&heap),\n\t\t\t\t\t \"Heap should not be empty\");\n\t\t\t\t\t/* Trigger merging. */\n\t\t\t\t\texpect_ptr_not_null(heap_first(&heap),\n\t\t\t\t\t \"Heap should not be empty\");\n\t\t\t\t}\n\t\t\t\texpect_u_eq(heap_validate(&heap), k + 1,\n\t\t\t\t \"Incorrect node count\");\n\t\t\t}\n\n\t\t\texpect_false(heap_empty(&heap),\n\t\t\t \"Heap should not be empty\");\n\n\t\t\t/* Remove nodes. */\n\t\t\tswitch (i % 6) {\n\t\t\tcase 0:\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k,\n\t\t\t\t\t \"Incorrect node count\");\n\t\t\t\t\tnode_remove(&heap, &nodes[k]);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k\n\t\t\t\t\t - 1, \"Incorrect node count\");\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\tfor (k = j; k > 0; k--) {\n\t\t\t\t\tnode_remove(&heap, &nodes[k-1]);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), k - 1,\n\t\t\t\t\t \"Incorrect node count\");\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 2: {\n\t\t\t\tnode_t *prev = NULL;\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\tnode_t *node = node_remove_first(&heap);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k\n\t\t\t\t\t - 1, \"Incorrect node count\");\n\t\t\t\t\tif (prev != NULL) {\n\t\t\t\t\t\texpect_d_ge(node_cmp(node,\n\t\t\t\t\t\t prev), 0,\n\t\t\t\t\t\t \"Bad removal order\");\n\t\t\t\t\t}\n\t\t\t\t\tprev = node;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} case 3: {\n\t\t\t\tnode_t *prev = NULL;\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\tnode_t *node = heap_first(&heap);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k,\n\t\t\t\t\t \"Incorrect node count\");\n\t\t\t\t\tif (prev != NULL) {\n\t\t\t\t\t\texpect_d_ge(node_cmp(node,\n\t\t\t\t\t\t prev), 0,\n\t\t\t\t\t\t \"Bad removal order\");\n\t\t\t\t\t}\n\t\t\t\t\tnode_remove(&heap, node);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k\n\t\t\t\t\t - 1, \"Incorrect node count\");\n\t\t\t\t\tprev = node;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} case 4: {\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\tnode_remove_any(&heap);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k\n\t\t\t\t\t - 1, \"Incorrect node count\");\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} case 5: {\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\tnode_t *node = heap_any(&heap);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k,\n\t\t\t\t\t \"Incorrect node count\");\n\t\t\t\t\tnode_remove(&heap, node);\n\t\t\t\t\texpect_u_eq(heap_validate(&heap), j - k\n\t\t\t\t\t - 1, \"Incorrect node count\");\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} default:\n\t\t\t\tnot_reached();\n\t\t\t}\n\n\t\t\texpect_ptr_null(heap_first(&heap),\n\t\t\t \"Heap should be empty\");\n\t\t\texpect_ptr_null(heap_any(&heap),\n\t\t\t \"Heap should be empty\");\n\t\t\texpect_true(heap_empty(&heap), \"Heap should be empty\");\n\t\t}\n\t}\n\tfini_gen_rand(sfmt);\n#undef NNODES\n#undef SEED\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_ph_empty,\n\t test_ph_random);\n}\n" }, { "path": "deps/jemalloc/test/unit/prng.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_prng_lg_range_u32) {\n\tuint32_t sa, sb;\n\tuint32_t ra, rb;\n\tunsigned lg_range;\n\n\tsa = 42;\n\tra = prng_lg_range_u32(&sa, 32);\n\tsa = 42;\n\trb = prng_lg_range_u32(&sa, 32);\n\texpect_u32_eq(ra, rb,\n\t \"Repeated generation should produce repeated results\");\n\n\tsb = 42;\n\trb = prng_lg_range_u32(&sb, 32);\n\texpect_u32_eq(ra, rb,\n\t \"Equivalent generation should produce equivalent results\");\n\n\tsa = 42;\n\tra = prng_lg_range_u32(&sa, 32);\n\trb = prng_lg_range_u32(&sa, 32);\n\texpect_u32_ne(ra, rb,\n\t \"Full-width results must not immediately repeat\");\n\n\tsa = 42;\n\tra = prng_lg_range_u32(&sa, 32);\n\tfor (lg_range = 31; lg_range > 0; lg_range--) {\n\t\tsb = 42;\n\t\trb = prng_lg_range_u32(&sb, lg_range);\n\t\texpect_u32_eq((rb & (UINT32_C(0xffffffff) << lg_range)),\n\t\t 0, \"High order bits should be 0, lg_range=%u\", lg_range);\n\t\texpect_u32_eq(rb, (ra >> (32 - lg_range)),\n\t\t \"Expected high order bits of full-width result, \"\n\t\t \"lg_range=%u\", lg_range);\n\t}\n\n}\nTEST_END\n\nTEST_BEGIN(test_prng_lg_range_u64) {\n\tuint64_t sa, sb, ra, rb;\n\tunsigned lg_range;\n\n\tsa = 42;\n\tra = prng_lg_range_u64(&sa, 64);\n\tsa = 42;\n\trb = prng_lg_range_u64(&sa, 64);\n\texpect_u64_eq(ra, rb,\n\t \"Repeated generation should produce repeated results\");\n\n\tsb = 42;\n\trb = prng_lg_range_u64(&sb, 64);\n\texpect_u64_eq(ra, rb,\n\t \"Equivalent generation should produce equivalent results\");\n\n\tsa = 42;\n\tra = prng_lg_range_u64(&sa, 64);\n\trb = prng_lg_range_u64(&sa, 64);\n\texpect_u64_ne(ra, rb,\n\t \"Full-width results must not immediately repeat\");\n\n\tsa = 42;\n\tra = prng_lg_range_u64(&sa, 64);\n\tfor (lg_range = 63; lg_range > 0; lg_range--) {\n\t\tsb = 42;\n\t\trb = prng_lg_range_u64(&sb, lg_range);\n\t\texpect_u64_eq((rb & (UINT64_C(0xffffffffffffffff) << lg_range)),\n\t\t 0, \"High order bits should be 0, lg_range=%u\", lg_range);\n\t\texpect_u64_eq(rb, (ra >> (64 - lg_range)),\n\t\t \"Expected high order bits of full-width result, \"\n\t\t \"lg_range=%u\", lg_range);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_prng_lg_range_zu) {\n\tsize_t sa, sb;\n\tsize_t ra, rb;\n\tunsigned lg_range;\n\n\tsa = 42;\n\tra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR));\n\tsa = 42;\n\trb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR));\n\texpect_zu_eq(ra, rb,\n\t \"Repeated generation should produce repeated results\");\n\n\tsb = 42;\n\trb = prng_lg_range_zu(&sb, ZU(1) << (3 + LG_SIZEOF_PTR));\n\texpect_zu_eq(ra, rb,\n\t \"Equivalent generation should produce equivalent results\");\n\n\tsa = 42;\n\tra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR));\n\trb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR));\n\texpect_zu_ne(ra, rb,\n\t \"Full-width results must not immediately repeat\");\n\n\tsa = 42;\n\tra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR));\n\tfor (lg_range = (ZU(1) << (3 + LG_SIZEOF_PTR)) - 1; lg_range > 0;\n\t lg_range--) {\n\t\tsb = 42;\n\t\trb = prng_lg_range_zu(&sb, lg_range);\n\t\texpect_zu_eq((rb & (SIZE_T_MAX << lg_range)),\n\t\t 0, \"High order bits should be 0, lg_range=%u\", lg_range);\n\t\texpect_zu_eq(rb, (ra >> ((ZU(1) << (3 + LG_SIZEOF_PTR)) -\n\t\t lg_range)), \"Expected high order bits of full-width \"\n\t\t \"result, lg_range=%u\", lg_range);\n\t}\n\n}\nTEST_END\n\nTEST_BEGIN(test_prng_range_u32) {\n\tuint32_t range;\n\n\tconst uint32_t max_range = 10000000;\n\tconst uint32_t range_step = 97;\n\tconst unsigned nreps = 10;\n\n\tfor (range = 2; range < max_range; range += range_step) {\n\t\tuint32_t s;\n\t\tunsigned rep;\n\n\t\ts = range;\n\t\tfor (rep = 0; rep < nreps; rep++) {\n\t\t\tuint32_t r = prng_range_u32(&s, range);\n\n\t\t\texpect_u32_lt(r, range, \"Out of range\");\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_prng_range_u64) {\n\tuint64_t range;\n\n\tconst uint64_t max_range = 10000000;\n\tconst uint64_t range_step = 97;\n\tconst unsigned nreps = 10;\n\n\tfor (range = 2; range < max_range; range += range_step) {\n\t\tuint64_t s;\n\t\tunsigned rep;\n\n\t\ts = range;\n\t\tfor (rep = 0; rep < nreps; rep++) {\n\t\t\tuint64_t r = prng_range_u64(&s, range);\n\n\t\t\texpect_u64_lt(r, range, \"Out of range\");\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_prng_range_zu) {\n\tsize_t range;\n\n\tconst size_t max_range = 10000000;\n\tconst size_t range_step = 97;\n\tconst unsigned nreps = 10;\n\n\n\tfor (range = 2; range < max_range; range += range_step) {\n\t\tsize_t s;\n\t\tunsigned rep;\n\n\t\ts = range;\n\t\tfor (rep = 0; rep < nreps; rep++) {\n\t\t\tsize_t r = prng_range_zu(&s, range);\n\n\t\t\texpect_zu_lt(r, range, \"Out of range\");\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_prng_lg_range_u32,\n\t test_prng_lg_range_u64,\n\t test_prng_lg_range_zu,\n\t test_prng_range_u32,\n\t test_prng_range_u64,\n\t test_prng_range_zu);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_accum.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n\n#define NTHREADS\t\t4\n#define NALLOCS_PER_THREAD\t50\n#define DUMP_INTERVAL\t\t1\n#define BT_COUNT_CHECK_INTERVAL\t5\n\nstatic int\nprof_dump_open_file_intercept(const char *filename, int mode) {\n\tint fd;\n\n\tfd = open(\"/dev/null\", O_WRONLY);\n\tassert_d_ne(fd, -1, \"Unexpected open() failure\");\n\n\treturn fd;\n}\n\nstatic void *\nalloc_from_permuted_backtrace(unsigned thd_ind, unsigned iteration) {\n\treturn btalloc(1, thd_ind*NALLOCS_PER_THREAD + iteration);\n}\n\nstatic void *\nthd_start(void *varg) {\n\tunsigned thd_ind = *(unsigned *)varg;\n\tsize_t bt_count_prev, bt_count;\n\tunsigned i_prev, i;\n\n\ti_prev = 0;\n\tbt_count_prev = 0;\n\tfor (i = 0; i < NALLOCS_PER_THREAD; i++) {\n\t\tvoid *p = alloc_from_permuted_backtrace(thd_ind, i);\n\t\tdallocx(p, 0);\n\t\tif (i % DUMP_INTERVAL == 0) {\n\t\t\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, NULL, 0),\n\t\t\t 0, \"Unexpected error while dumping heap profile\");\n\t\t}\n\n\t\tif (i % BT_COUNT_CHECK_INTERVAL == 0 ||\n\t\t i+1 == NALLOCS_PER_THREAD) {\n\t\t\tbt_count = prof_bt_count();\n\t\t\texpect_zu_le(bt_count_prev+(i-i_prev), bt_count,\n\t\t\t \"Expected larger backtrace count increase\");\n\t\t\ti_prev = i;\n\t\t\tbt_count_prev = bt_count;\n\t\t}\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_idump) {\n\tbool active;\n\tthd_t thds[NTHREADS];\n\tunsigned thd_args[NTHREADS];\n\tunsigned i;\n\n\ttest_skip_if(!config_prof);\n\n\tactive = true;\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, (void *)&active,\n\t sizeof(active)), 0,\n\t \"Unexpected mallctl failure while activating profiling\");\n\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_args[i] = i;\n\t\tthd_create(&thds[i], thd_start, (void *)&thd_args[i]);\n\t}\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_idump);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_accum.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_accum:true,prof_active:false,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_active.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_data.h\"\n\nstatic void\nmallctl_bool_get(const char *name, bool expected, const char *func, int line) {\n\tbool old;\n\tsize_t sz;\n\n\tsz = sizeof(old);\n\texpect_d_eq(mallctl(name, (void *)&old, &sz, NULL, 0), 0,\n\t \"%s():%d: Unexpected mallctl failure reading %s\", func, line, name);\n\texpect_b_eq(old, expected, \"%s():%d: Unexpected %s value\", func, line,\n\t name);\n}\n\nstatic void\nmallctl_bool_set(const char *name, bool old_expected, bool val_new,\n const char *func, int line) {\n\tbool old;\n\tsize_t sz;\n\n\tsz = sizeof(old);\n\texpect_d_eq(mallctl(name, (void *)&old, &sz, (void *)&val_new,\n\t sizeof(val_new)), 0,\n\t \"%s():%d: Unexpected mallctl failure reading/writing %s\", func,\n\t line, name);\n\texpect_b_eq(old, old_expected, \"%s():%d: Unexpected %s value\", func,\n\t line, name);\n}\n\nstatic void\nmallctl_prof_active_get_impl(bool prof_active_old_expected, const char *func,\n int line) {\n\tmallctl_bool_get(\"prof.active\", prof_active_old_expected, func, line);\n}\n#define mallctl_prof_active_get(a)\t\t\t\t\t\\\n\tmallctl_prof_active_get_impl(a, __func__, __LINE__)\n\nstatic void\nmallctl_prof_active_set_impl(bool prof_active_old_expected,\n bool prof_active_new, const char *func, int line) {\n\tmallctl_bool_set(\"prof.active\", prof_active_old_expected,\n\t prof_active_new, func, line);\n}\n#define mallctl_prof_active_set(a, b)\t\t\t\t\t\\\n\tmallctl_prof_active_set_impl(a, b, __func__, __LINE__)\n\nstatic void\nmallctl_thread_prof_active_get_impl(bool thread_prof_active_old_expected,\n const char *func, int line) {\n\tmallctl_bool_get(\"thread.prof.active\", thread_prof_active_old_expected,\n\t func, line);\n}\n#define mallctl_thread_prof_active_get(a)\t\t\t\t\\\n\tmallctl_thread_prof_active_get_impl(a, __func__, __LINE__)\n\nstatic void\nmallctl_thread_prof_active_set_impl(bool thread_prof_active_old_expected,\n bool thread_prof_active_new, const char *func, int line) {\n\tmallctl_bool_set(\"thread.prof.active\", thread_prof_active_old_expected,\n\t thread_prof_active_new, func, line);\n}\n#define mallctl_thread_prof_active_set(a, b)\t\t\t\t\\\n\tmallctl_thread_prof_active_set_impl(a, b, __func__, __LINE__)\n\nstatic void\nprof_sampling_probe_impl(bool expect_sample, const char *func, int line) {\n\tvoid *p;\n\tsize_t expected_backtraces = expect_sample ? 1 : 0;\n\n\texpect_zu_eq(prof_bt_count(), 0, \"%s():%d: Expected 0 backtraces\", func,\n\t line);\n\tp = mallocx(1, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\texpect_zu_eq(prof_bt_count(), expected_backtraces,\n\t \"%s():%d: Unexpected backtrace count\", func, line);\n\tdallocx(p, 0);\n}\n#define prof_sampling_probe(a)\t\t\t\t\t\t\\\n\tprof_sampling_probe_impl(a, __func__, __LINE__)\n\nTEST_BEGIN(test_prof_active) {\n\ttest_skip_if(!config_prof);\n\n\tmallctl_prof_active_get(true);\n\tmallctl_thread_prof_active_get(false);\n\n\tmallctl_prof_active_set(true, true);\n\tmallctl_thread_prof_active_set(false, false);\n\t/* prof.active, !thread.prof.active. */\n\tprof_sampling_probe(false);\n\n\tmallctl_prof_active_set(true, false);\n\tmallctl_thread_prof_active_set(false, false);\n\t/* !prof.active, !thread.prof.active. */\n\tprof_sampling_probe(false);\n\n\tmallctl_prof_active_set(false, false);\n\tmallctl_thread_prof_active_set(false, true);\n\t/* !prof.active, thread.prof.active. */\n\tprof_sampling_probe(false);\n\n\tmallctl_prof_active_set(false, true);\n\tmallctl_thread_prof_active_set(true, true);\n\t/* prof.active, thread.prof.active. */\n\tprof_sampling_probe(true);\n\n\t/* Restore settings. */\n\tmallctl_prof_active_set(true, true);\n\tmallctl_thread_prof_active_set(true, false);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_prof_active);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_active.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,prof_thread_active_init:false,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_gdump.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_sys.h\"\n\nstatic bool did_prof_dump_open;\n\nstatic int\nprof_dump_open_file_intercept(const char *filename, int mode) {\n\tint fd;\n\n\tdid_prof_dump_open = true;\n\n\tfd = open(\"/dev/null\", O_WRONLY);\n\tassert_d_ne(fd, -1, \"Unexpected open() failure\");\n\n\treturn fd;\n}\n\nTEST_BEGIN(test_gdump) {\n\ttest_skip_if(opt_hpa);\n\tbool active, gdump, gdump_old;\n\tvoid *p, *q, *r, *s;\n\tsize_t sz;\n\n\ttest_skip_if(!config_prof);\n\n\tactive = true;\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, (void *)&active,\n\t sizeof(active)), 0,\n\t \"Unexpected mallctl failure while activating profiling\");\n\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\n\tdid_prof_dump_open = false;\n\tp = mallocx((1U << SC_LG_LARGE_MINCLASS), 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\texpect_true(did_prof_dump_open, \"Expected a profile dump\");\n\n\tdid_prof_dump_open = false;\n\tq = mallocx((1U << SC_LG_LARGE_MINCLASS), 0);\n\texpect_ptr_not_null(q, \"Unexpected mallocx() failure\");\n\texpect_true(did_prof_dump_open, \"Expected a profile dump\");\n\n\tgdump = false;\n\tsz = sizeof(gdump_old);\n\texpect_d_eq(mallctl(\"prof.gdump\", (void *)&gdump_old, &sz,\n\t (void *)&gdump, sizeof(gdump)), 0,\n\t \"Unexpected mallctl failure while disabling prof.gdump\");\n\tassert(gdump_old);\n\tdid_prof_dump_open = false;\n\tr = mallocx((1U << SC_LG_LARGE_MINCLASS), 0);\n\texpect_ptr_not_null(q, \"Unexpected mallocx() failure\");\n\texpect_false(did_prof_dump_open, \"Unexpected profile dump\");\n\n\tgdump = true;\n\tsz = sizeof(gdump_old);\n\texpect_d_eq(mallctl(\"prof.gdump\", (void *)&gdump_old, &sz,\n\t (void *)&gdump, sizeof(gdump)), 0,\n\t \"Unexpected mallctl failure while enabling prof.gdump\");\n\tassert(!gdump_old);\n\tdid_prof_dump_open = false;\n\ts = mallocx((1U << SC_LG_LARGE_MINCLASS), 0);\n\texpect_ptr_not_null(q, \"Unexpected mallocx() failure\");\n\texpect_true(did_prof_dump_open, \"Expected a profile dump\");\n\n\tdallocx(p, 0);\n\tdallocx(q, 0);\n\tdallocx(r, 0);\n\tdallocx(s, 0);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_gdump);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_gdump.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:false,prof_gdump:true\"\nfi\n\n" }, { "path": "deps/jemalloc/test/unit/prof_hook.c", "content": "#include \"test/jemalloc_test.h\"\n\nconst char *dump_filename = \"/dev/null\";\n\nprof_backtrace_hook_t default_hook;\n\nbool mock_bt_hook_called = false;\nbool mock_dump_hook_called = false;\n\nvoid\nmock_bt_hook(void **vec, unsigned *len, unsigned max_len) {\n\t*len = max_len;\n\tfor (unsigned i = 0; i < max_len; ++i) {\n\t\tvec[i] = (void *)((uintptr_t)i);\n\t}\n\tmock_bt_hook_called = true;\n}\n\nvoid\nmock_bt_augmenting_hook(void **vec, unsigned *len, unsigned max_len) {\n\tdefault_hook(vec, len, max_len);\n\texpect_u_gt(*len, 0, \"Default backtrace hook returned empty backtrace\");\n\texpect_u_lt(*len, max_len,\n\t \"Default backtrace hook returned too large backtrace\");\n\n\t/* Add a separator between default frames and augmented */\n\tvec[*len] = (void *)0x030303030;\n\t(*len)++;\n\n\t/* Add more stack frames */\n\tfor (unsigned i = 0; i < 3; ++i) {\n\t\tif (*len == max_len) {\n\t\t\tbreak;\n\t\t}\n\t\tvec[*len] = (void *)((uintptr_t)i);\n\t\t(*len)++;\n\t}\n\n\n\tmock_bt_hook_called = true;\n}\n\nvoid\nmock_dump_hook(const char *filename) {\n\tmock_dump_hook_called = true;\n\texpect_str_eq(filename, dump_filename,\n\t \"Incorrect file name passed to the dump hook\");\n}\n\nTEST_BEGIN(test_prof_backtrace_hook_replace) {\n\n\ttest_skip_if(!config_prof);\n\n\tmock_bt_hook_called = false;\n\n\tvoid *p0 = mallocx(1, 0);\n\tassert_ptr_not_null(p0, \"Failed to allocate\");\n\n\texpect_false(mock_bt_hook_called, \"Called mock hook before it's set\");\n\n\tprof_backtrace_hook_t null_hook = NULL;\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_backtrace\",\n\t NULL, 0, (void *)&null_hook, sizeof(null_hook)),\n\t\tEINVAL, \"Incorrectly allowed NULL backtrace hook\");\n\n\tsize_t default_hook_sz = sizeof(prof_backtrace_hook_t);\n\tprof_backtrace_hook_t hook = &mock_bt_hook;\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_backtrace\",\n\t (void *)&default_hook, &default_hook_sz, (void *)&hook,\n\t sizeof(hook)), 0, \"Unexpected mallctl failure setting hook\");\n\n\tvoid *p1 = mallocx(1, 0);\n\tassert_ptr_not_null(p1, \"Failed to allocate\");\n\n\texpect_true(mock_bt_hook_called, \"Didn't call mock hook\");\n\n\tprof_backtrace_hook_t current_hook;\n\tsize_t current_hook_sz = sizeof(prof_backtrace_hook_t);\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_backtrace\",\n\t (void *)¤t_hook, ¤t_hook_sz, (void *)&default_hook,\n\t sizeof(default_hook)), 0,\n\t \"Unexpected mallctl failure resetting hook to default\");\n\n\texpect_ptr_eq(current_hook, hook,\n\t \"Hook returned by mallctl is not equal to mock hook\");\n\n\tdallocx(p1, 0);\n\tdallocx(p0, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_prof_backtrace_hook_augment) {\n\n\ttest_skip_if(!config_prof);\n\n\tmock_bt_hook_called = false;\n\n\tvoid *p0 = mallocx(1, 0);\n\tassert_ptr_not_null(p0, \"Failed to allocate\");\n\n\texpect_false(mock_bt_hook_called, \"Called mock hook before it's set\");\n\n\tsize_t default_hook_sz = sizeof(prof_backtrace_hook_t);\n\tprof_backtrace_hook_t hook = &mock_bt_augmenting_hook;\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_backtrace\",\n\t (void *)&default_hook, &default_hook_sz, (void *)&hook,\n\t sizeof(hook)), 0, \"Unexpected mallctl failure setting hook\");\n\n\tvoid *p1 = mallocx(1, 0);\n\tassert_ptr_not_null(p1, \"Failed to allocate\");\n\n\texpect_true(mock_bt_hook_called, \"Didn't call mock hook\");\n\n\tprof_backtrace_hook_t current_hook;\n\tsize_t current_hook_sz = sizeof(prof_backtrace_hook_t);\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_backtrace\",\n\t (void *)¤t_hook, ¤t_hook_sz, (void *)&default_hook,\n\t sizeof(default_hook)), 0,\n\t \"Unexpected mallctl failure resetting hook to default\");\n\n\texpect_ptr_eq(current_hook, hook,\n\t \"Hook returned by mallctl is not equal to mock hook\");\n\n\tdallocx(p1, 0);\n\tdallocx(p0, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_prof_dump_hook) {\n\n\ttest_skip_if(!config_prof);\n\n\tmock_dump_hook_called = false;\n\n\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, (void *)&dump_filename,\n\t sizeof(dump_filename)), 0, \"Failed to dump heap profile\");\n\n\texpect_false(mock_dump_hook_called, \"Called dump hook before it's set\");\n\n\tsize_t default_hook_sz = sizeof(prof_dump_hook_t);\n\tprof_dump_hook_t hook = &mock_dump_hook;\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_dump\",\n\t (void *)&default_hook, &default_hook_sz, (void *)&hook,\n\t sizeof(hook)), 0, \"Unexpected mallctl failure setting hook\");\n\n\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, (void *)&dump_filename,\n\t sizeof(dump_filename)), 0, \"Failed to dump heap profile\");\n\n\texpect_true(mock_dump_hook_called, \"Didn't call mock hook\");\n\n\tprof_dump_hook_t current_hook;\n\tsize_t current_hook_sz = sizeof(prof_dump_hook_t);\n\texpect_d_eq(mallctl(\"experimental.hooks.prof_dump\",\n\t (void *)¤t_hook, ¤t_hook_sz, (void *)&default_hook,\n\t sizeof(default_hook)), 0,\n\t \"Unexpected mallctl failure resetting hook to default\");\n\n\texpect_ptr_eq(current_hook, hook,\n\t \"Hook returned by mallctl is not equal to mock hook\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_prof_backtrace_hook_replace,\n\t test_prof_backtrace_hook_augment,\n\t test_prof_dump_hook);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_hook.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0\"\nfi\n\n" }, { "path": "deps/jemalloc/test/unit/prof_idump.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_sys.h\"\n\n#define TEST_PREFIX \"test_prefix\"\n\nstatic bool did_prof_dump_open;\n\nstatic int\nprof_dump_open_file_intercept(const char *filename, int mode) {\n\tint fd;\n\n\tdid_prof_dump_open = true;\n\n\tconst char filename_prefix[] = TEST_PREFIX \".\";\n\texpect_d_eq(strncmp(filename_prefix, filename, sizeof(filename_prefix)\n\t - 1), 0, \"Dump file name should start with \\\"\" TEST_PREFIX \".\\\"\");\n\n\tfd = open(\"/dev/null\", O_WRONLY);\n\tassert_d_ne(fd, -1, \"Unexpected open() failure\");\n\n\treturn fd;\n}\n\nTEST_BEGIN(test_idump) {\n\tbool active;\n\tvoid *p;\n\n\tconst char *test_prefix = TEST_PREFIX;\n\n\ttest_skip_if(!config_prof);\n\n\tactive = true;\n\n\texpect_d_eq(mallctl(\"prof.prefix\", NULL, NULL, (void *)&test_prefix,\n\t sizeof(test_prefix)), 0,\n\t \"Unexpected mallctl failure while overwriting dump prefix\");\n\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, (void *)&active,\n\t sizeof(active)), 0,\n\t \"Unexpected mallctl failure while activating profiling\");\n\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\n\tdid_prof_dump_open = false;\n\tp = mallocx(1, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\tdallocx(p, 0);\n\texpect_true(did_prof_dump_open, \"Expected a profile dump\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_idump);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_idump.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"tcache:false\"\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"${MALLOC_CONF},prof:true,prof_accum:true,prof_active:false,lg_prof_sample:0,lg_prof_interval:0\"\nfi\n\n\n" }, { "path": "deps/jemalloc/test/unit/prof_log.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"jemalloc/internal/prof_log.h\"\n\n#define N_PARAM 100\n#define N_THREADS 10\n\nstatic void expect_rep() {\n\texpect_b_eq(prof_log_rep_check(), false, \"Rep check failed\");\n}\n\nstatic void expect_log_empty() {\n\texpect_zu_eq(prof_log_bt_count(), 0,\n\t \"The log has backtraces; it isn't empty\");\n\texpect_zu_eq(prof_log_thr_count(), 0,\n\t \"The log has threads; it isn't empty\");\n\texpect_zu_eq(prof_log_alloc_count(), 0,\n\t \"The log has allocations; it isn't empty\");\n}\n\nvoid *buf[N_PARAM];\n\nstatic void f() {\n\tint i;\n\tfor (i = 0; i < N_PARAM; i++) {\n\t\tbuf[i] = malloc(100);\n\t}\n\tfor (i = 0; i < N_PARAM; i++) {\n\t\tfree(buf[i]);\n\t}\n}\n\nTEST_BEGIN(test_prof_log_many_logs) {\n\tint i;\n\n\ttest_skip_if(!config_prof);\n\n\tfor (i = 0; i < N_PARAM; i++) {\n\t\texpect_b_eq(prof_log_is_logging(), false,\n\t\t \"Logging shouldn't have started yet\");\n\t\texpect_d_eq(mallctl(\"prof.log_start\", NULL, NULL, NULL, 0), 0,\n\t\t \"Unexpected mallctl failure when starting logging\");\n\t\texpect_b_eq(prof_log_is_logging(), true,\n\t\t \"Logging should be started by now\");\n\t\texpect_log_empty();\n\t\texpect_rep();\n\t\tf();\n\t\texpect_zu_eq(prof_log_thr_count(), 1, \"Wrong thread count\");\n\t\texpect_rep();\n\t\texpect_b_eq(prof_log_is_logging(), true,\n\t\t \"Logging should still be on\");\n\t\texpect_d_eq(mallctl(\"prof.log_stop\", NULL, NULL, NULL, 0), 0,\n\t\t \"Unexpected mallctl failure when stopping logging\");\n\t\texpect_b_eq(prof_log_is_logging(), false,\n\t\t \"Logging should have turned off\");\n\t}\n}\nTEST_END\n\nthd_t thr_buf[N_THREADS];\n\nstatic void *f_thread(void *unused) {\n\tint i;\n\tfor (i = 0; i < N_PARAM; i++) {\n\t\tvoid *p = malloc(100);\n\t\tmemset(p, 100, 1);\n\t\tfree(p);\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_prof_log_many_threads) {\n\n\ttest_skip_if(!config_prof);\n\n\tint i;\n\texpect_d_eq(mallctl(\"prof.log_start\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl failure when starting logging\");\n\tfor (i = 0; i < N_THREADS; i++) {\n\t\tthd_create(&thr_buf[i], &f_thread, NULL);\n\t}\n\n\tfor (i = 0; i < N_THREADS; i++) {\n\t\tthd_join(thr_buf[i], NULL);\n\t}\n\texpect_zu_eq(prof_log_thr_count(), N_THREADS,\n\t \"Wrong number of thread entries\");\n\texpect_rep();\n\texpect_d_eq(mallctl(\"prof.log_stop\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl failure when stopping logging\");\n}\nTEST_END\n\nstatic void f3() {\n\tvoid *p = malloc(100);\n\tfree(p);\n}\n\nstatic void f1() {\n\tvoid *p = malloc(100);\n\tf3();\n\tfree(p);\n}\n\nstatic void f2() {\n\tvoid *p = malloc(100);\n\tfree(p);\n}\n\nTEST_BEGIN(test_prof_log_many_traces) {\n\n\ttest_skip_if(!config_prof);\n\n\texpect_d_eq(mallctl(\"prof.log_start\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl failure when starting logging\");\n\tint i;\n\texpect_rep();\n\texpect_log_empty();\n\tfor (i = 0; i < N_PARAM; i++) {\n\t\texpect_rep();\n\t\tf1();\n\t\texpect_rep();\n\t\tf2();\n\t\texpect_rep();\n\t\tf3();\n\t\texpect_rep();\n\t}\n\t/*\n\t * There should be 8 total backtraces: two for malloc/free in f1(), two\n\t * for malloc/free in f2(), two for malloc/free in f3(), and then two\n\t * for malloc/free in f1()'s call to f3(). However compiler\n\t * optimizations such as loop unrolling might generate more call sites.\n\t * So >= 8 traces are expected.\n\t */\n\texpect_zu_ge(prof_log_bt_count(), 8,\n\t \"Expect at least 8 backtraces given sample workload\");\n\texpect_d_eq(mallctl(\"prof.log_stop\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl failure when stopping logging\");\n}\nTEST_END\n\nint\nmain(void) {\n\tif (config_prof) {\n\t\tprof_log_dummy_set(true);\n\t}\n\treturn test_no_reentrancy(\n\t test_prof_log_many_logs,\n\t test_prof_log_many_traces,\n\t test_prof_log_many_threads);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_log.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_mdump.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_sys.h\"\n\nstatic const char *test_filename = \"test_filename\";\nstatic bool did_prof_dump_open;\n\nstatic int\nprof_dump_open_file_intercept(const char *filename, int mode) {\n\tint fd;\n\n\tdid_prof_dump_open = true;\n\n\t/*\n\t * Stronger than a strcmp() - verifying that we internally directly use\n\t * the caller supplied char pointer.\n\t */\n\texpect_ptr_eq(filename, test_filename,\n\t \"Dump file name should be \\\"%s\\\"\", test_filename);\n\n\tfd = open(\"/dev/null\", O_WRONLY);\n\tassert_d_ne(fd, -1, \"Unexpected open() failure\");\n\n\treturn fd;\n}\n\nTEST_BEGIN(test_mdump_normal) {\n\ttest_skip_if(!config_prof);\n\n\tprof_dump_open_file_t *open_file_orig = prof_dump_open_file;\n\n\tvoid *p = mallocx(1, 0);\n\tassert_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\tdid_prof_dump_open = false;\n\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, (void *)&test_filename,\n\t sizeof(test_filename)), 0,\n\t \"Unexpected mallctl failure while dumping\");\n\texpect_true(did_prof_dump_open, \"Expected a profile dump\");\n\n\tdallocx(p, 0);\n\n\tprof_dump_open_file = open_file_orig;\n}\nTEST_END\n\nstatic int\nprof_dump_open_file_error(const char *filename, int mode) {\n\treturn -1;\n}\n\n/*\n * In the context of test_mdump_output_error, prof_dump_write_file_count is the\n * total number of times prof_dump_write_file_error() is expected to be called.\n * In the context of test_mdump_maps_error, prof_dump_write_file_count is the\n * total number of times prof_dump_write_file_error() is expected to be called\n * starting from the one that contains an 'M' (beginning the \"MAPPED_LIBRARIES\"\n * header).\n */\nstatic int prof_dump_write_file_count;\n\nstatic ssize_t\nprof_dump_write_file_error(int fd, const void *s, size_t len) {\n\t--prof_dump_write_file_count;\n\n\texpect_d_ge(prof_dump_write_file_count, 0,\n\t \"Write is called after error occurs\");\n\n\tif (prof_dump_write_file_count == 0) {\n\t\treturn -1;\n\t} else {\n\t\t/*\n\t\t * Any non-negative number indicates success, and for\n\t\t * simplicity we just use 0. When prof_dump_write_file_count\n\t\t * is positive, it means that we haven't reached the write that\n\t\t * we want to fail; when prof_dump_write_file_count is\n\t\t * negative, it means that we've already violated the\n\t\t * expect_d_ge(prof_dump_write_file_count, 0) statement above,\n\t\t * but instead of aborting, we continue the rest of the test,\n\t\t * and we indicate that all the writes after the failed write\n\t\t * are successful.\n\t\t */\n\t\treturn 0;\n\t}\n}\n\nstatic void\nexpect_write_failure(int count) {\n\tprof_dump_write_file_count = count;\n\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, (void *)&test_filename,\n\t sizeof(test_filename)), EFAULT, \"Dump should err\");\n\texpect_d_eq(prof_dump_write_file_count, 0,\n\t \"Dumping stopped after a wrong number of writes\");\n}\n\nTEST_BEGIN(test_mdump_output_error) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_debug);\n\n\tprof_dump_open_file_t *open_file_orig = prof_dump_open_file;\n\tprof_dump_write_file_t *write_file_orig = prof_dump_write_file;\n\n\tprof_dump_write_file = prof_dump_write_file_error;\n\n\tvoid *p = mallocx(1, 0);\n\tassert_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\t/*\n\t * When opening the dump file fails, there shouldn't be any write, and\n\t * mallctl() should return failure.\n\t */\n\tprof_dump_open_file = prof_dump_open_file_error;\n\texpect_write_failure(0);\n\n\t/*\n\t * When the n-th write fails, there shouldn't be any more write, and\n\t * mallctl() should return failure.\n\t */\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\texpect_write_failure(1); /* First write fails. */\n\texpect_write_failure(2); /* Second write fails. */\n\n\tdallocx(p, 0);\n\n\tprof_dump_open_file = open_file_orig;\n\tprof_dump_write_file = write_file_orig;\n}\nTEST_END\n\nstatic int\nprof_dump_open_maps_error() {\n\treturn -1;\n}\n\nstatic bool started_piping_maps_file;\n\nstatic ssize_t\nprof_dump_write_maps_file_error(int fd, const void *s, size_t len) {\n\t/* The main dump doesn't contain any capital 'M'. */\n\tif (!started_piping_maps_file && strchr(s, 'M') != NULL) {\n\t\tstarted_piping_maps_file = true;\n\t}\n\n\tif (started_piping_maps_file) {\n\t\treturn prof_dump_write_file_error(fd, s, len);\n\t} else {\n\t\t/* Return success when we haven't started piping maps. */\n\t\treturn 0;\n\t}\n}\n\nstatic void\nexpect_maps_write_failure(int count) {\n\tint mfd = prof_dump_open_maps();\n\tif (mfd == -1) {\n\t\t/* No need to continue if we just can't find the maps file. */\n\t\treturn;\n\t}\n\tclose(mfd);\n\tstarted_piping_maps_file = false;\n\texpect_write_failure(count);\n\texpect_true(started_piping_maps_file, \"Should start piping maps\");\n}\n\nTEST_BEGIN(test_mdump_maps_error) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_debug);\n\n\tprof_dump_open_file_t *open_file_orig = prof_dump_open_file;\n\tprof_dump_write_file_t *write_file_orig = prof_dump_write_file;\n\tprof_dump_open_maps_t *open_maps_orig = prof_dump_open_maps;\n\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\tprof_dump_write_file = prof_dump_write_maps_file_error;\n\n\tvoid *p = mallocx(1, 0);\n\tassert_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\t/*\n\t * When opening the maps file fails, there shouldn't be any maps write,\n\t * and mallctl() should return success.\n\t */\n\tprof_dump_open_maps = prof_dump_open_maps_error;\n\tstarted_piping_maps_file = false;\n\tprof_dump_write_file_count = 0;\n\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, (void *)&test_filename,\n\t sizeof(test_filename)), 0,\n\t \"mallctl should not fail in case of maps file opening failure\");\n\texpect_false(started_piping_maps_file, \"Shouldn't start piping maps\");\n\texpect_d_eq(prof_dump_write_file_count, 0,\n\t \"Dumping stopped after a wrong number of writes\");\n\n\t/*\n\t * When the n-th maps write fails (given that we are able to find the\n\t * maps file), there shouldn't be any more maps write, and mallctl()\n\t * should return failure.\n\t */\n\tprof_dump_open_maps = open_maps_orig;\n\texpect_maps_write_failure(1); /* First write fails. */\n\texpect_maps_write_failure(2); /* Second write fails. */\n\n\tdallocx(p, 0);\n\n\tprof_dump_open_file = open_file_orig;\n\tprof_dump_write_file = write_file_orig;\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_mdump_normal,\n\t test_mdump_output_error,\n\t test_mdump_maps_error);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_mdump.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,lg_prof_sample:0\"\nfi\n\n" }, { "path": "deps/jemalloc/test/unit/prof_recent.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_recent.h\"\n\n/* As specified in the shell script */\n#define OPT_ALLOC_MAX 3\n\n/* Invariant before and after every test (when config_prof is on) */\nstatic void\nconfirm_prof_setup() {\n\t/* Options */\n\tassert_true(opt_prof, \"opt_prof not on\");\n\tassert_true(opt_prof_active, \"opt_prof_active not on\");\n\tassert_zd_eq(opt_prof_recent_alloc_max, OPT_ALLOC_MAX,\n\t \"opt_prof_recent_alloc_max not set correctly\");\n\n\t/* Dynamics */\n\tassert_true(prof_active_state, \"prof_active not on\");\n\tassert_zd_eq(prof_recent_alloc_max_ctl_read(), OPT_ALLOC_MAX,\n\t \"prof_recent_alloc_max not set correctly\");\n}\n\nTEST_BEGIN(test_confirm_setup) {\n\ttest_skip_if(!config_prof);\n\tconfirm_prof_setup();\n}\nTEST_END\n\nTEST_BEGIN(test_prof_recent_off) {\n\ttest_skip_if(config_prof);\n\n\tconst ssize_t past_ref = 0, future_ref = 0;\n\tconst size_t len_ref = sizeof(ssize_t);\n\n\tssize_t past = past_ref, future = future_ref;\n\tsize_t len = len_ref;\n\n#define ASSERT_SHOULD_FAIL(opt, a, b, c, d) do {\t\t\t\\\n\tassert_d_eq(mallctl(\"experimental.prof_recent.\" opt, a, b, c,\t\\\n\t d), ENOENT, \"Should return ENOENT when config_prof is off\");\\\n\tassert_zd_eq(past, past_ref, \"output was touched\");\t\t\\\n\tassert_zu_eq(len, len_ref, \"output length was touched\");\t\\\n\tassert_zd_eq(future, future_ref, \"input was touched\");\t\t\\\n} while (0)\n\n\tASSERT_SHOULD_FAIL(\"alloc_max\", NULL, NULL, NULL, 0);\n\tASSERT_SHOULD_FAIL(\"alloc_max\", &past, &len, NULL, 0);\n\tASSERT_SHOULD_FAIL(\"alloc_max\", NULL, NULL, &future, len);\n\tASSERT_SHOULD_FAIL(\"alloc_max\", &past, &len, &future, len);\n\n#undef ASSERT_SHOULD_FAIL\n}\nTEST_END\n\nTEST_BEGIN(test_prof_recent_on) {\n\ttest_skip_if(!config_prof);\n\n\tssize_t past, future;\n\tsize_t len = sizeof(ssize_t);\n\n\tconfirm_prof_setup();\n\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, NULL, 0), 0, \"no-op mallctl should be allowed\");\n\tconfirm_prof_setup();\n\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t &past, &len, NULL, 0), 0, \"Read error\");\n\texpect_zd_eq(past, OPT_ALLOC_MAX, \"Wrong read result\");\n\tfuture = OPT_ALLOC_MAX + 1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, len), 0, \"Write error\");\n\tfuture = -1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t &past, &len, &future, len), 0, \"Read/write error\");\n\texpect_zd_eq(past, OPT_ALLOC_MAX + 1, \"Wrong read result\");\n\tfuture = -2;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t &past, &len, &future, len), EINVAL,\n\t \"Invalid write should return EINVAL\");\n\texpect_zd_eq(past, OPT_ALLOC_MAX + 1,\n\t \"Output should not be touched given invalid write\");\n\tfuture = OPT_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t &past, &len, &future, len), 0, \"Read/write error\");\n\texpect_zd_eq(past, -1, \"Wrong read result\");\n\tfuture = OPT_ALLOC_MAX + 2;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t &past, &len, &future, len * 2), EINVAL,\n\t \"Invalid write should return EINVAL\");\n\texpect_zd_eq(past, -1,\n\t \"Output should not be touched given invalid write\");\n\n\tconfirm_prof_setup();\n}\nTEST_END\n\n/* Reproducible sequence of request sizes */\n#define NTH_REQ_SIZE(n) ((n) * 97 + 101)\n\nstatic void\nconfirm_malloc(void *p) {\n\tassert_ptr_not_null(p, \"malloc failed unexpectedly\");\n\tedata_t *e = emap_edata_lookup(TSDN_NULL, &arena_emap_global, p);\n\tassert_ptr_not_null(e, \"NULL edata for living pointer\");\n\tprof_recent_t *n = edata_prof_recent_alloc_get_no_lock_test(e);\n\tassert_ptr_not_null(n, \"Record in edata should not be NULL\");\n\texpect_ptr_not_null(n->alloc_tctx,\n\t \"alloc_tctx in record should not be NULL\");\n\texpect_ptr_eq(e, prof_recent_alloc_edata_get_no_lock_test(n),\n\t \"edata pointer in record is not correct\");\n\texpect_ptr_null(n->dalloc_tctx, \"dalloc_tctx in record should be NULL\");\n}\n\nstatic void\nconfirm_record_size(prof_recent_t *n, unsigned kth) {\n\texpect_zu_eq(n->size, NTH_REQ_SIZE(kth),\n\t \"Recorded allocation size is wrong\");\n}\n\nstatic void\nconfirm_record_living(prof_recent_t *n) {\n\texpect_ptr_not_null(n->alloc_tctx,\n\t \"alloc_tctx in record should not be NULL\");\n\tedata_t *edata = prof_recent_alloc_edata_get_no_lock_test(n);\n\tassert_ptr_not_null(edata,\n\t \"Recorded edata should not be NULL for living pointer\");\n\texpect_ptr_eq(n, edata_prof_recent_alloc_get_no_lock_test(edata),\n\t \"Record in edata is not correct\");\n\texpect_ptr_null(n->dalloc_tctx, \"dalloc_tctx in record should be NULL\");\n}\n\nstatic void\nconfirm_record_released(prof_recent_t *n) {\n\texpect_ptr_not_null(n->alloc_tctx,\n\t \"alloc_tctx in record should not be NULL\");\n\texpect_ptr_null(prof_recent_alloc_edata_get_no_lock_test(n),\n\t \"Recorded edata should be NULL for released pointer\");\n\texpect_ptr_not_null(n->dalloc_tctx,\n\t \"dalloc_tctx in record should not be NULL for released pointer\");\n}\n\nTEST_BEGIN(test_prof_recent_alloc) {\n\ttest_skip_if(!config_prof);\n\n\tbool b;\n\tunsigned i, c;\n\tsize_t req_size;\n\tvoid *p;\n\tprof_recent_t *n;\n\tssize_t future;\n\n\tconfirm_prof_setup();\n\n\t/*\n\t * First batch of 2 * OPT_ALLOC_MAX allocations. After the\n\t * (OPT_ALLOC_MAX - 1)'th allocation the recorded allocations should\n\t * always be the last OPT_ALLOC_MAX allocations coming from here.\n\t */\n\tfor (i = 0; i < 2 * OPT_ALLOC_MAX; ++i) {\n\t\treq_size = NTH_REQ_SIZE(i);\n\t\tp = malloc(req_size);\n\t\tconfirm_malloc(p);\n\t\tif (i < OPT_ALLOC_MAX - 1) {\n\t\t\tassert_false(ql_empty(&prof_recent_alloc_list),\n\t\t\t \"Empty recent allocation\");\n\t\t\tfree(p);\n\t\t\t/*\n\t\t\t * The recorded allocations may still include some\n\t\t\t * other allocations before the test run started,\n\t\t\t * so keep allocating without checking anything.\n\t\t\t */\n\t\t\tcontinue;\n\t\t}\n\t\tc = 0;\n\t\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t\t++c;\n\t\t\tconfirm_record_size(n, i + c - OPT_ALLOC_MAX);\n\t\t\tif (c == OPT_ALLOC_MAX) {\n\t\t\t\tconfirm_record_living(n);\n\t\t\t} else {\n\t\t\t\tconfirm_record_released(n);\n\t\t\t}\n\t\t}\n\t\tassert_u_eq(c, OPT_ALLOC_MAX,\n\t\t \"Incorrect total number of allocations\");\n\t\tfree(p);\n\t}\n\n\tconfirm_prof_setup();\n\n\tb = false;\n\tassert_d_eq(mallctl(\"prof.active\", NULL, NULL, &b, sizeof(bool)), 0,\n\t \"mallctl for turning off prof_active failed\");\n\n\t/*\n\t * Second batch of OPT_ALLOC_MAX allocations. Since prof_active is\n\t * turned off, this batch shouldn't be recorded.\n\t */\n\tfor (; i < 3 * OPT_ALLOC_MAX; ++i) {\n\t\treq_size = NTH_REQ_SIZE(i);\n\t\tp = malloc(req_size);\n\t\tassert_ptr_not_null(p, \"malloc failed unexpectedly\");\n\t\tc = 0;\n\t\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t\tconfirm_record_size(n, c + OPT_ALLOC_MAX);\n\t\t\tconfirm_record_released(n);\n\t\t\t++c;\n\t\t}\n\t\tassert_u_eq(c, OPT_ALLOC_MAX,\n\t\t \"Incorrect total number of allocations\");\n\t\tfree(p);\n\t}\n\n\tb = true;\n\tassert_d_eq(mallctl(\"prof.active\", NULL, NULL, &b, sizeof(bool)), 0,\n\t \"mallctl for turning on prof_active failed\");\n\n\tconfirm_prof_setup();\n\n\t/*\n\t * Third batch of OPT_ALLOC_MAX allocations. Since prof_active is\n\t * turned back on, they should be recorded, and in the list of recorded\n\t * allocations they should follow the first batch rather than the\n\t * second batch.\n\t */\n\tfor (; i < 4 * OPT_ALLOC_MAX; ++i) {\n\t\treq_size = NTH_REQ_SIZE(i);\n\t\tp = malloc(req_size);\n\t\tconfirm_malloc(p);\n\t\tc = 0;\n\t\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t\t++c;\n\t\t\tconfirm_record_size(n,\n\t\t\t /* Is the allocation from the third batch? */\n\t\t\t i + c - OPT_ALLOC_MAX >= 3 * OPT_ALLOC_MAX ?\n\t\t\t /* If yes, then it's just recorded. */\n\t\t\t i + c - OPT_ALLOC_MAX :\n\t\t\t /*\n\t\t\t * Otherwise, it should come from the first batch\n\t\t\t * instead of the second batch.\n\t\t\t */\n\t\t\t i + c - 2 * OPT_ALLOC_MAX);\n\t\t\tif (c == OPT_ALLOC_MAX) {\n\t\t\t\tconfirm_record_living(n);\n\t\t\t} else {\n\t\t\t\tconfirm_record_released(n);\n\t\t\t}\n\t\t}\n\t\tassert_u_eq(c, OPT_ALLOC_MAX,\n\t\t \"Incorrect total number of allocations\");\n\t\tfree(p);\n\t}\n\n\t/* Increasing the limit shouldn't alter the list of records. */\n\tfuture = OPT_ALLOC_MAX + 1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tc = 0;\n\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\tconfirm_record_size(n, c + 3 * OPT_ALLOC_MAX);\n\t\tconfirm_record_released(n);\n\t\t++c;\n\t}\n\tassert_u_eq(c, OPT_ALLOC_MAX,\n\t \"Incorrect total number of allocations\");\n\n\t/*\n\t * Decreasing the limit shouldn't alter the list of records as long as\n\t * the new limit is still no less than the length of the list.\n\t */\n\tfuture = OPT_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tc = 0;\n\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\tconfirm_record_size(n, c + 3 * OPT_ALLOC_MAX);\n\t\tconfirm_record_released(n);\n\t\t++c;\n\t}\n\tassert_u_eq(c, OPT_ALLOC_MAX,\n\t \"Incorrect total number of allocations\");\n\n\t/*\n\t * Decreasing the limit should shorten the list of records if the new\n\t * limit is less than the length of the list.\n\t */\n\tfuture = OPT_ALLOC_MAX - 1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tc = 0;\n\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t++c;\n\t\tconfirm_record_size(n, c + 3 * OPT_ALLOC_MAX);\n\t\tconfirm_record_released(n);\n\t}\n\tassert_u_eq(c, OPT_ALLOC_MAX - 1,\n\t \"Incorrect total number of allocations\");\n\n\t/* Setting to unlimited shouldn't alter the list of records. */\n\tfuture = -1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tc = 0;\n\tql_foreach(n, &prof_recent_alloc_list, link) {\n\t\t++c;\n\t\tconfirm_record_size(n, c + 3 * OPT_ALLOC_MAX);\n\t\tconfirm_record_released(n);\n\t}\n\tassert_u_eq(c, OPT_ALLOC_MAX - 1,\n\t \"Incorrect total number of allocations\");\n\n\t/* Downshift to only one record. */\n\tfuture = 1;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tassert_false(ql_empty(&prof_recent_alloc_list), \"Recent list is empty\");\n\tn = ql_first(&prof_recent_alloc_list);\n\tconfirm_record_size(n, 4 * OPT_ALLOC_MAX - 1);\n\tconfirm_record_released(n);\n\tn = ql_next(&prof_recent_alloc_list, n, link);\n\tassert_ptr_null(n, \"Recent list should only contain one record\");\n\n\t/* Completely turn off. */\n\tfuture = 0;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tassert_true(ql_empty(&prof_recent_alloc_list),\n\t \"Recent list should be empty\");\n\n\t/* Restore the settings. */\n\tfuture = OPT_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tassert_true(ql_empty(&prof_recent_alloc_list),\n\t \"Recent list should be empty\");\n\n\tconfirm_prof_setup();\n}\nTEST_END\n\n#undef NTH_REQ_SIZE\n\n#define DUMP_OUT_SIZE 4096\nstatic char dump_out[DUMP_OUT_SIZE];\nstatic size_t dump_out_len = 0;\n\nstatic void\ntest_dump_write_cb(void *not_used, const char *str) {\n\tsize_t len = strlen(str);\n\tassert(dump_out_len + len < DUMP_OUT_SIZE);\n\tmemcpy(dump_out + dump_out_len, str, len + 1);\n\tdump_out_len += len;\n}\n\nstatic void\ncall_dump() {\n\tstatic void *in[2] = {test_dump_write_cb, NULL};\n\tdump_out_len = 0;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_dump\",\n\t NULL, NULL, in, sizeof(in)), 0, \"Dump mallctl raised error\");\n}\n\ntypedef struct {\n\tsize_t size;\n\tsize_t usize;\n\tbool released;\n} confirm_record_t;\n\n#define DUMP_ERROR \"Dump output is wrong\"\n\nstatic void\nconfirm_record(const char *template, const confirm_record_t *records,\n const size_t n_records) {\n\tstatic const char *types[2] = {\"alloc\", \"dalloc\"};\n\tstatic char buf[64];\n\n\t/*\n\t * The template string would be in the form of:\n\t * \"{...,\\\"recent_alloc\\\":[]}\",\n\t * and dump_out would be in the form of:\n\t * \"{...,\\\"recent_alloc\\\":[...]}\".\n\t * Using \"- 2\" serves to cut right before the ending \"]}\".\n\t */\n\tassert_d_eq(memcmp(dump_out, template, strlen(template) - 2), 0,\n\t DUMP_ERROR);\n\tassert_d_eq(memcmp(dump_out + strlen(dump_out) - 2,\n\t template + strlen(template) - 2, 2), 0, DUMP_ERROR);\n\n\tconst char *start = dump_out + strlen(template) - 2;\n\tconst char *end = dump_out + strlen(dump_out) - 2;\n\tconst confirm_record_t *record;\n\tfor (record = records; record < records + n_records; ++record) {\n\n#define ASSERT_CHAR(c) do {\t\t\t\t\t\t\\\n\tassert_true(start < end, DUMP_ERROR);\t\t\t\t\\\n\tassert_c_eq(*start++, c, DUMP_ERROR);\t\t\t\t\\\n} while (0)\n\n#define ASSERT_STR(s) do {\t\t\t\t\t\t\\\n\tconst size_t len = strlen(s);\t\t\t\t\t\\\n\tassert_true(start + len <= end, DUMP_ERROR);\t\t\t\\\n\tassert_d_eq(memcmp(start, s, len), 0, DUMP_ERROR);\t\t\\\n\tstart += len;\t\t\t\t\t\t\t\\\n} while (0)\n\n#define ASSERT_FORMATTED_STR(s, ...) do {\t\t\t\t\\\n\tmalloc_snprintf(buf, sizeof(buf), s, __VA_ARGS__);\t\t\\\n\tASSERT_STR(buf);\t\t\t\t\t\t\\\n} while (0)\n\n\t\tif (record != records) {\n\t\t\tASSERT_CHAR(',');\n\t\t}\n\n\t\tASSERT_CHAR('{');\n\n\t\tASSERT_STR(\"\\\"size\\\"\");\n\t\tASSERT_CHAR(':');\n\t\tASSERT_FORMATTED_STR(\"%zu\", record->size);\n\t\tASSERT_CHAR(',');\n\n\t\tASSERT_STR(\"\\\"usize\\\"\");\n\t\tASSERT_CHAR(':');\n\t\tASSERT_FORMATTED_STR(\"%zu\", record->usize);\n\t\tASSERT_CHAR(',');\n\n\t\tASSERT_STR(\"\\\"released\\\"\");\n\t\tASSERT_CHAR(':');\n\t\tASSERT_STR(record->released ? \"true\" : \"false\");\n\t\tASSERT_CHAR(',');\n\n\t\tconst char **type = types;\n\t\twhile (true) {\n\t\t\tASSERT_FORMATTED_STR(\"\\\"%s_thread_uid\\\"\", *type);\n\t\t\tASSERT_CHAR(':');\n\t\t\twhile (isdigit(*start)) {\n\t\t\t\t++start;\n\t\t\t}\n\t\t\tASSERT_CHAR(',');\n\n\t\t\tif (opt_prof_sys_thread_name) {\n\t\t\t\tASSERT_FORMATTED_STR(\"\\\"%s_thread_name\\\"\",\n\t\t\t\t *type);\n\t\t\t\tASSERT_CHAR(':');\n\t\t\t\tASSERT_CHAR('\"');\n\t\t\t\twhile (*start != '\"') {\n\t\t\t\t\t++start;\n\t\t\t\t}\n\t\t\t\tASSERT_CHAR('\"');\n\t\t\t\tASSERT_CHAR(',');\n\t\t\t}\n\n\t\t\tASSERT_FORMATTED_STR(\"\\\"%s_time\\\"\", *type);\n\t\t\tASSERT_CHAR(':');\n\t\t\twhile (isdigit(*start)) {\n\t\t\t\t++start;\n\t\t\t}\n\t\t\tASSERT_CHAR(',');\n\n\t\t\tASSERT_FORMATTED_STR(\"\\\"%s_trace\\\"\", *type);\n\t\t\tASSERT_CHAR(':');\n\t\t\tASSERT_CHAR('[');\n\t\t\twhile (isdigit(*start) || *start == 'x' ||\n\t\t\t (*start >= 'a' && *start <= 'f') ||\n\t\t\t *start == '\\\"' || *start == ',') {\n\t\t\t\t++start;\n\t\t\t}\n\t\t\tASSERT_CHAR(']');\n\n\t\t\tif (strcmp(*type, \"dalloc\") == 0) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tassert(strcmp(*type, \"alloc\") == 0);\n\t\t\tif (!record->released) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tASSERT_CHAR(',');\n\t\t\t++type;\n\t\t}\n\n\t\tASSERT_CHAR('}');\n\n#undef ASSERT_FORMATTED_STR\n#undef ASSERT_STR\n#undef ASSERT_CHAR\n\n\t}\n\tassert_ptr_eq(record, records + n_records, DUMP_ERROR);\n\tassert_ptr_eq(start, end, DUMP_ERROR);\n}\n\nTEST_BEGIN(test_prof_recent_alloc_dump) {\n\ttest_skip_if(!config_prof);\n\n\tconfirm_prof_setup();\n\n\tssize_t future;\n\tvoid *p, *q;\n\tconfirm_record_t records[2];\n\n\tassert_zu_eq(lg_prof_sample, (size_t)0,\n\t \"lg_prof_sample not set correctly\");\n\n\tfuture = 0;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tcall_dump();\n\texpect_str_eq(dump_out, \"{\\\"sample_interval\\\":1,\"\n\t \"\\\"recent_alloc_max\\\":0,\\\"recent_alloc\\\":[]}\", DUMP_ERROR);\n\n\tfuture = 2;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tcall_dump();\n\tconst char *template = \"{\\\"sample_interval\\\":1,\"\n\t \"\\\"recent_alloc_max\\\":2,\\\"recent_alloc\\\":[]}\";\n\texpect_str_eq(dump_out, template, DUMP_ERROR);\n\n\tp = malloc(7);\n\tcall_dump();\n\trecords[0].size = 7;\n\trecords[0].usize = sz_s2u(7);\n\trecords[0].released = false;\n\tconfirm_record(template, records, 1);\n\n\tq = mallocx(17, MALLOCX_ALIGN(128));\n\tcall_dump();\n\trecords[1].size = 17;\n\trecords[1].usize = sz_sa2u(17, 128);\n\trecords[1].released = false;\n\tconfirm_record(template, records, 2);\n\n\tfree(q);\n\tcall_dump();\n\trecords[1].released = true;\n\tconfirm_record(template, records, 2);\n\n\tfree(p);\n\tcall_dump();\n\trecords[0].released = true;\n\tconfirm_record(template, records, 2);\n\n\tfuture = OPT_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &future, sizeof(ssize_t)), 0, \"Write error\");\n\tconfirm_prof_setup();\n}\nTEST_END\n\n#undef DUMP_ERROR\n#undef DUMP_OUT_SIZE\n\n#define N_THREADS 8\n#define N_PTRS 512\n#define N_CTLS 8\n#define N_ITERS 2048\n#define STRESS_ALLOC_MAX 4096\n\ntypedef struct {\n\tthd_t thd;\n\tsize_t id;\n\tvoid *ptrs[N_PTRS];\n\tsize_t count;\n} thd_data_t;\n\nstatic thd_data_t thd_data[N_THREADS];\nstatic ssize_t test_max;\n\nstatic void\ntest_write_cb(void *cbopaque, const char *str) {\n\tsleep_ns(1000 * 1000);\n}\n\nstatic void *\nf_thread(void *arg) {\n\tconst size_t thd_id = *(size_t *)arg;\n\tthd_data_t *data_p = thd_data + thd_id;\n\tassert(data_p->id == thd_id);\n\tdata_p->count = 0;\n\tuint64_t rand = (uint64_t)thd_id;\n\ttsd_t *tsd = tsd_fetch();\n\tassert(test_max > 1);\n\tssize_t last_max = -1;\n\tfor (int i = 0; i < N_ITERS; i++) {\n\t\trand = prng_range_u64(&rand, N_PTRS + N_CTLS * 5);\n\t\tassert(data_p->count <= N_PTRS);\n\t\tif (rand < data_p->count) {\n\t\t\tassert(data_p->count > 0);\n\t\t\tif (rand != data_p->count - 1) {\n\t\t\t\tassert(data_p->count > 1);\n\t\t\t\tvoid *temp = data_p->ptrs[rand];\n\t\t\t\tdata_p->ptrs[rand] =\n\t\t\t\t data_p->ptrs[data_p->count - 1];\n\t\t\t\tdata_p->ptrs[data_p->count - 1] = temp;\n\t\t\t}\n\t\t\tfree(data_p->ptrs[--data_p->count]);\n\t\t} else if (rand < N_PTRS) {\n\t\t\tassert(data_p->count < N_PTRS);\n\t\t\tdata_p->ptrs[data_p->count++] = malloc(1);\n\t\t} else if (rand % 5 == 0) {\n\t\t\tprof_recent_alloc_dump(tsd, test_write_cb, NULL);\n\t\t} else if (rand % 5 == 1) {\n\t\t\tlast_max = prof_recent_alloc_max_ctl_read();\n\t\t} else if (rand % 5 == 2) {\n\t\t\tlast_max =\n\t\t\t prof_recent_alloc_max_ctl_write(tsd, test_max * 2);\n\t\t} else if (rand % 5 == 3) {\n\t\t\tlast_max =\n\t\t\t prof_recent_alloc_max_ctl_write(tsd, test_max);\n\t\t} else {\n\t\t\tassert(rand % 5 == 4);\n\t\t\tlast_max =\n\t\t\t prof_recent_alloc_max_ctl_write(tsd, test_max / 2);\n\t\t}\n\t\tassert_zd_ge(last_max, -1, \"Illegal last-N max\");\n\t}\n\n\twhile (data_p->count > 0) {\n\t\tfree(data_p->ptrs[--data_p->count]);\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_prof_recent_stress) {\n\ttest_skip_if(!config_prof);\n\n\tconfirm_prof_setup();\n\n\ttest_max = OPT_ALLOC_MAX;\n\tfor (size_t i = 0; i < N_THREADS; i++) {\n\t\tthd_data_t *data_p = thd_data + i;\n\t\tdata_p->id = i;\n\t\tthd_create(&data_p->thd, &f_thread, &data_p->id);\n\t}\n\tfor (size_t i = 0; i < N_THREADS; i++) {\n\t\tthd_data_t *data_p = thd_data + i;\n\t\tthd_join(data_p->thd, NULL);\n\t}\n\n\ttest_max = STRESS_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &test_max, sizeof(ssize_t)), 0, \"Write error\");\n\tfor (size_t i = 0; i < N_THREADS; i++) {\n\t\tthd_data_t *data_p = thd_data + i;\n\t\tdata_p->id = i;\n\t\tthd_create(&data_p->thd, &f_thread, &data_p->id);\n\t}\n\tfor (size_t i = 0; i < N_THREADS; i++) {\n\t\tthd_data_t *data_p = thd_data + i;\n\t\tthd_join(data_p->thd, NULL);\n\t}\n\n\ttest_max = OPT_ALLOC_MAX;\n\tassert_d_eq(mallctl(\"experimental.prof_recent.alloc_max\",\n\t NULL, NULL, &test_max, sizeof(ssize_t)), 0, \"Write error\");\n\tconfirm_prof_setup();\n}\nTEST_END\n\n#undef STRESS_ALLOC_MAX\n#undef N_ITERS\n#undef N_PTRS\n#undef N_THREADS\n\nint\nmain(void) {\n\treturn test(\n\t test_confirm_setup,\n\t test_prof_recent_off,\n\t test_prof_recent_on,\n\t test_prof_recent_alloc,\n\t test_prof_recent_alloc_dump,\n\t test_prof_recent_stress);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_recent.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0,prof_recent_alloc_max:3\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_reset.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_data.h\"\n#include \"jemalloc/internal/prof_sys.h\"\n\nstatic int\nprof_dump_open_file_intercept(const char *filename, int mode) {\n\tint fd;\n\n\tfd = open(\"/dev/null\", O_WRONLY);\n\tassert_d_ne(fd, -1, \"Unexpected open() failure\");\n\n\treturn fd;\n}\n\nstatic void\nset_prof_active(bool active) {\n\texpect_d_eq(mallctl(\"prof.active\", NULL, NULL, (void *)&active,\n\t sizeof(active)), 0, \"Unexpected mallctl failure\");\n}\n\nstatic size_t\nget_lg_prof_sample(void) {\n\tsize_t ret;\n\tsize_t sz = sizeof(size_t);\n\n\texpect_d_eq(mallctl(\"prof.lg_sample\", (void *)&ret, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure while reading profiling sample rate\");\n\treturn ret;\n}\n\nstatic void\ndo_prof_reset(size_t lg_prof_sample_input) {\n\texpect_d_eq(mallctl(\"prof.reset\", NULL, NULL,\n\t (void *)&lg_prof_sample_input, sizeof(size_t)), 0,\n\t \"Unexpected mallctl failure while resetting profile data\");\n\texpect_zu_eq(lg_prof_sample_input, get_lg_prof_sample(),\n\t \"Expected profile sample rate change\");\n}\n\nTEST_BEGIN(test_prof_reset_basic) {\n\tsize_t lg_prof_sample_orig, lg_prof_sample_cur, lg_prof_sample_next;\n\tsize_t sz;\n\tunsigned i;\n\n\ttest_skip_if(!config_prof);\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"opt.lg_prof_sample\", (void *)&lg_prof_sample_orig,\n\t &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure while reading profiling sample rate\");\n\texpect_zu_eq(lg_prof_sample_orig, 0,\n\t \"Unexpected profiling sample rate\");\n\tlg_prof_sample_cur = get_lg_prof_sample();\n\texpect_zu_eq(lg_prof_sample_orig, lg_prof_sample_cur,\n\t \"Unexpected disagreement between \\\"opt.lg_prof_sample\\\" and \"\n\t \"\\\"prof.lg_sample\\\"\");\n\n\t/* Test simple resets. */\n\tfor (i = 0; i < 2; i++) {\n\t\texpect_d_eq(mallctl(\"prof.reset\", NULL, NULL, NULL, 0), 0,\n\t\t \"Unexpected mallctl failure while resetting profile data\");\n\t\tlg_prof_sample_cur = get_lg_prof_sample();\n\t\texpect_zu_eq(lg_prof_sample_orig, lg_prof_sample_cur,\n\t\t \"Unexpected profile sample rate change\");\n\t}\n\n\t/* Test resets with prof.lg_sample changes. */\n\tlg_prof_sample_next = 1;\n\tfor (i = 0; i < 2; i++) {\n\t\tdo_prof_reset(lg_prof_sample_next);\n\t\tlg_prof_sample_cur = get_lg_prof_sample();\n\t\texpect_zu_eq(lg_prof_sample_cur, lg_prof_sample_next,\n\t\t \"Expected profile sample rate change\");\n\t\tlg_prof_sample_next = lg_prof_sample_orig;\n\t}\n\n\t/* Make sure the test code restored prof.lg_sample. */\n\tlg_prof_sample_cur = get_lg_prof_sample();\n\texpect_zu_eq(lg_prof_sample_orig, lg_prof_sample_cur,\n\t \"Unexpected disagreement between \\\"opt.lg_prof_sample\\\" and \"\n\t \"\\\"prof.lg_sample\\\"\");\n}\nTEST_END\n\nTEST_BEGIN(test_prof_reset_cleanup) {\n\ttest_skip_if(!config_prof);\n\n\tset_prof_active(true);\n\n\texpect_zu_eq(prof_bt_count(), 0, \"Expected 0 backtraces\");\n\tvoid *p = mallocx(1, 0);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\texpect_zu_eq(prof_bt_count(), 1, \"Expected 1 backtrace\");\n\n\tprof_cnt_t cnt_all;\n\tprof_cnt_all(&cnt_all);\n\texpect_u64_eq(cnt_all.curobjs, 1, \"Expected 1 allocation\");\n\n\texpect_d_eq(mallctl(\"prof.reset\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected error while resetting heap profile data\");\n\tprof_cnt_all(&cnt_all);\n\texpect_u64_eq(cnt_all.curobjs, 0, \"Expected 0 allocations\");\n\texpect_zu_eq(prof_bt_count(), 1, \"Expected 1 backtrace\");\n\n\tdallocx(p, 0);\n\texpect_zu_eq(prof_bt_count(), 0, \"Expected 0 backtraces\");\n\n\tset_prof_active(false);\n}\nTEST_END\n\n#define NTHREADS\t\t4\n#define NALLOCS_PER_THREAD\t(1U << 13)\n#define OBJ_RING_BUF_COUNT\t1531\n#define RESET_INTERVAL\t\t(1U << 10)\n#define DUMP_INTERVAL\t\t3677\nstatic void *\nthd_start(void *varg) {\n\tunsigned thd_ind = *(unsigned *)varg;\n\tunsigned i;\n\tvoid *objs[OBJ_RING_BUF_COUNT];\n\n\tmemset(objs, 0, sizeof(objs));\n\n\tfor (i = 0; i < NALLOCS_PER_THREAD; i++) {\n\t\tif (i % RESET_INTERVAL == 0) {\n\t\t\texpect_d_eq(mallctl(\"prof.reset\", NULL, NULL, NULL, 0),\n\t\t\t 0, \"Unexpected error while resetting heap profile \"\n\t\t\t \"data\");\n\t\t}\n\n\t\tif (i % DUMP_INTERVAL == 0) {\n\t\t\texpect_d_eq(mallctl(\"prof.dump\", NULL, NULL, NULL, 0),\n\t\t\t 0, \"Unexpected error while dumping heap profile\");\n\t\t}\n\n\t\t{\n\t\t\tvoid **pp = &objs[i % OBJ_RING_BUF_COUNT];\n\t\t\tif (*pp != NULL) {\n\t\t\t\tdallocx(*pp, 0);\n\t\t\t\t*pp = NULL;\n\t\t\t}\n\t\t\t*pp = btalloc(1, thd_ind*NALLOCS_PER_THREAD + i);\n\t\t\texpect_ptr_not_null(*pp,\n\t\t\t \"Unexpected btalloc() failure\");\n\t\t}\n\t}\n\n\t/* Clean up any remaining objects. */\n\tfor (i = 0; i < OBJ_RING_BUF_COUNT; i++) {\n\t\tvoid **pp = &objs[i % OBJ_RING_BUF_COUNT];\n\t\tif (*pp != NULL) {\n\t\t\tdallocx(*pp, 0);\n\t\t\t*pp = NULL;\n\t\t}\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_prof_reset) {\n\tsize_t lg_prof_sample_orig;\n\tthd_t thds[NTHREADS];\n\tunsigned thd_args[NTHREADS];\n\tunsigned i;\n\tsize_t bt_count, tdata_count;\n\n\ttest_skip_if(!config_prof);\n\n\tbt_count = prof_bt_count();\n\texpect_zu_eq(bt_count, 0,\n\t \"Unexpected pre-existing tdata structures\");\n\ttdata_count = prof_tdata_count();\n\n\tlg_prof_sample_orig = get_lg_prof_sample();\n\tdo_prof_reset(5);\n\n\tset_prof_active(true);\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_args[i] = i;\n\t\tthd_create(&thds[i], thd_start, (void *)&thd_args[i]);\n\t}\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n\n\texpect_zu_eq(prof_bt_count(), bt_count,\n\t \"Unexpected bactrace count change\");\n\texpect_zu_eq(prof_tdata_count(), tdata_count,\n\t \"Unexpected remaining tdata structures\");\n\n\tset_prof_active(false);\n\n\tdo_prof_reset(lg_prof_sample_orig);\n}\nTEST_END\n#undef NTHREADS\n#undef NALLOCS_PER_THREAD\n#undef OBJ_RING_BUF_COUNT\n#undef RESET_INTERVAL\n#undef DUMP_INTERVAL\n\n/* Test sampling at the same allocation site across resets. */\n#define NITER 10\nTEST_BEGIN(test_xallocx) {\n\tsize_t lg_prof_sample_orig;\n\tunsigned i;\n\tvoid *ptrs[NITER];\n\n\ttest_skip_if(!config_prof);\n\n\tlg_prof_sample_orig = get_lg_prof_sample();\n\tset_prof_active(true);\n\n\t/* Reset profiling. */\n\tdo_prof_reset(0);\n\n\tfor (i = 0; i < NITER; i++) {\n\t\tvoid *p;\n\t\tsize_t sz, nsz;\n\n\t\t/* Reset profiling. */\n\t\tdo_prof_reset(0);\n\n\t\t/* Allocate small object (which will be promoted). */\n\t\tp = ptrs[i] = mallocx(1, 0);\n\t\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\t\t/* Reset profiling. */\n\t\tdo_prof_reset(0);\n\n\t\t/* Perform successful xallocx(). */\n\t\tsz = sallocx(p, 0);\n\t\texpect_zu_eq(xallocx(p, sz, 0, 0), sz,\n\t\t \"Unexpected xallocx() failure\");\n\n\t\t/* Perform unsuccessful xallocx(). */\n\t\tnsz = nallocx(sz+1, 0);\n\t\texpect_zu_eq(xallocx(p, nsz, 0, 0), sz,\n\t\t \"Unexpected xallocx() success\");\n\t}\n\n\tfor (i = 0; i < NITER; i++) {\n\t\t/* dallocx. */\n\t\tdallocx(ptrs[i], 0);\n\t}\n\n\tset_prof_active(false);\n\tdo_prof_reset(lg_prof_sample_orig);\n}\nTEST_END\n#undef NITER\n\nint\nmain(void) {\n\t/* Intercept dumping prior to running any tests. */\n\tprof_dump_open_file = prof_dump_open_file_intercept;\n\n\treturn test_no_reentrancy(\n\t test_prof_reset_basic,\n\t test_prof_reset_cleanup,\n\t test_prof_reset,\n\t test_xallocx);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_reset.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:false,lg_prof_sample:0,prof_recent_alloc_max:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_stats.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define N_PTRS 3\n\nstatic void\ntest_combinations(szind_t ind, size_t sizes_array[N_PTRS],\n int flags_array[N_PTRS]) {\n#define MALLCTL_STR_LEN 64\n\tassert(opt_prof && opt_prof_stats);\n\n\tchar mallctl_live_str[MALLCTL_STR_LEN];\n\tchar mallctl_accum_str[MALLCTL_STR_LEN];\n\tif (ind < SC_NBINS) {\n\t\tmalloc_snprintf(mallctl_live_str, MALLCTL_STR_LEN,\n\t\t \"prof.stats.bins.%u.live\", (unsigned)ind);\n\t\tmalloc_snprintf(mallctl_accum_str, MALLCTL_STR_LEN,\n\t\t \"prof.stats.bins.%u.accum\", (unsigned)ind);\n\t} else {\n\t\tmalloc_snprintf(mallctl_live_str, MALLCTL_STR_LEN,\n\t\t \"prof.stats.lextents.%u.live\", (unsigned)(ind - SC_NBINS));\n\t\tmalloc_snprintf(mallctl_accum_str, MALLCTL_STR_LEN,\n\t\t \"prof.stats.lextents.%u.accum\", (unsigned)(ind - SC_NBINS));\n\t}\n\n\tsize_t stats_len = 2 * sizeof(uint64_t);\n\n\tuint64_t live_stats_orig[2];\n\tassert_d_eq(mallctl(mallctl_live_str, &live_stats_orig, &stats_len,\n\t NULL, 0), 0, \"\");\n\tuint64_t accum_stats_orig[2];\n\tassert_d_eq(mallctl(mallctl_accum_str, &accum_stats_orig, &stats_len,\n\t NULL, 0), 0, \"\");\n\n\tvoid *ptrs[N_PTRS];\n\n\tuint64_t live_req_sum = 0;\n\tuint64_t live_count = 0;\n\tuint64_t accum_req_sum = 0;\n\tuint64_t accum_count = 0;\n\n\tfor (size_t i = 0; i < N_PTRS; ++i) {\n\t\tsize_t sz = sizes_array[i];\n\t\tint flags = flags_array[i];\n\t\tvoid *p = mallocx(sz, flags);\n\t\tassert_ptr_not_null(p, \"malloc() failed\");\n\t\tassert(TEST_MALLOC_SIZE(p) == sz_index2size(ind));\n\t\tptrs[i] = p;\n\t\tlive_req_sum += sz;\n\t\tlive_count++;\n\t\taccum_req_sum += sz;\n\t\taccum_count++;\n\t\tuint64_t live_stats[2];\n\t\tassert_d_eq(mallctl(mallctl_live_str, &live_stats, &stats_len,\n\t\t NULL, 0), 0, \"\");\n\t\texpect_u64_eq(live_stats[0] - live_stats_orig[0],\n\t\t live_req_sum, \"\");\n\t\texpect_u64_eq(live_stats[1] - live_stats_orig[1],\n\t\t live_count, \"\");\n\t\tuint64_t accum_stats[2];\n\t\tassert_d_eq(mallctl(mallctl_accum_str, &accum_stats, &stats_len,\n\t\t NULL, 0), 0, \"\");\n\t\texpect_u64_eq(accum_stats[0] - accum_stats_orig[0],\n\t\t accum_req_sum, \"\");\n\t\texpect_u64_eq(accum_stats[1] - accum_stats_orig[1],\n\t\t accum_count, \"\");\n\t}\n\n\tfor (size_t i = 0; i < N_PTRS; ++i) {\n\t\tsize_t sz = sizes_array[i];\n\t\tint flags = flags_array[i];\n\t\tsdallocx(ptrs[i], sz, flags);\n\t\tlive_req_sum -= sz;\n\t\tlive_count--;\n\t\tuint64_t live_stats[2];\n\t\tassert_d_eq(mallctl(mallctl_live_str, &live_stats, &stats_len,\n\t\t NULL, 0), 0, \"\");\n\t\texpect_u64_eq(live_stats[0] - live_stats_orig[0],\n\t\t live_req_sum, \"\");\n\t\texpect_u64_eq(live_stats[1] - live_stats_orig[1],\n\t\t live_count, \"\");\n\t\tuint64_t accum_stats[2];\n\t\tassert_d_eq(mallctl(mallctl_accum_str, &accum_stats, &stats_len,\n\t\t NULL, 0), 0, \"\");\n\t\texpect_u64_eq(accum_stats[0] - accum_stats_orig[0],\n\t\t accum_req_sum, \"\");\n\t\texpect_u64_eq(accum_stats[1] - accum_stats_orig[1],\n\t\t accum_count, \"\");\n\t}\n#undef MALLCTL_STR_LEN\n}\n\nstatic void\ntest_szind_wrapper(szind_t ind) {\n\tsize_t sizes_array[N_PTRS];\n\tint flags_array[N_PTRS];\n\tfor (size_t i = 0, sz = sz_index2size(ind) - N_PTRS; i < N_PTRS;\n\t ++i, ++sz) {\n\t\tsizes_array[i] = sz;\n\t\tflags_array[i] = 0;\n\t}\n\ttest_combinations(ind, sizes_array, flags_array);\n}\n\nTEST_BEGIN(test_prof_stats) {\n\ttest_skip_if(!config_prof);\n\ttest_szind_wrapper(0);\n\ttest_szind_wrapper(1);\n\ttest_szind_wrapper(2);\n\ttest_szind_wrapper(SC_NBINS);\n\ttest_szind_wrapper(SC_NBINS + 1);\n\ttest_szind_wrapper(SC_NBINS + 2);\n}\nTEST_END\n\nstatic void\ntest_szind_aligned_wrapper(szind_t ind, unsigned lg_align) {\n\tsize_t sizes_array[N_PTRS];\n\tint flags_array[N_PTRS];\n\tint flags = MALLOCX_LG_ALIGN(lg_align);\n\tfor (size_t i = 0, sz = sz_index2size(ind) - N_PTRS; i < N_PTRS;\n\t ++i, ++sz) {\n\t\tsizes_array[i] = sz;\n\t\tflags_array[i] = flags;\n\t}\n\ttest_combinations(\n\t sz_size2index(sz_sa2u(sz_index2size(ind), 1 << lg_align)),\n\t sizes_array, flags_array);\n}\n\nTEST_BEGIN(test_prof_stats_aligned) {\n\ttest_skip_if(!config_prof);\n\tfor (szind_t ind = 0; ind < 10; ++ind) {\n\t\tfor (unsigned lg_align = 0; lg_align < 10; ++lg_align) {\n\t\t\ttest_szind_aligned_wrapper(ind, lg_align);\n\t\t}\n\t}\n\tfor (szind_t ind = SC_NBINS - 5; ind < SC_NBINS + 5; ++ind) {\n\t\tfor (unsigned lg_align = SC_LG_LARGE_MINCLASS - 5;\n\t\t lg_align < SC_LG_LARGE_MINCLASS + 5; ++lg_align) {\n\t\t\ttest_szind_aligned_wrapper(ind, lg_align);\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_prof_stats,\n\t test_prof_stats_aligned);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_stats.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0,prof_stats:true\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_sys_thread_name.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_sys.h\"\n\nstatic const char *test_thread_name = \"test_name\";\n\nstatic int\ntest_prof_sys_thread_name_read_error(char *buf, size_t limit) {\n\treturn ENOSYS;\n}\n\nstatic int\ntest_prof_sys_thread_name_read(char *buf, size_t limit) {\n\tassert(strlen(test_thread_name) < limit);\n\tstrncpy(buf, test_thread_name, limit);\n\treturn 0;\n}\n\nstatic int\ntest_prof_sys_thread_name_read_clear(char *buf, size_t limit) {\n\tassert(limit > 0);\n\tbuf[0] = '\\0';\n\treturn 0;\n}\n\nTEST_BEGIN(test_prof_sys_thread_name) {\n\ttest_skip_if(!config_prof);\n\n\tbool oldval;\n\tsize_t sz = sizeof(oldval);\n\tassert_d_eq(mallctl(\"opt.prof_sys_thread_name\", &oldval, &sz, NULL, 0),\n\t 0, \"mallctl failed\");\n\tassert_true(oldval, \"option was not set correctly\");\n\n\tconst char *thread_name;\n\tsz = sizeof(thread_name);\n\tassert_d_eq(mallctl(\"thread.prof.name\", &thread_name, &sz, NULL, 0), 0,\n\t \"mallctl read for thread name should not fail\");\n\texpect_str_eq(thread_name, \"\", \"Initial thread name should be empty\");\n\n\tthread_name = test_thread_name;\n\tassert_d_eq(mallctl(\"thread.prof.name\", NULL, NULL, &thread_name, sz),\n\t ENOENT, \"mallctl write for thread name should fail\");\n\tassert_ptr_eq(thread_name, test_thread_name,\n\t \"Thread name should not be touched\");\n\n\tprof_sys_thread_name_read = test_prof_sys_thread_name_read_error;\n\tvoid *p = malloc(1);\n\tfree(p);\n\tassert_d_eq(mallctl(\"thread.prof.name\", &thread_name, &sz, NULL, 0), 0,\n\t \"mallctl read for thread name should not fail\");\n\tassert_str_eq(thread_name, \"\",\n\t \"Thread name should stay the same if the system call fails\");\n\n\tprof_sys_thread_name_read = test_prof_sys_thread_name_read;\n\tp = malloc(1);\n\tfree(p);\n\tassert_d_eq(mallctl(\"thread.prof.name\", &thread_name, &sz, NULL, 0), 0,\n\t \"mallctl read for thread name should not fail\");\n\tassert_str_eq(thread_name, test_thread_name,\n\t \"Thread name should be changed if the system call succeeds\");\n\n\tprof_sys_thread_name_read = test_prof_sys_thread_name_read_clear;\n\tp = malloc(1);\n\tfree(p);\n\tassert_d_eq(mallctl(\"thread.prof.name\", &thread_name, &sz, NULL, 0), 0,\n\t \"mallctl read for thread name should not fail\");\n\texpect_str_eq(thread_name, \"\", \"Thread name should be updated if the \"\n\t \"system call returns a different name\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_prof_sys_thread_name);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_sys_thread_name.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0,prof_sys_thread_name:true\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_tctx.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/prof_data.h\"\n\nTEST_BEGIN(test_prof_realloc) {\n\ttsd_t *tsd;\n\tint flags;\n\tvoid *p, *q;\n\tprof_info_t prof_info_p, prof_info_q;\n\tprof_cnt_t cnt_0, cnt_1, cnt_2, cnt_3;\n\n\ttest_skip_if(!config_prof);\n\n\ttsd = tsd_fetch();\n\tflags = MALLOCX_TCACHE_NONE;\n\n\tprof_cnt_all(&cnt_0);\n\tp = mallocx(1024, flags);\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\tprof_info_get(tsd, p, NULL, &prof_info_p);\n\texpect_ptr_ne(prof_info_p.alloc_tctx, (prof_tctx_t *)(uintptr_t)1U,\n\t \"Expected valid tctx\");\n\tprof_cnt_all(&cnt_1);\n\texpect_u64_eq(cnt_0.curobjs + 1, cnt_1.curobjs,\n\t \"Allocation should have increased sample size\");\n\n\tq = rallocx(p, 2048, flags);\n\texpect_ptr_ne(p, q, \"Expected move\");\n\texpect_ptr_not_null(p, \"Unexpected rmallocx() failure\");\n\tprof_info_get(tsd, q, NULL, &prof_info_q);\n\texpect_ptr_ne(prof_info_q.alloc_tctx, (prof_tctx_t *)(uintptr_t)1U,\n\t \"Expected valid tctx\");\n\tprof_cnt_all(&cnt_2);\n\texpect_u64_eq(cnt_1.curobjs, cnt_2.curobjs,\n\t \"Reallocation should not have changed sample size\");\n\n\tdallocx(q, flags);\n\tprof_cnt_all(&cnt_3);\n\texpect_u64_eq(cnt_0.curobjs, cnt_3.curobjs,\n\t \"Sample size should have returned to base level\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_prof_realloc);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_tctx.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/prof_thread_name.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic void\nmallctl_thread_name_get_impl(const char *thread_name_expected, const char *func,\n int line) {\n\tconst char *thread_name_old;\n\tsize_t sz;\n\n\tsz = sizeof(thread_name_old);\n\texpect_d_eq(mallctl(\"thread.prof.name\", (void *)&thread_name_old, &sz,\n\t NULL, 0), 0,\n\t \"%s():%d: Unexpected mallctl failure reading thread.prof.name\",\n\t func, line);\n\texpect_str_eq(thread_name_old, thread_name_expected,\n\t \"%s():%d: Unexpected thread.prof.name value\", func, line);\n}\n#define mallctl_thread_name_get(a)\t\t\t\t\t\\\n\tmallctl_thread_name_get_impl(a, __func__, __LINE__)\n\nstatic void\nmallctl_thread_name_set_impl(const char *thread_name, const char *func,\n int line) {\n\texpect_d_eq(mallctl(\"thread.prof.name\", NULL, NULL,\n\t (void *)&thread_name, sizeof(thread_name)), 0,\n\t \"%s():%d: Unexpected mallctl failure writing thread.prof.name\",\n\t func, line);\n\tmallctl_thread_name_get_impl(thread_name, func, line);\n}\n#define mallctl_thread_name_set(a)\t\t\t\t\t\\\n\tmallctl_thread_name_set_impl(a, __func__, __LINE__)\n\nTEST_BEGIN(test_prof_thread_name_validation) {\n\tconst char *thread_name;\n\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(opt_prof_sys_thread_name);\n\n\tmallctl_thread_name_get(\"\");\n\tmallctl_thread_name_set(\"hi there\");\n\n\t/* NULL input shouldn't be allowed. */\n\tthread_name = NULL;\n\texpect_d_eq(mallctl(\"thread.prof.name\", NULL, NULL,\n\t (void *)&thread_name, sizeof(thread_name)), EFAULT,\n\t \"Unexpected mallctl result writing \\\"%s\\\" to thread.prof.name\",\n\t thread_name);\n\n\t/* '\\n' shouldn't be allowed. */\n\tthread_name = \"hi\\nthere\";\n\texpect_d_eq(mallctl(\"thread.prof.name\", NULL, NULL,\n\t (void *)&thread_name, sizeof(thread_name)), EFAULT,\n\t \"Unexpected mallctl result writing \\\"%s\\\" to thread.prof.name\",\n\t thread_name);\n\n\t/* Simultaneous read/write shouldn't be allowed. */\n\t{\n\t\tconst char *thread_name_old;\n\t\tsize_t sz;\n\n\t\tsz = sizeof(thread_name_old);\n\t\texpect_d_eq(mallctl(\"thread.prof.name\",\n\t\t (void *)&thread_name_old, &sz, (void *)&thread_name,\n\t\t sizeof(thread_name)), EPERM,\n\t\t \"Unexpected mallctl result writing \\\"%s\\\" to \"\n\t\t \"thread.prof.name\", thread_name);\n\t}\n\n\tmallctl_thread_name_set(\"\");\n}\nTEST_END\n\n#define NTHREADS\t4\n#define NRESET\t\t25\nstatic void *\nthd_start(void *varg) {\n\tunsigned thd_ind = *(unsigned *)varg;\n\tchar thread_name[16] = \"\";\n\tunsigned i;\n\n\tmalloc_snprintf(thread_name, sizeof(thread_name), \"thread %u\", thd_ind);\n\n\tmallctl_thread_name_get(\"\");\n\tmallctl_thread_name_set(thread_name);\n\n\tfor (i = 0; i < NRESET; i++) {\n\t\texpect_d_eq(mallctl(\"prof.reset\", NULL, NULL, NULL, 0), 0,\n\t\t \"Unexpected error while resetting heap profile data\");\n\t\tmallctl_thread_name_get(thread_name);\n\t}\n\n\tmallctl_thread_name_set(thread_name);\n\tmallctl_thread_name_set(\"\");\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_prof_thread_name_threaded) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(opt_prof_sys_thread_name);\n\n\tthd_t thds[NTHREADS];\n\tunsigned thd_args[NTHREADS];\n\tunsigned i;\n\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_args[i] = i;\n\t\tthd_create(&thds[i], thd_start, (void *)&thd_args[i]);\n\t}\n\tfor (i = 0; i < NTHREADS; i++) {\n\t\tthd_join(thds[i], NULL);\n\t}\n}\nTEST_END\n#undef NTHREADS\n#undef NRESET\n\nint\nmain(void) {\n\treturn test(\n\t test_prof_thread_name_validation,\n\t test_prof_thread_name_threaded);\n}\n" }, { "path": "deps/jemalloc/test/unit/prof_thread_name.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:false\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/psset.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/psset.h\"\n\n#define PAGESLAB_ADDR ((void *)(1234 * HUGEPAGE))\n#define PAGESLAB_AGE 5678\n\n#define ALLOC_ARENA_IND 111\n#define ALLOC_ESN 222\n\nstatic void\nedata_init_test(edata_t *edata) {\n\tmemset(edata, 0, sizeof(*edata));\n\tedata_arena_ind_set(edata, ALLOC_ARENA_IND);\n\tedata_esn_set(edata, ALLOC_ESN);\n}\n\nstatic void\ntest_psset_fake_purge(hpdata_t *ps) {\n\thpdata_purge_state_t purge_state;\n\thpdata_alloc_allowed_set(ps, false);\n\thpdata_purge_begin(ps, &purge_state);\n\tvoid *addr;\n\tsize_t size;\n\twhile (hpdata_purge_next(ps, &purge_state, &addr, &size)) {\n\t}\n\thpdata_purge_end(ps, &purge_state);\n\thpdata_alloc_allowed_set(ps, true);\n}\n\nstatic void\ntest_psset_alloc_new(psset_t *psset, hpdata_t *ps, edata_t *r_edata,\n size_t size) {\n\thpdata_assert_empty(ps);\n\n\ttest_psset_fake_purge(ps);\n\n\tpsset_insert(psset, ps);\n\tpsset_update_begin(psset, ps);\n\n void *addr = hpdata_reserve_alloc(ps, size);\n edata_init(r_edata, edata_arena_ind_get(r_edata), addr, size,\n\t /* slab */ false, SC_NSIZES, /* sn */ 0, extent_state_active,\n /* zeroed */ false, /* committed */ true, EXTENT_PAI_HPA,\n EXTENT_NOT_HEAD);\n edata_ps_set(r_edata, ps);\n\tpsset_update_end(psset, ps);\n}\n\nstatic bool\ntest_psset_alloc_reuse(psset_t *psset, edata_t *r_edata, size_t size) {\n\thpdata_t *ps = psset_pick_alloc(psset, size);\n\tif (ps == NULL) {\n\t\treturn true;\n\t}\n\tpsset_update_begin(psset, ps);\n\tvoid *addr = hpdata_reserve_alloc(ps, size);\n\tedata_init(r_edata, edata_arena_ind_get(r_edata), addr, size,\n\t /* slab */ false, SC_NSIZES, /* sn */ 0, extent_state_active,\n\t /* zeroed */ false, /* committed */ true, EXTENT_PAI_HPA,\n\t EXTENT_NOT_HEAD);\n\tedata_ps_set(r_edata, ps);\n\tpsset_update_end(psset, ps);\n\treturn false;\n}\n\nstatic hpdata_t *\ntest_psset_dalloc(psset_t *psset, edata_t *edata) {\n\thpdata_t *ps = edata_ps_get(edata);\n\tpsset_update_begin(psset, ps);\n\thpdata_unreserve(ps, edata_addr_get(edata), edata_size_get(edata));\n\tpsset_update_end(psset, ps);\n\tif (hpdata_empty(ps)) {\n\t\tpsset_remove(psset, ps);\n\t\treturn ps;\n\t} else {\n\t\treturn NULL;\n\t}\n}\n\nstatic void\nedata_expect(edata_t *edata, size_t page_offset, size_t page_cnt) {\n\t/*\n\t * Note that allocations should get the arena ind of their home\n\t * arena, *not* the arena ind of the pageslab allocator.\n\t */\n\texpect_u_eq(ALLOC_ARENA_IND, edata_arena_ind_get(edata),\n\t \"Arena ind changed\");\n\texpect_ptr_eq(\n\t (void *)((uintptr_t)PAGESLAB_ADDR + (page_offset << LG_PAGE)),\n\t edata_addr_get(edata), \"Didn't allocate in order\");\n\texpect_zu_eq(page_cnt << LG_PAGE, edata_size_get(edata), \"\");\n\texpect_false(edata_slab_get(edata), \"\");\n\texpect_u_eq(SC_NSIZES, edata_szind_get_maybe_invalid(edata),\n\t \"\");\n\texpect_u64_eq(0, edata_sn_get(edata), \"\");\n\texpect_d_eq(edata_state_get(edata), extent_state_active, \"\");\n\texpect_false(edata_zeroed_get(edata), \"\");\n\texpect_true(edata_committed_get(edata), \"\");\n\texpect_d_eq(EXTENT_PAI_HPA, edata_pai_get(edata), \"\");\n\texpect_false(edata_is_head_get(edata), \"\");\n}\n\nTEST_BEGIN(test_empty) {\n\tbool err;\n\thpdata_t pageslab;\n\thpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);\n\n\tedata_t alloc;\n\tedata_init_test(&alloc);\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\t/* Empty psset should return fail allocations. */\n\terr = test_psset_alloc_reuse(&psset, &alloc, PAGE);\n\texpect_true(err, \"Empty psset succeeded in an allocation.\");\n}\nTEST_END\n\nTEST_BEGIN(test_fill) {\n\tbool err;\n\n\thpdata_t pageslab;\n\thpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);\n\n\tedata_t alloc[HUGEPAGE_PAGES];\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\tedata_init_test(&alloc[0]);\n\ttest_psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES; i++) {\n\t\tedata_init_test(&alloc[i]);\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t}\n\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\tedata_t *edata = &alloc[i];\n\t\tedata_expect(edata, i, 1);\n\t}\n\n\t/* The pageslab, and thus psset, should now have no allocations. */\n\tedata_t extra_alloc;\n\tedata_init_test(&extra_alloc);\n\terr = test_psset_alloc_reuse(&psset, &extra_alloc, PAGE);\n\texpect_true(err, \"Alloc succeeded even though psset should be empty\");\n}\nTEST_END\n\nTEST_BEGIN(test_reuse) {\n\tbool err;\n\thpdata_t *ps;\n\n\thpdata_t pageslab;\n\thpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);\n\n\tedata_t alloc[HUGEPAGE_PAGES];\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\tedata_init_test(&alloc[0]);\n\ttest_psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES; i++) {\n\t\tedata_init_test(&alloc[i]);\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t}\n\n\t/* Free odd indices. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i ++) {\n\t\tif (i % 2 == 0) {\n\t\t\tcontinue;\n\t\t}\n\t\tps = test_psset_dalloc(&psset, &alloc[i]);\n\t\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\t}\n\t/* Realloc into them. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\tif (i % 2 == 0) {\n\t\t\tcontinue;\n\t\t}\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t\tedata_expect(&alloc[i], i, 1);\n\t}\n\t/* Now, free the pages at indices 0 or 1 mod 2. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\tif (i % 4 > 1) {\n\t\t\tcontinue;\n\t\t}\n\t\tps = test_psset_dalloc(&psset, &alloc[i]);\n\t\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\t}\n\t/* And realloc 2-page allocations into them. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\tif (i % 4 != 0) {\n\t\t\tcontinue;\n\t\t}\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], 2 * PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t\tedata_expect(&alloc[i], i, 2);\n\t}\n\t/* Free all the 2-page allocations. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES; i++) {\n\t\tif (i % 4 != 0) {\n\t\t\tcontinue;\n\t\t}\n\t\tps = test_psset_dalloc(&psset, &alloc[i]);\n\t\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\t}\n\t/*\n\t * Free up a 1-page hole next to a 2-page hole, but somewhere in the\n\t * middle of the pageslab. Index 11 should be right before such a hole\n\t * (since 12 % 4 == 0).\n\t */\n\tsize_t index_of_3 = 11;\n\tps = test_psset_dalloc(&psset, &alloc[index_of_3]);\n\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\terr = test_psset_alloc_reuse(&psset, &alloc[index_of_3], 3 * PAGE);\n\texpect_false(err, \"Should have been able to find alloc.\");\n\tedata_expect(&alloc[index_of_3], index_of_3, 3);\n\n\t/*\n\t * Free up a 4-page hole at the end. Recall that the pages at offsets 0\n\t * and 1 mod 4 were freed above, so we just have to free the last\n\t * allocations.\n\t */\n\tps = test_psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);\n\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\tps = test_psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 2]);\n\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\n\t/* Make sure we can satisfy an allocation at the very end of a slab. */\n\tsize_t index_of_4 = HUGEPAGE_PAGES - 4;\n\terr = test_psset_alloc_reuse(&psset, &alloc[index_of_4], 4 * PAGE);\n\texpect_false(err, \"Should have been able to find alloc.\");\n\tedata_expect(&alloc[index_of_4], index_of_4, 4);\n}\nTEST_END\n\nTEST_BEGIN(test_evict) {\n\tbool err;\n\thpdata_t *ps;\n\n\thpdata_t pageslab;\n\thpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);\n\n\tedata_t alloc[HUGEPAGE_PAGES];\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\t/* Alloc the whole slab. */\n\tedata_init_test(&alloc[0]);\n\ttest_psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES; i++) {\n\t\tedata_init_test(&alloc[i]);\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Unxpected allocation failure\");\n\t}\n\n\t/* Dealloc the whole slab, going forwards. */\n\tfor (size_t i = 0; i < HUGEPAGE_PAGES - 1; i++) {\n\t\tps = test_psset_dalloc(&psset, &alloc[i]);\n\t\texpect_ptr_null(ps, \"Nonempty pageslab evicted\");\n\t}\n\tps = test_psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);\n\texpect_ptr_eq(&pageslab, ps, \"Empty pageslab not evicted.\");\n\n\terr = test_psset_alloc_reuse(&psset, &alloc[0], PAGE);\n\texpect_true(err, \"psset should be empty.\");\n}\nTEST_END\n\nTEST_BEGIN(test_multi_pageslab) {\n\tbool err;\n\thpdata_t *ps;\n\n\thpdata_t pageslab[2];\n\thpdata_init(&pageslab[0], PAGESLAB_ADDR, PAGESLAB_AGE);\n\thpdata_init(&pageslab[1],\n\t (void *)((uintptr_t)PAGESLAB_ADDR + HUGEPAGE),\n\t PAGESLAB_AGE + 1);\n\n\tedata_t alloc[2][HUGEPAGE_PAGES];\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\t/* Insert both slabs. */\n\tedata_init_test(&alloc[0][0]);\n\ttest_psset_alloc_new(&psset, &pageslab[0], &alloc[0][0], PAGE);\n\tedata_init_test(&alloc[1][0]);\n\ttest_psset_alloc_new(&psset, &pageslab[1], &alloc[1][0], PAGE);\n\n\t/* Fill them both up; make sure we do so in first-fit order. */\n\tfor (size_t i = 0; i < 2; i++) {\n\t\tfor (size_t j = 1; j < HUGEPAGE_PAGES; j++) {\n\t\t\tedata_init_test(&alloc[i][j]);\n\t\t\terr = test_psset_alloc_reuse(&psset, &alloc[i][j], PAGE);\n\t\t\texpect_false(err,\n\t\t\t \"Nonempty psset failed page allocation.\");\n\t\t\tassert_ptr_eq(&pageslab[i], edata_ps_get(&alloc[i][j]),\n\t\t\t \"Didn't pick pageslabs in first-fit\");\n\t\t}\n\t}\n\n\t/*\n\t * Free up a 2-page hole in the earlier slab, and a 1-page one in the\n\t * later one. We should still pick the later one.\n\t */\n\tps = test_psset_dalloc(&psset, &alloc[0][0]);\n\texpect_ptr_null(ps, \"Unexpected eviction\");\n\tps = test_psset_dalloc(&psset, &alloc[0][1]);\n\texpect_ptr_null(ps, \"Unexpected eviction\");\n\tps = test_psset_dalloc(&psset, &alloc[1][0]);\n\texpect_ptr_null(ps, \"Unexpected eviction\");\n\terr = test_psset_alloc_reuse(&psset, &alloc[0][0], PAGE);\n\texpect_ptr_eq(&pageslab[1], edata_ps_get(&alloc[0][0]),\n\t \"Should have picked the fuller pageslab\");\n\n\t/*\n\t * Now both slabs have 1-page holes. Free up a second one in the later\n\t * slab.\n\t */\n\tps = test_psset_dalloc(&psset, &alloc[1][1]);\n\texpect_ptr_null(ps, \"Unexpected eviction\");\n\n\t/*\n\t * We should be able to allocate a 2-page object, even though an earlier\n\t * size class is nonempty.\n\t */\n\terr = test_psset_alloc_reuse(&psset, &alloc[1][0], 2 * PAGE);\n\texpect_false(err, \"Allocation should have succeeded\");\n}\nTEST_END\n\nstatic void\nstats_expect_empty(psset_bin_stats_t *stats) {\n\tassert_zu_eq(0, stats->npageslabs,\n\t \"Supposedly empty bin had positive npageslabs\");\n\texpect_zu_eq(0, stats->nactive, \"Unexpected nonempty bin\"\n\t \"Supposedly empty bin had positive nactive\");\n}\n\nstatic void\nstats_expect(psset_t *psset, size_t nactive) {\n\tif (nactive == HUGEPAGE_PAGES) {\n\t\texpect_zu_eq(1, psset->stats.full_slabs[0].npageslabs,\n\t\t \"Expected a full slab\");\n\t\texpect_zu_eq(HUGEPAGE_PAGES,\n\t\t psset->stats.full_slabs[0].nactive,\n\t\t \"Should have exactly filled the bin\");\n\t} else {\n\t\tstats_expect_empty(&psset->stats.full_slabs[0]);\n\t}\n\tsize_t ninactive = HUGEPAGE_PAGES - nactive;\n\tpszind_t nonempty_pind = PSSET_NPSIZES;\n\tif (ninactive != 0 && ninactive < HUGEPAGE_PAGES) {\n\t\tnonempty_pind = sz_psz2ind(sz_psz_quantize_floor(\n\t\t ninactive << LG_PAGE));\n\t}\n\tfor (pszind_t i = 0; i < PSSET_NPSIZES; i++) {\n\t\tif (i == nonempty_pind) {\n\t\t\tassert_zu_eq(1,\n\t\t\t psset->stats.nonfull_slabs[i][0].npageslabs,\n\t\t\t \"Should have found a slab\");\n\t\t\texpect_zu_eq(nactive,\n\t\t\t psset->stats.nonfull_slabs[i][0].nactive,\n\t\t\t \"Mismatch in active pages\");\n\t\t} else {\n\t\t\tstats_expect_empty(&psset->stats.nonfull_slabs[i][0]);\n\t\t}\n\t}\n\texpect_zu_eq(nactive, psset_nactive(psset), \"\");\n}\n\nTEST_BEGIN(test_stats) {\n\tbool err;\n\n\thpdata_t pageslab;\n\thpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);\n\n\tedata_t alloc[HUGEPAGE_PAGES];\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\tstats_expect(&psset, 0);\n\n\tedata_init_test(&alloc[0]);\n\ttest_psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES; i++) {\n\t\tstats_expect(&psset, i);\n\t\tedata_init_test(&alloc[i]);\n\t\terr = test_psset_alloc_reuse(&psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t}\n\tstats_expect(&psset, HUGEPAGE_PAGES);\n\thpdata_t *ps;\n\tfor (ssize_t i = HUGEPAGE_PAGES - 1; i >= 0; i--) {\n\t\tps = test_psset_dalloc(&psset, &alloc[i]);\n\t\texpect_true((ps == NULL) == (i != 0),\n\t\t \"test_psset_dalloc should only evict a slab on the last \"\n\t\t \"free\");\n\t\tstats_expect(&psset, i);\n\t}\n\n\ttest_psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);\n\tstats_expect(&psset, 1);\n\tpsset_update_begin(&psset, &pageslab);\n\tstats_expect(&psset, 0);\n\tpsset_update_end(&psset, &pageslab);\n\tstats_expect(&psset, 1);\n}\nTEST_END\n\n/*\n * Fills in and inserts two pageslabs, with the first better than the second,\n * and each fully allocated (into the allocations in allocs and worse_allocs,\n * each of which should be HUGEPAGE_PAGES long), except for a single free page\n * at the end.\n *\n * (There's nothing magic about these numbers; it's just useful to share the\n * setup between the oldest fit and the insert/remove test).\n */\nstatic void\ninit_test_pageslabs(psset_t *psset, hpdata_t *pageslab,\n hpdata_t *worse_pageslab, edata_t *alloc, edata_t *worse_alloc) {\n\tbool err;\n\n\thpdata_init(pageslab, (void *)(10 * HUGEPAGE), PAGESLAB_AGE);\n\t/*\n\t * This pageslab would be better from an address-first-fit POV, but\n\t * worse from an age POV.\n\t */\n\thpdata_init(worse_pageslab, (void *)(9 * HUGEPAGE), PAGESLAB_AGE + 1);\n\n\tpsset_init(psset);\n\n\tedata_init_test(&alloc[0]);\n\ttest_psset_alloc_new(psset, pageslab, &alloc[0], PAGE);\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES; i++) {\n\t\tedata_init_test(&alloc[i]);\n\t\terr = test_psset_alloc_reuse(psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t\texpect_ptr_eq(pageslab, edata_ps_get(&alloc[i]),\n\t\t \"Allocated from the wrong pageslab\");\n\t}\n\n\tedata_init_test(&worse_alloc[0]);\n\ttest_psset_alloc_new(psset, worse_pageslab, &worse_alloc[0], PAGE);\n\texpect_ptr_eq(worse_pageslab, edata_ps_get(&worse_alloc[0]),\n\t \"Allocated from the wrong pageslab\");\n\t/*\n\t * Make the two pssets otherwise indistinguishable; all full except for\n\t * a single page.\n\t */\n\tfor (size_t i = 1; i < HUGEPAGE_PAGES - 1; i++) {\n\t\tedata_init_test(&worse_alloc[i]);\n\t\terr = test_psset_alloc_reuse(psset, &alloc[i], PAGE);\n\t\texpect_false(err, \"Nonempty psset failed page allocation.\");\n\t\texpect_ptr_eq(worse_pageslab, edata_ps_get(&alloc[i]),\n\t\t \"Allocated from the wrong pageslab\");\n\t}\n\n\t/* Deallocate the last page from the older pageslab. */\n\thpdata_t *evicted = test_psset_dalloc(psset,\n\t &alloc[HUGEPAGE_PAGES - 1]);\n\texpect_ptr_null(evicted, \"Unexpected eviction\");\n}\n\nTEST_BEGIN(test_oldest_fit) {\n\tbool err;\n\tedata_t alloc[HUGEPAGE_PAGES];\n\tedata_t worse_alloc[HUGEPAGE_PAGES];\n\n\thpdata_t pageslab;\n\thpdata_t worse_pageslab;\n\n\tpsset_t psset;\n\n\tinit_test_pageslabs(&psset, &pageslab, &worse_pageslab, alloc,\n\t worse_alloc);\n\n\t/* The edata should come from the better pageslab. */\n\tedata_t test_edata;\n\tedata_init_test(&test_edata);\n\terr = test_psset_alloc_reuse(&psset, &test_edata, PAGE);\n\texpect_false(err, \"Nonempty psset failed page allocation\");\n\texpect_ptr_eq(&pageslab, edata_ps_get(&test_edata),\n\t \"Allocated from the wrong pageslab\");\n}\nTEST_END\n\nTEST_BEGIN(test_insert_remove) {\n\tbool err;\n\thpdata_t *ps;\n\tedata_t alloc[HUGEPAGE_PAGES];\n\tedata_t worse_alloc[HUGEPAGE_PAGES];\n\n\thpdata_t pageslab;\n\thpdata_t worse_pageslab;\n\n\tpsset_t psset;\n\n\tinit_test_pageslabs(&psset, &pageslab, &worse_pageslab, alloc,\n\t worse_alloc);\n\n\t/* Remove better; should still be able to alloc from worse. */\n\tpsset_update_begin(&psset, &pageslab);\n\terr = test_psset_alloc_reuse(&psset, &worse_alloc[HUGEPAGE_PAGES - 1],\n\t PAGE);\n\texpect_false(err, \"Removal should still leave an empty page\");\n\texpect_ptr_eq(&worse_pageslab,\n\t edata_ps_get(&worse_alloc[HUGEPAGE_PAGES - 1]),\n\t \"Allocated out of wrong ps\");\n\n\t/*\n\t * After deallocating the previous alloc and reinserting better, it\n\t * should be preferred for future allocations.\n\t */\n\tps = test_psset_dalloc(&psset, &worse_alloc[HUGEPAGE_PAGES - 1]);\n\texpect_ptr_null(ps, \"Incorrect eviction of nonempty pageslab\");\n\tpsset_update_end(&psset, &pageslab);\n\terr = test_psset_alloc_reuse(&psset, &alloc[HUGEPAGE_PAGES - 1], PAGE);\n\texpect_false(err, \"psset should be nonempty\");\n\texpect_ptr_eq(&pageslab, edata_ps_get(&alloc[HUGEPAGE_PAGES - 1]),\n\t \"Removal/reinsertion shouldn't change ordering\");\n\t/*\n\t * After deallocating and removing both, allocations should fail.\n\t */\n\tps = test_psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);\n\texpect_ptr_null(ps, \"Incorrect eviction\");\n\tpsset_update_begin(&psset, &pageslab);\n\tpsset_update_begin(&psset, &worse_pageslab);\n\terr = test_psset_alloc_reuse(&psset, &alloc[HUGEPAGE_PAGES - 1], PAGE);\n\texpect_true(err, \"psset should be empty, but an alloc succeeded\");\n}\nTEST_END\n\nTEST_BEGIN(test_purge_prefers_nonhuge) {\n\t/*\n\t * All else being equal, we should prefer purging non-huge pages over\n\t * huge ones for non-empty extents.\n\t */\n\n\t/* Nothing magic about this constant. */\n\tenum {\n\t\tNHP = 23,\n\t};\n\thpdata_t *hpdata;\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\thpdata_t hpdata_huge[NHP];\n\tuintptr_t huge_begin = (uintptr_t)&hpdata_huge[0];\n\tuintptr_t huge_end = (uintptr_t)&hpdata_huge[NHP];\n\thpdata_t hpdata_nonhuge[NHP];\n\tuintptr_t nonhuge_begin = (uintptr_t)&hpdata_nonhuge[0];\n\tuintptr_t nonhuge_end = (uintptr_t)&hpdata_nonhuge[NHP];\n\n\tfor (size_t i = 0; i < NHP; i++) {\n\t\thpdata_init(&hpdata_huge[i], (void *)((10 + i) * HUGEPAGE),\n\t\t 123 + i);\n\t\tpsset_insert(&psset, &hpdata_huge[i]);\n\n\t\thpdata_init(&hpdata_nonhuge[i],\n\t\t (void *)((10 + NHP + i) * HUGEPAGE),\n\t\t 456 + i);\n\t\tpsset_insert(&psset, &hpdata_nonhuge[i]);\n\n\t}\n\tfor (int i = 0; i < 2 * NHP; i++) {\n\t\thpdata = psset_pick_alloc(&psset, HUGEPAGE * 3 / 4);\n\t\tpsset_update_begin(&psset, hpdata);\n\t\tvoid *ptr;\n\t\tptr = hpdata_reserve_alloc(hpdata, HUGEPAGE * 3 / 4);\n\t\t/* Ignore the first alloc, which will stick around. */\n\t\t(void)ptr;\n\t\t/*\n\t\t * The second alloc is to dirty the pages; free it immediately\n\t\t * after allocating.\n\t\t */\n\t\tptr = hpdata_reserve_alloc(hpdata, HUGEPAGE / 4);\n\t\thpdata_unreserve(hpdata, ptr, HUGEPAGE / 4);\n\n\t\tif (huge_begin <= (uintptr_t)hpdata\n\t\t && (uintptr_t)hpdata < huge_end) {\n\t\t\thpdata_hugify(hpdata);\n\t\t}\n\n\t\thpdata_purge_allowed_set(hpdata, true);\n\t\tpsset_update_end(&psset, hpdata);\n\t}\n\n\t/*\n\t * We've got a bunch of 1/8th dirty hpdatas. It should give us all the\n\t * non-huge ones to purge, then all the huge ones, then refuse to purge\n\t * further.\n\t */\n\tfor (int i = 0; i < NHP; i++) {\n\t\thpdata = psset_pick_purge(&psset);\n\t\tassert_true(nonhuge_begin <= (uintptr_t)hpdata\n\t\t && (uintptr_t)hpdata < nonhuge_end, \"\");\n\t\tpsset_update_begin(&psset, hpdata);\n\t\ttest_psset_fake_purge(hpdata);\n\t\thpdata_purge_allowed_set(hpdata, false);\n\t\tpsset_update_end(&psset, hpdata);\n\t}\n\tfor (int i = 0; i < NHP; i++) {\n\t\thpdata = psset_pick_purge(&psset);\n\t\texpect_true(huge_begin <= (uintptr_t)hpdata\n\t\t && (uintptr_t)hpdata < huge_end, \"\");\n\t\tpsset_update_begin(&psset, hpdata);\n\t\thpdata_dehugify(hpdata);\n\t\ttest_psset_fake_purge(hpdata);\n\t\thpdata_purge_allowed_set(hpdata, false);\n\t\tpsset_update_end(&psset, hpdata);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_purge_prefers_empty) {\n\tvoid *ptr;\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\thpdata_t hpdata_empty;\n\thpdata_t hpdata_nonempty;\n\thpdata_init(&hpdata_empty, (void *)(10 * HUGEPAGE), 123);\n\tpsset_insert(&psset, &hpdata_empty);\n\thpdata_init(&hpdata_nonempty, (void *)(11 * HUGEPAGE), 456);\n\tpsset_insert(&psset, &hpdata_nonempty);\n\n\tpsset_update_begin(&psset, &hpdata_empty);\n\tptr = hpdata_reserve_alloc(&hpdata_empty, PAGE);\n\texpect_ptr_eq(hpdata_addr_get(&hpdata_empty), ptr, \"\");\n\thpdata_unreserve(&hpdata_empty, ptr, PAGE);\n\thpdata_purge_allowed_set(&hpdata_empty, true);\n\tpsset_update_end(&psset, &hpdata_empty);\n\n\tpsset_update_begin(&psset, &hpdata_nonempty);\n\tptr = hpdata_reserve_alloc(&hpdata_nonempty, 10 * PAGE);\n\texpect_ptr_eq(hpdata_addr_get(&hpdata_nonempty), ptr, \"\");\n\thpdata_unreserve(&hpdata_nonempty, ptr, 9 * PAGE);\n\thpdata_purge_allowed_set(&hpdata_nonempty, true);\n\tpsset_update_end(&psset, &hpdata_nonempty);\n\n\t/*\n\t * The nonempty slab has 9 dirty pages, while the empty one has only 1.\n\t * We should still pick the empty one for purging.\n\t */\n\thpdata_t *to_purge = psset_pick_purge(&psset);\n\texpect_ptr_eq(&hpdata_empty, to_purge, \"\");\n}\nTEST_END\n\nTEST_BEGIN(test_purge_prefers_empty_huge) {\n\tvoid *ptr;\n\n\tpsset_t psset;\n\tpsset_init(&psset);\n\n\tenum {NHP = 10 };\n\n\thpdata_t hpdata_huge[NHP];\n\thpdata_t hpdata_nonhuge[NHP];\n\n\tuintptr_t cur_addr = 100 * HUGEPAGE;\n\tuint64_t cur_age = 123;\n\tfor (int i = 0; i < NHP; i++) {\n\t\thpdata_init(&hpdata_huge[i], (void *)cur_addr, cur_age);\n\t\tcur_addr += HUGEPAGE;\n\t\tcur_age++;\n\t\tpsset_insert(&psset, &hpdata_huge[i]);\n\n\t\thpdata_init(&hpdata_nonhuge[i], (void *)cur_addr, cur_age);\n\t\tcur_addr += HUGEPAGE;\n\t\tcur_age++;\n\t\tpsset_insert(&psset, &hpdata_nonhuge[i]);\n\n\t\t/*\n\t\t * Make the hpdata_huge[i] fully dirty, empty, purgable, and\n\t\t * huge.\n\t\t */\n\t\tpsset_update_begin(&psset, &hpdata_huge[i]);\n\t\tptr = hpdata_reserve_alloc(&hpdata_huge[i], HUGEPAGE);\n\t\texpect_ptr_eq(hpdata_addr_get(&hpdata_huge[i]), ptr, \"\");\n\t\thpdata_hugify(&hpdata_huge[i]);\n\t\thpdata_unreserve(&hpdata_huge[i], ptr, HUGEPAGE);\n\t\thpdata_purge_allowed_set(&hpdata_huge[i], true);\n\t\tpsset_update_end(&psset, &hpdata_huge[i]);\n\n\t\t/*\n\t\t * Make hpdata_nonhuge[i] fully dirty, empty, purgable, and\n\t\t * non-huge.\n\t\t */\n\t\tpsset_update_begin(&psset, &hpdata_nonhuge[i]);\n\t\tptr = hpdata_reserve_alloc(&hpdata_nonhuge[i], HUGEPAGE);\n\t\texpect_ptr_eq(hpdata_addr_get(&hpdata_nonhuge[i]), ptr, \"\");\n\t\thpdata_unreserve(&hpdata_nonhuge[i], ptr, HUGEPAGE);\n\t\thpdata_purge_allowed_set(&hpdata_nonhuge[i], true);\n\t\tpsset_update_end(&psset, &hpdata_nonhuge[i]);\n\t}\n\n\t/*\n\t * We have a bunch of empty slabs, half huge, half nonhuge, inserted in\n\t * alternating order. We should pop all the huge ones before popping\n\t * any of the non-huge ones for purging.\n\t */\n\tfor (int i = 0; i < NHP; i++) {\n\t\thpdata_t *to_purge = psset_pick_purge(&psset);\n\t\texpect_ptr_eq(&hpdata_huge[i], to_purge, \"\");\n\t\tpsset_update_begin(&psset, to_purge);\n\t\thpdata_purge_allowed_set(to_purge, false);\n\t\tpsset_update_end(&psset, to_purge);\n\t}\n\tfor (int i = 0; i < NHP; i++) {\n\t\thpdata_t *to_purge = psset_pick_purge(&psset);\n\t\texpect_ptr_eq(&hpdata_nonhuge[i], to_purge, \"\");\n\t\tpsset_update_begin(&psset, to_purge);\n\t\thpdata_purge_allowed_set(to_purge, false);\n\t\tpsset_update_end(&psset, to_purge);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_empty,\n\t test_fill,\n\t test_reuse,\n\t test_evict,\n\t test_multi_pageslab,\n\t test_stats,\n\t test_oldest_fit,\n\t test_insert_remove,\n\t test_purge_prefers_nonhuge,\n\t test_purge_prefers_empty,\n\t test_purge_prefers_empty_huge);\n}\n" }, { "path": "deps/jemalloc/test/unit/ql.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/ql.h\"\n\n/* Number of ring entries, in [2..26]. */\n#define NENTRIES 9\n\ntypedef struct list_s list_t;\ntypedef ql_head(list_t) list_head_t;\n\nstruct list_s {\n\tql_elm(list_t) link;\n\tchar id;\n};\n\nstatic void\ntest_empty_list(list_head_t *head) {\n\tlist_t *t;\n\tunsigned i;\n\n\texpect_true(ql_empty(head), \"Unexpected element for empty list\");\n\texpect_ptr_null(ql_first(head), \"Unexpected element for empty list\");\n\texpect_ptr_null(ql_last(head, link),\n\t \"Unexpected element for empty list\");\n\n\ti = 0;\n\tql_foreach(t, head, link) {\n\t\ti++;\n\t}\n\texpect_u_eq(i, 0, \"Unexpected element for empty list\");\n\n\ti = 0;\n\tql_reverse_foreach(t, head, link) {\n\t\ti++;\n\t}\n\texpect_u_eq(i, 0, \"Unexpected element for empty list\");\n}\n\nTEST_BEGIN(test_ql_empty) {\n\tlist_head_t head;\n\n\tql_new(&head);\n\ttest_empty_list(&head);\n}\nTEST_END\n\nstatic void\ninit_entries(list_t *entries, unsigned nentries) {\n\tunsigned i;\n\n\tfor (i = 0; i < nentries; i++) {\n\t\tentries[i].id = 'a' + i;\n\t\tql_elm_new(&entries[i], link);\n\t}\n}\n\nstatic void\ntest_entries_list(list_head_t *head, list_t *entries, unsigned nentries) {\n\tlist_t *t;\n\tunsigned i;\n\n\texpect_false(ql_empty(head), \"List should not be empty\");\n\texpect_c_eq(ql_first(head)->id, entries[0].id, \"Element id mismatch\");\n\texpect_c_eq(ql_last(head, link)->id, entries[nentries-1].id,\n\t \"Element id mismatch\");\n\n\ti = 0;\n\tql_foreach(t, head, link) {\n\t\texpect_c_eq(t->id, entries[i].id, \"Element id mismatch\");\n\t\ti++;\n\t}\n\n\ti = 0;\n\tql_reverse_foreach(t, head, link) {\n\t\texpect_c_eq(t->id, entries[nentries-i-1].id,\n\t\t \"Element id mismatch\");\n\t\ti++;\n\t}\n\n\tfor (i = 0; i < nentries-1; i++) {\n\t\tt = ql_next(head, &entries[i], link);\n\t\texpect_c_eq(t->id, entries[i+1].id, \"Element id mismatch\");\n\t}\n\texpect_ptr_null(ql_next(head, &entries[nentries-1], link),\n\t \"Unexpected element\");\n\n\texpect_ptr_null(ql_prev(head, &entries[0], link), \"Unexpected element\");\n\tfor (i = 1; i < nentries; i++) {\n\t\tt = ql_prev(head, &entries[i], link);\n\t\texpect_c_eq(t->id, entries[i-1].id, \"Element id mismatch\");\n\t}\n}\n\nTEST_BEGIN(test_ql_tail_insert) {\n\tlist_head_t head;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_tail_insert(&head, &entries[i], link);\n\t}\n\n\ttest_entries_list(&head, entries, NENTRIES);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_tail_remove) {\n\tlist_head_t head;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_tail_insert(&head, &entries[i], link);\n\t}\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\ttest_entries_list(&head, entries, NENTRIES-i);\n\t\tql_tail_remove(&head, list_t, link);\n\t}\n\ttest_empty_list(&head);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_head_insert) {\n\tlist_head_t head;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_head_insert(&head, &entries[NENTRIES-i-1], link);\n\t}\n\n\ttest_entries_list(&head, entries, NENTRIES);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_head_remove) {\n\tlist_head_t head;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_head_insert(&head, &entries[NENTRIES-i-1], link);\n\t}\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\ttest_entries_list(&head, &entries[i], NENTRIES-i);\n\t\tql_head_remove(&head, list_t, link);\n\t}\n\ttest_empty_list(&head);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_insert) {\n\tlist_head_t head;\n\tlist_t entries[8];\n\tlist_t *a, *b, *c, *d, *e, *f, *g, *h;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\ta = &entries[0];\n\tb = &entries[1];\n\tc = &entries[2];\n\td = &entries[3];\n\te = &entries[4];\n\tf = &entries[5];\n\tg = &entries[6];\n\th = &entries[7];\n\n\t/*\n\t * ql_remove(), ql_before_insert(), and ql_after_insert() are used\n\t * internally by other macros that are already tested, so there's no\n\t * need to test them completely. However, insertion/deletion from the\n\t * middle of lists is not otherwise tested; do so here.\n\t */\n\tql_tail_insert(&head, f, link);\n\tql_before_insert(&head, f, b, link);\n\tql_before_insert(&head, f, c, link);\n\tql_after_insert(f, h, link);\n\tql_after_insert(f, g, link);\n\tql_before_insert(&head, b, a, link);\n\tql_after_insert(c, d, link);\n\tql_before_insert(&head, f, e, link);\n\n\ttest_entries_list(&head, entries, sizeof(entries)/sizeof(list_t));\n}\nTEST_END\n\nstatic void\ntest_concat_split_entries(list_t *entries, unsigned nentries_a,\n unsigned nentries_b) {\n\tinit_entries(entries, nentries_a + nentries_b);\n\n\tlist_head_t head_a;\n\tql_new(&head_a);\n\tfor (unsigned i = 0; i < nentries_a; i++) {\n\t\tql_tail_insert(&head_a, &entries[i], link);\n\t}\n\tif (nentries_a == 0) {\n\t\ttest_empty_list(&head_a);\n\t} else {\n\t\ttest_entries_list(&head_a, entries, nentries_a);\n\t}\n\n\tlist_head_t head_b;\n\tql_new(&head_b);\n\tfor (unsigned i = 0; i < nentries_b; i++) {\n\t\tql_tail_insert(&head_b, &entries[nentries_a + i], link);\n\t}\n\tif (nentries_b == 0) {\n\t\ttest_empty_list(&head_b);\n\t} else {\n\t\ttest_entries_list(&head_b, entries + nentries_a, nentries_b);\n\t}\n\n\tql_concat(&head_a, &head_b, link);\n\tif (nentries_a + nentries_b == 0) {\n\t\ttest_empty_list(&head_a);\n\t} else {\n\t\ttest_entries_list(&head_a, entries, nentries_a + nentries_b);\n\t}\n\ttest_empty_list(&head_b);\n\n\tif (nentries_b == 0) {\n\t\treturn;\n\t}\n\n\tlist_head_t head_c;\n\tql_split(&head_a, &entries[nentries_a], &head_c, link);\n\tif (nentries_a == 0) {\n\t\ttest_empty_list(&head_a);\n\t} else {\n\t\ttest_entries_list(&head_a, entries, nentries_a);\n\t}\n\ttest_entries_list(&head_c, entries + nentries_a, nentries_b);\n}\n\nTEST_BEGIN(test_ql_concat_split) {\n\tlist_t entries[NENTRIES];\n\n\ttest_concat_split_entries(entries, 0, 0);\n\n\ttest_concat_split_entries(entries, 0, 1);\n\ttest_concat_split_entries(entries, 1, 0);\n\n\ttest_concat_split_entries(entries, 0, NENTRIES);\n\ttest_concat_split_entries(entries, 1, NENTRIES - 1);\n\ttest_concat_split_entries(entries, NENTRIES / 2,\n\t NENTRIES - NENTRIES / 2);\n\ttest_concat_split_entries(entries, NENTRIES - 1, 1);\n\ttest_concat_split_entries(entries, NENTRIES, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_rotate) {\n\tlist_head_t head;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head);\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_tail_insert(&head, &entries[i], link);\n\t}\n\n\tchar head_id = ql_first(&head)->id;\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tassert_c_eq(ql_first(&head)->id, head_id, \"\");\n\t\tql_rotate(&head, link);\n\t\tassert_c_eq(ql_last(&head, link)->id, head_id, \"\");\n\t\thead_id++;\n\t}\n\ttest_entries_list(&head, entries, NENTRIES);\n}\nTEST_END\n\nTEST_BEGIN(test_ql_move) {\n\tlist_head_t head_dest, head_src;\n\tlist_t entries[NENTRIES];\n\tunsigned i;\n\n\tql_new(&head_src);\n\tql_move(&head_dest, &head_src);\n\ttest_empty_list(&head_src);\n\ttest_empty_list(&head_dest);\n\n\tinit_entries(entries, sizeof(entries)/sizeof(list_t));\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tql_tail_insert(&head_src, &entries[i], link);\n\t}\n\tql_move(&head_dest, &head_src);\n\ttest_empty_list(&head_src);\n\ttest_entries_list(&head_dest, entries, NENTRIES);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_ql_empty,\n\t test_ql_tail_insert,\n\t test_ql_tail_remove,\n\t test_ql_head_insert,\n\t test_ql_head_remove,\n\t test_ql_insert,\n\t test_ql_concat_split,\n\t test_ql_rotate,\n\t test_ql_move);\n}\n" }, { "path": "deps/jemalloc/test/unit/qr.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/qr.h\"\n\n/* Number of ring entries, in [2..26]. */\n#define NENTRIES 9\n/* Split index, in [1..NENTRIES). */\n#define SPLIT_INDEX 5\n\ntypedef struct ring_s ring_t;\n\nstruct ring_s {\n\tqr(ring_t) link;\n\tchar id;\n};\n\nstatic void\ninit_entries(ring_t *entries) {\n\tunsigned i;\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tqr_new(&entries[i], link);\n\t\tentries[i].id = 'a' + i;\n\t}\n}\n\nstatic void\ntest_independent_entries(ring_t *entries) {\n\tring_t *t;\n\tunsigned i, j;\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_foreach(t, &entries[i], link) {\n\t\t\tj++;\n\t\t}\n\t\texpect_u_eq(j, 1,\n\t\t \"Iteration over single-element ring should visit precisely \"\n\t\t \"one element\");\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_reverse_foreach(t, &entries[i], link) {\n\t\t\tj++;\n\t\t}\n\t\texpect_u_eq(j, 1,\n\t\t \"Iteration over single-element ring should visit precisely \"\n\t\t \"one element\");\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_next(&entries[i], link);\n\t\texpect_ptr_eq(t, &entries[i],\n\t\t \"Next element in single-element ring should be same as \"\n\t\t \"current element\");\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_prev(&entries[i], link);\n\t\texpect_ptr_eq(t, &entries[i],\n\t\t \"Previous element in single-element ring should be same as \"\n\t\t \"current element\");\n\t}\n}\n\nTEST_BEGIN(test_qr_one) {\n\tring_t entries[NENTRIES];\n\n\tinit_entries(entries);\n\ttest_independent_entries(entries);\n}\nTEST_END\n\nstatic void\ntest_entries_ring(ring_t *entries) {\n\tring_t *t;\n\tunsigned i, j;\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[(i+j) % NENTRIES].id,\n\t\t\t \"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_reverse_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[(NENTRIES+i-j-1) %\n\t\t\t NENTRIES].id, \"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_next(&entries[i], link);\n\t\texpect_c_eq(t->id, entries[(i+1) % NENTRIES].id,\n\t\t \"Element id mismatch\");\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_prev(&entries[i], link);\n\t\texpect_c_eq(t->id, entries[(NENTRIES+i-1) % NENTRIES].id,\n\t\t \"Element id mismatch\");\n\t}\n}\n\nTEST_BEGIN(test_qr_after_insert) {\n\tring_t entries[NENTRIES];\n\tunsigned i;\n\n\tinit_entries(entries);\n\tfor (i = 1; i < NENTRIES; i++) {\n\t\tqr_after_insert(&entries[i - 1], &entries[i], link);\n\t}\n\ttest_entries_ring(entries);\n}\nTEST_END\n\nTEST_BEGIN(test_qr_remove) {\n\tring_t entries[NENTRIES];\n\tring_t *t;\n\tunsigned i, j;\n\n\tinit_entries(entries);\n\tfor (i = 1; i < NENTRIES; i++) {\n\t\tqr_after_insert(&entries[i - 1], &entries[i], link);\n\t}\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[i+j].id,\n\t\t\t \"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t\tj = 0;\n\t\tqr_reverse_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[NENTRIES - 1 - j].id,\n\t\t\t\"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t\tqr_remove(&entries[i], link);\n\t}\n\ttest_independent_entries(entries);\n}\nTEST_END\n\nTEST_BEGIN(test_qr_before_insert) {\n\tring_t entries[NENTRIES];\n\tring_t *t;\n\tunsigned i, j;\n\n\tinit_entries(entries);\n\tfor (i = 1; i < NENTRIES; i++) {\n\t\tqr_before_insert(&entries[i - 1], &entries[i], link);\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[(NENTRIES+i-j) %\n\t\t\t NENTRIES].id, \"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_reverse_foreach(t, &entries[i], link) {\n\t\t\texpect_c_eq(t->id, entries[(i+j+1) % NENTRIES].id,\n\t\t\t \"Element id mismatch\");\n\t\t\tj++;\n\t\t}\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_next(&entries[i], link);\n\t\texpect_c_eq(t->id, entries[(NENTRIES+i-1) % NENTRIES].id,\n\t\t \"Element id mismatch\");\n\t}\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tt = qr_prev(&entries[i], link);\n\t\texpect_c_eq(t->id, entries[(i+1) % NENTRIES].id,\n\t\t \"Element id mismatch\");\n\t}\n}\nTEST_END\n\nstatic void\ntest_split_entries(ring_t *entries) {\n\tring_t *t;\n\tunsigned i, j;\n\n\tfor (i = 0; i < NENTRIES; i++) {\n\t\tj = 0;\n\t\tqr_foreach(t, &entries[i], link) {\n\t\t\tif (i < SPLIT_INDEX) {\n\t\t\t\texpect_c_eq(t->id,\n\t\t\t\t entries[(i+j) % SPLIT_INDEX].id,\n\t\t\t\t \"Element id mismatch\");\n\t\t\t} else {\n\t\t\t\texpect_c_eq(t->id, entries[(i+j-SPLIT_INDEX) %\n\t\t\t\t (NENTRIES-SPLIT_INDEX) + SPLIT_INDEX].id,\n\t\t\t\t \"Element id mismatch\");\n\t\t\t}\n\t\t\tj++;\n\t\t}\n\t}\n}\n\nTEST_BEGIN(test_qr_meld_split) {\n\tring_t entries[NENTRIES];\n\tunsigned i;\n\n\tinit_entries(entries);\n\tfor (i = 1; i < NENTRIES; i++) {\n\t\tqr_after_insert(&entries[i - 1], &entries[i], link);\n\t}\n\n\tqr_split(&entries[0], &entries[SPLIT_INDEX], link);\n\ttest_split_entries(entries);\n\n\tqr_meld(&entries[0], &entries[SPLIT_INDEX], link);\n\ttest_entries_ring(entries);\n\n\tqr_meld(&entries[0], &entries[SPLIT_INDEX], link);\n\ttest_split_entries(entries);\n\n\tqr_split(&entries[0], &entries[SPLIT_INDEX], link);\n\ttest_entries_ring(entries);\n\n\tqr_split(&entries[0], &entries[0], link);\n\ttest_entries_ring(entries);\n\n\tqr_meld(&entries[0], &entries[0], link);\n\ttest_entries_ring(entries);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_qr_one,\n\t test_qr_after_insert,\n\t test_qr_remove,\n\t test_qr_before_insert,\n\t test_qr_meld_split);\n}\n" }, { "path": "deps/jemalloc/test/unit/rb.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \n\n#include \"jemalloc/internal/rb.h\"\n\n#define rbtn_black_height(a_type, a_field, a_rbt, r_height) do {\t\\\n\ta_type *rbp_bh_t;\t\t\t\t\t\t\\\n\tfor (rbp_bh_t = (a_rbt)->rbt_root, (r_height) = 0; rbp_bh_t !=\t\\\n\t NULL; rbp_bh_t = rbtn_left_get(a_type, a_field,\t\t\\\n\t rbp_bh_t)) {\t\t\t\t\t\t\\\n\t\tif (!rbtn_red_get(a_type, a_field, rbp_bh_t)) {\t\t\\\n\t\t(r_height)++;\t\t\t\t\t\t\\\n\t\t}\t\t\t\t\t\t\t\\\n\t}\t\t\t\t\t\t\t\t\\\n} while (0)\n\nstatic bool summarize_always_returns_true = false;\n\ntypedef struct node_s node_t;\nstruct node_s {\n#define NODE_MAGIC 0x9823af7e\n\tuint32_t magic;\n\trb_node(node_t) link;\n\t/* Order used by nodes. */\n\tuint64_t key;\n\t/*\n\t * Our made-up summary property is \"specialness\", with summarization\n\t * taking the max.\n\t */\n\tuint64_t specialness;\n\n\t/*\n\t * Used by some of the test randomization to avoid double-removing\n\t * nodes.\n\t */\n\tbool mid_remove;\n\n\t/*\n\t * To test searching functionality, we want to temporarily weaken the\n\t * ordering to allow non-equal nodes that nevertheless compare equal.\n\t */\n\tbool allow_duplicates;\n\n\t/*\n\t * In check_consistency, it's handy to know a node's rank in the tree;\n\t * this tracks it (but only there; not all tests use this).\n\t */\n\tint rank;\n\tint filtered_rank;\n\n\t/*\n\t * Replicate the internal structure of the tree, to make sure the\n\t * implementation doesn't miss any updates.\n\t */\n\tconst node_t *summary_lchild;\n\tconst node_t *summary_rchild;\n\tuint64_t summary_max_specialness;\n};\n\nstatic int\nnode_cmp(const node_t *a, const node_t *b) {\n\tint ret;\n\n\texpect_u32_eq(a->magic, NODE_MAGIC, \"Bad magic\");\n\texpect_u32_eq(b->magic, NODE_MAGIC, \"Bad magic\");\n\n\tret = (a->key > b->key) - (a->key < b->key);\n\tif (ret == 0 && !a->allow_duplicates) {\n\t\t/*\n\t\t * Duplicates are not allowed in the tree, so force an\n\t\t * arbitrary ordering for non-identical items with equal keys,\n\t\t * unless the user is searching and wants to allow the\n\t\t * duplicate.\n\t\t */\n\t\tret = (((uintptr_t)a) > ((uintptr_t)b))\n\t\t - (((uintptr_t)a) < ((uintptr_t)b));\n\t}\n\treturn ret;\n}\n\nstatic uint64_t\nnode_subtree_specialness(node_t *n, const node_t *lchild,\n const node_t *rchild) {\n\tuint64_t subtree_specialness = n->specialness;\n\tif (lchild != NULL\n\t && lchild->summary_max_specialness > subtree_specialness) {\n\t\tsubtree_specialness = lchild->summary_max_specialness;\n\t}\n\tif (rchild != NULL\n\t && rchild->summary_max_specialness > subtree_specialness) {\n\t\tsubtree_specialness = rchild->summary_max_specialness;\n\t}\n\treturn subtree_specialness;\n}\n\nstatic bool\nnode_summarize(node_t *a, const node_t *lchild, const node_t *rchild) {\n\tuint64_t new_summary_max_specialness = node_subtree_specialness(\n\t a, lchild, rchild);\n\tbool changed = (a->summary_lchild != lchild)\n\t || (a->summary_rchild != rchild)\n\t || (new_summary_max_specialness != a->summary_max_specialness);\n\ta->summary_max_specialness = new_summary_max_specialness;\n\ta->summary_lchild = lchild;\n\ta->summary_rchild = rchild;\n\treturn changed || summarize_always_returns_true;\n}\n\ntypedef rb_tree(node_t) tree_t;\nrb_summarized_proto(static, tree_, tree_t, node_t);\nrb_summarized_gen(static, tree_, tree_t, node_t, link, node_cmp,\n node_summarize);\n\nstatic bool\nspecialness_filter_node(void *ctx, node_t *node) {\n\tuint64_t specialness = *(uint64_t *)ctx;\n\treturn node->specialness >= specialness;\n}\n\nstatic bool\nspecialness_filter_subtree(void *ctx, node_t *node) {\n\tuint64_t specialness = *(uint64_t *)ctx;\n\treturn node->summary_max_specialness >= specialness;\n}\n\nstatic node_t *\ntree_iterate_cb(tree_t *tree, node_t *node, void *data) {\n\tunsigned *i = (unsigned *)data;\n\tnode_t *search_node;\n\n\texpect_u32_eq(node->magic, NODE_MAGIC, \"Bad magic\");\n\n\t/* Test rb_search(). */\n\tsearch_node = tree_search(tree, node);\n\texpect_ptr_eq(search_node, node,\n\t \"tree_search() returned unexpected node\");\n\n\t/* Test rb_nsearch(). */\n\tsearch_node = tree_nsearch(tree, node);\n\texpect_ptr_eq(search_node, node,\n\t \"tree_nsearch() returned unexpected node\");\n\n\t/* Test rb_psearch(). */\n\tsearch_node = tree_psearch(tree, node);\n\texpect_ptr_eq(search_node, node,\n\t \"tree_psearch() returned unexpected node\");\n\n\t(*i)++;\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_rb_empty) {\n\ttree_t tree;\n\tnode_t key;\n\n\ttree_new(&tree);\n\n\texpect_true(tree_empty(&tree), \"Tree should be empty\");\n\texpect_ptr_null(tree_first(&tree), \"Unexpected node\");\n\texpect_ptr_null(tree_last(&tree), \"Unexpected node\");\n\n\tkey.key = 0;\n\tkey.magic = NODE_MAGIC;\n\texpect_ptr_null(tree_search(&tree, &key), \"Unexpected node\");\n\n\tkey.key = 0;\n\tkey.magic = NODE_MAGIC;\n\texpect_ptr_null(tree_nsearch(&tree, &key), \"Unexpected node\");\n\n\tkey.key = 0;\n\tkey.magic = NODE_MAGIC;\n\texpect_ptr_null(tree_psearch(&tree, &key), \"Unexpected node\");\n\n\tunsigned nodes = 0;\n\ttree_iter_filtered(&tree, NULL, &tree_iterate_cb,\n\t &nodes, &specialness_filter_node, &specialness_filter_subtree,\n\t NULL);\n\texpect_u_eq(0, nodes, \"\");\n\n\tnodes = 0;\n\ttree_reverse_iter_filtered(&tree, NULL, &tree_iterate_cb,\n\t &nodes, &specialness_filter_node, &specialness_filter_subtree,\n\t NULL);\n\texpect_u_eq(0, nodes, \"\");\n\n\texpect_ptr_null(tree_first_filtered(&tree, &specialness_filter_node,\n\t &specialness_filter_subtree, NULL), \"\");\n\texpect_ptr_null(tree_last_filtered(&tree, &specialness_filter_node,\n\t &specialness_filter_subtree, NULL), \"\");\n\n\tkey.key = 0;\n\tkey.magic = NODE_MAGIC;\n\texpect_ptr_null(tree_search_filtered(&tree, &key,\n\t &specialness_filter_node, &specialness_filter_subtree, NULL), \"\");\n\texpect_ptr_null(tree_nsearch_filtered(&tree, &key,\n\t &specialness_filter_node, &specialness_filter_subtree, NULL), \"\");\n\texpect_ptr_null(tree_psearch_filtered(&tree, &key,\n\t &specialness_filter_node, &specialness_filter_subtree, NULL), \"\");\n}\nTEST_END\n\nstatic unsigned\ntree_recurse(node_t *node, unsigned black_height, unsigned black_depth) {\n\tunsigned ret = 0;\n\tnode_t *left_node;\n\tnode_t *right_node;\n\n\tif (node == NULL) {\n\t\treturn ret;\n\t}\n\n\tleft_node = rbtn_left_get(node_t, link, node);\n\tright_node = rbtn_right_get(node_t, link, node);\n\n\texpect_ptr_eq(left_node, node->summary_lchild,\n\t \"summary missed a tree update\");\n\texpect_ptr_eq(right_node, node->summary_rchild,\n\t \"summary missed a tree update\");\n\n\tuint64_t expected_subtree_specialness = node_subtree_specialness(node,\n\t left_node, right_node);\n\texpect_u64_eq(expected_subtree_specialness,\n\t node->summary_max_specialness, \"Incorrect summary\");\n\n\tif (!rbtn_red_get(node_t, link, node)) {\n\t\tblack_depth++;\n\t}\n\n\t/* Red nodes must be interleaved with black nodes. */\n\tif (rbtn_red_get(node_t, link, node)) {\n\t\tif (left_node != NULL) {\n\t\t\texpect_false(rbtn_red_get(node_t, link, left_node),\n\t\t\t\t\"Node should be black\");\n\t\t}\n\t\tif (right_node != NULL) {\n\t\t\texpect_false(rbtn_red_get(node_t, link, right_node),\n\t\t\t \"Node should be black\");\n\t\t}\n\t}\n\n\t/* Self. */\n\texpect_u32_eq(node->magic, NODE_MAGIC, \"Bad magic\");\n\n\t/* Left subtree. */\n\tif (left_node != NULL) {\n\t\tret += tree_recurse(left_node, black_height, black_depth);\n\t} else {\n\t\tret += (black_depth != black_height);\n\t}\n\n\t/* Right subtree. */\n\tif (right_node != NULL) {\n\t\tret += tree_recurse(right_node, black_height, black_depth);\n\t} else {\n\t\tret += (black_depth != black_height);\n\t}\n\n\treturn ret;\n}\n\nstatic unsigned\ntree_iterate(tree_t *tree) {\n\tunsigned i;\n\n\ti = 0;\n\ttree_iter(tree, NULL, tree_iterate_cb, (void *)&i);\n\n\treturn i;\n}\n\nstatic unsigned\ntree_iterate_reverse(tree_t *tree) {\n\tunsigned i;\n\n\ti = 0;\n\ttree_reverse_iter(tree, NULL, tree_iterate_cb, (void *)&i);\n\n\treturn i;\n}\n\nstatic void\nnode_remove(tree_t *tree, node_t *node, unsigned nnodes) {\n\tnode_t *search_node;\n\tunsigned black_height, imbalances;\n\n\ttree_remove(tree, node);\n\n\t/* Test rb_nsearch(). */\n\tsearch_node = tree_nsearch(tree, node);\n\tif (search_node != NULL) {\n\t\texpect_u64_ge(search_node->key, node->key,\n\t\t \"Key ordering error\");\n\t}\n\n\t/* Test rb_psearch(). */\n\tsearch_node = tree_psearch(tree, node);\n\tif (search_node != NULL) {\n\t\texpect_u64_le(search_node->key, node->key,\n\t\t \"Key ordering error\");\n\t}\n\n\tnode->magic = 0;\n\n\trbtn_black_height(node_t, link, tree, black_height);\n\timbalances = tree_recurse(tree->rbt_root, black_height, 0);\n\texpect_u_eq(imbalances, 0, \"Tree is unbalanced\");\n\texpect_u_eq(tree_iterate(tree), nnodes-1,\n\t \"Unexpected node iteration count\");\n\texpect_u_eq(tree_iterate_reverse(tree), nnodes-1,\n\t \"Unexpected node iteration count\");\n}\n\nstatic node_t *\nremove_iterate_cb(tree_t *tree, node_t *node, void *data) {\n\tunsigned *nnodes = (unsigned *)data;\n\tnode_t *ret = tree_next(tree, node);\n\n\tnode_remove(tree, node, *nnodes);\n\n\treturn ret;\n}\n\nstatic node_t *\nremove_reverse_iterate_cb(tree_t *tree, node_t *node, void *data) {\n\tunsigned *nnodes = (unsigned *)data;\n\tnode_t *ret = tree_prev(tree, node);\n\n\tnode_remove(tree, node, *nnodes);\n\n\treturn ret;\n}\n\nstatic void\ndestroy_cb(node_t *node, void *data) {\n\tunsigned *nnodes = (unsigned *)data;\n\n\texpect_u_gt(*nnodes, 0, \"Destruction removed too many nodes\");\n\t(*nnodes)--;\n}\n\nTEST_BEGIN(test_rb_random) {\n\tenum {\n\t\tNNODES = 25,\n\t\tNBAGS = 500,\n\t\tSEED = 42\n\t};\n\tsfmt_t *sfmt;\n\tuint64_t bag[NNODES];\n\ttree_t tree;\n\tnode_t nodes[NNODES];\n\tunsigned i, j, k, black_height, imbalances;\n\n\tsfmt = init_gen_rand(SEED);\n\tfor (i = 0; i < NBAGS; i++) {\n\t\tswitch (i) {\n\t\tcase 0:\n\t\t\t/* Insert in order. */\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = j;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase 1:\n\t\t\t/* Insert in reverse order. */\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = NNODES - j - 1;\n\t\t\t}\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tfor (j = 0; j < NNODES; j++) {\n\t\t\t\tbag[j] = gen_rand64_range(sfmt, NNODES);\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * We alternate test behavior with a period of 2 here, and a\n\t\t * period of 5 down below, so there's no cycle in which certain\n\t\t * combinations get omitted.\n\t\t */\n\t\tsummarize_always_returns_true = (i % 2 == 0);\n\n\t\tfor (j = 1; j <= NNODES; j++) {\n\t\t\t/* Initialize tree and nodes. */\n\t\t\ttree_new(&tree);\n\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\tnodes[k].magic = NODE_MAGIC;\n\t\t\t\tnodes[k].key = bag[k];\n\t\t\t\tnodes[k].specialness = gen_rand64_range(sfmt,\n\t\t\t\t NNODES);\n\t\t\t\tnodes[k].mid_remove = false;\n\t\t\t\tnodes[k].allow_duplicates = false;\n\t\t\t\tnodes[k].summary_lchild = NULL;\n\t\t\t\tnodes[k].summary_rchild = NULL;\n\t\t\t\tnodes[k].summary_max_specialness = 0;\n\t\t\t}\n\n\t\t\t/* Insert nodes. */\n\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\ttree_insert(&tree, &nodes[k]);\n\n\t\t\t\trbtn_black_height(node_t, link, &tree,\n\t\t\t\t black_height);\n\t\t\t\timbalances = tree_recurse(tree.rbt_root,\n\t\t\t\t black_height, 0);\n\t\t\t\texpect_u_eq(imbalances, 0,\n\t\t\t\t \"Tree is unbalanced\");\n\n\t\t\t\texpect_u_eq(tree_iterate(&tree), k+1,\n\t\t\t\t \"Unexpected node iteration count\");\n\t\t\t\texpect_u_eq(tree_iterate_reverse(&tree), k+1,\n\t\t\t\t \"Unexpected node iteration count\");\n\n\t\t\t\texpect_false(tree_empty(&tree),\n\t\t\t\t \"Tree should not be empty\");\n\t\t\t\texpect_ptr_not_null(tree_first(&tree),\n\t\t\t\t \"Tree should not be empty\");\n\t\t\t\texpect_ptr_not_null(tree_last(&tree),\n\t\t\t\t \"Tree should not be empty\");\n\n\t\t\t\ttree_next(&tree, &nodes[k]);\n\t\t\t\ttree_prev(&tree, &nodes[k]);\n\t\t\t}\n\n\t\t\t/* Remove nodes. */\n\t\t\tswitch (i % 5) {\n\t\t\tcase 0:\n\t\t\t\tfor (k = 0; k < j; k++) {\n\t\t\t\t\tnode_remove(&tree, &nodes[k], j - k);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\tfor (k = j; k > 0; k--) {\n\t\t\t\t\tnode_remove(&tree, &nodes[k-1], k);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 2: {\n\t\t\t\tnode_t *start;\n\t\t\t\tunsigned nnodes = j;\n\n\t\t\t\tstart = NULL;\n\t\t\t\tdo {\n\t\t\t\t\tstart = tree_iter(&tree, start,\n\t\t\t\t\t remove_iterate_cb, (void *)&nnodes);\n\t\t\t\t\tnnodes--;\n\t\t\t\t} while (start != NULL);\n\t\t\t\texpect_u_eq(nnodes, 0,\n\t\t\t\t \"Removal terminated early\");\n\t\t\t\tbreak;\n\t\t\t} case 3: {\n\t\t\t\tnode_t *start;\n\t\t\t\tunsigned nnodes = j;\n\n\t\t\t\tstart = NULL;\n\t\t\t\tdo {\n\t\t\t\t\tstart = tree_reverse_iter(&tree, start,\n\t\t\t\t\t remove_reverse_iterate_cb,\n\t\t\t\t\t (void *)&nnodes);\n\t\t\t\t\tnnodes--;\n\t\t\t\t} while (start != NULL);\n\t\t\t\texpect_u_eq(nnodes, 0,\n\t\t\t\t \"Removal terminated early\");\n\t\t\t\tbreak;\n\t\t\t} case 4: {\n\t\t\t\tunsigned nnodes = j;\n\t\t\t\ttree_destroy(&tree, destroy_cb, &nnodes);\n\t\t\t\texpect_u_eq(nnodes, 0,\n\t\t\t\t \"Destruction terminated early\");\n\t\t\t\tbreak;\n\t\t\t} default:\n\t\t\t\tnot_reached();\n\t\t\t}\n\t\t}\n\t}\n\tfini_gen_rand(sfmt);\n}\nTEST_END\n\nstatic void\nexpect_simple_consistency(tree_t *tree, uint64_t specialness,\n bool expected_empty, node_t *expected_first, node_t *expected_last) {\n\tbool empty;\n\tnode_t *first;\n\tnode_t *last;\n\n\tempty = tree_empty_filtered(tree, &specialness_filter_node,\n\t &specialness_filter_subtree, &specialness);\n\texpect_b_eq(expected_empty, empty, \"\");\n\n\tfirst = tree_first_filtered(tree,\n\t &specialness_filter_node, &specialness_filter_subtree,\n\t (void *)&specialness);\n\texpect_ptr_eq(expected_first, first, \"\");\n\n\tlast = tree_last_filtered(tree,\n\t &specialness_filter_node, &specialness_filter_subtree,\n\t (void *)&specialness);\n\texpect_ptr_eq(expected_last, last, \"\");\n}\n\nTEST_BEGIN(test_rb_filter_simple) {\n\tenum {FILTER_NODES = 10};\n\tnode_t nodes[FILTER_NODES];\n\tfor (unsigned i = 0; i < FILTER_NODES; i++) {\n\t\tnodes[i].magic = NODE_MAGIC;\n\t\tnodes[i].key = i;\n\t\tif (i == 0) {\n\t\t\tnodes[i].specialness = 0;\n\t\t} else {\n\t\t\tnodes[i].specialness = ffs_u(i);\n\t\t}\n\t\tnodes[i].mid_remove = false;\n\t\tnodes[i].allow_duplicates = false;\n\t\tnodes[i].summary_lchild = NULL;\n\t\tnodes[i].summary_rchild = NULL;\n\t\tnodes[i].summary_max_specialness = 0;\n\t}\n\n\tsummarize_always_returns_true = false;\n\n\ttree_t tree;\n\ttree_new(&tree);\n\n\t/* Should be empty */\n\texpect_simple_consistency(&tree, /* specialness */ 0, /* empty */ true,\n\t /* first */ NULL, /* last */ NULL);\n\n\t/* Fill in just the odd nodes. */\n\tfor (int i = 1; i < FILTER_NODES; i += 2) {\n\t\ttree_insert(&tree, &nodes[i]);\n\t}\n\n\t/* A search for an odd node should succeed. */\n\texpect_simple_consistency(&tree, /* specialness */ 0, /* empty */ false,\n\t /* first */ &nodes[1], /* last */ &nodes[9]);\n\n\t/* But a search for an even one should fail. */\n\texpect_simple_consistency(&tree, /* specialness */ 1, /* empty */ true,\n\t /* first */ NULL, /* last */ NULL);\n\n\t/* Now we add an even. */\n\ttree_insert(&tree, &nodes[4]);\n\texpect_simple_consistency(&tree, /* specialness */ 1, /* empty */ false,\n\t /* first */ &nodes[4], /* last */ &nodes[4]);\n\n\t/* A smaller even, and a larger even. */\n\ttree_insert(&tree, &nodes[2]);\n\ttree_insert(&tree, &nodes[8]);\n\n\t/*\n\t * A first-search (resp. last-search) for an even should switch to the\n\t * lower (higher) one, now that it's been added.\n\t */\n\texpect_simple_consistency(&tree, /* specialness */ 1, /* empty */ false,\n\t /* first */ &nodes[2], /* last */ &nodes[8]);\n\n\t/*\n\t * If we remove 2, a first-search we should go back to 4, while a\n\t * last-search should remain unchanged.\n\t */\n\ttree_remove(&tree, &nodes[2]);\n\texpect_simple_consistency(&tree, /* specialness */ 1, /* empty */ false,\n\t /* first */ &nodes[4], /* last */ &nodes[8]);\n\n\t/* Reinsert 2, then find it again. */\n\ttree_insert(&tree, &nodes[2]);\n\texpect_simple_consistency(&tree, /* specialness */ 1, /* empty */ false,\n\t /* first */ &nodes[2], /* last */ &nodes[8]);\n\n\t/* Searching for a multiple of 4 should not have changed. */\n\texpect_simple_consistency(&tree, /* specialness */ 2, /* empty */ false,\n\t /* first */ &nodes[4], /* last */ &nodes[8]);\n\n\t/* And a multiple of 8 */\n\texpect_simple_consistency(&tree, /* specialness */ 3, /* empty */ false,\n\t /* first */ &nodes[8], /* last */ &nodes[8]);\n\n\t/* But not a multiple of 16 */\n\texpect_simple_consistency(&tree, /* specialness */ 4, /* empty */ true,\n\t /* first */ NULL, /* last */ NULL);\n}\nTEST_END\n\ntypedef struct iter_ctx_s iter_ctx_t;\nstruct iter_ctx_s {\n\tint ncalls;\n\tnode_t *last_node;\n\n\tint ncalls_max;\n\tbool forward;\n};\n\nstatic node_t *\ntree_iterate_filtered_cb(tree_t *tree, node_t *node, void *arg) {\n\titer_ctx_t *ctx = (iter_ctx_t *)arg;\n\tctx->ncalls++;\n\texpect_u64_ge(node->specialness, 1,\n\t \"Should only invoke cb on nodes that pass the filter\");\n\tif (ctx->last_node != NULL) {\n\t\tif (ctx->forward) {\n\t\t\texpect_d_lt(node_cmp(ctx->last_node, node), 0,\n\t\t\t \"Incorrect iteration order\");\n\t\t} else {\n\t\t\texpect_d_gt(node_cmp(ctx->last_node, node), 0,\n\t\t\t \"Incorrect iteration order\");\n\t\t}\n\t}\n\tctx->last_node = node;\n\tif (ctx->ncalls == ctx->ncalls_max) {\n\t\treturn node;\n\t}\n\treturn NULL;\n}\n\nstatic int\nqsort_node_cmp(const void *ap, const void *bp) {\n\tnode_t *a = *(node_t **)ap;\n\tnode_t *b = *(node_t **)bp;\n\treturn node_cmp(a, b);\n}\n\n#define UPDATE_TEST_MAX 100\nstatic void\ncheck_consistency(tree_t *tree, node_t nodes[UPDATE_TEST_MAX], int nnodes) {\n\tuint64_t specialness = 1;\n\n\tbool empty;\n\tbool real_empty = true;\n\tnode_t *first;\n\tnode_t *real_first = NULL;\n\tnode_t *last;\n\tnode_t *real_last = NULL;\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tif (nodes[i].specialness >= specialness) {\n\t\t\treal_empty = false;\n\t\t\tif (real_first == NULL\n\t\t\t || node_cmp(&nodes[i], real_first) < 0) {\n\t\t\t\treal_first = &nodes[i];\n\t\t\t}\n\t\t\tif (real_last == NULL\n\t\t\t || node_cmp(&nodes[i], real_last) > 0) {\n\t\t\t\treal_last = &nodes[i];\n\t\t\t}\n\t\t}\n\t}\n\n\tempty = tree_empty_filtered(tree, &specialness_filter_node,\n\t &specialness_filter_subtree, &specialness);\n\texpect_b_eq(real_empty, empty, \"\");\n\n\tfirst = tree_first_filtered(tree, &specialness_filter_node,\n\t &specialness_filter_subtree, &specialness);\n\texpect_ptr_eq(real_first, first, \"\");\n\n\tlast = tree_last_filtered(tree, &specialness_filter_node,\n\t &specialness_filter_subtree, &specialness);\n\texpect_ptr_eq(real_last, last, \"\");\n\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tnode_t *next_filtered;\n\t\tnode_t *real_next_filtered = NULL;\n\t\tnode_t *prev_filtered;\n\t\tnode_t *real_prev_filtered = NULL;\n\t\tfor (int j = 0; j < nnodes; j++) {\n\t\t\tif (nodes[j].specialness < specialness) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (node_cmp(&nodes[j], &nodes[i]) < 0\n\t\t\t && (real_prev_filtered == NULL\n\t\t\t || node_cmp(&nodes[j], real_prev_filtered) > 0)) {\n\t\t\t\treal_prev_filtered = &nodes[j];\n\t\t\t}\n\t\t\tif (node_cmp(&nodes[j], &nodes[i]) > 0\n\t\t\t && (real_next_filtered == NULL\n\t\t\t || node_cmp(&nodes[j], real_next_filtered) < 0)) {\n\t\t\t\treal_next_filtered = &nodes[j];\n\t\t\t}\n\t\t}\n\t\tnext_filtered = tree_next_filtered(tree, &nodes[i],\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_next_filtered, next_filtered, \"\");\n\n\t\tprev_filtered = tree_prev_filtered(tree, &nodes[i],\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_prev_filtered, prev_filtered, \"\");\n\n\t\tnode_t *search_filtered;\n\t\tnode_t *real_search_filtered;\n\t\tnode_t *nsearch_filtered;\n\t\tnode_t *real_nsearch_filtered;\n\t\tnode_t *psearch_filtered;\n\t\tnode_t *real_psearch_filtered;\n\n\t\t/*\n\t\t * search, nsearch, psearch from a node before nodes[i] in the\n\t\t * ordering.\n\t\t */\n\t\tnode_t before;\n\t\tbefore.magic = NODE_MAGIC;\n\t\tbefore.key = nodes[i].key - 1;\n\t\tbefore.allow_duplicates = false;\n\t\treal_search_filtered = NULL;\n\t\tsearch_filtered = tree_search_filtered(tree, &before,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_search_filtered, search_filtered, \"\");\n\n\t\treal_nsearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_next_filtered);\n\t\tnsearch_filtered = tree_nsearch_filtered(tree, &before,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_nsearch_filtered, nsearch_filtered, \"\");\n\n\t\treal_psearch_filtered = real_prev_filtered;\n\t\tpsearch_filtered = tree_psearch_filtered(tree, &before,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_psearch_filtered, psearch_filtered, \"\");\n\n\t\t/* search, nsearch, psearch from nodes[i] */\n\t\treal_search_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : NULL);\n\t\tsearch_filtered = tree_search_filtered(tree, &nodes[i],\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_search_filtered, search_filtered, \"\");\n\n\t\treal_nsearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_next_filtered);\n\t\tnsearch_filtered = tree_nsearch_filtered(tree, &nodes[i],\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_nsearch_filtered, nsearch_filtered, \"\");\n\n\t\treal_psearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_prev_filtered);\n\t\tpsearch_filtered = tree_psearch_filtered(tree, &nodes[i],\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_psearch_filtered, psearch_filtered, \"\");\n\n\t\t/*\n\t\t * search, nsearch, psearch from a node equivalent to but\n\t\t * distinct from nodes[i].\n\t\t */\n\t\tnode_t equiv;\n\t\tequiv.magic = NODE_MAGIC;\n\t\tequiv.key = nodes[i].key;\n\t\tequiv.allow_duplicates = true;\n\t\treal_search_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : NULL);\n\t\tsearch_filtered = tree_search_filtered(tree, &equiv,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_search_filtered, search_filtered, \"\");\n\n\t\treal_nsearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_next_filtered);\n\t\tnsearch_filtered = tree_nsearch_filtered(tree, &equiv,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_nsearch_filtered, nsearch_filtered, \"\");\n\n\t\treal_psearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_prev_filtered);\n\t\tpsearch_filtered = tree_psearch_filtered(tree, &equiv,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_psearch_filtered, psearch_filtered, \"\");\n\n\t\t/*\n\t\t * search, nsearch, psearch from a node after nodes[i] in the\n\t\t * ordering.\n\t\t */\n\t\tnode_t after;\n\t\tafter.magic = NODE_MAGIC;\n\t\tafter.key = nodes[i].key + 1;\n\t\tafter.allow_duplicates = false;\n\t\treal_search_filtered = NULL;\n\t\tsearch_filtered = tree_search_filtered(tree, &after,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_search_filtered, search_filtered, \"\");\n\n\t\treal_nsearch_filtered = real_next_filtered;\n\t\tnsearch_filtered = tree_nsearch_filtered(tree, &after,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_nsearch_filtered, nsearch_filtered, \"\");\n\n\t\treal_psearch_filtered = (nodes[i].specialness >= specialness ?\n\t\t &nodes[i] : real_prev_filtered);\n\t\tpsearch_filtered = tree_psearch_filtered(tree, &after,\n\t\t &specialness_filter_node, &specialness_filter_subtree,\n\t\t &specialness);\n\t\texpect_ptr_eq(real_psearch_filtered, psearch_filtered, \"\");\n\t}\n\n\t/* Filtered iteration test setup. */\n\tint nspecial = 0;\n\tnode_t *sorted_nodes[UPDATE_TEST_MAX];\n\tnode_t *sorted_filtered_nodes[UPDATE_TEST_MAX];\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tsorted_nodes[i] = &nodes[i];\n\t}\n\tqsort(sorted_nodes, nnodes, sizeof(node_t *), &qsort_node_cmp);\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tsorted_nodes[i]->rank = i;\n\t\tsorted_nodes[i]->filtered_rank = nspecial;\n\t\tif (sorted_nodes[i]->specialness >= 1) {\n\t\t\tsorted_filtered_nodes[nspecial] = sorted_nodes[i];\n\t\t\tnspecial++;\n\t\t}\n\t}\n\n\tnode_t *iter_result;\n\n\titer_ctx_t ctx;\n\tctx.ncalls = 0;\n\tctx.last_node = NULL;\n\tctx.ncalls_max = INT_MAX;\n\tctx.forward = true;\n\n\t/* Filtered forward iteration from the beginning. */\n\titer_result = tree_iter_filtered(tree, NULL, &tree_iterate_filtered_cb,\n\t &ctx, &specialness_filter_node, &specialness_filter_subtree,\n\t &specialness);\n\texpect_ptr_null(iter_result, \"\");\n\texpect_d_eq(nspecial, ctx.ncalls, \"\");\n\t/* Filtered forward iteration from a starting point. */\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tctx.ncalls = 0;\n\t\tctx.last_node = NULL;\n\t\titer_result = tree_iter_filtered(tree, &nodes[i],\n\t\t &tree_iterate_filtered_cb, &ctx, &specialness_filter_node,\n\t\t &specialness_filter_subtree, &specialness);\n\t\texpect_ptr_null(iter_result, \"\");\n\t\texpect_d_eq(nspecial - nodes[i].filtered_rank, ctx.ncalls, \"\");\n\t}\n\t/* Filtered forward iteration from the beginning, with stopping */\n\tfor (int i = 0; i < nspecial; i++) {\n\t\tctx.ncalls = 0;\n\t\tctx.last_node = NULL;\n\t\tctx.ncalls_max = i + 1;\n\t\titer_result = tree_iter_filtered(tree, NULL,\n\t\t &tree_iterate_filtered_cb, &ctx, &specialness_filter_node,\n\t\t &specialness_filter_subtree, &specialness);\n\t\texpect_ptr_eq(sorted_filtered_nodes[i], iter_result, \"\");\n\t\texpect_d_eq(ctx.ncalls, i + 1, \"\");\n\t}\n\t/* Filtered forward iteration from a starting point, with stopping. */\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tfor (int j = 0; j < nspecial - nodes[i].filtered_rank; j++) {\n\t\t\tctx.ncalls = 0;\n\t\t\tctx.last_node = NULL;\n\t\t\tctx.ncalls_max = j + 1;\n\t\t\titer_result = tree_iter_filtered(tree, &nodes[i],\n\t\t\t &tree_iterate_filtered_cb, &ctx,\n\t\t\t &specialness_filter_node,\n\t\t\t &specialness_filter_subtree, &specialness);\n\t\t\texpect_d_eq(j + 1, ctx.ncalls, \"\");\n\t\t\texpect_ptr_eq(sorted_filtered_nodes[\n\t\t\t nodes[i].filtered_rank + j], iter_result, \"\");\n\t\t}\n\t}\n\n\t/* Backwards iteration. */\n\tctx.ncalls = 0;\n\tctx.last_node = NULL;\n\tctx.ncalls_max = INT_MAX;\n\tctx.forward = false;\n\n\t/* Filtered backward iteration from the end. */\n\titer_result = tree_reverse_iter_filtered(tree, NULL,\n\t &tree_iterate_filtered_cb, &ctx, &specialness_filter_node,\n\t &specialness_filter_subtree, &specialness);\n\texpect_ptr_null(iter_result, \"\");\n\texpect_d_eq(nspecial, ctx.ncalls, \"\");\n\t/* Filtered backward iteration from a starting point. */\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tctx.ncalls = 0;\n\t\tctx.last_node = NULL;\n\t\titer_result = tree_reverse_iter_filtered(tree, &nodes[i],\n\t\t &tree_iterate_filtered_cb, &ctx, &specialness_filter_node,\n\t\t &specialness_filter_subtree, &specialness);\n\t\texpect_ptr_null(iter_result, \"\");\n\t\tint surplus_rank = (nodes[i].specialness >= 1 ? 1 : 0);\n\t\texpect_d_eq(nodes[i].filtered_rank + surplus_rank, ctx.ncalls,\n\t\t \"\");\n\t}\n\t/* Filtered backward iteration from the end, with stopping */\n\tfor (int i = 0; i < nspecial; i++) {\n\t\tctx.ncalls = 0;\n\t\tctx.last_node = NULL;\n\t\tctx.ncalls_max = i + 1;\n\t\titer_result = tree_reverse_iter_filtered(tree, NULL,\n\t\t &tree_iterate_filtered_cb, &ctx, &specialness_filter_node,\n\t\t &specialness_filter_subtree, &specialness);\n\t\texpect_ptr_eq(sorted_filtered_nodes[nspecial - i - 1],\n\t\t iter_result, \"\");\n\t\texpect_d_eq(ctx.ncalls, i + 1, \"\");\n\t}\n\t/* Filtered backward iteration from a starting point, with stopping. */\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tint surplus_rank = (nodes[i].specialness >= 1 ? 1 : 0);\n\t\tfor (int j = 0; j < nodes[i].filtered_rank + surplus_rank;\n\t\t j++) {\n\t\t\tctx.ncalls = 0;\n\t\t\tctx.last_node = NULL;\n\t\t\tctx.ncalls_max = j + 1;\n\t\t\titer_result = tree_reverse_iter_filtered(tree,\n\t\t\t &nodes[i], &tree_iterate_filtered_cb, &ctx,\n\t\t\t &specialness_filter_node,\n\t\t\t &specialness_filter_subtree, &specialness);\n\t\t\texpect_d_eq(j + 1, ctx.ncalls, \"\");\n\t\t\texpect_ptr_eq(sorted_filtered_nodes[\n\t\t\t nodes[i].filtered_rank - j - 1 + surplus_rank],\n\t\t\t iter_result, \"\");\n\t\t}\n\t}\n}\n\nstatic void\ndo_update_search_test(int nnodes, int ntrees, int nremovals,\n int nupdates) {\n\tnode_t nodes[UPDATE_TEST_MAX];\n\tassert(nnodes <= UPDATE_TEST_MAX);\n\n\tsfmt_t *sfmt = init_gen_rand(12345);\n\tfor (int i = 0; i < ntrees; i++) {\n\t\ttree_t tree;\n\t\ttree_new(&tree);\n\t\tfor (int j = 0; j < nnodes; j++) {\n\t\t\tnodes[j].magic = NODE_MAGIC;\n\t\t\t/*\n\t\t\t * In consistency checking, we increment or decrement a\n\t\t\t * key and assume that the result is not a key in the\n\t\t\t * tree. This isn't a *real* concern with 64-bit keys\n\t\t\t * and a good PRNG, but why not be correct anyways?\n\t\t\t */\n\t\t\tnodes[j].key = 2 * gen_rand64(sfmt);\n\t\t\tnodes[j].specialness = 0;\n\t\t\tnodes[j].mid_remove = false;\n\t\t\tnodes[j].allow_duplicates = false;\n\t\t\tnodes[j].summary_lchild = NULL;\n\t\t\tnodes[j].summary_rchild = NULL;\n\t\t\tnodes[j].summary_max_specialness = 0;\n\t\t\ttree_insert(&tree, &nodes[j]);\n\t\t}\n\t\tfor (int j = 0; j < nremovals; j++) {\n\t\t\tint victim = (int)gen_rand64_range(sfmt, nnodes);\n\t\t\tif (!nodes[victim].mid_remove) {\n\t\t\t\ttree_remove(&tree, &nodes[victim]);\n\t\t\t\tnodes[victim].mid_remove = true;\n\t\t\t}\n\t\t}\n\t\tfor (int j = 0; j < nnodes; j++) {\n\t\t\tif (nodes[j].mid_remove) {\n\t\t\t\tnodes[j].mid_remove = false;\n\t\t\t\tnodes[j].key = 2 * gen_rand64(sfmt);\n\t\t\t\ttree_insert(&tree, &nodes[j]);\n\t\t\t}\n\t\t}\n\t\tfor (int j = 0; j < nupdates; j++) {\n\t\t\tuint32_t ind = gen_rand32_range(sfmt, nnodes);\n\t\t\tnodes[ind].specialness = 1 - nodes[ind].specialness;\n\t\t\ttree_update_summaries(&tree, &nodes[ind]);\n\t\t\tcheck_consistency(&tree, nodes, nnodes);\n\t\t}\n\t}\n}\n\nTEST_BEGIN(test_rb_update_search) {\n\tsummarize_always_returns_true = false;\n\tdo_update_search_test(2, 100, 3, 50);\n\tdo_update_search_test(5, 100, 3, 50);\n\tdo_update_search_test(12, 100, 5, 1000);\n\tdo_update_search_test(100, 1, 50, 500);\n}\nTEST_END\n\ntypedef rb_tree(node_t) unsummarized_tree_t;\nrb_gen(static UNUSED, unsummarized_tree_, unsummarized_tree_t, node_t, link,\n node_cmp);\n\nstatic node_t *\nunsummarized_tree_iterate_cb(unsummarized_tree_t *tree, node_t *node,\n void *data) {\n\tunsigned *i = (unsigned *)data;\n\t(*i)++;\n\treturn NULL;\n}\n/*\n * The unsummarized and summarized funtionality is implemented via the same\n * functions; we don't really need to do much more than test that we can exclude\n * the filtered functionality without anything breaking.\n */\nTEST_BEGIN(test_rb_unsummarized) {\n\tunsummarized_tree_t tree;\n\tunsummarized_tree_new(&tree);\n\tunsigned nnodes = 0;\n\tunsummarized_tree_iter(&tree, NULL, &unsummarized_tree_iterate_cb,\n\t &nnodes);\n\texpect_u_eq(0, nnodes, \"\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_rb_empty,\n\t test_rb_random,\n\t test_rb_filter_simple,\n\t test_rb_update_search,\n\t test_rb_unsummarized);\n}\n" }, { "path": "deps/jemalloc/test/unit/retained.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/spin.h\"\n\nstatic unsigned\t\tarena_ind;\nstatic size_t\t\tsz;\nstatic size_t\t\tesz;\n#define NEPOCHS\t\t8\n#define PER_THD_NALLOCS\t1\nstatic atomic_u_t\tepoch;\nstatic atomic_u_t\tnfinished;\n\nstatic unsigned\ndo_arena_create(extent_hooks_t *h) {\n\tunsigned new_arena_ind;\n\tsize_t ind_sz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&new_arena_ind, &ind_sz,\n\t (void *)(h != NULL ? &h : NULL), (h != NULL ? sizeof(h) : 0)), 0,\n\t \"Unexpected mallctl() failure\");\n\treturn new_arena_ind;\n}\n\nstatic void\ndo_arena_destroy(unsigned ind) {\n\tsize_t mib[3];\n\tsize_t miblen;\n\n\tmiblen = sizeof(mib)/sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arena.0.destroy\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() failure\");\n\tmib[1] = (size_t)ind;\n\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctlbymib() failure\");\n}\n\nstatic void\ndo_refresh(void) {\n\tuint64_t refresh_epoch = 1;\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&refresh_epoch,\n\t sizeof(refresh_epoch)), 0, \"Unexpected mallctl() failure\");\n}\n\nstatic size_t\ndo_get_size_impl(const char *cmd, unsigned ind) {\n\tsize_t mib[4];\n\tsize_t miblen = sizeof(mib) / sizeof(size_t);\n\tsize_t z = sizeof(size_t);\n\n\texpect_d_eq(mallctlnametomib(cmd, mib, &miblen),\n\t 0, \"Unexpected mallctlnametomib(\\\"%s\\\", ...) failure\", cmd);\n\tmib[2] = ind;\n\tsize_t size;\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&size, &z, NULL, 0),\n\t 0, \"Unexpected mallctlbymib([\\\"%s\\\"], ...) failure\", cmd);\n\n\treturn size;\n}\n\nstatic size_t\ndo_get_active(unsigned ind) {\n\treturn do_get_size_impl(\"stats.arenas.0.pactive\", ind) * PAGE;\n}\n\nstatic size_t\ndo_get_mapped(unsigned ind) {\n\treturn do_get_size_impl(\"stats.arenas.0.mapped\", ind);\n}\n\nstatic void *\nthd_start(void *arg) {\n\tfor (unsigned next_epoch = 1; next_epoch < NEPOCHS; next_epoch++) {\n\t\t/* Busy-wait for next epoch. */\n\t\tunsigned cur_epoch;\n\t\tspin_t spinner = SPIN_INITIALIZER;\n\t\twhile ((cur_epoch = atomic_load_u(&epoch, ATOMIC_ACQUIRE)) !=\n\t\t next_epoch) {\n\t\t\tspin_adaptive(&spinner);\n\t\t}\n\t\texpect_u_eq(cur_epoch, next_epoch, \"Unexpected epoch\");\n\n\t\t/*\n\t\t * Allocate. The main thread will reset the arena, so there's\n\t\t * no need to deallocate.\n\t\t */\n\t\tfor (unsigned i = 0; i < PER_THD_NALLOCS; i++) {\n\t\t\tvoid *p = mallocx(sz, MALLOCX_ARENA(arena_ind) |\n\t\t\t MALLOCX_TCACHE_NONE\n\t\t\t );\n\t\t\texpect_ptr_not_null(p,\n\t\t\t \"Unexpected mallocx() failure\\n\");\n\t\t}\n\n\t\t/* Let the main thread know we've finished this iteration. */\n\t\tatomic_fetch_add_u(&nfinished, 1, ATOMIC_RELEASE);\n\t}\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_retained) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(opt_hpa);\n\n\tarena_ind = do_arena_create(NULL);\n\tsz = nallocx(HUGEPAGE, 0);\n\tsize_t guard_sz = san_guard_enabled() ? SAN_PAGE_GUARDS_SIZE : 0;\n\tesz = sz + sz_large_pad + guard_sz;\n\n\tatomic_store_u(&epoch, 0, ATOMIC_RELAXED);\n\n\tunsigned nthreads = ncpus * 2;\n\tif (LG_SIZEOF_PTR < 3 && nthreads > 16) {\n\t\tnthreads = 16; /* 32-bit platform could run out of vaddr. */\n\t}\n\tVARIABLE_ARRAY(thd_t, threads, nthreads);\n\tfor (unsigned i = 0; i < nthreads; i++) {\n\t\tthd_create(&threads[i], thd_start, NULL);\n\t}\n\n\tfor (unsigned e = 1; e < NEPOCHS; e++) {\n\t\tatomic_store_u(&nfinished, 0, ATOMIC_RELEASE);\n\t\tatomic_store_u(&epoch, e, ATOMIC_RELEASE);\n\n\t\t/* Wait for threads to finish allocating. */\n\t\tspin_t spinner = SPIN_INITIALIZER;\n\t\twhile (atomic_load_u(&nfinished, ATOMIC_ACQUIRE) < nthreads) {\n\t\t\tspin_adaptive(&spinner);\n\t\t}\n\n\t\t/*\n\t\t * Assert that retained is no more than the sum of size classes\n\t\t * that should have been used to satisfy the worker threads'\n\t\t * requests, discounting per growth fragmentation.\n\t\t */\n\t\tdo_refresh();\n\n\t\tsize_t allocated = (esz - guard_sz) * nthreads *\n\t\t PER_THD_NALLOCS;\n\t\tsize_t active = do_get_active(arena_ind);\n\t\texpect_zu_le(allocated, active, \"Unexpected active memory\");\n\t\tsize_t mapped = do_get_mapped(arena_ind);\n\t\texpect_zu_le(active, mapped, \"Unexpected mapped memory\");\n\n\t\tarena_t *arena = arena_get(tsdn_fetch(), arena_ind, false);\n\t\tsize_t usable = 0;\n\t\tsize_t fragmented = 0;\n\t\tfor (pszind_t pind = sz_psz2ind(HUGEPAGE); pind <\n\t\t arena->pa_shard.pac.exp_grow.next; pind++) {\n\t\t\tsize_t psz = sz_pind2sz(pind);\n\t\t\tsize_t psz_fragmented = psz % esz;\n\t\t\tsize_t psz_usable = psz - psz_fragmented;\n\t\t\t/*\n\t\t\t * Only consider size classes that wouldn't be skipped.\n\t\t\t */\n\t\t\tif (psz_usable > 0) {\n\t\t\t\texpect_zu_lt(usable, allocated,\n\t\t\t\t \"Excessive retained memory \"\n\t\t\t\t \"(%#zx[+%#zx] > %#zx)\", usable, psz_usable,\n\t\t\t\t allocated);\n\t\t\t\tfragmented += psz_fragmented;\n\t\t\t\tusable += psz_usable;\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * Clean up arena. Destroying and recreating the arena\n\t\t * is simpler that specifying extent hooks that deallocate\n\t\t * (rather than retaining) during reset.\n\t\t */\n\t\tdo_arena_destroy(arena_ind);\n\t\texpect_u_eq(do_arena_create(NULL), arena_ind,\n\t\t \"Unexpected arena index\");\n\t}\n\n\tfor (unsigned i = 0; i < nthreads; i++) {\n\t\tthd_join(threads[i], NULL);\n\t}\n\n\tdo_arena_destroy(arena_ind);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_retained);\n}\n" }, { "path": "deps/jemalloc/test/unit/rtree.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/rtree.h\"\n\n#define INVALID_ARENA_IND ((1U << MALLOCX_ARENA_BITS) - 1)\n\n/* Potentially too large to safely place on the stack. */\nrtree_t test_rtree;\n\nTEST_BEGIN(test_rtree_read_empty) {\n\ttsdn_t *tsdn;\n\n\ttsdn = tsdn_fetch();\n\n\tbase_t *base = base_new(tsdn, 0, &ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new failure\");\n\n\trtree_t *rtree = &test_rtree;\n\trtree_ctx_t rtree_ctx;\n\trtree_ctx_data_init(&rtree_ctx);\n\texpect_false(rtree_new(rtree, base, false),\n\t \"Unexpected rtree_new() failure\");\n\trtree_contents_t contents;\n\texpect_true(rtree_read_independent(tsdn, rtree, &rtree_ctx, PAGE,\n\t &contents), \"rtree_read_independent() should fail on empty rtree.\");\n\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\n#undef NTHREADS\n#undef NITERS\n#undef SEED\n\nstatic edata_t *\nalloc_edata(void) {\n\tvoid *ret = mallocx(sizeof(edata_t), MALLOCX_ALIGN(EDATA_ALIGNMENT));\n\tassert_ptr_not_null(ret, \"Unexpected mallocx() failure\");\n\n\treturn ret;\n}\n\nTEST_BEGIN(test_rtree_extrema) {\n\tedata_t *edata_a, *edata_b;\n\tedata_a = alloc_edata();\n\tedata_b = alloc_edata();\n\tedata_init(edata_a, INVALID_ARENA_IND, NULL, SC_LARGE_MINCLASS,\n\t false, sz_size2index(SC_LARGE_MINCLASS), 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\tedata_init(edata_b, INVALID_ARENA_IND, NULL, 0, false, SC_NSIZES, 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\n\ttsdn_t *tsdn = tsdn_fetch();\n\n\tbase_t *base = base_new(tsdn, 0, &ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new failure\");\n\n\trtree_t *rtree = &test_rtree;\n\trtree_ctx_t rtree_ctx;\n\trtree_ctx_data_init(&rtree_ctx);\n\texpect_false(rtree_new(rtree, base, false),\n\t \"Unexpected rtree_new() failure\");\n\n\trtree_contents_t contents_a;\n\tcontents_a.edata = edata_a;\n\tcontents_a.metadata.szind = edata_szind_get(edata_a);\n\tcontents_a.metadata.slab = edata_slab_get(edata_a);\n\tcontents_a.metadata.is_head = edata_is_head_get(edata_a);\n\tcontents_a.metadata.state = edata_state_get(edata_a);\n\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, PAGE, contents_a),\n\t \"Unexpected rtree_write() failure\");\n\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, PAGE, contents_a),\n\t \"Unexpected rtree_write() failure\");\n\trtree_contents_t read_contents_a = rtree_read(tsdn, rtree, &rtree_ctx,\n\t PAGE);\n\texpect_true(contents_a.edata == read_contents_a.edata\n\t && contents_a.metadata.szind == read_contents_a.metadata.szind\n\t && contents_a.metadata.slab == read_contents_a.metadata.slab\n\t && contents_a.metadata.is_head == read_contents_a.metadata.is_head\n\t && contents_a.metadata.state == read_contents_a.metadata.state,\n\t \"rtree_read() should return previously set value\");\n\n\trtree_contents_t contents_b;\n\tcontents_b.edata = edata_b;\n\tcontents_b.metadata.szind = edata_szind_get_maybe_invalid(edata_b);\n\tcontents_b.metadata.slab = edata_slab_get(edata_b);\n\tcontents_b.metadata.is_head = edata_is_head_get(edata_b);\n\tcontents_b.metadata.state = edata_state_get(edata_b);\n\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, ~((uintptr_t)0),\n\t contents_b), \"Unexpected rtree_write() failure\");\n\trtree_contents_t read_contents_b = rtree_read(tsdn, rtree, &rtree_ctx,\n\t ~((uintptr_t)0));\n\tassert_true(contents_b.edata == read_contents_b.edata\n\t && contents_b.metadata.szind == read_contents_b.metadata.szind\n\t && contents_b.metadata.slab == read_contents_b.metadata.slab\n\t && contents_b.metadata.is_head == read_contents_b.metadata.is_head\n\t && contents_b.metadata.state == read_contents_b.metadata.state,\n\t \"rtree_read() should return previously set value\");\n\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\nTEST_BEGIN(test_rtree_bits) {\n\ttsdn_t *tsdn = tsdn_fetch();\n\tbase_t *base = base_new(tsdn, 0, &ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new failure\");\n\n\tuintptr_t keys[] = {PAGE, PAGE + 1,\n\t PAGE + (((uintptr_t)1) << LG_PAGE) - 1};\n\tedata_t *edata_c = alloc_edata();\n\tedata_init(edata_c, INVALID_ARENA_IND, NULL, 0, false, SC_NSIZES, 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\n\trtree_t *rtree = &test_rtree;\n\trtree_ctx_t rtree_ctx;\n\trtree_ctx_data_init(&rtree_ctx);\n\texpect_false(rtree_new(rtree, base, false),\n\t \"Unexpected rtree_new() failure\");\n\n\tfor (unsigned i = 0; i < sizeof(keys)/sizeof(uintptr_t); i++) {\n\t\trtree_contents_t contents;\n\t\tcontents.edata = edata_c;\n\t\tcontents.metadata.szind = SC_NSIZES;\n\t\tcontents.metadata.slab = false;\n\t\tcontents.metadata.is_head = false;\n\t\tcontents.metadata.state = extent_state_active;\n\n\t\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, keys[i],\n\t\t contents), \"Unexpected rtree_write() failure\");\n\t\tfor (unsigned j = 0; j < sizeof(keys)/sizeof(uintptr_t); j++) {\n\t\t\texpect_ptr_eq(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t\t keys[j]).edata, edata_c,\n\t\t\t \"rtree_edata_read() should return previously set \"\n\t\t\t \"value and ignore insignificant key bits; i=%u, \"\n\t\t\t \"j=%u, set key=%#\"FMTxPTR\", get key=%#\"FMTxPTR, i,\n\t\t\t j, keys[i], keys[j]);\n\t\t}\n\t\texpect_ptr_null(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t (((uintptr_t)2) << LG_PAGE)).edata,\n\t\t \"Only leftmost rtree leaf should be set; i=%u\", i);\n\t\trtree_clear(tsdn, rtree, &rtree_ctx, keys[i]);\n\t}\n\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\nTEST_BEGIN(test_rtree_random) {\n#define NSET 16\n#define SEED 42\n\tsfmt_t *sfmt = init_gen_rand(SEED);\n\ttsdn_t *tsdn = tsdn_fetch();\n\n\tbase_t *base = base_new(tsdn, 0, &ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new failure\");\n\n\tuintptr_t keys[NSET];\n\trtree_t *rtree = &test_rtree;\n\trtree_ctx_t rtree_ctx;\n\trtree_ctx_data_init(&rtree_ctx);\n\n\tedata_t *edata_d = alloc_edata();\n\tedata_init(edata_d, INVALID_ARENA_IND, NULL, 0, false, SC_NSIZES, 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\n\texpect_false(rtree_new(rtree, base, false),\n\t \"Unexpected rtree_new() failure\");\n\n\tfor (unsigned i = 0; i < NSET; i++) {\n\t\tkeys[i] = (uintptr_t)gen_rand64(sfmt);\n\t\trtree_leaf_elm_t *elm = rtree_leaf_elm_lookup(tsdn, rtree,\n\t\t &rtree_ctx, keys[i], false, true);\n\t\texpect_ptr_not_null(elm,\n\t\t \"Unexpected rtree_leaf_elm_lookup() failure\");\n\t\trtree_contents_t contents;\n\t\tcontents.edata = edata_d;\n\t\tcontents.metadata.szind = SC_NSIZES;\n\t\tcontents.metadata.slab = false;\n\t\tcontents.metadata.is_head = false;\n\t\tcontents.metadata.state = edata_state_get(edata_d);\n\t\trtree_leaf_elm_write(tsdn, rtree, elm, contents);\n\t\texpect_ptr_eq(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t keys[i]).edata, edata_d,\n\t\t \"rtree_edata_read() should return previously set value\");\n\t}\n\tfor (unsigned i = 0; i < NSET; i++) {\n\t\texpect_ptr_eq(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t keys[i]).edata, edata_d,\n\t\t \"rtree_edata_read() should return previously set value, \"\n\t\t \"i=%u\", i);\n\t}\n\n\tfor (unsigned i = 0; i < NSET; i++) {\n\t\trtree_clear(tsdn, rtree, &rtree_ctx, keys[i]);\n\t\texpect_ptr_null(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t keys[i]).edata,\n\t\t \"rtree_edata_read() should return previously set value\");\n\t}\n\tfor (unsigned i = 0; i < NSET; i++) {\n\t\texpect_ptr_null(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t keys[i]).edata,\n\t\t \"rtree_edata_read() should return previously set value\");\n\t}\n\n\tbase_delete(tsdn, base);\n\tfini_gen_rand(sfmt);\n#undef NSET\n#undef SEED\n}\nTEST_END\n\nstatic void\ntest_rtree_range_write(tsdn_t *tsdn, rtree_t *rtree, uintptr_t start,\n uintptr_t end) {\n\trtree_ctx_t rtree_ctx;\n\trtree_ctx_data_init(&rtree_ctx);\n\n\tedata_t *edata_e = alloc_edata();\n\tedata_init(edata_e, INVALID_ARENA_IND, NULL, 0, false, SC_NSIZES, 0,\n\t extent_state_active, false, false, EXTENT_PAI_PAC, EXTENT_NOT_HEAD);\n\trtree_contents_t contents;\n\tcontents.edata = edata_e;\n\tcontents.metadata.szind = SC_NSIZES;\n\tcontents.metadata.slab = false;\n\tcontents.metadata.is_head = false;\n\tcontents.metadata.state = extent_state_active;\n\n\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, start,\n\t contents), \"Unexpected rtree_write() failure\");\n\texpect_false(rtree_write(tsdn, rtree, &rtree_ctx, end,\n\t contents), \"Unexpected rtree_write() failure\");\n\n\trtree_write_range(tsdn, rtree, &rtree_ctx, start, end, contents);\n\tfor (uintptr_t i = 0; i < ((end - start) >> LG_PAGE); i++) {\n\t\texpect_ptr_eq(rtree_read(tsdn, rtree, &rtree_ctx,\n\t\t start + (i << LG_PAGE)).edata, edata_e,\n\t\t \"rtree_edata_read() should return previously set value\");\n\t}\n\trtree_clear_range(tsdn, rtree, &rtree_ctx, start, end);\n\trtree_leaf_elm_t *elm;\n\tfor (uintptr_t i = 0; i < ((end - start) >> LG_PAGE); i++) {\n\t\telm = rtree_leaf_elm_lookup(tsdn, rtree, &rtree_ctx,\n\t\t start + (i << LG_PAGE), false, false);\n\t\texpect_ptr_not_null(elm, \"Should have been initialized.\");\n\t\texpect_ptr_null(rtree_leaf_elm_read(tsdn, rtree, elm,\n\t\t false).edata, \"Should have been cleared.\");\n\t}\n}\n\nTEST_BEGIN(test_rtree_range) {\n\ttsdn_t *tsdn = tsdn_fetch();\n\tbase_t *base = base_new(tsdn, 0, &ehooks_default_extent_hooks,\n\t /* metadata_use_hooks */ true);\n\texpect_ptr_not_null(base, \"Unexpected base_new failure\");\n\n\trtree_t *rtree = &test_rtree;\n\texpect_false(rtree_new(rtree, base, false),\n\t \"Unexpected rtree_new() failure\");\n\n\t/* Not crossing rtree node boundary first. */\n\tuintptr_t start = ZU(1) << rtree_leaf_maskbits();\n\tuintptr_t end = start + (ZU(100) << LG_PAGE);\n\ttest_rtree_range_write(tsdn, rtree, start, end);\n\n\t/* Crossing rtree node boundary. */\n\tstart = (ZU(1) << rtree_leaf_maskbits()) - (ZU(10) << LG_PAGE);\n\tend = start + (ZU(100) << LG_PAGE);\n\tassert_ptr_ne((void *)rtree_leafkey(start), (void *)rtree_leafkey(end),\n\t \"The range should span across two rtree nodes\");\n\ttest_rtree_range_write(tsdn, rtree, start, end);\n\n\tbase_delete(tsdn, base);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_rtree_read_empty,\n\t test_rtree_extrema,\n\t test_rtree_bits,\n\t test_rtree_random,\n\t test_rtree_range);\n}\n" }, { "path": "deps/jemalloc/test/unit/safety_check.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/safety_check.h\"\n\n/*\n * Note that we get called through safety_check.sh, which turns on sampling for\n * everything.\n */\n\nbool fake_abort_called;\nvoid fake_abort(const char *message) {\n\t(void)message;\n\tfake_abort_called = true;\n}\n\nstatic void\nbuffer_overflow_write(char *ptr, size_t size) {\n\t/* Avoid overflow warnings. */\n\tvolatile size_t idx = size;\n\tptr[idx] = 0;\n}\n\nTEST_BEGIN(test_malloc_free_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = malloc(128);\n\tbuffer_overflow_write(ptr, 128);\n\tfree(ptr);\n\tsafety_check_set_abort(NULL);\n\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n}\nTEST_END\n\nTEST_BEGIN(test_mallocx_dallocx_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = mallocx(128, 0);\n\tbuffer_overflow_write(ptr, 128);\n\tdallocx(ptr, 0);\n\tsafety_check_set_abort(NULL);\n\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n}\nTEST_END\n\nTEST_BEGIN(test_malloc_sdallocx_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = malloc(128);\n\tbuffer_overflow_write(ptr, 128);\n\tsdallocx(ptr, 128, 0);\n\tsafety_check_set_abort(NULL);\n\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n}\nTEST_END\n\nTEST_BEGIN(test_realloc_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = malloc(128);\n\tbuffer_overflow_write(ptr, 128);\n\tptr = realloc(ptr, 129);\n\tsafety_check_set_abort(NULL);\n\tfree(ptr);\n\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n}\nTEST_END\n\nTEST_BEGIN(test_rallocx_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = malloc(128);\n\tbuffer_overflow_write(ptr, 128);\n\tptr = rallocx(ptr, 129, 0);\n\tsafety_check_set_abort(NULL);\n\tfree(ptr);\n\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n}\nTEST_END\n\nTEST_BEGIN(test_xallocx_overflow) {\n\ttest_skip_if(!config_prof);\n\ttest_skip_if(!config_opt_safety_checks);\n\n\tsafety_check_set_abort(&fake_abort);\n\t/* Buffer overflow! */\n\tchar* ptr = malloc(128);\n\tbuffer_overflow_write(ptr, 128);\n\tsize_t result = xallocx(ptr, 129, 0, 0);\n\texpect_zu_eq(result, 128, \"\");\n\tfree(ptr);\n\texpect_b_eq(fake_abort_called, true, \"Redzone check didn't fire.\");\n\tfake_abort_called = false;\n\tsafety_check_set_abort(NULL);\n}\nTEST_END\n\nTEST_BEGIN(test_realloc_no_overflow) {\n\tchar* ptr = malloc(128);\n\tptr = realloc(ptr, 256);\n\tptr[128] = 0;\n\tptr[255] = 0;\n\tfree(ptr);\n\n\tptr = malloc(128);\n\tptr = realloc(ptr, 64);\n\tptr[63] = 0;\n\tptr[0] = 0;\n\tfree(ptr);\n}\nTEST_END\n\nTEST_BEGIN(test_rallocx_no_overflow) {\n\tchar* ptr = malloc(128);\n\tptr = rallocx(ptr, 256, 0);\n\tptr[128] = 0;\n\tptr[255] = 0;\n\tfree(ptr);\n\n\tptr = malloc(128);\n\tptr = rallocx(ptr, 64, 0);\n\tptr[63] = 0;\n\tptr[0] = 0;\n\tfree(ptr);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_malloc_free_overflow,\n\t test_mallocx_dallocx_overflow,\n\t test_malloc_sdallocx_overflow,\n\t test_realloc_overflow,\n\t test_rallocx_overflow,\n\t test_xallocx_overflow,\n\t test_realloc_no_overflow,\n\t test_rallocx_no_overflow);\n}\n" }, { "path": "deps/jemalloc/test/unit/safety_check.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,prof_active:true,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/san.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/arena_util.h\"\n#include \"test/san.h\"\n\n#include \"jemalloc/internal/san.h\"\n\nstatic void\nverify_extent_guarded(tsdn_t *tsdn, void *ptr) {\n\texpect_true(extent_is_guarded(tsdn, ptr),\n\t \"All extents should be guarded.\");\n}\n\n#define MAX_SMALL_ALLOCATIONS 4096\nvoid *small_alloc[MAX_SMALL_ALLOCATIONS];\n\n/*\n * This test allocates page sized slabs and checks that every two slabs have\n * at least one page in between them. That page is supposed to be the guard\n * page.\n */\nTEST_BEGIN(test_guarded_small) {\n\ttest_skip_if(opt_prof);\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tunsigned npages = 16, pages_found = 0, ends_found = 0;\n\tVARIABLE_ARRAY(uintptr_t, pages, npages);\n\n\t/* Allocate to get sanitized pointers. */\n\tsize_t slab_sz = PAGE;\n\tsize_t sz = slab_sz / 8;\n\tunsigned n_alloc = 0;\n\twhile (n_alloc < MAX_SMALL_ALLOCATIONS) {\n\t\tvoid *ptr = malloc(sz);\n\t\texpect_ptr_not_null(ptr, \"Unexpected malloc() failure\");\n\t\tsmall_alloc[n_alloc] = ptr;\n\t\tverify_extent_guarded(tsdn, ptr);\n\t\tif ((uintptr_t)ptr % PAGE == 0) {\n\t\t\tassert_u_lt(pages_found, npages,\n\t\t\t \"Unexpectedly large number of page aligned allocs\");\n\t\t\tpages[pages_found++] = (uintptr_t)ptr;\n\t\t}\n\t\tif (((uintptr_t)ptr + (uintptr_t)sz) % PAGE == 0) {\n\t\t\tends_found++;\n\t\t}\n\t\tn_alloc++;\n\t\tif (pages_found == npages && ends_found == npages) {\n\t\t\tbreak;\n\t\t}\n\t}\n\t/* Should found the ptrs being checked for overflow and underflow. */\n\texpect_u_eq(pages_found, npages, \"Could not found the expected pages.\");\n\texpect_u_eq(ends_found, npages, \"Could not found the expected pages.\");\n\n\t/* Verify the pages are not continuous, i.e. separated by guards. */\n\tfor (unsigned i = 0; i < npages - 1; i++) {\n\t\tfor (unsigned j = i + 1; j < npages; j++) {\n\t\t\tuintptr_t ptr_diff = pages[i] > pages[j] ?\n\t\t\t pages[i] - pages[j] : pages[j] - pages[i];\n\t\t\texpect_zu_ge((size_t)ptr_diff, slab_sz + PAGE,\n\t\t\t \"There should be at least one pages between \"\n\t\t\t \"guarded slabs\");\n\t\t}\n\t}\n\n\tfor (unsigned i = 0; i < n_alloc + 1; i++) {\n\t\tfree(small_alloc[i]);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_guarded_large) {\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tunsigned nlarge = 32;\n\tVARIABLE_ARRAY(uintptr_t, large, nlarge);\n\n\t/* Allocate to get sanitized pointers. */\n\tsize_t large_sz = SC_LARGE_MINCLASS;\n\tfor (unsigned i = 0; i < nlarge; i++) {\n\t\tvoid *ptr = malloc(large_sz);\n\t\tverify_extent_guarded(tsdn, ptr);\n\t\texpect_ptr_not_null(ptr, \"Unexpected malloc() failure\");\n\t\tlarge[i] = (uintptr_t)ptr;\n\t}\n\n\t/* Verify the pages are not continuous, i.e. separated by guards. */\n\tfor (unsigned i = 0; i < nlarge; i++) {\n\t\tfor (unsigned j = i + 1; j < nlarge; j++) {\n\t\t\tuintptr_t ptr_diff = large[i] > large[j] ?\n\t\t\t large[i] - large[j] : large[j] - large[i];\n\t\t\texpect_zu_ge((size_t)ptr_diff, large_sz + 2 * PAGE,\n\t\t\t \"There should be at least two pages between \"\n\t\t\t \" guarded large allocations\");\n\t\t}\n\t}\n\n\tfor (unsigned i = 0; i < nlarge; i++) {\n\t\tfree((void *)large[i]);\n\t}\n}\nTEST_END\n\nstatic void\nverify_pdirty(unsigned arena_ind, uint64_t expected) {\n\tuint64_t pdirty = get_arena_pdirty(arena_ind);\n\texpect_u64_eq(pdirty, expected / PAGE,\n\t \"Unexpected dirty page amount.\");\n}\n\nstatic void\nverify_pmuzzy(unsigned arena_ind, uint64_t expected) {\n\tuint64_t pmuzzy = get_arena_pmuzzy(arena_ind);\n\texpect_u64_eq(pmuzzy, expected / PAGE,\n\t \"Unexpected muzzy page amount.\");\n}\n\nTEST_BEGIN(test_guarded_decay) {\n\tunsigned arena_ind = do_arena_create(-1, -1);\n\tdo_decay(arena_ind);\n\tdo_purge(arena_ind);\n\n\tverify_pdirty(arena_ind, 0);\n\tverify_pmuzzy(arena_ind, 0);\n\n\t/* Verify that guarded extents as dirty. */\n\tsize_t sz1 = PAGE, sz2 = PAGE * 2;\n\t/* W/o maps_coalesce, guarded extents are unguarded eagerly. */\n\tsize_t add_guard_size = maps_coalesce ? 0 : SAN_PAGE_GUARDS_SIZE;\n\tgenerate_dirty(arena_ind, sz1);\n\tverify_pdirty(arena_ind, sz1 + add_guard_size);\n\tverify_pmuzzy(arena_ind, 0);\n\n\t/* Should reuse the first extent. */\n\tgenerate_dirty(arena_ind, sz1);\n\tverify_pdirty(arena_ind, sz1 + add_guard_size);\n\tverify_pmuzzy(arena_ind, 0);\n\n\t/* Should not reuse; expect new dirty pages. */\n\tgenerate_dirty(arena_ind, sz2);\n\tverify_pdirty(arena_ind, sz1 + sz2 + 2 * add_guard_size);\n\tverify_pmuzzy(arena_ind, 0);\n\n\ttsdn_t *tsdn = tsd_tsdn(tsd_fetch());\n\tint flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\n\t/* Should reuse dirty extents for the two mallocx. */\n\tvoid *p1 = do_mallocx(sz1, flags);\n\tverify_extent_guarded(tsdn, p1);\n\tverify_pdirty(arena_ind, sz2 + add_guard_size);\n\n\tvoid *p2 = do_mallocx(sz2, flags);\n\tverify_extent_guarded(tsdn, p2);\n\tverify_pdirty(arena_ind, 0);\n\tverify_pmuzzy(arena_ind, 0);\n\n\tdallocx(p1, flags);\n\tverify_pdirty(arena_ind, sz1 + add_guard_size);\n\tdallocx(p2, flags);\n\tverify_pdirty(arena_ind, sz1 + sz2 + 2 * add_guard_size);\n\tverify_pmuzzy(arena_ind, 0);\n\n\tdo_purge(arena_ind);\n\tverify_pdirty(arena_ind, 0);\n\tverify_pmuzzy(arena_ind, 0);\n\n\tif (config_stats) {\n\t\texpect_u64_eq(get_arena_npurge(arena_ind), 1,\n\t\t \"Expected purging to occur\");\n\t\texpect_u64_eq(get_arena_dirty_npurge(arena_ind), 1,\n\t\t \"Expected purging to occur\");\n\t\texpect_u64_eq(get_arena_dirty_purged(arena_ind),\n\t\t (sz1 + sz2 + 2 * add_guard_size) / PAGE,\n\t\t \"Expected purging to occur\");\n\t\texpect_u64_eq(get_arena_muzzy_npurge(arena_ind), 0,\n\t\t \"Expected purging to occur\");\n\t}\n\n\tif (opt_retain) {\n\t\t/*\n\t\t * With retain, guarded extents are not mergable and will be\n\t\t * cached in ecache_retained. They should be reused.\n\t\t */\n\t\tvoid *new_p1 = do_mallocx(sz1, flags);\n\t\tverify_extent_guarded(tsdn, p1);\n\t\texpect_ptr_eq(p1, new_p1, \"Expect to reuse p1\");\n\n\t\tvoid *new_p2 = do_mallocx(sz2, flags);\n\t\tverify_extent_guarded(tsdn, p2);\n\t\texpect_ptr_eq(p2, new_p2, \"Expect to reuse p2\");\n\n\t\tdallocx(new_p1, flags);\n\t\tverify_pdirty(arena_ind, sz1 + add_guard_size);\n\t\tdallocx(new_p2, flags);\n\t\tverify_pdirty(arena_ind, sz1 + sz2 + 2 * add_guard_size);\n\t\tverify_pmuzzy(arena_ind, 0);\n\t}\n\n\tdo_arena_destroy(arena_ind);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_guarded_small,\n\t test_guarded_large,\n\t test_guarded_decay);\n}\n" }, { "path": "deps/jemalloc/test/unit/san.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"san_guard_large:1,san_guard_small:1\"\n" }, { "path": "deps/jemalloc/test/unit/san_bump.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/arena_util.h\"\n\n#include \"jemalloc/internal/arena_structs.h\"\n#include \"jemalloc/internal/san_bump.h\"\n\nTEST_BEGIN(test_san_bump_alloc) {\n\ttest_skip_if(!maps_coalesce || !opt_retain);\n\n\ttsdn_t *tsdn = tsdn_fetch();\n\n\tsan_bump_alloc_t sba;\n\tsan_bump_alloc_init(&sba);\n\n\tunsigned arena_ind = do_arena_create(0, 0);\n\tassert_u_ne(arena_ind, UINT_MAX, \"Failed to create an arena\");\n\n\tarena_t *arena = arena_get(tsdn, arena_ind, false);\n\tpac_t *pac = &arena->pa_shard.pac;\n\n\tsize_t alloc_size = PAGE * 16;\n\tsize_t alloc_n = alloc_size / sizeof(unsigned);\n\tedata_t* edata = san_bump_alloc(tsdn, &sba, pac, pac_ehooks_get(pac),\n\t alloc_size, /* zero */ false);\n\n\texpect_ptr_not_null(edata, \"Failed to allocate edata\");\n\texpect_u_eq(edata_arena_ind_get(edata), arena_ind,\n\t \"Edata was assigned an incorrect arena id\");\n\texpect_zu_eq(edata_size_get(edata), alloc_size,\n\t \"Allocated edata of incorrect size\");\n\texpect_false(edata_slab_get(edata),\n\t \"Bump allocator incorrectly assigned 'slab' to true\");\n\texpect_true(edata_committed_get(edata), \"Edata is not committed\");\n\n\tvoid *ptr = edata_addr_get(edata);\n\texpect_ptr_not_null(ptr, \"Edata was assigned an invalid address\");\n\t/* Test that memory is allocated; no guard pages are misplaced */\n\tfor (unsigned i = 0; i < alloc_n; ++i) {\n\t\t((unsigned *)ptr)[i] = 1;\n\t}\n\n\tsize_t alloc_size2 = PAGE * 28;\n\tsize_t alloc_n2 = alloc_size / sizeof(unsigned);\n\tedata_t *edata2 = san_bump_alloc(tsdn, &sba, pac, pac_ehooks_get(pac),\n\t alloc_size2, /* zero */ true);\n\n\texpect_ptr_not_null(edata2, \"Failed to allocate edata\");\n\texpect_u_eq(edata_arena_ind_get(edata2), arena_ind,\n\t \"Edata was assigned an incorrect arena id\");\n\texpect_zu_eq(edata_size_get(edata2), alloc_size2,\n\t \"Allocated edata of incorrect size\");\n\texpect_false(edata_slab_get(edata2),\n\t \"Bump allocator incorrectly assigned 'slab' to true\");\n\texpect_true(edata_committed_get(edata2), \"Edata is not committed\");\n\n\tvoid *ptr2 = edata_addr_get(edata2);\n\texpect_ptr_not_null(ptr, \"Edata was assigned an invalid address\");\n\n\tuintptr_t ptrdiff = ptr2 > ptr ? (uintptr_t)ptr2 - (uintptr_t)ptr\n\t : (uintptr_t)ptr - (uintptr_t)ptr2;\n\tsize_t between_allocs = (size_t)ptrdiff - alloc_size;\n\n\texpect_zu_ge(between_allocs, PAGE,\n\t \"Guard page between allocs is missing\");\n\n\tfor (unsigned i = 0; i < alloc_n2; ++i) {\n\t\texpect_u_eq(((unsigned *)ptr2)[i], 0, \"Memory is not zeroed\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_large_alloc_size) {\n\ttest_skip_if(!maps_coalesce || !opt_retain);\n\n\ttsdn_t *tsdn = tsdn_fetch();\n\n\tsan_bump_alloc_t sba;\n\tsan_bump_alloc_init(&sba);\n\n\tunsigned arena_ind = do_arena_create(0, 0);\n\tassert_u_ne(arena_ind, UINT_MAX, \"Failed to create an arena\");\n\n\tarena_t *arena = arena_get(tsdn, arena_ind, false);\n\tpac_t *pac = &arena->pa_shard.pac;\n\n\tsize_t alloc_size = SBA_RETAINED_ALLOC_SIZE * 2;\n\tedata_t* edata = san_bump_alloc(tsdn, &sba, pac, pac_ehooks_get(pac),\n\t alloc_size, /* zero */ false);\n\texpect_u_eq(edata_arena_ind_get(edata), arena_ind,\n\t \"Edata was assigned an incorrect arena id\");\n\texpect_zu_eq(edata_size_get(edata), alloc_size,\n\t \"Allocated edata of incorrect size\");\n\texpect_false(edata_slab_get(edata),\n\t \"Bump allocator incorrectly assigned 'slab' to true\");\n\texpect_true(edata_committed_get(edata), \"Edata is not committed\");\n\n\tvoid *ptr = edata_addr_get(edata);\n\texpect_ptr_not_null(ptr, \"Edata was assigned an invalid address\");\n\t/* Test that memory is allocated; no guard pages are misplaced */\n\tfor (unsigned i = 0; i < alloc_size / PAGE; ++i) {\n\t\t*((char *)ptr + PAGE * i) = 1;\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_san_bump_alloc,\n\t test_large_alloc_size);\n}\n" }, { "path": "deps/jemalloc/test/unit/sc.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_update_slab_size) {\n\tsc_data_t data;\n\tmemset(&data, 0, sizeof(data));\n\tsc_data_init(&data);\n\tsc_t *tiny = &data.sc[0];\n\tsize_t tiny_size = (ZU(1) << tiny->lg_base)\n\t + (ZU(tiny->ndelta) << tiny->lg_delta);\n\tsize_t pgs_too_big = (tiny_size * BITMAP_MAXBITS + PAGE - 1) / PAGE + 1;\n\tsc_data_update_slab_size(&data, tiny_size, tiny_size, (int)pgs_too_big);\n\texpect_zu_lt((size_t)tiny->pgs, pgs_too_big, \"Allowed excessive pages\");\n\n\tsc_data_update_slab_size(&data, 1, 10 * PAGE, 1);\n\tfor (int i = 0; i < data.nbins; i++) {\n\t\tsc_t *sc = &data.sc[i];\n\t\tsize_t reg_size = (ZU(1) << sc->lg_base)\n\t\t + (ZU(sc->ndelta) << sc->lg_delta);\n\t\tif (reg_size <= PAGE) {\n\t\t\texpect_d_eq(sc->pgs, 1, \"Ignored valid page size hint\");\n\t\t} else {\n\t\t\texpect_d_gt(sc->pgs, 1,\n\t\t\t \"Allowed invalid page size hint\");\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_update_slab_size);\n}\n" }, { "path": "deps/jemalloc/test/unit/sec.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/sec.h\"\n\ntypedef struct pai_test_allocator_s pai_test_allocator_t;\nstruct pai_test_allocator_s {\n\tpai_t pai;\n\tbool alloc_fail;\n\tsize_t alloc_count;\n\tsize_t alloc_batch_count;\n\tsize_t dalloc_count;\n\tsize_t dalloc_batch_count;\n\t/*\n\t * We use a simple bump allocator as the implementation. This isn't\n\t * *really* correct, since we may allow expansion into a subsequent\n\t * allocation, but it's not like the SEC is really examining the\n\t * pointers it gets back; this is mostly just helpful for debugging.\n\t */\n\tuintptr_t next_ptr;\n\tsize_t expand_count;\n\tbool expand_return_value;\n\tsize_t shrink_count;\n\tbool shrink_return_value;\n};\n\nstatic void\ntest_sec_init(sec_t *sec, pai_t *fallback, size_t nshards, size_t max_alloc,\n size_t max_bytes) {\n\tsec_opts_t opts;\n\topts.nshards = 1;\n\topts.max_alloc = max_alloc;\n\topts.max_bytes = max_bytes;\n\t/*\n\t * Just choose reasonable defaults for these; most tests don't care so\n\t * long as they're something reasonable.\n\t */\n\topts.bytes_after_flush = max_bytes / 2;\n\topts.batch_fill_extra = 4;\n\n\t/*\n\t * We end up leaking this base, but that's fine; this test is\n\t * short-running, and SECs are arena-scoped in reality.\n\t */\n\tbase_t *base = base_new(TSDN_NULL, /* ind */ 123,\n\t &ehooks_default_extent_hooks, /* metadata_use_hooks */ true);\n\n\tbool err = sec_init(TSDN_NULL, sec, base, fallback, &opts);\n\tassert_false(err, \"Unexpected initialization failure\");\n\tassert_u_ge(sec->npsizes, 0, \"Zero size classes allowed for caching\");\n}\n\nstatic inline edata_t *\npai_test_allocator_alloc(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t alignment, bool zero, bool guarded, bool frequent_reuse,\n bool *deferred_work_generated) {\n\tassert(!guarded);\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\tif (ta->alloc_fail) {\n\t\treturn NULL;\n\t}\n\tedata_t *edata = malloc(sizeof(edata_t));\n\tassert_ptr_not_null(edata, \"\");\n\tta->next_ptr += alignment - 1;\n\tedata_init(edata, /* arena_ind */ 0,\n\t (void *)(ta->next_ptr & ~(alignment - 1)), size,\n\t /* slab */ false,\n\t /* szind */ 0, /* sn */ 1, extent_state_active, /* zero */ zero,\n\t /* comitted */ true, /* ranged */ false, EXTENT_NOT_HEAD);\n\tta->next_ptr += size;\n\tta->alloc_count++;\n\treturn edata;\n}\n\nstatic inline size_t\npai_test_allocator_alloc_batch(tsdn_t *tsdn, pai_t *self, size_t size,\n size_t nallocs, edata_list_active_t *results,\n bool *deferred_work_generated) {\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\tif (ta->alloc_fail) {\n\t\treturn 0;\n\t}\n\tfor (size_t i = 0; i < nallocs; i++) {\n\t\tedata_t *edata = malloc(sizeof(edata_t));\n\t\tassert_ptr_not_null(edata, \"\");\n\t\tedata_init(edata, /* arena_ind */ 0,\n\t\t (void *)ta->next_ptr, size,\n\t\t /* slab */ false, /* szind */ 0, /* sn */ 1,\n\t\t extent_state_active, /* zero */ false, /* comitted */ true,\n\t\t /* ranged */ false, EXTENT_NOT_HEAD);\n\t\tta->next_ptr += size;\n\t\tta->alloc_batch_count++;\n\t\tedata_list_active_append(results, edata);\n\t}\n\treturn nallocs;\n}\n\nstatic bool\npai_test_allocator_expand(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool zero,\n bool *deferred_work_generated) {\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\tta->expand_count++;\n\treturn ta->expand_return_value;\n}\n\nstatic bool\npai_test_allocator_shrink(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n size_t old_size, size_t new_size, bool *deferred_work_generated) {\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\tta->shrink_count++;\n\treturn ta->shrink_return_value;\n}\n\nstatic void\npai_test_allocator_dalloc(tsdn_t *tsdn, pai_t *self, edata_t *edata,\n bool *deferred_work_generated) {\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\tta->dalloc_count++;\n\tfree(edata);\n}\n\nstatic void\npai_test_allocator_dalloc_batch(tsdn_t *tsdn, pai_t *self,\n edata_list_active_t *list, bool *deferred_work_generated) {\n\tpai_test_allocator_t *ta = (pai_test_allocator_t *)self;\n\n\tedata_t *edata;\n\twhile ((edata = edata_list_active_first(list)) != NULL) {\n\t\tedata_list_active_remove(list, edata);\n\t\tta->dalloc_batch_count++;\n\t\tfree(edata);\n\t}\n}\n\nstatic inline void\npai_test_allocator_init(pai_test_allocator_t *ta) {\n\tta->alloc_fail = false;\n\tta->alloc_count = 0;\n\tta->alloc_batch_count = 0;\n\tta->dalloc_count = 0;\n\tta->dalloc_batch_count = 0;\n\t/* Just don't start the edata at 0. */\n\tta->next_ptr = 10 * PAGE;\n\tta->expand_count = 0;\n\tta->expand_return_value = false;\n\tta->shrink_count = 0;\n\tta->shrink_return_value = false;\n\tta->pai.alloc = &pai_test_allocator_alloc;\n\tta->pai.alloc_batch = &pai_test_allocator_alloc_batch;\n\tta->pai.expand = &pai_test_allocator_expand;\n\tta->pai.shrink = &pai_test_allocator_shrink;\n\tta->pai.dalloc = &pai_test_allocator_dalloc;\n\tta->pai.dalloc_batch = &pai_test_allocator_dalloc_batch;\n}\n\nTEST_BEGIN(test_reuse) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/*\n\t * We can't use the \"real\" tsd, since we malloc within the test\n\t * allocator hooks; we'd get lock inversion crashes. Eventually, we\n\t * should have a way to mock tsds, but for now just don't do any\n\t * lock-order checking.\n\t */\n\ttsdn_t *tsdn = TSDN_NULL;\n\t/*\n\t * 11 allocs apiece of 1-PAGE and 2-PAGE objects means that we should be\n\t * able to get to 33 pages in the cache before triggering a flush. We\n\t * set the flush liimt to twice this amount, to avoid accidentally\n\t * triggering a flush caused by the batch-allocation down the cache fill\n\t * pathway disrupting ordering.\n\t */\n\tenum { NALLOCS = 11 };\n\tedata_t *one_page[NALLOCS];\n\tedata_t *two_page[NALLOCS];\n\tbool deferred_work_generated = false;\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ 2 * PAGE,\n\t /* max_bytes */ 2 * (NALLOCS * PAGE + NALLOCS * 2 * PAGE));\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tone_page[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_not_null(one_page[i], \"Unexpected alloc failure\");\n\t\ttwo_page[i] = pai_alloc(tsdn, &sec.pai, 2 * PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_not_null(one_page[i], \"Unexpected alloc failure\");\n\t}\n\texpect_zu_eq(0, ta.alloc_count, \"Should be using batch allocs\");\n\tsize_t max_allocs = ta.alloc_count + ta.alloc_batch_count;\n\texpect_zu_le(2 * NALLOCS, max_allocs,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n\t/*\n\t * Free in a different order than we allocated, to make sure free-list\n\t * separation works correctly.\n\t */\n\tfor (int i = NALLOCS - 1; i >= 0; i--) {\n\t\tpai_dalloc(tsdn, &sec.pai, one_page[i],\n\t\t &deferred_work_generated);\n\t}\n\tfor (int i = NALLOCS - 1; i >= 0; i--) {\n\t\tpai_dalloc(tsdn, &sec.pai, two_page[i],\n\t\t &deferred_work_generated);\n\t}\n\texpect_zu_eq(max_allocs, ta.alloc_count + ta.alloc_batch_count,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n\t/*\n\t * Check that the n'th most recent deallocated extent is returned for\n\t * the n'th alloc request of a given size.\n\t */\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tedata_t *alloc1 = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\tedata_t *alloc2 = pai_alloc(tsdn, &sec.pai, 2 * PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_eq(one_page[i], alloc1,\n\t\t \"Got unexpected allocation\");\n\t\texpect_ptr_eq(two_page[i], alloc2,\n\t\t \"Got unexpected allocation\");\n\t}\n\texpect_zu_eq(max_allocs, ta.alloc_count + ta.alloc_batch_count,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n}\nTEST_END\n\n\nTEST_BEGIN(test_auto_flush) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\t/*\n\t * 10-allocs apiece of 1-PAGE and 2-PAGE objects means that we should be\n\t * able to get to 30 pages in the cache before triggering a flush. The\n\t * choice of NALLOCS here is chosen to match the batch allocation\n\t * default (4 extra + 1 == 5; so 10 allocations leaves the cache exactly\n\t * empty, even in the presence of batch allocation on fill).\n\t * Eventually, once our allocation batching strategies become smarter,\n\t * this should change.\n\t */\n\tenum { NALLOCS = 10 };\n\tedata_t *extra_alloc;\n\tedata_t *allocs[NALLOCS];\n\tbool deferred_work_generated = false;\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ PAGE,\n\t /* max_bytes */ NALLOCS * PAGE);\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_not_null(allocs[i], \"Unexpected alloc failure\");\n\t}\n\textra_alloc = pai_alloc(tsdn, &sec.pai, PAGE, PAGE, /* zero */ false,\n\t /* guarded */ false, /* frequent_reuse */ false,\n\t &deferred_work_generated);\n\texpect_ptr_not_null(extra_alloc, \"Unexpected alloc failure\");\n\tsize_t max_allocs = ta.alloc_count + ta.alloc_batch_count;\n\texpect_zu_le(NALLOCS + 1, max_allocs,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n\t/* Free until the SEC is full, but should not have flushed yet. */\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[i], &deferred_work_generated);\n\t}\n\texpect_zu_le(NALLOCS + 1, max_allocs,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n\t/*\n\t * Free the extra allocation; this should trigger a flush. The internal\n\t * flushing logic is allowed to get complicated; for now, we rely on our\n\t * whitebox knowledge of the fact that the SEC flushes bins in their\n\t * entirety when it decides to do so, and it has only one bin active\n\t * right now.\n\t */\n\tpai_dalloc(tsdn, &sec.pai, extra_alloc, &deferred_work_generated);\n\texpect_zu_eq(max_allocs, ta.alloc_count + ta.alloc_batch_count,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of (non-batch) deallocations\");\n\texpect_zu_eq(NALLOCS + 1, ta.dalloc_batch_count,\n\t \"Incorrect number of batch deallocations\");\n}\nTEST_END\n\n/*\n * A disable and a flush are *almost* equivalent; the only difference is what\n * happens afterwards; disabling disallows all future caching as well.\n */\nstatic void\ndo_disable_flush_test(bool is_disable) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tenum { NALLOCS = 11 };\n\tedata_t *allocs[NALLOCS];\n\tbool deferred_work_generated = false;\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ PAGE,\n\t /* max_bytes */ NALLOCS * PAGE);\n\tfor (int i = 0; i < NALLOCS; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_ptr_not_null(allocs[i], \"Unexpected alloc failure\");\n\t}\n\t/* Free all but the last aloc. */\n\tfor (int i = 0; i < NALLOCS - 1; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[i], &deferred_work_generated);\n\t}\n\tsize_t max_allocs = ta.alloc_count + ta.alloc_batch_count;\n\n\texpect_zu_le(NALLOCS, max_allocs, \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of allocations\");\n\n\tif (is_disable) {\n\t\tsec_disable(tsdn, &sec);\n\t} else {\n\t\tsec_flush(tsdn, &sec);\n\t}\n\n\texpect_zu_eq(max_allocs, ta.alloc_count + ta.alloc_batch_count,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(0, ta.dalloc_count,\n\t \"Incorrect number of (non-batch) deallocations\");\n\texpect_zu_le(NALLOCS - 1, ta.dalloc_batch_count,\n\t \"Incorrect number of batch deallocations\");\n\tsize_t old_dalloc_batch_count = ta.dalloc_batch_count;\n\n\t/*\n\t * If we free into a disabled SEC, it should forward to the fallback.\n\t * Otherwise, the SEC should accept the allocation.\n\t */\n\tpai_dalloc(tsdn, &sec.pai, allocs[NALLOCS - 1],\n\t &deferred_work_generated);\n\n\texpect_zu_eq(max_allocs, ta.alloc_count + ta.alloc_batch_count,\n\t \"Incorrect number of allocations\");\n\texpect_zu_eq(is_disable ? 1 : 0, ta.dalloc_count,\n\t \"Incorrect number of (non-batch) deallocations\");\n\texpect_zu_eq(old_dalloc_batch_count, ta.dalloc_batch_count,\n\t \"Incorrect number of batch deallocations\");\n}\n\nTEST_BEGIN(test_disable) {\n\tdo_disable_flush_test(/* is_disable */ true);\n}\nTEST_END\n\nTEST_BEGIN(test_flush) {\n\tdo_disable_flush_test(/* is_disable */ false);\n}\nTEST_END\n\nTEST_BEGIN(test_max_alloc_respected) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tsize_t max_alloc = 2 * PAGE;\n\tsize_t attempted_alloc = 3 * PAGE;\n\n\tbool deferred_work_generated = false;\n\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, max_alloc,\n\t /* max_bytes */ 1000 * PAGE);\n\n\tfor (size_t i = 0; i < 100; i++) {\n\t\texpect_zu_eq(i, ta.alloc_count,\n\t\t \"Incorrect number of allocations\");\n\t\texpect_zu_eq(i, ta.dalloc_count,\n\t\t \"Incorrect number of deallocations\");\n\t\tedata_t *edata = pai_alloc(tsdn, &sec.pai, attempted_alloc,\n\t\t PAGE, /* zero */ false, /* guarded */ false,\n\t\t /* frequent_reuse */ false, &deferred_work_generated);\n\t\texpect_ptr_not_null(edata, \"Unexpected alloc failure\");\n\t\texpect_zu_eq(i + 1, ta.alloc_count,\n\t\t \"Incorrect number of allocations\");\n\t\texpect_zu_eq(i, ta.dalloc_count,\n\t\t \"Incorrect number of deallocations\");\n\t\tpai_dalloc(tsdn, &sec.pai, edata, &deferred_work_generated);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_expand_shrink_delegate) {\n\t/*\n\t * Expand and shrink shouldn't affect sec state; they should just\n\t * delegate to the fallback PAI.\n\t */\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tbool deferred_work_generated = false;\n\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ 10 * PAGE,\n\t /* max_bytes */ 1000 * PAGE);\n\tedata_t *edata = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t /* zero */ false, /* guarded */ false, /* frequent_reuse */ false,\n\t &deferred_work_generated);\n\texpect_ptr_not_null(edata, \"Unexpected alloc failure\");\n\n\tbool err = pai_expand(tsdn, &sec.pai, edata, PAGE, 4 * PAGE,\n\t /* zero */ false, &deferred_work_generated);\n\texpect_false(err, \"Unexpected expand failure\");\n\texpect_zu_eq(1, ta.expand_count, \"\");\n\tta.expand_return_value = true;\n\terr = pai_expand(tsdn, &sec.pai, edata, 4 * PAGE, 3 * PAGE,\n\t /* zero */ false, &deferred_work_generated);\n\texpect_true(err, \"Unexpected expand success\");\n\texpect_zu_eq(2, ta.expand_count, \"\");\n\n\terr = pai_shrink(tsdn, &sec.pai, edata, 4 * PAGE, 2 * PAGE,\n\t &deferred_work_generated);\n\texpect_false(err, \"Unexpected shrink failure\");\n\texpect_zu_eq(1, ta.shrink_count, \"\");\n\tta.shrink_return_value = true;\n\terr = pai_shrink(tsdn, &sec.pai, edata, 2 * PAGE, PAGE,\n\t &deferred_work_generated);\n\texpect_true(err, \"Unexpected shrink success\");\n\texpect_zu_eq(2, ta.shrink_count, \"\");\n}\nTEST_END\n\nTEST_BEGIN(test_nshards_0) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\tbase_t *base = base_new(TSDN_NULL, /* ind */ 123,\n\t &ehooks_default_extent_hooks, /* metadata_use_hooks */ true);\n\n\tsec_opts_t opts = SEC_OPTS_DEFAULT;\n\topts.nshards = 0;\n\tsec_init(TSDN_NULL, &sec, base, &ta.pai, &opts);\n\n\tbool deferred_work_generated = false;\n\tedata_t *edata = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t /* zero */ false, /* guarded */ false, /* frequent_reuse */ false,\n\t &deferred_work_generated);\n\tpai_dalloc(tsdn, &sec.pai, edata, &deferred_work_generated);\n\n\t/* Both operations should have gone directly to the fallback. */\n\texpect_zu_eq(1, ta.alloc_count, \"\");\n\texpect_zu_eq(1, ta.dalloc_count, \"\");\n}\nTEST_END\n\nstatic void\nexpect_stats_pages(tsdn_t *tsdn, sec_t *sec, size_t npages) {\n\tsec_stats_t stats;\n\t/*\n\t * Check that the stats merging accumulates rather than overwrites by\n\t * putting some (made up) data there to begin with.\n\t */\n\tstats.bytes = 123;\n\tsec_stats_merge(tsdn, sec, &stats);\n\tassert_zu_le(npages * PAGE + 123, stats.bytes, \"\");\n}\n\nTEST_BEGIN(test_stats_simple) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tenum {\n\t\tNITERS = 100,\n\t\tFLUSH_PAGES = 20,\n\t};\n\n\tbool deferred_work_generated = false;\n\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ PAGE,\n\t /* max_bytes */ FLUSH_PAGES * PAGE);\n\n\tedata_t *allocs[FLUSH_PAGES];\n\tfor (size_t i = 0; i < FLUSH_PAGES; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_stats_pages(tsdn, &sec, 0);\n\t}\n\n\t/* Increase and decrease, without flushing. */\n\tfor (size_t i = 0; i < NITERS; i++) {\n\t\tfor (size_t j = 0; j < FLUSH_PAGES / 2; j++) {\n\t\t\tpai_dalloc(tsdn, &sec.pai, allocs[j],\n\t\t\t &deferred_work_generated);\n\t\t\texpect_stats_pages(tsdn, &sec, j + 1);\n\t\t}\n\t\tfor (size_t j = 0; j < FLUSH_PAGES / 2; j++) {\n\t\t\tallocs[j] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t\t /* zero */ false, /* guarded */ false,\n\t\t\t /* frequent_reuse */ false,\n\t\t\t &deferred_work_generated);\n\t\t\texpect_stats_pages(tsdn, &sec, FLUSH_PAGES / 2 - j - 1);\n\t\t}\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_stats_auto_flush) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tenum {\n\t\tFLUSH_PAGES = 10,\n\t};\n\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ PAGE,\n\t /* max_bytes */ FLUSH_PAGES * PAGE);\n\n\tedata_t *extra_alloc0;\n\tedata_t *extra_alloc1;\n\tedata_t *allocs[2 * FLUSH_PAGES];\n\n\tbool deferred_work_generated = false;\n\n\textra_alloc0 = pai_alloc(tsdn, &sec.pai, PAGE, PAGE, /* zero */ false,\n\t /* guarded */ false, /* frequent_reuse */ false,\n\t &deferred_work_generated);\n\textra_alloc1 = pai_alloc(tsdn, &sec.pai, PAGE, PAGE, /* zero */ false,\n\t /* guarded */ false, /* frequent_reuse */ false,\n\t &deferred_work_generated);\n\n\tfor (size_t i = 0; i < 2 * FLUSH_PAGES; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t}\n\n\tfor (size_t i = 0; i < FLUSH_PAGES; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[i], &deferred_work_generated);\n\t}\n\tpai_dalloc(tsdn, &sec.pai, extra_alloc0, &deferred_work_generated);\n\n\t/* Flush the remaining pages; stats should still work. */\n\tfor (size_t i = 0; i < FLUSH_PAGES; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[FLUSH_PAGES + i],\n\t\t &deferred_work_generated);\n\t}\n\n\tpai_dalloc(tsdn, &sec.pai, extra_alloc1, &deferred_work_generated);\n\n\texpect_stats_pages(tsdn, &sec, ta.alloc_count + ta.alloc_batch_count\n\t - ta.dalloc_count - ta.dalloc_batch_count);\n}\nTEST_END\n\nTEST_BEGIN(test_stats_manual_flush) {\n\tpai_test_allocator_t ta;\n\tpai_test_allocator_init(&ta);\n\tsec_t sec;\n\n\t/* See the note above -- we can't use the real tsd. */\n\ttsdn_t *tsdn = TSDN_NULL;\n\n\tenum {\n\t\tFLUSH_PAGES = 10,\n\t};\n\n\ttest_sec_init(&sec, &ta.pai, /* nshards */ 1, /* max_alloc */ PAGE,\n\t /* max_bytes */ FLUSH_PAGES * PAGE);\n\n\tbool deferred_work_generated = false;\n\tedata_t *allocs[FLUSH_PAGES];\n\tfor (size_t i = 0; i < FLUSH_PAGES; i++) {\n\t\tallocs[i] = pai_alloc(tsdn, &sec.pai, PAGE, PAGE,\n\t\t /* zero */ false, /* guarded */ false, /* frequent_reuse */\n\t\t false, &deferred_work_generated);\n\t\texpect_stats_pages(tsdn, &sec, 0);\n\t}\n\n\t/* Dalloc the first half of the allocations. */\n\tfor (size_t i = 0; i < FLUSH_PAGES / 2; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[i], &deferred_work_generated);\n\t\texpect_stats_pages(tsdn, &sec, i + 1);\n\t}\n\n\tsec_flush(tsdn, &sec);\n\texpect_stats_pages(tsdn, &sec, 0);\n\n\t/* Flush the remaining pages. */\n\tfor (size_t i = 0; i < FLUSH_PAGES / 2; i++) {\n\t\tpai_dalloc(tsdn, &sec.pai, allocs[FLUSH_PAGES / 2 + i],\n\t\t &deferred_work_generated);\n\t\texpect_stats_pages(tsdn, &sec, i + 1);\n\t}\n\tsec_disable(tsdn, &sec);\n\texpect_stats_pages(tsdn, &sec, 0);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_reuse,\n\t test_auto_flush,\n\t test_disable,\n\t test_flush,\n\t test_max_alloc_respected,\n\t test_expand_shrink_delegate,\n\t test_nshards_0,\n\t test_stats_simple,\n\t test_stats_auto_flush,\n\t test_stats_manual_flush);\n}\n" }, { "path": "deps/jemalloc/test/unit/seq.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/seq.h\"\n\ntypedef struct data_s data_t;\nstruct data_s {\n\tint arr[10];\n};\n\nstatic void\nset_data(data_t *data, int num) {\n\tfor (int i = 0; i < 10; i++) {\n\t\tdata->arr[i] = num;\n\t}\n}\n\nstatic void\nexpect_data(data_t *data) {\n\tint num = data->arr[0];\n\tfor (int i = 0; i < 10; i++) {\n\t\texpect_d_eq(num, data->arr[i], \"Data consistency error\");\n\t}\n}\n\nseq_define(data_t, data)\n\ntypedef struct thd_data_s thd_data_t;\nstruct thd_data_s {\n\tseq_data_t data;\n};\n\nstatic void *\nseq_reader_thd(void *arg) {\n\tthd_data_t *thd_data = (thd_data_t *)arg;\n\tint iter = 0;\n\tdata_t local_data;\n\twhile (iter < 1000 * 1000 - 1) {\n\t\tbool success = seq_try_load_data(&local_data, &thd_data->data);\n\t\tif (success) {\n\t\t\texpect_data(&local_data);\n\t\t\texpect_d_le(iter, local_data.arr[0],\n\t\t\t \"Seq read went back in time.\");\n\t\t\titer = local_data.arr[0];\n\t\t}\n\t}\n\treturn NULL;\n}\n\nstatic void *\nseq_writer_thd(void *arg) {\n\tthd_data_t *thd_data = (thd_data_t *)arg;\n\tdata_t local_data;\n\tmemset(&local_data, 0, sizeof(local_data));\n\tfor (int i = 0; i < 1000 * 1000; i++) {\n\t\tset_data(&local_data, i);\n\t\tseq_store_data(&thd_data->data, &local_data);\n\t}\n\treturn NULL;\n}\n\nTEST_BEGIN(test_seq_threaded) {\n\tthd_data_t thd_data;\n\tmemset(&thd_data, 0, sizeof(thd_data));\n\n\tthd_t reader;\n\tthd_t writer;\n\n\tthd_create(&reader, seq_reader_thd, &thd_data);\n\tthd_create(&writer, seq_writer_thd, &thd_data);\n\n\tthd_join(reader, NULL);\n\tthd_join(writer, NULL);\n}\nTEST_END\n\nTEST_BEGIN(test_seq_simple) {\n\tdata_t data;\n\tseq_data_t seq;\n\tmemset(&seq, 0, sizeof(seq));\n\tfor (int i = 0; i < 1000 * 1000; i++) {\n\t\tset_data(&data, i);\n\t\tseq_store_data(&seq, &data);\n\t\tset_data(&data, 0);\n\t\tbool success = seq_try_load_data(&data, &seq);\n\t\texpect_b_eq(success, true, \"Failed non-racing read\");\n\t\texpect_data(&data);\n\t}\n}\nTEST_END\n\nint main(void) {\n\treturn test_no_reentrancy(\n\t test_seq_simple,\n\t test_seq_threaded);\n}\n" }, { "path": "deps/jemalloc/test/unit/size_check.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/safety_check.h\"\n\nbool fake_abort_called;\nvoid fake_abort(const char *message) {\n\t(void)message;\n\tfake_abort_called = true;\n}\n\n#define SMALL_SIZE1 SC_SMALL_MAXCLASS\n#define SMALL_SIZE2 (SC_SMALL_MAXCLASS / 2)\n\n#define LARGE_SIZE1 SC_LARGE_MINCLASS\n#define LARGE_SIZE2 (LARGE_SIZE1 * 2)\n\nvoid *\ntest_invalid_size_pre(size_t sz) {\n\tsafety_check_set_abort(&fake_abort);\n\n\tfake_abort_called = false;\n\tvoid *ptr = malloc(sz);\n\tassert_ptr_not_null(ptr, \"Unexpected failure\");\n\n\treturn ptr;\n}\n\nvoid\ntest_invalid_size_post(void) {\n\texpect_true(fake_abort_called, \"Safety check didn't fire\");\n\tsafety_check_set_abort(NULL);\n}\n\nTEST_BEGIN(test_invalid_size_sdallocx) {\n\ttest_skip_if(!config_opt_size_checks);\n\n\tvoid *ptr = test_invalid_size_pre(SMALL_SIZE1);\n\tsdallocx(ptr, SMALL_SIZE2, 0);\n\ttest_invalid_size_post();\n\n\tptr = test_invalid_size_pre(LARGE_SIZE1);\n\tsdallocx(ptr, LARGE_SIZE2, 0);\n\ttest_invalid_size_post();\n}\nTEST_END\n\nTEST_BEGIN(test_invalid_size_sdallocx_nonzero_flag) {\n\ttest_skip_if(!config_opt_size_checks);\n\n\tvoid *ptr = test_invalid_size_pre(SMALL_SIZE1);\n\tsdallocx(ptr, SMALL_SIZE2, MALLOCX_TCACHE_NONE);\n\ttest_invalid_size_post();\n\n\tptr = test_invalid_size_pre(LARGE_SIZE1);\n\tsdallocx(ptr, LARGE_SIZE2, MALLOCX_TCACHE_NONE);\n\ttest_invalid_size_post();\n}\nTEST_END\n\nTEST_BEGIN(test_invalid_size_sdallocx_noflags) {\n\ttest_skip_if(!config_opt_size_checks);\n\n\tvoid *ptr = test_invalid_size_pre(SMALL_SIZE1);\n\tje_sdallocx_noflags(ptr, SMALL_SIZE2);\n\ttest_invalid_size_post();\n\n\tptr = test_invalid_size_pre(LARGE_SIZE1);\n\tje_sdallocx_noflags(ptr, LARGE_SIZE2);\n\ttest_invalid_size_post();\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_invalid_size_sdallocx,\n\t test_invalid_size_sdallocx_nonzero_flag,\n\t test_invalid_size_sdallocx_noflags);\n}\n" }, { "path": "deps/jemalloc/test/unit/size_check.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:false\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/size_classes.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic size_t\nget_max_size_class(void) {\n\tunsigned nlextents;\n\tsize_t mib[4];\n\tsize_t sz, miblen, max_size_class;\n\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.nlextents\", (void *)&nlextents, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() error\");\n\n\tmiblen = sizeof(mib) / sizeof(size_t);\n\texpect_d_eq(mallctlnametomib(\"arenas.lextent.0.size\", mib, &miblen), 0,\n\t \"Unexpected mallctlnametomib() error\");\n\tmib[2] = nlextents - 1;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,\n\t NULL, 0), 0, \"Unexpected mallctlbymib() error\");\n\n\treturn max_size_class;\n}\n\nTEST_BEGIN(test_size_classes) {\n\tsize_t size_class, max_size_class;\n\tszind_t index, max_index;\n\n\tmax_size_class = get_max_size_class();\n\tmax_index = sz_size2index(max_size_class);\n\n\tfor (index = 0, size_class = sz_index2size(index); index < max_index ||\n\t size_class < max_size_class; index++, size_class =\n\t sz_index2size(index)) {\n\t\texpect_true(index < max_index,\n\t\t \"Loop conditionals should be equivalent; index=%u, \"\n\t\t \"size_class=%zu (%#zx)\", index, size_class, size_class);\n\t\texpect_true(size_class < max_size_class,\n\t\t \"Loop conditionals should be equivalent; index=%u, \"\n\t\t \"size_class=%zu (%#zx)\", index, size_class, size_class);\n\n\t\texpect_u_eq(index, sz_size2index(size_class),\n\t\t \"sz_size2index() does not reverse sz_index2size(): index=%u\"\n\t\t \" --> size_class=%zu --> index=%u --> size_class=%zu\",\n\t\t index, size_class, sz_size2index(size_class),\n\t\t sz_index2size(sz_size2index(size_class)));\n\t\texpect_zu_eq(size_class,\n\t\t sz_index2size(sz_size2index(size_class)),\n\t\t \"sz_index2size() does not reverse sz_size2index(): index=%u\"\n\t\t \" --> size_class=%zu --> index=%u --> size_class=%zu\",\n\t\t index, size_class, sz_size2index(size_class),\n\t\t sz_index2size(sz_size2index(size_class)));\n\n\t\texpect_u_eq(index+1, sz_size2index(size_class+1),\n\t\t \"Next size_class does not round up properly\");\n\n\t\texpect_zu_eq(size_class, (index > 0) ?\n\t\t sz_s2u(sz_index2size(index-1)+1) : sz_s2u(1),\n\t\t \"sz_s2u() does not round up to size class\");\n\t\texpect_zu_eq(size_class, sz_s2u(size_class-1),\n\t\t \"sz_s2u() does not round up to size class\");\n\t\texpect_zu_eq(size_class, sz_s2u(size_class),\n\t\t \"sz_s2u() does not compute same size class\");\n\t\texpect_zu_eq(sz_s2u(size_class+1), sz_index2size(index+1),\n\t\t \"sz_s2u() does not round up to next size class\");\n\t}\n\n\texpect_u_eq(index, sz_size2index(sz_index2size(index)),\n\t \"sz_size2index() does not reverse sz_index2size()\");\n\texpect_zu_eq(max_size_class, sz_index2size(\n\t sz_size2index(max_size_class)),\n\t \"sz_index2size() does not reverse sz_size2index()\");\n\n\texpect_zu_eq(size_class, sz_s2u(sz_index2size(index-1)+1),\n\t \"sz_s2u() does not round up to size class\");\n\texpect_zu_eq(size_class, sz_s2u(size_class-1),\n\t \"sz_s2u() does not round up to size class\");\n\texpect_zu_eq(size_class, sz_s2u(size_class),\n\t \"sz_s2u() does not compute same size class\");\n}\nTEST_END\n\nTEST_BEGIN(test_psize_classes) {\n\tsize_t size_class, max_psz;\n\tpszind_t pind, max_pind;\n\n\tmax_psz = get_max_size_class() + PAGE;\n\tmax_pind = sz_psz2ind(max_psz);\n\n\tfor (pind = 0, size_class = sz_pind2sz(pind);\n\t pind < max_pind || size_class < max_psz;\n\t pind++, size_class = sz_pind2sz(pind)) {\n\t\texpect_true(pind < max_pind,\n\t\t \"Loop conditionals should be equivalent; pind=%u, \"\n\t\t \"size_class=%zu (%#zx)\", pind, size_class, size_class);\n\t\texpect_true(size_class < max_psz,\n\t\t \"Loop conditionals should be equivalent; pind=%u, \"\n\t\t \"size_class=%zu (%#zx)\", pind, size_class, size_class);\n\n\t\texpect_u_eq(pind, sz_psz2ind(size_class),\n\t\t \"sz_psz2ind() does not reverse sz_pind2sz(): pind=%u -->\"\n\t\t \" size_class=%zu --> pind=%u --> size_class=%zu\", pind,\n\t\t size_class, sz_psz2ind(size_class),\n\t\t sz_pind2sz(sz_psz2ind(size_class)));\n\t\texpect_zu_eq(size_class, sz_pind2sz(sz_psz2ind(size_class)),\n\t\t \"sz_pind2sz() does not reverse sz_psz2ind(): pind=%u -->\"\n\t\t \" size_class=%zu --> pind=%u --> size_class=%zu\", pind,\n\t\t size_class, sz_psz2ind(size_class),\n\t\t sz_pind2sz(sz_psz2ind(size_class)));\n\n\t\tif (size_class == SC_LARGE_MAXCLASS) {\n\t\t\texpect_u_eq(SC_NPSIZES, sz_psz2ind(size_class + 1),\n\t\t\t \"Next size_class does not round up properly\");\n\t\t} else {\n\t\t\texpect_u_eq(pind + 1, sz_psz2ind(size_class + 1),\n\t\t\t \"Next size_class does not round up properly\");\n\t\t}\n\n\t\texpect_zu_eq(size_class, (pind > 0) ?\n\t\t sz_psz2u(sz_pind2sz(pind-1)+1) : sz_psz2u(1),\n\t\t \"sz_psz2u() does not round up to size class\");\n\t\texpect_zu_eq(size_class, sz_psz2u(size_class-1),\n\t\t \"sz_psz2u() does not round up to size class\");\n\t\texpect_zu_eq(size_class, sz_psz2u(size_class),\n\t\t \"sz_psz2u() does not compute same size class\");\n\t\texpect_zu_eq(sz_psz2u(size_class+1), sz_pind2sz(pind+1),\n\t\t \"sz_psz2u() does not round up to next size class\");\n\t}\n\n\texpect_u_eq(pind, sz_psz2ind(sz_pind2sz(pind)),\n\t \"sz_psz2ind() does not reverse sz_pind2sz()\");\n\texpect_zu_eq(max_psz, sz_pind2sz(sz_psz2ind(max_psz)),\n\t \"sz_pind2sz() does not reverse sz_psz2ind()\");\n\n\texpect_zu_eq(size_class, sz_psz2u(sz_pind2sz(pind-1)+1),\n\t \"sz_psz2u() does not round up to size class\");\n\texpect_zu_eq(size_class, sz_psz2u(size_class-1),\n\t \"sz_psz2u() does not round up to size class\");\n\texpect_zu_eq(size_class, sz_psz2u(size_class),\n\t \"sz_psz2u() does not compute same size class\");\n}\nTEST_END\n\nTEST_BEGIN(test_overflow) {\n\tsize_t max_size_class, max_psz;\n\n\tmax_size_class = get_max_size_class();\n\tmax_psz = max_size_class + PAGE;\n\n\texpect_u_eq(sz_size2index(max_size_class+1), SC_NSIZES,\n\t \"sz_size2index() should return NSIZES on overflow\");\n\texpect_u_eq(sz_size2index(ZU(PTRDIFF_MAX)+1), SC_NSIZES,\n\t \"sz_size2index() should return NSIZES on overflow\");\n\texpect_u_eq(sz_size2index(SIZE_T_MAX), SC_NSIZES,\n\t \"sz_size2index() should return NSIZES on overflow\");\n\n\texpect_zu_eq(sz_s2u(max_size_class+1), 0,\n\t \"sz_s2u() should return 0 for unsupported size\");\n\texpect_zu_eq(sz_s2u(ZU(PTRDIFF_MAX)+1), 0,\n\t \"sz_s2u() should return 0 for unsupported size\");\n\texpect_zu_eq(sz_s2u(SIZE_T_MAX), 0,\n\t \"sz_s2u() should return 0 on overflow\");\n\n\texpect_u_eq(sz_psz2ind(max_size_class+1), SC_NPSIZES,\n\t \"sz_psz2ind() should return NPSIZES on overflow\");\n\texpect_u_eq(sz_psz2ind(ZU(PTRDIFF_MAX)+1), SC_NPSIZES,\n\t \"sz_psz2ind() should return NPSIZES on overflow\");\n\texpect_u_eq(sz_psz2ind(SIZE_T_MAX), SC_NPSIZES,\n\t \"sz_psz2ind() should return NPSIZES on overflow\");\n\n\texpect_zu_eq(sz_psz2u(max_size_class+1), max_psz,\n\t \"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported\"\n\t \" size\");\n\texpect_zu_eq(sz_psz2u(ZU(PTRDIFF_MAX)+1), max_psz,\n\t \"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported \"\n\t \"size\");\n\texpect_zu_eq(sz_psz2u(SIZE_T_MAX), max_psz,\n\t \"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_size_classes,\n\t test_psize_classes,\n\t test_overflow);\n}\n" }, { "path": "deps/jemalloc/test/unit/slab.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define INVALID_ARENA_IND ((1U << MALLOCX_ARENA_BITS) - 1)\n\nTEST_BEGIN(test_arena_slab_regind) {\n\tszind_t binind;\n\n\tfor (binind = 0; binind < SC_NBINS; binind++) {\n\t\tsize_t regind;\n\t\tedata_t slab;\n\t\tconst bin_info_t *bin_info = &bin_infos[binind];\n\t\tedata_init(&slab, INVALID_ARENA_IND,\n\t\t mallocx(bin_info->slab_size, MALLOCX_LG_ALIGN(LG_PAGE)),\n\t\t bin_info->slab_size, true,\n\t\t binind, 0, extent_state_active, false, true, EXTENT_PAI_PAC,\n\t\t EXTENT_NOT_HEAD);\n\t\texpect_ptr_not_null(edata_addr_get(&slab),\n\t\t \"Unexpected malloc() failure\");\n\t\tarena_dalloc_bin_locked_info_t dalloc_info;\n\t\tarena_dalloc_bin_locked_begin(&dalloc_info, binind);\n\t\tfor (regind = 0; regind < bin_info->nregs; regind++) {\n\t\t\tvoid *reg = (void *)((uintptr_t)edata_addr_get(&slab) +\n\t\t\t (bin_info->reg_size * regind));\n\t\t\texpect_zu_eq(arena_slab_regind(&dalloc_info, binind,\n\t\t\t &slab, reg),\n\t\t\t regind,\n\t\t\t \"Incorrect region index computed for size %zu\",\n\t\t\t bin_info->reg_size);\n\t\t}\n\t\tfree(edata_addr_get(&slab));\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_arena_slab_regind);\n}\n" }, { "path": "deps/jemalloc/test/unit/smoothstep.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic const uint64_t smoothstep_tab[] = {\n#define STEP(step, h, x, y)\t\t\t\\\n\th,\n\tSMOOTHSTEP\n#undef STEP\n};\n\nTEST_BEGIN(test_smoothstep_integral) {\n\tuint64_t sum, min, max;\n\tunsigned i;\n\n\t/*\n\t * The integral of smoothstep in the [0..1] range equals 1/2. Verify\n\t * that the fixed point representation's integral is no more than\n\t * rounding error distant from 1/2. Regarding rounding, each table\n\t * element is rounded down to the nearest fixed point value, so the\n\t * integral may be off by as much as SMOOTHSTEP_NSTEPS ulps.\n\t */\n\tsum = 0;\n\tfor (i = 0; i < SMOOTHSTEP_NSTEPS; i++) {\n\t\tsum += smoothstep_tab[i];\n\t}\n\n\tmax = (KQU(1) << (SMOOTHSTEP_BFP-1)) * (SMOOTHSTEP_NSTEPS+1);\n\tmin = max - SMOOTHSTEP_NSTEPS;\n\n\texpect_u64_ge(sum, min,\n\t \"Integral too small, even accounting for truncation\");\n\texpect_u64_le(sum, max, \"Integral exceeds 1/2\");\n\tif (false) {\n\t\tmalloc_printf(\"%\"FMTu64\" ulps under 1/2 (limit %d)\\n\",\n\t\t max - sum, SMOOTHSTEP_NSTEPS);\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_smoothstep_monotonic) {\n\tuint64_t prev_h;\n\tunsigned i;\n\n\t/*\n\t * The smoothstep function is monotonic in [0..1], i.e. its slope is\n\t * non-negative. In practice we want to parametrize table generation\n\t * such that piecewise slope is greater than zero, but do not require\n\t * that here.\n\t */\n\tprev_h = 0;\n\tfor (i = 0; i < SMOOTHSTEP_NSTEPS; i++) {\n\t\tuint64_t h = smoothstep_tab[i];\n\t\texpect_u64_ge(h, prev_h, \"Piecewise non-monotonic, i=%u\", i);\n\t\tprev_h = h;\n\t}\n\texpect_u64_eq(smoothstep_tab[SMOOTHSTEP_NSTEPS-1],\n\t (KQU(1) << SMOOTHSTEP_BFP), \"Last step must equal 1\");\n}\nTEST_END\n\nTEST_BEGIN(test_smoothstep_slope) {\n\tuint64_t prev_h, prev_delta;\n\tunsigned i;\n\n\t/*\n\t * The smoothstep slope strictly increases until x=0.5, and then\n\t * strictly decreases until x=1.0. Verify the slightly weaker\n\t * requirement of monotonicity, so that inadequate table precision does\n\t * not cause false test failures.\n\t */\n\tprev_h = 0;\n\tprev_delta = 0;\n\tfor (i = 0; i < SMOOTHSTEP_NSTEPS / 2 + SMOOTHSTEP_NSTEPS % 2; i++) {\n\t\tuint64_t h = smoothstep_tab[i];\n\t\tuint64_t delta = h - prev_h;\n\t\texpect_u64_ge(delta, prev_delta,\n\t\t \"Slope must monotonically increase in 0.0 <= x <= 0.5, \"\n\t\t \"i=%u\", i);\n\t\tprev_h = h;\n\t\tprev_delta = delta;\n\t}\n\n\tprev_h = KQU(1) << SMOOTHSTEP_BFP;\n\tprev_delta = 0;\n\tfor (i = SMOOTHSTEP_NSTEPS-1; i >= SMOOTHSTEP_NSTEPS / 2; i--) {\n\t\tuint64_t h = smoothstep_tab[i];\n\t\tuint64_t delta = prev_h - h;\n\t\texpect_u64_ge(delta, prev_delta,\n\t\t \"Slope must monotonically decrease in 0.5 <= x <= 1.0, \"\n\t\t \"i=%u\", i);\n\t\tprev_h = h;\n\t\tprev_delta = delta;\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_smoothstep_integral,\n\t test_smoothstep_monotonic,\n\t test_smoothstep_slope);\n}\n" }, { "path": "deps/jemalloc/test/unit/spin.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/spin.h\"\n\nTEST_BEGIN(test_spin) {\n\tspin_t spinner = SPIN_INITIALIZER;\n\n\tfor (unsigned i = 0; i < 100; i++) {\n\t\tspin_adaptive(&spinner);\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_spin);\n}\n" }, { "path": "deps/jemalloc/test/unit/stats.c", "content": "#include \"test/jemalloc_test.h\"\n\n#define STRINGIFY_HELPER(x) #x\n#define STRINGIFY(x) STRINGIFY_HELPER(x)\n\nTEST_BEGIN(test_stats_summary) {\n\tsize_t sz, allocated, active, resident, mapped;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.allocated\", (void *)&allocated, &sz, NULL,\n\t 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.active\", (void *)&active, &sz, NULL, 0),\n\t expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.resident\", (void *)&resident, &sz, NULL, 0),\n\t expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.mapped\", (void *)&mapped, &sz, NULL, 0),\n\t expected, \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_zu_le(allocated, active,\n\t\t \"allocated should be no larger than active\");\n\t\texpect_zu_lt(active, resident,\n\t\t \"active should be less than resident\");\n\t\texpect_zu_lt(active, mapped,\n\t\t \"active should be less than mapped\");\n\t}\n}\nTEST_END\n\nTEST_BEGIN(test_stats_large) {\n\tvoid *p;\n\tuint64_t epoch;\n\tsize_t allocated;\n\tuint64_t nmalloc, ndalloc, nrequests;\n\tsize_t sz;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\tp = mallocx(SC_SMALL_MAXCLASS + 1, MALLOCX_ARENA(0));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.allocated\",\n\t (void *)&allocated, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(uint64_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.nmalloc\", (void *)&nmalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.ndalloc\", (void *)&ndalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.nrequests\",\n\t (void *)&nrequests, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_zu_gt(allocated, 0,\n\t\t \"allocated should be greater than zero\");\n\t\texpect_u64_ge(nmalloc, ndalloc,\n\t\t \"nmalloc should be at least as large as ndalloc\");\n\t\texpect_u64_le(nmalloc, nrequests,\n\t\t \"nmalloc should no larger than nrequests\");\n\t}\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_stats_arenas_summary) {\n\tvoid *little, *large;\n\tuint64_t epoch;\n\tsize_t sz;\n\tint expected = config_stats ? 0 : ENOENT;\n\tsize_t mapped;\n\tuint64_t dirty_npurge, dirty_nmadvise, dirty_purged;\n\tuint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;\n\n\tlittle = mallocx(SC_SMALL_MAXCLASS, MALLOCX_ARENA(0));\n\texpect_ptr_not_null(little, \"Unexpected mallocx() failure\");\n\tlarge = mallocx((1U << SC_LG_LARGE_MINCLASS),\n\t MALLOCX_ARENA(0));\n\texpect_ptr_not_null(large, \"Unexpected mallocx() failure\");\n\n\tdallocx(little, 0);\n\tdallocx(large, 0);\n\n\texpect_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t opt_tcache ? 0 : EFAULT, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"arena.0.purge\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected mallctl() failure\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.mapped\", (void *)&mapped, &sz, NULL,\n\t 0), expected, \"Unexepected mallctl() result\");\n\n\tsz = sizeof(uint64_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.dirty_npurge\",\n\t (void *)&dirty_npurge, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.dirty_nmadvise\",\n\t (void *)&dirty_nmadvise, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.dirty_purged\",\n\t (void *)&dirty_purged, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.muzzy_npurge\",\n\t (void *)&muzzy_npurge, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.muzzy_nmadvise\",\n\t (void *)&muzzy_nmadvise, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.muzzy_purged\",\n\t (void *)&muzzy_purged, &sz, NULL, 0), expected,\n\t \"Unexepected mallctl() result\");\n\n\tif (config_stats) {\n\t\tif (!is_background_thread_enabled() && !opt_hpa) {\n\t\t\texpect_u64_gt(dirty_npurge + muzzy_npurge, 0,\n\t\t\t \"At least one purge should have occurred\");\n\t\t}\n\t\texpect_u64_le(dirty_nmadvise, dirty_purged,\n\t\t \"dirty_nmadvise should be no greater than dirty_purged\");\n\t\texpect_u64_le(muzzy_nmadvise, muzzy_purged,\n\t\t \"muzzy_nmadvise should be no greater than muzzy_purged\");\n\t}\n}\nTEST_END\n\nvoid *\nthd_start(void *arg) {\n\treturn NULL;\n}\n\nstatic void\nno_lazy_lock(void) {\n\tthd_t thd;\n\n\tthd_create(&thd, thd_start, NULL);\n\tthd_join(thd, NULL);\n}\n\nTEST_BEGIN(test_stats_arenas_small) {\n\tvoid *p;\n\tsize_t sz, allocated;\n\tuint64_t epoch, nmalloc, ndalloc, nrequests;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\tno_lazy_lock(); /* Lazy locking would dodge tcache testing. */\n\n\tp = mallocx(SC_SMALL_MAXCLASS, MALLOCX_ARENA(0));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\texpect_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t opt_tcache ? 0 : EFAULT, \"Unexpected mallctl() result\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.small.allocated\",\n\t (void *)&allocated, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(uint64_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.small.nmalloc\", (void *)&nmalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.small.ndalloc\", (void *)&ndalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.small.nrequests\",\n\t (void *)&nrequests, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_zu_gt(allocated, 0,\n\t\t \"allocated should be greater than zero\");\n\t\texpect_u64_gt(nmalloc, 0,\n\t\t \"nmalloc should be no greater than zero\");\n\t\texpect_u64_ge(nmalloc, ndalloc,\n\t\t \"nmalloc should be at least as large as ndalloc\");\n\t\texpect_u64_gt(nrequests, 0,\n\t\t \"nrequests should be greater than zero\");\n\t}\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_stats_arenas_large) {\n\tvoid *p;\n\tsize_t sz, allocated;\n\tuint64_t epoch, nmalloc, ndalloc;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\tp = mallocx((1U << SC_LG_LARGE_MINCLASS), MALLOCX_ARENA(0));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.allocated\",\n\t (void *)&allocated, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(uint64_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.nmalloc\", (void *)&nmalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.large.ndalloc\", (void *)&ndalloc,\n\t &sz, NULL, 0), expected, \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_zu_gt(allocated, 0,\n\t\t \"allocated should be greater than zero\");\n\t\texpect_u64_gt(nmalloc, 0,\n\t\t \"nmalloc should be greater than zero\");\n\t\texpect_u64_ge(nmalloc, ndalloc,\n\t\t \"nmalloc should be at least as large as ndalloc\");\n\t}\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nstatic void\ngen_mallctl_str(char *cmd, char *name, unsigned arena_ind) {\n\tsprintf(cmd, \"stats.arenas.%u.bins.0.%s\", arena_ind, name);\n}\n\nTEST_BEGIN(test_stats_arenas_bins) {\n\tvoid *p;\n\tsize_t sz, curslabs, curregs, nonfull_slabs;\n\tuint64_t epoch, nmalloc, ndalloc, nrequests, nfills, nflushes;\n\tuint64_t nslabs, nreslabs;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\t/* Make sure allocation below isn't satisfied by tcache. */\n\texpect_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t opt_tcache ? 0 : EFAULT, \"Unexpected mallctl() result\");\n\n\tunsigned arena_ind, old_arena_ind;\n\tsz = sizeof(unsigned);\n\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind, &sz, NULL, 0),\n\t 0, \"Arena creation failure\");\n\tsz = sizeof(arena_ind);\n\texpect_d_eq(mallctl(\"thread.arena\", (void *)&old_arena_ind, &sz,\n\t (void *)&arena_ind, sizeof(arena_ind)), 0,\n\t \"Unexpected mallctl() failure\");\n\n\tp = malloc(bin_infos[0].reg_size);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\n\texpect_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t opt_tcache ? 0 : EFAULT, \"Unexpected mallctl() result\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tchar cmd[128];\n\tsz = sizeof(uint64_t);\n\tgen_mallctl_str(cmd, \"nmalloc\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nmalloc, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tgen_mallctl_str(cmd, \"ndalloc\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&ndalloc, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tgen_mallctl_str(cmd, \"nrequests\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nrequests, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(size_t);\n\tgen_mallctl_str(cmd, \"curregs\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&curregs, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\n\tsz = sizeof(uint64_t);\n\tgen_mallctl_str(cmd, \"nfills\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nfills, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tgen_mallctl_str(cmd, \"nflushes\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nflushes, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\n\tgen_mallctl_str(cmd, \"nslabs\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nslabs, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tgen_mallctl_str(cmd, \"nreslabs\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nreslabs, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(size_t);\n\tgen_mallctl_str(cmd, \"curslabs\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&curslabs, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tgen_mallctl_str(cmd, \"nonfull_slabs\", arena_ind);\n\texpect_d_eq(mallctl(cmd, (void *)&nonfull_slabs, &sz, NULL, 0),\n\t expected, \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_u64_gt(nmalloc, 0,\n\t\t \"nmalloc should be greater than zero\");\n\t\texpect_u64_ge(nmalloc, ndalloc,\n\t\t \"nmalloc should be at least as large as ndalloc\");\n\t\texpect_u64_gt(nrequests, 0,\n\t\t \"nrequests should be greater than zero\");\n\t\texpect_zu_gt(curregs, 0,\n\t\t \"allocated should be greater than zero\");\n\t\tif (opt_tcache) {\n\t\t\texpect_u64_gt(nfills, 0,\n\t\t\t \"At least one fill should have occurred\");\n\t\t\texpect_u64_gt(nflushes, 0,\n\t\t\t \"At least one flush should have occurred\");\n\t\t}\n\t\texpect_u64_gt(nslabs, 0,\n\t\t \"At least one slab should have been allocated\");\n\t\texpect_zu_gt(curslabs, 0,\n\t\t \"At least one slab should be currently allocated\");\n\t\texpect_zu_eq(nonfull_slabs, 0,\n\t\t \"slabs_nonfull should be empty\");\n\t}\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_stats_arenas_lextents) {\n\tvoid *p;\n\tuint64_t epoch, nmalloc, ndalloc;\n\tsize_t curlextents, sz, hsize;\n\tint expected = config_stats ? 0 : ENOENT;\n\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&hsize, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() failure\");\n\n\tp = mallocx(hsize, MALLOCX_ARENA(0));\n\texpect_ptr_not_null(p, \"Unexpected mallocx() failure\");\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsz = sizeof(uint64_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.lextents.0.nmalloc\",\n\t (void *)&nmalloc, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\texpect_d_eq(mallctl(\"stats.arenas.0.lextents.0.ndalloc\",\n\t (void *)&ndalloc, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\tsz = sizeof(size_t);\n\texpect_d_eq(mallctl(\"stats.arenas.0.lextents.0.curlextents\",\n\t (void *)&curlextents, &sz, NULL, 0), expected,\n\t \"Unexpected mallctl() result\");\n\n\tif (config_stats) {\n\t\texpect_u64_gt(nmalloc, 0,\n\t\t \"nmalloc should be greater than zero\");\n\t\texpect_u64_ge(nmalloc, ndalloc,\n\t\t \"nmalloc should be at least as large as ndalloc\");\n\t\texpect_u64_gt(curlextents, 0,\n\t\t \"At least one extent should be currently allocated\");\n\t}\n\n\tdallocx(p, 0);\n}\nTEST_END\n\nstatic void\ntest_tcache_bytes_for_usize(size_t usize) {\n\tuint64_t epoch;\n\tsize_t tcache_bytes, tcache_stashed_bytes;\n\tsize_t sz = sizeof(tcache_bytes);\n\n\tvoid *ptr = mallocx(usize, 0);\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL) \".tcache_bytes\",\n\t &tcache_bytes, &sz, NULL, 0), 0, \"Unexpected mallctl failure\");\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL)\n\t \".tcache_stashed_bytes\", &tcache_stashed_bytes, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\tsize_t tcache_bytes_before = tcache_bytes + tcache_stashed_bytes;\n\tdallocx(ptr, 0);\n\n\texpect_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL) \".tcache_bytes\",\n\t &tcache_bytes, &sz, NULL, 0), 0, \"Unexpected mallctl failure\");\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL)\n\t \".tcache_stashed_bytes\", &tcache_stashed_bytes, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\tsize_t tcache_bytes_after = tcache_bytes + tcache_stashed_bytes;\n\tassert_zu_eq(tcache_bytes_after - tcache_bytes_before,\n\t usize, \"Incorrectly attributed a free\");\n}\n\nTEST_BEGIN(test_stats_tcache_bytes_small) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(!opt_tcache);\n\ttest_skip_if(opt_tcache_max < SC_SMALL_MAXCLASS);\n\n\ttest_tcache_bytes_for_usize(SC_SMALL_MAXCLASS);\n}\nTEST_END\n\nTEST_BEGIN(test_stats_tcache_bytes_large) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(!opt_tcache);\n\ttest_skip_if(opt_tcache_max < SC_LARGE_MINCLASS);\n\n\ttest_tcache_bytes_for_usize(SC_LARGE_MINCLASS);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test_no_reentrancy(\n\t test_stats_summary,\n\t test_stats_large,\n\t test_stats_arenas_summary,\n\t test_stats_arenas_small,\n\t test_stats_arenas_large,\n\t test_stats_arenas_bins,\n\t test_stats_arenas_lextents,\n\t test_stats_tcache_bytes_small,\n\t test_stats_tcache_bytes_large);\n}\n" }, { "path": "deps/jemalloc/test/unit/stats_print.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/util.h\"\n\ntypedef enum {\n\tTOKEN_TYPE_NONE,\n\tTOKEN_TYPE_ERROR,\n\tTOKEN_TYPE_EOI,\n\tTOKEN_TYPE_NULL,\n\tTOKEN_TYPE_FALSE,\n\tTOKEN_TYPE_TRUE,\n\tTOKEN_TYPE_LBRACKET,\n\tTOKEN_TYPE_RBRACKET,\n\tTOKEN_TYPE_LBRACE,\n\tTOKEN_TYPE_RBRACE,\n\tTOKEN_TYPE_COLON,\n\tTOKEN_TYPE_COMMA,\n\tTOKEN_TYPE_STRING,\n\tTOKEN_TYPE_NUMBER\n} token_type_t;\n\ntypedef struct parser_s parser_t;\ntypedef struct {\n\tparser_t\t*parser;\n\ttoken_type_t\ttoken_type;\n\tsize_t\t\tpos;\n\tsize_t\t\tlen;\n\tsize_t\t\tline;\n\tsize_t\t\tcol;\n} token_t;\n\nstruct parser_s {\n\tbool verbose;\n\tchar\t*buf; /* '\\0'-terminated. */\n\tsize_t\tlen; /* Number of characters preceding '\\0' in buf. */\n\tsize_t\tpos;\n\tsize_t\tline;\n\tsize_t\tcol;\n\ttoken_t\ttoken;\n};\n\nstatic void\ntoken_init(token_t *token, parser_t *parser, token_type_t token_type,\n size_t pos, size_t len, size_t line, size_t col) {\n\ttoken->parser = parser;\n\ttoken->token_type = token_type;\n\ttoken->pos = pos;\n\ttoken->len = len;\n\ttoken->line = line;\n\ttoken->col = col;\n}\n\nstatic void\ntoken_error(token_t *token) {\n\tif (!token->parser->verbose) {\n\t\treturn;\n\t}\n\tswitch (token->token_type) {\n\tcase TOKEN_TYPE_NONE:\n\t\tnot_reached();\n\tcase TOKEN_TYPE_ERROR:\n\t\tmalloc_printf(\"%zu:%zu: Unexpected character in token: \",\n\t\t token->line, token->col);\n\t\tbreak;\n\tdefault:\n\t\tmalloc_printf(\"%zu:%zu: Unexpected token: \", token->line,\n\t\t token->col);\n\t\tbreak;\n\t}\n\tUNUSED ssize_t err = malloc_write_fd(STDERR_FILENO,\n\t &token->parser->buf[token->pos], token->len);\n\tmalloc_printf(\"\\n\");\n}\n\nstatic void\nparser_init(parser_t *parser, bool verbose) {\n\tparser->verbose = verbose;\n\tparser->buf = NULL;\n\tparser->len = 0;\n\tparser->pos = 0;\n\tparser->line = 1;\n\tparser->col = 0;\n}\n\nstatic void\nparser_fini(parser_t *parser) {\n\tif (parser->buf != NULL) {\n\t\tdallocx(parser->buf, MALLOCX_TCACHE_NONE);\n\t}\n}\n\nstatic bool\nparser_append(parser_t *parser, const char *str) {\n\tsize_t len = strlen(str);\n\tchar *buf = (parser->buf == NULL) ? mallocx(len + 1,\n\t MALLOCX_TCACHE_NONE) : rallocx(parser->buf, parser->len + len + 1,\n\t MALLOCX_TCACHE_NONE);\n\tif (buf == NULL) {\n\t\treturn true;\n\t}\n\tmemcpy(&buf[parser->len], str, len + 1);\n\tparser->buf = buf;\n\tparser->len += len;\n\treturn false;\n}\n\nstatic bool\nparser_tokenize(parser_t *parser) {\n\tenum {\n\t\tSTATE_START,\n\t\tSTATE_EOI,\n\t\tSTATE_N, STATE_NU, STATE_NUL, STATE_NULL,\n\t\tSTATE_F, STATE_FA, STATE_FAL, STATE_FALS, STATE_FALSE,\n\t\tSTATE_T, STATE_TR, STATE_TRU, STATE_TRUE,\n\t\tSTATE_LBRACKET,\n\t\tSTATE_RBRACKET,\n\t\tSTATE_LBRACE,\n\t\tSTATE_RBRACE,\n\t\tSTATE_COLON,\n\t\tSTATE_COMMA,\n\t\tSTATE_CHARS,\n\t\tSTATE_CHAR_ESCAPE,\n\t\tSTATE_CHAR_U, STATE_CHAR_UD, STATE_CHAR_UDD, STATE_CHAR_UDDD,\n\t\tSTATE_STRING,\n\t\tSTATE_MINUS,\n\t\tSTATE_LEADING_ZERO,\n\t\tSTATE_DIGITS,\n\t\tSTATE_DECIMAL,\n\t\tSTATE_FRAC_DIGITS,\n\t\tSTATE_EXP,\n\t\tSTATE_EXP_SIGN,\n\t\tSTATE_EXP_DIGITS,\n\t\tSTATE_ACCEPT\n\t} state = STATE_START;\n\tsize_t token_pos JEMALLOC_CC_SILENCE_INIT(0);\n\tsize_t token_line JEMALLOC_CC_SILENCE_INIT(1);\n\tsize_t token_col JEMALLOC_CC_SILENCE_INIT(0);\n\n\texpect_zu_le(parser->pos, parser->len,\n\t \"Position is past end of buffer\");\n\n\twhile (state != STATE_ACCEPT) {\n\t\tchar c = parser->buf[parser->pos];\n\n\t\tswitch (state) {\n\t\tcase STATE_START:\n\t\t\ttoken_pos = parser->pos;\n\t\t\ttoken_line = parser->line;\n\t\t\ttoken_col = parser->col;\n\t\t\tswitch (c) {\n\t\t\tcase ' ': case '\\b': case '\\n': case '\\r': case '\\t':\n\t\t\t\tbreak;\n\t\t\tcase '\\0':\n\t\t\t\tstate = STATE_EOI;\n\t\t\t\tbreak;\n\t\t\tcase 'n':\n\t\t\t\tstate = STATE_N;\n\t\t\t\tbreak;\n\t\t\tcase 'f':\n\t\t\t\tstate = STATE_F;\n\t\t\t\tbreak;\n\t\t\tcase 't':\n\t\t\t\tstate = STATE_T;\n\t\t\t\tbreak;\n\t\t\tcase '[':\n\t\t\t\tstate = STATE_LBRACKET;\n\t\t\t\tbreak;\n\t\t\tcase ']':\n\t\t\t\tstate = STATE_RBRACKET;\n\t\t\t\tbreak;\n\t\t\tcase '{':\n\t\t\t\tstate = STATE_LBRACE;\n\t\t\t\tbreak;\n\t\t\tcase '}':\n\t\t\t\tstate = STATE_RBRACE;\n\t\t\t\tbreak;\n\t\t\tcase ':':\n\t\t\t\tstate = STATE_COLON;\n\t\t\t\tbreak;\n\t\t\tcase ',':\n\t\t\t\tstate = STATE_COMMA;\n\t\t\t\tbreak;\n\t\t\tcase '\"':\n\t\t\t\tstate = STATE_CHARS;\n\t\t\t\tbreak;\n\t\t\tcase '-':\n\t\t\t\tstate = STATE_MINUS;\n\t\t\t\tbreak;\n\t\t\tcase '0':\n\t\t\t\tstate = STATE_LEADING_ZERO;\n\t\t\t\tbreak;\n\t\t\tcase '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tstate = STATE_DIGITS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_EOI:\n\t\t\ttoken_init(&parser->token, parser,\n\t\t\t TOKEN_TYPE_EOI, token_pos, parser->pos -\n\t\t\t token_pos, token_line, token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_N:\n\t\t\tswitch (c) {\n\t\t\tcase 'u':\n\t\t\t\tstate = STATE_NU;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_NU:\n\t\t\tswitch (c) {\n\t\t\tcase 'l':\n\t\t\t\tstate = STATE_NUL;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_NUL:\n\t\t\tswitch (c) {\n\t\t\tcase 'l':\n\t\t\t\tstate = STATE_NULL;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_NULL:\n\t\t\tswitch (c) {\n\t\t\tcase ' ': case '\\b': case '\\n': case '\\r': case '\\t':\n\t\t\tcase '\\0':\n\t\t\tcase '[': case ']': case '{': case '}': case ':':\n\t\t\tcase ',':\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_NULL,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_F:\n\t\t\tswitch (c) {\n\t\t\tcase 'a':\n\t\t\t\tstate = STATE_FA;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_FA:\n\t\t\tswitch (c) {\n\t\t\tcase 'l':\n\t\t\t\tstate = STATE_FAL;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_FAL:\n\t\t\tswitch (c) {\n\t\t\tcase 's':\n\t\t\t\tstate = STATE_FALS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_FALS:\n\t\t\tswitch (c) {\n\t\t\tcase 'e':\n\t\t\t\tstate = STATE_FALSE;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_FALSE:\n\t\t\tswitch (c) {\n\t\t\tcase ' ': case '\\b': case '\\n': case '\\r': case '\\t':\n\t\t\tcase '\\0':\n\t\t\tcase '[': case ']': case '{': case '}': case ':':\n\t\t\tcase ',':\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoken_init(&parser->token, parser,\n\t\t\t TOKEN_TYPE_FALSE, token_pos, parser->pos -\n\t\t\t token_pos, token_line, token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_T:\n\t\t\tswitch (c) {\n\t\t\tcase 'r':\n\t\t\t\tstate = STATE_TR;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_TR:\n\t\t\tswitch (c) {\n\t\t\tcase 'u':\n\t\t\t\tstate = STATE_TRU;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_TRU:\n\t\t\tswitch (c) {\n\t\t\tcase 'e':\n\t\t\t\tstate = STATE_TRUE;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_TRUE:\n\t\t\tswitch (c) {\n\t\t\tcase ' ': case '\\b': case '\\n': case '\\r': case '\\t':\n\t\t\tcase '\\0':\n\t\t\tcase '[': case ']': case '{': case '}': case ':':\n\t\t\tcase ',':\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_TRUE,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_LBRACKET:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_LBRACKET,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_RBRACKET:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_RBRACKET,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_LBRACE:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_LBRACE,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_RBRACE:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_RBRACE,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_COLON:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_COLON,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_COMMA:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_COMMA,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_CHARS:\n\t\t\tswitch (c) {\n\t\t\tcase '\\\\':\n\t\t\t\tstate = STATE_CHAR_ESCAPE;\n\t\t\t\tbreak;\n\t\t\tcase '\"':\n\t\t\t\tstate = STATE_STRING;\n\t\t\t\tbreak;\n\t\t\tcase 0x00: case 0x01: case 0x02: case 0x03: case 0x04:\n\t\t\tcase 0x05: case 0x06: case 0x07: case 0x08: case 0x09:\n\t\t\tcase 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e:\n\t\t\tcase 0x0f: case 0x10: case 0x11: case 0x12: case 0x13:\n\t\t\tcase 0x14: case 0x15: case 0x16: case 0x17: case 0x18:\n\t\t\tcase 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d:\n\t\t\tcase 0x1e: case 0x1f:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_CHAR_ESCAPE:\n\t\t\tswitch (c) {\n\t\t\tcase '\"': case '\\\\': case '/': case 'b': case 'n':\n\t\t\tcase 'r': case 't':\n\t\t\t\tstate = STATE_CHARS;\n\t\t\t\tbreak;\n\t\t\tcase 'u':\n\t\t\t\tstate = STATE_CHAR_U;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_CHAR_U:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\tcase 'a': case 'b': case 'c': case 'd': case 'e':\n\t\t\tcase 'f':\n\t\t\tcase 'A': case 'B': case 'C': case 'D': case 'E':\n\t\t\tcase 'F':\n\t\t\t\tstate = STATE_CHAR_UD;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_CHAR_UD:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\tcase 'a': case 'b': case 'c': case 'd': case 'e':\n\t\t\tcase 'f':\n\t\t\tcase 'A': case 'B': case 'C': case 'D': case 'E':\n\t\t\tcase 'F':\n\t\t\t\tstate = STATE_CHAR_UDD;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_CHAR_UDD:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\tcase 'a': case 'b': case 'c': case 'd': case 'e':\n\t\t\tcase 'f':\n\t\t\tcase 'A': case 'B': case 'C': case 'D': case 'E':\n\t\t\tcase 'F':\n\t\t\t\tstate = STATE_CHAR_UDDD;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_CHAR_UDDD:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\tcase 'a': case 'b': case 'c': case 'd': case 'e':\n\t\t\tcase 'f':\n\t\t\tcase 'A': case 'B': case 'C': case 'D': case 'E':\n\t\t\tcase 'F':\n\t\t\t\tstate = STATE_CHARS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_STRING:\n\t\t\ttoken_init(&parser->token, parser, TOKEN_TYPE_STRING,\n\t\t\t token_pos, parser->pos - token_pos, token_line,\n\t\t\t token_col);\n\t\t\tstate = STATE_ACCEPT;\n\t\t\tbreak;\n\t\tcase STATE_MINUS:\n\t\t\tswitch (c) {\n\t\t\tcase '0':\n\t\t\t\tstate = STATE_LEADING_ZERO;\n\t\t\t\tbreak;\n\t\t\tcase '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tstate = STATE_DIGITS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_LEADING_ZERO:\n\t\t\tswitch (c) {\n\t\t\tcase '.':\n\t\t\t\tstate = STATE_DECIMAL;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_NUMBER, token_pos, parser->pos -\n\t\t\t\t token_pos, token_line, token_col);\n\t\t\t\tstate = STATE_ACCEPT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_DIGITS:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tbreak;\n\t\t\tcase '.':\n\t\t\t\tstate = STATE_DECIMAL;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_NUMBER, token_pos, parser->pos -\n\t\t\t\t token_pos, token_line, token_col);\n\t\t\t\tstate = STATE_ACCEPT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_DECIMAL:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tstate = STATE_FRAC_DIGITS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_FRAC_DIGITS:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tbreak;\n\t\t\tcase 'e': case 'E':\n\t\t\t\tstate = STATE_EXP;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_NUMBER, token_pos, parser->pos -\n\t\t\t\t token_pos, token_line, token_col);\n\t\t\t\tstate = STATE_ACCEPT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_EXP:\n\t\t\tswitch (c) {\n\t\t\tcase '-': case '+':\n\t\t\t\tstate = STATE_EXP_SIGN;\n\t\t\t\tbreak;\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tstate = STATE_EXP_DIGITS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_EXP_SIGN:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tstate = STATE_EXP_DIGITS;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_ERROR, token_pos, parser->pos + 1\n\t\t\t\t - token_pos, token_line, token_col);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase STATE_EXP_DIGITS:\n\t\t\tswitch (c) {\n\t\t\tcase '0': case '1': case '2': case '3': case '4':\n\t\t\tcase '5': case '6': case '7': case '8': case '9':\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\ttoken_init(&parser->token, parser,\n\t\t\t\t TOKEN_TYPE_NUMBER, token_pos, parser->pos -\n\t\t\t\t token_pos, token_line, token_col);\n\t\t\t\tstate = STATE_ACCEPT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tnot_reached();\n\t\t}\n\n\t\tif (state != STATE_ACCEPT) {\n\t\t\tif (c == '\\n') {\n\t\t\t\tparser->line++;\n\t\t\t\tparser->col = 0;\n\t\t\t} else {\n\t\t\t\tparser->col++;\n\t\t\t}\n\t\t\tparser->pos++;\n\t\t}\n\t}\n\treturn false;\n}\n\nstatic bool\tparser_parse_array(parser_t *parser);\nstatic bool\tparser_parse_object(parser_t *parser);\n\nstatic bool\nparser_parse_value(parser_t *parser) {\n\tswitch (parser->token.token_type) {\n\tcase TOKEN_TYPE_NULL:\n\tcase TOKEN_TYPE_FALSE:\n\tcase TOKEN_TYPE_TRUE:\n\tcase TOKEN_TYPE_STRING:\n\tcase TOKEN_TYPE_NUMBER:\n\t\treturn false;\n\tcase TOKEN_TYPE_LBRACE:\n\t\treturn parser_parse_object(parser);\n\tcase TOKEN_TYPE_LBRACKET:\n\t\treturn parser_parse_array(parser);\n\tdefault:\n\t\treturn true;\n\t}\n\tnot_reached();\n}\n\nstatic bool\nparser_parse_pair(parser_t *parser) {\n\texpect_d_eq(parser->token.token_type, TOKEN_TYPE_STRING,\n\t \"Pair should start with string\");\n\tif (parser_tokenize(parser)) {\n\t\treturn true;\n\t}\n\tswitch (parser->token.token_type) {\n\tcase TOKEN_TYPE_COLON:\n\t\tif (parser_tokenize(parser)) {\n\t\t\treturn true;\n\t\t}\n\t\treturn parser_parse_value(parser);\n\tdefault:\n\t\treturn true;\n\t}\n}\n\nstatic bool\nparser_parse_values(parser_t *parser) {\n\tif (parser_parse_value(parser)) {\n\t\treturn true;\n\t}\n\n\twhile (true) {\n\t\tif (parser_tokenize(parser)) {\n\t\t\treturn true;\n\t\t}\n\t\tswitch (parser->token.token_type) {\n\t\tcase TOKEN_TYPE_COMMA:\n\t\t\tif (parser_tokenize(parser)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tif (parser_parse_value(parser)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase TOKEN_TYPE_RBRACKET:\n\t\t\treturn false;\n\t\tdefault:\n\t\t\treturn true;\n\t\t}\n\t}\n}\n\nstatic bool\nparser_parse_array(parser_t *parser) {\n\texpect_d_eq(parser->token.token_type, TOKEN_TYPE_LBRACKET,\n\t \"Array should start with [\");\n\tif (parser_tokenize(parser)) {\n\t\treturn true;\n\t}\n\tswitch (parser->token.token_type) {\n\tcase TOKEN_TYPE_RBRACKET:\n\t\treturn false;\n\tdefault:\n\t\treturn parser_parse_values(parser);\n\t}\n\tnot_reached();\n}\n\nstatic bool\nparser_parse_pairs(parser_t *parser) {\n\texpect_d_eq(parser->token.token_type, TOKEN_TYPE_STRING,\n\t \"Object should start with string\");\n\tif (parser_parse_pair(parser)) {\n\t\treturn true;\n\t}\n\n\twhile (true) {\n\t\tif (parser_tokenize(parser)) {\n\t\t\treturn true;\n\t\t}\n\t\tswitch (parser->token.token_type) {\n\t\tcase TOKEN_TYPE_COMMA:\n\t\t\tif (parser_tokenize(parser)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tswitch (parser->token.token_type) {\n\t\t\tcase TOKEN_TYPE_STRING:\n\t\t\t\tif (parser_parse_pair(parser)) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tbreak;\n\t\tcase TOKEN_TYPE_RBRACE:\n\t\t\treturn false;\n\t\tdefault:\n\t\t\treturn true;\n\t\t}\n\t}\n}\n\nstatic bool\nparser_parse_object(parser_t *parser) {\n\texpect_d_eq(parser->token.token_type, TOKEN_TYPE_LBRACE,\n\t \"Object should start with {\");\n\tif (parser_tokenize(parser)) {\n\t\treturn true;\n\t}\n\tswitch (parser->token.token_type) {\n\tcase TOKEN_TYPE_STRING:\n\t\treturn parser_parse_pairs(parser);\n\tcase TOKEN_TYPE_RBRACE:\n\t\treturn false;\n\tdefault:\n\t\treturn true;\n\t}\n\tnot_reached();\n}\n\nstatic bool\nparser_parse(parser_t *parser) {\n\tif (parser_tokenize(parser)) {\n\t\tgoto label_error;\n\t}\n\tif (parser_parse_value(parser)) {\n\t\tgoto label_error;\n\t}\n\n\tif (parser_tokenize(parser)) {\n\t\tgoto label_error;\n\t}\n\tswitch (parser->token.token_type) {\n\tcase TOKEN_TYPE_EOI:\n\t\treturn false;\n\tdefault:\n\t\tgoto label_error;\n\t}\n\tnot_reached();\n\nlabel_error:\n\ttoken_error(&parser->token);\n\treturn true;\n}\n\nTEST_BEGIN(test_json_parser) {\n\tsize_t i;\n\tconst char *invalid_inputs[] = {\n\t\t/* Tokenizer error case tests. */\n\t\t\"{ \\\"string\\\": X }\",\n\t\t\"{ \\\"string\\\": nXll }\",\n\t\t\"{ \\\"string\\\": nuXl }\",\n\t\t\"{ \\\"string\\\": nulX }\",\n\t\t\"{ \\\"string\\\": nullX }\",\n\t\t\"{ \\\"string\\\": fXlse }\",\n\t\t\"{ \\\"string\\\": faXse }\",\n\t\t\"{ \\\"string\\\": falXe }\",\n\t\t\"{ \\\"string\\\": falsX }\",\n\t\t\"{ \\\"string\\\": falseX }\",\n\t\t\"{ \\\"string\\\": tXue }\",\n\t\t\"{ \\\"string\\\": trXe }\",\n\t\t\"{ \\\"string\\\": truX }\",\n\t\t\"{ \\\"string\\\": trueX }\",\n\t\t\"{ \\\"string\\\": \\\"\\n\\\" }\",\n\t\t\"{ \\\"string\\\": \\\"\\\\z\\\" }\",\n\t\t\"{ \\\"string\\\": \\\"\\\\uX000\\\" }\",\n\t\t\"{ \\\"string\\\": \\\"\\\\u0X00\\\" }\",\n\t\t\"{ \\\"string\\\": \\\"\\\\u00X0\\\" }\",\n\t\t\"{ \\\"string\\\": \\\"\\\\u000X\\\" }\",\n\t\t\"{ \\\"string\\\": -X }\",\n\t\t\"{ \\\"string\\\": 0.X }\",\n\t\t\"{ \\\"string\\\": 0.0eX }\",\n\t\t\"{ \\\"string\\\": 0.0e+X }\",\n\n\t\t/* Parser error test cases. */\n\t\t\"{\\\"string\\\": }\",\n\t\t\"{\\\"string\\\" }\",\n\t\t\"{\\\"string\\\": [ 0 }\",\n\t\t\"{\\\"string\\\": {\\\"a\\\":0, 1 } }\",\n\t\t\"{\\\"string\\\": {\\\"a\\\":0: } }\",\n\t\t\"{\",\n\t\t\"{}{\",\n\t};\n\tconst char *valid_inputs[] = {\n\t\t/* Token tests. */\n\t\t\"null\",\n\t\t\"false\",\n\t\t\"true\",\n\t\t\"{}\",\n\t\t\"{\\\"a\\\": 0}\",\n\t\t\"[]\",\n\t\t\"[0, 1]\",\n\t\t\"0\",\n\t\t\"1\",\n\t\t\"10\",\n\t\t\"-10\",\n\t\t\"10.23\",\n\t\t\"10.23e4\",\n\t\t\"10.23e-4\",\n\t\t\"10.23e+4\",\n\t\t\"10.23E4\",\n\t\t\"10.23E-4\",\n\t\t\"10.23E+4\",\n\t\t\"-10.23\",\n\t\t\"-10.23e4\",\n\t\t\"-10.23e-4\",\n\t\t\"-10.23e+4\",\n\t\t\"-10.23E4\",\n\t\t\"-10.23E-4\",\n\t\t\"-10.23E+4\",\n\t\t\"\\\"value\\\"\",\n\t\t\"\\\" \\\\\\\" \\\\/ \\\\b \\\\n \\\\r \\\\t \\\\u0abc \\\\u1DEF \\\"\",\n\n\t\t/* Parser test with various nesting. */\n\t\t\"{\\\"a\\\":null, \\\"b\\\":[1,[{\\\"c\\\":2},3]], \\\"d\\\":{\\\"e\\\":true}}\",\n\t};\n\n\tfor (i = 0; i < sizeof(invalid_inputs)/sizeof(const char *); i++) {\n\t\tconst char *input = invalid_inputs[i];\n\t\tparser_t parser;\n\t\tparser_init(&parser, false);\n\t\texpect_false(parser_append(&parser, input),\n\t\t \"Unexpected input appending failure\");\n\t\texpect_true(parser_parse(&parser),\n\t\t \"Unexpected parse success for input: %s\", input);\n\t\tparser_fini(&parser);\n\t}\n\n\tfor (i = 0; i < sizeof(valid_inputs)/sizeof(const char *); i++) {\n\t\tconst char *input = valid_inputs[i];\n\t\tparser_t parser;\n\t\tparser_init(&parser, true);\n\t\texpect_false(parser_append(&parser, input),\n\t\t \"Unexpected input appending failure\");\n\t\texpect_false(parser_parse(&parser),\n\t\t \"Unexpected parse error for input: %s\", input);\n\t\tparser_fini(&parser);\n\t}\n}\nTEST_END\n\nvoid\nwrite_cb(void *opaque, const char *str) {\n\tparser_t *parser = (parser_t *)opaque;\n\tif (parser_append(parser, str)) {\n\t\ttest_fail(\"Unexpected input appending failure\");\n\t}\n}\n\nTEST_BEGIN(test_stats_print_json) {\n\tconst char *opts[] = {\n\t\t\"J\",\n\t\t\"Jg\",\n\t\t\"Jm\",\n\t\t\"Jd\",\n\t\t\"Jmd\",\n\t\t\"Jgd\",\n\t\t\"Jgm\",\n\t\t\"Jgmd\",\n\t\t\"Ja\",\n\t\t\"Jb\",\n\t\t\"Jl\",\n\t\t\"Jx\",\n\t\t\"Jbl\",\n\t\t\"Jal\",\n\t\t\"Jab\",\n\t\t\"Jabl\",\n\t\t\"Jax\",\n\t\t\"Jbx\",\n\t\t\"Jlx\",\n\t\t\"Jablx\",\n\t\t\"Jgmdablx\",\n\t};\n\tunsigned arena_ind, i;\n\n\tfor (i = 0; i < 3; i++) {\n\t\tunsigned j;\n\n\t\tswitch (i) {\n\t\tcase 0:\n\t\t\tbreak;\n\t\tcase 1: {\n\t\t\tsize_t sz = sizeof(arena_ind);\n\t\t\texpect_d_eq(mallctl(\"arenas.create\", (void *)&arena_ind,\n\t\t\t &sz, NULL, 0), 0, \"Unexpected mallctl failure\");\n\t\t\tbreak;\n\t\t} case 2: {\n\t\t\tsize_t mib[3];\n\t\t\tsize_t miblen = sizeof(mib)/sizeof(size_t);\n\t\t\texpect_d_eq(mallctlnametomib(\"arena.0.destroy\",\n\t\t\t mib, &miblen), 0,\n\t\t\t \"Unexpected mallctlnametomib failure\");\n\t\t\tmib[1] = arena_ind;\n\t\t\texpect_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL,\n\t\t\t 0), 0, \"Unexpected mallctlbymib failure\");\n\t\t\tbreak;\n\t\t} default:\n\t\t\tnot_reached();\n\t\t}\n\n\t\tfor (j = 0; j < sizeof(opts)/sizeof(const char *); j++) {\n\t\t\tparser_t parser;\n\n\t\t\tparser_init(&parser, true);\n\t\t\tmalloc_stats_print(write_cb, (void *)&parser, opts[j]);\n\t\t\texpect_false(parser_parse(&parser),\n\t\t\t \"Unexpected parse error, opts=\\\"%s\\\"\", opts[j]);\n\t\t\tparser_fini(&parser);\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_json_parser,\n\t test_stats_print_json);\n}\n" }, { "path": "deps/jemalloc/test/unit/sz.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_sz_psz2ind) {\n\t/*\n\t * Testing page size classes which reside prior to the regular group\n\t * with all size classes divisible by page size.\n\t * For x86_64 Linux, it's 4096, 8192, 12288, 16384, with corresponding\n\t * pszind 0, 1, 2 and 3.\n\t */\n\tfor (size_t i = 0; i < SC_NGROUP; i++) {\n\t\tfor (size_t psz = i * PAGE + 1; psz <= (i + 1) * PAGE; psz++) {\n\t\t\tpszind_t ind = sz_psz2ind(psz);\n\t\t\texpect_zu_eq(ind, i, \"Got %u as sz_psz2ind of %zu\", ind,\n\t\t\t psz);\n\t\t}\n\t}\n\n\tsc_data_t data;\n\tmemset(&data, 0, sizeof(data));\n\tsc_data_init(&data);\n\t/*\n\t * 'base' is the base of the first regular group with all size classes\n\t * divisible by page size.\n\t * For x86_64 Linux, it's 16384, and base_ind is 36.\n\t */\n\tsize_t base_psz = 1 << (SC_LG_NGROUP + LG_PAGE);\n\tsize_t base_ind = 0;\n\twhile (base_ind < SC_NSIZES &&\n\t reg_size_compute(data.sc[base_ind].lg_base,\n\t\tdata.sc[base_ind].lg_delta,\n\t\tdata.sc[base_ind].ndelta) < base_psz) {\n\t\tbase_ind++;\n\t}\n\texpect_zu_eq(\n\t reg_size_compute(data.sc[base_ind].lg_base,\n\t\tdata.sc[base_ind].lg_delta, data.sc[base_ind].ndelta),\n\t base_psz, \"Size class equal to %zu not found\", base_psz);\n\t/*\n\t * Test different sizes falling into groups after the 'base'. The\n\t * increment is PAGE / 3 for the execution speed purpose.\n\t */\n\tbase_ind -= SC_NGROUP;\n\tfor (size_t psz = base_psz; psz <= 64 * 1024 * 1024; psz += PAGE / 3) {\n\t\tpszind_t ind = sz_psz2ind(psz);\n\t\tsc_t gt_sc = data.sc[ind + base_ind];\n\t\texpect_zu_gt(psz,\n\t\t reg_size_compute(gt_sc.lg_base, gt_sc.lg_delta,\n\t\t\tgt_sc.ndelta),\n\t\t \"Got %u as sz_psz2ind of %zu\", ind, psz);\n\t\tsc_t le_sc = data.sc[ind + base_ind + 1];\n\t\texpect_zu_le(psz,\n\t\t reg_size_compute(le_sc.lg_base, le_sc.lg_delta,\n\t\t\tle_sc.ndelta),\n\t\t \"Got %u as sz_psz2ind of %zu\", ind, psz);\n\t}\n\n\tpszind_t max_ind = sz_psz2ind(SC_LARGE_MAXCLASS + 1);\n\texpect_lu_eq(max_ind, SC_NPSIZES,\n\t \"Got %u as sz_psz2ind of %llu\", max_ind, SC_LARGE_MAXCLASS);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(test_sz_psz2ind);\n}\n" }, { "path": "deps/jemalloc/test/unit/tcache_max.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/san.h\"\n\nconst char *malloc_conf = TEST_SAN_UAF_ALIGN_DISABLE;\n\nenum {\n\talloc_option_start = 0,\n\tuse_malloc = 0,\n\tuse_mallocx,\n\talloc_option_end\n};\n\nenum {\n\tdalloc_option_start = 0,\n\tuse_free = 0,\n\tuse_dallocx,\n\tuse_sdallocx,\n\tdalloc_option_end\n};\n\nstatic unsigned alloc_option, dalloc_option;\nstatic size_t tcache_max;\n\nstatic void *\nalloc_func(size_t sz) {\n\tvoid *ret;\n\n\tswitch (alloc_option) {\n\tcase use_malloc:\n\t\tret = malloc(sz);\n\t\tbreak;\n\tcase use_mallocx:\n\t\tret = mallocx(sz, 0);\n\t\tbreak;\n\tdefault:\n\t\tunreachable();\n\t}\n\texpect_ptr_not_null(ret, \"Unexpected malloc / mallocx failure\");\n\n\treturn ret;\n}\n\nstatic void\ndalloc_func(void *ptr, size_t sz) {\n\tswitch (dalloc_option) {\n\tcase use_free:\n\t\tfree(ptr);\n\t\tbreak;\n\tcase use_dallocx:\n\t\tdallocx(ptr, 0);\n\t\tbreak;\n\tcase use_sdallocx:\n\t\tsdallocx(ptr, sz, 0);\n\t\tbreak;\n\tdefault:\n\t\tunreachable();\n\t}\n}\n\nstatic size_t\ntcache_bytes_read(void) {\n\tuint64_t epoch;\n\tassert_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsize_t tcache_bytes;\n\tsize_t sz = sizeof(tcache_bytes);\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL) \".tcache_bytes\",\n\t &tcache_bytes, &sz, NULL, 0), 0, \"Unexpected mallctl failure\");\n\n\treturn tcache_bytes;\n}\n\nstatic void\ntcache_bytes_check_update(size_t *prev, ssize_t diff) {\n\tsize_t tcache_bytes = tcache_bytes_read();\n\texpect_zu_eq(tcache_bytes, *prev + diff, \"tcache bytes not expected\");\n\n\t*prev += diff;\n}\n\nstatic void\ntest_tcache_bytes_alloc(size_t alloc_size) {\n\texpect_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0), 0,\n\t \"Unexpected tcache flush failure\");\n\n\tsize_t usize = sz_s2u(alloc_size);\n\t/* No change is expected if usize is outside of tcache_max range. */\n\tbool cached = (usize <= tcache_max);\n\tssize_t diff = cached ? usize : 0;\n\n\tvoid *ptr1 = alloc_func(alloc_size);\n\tvoid *ptr2 = alloc_func(alloc_size);\n\n\tsize_t bytes = tcache_bytes_read();\n\tdalloc_func(ptr2, alloc_size);\n\t/* Expect tcache_bytes increase after dalloc */\n\ttcache_bytes_check_update(&bytes, diff);\n\n\tdalloc_func(ptr1, alloc_size);\n\t/* Expect tcache_bytes increase again */\n\ttcache_bytes_check_update(&bytes, diff);\n\n\tvoid *ptr3 = alloc_func(alloc_size);\n\tif (cached) {\n\t\texpect_ptr_eq(ptr1, ptr3, \"Unexpected cached ptr\");\n\t}\n\t/* Expect tcache_bytes decrease after alloc */\n\ttcache_bytes_check_update(&bytes, -diff);\n\n\tvoid *ptr4 = alloc_func(alloc_size);\n\tif (cached) {\n\t\texpect_ptr_eq(ptr2, ptr4, \"Unexpected cached ptr\");\n\t}\n\t/* Expect tcache_bytes decrease again */\n\ttcache_bytes_check_update(&bytes, -diff);\n\n\tdalloc_func(ptr3, alloc_size);\n\ttcache_bytes_check_update(&bytes, diff);\n\tdalloc_func(ptr4, alloc_size);\n\ttcache_bytes_check_update(&bytes, diff);\n}\n\nstatic void\ntest_tcache_max_impl(void) {\n\tsize_t sz;\n\tsz = sizeof(tcache_max);\n\tassert_d_eq(mallctl(\"arenas.tcache_max\", (void *)&tcache_max,\n\t &sz, NULL, 0), 0, \"Unexpected mallctl() failure\");\n\n\t/* opt.tcache_max set to 1024 in tcache_max.sh */\n\texpect_zu_eq(tcache_max, 1024, \"tcache_max not expected\");\n\n\ttest_tcache_bytes_alloc(1);\n\ttest_tcache_bytes_alloc(tcache_max - 1);\n\ttest_tcache_bytes_alloc(tcache_max);\n\ttest_tcache_bytes_alloc(tcache_max + 1);\n\n\ttest_tcache_bytes_alloc(PAGE - 1);\n\ttest_tcache_bytes_alloc(PAGE);\n\ttest_tcache_bytes_alloc(PAGE + 1);\n\n\tsize_t large;\n\tsz = sizeof(large);\n\tassert_d_eq(mallctl(\"arenas.lextent.0.size\", (void *)&large, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl() failure\");\n\n\ttest_tcache_bytes_alloc(large - 1);\n\ttest_tcache_bytes_alloc(large);\n\ttest_tcache_bytes_alloc(large + 1);\n}\n\nTEST_BEGIN(test_tcache_max) {\n\ttest_skip_if(!config_stats);\n\ttest_skip_if(!opt_tcache);\n\ttest_skip_if(opt_prof);\n\ttest_skip_if(san_uaf_detection_enabled());\n\n\tfor (alloc_option = alloc_option_start;\n\t alloc_option < alloc_option_end;\n\t alloc_option++) {\n\t\tfor (dalloc_option = dalloc_option_start;\n\t\t dalloc_option < dalloc_option_end;\n\t\t dalloc_option++) {\n\t\t\ttest_tcache_max_impl();\n\t\t}\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(test_tcache_max);\n}\n" }, { "path": "deps/jemalloc/test/unit/tcache_max.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"tcache_max:1024\"\n" }, { "path": "deps/jemalloc/test/unit/test_hooks.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic bool hook_called = false;\n\nstatic void\nhook() {\n\thook_called = true;\n}\n\nstatic int\nfunc_to_hook(int arg1, int arg2) {\n\treturn arg1 + arg2;\n}\n\n#define func_to_hook JEMALLOC_TEST_HOOK(func_to_hook, test_hooks_libc_hook)\n\nTEST_BEGIN(unhooked_call) {\n\ttest_hooks_libc_hook = NULL;\n\thook_called = false;\n\texpect_d_eq(3, func_to_hook(1, 2), \"Hooking changed return value.\");\n\texpect_false(hook_called, \"Nulling out hook didn't take.\");\n}\nTEST_END\n\nTEST_BEGIN(hooked_call) {\n\ttest_hooks_libc_hook = &hook;\n\thook_called = false;\n\texpect_d_eq(3, func_to_hook(1, 2), \"Hooking changed return value.\");\n\texpect_true(hook_called, \"Hook should have executed.\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t unhooked_call,\n\t hooked_call);\n}\n" }, { "path": "deps/jemalloc/test/unit/thread_event.c", "content": "#include \"test/jemalloc_test.h\"\n\nTEST_BEGIN(test_next_event_fast) {\n\ttsd_t *tsd = tsd_fetch();\n\tte_ctx_t ctx;\n\tte_ctx_get(tsd, &ctx, true);\n\n\tte_ctx_last_event_set(&ctx, 0);\n\tte_ctx_current_bytes_set(&ctx, TE_NEXT_EVENT_FAST_MAX - 8U);\n\tte_ctx_next_event_set(tsd, &ctx, TE_NEXT_EVENT_FAST_MAX);\n#define E(event, condition, is_alloc)\t\t\t\t\t\\\n\tif (is_alloc && condition) {\t\t\t\t\t\\\n\t\tevent##_event_wait_set(tsd, TE_NEXT_EVENT_FAST_MAX);\t\\\n\t}\n\tITERATE_OVER_ALL_EVENTS\n#undef E\n\n\t/* Test next_event_fast rolling back to 0. */\n\tvoid *p = malloc(16U);\n\tassert_ptr_not_null(p, \"malloc() failed\");\n\tfree(p);\n\n\t/* Test next_event_fast resuming to be equal to next_event. */\n\tvoid *q = malloc(SC_LOOKUP_MAXCLASS);\n\tassert_ptr_not_null(q, \"malloc() failed\");\n\tfree(q);\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_next_event_fast);\n}\n" }, { "path": "deps/jemalloc/test/unit/thread_event.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_prof}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"prof:true,lg_prof_sample:0\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/ticker.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \"jemalloc/internal/ticker.h\"\n\nTEST_BEGIN(test_ticker_tick) {\n#define NREPS 2\n#define NTICKS 3\n\tticker_t ticker;\n\tint32_t i, j;\n\n\tticker_init(&ticker, NTICKS);\n\tfor (i = 0; i < NREPS; i++) {\n\t\tfor (j = 0; j < NTICKS; j++) {\n\t\t\texpect_u_eq(ticker_read(&ticker), NTICKS - j,\n\t\t\t \"Unexpected ticker value (i=%d, j=%d)\", i, j);\n\t\t\texpect_false(ticker_tick(&ticker),\n\t\t\t \"Unexpected ticker fire (i=%d, j=%d)\", i, j);\n\t\t}\n\t\texpect_u32_eq(ticker_read(&ticker), 0,\n\t\t \"Expected ticker depletion\");\n\t\texpect_true(ticker_tick(&ticker),\n\t\t \"Expected ticker fire (i=%d)\", i);\n\t\texpect_u32_eq(ticker_read(&ticker), NTICKS,\n\t\t \"Expected ticker reset\");\n\t}\n#undef NTICKS\n}\nTEST_END\n\nTEST_BEGIN(test_ticker_ticks) {\n#define NTICKS 3\n\tticker_t ticker;\n\n\tticker_init(&ticker, NTICKS);\n\n\texpect_u_eq(ticker_read(&ticker), NTICKS, \"Unexpected ticker value\");\n\texpect_false(ticker_ticks(&ticker, NTICKS), \"Unexpected ticker fire\");\n\texpect_u_eq(ticker_read(&ticker), 0, \"Unexpected ticker value\");\n\texpect_true(ticker_ticks(&ticker, NTICKS), \"Expected ticker fire\");\n\texpect_u_eq(ticker_read(&ticker), NTICKS, \"Unexpected ticker value\");\n\n\texpect_true(ticker_ticks(&ticker, NTICKS + 1), \"Expected ticker fire\");\n\texpect_u_eq(ticker_read(&ticker), NTICKS, \"Unexpected ticker value\");\n#undef NTICKS\n}\nTEST_END\n\nTEST_BEGIN(test_ticker_copy) {\n#define NTICKS 3\n\tticker_t ta, tb;\n\n\tticker_init(&ta, NTICKS);\n\tticker_copy(&tb, &ta);\n\texpect_u_eq(ticker_read(&tb), NTICKS, \"Unexpected ticker value\");\n\texpect_true(ticker_ticks(&tb, NTICKS + 1), \"Expected ticker fire\");\n\texpect_u_eq(ticker_read(&tb), NTICKS, \"Unexpected ticker value\");\n\n\tticker_tick(&ta);\n\tticker_copy(&tb, &ta);\n\texpect_u_eq(ticker_read(&tb), NTICKS - 1, \"Unexpected ticker value\");\n\texpect_true(ticker_ticks(&tb, NTICKS), \"Expected ticker fire\");\n\texpect_u_eq(ticker_read(&tb), NTICKS, \"Unexpected ticker value\");\n#undef NTICKS\n}\nTEST_END\n\nTEST_BEGIN(test_ticker_geom) {\n\tconst int32_t ticks = 100;\n\tconst uint64_t niters = 100 * 1000;\n\n\tticker_geom_t ticker;\n\tticker_geom_init(&ticker, ticks);\n\tuint64_t total_ticks = 0;\n\t/* Just some random constant. */\n\tuint64_t prng_state = 0x343219f93496db9fULL;\n\tfor (uint64_t i = 0; i < niters; i++) {\n\t\twhile(!ticker_geom_tick(&ticker, &prng_state)) {\n\t\t\ttotal_ticks++;\n\t\t}\n\t}\n\t/*\n\t * In fact, with this choice of random seed and the PRNG implementation\n\t * used at the time this was tested, total_ticks is 95.1% of the\n\t * expected ticks.\n\t */\n\texpect_u64_ge(total_ticks , niters * ticks * 9 / 10,\n\t \"Mean off by > 10%%\");\n\texpect_u64_le(total_ticks , niters * ticks * 11 / 10,\n\t \"Mean off by > 10%%\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_ticker_tick,\n\t test_ticker_ticks,\n\t test_ticker_copy,\n\t test_ticker_geom);\n}\n" }, { "path": "deps/jemalloc/test/unit/tsd.c", "content": "#include \"test/jemalloc_test.h\"\n\n/*\n * If we're e.g. in debug mode, we *never* enter the fast path, and so shouldn't\n * be asserting that we're on one.\n */\nstatic bool originally_fast;\nstatic int data_cleanup_count;\n\nvoid\ndata_cleanup(int *data) {\n\tif (data_cleanup_count == 0) {\n\t\texpect_x_eq(*data, MALLOC_TSD_TEST_DATA_INIT,\n\t\t \"Argument passed into cleanup function should match tsd \"\n\t\t \"value\");\n\t}\n\t++data_cleanup_count;\n\n\t/*\n\t * Allocate during cleanup for two rounds, in order to assure that\n\t * jemalloc's internal tsd reinitialization happens.\n\t */\n\tbool reincarnate = false;\n\tswitch (*data) {\n\tcase MALLOC_TSD_TEST_DATA_INIT:\n\t\t*data = 1;\n\t\treincarnate = true;\n\t\tbreak;\n\tcase 1:\n\t\t*data = 2;\n\t\treincarnate = true;\n\t\tbreak;\n\tcase 2:\n\t\treturn;\n\tdefault:\n\t\tnot_reached();\n\t}\n\n\tif (reincarnate) {\n\t\tvoid *p = mallocx(1, 0);\n\t\texpect_ptr_not_null(p, \"Unexpeced mallocx() failure\");\n\t\tdallocx(p, 0);\n\t}\n}\n\nstatic void *\nthd_start(void *arg) {\n\tint d = (int)(uintptr_t)arg;\n\tvoid *p;\n\n\t/*\n\t * Test free before tsd init -- the free fast path (which does not\n\t * explicitly check for NULL) has to tolerate this case, and fall back\n\t * to free_default.\n\t */\n\tfree(NULL);\n\n\ttsd_t *tsd = tsd_fetch();\n\texpect_x_eq(tsd_test_data_get(tsd), MALLOC_TSD_TEST_DATA_INIT,\n\t \"Initial tsd get should return initialization value\");\n\n\tp = malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\n\ttsd_test_data_set(tsd, d);\n\texpect_x_eq(tsd_test_data_get(tsd), d,\n\t \"After tsd set, tsd get should return value that was set\");\n\n\td = 0;\n\texpect_x_eq(tsd_test_data_get(tsd), (int)(uintptr_t)arg,\n\t \"Resetting local data should have no effect on tsd\");\n\n\ttsd_test_callback_set(tsd, &data_cleanup);\n\n\tfree(p);\n\treturn NULL;\n}\n\nTEST_BEGIN(test_tsd_main_thread) {\n\tthd_start((void *)(uintptr_t)0xa5f3e329);\n}\nTEST_END\n\nTEST_BEGIN(test_tsd_sub_thread) {\n\tthd_t thd;\n\n\tdata_cleanup_count = 0;\n\tthd_create(&thd, thd_start, (void *)MALLOC_TSD_TEST_DATA_INIT);\n\tthd_join(thd, NULL);\n\t/*\n\t * We reincarnate twice in the data cleanup, so it should execute at\n\t * least 3 times.\n\t */\n\texpect_x_ge(data_cleanup_count, 3,\n\t \"Cleanup function should have executed multiple times.\");\n}\nTEST_END\n\nstatic void *\nthd_start_reincarnated(void *arg) {\n\ttsd_t *tsd = tsd_fetch();\n\tassert(tsd);\n\n\tvoid *p = malloc(1);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\n\t/* Manually trigger reincarnation. */\n\texpect_ptr_not_null(tsd_arena_get(tsd),\n\t \"Should have tsd arena set.\");\n\ttsd_cleanup((void *)tsd);\n\texpect_ptr_null(*tsd_arenap_get_unsafe(tsd),\n\t \"TSD arena should have been cleared.\");\n\texpect_u_eq(tsd_state_get(tsd), tsd_state_purgatory,\n\t \"TSD state should be purgatory\\n\");\n\n\tfree(p);\n\texpect_u_eq(tsd_state_get(tsd), tsd_state_reincarnated,\n\t \"TSD state should be reincarnated\\n\");\n\tp = mallocx(1, MALLOCX_TCACHE_NONE);\n\texpect_ptr_not_null(p, \"Unexpected malloc() failure\");\n\texpect_ptr_null(*tsd_arenap_get_unsafe(tsd),\n\t \"Should not have tsd arena set after reincarnation.\");\n\n\tfree(p);\n\ttsd_cleanup((void *)tsd);\n\texpect_ptr_null(*tsd_arenap_get_unsafe(tsd),\n\t \"TSD arena should have been cleared after 2nd cleanup.\");\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_tsd_reincarnation) {\n\tthd_t thd;\n\tthd_create(&thd, thd_start_reincarnated, NULL);\n\tthd_join(thd, NULL);\n}\nTEST_END\n\ntypedef struct {\n\tatomic_u32_t phase;\n\tatomic_b_t error;\n} global_slow_data_t;\n\nstatic void *\nthd_start_global_slow(void *arg) {\n\t/* PHASE 0 */\n\tglobal_slow_data_t *data = (global_slow_data_t *)arg;\n\tfree(mallocx(1, 0));\n\n\ttsd_t *tsd = tsd_fetch();\n\t/*\n\t * No global slowness has happened yet; there was an error if we were\n\t * originally fast but aren't now.\n\t */\n\tatomic_store_b(&data->error, originally_fast && !tsd_fast(tsd),\n\t ATOMIC_SEQ_CST);\n\tatomic_store_u32(&data->phase, 1, ATOMIC_SEQ_CST);\n\n\t/* PHASE 2 */\n\twhile (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 2) {\n\t}\n\tfree(mallocx(1, 0));\n\tatomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);\n\tatomic_store_u32(&data->phase, 3, ATOMIC_SEQ_CST);\n\n\t/* PHASE 4 */\n\twhile (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 4) {\n\t}\n\tfree(mallocx(1, 0));\n\tatomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);\n\tatomic_store_u32(&data->phase, 5, ATOMIC_SEQ_CST);\n\n\t/* PHASE 6 */\n\twhile (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 6) {\n\t}\n\tfree(mallocx(1, 0));\n\t/* Only one decrement so far. */\n\tatomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);\n\tatomic_store_u32(&data->phase, 7, ATOMIC_SEQ_CST);\n\n\t/* PHASE 8 */\n\twhile (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 8) {\n\t}\n\tfree(mallocx(1, 0));\n\t/*\n\t * Both decrements happened; we should be fast again (if we ever\n\t * were)\n\t */\n\tatomic_store_b(&data->error, originally_fast && !tsd_fast(tsd),\n\t ATOMIC_SEQ_CST);\n\tatomic_store_u32(&data->phase, 9, ATOMIC_SEQ_CST);\n\n\treturn NULL;\n}\n\nTEST_BEGIN(test_tsd_global_slow) {\n\tglobal_slow_data_t data = {ATOMIC_INIT(0), ATOMIC_INIT(false)};\n\t/*\n\t * Note that the \"mallocx\" here (vs. malloc) is important, since the\n\t * compiler is allowed to optimize away free(malloc(1)) but not\n\t * free(mallocx(1)).\n\t */\n\tfree(mallocx(1, 0));\n\ttsd_t *tsd = tsd_fetch();\n\toriginally_fast = tsd_fast(tsd);\n\n\tthd_t thd;\n\tthd_create(&thd, thd_start_global_slow, (void *)&data.phase);\n\t/* PHASE 1 */\n\twhile (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 1) {\n\t\t/*\n\t\t * We don't have a portable condvar/semaphore mechanism.\n\t\t * Spin-wait.\n\t\t */\n\t}\n\texpect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), \"\");\n\ttsd_global_slow_inc(tsd_tsdn(tsd));\n\tfree(mallocx(1, 0));\n\texpect_false(tsd_fast(tsd), \"\");\n\tatomic_store_u32(&data.phase, 2, ATOMIC_SEQ_CST);\n\n\t/* PHASE 3 */\n\twhile (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 3) {\n\t}\n\texpect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), \"\");\n\t/* Increase again, so that we can test multiple fast/slow changes. */\n\ttsd_global_slow_inc(tsd_tsdn(tsd));\n\tatomic_store_u32(&data.phase, 4, ATOMIC_SEQ_CST);\n\tfree(mallocx(1, 0));\n\texpect_false(tsd_fast(tsd), \"\");\n\n\t/* PHASE 5 */\n\twhile (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 5) {\n\t}\n\texpect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), \"\");\n\ttsd_global_slow_dec(tsd_tsdn(tsd));\n\tatomic_store_u32(&data.phase, 6, ATOMIC_SEQ_CST);\n\t/* We only decreased once; things should still be slow. */\n\tfree(mallocx(1, 0));\n\texpect_false(tsd_fast(tsd), \"\");\n\n\t/* PHASE 7 */\n\twhile (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 7) {\n\t}\n\texpect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), \"\");\n\ttsd_global_slow_dec(tsd_tsdn(tsd));\n\tatomic_store_u32(&data.phase, 8, ATOMIC_SEQ_CST);\n\t/* We incremented and then decremented twice; we should be fast now. */\n\tfree(mallocx(1, 0));\n\texpect_true(!originally_fast || tsd_fast(tsd), \"\");\n\n\t/* PHASE 9 */\n\twhile (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 9) {\n\t}\n\texpect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), \"\");\n\n\tthd_join(thd, NULL);\n}\nTEST_END\n\nint\nmain(void) {\n\t/* Ensure tsd bootstrapped. */\n\tif (nallocx(1, 0) == 0) {\n\t\tmalloc_printf(\"Initialization error\");\n\t\treturn test_status_fail;\n\t}\n\n\treturn test_no_reentrancy(\n\t test_tsd_main_thread,\n\t test_tsd_sub_thread,\n\t test_tsd_reincarnation,\n\t test_tsd_global_slow);\n}\n" }, { "path": "deps/jemalloc/test/unit/uaf.c", "content": "#include \"test/jemalloc_test.h\"\n#include \"test/arena_util.h\"\n#include \"test/san.h\"\n\n#include \"jemalloc/internal/cache_bin.h\"\n#include \"jemalloc/internal/san.h\"\n#include \"jemalloc/internal/safety_check.h\"\n\nconst char *malloc_conf = TEST_SAN_UAF_ALIGN_ENABLE;\n\nstatic size_t san_uaf_align;\n\nstatic bool fake_abort_called;\nvoid fake_abort(const char *message) {\n\t(void)message;\n\tfake_abort_called = true;\n}\n\nstatic void\ntest_write_after_free_pre(void) {\n\tsafety_check_set_abort(&fake_abort);\n\tfake_abort_called = false;\n}\n\nstatic void\ntest_write_after_free_post(void) {\n\tassert_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t 0, \"Unexpected tcache flush failure\");\n\texpect_true(fake_abort_called, \"Use-after-free check didn't fire.\");\n\tsafety_check_set_abort(NULL);\n}\n\nstatic bool\nuaf_detection_enabled(void) {\n\tif (!config_uaf_detection || !san_uaf_detection_enabled()) {\n\t\treturn false;\n\t}\n\n\tssize_t lg_san_uaf_align;\n\tsize_t sz = sizeof(lg_san_uaf_align);\n\tassert_d_eq(mallctl(\"opt.lg_san_uaf_align\", &lg_san_uaf_align, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\tif (lg_san_uaf_align < 0) {\n\t\treturn false;\n\t}\n\tassert_zd_ge(lg_san_uaf_align, LG_PAGE, \"san_uaf_align out of range\");\n\tsan_uaf_align = (size_t)1 << lg_san_uaf_align;\n\n\tbool tcache_enabled;\n\tsz = sizeof(tcache_enabled);\n\tassert_d_eq(mallctl(\"thread.tcache.enabled\", &tcache_enabled, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\tif (!tcache_enabled) {\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\nstatic size_t\nread_tcache_stashed_bytes(unsigned arena_ind) {\n\tif (!config_stats) {\n\t\treturn 0;\n\t}\n\n\tuint64_t epoch;\n\tassert_d_eq(mallctl(\"epoch\", NULL, NULL, (void *)&epoch, sizeof(epoch)),\n\t 0, \"Unexpected mallctl() failure\");\n\n\tsize_t tcache_stashed_bytes;\n\tsize_t sz = sizeof(tcache_stashed_bytes);\n\tassert_d_eq(mallctl(\n\t \"stats.arenas.\" STRINGIFY(MALLCTL_ARENAS_ALL)\n\t \".tcache_stashed_bytes\", &tcache_stashed_bytes, &sz, NULL, 0), 0,\n\t \"Unexpected mallctl failure\");\n\n\treturn tcache_stashed_bytes;\n}\n\nstatic void\ntest_use_after_free(size_t alloc_size, bool write_after_free) {\n\tvoid *ptr = (void *)(uintptr_t)san_uaf_align;\n\tassert_true(cache_bin_nonfast_aligned(ptr), \"Wrong alignment\");\n\tptr = (void *)((uintptr_t)123 * (uintptr_t)san_uaf_align);\n\tassert_true(cache_bin_nonfast_aligned(ptr), \"Wrong alignment\");\n\tptr = (void *)((uintptr_t)san_uaf_align + 1);\n\tassert_false(cache_bin_nonfast_aligned(ptr), \"Wrong alignment\");\n\n\t/*\n\t * Disable purging (-1) so that all dirty pages remain committed, to\n\t * make use-after-free tolerable.\n\t */\n\tunsigned arena_ind = do_arena_create(-1, -1);\n\tint flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;\n\n\tsize_t n_max = san_uaf_align * 2;\n\tvoid **items = mallocx(n_max * sizeof(void *), flags);\n\tassert_ptr_not_null(items, \"Unexpected mallocx failure\");\n\n\tbool found = false;\n\tsize_t iter = 0;\n\tchar magic = 's';\n\tassert_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t 0, \"Unexpected tcache flush failure\");\n\twhile (!found) {\n\t\tptr = mallocx(alloc_size, flags);\n\t\tassert_ptr_not_null(ptr, \"Unexpected mallocx failure\");\n\n\t\tfound = cache_bin_nonfast_aligned(ptr);\n\t\t*(char *)ptr = magic;\n\t\titems[iter] = ptr;\n\t\tassert_zu_lt(iter++, n_max, \"No aligned ptr found\");\n\t}\n\n\tif (write_after_free) {\n\t\ttest_write_after_free_pre();\n\t}\n\tbool junked = false;\n\twhile (iter-- != 0) {\n\t\tchar *volatile mem = items[iter];\n\t\tassert_c_eq(*mem, magic, \"Unexpected memory content\");\n\t\tsize_t stashed_before = read_tcache_stashed_bytes(arena_ind);\n\t\tfree(mem);\n\t\tif (*mem != magic) {\n\t\t\tjunked = true;\n\t\t\tassert_c_eq(*mem, (char)uaf_detect_junk,\n\t\t\t \"Unexpected junk-filling bytes\");\n\t\t\tif (write_after_free) {\n\t\t\t\t*(char *)mem = magic + 1;\n\t\t\t}\n\n\t\t\tsize_t stashed_after = read_tcache_stashed_bytes(\n\t\t\t arena_ind);\n\t\t\t/*\n\t\t\t * An edge case is the deallocation above triggering the\n\t\t\t * tcache GC event, in which case the stashed pointers\n\t\t\t * may get flushed immediately, before returning from\n\t\t\t * free(). Treat these cases as checked already.\n\t\t\t */\n\t\t\tif (stashed_after <= stashed_before) {\n\t\t\t\tfake_abort_called = true;\n\t\t\t}\n\t\t}\n\t\t/* Flush tcache (including stashed). */\n\t\tassert_d_eq(mallctl(\"thread.tcache.flush\", NULL, NULL, NULL, 0),\n\t\t 0, \"Unexpected tcache flush failure\");\n\t}\n\texpect_true(junked, \"Aligned ptr not junked\");\n\tif (write_after_free) {\n\t\ttest_write_after_free_post();\n\t}\n\n\tdallocx(items, flags);\n\tdo_arena_destroy(arena_ind);\n}\n\nTEST_BEGIN(test_read_after_free) {\n\ttest_skip_if(!uaf_detection_enabled());\n\n\ttest_use_after_free(sizeof(void *), /* write_after_free */ false);\n\ttest_use_after_free(sizeof(void *) + 1, /* write_after_free */ false);\n\ttest_use_after_free(16, /* write_after_free */ false);\n\ttest_use_after_free(20, /* write_after_free */ false);\n\ttest_use_after_free(32, /* write_after_free */ false);\n\ttest_use_after_free(33, /* write_after_free */ false);\n\ttest_use_after_free(48, /* write_after_free */ false);\n\ttest_use_after_free(64, /* write_after_free */ false);\n\ttest_use_after_free(65, /* write_after_free */ false);\n\ttest_use_after_free(129, /* write_after_free */ false);\n\ttest_use_after_free(255, /* write_after_free */ false);\n\ttest_use_after_free(256, /* write_after_free */ false);\n}\nTEST_END\n\nTEST_BEGIN(test_write_after_free) {\n\ttest_skip_if(!uaf_detection_enabled());\n\n\ttest_use_after_free(sizeof(void *), /* write_after_free */ true);\n\ttest_use_after_free(sizeof(void *) + 1, /* write_after_free */ true);\n\ttest_use_after_free(16, /* write_after_free */ true);\n\ttest_use_after_free(20, /* write_after_free */ true);\n\ttest_use_after_free(32, /* write_after_free */ true);\n\ttest_use_after_free(33, /* write_after_free */ true);\n\ttest_use_after_free(48, /* write_after_free */ true);\n\ttest_use_after_free(64, /* write_after_free */ true);\n\ttest_use_after_free(65, /* write_after_free */ true);\n\ttest_use_after_free(129, /* write_after_free */ true);\n\ttest_use_after_free(255, /* write_after_free */ true);\n\ttest_use_after_free(256, /* write_after_free */ true);\n}\nTEST_END\n\nstatic bool\ncheck_allocated_intact(void **allocated, size_t n_alloc) {\n\tfor (unsigned i = 0; i < n_alloc; i++) {\n\t\tvoid *ptr = *(void **)allocated[i];\n\t\tbool found = false;\n\t\tfor (unsigned j = 0; j < n_alloc; j++) {\n\t\t\tif (ptr == allocated[j]) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (!found) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\nTEST_BEGIN(test_use_after_free_integration) {\n\ttest_skip_if(!uaf_detection_enabled());\n\n\tunsigned arena_ind = do_arena_create(-1, -1);\n\tint flags = MALLOCX_ARENA(arena_ind);\n\n\tsize_t n_alloc = san_uaf_align * 2;\n\tvoid **allocated = mallocx(n_alloc * sizeof(void *), flags);\n\tassert_ptr_not_null(allocated, \"Unexpected mallocx failure\");\n\n\tfor (unsigned i = 0; i < n_alloc; i++) {\n\t\tallocated[i] = mallocx(sizeof(void *) * 8, flags);\n\t\tassert_ptr_not_null(allocated[i], \"Unexpected mallocx failure\");\n\t\tif (i > 0) {\n\t\t\t/* Emulate a circular list. */\n\t\t\t*(void **)allocated[i] = allocated[i - 1];\n\t\t}\n\t}\n\t*(void **)allocated[0] = allocated[n_alloc - 1];\n\texpect_true(check_allocated_intact(allocated, n_alloc),\n\t \"Allocated data corrupted\");\n\n\tfor (unsigned i = 0; i < n_alloc; i++) {\n\t\tfree(allocated[i]);\n\t}\n\t/* Read-after-free */\n\texpect_false(check_allocated_intact(allocated, n_alloc),\n\t \"Junk-filling not detected\");\n\n\ttest_write_after_free_pre();\n\tfor (unsigned i = 0; i < n_alloc; i++) {\n\t\tallocated[i] = mallocx(sizeof(void *), flags);\n\t\tassert_ptr_not_null(allocated[i], \"Unexpected mallocx failure\");\n\t\t*(void **)allocated[i] = (void *)(uintptr_t)i;\n\t}\n\t/* Write-after-free */\n\tfor (unsigned i = 0; i < n_alloc; i++) {\n\t\tfree(allocated[i]);\n\t\t*(void **)allocated[i] = NULL;\n\t}\n\ttest_write_after_free_post();\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_read_after_free,\n\t test_write_after_free,\n\t test_use_after_free_integration);\n}\n" }, { "path": "deps/jemalloc/test/unit/witness.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic witness_lock_error_t *witness_lock_error_orig;\nstatic witness_owner_error_t *witness_owner_error_orig;\nstatic witness_not_owner_error_t *witness_not_owner_error_orig;\nstatic witness_depth_error_t *witness_depth_error_orig;\n\nstatic bool saw_lock_error;\nstatic bool saw_owner_error;\nstatic bool saw_not_owner_error;\nstatic bool saw_depth_error;\n\nstatic void\nwitness_lock_error_intercept(const witness_list_t *witnesses,\n const witness_t *witness) {\n\tsaw_lock_error = true;\n}\n\nstatic void\nwitness_owner_error_intercept(const witness_t *witness) {\n\tsaw_owner_error = true;\n}\n\nstatic void\nwitness_not_owner_error_intercept(const witness_t *witness) {\n\tsaw_not_owner_error = true;\n}\n\nstatic void\nwitness_depth_error_intercept(const witness_list_t *witnesses,\n witness_rank_t rank_inclusive, unsigned depth) {\n\tsaw_depth_error = true;\n}\n\nstatic int\nwitness_comp(const witness_t *a, void *oa, const witness_t *b, void *ob) {\n\texpect_u_eq(a->rank, b->rank, \"Witnesses should have equal rank\");\n\n\tassert(oa == (void *)a);\n\tassert(ob == (void *)b);\n\n\treturn strcmp(a->name, b->name);\n}\n\nstatic int\nwitness_comp_reverse(const witness_t *a, void *oa, const witness_t *b,\n void *ob) {\n\texpect_u_eq(a->rank, b->rank, \"Witnesses should have equal rank\");\n\n\tassert(oa == (void *)a);\n\tassert(ob == (void *)b);\n\n\treturn -strcmp(a->name, b->name);\n}\n\nTEST_BEGIN(test_witness) {\n\twitness_t a, b;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)1U, 0);\n\n\twitness_init(&a, \"a\", 1, NULL, NULL);\n\twitness_assert_not_owner(&witness_tsdn, &a);\n\twitness_lock(&witness_tsdn, &a);\n\twitness_assert_owner(&witness_tsdn, &a);\n\twitness_assert_depth(&witness_tsdn, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)1U, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)2U, 0);\n\n\twitness_init(&b, \"b\", 2, NULL, NULL);\n\twitness_assert_not_owner(&witness_tsdn, &b);\n\twitness_lock(&witness_tsdn, &b);\n\twitness_assert_owner(&witness_tsdn, &b);\n\twitness_assert_depth(&witness_tsdn, 2);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)1U, 2);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)2U, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)3U, 0);\n\n\twitness_unlock(&witness_tsdn, &a);\n\twitness_assert_depth(&witness_tsdn, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)1U, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)2U, 1);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)3U, 0);\n\twitness_unlock(&witness_tsdn, &b);\n\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\twitness_assert_depth_to_rank(&witness_tsdn, (witness_rank_t)1U, 0);\n}\nTEST_END\n\nTEST_BEGIN(test_witness_comp) {\n\twitness_t a, b, c, d;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_init(&a, \"a\", 1, witness_comp, &a);\n\twitness_assert_not_owner(&witness_tsdn, &a);\n\twitness_lock(&witness_tsdn, &a);\n\twitness_assert_owner(&witness_tsdn, &a);\n\twitness_assert_depth(&witness_tsdn, 1);\n\n\twitness_init(&b, \"b\", 1, witness_comp, &b);\n\twitness_assert_not_owner(&witness_tsdn, &b);\n\twitness_lock(&witness_tsdn, &b);\n\twitness_assert_owner(&witness_tsdn, &b);\n\twitness_assert_depth(&witness_tsdn, 2);\n\twitness_unlock(&witness_tsdn, &b);\n\twitness_assert_depth(&witness_tsdn, 1);\n\n\twitness_lock_error_orig = witness_lock_error;\n\twitness_lock_error = witness_lock_error_intercept;\n\tsaw_lock_error = false;\n\n\twitness_init(&c, \"c\", 1, witness_comp_reverse, &c);\n\twitness_assert_not_owner(&witness_tsdn, &c);\n\texpect_false(saw_lock_error, \"Unexpected witness lock error\");\n\twitness_lock(&witness_tsdn, &c);\n\texpect_true(saw_lock_error, \"Expected witness lock error\");\n\twitness_unlock(&witness_tsdn, &c);\n\twitness_assert_depth(&witness_tsdn, 1);\n\n\tsaw_lock_error = false;\n\n\twitness_init(&d, \"d\", 1, NULL, NULL);\n\twitness_assert_not_owner(&witness_tsdn, &d);\n\texpect_false(saw_lock_error, \"Unexpected witness lock error\");\n\twitness_lock(&witness_tsdn, &d);\n\texpect_true(saw_lock_error, \"Expected witness lock error\");\n\twitness_unlock(&witness_tsdn, &d);\n\twitness_assert_depth(&witness_tsdn, 1);\n\n\twitness_unlock(&witness_tsdn, &a);\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_lock_error = witness_lock_error_orig;\n}\nTEST_END\n\nTEST_BEGIN(test_witness_reversal) {\n\twitness_t a, b;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_lock_error_orig = witness_lock_error;\n\twitness_lock_error = witness_lock_error_intercept;\n\tsaw_lock_error = false;\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_init(&a, \"a\", 1, NULL, NULL);\n\twitness_init(&b, \"b\", 2, NULL, NULL);\n\n\twitness_lock(&witness_tsdn, &b);\n\twitness_assert_depth(&witness_tsdn, 1);\n\texpect_false(saw_lock_error, \"Unexpected witness lock error\");\n\twitness_lock(&witness_tsdn, &a);\n\texpect_true(saw_lock_error, \"Expected witness lock error\");\n\n\twitness_unlock(&witness_tsdn, &a);\n\twitness_assert_depth(&witness_tsdn, 1);\n\twitness_unlock(&witness_tsdn, &b);\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_lock_error = witness_lock_error_orig;\n}\nTEST_END\n\nTEST_BEGIN(test_witness_recursive) {\n\twitness_t a;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_not_owner_error_orig = witness_not_owner_error;\n\twitness_not_owner_error = witness_not_owner_error_intercept;\n\tsaw_not_owner_error = false;\n\n\twitness_lock_error_orig = witness_lock_error;\n\twitness_lock_error = witness_lock_error_intercept;\n\tsaw_lock_error = false;\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_init(&a, \"a\", 1, NULL, NULL);\n\n\twitness_lock(&witness_tsdn, &a);\n\texpect_false(saw_lock_error, \"Unexpected witness lock error\");\n\texpect_false(saw_not_owner_error, \"Unexpected witness not owner error\");\n\twitness_lock(&witness_tsdn, &a);\n\texpect_true(saw_lock_error, \"Expected witness lock error\");\n\texpect_true(saw_not_owner_error, \"Expected witness not owner error\");\n\n\twitness_unlock(&witness_tsdn, &a);\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_owner_error = witness_owner_error_orig;\n\twitness_lock_error = witness_lock_error_orig;\n\n}\nTEST_END\n\nTEST_BEGIN(test_witness_unlock_not_owned) {\n\twitness_t a;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_owner_error_orig = witness_owner_error;\n\twitness_owner_error = witness_owner_error_intercept;\n\tsaw_owner_error = false;\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_init(&a, \"a\", 1, NULL, NULL);\n\n\texpect_false(saw_owner_error, \"Unexpected owner error\");\n\twitness_unlock(&witness_tsdn, &a);\n\texpect_true(saw_owner_error, \"Expected owner error\");\n\n\twitness_assert_lockless(&witness_tsdn);\n\n\twitness_owner_error = witness_owner_error_orig;\n}\nTEST_END\n\nTEST_BEGIN(test_witness_depth) {\n\twitness_t a;\n\twitness_tsdn_t witness_tsdn = { WITNESS_TSD_INITIALIZER };\n\n\ttest_skip_if(!config_debug);\n\n\twitness_depth_error_orig = witness_depth_error;\n\twitness_depth_error = witness_depth_error_intercept;\n\tsaw_depth_error = false;\n\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\n\twitness_init(&a, \"a\", 1, NULL, NULL);\n\n\texpect_false(saw_depth_error, \"Unexpected depth error\");\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\n\twitness_lock(&witness_tsdn, &a);\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\texpect_true(saw_depth_error, \"Expected depth error\");\n\n\twitness_unlock(&witness_tsdn, &a);\n\n\twitness_assert_lockless(&witness_tsdn);\n\twitness_assert_depth(&witness_tsdn, 0);\n\n\twitness_depth_error = witness_depth_error_orig;\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_witness,\n\t test_witness_comp,\n\t test_witness_reversal,\n\t test_witness_recursive,\n\t test_witness_unlock_not_owned,\n\t test_witness_depth);\n}\n" }, { "path": "deps/jemalloc/test/unit/zero.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic void\ntest_zero(size_t sz_min, size_t sz_max) {\n\tuint8_t *s;\n\tsize_t sz_prev, sz, i;\n#define MAGIC\t((uint8_t)0x61)\n\n\tsz_prev = 0;\n\ts = (uint8_t *)mallocx(sz_min, 0);\n\texpect_ptr_not_null((void *)s, \"Unexpected mallocx() failure\");\n\n\tfor (sz = sallocx(s, 0); sz <= sz_max;\n\t sz_prev = sz, sz = sallocx(s, 0)) {\n\t\tif (sz_prev > 0) {\n\t\t\texpect_u_eq(s[0], MAGIC,\n\t\t\t \"Previously allocated byte %zu/%zu is corrupted\",\n\t\t\t ZU(0), sz_prev);\n\t\t\texpect_u_eq(s[sz_prev-1], MAGIC,\n\t\t\t \"Previously allocated byte %zu/%zu is corrupted\",\n\t\t\t sz_prev-1, sz_prev);\n\t\t}\n\n\t\tfor (i = sz_prev; i < sz; i++) {\n\t\t\texpect_u_eq(s[i], 0x0,\n\t\t\t \"Newly allocated byte %zu/%zu isn't zero-filled\",\n\t\t\t i, sz);\n\t\t\ts[i] = MAGIC;\n\t\t}\n\n\t\tif (xallocx(s, sz+1, 0, 0) == sz) {\n\t\t\ts = (uint8_t *)rallocx(s, sz+1, 0);\n\t\t\texpect_ptr_not_null((void *)s,\n\t\t\t \"Unexpected rallocx() failure\");\n\t\t}\n\t}\n\n\tdallocx(s, 0);\n#undef MAGIC\n}\n\nTEST_BEGIN(test_zero_small) {\n\ttest_skip_if(!config_fill);\n\ttest_zero(1, SC_SMALL_MAXCLASS - 1);\n}\nTEST_END\n\nTEST_BEGIN(test_zero_large) {\n\ttest_skip_if(!config_fill);\n\ttest_zero(SC_SMALL_MAXCLASS + 1, 1U << (SC_LG_LARGE_MINCLASS + 1));\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_zero_small,\n\t test_zero_large);\n}\n" }, { "path": "deps/jemalloc/test/unit/zero.sh", "content": "#!/bin/sh\n\nif [ \"x${enable_fill}\" = \"x1\" ] ; then\n export MALLOC_CONF=\"abort:false,junk:false,zero:true\"\nfi\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_abort.c", "content": "#include \"test/jemalloc_test.h\"\n\n#include \n\nstatic bool abort_called = false;\n\nvoid set_abort_called() {\n\tabort_called = true;\n};\n\nTEST_BEGIN(test_realloc_abort) {\n\tabort_called = false;\n\tsafety_check_set_abort(&set_abort_called);\n\tvoid *ptr = mallocx(42, 0);\n\texpect_ptr_not_null(ptr, \"Unexpected mallocx error\");\n\tptr = realloc(ptr, 0);\n\texpect_true(abort_called, \"Realloc with zero size didn't abort\");\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_realloc_abort);\n}\n\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_abort.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"zero_realloc:abort\"\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_alloc.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic uint64_t\nallocated() {\n\tif (!config_stats) {\n\t\treturn 0;\n\t}\n\tuint64_t allocated;\n\tsize_t sz = sizeof(allocated);\n\texpect_d_eq(mallctl(\"thread.allocated\", (void *)&allocated, &sz, NULL,\n\t 0), 0, \"Unexpected mallctl failure\");\n\treturn allocated;\n}\n\nstatic uint64_t\ndeallocated() {\n\tif (!config_stats) {\n\t\treturn 0;\n\t}\n\tuint64_t deallocated;\n\tsize_t sz = sizeof(deallocated);\n\texpect_d_eq(mallctl(\"thread.deallocated\", (void *)&deallocated, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\treturn deallocated;\n}\n\nTEST_BEGIN(test_realloc_alloc) {\n\tvoid *ptr = mallocx(1, 0);\n\texpect_ptr_not_null(ptr, \"Unexpected mallocx error\");\n\tuint64_t allocated_before = allocated();\n\tuint64_t deallocated_before = deallocated();\n\tptr = realloc(ptr, 0);\n\tuint64_t allocated_after = allocated();\n\tuint64_t deallocated_after = deallocated();\n\tif (config_stats) {\n\t\texpect_u64_lt(allocated_before, allocated_after,\n\t\t \"Unexpected stats change\");\n\t\texpect_u64_lt(deallocated_before, deallocated_after,\n\t\t \"Unexpected stats change\");\n\t}\n\tdallocx(ptr, 0);\n}\nTEST_END\nint\nmain(void) {\n\treturn test(\n\t test_realloc_alloc);\n}\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_alloc.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"zero_realloc:alloc\"\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_free.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic uint64_t\ndeallocated() {\n\tif (!config_stats) {\n\t\treturn 0;\n\t}\n\tuint64_t deallocated;\n\tsize_t sz = sizeof(deallocated);\n\texpect_d_eq(mallctl(\"thread.deallocated\", (void *)&deallocated, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\treturn deallocated;\n}\n\nTEST_BEGIN(test_realloc_free) {\n\tvoid *ptr = mallocx(42, 0);\n\texpect_ptr_not_null(ptr, \"Unexpected mallocx error\");\n\tuint64_t deallocated_before = deallocated();\n\tptr = realloc(ptr, 0);\n\tuint64_t deallocated_after = deallocated();\n\texpect_ptr_null(ptr, \"Realloc didn't free\");\n\tif (config_stats) {\n\t\texpect_u64_gt(deallocated_after, deallocated_before,\n\t\t \"Realloc didn't free\");\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\treturn test(\n\t test_realloc_free);\n}\n" }, { "path": "deps/jemalloc/test/unit/zero_realloc_free.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"zero_realloc:free\"\n" }, { "path": "deps/jemalloc/test/unit/zero_reallocs.c", "content": "#include \"test/jemalloc_test.h\"\n\nstatic size_t\nzero_reallocs() {\n\tif (!config_stats) {\n\t\treturn 0;\n\t}\n\tsize_t count = 12345;\n\tsize_t sz = sizeof(count);\n\n\texpect_d_eq(mallctl(\"stats.zero_reallocs\", (void *)&count, &sz,\n\t NULL, 0), 0, \"Unexpected mallctl failure\");\n\treturn count;\n}\n\nTEST_BEGIN(test_zero_reallocs) {\n\ttest_skip_if(!config_stats);\n\n\tfor (size_t i = 0; i < 100; ++i) {\n\t\tvoid *ptr = mallocx(i * i + 1, 0);\n\t\texpect_ptr_not_null(ptr, \"Unexpected mallocx error\");\n\t\tsize_t count = zero_reallocs();\n\t\texpect_zu_eq(i, count, \"Incorrect zero realloc count\");\n\t\tptr = realloc(ptr, 0);\n\t\texpect_ptr_null(ptr, \"Realloc didn't free\");\n\t\tcount = zero_reallocs();\n\t\texpect_zu_eq(i + 1, count, \"Realloc didn't adjust count\");\n\t}\n}\nTEST_END\n\nint\nmain(void) {\n\t/*\n\t * We expect explicit counts; reentrant tests run multiple times, so\n\t * counts leak across runs.\n\t */\n\treturn test_no_reentrancy(\n\t test_zero_reallocs);\n}\n" }, { "path": "deps/jemalloc/test/unit/zero_reallocs.sh", "content": "#!/bin/sh\n\nexport MALLOC_CONF=\"zero_realloc:free\"\n" }, { "path": "deps/linenoise/.gitignore", "content": "linenoise_example\n*.dSYM\nhistory.txt\n" }, { "path": "deps/linenoise/Makefile", "content": "STD=\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS)\nR_LDFLAGS= $(LDFLAGS)\nDEBUG= -g\n\nR_CC=$(CC) $(R_CFLAGS)\nR_LD=$(CC) $(R_LDFLAGS)\n\nlinenoise.o: linenoise.h linenoise.c\n\nlinenoise_example: linenoise.o example.o\n\t$(R_LD) -o $@ $^\n\n.c.o:\n\t$(R_CC) -c $<\n\nclean:\n\trm -f linenoise_example *.o\n" }, { "path": "deps/linenoise/README.markdown", "content": "# Linenoise\n\nA minimal, zero-config, BSD licensed, readline replacement used in Redis,\nMongoDB, and Android.\n\n* Single and multi line editing mode with the usual key bindings implemented.\n* History handling.\n* Completion.\n* Hints (suggestions at the right of the prompt as you type).\n* About 1,100 lines of BSD license source code.\n* Only uses a subset of VT100 escapes (ANSI.SYS compatible).\n\n## Can a line editing library be 20k lines of code?\n\nLine editing with some support for history is a really important feature for command line utilities. Instead of retyping almost the same stuff again and again it's just much better to hit the up arrow and edit on syntax errors, or in order to try a slightly different command. But apparently code dealing with terminals is some sort of Black Magic: readline is 30k lines of code, libedit 20k. Is it reasonable to link small utilities to huge libraries just to get a minimal support for line editing?\n\nSo what usually happens is either:\n\n * Large programs with configure scripts disabling line editing if readline is not present in the system, or not supporting it at all since readline is GPL licensed and libedit (the BSD clone) is not as known and available as readline is (Real world example of this problem: Tclsh).\n * Smaller programs not using a configure script not supporting line editing at all (A problem we had with Redis-cli for instance).\n \nThe result is a pollution of binaries without line editing support.\n\nSo I spent more or less two hours doing a reality check resulting in this little library: is it *really* needed for a line editing library to be 20k lines of code? Apparently not, it is possibe to get a very small, zero configuration, trivial to embed library, that solves the problem. Smaller programs will just include this, supporting line editing out of the box. Larger programs may use this little library or just checking with configure if readline/libedit is available and resorting to Linenoise if not.\n\n## Terminals, in 2010.\n\nApparently almost every terminal you can happen to use today has some kind of support for basic VT100 escape sequences. So I tried to write a lib using just very basic VT100 features. The resulting library appears to work everywhere I tried to use it, and now can work even on ANSI.SYS compatible terminals, since no\nVT220 specific sequences are used anymore.\n\nThe library is currently about 1100 lines of code. In order to use it in your project just look at the *example.c* file in the source distribution, it is trivial. Linenoise is BSD code, so you can use both in free software and commercial software.\n\n## Tested with...\n\n * Linux text only console ($TERM = linux)\n * Linux KDE terminal application ($TERM = xterm)\n * Linux xterm ($TERM = xterm)\n * Linux Buildroot ($TERM = vt100)\n * Mac OS X iTerm ($TERM = xterm)\n * Mac OS X default Terminal.app ($TERM = xterm)\n * OpenBSD 4.5 through an OSX Terminal.app ($TERM = screen)\n * IBM AIX 6.1\n * FreeBSD xterm ($TERM = xterm)\n * ANSI.SYS\n * Emacs comint mode ($TERM = dumb)\n\nPlease test it everywhere you can and report back!\n\n## Let's push this forward!\n\nPatches should be provided in the respect of Linenoise sensibility for small\neasy to understand code.\n\nSend feedbacks to antirez at gmail\n\n# The API\n\nLinenoise is very easy to use, and reading the example shipped with the\nlibrary should get you up to speed ASAP. Here is a list of API calls\nand how to use them.\n\n char *linenoise(const char *prompt);\n\nThis is the main Linenoise call: it shows the user a prompt with line editing\nand history capabilities. The prompt you specify is used as a prompt, that is,\nit will be printed to the left of the cursor. The library returns a buffer\nwith the line composed by the user, or NULL on end of file or when there\nis an out of memory condition.\n\nWhen a tty is detected (the user is actually typing into a terminal session)\nthe maximum editable line length is `LINENOISE_MAX_LINE`. When instead the\nstandard input is not a tty, which happens every time you redirect a file\nto a program, or use it in an Unix pipeline, there are no limits to the\nlength of the line that can be returned.\n\nThe returned line should be freed with the `free()` standard system call.\nHowever sometimes it could happen that your program uses a different dynamic\nallocation library, so you may also used `linenoiseFree` to make sure the\nline is freed with the same allocator it was created.\n\nThe canonical loop used by a program using Linenoise will be something like\nthis:\n\n while((line = linenoise(\"hello> \")) != NULL) {\n printf(\"You wrote: %s\\n\", line);\n linenoiseFree(line); /* Or just free(line) if you use libc malloc. */\n }\n\n## Single line VS multi line editing\n\nBy default, Linenoise uses single line editing, that is, a single row on the\nscreen will be used, and as the user types more, the text will scroll towards\nleft to make room. This works if your program is one where the user is\nunlikely to write a lot of text, otherwise multi line editing, where multiple\nscreens rows are used, can be a lot more comfortable.\n\nIn order to enable multi line editing use the following API call:\n\n linenoiseSetMultiLine(1);\n\nYou can disable it using `0` as argument.\n\n## History\n\nLinenoise supporst history, so that the user does not have to retype\nagain and again the same things, but can use the down and up arrows in order\nto search and re-edit already inserted lines of text.\n\nThe followings are the history API calls:\n\n int linenoiseHistoryAdd(const char *line, int is_sensitive);\n int linenoiseHistorySetMaxLen(int len);\n int linenoiseHistorySave(const char *filename);\n int linenoiseHistoryLoad(const char *filename);\n\nUse `linenoiseHistoryAdd` every time you want to add a new element\nto the top of the history (it will be the first the user will see when\nusing the up arrow).\n\nNote that for history to work, you have to set a length for the history\n(which is zero by default, so history will be disabled if you don't set\na proper one). This is accomplished using the `linenoiseHistorySetMaxLen`\nfunction.\n\nLinenoise has direct support for persisting the history into an history\nfile. The functions `linenoiseHistorySave` and `linenoiseHistoryLoad` do\njust that. Both functions return -1 on error and 0 on success.\n\n## Mask mode\n\nSometimes it is useful to allow the user to type passwords or other\nsecrets that should not be displayed. For such situations linenoise supports\na \"mask mode\" that will just replace the characters the user is typing \nwith `*` characters, like in the following example:\n\n $ ./linenoise_example\n hello> get mykey\n echo: 'get mykey'\n hello> /mask\n hello> *********\n\nYou can enable and disable mask mode using the following two functions:\n\n void linenoiseMaskModeEnable(void);\n void linenoiseMaskModeDisable(void);\n\n## Completion\n\nLinenoise supports completion, which is the ability to complete the user\ninput when she or he presses the `` key.\n\nIn order to use completion, you need to register a completion callback, which\nis called every time the user presses ``. Your callback will return a\nlist of items that are completions for the current string.\n\nThe following is an example of registering a completion callback:\n\n linenoiseSetCompletionCallback(completion);\n\nThe completion must be a function returning `void` and getting as input\na `const char` pointer, which is the line the user has typed so far, and\na `linenoiseCompletions` object pointer, which is used as argument of\n`linenoiseAddCompletion` in order to add completions inside the callback.\nAn example will make it more clear:\n\n void completion(const char *buf, linenoiseCompletions *lc) {\n if (buf[0] == 'h') {\n linenoiseAddCompletion(lc,\"hello\");\n linenoiseAddCompletion(lc,\"hello there\");\n }\n }\n\nBasically in your completion callback, you inspect the input, and return\na list of items that are good completions by using `linenoiseAddCompletion`.\n\nIf you want to test the completion feature, compile the example program\nwith `make`, run it, type `h` and press ``.\n\n## Hints\n\nLinenoise has a feature called *hints* which is very useful when you\nuse Linenoise in order to implement a REPL (Read Eval Print Loop) for\na program that accepts commands and arguments, but may also be useful in\nother conditions.\n\nThe feature shows, on the right of the cursor, as the user types, hints that\nmay be useful. The hints can be displayed using a different color compared\nto the color the user is typing, and can also be bold.\n\nFor example as the user starts to type `\"git remote add\"`, with hints it's\npossible to show on the right of the prompt a string ` `.\n\nThe feature works similarly to the history feature, using a callback.\nTo register the callback we use:\n\n linenoiseSetHintsCallback(hints);\n\nThe callback itself is implemented like this:\n\n char *hints(const char *buf, int *color, int *bold) {\n if (!strcasecmp(buf,\"git remote add\")) {\n *color = 35;\n *bold = 0;\n return \" \";\n }\n return NULL;\n }\n\nThe callback function returns the string that should be displayed or NULL\nif no hint is available for the text the user currently typed. The returned\nstring will be trimmed as needed depending on the number of columns available\non the screen.\n\nIt is possible to return a string allocated in dynamic way, by also registering\na function to deallocate the hint string once used:\n\n void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *);\n\nThe free hint callback will just receive the pointer and free the string\nas needed (depending on how the hits callback allocated it).\n\nAs you can see in the example above, a `color` (in xterm color terminal codes)\ncan be provided together with a `bold` attribute. If no color is set, the\ncurrent terminal foreground color is used. If no bold attribute is set,\nnon-bold text is printed.\n\nColor codes are:\n\n red = 31\n green = 32\n yellow = 33\n blue = 34\n magenta = 35\n cyan = 36\n white = 37;\n\n## Screen handling\n\nSometimes you may want to clear the screen as a result of something the\nuser typed. You can do this by calling the following function:\n\n void linenoiseClearScreen(void);\n\n## Related projects\n\n* [Linenoise NG](https://github.com/arangodb/linenoise-ng) is a fork of Linenoise that aims to add more advanced features like UTF-8 support, Windows support and other features. Uses C++ instead of C as development language.\n* [Linenoise-swift](https://github.com/andybest/linenoise-swift) is a reimplementation of Linenoise written in Swift.\n" }, { "path": "deps/linenoise/example.c", "content": "#include \n#include \n#include \n#include \"linenoise.h\"\n\n\nvoid completion(const char *buf, linenoiseCompletions *lc) {\n if (buf[0] == 'h') {\n linenoiseAddCompletion(lc,\"hello\");\n linenoiseAddCompletion(lc,\"hello there\");\n }\n}\n\nchar *hints(const char *buf, int *color, int *bold) {\n if (!strcasecmp(buf,\"hello\")) {\n *color = 35;\n *bold = 0;\n return \" World\";\n }\n return NULL;\n}\n\nint main(int argc, char **argv) {\n char *line;\n char *prgname = argv[0];\n\n /* Parse options, with --multiline we enable multi line editing. */\n while(argc > 1) {\n argc--;\n argv++;\n if (!strcmp(*argv,\"--multiline\")) {\n linenoiseSetMultiLine(1);\n printf(\"Multi-line mode enabled.\\n\");\n } else if (!strcmp(*argv,\"--keycodes\")) {\n linenoisePrintKeyCodes();\n exit(0);\n } else {\n fprintf(stderr, \"Usage: %s [--multiline] [--keycodes]\\n\", prgname);\n exit(1);\n }\n }\n\n /* Set the completion callback. This will be called every time the\n * user uses the key. */\n linenoiseSetCompletionCallback(completion);\n linenoiseSetHintsCallback(hints);\n\n /* Load history from file. The history file is just a plain text file\n * where entries are separated by newlines. */\n linenoiseHistoryLoad(\"history.txt\"); /* Load the history at startup */\n\n /* Now this is the main loop of the typical linenoise-based application.\n * The call to linenoise() will block as long as the user types something\n * and presses enter.\n *\n * The typed string is returned as a malloc() allocated string by\n * linenoise, so the user needs to free() it. */\n \n while((line = linenoise(\"hello> \")) != NULL) {\n /* Do something with the string. */\n if (line[0] != '\\0' && line[0] != '/') {\n printf(\"echo: '%s'\\n\", line);\n linenoiseHistoryAdd(line); /* Add to the history. */\n linenoiseHistorySave(\"history.txt\"); /* Save the history on disk. */\n } else if (!strncmp(line,\"/historylen\",11)) {\n /* The \"/historylen\" command will change the history len. */\n int len = atoi(line+11);\n linenoiseHistorySetMaxLen(len);\n } else if (!strncmp(line, \"/mask\", 5)) {\n linenoiseMaskModeEnable();\n } else if (!strncmp(line, \"/unmask\", 7)) {\n linenoiseMaskModeDisable();\n } else if (line[0] == '/') {\n printf(\"Unreconized command: %s\\n\", line);\n }\n free(line);\n }\n return 0;\n}\n" }, { "path": "deps/linenoise/linenoise.c", "content": "/* linenoise.c -- guerrilla line editing library against the idea that a\n * line editing lib needs to be 20,000 lines of C code.\n *\n * You can find the latest source code at:\n *\n * http://github.com/antirez/linenoise\n *\n * Does a number of crazy assumptions that happen to be true in 99.9999% of\n * the 2010 UNIX computers around.\n *\n * ------------------------------------------------------------------------\n *\n * Copyright (c) 2010-2016, Salvatore Sanfilippo \n * Copyright (c) 2010-2013, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * ------------------------------------------------------------------------\n *\n * References:\n * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html\n * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html\n *\n * Todo list:\n * - Filter bogus Ctrl+ combinations.\n * - Win32 support\n *\n * Bloat:\n * - History search like Ctrl+r in readline?\n *\n * List of escape sequences used by this program, we do everything just\n * with three sequences. In order to be so cheap we may have some\n * flickering effect with some slow terminal, but the lesser sequences\n * the more compatible.\n *\n * EL (Erase Line)\n * Sequence: ESC [ n K\n * Effect: if n is 0 or missing, clear from cursor to end of line\n * Effect: if n is 1, clear from beginning of line to cursor\n * Effect: if n is 2, clear entire line\n *\n * CUF (CUrsor Forward)\n * Sequence: ESC [ n C\n * Effect: moves cursor forward n chars\n *\n * CUB (CUrsor Backward)\n * Sequence: ESC [ n D\n * Effect: moves cursor backward n chars\n *\n * The following is used to get the terminal width if getting\n * the width with the TIOCGWINSZ ioctl fails\n *\n * DSR (Device Status Report)\n * Sequence: ESC [ 6 n\n * Effect: reports the current cusor position as ESC [ n ; m R\n * where n is the row and m is the column\n *\n * When multi line mode is enabled, we also use an additional escape\n * sequence. However multi line editing is disabled by default.\n *\n * CUU (Cursor Up)\n * Sequence: ESC [ n A\n * Effect: moves cursor up of n chars.\n *\n * CUD (Cursor Down)\n * Sequence: ESC [ n B\n * Effect: moves cursor down of n chars.\n *\n * When linenoiseClearScreen() is called, two additional escape sequences\n * are used in order to clear the screen and position the cursor at home\n * position.\n *\n * CUP (Cursor position)\n * Sequence: ESC [ H\n * Effect: moves the cursor to upper left corner\n *\n * ED (Erase display)\n * Sequence: ESC [ 2 J\n * Effect: clear the whole screen\n *\n */\n\n#define _DEFAULT_SOURCE /* For fchmod() */\n#define _BSD_SOURCE /* For fchmod() */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"linenoise.h\"\n\n#define SEQ_BUFFER_MAX_LENGTH 8\n#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100\n#define LINENOISE_MAX_LINE 4096\nstatic char *unsupported_term[] = {\"dumb\",\"cons25\",\"emacs\",NULL};\nstatic linenoiseCompletionCallback *completionCallback = NULL;\nstatic linenoiseHintsCallback *hintsCallback = NULL;\nstatic linenoiseFreeHintsCallback *freeHintsCallback = NULL;\n\nstatic struct termios orig_termios; /* In order to restore at exit.*/\nstatic int maskmode = 0; /* Show \"***\" instead of input. For passwords. */\nstatic int rawmode = 0; /* For atexit() function to check if restore is needed*/\nstatic int mlmode = 0; /* Multi line mode. Default is single line. */\nstatic int atexit_registered = 0; /* Register atexit just 1 time. */\nstatic int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;\nstatic int history_len = 0;\nstatic char **history = NULL;\nstatic int *history_sensitive = NULL; /* An array records whether each line in\n * history is sensitive. */\n\nstatic int reverse_search_mode_enabled = 0;\nstatic int reverse_search_direction = 0; /* 1 means forward, -1 means backward. */\nstatic int cycle_to_next_search = 0; /* indicates whether to continue the search with CTRL+S or CTRL+R. */\nstatic char search_result[LINENOISE_MAX_LINE];\nstatic char search_result_friendly[LINENOISE_MAX_LINE];\nstatic int search_result_history_index = 0;\nstatic int search_result_start_offset = 0;\nstatic int ignore_once_hint = 0; /* Flag to ignore hint once, preventing it from interfering\n * with search results right after exiting search mode. */\n\n/* The linenoiseState structure represents the state during line editing.\n * We pass this state to functions implementing specific editing\n * functionalities. */\nstruct linenoiseState {\n int ifd; /* Terminal stdin file descriptor. */\n int ofd; /* Terminal stdout file descriptor. */\n char *buf; /* Edited line buffer. */\n size_t buflen; /* Edited line buffer size. */\n const char *origin_prompt; /* Original prompt, used to restore when exiting search mode. */\n const char *prompt; /* Prompt to display. */\n size_t plen; /* Prompt length. */\n size_t pos; /* Current cursor position. */\n size_t oldpos; /* Previous refresh cursor position. */\n size_t len; /* Current edited line length. */\n size_t cols; /* Number of columns in terminal. */\n size_t maxrows; /* Maximum num of rows used so far (multiline mode) */\n int history_index; /* The history index we are currently editing. */\n};\n\ntypedef struct {\n int len; /* Length of the result string. */\n char *result; /* Search result string. */\n int search_term_index; /* Position of the search term in the history record. */\n int search_term_len; /* Length of the search term. */\n} linenoiseHistorySearchResult;\n\nenum KEY_ACTION{\n\tKEY_NULL = 0,\t /* NULL */\n\tCTRL_A = 1, /* Ctrl+a */\n\tCTRL_B = 2, /* Ctrl-b */\n\tCTRL_C = 3, /* Ctrl-c */\n\tCTRL_D = 4, /* Ctrl-d */\n\tCTRL_E = 5, /* Ctrl-e */\n\tCTRL_F = 6, /* Ctrl-f */\n\tCTRL_G = 7, /* Ctrl-g */\n\tCTRL_H = 8, /* Ctrl-h */\n\tTAB = 9, /* Tab */\n\tNL = 10, /* Enter typed before raw mode was enabled */\n\tCTRL_K = 11, /* Ctrl+k */\n\tCTRL_L = 12, /* Ctrl+l */\n\tENTER = 13, /* Enter */\n\tCTRL_N = 14, /* Ctrl-n */\n\tCTRL_P = 16, /* Ctrl-p */\n\tCTRL_R = 18, /* Ctrl-r */\n\tCTRL_S = 19, /* Ctrl-s */\n\tCTRL_T = 20, /* Ctrl-t */\n\tCTRL_U = 21, /* Ctrl+u */\n\tCTRL_W = 23, /* Ctrl+w */\n\tESC = 27, /* Escape */\n\tBACKSPACE = 127 /* Backspace */\n};\n\nstatic void linenoiseAtExit(void);\nint linenoiseHistoryAdd(const char *line, int is_sensitive);\nstatic void refreshLine(struct linenoiseState *l);\nstatic void refreshSearchResult(struct linenoiseState *ls);\n\nstatic inline void resetSearchResult(void) {\n memset(search_result, 0, sizeof(search_result));\n memset(search_result_friendly, 0, sizeof(search_result_friendly));\n}\n\n/* Debugging macro. */\n#if 0\nFILE *lndebug_fp = NULL;\n#define lndebug(...) \\\n do { \\\n if (lndebug_fp == NULL) { \\\n lndebug_fp = fopen(\"/tmp/lndebug.txt\",\"a\"); \\\n fprintf(lndebug_fp, \\\n \"[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\\n\", \\\n (int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \\\n (int)l->maxrows,old_rows); \\\n } \\\n fprintf(lndebug_fp, \", \" __VA_ARGS__); \\\n fflush(lndebug_fp); \\\n } while (0)\n#else\n#define lndebug(fmt, ...)\n#endif\n\n/* ======================= Low level terminal handling ====================== */\n\n/* Enable \"mask mode\". When it is enabled, instead of the input that\n * the user is typing, the terminal will just display a corresponding\n * number of asterisks, like \"****\". This is useful for passwords and other\n * secrets that should not be displayed. */\nvoid linenoiseMaskModeEnable(void) {\n maskmode = 1;\n}\n\n/* Disable mask mode. */\nvoid linenoiseMaskModeDisable(void) {\n maskmode = 0;\n}\n\n/* Set if to use or not the multi line mode. */\nvoid linenoiseSetMultiLine(int ml) {\n mlmode = ml;\n}\n\n#define REVERSE_SEARCH_PROMPT(direction) ((direction) == -1 ? \"(reverse-i-search): \" : \"(i-search): \")\n\n/* Enables the reverse search mode and refreshes the prompt. */\nstatic void enableReverseSearchMode(struct linenoiseState *l) {\n assert(reverse_search_mode_enabled != 1);\n reverse_search_mode_enabled = 1;\n l->origin_prompt = l->prompt;\n l->prompt = REVERSE_SEARCH_PROMPT(reverse_search_direction);\n refreshLine(l);\n}\n\n/* This function disables the reverse search mode and returns the terminal to its original state.\n * If the 'discard' parameter is true, it discards the user's input search keyword and search result.\n * Otherwise, it copies the search result into 'buf', If there is no search result, it copies the\n * input search keyword instead. */\nstatic void disableReverseSearchMode(struct linenoiseState *l, char *buf, size_t buflen, int discard) {\n if (discard) {\n buf[0] = '\\0';\n l->pos = l->len = 0;\n } else {\n ignore_once_hint = 1;\n if (strlen(search_result)) {\n strncpy(buf, search_result, buflen);\n buf[buflen-1] = '\\0';\n l->pos = l->len = strlen(buf);\n }\n }\n\n /* Reset the state to non-search state. */\n reverse_search_mode_enabled = 0;\n l->prompt = l->origin_prompt;\n resetSearchResult();\n refreshLine(l);\n}\n\n/* Return true if the terminal name is in the list of terminals we know are\n * not able to understand basic escape sequences. */\nstatic int isUnsupportedTerm(void) {\n char *term = getenv(\"TERM\");\n int j;\n\n if (term == NULL) return 0;\n for (j = 0; unsupported_term[j]; j++)\n if (!strcasecmp(term,unsupported_term[j])) return 1;\n return 0;\n}\n\n/* Raw mode: 1960's magic. */\nstatic int enableRawMode(int fd) {\n if (getenv(\"FAKETTY_WITH_PROMPT\") != NULL) {\n return 0;\n }\n\n struct termios raw;\n\n if (!isatty(STDIN_FILENO)) goto fatal;\n if (!atexit_registered) {\n atexit(linenoiseAtExit);\n atexit_registered = 1;\n }\n if (tcgetattr(fd,&orig_termios) == -1) goto fatal;\n\n raw = orig_termios; /* modify the original mode */\n /* input modes: no break, no CR to NL, no parity check, no strip char,\n * no start/stop output control. */\n raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);\n /* output modes - disable post processing */\n raw.c_oflag &= ~(OPOST);\n /* control modes - set 8 bit chars */\n raw.c_cflag |= (CS8);\n /* local modes - choing off, canonical off, no extended functions,\n * no signal chars (^Z,^C) */\n raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);\n /* control chars - set return condition: min number of bytes and timer.\n * We want read to return every single byte, without timeout. */\n raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */\n\n /* put terminal in raw mode */\n if (tcsetattr(fd,TCSANOW,&raw) < 0) goto fatal;\n rawmode = 1;\n return 0;\n\nfatal:\n errno = ENOTTY;\n return -1;\n}\n\nstatic void disableRawMode(int fd) {\n /* Don't even check the return value as it's too late. */\n if (rawmode && tcsetattr(fd,TCSANOW,&orig_termios) != -1)\n rawmode = 0;\n}\n\n/* Use the ESC [6n escape sequence to query the horizontal cursor position\n * and return it. On error -1 is returned, on success the position of the\n * cursor. */\nstatic int getCursorPosition(int ifd, int ofd) {\n char buf[32];\n int cols, rows;\n unsigned int i = 0;\n\n /* Report cursor location */\n if (write(ofd, \"\\x1b[6n\", 4) != 4) return -1;\n\n /* Read the response: ESC [ rows ; cols R */\n while (i < sizeof(buf)-1) {\n if (read(ifd,buf+i,1) != 1) break;\n if (buf[i] == 'R') break;\n i++;\n }\n buf[i] = '\\0';\n\n /* Parse it. */\n if (buf[0] != ESC || buf[1] != '[') return -1;\n if (sscanf(buf+2,\"%d;%d\",&rows,&cols) != 2) return -1;\n return cols;\n}\n\n/* Try to get the number of columns in the current terminal, or assume 80\n * if it fails. */\nstatic int getColumns(int ifd, int ofd) {\n if (getenv(\"FAKETTY_WITH_PROMPT\") != NULL) {\n goto failed;\n }\n struct winsize ws;\n\n if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {\n /* ioctl() failed. Try to query the terminal itself. */\n int start, cols;\n\n /* Get the initial position so we can restore it later. */\n start = getCursorPosition(ifd,ofd);\n if (start == -1) goto failed;\n\n /* Go to right margin and get position. */\n if (write(ofd,\"\\x1b[999C\",6) != 6) goto failed;\n cols = getCursorPosition(ifd,ofd);\n if (cols == -1) goto failed;\n\n /* Restore position. */\n if (cols > start) {\n char seq[32];\n snprintf(seq,32,\"\\x1b[%dD\",cols-start);\n if (write(ofd,seq,strlen(seq)) == -1) {\n /* Can't recover... */\n }\n }\n return cols;\n } else {\n return ws.ws_col;\n }\n\nfailed:\n return 80;\n}\n\n/* Clear the screen. Used to handle ctrl+l */\nvoid linenoiseClearScreen(void) {\n if (write(STDOUT_FILENO,\"\\x1b[H\\x1b[2J\",7) <= 0) {\n /* nothing to do, just to avoid warning. */\n }\n}\n\n/* Beep, used for completion when there is nothing to complete or when all\n * the choices were already shown. */\nstatic void linenoiseBeep(void) {\n fprintf(stderr, \"\\x7\");\n fflush(stderr);\n}\n\n/* ============================== Completion ================================ */\n\n/* Free a list of completion option populated by linenoiseAddCompletion(). */\nstatic void freeCompletions(linenoiseCompletions *lc) {\n size_t i;\n for (i = 0; i < lc->len; i++)\n free(lc->cvec[i]);\n if (lc->cvec != NULL)\n free(lc->cvec);\n}\n\n/* This is an helper function for linenoiseEdit() and is called when the\n * user types the key in order to complete the string currently in the\n * input.\n *\n * The state of the editing is encapsulated into the pointed linenoiseState\n * structure as described in the structure definition. */\nstatic int completeLine(struct linenoiseState *ls) {\n linenoiseCompletions lc = { 0, NULL };\n int nread, nwritten;\n char c = 0;\n\n completionCallback(ls->buf,&lc);\n if (lc.len == 0) {\n linenoiseBeep();\n } else {\n size_t stop = 0, i = 0;\n\n while(!stop) {\n /* Show completion or original buffer */\n if (i < lc.len) {\n struct linenoiseState saved = *ls;\n\n ls->len = ls->pos = strlen(lc.cvec[i]);\n ls->buf = lc.cvec[i];\n refreshLine(ls);\n ls->len = saved.len;\n ls->pos = saved.pos;\n ls->buf = saved.buf;\n } else {\n refreshLine(ls);\n }\n\n nread = read(ls->ifd,&c,1);\n if (nread <= 0) {\n freeCompletions(&lc);\n return -1;\n }\n\n switch(c) {\n case 9: /* tab */\n i = (i+1) % (lc.len+1);\n if (i == lc.len) linenoiseBeep();\n break;\n case 27: /* escape */\n /* Re-show original buffer */\n if (i < lc.len) refreshLine(ls);\n stop = 1;\n break;\n default:\n /* Update buffer and return */\n if (i < lc.len) {\n nwritten = snprintf(ls->buf,ls->buflen,\"%s\",lc.cvec[i]);\n ls->len = ls->pos = nwritten;\n }\n stop = 1;\n break;\n }\n }\n }\n\n freeCompletions(&lc);\n return c; /* Return last read character */\n}\n\n/* Register a callback function to be called for tab-completion. */\nvoid linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {\n completionCallback = fn;\n}\n\n/* Register a hits function to be called to show hits to the user at the\n * right of the prompt. */\nvoid linenoiseSetHintsCallback(linenoiseHintsCallback *fn) {\n hintsCallback = fn;\n}\n\n/* Register a function to free the hints returned by the hints callback\n * registered with linenoiseSetHintsCallback(). */\nvoid linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) {\n freeHintsCallback = fn;\n}\n\n/* This function is used by the callback function registered by the user\n * in order to add completion options given the input string when the\n * user typed . See the example.c source code for a very easy to\n * understand example. */\nvoid linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {\n size_t len = strlen(str);\n char *copy, **cvec;\n\n copy = malloc(len+1);\n if (copy == NULL) return;\n memcpy(copy,str,len+1);\n cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));\n if (cvec == NULL) {\n free(copy);\n return;\n }\n lc->cvec = cvec;\n lc->cvec[lc->len++] = copy;\n}\n\n/* =========================== Line editing ================================= */\n\n/* We define a very simple \"append buffer\" structure, that is an heap\n * allocated string where we can append to. This is useful in order to\n * write all the escape sequences in a buffer and flush them to the standard\n * output in a single call, to avoid flickering effects. */\nstruct abuf {\n char *b;\n int len;\n};\n\nstatic void abInit(struct abuf *ab) {\n ab->b = NULL;\n ab->len = 0;\n}\n\nstatic void abAppend(struct abuf *ab, const char *s, int len) {\n char *new = realloc(ab->b,ab->len+len);\n\n if (new == NULL) return;\n memcpy(new+ab->len,s,len);\n ab->b = new;\n ab->len += len;\n}\n\nstatic void abFree(struct abuf *ab) {\n free(ab->b);\n}\n\n/* Helper of refreshSingleLine() and refreshMultiLine() to show hints\n * to the right of the prompt. */\nvoid refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {\n char seq[64];\n\n /* Show hits when not in reverse search mode and not instructed to ignore once. */\n if (reverse_search_mode_enabled || ignore_once_hint) {\n ignore_once_hint = 0;\n return;\n }\n\n if (hintsCallback && plen+l->len < l->cols) {\n int color = -1, bold = 0;\n char *hint = hintsCallback(l->buf,&color,&bold);\n if (hint) {\n int hintlen = strlen(hint);\n int hintmaxlen = l->cols-(plen+l->len);\n if (hintlen > hintmaxlen) hintlen = hintmaxlen;\n if (bold == 1 && color == -1) color = 37;\n if (color != -1 || bold != 0)\n snprintf(seq,64,\"\\033[%d;%d;49m\",bold,color);\n else\n seq[0] = '\\0';\n abAppend(ab,seq,strlen(seq));\n abAppend(ab,hint,hintlen);\n if (color != -1 || bold != 0)\n abAppend(ab,\"\\033[0m\",4);\n /* Call the function to free the hint returned. */\n if (freeHintsCallback) freeHintsCallback(hint);\n }\n }\n}\n\n/* Single line low level line refresh.\n *\n * Rewrite the currently edited line accordingly to the buffer content,\n * cursor position, and number of columns of the terminal. */\nstatic void refreshSingleLine(struct linenoiseState *l) {\n char seq[64];\n size_t plen = strlen(l->prompt);\n int fd = l->ofd;\n char *buf = l->buf;\n size_t len = l->len;\n size_t pos = l->pos;\n struct abuf ab;\n\n while((plen+pos) >= l->cols) {\n buf++;\n len--;\n pos--;\n }\n while (plen+len > l->cols) {\n len--;\n }\n\n abInit(&ab);\n /* Cursor to left edge */\n snprintf(seq,64,\"\\r\");\n abAppend(&ab,seq,strlen(seq));\n /* Write the prompt and the current buffer content */\n abAppend(&ab,l->prompt,strlen(l->prompt));\n if (maskmode == 1) {\n while (len--) abAppend(&ab,\"*\",1);\n } else {\n abAppend(&ab,buf,len);\n }\n /* Show hits if any. */\n refreshShowHints(&ab,l,plen);\n /* Erase to right */\n snprintf(seq,64,\"\\x1b[0K\");\n abAppend(&ab,seq,strlen(seq));\n /* Move cursor to original position. */\n snprintf(seq,64,\"\\r\\x1b[%dC\", (int)(pos+plen));\n abAppend(&ab,seq,strlen(seq));\n if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */\n abFree(&ab);\n}\n\n/* Multi line low level line refresh.\n *\n * Rewrite the currently edited line accordingly to the buffer content,\n * cursor position, and number of columns of the terminal. */\nstatic void refreshMultiLine(struct linenoiseState *l) {\n char seq[64];\n int plen = strlen(l->prompt);\n int rows = (plen+l->len+l->cols-1)/l->cols; /* rows used by current buf. */\n int rpos = (plen+l->oldpos+l->cols)/l->cols; /* cursor relative row. */\n int rpos2; /* rpos after refresh. */\n int col; /* colum position, zero-based. */\n int old_rows = l->maxrows;\n int fd = l->ofd, j;\n struct abuf ab;\n\n /* Update maxrows if needed. */\n if (rows > (int)l->maxrows) l->maxrows = rows;\n\n /* First step: clear all the lines used before. To do so start by\n * going to the last row. */\n abInit(&ab);\n if (old_rows-rpos > 0) {\n lndebug(\"go down %d\", old_rows-rpos);\n snprintf(seq,64,\"\\x1b[%dB\", old_rows-rpos);\n abAppend(&ab,seq,strlen(seq));\n }\n\n /* Now for every row clear it, go up. */\n for (j = 0; j < old_rows-1; j++) {\n lndebug(\"clear+up\");\n snprintf(seq,64,\"\\r\\x1b[0K\\x1b[1A\");\n abAppend(&ab,seq,strlen(seq));\n }\n\n /* Clean the top line. */\n lndebug(\"clear\");\n snprintf(seq,64,\"\\r\\x1b[0K\");\n abAppend(&ab,seq,strlen(seq));\n\n /* Write the prompt and the current buffer content */\n abAppend(&ab,l->prompt,strlen(l->prompt));\n if (maskmode == 1) {\n unsigned int i;\n for (i = 0; i < l->len; i++) abAppend(&ab,\"*\",1);\n } else {\n refreshSearchResult(l);\n if (strlen(search_result) > 0) {\n abAppend(&ab, search_result_friendly, strlen(search_result_friendly));\n } else {\n abAppend(&ab,l->buf,l->len);\n }\n }\n\n /* Show hits if any. */\n refreshShowHints(&ab,l,plen);\n\n /* If we are at the very end of the screen with our prompt, we need to\n * emit a newline and move the prompt to the first column. */\n if (l->pos &&\n l->pos == l->len &&\n (l->pos+plen) % l->cols == 0)\n {\n lndebug(\"\");\n abAppend(&ab,\"\\n\",1);\n snprintf(seq,64,\"\\r\");\n abAppend(&ab,seq,strlen(seq));\n rows++;\n if (rows > (int)l->maxrows) l->maxrows = rows;\n }\n\n /* Move cursor to right position. */\n rpos2 = (plen+l->pos+l->cols)/l->cols; /* current cursor relative row. */\n lndebug(\"rpos2 %d\", rpos2);\n\n /* Go up till we reach the expected position. */\n if (rows-rpos2 > 0) {\n lndebug(\"go-up %d\", rows-rpos2);\n snprintf(seq,64,\"\\x1b[%dA\", rows-rpos2);\n abAppend(&ab,seq,strlen(seq));\n }\n\n /* Set column. */\n col = (plen+(int)l->pos) % (int)l->cols;\n if (strlen(search_result) > 0) {\n col += search_result_start_offset;\n }\n lndebug(\"set col %d\", 1+col);\n if (col)\n snprintf(seq,64,\"\\r\\x1b[%dC\", col);\n else\n snprintf(seq,64,\"\\r\");\n abAppend(&ab,seq,strlen(seq));\n\n lndebug(\"\\n\");\n l->oldpos = l->pos;\n\n if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */\n abFree(&ab);\n}\n\n/* Calls the two low level functions refreshSingleLine() or\n * refreshMultiLine() according to the selected mode. */\nstatic void refreshLine(struct linenoiseState *l) {\n if (mlmode)\n refreshMultiLine(l);\n else\n refreshSingleLine(l);\n}\n\n/* Insert the character 'c' at cursor current position.\n *\n * On error writing to the terminal -1 is returned, otherwise 0. */\nint linenoiseEditInsert(struct linenoiseState *l, char c) {\n if (l->len < l->buflen) {\n if (l->len == l->pos) {\n l->buf[l->pos] = c;\n l->pos++;\n l->len++;\n l->buf[l->len] = '\\0';\n if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) {\n /* Avoid a full update of the line in the\n * trivial case. */\n char d = (maskmode==1) ? '*' : c;\n if (write(l->ofd,&d,1) == -1) return -1;\n } else {\n refreshLine(l);\n }\n } else {\n memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos);\n l->buf[l->pos] = c;\n l->len++;\n l->pos++;\n l->buf[l->len] = '\\0';\n refreshLine(l);\n }\n }\n return 0;\n}\n\n/* Move cursor on the left. */\nvoid linenoiseEditMoveLeft(struct linenoiseState *l) {\n if (l->pos > 0) {\n l->pos--;\n refreshLine(l);\n }\n}\n\n/* Move cursor on the right. */\nvoid linenoiseEditMoveRight(struct linenoiseState *l) {\n if (l->pos != l->len) {\n l->pos++;\n refreshLine(l);\n }\n}\n\n/* Consider letters/digits/underscore as “word”; others as delimiters. */\nstatic int isWordChar(char c) {\n return (c == '_' || (c >= '0' && c <= '9') ||\n (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));\n}\n\nstatic void linenoiseEditMoveWordLeft(struct linenoiseState *l) {\n if (l->pos == 0) return;\n /* Skip any delimiters, then move left over the previous word */\n while (l->pos > 0 && !isWordChar(l->buf[l->pos - 1])) l->pos--;\n /* Then move to the start of that word */\n while (l->pos > 0 && isWordChar(l->buf[l->pos - 1])) l->pos--;\n refreshLine(l);\n}\n\nstatic void linenoiseEditMoveWordRight(struct linenoiseState *l) {\n if (l->pos == l->len) return;\n /* Skip the current word to the right */\n while (l->pos < l->len && isWordChar(l->buf[l->pos])) l->pos++;\n /* Then skip any delimiters to reach the next word */\n while (l->pos < l->len && !isWordChar(l->buf[l->pos])) l->pos++;\n refreshLine(l);\n}\n\n/* Move cursor to the start of the line. */\nvoid linenoiseEditMoveHome(struct linenoiseState *l) {\n if (l->pos != 0) {\n l->pos = 0;\n refreshLine(l);\n }\n}\n\n/* Move cursor to the end of the line. */\nvoid linenoiseEditMoveEnd(struct linenoiseState *l) {\n if (l->pos != l->len) {\n l->pos = l->len;\n refreshLine(l);\n }\n}\n\n/* Substitute the currently edited line with the next or previous history\n * entry as specified by 'dir'. */\n#define LINENOISE_HISTORY_NEXT 0\n#define LINENOISE_HISTORY_PREV 1\nvoid linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {\n if (history_len > 1) {\n /* Update the current history entry before to\n * overwrite it with the next one. */\n free(history[history_len - 1 - l->history_index]);\n history[history_len - 1 - l->history_index] = strdup(l->buf);\n /* Show the new entry */\n l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;\n if (l->history_index < 0) {\n l->history_index = 0;\n return;\n } else if (l->history_index >= history_len) {\n l->history_index = history_len-1;\n return;\n }\n strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen);\n l->buf[l->buflen-1] = '\\0';\n l->len = l->pos = strlen(l->buf);\n refreshLine(l);\n }\n}\n\n/* Delete the character at the right of the cursor without altering the cursor\n * position. Basically this is what happens with the \"Delete\" keyboard key. */\nvoid linenoiseEditDelete(struct linenoiseState *l) {\n if (l->len > 0 && l->pos < l->len) {\n memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1);\n l->len--;\n l->buf[l->len] = '\\0';\n refreshLine(l);\n }\n}\n\n/* Backspace implementation. */\nvoid linenoiseEditBackspace(struct linenoiseState *l) {\n if (l->pos > 0 && l->len > 0) {\n memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);\n l->pos--;\n l->len--;\n l->buf[l->len] = '\\0';\n refreshLine(l);\n }\n}\n\n/* Delete the previous word, maintaining the cursor at the start of the\n * current word. */\nvoid linenoiseEditDeletePrevWord(struct linenoiseState *l) {\n size_t old_pos = l->pos;\n size_t diff;\n\n while (l->pos > 0 && l->buf[l->pos-1] == ' ')\n l->pos--;\n while (l->pos > 0 && l->buf[l->pos-1] != ' ')\n l->pos--;\n diff = old_pos - l->pos;\n memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1);\n l->len -= diff;\n refreshLine(l);\n}\n\n/* This function is the core of the line editing capability of linenoise.\n * It expects 'fd' to be already in \"raw mode\" so that every key pressed\n * will be returned ASAP to read().\n *\n * The resulting string is put into 'buf' when the user type enter, or\n * when ctrl+d is typed.\n *\n * The function returns the length of the current buffer. */\nstatic int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt)\n{\n struct linenoiseState l;\n\n /* Populate the linenoise state that we pass to functions implementing\n * specific editing functionalities. */\n l.ifd = stdin_fd;\n l.ofd = stdout_fd;\n l.buf = buf;\n l.buflen = buflen;\n l.prompt = prompt;\n l.plen = strlen(prompt);\n l.oldpos = l.pos = 0;\n l.len = 0;\n l.cols = getColumns(stdin_fd, stdout_fd);\n l.maxrows = 0;\n l.history_index = 0;\n\n /* Buffer starts empty. */\n l.buf[0] = '\\0';\n l.buflen--; /* Make sure there is always space for the nulterm */\n\n /* The latest history entry is always our current buffer, that\n * initially is just an empty string. */\n linenoiseHistoryAdd(\"\", 0);\n\n if (write(l.ofd,prompt,l.plen) == -1) return -1;\n while(1) {\n char c;\n int nread;\n char seq[3];\n\n nread = read(l.ifd,&c,1);\n if (nread <= 0) return l.len;\n\n /* Only autocomplete when the callback is set. It returns < 0 when\n * there was an error reading from fd. Otherwise it will return the\n * character that should be handled next. */\n if (c == TAB && completionCallback != NULL && !reverse_search_mode_enabled) {\n c = completeLine(&l);\n /* Return on errors */\n if (c < 0) return l.len;\n /* Read next character when 0 */\n if (c == 0) continue;\n }\n\n switch(c) {\n case NL: /* enter, typed before raw mode was enabled */\n break;\n case TAB:\n if (reverse_search_mode_enabled) disableReverseSearchMode(&l, buf, buflen, 0);\n break;\n case ENTER: /* enter */\n history_len--;\n free(history[history_len]);\n if (mlmode) linenoiseEditMoveEnd(&l);\n if (hintsCallback) {\n /* Force a refresh without hints to leave the previous\n * line as the user typed it after a newline. */\n linenoiseHintsCallback *hc = hintsCallback;\n hintsCallback = NULL;\n refreshLine(&l);\n hintsCallback = hc;\n }\n\n if (reverse_search_mode_enabled) disableReverseSearchMode(&l, buf, buflen, 0);\n return (int)l.len;\n case CTRL_C: /* ctrl-c */\n if (reverse_search_mode_enabled) {\n disableReverseSearchMode(&l, buf, buflen, 1);\n break;\n }\n errno = EAGAIN;\n return -1;\n case BACKSPACE: /* backspace */\n case 8: /* ctrl-h */\n linenoiseEditBackspace(&l);\n break;\n case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the\n line is empty, act as end-of-file. */\n if (l.len > 0) {\n linenoiseEditDelete(&l);\n } else {\n history_len--;\n free(history[history_len]);\n return -1;\n }\n break;\n case CTRL_T: /* ctrl-t, swaps current character with previous. */\n if (l.pos > 0 && l.pos < l.len) {\n int aux = buf[l.pos-1];\n buf[l.pos-1] = buf[l.pos];\n buf[l.pos] = aux;\n if (l.pos != l.len-1) l.pos++;\n refreshLine(&l);\n }\n break;\n case CTRL_B: /* ctrl-b */\n linenoiseEditMoveLeft(&l);\n break;\n case CTRL_F: /* ctrl-f */\n linenoiseEditMoveRight(&l);\n break;\n case CTRL_P: /* ctrl-p */\n linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);\n break;\n case CTRL_R:\n case CTRL_S:\n reverse_search_direction = c == CTRL_R ? -1 : 1;\n if (reverse_search_mode_enabled) {\n /* cycle search results */\n cycle_to_next_search = 1;\n l.prompt = REVERSE_SEARCH_PROMPT(reverse_search_direction);\n refreshLine(&l);\n break;\n }\n buf[0] = '\\0';\n l.pos = l.len = 0;\n enableReverseSearchMode(&l);\n break;\n case CTRL_G:\n if (reverse_search_mode_enabled) disableReverseSearchMode(&l, buf, buflen, 1);\n break;\n case CTRL_N: /* ctrl-n */\n linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);\n break;\n case ESC: /* escape sequence */\n /* Read the next two bytes representing the escape sequence.\n * Use two calls to handle slow terminals returning the two\n * chars at different times. */\n if (read(l.ifd,seq,1) == -1) break;\n\n /* Handle Meta-b / Meta-f directly because it's a 2-byte sequence */\n if (seq[0] == 'b' || seq[0] == 'f') {\n if (reverse_search_mode_enabled) {\n disableReverseSearchMode(&l, buf, buflen, 1);\n break;\n }\n if (seq[0] == 'b') linenoiseEditMoveWordLeft(&l); /* ESC b → word left */\n else linenoiseEditMoveWordRight(&l); /* ESC f → word right */\n break;\n }\n\n if (read(l.ifd,seq+1,1) == -1) break;\n\n if (reverse_search_mode_enabled) {\n disableReverseSearchMode(&l, buf, buflen, 1);\n break;\n }\n\n /* ESC [ sequences. */\n if (seq[0] == '[') {\n if (seq[1] >= '0' && seq[1] <= '9') {\n /* Extended escape, read additional bytes.\n * Examples: ESC [1;5C ESC [3~ */\n char seq_buffer[SEQ_BUFFER_MAX_LENGTH];\n int i = 0;\n seq_buffer[i++] = seq[1];\n\n /* Read more bytes until we see a CSI final byte (range @..~).\n * Use SEQ_BUFFER_MAX_LENGTH-1 to reserve one position for '\\0'. */\n char seq_char;\n while (i < SEQ_BUFFER_MAX_LENGTH - 1 && read(l.ifd, &seq_char, 1) == 1) {\n seq_buffer[i++] = seq_char;\n if (seq_char >= '@' && seq_char <= '~') break; /* CSI final byte */\n }\n seq_buffer[i] = '\\0';\n\n /* The exact key mapping behavior depends on your keyboard/terminal setup.\n * For example, in MacOS terminal you can go to the profile keyboard setting\n * to see or configure the current mapping.\n *\n * Take action `[1;5C` (Ctrl + →) or `[1;3D` (Alt + ←) as examples:\n * [ indicates a CSI (Control Sequence Introducer), telling the terminal\n * \"What follows is a control command, not text\"\n * 1 is how many units to move (default is 1 if omitted)\n * ; is the separator between parameters\n * 5 is the modifier mask for Ctrl. Other possible values include 1 (no modifier),\n * 2 (Shift), 3 (Alt), 4 (Shift + Alt), 6 (Shift + Ctrl), 7 (Alt + Ctrl), etc.\n * C is the cursor right command. Other commands include A (cursor up), B (cursor\n * down), D (cursor left).\n */\n\n /* Word left: Ctrl + ← (modifier 5) or Alt + ← (modifier 3) */\n if (strcmp(seq_buffer, \"1;5D\") == 0 || strcmp(seq_buffer, \"1;3D\") == 0) {\n linenoiseEditMoveWordLeft(&l);\n break;\n }\n /* Word right: Ctrl + → (modifier 5) or Alt + → (modifier 3) */\n if (strcmp(seq_buffer, \"1;5C\") == 0 || strcmp(seq_buffer, \"1;3C\") == 0) {\n linenoiseEditMoveWordRight(&l);\n break;\n }\n /* Delete key */\n if (strcmp(seq_buffer, \"3~\") == 0) {\n linenoiseEditDelete(&l);\n break;\n }\n } else {\n switch(seq[1]) {\n case 'A': /* Up */\n linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);\n break;\n case 'B': /* Down */\n linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);\n break;\n case 'C': /* Right */\n linenoiseEditMoveRight(&l);\n break;\n case 'D': /* Left */\n linenoiseEditMoveLeft(&l);\n break;\n case 'H': /* Home */\n linenoiseEditMoveHome(&l);\n break;\n case 'F': /* End*/\n linenoiseEditMoveEnd(&l);\n break;\n }\n }\n }\n\n /* ESC O sequences. */\n else if (seq[0] == 'O') {\n switch(seq[1]) {\n case 'H': /* Home */\n linenoiseEditMoveHome(&l);\n break;\n case 'F': /* End*/\n linenoiseEditMoveEnd(&l);\n break;\n }\n }\n break;\n default:\n if (linenoiseEditInsert(&l,c)) return -1;\n break;\n case CTRL_U: /* Ctrl+u, delete the whole line. */\n buf[0] = '\\0';\n l.pos = l.len = 0;\n refreshLine(&l);\n break;\n case CTRL_K: /* Ctrl+k, delete from current to end of line. */\n buf[l.pos] = '\\0';\n l.len = l.pos;\n refreshLine(&l);\n break;\n case CTRL_A: /* Ctrl+a, go to the start of the line */\n linenoiseEditMoveHome(&l);\n break;\n case CTRL_E: /* ctrl+e, go to the end of the line */\n linenoiseEditMoveEnd(&l);\n break;\n case CTRL_L: /* ctrl+l, clear screen */\n linenoiseClearScreen();\n refreshLine(&l);\n break;\n case CTRL_W: /* ctrl+w, delete previous word */\n linenoiseEditDeletePrevWord(&l);\n break;\n }\n }\n return l.len;\n}\n\n/* This special mode is used by linenoise in order to print scan codes\n * on screen for debugging / development purposes. It is implemented\n * by the linenoise_example program using the --keycodes option. */\nvoid linenoisePrintKeyCodes(void) {\n char quit[4];\n\n printf(\"Linenoise key codes debugging mode.\\n\"\n \"Press keys to see scan codes. Type 'quit' at any time to exit.\\n\");\n if (enableRawMode(STDIN_FILENO) == -1) return;\n memset(quit,' ',4);\n while(1) {\n char c;\n int nread;\n\n nread = read(STDIN_FILENO,&c,1);\n if (nread <= 0) continue;\n memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */\n quit[sizeof(quit)-1] = c; /* Insert current char on the right. */\n if (memcmp(quit,\"quit\",sizeof(quit)) == 0) break;\n\n printf(\"'%c' %02x (%d) (type quit to exit)\\n\",\n isprint(c) ? c : '?', (int)c, (int)c);\n printf(\"\\r\"); /* Go left edge manually, we are in raw mode. */\n fflush(stdout);\n }\n disableRawMode(STDIN_FILENO);\n}\n\n/* This function calls the line editing function linenoiseEdit() using\n * the STDIN file descriptor set in raw mode. */\nstatic int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {\n int count;\n\n if (buflen == 0) {\n errno = EINVAL;\n return -1;\n }\n\n if (enableRawMode(STDIN_FILENO) == -1) return -1;\n count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, buflen, prompt);\n disableRawMode(STDIN_FILENO);\n printf(\"\\n\");\n return count;\n}\n\n/* This function is called when linenoise() is called with the standard\n * input file descriptor not attached to a TTY. So for example when the\n * program using linenoise is called in pipe or with a file redirected\n * to its standard input. In this case, we want to be able to return the\n * line regardless of its length (by default we are limited to 4k). */\nstatic char *linenoiseNoTTY(void) {\n char *line = NULL;\n size_t len = 0, maxlen = 0;\n\n while(1) {\n if (len == maxlen) {\n if (maxlen == 0) maxlen = 16;\n maxlen *= 2;\n char *oldval = line;\n line = realloc(line,maxlen);\n if (line == NULL) {\n if (oldval) free(oldval);\n return NULL;\n }\n }\n int c = fgetc(stdin);\n if (c == EOF || c == '\\n') {\n if (c == EOF && len == 0) {\n free(line);\n return NULL;\n } else {\n line[len] = '\\0';\n return line;\n }\n } else {\n line[len] = c;\n len++;\n }\n }\n}\n\n/* The high level function that is the main API of the linenoise library.\n * This function checks if the terminal has basic capabilities, just checking\n * for a blacklist of stupid terminals, and later either calls the line\n * editing function or uses dummy fgets() so that you will be able to type\n * something even in the most desperate of the conditions. */\nchar *linenoise(const char *prompt) {\n char buf[LINENOISE_MAX_LINE] = {0};\n int count;\n\n if (getenv(\"FAKETTY_WITH_PROMPT\") == NULL && !isatty(STDIN_FILENO)) {\n /* Not a tty: read from file / pipe. In this mode we don't want any\n * limit to the line size, so we call a function to handle that. */\n return linenoiseNoTTY();\n } else if (getenv(\"FAKETTY_WITH_PROMPT\") == NULL && isUnsupportedTerm()) {\n size_t len;\n\n printf(\"%s\",prompt);\n fflush(stdout);\n if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;\n len = strlen(buf);\n while(len && (buf[len-1] == '\\n' || buf[len-1] == '\\r')) {\n len--;\n buf[len] = '\\0';\n }\n return strdup(buf);\n } else {\n count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);\n if (count == -1) return NULL;\n return strdup(buf);\n }\n}\n\n/* This is just a wrapper the user may want to call in order to make sure\n * the linenoise returned buffer is freed with the same allocator it was\n * created with. Useful when the main program is using an alternative\n * allocator. */\nvoid linenoiseFree(void *ptr) {\n free(ptr);\n}\n\n/* ================================ History ================================= */\n\n/* Free the history, but does not reset it. Only used when we have to\n * exit() to avoid memory leaks are reported by valgrind & co. */\nstatic void freeHistory(void) {\n if (history) {\n int j;\n\n for (j = 0; j < history_len; j++)\n free(history[j]);\n free(history);\n free(history_sensitive);\n }\n}\n\n/* At exit we'll try to fix the terminal to the initial conditions. */\nstatic void linenoiseAtExit(void) {\n disableRawMode(STDIN_FILENO);\n freeHistory();\n}\n\n/* This is the API call to add a new entry in the linenoise history.\n * It uses a fixed array of char pointers that are shifted (memmoved)\n * when the history max length is reached in order to remove the older\n * entry and make room for the new one, so it is not exactly suitable for huge\n * histories, but will work well for a few hundred of entries.\n *\n * Using a circular buffer is smarter, but a bit more complex to handle. */\nint linenoiseHistoryAdd(const char *line, int is_sensitive) {\n char *linecopy;\n\n if (history_max_len == 0) return 0;\n\n /* Initialization on first call. */\n if (history == NULL) {\n history = malloc(sizeof(char*)*history_max_len);\n if (history == NULL) return 0;\n history_sensitive = malloc(sizeof(int)*history_max_len);\n if (history_sensitive == NULL) {\n free(history);\n history = NULL;\n return 0;\n }\n memset(history,0,(sizeof(char*)*history_max_len));\n memset(history_sensitive,0,(sizeof(int)*history_max_len));\n }\n\n /* Don't add duplicated lines. */\n if (history_len && !strcmp(history[history_len-1], line)) return 0;\n\n /* Add an heap allocated copy of the line in the history.\n * If we reached the max length, remove the older line. */\n linecopy = strdup(line);\n if (!linecopy) return 0;\n if (history_len == history_max_len) {\n free(history[0]);\n memmove(history,history+1,sizeof(char*)*(history_max_len-1));\n memmove(history_sensitive,history_sensitive+1,sizeof(int)*(history_max_len-1));\n history_len--;\n }\n history[history_len] = linecopy;\n history_sensitive[history_len] = is_sensitive;\n history_len++;\n return 1;\n}\n\n/* Set the maximum length for the history. This function can be called even\n * if there is already some history, the function will make sure to retain\n * just the latest 'len' elements if the new history length value is smaller\n * than the amount of items already inside the history. */\nint linenoiseHistorySetMaxLen(int len) {\n char **new;\n int *new_sensitive;\n\n if (len < 1) return 0;\n if (history) {\n int tocopy = history_len;\n\n new = malloc(sizeof(char*)*len);\n if (new == NULL) return 0;\n new_sensitive = malloc(sizeof(int)*len);\n if (new_sensitive == NULL) {\n free(new);\n return 0;\n }\n\n /* If we can't copy everything, free the elements we'll not use. */\n if (len < tocopy) {\n int j;\n\n for (j = 0; j < tocopy-len; j++) free(history[j]);\n tocopy = len;\n }\n memset(new,0,sizeof(char*)*len);\n memset(new_sensitive,0,sizeof(int)*len);\n memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);\n memcpy(new_sensitive,history_sensitive+(history_len-tocopy), sizeof(int)*tocopy);\n free(history);\n free(history_sensitive);\n history = new;\n history_sensitive = new_sensitive;\n }\n history_max_len = len;\n if (history_len > history_max_len)\n history_len = history_max_len;\n return 1;\n}\n\n/* Save the history in the specified file. On success 0 is returned\n * otherwise -1 is returned. */\nint linenoiseHistorySave(const char *filename) {\n mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);\n FILE *fp;\n int j;\n\n fp = fopen(filename,\"w\");\n umask(old_umask);\n if (fp == NULL) return -1;\n fchmod(fileno(fp),S_IRUSR|S_IWUSR);\n for (j = 0; j < history_len; j++)\n if (!history_sensitive[j]) fprintf(fp,\"%s\\n\",history[j]);\n fclose(fp);\n return 0;\n}\n\n/* Load the history from the specified file. If the file does not exist\n * zero is returned and no operation is performed.\n *\n * If the file exists and the operation succeeded 0 is returned, otherwise\n * on error -1 is returned. */\nint linenoiseHistoryLoad(const char *filename) {\n FILE *fp = fopen(filename,\"r\");\n char buf[LINENOISE_MAX_LINE];\n\n if (fp == NULL) return -1;\n\n while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {\n char *p;\n\n p = strchr(buf,'\\r');\n if (!p) p = strchr(buf,'\\n');\n if (p) *p = '\\0';\n linenoiseHistoryAdd(buf, 0);\n }\n fclose(fp);\n return 0;\n}\n\n/* This function updates the search index based on the direction of the search.\n * Returns 0 if the beginning or end of the history is reached, otherwise, returns 1. */\nstatic int setNextSearchIndex(int *i) {\n if (reverse_search_direction == 1) {\n if (*i == history_len-1) return 0;\n *i = *i + 1;\n } else {\n if (*i <= 0) return 0;\n *i = *i - 1;\n }\n return 1;\n}\n\nlinenoiseHistorySearchResult searchInHistory(char *search_term) {\n linenoiseHistorySearchResult result = {0};\n\n if (!history_len || !strlen(search_term)) return result;\n\n int i = cycle_to_next_search ? search_result_history_index :\n (reverse_search_direction == -1 ? history_len-1 : 0);\n \n while (1) {\n char *found = strstr(history[i], search_term);\n \n /* check if we found the same string at another index when cycling, this would be annoying to cycle through\n * as it might appear that cycling isn't working */\n int strings_are_the_same = cycle_to_next_search && strcmp(history[i], history[search_result_history_index]) == 0; \n\n if (found && !strings_are_the_same) {\n int haystack_index = found - history[i];\n result.result = history[i];\n result.len = strlen(history[i]);\n result.search_term_index = haystack_index;\n result.search_term_len = strlen(search_term);\n search_result_history_index = i;\n break;\n }\n\n /* Exit if reached the end. */\n if (!setNextSearchIndex(&i)) break;\n }\n\n return result;\n}\n\nstatic void refreshSearchResult(struct linenoiseState *ls) {\n if (!reverse_search_mode_enabled) {\n return;\n }\n\n linenoiseHistorySearchResult sr = searchInHistory(ls->buf);\n int found = sr.result && sr.len;\n\n /* If the search term has not changed and we are cycling to the next search result\n * (using CTRL+R or CTRL+S), there is no need to reset the old search result. */\n if (!cycle_to_next_search || found)\n resetSearchResult();\n cycle_to_next_search = 0;\n\n if (found) {\n char *bold = \"\\x1B[1m\";\n char *normal = \"\\x1B[0m\";\n\n int size_needed = sr.search_term_index + sr.search_term_len + sr.len -\n (sr.search_term_index+sr.search_term_len) + sizeof(normal) + sizeof(bold) + sizeof(normal);\n if (size_needed > sizeof(search_result_friendly) - 1) {\n return;\n }\n\n /* Allocate memory for the prefix, match, and suffix strings, one extra byte for `\\0`. */\n char *prefix = calloc(sizeof(char), sr.search_term_index + 1);\n char *match = calloc(sizeof(char), sr.search_term_len + 1);\n char *suffix = calloc(sizeof(char), sr.len - (sr.search_term_index+sr.search_term_len) + 1);\n\n memcpy(prefix, sr.result, sr.search_term_index);\n memcpy(match, sr.result + sr.search_term_index, sr.search_term_len);\n memcpy(suffix, sr.result + sr.search_term_index + sr.search_term_len,\n sr.len - (sr.search_term_index+sr.search_term_len));\n sprintf(search_result, \"%s%s%s\", prefix, match, suffix);\n sprintf(search_result_friendly, \"%s%s%s%s%s%s\", normal, prefix, bold, match, normal, suffix);\n\n free(prefix);\n free(match);\n free(suffix);\n\n search_result_start_offset = sr.search_term_index;\n }\n}\n" }, { "path": "deps/linenoise/linenoise.h", "content": "/* linenoise.h -- VERSION 1.0\n *\n * Guerrilla line editing library against the idea that a line editing lib\n * needs to be 20,000 lines of C code.\n *\n * See linenoise.c for more information.\n *\n * ------------------------------------------------------------------------\n *\n * Copyright (c) 2010-2014, Salvatore Sanfilippo \n * Copyright (c) 2010-2013, Pieter Noordhuis \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef __LINENOISE_H\n#define __LINENOISE_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\ntypedef struct linenoiseCompletions {\n size_t len;\n char **cvec;\n} linenoiseCompletions;\n\ntypedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);\ntypedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold);\ntypedef void(linenoiseFreeHintsCallback)(void *);\nvoid linenoiseSetCompletionCallback(linenoiseCompletionCallback *);\nvoid linenoiseSetHintsCallback(linenoiseHintsCallback *);\nvoid linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *);\nvoid linenoiseAddCompletion(linenoiseCompletions *, const char *);\n\nchar *linenoise(const char *prompt);\nvoid linenoiseFree(void *ptr);\nint linenoiseHistoryAdd(const char *line, int is_sensitive);\nint linenoiseHistorySetMaxLen(int len);\nint linenoiseHistorySave(const char *filename);\nint linenoiseHistoryLoad(const char *filename);\nvoid linenoiseClearScreen(void);\nvoid linenoiseSetMultiLine(int ml);\nvoid linenoisePrintKeyCodes(void);\nvoid linenoiseMaskModeEnable(void);\nvoid linenoiseMaskModeDisable(void);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __LINENOISE_H */\n" }, { "path": "deps/lua/COPYRIGHT", "content": "Lua License\n-----------\n\nLua is licensed under the terms of the MIT license reproduced below.\nThis means that Lua is free software and can be used for both academic\nand commercial purposes at absolutely no cost.\n\nFor details and rationale, see http://www.lua.org/license.html .\n\n===============================================================================\n\nCopyright (C) 1994-2012 Lua.org, PUC-Rio.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n===============================================================================\n\n(end of COPYRIGHT)\n" }, { "path": "deps/lua/HISTORY", "content": "HISTORY for Lua 5.1\n\n* Changes from version 5.0 to 5.1\n -------------------------------\n Language:\n + new module system.\n + new semantics for control variables of fors.\n + new semantics for setn/getn.\n + new syntax/semantics for varargs.\n + new long strings and comments.\n + new `mod' operator (`%')\n + new length operator #t\n + metatables for all types\n API:\n + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer.\n + user supplies memory allocator (lua_open becomes lua_newstate).\n + luaopen_* functions must be called through Lua.\n Implementation:\n + new configuration scheme via luaconf.h.\n + incremental garbage collection.\n + better handling of end-of-line in the lexer.\n + fully reentrant parser (new Lua function `load')\n + better support for 64-bit machines.\n + native loadlib support for Mac OS X.\n + standard distribution in only one library (lualib.a merged into lua.a)\n\n* Changes from version 4.0 to 5.0\n -------------------------------\n Language:\n + lexical scoping.\n + Lua coroutines.\n + standard libraries now packaged in tables.\n + tags replaced by metatables and tag methods replaced by metamethods,\n stored in metatables.\n + proper tail calls.\n + each function can have its own global table, which can be shared.\n + new __newindex metamethod, called when we insert a new key into a table.\n + new block comments: --[[ ... ]].\n + new generic for.\n + new weak tables.\n + new boolean type.\n + new syntax \"local function\".\n + (f()) returns the first value returned by f.\n + {f()} fills a table with all values returned by f.\n + \\n ignored in [[\\n .\n + fixed and-or priorities.\n + more general syntax for function definition (e.g. function a.x.y:f()...end).\n + more general syntax for function calls (e.g. (print or write)(9)).\n + new functions (time/date, tmpfile, unpack, require, load*, etc.).\n API:\n + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer.\n + introduced lightweight userdata, a simple \"void*\" without a metatable.\n + new error handling protocol: the core no longer prints error messages;\n all errors are reported to the caller on the stack.\n + new lua_atpanic for host cleanup.\n + new, signal-safe, hook scheme.\n Implementation:\n + new license: MIT.\n + new, faster, register-based virtual machine.\n + support for external multithreading and coroutines.\n + new and consistent error message format.\n + the core no longer needs \"stdio.h\" for anything (except for a single\n use of sprintf to convert numbers to strings).\n + lua.c now runs the environment variable LUA_INIT, if present. It can\n be \"@filename\", to run a file, or the chunk itself.\n + support for user extensions in lua.c.\n sample implementation given for command line editing.\n + new dynamic loading library, active by default on several platforms.\n + safe garbage-collector metamethods.\n + precompiled bytecodes checked for integrity (secure binary dostring).\n + strings are fully aligned.\n + position capture in string.find.\n + read('*l') can read lines with embedded zeros.\n\n* Changes from version 3.2 to 4.0\n -------------------------------\n Language:\n + new \"break\" and \"for\" statements (both numerical and for tables).\n + uniform treatment of globals: globals are now stored in a Lua table.\n + improved error messages.\n + no more '$debug': full speed *and* full debug information.\n + new read form: read(N) for next N bytes.\n + general read patterns now deprecated.\n (still available with -DCOMPAT_READPATTERNS.)\n + all return values are passed as arguments for the last function\n (old semantics still available with -DLUA_COMPAT_ARGRET)\n + garbage collection tag methods for tables now deprecated.\n + there is now only one tag method for order.\n API:\n + New API: fully re-entrant, simpler, and more efficient.\n + New debug API.\n Implementation:\n + faster than ever: cleaner virtual machine and new hashing algorithm.\n + non-recursive garbage-collector algorithm.\n + reduced memory usage for programs with many strings.\n + improved treatment for memory allocation errors.\n + improved support for 16-bit machines (we hope).\n + code now compiles unmodified as both ANSI C and C++.\n + numbers in bases other than 10 are converted using strtoul.\n + new -f option in Lua to support #! scripts.\n + luac can now combine text and binaries.\n\n* Changes from version 3.1 to 3.2\n -------------------------------\n + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT.\n + increased limit on the number of constants and globals per function\n (from 2^16 to 2^24).\n + debugging info (lua_debug and hooks) moved into lua_state and new API\n functions provided to get and set this info.\n + new debug lib gives full debugging access within Lua.\n + new table functions \"foreachi\", \"sort\", \"tinsert\", \"tremove\", \"getn\".\n + new io functions \"flush\", \"seek\".\n\n* Changes from version 3.0 to 3.1\n -------------------------------\n + NEW FEATURE: anonymous functions with closures (via \"upvalues\").\n + new syntax:\n - local variables in chunks.\n - better scope control with DO block END.\n - constructors can now be also written: { record-part; list-part }.\n - more general syntax for function calls and lvalues, e.g.:\n f(x).y=1\n o:f(x,y):g(z)\n f\"string\" is sugar for f(\"string\")\n + strings may now contain arbitrary binary data (e.g., embedded zeros).\n + major code re-organization and clean-up; reduced module interdependecies.\n + no arbitrary limits on the total number of constants and globals.\n + support for multiple global contexts.\n + better syntax error messages.\n + new traversal functions \"foreach\" and \"foreachvar\".\n + the default for numbers is now double.\n changing it to use floats or longs is easy.\n + complete debug information stored in pre-compiled chunks.\n + sample interpreter now prompts user when run interactively, and also\n handles control-C interruptions gracefully.\n\n* Changes from version 2.5 to 3.0\n -------------------------------\n + NEW CONCEPT: \"tag methods\".\n Tag methods replace fallbacks as the meta-mechanism for extending the\n semantics of Lua. Whereas fallbacks had a global nature, tag methods\n work on objects having the same tag (e.g., groups of tables).\n Existing code that uses fallbacks should work without change.\n + new, general syntax for constructors {[exp] = exp, ... }.\n + support for handling variable number of arguments in functions (varargs).\n + support for conditional compilation ($if ... $else ... $end).\n + cleaner semantics in API simplifies host code.\n + better support for writing libraries (auxlib.h).\n + better type checking and error messages in the standard library.\n + luac can now also undump.\n\n* Changes from version 2.4 to 2.5\n -------------------------------\n + io and string libraries are now based on pattern matching;\n the old libraries are still available for compatibility\n + dofile and dostring can now return values (via return statement)\n + better support for 16- and 64-bit machines\n + expanded documentation, with more examples\n\n* Changes from version 2.2 to 2.4\n -------------------------------\n + external compiler creates portable binary files that can be loaded faster\n + interface for debugging and profiling\n + new \"getglobal\" fallback\n + new functions for handling references to Lua objects\n + new functions in standard lib\n + only one copy of each string is stored\n + expanded documentation, with more examples\n\n* Changes from version 2.1 to 2.2\n -------------------------------\n + functions now may be declared with any \"lvalue\" as a name\n + garbage collection of functions\n + support for pipes\n\n* Changes from version 1.1 to 2.1\n -------------------------------\n + object-oriented support\n + fallbacks\n + simplified syntax for tables\n + many internal improvements\n\n(end of HISTORY)\n" }, { "path": "deps/lua/INSTALL", "content": "INSTALL for Lua 5.1\n\n* Building Lua\n ------------\n Lua is built in the src directory, but the build process can be\n controlled from the top-level Makefile.\n\n Building Lua on Unix systems should be very easy. First do \"make\" and\n see if your platform is listed. If so, just do \"make xxx\", where xxx\n is your platform name. The platforms currently supported are:\n aix ansi bsd freebsd generic linux macosx mingw posix solaris\n\n If your platform is not listed, try the closest one or posix, generic,\n ansi, in this order.\n\n See below for customization instructions and for instructions on how\n to build with other Windows compilers.\n\n If you want to check that Lua has been built correctly, do \"make test\"\n after building Lua. Also, have a look at the example programs in test.\n\n* Installing Lua\n --------------\n Once you have built Lua, you may want to install it in an official\n place in your system. In this case, do \"make install\". The official\n place and the way to install files are defined in Makefile. You must\n have the right permissions to install files.\n\n If you want to build and install Lua in one step, do \"make xxx install\",\n where xxx is your platform name.\n\n If you want to install Lua locally, then do \"make local\". This will\n create directories bin, include, lib, man, and install Lua there as\n follows:\n\n bin:\tlua luac\n include:\tlua.h luaconf.h lualib.h lauxlib.h lua.hpp\n lib:\tliblua.a\n man/man1:\tlua.1 luac.1\n\n These are the only directories you need for development.\n\n There are man pages for lua and luac, in both nroff and html, and a\n reference manual in html in doc, some sample code in test, and some\n useful stuff in etc. You don't need these directories for development.\n\n If you want to install Lua locally, but in some other directory, do\n \"make install INSTALL_TOP=xxx\", where xxx is your chosen directory.\n\n See below for instructions for Windows and other systems.\n\n* Customization\n -------------\n Three things can be customized by editing a file:\n - Where and how to install Lua -- edit Makefile.\n - How to build Lua -- edit src/Makefile.\n - Lua features -- edit src/luaconf.h.\n\n You don't actually need to edit the Makefiles because you may set the\n relevant variables when invoking make.\n\n On the other hand, if you need to select some Lua features, you'll need\n to edit src/luaconf.h. The edited file will be the one installed, and\n it will be used by any Lua clients that you build, to ensure consistency.\n\n We strongly recommend that you enable dynamic loading. This is done\n automatically for all platforms listed above that have this feature\n (and also Windows). See src/luaconf.h and also src/Makefile.\n\n* Building Lua on Windows and other systems\n -----------------------------------------\n If you're not using the usual Unix tools, then the instructions for\n building Lua depend on the compiler you use. You'll need to create\n projects (or whatever your compiler uses) for building the library,\n the interpreter, and the compiler, as follows:\n\n library:\tlapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c\n\t\tlmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c\n\t\tltable.c ltm.c lundump.c lvm.c lzio.c\n\t\tlauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c\n\t\tltablib.c lstrlib.c loadlib.c linit.c\n\n interpreter:\tlibrary, lua.c\n\n compiler:\tlibrary, luac.c print.c\n\n If you use Visual Studio .NET, you can use etc/luavs.bat in its\n \"Command Prompt\".\n\n If all you want is to build the Lua interpreter, you may put all .c files\n in a single project, except for luac.c and print.c. Or just use etc/all.c.\n\n To use Lua as a library in your own programs, you'll need to know how to\n create and use libraries with your compiler.\n\n As mentioned above, you may edit luaconf.h to select some features before\n building Lua.\n\n(end of INSTALL)\n" }, { "path": "deps/lua/Makefile", "content": "# makefile for installing Lua\n# see INSTALL for installation instructions\n# see src/Makefile and src/luaconf.h for further customization\n\n# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================\n\n# Your platform. See PLATS for possible values.\nPLAT= none\n\n# Where to install. The installation starts in the src and doc directories,\n# so take care if INSTALL_TOP is not an absolute path.\nINSTALL_TOP= /usr/local\nINSTALL_BIN= $(INSTALL_TOP)/bin\nINSTALL_INC= $(INSTALL_TOP)/include\nINSTALL_LIB= $(INSTALL_TOP)/lib\nINSTALL_MAN= $(INSTALL_TOP)/man/man1\n#\n# You probably want to make INSTALL_LMOD and INSTALL_CMOD consistent with\n# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h (and also with etc/lua.pc).\nINSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V\nINSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V\n\n# How to install. If your install program does not support \"-p\", then you\n# may have to run ranlib on the installed liblua.a (do \"make ranlib\").\nINSTALL= install -p\nINSTALL_EXEC= $(INSTALL) -m 0755\nINSTALL_DATA= $(INSTALL) -m 0644\n#\n# If you don't have install you can use cp instead.\n# INSTALL= cp -p\n# INSTALL_EXEC= $(INSTALL)\n# INSTALL_DATA= $(INSTALL)\n\n# Utilities.\nMKDIR= mkdir -p\nRANLIB= ranlib\n\n# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========\n\n# Convenience platforms targets.\nPLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris\n\n# What to install.\nTO_BIN= lua luac\nTO_INC= lua.h luaconf.h lualib.h lauxlib.h ../etc/lua.hpp\nTO_LIB= liblua.a\nTO_MAN= lua.1 luac.1\n\n# Lua version and release.\nV= 5.1\nR= 5.1.5\n\nall:\t$(PLAT)\n\n$(PLATS) clean:\n\tcd src && $(MAKE) $@\n\ntest:\tdummy\n\tsrc/lua test/hello.lua\n\ninstall: dummy\n\tcd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)\n\tcd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)\n\tcd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)\n\tcd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)\n\tcd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)\n\nranlib:\n\tcd src && cd $(INSTALL_LIB) && $(RANLIB) $(TO_LIB)\n\nlocal:\n\t$(MAKE) install INSTALL_TOP=..\n\nnone:\n\t@echo \"Please do\"\n\t@echo \" make PLATFORM\"\n\t@echo \"where PLATFORM is one of these:\"\n\t@echo \" $(PLATS)\"\n\t@echo \"See INSTALL for complete instructions.\"\n\n# make may get confused with test/ and INSTALL in a case-insensitive OS\ndummy:\n\n# echo config parameters\necho:\n\t@echo \"\"\n\t@echo \"These are the parameters currently set in src/Makefile to build Lua $R:\"\n\t@echo \"\"\n\t@cd src && $(MAKE) -s echo\n\t@echo \"\"\n\t@echo \"These are the parameters currently set in Makefile to install Lua $R:\"\n\t@echo \"\"\n\t@echo \"PLAT = $(PLAT)\"\n\t@echo \"INSTALL_TOP = $(INSTALL_TOP)\"\n\t@echo \"INSTALL_BIN = $(INSTALL_BIN)\"\n\t@echo \"INSTALL_INC = $(INSTALL_INC)\"\n\t@echo \"INSTALL_LIB = $(INSTALL_LIB)\"\n\t@echo \"INSTALL_MAN = $(INSTALL_MAN)\"\n\t@echo \"INSTALL_LMOD = $(INSTALL_LMOD)\"\n\t@echo \"INSTALL_CMOD = $(INSTALL_CMOD)\"\n\t@echo \"INSTALL_EXEC = $(INSTALL_EXEC)\"\n\t@echo \"INSTALL_DATA = $(INSTALL_DATA)\"\n\t@echo \"\"\n\t@echo \"See also src/luaconf.h .\"\n\t@echo \"\"\n\n# echo private config parameters\npecho:\n\t@echo \"V = $(V)\"\n\t@echo \"R = $(R)\"\n\t@echo \"TO_BIN = $(TO_BIN)\"\n\t@echo \"TO_INC = $(TO_INC)\"\n\t@echo \"TO_LIB = $(TO_LIB)\"\n\t@echo \"TO_MAN = $(TO_MAN)\"\n\n# echo config parameters as Lua code\n# uncomment the last sed expression if you want nil instead of empty strings\nlecho:\n\t@echo \"-- installation parameters for Lua $R\"\n\t@echo \"VERSION = '$V'\"\n\t@echo \"RELEASE = '$R'\"\n\t@$(MAKE) echo | grep = | sed -e 's/= /= \"/' -e 's/$$/\"/' #-e 's/\"\"/nil/'\n\t@echo \"-- EOF\"\n\n# list targets that do not create files (but not all makes understand .PHONY)\n.PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho\n\n# (end of Makefile)\n" }, { "path": "deps/lua/README", "content": "README for Lua 5.1\n\nSee INSTALL for installation instructions.\nSee HISTORY for a summary of changes since the last released version.\n\n* What is Lua?\n ------------\n Lua is a powerful, light-weight programming language designed for extending\n applications. Lua is also frequently used as a general-purpose, stand-alone\n language. Lua is free software.\n\n For complete information, visit Lua's web site at http://www.lua.org/ .\n For an executive summary, see http://www.lua.org/about.html .\n\n Lua has been used in many different projects around the world.\n For a short list, see http://www.lua.org/uses.html .\n\n* Availability\n ------------\n Lua is freely available for both academic and commercial purposes.\n See COPYRIGHT and http://www.lua.org/license.html for details.\n Lua can be downloaded at http://www.lua.org/download.html .\n\n* Installation\n ------------\n Lua is implemented in pure ANSI C, and compiles unmodified in all known\n platforms that have an ANSI C compiler. In most Unix-like platforms, simply\n do \"make\" with a suitable target. See INSTALL for detailed instructions.\n\n* Origin\n ------\n Lua is developed at Lua.org, a laboratory of the Department of Computer\n Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro\n in Brazil).\n For more information about the authors, see http://www.lua.org/authors.html .\n\n(end of README)\n" }, { "path": "deps/lua/doc/contents.html", "content": "\n\n\nLua 5.1 Reference Manual - contents\n\n\n\n\n\n\n\n
\n

\n\"\"\nLua 5.1 Reference Manual\n

\n\n

\nThe reference manual is the official definition of the Lua language.\nFor a complete introduction to Lua programming, see the book\nProgramming in Lua.\n\n

\nThis manual is also available as a book:\n

\n\n\"\"\n\nLua 5.1 Reference Manual\n
by R. Ierusalimschy, L. H. de Figueiredo, W. Celes\n
Lua.org, August 2006\n
ISBN 85-903798-3-3\n
\n
\n\n

\nBuy a copy\nof this book and\nhelp to support\nthe Lua project.\n\n

\nstart\n·\ncontents\n·\nindex\n·\nother versions\n

\n\nCopyright © 2006–2012 Lua.org, PUC-Rio.\nFreely available under the terms of the\nLua license.\n\n\n

Contents

\n\n\n

Index

\n\n\n\n\n\n\n\n
\n

Lua functions

\n_G
\n_VERSION
\n

\n\nassert
\ncollectgarbage
\ndofile
\nerror
\ngetfenv
\ngetmetatable
\nipairs
\nload
\nloadfile
\nloadstring
\nmodule
\nnext
\npairs
\npcall
\nprint
\nrawequal
\nrawget
\nrawset
\nrequire
\nselect
\nsetfenv
\nsetmetatable
\ntonumber
\ntostring
\ntype
\nunpack
\nxpcall
\n

\n\ncoroutine.create
\ncoroutine.resume
\ncoroutine.running
\ncoroutine.status
\ncoroutine.wrap
\ncoroutine.yield
\n

\n\ndebug.debug
\ndebug.getfenv
\ndebug.gethook
\ndebug.getinfo
\ndebug.getlocal
\ndebug.getmetatable
\ndebug.getregistry
\ndebug.getupvalue
\ndebug.setfenv
\ndebug.sethook
\ndebug.setlocal
\ndebug.setmetatable
\ndebug.setupvalue
\ndebug.traceback
\n\n

\n

 

\nfile:close
\nfile:flush
\nfile:lines
\nfile:read
\nfile:seek
\nfile:setvbuf
\nfile:write
\n

\n\nio.close
\nio.flush
\nio.input
\nio.lines
\nio.open
\nio.output
\nio.popen
\nio.read
\nio.stderr
\nio.stdin
\nio.stdout
\nio.tmpfile
\nio.type
\nio.write
\n

\n\nmath.abs
\nmath.acos
\nmath.asin
\nmath.atan
\nmath.atan2
\nmath.ceil
\nmath.cos
\nmath.cosh
\nmath.deg
\nmath.exp
\nmath.floor
\nmath.fmod
\nmath.frexp
\nmath.huge
\nmath.ldexp
\nmath.log
\nmath.log10
\nmath.max
\nmath.min
\nmath.modf
\nmath.pi
\nmath.pow
\nmath.rad
\nmath.random
\nmath.randomseed
\nmath.sin
\nmath.sinh
\nmath.sqrt
\nmath.tan
\nmath.tanh
\n

\n\nos.clock
\nos.date
\nos.difftime
\nos.execute
\nos.exit
\nos.getenv
\nos.remove
\nos.rename
\nos.setlocale
\nos.time
\nos.tmpname
\n

\n\npackage.cpath
\npackage.loaded
\npackage.loaders
\npackage.loadlib
\npackage.path
\npackage.preload
\npackage.seeall
\n

\n\nstring.byte
\nstring.char
\nstring.dump
\nstring.find
\nstring.format
\nstring.gmatch
\nstring.gsub
\nstring.len
\nstring.lower
\nstring.match
\nstring.rep
\nstring.reverse
\nstring.sub
\nstring.upper
\n

\n\ntable.concat
\ntable.insert
\ntable.maxn
\ntable.remove
\ntable.sort
\n\n

\n

C API

\nlua_Alloc
\nlua_CFunction
\nlua_Debug
\nlua_Hook
\nlua_Integer
\nlua_Number
\nlua_Reader
\nlua_State
\nlua_Writer
\n

\n\nlua_atpanic
\nlua_call
\nlua_checkstack
\nlua_close
\nlua_concat
\nlua_cpcall
\nlua_createtable
\nlua_dump
\nlua_equal
\nlua_error
\nlua_gc
\nlua_getallocf
\nlua_getfenv
\nlua_getfield
\nlua_getglobal
\nlua_gethook
\nlua_gethookcount
\nlua_gethookmask
\nlua_getinfo
\nlua_getlocal
\nlua_getmetatable
\nlua_getstack
\nlua_gettable
\nlua_gettop
\nlua_getupvalue
\nlua_insert
\nlua_isboolean
\nlua_iscfunction
\nlua_isfunction
\nlua_islightuserdata
\nlua_isnil
\nlua_isnone
\nlua_isnoneornil
\nlua_isnumber
\nlua_isstring
\nlua_istable
\nlua_isthread
\nlua_isuserdata
\nlua_lessthan
\nlua_load
\nlua_newstate
\nlua_newtable
\nlua_newthread
\nlua_newuserdata
\nlua_next
\nlua_objlen
\nlua_pcall
\nlua_pop
\nlua_pushboolean
\nlua_pushcclosure
\nlua_pushcfunction
\nlua_pushfstring
\nlua_pushinteger
\nlua_pushlightuserdata
\nlua_pushliteral
\nlua_pushlstring
\nlua_pushnil
\nlua_pushnumber
\nlua_pushstring
\nlua_pushthread
\nlua_pushvalue
\nlua_pushvfstring
\nlua_rawequal
\nlua_rawget
\nlua_rawgeti
\nlua_rawset
\nlua_rawseti
\nlua_register
\nlua_remove
\nlua_replace
\nlua_resume
\nlua_setallocf
\nlua_setfenv
\nlua_setfield
\nlua_setglobal
\nlua_sethook
\nlua_setlocal
\nlua_setmetatable
\nlua_settable
\nlua_settop
\nlua_setupvalue
\nlua_status
\nlua_toboolean
\nlua_tocfunction
\nlua_tointeger
\nlua_tolstring
\nlua_tonumber
\nlua_topointer
\nlua_tostring
\nlua_tothread
\nlua_touserdata
\nlua_type
\nlua_typename
\nlua_upvalueindex
\nlua_xmove
\nlua_yield
\n\n

\n

auxiliary library

\nluaL_Buffer
\nluaL_Reg
\n

\n\nluaL_addchar
\nluaL_addlstring
\nluaL_addsize
\nluaL_addstring
\nluaL_addvalue
\nluaL_argcheck
\nluaL_argerror
\nluaL_buffinit
\nluaL_callmeta
\nluaL_checkany
\nluaL_checkint
\nluaL_checkinteger
\nluaL_checklong
\nluaL_checklstring
\nluaL_checknumber
\nluaL_checkoption
\nluaL_checkstack
\nluaL_checkstring
\nluaL_checktype
\nluaL_checkudata
\nluaL_dofile
\nluaL_dostring
\nluaL_error
\nluaL_getmetafield
\nluaL_getmetatable
\nluaL_gsub
\nluaL_loadbuffer
\nluaL_loadfile
\nluaL_loadstring
\nluaL_newmetatable
\nluaL_newstate
\nluaL_openlibs
\nluaL_optint
\nluaL_optinteger
\nluaL_optlong
\nluaL_optlstring
\nluaL_optnumber
\nluaL_optstring
\nluaL_prepbuffer
\nluaL_pushresult
\nluaL_ref
\nluaL_register
\nluaL_typename
\nluaL_typerror
\nluaL_unref
\nluaL_where
\n\n

\n

\n\n

\n\nLast update:\nMon Feb 13 18:53:32 BRST 2012\n\n\n\n\n\n" }, { "path": "deps/lua/doc/lua.1", "content": ".\\\" $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $\n.TH LUA 1 \"$Date: 2006/01/06 16:03:34 $\"\n.SH NAME\nlua \\- Lua interpreter\n.SH SYNOPSIS\n.B lua\n[\n.I options\n]\n[\n.I script\n[\n.I args\n]\n]\n.SH DESCRIPTION\n.B lua\nis the stand-alone Lua interpreter.\nIt loads and executes Lua programs,\neither in textual source form or\nin precompiled binary form.\n(Precompiled binaries are output by\n.BR luac ,\nthe Lua compiler.)\n.B lua\ncan be used as a batch interpreter and also interactively.\n.LP\nThe given\n.I options\n(see below)\nare executed and then\nthe Lua program in file\n.I script\nis loaded and executed.\nThe given\n.I args\nare available to\n.I script\nas strings in a global table named\n.BR arg .\nIf these arguments contain spaces or other characters special to the shell,\nthen they should be quoted\n(but note that the quotes will be removed by the shell).\nThe arguments in\n.B arg\nstart at 0,\nwhich contains the string\n.RI ' script '.\nThe index of the last argument is stored in\n.BR arg.n .\nThe arguments given in the command line before\n.IR script ,\nincluding the name of the interpreter,\nare available in negative indices in\n.BR arg .\n.LP\nAt the very start,\nbefore even handling the command line,\n.B lua\nexecutes the contents of the environment variable\n.BR LUA_INIT ,\nif it is defined.\nIf the value of\n.B LUA_INIT\nis of the form\n.RI '@ filename ',\nthen\n.I filename\nis executed.\nOtherwise, the string is assumed to be a Lua statement and is executed.\n.LP\nOptions start with\n.B '\\-'\nand are described below.\nYou can use\n.B \"'\\--'\"\nto signal the end of options.\n.LP\nIf no arguments are given,\nthen\n.B \"\\-v \\-i\"\nis assumed when the standard input is a terminal;\notherwise,\n.B \"\\-\"\nis assumed.\n.LP\nIn interactive mode,\n.B lua\nprompts the user,\nreads lines from the standard input,\nand executes them as they are read.\nIf a line does not contain a complete statement,\nthen a secondary prompt is displayed and\nlines are read until a complete statement is formed or\na syntax error is found.\nSo, one way to interrupt the reading of an incomplete statement is\nto force a syntax error:\nadding a\n.B ';' \nin the middle of a statement is a sure way of forcing a syntax error\n(except inside multiline strings and comments; these must be closed explicitly).\nIf a line starts with\n.BR '=' ,\nthen\n.B lua\ndisplays the values of all the expressions in the remainder of the\nline. The expressions must be separated by commas.\nThe primary prompt is the value of the global variable\n.BR _PROMPT ,\nif this value is a string;\notherwise, the default prompt is used.\nSimilarly, the secondary prompt is the value of the global variable\n.BR _PROMPT2 .\nSo,\nto change the prompts,\nset the corresponding variable to a string of your choice.\nYou can do that after calling the interpreter\nor on the command line\n(but in this case you have to be careful with quotes\nif the prompt string contains a space; otherwise you may confuse the shell.)\nThe default prompts are \"> \" and \">> \".\n.SH OPTIONS\n.TP\n.B \\-\nload and execute the standard input as a file,\nthat is,\nnot interactively,\neven when the standard input is a terminal.\n.TP\n.BI \\-e \" stat\"\nexecute statement\n.IR stat .\nYou need to quote\n.I stat \nif it contains spaces, quotes,\nor other characters special to the shell.\n.TP\n.B \\-i\nenter interactive mode after\n.I script\nis executed.\n.TP\n.BI \\-l \" name\"\ncall\n.BI require(' name ')\nbefore executing\n.IR script .\nTypically used to load libraries.\n.TP\n.B \\-v\nshow version information.\n.SH \"SEE ALSO\"\n.BR luac (1)\n.br\nhttp://www.lua.org/\n.SH DIAGNOSTICS\nError messages should be self explanatory.\n.SH AUTHORS\nR. Ierusalimschy,\nL. H. de Figueiredo,\nand\nW. Celes\n.\\\" EOF\n" }, { "path": "deps/lua/doc/lua.css", "content": "body {\n\tcolor: #000000 ;\n\tbackground-color: #FFFFFF ;\n\tfont-family: Helvetica, Arial, sans-serif ;\n\ttext-align: justify ;\n\tmargin-right: 30px ;\n\tmargin-left: 30px ;\n}\n\nh1, h2, h3, h4 {\n\tfont-family: Verdana, Geneva, sans-serif ;\n\tfont-weight: normal ;\n\tfont-style: italic ;\n}\n\nh2 {\n\tpadding-top: 0.4em ;\n\tpadding-bottom: 0.4em ;\n\tpadding-left: 30px ;\n\tpadding-right: 30px ;\n\tmargin-left: -30px ;\n\tbackground-color: #E0E0FF ;\n}\n\nh3 {\n\tpadding-left: 0.5em ;\n\tborder-left: solid #E0E0FF 1em ;\n}\n\ntable h3 {\n\tpadding-left: 0px ;\n\tborder-left: none ;\n}\n\na:link {\n\tcolor: #000080 ;\n\tbackground-color: inherit ;\n\ttext-decoration: none ;\n}\n\na:visited {\n\tbackground-color: inherit ;\n\ttext-decoration: none ;\n}\n\na:link:hover, a:visited:hover {\n\tcolor: #000080 ;\n\tbackground-color: #E0E0FF ;\n}\n\na:link:active, a:visited:active {\n\tcolor: #FF0000 ;\n}\n\nhr {\n\tborder: 0 ;\n\theight: 1px ;\n\tcolor: #a0a0a0 ;\n\tbackground-color: #a0a0a0 ;\n}\n\n:target {\n\tbackground-color: #F8F8F8 ;\n\tpadding: 8px ;\n\tborder: solid #a0a0a0 2px ;\n}\n\n.footer {\n\tcolor: gray ;\n\tfont-size: small ;\n}\n\ninput[type=text] {\n\tborder: solid #a0a0a0 2px ;\n\tborder-radius: 2em ;\n\t-moz-border-radius: 2em ;\n\tbackground-image: url('images/search.png') ;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 4px center ;\n\tpadding-left: 20px ;\n\theight: 2em ;\n}\n\n" }, { "path": "deps/lua/doc/lua.html", "content": "\n\n\nLUA man page\n\n\n\n\n\n

NAME

\nlua - Lua interpreter\n

SYNOPSIS

\nlua\n[\noptions\n]\n[\nscript\n[\nargs\n]\n]\n

DESCRIPTION

\nlua\nis the stand-alone Lua interpreter.\nIt loads and executes Lua programs,\neither in textual source form or\nin precompiled binary form.\n(Precompiled binaries are output by\nluac,\nthe Lua compiler.)\nlua\ncan be used as a batch interpreter and also interactively.\n

\nThe given\noptions\n(see below)\nare executed and then\nthe Lua program in file\nscript\nis loaded and executed.\nThe given\nargs\nare available to\nscript\nas strings in a global table named\narg.\nIf these arguments contain spaces or other characters special to the shell,\nthen they should be quoted\n(but note that the quotes will be removed by the shell).\nThe arguments in\narg\nstart at 0,\nwhich contains the string\n'script'.\nThe index of the last argument is stored in\narg.n.\nThe arguments given in the command line before\nscript,\nincluding the name of the interpreter,\nare available in negative indices in\narg.\n

\nAt the very start,\nbefore even handling the command line,\nlua\nexecutes the contents of the environment variable\nLUA_INIT,\nif it is defined.\nIf the value of\nLUA_INIT\nis of the form\n'@filename',\nthen\nfilename\nis executed.\nOtherwise, the string is assumed to be a Lua statement and is executed.\n

\nOptions start with\n'-'\nand are described below.\nYou can use\n'--'\nto signal the end of options.\n

\nIf no arguments are given,\nthen\n\"-v -i\"\nis assumed when the standard input is a terminal;\notherwise,\n\"-\"\nis assumed.\n

\nIn interactive mode,\nlua\nprompts the user,\nreads lines from the standard input,\nand executes them as they are read.\nIf a line does not contain a complete statement,\nthen a secondary prompt is displayed and\nlines are read until a complete statement is formed or\na syntax error is found.\nSo, one way to interrupt the reading of an incomplete statement is\nto force a syntax error:\nadding a\n';'\nin the middle of a statement is a sure way of forcing a syntax error\n(except inside multiline strings and comments; these must be closed explicitly).\nIf a line starts with\n'=',\nthen\nlua\ndisplays the values of all the expressions in the remainder of the\nline. The expressions must be separated by commas.\nThe primary prompt is the value of the global variable\n_PROMPT,\nif this value is a string;\notherwise, the default prompt is used.\nSimilarly, the secondary prompt is the value of the global variable\n_PROMPT2.\nSo,\nto change the prompts,\nset the corresponding variable to a string of your choice.\nYou can do that after calling the interpreter\nor on the command line\n(but in this case you have to be careful with quotes\nif the prompt string contains a space; otherwise you may confuse the shell.)\nThe default prompts are \"> \" and \">> \".\n

OPTIONS

\n

\n-\nload and execute the standard input as a file,\nthat is,\nnot interactively,\neven when the standard input is a terminal.\n

\n-e stat\nexecute statement\nstat.\nYou need to quote\nstat \nif it contains spaces, quotes,\nor other characters special to the shell.\n

\n-i\nenter interactive mode after\nscript\nis executed.\n

\n-l name\ncall\nrequire('name')\nbefore executing\nscript.\nTypically used to load libraries.\n

\n-v\nshow version information.\n

SEE ALSO

\nluac(1)\n
\nhttp://www.lua.org/\n

DIAGNOSTICS

\nError messages should be self explanatory.\n

AUTHORS

\nR. Ierusalimschy,\nL. H. de Figueiredo,\nand\nW. Celes\n\n\n\n" }, { "path": "deps/lua/doc/luac.1", "content": ".\\\" $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $\n.TH LUAC 1 \"$Date: 2006/01/06 16:03:34 $\"\n.SH NAME\nluac \\- Lua compiler\n.SH SYNOPSIS\n.B luac\n[\n.I options\n] [\n.I filenames\n]\n.SH DESCRIPTION\n.B luac\nis the Lua compiler.\nIt translates programs written in the Lua programming language\ninto binary files that can be later loaded and executed.\n.LP\nThe main advantages of precompiling chunks are:\nfaster loading,\nprotecting source code from accidental user changes,\nand\noff-line syntax checking.\n.LP\nPre-compiling does not imply faster execution\nbecause in Lua chunks are always compiled into bytecodes before being executed.\n.B luac\nsimply allows those bytecodes to be saved in a file for later execution.\n.LP\nPre-compiled chunks are not necessarily smaller than the corresponding source.\nThe main goal in pre-compiling is faster loading.\n.LP\nThe binary files created by\n.B luac\nare portable only among architectures with the same word size and byte order.\n.LP\n.B luac\nproduces a single output file containing the bytecodes\nfor all source files given.\nBy default,\nthe output file is named\n.BR luac.out ,\nbut you can change this with the\n.B \\-o\noption.\n.LP\nIn the command line,\nyou can mix\ntext files containing Lua source and\nbinary files containing precompiled chunks.\nThis is useful to combine several precompiled chunks,\neven from different (but compatible) platforms,\ninto a single precompiled chunk.\n.LP\nYou can use\n.B \"'\\-'\"\nto indicate the standard input as a source file\nand\n.B \"'\\--'\"\nto signal the end of options\n(that is,\nall remaining arguments will be treated as files even if they start with\n.BR \"'\\-'\" ).\n.LP\nThe internal format of the binary files produced by\n.B luac\nis likely to change when a new version of Lua is released.\nSo,\nsave the source files of all Lua programs that you precompile.\n.LP\n.SH OPTIONS\nOptions must be separate.\n.TP\n.B \\-l\nproduce a listing of the compiled bytecode for Lua's virtual machine.\nListing bytecodes is useful to learn about Lua's virtual machine.\nIf no files are given, then\n.B luac\nloads\n.B luac.out\nand lists its contents.\n.TP\n.BI \\-o \" file\"\noutput to\n.IR file ,\ninstead of the default\n.BR luac.out .\n(You can use\n.B \"'\\-'\"\nfor standard output,\nbut not on platforms that open standard output in text mode.)\nThe output file may be a source file because\nall files are loaded before the output file is written.\nBe careful not to overwrite precious files.\n.TP\n.B \\-p\nload files but do not generate any output file.\nUsed mainly for syntax checking and for testing precompiled chunks:\ncorrupted files will probably generate errors when loaded.\nLua always performs a thorough integrity test on precompiled chunks.\nBytecode that passes this test is completely safe,\nin the sense that it will not break the interpreter.\nHowever,\nthere is no guarantee that such code does anything sensible.\n(None can be given, because the halting problem is unsolvable.)\nIf no files are given, then\n.B luac\nloads\n.B luac.out\nand tests its contents.\nNo messages are displayed if the file passes the integrity test.\n.TP\n.B \\-s\nstrip debug information before writing the output file.\nThis saves some space in very large chunks,\nbut if errors occur when running a stripped chunk,\nthen the error messages may not contain the full information they usually do.\nFor instance,\nline numbers and names of local variables are lost.\n.TP\n.B \\-v\nshow version information.\n.SH FILES\n.TP 15\n.B luac.out\ndefault output file\n.SH \"SEE ALSO\"\n.BR lua (1)\n.br\nhttp://www.lua.org/\n.SH DIAGNOSTICS\nError messages should be self explanatory.\n.SH AUTHORS\nL. H. de Figueiredo,\nR. Ierusalimschy and\nW. Celes\n.\\\" EOF\n" }, { "path": "deps/lua/doc/luac.html", "content": "\n\n\nLUAC man page\n\n\n\n\n\n

NAME

\nluac - Lua compiler\n

SYNOPSIS

\nluac\n[\noptions\n] [\nfilenames\n]\n

DESCRIPTION

\nluac\nis the Lua compiler.\nIt translates programs written in the Lua programming language\ninto binary files that can be later loaded and executed.\n

\nThe main advantages of precompiling chunks are:\nfaster loading,\nprotecting source code from accidental user changes,\nand\noff-line syntax checking.\n

\nPrecompiling does not imply faster execution\nbecause in Lua chunks are always compiled into bytecodes before being executed.\nluac\nsimply allows those bytecodes to be saved in a file for later execution.\n

\nPrecompiled chunks are not necessarily smaller than the corresponding source.\nThe main goal in precompiling is faster loading.\n

\nThe binary files created by\nluac\nare portable only among architectures with the same word size and byte order.\n

\nluac\nproduces a single output file containing the bytecodes\nfor all source files given.\nBy default,\nthe output file is named\nluac.out,\nbut you can change this with the\n-o\noption.\n

\nIn the command line,\nyou can mix\ntext files containing Lua source and\nbinary files containing precompiled chunks.\nThis is useful because several precompiled chunks,\neven from different (but compatible) platforms,\ncan be combined into a single precompiled chunk.\n

\nYou can use\n'-'\nto indicate the standard input as a source file\nand\n'--'\nto signal the end of options\n(that is,\nall remaining arguments will be treated as files even if they start with\n'-').\n

\nThe internal format of the binary files produced by\nluac\nis likely to change when a new version of Lua is released.\nSo,\nsave the source files of all Lua programs that you precompile.\n

\n

OPTIONS

\nOptions must be separate.\n

\n-l\nproduce a listing of the compiled bytecode for Lua's virtual machine.\nListing bytecodes is useful to learn about Lua's virtual machine.\nIf no files are given, then\nluac\nloads\nluac.out\nand lists its contents.\n

\n-o file\noutput to\nfile,\ninstead of the default\nluac.out.\n(You can use\n'-'\nfor standard output,\nbut not on platforms that open standard output in text mode.)\nThe output file may be a source file because\nall files are loaded before the output file is written.\nBe careful not to overwrite precious files.\n

\n-p\nload files but do not generate any output file.\nUsed mainly for syntax checking and for testing precompiled chunks:\ncorrupted files will probably generate errors when loaded.\nLua always performs a thorough integrity test on precompiled chunks.\nBytecode that passes this test is completely safe,\nin the sense that it will not break the interpreter.\nHowever,\nthere is no guarantee that such code does anything sensible.\n(None can be given, because the halting problem is unsolvable.)\nIf no files are given, then\nluac\nloads\nluac.out\nand tests its contents.\nNo messages are displayed if the file passes the integrity test.\n

\n-s\nstrip debug information before writing the output file.\nThis saves some space in very large chunks,\nbut if errors occur when running a stripped chunk,\nthen the error messages may not contain the full information they usually do.\nFor instance,\nline numbers and names of local variables are lost.\n

\n-v\nshow version information.\n

FILES

\n

\nluac.out\ndefault output file\n

SEE ALSO

\nlua(1)\n
\nhttp://www.lua.org/\n

DIAGNOSTICS

\nError messages should be self explanatory.\n

AUTHORS

\nL. H. de Figueiredo,\nR. Ierusalimschy and\nW. Celes\n\n\n\n" }, { "path": "deps/lua/doc/manual.css", "content": "h3 code {\n\tfont-family: inherit ;\n\tfont-size: inherit ;\n}\n\npre, code {\n\tfont-size: 12pt ;\n}\n\nspan.apii {\n\tfloat: right ;\n\tfont-family: inherit ;\n\tfont-style: normal ;\n\tfont-size: small ;\n\tcolor: gray ;\n}\n\np+h1, ul+h1 {\n\tpadding-top: 0.4em ;\n\tpadding-bottom: 0.4em ;\n\tpadding-left: 30px ;\n\tmargin-left: -30px ;\n\tbackground-color: #E0E0FF ;\n}\n" }, { "path": "deps/lua/doc/manual.html", "content": "\n\n\n\nLua 5.1 Reference Manual\n\n\n\n\n\n\n\n
\n

\n\"\"\nLua 5.1 Reference Manual\n

\n\nby Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes\n

\n\nCopyright © 2006–2012 Lua.org, PUC-Rio.\nFreely available under the terms of the\nLua license.\n\n

\n

\n\ncontents\n·\nindex\n·\nother versions\n\n\n

\n\n\n\n\n\n\n

1 - Introduction

\n\n

\nLua is an extension programming language designed to support\ngeneral procedural programming with data description\nfacilities.\nIt also offers good support for object-oriented programming,\nfunctional programming, and data-driven programming.\nLua is intended to be used as a powerful, light-weight\nscripting language for any program that needs one.\nLua is implemented as a library, written in clean C\n(that is, in the common subset of ANSI C and C++).\n\n\n

\nBeing an extension language, Lua has no notion of a \"main\" program:\nit only works embedded in a host client,\ncalled the embedding program or simply the host.\nThis host program can invoke functions to execute a piece of Lua code,\ncan write and read Lua variables,\nand can register C functions to be called by Lua code.\nThrough the use of C functions, Lua can be augmented to cope with\na wide range of different domains,\nthus creating customized programming languages sharing a syntactical framework.\nThe Lua distribution includes a sample host program called lua,\nwhich uses the Lua library to offer a complete, stand-alone Lua interpreter.\n\n\n

\nLua is free software,\nand is provided as usual with no guarantees,\nas stated in its license.\nThe implementation described in this manual is available\nat Lua's official web site, www.lua.org.\n\n\n

\nLike any other reference manual,\nthis document is dry in places.\nFor a discussion of the decisions behind the design of Lua,\nsee the technical papers available at Lua's web site.\nFor a detailed introduction to programming in Lua,\nsee Roberto's book, Programming in Lua (Second Edition).\n\n\n\n

2 - The Language

\n\n

\nThis section describes the lexis, the syntax, and the semantics of Lua.\nIn other words,\nthis section describes\nwhich tokens are valid,\nhow they can be combined,\nand what their combinations mean.\n\n\n

\nThe language constructs will be explained using the usual extended BNF notation,\nin which\n{a} means 0 or more a's, and\n[a] means an optional a.\nNon-terminals are shown like non-terminal,\nkeywords are shown like kword,\nand other terminal symbols are shown like `=´.\nThe complete syntax of Lua can be found in §8\nat the end of this manual.\n\n\n\n

2.1 - Lexical Conventions

\n\n

\nNames\n(also called identifiers)\nin Lua can be any string of letters,\ndigits, and underscores,\nnot beginning with a digit.\nThis coincides with the definition of names in most languages.\n(The definition of letter depends on the current locale:\nany character considered alphabetic by the current locale\ncan be used in an identifier.)\nIdentifiers are used to name variables and table fields.\n\n\n

\nThe following keywords are reserved\nand cannot be used as names:\n\n\n

\n     and       break     do        else      elseif\n     end       false     for       function  if\n     in        local     nil       not       or\n     repeat    return    then      true      until     while\n
\n\n

\nLua is a case-sensitive language:\nand is a reserved word, but And and AND\nare two different, valid names.\nAs a convention, names starting with an underscore followed by\nuppercase letters (such as _VERSION)\nare reserved for internal global variables used by Lua.\n\n\n

\nThe following strings denote other tokens:\n\n

\n     +     -     *     /     %     ^     #\n     ==    ~=    <=    >=    <     >     =\n     (     )     {     }     [     ]\n     ;     :     ,     .     ..    ...\n
\n\n

\nLiteral strings\ncan be delimited by matching single or double quotes,\nand can contain the following C-like escape sequences:\n'\\a' (bell),\n'\\b' (backspace),\n'\\f' (form feed),\n'\\n' (newline),\n'\\r' (carriage return),\n'\\t' (horizontal tab),\n'\\v' (vertical tab),\n'\\\\' (backslash),\n'\\\"' (quotation mark [double quote]),\nand '\\'' (apostrophe [single quote]).\nMoreover, a backslash followed by a real newline\nresults in a newline in the string.\nA character in a string can also be specified by its numerical value\nusing the escape sequence \\ddd,\nwhere ddd is a sequence of up to three decimal digits.\n(Note that if a numerical escape is to be followed by a digit,\nit must be expressed using exactly three digits.)\nStrings in Lua can contain any 8-bit value, including embedded zeros,\nwhich can be specified as '\\0'.\n\n\n

\nLiteral strings can also be defined using a long format\nenclosed by long brackets.\nWe define an opening long bracket of level n as an opening\nsquare bracket followed by n equal signs followed by another\nopening square bracket.\nSo, an opening long bracket of level 0 is written as [[,\nan opening long bracket of level 1 is written as [=[,\nand so on.\nA closing long bracket is defined similarly;\nfor instance, a closing long bracket of level 4 is written as ]====].\nA long string starts with an opening long bracket of any level and\nends at the first closing long bracket of the same level.\nLiterals in this bracketed form can run for several lines,\ndo not interpret any escape sequences,\nand ignore long brackets of any other level.\nThey can contain anything except a closing bracket of the proper level.\n\n\n

\nFor convenience,\nwhen the opening long bracket is immediately followed by a newline,\nthe newline is not included in the string.\nAs an example, in a system using ASCII\n(in which 'a' is coded as 97,\nnewline is coded as 10, and '1' is coded as 49),\nthe five literal strings below denote the same string:\n\n

\n     a = 'alo\\n123\"'\n     a = \"alo\\n123\\\"\"\n     a = '\\97lo\\10\\04923\"'\n     a = [[alo\n     123\"]]\n     a = [==[\n     alo\n     123\"]==]\n
\n\n

\nA numerical constant can be written with an optional decimal part\nand an optional decimal exponent.\nLua also accepts integer hexadecimal constants,\nby prefixing them with 0x.\nExamples of valid numerical constants are\n\n

\n     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56\n
\n\n

\nA comment starts with a double hyphen (--)\nanywhere outside a string.\nIf the text immediately after -- is not an opening long bracket,\nthe comment is a short comment,\nwhich runs until the end of the line.\nOtherwise, it is a long comment,\nwhich runs until the corresponding closing long bracket.\nLong comments are frequently used to disable code temporarily.\n\n\n\n\n\n

2.2 - Values and Types

\n\n

\nLua is a dynamically typed language.\nThis means that\nvariables do not have types; only values do.\nThere are no type definitions in the language.\nAll values carry their own type.\n\n\n

\nAll values in Lua are first-class values.\nThis means that all values can be stored in variables,\npassed as arguments to other functions, and returned as results.\n\n\n

\nThere are eight basic types in Lua:\nnil, boolean, number,\nstring, function, userdata,\nthread, and table.\nNil is the type of the value nil,\nwhose main property is to be different from any other value;\nit usually represents the absence of a useful value.\nBoolean is the type of the values false and true.\nBoth nil and false make a condition false;\nany other value makes it true.\nNumber represents real (double-precision floating-point) numbers.\n(It is easy to build Lua interpreters that use other\ninternal representations for numbers,\nsuch as single-precision float or long integers;\nsee file luaconf.h.)\nString represents arrays of characters.\n\nLua is 8-bit clean:\nstrings can contain any 8-bit character,\nincluding embedded zeros ('\\0') (see §2.1).\n\n\n

\nLua can call (and manipulate) functions written in Lua and\nfunctions written in C\n(see §2.5.8).\n\n\n

\nThe type userdata is provided to allow arbitrary C data to\nbe stored in Lua variables.\nThis type corresponds to a block of raw memory\nand has no pre-defined operations in Lua,\nexcept assignment and identity test.\nHowever, by using metatables,\nthe programmer can define operations for userdata values\n(see §2.8).\nUserdata values cannot be created or modified in Lua,\nonly through the C API.\nThis guarantees the integrity of data owned by the host program.\n\n\n

\nThe type thread represents independent threads of execution\nand it is used to implement coroutines (see §2.11).\nDo not confuse Lua threads with operating-system threads.\nLua supports coroutines on all systems,\neven those that do not support threads.\n\n\n

\nThe type table implements associative arrays,\nthat is, arrays that can be indexed not only with numbers,\nbut with any value (except nil).\nTables can be heterogeneous;\nthat is, they can contain values of all types (except nil).\nTables are the sole data structuring mechanism in Lua;\nthey can be used to represent ordinary arrays,\nsymbol tables, sets, records, graphs, trees, etc.\nTo represent records, Lua uses the field name as an index.\nThe language supports this representation by\nproviding a.name as syntactic sugar for a[\"name\"].\nThere are several convenient ways to create tables in Lua\n(see §2.5.7).\n\n\n

\nLike indices,\nthe value of a table field can be of any type (except nil).\nIn particular,\nbecause functions are first-class values,\ntable fields can contain functions.\nThus tables can also carry methods (see §2.5.9).\n\n\n

\nTables, functions, threads, and (full) userdata values are objects:\nvariables do not actually contain these values,\nonly references to them.\nAssignment, parameter passing, and function returns\nalways manipulate references to such values;\nthese operations do not imply any kind of copy.\n\n\n

\nThe library function type returns a string describing the type\nof a given value.\n\n\n\n

2.2.1 - Coercion

\n\n

\nLua provides automatic conversion between\nstring and number values at run time.\nAny arithmetic operation applied to a string tries to convert\nthis string to a number, following the usual conversion rules.\nConversely, whenever a number is used where a string is expected,\nthe number is converted to a string, in a reasonable format.\nFor complete control over how numbers are converted to strings,\nuse the format function from the string library\n(see string.format).\n\n\n\n\n\n\n\n

2.3 - Variables

\n\n

\nVariables are places that store values.\n\nThere are three kinds of variables in Lua:\nglobal variables, local variables, and table fields.\n\n\n

\nA single name can denote a global variable or a local variable\n(or a function's formal parameter,\nwhich is a particular kind of local variable):\n\n

\n\tvar ::= Name\n

\nName denotes identifiers, as defined in §2.1.\n\n\n

\nAny variable is assumed to be global unless explicitly declared\nas a local (see §2.4.7).\nLocal variables are lexically scoped:\nlocal variables can be freely accessed by functions\ndefined inside their scope (see §2.6).\n\n\n

\nBefore the first assignment to a variable, its value is nil.\n\n\n

\nSquare brackets are used to index a table:\n\n

\n\tvar ::= prefixexp `[´ exp `]´\n

\nThe meaning of accesses to global variables \nand table fields can be changed via metatables.\nAn access to an indexed variable t[i] is equivalent to\na call gettable_event(t,i).\n(See §2.8 for a complete description of the\ngettable_event function.\nThis function is not defined or callable in Lua.\nWe use it here only for explanatory purposes.)\n\n\n

\nThe syntax var.Name is just syntactic sugar for\nvar[\"Name\"]:\n\n

\n\tvar ::= prefixexp `.´ Name\n
\n\n

\nAll global variables live as fields in ordinary Lua tables,\ncalled environment tables or simply\nenvironments (see §2.9).\nEach function has its own reference to an environment,\nso that all global variables in this function\nwill refer to this environment table.\nWhen a function is created,\nit inherits the environment from the function that created it.\nTo get the environment table of a Lua function,\nyou call getfenv.\nTo replace it,\nyou call setfenv.\n(You can only manipulate the environment of C functions\nthrough the debug library; (see §5.9).)\n\n\n

\nAn access to a global variable x\nis equivalent to _env.x,\nwhich in turn is equivalent to\n\n

\n     gettable_event(_env, \"x\")\n

\nwhere _env is the environment of the running function.\n(See §2.8 for a complete description of the\ngettable_event function.\nThis function is not defined or callable in Lua.\nSimilarly, the _env variable is not defined in Lua.\nWe use them here only for explanatory purposes.)\n\n\n\n\n\n

2.4 - Statements

\n\n

\nLua supports an almost conventional set of statements,\nsimilar to those in Pascal or C.\nThis set includes\nassignments, control structures, function calls,\nand variable declarations.\n\n\n\n

2.4.1 - Chunks

\n\n

\nThe unit of execution of Lua is called a chunk.\nA chunk is simply a sequence of statements,\nwhich are executed sequentially.\nEach statement can be optionally followed by a semicolon:\n\n

\n\tchunk ::= {stat [`;´]}\n

\nThere are no empty statements and thus ';;' is not legal.\n\n\n

\nLua handles a chunk as the body of an anonymous function \nwith a variable number of arguments\n(see §2.5.9).\nAs such, chunks can define local variables,\nreceive arguments, and return values.\n\n\n

\nA chunk can be stored in a file or in a string inside the host program.\nTo execute a chunk,\nLua first pre-compiles the chunk into instructions for a virtual machine,\nand then it executes the compiled code\nwith an interpreter for the virtual machine.\n\n\n

\nChunks can also be pre-compiled into binary form;\nsee program luac for details.\nPrograms in source and compiled forms are interchangeable;\nLua automatically detects the file type and acts accordingly.\n\n\n\n\n\n\n

2.4.2 - Blocks

\nA block is a list of statements;\nsyntactically, a block is the same as a chunk:\n\n

\n\tblock ::= chunk\n
\n\n

\nA block can be explicitly delimited to produce a single statement:\n\n

\n\tstat ::= do block end\n

\nExplicit blocks are useful\nto control the scope of variable declarations.\nExplicit blocks are also sometimes used to\nadd a return or break statement in the middle\nof another block (see §2.4.4).\n\n\n\n\n\n

2.4.3 - Assignment

\n\n

\nLua allows multiple assignments.\nTherefore, the syntax for assignment\ndefines a list of variables on the left side\nand a list of expressions on the right side.\nThe elements in both lists are separated by commas:\n\n

\n\tstat ::= varlist `=´ explist\n\tvarlist ::= var {`,´ var}\n\texplist ::= exp {`,´ exp}\n

\nExpressions are discussed in §2.5.\n\n\n

\nBefore the assignment,\nthe list of values is adjusted to the length of\nthe list of variables.\nIf there are more values than needed,\nthe excess values are thrown away.\nIf there are fewer values than needed,\nthe list is extended with as many nil's as needed.\nIf the list of expressions ends with a function call,\nthen all values returned by that call enter the list of values,\nbefore the adjustment\n(except when the call is enclosed in parentheses; see §2.5).\n\n\n

\nThe assignment statement first evaluates all its expressions\nand only then are the assignments performed.\nThus the code\n\n

\n     i = 3\n     i, a[i] = i+1, 20\n

\nsets a[3] to 20, without affecting a[4]\nbecause the i in a[i] is evaluated (to 3)\nbefore it is assigned 4.\nSimilarly, the line\n\n

\n     x, y = y, x\n

\nexchanges the values of x and y,\nand\n\n

\n     x, y, z = y, z, x\n

\ncyclically permutes the values of x, y, and z.\n\n\n

\nThe meaning of assignments to global variables\nand table fields can be changed via metatables.\nAn assignment to an indexed variable t[i] = val is equivalent to\nsettable_event(t,i,val).\n(See §2.8 for a complete description of the\nsettable_event function.\nThis function is not defined or callable in Lua.\nWe use it here only for explanatory purposes.)\n\n\n

\nAn assignment to a global variable x = val\nis equivalent to the assignment\n_env.x = val,\nwhich in turn is equivalent to\n\n

\n     settable_event(_env, \"x\", val)\n

\nwhere _env is the environment of the running function.\n(The _env variable is not defined in Lua.\nWe use it here only for explanatory purposes.)\n\n\n\n\n\n

2.4.4 - Control Structures

\nThe control structures\nif, while, and repeat have the usual meaning and\nfamiliar syntax:\n\n\n\n\n

\n\tstat ::= while exp do block end\n\tstat ::= repeat block until exp\n\tstat ::= if exp then block {elseif exp then block} [else block] end\n

\nLua also has a for statement, in two flavors (see §2.4.5).\n\n\n

\nThe condition expression of a\ncontrol structure can return any value.\nBoth false and nil are considered false.\nAll values different from nil and false are considered true\n(in particular, the number 0 and the empty string are also true).\n\n\n

\nIn the repeat–until loop,\nthe inner block does not end at the until keyword,\nbut only after the condition.\nSo, the condition can refer to local variables\ndeclared inside the loop block.\n\n\n

\nThe return statement is used to return values\nfrom a function or a chunk (which is just a function).\n\nFunctions and chunks can return more than one value,\nand so the syntax for the return statement is\n\n

\n\tstat ::= return [explist]\n
\n\n

\nThe break statement is used to terminate the execution of a\nwhile, repeat, or for loop,\nskipping to the next statement after the loop:\n\n\n

\n\tstat ::= break\n

\nA break ends the innermost enclosing loop.\n\n\n

\nThe return and break\nstatements can only be written as the last statement of a block.\nIf it is really necessary to return or break in the\nmiddle of a block,\nthen an explicit inner block can be used,\nas in the idioms\ndo return end and do break end,\nbecause now return and break are the last statements in\ntheir (inner) blocks.\n\n\n\n\n\n

2.4.5 - For Statement

\n\n

\n\nThe for statement has two forms:\none numeric and one generic.\n\n\n

\nThe numeric for loop repeats a block of code while a\ncontrol variable runs through an arithmetic progression.\nIt has the following syntax:\n\n

\n\tstat ::= for Name `=´ exp `,´ exp [`,´ exp] do block end\n

\nThe block is repeated for name starting at the value of\nthe first exp, until it passes the second exp by steps of the\nthird exp.\nMore precisely, a for statement like\n\n

\n     for v = e1, e2, e3 do block end\n

\nis equivalent to the code:\n\n

\n     do\n       local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)\n       if not (var and limit and step) then error() end\n       while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do\n         local v = var\n         block\n         var = var + step\n       end\n     end\n

\nNote the following:\n\n

    \n\n
  • \nAll three control expressions are evaluated only once,\nbefore the loop starts.\nThey must all result in numbers.\n
    • \n\n
  • \nvar, limit, and step are invisible variables.\nThe names shown here are for explanatory purposes only.\n
    • \n\n
  • \nIf the third expression (the step) is absent,\nthen a step of 1 is used.\n
    • \n\n
  • \nYou can use break to exit a for loop.\n
    • \n\n
  • \nThe loop variable v is local to the loop;\nyou cannot use its value after the for ends or is broken.\nIf you need this value,\nassign it to another variable before breaking or exiting the loop.\n
    • \n\n
\n\n

\nThe generic for statement works over functions,\ncalled iterators.\nOn each iteration, the iterator function is called to produce a new value,\nstopping when this new value is nil.\nThe generic for loop has the following syntax:\n\n

\n\tstat ::= for namelist in explist do block end\n\tnamelist ::= Name {`,´ Name}\n

\nA for statement like\n\n

\n     for var_1, ···, var_n in explist do block end\n

\nis equivalent to the code:\n\n

\n     do\n       local f, s, var = explist\n       while true do\n         local var_1, ···, var_n = f(s, var)\n         var = var_1\n         if var == nil then break end\n         block\n       end\n     end\n

\nNote the following:\n\n

    \n\n
  • \nexplist is evaluated only once.\nIts results are an iterator function,\na state,\nand an initial value for the first iterator variable.\n
    • \n\n
  • \nf, s, and var are invisible variables.\nThe names are here for explanatory purposes only.\n
    • \n\n
  • \nYou can use break to exit a for loop.\n
    • \n\n
  • \nThe loop variables var_i are local to the loop;\nyou cannot use their values after the for ends.\nIf you need these values,\nthen assign them to other variables before breaking or exiting the loop.\n
    • \n\n
\n\n\n\n\n

2.4.6 - Function Calls as Statements

\nTo allow possible side-effects,\nfunction calls can be executed as statements:\n\n

\n\tstat ::= functioncall\n

\nIn this case, all returned values are thrown away.\nFunction calls are explained in §2.5.8.\n\n\n\n\n\n

2.4.7 - Local Declarations

\nLocal variables can be declared anywhere inside a block.\nThe declaration can include an initial assignment:\n\n

\n\tstat ::= local namelist [`=´ explist]\n

\nIf present, an initial assignment has the same semantics\nof a multiple assignment (see §2.4.3).\nOtherwise, all variables are initialized with nil.\n\n\n

\nA chunk is also a block (see §2.4.1),\nand so local variables can be declared in a chunk outside any explicit block.\nThe scope of such local variables extends until the end of the chunk.\n\n\n

\nThe visibility rules for local variables are explained in §2.6.\n\n\n\n\n\n\n\n

2.5 - Expressions

\n\n

\nThe basic expressions in Lua are the following:\n\n

\n\texp ::= prefixexp\n\texp ::= nil | false | true\n\texp ::= Number\n\texp ::= String\n\texp ::= function\n\texp ::= tableconstructor\n\texp ::= `...´\n\texp ::= exp binop exp\n\texp ::= unop exp\n\tprefixexp ::= var | functioncall | `(´ exp `)´\n
\n\n

\nNumbers and literal strings are explained in §2.1;\nvariables are explained in §2.3;\nfunction definitions are explained in §2.5.9;\nfunction calls are explained in §2.5.8;\ntable constructors are explained in §2.5.7.\nVararg expressions,\ndenoted by three dots ('...'), can only be used when\ndirectly inside a vararg function;\nthey are explained in §2.5.9.\n\n\n

\nBinary operators comprise arithmetic operators (see §2.5.1),\nrelational operators (see §2.5.2), logical operators (see §2.5.3),\nand the concatenation operator (see §2.5.4).\nUnary operators comprise the unary minus (see §2.5.1),\nthe unary not (see §2.5.3),\nand the unary length operator (see §2.5.5).\n\n\n

\nBoth function calls and vararg expressions can result in multiple values.\nIf an expression is used as a statement\n(only possible for function calls (see §2.4.6)),\nthen its return list is adjusted to zero elements,\nthus discarding all returned values.\nIf an expression is used as the last (or the only) element\nof a list of expressions,\nthen no adjustment is made\n(unless the call is enclosed in parentheses).\nIn all other contexts,\nLua adjusts the result list to one element,\ndiscarding all values except the first one.\n\n\n

\nHere are some examples:\n\n

\n     f()                -- adjusted to 0 results\n     g(f(), x)          -- f() is adjusted to 1 result\n     g(x, f())          -- g gets x plus all results from f()\n     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)\n     a,b = ...          -- a gets the first vararg parameter, b gets\n                        -- the second (both a and b can get nil if there\n                        -- is no corresponding vararg parameter)\n     \n     a,b,c = x, f()     -- f() is adjusted to 2 results\n     a,b,c = f()        -- f() is adjusted to 3 results\n     return f()         -- returns all results from f()\n     return ...         -- returns all received vararg parameters\n     return x,y,f()     -- returns x, y, and all results from f()\n     {f()}              -- creates a list with all results from f()\n     {...}              -- creates a list with all vararg parameters\n     {f(), nil}         -- f() is adjusted to 1 result\n
\n\n

\nAny expression enclosed in parentheses always results in only one value.\nThus,\n(f(x,y,z)) is always a single value,\neven if f returns several values.\n(The value of (f(x,y,z)) is the first value returned by f\nor nil if f does not return any values.)\n\n\n\n

2.5.1 - Arithmetic Operators

\nLua supports the usual arithmetic operators:\nthe binary + (addition),\n- (subtraction), * (multiplication),\n/ (division), % (modulo), and ^ (exponentiation);\nand unary - (negation).\nIf the operands are numbers, or strings that can be converted to\nnumbers (see §2.2.1),\nthen all operations have the usual meaning.\nExponentiation works for any exponent.\nFor instance, x^(-0.5) computes the inverse of the square root of x.\nModulo is defined as\n\n

\n     a % b == a - math.floor(a/b)*b\n

\nThat is, it is the remainder of a division that rounds\nthe quotient towards minus infinity.\n\n\n\n\n\n

2.5.2 - Relational Operators

\nThe relational operators in Lua are\n\n

\n     ==    ~=    <     >     <=    >=\n

\nThese operators always result in false or true.\n\n\n

\nEquality (==) first compares the type of its operands.\nIf the types are different, then the result is false.\nOtherwise, the values of the operands are compared.\nNumbers and strings are compared in the usual way.\nObjects (tables, userdata, threads, and functions)\nare compared by reference:\ntwo objects are considered equal only if they are the same object.\nEvery time you create a new object\n(a table, userdata, thread, or function),\nthis new object is different from any previously existing object.\n\n\n

\nYou can change the way that Lua compares tables and userdata \nby using the \"eq\" metamethod (see §2.8).\n\n\n

\nThe conversion rules of §2.2.1\ndo not apply to equality comparisons.\nThus, \"0\"==0 evaluates to false,\nand t[0] and t[\"0\"] denote different\nentries in a table.\n\n\n

\nThe operator ~= is exactly the negation of equality (==).\n\n\n

\nThe order operators work as follows.\nIf both arguments are numbers, then they are compared as such.\nOtherwise, if both arguments are strings,\nthen their values are compared according to the current locale.\nOtherwise, Lua tries to call the \"lt\" or the \"le\"\nmetamethod (see §2.8).\nA comparison a > b is translated to b < a\nand a >= b is translated to b <= a.\n\n\n\n\n\n

2.5.3 - Logical Operators

\nThe logical operators in Lua are\nand, or, and not.\nLike the control structures (see §2.4.4),\nall logical operators consider both false and nil as false\nand anything else as true.\n\n\n

\nThe negation operator not always returns false or true.\nThe conjunction operator and returns its first argument\nif this value is false or nil;\notherwise, and returns its second argument.\nThe disjunction operator or returns its first argument\nif this value is different from nil and false;\notherwise, or returns its second argument.\nBoth and and or use short-cut evaluation;\nthat is,\nthe second operand is evaluated only if necessary.\nHere are some examples:\n\n

\n     10 or 20            --> 10\n     10 or error()       --> 10\n     nil or \"a\"          --> \"a\"\n     nil and 10          --> nil\n     false and error()   --> false\n     false and nil       --> false\n     false or nil        --> nil\n     10 and 20           --> 20\n

\n(In this manual,\n--> indicates the result of the preceding expression.)\n\n\n\n\n\n

2.5.4 - Concatenation

\nThe string concatenation operator in Lua is\ndenoted by two dots ('..').\nIf both operands are strings or numbers, then they are converted to\nstrings according to the rules mentioned in §2.2.1.\nOtherwise, the \"concat\" metamethod is called (see §2.8).\n\n\n\n\n\n

2.5.5 - The Length Operator

\n\n

\nThe length operator is denoted by the unary operator #.\nThe length of a string is its number of bytes\n(that is, the usual meaning of string length when each\ncharacter is one byte).\n\n\n

\nThe length of a table t is defined to be any\ninteger index n\nsuch that t[n] is not nil and t[n+1] is nil;\nmoreover, if t[1] is nil, n can be zero.\nFor a regular array, with non-nil values from 1 to a given n,\nits length is exactly that n,\nthe index of its last value.\nIf the array has \"holes\"\n(that is, nil values between other non-nil values),\nthen #t can be any of the indices that\ndirectly precedes a nil value\n(that is, it may consider any such nil value as the end of\nthe array). \n\n\n\n\n\n

2.5.6 - Precedence

\nOperator precedence in Lua follows the table below,\nfrom lower to higher priority:\n\n

\n     or\n     and\n     <     >     <=    >=    ~=    ==\n     ..\n     +     -\n     *     /     %\n     not   #     - (unary)\n     ^\n

\nAs usual,\nyou can use parentheses to change the precedences of an expression.\nThe concatenation ('..') and exponentiation ('^')\noperators are right associative.\nAll other binary operators are left associative.\n\n\n\n\n\n

2.5.7 - Table Constructors

\nTable constructors are expressions that create tables.\nEvery time a constructor is evaluated, a new table is created.\nA constructor can be used to create an empty table\nor to create a table and initialize some of its fields.\nThe general syntax for constructors is\n\n

\n\ttableconstructor ::= `{´ [fieldlist] `}´\n\tfieldlist ::= field {fieldsep field} [fieldsep]\n\tfield ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp\n\tfieldsep ::= `,´ | `;´\n
\n\n

\nEach field of the form [exp1] = exp2 adds to the new table an entry\nwith key exp1 and value exp2.\nA field of the form name = exp is equivalent to\n[\"name\"] = exp.\nFinally, fields of the form exp are equivalent to\n[i] = exp, where i are consecutive numerical integers,\nstarting with 1.\nFields in the other formats do not affect this counting.\nFor example,\n\n

\n     a = { [f(1)] = g; \"x\", \"y\"; x = 1, f(x), [30] = 23; 45 }\n

\nis equivalent to\n\n

\n     do\n       local t = {}\n       t[f(1)] = g\n       t[1] = \"x\"         -- 1st exp\n       t[2] = \"y\"         -- 2nd exp\n       t.x = 1            -- t[\"x\"] = 1\n       t[3] = f(x)        -- 3rd exp\n       t[30] = 23\n       t[4] = 45          -- 4th exp\n       a = t\n     end\n
\n\n

\nIf the last field in the list has the form exp\nand the expression is a function call or a vararg expression,\nthen all values returned by this expression enter the list consecutively\n(see §2.5.8).\nTo avoid this,\nenclose the function call or the vararg expression\nin parentheses (see §2.5).\n\n\n

\nThe field list can have an optional trailing separator,\nas a convenience for machine-generated code.\n\n\n\n\n\n

2.5.8 - Function Calls

\nA function call in Lua has the following syntax:\n\n

\n\tfunctioncall ::= prefixexp args\n

\nIn a function call,\nfirst prefixexp and args are evaluated.\nIf the value of prefixexp has type function,\nthen this function is called\nwith the given arguments.\nOtherwise, the prefixexp \"call\" metamethod is called,\nhaving as first parameter the value of prefixexp,\nfollowed by the original call arguments\n(see §2.8).\n\n\n

\nThe form\n\n

\n\tfunctioncall ::= prefixexp `:´ Name args\n

\ncan be used to call \"methods\".\nA call v:name(args)\nis syntactic sugar for v.name(v,args),\nexcept that v is evaluated only once.\n\n\n

\nArguments have the following syntax:\n\n

\n\targs ::= `(´ [explist] `)´\n\targs ::= tableconstructor\n\targs ::= String\n

\nAll argument expressions are evaluated before the call.\nA call of the form f{fields} is\nsyntactic sugar for f({fields});\nthat is, the argument list is a single new table.\nA call of the form f'string'\n(or f\"string\" or f[[string]])\nis syntactic sugar for f('string');\nthat is, the argument list is a single literal string.\n\n\n

\nAs an exception to the free-format syntax of Lua,\nyou cannot put a line break before the '(' in a function call.\nThis restriction avoids some ambiguities in the language.\nIf you write\n\n

\n     a = f\n     (g).x(a)\n

\nLua would see that as a single statement, a = f(g).x(a).\nSo, if you want two statements, you must add a semi-colon between them.\nIf you actually want to call f,\nyou must remove the line break before (g).\n\n\n

\nA call of the form return functioncall is called\na tail call.\nLua implements proper tail calls\n(or proper tail recursion):\nin a tail call,\nthe called function reuses the stack entry of the calling function.\nTherefore, there is no limit on the number of nested tail calls that\na program can execute.\nHowever, a tail call erases any debug information about the\ncalling function.\nNote that a tail call only happens with a particular syntax,\nwhere the return has one single function call as argument;\nthis syntax makes the calling function return exactly\nthe returns of the called function.\nSo, none of the following examples are tail calls:\n\n

\n     return (f(x))        -- results adjusted to 1\n     return 2 * f(x)\n     return x, f(x)       -- additional results\n     f(x); return         -- results discarded\n     return x or f(x)     -- results adjusted to 1\n
\n\n\n\n\n

2.5.9 - Function Definitions

\n\n

\nThe syntax for function definition is\n\n

\n\tfunction ::= function funcbody\n\tfuncbody ::= `(´ [parlist] `)´ block end\n
\n\n

\nThe following syntactic sugar simplifies function definitions:\n\n

\n\tstat ::= function funcname funcbody\n\tstat ::= local function Name funcbody\n\tfuncname ::= Name {`.´ Name} [`:´ Name]\n

\nThe statement\n\n

\n     function f () body end\n

\ntranslates to\n\n

\n     f = function () body end\n

\nThe statement\n\n

\n     function t.a.b.c.f () body end\n

\ntranslates to\n\n

\n     t.a.b.c.f = function () body end\n

\nThe statement\n\n

\n     local function f () body end\n

\ntranslates to\n\n

\n     local f; f = function () body end\n

\nnot to\n\n

\n     local f = function () body end\n

\n(This only makes a difference when the body of the function\ncontains references to f.)\n\n\n

\nA function definition is an executable expression,\nwhose value has type function.\nWhen Lua pre-compiles a chunk,\nall its function bodies are pre-compiled too.\nThen, whenever Lua executes the function definition,\nthe function is instantiated (or closed).\nThis function instance (or closure)\nis the final value of the expression.\nDifferent instances of the same function\ncan refer to different external local variables\nand can have different environment tables.\n\n\n

\nParameters act as local variables that are\ninitialized with the argument values:\n\n

\n\tparlist ::= namelist [`,´ `...´] | `...´\n

\nWhen a function is called,\nthe list of arguments is adjusted to\nthe length of the list of parameters,\nunless the function is a variadic or vararg function,\nwhich is\nindicated by three dots ('...') at the end of its parameter list.\nA vararg function does not adjust its argument list;\ninstead, it collects all extra arguments and supplies them\nto the function through a vararg expression,\nwhich is also written as three dots.\nThe value of this expression is a list of all actual extra arguments,\nsimilar to a function with multiple results.\nIf a vararg expression is used inside another expression\nor in the middle of a list of expressions,\nthen its return list is adjusted to one element.\nIf the expression is used as the last element of a list of expressions,\nthen no adjustment is made\n(unless that last expression is enclosed in parentheses).\n\n\n

\nAs an example, consider the following definitions:\n\n

\n     function f(a, b) end\n     function g(a, b, ...) end\n     function r() return 1,2,3 end\n

\nThen, we have the following mapping from arguments to parameters and\nto the vararg expression:\n\n

\n     CALL            PARAMETERS\n     \n     f(3)             a=3, b=nil\n     f(3, 4)          a=3, b=4\n     f(3, 4, 5)       a=3, b=4\n     f(r(), 10)       a=1, b=10\n     f(r())           a=1, b=2\n     \n     g(3)             a=3, b=nil, ... -->  (nothing)\n     g(3, 4)          a=3, b=4,   ... -->  (nothing)\n     g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8\n     g(5, r())        a=5, b=1,   ... -->  2  3\n
\n\n

\nResults are returned using the return statement (see §2.4.4).\nIf control reaches the end of a function\nwithout encountering a return statement,\nthen the function returns with no results.\n\n\n

\nThe colon syntax\nis used for defining methods,\nthat is, functions that have an implicit extra parameter self.\nThus, the statement\n\n

\n     function t.a.b.c:f (params) body end\n

\nis syntactic sugar for\n\n

\n     t.a.b.c.f = function (self, params) body end\n
\n\n\n\n\n\n\n

2.6 - Visibility Rules

\n\n

\n\nLua is a lexically scoped language.\nThe scope of variables begins at the first statement after\ntheir declaration and lasts until the end of the innermost block that\nincludes the declaration.\nConsider the following example:\n\n

\n     x = 10                -- global variable\n     do                    -- new block\n       local x = x         -- new 'x', with value 10\n       print(x)            --> 10\n       x = x+1\n       do                  -- another block\n         local x = x+1     -- another 'x'\n         print(x)          --> 12\n       end\n       print(x)            --> 11\n     end\n     print(x)              --> 10  (the global one)\n
\n\n

\nNotice that, in a declaration like local x = x,\nthe new x being declared is not in scope yet,\nand so the second x refers to the outside variable.\n\n\n

\nBecause of the lexical scoping rules,\nlocal variables can be freely accessed by functions\ndefined inside their scope.\nA local variable used by an inner function is called\nan upvalue, or external local variable,\ninside the inner function.\n\n\n

\nNotice that each execution of a local statement\ndefines new local variables.\nConsider the following example:\n\n

\n     a = {}\n     local x = 20\n     for i=1,10 do\n       local y = 0\n       a[i] = function () y=y+1; return x+y end\n     end\n

\nThe loop creates ten closures\n(that is, ten instances of the anonymous function).\nEach of these closures uses a different y variable,\nwhile all of them share the same x.\n\n\n\n\n\n

2.7 - Error Handling

\n\n

\nBecause Lua is an embedded extension language,\nall Lua actions start from C code in the host program\ncalling a function from the Lua library (see lua_pcall).\nWhenever an error occurs during Lua compilation or execution,\ncontrol returns to C,\nwhich can take appropriate measures\n(such as printing an error message).\n\n\n

\nLua code can explicitly generate an error by calling the\nerror function.\nIf you need to catch errors in Lua,\nyou can use the pcall function.\n\n\n\n\n\n

2.8 - Metatables

\n\n

\nEvery value in Lua can have a metatable.\nThis metatable is an ordinary Lua table\nthat defines the behavior of the original value\nunder certain special operations.\nYou can change several aspects of the behavior\nof operations over a value by setting specific fields in its metatable.\nFor instance, when a non-numeric value is the operand of an addition,\nLua checks for a function in the field \"__add\" in its metatable.\nIf it finds one,\nLua calls this function to perform the addition.\n\n\n

\nWe call the keys in a metatable events\nand the values metamethods.\nIn the previous example, the event is \"add\" \nand the metamethod is the function that performs the addition.\n\n\n

\nYou can query the metatable of any value\nthrough the getmetatable function.\n\n\n

\nYou can replace the metatable of tables\nthrough the setmetatable\nfunction.\nYou cannot change the metatable of other types from Lua\n(except by using the debug library);\nyou must use the C API for that.\n\n\n

\nTables and full userdata have individual metatables\n(although multiple tables and userdata can share their metatables).\nValues of all other types share one single metatable per type;\nthat is, there is one single metatable for all numbers,\none for all strings, etc.\n\n\n

\nA metatable controls how an object behaves in arithmetic operations,\norder comparisons, concatenation, length operation, and indexing.\nA metatable also can define a function to be called when a userdata\nis garbage collected.\nFor each of these operations Lua associates a specific key\ncalled an event.\nWhen Lua performs one of these operations over a value,\nit checks whether this value has a metatable with the corresponding event.\nIf so, the value associated with that key (the metamethod)\ncontrols how Lua will perform the operation.\n\n\n

\nMetatables control the operations listed next.\nEach operation is identified by its corresponding name.\nThe key for each operation is a string with its name prefixed by\ntwo underscores, '__';\nfor instance, the key for operation \"add\" is the\nstring \"__add\".\nThe semantics of these operations is better explained by a Lua function\ndescribing how the interpreter executes the operation.\n\n\n

\nThe code shown here in Lua is only illustrative;\nthe real behavior is hard coded in the interpreter\nand it is much more efficient than this simulation.\nAll functions used in these descriptions\n(rawget, tonumber, etc.)\nare described in §5.1.\nIn particular, to retrieve the metamethod of a given object,\nwe use the expression\n\n

\n     metatable(obj)[event]\n

\nThis should be read as\n\n

\n     rawget(getmetatable(obj) or {}, event)\n

\n\nThat is, the access to a metamethod does not invoke other metamethods,\nand the access to objects with no metatables does not fail\n(it simply results in nil).\n\n\n\n

    \n\n
  • \"add\":\nthe + operation.\n\n\n\n

    \nThe function getbinhandler below defines how Lua chooses a handler\nfor a binary operation.\nFirst, Lua tries the first operand.\nIf its type does not define a handler for the operation,\nthen Lua tries the second operand.\n\n

    \n     function getbinhandler (op1, op2, event)\n       return metatable(op1)[event] or metatable(op2)[event]\n     end\n

    \nBy using this function,\nthe behavior of the op1 + op2 is\n\n

    \n     function add_event (op1, op2)\n       local o1, o2 = tonumber(op1), tonumber(op2)\n       if o1 and o2 then  -- both operands are numeric?\n         return o1 + o2   -- '+' here is the primitive 'add'\n       else  -- at least one of the operands is not numeric\n         local h = getbinhandler(op1, op2, \"__add\")\n         if h then\n           -- call the handler with both operands\n           return (h(op1, op2))\n         else  -- no handler available: default behavior\n           error(···)\n         end\n       end\n     end\n

    \n

    • \n\n
  • \"sub\":\nthe - operation.\n\nBehavior similar to the \"add\" operation.\n
    • \n\n
  • \"mul\":\nthe * operation.\n\nBehavior similar to the \"add\" operation.\n
    • \n\n
  • \"div\":\nthe / operation.\n\nBehavior similar to the \"add\" operation.\n
    • \n\n
  • \"mod\":\nthe % operation.\n\nBehavior similar to the \"add\" operation,\nwith the operation\no1 - floor(o1/o2)*o2 as the primitive operation.\n
    • \n\n
  • \"pow\":\nthe ^ (exponentiation) operation.\n\nBehavior similar to the \"add\" operation,\nwith the function pow (from the C math library)\nas the primitive operation.\n
    • \n\n
  • \"unm\":\nthe unary - operation.\n\n\n
    \n     function unm_event (op)\n       local o = tonumber(op)\n       if o then  -- operand is numeric?\n         return -o  -- '-' here is the primitive 'unm'\n       else  -- the operand is not numeric.\n         -- Try to get a handler from the operand\n         local h = metatable(op).__unm\n         if h then\n           -- call the handler with the operand\n           return (h(op))\n         else  -- no handler available: default behavior\n           error(···)\n         end\n       end\n     end\n

    \n

    • \n\n
  • \"concat\":\nthe .. (concatenation) operation.\n\n\n
    \n     function concat_event (op1, op2)\n       if (type(op1) == \"string\" or type(op1) == \"number\") and\n          (type(op2) == \"string\" or type(op2) == \"number\") then\n         return op1 .. op2  -- primitive string concatenation\n       else\n         local h = getbinhandler(op1, op2, \"__concat\")\n         if h then\n           return (h(op1, op2))\n         else\n           error(···)\n         end\n       end\n     end\n

    \n

    • \n\n
  • \"len\":\nthe # operation.\n\n\n
    \n     function len_event (op)\n       if type(op) == \"string\" then\n         return strlen(op)         -- primitive string length\n       elseif type(op) == \"table\" then\n         return #op                -- primitive table length\n       else\n         local h = metatable(op).__len\n         if h then\n           -- call the handler with the operand\n           return (h(op))\n         else  -- no handler available: default behavior\n           error(···)\n         end\n       end\n     end\n

    \nSee §2.5.5 for a description of the length of a table.\n

    • \n\n
  • \"eq\":\nthe == operation.\n\nThe function getcomphandler defines how Lua chooses a metamethod\nfor comparison operators.\nA metamethod only is selected when both objects\nbeing compared have the same type\nand the same metamethod for the selected operation.\n\n
    \n     function getcomphandler (op1, op2, event)\n       if type(op1) ~= type(op2) then return nil end\n       local mm1 = metatable(op1)[event]\n       local mm2 = metatable(op2)[event]\n       if mm1 == mm2 then return mm1 else return nil end\n     end\n

    \nThe \"eq\" event is defined as follows:\n\n

    \n     function eq_event (op1, op2)\n       if type(op1) ~= type(op2) then  -- different types?\n         return false   -- different objects\n       end\n       if op1 == op2 then   -- primitive equal?\n         return true   -- objects are equal\n       end\n       -- try metamethod\n       local h = getcomphandler(op1, op2, \"__eq\")\n       if h then\n         return (h(op1, op2))\n       else\n         return false\n       end\n     end\n

    \na ~= b is equivalent to not (a == b).\n

    • \n\n
  • \"lt\":\nthe < operation.\n\n\n
    \n     function lt_event (op1, op2)\n       if type(op1) == \"number\" and type(op2) == \"number\" then\n         return op1 < op2   -- numeric comparison\n       elseif type(op1) == \"string\" and type(op2) == \"string\" then\n         return op1 < op2   -- lexicographic comparison\n       else\n         local h = getcomphandler(op1, op2, \"__lt\")\n         if h then\n           return (h(op1, op2))\n         else\n           error(···)\n         end\n       end\n     end\n

    \na > b is equivalent to b < a.\n

    • \n\n
  • \"le\":\nthe <= operation.\n\n\n
    \n     function le_event (op1, op2)\n       if type(op1) == \"number\" and type(op2) == \"number\" then\n         return op1 <= op2   -- numeric comparison\n       elseif type(op1) == \"string\" and type(op2) == \"string\" then\n         return op1 <= op2   -- lexicographic comparison\n       else\n         local h = getcomphandler(op1, op2, \"__le\")\n         if h then\n           return (h(op1, op2))\n         else\n           h = getcomphandler(op1, op2, \"__lt\")\n           if h then\n             return not h(op2, op1)\n           else\n             error(···)\n           end\n         end\n       end\n     end\n

    \na >= b is equivalent to b <= a.\nNote that, in the absence of a \"le\" metamethod,\nLua tries the \"lt\", assuming that a <= b is\nequivalent to not (b < a).\n

    • \n\n
  • \"index\":\nThe indexing access table[key].\n\n\n
    \n     function gettable_event (table, key)\n       local h\n       if type(table) == \"table\" then\n         local v = rawget(table, key)\n         if v ~= nil then return v end\n         h = metatable(table).__index\n         if h == nil then return nil end\n       else\n         h = metatable(table).__index\n         if h == nil then\n           error(···)\n         end\n       end\n       if type(h) == \"function\" then\n         return (h(table, key))     -- call the handler\n       else return h[key]           -- or repeat operation on it\n       end\n     end\n

    \n

    • \n\n
  • \"newindex\":\nThe indexing assignment table[key] = value.\n\n\n
    \n     function settable_event (table, key, value)\n       local h\n       if type(table) == \"table\" then\n         local v = rawget(table, key)\n         if v ~= nil then rawset(table, key, value); return end\n         h = metatable(table).__newindex\n         if h == nil then rawset(table, key, value); return end\n       else\n         h = metatable(table).__newindex\n         if h == nil then\n           error(···)\n         end\n       end\n       if type(h) == \"function\" then\n         h(table, key,value)           -- call the handler\n       else h[key] = value             -- or repeat operation on it\n       end\n     end\n

    \n

    • \n\n
  • \"call\":\ncalled when Lua calls a value.\n\n\n
    \n     function function_event (func, ...)\n       if type(func) == \"function\" then\n         return func(...)   -- primitive call\n       else\n         local h = metatable(func).__call\n         if h then\n           return h(func, ...)\n         else\n           error(···)\n         end\n       end\n     end\n

    \n

    • \n\n
\n\n\n\n\n

2.9 - Environments

\n\n

\nBesides metatables,\nobjects of types thread, function, and userdata\nhave another table associated with them,\ncalled their environment.\nLike metatables, environments are regular tables and\nmultiple objects can share the same environment.\n\n\n

\nThreads are created sharing the environment of the creating thread.\nUserdata and C functions are created sharing the environment\nof the creating C function.\nNon-nested Lua functions\n(created by loadfile, loadstring or load)\nare created sharing the environment of the creating thread.\nNested Lua functions are created sharing the environment of\nthe creating Lua function.\n\n\n

\nEnvironments associated with userdata have no meaning for Lua.\nIt is only a convenience feature for programmers to associate a table to\na userdata.\n\n\n

\nEnvironments associated with threads are called\nglobal environments.\nThey are used as the default environment for threads and\nnon-nested Lua functions created by the thread\nand can be directly accessed by C code (see §3.3).\n\n\n

\nThe environment associated with a C function can be directly\naccessed by C code (see §3.3).\nIt is used as the default environment for other C functions\nand userdata created by the function.\n\n\n

\nEnvironments associated with Lua functions are used to resolve\nall accesses to global variables within the function (see §2.3).\nThey are used as the default environment for nested Lua functions\ncreated by the function.\n\n\n

\nYou can change the environment of a Lua function or the\nrunning thread by calling setfenv.\nYou can get the environment of a Lua function or the running thread\nby calling getfenv.\nTo manipulate the environment of other objects\n(userdata, C functions, other threads) you must\nuse the C API.\n\n\n\n\n\n

2.10 - Garbage Collection

\n\n

\nLua performs automatic memory management.\nThis means that\nyou have to worry neither about allocating memory for new objects\nnor about freeing it when the objects are no longer needed.\nLua manages memory automatically by running\na garbage collector from time to time\nto collect all dead objects\n(that is, objects that are no longer accessible from Lua).\nAll memory used by Lua is subject to automatic management:\ntables, userdata, functions, threads, strings, etc.\n\n\n

\nLua implements an incremental mark-and-sweep collector.\nIt uses two numbers to control its garbage-collection cycles:\nthe garbage-collector pause and\nthe garbage-collector step multiplier.\nBoth use percentage points as units\n(so that a value of 100 means an internal value of 1).\n\n\n

\nThe garbage-collector pause\ncontrols how long the collector waits before starting a new cycle.\nLarger values make the collector less aggressive.\nValues smaller than 100 mean the collector will not wait to\nstart a new cycle.\nA value of 200 means that the collector waits for the total memory in use\nto double before starting a new cycle.\n\n\n

\nThe step multiplier\ncontrols the relative speed of the collector relative to\nmemory allocation.\nLarger values make the collector more aggressive but also increase\nthe size of each incremental step.\nValues smaller than 100 make the collector too slow and\ncan result in the collector never finishing a cycle.\nThe default, 200, means that the collector runs at \"twice\"\nthe speed of memory allocation.\n\n\n

\nYou can change these numbers by calling lua_gc in C\nor collectgarbage in Lua.\nWith these functions you can also control \nthe collector directly (e.g., stop and restart it).\n\n\n\n

2.10.1 - Garbage-Collection Metamethods

\n\n

\nUsing the C API,\nyou can set garbage-collector metamethods for userdata (see §2.8).\nThese metamethods are also called finalizers.\nFinalizers allow you to coordinate Lua's garbage collection\nwith external resource management\n(such as closing files, network or database connections,\nor freeing your own memory).\n\n\n

\nGarbage userdata with a field __gc in their metatables are not\ncollected immediately by the garbage collector.\nInstead, Lua puts them in a list.\nAfter the collection,\nLua does the equivalent of the following function\nfor each userdata in that list:\n\n

\n     function gc_event (udata)\n       local h = metatable(udata).__gc\n       if h then\n         h(udata)\n       end\n     end\n
\n\n

\nAt the end of each garbage-collection cycle,\nthe finalizers for userdata are called in reverse\norder of their creation,\namong those collected in that cycle.\nThat is, the first finalizer to be called is the one associated\nwith the userdata created last in the program.\nThe userdata itself is freed only in the next garbage-collection cycle.\n\n\n\n\n\n

2.10.2 - Weak Tables

\n\n

\nA weak table is a table whose elements are\nweak references.\nA weak reference is ignored by the garbage collector.\nIn other words,\nif the only references to an object are weak references,\nthen the garbage collector will collect this object.\n\n\n

\nA weak table can have weak keys, weak values, or both.\nA table with weak keys allows the collection of its keys,\nbut prevents the collection of its values.\nA table with both weak keys and weak values allows the collection of\nboth keys and values.\nIn any case, if either the key or the value is collected,\nthe whole pair is removed from the table.\nThe weakness of a table is controlled by the\n__mode field of its metatable.\nIf the __mode field is a string containing the character 'k',\nthe keys in the table are weak.\nIf __mode contains 'v',\nthe values in the table are weak.\n\n\n

\nAfter you use a table as a metatable,\nyou should not change the value of its __mode field.\nOtherwise, the weak behavior of the tables controlled by this\nmetatable is undefined.\n\n\n\n\n\n\n\n

2.11 - Coroutines

\n\n

\nLua supports coroutines,\nalso called collaborative multithreading.\nA coroutine in Lua represents an independent thread of execution.\nUnlike threads in multithread systems, however,\na coroutine only suspends its execution by explicitly calling\na yield function.\n\n\n

\nYou create a coroutine with a call to coroutine.create.\nIts sole argument is a function\nthat is the main function of the coroutine.\nThe create function only creates a new coroutine and\nreturns a handle to it (an object of type thread);\nit does not start the coroutine execution.\n\n\n

\nWhen you first call coroutine.resume,\npassing as its first argument\na thread returned by coroutine.create,\nthe coroutine starts its execution,\nat the first line of its main function.\nExtra arguments passed to coroutine.resume are passed on\nto the coroutine main function.\nAfter the coroutine starts running,\nit runs until it terminates or yields.\n\n\n

\nA coroutine can terminate its execution in two ways:\nnormally, when its main function returns\n(explicitly or implicitly, after the last instruction);\nand abnormally, if there is an unprotected error.\nIn the first case, coroutine.resume returns true,\nplus any values returned by the coroutine main function.\nIn case of errors, coroutine.resume returns false\nplus an error message.\n\n\n

\nA coroutine yields by calling coroutine.yield.\nWhen a coroutine yields,\nthe corresponding coroutine.resume returns immediately,\neven if the yield happens inside nested function calls\n(that is, not in the main function,\nbut in a function directly or indirectly called by the main function).\nIn the case of a yield, coroutine.resume also returns true,\nplus any values passed to coroutine.yield.\nThe next time you resume the same coroutine,\nit continues its execution from the point where it yielded,\nwith the call to coroutine.yield returning any extra\narguments passed to coroutine.resume.\n\n\n

\nLike coroutine.create,\nthe coroutine.wrap function also creates a coroutine,\nbut instead of returning the coroutine itself,\nit returns a function that, when called, resumes the coroutine.\nAny arguments passed to this function\ngo as extra arguments to coroutine.resume.\ncoroutine.wrap returns all the values returned by coroutine.resume,\nexcept the first one (the boolean error code).\nUnlike coroutine.resume,\ncoroutine.wrap does not catch errors;\nany error is propagated to the caller.\n\n\n

\nAs an example,\nconsider the following code:\n\n

\n     function foo (a)\n       print(\"foo\", a)\n       return coroutine.yield(2*a)\n     end\n     \n     co = coroutine.create(function (a,b)\n           print(\"co-body\", a, b)\n           local r = foo(a+1)\n           print(\"co-body\", r)\n           local r, s = coroutine.yield(a+b, a-b)\n           print(\"co-body\", r, s)\n           return b, \"end\"\n     end)\n            \n     print(\"main\", coroutine.resume(co, 1, 10))\n     print(\"main\", coroutine.resume(co, \"r\"))\n     print(\"main\", coroutine.resume(co, \"x\", \"y\"))\n     print(\"main\", coroutine.resume(co, \"x\", \"y\"))\n

\nWhen you run it, it produces the following output:\n\n

\n     co-body 1       10\n     foo     2\n     \n     main    true    4\n     co-body r\n     main    true    11      -9\n     co-body x       y\n     main    true    10      end\n     main    false   cannot resume dead coroutine\n
\n\n\n\n\n

3 - The Application Program Interface

\n\n

\n\nThis section describes the C API for Lua, that is,\nthe set of C functions available to the host program to communicate\nwith Lua.\nAll API functions and related types and constants\nare declared in the header file lua.h.\n\n\n

\nEven when we use the term \"function\",\nany facility in the API may be provided as a macro instead.\nAll such macros use each of their arguments exactly once\n(except for the first argument, which is always a Lua state),\nand so do not generate any hidden side-effects.\n\n\n

\nAs in most C libraries,\nthe Lua API functions do not check their arguments for validity or consistency.\nHowever, you can change this behavior by compiling Lua\nwith a proper definition for the macro luai_apicheck,\nin file luaconf.h.\n\n\n\n

3.1 - The Stack

\n\n

\nLua uses a virtual stack to pass values to and from C.\nEach element in this stack represents a Lua value\n(nil, number, string, etc.).\n\n\n

\nWhenever Lua calls C, the called function gets a new stack,\nwhich is independent of previous stacks and of stacks of\nC functions that are still active.\nThis stack initially contains any arguments to the C function\nand it is where the C function pushes its results\nto be returned to the caller (see lua_CFunction).\n\n\n

\nFor convenience,\nmost query operations in the API do not follow a strict stack discipline.\nInstead, they can refer to any element in the stack\nby using an index:\nA positive index represents an absolute stack position\n(starting at 1);\na negative index represents an offset relative to the top of the stack.\nMore specifically, if the stack has n elements,\nthen index 1 represents the first element\n(that is, the element that was pushed onto the stack first)\nand\nindex n represents the last element;\nindex -1 also represents the last element\n(that is, the element at the top)\nand index -n represents the first element.\nWe say that an index is valid\nif it lies between 1 and the stack top\n(that is, if 1 ≤ abs(index) ≤ top).\n \n\n\n\n\n\n

3.2 - Stack Size

\n\n

\nWhen you interact with Lua API,\nyou are responsible for ensuring consistency.\nIn particular,\nyou are responsible for controlling stack overflow.\nYou can use the function lua_checkstack\nto grow the stack size.\n\n\n

\nWhenever Lua calls C,\nit ensures that at least LUA_MINSTACK stack positions are available.\nLUA_MINSTACK is defined as 20,\nso that usually you do not have to worry about stack space\nunless your code has loops pushing elements onto the stack.\n\n\n

\nMost query functions accept as indices any value inside the\navailable stack space, that is, indices up to the maximum stack size\nyou have set through lua_checkstack.\nSuch indices are called acceptable indices.\nMore formally, we define an acceptable index\nas follows:\n\n

\n     (index < 0 && abs(index) <= top) ||\n     (index > 0 && index <= stackspace)\n

\nNote that 0 is never an acceptable index.\n\n\n\n\n\n

3.3 - Pseudo-Indices

\n\n

\nUnless otherwise noted,\nany function that accepts valid indices can also be called with\npseudo-indices,\nwhich represent some Lua values that are accessible to C code\nbut which are not in the stack.\nPseudo-indices are used to access the thread environment,\nthe function environment,\nthe registry,\nand the upvalues of a C function (see §3.4).\n\n\n

\nThe thread environment (where global variables live) is\nalways at pseudo-index LUA_GLOBALSINDEX.\nThe environment of the running C function is always\nat pseudo-index LUA_ENVIRONINDEX.\n\n\n

\nTo access and change the value of global variables,\nyou can use regular table operations over an environment table.\nFor instance, to access the value of a global variable, do\n\n

\n     lua_getfield(L, LUA_GLOBALSINDEX, varname);\n
\n\n\n\n\n

3.4 - C Closures

\n\n

\nWhen a C function is created,\nit is possible to associate some values with it,\nthus creating a C closure;\nthese values are called upvalues and are\naccessible to the function whenever it is called\n(see lua_pushcclosure).\n\n\n

\nWhenever a C function is called,\nits upvalues are located at specific pseudo-indices.\nThese pseudo-indices are produced by the macro\nlua_upvalueindex.\nThe first value associated with a function is at position\nlua_upvalueindex(1), and so on.\nAny access to lua_upvalueindex(n),\nwhere n is greater than the number of upvalues of the\ncurrent function (but not greater than 256),\nproduces an acceptable (but invalid) index.\n\n\n\n\n\n

3.5 - Registry

\n\n

\nLua provides a registry,\na pre-defined table that can be used by any C code to\nstore whatever Lua value it needs to store.\nThis table is always located at pseudo-index\nLUA_REGISTRYINDEX.\nAny C library can store data into this table,\nbut it should take care to choose keys different from those used\nby other libraries, to avoid collisions.\nTypically, you should use as key a string containing your library name\nor a light userdata with the address of a C object in your code.\n\n\n

\nThe integer keys in the registry are used by the reference mechanism,\nimplemented by the auxiliary library,\nand therefore should not be used for other purposes.\n\n\n\n\n\n

3.6 - Error Handling in C

\n\n

\nInternally, Lua uses the C longjmp facility to handle errors.\n(You can also choose to use exceptions if you use C++;\nsee file luaconf.h.)\nWhen Lua faces any error\n(such as memory allocation errors, type errors, syntax errors,\nand runtime errors)\nit raises an error;\nthat is, it does a long jump.\nA protected environment uses setjmp\nto set a recover point;\nany error jumps to the most recent active recover point.\n\n\n

\nMost functions in the API can throw an error,\nfor instance due to a memory allocation error.\nThe documentation for each function indicates whether\nit can throw errors.\n\n\n

\nInside a C function you can throw an error by calling lua_error.\n\n\n\n\n\n

3.7 - Functions and Types

\n\n

\nHere we list all functions and types from the C API in\nalphabetical order.\nEach function has an indicator like this:\n[-o, +p, x]\n\n\n

\nThe first field, o,\nis how many elements the function pops from the stack.\nThe second field, p,\nis how many elements the function pushes onto the stack.\n(Any function always pushes its results after popping its arguments.)\nA field in the form x|y means the function can push (or pop)\nx or y elements,\ndepending on the situation;\nan interrogation mark '?' means that\nwe cannot know how many elements the function pops/pushes\nby looking only at its arguments\n(e.g., they may depend on what is on the stack).\nThe third field, x,\ntells whether the function may throw errors:\n'-' means the function never throws any error;\n'm' means the function may throw an error\nonly due to not enough memory;\n'e' means the function may throw other kinds of errors;\n'v' means the function may throw an error on purpose.\n\n\n\n

lua_Alloc

\n
typedef void * (*lua_Alloc) (void *ud,\n                             void *ptr,\n                             size_t osize,\n                             size_t nsize);
\n\n

\nThe type of the memory-allocation function used by Lua states.\nThe allocator function must provide a\nfunctionality similar to realloc,\nbut not exactly the same.\nIts arguments are\nud, an opaque pointer passed to lua_newstate;\nptr, a pointer to the block being allocated/reallocated/freed;\nosize, the original size of the block;\nnsize, the new size of the block.\nptr is NULL if and only if osize is zero.\nWhen nsize is zero, the allocator must return NULL;\nif osize is not zero,\nit should free the block pointed to by ptr.\nWhen nsize is not zero, the allocator returns NULL\nif and only if it cannot fill the request.\nWhen nsize is not zero and osize is zero,\nthe allocator should behave like malloc.\nWhen nsize and osize are not zero,\nthe allocator behaves like realloc.\nLua assumes that the allocator never fails when\nosize >= nsize.\n\n\n

\nHere is a simple implementation for the allocator function.\nIt is used in the auxiliary library by luaL_newstate.\n\n

\n     static void *l_alloc (void *ud, void *ptr, size_t osize,\n                                                size_t nsize) {\n       (void)ud;  (void)osize;  /* not used */\n       if (nsize == 0) {\n         free(ptr);\n         return NULL;\n       }\n       else\n         return realloc(ptr, nsize);\n     }\n

\nThis code assumes\nthat free(NULL) has no effect and that\nrealloc(NULL, size) is equivalent to malloc(size).\nANSI C ensures both behaviors.\n\n\n\n\n\n

lua_atpanic

\n[-0, +0, -]\n

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
\n\n

\nSets a new panic function and returns the old one.\n\n\n

\nIf an error happens outside any protected environment,\nLua calls a panic function\nand then calls exit(EXIT_FAILURE),\nthus exiting the host application.\nYour panic function can avoid this exit by\nnever returning (e.g., doing a long jump).\n\n\n

\nThe panic function can access the error message at the top of the stack.\n\n\n\n\n\n

lua_call

\n[-(nargs + 1), +nresults, e]\n

void lua_call (lua_State *L, int nargs, int nresults);
\n\n

\nCalls a function.\n\n\n

\nTo call a function you must use the following protocol:\nfirst, the function to be called is pushed onto the stack;\nthen, the arguments to the function are pushed\nin direct order;\nthat is, the first argument is pushed first.\nFinally you call lua_call;\nnargs is the number of arguments that you pushed onto the stack.\nAll arguments and the function value are popped from the stack\nwhen the function is called.\nThe function results are pushed onto the stack when the function returns.\nThe number of results is adjusted to nresults,\nunless nresults is LUA_MULTRET.\nIn this case, all results from the function are pushed.\nLua takes care that the returned values fit into the stack space.\nThe function results are pushed onto the stack in direct order\n(the first result is pushed first),\nso that after the call the last result is on the top of the stack.\n\n\n

\nAny error inside the called function is propagated upwards\n(with a longjmp).\n\n\n

\nThe following example shows how the host program can do the\nequivalent to this Lua code:\n\n

\n     a = f(\"how\", t.x, 14)\n

\nHere it is in C:\n\n

\n     lua_getfield(L, LUA_GLOBALSINDEX, \"f\"); /* function to be called */\n     lua_pushstring(L, \"how\");                        /* 1st argument */\n     lua_getfield(L, LUA_GLOBALSINDEX, \"t\");   /* table to be indexed */\n     lua_getfield(L, -1, \"x\");        /* push result of t.x (2nd arg) */\n     lua_remove(L, -2);                  /* remove 't' from the stack */\n     lua_pushinteger(L, 14);                          /* 3rd argument */\n     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */\n     lua_setfield(L, LUA_GLOBALSINDEX, \"a\");        /* set global 'a' */\n

\nNote that the code above is \"balanced\":\nat its end, the stack is back to its original configuration.\nThis is considered good programming practice.\n\n\n\n\n\n

lua_CFunction

\n
typedef int (*lua_CFunction) (lua_State *L);
\n\n

\nType for C functions.\n\n\n

\nIn order to communicate properly with Lua,\na C function must use the following protocol,\nwhich defines the way parameters and results are passed:\na C function receives its arguments from Lua in its stack\nin direct order (the first argument is pushed first).\nSo, when the function starts,\nlua_gettop(L) returns the number of arguments received by the function.\nThe first argument (if any) is at index 1\nand its last argument is at index lua_gettop(L).\nTo return values to Lua, a C function just pushes them onto the stack,\nin direct order (the first result is pushed first),\nand returns the number of results.\nAny other value in the stack below the results will be properly\ndiscarded by Lua.\nLike a Lua function, a C function called by Lua can also return\nmany results.\n\n\n

\nAs an example, the following function receives a variable number\nof numerical arguments and returns their average and sum:\n\n

\n     static int foo (lua_State *L) {\n       int n = lua_gettop(L);    /* number of arguments */\n       lua_Number sum = 0;\n       int i;\n       for (i = 1; i <= n; i++) {\n         if (!lua_isnumber(L, i)) {\n           lua_pushstring(L, \"incorrect argument\");\n           lua_error(L);\n         }\n         sum += lua_tonumber(L, i);\n       }\n       lua_pushnumber(L, sum/n);        /* first result */\n       lua_pushnumber(L, sum);         /* second result */\n       return 2;                   /* number of results */\n     }\n
\n\n\n\n\n

lua_checkstack

\n[-0, +0, m]\n

int lua_checkstack (lua_State *L, int extra);
\n\n

\nEnsures that there are at least extra free stack slots in the stack.\nIt returns false if it cannot grow the stack to that size.\nThis function never shrinks the stack;\nif the stack is already larger than the new size,\nit is left unchanged.\n\n\n\n\n\n

lua_close

\n[-0, +0, -]\n

void lua_close (lua_State *L);
\n\n

\nDestroys all objects in the given Lua state\n(calling the corresponding garbage-collection metamethods, if any)\nand frees all dynamic memory used by this state.\nOn several platforms, you may not need to call this function,\nbecause all resources are naturally released when the host program ends.\nOn the other hand, long-running programs,\nsuch as a daemon or a web server,\nmight need to release states as soon as they are not needed,\nto avoid growing too large.\n\n\n\n\n\n

lua_concat

\n[-n, +1, e]\n

void lua_concat (lua_State *L, int n);
\n\n

\nConcatenates the n values at the top of the stack,\npops them, and leaves the result at the top.\nIf n is 1, the result is the single value on the stack\n(that is, the function does nothing);\nif n is 0, the result is the empty string.\nConcatenation is performed following the usual semantics of Lua\n(see §2.5.4).\n\n\n\n\n\n

lua_cpcall

\n[-0, +(0|1), -]\n

int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
\n\n

\nCalls the C function func in protected mode.\nfunc starts with only one element in its stack,\na light userdata containing ud.\nIn case of errors,\nlua_cpcall returns the same error codes as lua_pcall,\nplus the error object on the top of the stack;\notherwise, it returns zero, and does not change the stack.\nAll values returned by func are discarded.\n\n\n\n\n\n

lua_createtable

\n[-0, +1, m]\n

void lua_createtable (lua_State *L, int narr, int nrec);
\n\n

\nCreates a new empty table and pushes it onto the stack.\nThe new table has space pre-allocated\nfor narr array elements and nrec non-array elements.\nThis pre-allocation is useful when you know exactly how many elements\nthe table will have.\nOtherwise you can use the function lua_newtable.\n\n\n\n\n\n

lua_dump

\n[-0, +0, m]\n

int lua_dump (lua_State *L, lua_Writer writer, void *data);
\n\n

\nDumps a function as a binary chunk.\nReceives a Lua function on the top of the stack\nand produces a binary chunk that,\nif loaded again,\nresults in a function equivalent to the one dumped.\nAs it produces parts of the chunk,\nlua_dump calls function writer (see lua_Writer)\nwith the given data\nto write them.\n\n\n

\nThe value returned is the error code returned by the last\ncall to the writer;\n0 means no errors.\n\n\n

\nThis function does not pop the Lua function from the stack.\n\n\n\n\n\n

lua_equal

\n[-0, +0, e]\n

int lua_equal (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the two values in acceptable indices index1 and\nindex2 are equal,\nfollowing the semantics of the Lua == operator\n(that is, may call metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices is non valid.\n\n\n\n\n\n

lua_error

\n[-1, +0, v]\n

int lua_error (lua_State *L);
\n\n

\nGenerates a Lua error.\nThe error message (which can actually be a Lua value of any type)\nmust be on the stack top.\nThis function does a long jump,\nand therefore never returns.\n(see luaL_error).\n\n\n\n\n\n

lua_gc

\n[-0, +0, e]\n

int lua_gc (lua_State *L, int what, int data);
\n\n

\nControls the garbage collector.\n\n\n

\nThis function performs several tasks,\naccording to the value of the parameter what:\n\n

    \n\n
  • LUA_GCSTOP:\nstops the garbage collector.\n
    • \n\n
  • LUA_GCRESTART:\nrestarts the garbage collector.\n
    • \n\n
  • LUA_GCCOLLECT:\nperforms a full garbage-collection cycle.\n
    • \n\n
  • LUA_GCCOUNT:\nreturns the current amount of memory (in Kbytes) in use by Lua.\n
    • \n\n
  • LUA_GCCOUNTB:\nreturns the remainder of dividing the current amount of bytes of\nmemory in use by Lua by 1024.\n
    • \n\n
  • LUA_GCSTEP:\nperforms an incremental step of garbage collection.\nThe step \"size\" is controlled by data\n(larger values mean more steps) in a non-specified way.\nIf you want to control the step size\nyou must experimentally tune the value of data.\nThe function returns 1 if the step finished a\ngarbage-collection cycle.\n
    • \n\n
  • LUA_GCSETPAUSE:\nsets data as the new value\nfor the pause of the collector (see §2.10).\nThe function returns the previous value of the pause.\n
    • \n\n
  • LUA_GCSETSTEPMUL:\nsets data as the new value for the step multiplier of\nthe collector (see §2.10).\nThe function returns the previous value of the step multiplier.\n
    • \n\n
\n\n\n\n\n

lua_getallocf

\n[-0, +0, -]\n

lua_Alloc lua_getallocf (lua_State *L, void **ud);
\n\n

\nReturns the memory-allocation function of a given state.\nIf ud is not NULL, Lua stores in *ud the\nopaque pointer passed to lua_newstate.\n\n\n\n\n\n

lua_getfenv

\n[-0, +1, -]\n

void lua_getfenv (lua_State *L, int index);
\n\n

\nPushes onto the stack the environment table of\nthe value at the given index.\n\n\n\n\n\n

lua_getfield

\n[-0, +1, e]\n

void lua_getfield (lua_State *L, int index, const char *k);
\n\n

\nPushes onto the stack the value t[k],\nwhere t is the value at the given valid index.\nAs in Lua, this function may trigger a metamethod\nfor the \"index\" event (see §2.8).\n\n\n\n\n\n

lua_getglobal

\n[-0, +1, e]\n

void lua_getglobal (lua_State *L, const char *name);
\n\n

\nPushes onto the stack the value of the global name.\nIt is defined as a macro:\n\n

\n     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)\n
\n\n\n\n\n

lua_getmetatable

\n[-0, +(0|1), -]\n

int lua_getmetatable (lua_State *L, int index);
\n\n

\nPushes onto the stack the metatable of the value at the given\nacceptable index.\nIf the index is not valid,\nor if the value does not have a metatable,\nthe function returns 0 and pushes nothing on the stack.\n\n\n\n\n\n

lua_gettable

\n[-1, +1, e]\n

void lua_gettable (lua_State *L, int index);
\n\n

\nPushes onto the stack the value t[k],\nwhere t is the value at the given valid index\nand k is the value at the top of the stack.\n\n\n

\nThis function pops the key from the stack\n(putting the resulting value in its place).\nAs in Lua, this function may trigger a metamethod\nfor the \"index\" event (see §2.8).\n\n\n\n\n\n

lua_gettop

\n[-0, +0, -]\n

int lua_gettop (lua_State *L);
\n\n

\nReturns the index of the top element in the stack.\nBecause indices start at 1,\nthis result is equal to the number of elements in the stack\n(and so 0 means an empty stack).\n\n\n\n\n\n

lua_insert

\n[-1, +1, -]\n

void lua_insert (lua_State *L, int index);
\n\n

\nMoves the top element into the given valid index,\nshifting up the elements above this index to open space.\nCannot be called with a pseudo-index,\nbecause a pseudo-index is not an actual stack position.\n\n\n\n\n\n

lua_Integer

\n
typedef ptrdiff_t lua_Integer;
\n\n

\nThe type used by the Lua API to represent integral values.\n\n\n

\nBy default it is a ptrdiff_t,\nwhich is usually the largest signed integral type the machine handles\n\"comfortably\".\n\n\n\n\n\n

lua_isboolean

\n[-0, +0, -]\n

int lua_isboolean (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index has type boolean,\nand 0 otherwise.\n\n\n\n\n\n

lua_iscfunction

\n[-0, +0, -]\n

int lua_iscfunction (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a C function,\nand 0 otherwise.\n\n\n\n\n\n

lua_isfunction

\n[-0, +0, -]\n

int lua_isfunction (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a function\n(either C or Lua), and 0 otherwise.\n\n\n\n\n\n

lua_islightuserdata

\n[-0, +0, -]\n

int lua_islightuserdata (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a light userdata,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnil

\n[-0, +0, -]\n

int lua_isnil (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is nil,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnone

\n[-0, +0, -]\n

int lua_isnone (lua_State *L, int index);
\n\n

\nReturns 1 if the given acceptable index is not valid\n(that is, it refers to an element outside the current stack),\nand 0 otherwise.\n\n\n\n\n\n

lua_isnoneornil

\n[-0, +0, -]\n

int lua_isnoneornil (lua_State *L, int index);
\n\n

\nReturns 1 if the given acceptable index is not valid\n(that is, it refers to an element outside the current stack)\nor if the value at this index is nil,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnumber

\n[-0, +0, -]\n

int lua_isnumber (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a number\nor a string convertible to a number,\nand 0 otherwise.\n\n\n\n\n\n

lua_isstring

\n[-0, +0, -]\n

int lua_isstring (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a string\nor a number (which is always convertible to a string),\nand 0 otherwise.\n\n\n\n\n\n

lua_istable

\n[-0, +0, -]\n

int lua_istable (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a table,\nand 0 otherwise.\n\n\n\n\n\n

lua_isthread

\n[-0, +0, -]\n

int lua_isthread (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a thread,\nand 0 otherwise.\n\n\n\n\n\n

lua_isuserdata

\n[-0, +0, -]\n

int lua_isuserdata (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a userdata\n(either full or light), and 0 otherwise.\n\n\n\n\n\n

lua_lessthan

\n[-0, +0, e]\n

int lua_lessthan (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the value at acceptable index index1 is smaller\nthan the value at acceptable index index2,\nfollowing the semantics of the Lua < operator\n(that is, may call metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices is non valid.\n\n\n\n\n\n

lua_load

\n[-0, +1, -]\n

int lua_load (lua_State *L,\n              lua_Reader reader,\n              void *data,\n              const char *chunkname);
\n\n

\nLoads a Lua chunk.\nIf there are no errors,\nlua_load pushes the compiled chunk as a Lua\nfunction on top of the stack.\nOtherwise, it pushes an error message.\nThe return values of lua_load are:\n\n

    \n\n
  • 0: no errors;
    • \n\n
  • LUA_ERRSYNTAX:\nsyntax error during pre-compilation;
    • \n\n
  • LUA_ERRMEM:\nmemory allocation error.
    • \n\n
\n\n

\nThis function only loads a chunk;\nit does not run it.\n\n\n

\nlua_load automatically detects whether the chunk is text or binary,\nand loads it accordingly (see program luac).\n\n\n

\nThe lua_load function uses a user-supplied reader function\nto read the chunk (see lua_Reader).\nThe data argument is an opaque value passed to the reader function.\n\n\n

\nThe chunkname argument gives a name to the chunk,\nwhich is used for error messages and in debug information (see §3.8).\n\n\n\n\n\n

lua_newstate

\n[-0, +0, -]\n

lua_State *lua_newstate (lua_Alloc f, void *ud);
\n\n

\nCreates a new, independent state.\nReturns NULL if cannot create the state\n(due to lack of memory).\nThe argument f is the allocator function;\nLua does all memory allocation for this state through this function.\nThe second argument, ud, is an opaque pointer that Lua\nsimply passes to the allocator in every call.\n\n\n\n\n\n

lua_newtable

\n[-0, +1, m]\n

void lua_newtable (lua_State *L);
\n\n

\nCreates a new empty table and pushes it onto the stack.\nIt is equivalent to lua_createtable(L, 0, 0).\n\n\n\n\n\n

lua_newthread

\n[-0, +1, m]\n

lua_State *lua_newthread (lua_State *L);
\n\n

\nCreates a new thread, pushes it on the stack,\nand returns a pointer to a lua_State that represents this new thread.\nThe new state returned by this function shares with the original state\nall global objects (such as tables),\nbut has an independent execution stack.\n\n\n

\nThere is no explicit function to close or to destroy a thread.\nThreads are subject to garbage collection,\nlike any Lua object.\n\n\n\n\n\n

lua_newuserdata

\n[-0, +1, m]\n

void *lua_newuserdata (lua_State *L, size_t size);
\n\n

\nThis function allocates a new block of memory with the given size,\npushes onto the stack a new full userdata with the block address,\nand returns this address.\n\n\n

\nUserdata represent C values in Lua.\nA full userdata represents a block of memory.\nIt is an object (like a table):\nyou must create it, it can have its own metatable,\nand you can detect when it is being collected.\nA full userdata is only equal to itself (under raw equality).\n\n\n

\nWhen Lua collects a full userdata with a gc metamethod,\nLua calls the metamethod and marks the userdata as finalized.\nWhen this userdata is collected again then\nLua frees its corresponding memory.\n\n\n\n\n\n

lua_next

\n[-1, +(2|0), e]\n

int lua_next (lua_State *L, int index);
\n\n

\nPops a key from the stack,\nand pushes a key-value pair from the table at the given index\n(the \"next\" pair after the given key).\nIf there are no more elements in the table,\nthen lua_next returns 0 (and pushes nothing).\n\n\n

\nA typical traversal looks like this:\n\n

\n     /* table is in the stack at index 't' */\n     lua_pushnil(L);  /* first key */\n     while (lua_next(L, t) != 0) {\n       /* uses 'key' (at index -2) and 'value' (at index -1) */\n       printf(\"%s - %s\\n\",\n              lua_typename(L, lua_type(L, -2)),\n              lua_typename(L, lua_type(L, -1)));\n       /* removes 'value'; keeps 'key' for next iteration */\n       lua_pop(L, 1);\n     }\n
\n\n

\nWhile traversing a table,\ndo not call lua_tolstring directly on a key,\nunless you know that the key is actually a string.\nRecall that lua_tolstring changes\nthe value at the given index;\nthis confuses the next call to lua_next.\n\n\n\n\n\n

lua_Number

\n
typedef double lua_Number;
\n\n

\nThe type of numbers in Lua.\nBy default, it is double, but that can be changed in luaconf.h.\n\n\n

\nThrough the configuration file you can change\nLua to operate with another type for numbers (e.g., float or long).\n\n\n\n\n\n

lua_objlen

\n[-0, +0, -]\n

size_t lua_objlen (lua_State *L, int index);
\n\n

\nReturns the \"length\" of the value at the given acceptable index:\nfor strings, this is the string length;\nfor tables, this is the result of the length operator ('#');\nfor userdata, this is the size of the block of memory allocated\nfor the userdata;\nfor other values, it is 0.\n\n\n\n\n\n

lua_pcall

\n[-(nargs + 1), +(nresults|1), -]\n

int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
\n\n

\nCalls a function in protected mode.\n\n\n

\nBoth nargs and nresults have the same meaning as\nin lua_call.\nIf there are no errors during the call,\nlua_pcall behaves exactly like lua_call.\nHowever, if there is any error,\nlua_pcall catches it,\npushes a single value on the stack (the error message),\nand returns an error code.\nLike lua_call,\nlua_pcall always removes the function\nand its arguments from the stack.\n\n\n

\nIf errfunc is 0,\nthen the error message returned on the stack\nis exactly the original error message.\nOtherwise, errfunc is the stack index of an\nerror handler function.\n(In the current implementation, this index cannot be a pseudo-index.)\nIn case of runtime errors,\nthis function will be called with the error message\nand its return value will be the message returned on the stack by lua_pcall.\n\n\n

\nTypically, the error handler function is used to add more debug\ninformation to the error message, such as a stack traceback.\nSuch information cannot be gathered after the return of lua_pcall,\nsince by then the stack has unwound.\n\n\n

\nThe lua_pcall function returns 0 in case of success\nor one of the following error codes\n(defined in lua.h):\n\n

    \n\n
  • LUA_ERRRUN:\na runtime error.\n
    • \n\n
  • LUA_ERRMEM:\nmemory allocation error.\nFor such errors, Lua does not call the error handler function.\n
    • \n\n
  • LUA_ERRERR:\nerror while running the error handler function.\n
    • \n\n
\n\n\n\n\n

lua_pop

\n[-n, +0, -]\n

void lua_pop (lua_State *L, int n);
\n\n

\nPops n elements from the stack.\n\n\n\n\n\n

lua_pushboolean

\n[-0, +1, -]\n

void lua_pushboolean (lua_State *L, int b);
\n\n

\nPushes a boolean value with value b onto the stack.\n\n\n\n\n\n

lua_pushcclosure

\n[-n, +1, m]\n

void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
\n\n

\nPushes a new C closure onto the stack.\n\n\n

\nWhen a C function is created,\nit is possible to associate some values with it,\nthus creating a C closure (see §3.4);\nthese values are then accessible to the function whenever it is called.\nTo associate values with a C function,\nfirst these values should be pushed onto the stack\n(when there are multiple values, the first value is pushed first).\nThen lua_pushcclosure\nis called to create and push the C function onto the stack,\nwith the argument n telling how many values should be\nassociated with the function.\nlua_pushcclosure also pops these values from the stack.\n\n\n

\nThe maximum value for n is 255.\n\n\n\n\n\n

lua_pushcfunction

\n[-0, +1, m]\n

void lua_pushcfunction (lua_State *L, lua_CFunction f);
\n\n

\nPushes a C function onto the stack.\nThis function receives a pointer to a C function\nand pushes onto the stack a Lua value of type function that,\nwhen called, invokes the corresponding C function.\n\n\n

\nAny function to be registered in Lua must\nfollow the correct protocol to receive its parameters\nand return its results (see lua_CFunction).\n\n\n

\nlua_pushcfunction is defined as a macro:\n\n

\n     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)\n
\n\n\n\n\n

lua_pushfstring

\n[-0, +1, m]\n

const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
\n\n

\nPushes onto the stack a formatted string\nand returns a pointer to this string.\nIt is similar to the C function sprintf,\nbut has some important differences:\n\n

    \n\n
  • \nYou do not have to allocate space for the result:\nthe result is a Lua string and Lua takes care of memory allocation\n(and deallocation, through garbage collection).\n
    • \n\n
  • \nThe conversion specifiers are quite restricted.\nThere are no flags, widths, or precisions.\nThe conversion specifiers can only be\n'%%' (inserts a '%' in the string),\n'%s' (inserts a zero-terminated string, with no size restrictions),\n'%f' (inserts a lua_Number),\n'%p' (inserts a pointer as a hexadecimal numeral),\n'%d' (inserts an int), and\n'%c' (inserts an int as a character).\n
    • \n\n
\n\n\n\n\n

lua_pushinteger

\n[-0, +1, -]\n

void lua_pushinteger (lua_State *L, lua_Integer n);
\n\n

\nPushes a number with value n onto the stack.\n\n\n\n\n\n

lua_pushlightuserdata

\n[-0, +1, -]\n

void lua_pushlightuserdata (lua_State *L, void *p);
\n\n

\nPushes a light userdata onto the stack.\n\n\n

\nUserdata represent C values in Lua.\nA light userdata represents a pointer.\nIt is a value (like a number):\nyou do not create it, it has no individual metatable,\nand it is not collected (as it was never created).\nA light userdata is equal to \"any\"\nlight userdata with the same C address.\n\n\n\n\n\n

lua_pushliteral

\n[-0, +1, m]\n

void lua_pushliteral (lua_State *L, const char *s);
\n\n

\nThis macro is equivalent to lua_pushlstring,\nbut can be used only when s is a literal string.\nIn these cases, it automatically provides the string length.\n\n\n\n\n\n

lua_pushlstring

\n[-0, +1, m]\n

void lua_pushlstring (lua_State *L, const char *s, size_t len);
\n\n

\nPushes the string pointed to by s with size len\nonto the stack.\nLua makes (or reuses) an internal copy of the given string,\nso the memory at s can be freed or reused immediately after\nthe function returns.\nThe string can contain embedded zeros.\n\n\n\n\n\n

lua_pushnil

\n[-0, +1, -]\n

void lua_pushnil (lua_State *L);
\n\n

\nPushes a nil value onto the stack.\n\n\n\n\n\n

lua_pushnumber

\n[-0, +1, -]\n

void lua_pushnumber (lua_State *L, lua_Number n);
\n\n

\nPushes a number with value n onto the stack.\n\n\n\n\n\n

lua_pushstring

\n[-0, +1, m]\n

void lua_pushstring (lua_State *L, const char *s);
\n\n

\nPushes the zero-terminated string pointed to by s\nonto the stack.\nLua makes (or reuses) an internal copy of the given string,\nso the memory at s can be freed or reused immediately after\nthe function returns.\nThe string cannot contain embedded zeros;\nit is assumed to end at the first zero.\n\n\n\n\n\n

lua_pushthread

\n[-0, +1, -]\n

int lua_pushthread (lua_State *L);
\n\n

\nPushes the thread represented by L onto the stack.\nReturns 1 if this thread is the main thread of its state.\n\n\n\n\n\n

lua_pushvalue

\n[-0, +1, -]\n

void lua_pushvalue (lua_State *L, int index);
\n\n

\nPushes a copy of the element at the given valid index\nonto the stack.\n\n\n\n\n\n

lua_pushvfstring

\n[-0, +1, m]\n

const char *lua_pushvfstring (lua_State *L,\n                              const char *fmt,\n                              va_list argp);
\n\n

\nEquivalent to lua_pushfstring, except that it receives a va_list\ninstead of a variable number of arguments.\n\n\n\n\n\n

lua_rawequal

\n[-0, +0, -]\n

int lua_rawequal (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the two values in acceptable indices index1 and\nindex2 are primitively equal\n(that is, without calling metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices are non valid.\n\n\n\n\n\n

lua_rawget

\n[-1, +1, -]\n

void lua_rawget (lua_State *L, int index);
\n\n

\nSimilar to lua_gettable, but does a raw access\n(i.e., without metamethods).\n\n\n\n\n\n

lua_rawgeti

\n[-0, +1, -]\n

void lua_rawgeti (lua_State *L, int index, int n);
\n\n

\nPushes onto the stack the value t[n],\nwhere t is the value at the given valid index.\nThe access is raw;\nthat is, it does not invoke metamethods.\n\n\n\n\n\n

lua_rawset

\n[-2, +0, m]\n

void lua_rawset (lua_State *L, int index);
\n\n

\nSimilar to lua_settable, but does a raw assignment\n(i.e., without metamethods).\n\n\n\n\n\n

lua_rawseti

\n[-1, +0, m]\n

void lua_rawseti (lua_State *L, int index, int n);
\n\n

\nDoes the equivalent of t[n] = v,\nwhere t is the value at the given valid index\nand v is the value at the top of the stack.\n\n\n

\nThis function pops the value from the stack.\nThe assignment is raw;\nthat is, it does not invoke metamethods.\n\n\n\n\n\n

lua_Reader

\n
typedef const char * (*lua_Reader) (lua_State *L,\n                                    void *data,\n                                    size_t *size);
\n\n

\nThe reader function used by lua_load.\nEvery time it needs another piece of the chunk,\nlua_load calls the reader,\npassing along its data parameter.\nThe reader must return a pointer to a block of memory\nwith a new piece of the chunk\nand set size to the block size.\nThe block must exist until the reader function is called again.\nTo signal the end of the chunk,\nthe reader must return NULL or set size to zero.\nThe reader function may return pieces of any size greater than zero.\n\n\n\n\n\n

lua_register

\n[-0, +0, e]\n

void lua_register (lua_State *L,\n                   const char *name,\n                   lua_CFunction f);
\n\n

\nSets the C function f as the new value of global name.\nIt is defined as a macro:\n\n

\n     #define lua_register(L,n,f) \\\n            (lua_pushcfunction(L, f), lua_setglobal(L, n))\n
\n\n\n\n\n

lua_remove

\n[-1, +0, -]\n

void lua_remove (lua_State *L, int index);
\n\n

\nRemoves the element at the given valid index,\nshifting down the elements above this index to fill the gap.\nCannot be called with a pseudo-index,\nbecause a pseudo-index is not an actual stack position.\n\n\n\n\n\n

lua_replace

\n[-1, +0, -]\n

void lua_replace (lua_State *L, int index);
\n\n

\nMoves the top element into the given position (and pops it),\nwithout shifting any element\n(therefore replacing the value at the given position).\n\n\n\n\n\n

lua_resume

\n[-?, +?, -]\n

int lua_resume (lua_State *L, int narg);
\n\n

\nStarts and resumes a coroutine in a given thread.\n\n\n

\nTo start a coroutine, you first create a new thread\n(see lua_newthread);\nthen you push onto its stack the main function plus any arguments;\nthen you call lua_resume,\nwith narg being the number of arguments.\nThis call returns when the coroutine suspends or finishes its execution.\nWhen it returns, the stack contains all values passed to lua_yield,\nor all values returned by the body function.\nlua_resume returns\nLUA_YIELD if the coroutine yields,\n0 if the coroutine finishes its execution\nwithout errors,\nor an error code in case of errors (see lua_pcall).\nIn case of errors,\nthe stack is not unwound,\nso you can use the debug API over it.\nThe error message is on the top of the stack.\nTo restart a coroutine, you put on its stack only the values to\nbe passed as results from yield,\nand then call lua_resume.\n\n\n\n\n\n

lua_setallocf

\n[-0, +0, -]\n

void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
\n\n

\nChanges the allocator function of a given state to f\nwith user data ud.\n\n\n\n\n\n

lua_setfenv

\n[-1, +0, -]\n

int lua_setfenv (lua_State *L, int index);
\n\n

\nPops a table from the stack and sets it as\nthe new environment for the value at the given index.\nIf the value at the given index is\nneither a function nor a thread nor a userdata,\nlua_setfenv returns 0.\nOtherwise it returns 1.\n\n\n\n\n\n

lua_setfield

\n[-1, +0, e]\n

void lua_setfield (lua_State *L, int index, const char *k);
\n\n

\nDoes the equivalent to t[k] = v,\nwhere t is the value at the given valid index\nand v is the value at the top of the stack.\n\n\n

\nThis function pops the value from the stack.\nAs in Lua, this function may trigger a metamethod\nfor the \"newindex\" event (see §2.8).\n\n\n\n\n\n

lua_setglobal

\n[-1, +0, e]\n

void lua_setglobal (lua_State *L, const char *name);
\n\n

\nPops a value from the stack and\nsets it as the new value of global name.\nIt is defined as a macro:\n\n

\n     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)\n
\n\n\n\n\n

lua_setmetatable

\n[-1, +0, -]\n

int lua_setmetatable (lua_State *L, int index);
\n\n

\nPops a table from the stack and\nsets it as the new metatable for the value at the given\nacceptable index.\n\n\n\n\n\n

lua_settable

\n[-2, +0, e]\n

void lua_settable (lua_State *L, int index);
\n\n

\nDoes the equivalent to t[k] = v,\nwhere t is the value at the given valid index,\nv is the value at the top of the stack,\nand k is the value just below the top.\n\n\n

\nThis function pops both the key and the value from the stack.\nAs in Lua, this function may trigger a metamethod\nfor the \"newindex\" event (see §2.8).\n\n\n\n\n\n

lua_settop

\n[-?, +?, -]\n

void lua_settop (lua_State *L, int index);
\n\n

\nAccepts any acceptable index, or 0,\nand sets the stack top to this index.\nIf the new top is larger than the old one,\nthen the new elements are filled with nil.\nIf index is 0, then all stack elements are removed.\n\n\n\n\n\n

lua_State

\n
typedef struct lua_State lua_State;
\n\n

\nOpaque structure that keeps the whole state of a Lua interpreter.\nThe Lua library is fully reentrant:\nit has no global variables.\nAll information about a state is kept in this structure.\n\n\n

\nA pointer to this state must be passed as the first argument to\nevery function in the library, except to lua_newstate,\nwhich creates a Lua state from scratch.\n\n\n\n\n\n

lua_status

\n[-0, +0, -]\n

int lua_status (lua_State *L);
\n\n

\nReturns the status of the thread L.\n\n\n

\nThe status can be 0 for a normal thread,\nan error code if the thread finished its execution with an error,\nor LUA_YIELD if the thread is suspended.\n\n\n\n\n\n

lua_toboolean

\n[-0, +0, -]\n

int lua_toboolean (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index to a C boolean\nvalue (0 or 1).\nLike all tests in Lua,\nlua_toboolean returns 1 for any Lua value\ndifferent from false and nil;\notherwise it returns 0.\nIt also returns 0 when called with a non-valid index.\n(If you want to accept only actual boolean values,\nuse lua_isboolean to test the value's type.)\n\n\n\n\n\n

lua_tocfunction

\n[-0, +0, -]\n

lua_CFunction lua_tocfunction (lua_State *L, int index);
\n\n

\nConverts a value at the given acceptable index to a C function.\nThat value must be a C function;\notherwise, returns NULL.\n\n\n\n\n\n

lua_tointeger

\n[-0, +0, -]\n

lua_Integer lua_tointeger (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index\nto the signed integral type lua_Integer.\nThe Lua value must be a number or a string convertible to a number\n(see §2.2.1);\notherwise, lua_tointeger returns 0.\n\n\n

\nIf the number is not an integer,\nit is truncated in some non-specified way.\n\n\n\n\n\n

lua_tolstring

\n[-0, +0, m]\n

const char *lua_tolstring (lua_State *L, int index, size_t *len);
\n\n

\nConverts the Lua value at the given acceptable index to a C string.\nIf len is not NULL,\nit also sets *len with the string length.\nThe Lua value must be a string or a number;\notherwise, the function returns NULL.\nIf the value is a number,\nthen lua_tolstring also\nchanges the actual value in the stack to a string.\n(This change confuses lua_next\nwhen lua_tolstring is applied to keys during a table traversal.)\n\n\n

\nlua_tolstring returns a fully aligned pointer\nto a string inside the Lua state.\nThis string always has a zero ('\\0')\nafter its last character (as in C),\nbut can contain other zeros in its body.\nBecause Lua has garbage collection,\nthere is no guarantee that the pointer returned by lua_tolstring\nwill be valid after the corresponding value is removed from the stack.\n\n\n\n\n\n

lua_tonumber

\n[-0, +0, -]\n

lua_Number lua_tonumber (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index\nto the C type lua_Number (see lua_Number).\nThe Lua value must be a number or a string convertible to a number\n(see §2.2.1);\notherwise, lua_tonumber returns 0.\n\n\n\n\n\n

lua_topointer

\n[-0, +0, -]\n

const void *lua_topointer (lua_State *L, int index);
\n\n

\nConverts the value at the given acceptable index to a generic\nC pointer (void*).\nThe value can be a userdata, a table, a thread, or a function;\notherwise, lua_topointer returns NULL.\nDifferent objects will give different pointers.\nThere is no way to convert the pointer back to its original value.\n\n\n

\nTypically this function is used only for debug information.\n\n\n\n\n\n

lua_tostring

\n[-0, +0, m]\n

const char *lua_tostring (lua_State *L, int index);
\n\n

\nEquivalent to lua_tolstring with len equal to NULL.\n\n\n\n\n\n

lua_tothread

\n[-0, +0, -]\n

lua_State *lua_tothread (lua_State *L, int index);
\n\n

\nConverts the value at the given acceptable index to a Lua thread\n(represented as lua_State*).\nThis value must be a thread;\notherwise, the function returns NULL.\n\n\n\n\n\n

lua_touserdata

\n[-0, +0, -]\n

void *lua_touserdata (lua_State *L, int index);
\n\n

\nIf the value at the given acceptable index is a full userdata,\nreturns its block address.\nIf the value is a light userdata,\nreturns its pointer.\nOtherwise, returns NULL.\n\n\n\n\n\n

lua_type

\n[-0, +0, -]\n

int lua_type (lua_State *L, int index);
\n\n

\nReturns the type of the value in the given acceptable index,\nor LUA_TNONE for a non-valid index\n(that is, an index to an \"empty\" stack position).\nThe types returned by lua_type are coded by the following constants\ndefined in lua.h:\nLUA_TNIL,\nLUA_TNUMBER,\nLUA_TBOOLEAN,\nLUA_TSTRING,\nLUA_TTABLE,\nLUA_TFUNCTION,\nLUA_TUSERDATA,\nLUA_TTHREAD,\nand\nLUA_TLIGHTUSERDATA.\n\n\n\n\n\n

lua_typename

\n[-0, +0, -]\n

const char *lua_typename  (lua_State *L, int tp);
\n\n

\nReturns the name of the type encoded by the value tp,\nwhich must be one the values returned by lua_type.\n\n\n\n\n\n

lua_Writer

\n
typedef int (*lua_Writer) (lua_State *L,\n                           const void* p,\n                           size_t sz,\n                           void* ud);
\n\n

\nThe type of the writer function used by lua_dump.\nEvery time it produces another piece of chunk,\nlua_dump calls the writer,\npassing along the buffer to be written (p),\nits size (sz),\nand the data parameter supplied to lua_dump.\n\n\n

\nThe writer returns an error code:\n0 means no errors;\nany other value means an error and stops lua_dump from\ncalling the writer again.\n\n\n\n\n\n

lua_xmove

\n[-?, +?, -]\n

void lua_xmove (lua_State *from, lua_State *to, int n);
\n\n

\nExchange values between different threads of the same global state.\n\n\n

\nThis function pops n values from the stack from,\nand pushes them onto the stack to.\n\n\n\n\n\n

lua_yield

\n[-?, +?, -]\n

int lua_yield  (lua_State *L, int nresults);
\n\n

\nYields a coroutine.\n\n\n

\nThis function should only be called as the\nreturn expression of a C function, as follows:\n\n

\n     return lua_yield (L, nresults);\n

\nWhen a C function calls lua_yield in that way,\nthe running coroutine suspends its execution,\nand the call to lua_resume that started this coroutine returns.\nThe parameter nresults is the number of values from the stack\nthat are passed as results to lua_resume.\n\n\n\n\n\n\n\n

3.8 - The Debug Interface

\n\n

\nLua has no built-in debugging facilities.\nInstead, it offers a special interface\nby means of functions and hooks.\nThis interface allows the construction of different\nkinds of debuggers, profilers, and other tools\nthat need \"inside information\" from the interpreter.\n\n\n\n

lua_Debug

\n
typedef struct lua_Debug {\n  int event;\n  const char *name;           /* (n) */\n  const char *namewhat;       /* (n) */\n  const char *what;           /* (S) */\n  const char *source;         /* (S) */\n  int currentline;            /* (l) */\n  int nups;                   /* (u) number of upvalues */\n  int linedefined;            /* (S) */\n  int lastlinedefined;        /* (S) */\n  char short_src[LUA_IDSIZE]; /* (S) */\n  /* private part */\n  other fields\n} lua_Debug;
\n\n

\nA structure used to carry different pieces of\ninformation about an active function.\nlua_getstack fills only the private part\nof this structure, for later use.\nTo fill the other fields of lua_Debug with useful information,\ncall lua_getinfo.\n\n\n

\nThe fields of lua_Debug have the following meaning:\n\n

    \n\n
  • source:\nIf the function was defined in a string,\nthen source is that string.\nIf the function was defined in a file,\nthen source starts with a '@' followed by the file name.\n
    • \n\n
  • short_src:\na \"printable\" version of source, to be used in error messages.\n
    • \n\n
  • linedefined:\nthe line number where the definition of the function starts.\n
    • \n\n
  • lastlinedefined:\nthe line number where the definition of the function ends.\n
    • \n\n
  • what:\nthe string \"Lua\" if the function is a Lua function,\n\"C\" if it is a C function,\n\"main\" if it is the main part of a chunk,\nand \"tail\" if it was a function that did a tail call.\nIn the latter case,\nLua has no other information about the function.\n
    • \n\n
  • currentline:\nthe current line where the given function is executing.\nWhen no line information is available,\ncurrentline is set to -1.\n
    • \n\n
  • name:\na reasonable name for the given function.\nBecause functions in Lua are first-class values,\nthey do not have a fixed name:\nsome functions can be the value of multiple global variables,\nwhile others can be stored only in a table field.\nThe lua_getinfo function checks how the function was\ncalled to find a suitable name.\nIf it cannot find a name,\nthen name is set to NULL.\n
    • \n\n
  • namewhat:\nexplains the name field.\nThe value of namewhat can be\n\"global\", \"local\", \"method\",\n\"field\", \"upvalue\", or \"\" (the empty string),\naccording to how the function was called.\n(Lua uses the empty string when no other option seems to apply.)\n
    • \n\n
  • nups:\nthe number of upvalues of the function.\n
    • \n\n
\n\n\n\n\n

lua_gethook

\n[-0, +0, -]\n

lua_Hook lua_gethook (lua_State *L);
\n\n

\nReturns the current hook function.\n\n\n\n\n\n

lua_gethookcount

\n[-0, +0, -]\n

int lua_gethookcount (lua_State *L);
\n\n

\nReturns the current hook count.\n\n\n\n\n\n

lua_gethookmask

\n[-0, +0, -]\n

int lua_gethookmask (lua_State *L);
\n\n

\nReturns the current hook mask.\n\n\n\n\n\n

lua_getinfo

\n[-(0|1), +(0|1|2), m]\n

int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
\n\n

\nReturns information about a specific function or function invocation.\n\n\n

\nTo get information about a function invocation,\nthe parameter ar must be a valid activation record that was\nfilled by a previous call to lua_getstack or\ngiven as argument to a hook (see lua_Hook).\n\n\n

\nTo get information about a function you push it onto the stack\nand start the what string with the character '>'.\n(In that case,\nlua_getinfo pops the function in the top of the stack.)\nFor instance, to know in which line a function f was defined,\nyou can write the following code:\n\n

\n     lua_Debug ar;\n     lua_getfield(L, LUA_GLOBALSINDEX, \"f\");  /* get global 'f' */\n     lua_getinfo(L, \">S\", &ar);\n     printf(\"%d\\n\", ar.linedefined);\n
\n\n

\nEach character in the string what\nselects some fields of the structure ar to be filled or\na value to be pushed on the stack:\n\n

    \n\n
  • 'n': fills in the field name and namewhat;\n
    • \n\n
  • 'S':\nfills in the fields source, short_src,\nlinedefined, lastlinedefined, and what;\n
    • \n\n
  • 'l': fills in the field currentline;\n
    • \n\n
  • 'u': fills in the field nups;\n
    • \n\n
  • 'f':\npushes onto the stack the function that is\nrunning at the given level;\n
    • \n\n
  • 'L':\npushes onto the stack a table whose indices are the\nnumbers of the lines that are valid on the function.\n(A valid line is a line with some associated code,\nthat is, a line where you can put a break point.\nNon-valid lines include empty lines and comments.)\n
    • \n\n
\n\n

\nThis function returns 0 on error\n(for instance, an invalid option in what).\n\n\n\n\n\n

lua_getlocal

\n[-0, +(0|1), -]\n

const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);
\n\n

\nGets information about a local variable of a given activation record.\nThe parameter ar must be a valid activation record that was\nfilled by a previous call to lua_getstack or\ngiven as argument to a hook (see lua_Hook).\nThe index n selects which local variable to inspect\n(1 is the first parameter or active local variable, and so on,\nuntil the last active local variable).\nlua_getlocal pushes the variable's value onto the stack\nand returns its name.\n\n\n

\nVariable names starting with '(' (open parentheses)\nrepresent internal variables\n(loop control variables, temporaries, and C function locals).\n\n\n

\nReturns NULL (and pushes nothing)\nwhen the index is greater than\nthe number of active local variables.\n\n\n\n\n\n

lua_getstack

\n[-0, +0, -]\n

int lua_getstack (lua_State *L, int level, lua_Debug *ar);
\n\n

\nGet information about the interpreter runtime stack.\n\n\n

\nThis function fills parts of a lua_Debug structure with\nan identification of the activation record\nof the function executing at a given level.\nLevel 0 is the current running function,\nwhereas level n+1 is the function that has called level n.\nWhen there are no errors, lua_getstack returns 1;\nwhen called with a level greater than the stack depth,\nit returns 0.\n\n\n\n\n\n

lua_getupvalue

\n[-0, +(0|1), -]\n

const char *lua_getupvalue (lua_State *L, int funcindex, int n);
\n\n

\nGets information about a closure's upvalue.\n(For Lua functions,\nupvalues are the external local variables that the function uses,\nand that are consequently included in its closure.)\nlua_getupvalue gets the index n of an upvalue,\npushes the upvalue's value onto the stack,\nand returns its name.\nfuncindex points to the closure in the stack.\n(Upvalues have no particular order,\nas they are active through the whole function.\nSo, they are numbered in an arbitrary order.)\n\n\n

\nReturns NULL (and pushes nothing)\nwhen the index is greater than the number of upvalues.\nFor C functions, this function uses the empty string \"\"\nas a name for all upvalues.\n\n\n\n\n\n

lua_Hook

\n
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
\n\n

\nType for debugging hook functions.\n\n\n

\nWhenever a hook is called, its ar argument has its field\nevent set to the specific event that triggered the hook.\nLua identifies these events with the following constants:\nLUA_HOOKCALL, LUA_HOOKRET,\nLUA_HOOKTAILRET, LUA_HOOKLINE,\nand LUA_HOOKCOUNT.\nMoreover, for line events, the field currentline is also set.\nTo get the value of any other field in ar,\nthe hook must call lua_getinfo.\nFor return events, event can be LUA_HOOKRET,\nthe normal value, or LUA_HOOKTAILRET.\nIn the latter case, Lua is simulating a return from\na function that did a tail call;\nin this case, it is useless to call lua_getinfo.\n\n\n

\nWhile Lua is running a hook, it disables other calls to hooks.\nTherefore, if a hook calls back Lua to execute a function or a chunk,\nthis execution occurs without any calls to hooks.\n\n\n\n\n\n

lua_sethook

\n[-0, +0, -]\n

int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
\n\n

\nSets the debugging hook function.\n\n\n

\nArgument f is the hook function.\nmask specifies on which events the hook will be called:\nit is formed by a bitwise or of the constants\nLUA_MASKCALL,\nLUA_MASKRET,\nLUA_MASKLINE,\nand LUA_MASKCOUNT.\nThe count argument is only meaningful when the mask\nincludes LUA_MASKCOUNT.\nFor each event, the hook is called as explained below:\n\n

    \n\n
  • The call hook: is called when the interpreter calls a function.\nThe hook is called just after Lua enters the new function,\nbefore the function gets its arguments.\n
    • \n\n
  • The return hook: is called when the interpreter returns from a function.\nThe hook is called just before Lua leaves the function.\nYou have no access to the values to be returned by the function.\n
    • \n\n
  • The line hook: is called when the interpreter is about to\nstart the execution of a new line of code,\nor when it jumps back in the code (even to the same line).\n(This event only happens while Lua is executing a Lua function.)\n
    • \n\n
  • The count hook: is called after the interpreter executes every\ncount instructions.\n(This event only happens while Lua is executing a Lua function.)\n
    • \n\n
\n\n

\nA hook is disabled by setting mask to zero.\n\n\n\n\n\n

lua_setlocal

\n[-(0|1), +0, -]\n

const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
\n\n

\nSets the value of a local variable of a given activation record.\nParameters ar and n are as in lua_getlocal\n(see lua_getlocal).\nlua_setlocal assigns the value at the top of the stack\nto the variable and returns its name.\nIt also pops the value from the stack.\n\n\n

\nReturns NULL (and pops nothing)\nwhen the index is greater than\nthe number of active local variables.\n\n\n\n\n\n

lua_setupvalue

\n[-(0|1), +0, -]\n

const char *lua_setupvalue (lua_State *L, int funcindex, int n);
\n\n

\nSets the value of a closure's upvalue.\nIt assigns the value at the top of the stack\nto the upvalue and returns its name.\nIt also pops the value from the stack.\nParameters funcindex and n are as in the lua_getupvalue\n(see lua_getupvalue).\n\n\n

\nReturns NULL (and pops nothing)\nwhen the index is greater than the number of upvalues.\n\n\n\n\n\n\n\n

4 - The Auxiliary Library

\n\n

\n\nThe auxiliary library provides several convenient functions\nto interface C with Lua.\nWhile the basic API provides the primitive functions for all \ninteractions between C and Lua,\nthe auxiliary library provides higher-level functions for some\ncommon tasks.\n\n\n

\nAll functions from the auxiliary library\nare defined in header file lauxlib.h and\nhave a prefix luaL_.\n\n\n

\nAll functions in the auxiliary library are built on\ntop of the basic API,\nand so they provide nothing that cannot be done with this API.\n\n\n

\nSeveral functions in the auxiliary library are used to\ncheck C function arguments.\nTheir names are always luaL_check* or luaL_opt*.\nAll of these functions throw an error if the check is not satisfied.\nBecause the error message is formatted for arguments\n(e.g., \"bad argument #1\"),\nyou should not use these functions for other stack values.\n\n\n\n

4.1 - Functions and Types

\n\n

\nHere we list all functions and types from the auxiliary library\nin alphabetical order.\n\n\n\n

luaL_addchar

\n[-0, +0, m]\n

void luaL_addchar (luaL_Buffer *B, char c);
\n\n

\nAdds the character c to the buffer B\n(see luaL_Buffer).\n\n\n\n\n\n

luaL_addlstring

\n[-0, +0, m]\n

void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
\n\n

\nAdds the string pointed to by s with length l to\nthe buffer B\n(see luaL_Buffer).\nThe string may contain embedded zeros.\n\n\n\n\n\n

luaL_addsize

\n[-0, +0, m]\n

void luaL_addsize (luaL_Buffer *B, size_t n);
\n\n

\nAdds to the buffer B (see luaL_Buffer)\na string of length n previously copied to the\nbuffer area (see luaL_prepbuffer).\n\n\n\n\n\n

luaL_addstring

\n[-0, +0, m]\n

void luaL_addstring (luaL_Buffer *B, const char *s);
\n\n

\nAdds the zero-terminated string pointed to by s\nto the buffer B\n(see luaL_Buffer).\nThe string may not contain embedded zeros.\n\n\n\n\n\n

luaL_addvalue

\n[-1, +0, m]\n

void luaL_addvalue (luaL_Buffer *B);
\n\n

\nAdds the value at the top of the stack\nto the buffer B\n(see luaL_Buffer).\nPops the value.\n\n\n

\nThis is the only function on string buffers that can (and must)\nbe called with an extra element on the stack,\nwhich is the value to be added to the buffer.\n\n\n\n\n\n

luaL_argcheck

\n[-0, +0, v]\n

void luaL_argcheck (lua_State *L,\n                    int cond,\n                    int narg,\n                    const char *extramsg);
\n\n

\nChecks whether cond is true.\nIf not, raises an error with the following message,\nwhere func is retrieved from the call stack:\n\n

\n     bad argument #<narg> to <func> (<extramsg>)\n
\n\n\n\n\n

luaL_argerror

\n[-0, +0, v]\n

int luaL_argerror (lua_State *L, int narg, const char *extramsg);
\n\n

\nRaises an error with the following message,\nwhere func is retrieved from the call stack:\n\n

\n     bad argument #<narg> to <func> (<extramsg>)\n
\n\n

\nThis function never returns,\nbut it is an idiom to use it in C functions\nas return luaL_argerror(args).\n\n\n\n\n\n

luaL_Buffer

\n
typedef struct luaL_Buffer luaL_Buffer;
\n\n

\nType for a string buffer.\n\n\n

\nA string buffer allows C code to build Lua strings piecemeal.\nIts pattern of use is as follows:\n\n

    \n\n
  • First you declare a variable b of type luaL_Buffer.
    • \n\n
  • Then you initialize it with a call luaL_buffinit(L, &b).
    • \n\n
  • \nThen you add string pieces to the buffer calling any of\nthe luaL_add* functions.\n
    • \n\n
  • \nYou finish by calling luaL_pushresult(&b).\nThis call leaves the final string on the top of the stack.\n
    • \n\n
\n\n

\nDuring its normal operation,\na string buffer uses a variable number of stack slots.\nSo, while using a buffer, you cannot assume that you know where\nthe top of the stack is.\nYou can use the stack between successive calls to buffer operations\nas long as that use is balanced;\nthat is,\nwhen you call a buffer operation,\nthe stack is at the same level\nit was immediately after the previous buffer operation.\n(The only exception to this rule is luaL_addvalue.)\nAfter calling luaL_pushresult the stack is back to its\nlevel when the buffer was initialized,\nplus the final string on its top.\n\n\n\n\n\n

luaL_buffinit

\n[-0, +0, -]\n

void luaL_buffinit (lua_State *L, luaL_Buffer *B);
\n\n

\nInitializes a buffer B.\nThis function does not allocate any space;\nthe buffer must be declared as a variable\n(see luaL_Buffer).\n\n\n\n\n\n

luaL_callmeta

\n[-0, +(0|1), e]\n

int luaL_callmeta (lua_State *L, int obj, const char *e);
\n\n

\nCalls a metamethod.\n\n\n

\nIf the object at index obj has a metatable and this\nmetatable has a field e,\nthis function calls this field and passes the object as its only argument.\nIn this case this function returns 1 and pushes onto the\nstack the value returned by the call.\nIf there is no metatable or no metamethod,\nthis function returns 0 (without pushing any value on the stack).\n\n\n\n\n\n

luaL_checkany

\n[-0, +0, v]\n

void luaL_checkany (lua_State *L, int narg);
\n\n

\nChecks whether the function has an argument\nof any type (including nil) at position narg.\n\n\n\n\n\n

luaL_checkint

\n[-0, +0, v]\n

int luaL_checkint (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to an int.\n\n\n\n\n\n

luaL_checkinteger

\n[-0, +0, v]\n

lua_Integer luaL_checkinteger (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to a lua_Integer.\n\n\n\n\n\n

luaL_checklong

\n[-0, +0, v]\n

long luaL_checklong (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to a long.\n\n\n\n\n\n

luaL_checklstring

\n[-0, +0, v]\n

const char *luaL_checklstring (lua_State *L, int narg, size_t *l);
\n\n

\nChecks whether the function argument narg is a string\nand returns this string;\nif l is not NULL fills *l\nwith the string's length.\n\n\n

\nThis function uses lua_tolstring to get its result,\nso all conversions and caveats of that function apply here.\n\n\n\n\n\n

luaL_checknumber

\n[-0, +0, v]\n

lua_Number luaL_checknumber (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number.\n\n\n\n\n\n

luaL_checkoption

\n[-0, +0, v]\n

int luaL_checkoption (lua_State *L,\n                      int narg,\n                      const char *def,\n                      const char *const lst[]);
\n\n

\nChecks whether the function argument narg is a string and\nsearches for this string in the array lst\n(which must be NULL-terminated).\nReturns the index in the array where the string was found.\nRaises an error if the argument is not a string or\nif the string cannot be found.\n\n\n

\nIf def is not NULL,\nthe function uses def as a default value when\nthere is no argument narg or if this argument is nil.\n\n\n

\nThis is a useful function for mapping strings to C enums.\n(The usual convention in Lua libraries is\nto use strings instead of numbers to select options.)\n\n\n\n\n\n

luaL_checkstack

\n[-0, +0, v]\n

void luaL_checkstack (lua_State *L, int sz, const char *msg);
\n\n

\nGrows the stack size to top + sz elements,\nraising an error if the stack cannot grow to that size.\nmsg is an additional text to go into the error message.\n\n\n\n\n\n

luaL_checkstring

\n[-0, +0, v]\n

const char *luaL_checkstring (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a string\nand returns this string.\n\n\n

\nThis function uses lua_tolstring to get its result,\nso all conversions and caveats of that function apply here.\n\n\n\n\n\n

luaL_checktype

\n[-0, +0, v]\n

void luaL_checktype (lua_State *L, int narg, int t);
\n\n

\nChecks whether the function argument narg has type t.\nSee lua_type for the encoding of types for t.\n\n\n\n\n\n

luaL_checkudata

\n[-0, +0, v]\n

void *luaL_checkudata (lua_State *L, int narg, const char *tname);
\n\n

\nChecks whether the function argument narg is a userdata\nof the type tname (see luaL_newmetatable).\n\n\n\n\n\n

luaL_dofile

\n[-0, +?, m]\n

int luaL_dofile (lua_State *L, const char *filename);
\n\n

\nLoads and runs the given file.\nIt is defined as the following macro:\n\n

\n     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))\n

\nIt returns 0 if there are no errors\nor 1 in case of errors.\n\n\n\n\n\n

luaL_dostring

\n[-0, +?, m]\n

int luaL_dostring (lua_State *L, const char *str);
\n\n

\nLoads and runs the given string.\nIt is defined as the following macro:\n\n

\n     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))\n

\nIt returns 0 if there are no errors\nor 1 in case of errors.\n\n\n\n\n\n

luaL_error

\n[-0, +0, v]\n

int luaL_error (lua_State *L, const char *fmt, ...);
\n\n

\nRaises an error.\nThe error message format is given by fmt\nplus any extra arguments,\nfollowing the same rules of lua_pushfstring.\nIt also adds at the beginning of the message the file name and\nthe line number where the error occurred,\nif this information is available.\n\n\n

\nThis function never returns,\nbut it is an idiom to use it in C functions\nas return luaL_error(args).\n\n\n\n\n\n

luaL_getmetafield

\n[-0, +(0|1), m]\n

int luaL_getmetafield (lua_State *L, int obj, const char *e);
\n\n

\nPushes onto the stack the field e from the metatable\nof the object at index obj.\nIf the object does not have a metatable,\nor if the metatable does not have this field,\nreturns 0 and pushes nothing.\n\n\n\n\n\n

luaL_getmetatable

\n[-0, +1, -]\n

void luaL_getmetatable (lua_State *L, const char *tname);
\n\n

\nPushes onto the stack the metatable associated with name tname\nin the registry (see luaL_newmetatable).\n\n\n\n\n\n

luaL_gsub

\n[-0, +1, m]\n

const char *luaL_gsub (lua_State *L,\n                       const char *s,\n                       const char *p,\n                       const char *r);
\n\n

\nCreates a copy of string s by replacing\nany occurrence of the string p\nwith the string r.\nPushes the resulting string on the stack and returns it.\n\n\n\n\n\n

luaL_loadbuffer

\n[-0, +1, m]\n

int luaL_loadbuffer (lua_State *L,\n                     const char *buff,\n                     size_t sz,\n                     const char *name);
\n\n

\nLoads a buffer as a Lua chunk.\nThis function uses lua_load to load the chunk in the\nbuffer pointed to by buff with size sz.\n\n\n

\nThis function returns the same results as lua_load.\nname is the chunk name,\nused for debug information and error messages.\n\n\n\n\n\n

luaL_loadfile

\n[-0, +1, m]\n

int luaL_loadfile (lua_State *L, const char *filename);
\n\n

\nLoads a file as a Lua chunk.\nThis function uses lua_load to load the chunk in the file\nnamed filename.\nIf filename is NULL,\nthen it loads from the standard input.\nThe first line in the file is ignored if it starts with a #.\n\n\n

\nThis function returns the same results as lua_load,\nbut it has an extra error code LUA_ERRFILE\nif it cannot open/read the file.\n\n\n

\nAs lua_load, this function only loads the chunk;\nit does not run it.\n\n\n\n\n\n

luaL_loadstring

\n[-0, +1, m]\n

int luaL_loadstring (lua_State *L, const char *s);
\n\n

\nLoads a string as a Lua chunk.\nThis function uses lua_load to load the chunk in\nthe zero-terminated string s.\n\n\n

\nThis function returns the same results as lua_load.\n\n\n

\nAlso as lua_load, this function only loads the chunk;\nit does not run it.\n\n\n\n\n\n

luaL_newmetatable

\n[-0, +1, m]\n

int luaL_newmetatable (lua_State *L, const char *tname);
\n\n

\nIf the registry already has the key tname,\nreturns 0.\nOtherwise,\ncreates a new table to be used as a metatable for userdata,\nadds it to the registry with key tname,\nand returns 1.\n\n\n

\nIn both cases pushes onto the stack the final value associated\nwith tname in the registry.\n\n\n\n\n\n

luaL_newstate

\n[-0, +0, -]\n

lua_State *luaL_newstate (void);
\n\n

\nCreates a new Lua state.\nIt calls lua_newstate with an\nallocator based on the standard C realloc function\nand then sets a panic function (see lua_atpanic) that prints\nan error message to the standard error output in case of fatal\nerrors.\n\n\n

\nReturns the new state,\nor NULL if there is a memory allocation error.\n\n\n\n\n\n

luaL_openlibs

\n[-0, +0, m]\n

void luaL_openlibs (lua_State *L);
\n\n

\nOpens all standard Lua libraries into the given state.\n\n\n\n\n\n

luaL_optint

\n[-0, +0, v]\n

int luaL_optint (lua_State *L, int narg, int d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to an int.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optinteger

\n[-0, +0, v]\n

lua_Integer luaL_optinteger (lua_State *L,\n                             int narg,\n                             lua_Integer d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to a lua_Integer.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optlong

\n[-0, +0, v]\n

long luaL_optlong (lua_State *L, int narg, long d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to a long.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optlstring

\n[-0, +0, v]\n

const char *luaL_optlstring (lua_State *L,\n                             int narg,\n                             const char *d,\n                             size_t *l);
\n\n

\nIf the function argument narg is a string,\nreturns this string.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n

\nIf l is not NULL,\nfills the position *l with the results's length.\n\n\n\n\n\n

luaL_optnumber

\n[-0, +0, v]\n

lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);
\n\n

\nIf the function argument narg is a number,\nreturns this number.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optstring

\n[-0, +0, v]\n

const char *luaL_optstring (lua_State *L,\n                            int narg,\n                            const char *d);
\n\n

\nIf the function argument narg is a string,\nreturns this string.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_prepbuffer

\n[-0, +0, -]\n

char *luaL_prepbuffer (luaL_Buffer *B);
\n\n

\nReturns an address to a space of size LUAL_BUFFERSIZE\nwhere you can copy a string to be added to buffer B\n(see luaL_Buffer).\nAfter copying the string into this space you must call\nluaL_addsize with the size of the string to actually add \nit to the buffer.\n\n\n\n\n\n

luaL_pushresult

\n[-?, +1, m]\n

void luaL_pushresult (luaL_Buffer *B);
\n\n

\nFinishes the use of buffer B leaving the final string on\nthe top of the stack.\n\n\n\n\n\n

luaL_ref

\n[-1, +0, m]\n

int luaL_ref (lua_State *L, int t);
\n\n

\nCreates and returns a reference,\nin the table at index t,\nfor the object at the top of the stack (and pops the object).\n\n\n

\nA reference is a unique integer key.\nAs long as you do not manually add integer keys into table t,\nluaL_ref ensures the uniqueness of the key it returns.\nYou can retrieve an object referred by reference r\nby calling lua_rawgeti(L, t, r).\nFunction luaL_unref frees a reference and its associated object.\n\n\n

\nIf the object at the top of the stack is nil,\nluaL_ref returns the constant LUA_REFNIL.\nThe constant LUA_NOREF is guaranteed to be different\nfrom any reference returned by luaL_ref.\n\n\n\n\n\n

luaL_Reg

\n
typedef struct luaL_Reg {\n  const char *name;\n  lua_CFunction func;\n} luaL_Reg;
\n\n

\nType for arrays of functions to be registered by\nluaL_register.\nname is the function name and func is a pointer to\nthe function.\nAny array of luaL_Reg must end with an sentinel entry\nin which both name and func are NULL.\n\n\n\n\n\n

luaL_register

\n[-(0|1), +1, m]\n

void luaL_register (lua_State *L,\n                    const char *libname,\n                    const luaL_Reg *l);
\n\n

\nOpens a library.\n\n\n

\nWhen called with libname equal to NULL,\nit simply registers all functions in the list l\n(see luaL_Reg) into the table on the top of the stack.\n\n\n

\nWhen called with a non-null libname,\nluaL_register creates a new table t,\nsets it as the value of the global variable libname,\nsets it as the value of package.loaded[libname],\nand registers on it all functions in the list l.\nIf there is a table in package.loaded[libname] or in\nvariable libname,\nreuses this table instead of creating a new one.\n\n\n

\nIn any case the function leaves the table\non the top of the stack.\n\n\n\n\n\n

luaL_typename

\n[-0, +0, -]\n

const char *luaL_typename (lua_State *L, int index);
\n\n

\nReturns the name of the type of the value at the given index.\n\n\n\n\n\n

luaL_typerror

\n[-0, +0, v]\n

int luaL_typerror (lua_State *L, int narg, const char *tname);
\n\n

\nGenerates an error with a message like the following:\n\n

\n     location: bad argument narg to 'func' (tname expected, got rt)\n

\nwhere location is produced by luaL_where,\nfunc is the name of the current function,\nand rt is the type name of the actual argument.\n\n\n\n\n\n

luaL_unref

\n[-0, +0, -]\n

void luaL_unref (lua_State *L, int t, int ref);
\n\n

\nReleases reference ref from the table at index t\n(see luaL_ref).\nThe entry is removed from the table,\nso that the referred object can be collected.\nThe reference ref is also freed to be used again.\n\n\n

\nIf ref is LUA_NOREF or LUA_REFNIL,\nluaL_unref does nothing.\n\n\n\n\n\n

luaL_where

\n[-0, +1, m]\n

void luaL_where (lua_State *L, int lvl);
\n\n

\nPushes onto the stack a string identifying the current position\nof the control at level lvl in the call stack.\nTypically this string has the following format:\n\n

\n     chunkname:currentline:\n

\nLevel 0 is the running function,\nlevel 1 is the function that called the running function,\netc.\n\n\n

\nThis function is used to build a prefix for error messages.\n\n\n\n\n\n\n\n

5 - Standard Libraries

\n\n

\nThe standard Lua libraries provide useful functions\nthat are implemented directly through the C API.\nSome of these functions provide essential services to the language\n(e.g., type and getmetatable);\nothers provide access to \"outside\" services (e.g., I/O);\nand others could be implemented in Lua itself,\nbut are quite useful or have critical performance requirements that\ndeserve an implementation in C (e.g., table.sort).\n\n\n

\nAll libraries are implemented through the official C API\nand are provided as separate C modules.\nCurrently, Lua has the following standard libraries:\n\n

    \n\n
  • basic library, which includes the coroutine sub-library;
    • \n\n
  • package library;
    • \n\n
  • string manipulation;
    • \n\n
  • table manipulation;
    • \n\n
  • mathematical functions (sin, log, etc.);
    • \n\n
  • input and output;
    • \n\n
  • operating system facilities;
    • \n\n
  • debug facilities.
    • \n\n

\nExcept for the basic and package libraries,\neach library provides all its functions as fields of a global table\nor as methods of its objects.\n\n\n

\nTo have access to these libraries,\nthe C host program should call the luaL_openlibs function,\nwhich opens all standard libraries.\nAlternatively,\nit can open them individually by calling\nluaopen_base (for the basic library),\nluaopen_package (for the package library),\nluaopen_string (for the string library),\nluaopen_table (for the table library),\nluaopen_math (for the mathematical library),\nluaopen_io (for the I/O library),\nluaopen_os (for the Operating System library),\nand luaopen_debug (for the debug library).\nThese functions are declared in lualib.h\nand should not be called directly:\nyou must call them like any other Lua C function,\ne.g., by using lua_call.\n\n\n\n

5.1 - Basic Functions

\n\n

\nThe basic library provides some core functions to Lua.\nIf you do not include this library in your application,\nyou should check carefully whether you need to provide \nimplementations for some of its facilities.\n\n\n

\n

assert (v [, message])

\nIssues an error when\nthe value of its argument v is false (i.e., nil or false);\notherwise, returns all its arguments.\nmessage is an error message;\nwhen absent, it defaults to \"assertion failed!\"\n\n\n\n\n

\n

collectgarbage ([opt [, arg]])

\n\n\n

\nThis function is a generic interface to the garbage collector.\nIt performs different functions according to its first argument, opt:\n\n

    \n\n
  • \"collect\":\nperforms a full garbage-collection cycle.\nThis is the default option.\n
    • \n\n
  • \"stop\":\nstops the garbage collector.\n
    • \n\n
  • \"restart\":\nrestarts the garbage collector.\n
    • \n\n
  • \"count\":\nreturns the total memory in use by Lua (in Kbytes).\n
    • \n\n
  • \"step\":\nperforms a garbage-collection step.\nThe step \"size\" is controlled by arg\n(larger values mean more steps) in a non-specified way.\nIf you want to control the step size\nyou must experimentally tune the value of arg.\nReturns true if the step finished a collection cycle.\n
    • \n\n
  • \"setpause\":\nsets arg as the new value for the pause of\nthe collector (see §2.10).\nReturns the previous value for pause.\n
    • \n\n
  • \"setstepmul\":\nsets arg as the new value for the step multiplier of\nthe collector (see §2.10).\nReturns the previous value for step.\n
    • \n\n
\n\n\n\n

\n

dofile ([filename])

\nOpens the named file and executes its contents as a Lua chunk.\nWhen called without arguments,\ndofile executes the contents of the standard input (stdin).\nReturns all values returned by the chunk.\nIn case of errors, dofile propagates the error\nto its caller (that is, dofile does not run in protected mode).\n\n\n\n\n

\n

error (message [, level])

\nTerminates the last protected function called\nand returns message as the error message.\nFunction error never returns.\n\n\n

\nUsually, error adds some information about the error position\nat the beginning of the message.\nThe level argument specifies how to get the error position.\nWith level 1 (the default), the error position is where the\nerror function was called.\nLevel 2 points the error to where the function\nthat called error was called; and so on.\nPassing a level 0 avoids the addition of error position information\nto the message.\n\n\n\n\n

\n

_G

\nA global variable (not a function) that\nholds the global environment (that is, _G._G = _G).\nLua itself does not use this variable;\nchanging its value does not affect any environment,\nnor vice-versa.\n(Use setfenv to change environments.)\n\n\n\n\n

\n

getfenv ([f])

\nReturns the current environment in use by the function.\nf can be a Lua function or a number\nthat specifies the function at that stack level:\nLevel 1 is the function calling getfenv.\nIf the given function is not a Lua function,\nor if f is 0,\ngetfenv returns the global environment.\nThe default for f is 1.\n\n\n\n\n

\n

getmetatable (object)

\n\n\n

\nIf object does not have a metatable, returns nil.\nOtherwise,\nif the object's metatable has a \"__metatable\" field,\nreturns the associated value.\nOtherwise, returns the metatable of the given object.\n\n\n\n\n

\n

ipairs (t)

\n\n\n

\nReturns three values: an iterator function, the table t, and 0,\nso that the construction\n\n

\n     for i,v in ipairs(t) do body end\n

\nwill iterate over the pairs (1,t[1]), (2,t[2]), ···,\nup to the first integer key absent from the table.\n\n\n\n\n

\n

load (func [, chunkname])

\n\n\n

\nLoads a chunk using function func to get its pieces.\nEach call to func must return a string that concatenates\nwith previous results.\nA return of an empty string, nil, or no value signals the end of the chunk.\n\n\n

\nIf there are no errors, \nreturns the compiled chunk as a function;\notherwise, returns nil plus the error message.\nThe environment of the returned function is the global environment.\n\n\n

\nchunkname is used as the chunk name for error messages\nand debug information.\nWhen absent,\nit defaults to \"=(load)\".\n\n\n\n\n

\n

loadfile ([filename])

\n\n\n

\nSimilar to load,\nbut gets the chunk from file filename\nor from the standard input,\nif no file name is given.\n\n\n\n\n

\n

loadstring (string [, chunkname])

\n\n\n

\nSimilar to load,\nbut gets the chunk from the given string.\n\n\n

\nTo load and run a given string, use the idiom\n\n

\n     assert(loadstring(s))()\n
\n\n

\nWhen absent,\nchunkname defaults to the given string.\n\n\n\n\n

\n

next (table [, index])

\n\n\n

\nAllows a program to traverse all fields of a table.\nIts first argument is a table and its second argument\nis an index in this table.\nnext returns the next index of the table\nand its associated value.\nWhen called with nil as its second argument,\nnext returns an initial index\nand its associated value.\nWhen called with the last index,\nor with nil in an empty table,\nnext returns nil.\nIf the second argument is absent, then it is interpreted as nil.\nIn particular,\nyou can use next(t) to check whether a table is empty.\n\n\n

\nThe order in which the indices are enumerated is not specified,\neven for numeric indices.\n(To traverse a table in numeric order,\nuse a numerical for or the ipairs function.)\n\n\n

\nThe behavior of next is undefined if,\nduring the traversal,\nyou assign any value to a non-existent field in the table.\nYou may however modify existing fields.\nIn particular, you may clear existing fields.\n\n\n\n\n

\n

pairs (t)

\n\n\n

\nReturns three values: the next function, the table t, and nil,\nso that the construction\n\n

\n     for k,v in pairs(t) do body end\n

\nwill iterate over all key–value pairs of table t.\n\n\n

\nSee function next for the caveats of modifying\nthe table during its traversal.\n\n\n\n\n

\n

pcall (f, arg1, ···)

\n\n\n

\nCalls function f with\nthe given arguments in protected mode.\nThis means that any error inside f is not propagated;\ninstead, pcall catches the error\nand returns a status code.\nIts first result is the status code (a boolean),\nwhich is true if the call succeeds without errors.\nIn such case, pcall also returns all results from the call,\nafter this first result.\nIn case of any error, pcall returns false plus the error message.\n\n\n\n\n

\n

print (···)

\nReceives any number of arguments,\nand prints their values to stdout,\nusing the tostring function to convert them to strings.\nprint is not intended for formatted output,\nbut only as a quick way to show a value,\ntypically for debugging.\nFor formatted output, use string.format.\n\n\n\n\n

\n

rawequal (v1, v2)

\nChecks whether v1 is equal to v2,\nwithout invoking any metamethod.\nReturns a boolean.\n\n\n\n\n

\n

rawget (table, index)

\nGets the real value of table[index],\nwithout invoking any metamethod.\ntable must be a table;\nindex may be any value.\n\n\n\n\n

\n

rawset (table, index, value)

\nSets the real value of table[index] to value,\nwithout invoking any metamethod.\ntable must be a table,\nindex any value different from nil,\nand value any Lua value.\n\n\n

\nThis function returns table.\n\n\n\n\n

\n

select (index, ···)

\n\n\n

\nIf index is a number,\nreturns all arguments after argument number index.\nOtherwise, index must be the string \"#\",\nand select returns the total number of extra arguments it received.\n\n\n\n\n

\n

setfenv (f, table)

\n\n\n

\nSets the environment to be used by the given function.\nf can be a Lua function or a number\nthat specifies the function at that stack level:\nLevel 1 is the function calling setfenv.\nsetfenv returns the given function.\n\n\n

\nAs a special case, when f is 0 setfenv changes\nthe environment of the running thread.\nIn this case, setfenv returns no values.\n\n\n\n\n

\n

setmetatable (table, metatable)

\n\n\n

\nSets the metatable for the given table.\n(You cannot change the metatable of other types from Lua, only from C.)\nIf metatable is nil,\nremoves the metatable of the given table.\nIf the original metatable has a \"__metatable\" field,\nraises an error.\n\n\n

\nThis function returns table.\n\n\n\n\n

\n

tonumber (e [, base])

\nTries to convert its argument to a number.\nIf the argument is already a number or a string convertible\nto a number, then tonumber returns this number;\notherwise, it returns nil.\n\n\n

\nAn optional argument specifies the base to interpret the numeral.\nThe base may be any integer between 2 and 36, inclusive.\nIn bases above 10, the letter 'A' (in either upper or lower case)\nrepresents 10, 'B' represents 11, and so forth,\nwith 'Z' representing 35.\nIn base 10 (the default), the number can have a decimal part,\nas well as an optional exponent part (see §2.1).\nIn other bases, only unsigned integers are accepted.\n\n\n\n\n

\n

tostring (e)

\nReceives an argument of any type and\nconverts it to a string in a reasonable format.\nFor complete control of how numbers are converted,\nuse string.format.\n\n\n

\nIf the metatable of e has a \"__tostring\" field,\nthen tostring calls the corresponding value\nwith e as argument,\nand uses the result of the call as its result.\n\n\n\n\n

\n

type (v)

\nReturns the type of its only argument, coded as a string.\nThe possible results of this function are\n\"nil\" (a string, not the value nil),\n\"number\",\n\"string\",\n\"boolean\",\n\"table\",\n\"function\",\n\"thread\",\nand \"userdata\".\n\n\n\n\n

\n

unpack (list [, i [, j]])

\nReturns the elements from the given table.\nThis function is equivalent to\n\n
\n     return list[i], list[i+1], ···, list[j]\n

\nexcept that the above code can be written only for a fixed number\nof elements.\nBy default, i is 1 and j is the length of the list,\nas defined by the length operator (see §2.5.5).\n\n\n\n\n

\n

_VERSION

\nA global variable (not a function) that\nholds a string containing the current interpreter version.\nThe current contents of this variable is \"Lua 5.1\".\n\n\n\n\n

\n

xpcall (f, err)

\n\n\n

\nThis function is similar to pcall,\nexcept that you can set a new error handler.\n\n\n

\nxpcall calls function f in protected mode,\nusing err as the error handler.\nAny error inside f is not propagated;\ninstead, xpcall catches the error,\ncalls the err function with the original error object,\nand returns a status code.\nIts first result is the status code (a boolean),\nwhich is true if the call succeeds without errors.\nIn this case, xpcall also returns all results from the call,\nafter this first result.\nIn case of any error,\nxpcall returns false plus the result from err.\n\n\n\n\n\n\n\n

5.2 - Coroutine Manipulation

\n\n

\nThe operations related to coroutines comprise a sub-library of\nthe basic library and come inside the table coroutine.\nSee §2.11 for a general description of coroutines.\n\n\n

\n

coroutine.create (f)

\n\n\n

\nCreates a new coroutine, with body f.\nf must be a Lua function.\nReturns this new coroutine,\nan object with type \"thread\".\n\n\n\n\n

\n

coroutine.resume (co [, val1, ···])

\n\n\n

\nStarts or continues the execution of coroutine co.\nThe first time you resume a coroutine,\nit starts running its body.\nThe values val1, ··· are passed\nas the arguments to the body function.\nIf the coroutine has yielded,\nresume restarts it;\nthe values val1, ··· are passed\nas the results from the yield.\n\n\n

\nIf the coroutine runs without any errors,\nresume returns true plus any values passed to yield\n(if the coroutine yields) or any values returned by the body function\n(if the coroutine terminates).\nIf there is any error,\nresume returns false plus the error message.\n\n\n\n\n

\n

coroutine.running ()

\n\n\n

\nReturns the running coroutine,\nor nil when called by the main thread.\n\n\n\n\n

\n

coroutine.status (co)

\n\n\n

\nReturns the status of coroutine co, as a string:\n\"running\",\nif the coroutine is running (that is, it called status);\n\"suspended\", if the coroutine is suspended in a call to yield,\nor if it has not started running yet;\n\"normal\" if the coroutine is active but not running\n(that is, it has resumed another coroutine);\nand \"dead\" if the coroutine has finished its body function,\nor if it has stopped with an error.\n\n\n\n\n

\n

coroutine.wrap (f)

\n\n\n

\nCreates a new coroutine, with body f.\nf must be a Lua function.\nReturns a function that resumes the coroutine each time it is called.\nAny arguments passed to the function behave as the\nextra arguments to resume.\nReturns the same values returned by resume,\nexcept the first boolean.\nIn case of error, propagates the error.\n\n\n\n\n

\n

coroutine.yield (···)

\n\n\n

\nSuspends the execution of the calling coroutine.\nThe coroutine cannot be running a C function,\na metamethod, or an iterator.\nAny arguments to yield are passed as extra results to resume.\n\n\n\n\n\n\n\n

5.3 - Modules

\n\n

\nThe package library provides basic\nfacilities for loading and building modules in Lua.\nIt exports two of its functions directly in the global environment:\nrequire and module.\nEverything else is exported in a table package.\n\n\n

\n

module (name [, ···])

\n\n\n

\nCreates a module.\nIf there is a table in package.loaded[name],\nthis table is the module.\nOtherwise, if there is a global table t with the given name,\nthis table is the module.\nOtherwise creates a new table t and\nsets it as the value of the global name and\nthe value of package.loaded[name].\nThis function also initializes t._NAME with the given name,\nt._M with the module (t itself),\nand t._PACKAGE with the package name\n(the full module name minus last component; see below).\nFinally, module sets t as the new environment\nof the current function and the new value of package.loaded[name],\nso that require returns t.\n\n\n

\nIf name is a compound name\n(that is, one with components separated by dots),\nmodule creates (or reuses, if they already exist)\ntables for each component.\nFor instance, if name is a.b.c,\nthen module stores the module table in field c of\nfield b of global a.\n\n\n

\nThis function can receive optional options after\nthe module name,\nwhere each option is a function to be applied over the module.\n\n\n\n\n

\n

require (modname)

\n\n\n

\nLoads the given module.\nThe function starts by looking into the package.loaded table\nto determine whether modname is already loaded.\nIf it is, then require returns the value stored\nat package.loaded[modname].\nOtherwise, it tries to find a loader for the module.\n\n\n

\nTo find a loader,\nrequire is guided by the package.loaders array.\nBy changing this array,\nwe can change how require looks for a module.\nThe following explanation is based on the default configuration\nfor package.loaders.\n\n\n

\nFirst require queries package.preload[modname].\nIf it has a value,\nthis value (which should be a function) is the loader.\nOtherwise require searches for a Lua loader using the\npath stored in package.path.\nIf that also fails, it searches for a C loader using the\npath stored in package.cpath.\nIf that also fails,\nit tries an all-in-one loader (see package.loaders).\n\n\n

\nOnce a loader is found,\nrequire calls the loader with a single argument, modname.\nIf the loader returns any value,\nrequire assigns the returned value to package.loaded[modname].\nIf the loader returns no value and\nhas not assigned any value to package.loaded[modname],\nthen require assigns true to this entry.\nIn any case, require returns the\nfinal value of package.loaded[modname].\n\n\n

\nIf there is any error loading or running the module,\nor if it cannot find any loader for the module,\nthen require signals an error. \n\n\n\n\n

\n

package.cpath

\n\n\n

\nThe path used by require to search for a C loader.\n\n\n

\nLua initializes the C path package.cpath in the same way\nit initializes the Lua path package.path,\nusing the environment variable LUA_CPATH\nor a default path defined in luaconf.h.\n\n\n\n\n

\n\n

package.loaded

\n\n\n

\nA table used by require to control which\nmodules are already loaded.\nWhen you require a module modname and\npackage.loaded[modname] is not false,\nrequire simply returns the value stored there.\n\n\n\n\n

\n

package.loaders

\n\n\n

\nA table used by require to control how to load modules.\n\n\n

\nEach entry in this table is a searcher function.\nWhen looking for a module,\nrequire calls each of these searchers in ascending order,\nwith the module name (the argument given to require) as its\nsole parameter.\nThe function can return another function (the module loader)\nor a string explaining why it did not find that module\n(or nil if it has nothing to say).\nLua initializes this table with four functions.\n\n\n

\nThe first searcher simply looks for a loader in the\npackage.preload table.\n\n\n

\nThe second searcher looks for a loader as a Lua library,\nusing the path stored at package.path.\nA path is a sequence of templates separated by semicolons.\nFor each template,\nthe searcher will change each interrogation\nmark in the template by filename,\nwhich is the module name with each dot replaced by a\n\"directory separator\" (such as \"/\" in Unix);\nthen it will try to open the resulting file name.\nSo, for instance, if the Lua path is the string\n\n

\n     \"./?.lua;./?.lc;/usr/local/?/init.lua\"\n

\nthe search for a Lua file for module foo\nwill try to open the files\n./foo.lua, ./foo.lc, and\n/usr/local/foo/init.lua, in that order.\n\n\n

\nThe third searcher looks for a loader as a C library,\nusing the path given by the variable package.cpath.\nFor instance,\nif the C path is the string\n\n

\n     \"./?.so;./?.dll;/usr/local/?/init.so\"\n

\nthe searcher for module foo\nwill try to open the files ./foo.so, ./foo.dll,\nand /usr/local/foo/init.so, in that order.\nOnce it finds a C library,\nthis searcher first uses a dynamic link facility to link the\napplication with the library.\nThen it tries to find a C function inside the library to\nbe used as the loader.\nThe name of this C function is the string \"luaopen_\"\nconcatenated with a copy of the module name where each dot\nis replaced by an underscore.\nMoreover, if the module name has a hyphen,\nits prefix up to (and including) the first hyphen is removed.\nFor instance, if the module name is a.v1-b.c,\nthe function name will be luaopen_b_c.\n\n\n

\nThe fourth searcher tries an all-in-one loader.\nIt searches the C path for a library for\nthe root name of the given module.\nFor instance, when requiring a.b.c,\nit will search for a C library for a.\nIf found, it looks into it for an open function for\nthe submodule;\nin our example, that would be luaopen_a_b_c.\nWith this facility, a package can pack several C submodules\ninto one single library,\nwith each submodule keeping its original open function.\n\n\n\n\n

\n

package.loadlib (libname, funcname)

\n\n\n

\nDynamically links the host program with the C library libname.\nInside this library, looks for a function funcname\nand returns this function as a C function.\n(So, funcname must follow the protocol (see lua_CFunction)).\n\n\n

\nThis is a low-level function.\nIt completely bypasses the package and module system.\nUnlike require,\nit does not perform any path searching and\ndoes not automatically adds extensions.\nlibname must be the complete file name of the C library,\nincluding if necessary a path and extension.\nfuncname must be the exact name exported by the C library\n(which may depend on the C compiler and linker used).\n\n\n

\nThis function is not supported by ANSI C.\nAs such, it is only available on some platforms\n(Windows, Linux, Mac OS X, Solaris, BSD,\nplus other Unix systems that support the dlfcn standard).\n\n\n\n\n

\n

package.path

\n\n\n

\nThe path used by require to search for a Lua loader.\n\n\n

\nAt start-up, Lua initializes this variable with\nthe value of the environment variable LUA_PATH or\nwith a default path defined in luaconf.h,\nif the environment variable is not defined.\nAny \";;\" in the value of the environment variable\nis replaced by the default path.\n\n\n\n\n

\n

package.preload

\n\n\n

\nA table to store loaders for specific modules\n(see require).\n\n\n\n\n

\n

package.seeall (module)

\n\n\n

\nSets a metatable for module with\nits __index field referring to the global environment,\nso that this module inherits values\nfrom the global environment.\nTo be used as an option to function module.\n\n\n\n\n\n\n\n

5.4 - String Manipulation

\n\n

\nThis library provides generic functions for string manipulation,\nsuch as finding and extracting substrings, and pattern matching.\nWhen indexing a string in Lua, the first character is at position 1\n(not at 0, as in C).\nIndices are allowed to be negative and are interpreted as indexing backwards,\nfrom the end of the string.\nThus, the last character is at position -1, and so on.\n\n\n

\nThe string library provides all its functions inside the table\nstring.\nIt also sets a metatable for strings\nwhere the __index field points to the string table.\nTherefore, you can use the string functions in object-oriented style.\nFor instance, string.byte(s, i)\ncan be written as s:byte(i).\n\n\n

\nThe string library assumes one-byte character encodings.\n\n\n

\n

string.byte (s [, i [, j]])

\nReturns the internal numerical codes of the characters s[i],\ns[i+1], ···, s[j].\nThe default value for i is 1;\nthe default value for j is i.\n\n\n

\nNote that numerical codes are not necessarily portable across platforms.\n\n\n\n\n

\n

string.char (···)

\nReceives zero or more integers.\nReturns a string with length equal to the number of arguments,\nin which each character has the internal numerical code equal\nto its corresponding argument.\n\n\n

\nNote that numerical codes are not necessarily portable across platforms.\n\n\n\n\n

\n

string.dump (function)

\n\n\n

\nReturns a string containing a binary representation of the given function,\nso that a later loadstring on this string returns\na copy of the function.\nfunction must be a Lua function without upvalues.\n\n\n\n\n

\n

string.find (s, pattern [, init [, plain]])

\nLooks for the first match of\npattern in the string s.\nIf it finds a match, then find returns the indices of s\nwhere this occurrence starts and ends;\notherwise, it returns nil.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.\nA value of true as a fourth, optional argument plain\nturns off the pattern matching facilities,\nso the function does a plain \"find substring\" operation,\nwith no characters in pattern being considered \"magic\".\nNote that if plain is given, then init must be given as well.\n\n\n

\nIf the pattern has captures,\nthen in a successful match\nthe captured values are also returned,\nafter the two indices.\n\n\n\n\n

\n

string.format (formatstring, ···)

\nReturns a formatted version of its variable number of arguments\nfollowing the description given in its first argument (which must be a string).\nThe format string follows the same rules as the printf family of\nstandard C functions.\nThe only differences are that the options/modifiers\n*, l, L, n, p,\nand h are not supported\nand that there is an extra option, q.\nThe q option formats a string in a form suitable to be safely read\nback by the Lua interpreter:\nthe string is written between double quotes,\nand all double quotes, newlines, embedded zeros,\nand backslashes in the string\nare correctly escaped when written.\nFor instance, the call\n\n
\n     string.format('%q', 'a string with \"quotes\" and \\n new line')\n

\nwill produce the string:\n\n

\n     \"a string with \\\"quotes\\\" and \\\n      new line\"\n
\n\n

\nThe options c, d, E, e, f,\ng, G, i, o, u, X, and x all\nexpect a number as argument,\nwhereas q and s expect a string.\n\n\n

\nThis function does not accept string values\ncontaining embedded zeros,\nexcept as arguments to the q option.\n\n\n\n\n

\n

string.gmatch (s, pattern)

\nReturns an iterator function that,\neach time it is called,\nreturns the next captures from pattern over string s.\nIf pattern specifies no captures,\nthen the whole match is produced in each call.\n\n\n

\nAs an example, the following loop\n\n

\n     s = \"hello world from Lua\"\n     for w in string.gmatch(s, \"%a+\") do\n       print(w)\n     end\n

\nwill iterate over all the words from string s,\nprinting one per line.\nThe next example collects all pairs key=value from the\ngiven string into a table:\n\n

\n     t = {}\n     s = \"from=world, to=Lua\"\n     for k, v in string.gmatch(s, \"(%w+)=(%w+)\") do\n       t[k] = v\n     end\n
\n\n

\nFor this function, a '^' at the start of a pattern does not\nwork as an anchor, as this would prevent the iteration.\n\n\n\n\n

\n

string.gsub (s, pattern, repl [, n])

\nReturns a copy of s\nin which all (or the first n, if given)\noccurrences of the pattern have been\nreplaced by a replacement string specified by repl,\nwhich can be a string, a table, or a function.\ngsub also returns, as its second value,\nthe total number of matches that occurred.\n\n\n

\nIf repl is a string, then its value is used for replacement.\nThe character % works as an escape character:\nany sequence in repl of the form %n,\nwith n between 1 and 9,\nstands for the value of the n-th captured substring (see below).\nThe sequence %0 stands for the whole match.\nThe sequence %% stands for a single %.\n\n\n

\nIf repl is a table, then the table is queried for every match,\nusing the first capture as the key;\nif the pattern specifies no captures,\nthen the whole match is used as the key.\n\n\n

\nIf repl is a function, then this function is called every time a\nmatch occurs, with all captured substrings passed as arguments,\nin order;\nif the pattern specifies no captures,\nthen the whole match is passed as a sole argument.\n\n\n

\nIf the value returned by the table query or by the function call\nis a string or a number,\nthen it is used as the replacement string;\notherwise, if it is false or nil,\nthen there is no replacement\n(that is, the original match is kept in the string).\n\n\n

\nHere are some examples:\n\n

\n     x = string.gsub(\"hello world\", \"(%w+)\", \"%1 %1\")\n     --> x=\"hello hello world world\"\n     \n     x = string.gsub(\"hello world\", \"%w+\", \"%0 %0\", 1)\n     --> x=\"hello hello world\"\n     \n     x = string.gsub(\"hello world from Lua\", \"(%w+)%s*(%w+)\", \"%2 %1\")\n     --> x=\"world hello Lua from\"\n     \n     x = string.gsub(\"home = $HOME, user = $USER\", \"%$(%w+)\", os.getenv)\n     --> x=\"home = /home/roberto, user = roberto\"\n     \n     x = string.gsub(\"4+5 = $return 4+5$\", \"%$(.-)%$\", function (s)\n           return loadstring(s)()\n         end)\n     --> x=\"4+5 = 9\"\n     \n     local t = {name=\"lua\", version=\"5.1\"}\n     x = string.gsub(\"$name-$version.tar.gz\", \"%$(%w+)\", t)\n     --> x=\"lua-5.1.tar.gz\"\n
\n\n\n\n

\n

string.len (s)

\nReceives a string and returns its length.\nThe empty string \"\" has length 0.\nEmbedded zeros are counted,\nso \"a\\000bc\\000\" has length 5.\n\n\n\n\n

\n

string.lower (s)

\nReceives a string and returns a copy of this string with all\nuppercase letters changed to lowercase.\nAll other characters are left unchanged.\nThe definition of what an uppercase letter is depends on the current locale.\n\n\n\n\n

\n

string.match (s, pattern [, init])

\nLooks for the first match of\npattern in the string s.\nIf it finds one, then match returns\nthe captures from the pattern;\notherwise it returns nil.\nIf pattern specifies no captures,\nthen the whole match is returned.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.\n\n\n\n\n

\n

string.rep (s, n)

\nReturns a string that is the concatenation of n copies of\nthe string s.\n\n\n\n\n

\n

string.reverse (s)

\nReturns a string that is the string s reversed.\n\n\n\n\n

\n

string.sub (s, i [, j])

\nReturns the substring of s that\nstarts at i and continues until j;\ni and j can be negative.\nIf j is absent, then it is assumed to be equal to -1\n(which is the same as the string length).\nIn particular,\nthe call string.sub(s,1,j) returns a prefix of s\nwith length j,\nand string.sub(s, -i) returns a suffix of s\nwith length i.\n\n\n\n\n

\n

string.upper (s)

\nReceives a string and returns a copy of this string with all\nlowercase letters changed to uppercase.\nAll other characters are left unchanged.\nThe definition of what a lowercase letter is depends on the current locale.\n\n\n\n

5.4.1 - Patterns

\n\n\n

Character Class:

\nA character class is used to represent a set of characters.\nThe following combinations are allowed in describing a character class:\n\n

    \n\n
  • x:\n(where x is not one of the magic characters\n^$()%.[]*+-?)\nrepresents the character x itself.\n
    • \n\n
  • .: (a dot) represents all characters.
    • \n\n
  • %a: represents all letters.
    • \n\n
  • %c: represents all control characters.
    • \n\n
  • %d: represents all digits.
    • \n\n
  • %l: represents all lowercase letters.
    • \n\n
  • %p: represents all punctuation characters.
    • \n\n
  • %s: represents all space characters.
    • \n\n
  • %u: represents all uppercase letters.
    • \n\n
  • %w: represents all alphanumeric characters.
    • \n\n
  • %x: represents all hexadecimal digits.
    • \n\n
  • %z: represents the character with representation 0.
    • \n\n
  • %x: (where x is any non-alphanumeric character)\nrepresents the character x.\nThis is the standard way to escape the magic characters.\nAny punctuation character (even the non magic)\ncan be preceded by a '%'\nwhen used to represent itself in a pattern.\n
    • \n\n
  • [set]:\nrepresents the class which is the union of all\ncharacters in set.\nA range of characters can be specified by\nseparating the end characters of the range with a '-'.\nAll classes %x described above can also be used as\ncomponents in set.\nAll other characters in set represent themselves.\nFor example, [%w_] (or [_%w])\nrepresents all alphanumeric characters plus the underscore,\n[0-7] represents the octal digits,\nand [0-7%l%-] represents the octal digits plus\nthe lowercase letters plus the '-' character.\n\n\n

    \nThe interaction between ranges and classes is not defined.\nTherefore, patterns like [%a-z] or [a-%%]\nhave no meaning.\n

    • \n\n
  • [^set]:\nrepresents the complement of set,\nwhere set is interpreted as above.\n
    • \n\n

\nFor all classes represented by single letters (%a, %c, etc.),\nthe corresponding uppercase letter represents the complement of the class.\nFor instance, %S represents all non-space characters.\n\n\n

\nThe definitions of letter, space, and other character groups\ndepend on the current locale.\nIn particular, the class [a-z] may not be equivalent to %l.\n\n\n\n\n\n

Pattern Item:

\nA pattern item can be\n\n

    \n\n
  • \na single character class,\nwhich matches any single character in the class;\n
    • \n\n
  • \na single character class followed by '*',\nwhich matches 0 or more repetitions of characters in the class.\nThese repetition items will always match the longest possible sequence;\n
    • \n\n
  • \na single character class followed by '+',\nwhich matches 1 or more repetitions of characters in the class.\nThese repetition items will always match the longest possible sequence;\n
    • \n\n
  • \na single character class followed by '-',\nwhich also matches 0 or more repetitions of characters in the class.\nUnlike '*',\nthese repetition items will always match the shortest possible sequence;\n
    • \n\n
  • \na single character class followed by '?',\nwhich matches 0 or 1 occurrence of a character in the class;\n
    • \n\n
  • \n%n, for n between 1 and 9;\nsuch item matches a substring equal to the n-th captured string\n(see below);\n
    • \n\n
  • \n%bxy, where x and y are two distinct characters;\nsuch item matches strings that start with x, end with y,\nand where the x and y are balanced.\nThis means that, if one reads the string from left to right,\ncounting +1 for an x and -1 for a y,\nthe ending y is the first y where the count reaches 0.\nFor instance, the item %b() matches expressions with\nbalanced parentheses.\n
    • \n\n
\n\n\n\n\n

Pattern:

\nA pattern is a sequence of pattern items.\nA '^' at the beginning of a pattern anchors the match at the\nbeginning of the subject string.\nA '$' at the end of a pattern anchors the match at the\nend of the subject string.\nAt other positions,\n'^' and '$' have no special meaning and represent themselves.\n\n\n\n\n\n

Captures:

\nA pattern can contain sub-patterns enclosed in parentheses;\nthey describe captures.\nWhen a match succeeds, the substrings of the subject string\nthat match captures are stored (captured) for future use.\nCaptures are numbered according to their left parentheses.\nFor instance, in the pattern \"(a*(.)%w(%s*))\",\nthe part of the string matching \"a*(.)%w(%s*)\" is\nstored as the first capture (and therefore has number 1);\nthe character matching \".\" is captured with number 2,\nand the part matching \"%s*\" has number 3.\n\n\n

\nAs a special case, the empty capture () captures\nthe current string position (a number).\nFor instance, if we apply the pattern \"()aa()\" on the\nstring \"flaaap\", there will be two captures: 3 and 5.\n\n\n

\nA pattern cannot contain embedded zeros. Use %z instead.\n\n\n\n\n\n\n\n\n\n\n\n

5.5 - Table Manipulation

\nThis library provides generic functions for table manipulation.\nIt provides all its functions inside the table table.\n\n\n

\nMost functions in the table library assume that the table\nrepresents an array or a list.\nFor these functions, when we talk about the \"length\" of a table\nwe mean the result of the length operator.\n\n\n

\n

table.concat (table [, sep [, i [, j]]])

\nGiven an array where all elements are strings or numbers,\nreturns table[i]..sep..table[i+1] ··· sep..table[j].\nThe default value for sep is the empty string,\nthe default for i is 1,\nand the default for j is the length of the table.\nIf i is greater than j, returns the empty string.\n\n\n\n\n

\n

table.insert (table, [pos,] value)

\n\n\n

\nInserts element value at position pos in table,\nshifting up other elements to open space, if necessary.\nThe default value for pos is n+1,\nwhere n is the length of the table (see §2.5.5),\nso that a call table.insert(t,x) inserts x at the end\nof table t.\n\n\n\n\n

\n

table.maxn (table)

\n\n\n

\nReturns the largest positive numerical index of the given table,\nor zero if the table has no positive numerical indices.\n(To do its job this function does a linear traversal of\nthe whole table.) \n\n\n\n\n

\n

table.remove (table [, pos])

\n\n\n

\nRemoves from table the element at position pos,\nshifting down other elements to close the space, if necessary.\nReturns the value of the removed element.\nThe default value for pos is n,\nwhere n is the length of the table,\nso that a call table.remove(t) removes the last element\nof table t.\n\n\n\n\n

\n

table.sort (table [, comp])

\nSorts table elements in a given order, in-place,\nfrom table[1] to table[n],\nwhere n is the length of the table.\nIf comp is given,\nthen it must be a function that receives two table elements,\nand returns true\nwhen the first is less than the second\n(so that not comp(a[i+1],a[i]) will be true after the sort).\nIf comp is not given,\nthen the standard Lua operator < is used instead.\n\n\n

\nThe sort algorithm is not stable;\nthat is, elements considered equal by the given order\nmay have their relative positions changed by the sort.\n\n\n\n\n\n\n\n

5.6 - Mathematical Functions

\n\n

\nThis library is an interface to the standard C math library.\nIt provides all its functions inside the table math.\n\n\n

\n

math.abs (x)

\n\n\n

\nReturns the absolute value of x.\n\n\n\n\n

\n

math.acos (x)

\n\n\n

\nReturns the arc cosine of x (in radians).\n\n\n\n\n

\n

math.asin (x)

\n\n\n

\nReturns the arc sine of x (in radians).\n\n\n\n\n

\n

math.atan (x)

\n\n\n

\nReturns the arc tangent of x (in radians).\n\n\n\n\n

\n

math.atan2 (y, x)

\n\n\n

\nReturns the arc tangent of y/x (in radians),\nbut uses the signs of both parameters to find the\nquadrant of the result.\n(It also handles correctly the case of x being zero.)\n\n\n\n\n

\n

math.ceil (x)

\n\n\n

\nReturns the smallest integer larger than or equal to x.\n\n\n\n\n

\n

math.cos (x)

\n\n\n

\nReturns the cosine of x (assumed to be in radians).\n\n\n\n\n

\n

math.cosh (x)

\n\n\n

\nReturns the hyperbolic cosine of x.\n\n\n\n\n

\n

math.deg (x)

\n\n\n

\nReturns the angle x (given in radians) in degrees.\n\n\n\n\n

\n

math.exp (x)

\n\n\n

\nReturns the value ex.\n\n\n\n\n

\n

math.floor (x)

\n\n\n

\nReturns the largest integer smaller than or equal to x.\n\n\n\n\n

\n

math.fmod (x, y)

\n\n\n

\nReturns the remainder of the division of x by y\nthat rounds the quotient towards zero.\n\n\n\n\n

\n

math.frexp (x)

\n\n\n

\nReturns m and e such that x = m2e,\ne is an integer and the absolute value of m is\nin the range [0.5, 1)\n(or zero when x is zero).\n\n\n\n\n

\n

math.huge

\n\n\n

\nThe value HUGE_VAL,\na value larger than or equal to any other numerical value.\n\n\n\n\n

\n

math.ldexp (m, e)

\n\n\n

\nReturns m2e (e should be an integer).\n\n\n\n\n

\n

math.log (x)

\n\n\n

\nReturns the natural logarithm of x.\n\n\n\n\n

\n

math.log10 (x)

\n\n\n

\nReturns the base-10 logarithm of x.\n\n\n\n\n

\n

math.max (x, ···)

\n\n\n

\nReturns the maximum value among its arguments.\n\n\n\n\n

\n

math.min (x, ···)

\n\n\n

\nReturns the minimum value among its arguments.\n\n\n\n\n

\n

math.modf (x)

\n\n\n

\nReturns two numbers,\nthe integral part of x and the fractional part of x.\n\n\n\n\n

\n

math.pi

\n\n\n

\nThe value of pi.\n\n\n\n\n

\n

math.pow (x, y)

\n\n\n

\nReturns xy.\n(You can also use the expression x^y to compute this value.)\n\n\n\n\n

\n

math.rad (x)

\n\n\n

\nReturns the angle x (given in degrees) in radians.\n\n\n\n\n

\n

math.random ([m [, n]])

\n\n\n

\nThis function is an interface to the simple\npseudo-random generator function rand provided by ANSI C.\n(No guarantees can be given for its statistical properties.)\n\n\n

\nWhen called without arguments,\nreturns a uniform pseudo-random real number\nin the range [0,1). \nWhen called with an integer number m,\nmath.random returns\na uniform pseudo-random integer in the range [1, m].\nWhen called with two integer numbers m and n,\nmath.random returns a uniform pseudo-random\ninteger in the range [m, n].\n\n\n\n\n

\n

math.randomseed (x)

\n\n\n

\nSets x as the \"seed\"\nfor the pseudo-random generator:\nequal seeds produce equal sequences of numbers.\n\n\n\n\n

\n

math.sin (x)

\n\n\n

\nReturns the sine of x (assumed to be in radians).\n\n\n\n\n

\n

math.sinh (x)

\n\n\n

\nReturns the hyperbolic sine of x.\n\n\n\n\n

\n

math.sqrt (x)

\n\n\n

\nReturns the square root of x.\n(You can also use the expression x^0.5 to compute this value.)\n\n\n\n\n

\n

math.tan (x)

\n\n\n

\nReturns the tangent of x (assumed to be in radians).\n\n\n\n\n

\n

math.tanh (x)

\n\n\n

\nReturns the hyperbolic tangent of x.\n\n\n\n\n\n\n\n

5.7 - Input and Output Facilities

\n\n

\nThe I/O library provides two different styles for file manipulation.\nThe first one uses implicit file descriptors;\nthat is, there are operations to set a default input file and a\ndefault output file,\nand all input/output operations are over these default files.\nThe second style uses explicit file descriptors.\n\n\n

\nWhen using implicit file descriptors,\nall operations are supplied by table io.\nWhen using explicit file descriptors,\nthe operation io.open returns a file descriptor\nand then all operations are supplied as methods of the file descriptor.\n\n\n

\nThe table io also provides\nthree predefined file descriptors with their usual meanings from C:\nio.stdin, io.stdout, and io.stderr.\nThe I/O library never closes these files.\n\n\n

\nUnless otherwise stated,\nall I/O functions return nil on failure\n(plus an error message as a second result and\na system-dependent error code as a third result)\nand some value different from nil on success.\n\n\n

\n

io.close ([file])

\n\n\n

\nEquivalent to file:close().\nWithout a file, closes the default output file.\n\n\n\n\n

\n

io.flush ()

\n\n\n

\nEquivalent to file:flush over the default output file.\n\n\n\n\n

\n

io.input ([file])

\n\n\n

\nWhen called with a file name, it opens the named file (in text mode),\nand sets its handle as the default input file.\nWhen called with a file handle,\nit simply sets this file handle as the default input file.\nWhen called without parameters,\nit returns the current default input file.\n\n\n

\nIn case of errors this function raises the error,\ninstead of returning an error code.\n\n\n\n\n

\n

io.lines ([filename])

\n\n\n

\nOpens the given file name in read mode\nand returns an iterator function that,\neach time it is called,\nreturns a new line from the file.\nTherefore, the construction\n\n

\n     for line in io.lines(filename) do body end\n

\nwill iterate over all lines of the file.\nWhen the iterator function detects the end of file,\nit returns nil (to finish the loop) and automatically closes the file.\n\n\n

\nThe call io.lines() (with no file name) is equivalent\nto io.input():lines();\nthat is, it iterates over the lines of the default input file.\nIn this case it does not close the file when the loop ends.\n\n\n\n\n

\n

io.open (filename [, mode])

\n\n\n

\nThis function opens a file,\nin the mode specified in the string mode.\nIt returns a new file handle,\nor, in case of errors, nil plus an error message.\n\n\n

\nThe mode string can be any of the following:\n\n

    \n
  • \"r\": read mode (the default);
    • \n
  • \"w\": write mode;
    • \n
  • \"a\": append mode;
    • \n
  • \"r+\": update mode, all previous data is preserved;
    • \n
  • \"w+\": update mode, all previous data is erased;
    • \n
  • \"a+\": append update mode, previous data is preserved,\n writing is only allowed at the end of file.
    • \n

\nThe mode string can also have a 'b' at the end,\nwhich is needed in some systems to open the file in binary mode.\nThis string is exactly what is used in the\nstandard C function fopen.\n\n\n\n\n

\n

io.output ([file])

\n\n\n

\nSimilar to io.input, but operates over the default output file.\n\n\n\n\n

\n

io.popen (prog [, mode])

\n\n\n

\nStarts program prog in a separated process and returns\na file handle that you can use to read data from this program\n(if mode is \"r\", the default)\nor to write data to this program\n(if mode is \"w\").\n\n\n

\nThis function is system dependent and is not available\non all platforms.\n\n\n\n\n

\n

io.read (···)

\n\n\n

\nEquivalent to io.input():read.\n\n\n\n\n

\n

io.tmpfile ()

\n\n\n

\nReturns a handle for a temporary file.\nThis file is opened in update mode\nand it is automatically removed when the program ends.\n\n\n\n\n

\n

io.type (obj)

\n\n\n

\nChecks whether obj is a valid file handle.\nReturns the string \"file\" if obj is an open file handle,\n\"closed file\" if obj is a closed file handle,\nor nil if obj is not a file handle.\n\n\n\n\n

\n

io.write (···)

\n\n\n

\nEquivalent to io.output():write.\n\n\n\n\n

\n

file:close ()

\n\n\n

\nCloses file.\nNote that files are automatically closed when\ntheir handles are garbage collected,\nbut that takes an unpredictable amount of time to happen.\n\n\n\n\n

\n

file:flush ()

\n\n\n

\nSaves any written data to file.\n\n\n\n\n

\n

file:lines ()

\n\n\n

\nReturns an iterator function that,\neach time it is called,\nreturns a new line from the file.\nTherefore, the construction\n\n

\n     for line in file:lines() do body end\n

\nwill iterate over all lines of the file.\n(Unlike io.lines, this function does not close the file\nwhen the loop ends.)\n\n\n\n\n

\n

file:read (···)

\n\n\n

\nReads the file file,\naccording to the given formats, which specify what to read.\nFor each format,\nthe function returns a string (or a number) with the characters read,\nor nil if it cannot read data with the specified format.\nWhen called without formats,\nit uses a default format that reads the entire next line\n(see below).\n\n\n

\nThe available formats are\n\n

    \n\n
  • \"*n\":\nreads a number;\nthis is the only format that returns a number instead of a string.\n
    • \n\n
  • \"*a\":\nreads the whole file, starting at the current position.\nOn end of file, it returns the empty string.\n
    • \n\n
  • \"*l\":\nreads the next line (skipping the end of line),\nreturning nil on end of file.\nThis is the default format.\n
    • \n\n
  • number:\nreads a string with up to this number of characters,\nreturning nil on end of file.\nIf number is zero,\nit reads nothing and returns an empty string,\nor nil on end of file.\n
    • \n\n
\n\n\n\n

\n

file:seek ([whence] [, offset])

\n\n\n

\nSets and gets the file position,\nmeasured from the beginning of the file,\nto the position given by offset plus a base\nspecified by the string whence, as follows:\n\n

    \n
  • \"set\": base is position 0 (beginning of the file);
    • \n
  • \"cur\": base is current position;
    • \n
  • \"end\": base is end of file;
    • \n

\nIn case of success, function seek returns the final file position,\nmeasured in bytes from the beginning of the file.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n

\nThe default value for whence is \"cur\",\nand for offset is 0.\nTherefore, the call file:seek() returns the current\nfile position, without changing it;\nthe call file:seek(\"set\") sets the position to the\nbeginning of the file (and returns 0);\nand the call file:seek(\"end\") sets the position to the\nend of the file, and returns its size.\n\n\n\n\n

\n

file:setvbuf (mode [, size])

\n\n\n

\nSets the buffering mode for an output file.\nThere are three available modes:\n\n

    \n\n
  • \"no\":\nno buffering; the result of any output operation appears immediately.\n
    • \n\n
  • \"full\":\nfull buffering; output operation is performed only\nwhen the buffer is full (or when you explicitly flush the file\n(see io.flush)).\n
    • \n\n
  • \"line\":\nline buffering; output is buffered until a newline is output\nor there is any input from some special files\n(such as a terminal device).\n
    • \n\n

\nFor the last two cases, size\nspecifies the size of the buffer, in bytes.\nThe default is an appropriate size.\n\n\n\n\n

\n

file:write (···)

\n\n\n

\nWrites the value of each of its arguments to\nthe file.\nThe arguments must be strings or numbers.\nTo write other values,\nuse tostring or string.format before write.\n\n\n\n\n\n\n\n

5.8 - Operating System Facilities

\n\n

\nThis library is implemented through table os.\n\n\n

\n

os.clock ()

\n\n\n

\nReturns an approximation of the amount in seconds of CPU time\nused by the program.\n\n\n\n\n

\n

os.date ([format [, time]])

\n\n\n

\nReturns a string or a table containing date and time,\nformatted according to the given string format.\n\n\n

\nIf the time argument is present,\nthis is the time to be formatted\n(see the os.time function for a description of this value).\nOtherwise, date formats the current time.\n\n\n

\nIf format starts with '!',\nthen the date is formatted in Coordinated Universal Time.\nAfter this optional character,\nif format is the string \"*t\",\nthen date returns a table with the following fields:\nyear (four digits), month (1--12), day (1--31),\nhour (0--23), min (0--59), sec (0--61),\nwday (weekday, Sunday is 1),\nyday (day of the year),\nand isdst (daylight saving flag, a boolean).\n\n\n

\nIf format is not \"*t\",\nthen date returns the date as a string,\nformatted according to the same rules as the C function strftime.\n\n\n

\nWhen called without arguments,\ndate returns a reasonable date and time representation that depends on\nthe host system and on the current locale\n(that is, os.date() is equivalent to os.date(\"%c\")).\n\n\n\n\n

\n

os.difftime (t2, t1)

\n\n\n

\nReturns the number of seconds from time t1 to time t2.\nIn POSIX, Windows, and some other systems,\nthis value is exactly t2-t1.\n\n\n\n\n

\n

os.execute ([command])

\n\n\n

\nThis function is equivalent to the C function system.\nIt passes command to be executed by an operating system shell.\nIt returns a status code, which is system-dependent.\nIf command is absent, then it returns nonzero if a shell is available\nand zero otherwise.\n\n\n\n\n

\n

os.exit ([code])

\n\n\n

\nCalls the C function exit,\nwith an optional code,\nto terminate the host program.\nThe default value for code is the success code.\n\n\n\n\n

\n

os.getenv (varname)

\n\n\n

\nReturns the value of the process environment variable varname,\nor nil if the variable is not defined.\n\n\n\n\n

\n

os.remove (filename)

\n\n\n

\nDeletes the file or directory with the given name.\nDirectories must be empty to be removed.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n\n\n

\n

os.rename (oldname, newname)

\n\n\n

\nRenames file or directory named oldname to newname.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n\n\n

\n

os.setlocale (locale [, category])

\n\n\n

\nSets the current locale of the program.\nlocale is a string specifying a locale;\ncategory is an optional string describing which category to change:\n\"all\", \"collate\", \"ctype\",\n\"monetary\", \"numeric\", or \"time\";\nthe default category is \"all\".\nThe function returns the name of the new locale,\nor nil if the request cannot be honored.\n\n\n

\nIf locale is the empty string,\nthe current locale is set to an implementation-defined native locale.\nIf locale is the string \"C\",\nthe current locale is set to the standard C locale.\n\n\n

\nWhen called with nil as the first argument,\nthis function only returns the name of the current locale\nfor the given category.\n\n\n\n\n

\n

os.time ([table])

\n\n\n

\nReturns the current time when called without arguments,\nor a time representing the date and time specified by the given table.\nThis table must have fields year, month, and day,\nand may have fields hour, min, sec, and isdst\n(for a description of these fields, see the os.date function).\n\n\n

\nThe returned value is a number, whose meaning depends on your system.\nIn POSIX, Windows, and some other systems, this number counts the number\nof seconds since some given start time (the \"epoch\").\nIn other systems, the meaning is not specified,\nand the number returned by time can be used only as an argument to\ndate and difftime.\n\n\n\n\n

\n

os.tmpname ()

\n\n\n

\nReturns a string with a file name that can\nbe used for a temporary file.\nThe file must be explicitly opened before its use\nand explicitly removed when no longer needed.\n\n\n

\nOn some systems (POSIX),\nthis function also creates a file with that name,\nto avoid security risks.\n(Someone else might create the file with wrong permissions\nin the time between getting the name and creating the file.)\nYou still have to open the file to use it\nand to remove it (even if you do not use it).\n\n\n

\nWhen possible,\nyou may prefer to use io.tmpfile,\nwhich automatically removes the file when the program ends.\n\n\n\n\n\n\n\n

5.9 - The Debug Library

\n\n

\nThis library provides\nthe functionality of the debug interface to Lua programs.\nYou should exert care when using this library.\nThe functions provided here should be used exclusively for debugging\nand similar tasks, such as profiling.\nPlease resist the temptation to use them as a\nusual programming tool:\nthey can be very slow.\nMoreover, several of these functions\nviolate some assumptions about Lua code\n(e.g., that variables local to a function\ncannot be accessed from outside or\nthat userdata metatables cannot be changed by Lua code)\nand therefore can compromise otherwise secure code.\n\n\n

\nAll functions in this library are provided\ninside the debug table.\nAll functions that operate over a thread\nhave an optional first argument which is the\nthread to operate over.\nThe default is always the current thread.\n\n\n

\n

debug.debug ()

\n\n\n

\nEnters an interactive mode with the user,\nrunning each string that the user enters.\nUsing simple commands and other debug facilities,\nthe user can inspect global and local variables,\nchange their values, evaluate expressions, and so on.\nA line containing only the word cont finishes this function,\nso that the caller continues its execution.\n\n\n

\nNote that commands for debug.debug are not lexically nested\nwithin any function, and so have no direct access to local variables.\n\n\n\n\n

\n

debug.getfenv (o)

\nReturns the environment of object o.\n\n\n\n\n

\n

debug.gethook ([thread])

\n\n\n

\nReturns the current hook settings of the thread, as three values:\nthe current hook function, the current hook mask,\nand the current hook count\n(as set by the debug.sethook function).\n\n\n\n\n

\n

debug.getinfo ([thread,] function [, what])

\n\n\n

\nReturns a table with information about a function.\nYou can give the function directly,\nor you can give a number as the value of function,\nwhich means the function running at level function of the call stack\nof the given thread:\nlevel 0 is the current function (getinfo itself);\nlevel 1 is the function that called getinfo;\nand so on.\nIf function is a number larger than the number of active functions,\nthen getinfo returns nil.\n\n\n

\nThe returned table can contain all the fields returned by lua_getinfo,\nwith the string what describing which fields to fill in.\nThe default for what is to get all information available,\nexcept the table of valid lines.\nIf present,\nthe option 'f'\nadds a field named func with the function itself.\nIf present,\nthe option 'L'\nadds a field named activelines with the table of\nvalid lines.\n\n\n

\nFor instance, the expression debug.getinfo(1,\"n\").name returns\na table with a name for the current function,\nif a reasonable name can be found,\nand the expression debug.getinfo(print)\nreturns a table with all available information\nabout the print function.\n\n\n\n\n

\n

debug.getlocal ([thread,] level, local)

\n\n\n

\nThis function returns the name and the value of the local variable\nwith index local of the function at level level of the stack.\n(The first parameter or local variable has index 1, and so on,\nuntil the last active local variable.)\nThe function returns nil if there is no local\nvariable with the given index,\nand raises an error when called with a level out of range.\n(You can call debug.getinfo to check whether the level is valid.)\n\n\n

\nVariable names starting with '(' (open parentheses)\nrepresent internal variables\n(loop control variables, temporaries, and C function locals).\n\n\n\n\n

\n

debug.getmetatable (object)

\n\n\n

\nReturns the metatable of the given object\nor nil if it does not have a metatable.\n\n\n\n\n

\n

debug.getregistry ()

\n\n\n

\nReturns the registry table (see §3.5).\n\n\n\n\n

\n

debug.getupvalue (func, up)

\n\n\n

\nThis function returns the name and the value of the upvalue\nwith index up of the function func.\nThe function returns nil if there is no upvalue with the given index.\n\n\n\n\n

\n

debug.setfenv (object, table)

\n\n\n

\nSets the environment of the given object to the given table.\nReturns object.\n\n\n\n\n

\n

debug.sethook ([thread,] hook, mask [, count])

\n\n\n

\nSets the given function as a hook.\nThe string mask and the number count describe\nwhen the hook will be called.\nThe string mask may have the following characters,\nwith the given meaning:\n\n

    \n
  • \"c\": the hook is called every time Lua calls a function;
    • \n
  • \"r\": the hook is called every time Lua returns from a function;
    • \n
  • \"l\": the hook is called every time Lua enters a new line of code.
    • \n

\nWith a count different from zero,\nthe hook is called after every count instructions.\n\n\n

\nWhen called without arguments,\ndebug.sethook turns off the hook.\n\n\n

\nWhen the hook is called, its first parameter is a string\ndescribing the event that has triggered its call:\n\"call\", \"return\" (or \"tail return\",\nwhen simulating a return from a tail call),\n\"line\", and \"count\".\nFor line events,\nthe hook also gets the new line number as its second parameter.\nInside a hook,\nyou can call getinfo with level 2 to get more information about\nthe running function\n(level 0 is the getinfo function,\nand level 1 is the hook function),\nunless the event is \"tail return\".\nIn this case, Lua is only simulating the return,\nand a call to getinfo will return invalid data.\n\n\n\n\n

\n

debug.setlocal ([thread,] level, local, value)

\n\n\n

\nThis function assigns the value value to the local variable\nwith index local of the function at level level of the stack.\nThe function returns nil if there is no local\nvariable with the given index,\nand raises an error when called with a level out of range.\n(You can call getinfo to check whether the level is valid.)\nOtherwise, it returns the name of the local variable.\n\n\n\n\n

\n

debug.setmetatable (object, table)

\n\n\n

\nSets the metatable for the given object to the given table\n(which can be nil).\n\n\n\n\n

\n

debug.setupvalue (func, up, value)

\n\n\n

\nThis function assigns the value value to the upvalue\nwith index up of the function func.\nThe function returns nil if there is no upvalue\nwith the given index.\nOtherwise, it returns the name of the upvalue.\n\n\n\n\n

\n

debug.traceback ([thread,] [message [, level]])

\n\n\n

\nReturns a string with a traceback of the call stack.\nAn optional message string is appended\nat the beginning of the traceback.\nAn optional level number tells at which level\nto start the traceback\n(default is 1, the function calling traceback).\n\n\n\n\n\n\n\n

6 - Lua Stand-alone

\n\n

\nAlthough Lua has been designed as an extension language,\nto be embedded in a host C program,\nit is also frequently used as a stand-alone language.\nAn interpreter for Lua as a stand-alone language,\ncalled simply lua,\nis provided with the standard distribution.\nThe stand-alone interpreter includes\nall standard libraries, including the debug library.\nIts usage is:\n\n

\n     lua [options] [script [args]]\n

\nThe options are:\n\n

    \n
  • -e stat: executes string stat;
    • \n
  • -l mod: \"requires\" mod;
    • \n
  • -i: enters interactive mode after running script;
    • \n
  • -v: prints version information;
    • \n
  • --: stops handling options;
    • \n
  • -: executes stdin as a file and stops handling options.
    • \n

\nAfter handling its options, lua runs the given script,\npassing to it the given args as string arguments.\nWhen called without arguments,\nlua behaves as lua -v -i\nwhen the standard input (stdin) is a terminal,\nand as lua - otherwise.\n\n\n

\nBefore running any argument,\nthe interpreter checks for an environment variable LUA_INIT.\nIf its format is @filename,\nthen lua executes the file.\nOtherwise, lua executes the string itself.\n\n\n

\nAll options are handled in order, except -i.\nFor instance, an invocation like\n\n

\n     $ lua -e'a=1' -e 'print(a)' script.lua\n

\nwill first set a to 1, then print the value of a (which is '1'),\nand finally run the file script.lua with no arguments.\n(Here $ is the shell prompt. Your prompt may be different.)\n\n\n

\nBefore starting to run the script,\nlua collects all arguments in the command line\nin a global table called arg.\nThe script name is stored at index 0,\nthe first argument after the script name goes to index 1,\nand so on.\nAny arguments before the script name\n(that is, the interpreter name plus the options)\ngo to negative indices.\nFor instance, in the call\n\n

\n     $ lua -la b.lua t1 t2\n

\nthe interpreter first runs the file a.lua,\nthen creates a table\n\n

\n     arg = { [-2] = \"lua\", [-1] = \"-la\",\n             [0] = \"b.lua\",\n             [1] = \"t1\", [2] = \"t2\" }\n

\nand finally runs the file b.lua.\nThe script is called with arg[1], arg[2], ···\nas arguments;\nit can also access these arguments with the vararg expression '...'.\n\n\n

\nIn interactive mode,\nif you write an incomplete statement,\nthe interpreter waits for its completion\nby issuing a different prompt.\n\n\n

\nIf the global variable _PROMPT contains a string,\nthen its value is used as the prompt.\nSimilarly, if the global variable _PROMPT2 contains a string,\nits value is used as the secondary prompt\n(issued during incomplete statements).\nTherefore, both prompts can be changed directly on the command line\nor in any Lua programs by assigning to _PROMPT.\nSee the next example:\n\n

\n     $ lua -e\"_PROMPT='myprompt> '\" -i\n

\n(The outer pair of quotes is for the shell,\nthe inner pair is for Lua.)\nNote the use of -i to enter interactive mode;\notherwise,\nthe program would just end silently\nright after the assignment to _PROMPT.\n\n\n

\nTo allow the use of Lua as a\nscript interpreter in Unix systems,\nthe stand-alone interpreter skips\nthe first line of a chunk if it starts with #.\nTherefore, Lua scripts can be made into executable programs\nby using chmod +x and the #! form,\nas in\n\n

\n     #!/usr/local/bin/lua\n

\n(Of course,\nthe location of the Lua interpreter may be different in your machine.\nIf lua is in your PATH,\nthen \n\n

\n     #!/usr/bin/env lua\n

\nis a more portable solution.) \n\n\n\n

7 - Incompatibilities with the Previous Version

\n\n

\nHere we list the incompatibilities that you may find when moving a program\nfrom Lua 5.0 to Lua 5.1.\nYou can avoid most of the incompatibilities compiling Lua with\nappropriate options (see file luaconf.h).\nHowever,\nall these compatibility options will be removed in the next version of Lua.\n\n\n\n

7.1 - Changes in the Language

\n
    \n\n
  • \nThe vararg system changed from the pseudo-argument arg with a\ntable with the extra arguments to the vararg expression.\n(See compile-time option LUA_COMPAT_VARARG in luaconf.h.)\n
    • \n\n
  • \nThere was a subtle change in the scope of the implicit\nvariables of the for statement and for the repeat statement.\n
    • \n\n
  • \nThe long string/long comment syntax ([[string]])\ndoes not allow nesting.\nYou can use the new syntax ([=[string]=]) in these cases.\n(See compile-time option LUA_COMPAT_LSTR in luaconf.h.)\n
    • \n\n
\n\n\n\n\n

7.2 - Changes in the Libraries

\n
    \n\n
  • \nFunction string.gfind was renamed string.gmatch.\n(See compile-time option LUA_COMPAT_GFIND in luaconf.h.)\n
    • \n\n
  • \nWhen string.gsub is called with a function as its\nthird argument,\nwhenever this function returns nil or false the\nreplacement string is the whole match,\ninstead of the empty string.\n
    • \n\n
  • \nFunction table.setn was deprecated.\nFunction table.getn corresponds\nto the new length operator (#);\nuse the operator instead of the function.\n(See compile-time option LUA_COMPAT_GETN in luaconf.h.)\n
    • \n\n
  • \nFunction loadlib was renamed package.loadlib.\n(See compile-time option LUA_COMPAT_LOADLIB in luaconf.h.)\n
    • \n\n
  • \nFunction math.mod was renamed math.fmod.\n(See compile-time option LUA_COMPAT_MOD in luaconf.h.)\n
    • \n\n
  • \nFunctions table.foreach and table.foreachi are deprecated.\nYou can use a for loop with pairs or ipairs instead.\n
    • \n\n
  • \nThere were substantial changes in function require due to\nthe new module system.\nHowever, the new behavior is mostly compatible with the old,\nbut require gets the path from package.path instead\nof from LUA_PATH.\n
    • \n\n
  • \nFunction collectgarbage has different arguments.\nFunction gcinfo is deprecated;\nuse collectgarbage(\"count\") instead.\n
    • \n\n
\n\n\n\n\n

7.3 - Changes in the API

\n
    \n\n
  • \nThe luaopen_* functions (to open libraries)\ncannot be called directly,\nlike a regular C function.\nThey must be called through Lua,\nlike a Lua function.\n
    • \n\n
  • \nFunction lua_open was replaced by lua_newstate to\nallow the user to set a memory-allocation function.\nYou can use luaL_newstate from the standard library to\ncreate a state with a standard allocation function\n(based on realloc).\n
    • \n\n
  • \nFunctions luaL_getn and luaL_setn\n(from the auxiliary library) are deprecated.\nUse lua_objlen instead of luaL_getn\nand nothing instead of luaL_setn.\n
    • \n\n
  • \nFunction luaL_openlib was replaced by luaL_register.\n
    • \n\n
  • \nFunction luaL_checkudata now throws an error when the given value\nis not a userdata of the expected type.\n(In Lua 5.0 it returned NULL.)\n
    • \n\n
\n\n\n\n\n

8 - The Complete Syntax of Lua

\n\n

\nHere is the complete syntax of Lua in extended BNF.\n(It does not describe operator precedences.)\n\n\n\n\n

\n\n\tchunk ::= {stat [`;´]} [laststat [`;´]]\n\n\tblock ::= chunk\n\n\tstat ::=  varlist `=´ explist | \n\t\t functioncall | \n\t\t do block end | \n\t\t while exp do block end | \n\t\t repeat block until exp | \n\t\t if exp then block {elseif exp then block} [else block] end | \n\t\t for Name `=´ exp `,´ exp [`,´ exp] do block end | \n\t\t for namelist in explist do block end | \n\t\t function funcname funcbody | \n\t\t local function Name funcbody | \n\t\t local namelist [`=´ explist] \n\n\tlaststat ::= return [explist] | break\n\n\tfuncname ::= Name {`.´ Name} [`:´ Name]\n\n\tvarlist ::= var {`,´ var}\n\n\tvar ::=  Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name \n\n\tnamelist ::= Name {`,´ Name}\n\n\texplist ::= {exp `,´} exp\n\n\texp ::=  nil | false | true | Number | String | `...´ | function | \n\t\t prefixexp | tableconstructor | exp binop exp | unop exp \n\n\tprefixexp ::= var | functioncall | `(´ exp `)´\n\n\tfunctioncall ::=  prefixexp args | prefixexp `:´ Name args \n\n\targs ::=  `(´ [explist] `)´ | tableconstructor | String \n\n\tfunction ::= function funcbody\n\n\tfuncbody ::= `(´ [parlist] `)´ block end\n\n\tparlist ::= namelist [`,´ `...´] | `...´\n\n\ttableconstructor ::= `{´ [fieldlist] `}´\n\n\tfieldlist ::= field {fieldsep field} [fieldsep]\n\n\tfield ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp\n\n\tfieldsep ::= `,´ | `;´\n\n\tbinop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ | \n\t\t `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ | \n\t\t and | or\n\n\tunop ::= `-´ | not | `#´\n\n
\n\n

\n\n\n\n\n\n\n\n

\n\nLast update:\nMon Feb 13 18:54:19 BRST 2012\n\n\n\n\n\n" }, { "path": "deps/lua/doc/readme.html", "content": "\n\nLua documentation\n\n\n\n\n\n
\n

\n\"Lua\"\nDocumentation\n

\n\nThis is the documentation included in the source distribution of Lua 5.1.5.\n\n\n\nLua's\nofficial web site\ncontains updated documentation,\nespecially the\nreference manual.\n

\n\n

\n\nLast update:\nFri Feb 3 09:44:42 BRST 2012\n\n\n\n\n" }, { "path": "deps/lua/etc/Makefile", "content": "# makefile for Lua etc\n\nTOP= ..\nLIB= $(TOP)/src\nINC= $(TOP)/src\nBIN= $(TOP)/src\nSRC= $(TOP)/src\nTST= $(TOP)/test\n\nCC= gcc\nCFLAGS= -O2 -Wall -I$(INC) $(MYCFLAGS)\nMYCFLAGS= \nMYLDFLAGS= -Wl,-E\nMYLIBS= -lm\n#MYLIBS= -lm -Wl,-E -ldl -lreadline -lhistory -lncurses\nRM= rm -f\n\ndefault:\n\t@echo 'Please choose a target: min noparser one strict clean'\n\nmin:\tmin.c\n\t$(CC) $(CFLAGS) $@.c -L$(LIB) -llua $(MYLIBS)\n\techo 'print\"Hello there!\"' | ./a.out\n\nnoparser: noparser.o\n\t$(CC) noparser.o $(SRC)/lua.o -L$(LIB) -llua $(MYLIBS)\n\t$(BIN)/luac $(TST)/hello.lua\n\t-./a.out luac.out\n\t-./a.out -e'a=1'\n\none:\n\t$(CC) $(CFLAGS) all.c $(MYLIBS)\n\t./a.out $(TST)/hello.lua\n\nstrict:\n\t-$(BIN)/lua -e 'print(a);b=2'\n\t-$(BIN)/lua -lstrict -e 'print(a)'\n\t-$(BIN)/lua -e 'function f() b=2 end f()'\n\t-$(BIN)/lua -lstrict -e 'function f() b=2 end f()'\n\nclean:\n\t$(RM) a.out core core.* *.o luac.out\n\n.PHONY:\tdefault min noparser one strict clean\n" }, { "path": "deps/lua/etc/README", "content": "This directory contains some useful files and code.\nUnlike the code in ../src, everything here is in the public domain.\n\nIf any of the makes fail, you're probably not using the same libraries\nused to build Lua. Set MYLIBS in Makefile accordingly.\n\nall.c\n\tFull Lua interpreter in a single file.\n\tDo \"make one\" for a demo.\n\nlua.hpp\n\tLua header files for C++ using 'extern \"C\"'.\n\nlua.ico\n\tA Lua icon for Windows (and web sites: save as favicon.ico).\n\tDrawn by hand by Markus Gritsch .\n\nlua.pc\n\tpkg-config data for Lua\n\nluavs.bat\n\tScript to build Lua under \"Visual Studio .NET Command Prompt\".\n\tRun it from the toplevel as etc\\luavs.bat.\n\nmin.c\n\tA minimal Lua interpreter.\n\tGood for learning and for starting your own.\n\tDo \"make min\" for a demo.\n\nnoparser.c\n\tLinking with noparser.o avoids loading the parsing modules in lualib.a.\n\tDo \"make noparser\" for a demo.\n\nstrict.lua\n\tTraps uses of undeclared global variables.\n\tDo \"make strict\" for a demo.\n\n" }, { "path": "deps/lua/etc/all.c", "content": "/*\n* all.c -- Lua core, libraries and interpreter in a single file\n*/\n\n#define luaall_c\n\n#include \"lapi.c\"\n#include \"lcode.c\"\n#include \"ldebug.c\"\n#include \"ldo.c\"\n#include \"ldump.c\"\n#include \"lfunc.c\"\n#include \"lgc.c\"\n#include \"llex.c\"\n#include \"lmem.c\"\n#include \"lobject.c\"\n#include \"lopcodes.c\"\n#include \"lparser.c\"\n#include \"lstate.c\"\n#include \"lstring.c\"\n#include \"ltable.c\"\n#include \"ltm.c\"\n#include \"lundump.c\"\n#include \"lvm.c\"\n#include \"lzio.c\"\n\n#include \"lauxlib.c\"\n#include \"lbaselib.c\"\n#include \"ldblib.c\"\n#include \"liolib.c\"\n#include \"linit.c\"\n#include \"lmathlib.c\"\n#include \"loadlib.c\"\n#include \"loslib.c\"\n#include \"lstrlib.c\"\n#include \"ltablib.c\"\n\n#include \"lua.c\"\n" }, { "path": "deps/lua/etc/lua.hpp", "content": "// lua.hpp\n// Lua header files for C++\n// <> not supplied automatically because Lua also compiles as C++\n\nextern \"C\" {\n#include \"lua.h\"\n#include \"lualib.h\"\n#include \"lauxlib.h\"\n}\n" }, { "path": "deps/lua/etc/lua.pc", "content": "# lua.pc -- pkg-config data for Lua\n\n# vars from install Makefile\n\n# grep '^V=' ../Makefile\nV= 5.1\n# grep '^R=' ../Makefile\nR= 5.1.5\n\n# grep '^INSTALL_.*=' ../Makefile | sed 's/INSTALL_TOP/prefix/'\nprefix= /usr/local\nINSTALL_BIN= ${prefix}/bin\nINSTALL_INC= ${prefix}/include\nINSTALL_LIB= ${prefix}/lib\nINSTALL_MAN= ${prefix}/man/man1\nINSTALL_LMOD= ${prefix}/share/lua/${V}\nINSTALL_CMOD= ${prefix}/lib/lua/${V}\n\n# canonical vars\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/lib\nincludedir=${prefix}/include\n\nName: Lua\nDescription: An Extensible Extension Language\nVersion: ${R}\nRequires: \nLibs: -L${libdir} -llua -lm\nCflags: -I${includedir}\n\n# (end of lua.pc)\n" }, { "path": "deps/lua/etc/luavs.bat", "content": "@rem Script to build Lua under \"Visual Studio .NET Command Prompt\".\r\n@rem Do not run from this directory; run it from the toplevel: etc\\luavs.bat .\r\n@rem It creates lua51.dll, lua51.lib, lua.exe, and luac.exe in src.\r\n@rem (contributed by David Manura and Mike Pall)\r\n\r\n@setlocal\r\n@set MYCOMPILE=cl /nologo /MD /O2 /W3 /c /D_CRT_SECURE_NO_DEPRECATE\r\n@set MYLINK=link /nologo\r\n@set MYMT=mt /nologo\r\n\r\ncd src\r\n%MYCOMPILE% /DLUA_BUILD_AS_DLL l*.c\r\ndel lua.obj luac.obj\r\n%MYLINK% /DLL /out:lua51.dll l*.obj\r\nif exist lua51.dll.manifest^\r\n %MYMT% -manifest lua51.dll.manifest -outputresource:lua51.dll;2\r\n%MYCOMPILE% /DLUA_BUILD_AS_DLL lua.c\r\n%MYLINK% /out:lua.exe lua.obj lua51.lib\r\nif exist lua.exe.manifest^\r\n %MYMT% -manifest lua.exe.manifest -outputresource:lua.exe\r\n%MYCOMPILE% l*.c print.c\r\ndel lua.obj linit.obj lbaselib.obj ldblib.obj liolib.obj lmathlib.obj^\r\n loslib.obj ltablib.obj lstrlib.obj loadlib.obj\r\n%MYLINK% /out:luac.exe *.obj\r\nif exist luac.exe.manifest^\r\n %MYMT% -manifest luac.exe.manifest -outputresource:luac.exe\r\ndel *.obj *.manifest\r\ncd ..\r\n" }, { "path": "deps/lua/etc/min.c", "content": "/*\n* min.c -- a minimal Lua interpreter\n* loads stdin only with minimal error handling.\n* no interaction, and no standard library, only a \"print\" function.\n*/\n\n#include \n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\nstatic int print(lua_State *L)\n{\n int n=lua_gettop(L);\n int i;\n for (i=1; i<=n; i++)\n {\n if (i>1) printf(\"\\t\");\n if (lua_isstring(L,i))\n printf(\"%s\",lua_tostring(L,i));\n else if (lua_isnil(L,i))\n printf(\"%s\",\"nil\");\n else if (lua_isboolean(L,i))\n printf(\"%s\",lua_toboolean(L,i) ? \"true\" : \"false\");\n else\n printf(\"%s:%p\",luaL_typename(L,i),lua_topointer(L,i));\n }\n printf(\"\\n\");\n return 0;\n}\n\nint main(void)\n{\n lua_State *L=lua_open();\n lua_register(L,\"print\",print);\n if (luaL_dofile(L,NULL)!=0) fprintf(stderr,\"%s\\n\",lua_tostring(L,-1));\n lua_close(L);\n return 0;\n}\n" }, { "path": "deps/lua/etc/noparser.c", "content": "/*\n* The code below can be used to make a Lua core that does not contain the\n* parsing modules (lcode, llex, lparser), which represent 35% of the total core.\n* You'll only be able to load binary files and strings, precompiled with luac.\n* (Of course, you'll have to build luac with the original parsing modules!)\n*\n* To use this module, simply compile it (\"make noparser\" does that) and list\n* its object file before the Lua libraries. The linker should then not load\n* the parsing modules. To try it, do \"make luab\".\n*\n* If you also want to avoid the dump module (ldump.o), define NODUMP.\n* #define NODUMP\n*/\n\n#define LUA_CORE\n\n#include \"llex.h\"\n#include \"lparser.h\"\n#include \"lzio.h\"\n\nLUAI_FUNC void luaX_init (lua_State *L) {\n UNUSED(L);\n}\n\nLUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {\n UNUSED(z);\n UNUSED(buff);\n UNUSED(name);\n lua_pushliteral(L,\"parser not loaded\");\n lua_error(L);\n return NULL;\n}\n\n#ifdef NODUMP\n#include \"lundump.h\"\n\nLUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) {\n UNUSED(f);\n UNUSED(w);\n UNUSED(data);\n UNUSED(strip);\n#if 1\n UNUSED(L);\n return 0;\n#else\n lua_pushliteral(L,\"dumper not loaded\");\n lua_error(L);\n#endif\n}\n#endif\n" }, { "path": "deps/lua/etc/strict.lua", "content": "--\n-- strict.lua\n-- checks uses of undeclared global variables\n-- All global variables must be 'declared' through a regular assignment\n-- (even assigning nil will do) in a main chunk before being used\n-- anywhere or assigned to inside a function.\n--\n\nlocal getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget\n\nlocal mt = getmetatable(_G)\nif mt == nil then\n mt = {}\n setmetatable(_G, mt)\nend\n\nmt.__declared = {}\n\nlocal function what ()\n local d = getinfo(3, \"S\")\n return d and d.what or \"C\"\nend\n\nmt.__newindex = function (t, n, v)\n if not mt.__declared[n] then\n local w = what()\n if w ~= \"main\" and w ~= \"C\" then\n error(\"assign to undeclared variable '\"..n..\"'\", 2)\n end\n mt.__declared[n] = true\n end\n rawset(t, n, v)\nend\n \nmt.__index = function (t, n)\n if not mt.__declared[n] and what() ~= \"C\" then\n error(\"variable '\"..n..\"' is not declared\", 2)\n end\n return rawget(t, n)\nend\n\n" }, { "path": "deps/lua/src/Makefile", "content": "# makefile for building Lua\n# see ../INSTALL for installation instructions\n# see ../Makefile and luaconf.h for further customization\n\n# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================\n\n# Your platform. See PLATS for possible values.\nPLAT= none\n\nCC?= gcc\nCFLAGS= -O2 -Wall $(MYCFLAGS)\nAR= ar rcu\nRANLIB= ranlib\nRM= rm -f\nLIBS= -lm $(MYLIBS)\n\nMYCFLAGS=\nMYLDFLAGS=\nMYLIBS=\n\n# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========\n\nPLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris\n\nLUA_A=\tliblua.a\nCORE_O=\tlapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \\\n\tlobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o \\\n\tlundump.o lvm.o lzio.o strbuf.o fpconv.o\nLIB_O=\tlauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \\\n\tlstrlib.o loadlib.o linit.o lua_cjson.o lua_struct.o lua_cmsgpack.o \\\n\tlua_bit.o\n\nLUA_T=\tlua\nLUA_O=\tlua.o\n\nLUAC_T=\tluac\nLUAC_O=\tluac.o print.o\n\nALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)\nALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)\nALL_A= $(LUA_A)\n\ndefault: $(PLAT)\n\nall:\t$(ALL_T)\n\no:\t$(ALL_O)\n\na:\t$(ALL_A)\n\n$(LUA_A): $(CORE_O) $(LIB_O)\n\t$(AR) $@ $(CORE_O) $(LIB_O)\t# DLL needs all object files\n\t$(RANLIB) $@\n\n$(LUA_T): $(LUA_O) $(LUA_A)\n\t$(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)\n\n$(LUAC_T): $(LUAC_O) $(LUA_A)\n\t$(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)\n\nclean:\n\t$(RM) $(ALL_T) $(ALL_O)\n\ndepend:\n\t@$(CC) $(CFLAGS) -MM l*.c print.c\n\necho:\n\t@echo \"PLAT = $(PLAT)\"\n\t@echo \"CC = $(CC)\"\n\t@echo \"CFLAGS = $(CFLAGS)\"\n\t@echo \"AR = $(AR)\"\n\t@echo \"RANLIB = $(RANLIB)\"\n\t@echo \"RM = $(RM)\"\n\t@echo \"MYCFLAGS = $(MYCFLAGS)\"\n\t@echo \"MYLDFLAGS = $(MYLDFLAGS)\"\n\t@echo \"MYLIBS = $(MYLIBS)\"\n\n# convenience targets for popular platforms\n\nnone:\n\t@echo \"Please choose a platform:\"\n\t@echo \" $(PLATS)\"\n\naix:\n\t$(MAKE) all CC=\"xlc\" CFLAGS=\"-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN\" MYLIBS=\"-ldl\" MYLDFLAGS=\"-brtl -bexpall\"\n\nansi:\n\t$(MAKE) all MYCFLAGS=-DLUA_ANSI\n\nbsd:\n\t$(MAKE) all MYCFLAGS=\"-DLUA_USE_POSIX -DLUA_USE_DLOPEN\" MYLIBS=\"-Wl,-E\"\n\nfreebsd:\n\t$(MAKE) all MYCFLAGS=\"-DLUA_USE_LINUX\" MYLIBS=\"-Wl,-E -lreadline\"\n\ngeneric:\n\t$(MAKE) all MYCFLAGS=\n\nlinux:\n\t$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS=\"-Wl,-E -ldl -lreadline -lhistory -lncurses\"\n\nmacosx:\n\t$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS=\"-lreadline\"\n# use this on Mac OS X 10.3-\n#\t$(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX\n\nmingw:\n\t$(MAKE) \"LUA_A=lua51.dll\" \"LUA_T=lua.exe\" \\\n\t\"AR=$(CC) -shared -o\" \"RANLIB=strip --strip-unneeded\" \\\n\t\"MYCFLAGS=-DLUA_BUILD_AS_DLL\" \"MYLIBS=\" \"MYLDFLAGS=-s\" lua.exe\n\t$(MAKE) \"LUAC_T=luac.exe\" luac.exe\n\nposix:\n\t$(MAKE) all MYCFLAGS=-DLUA_USE_POSIX\n\nsolaris:\n\t$(MAKE) all MYCFLAGS=\"-DLUA_USE_POSIX -DLUA_USE_DLOPEN\" MYLIBS=\"-ldl\"\n\n# list targets that do not create files (but not all makes understand .PHONY)\n.PHONY: all $(PLATS) default o a clean depend echo none\n\n# DO NOT DELETE\n\nlapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \\\n lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \\\n lundump.h lvm.h\nlauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h\nlbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h\nlcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \\\n lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \\\n ltable.h\nldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h\nldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \\\n llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \\\n lfunc.h lstring.h lgc.h ltable.h lvm.h\nldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \\\n lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \\\n ltable.h lundump.h lvm.h\nldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \\\n lzio.h lmem.h lundump.h\nlfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \\\n lstate.h ltm.h lzio.h\nlgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \\\n lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h\nlinit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h\nliolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h\nllex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \\\n lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h\nlmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h\nlmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \\\n ltm.h lzio.h lmem.h ldo.h\nloadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h\nlobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \\\n ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h\nlopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h\nloslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h\nlparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \\\n lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \\\n lfunc.h lstring.h lgc.h ltable.h\nlstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \\\n ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h\nlstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \\\n ltm.h lzio.h lstring.h lgc.h\nlstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h\nltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \\\n ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h\nltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h\nltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \\\n lmem.h lstring.h lgc.h ltable.h\nlua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h\nluac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \\\n lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \\\n lundump.h\nlundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \\\n llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h\nlvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \\\n lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h\nlzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \\\n lzio.h\nprint.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \\\n ltm.h lzio.h lmem.h lopcodes.h lundump.h\n\n# (end of Makefile)\n" }, { "path": "deps/lua/src/fpconv.c", "content": "/* fpconv - Floating point conversion routines\n *\n * Copyright (c) 2011-2012 Mark Pulford \n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n/* JSON uses a '.' decimal separator. strtod() / sprintf() under C libraries\n * with locale support will break when the decimal separator is a comma.\n *\n * fpconv_* will around these issues with a translation buffer if required.\n */\n\n#include \n#include \n#include \n#include \n\n#include \"fpconv.h\"\n\n/* Lua CJSON assumes the locale is the same for all threads within a\n * process and doesn't change after initialisation.\n *\n * This avoids the need for per thread storage or expensive checks\n * for call. */\nstatic char locale_decimal_point = '.';\n\n/* In theory multibyte decimal_points are possible, but\n * Lua CJSON only supports UTF-8 and known locales only have\n * single byte decimal points ([.,]).\n *\n * localconv() may not be thread safe (=>crash), and nl_langinfo() is\n * not supported on some platforms. Use sprintf() instead - if the\n * locale does change, at least Lua CJSON won't crash. */\nstatic void fpconv_update_locale()\n{\n char buf[8];\n\n snprintf(buf, sizeof(buf), \"%g\", 0.5);\n\n /* Failing this test might imply the platform has a buggy dtoa\n * implementation or wide characters */\n if (buf[0] != '0' || buf[2] != '5' || buf[3] != 0) {\n fprintf(stderr, \"Error: wide characters found or printf() bug.\");\n abort();\n }\n\n locale_decimal_point = buf[1];\n}\n\n/* Check for a valid number character: [-+0-9a-yA-Y.]\n * Eg: -0.6e+5, infinity, 0xF0.F0pF0\n *\n * Used to find the probable end of a number. It doesn't matter if\n * invalid characters are counted - strtod() will find the valid\n * number if it exists. The risk is that slightly more memory might\n * be allocated before a parse error occurs. */\nstatic inline int valid_number_character(char ch)\n{\n char lower_ch;\n\n if ('0' <= ch && ch <= '9')\n return 1;\n if (ch == '-' || ch == '+' || ch == '.')\n return 1;\n\n /* Hex digits, exponent (e), base (p), \"infinity\",.. */\n lower_ch = ch | 0x20;\n if ('a' <= lower_ch && lower_ch <= 'y')\n return 1;\n\n return 0;\n}\n\n/* Calculate the size of the buffer required for a strtod locale\n * conversion. */\nstatic int strtod_buffer_size(const char *s)\n{\n const char *p = s;\n\n while (valid_number_character(*p))\n p++;\n\n return p - s;\n}\n\n/* Similar to strtod(), but must be passed the current locale's decimal point\n * character. Guaranteed to be called at the start of any valid number in a string */\ndouble fpconv_strtod(const char *nptr, char **endptr)\n{\n char localbuf[FPCONV_G_FMT_BUFSIZE];\n char *buf, *endbuf, *dp;\n int buflen;\n double value;\n\n /* System strtod() is fine when decimal point is '.' */\n if (locale_decimal_point == '.')\n return strtod(nptr, endptr);\n\n buflen = strtod_buffer_size(nptr);\n if (!buflen) {\n /* No valid characters found, standard strtod() return */\n *endptr = (char *)nptr;\n return 0;\n }\n\n /* Duplicate number into buffer */\n if (buflen >= FPCONV_G_FMT_BUFSIZE) {\n /* Handle unusually large numbers */\n buf = malloc(buflen + 1);\n if (!buf) {\n fprintf(stderr, \"Out of memory\");\n abort();\n }\n } else {\n /* This is the common case.. */\n buf = localbuf;\n }\n memcpy(buf, nptr, buflen);\n buf[buflen] = 0;\n\n /* Update decimal point character if found */\n dp = strchr(buf, '.');\n if (dp)\n *dp = locale_decimal_point;\n\n value = strtod(buf, &endbuf);\n *endptr = (char *)&nptr[endbuf - buf];\n if (buflen >= FPCONV_G_FMT_BUFSIZE)\n free(buf);\n\n return value;\n}\n\n/* \"fmt\" must point to a buffer of at least 6 characters */\nstatic void set_number_format(char *fmt, int precision)\n{\n int d1, d2, i;\n\n assert(1 <= precision && precision <= 14);\n\n /* Create printf format (%.14g) from precision */\n d1 = precision / 10;\n d2 = precision % 10;\n fmt[0] = '%';\n fmt[1] = '.';\n i = 2;\n if (d1) {\n fmt[i++] = '0' + d1;\n }\n fmt[i++] = '0' + d2;\n fmt[i++] = 'g';\n fmt[i] = 0;\n}\n\n/* Assumes there is always at least 32 characters available in the target buffer */\nint fpconv_g_fmt(char *str, double num, int precision)\n{\n char buf[FPCONV_G_FMT_BUFSIZE];\n char fmt[6];\n int len;\n char *b;\n\n set_number_format(fmt, precision);\n\n /* Pass through when decimal point character is dot. */\n if (locale_decimal_point == '.')\n return snprintf(str, FPCONV_G_FMT_BUFSIZE, fmt, num);\n\n /* snprintf() to a buffer then translate for other decimal point characters */\n len = snprintf(buf, FPCONV_G_FMT_BUFSIZE, fmt, num);\n\n /* Copy into target location. Translate decimal point if required */\n b = buf;\n do {\n *str++ = (*b == locale_decimal_point ? '.' : *b);\n } while(*b++);\n\n return len;\n}\n\nvoid fpconv_init()\n{\n fpconv_update_locale();\n}\n\n/* vi:ai et sw=4 ts=4:\n */\n" }, { "path": "deps/lua/src/fpconv.h", "content": "/* Lua CJSON floating point conversion routines */\n\n/* Buffer required to store the largest string representation of a double.\n *\n * Longest double printed with %.14g is 21 characters long:\n * -1.7976931348623e+308 */\n# define FPCONV_G_FMT_BUFSIZE 32\n\n#ifdef USE_INTERNAL_FPCONV\nstatic inline void fpconv_init()\n{\n /* Do nothing - not required */\n}\n#else\nextern void fpconv_init();\n#endif\n\nextern int fpconv_g_fmt(char*, double, int);\nextern double fpconv_strtod(const char*, char**);\n\n/* vi:ai et sw=4 ts=4:\n */\n" }, { "path": "deps/lua/src/lapi.c", "content": "/*\n** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $\n** Lua API\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n\n#define lapi_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lapi.h\"\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n#include \"lundump.h\"\n#include \"lvm.h\"\n\n\n\nconst char lua_ident[] =\n \"$Lua: \" LUA_RELEASE \" \" LUA_COPYRIGHT \" $\\n\"\n \"$Authors: \" LUA_AUTHORS \" $\\n\"\n \"$URL: www.lua.org $\\n\";\n\n\n\n#define api_checknelems(L, n)\tapi_check(L, (n) <= (L->top - L->base))\n\n#define api_checkvalidindex(L, i)\tapi_check(L, (i) != luaO_nilobject)\n\n#define api_incr_top(L) {api_check(L, L->top < L->ci->top); L->top++;}\n\n\n\nstatic TValue *index2adr (lua_State *L, int idx) {\n if (idx > 0) {\n TValue *o = L->base + (idx - 1);\n api_check(L, idx <= L->ci->top - L->base);\n if (o >= L->top) return cast(TValue *, luaO_nilobject);\n else return o;\n }\n else if (idx > LUA_REGISTRYINDEX) {\n api_check(L, idx != 0 && -idx <= L->top - L->base);\n return L->top + idx;\n }\n else switch (idx) { /* pseudo-indices */\n case LUA_REGISTRYINDEX: return registry(L);\n case LUA_ENVIRONINDEX: {\n Closure *func = curr_func(L);\n sethvalue(L, &L->env, func->c.env);\n return &L->env;\n }\n case LUA_GLOBALSINDEX: return gt(L);\n default: {\n Closure *func = curr_func(L);\n idx = LUA_GLOBALSINDEX - idx;\n return (idx <= func->c.nupvalues)\n ? &func->c.upvalue[idx-1]\n : cast(TValue *, luaO_nilobject);\n }\n }\n}\n\n\nstatic Table *getcurrenv (lua_State *L) {\n if (L->ci == L->base_ci) /* no enclosing function? */\n return hvalue(gt(L)); /* use global table as environment */\n else {\n Closure *func = curr_func(L);\n return func->c.env;\n }\n}\n\n\nvoid luaA_pushobject (lua_State *L, const TValue *o) {\n setobj2s(L, L->top, o);\n api_incr_top(L);\n}\n\n\nLUA_API int lua_checkstack (lua_State *L, int size) {\n int res = 1;\n lua_lock(L);\n if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)\n res = 0; /* stack overflow */\n else if (size > 0) {\n luaD_checkstack(L, size);\n if (L->ci->top < L->top + size)\n L->ci->top = L->top + size;\n }\n lua_unlock(L);\n return res;\n}\n\n\nLUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {\n int i;\n if (from == to) return;\n lua_lock(to);\n api_checknelems(from, n);\n api_check(from, G(from) == G(to));\n api_check(from, to->ci->top - to->top >= n);\n from->top -= n;\n for (i = 0; i < n; i++) {\n setobj2s(to, to->top++, from->top + i);\n }\n lua_unlock(to);\n}\n\n\nLUA_API void lua_setlevel (lua_State *from, lua_State *to) {\n to->nCcalls = from->nCcalls;\n}\n\n\nLUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {\n lua_CFunction old;\n lua_lock(L);\n old = G(L)->panic;\n G(L)->panic = panicf;\n lua_unlock(L);\n return old;\n}\n\n\nLUA_API lua_State *lua_newthread (lua_State *L) {\n lua_State *L1;\n lua_lock(L);\n luaC_checkGC(L);\n L1 = luaE_newthread(L);\n setthvalue(L, L->top, L1);\n api_incr_top(L);\n lua_unlock(L);\n luai_userstatethread(L, L1);\n return L1;\n}\n\n\n\n/*\n** basic stack manipulation\n*/\n\n\nLUA_API int lua_gettop (lua_State *L) {\n return cast_int(L->top - L->base);\n}\n\n\nLUA_API void lua_settop (lua_State *L, int idx) {\n lua_lock(L);\n if (idx >= 0) {\n api_check(L, idx <= L->stack_last - L->base);\n while (L->top < L->base + idx)\n setnilvalue(L->top++);\n L->top = L->base + idx;\n }\n else {\n api_check(L, -(idx+1) <= (L->top - L->base));\n L->top += idx+1; /* `subtract' index (index is negative) */\n }\n lua_unlock(L);\n}\n\n\nLUA_API void lua_remove (lua_State *L, int idx) {\n StkId p;\n lua_lock(L);\n p = index2adr(L, idx);\n api_checkvalidindex(L, p);\n while (++p < L->top) setobjs2s(L, p-1, p);\n L->top--;\n lua_unlock(L);\n}\n\n\nLUA_API void lua_insert (lua_State *L, int idx) {\n StkId p;\n StkId q;\n lua_lock(L);\n p = index2adr(L, idx);\n api_checkvalidindex(L, p);\n for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);\n setobjs2s(L, p, L->top);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_replace (lua_State *L, int idx) {\n StkId o;\n lua_lock(L);\n /* explicit test for incompatible code */\n if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)\n luaG_runerror(L, \"no calling environment\");\n api_checknelems(L, 1);\n o = index2adr(L, idx);\n api_checkvalidindex(L, o);\n if (idx == LUA_ENVIRONINDEX) {\n Closure *func = curr_func(L);\n api_check(L, ttistable(L->top - 1)); \n func->c.env = hvalue(L->top - 1);\n luaC_barrier(L, func, L->top - 1);\n }\n else {\n setobj(L, o, L->top - 1);\n if (idx < LUA_GLOBALSINDEX) /* function upvalue? */\n luaC_barrier(L, curr_func(L), L->top - 1);\n }\n L->top--;\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushvalue (lua_State *L, int idx) {\n lua_lock(L);\n setobj2s(L, L->top, index2adr(L, idx));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\n\n/*\n** access functions (stack -> C)\n*/\n\n\nLUA_API int lua_type (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);\n}\n\n\nLUA_API const char *lua_typename (lua_State *L, int t) {\n UNUSED(L);\n return (t == LUA_TNONE) ? \"no value\" : luaT_typenames[t];\n}\n\n\nLUA_API int lua_iscfunction (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n return iscfunction(o);\n}\n\n\nLUA_API int lua_isnumber (lua_State *L, int idx) {\n TValue n;\n const TValue *o = index2adr(L, idx);\n return tonumber(o, &n);\n}\n\n\nLUA_API int lua_isstring (lua_State *L, int idx) {\n int t = lua_type(L, idx);\n return (t == LUA_TSTRING || t == LUA_TNUMBER);\n}\n\n\nLUA_API int lua_isuserdata (lua_State *L, int idx) {\n const TValue *o = index2adr(L, idx);\n return (ttisuserdata(o) || ttislightuserdata(o));\n}\n\n\nLUA_API int lua_rawequal (lua_State *L, int index1, int index2) {\n StkId o1 = index2adr(L, index1);\n StkId o2 = index2adr(L, index2);\n return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0\n : luaO_rawequalObj(o1, o2);\n}\n\n\nLUA_API int lua_equal (lua_State *L, int index1, int index2) {\n StkId o1, o2;\n int i;\n lua_lock(L); /* may call tag method */\n o1 = index2adr(L, index1);\n o2 = index2adr(L, index2);\n i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);\n lua_unlock(L);\n return i;\n}\n\n\nLUA_API int lua_lessthan (lua_State *L, int index1, int index2) {\n StkId o1, o2;\n int i;\n lua_lock(L); /* may call tag method */\n o1 = index2adr(L, index1);\n o2 = index2adr(L, index2);\n i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0\n : luaV_lessthan(L, o1, o2);\n lua_unlock(L);\n return i;\n}\n\n\n\nLUA_API lua_Number lua_tonumber (lua_State *L, int idx) {\n TValue n;\n const TValue *o = index2adr(L, idx);\n if (tonumber(o, &n))\n return nvalue(o);\n else\n return 0;\n}\n\n\nLUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {\n TValue n;\n const TValue *o = index2adr(L, idx);\n if (tonumber(o, &n)) {\n lua_Integer res;\n lua_Number num = nvalue(o);\n lua_number2integer(res, num);\n return res;\n }\n else\n return 0;\n}\n\n\nLUA_API int lua_toboolean (lua_State *L, int idx) {\n const TValue *o = index2adr(L, idx);\n return !l_isfalse(o);\n}\n\n\nLUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {\n StkId o = index2adr(L, idx);\n if (!ttisstring(o)) {\n lua_lock(L); /* `luaV_tostring' may create a new string */\n if (!luaV_tostring(L, o)) { /* conversion failed? */\n if (len != NULL) *len = 0;\n lua_unlock(L);\n return NULL;\n }\n luaC_checkGC(L);\n o = index2adr(L, idx); /* previous call may reallocate the stack */\n lua_unlock(L);\n }\n if (len != NULL) *len = tsvalue(o)->len;\n return svalue(o);\n}\n\n\nLUA_API size_t lua_objlen (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n switch (ttype(o)) {\n case LUA_TSTRING: return tsvalue(o)->len;\n case LUA_TUSERDATA: return uvalue(o)->len;\n case LUA_TTABLE: return luaH_getn(hvalue(o));\n case LUA_TNUMBER: {\n size_t l;\n lua_lock(L); /* `luaV_tostring' may create a new string */\n l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);\n lua_unlock(L);\n return l;\n }\n default: return 0;\n }\n}\n\n\nLUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;\n}\n\n\nLUA_API void *lua_touserdata (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n switch (ttype(o)) {\n case LUA_TUSERDATA: return (rawuvalue(o) + 1);\n case LUA_TLIGHTUSERDATA: return pvalue(o);\n default: return NULL;\n }\n}\n\n\nLUA_API lua_State *lua_tothread (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n return (!ttisthread(o)) ? NULL : thvalue(o);\n}\n\n\nLUA_API const void *lua_topointer (lua_State *L, int idx) {\n StkId o = index2adr(L, idx);\n switch (ttype(o)) {\n case LUA_TTABLE: return hvalue(o);\n case LUA_TFUNCTION: return clvalue(o);\n case LUA_TTHREAD: return thvalue(o);\n case LUA_TUSERDATA:\n case LUA_TLIGHTUSERDATA:\n return lua_touserdata(L, idx);\n default: return NULL;\n }\n}\n\n\n\n/*\n** push functions (C -> stack)\n*/\n\n\nLUA_API void lua_pushnil (lua_State *L) {\n lua_lock(L);\n setnilvalue(L->top);\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushnumber (lua_State *L, lua_Number n) {\n lua_lock(L);\n setnvalue(L->top, n);\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {\n lua_lock(L);\n setnvalue(L->top, cast_num(n));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {\n lua_lock(L);\n luaC_checkGC(L);\n setsvalue2s(L, L->top, luaS_newlstr(L, s, len));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushstring (lua_State *L, const char *s) {\n if (s == NULL)\n lua_pushnil(L);\n else\n lua_pushlstring(L, s, strlen(s));\n}\n\n\nLUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,\n va_list argp) {\n const char *ret;\n lua_lock(L);\n luaC_checkGC(L);\n ret = luaO_pushvfstring(L, fmt, argp);\n lua_unlock(L);\n return ret;\n}\n\n\nLUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {\n const char *ret;\n va_list argp;\n lua_lock(L);\n luaC_checkGC(L);\n va_start(argp, fmt);\n ret = luaO_pushvfstring(L, fmt, argp);\n va_end(argp);\n lua_unlock(L);\n return ret;\n}\n\n\nLUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {\n Closure *cl;\n lua_lock(L);\n luaC_checkGC(L);\n api_checknelems(L, n);\n cl = luaF_newCclosure(L, n, getcurrenv(L));\n cl->c.f = fn;\n L->top -= n;\n while (n--)\n setobj2n(L, &cl->c.upvalue[n], L->top+n);\n setclvalue(L, L->top, cl);\n lua_assert(iswhite(obj2gco(cl)));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushboolean (lua_State *L, int b) {\n lua_lock(L);\n setbvalue(L->top, (b != 0)); /* ensure that true is 1 */\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_pushlightuserdata (lua_State *L, void *p) {\n lua_lock(L);\n setpvalue(L->top, p);\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API int lua_pushthread (lua_State *L) {\n lua_lock(L);\n setthvalue(L, L->top, L);\n api_incr_top(L);\n lua_unlock(L);\n return (G(L)->mainthread == L);\n}\n\n\n\n/*\n** get functions (Lua -> stack)\n*/\n\n\nLUA_API void lua_gettable (lua_State *L, int idx) {\n StkId t;\n lua_lock(L);\n t = index2adr(L, idx);\n api_checkvalidindex(L, t);\n luaV_gettable(L, t, L->top - 1, L->top - 1);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_getfield (lua_State *L, int idx, const char *k) {\n StkId t;\n TValue key;\n lua_lock(L);\n t = index2adr(L, idx);\n api_checkvalidindex(L, t);\n setsvalue(L, &key, luaS_new(L, k));\n luaV_gettable(L, t, &key, L->top);\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_rawget (lua_State *L, int idx) {\n StkId t;\n lua_lock(L);\n t = index2adr(L, idx);\n api_check(L, ttistable(t));\n setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));\n lua_unlock(L);\n}\n\n\nLUA_API void lua_rawgeti (lua_State *L, int idx, int n) {\n StkId o;\n lua_lock(L);\n o = index2adr(L, idx);\n api_check(L, ttistable(o));\n setobj2s(L, L->top, luaH_getnum(hvalue(o), n));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API void lua_createtable (lua_State *L, int narray, int nrec) {\n lua_lock(L);\n luaC_checkGC(L);\n sethvalue(L, L->top, luaH_new(L, narray, nrec));\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\nLUA_API int lua_getmetatable (lua_State *L, int objindex) {\n const TValue *obj;\n Table *mt = NULL;\n int res;\n lua_lock(L);\n obj = index2adr(L, objindex);\n switch (ttype(obj)) {\n case LUA_TTABLE:\n mt = hvalue(obj)->metatable;\n break;\n case LUA_TUSERDATA:\n mt = uvalue(obj)->metatable;\n break;\n default:\n mt = G(L)->mt[ttype(obj)];\n break;\n }\n if (mt == NULL)\n res = 0;\n else {\n sethvalue(L, L->top, mt);\n api_incr_top(L);\n res = 1;\n }\n lua_unlock(L);\n return res;\n}\n\n\nLUA_API void lua_getfenv (lua_State *L, int idx) {\n StkId o;\n lua_lock(L);\n o = index2adr(L, idx);\n api_checkvalidindex(L, o);\n switch (ttype(o)) {\n case LUA_TFUNCTION:\n sethvalue(L, L->top, clvalue(o)->c.env);\n break;\n case LUA_TUSERDATA:\n sethvalue(L, L->top, uvalue(o)->env);\n break;\n case LUA_TTHREAD:\n setobj2s(L, L->top, gt(thvalue(o)));\n break;\n default:\n setnilvalue(L->top);\n break;\n }\n api_incr_top(L);\n lua_unlock(L);\n}\n\n\n/*\n** set functions (stack -> Lua)\n*/\n\n\nLUA_API void lua_settable (lua_State *L, int idx) {\n StkId t;\n lua_lock(L);\n api_checknelems(L, 2);\n t = index2adr(L, idx);\n api_checkvalidindex(L, t);\n luaV_settable(L, t, L->top - 2, L->top - 1);\n L->top -= 2; /* pop index and value */\n lua_unlock(L);\n}\n\n\nLUA_API void lua_setfield (lua_State *L, int idx, const char *k) {\n StkId t;\n TValue key;\n lua_lock(L);\n api_checknelems(L, 1);\n t = index2adr(L, idx);\n api_checkvalidindex(L, t);\n setsvalue(L, &key, luaS_new(L, k));\n luaV_settable(L, t, &key, L->top - 1);\n L->top--; /* pop value */\n lua_unlock(L);\n}\n\n\nLUA_API void lua_rawset (lua_State *L, int idx) {\n StkId t;\n lua_lock(L);\n api_checknelems(L, 2);\n t = index2adr(L, idx);\n api_check(L, ttistable(t));\n if (hvalue(t)->readonly)\n luaG_runerror(L, \"Attempt to modify a readonly table\");\n setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);\n luaC_barriert(L, hvalue(t), L->top-1);\n L->top -= 2;\n lua_unlock(L);\n}\n\n\nLUA_API void lua_rawseti (lua_State *L, int idx, int n) {\n StkId o;\n lua_lock(L);\n api_checknelems(L, 1);\n o = index2adr(L, idx);\n api_check(L, ttistable(o));\n if (hvalue(o)->readonly)\n luaG_runerror(L, \"Attempt to modify a readonly table\");\n setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);\n luaC_barriert(L, hvalue(o), L->top-1);\n L->top--;\n lua_unlock(L);\n}\n\n\nLUA_API int lua_setmetatable (lua_State *L, int objindex) {\n TValue *obj;\n Table *mt;\n lua_lock(L);\n api_checknelems(L, 1);\n obj = index2adr(L, objindex);\n api_checkvalidindex(L, obj);\n if (ttisnil(L->top - 1))\n mt = NULL;\n else {\n api_check(L, ttistable(L->top - 1));\n mt = hvalue(L->top - 1);\n }\n switch (ttype(obj)) {\n case LUA_TTABLE: {\n if (hvalue(obj)->readonly)\n luaG_runerror(L, \"Attempt to modify a readonly table\");\n hvalue(obj)->metatable = mt;\n if (mt)\n luaC_objbarriert(L, hvalue(obj), mt);\n break;\n }\n case LUA_TUSERDATA: {\n uvalue(obj)->metatable = mt;\n if (mt)\n luaC_objbarrier(L, rawuvalue(obj), mt);\n break;\n }\n default: {\n G(L)->mt[ttype(obj)] = mt;\n break;\n }\n }\n L->top--;\n lua_unlock(L);\n return 1;\n}\n\n\nLUA_API int lua_setfenv (lua_State *L, int idx) {\n StkId o;\n int res = 1;\n lua_lock(L);\n api_checknelems(L, 1);\n o = index2adr(L, idx);\n api_checkvalidindex(L, o);\n api_check(L, ttistable(L->top - 1));\n switch (ttype(o)) {\n case LUA_TFUNCTION:\n clvalue(o)->c.env = hvalue(L->top - 1);\n break;\n case LUA_TUSERDATA:\n uvalue(o)->env = hvalue(L->top - 1);\n break;\n case LUA_TTHREAD:\n sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));\n break;\n default:\n res = 0;\n break;\n }\n if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));\n L->top--;\n lua_unlock(L);\n return res;\n}\n\n\n/*\n** `load' and `call' functions (run Lua code)\n*/\n\n\n#define adjustresults(L,nres) \\\n { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }\n\n\n#define checkresults(L,na,nr) \\\n api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))\n\t\n\nLUA_API void lua_call (lua_State *L, int nargs, int nresults) {\n StkId func;\n lua_lock(L);\n api_checknelems(L, nargs+1);\n checkresults(L, nargs, nresults);\n func = L->top - (nargs+1);\n luaD_call(L, func, nresults);\n adjustresults(L, nresults);\n lua_unlock(L);\n}\n\n\n\n/*\n** Execute a protected call.\n*/\nstruct CallS { /* data to `f_call' */\n StkId func;\n int nresults;\n};\n\n\nstatic void f_call (lua_State *L, void *ud) {\n struct CallS *c = cast(struct CallS *, ud);\n luaD_call(L, c->func, c->nresults);\n}\n\n\n\nLUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {\n struct CallS c;\n int status;\n ptrdiff_t func;\n lua_lock(L);\n api_checknelems(L, nargs+1);\n checkresults(L, nargs, nresults);\n if (errfunc == 0)\n func = 0;\n else {\n StkId o = index2adr(L, errfunc);\n api_checkvalidindex(L, o);\n func = savestack(L, o);\n }\n c.func = L->top - (nargs+1); /* function to be called */\n c.nresults = nresults;\n status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);\n adjustresults(L, nresults);\n lua_unlock(L);\n return status;\n}\n\n\n/*\n** Execute a protected C call.\n*/\nstruct CCallS { /* data to `f_Ccall' */\n lua_CFunction func;\n void *ud;\n};\n\n\nstatic void f_Ccall (lua_State *L, void *ud) {\n struct CCallS *c = cast(struct CCallS *, ud);\n Closure *cl;\n cl = luaF_newCclosure(L, 0, getcurrenv(L));\n cl->c.f = c->func;\n setclvalue(L, L->top, cl); /* push function */\n api_incr_top(L);\n setpvalue(L->top, c->ud); /* push only argument */\n api_incr_top(L);\n luaD_call(L, L->top - 2, 0);\n}\n\n\nLUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {\n struct CCallS c;\n int status;\n lua_lock(L);\n c.func = func;\n c.ud = ud;\n status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);\n lua_unlock(L);\n return status;\n}\n\n\nLUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,\n const char *chunkname) {\n ZIO z;\n int status;\n lua_lock(L);\n if (!chunkname) chunkname = \"?\";\n luaZ_init(L, &z, reader, data);\n status = luaD_protectedparser(L, &z, chunkname);\n lua_unlock(L);\n return status;\n}\n\n\nLUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {\n int status;\n TValue *o;\n lua_lock(L);\n api_checknelems(L, 1);\n o = L->top - 1;\n if (isLfunction(o))\n status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);\n else\n status = 1;\n lua_unlock(L);\n return status;\n}\n\n\nLUA_API int lua_status (lua_State *L) {\n return L->status;\n}\n\n\n/*\n** Garbage-collection function\n*/\n\nLUA_API int lua_gc (lua_State *L, int what, int data) {\n int res = 0;\n global_State *g;\n lua_lock(L);\n g = G(L);\n switch (what) {\n case LUA_GCSTOP: {\n g->GCthreshold = MAX_LUMEM;\n break;\n }\n case LUA_GCRESTART: {\n g->GCthreshold = g->totalbytes;\n break;\n }\n case LUA_GCCOLLECT: {\n luaC_fullgc(L);\n break;\n }\n case LUA_GCCOUNT: {\n /* GC values are expressed in Kbytes: #bytes/2^10 */\n res = cast_int(g->totalbytes >> 10);\n break;\n }\n case LUA_GCCOUNTB: {\n res = cast_int(g->totalbytes & 0x3ff);\n break;\n }\n case LUA_GCSTEP: {\n lu_mem a = (cast(lu_mem, data) << 10);\n if (a <= g->totalbytes)\n g->GCthreshold = g->totalbytes - a;\n else\n g->GCthreshold = 0;\n while (g->GCthreshold <= g->totalbytes) {\n luaC_step(L);\n if (g->gcstate == GCSpause) { /* end of cycle? */\n res = 1; /* signal it */\n break;\n }\n }\n break;\n }\n case LUA_GCSETPAUSE: {\n res = g->gcpause;\n g->gcpause = data;\n break;\n }\n case LUA_GCSETSTEPMUL: {\n res = g->gcstepmul;\n g->gcstepmul = data;\n break;\n }\n default: res = -1; /* invalid option */\n }\n lua_unlock(L);\n return res;\n}\n\n\n\n/*\n** miscellaneous functions\n*/\n\n\nLUA_API int lua_error (lua_State *L) {\n lua_lock(L);\n api_checknelems(L, 1);\n luaG_errormsg(L);\n lua_unlock(L);\n return 0; /* to avoid warnings */\n}\n\n\nLUA_API int lua_next (lua_State *L, int idx) {\n StkId t;\n int more;\n lua_lock(L);\n t = index2adr(L, idx);\n api_check(L, ttistable(t));\n more = luaH_next(L, hvalue(t), L->top - 1);\n if (more) {\n api_incr_top(L);\n }\n else /* no more elements */\n L->top -= 1; /* remove key */\n lua_unlock(L);\n return more;\n}\n\n\nLUA_API void lua_concat (lua_State *L, int n) {\n lua_lock(L);\n api_checknelems(L, n);\n if (n >= 2) {\n luaC_checkGC(L);\n luaV_concat(L, n, cast_int(L->top - L->base) - 1);\n L->top -= (n-1);\n }\n else if (n == 0) { /* push empty string */\n setsvalue2s(L, L->top, luaS_newlstr(L, \"\", 0));\n api_incr_top(L);\n }\n /* else n == 1; nothing to do */\n lua_unlock(L);\n}\n\n\nLUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {\n lua_Alloc f;\n lua_lock(L);\n if (ud) *ud = G(L)->ud;\n f = G(L)->frealloc;\n lua_unlock(L);\n return f;\n}\n\n\nLUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {\n lua_lock(L);\n G(L)->ud = ud;\n G(L)->frealloc = f;\n lua_unlock(L);\n}\n\n\nLUA_API void *lua_newuserdata (lua_State *L, size_t size) {\n Udata *u;\n lua_lock(L);\n luaC_checkGC(L);\n u = luaS_newudata(L, size, getcurrenv(L));\n setuvalue(L, L->top, u);\n api_incr_top(L);\n lua_unlock(L);\n return u + 1;\n}\n\n\n\n\nstatic const char *aux_upvalue (StkId fi, int n, TValue **val) {\n Closure *f;\n if (!ttisfunction(fi)) return NULL;\n f = clvalue(fi);\n if (f->c.isC) {\n if (!(1 <= n && n <= f->c.nupvalues)) return NULL;\n *val = &f->c.upvalue[n-1];\n return \"\";\n }\n else {\n Proto *p = f->l.p;\n if (!(1 <= n && n <= p->sizeupvalues)) return NULL;\n *val = f->l.upvals[n-1]->v;\n return getstr(p->upvalues[n-1]);\n }\n}\n\n\nLUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {\n const char *name;\n TValue *val;\n lua_lock(L);\n name = aux_upvalue(index2adr(L, funcindex), n, &val);\n if (name) {\n setobj2s(L, L->top, val);\n api_incr_top(L);\n }\n lua_unlock(L);\n return name;\n}\n\n\nLUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {\n const char *name;\n TValue *val;\n StkId fi;\n lua_lock(L);\n fi = index2adr(L, funcindex);\n api_checknelems(L, 1);\n name = aux_upvalue(fi, n, &val);\n if (name) {\n L->top--;\n setobj(L, val, L->top);\n luaC_barrier(L, clvalue(fi), L->top);\n }\n lua_unlock(L);\n return name;\n}\n\nLUA_API void lua_enablereadonlytable (lua_State *L, int objindex, int enabled) {\n const TValue* o = index2adr(L, objindex);\n api_check(L, ttistable(o));\n Table* t = hvalue(o);\n api_check(L, t != hvalue(registry(L)));\n t->readonly = enabled;\n}\n\nLUA_API int lua_isreadonlytable (lua_State *L, int objindex) {\n const TValue* o = index2adr(L, objindex);\n api_check(L, ttistable(o));\n Table* t = hvalue(o);\n api_check(L, t != hvalue(registry(L)));\n return t->readonly;\n}\n\n" }, { "path": "deps/lua/src/lapi.h", "content": "/*\n** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $\n** Auxiliary functions from Lua API\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lapi_h\n#define lapi_h\n\n\n#include \"lobject.h\"\n\n\nLUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);\n\n#endif\n" }, { "path": "deps/lua/src/lauxlib.c", "content": "/*\n** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $\n** Auxiliary functions for building Lua libraries\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n\n/* This file uses only the official API of Lua.\n** Any function declared here could be written as an application function.\n*/\n\n#define lauxlib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n\n\n#define FREELIST_REF\t0\t/* free list of references */\n\n\n/* convert a stack index to positive */\n#define abs_index(L, i)\t\t((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \\\n\t\t\t\t\tlua_gettop(L) + (i) + 1)\n\n\n/*\n** {======================================================\n** Error-report functions\n** =======================================================\n*/\n\n\nLUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {\n lua_Debug ar;\n if (!lua_getstack(L, 0, &ar)) /* no stack frame? */\n return luaL_error(L, \"bad argument #%d (%s)\", narg, extramsg);\n lua_getinfo(L, \"n\", &ar);\n if (strcmp(ar.namewhat, \"method\") == 0) {\n narg--; /* do not count `self' */\n if (narg == 0) /* error is in the self argument itself? */\n return luaL_error(L, \"calling \" LUA_QS \" on bad self (%s)\",\n ar.name, extramsg);\n }\n if (ar.name == NULL)\n ar.name = \"?\";\n return luaL_error(L, \"bad argument #%d to \" LUA_QS \" (%s)\",\n narg, ar.name, extramsg);\n}\n\n\nLUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {\n const char *msg = lua_pushfstring(L, \"%s expected, got %s\",\n tname, luaL_typename(L, narg));\n return luaL_argerror(L, narg, msg);\n}\n\n\nstatic void tag_error (lua_State *L, int narg, int tag) {\n luaL_typerror(L, narg, lua_typename(L, tag));\n}\n\n\nLUALIB_API void luaL_where (lua_State *L, int level) {\n lua_Debug ar;\n if (lua_getstack(L, level, &ar)) { /* check function at level */\n lua_getinfo(L, \"Sl\", &ar); /* get info about it */\n if (ar.currentline > 0) { /* is there info? */\n lua_pushfstring(L, \"%s:%d: \", ar.short_src, ar.currentline);\n return;\n }\n }\n lua_pushliteral(L, \"\"); /* else, no information available... */\n}\n\n\nLUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {\n va_list argp;\n va_start(argp, fmt);\n luaL_where(L, 1);\n lua_pushvfstring(L, fmt, argp);\n va_end(argp);\n lua_concat(L, 2);\n return lua_error(L);\n}\n\n/* }====================================================== */\n\n\nLUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,\n const char *const lst[]) {\n const char *name = (def) ? luaL_optstring(L, narg, def) :\n luaL_checkstring(L, narg);\n int i;\n for (i=0; lst[i]; i++)\n if (strcmp(lst[i], name) == 0)\n return i;\n return luaL_argerror(L, narg,\n lua_pushfstring(L, \"invalid option \" LUA_QS, name));\n}\n\n\nLUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {\n lua_getfield(L, LUA_REGISTRYINDEX, tname); /* get registry.name */\n if (!lua_isnil(L, -1)) /* name already in use? */\n return 0; /* leave previous value on top, but return 0 */\n lua_pop(L, 1);\n lua_newtable(L); /* create metatable */\n lua_pushvalue(L, -1);\n lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */\n return 1;\n}\n\n\nLUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {\n void *p = lua_touserdata(L, ud);\n if (p != NULL) { /* value is a userdata? */\n if (lua_getmetatable(L, ud)) { /* does it have a metatable? */\n lua_getfield(L, LUA_REGISTRYINDEX, tname); /* get correct metatable */\n if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */\n lua_pop(L, 2); /* remove both metatables */\n return p;\n }\n }\n }\n luaL_typerror(L, ud, tname); /* else error */\n return NULL; /* to avoid warnings */\n}\n\n\nLUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {\n if (!lua_checkstack(L, space))\n luaL_error(L, \"stack overflow (%s)\", mes);\n}\n\n\nLUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {\n if (lua_type(L, narg) != t)\n tag_error(L, narg, t);\n}\n\n\nLUALIB_API void luaL_checkany (lua_State *L, int narg) {\n if (lua_type(L, narg) == LUA_TNONE)\n luaL_argerror(L, narg, \"value expected\");\n}\n\n\nLUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {\n const char *s = lua_tolstring(L, narg, len);\n if (!s) tag_error(L, narg, LUA_TSTRING);\n return s;\n}\n\n\nLUALIB_API const char *luaL_optlstring (lua_State *L, int narg,\n const char *def, size_t *len) {\n if (lua_isnoneornil(L, narg)) {\n if (len)\n *len = (def ? strlen(def) : 0);\n return def;\n }\n else return luaL_checklstring(L, narg, len);\n}\n\n\nLUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {\n lua_Number d = lua_tonumber(L, narg);\n if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */\n tag_error(L, narg, LUA_TNUMBER);\n return d;\n}\n\n\nLUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {\n return luaL_opt(L, luaL_checknumber, narg, def);\n}\n\n\nLUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {\n lua_Integer d = lua_tointeger(L, narg);\n if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */\n tag_error(L, narg, LUA_TNUMBER);\n return d;\n}\n\n\nLUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,\n lua_Integer def) {\n return luaL_opt(L, luaL_checkinteger, narg, def);\n}\n\n\nLUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {\n if (!lua_getmetatable(L, obj)) /* no metatable? */\n return 0;\n lua_pushstring(L, event);\n lua_rawget(L, -2);\n if (lua_isnil(L, -1)) {\n lua_pop(L, 2); /* remove metatable and metafield */\n return 0;\n }\n else {\n lua_remove(L, -2); /* remove only metatable */\n return 1;\n }\n}\n\n\nLUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {\n obj = abs_index(L, obj);\n if (!luaL_getmetafield(L, obj, event)) /* no metafield? */\n return 0;\n lua_pushvalue(L, obj);\n lua_call(L, 1, 1);\n return 1;\n}\n\n\nLUALIB_API void (luaL_register) (lua_State *L, const char *libname,\n const luaL_Reg *l) {\n luaI_openlib(L, libname, l, 0);\n}\n\n\nstatic int libsize (const luaL_Reg *l) {\n int size = 0;\n for (; l->name; l++) size++;\n return size;\n}\n\n\nLUALIB_API void luaI_openlib (lua_State *L, const char *libname,\n const luaL_Reg *l, int nup) {\n if (libname) {\n int size = libsize(l);\n /* check whether lib already exists */\n luaL_findtable(L, LUA_REGISTRYINDEX, \"_LOADED\", 1);\n lua_getfield(L, -1, libname); /* get _LOADED[libname] */\n if (!lua_istable(L, -1)) { /* not found? */\n lua_pop(L, 1); /* remove previous result */\n /* try global variable (and create one if it does not exist) */\n if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)\n luaL_error(L, \"name conflict for module \" LUA_QS, libname);\n lua_pushvalue(L, -1);\n lua_setfield(L, -3, libname); /* _LOADED[libname] = new table */\n }\n lua_remove(L, -2); /* remove _LOADED table */\n lua_insert(L, -(nup+1)); /* move library table to below upvalues */\n }\n for (; l->name; l++) {\n int i;\n for (i=0; ifunc, nup);\n lua_setfield(L, -(nup+2), l->name);\n }\n lua_pop(L, nup); /* remove upvalues */\n}\n\n\n\n/*\n** {======================================================\n** getn-setn: size for arrays\n** =======================================================\n*/\n\n#if defined(LUA_COMPAT_GETN)\n\nstatic int checkint (lua_State *L, int topop) {\n int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;\n lua_pop(L, topop);\n return n;\n}\n\n\nstatic void getsizes (lua_State *L) {\n lua_getfield(L, LUA_REGISTRYINDEX, \"LUA_SIZES\");\n if (lua_isnil(L, -1)) { /* no `size' table? */\n lua_pop(L, 1); /* remove nil */\n lua_newtable(L); /* create it */\n lua_pushvalue(L, -1); /* `size' will be its own metatable */\n lua_setmetatable(L, -2);\n lua_pushliteral(L, \"kv\");\n lua_setfield(L, -2, \"__mode\"); /* metatable(N).__mode = \"kv\" */\n lua_pushvalue(L, -1);\n lua_setfield(L, LUA_REGISTRYINDEX, \"LUA_SIZES\"); /* store in register */\n }\n}\n\n\nLUALIB_API void luaL_setn (lua_State *L, int t, int n) {\n t = abs_index(L, t);\n lua_pushliteral(L, \"n\");\n lua_rawget(L, t);\n if (checkint(L, 1) >= 0) { /* is there a numeric field `n'? */\n lua_pushliteral(L, \"n\"); /* use it */\n lua_pushinteger(L, n);\n lua_rawset(L, t);\n }\n else { /* use `sizes' */\n getsizes(L);\n lua_pushvalue(L, t);\n lua_pushinteger(L, n);\n lua_rawset(L, -3); /* sizes[t] = n */\n lua_pop(L, 1); /* remove `sizes' */\n }\n}\n\n\nLUALIB_API int luaL_getn (lua_State *L, int t) {\n int n;\n t = abs_index(L, t);\n lua_pushliteral(L, \"n\"); /* try t.n */\n lua_rawget(L, t);\n if ((n = checkint(L, 1)) >= 0) return n;\n getsizes(L); /* else try sizes[t] */\n lua_pushvalue(L, t);\n lua_rawget(L, -2);\n if ((n = checkint(L, 2)) >= 0) return n;\n return (int)lua_objlen(L, t);\n}\n\n#endif\n\n/* }====================================================== */\n\n\n\nLUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,\n const char *r) {\n const char *wild;\n size_t l = strlen(p);\n luaL_Buffer b;\n luaL_buffinit(L, &b);\n while ((wild = strstr(s, p)) != NULL) {\n luaL_addlstring(&b, s, wild - s); /* push prefix */\n luaL_addstring(&b, r); /* push replacement in place of pattern */\n s = wild + l; /* continue after `p' */\n }\n luaL_addstring(&b, s); /* push last suffix */\n luaL_pushresult(&b);\n return lua_tostring(L, -1);\n}\n\n\nLUALIB_API const char *luaL_findtable (lua_State *L, int idx,\n const char *fname, int szhint) {\n const char *e;\n lua_pushvalue(L, idx);\n do {\n e = strchr(fname, '.');\n if (e == NULL) e = fname + strlen(fname);\n lua_pushlstring(L, fname, e - fname);\n lua_rawget(L, -2);\n if (lua_isnil(L, -1)) { /* no such field? */\n lua_pop(L, 1); /* remove this nil */\n lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */\n lua_pushlstring(L, fname, e - fname);\n lua_pushvalue(L, -2);\n lua_settable(L, -4); /* set new table into field */\n }\n else if (!lua_istable(L, -1)) { /* field has a non-table value? */\n lua_pop(L, 2); /* remove table and value */\n return fname; /* return problematic part of the name */\n }\n lua_remove(L, -2); /* remove previous table */\n fname = e + 1;\n } while (*e == '.');\n return NULL;\n}\n\n\n\n/*\n** {======================================================\n** Generic Buffer manipulation\n** =======================================================\n*/\n\n\n#define bufflen(B)\t((B)->p - (B)->buffer)\n#define bufffree(B)\t((size_t)(LUAL_BUFFERSIZE - bufflen(B)))\n\n#define LIMIT\t(LUA_MINSTACK/2)\n\n\nstatic int emptybuffer (luaL_Buffer *B) {\n size_t l = bufflen(B);\n if (l == 0) return 0; /* put nothing on stack */\n else {\n lua_pushlstring(B->L, B->buffer, l);\n B->p = B->buffer;\n B->lvl++;\n return 1;\n }\n}\n\n\nstatic void adjuststack (luaL_Buffer *B) {\n if (B->lvl > 1) {\n lua_State *L = B->L;\n int toget = 1; /* number of levels to concat */\n size_t toplen = lua_strlen(L, -1);\n do {\n size_t l = lua_strlen(L, -(toget+1));\n if (B->lvl - toget + 1 >= LIMIT || toplen > l) {\n toplen += l;\n toget++;\n }\n else break;\n } while (toget < B->lvl);\n lua_concat(L, toget);\n B->lvl = B->lvl - toget + 1;\n }\n}\n\n\nLUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {\n if (emptybuffer(B))\n adjuststack(B);\n return B->buffer;\n}\n\n\nLUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {\n while (l--)\n luaL_addchar(B, *s++);\n}\n\n\nLUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {\n luaL_addlstring(B, s, strlen(s));\n}\n\n\nLUALIB_API void luaL_pushresult (luaL_Buffer *B) {\n emptybuffer(B);\n lua_concat(B->L, B->lvl);\n B->lvl = 1;\n}\n\n\nLUALIB_API void luaL_addvalue (luaL_Buffer *B) {\n lua_State *L = B->L;\n size_t vl;\n const char *s = lua_tolstring(L, -1, &vl);\n if (vl <= bufffree(B)) { /* fit into buffer? */\n memcpy(B->p, s, vl); /* put it there */\n B->p += vl;\n lua_pop(L, 1); /* remove from stack */\n }\n else {\n if (emptybuffer(B))\n lua_insert(L, -2); /* put buffer before new value */\n B->lvl++; /* add new value into B stack */\n adjuststack(B);\n }\n}\n\n\nLUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {\n B->L = L;\n B->p = B->buffer;\n B->lvl = 0;\n}\n\n/* }====================================================== */\n\n\nLUALIB_API int luaL_ref (lua_State *L, int t) {\n int ref;\n t = abs_index(L, t);\n if (lua_isnil(L, -1)) {\n lua_pop(L, 1); /* remove from stack */\n return LUA_REFNIL; /* `nil' has a unique fixed reference */\n }\n lua_rawgeti(L, t, FREELIST_REF); /* get first free element */\n ref = (int)lua_tointeger(L, -1); /* ref = t[FREELIST_REF] */\n lua_pop(L, 1); /* remove it from stack */\n if (ref != 0) { /* any free element? */\n lua_rawgeti(L, t, ref); /* remove it from list */\n lua_rawseti(L, t, FREELIST_REF); /* (t[FREELIST_REF] = t[ref]) */\n }\n else { /* no free elements */\n ref = (int)lua_objlen(L, t);\n ref++; /* create new reference */\n }\n lua_rawseti(L, t, ref);\n return ref;\n}\n\n\nLUALIB_API void luaL_unref (lua_State *L, int t, int ref) {\n if (ref >= 0) {\n t = abs_index(L, t);\n lua_rawgeti(L, t, FREELIST_REF);\n lua_rawseti(L, t, ref); /* t[ref] = t[FREELIST_REF] */\n lua_pushinteger(L, ref);\n lua_rawseti(L, t, FREELIST_REF); /* t[FREELIST_REF] = ref */\n }\n}\n\n\n\n/*\n** {======================================================\n** Load functions\n** =======================================================\n*/\n\ntypedef struct LoadF {\n int extraline;\n FILE *f;\n char buff[LUAL_BUFFERSIZE];\n} LoadF;\n\n\nstatic const char *getF (lua_State *L, void *ud, size_t *size) {\n LoadF *lf = (LoadF *)ud;\n (void)L;\n if (lf->extraline) {\n lf->extraline = 0;\n *size = 1;\n return \"\\n\";\n }\n if (feof(lf->f)) return NULL;\n *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);\n return (*size > 0) ? lf->buff : NULL;\n}\n\n\nstatic int errfile (lua_State *L, const char *what, int fnameindex) {\n const char *serr = strerror(errno);\n const char *filename = lua_tostring(L, fnameindex) + 1;\n lua_pushfstring(L, \"cannot %s %s: %s\", what, filename, serr);\n lua_remove(L, fnameindex);\n return LUA_ERRFILE;\n}\n\n\nLUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {\n LoadF lf;\n int status, readstatus;\n int c;\n int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */\n lf.extraline = 0;\n if (filename == NULL) {\n lua_pushliteral(L, \"=stdin\");\n lf.f = stdin;\n }\n else {\n lua_pushfstring(L, \"@%s\", filename);\n lf.f = fopen(filename, \"r\");\n if (lf.f == NULL) return errfile(L, \"open\", fnameindex);\n }\n c = getc(lf.f);\n if (c == '#') { /* Unix exec. file? */\n lf.extraline = 1;\n while ((c = getc(lf.f)) != EOF && c != '\\n') ; /* skip first line */\n if (c == '\\n') c = getc(lf.f);\n }\n if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */\n lf.f = freopen(filename, \"rb\", lf.f); /* reopen in binary mode */\n if (lf.f == NULL) return errfile(L, \"reopen\", fnameindex);\n /* skip eventual `#!...' */\n while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;\n lf.extraline = 0;\n }\n ungetc(c, lf.f);\n status = lua_load(L, getF, &lf, lua_tostring(L, -1));\n readstatus = ferror(lf.f);\n if (filename) fclose(lf.f); /* close file (even in case of errors) */\n if (readstatus) {\n lua_settop(L, fnameindex); /* ignore results from `lua_load' */\n return errfile(L, \"read\", fnameindex);\n }\n lua_remove(L, fnameindex);\n return status;\n}\n\n\ntypedef struct LoadS {\n const char *s;\n size_t size;\n} LoadS;\n\n\nstatic const char *getS (lua_State *L, void *ud, size_t *size) {\n LoadS *ls = (LoadS *)ud;\n (void)L;\n if (ls->size == 0) return NULL;\n *size = ls->size;\n ls->size = 0;\n return ls->s;\n}\n\n\nLUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,\n const char *name) {\n LoadS ls;\n ls.s = buff;\n ls.size = size;\n return lua_load(L, getS, &ls, name);\n}\n\n\nLUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {\n return luaL_loadbuffer(L, s, strlen(s), s);\n}\n\n\n\n/* }====================================================== */\n\n\nstatic void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {\n (void)ud;\n (void)osize;\n if (nsize == 0) {\n free(ptr);\n return NULL;\n }\n else\n return realloc(ptr, nsize);\n}\n\n\nstatic int panic (lua_State *L) {\n (void)L; /* to avoid warnings */\n fprintf(stderr, \"PANIC: unprotected error in call to Lua API (%s)\\n\",\n lua_tostring(L, -1));\n return 0;\n}\n\n\nLUALIB_API lua_State *luaL_newstate (void) {\n lua_State *L = lua_newstate(l_alloc, NULL);\n if (L) lua_atpanic(L, &panic);\n return L;\n}\n\n" }, { "path": "deps/lua/src/lauxlib.h", "content": "/*\n** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $\n** Auxiliary functions for building Lua libraries\n** See Copyright Notice in lua.h\n*/\n\n\n#ifndef lauxlib_h\n#define lauxlib_h\n\n\n#include \n#include \n\n#include \"lua.h\"\n\n\n#if defined(LUA_COMPAT_GETN)\nLUALIB_API int (luaL_getn) (lua_State *L, int t);\nLUALIB_API void (luaL_setn) (lua_State *L, int t, int n);\n#else\n#define luaL_getn(L,i) ((int)lua_objlen(L, i))\n#define luaL_setn(L,i,j) ((void)0) /* no op! */\n#endif\n\n#if defined(LUA_COMPAT_OPENLIB)\n#define luaI_openlib\tluaL_openlib\n#endif\n\n\n/* extra error code for `luaL_load' */\n#define LUA_ERRFILE (LUA_ERRERR+1)\n\n\ntypedef struct luaL_Reg {\n const char *name;\n lua_CFunction func;\n} luaL_Reg;\n\n\n\nLUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,\n const luaL_Reg *l, int nup);\nLUALIB_API void (luaL_register) (lua_State *L, const char *libname,\n const luaL_Reg *l);\nLUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);\nLUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);\nLUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);\nLUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);\nLUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,\n size_t *l);\nLUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,\n const char *def, size_t *l);\nLUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);\nLUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);\n\nLUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);\nLUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,\n lua_Integer def);\n\nLUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);\nLUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);\nLUALIB_API void (luaL_checkany) (lua_State *L, int narg);\n\nLUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);\nLUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);\n\nLUALIB_API void (luaL_where) (lua_State *L, int lvl);\nLUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);\n\nLUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,\n const char *const lst[]);\n\nLUALIB_API int (luaL_ref) (lua_State *L, int t);\nLUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);\n\nLUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);\nLUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,\n const char *name);\nLUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);\n\nLUALIB_API lua_State *(luaL_newstate) (void);\n\n\nLUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,\n const char *r);\n\nLUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,\n const char *fname, int szhint);\n\n\n\n\n/*\n** ===============================================================\n** some useful macros\n** ===============================================================\n*/\n\n#define luaL_argcheck(L, cond,numarg,extramsg)\t\\\n\t\t((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))\n#define luaL_checkstring(L,n)\t(luaL_checklstring(L, (n), NULL))\n#define luaL_optstring(L,n,d)\t(luaL_optlstring(L, (n), (d), NULL))\n#define luaL_checkint(L,n)\t((int)luaL_checkinteger(L, (n)))\n#define luaL_optint(L,n,d)\t((int)luaL_optinteger(L, (n), (d)))\n#define luaL_checklong(L,n)\t((long)luaL_checkinteger(L, (n)))\n#define luaL_optlong(L,n,d)\t((long)luaL_optinteger(L, (n), (d)))\n\n#define luaL_typename(L,i)\tlua_typename(L, lua_type(L,(i)))\n\n#define luaL_dofile(L, fn) \\\n\t(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))\n\n#define luaL_dostring(L, s) \\\n\t(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))\n\n#define luaL_getmetatable(L,n)\t(lua_getfield(L, LUA_REGISTRYINDEX, (n)))\n\n#define luaL_opt(L,f,n,d)\t(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))\n\n/*\n** {======================================================\n** Generic Buffer manipulation\n** =======================================================\n*/\n\n\n\ntypedef struct luaL_Buffer {\n char *p;\t\t\t/* current position in buffer */\n int lvl; /* number of strings in the stack (level) */\n lua_State *L;\n char buffer[LUAL_BUFFERSIZE];\n} luaL_Buffer;\n\n#define luaL_addchar(B,c) \\\n ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \\\n (*(B)->p++ = (char)(c)))\n\n/* compatibility only */\n#define luaL_putchar(B,c)\tluaL_addchar(B,c)\n\n#define luaL_addsize(B,n)\t((B)->p += (n))\n\nLUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);\nLUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);\nLUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);\nLUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);\nLUALIB_API void (luaL_addvalue) (luaL_Buffer *B);\nLUALIB_API void (luaL_pushresult) (luaL_Buffer *B);\n\n\n/* }====================================================== */\n\n\n/* compatibility with ref system */\n\n/* pre-defined references */\n#define LUA_NOREF (-2)\n#define LUA_REFNIL (-1)\n\n#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \\\n (lua_pushstring(L, \"unlocked references are obsolete\"), lua_error(L), 0))\n\n#define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref))\n\n#define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))\n\n\n#define luaL_reg\tluaL_Reg\n\n#endif\n\n\n" }, { "path": "deps/lua/src/lbaselib.c", "content": "/*\n** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $\n** Basic library\n** See Copyright Notice in lua.h\n*/\n\n\n\n#include \n#include \n#include \n#include \n\n#define lbaselib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n\n\n/*\n** If your system does not support `stdout', you can just remove this function.\n** If you need, you can define your own `print' function, following this\n** model but changing `fputs' to put the strings at a proper place\n** (a console window or a log file, for instance).\n*/\nstatic int luaB_print (lua_State *L) {\n int n = lua_gettop(L); /* number of arguments */\n int i;\n lua_getglobal(L, \"tostring\");\n for (i=1; i<=n; i++) {\n const char *s;\n lua_pushvalue(L, -1); /* function to be called */\n lua_pushvalue(L, i); /* value to print */\n lua_call(L, 1, 1);\n s = lua_tostring(L, -1); /* get result */\n if (s == NULL)\n return luaL_error(L, LUA_QL(\"tostring\") \" must return a string to \"\n LUA_QL(\"print\"));\n if (i>1) fputs(\"\\t\", stdout);\n fputs(s, stdout);\n lua_pop(L, 1); /* pop result */\n }\n fputs(\"\\n\", stdout);\n return 0;\n}\n\n\nstatic int luaB_tonumber (lua_State *L) {\n int base = luaL_optint(L, 2, 10);\n if (base == 10) { /* standard conversion */\n luaL_checkany(L, 1);\n if (lua_isnumber(L, 1)) {\n lua_pushnumber(L, lua_tonumber(L, 1));\n return 1;\n }\n }\n else {\n const char *s1 = luaL_checkstring(L, 1);\n char *s2;\n unsigned long n;\n luaL_argcheck(L, 2 <= base && base <= 36, 2, \"base out of range\");\n n = strtoul(s1, &s2, base);\n if (s1 != s2) { /* at least one valid digit? */\n while (isspace((unsigned char)(*s2))) s2++; /* skip trailing spaces */\n if (*s2 == '\\0') { /* no invalid trailing characters? */\n lua_pushnumber(L, (lua_Number)n);\n return 1;\n }\n }\n }\n lua_pushnil(L); /* else not a number */\n return 1;\n}\n\n\nstatic int luaB_error (lua_State *L) {\n int level = luaL_optint(L, 2, 1);\n lua_settop(L, 1);\n if (lua_isstring(L, 1) && level > 0) { /* add extra information? */\n luaL_where(L, level);\n lua_pushvalue(L, 1);\n lua_concat(L, 2);\n }\n return lua_error(L);\n}\n\n\nstatic int luaB_getmetatable (lua_State *L) {\n luaL_checkany(L, 1);\n if (!lua_getmetatable(L, 1)) {\n lua_pushnil(L);\n return 1; /* no metatable */\n }\n luaL_getmetafield(L, 1, \"__metatable\");\n return 1; /* returns either __metatable field (if present) or metatable */\n}\n\n\nstatic int luaB_setmetatable (lua_State *L) {\n int t = lua_type(L, 2);\n luaL_checktype(L, 1, LUA_TTABLE);\n luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,\n \"nil or table expected\");\n if (luaL_getmetafield(L, 1, \"__metatable\"))\n luaL_error(L, \"cannot change a protected metatable\");\n lua_settop(L, 2);\n lua_setmetatable(L, 1);\n return 1;\n}\n\n\nstatic void getfunc (lua_State *L, int opt) {\n if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);\n else {\n lua_Debug ar;\n int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);\n luaL_argcheck(L, level >= 0, 1, \"level must be non-negative\");\n if (lua_getstack(L, level, &ar) == 0)\n luaL_argerror(L, 1, \"invalid level\");\n lua_getinfo(L, \"f\", &ar);\n if (lua_isnil(L, -1))\n luaL_error(L, \"no function environment for tail call at level %d\",\n level);\n }\n}\n\n\nstatic int luaB_getfenv (lua_State *L) {\n getfunc(L, 1);\n if (lua_iscfunction(L, -1)) /* is a C function? */\n lua_pushvalue(L, LUA_GLOBALSINDEX); /* return the thread's global env. */\n else\n lua_getfenv(L, -1);\n return 1;\n}\n\n\nstatic int luaB_setfenv (lua_State *L) {\n luaL_checktype(L, 2, LUA_TTABLE);\n getfunc(L, 0);\n lua_pushvalue(L, 2);\n if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {\n /* change environment of current thread */\n lua_pushthread(L);\n lua_insert(L, -2);\n lua_setfenv(L, -2);\n return 0;\n }\n else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)\n luaL_error(L,\n LUA_QL(\"setfenv\") \" cannot change environment of given object\");\n return 1;\n}\n\n\nstatic int luaB_rawequal (lua_State *L) {\n luaL_checkany(L, 1);\n luaL_checkany(L, 2);\n lua_pushboolean(L, lua_rawequal(L, 1, 2));\n return 1;\n}\n\n\nstatic int luaB_rawget (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n luaL_checkany(L, 2);\n lua_settop(L, 2);\n lua_rawget(L, 1);\n return 1;\n}\n\nstatic int luaB_rawset (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n luaL_checkany(L, 2);\n luaL_checkany(L, 3);\n lua_settop(L, 3);\n lua_rawset(L, 1);\n return 1;\n}\n\n\nstatic int luaB_gcinfo (lua_State *L) {\n lua_pushinteger(L, lua_getgccount(L));\n return 1;\n}\n\n\nstatic int luaB_collectgarbage (lua_State *L) {\n static const char *const opts[] = {\"stop\", \"restart\", \"collect\",\n \"count\", \"step\", \"setpause\", \"setstepmul\", NULL};\n static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,\n LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};\n int o = luaL_checkoption(L, 1, \"collect\", opts);\n int ex = luaL_optint(L, 2, 0);\n int res = lua_gc(L, optsnum[o], ex);\n switch (optsnum[o]) {\n case LUA_GCCOUNT: {\n int b = lua_gc(L, LUA_GCCOUNTB, 0);\n lua_pushnumber(L, res + ((lua_Number)b/1024));\n return 1;\n }\n case LUA_GCSTEP: {\n lua_pushboolean(L, res);\n return 1;\n }\n default: {\n lua_pushnumber(L, res);\n return 1;\n }\n }\n}\n\n\nstatic int luaB_type (lua_State *L) {\n luaL_checkany(L, 1);\n lua_pushstring(L, luaL_typename(L, 1));\n return 1;\n}\n\n\nstatic int luaB_next (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n lua_settop(L, 2); /* create a 2nd argument if there isn't one */\n if (lua_next(L, 1))\n return 2;\n else {\n lua_pushnil(L);\n return 1;\n }\n}\n\n\nstatic int luaB_pairs (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */\n lua_pushvalue(L, 1); /* state, */\n lua_pushnil(L); /* and initial value */\n return 3;\n}\n\n\nstatic int ipairsaux (lua_State *L) {\n int i = luaL_checkint(L, 2);\n luaL_checktype(L, 1, LUA_TTABLE);\n i++; /* next value */\n lua_pushinteger(L, i);\n lua_rawgeti(L, 1, i);\n return (lua_isnil(L, -1)) ? 0 : 2;\n}\n\n\nstatic int luaB_ipairs (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */\n lua_pushvalue(L, 1); /* state, */\n lua_pushinteger(L, 0); /* and initial value */\n return 3;\n}\n\n\nstatic int load_aux (lua_State *L, int status) {\n if (status == 0) /* OK? */\n return 1;\n else {\n lua_pushnil(L);\n lua_insert(L, -2); /* put before error message */\n return 2; /* return nil plus error message */\n }\n}\n\n\nstatic int luaB_loadstring (lua_State *L) {\n size_t l;\n const char *s = luaL_checklstring(L, 1, &l);\n const char *chunkname = luaL_optstring(L, 2, s);\n return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));\n}\n\n\nstatic int luaB_loadfile (lua_State *L) {\n const char *fname = luaL_optstring(L, 1, NULL);\n return load_aux(L, luaL_loadfile(L, fname));\n}\n\n\n/*\n** Reader for generic `load' function: `lua_load' uses the\n** stack for internal stuff, so the reader cannot change the\n** stack top. Instead, it keeps its resulting string in a\n** reserved slot inside the stack.\n*/\nstatic const char *generic_reader (lua_State *L, void *ud, size_t *size) {\n (void)ud; /* to avoid warnings */\n luaL_checkstack(L, 2, \"too many nested functions\");\n lua_pushvalue(L, 1); /* get function */\n lua_call(L, 0, 1); /* call it */\n if (lua_isnil(L, -1)) {\n *size = 0;\n return NULL;\n }\n else if (lua_isstring(L, -1)) {\n lua_replace(L, 3); /* save string in a reserved stack slot */\n return lua_tolstring(L, 3, size);\n }\n else luaL_error(L, \"reader function must return a string\");\n return NULL; /* to avoid warnings */\n}\n\n\nstatic int luaB_load (lua_State *L) {\n int status;\n const char *cname = luaL_optstring(L, 2, \"=(load)\");\n luaL_checktype(L, 1, LUA_TFUNCTION);\n lua_settop(L, 3); /* function, eventual name, plus one reserved slot */\n status = lua_load(L, generic_reader, NULL, cname);\n return load_aux(L, status);\n}\n\n\nstatic int luaB_dofile (lua_State *L) {\n const char *fname = luaL_optstring(L, 1, NULL);\n int n = lua_gettop(L);\n if (luaL_loadfile(L, fname) != 0) lua_error(L);\n lua_call(L, 0, LUA_MULTRET);\n return lua_gettop(L) - n;\n}\n\n\nstatic int luaB_assert (lua_State *L) {\n luaL_checkany(L, 1);\n if (!lua_toboolean(L, 1))\n return luaL_error(L, \"%s\", luaL_optstring(L, 2, \"assertion failed!\"));\n return lua_gettop(L);\n}\n\n\nstatic int luaB_unpack (lua_State *L) {\n int i, e;\n unsigned int n;\n luaL_checktype(L, 1, LUA_TTABLE);\n i = luaL_optint(L, 2, 1);\n e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));\n if (i > e) return 0; /* empty range */\n n = (unsigned int)e - (unsigned int)i; /* number of elements minus 1 */\n if (n >= INT_MAX || !lua_checkstack(L, ++n))\n return luaL_error(L, \"too many results to unpack\");\n lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */\n while (i++ < e) /* push arg[i + 1...e] */\n lua_rawgeti(L, 1, i);\n return n;\n}\n\n\nstatic int luaB_select (lua_State *L) {\n int n = lua_gettop(L);\n if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {\n lua_pushinteger(L, n-1);\n return 1;\n }\n else {\n int i = luaL_checkint(L, 1);\n if (i < 0) i = n + i;\n else if (i > n) i = n;\n luaL_argcheck(L, 1 <= i, 1, \"index out of range\");\n return n - i;\n }\n}\n\n\nstatic int luaB_pcall (lua_State *L) {\n int status;\n luaL_checkany(L, 1);\n status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);\n lua_pushboolean(L, (status == 0));\n lua_insert(L, 1);\n return lua_gettop(L); /* return status + all results */\n}\n\n\nstatic int luaB_xpcall (lua_State *L) {\n int status;\n luaL_checkany(L, 2);\n lua_settop(L, 2);\n lua_insert(L, 1); /* put error function under function to be called */\n status = lua_pcall(L, 0, LUA_MULTRET, 1);\n lua_pushboolean(L, (status == 0));\n lua_replace(L, 1);\n return lua_gettop(L); /* return status + all results */\n}\n\n\nstatic int luaB_tostring (lua_State *L) {\n luaL_checkany(L, 1);\n if (luaL_callmeta(L, 1, \"__tostring\")) /* is there a metafield? */\n return 1; /* use its value */\n switch (lua_type(L, 1)) {\n case LUA_TNUMBER:\n lua_pushstring(L, lua_tostring(L, 1));\n break;\n case LUA_TSTRING:\n lua_pushvalue(L, 1);\n break;\n case LUA_TBOOLEAN:\n lua_pushstring(L, (lua_toboolean(L, 1) ? \"true\" : \"false\"));\n break;\n case LUA_TNIL:\n lua_pushliteral(L, \"nil\");\n break;\n default:\n lua_pushfstring(L, \"%s: %p\", luaL_typename(L, 1), lua_topointer(L, 1));\n break;\n }\n return 1;\n}\n\n\nstatic int luaB_newproxy (lua_State *L) {\n lua_settop(L, 1);\n lua_newuserdata(L, 0); /* create proxy */\n if (lua_toboolean(L, 1) == 0)\n return 1; /* no metatable */\n else if (lua_isboolean(L, 1)) {\n lua_newtable(L); /* create a new metatable `m' ... */\n lua_pushvalue(L, -1); /* ... and mark `m' as a valid metatable */\n lua_pushboolean(L, 1);\n lua_rawset(L, lua_upvalueindex(1)); /* weaktable[m] = true */\n }\n else {\n int validproxy = 0; /* to check if weaktable[metatable(u)] == true */\n if (lua_getmetatable(L, 1)) {\n lua_rawget(L, lua_upvalueindex(1));\n validproxy = lua_toboolean(L, -1);\n lua_pop(L, 1); /* remove value */\n }\n luaL_argcheck(L, validproxy, 1, \"boolean or proxy expected\");\n lua_getmetatable(L, 1); /* metatable is valid; get it */\n }\n lua_setmetatable(L, 2);\n return 1;\n}\n\n\nstatic const luaL_Reg base_funcs[] = {\n {\"assert\", luaB_assert},\n {\"collectgarbage\", luaB_collectgarbage},\n {\"dofile\", luaB_dofile},\n {\"error\", luaB_error},\n {\"gcinfo\", luaB_gcinfo},\n {\"getfenv\", luaB_getfenv},\n {\"getmetatable\", luaB_getmetatable},\n {\"loadfile\", luaB_loadfile},\n {\"load\", luaB_load},\n {\"loadstring\", luaB_loadstring},\n {\"next\", luaB_next},\n {\"pcall\", luaB_pcall},\n {\"print\", luaB_print},\n {\"rawequal\", luaB_rawequal},\n {\"rawget\", luaB_rawget},\n {\"rawset\", luaB_rawset},\n {\"select\", luaB_select},\n {\"setfenv\", luaB_setfenv},\n {\"setmetatable\", luaB_setmetatable},\n {\"tonumber\", luaB_tonumber},\n {\"tostring\", luaB_tostring},\n {\"type\", luaB_type},\n {\"unpack\", luaB_unpack},\n {\"xpcall\", luaB_xpcall},\n {NULL, NULL}\n};\n\n\n/*\n** {======================================================\n** Coroutine library\n** =======================================================\n*/\n\n#define CO_RUN\t0\t/* running */\n#define CO_SUS\t1\t/* suspended */\n#define CO_NOR\t2\t/* 'normal' (it resumed another coroutine) */\n#define CO_DEAD\t3\n\nstatic const char *const statnames[] =\n {\"running\", \"suspended\", \"normal\", \"dead\"};\n\nstatic int costatus (lua_State *L, lua_State *co) {\n if (L == co) return CO_RUN;\n switch (lua_status(co)) {\n case LUA_YIELD:\n return CO_SUS;\n case 0: {\n lua_Debug ar;\n if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */\n return CO_NOR; /* it is running */\n else if (lua_gettop(co) == 0)\n return CO_DEAD;\n else\n return CO_SUS; /* initial state */\n }\n default: /* some error occured */\n return CO_DEAD;\n }\n}\n\n\nstatic int luaB_costatus (lua_State *L) {\n lua_State *co = lua_tothread(L, 1);\n luaL_argcheck(L, co, 1, \"coroutine expected\");\n lua_pushstring(L, statnames[costatus(L, co)]);\n return 1;\n}\n\n\nstatic int auxresume (lua_State *L, lua_State *co, int narg) {\n int status = costatus(L, co);\n if (!lua_checkstack(co, narg))\n luaL_error(L, \"too many arguments to resume\");\n if (status != CO_SUS) {\n lua_pushfstring(L, \"cannot resume %s coroutine\", statnames[status]);\n return -1; /* error flag */\n }\n lua_xmove(L, co, narg);\n lua_setlevel(L, co);\n status = lua_resume(co, narg);\n if (status == 0 || status == LUA_YIELD) {\n int nres = lua_gettop(co);\n if (!lua_checkstack(L, nres + 1))\n luaL_error(L, \"too many results to resume\");\n lua_xmove(co, L, nres); /* move yielded values */\n return nres;\n }\n else {\n lua_xmove(co, L, 1); /* move error message */\n return -1; /* error flag */\n }\n}\n\n\nstatic int luaB_coresume (lua_State *L) {\n lua_State *co = lua_tothread(L, 1);\n int r;\n luaL_argcheck(L, co, 1, \"coroutine expected\");\n r = auxresume(L, co, lua_gettop(L) - 1);\n if (r < 0) {\n lua_pushboolean(L, 0);\n lua_insert(L, -2);\n return 2; /* return false + error message */\n }\n else {\n lua_pushboolean(L, 1);\n lua_insert(L, -(r + 1));\n return r + 1; /* return true + `resume' returns */\n }\n}\n\n\nstatic int luaB_auxwrap (lua_State *L) {\n lua_State *co = lua_tothread(L, lua_upvalueindex(1));\n int r = auxresume(L, co, lua_gettop(L));\n if (r < 0) {\n if (lua_isstring(L, -1)) { /* error object is a string? */\n luaL_where(L, 1); /* add extra info */\n lua_insert(L, -2);\n lua_concat(L, 2);\n }\n lua_error(L); /* propagate error */\n }\n return r;\n}\n\n\nstatic int luaB_cocreate (lua_State *L) {\n lua_State *NL = lua_newthread(L);\n luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,\n \"Lua function expected\");\n lua_pushvalue(L, 1); /* move function to top */\n lua_xmove(L, NL, 1); /* move function from L to NL */\n return 1;\n}\n\n\nstatic int luaB_cowrap (lua_State *L) {\n luaB_cocreate(L);\n lua_pushcclosure(L, luaB_auxwrap, 1);\n return 1;\n}\n\n\nstatic int luaB_yield (lua_State *L) {\n return lua_yield(L, lua_gettop(L));\n}\n\n\nstatic int luaB_corunning (lua_State *L) {\n if (lua_pushthread(L))\n lua_pushnil(L); /* main thread is not a coroutine */\n return 1;\n}\n\n\nstatic const luaL_Reg co_funcs[] = {\n {\"create\", luaB_cocreate},\n {\"resume\", luaB_coresume},\n {\"running\", luaB_corunning},\n {\"status\", luaB_costatus},\n {\"wrap\", luaB_cowrap},\n {\"yield\", luaB_yield},\n {NULL, NULL}\n};\n\n/* }====================================================== */\n\n\nstatic void auxopen (lua_State *L, const char *name,\n lua_CFunction f, lua_CFunction u) {\n lua_pushcfunction(L, u);\n lua_pushcclosure(L, f, 1);\n lua_setfield(L, -2, name);\n}\n\n\nstatic void base_open (lua_State *L) {\n /* set global _G */\n lua_pushvalue(L, LUA_GLOBALSINDEX);\n lua_setglobal(L, \"_G\");\n /* open lib into global table */\n luaL_register(L, \"_G\", base_funcs);\n lua_pushliteral(L, LUA_VERSION);\n lua_setglobal(L, \"_VERSION\"); /* set global _VERSION */\n /* `ipairs' and `pairs' need auxiliary functions as upvalues */\n auxopen(L, \"ipairs\", luaB_ipairs, ipairsaux);\n auxopen(L, \"pairs\", luaB_pairs, luaB_next);\n /* `newproxy' needs a weaktable as upvalue */\n lua_createtable(L, 0, 1); /* new table `w' */\n lua_pushvalue(L, -1); /* `w' will be its own metatable */\n lua_setmetatable(L, -2);\n lua_pushliteral(L, \"kv\");\n lua_setfield(L, -2, \"__mode\"); /* metatable(w).__mode = \"kv\" */\n lua_pushcclosure(L, luaB_newproxy, 1);\n lua_setglobal(L, \"newproxy\"); /* set global `newproxy' */\n}\n\n\nLUALIB_API int luaopen_base (lua_State *L) {\n base_open(L);\n luaL_register(L, LUA_COLIBNAME, co_funcs);\n return 2;\n}\n\n" }, { "path": "deps/lua/src/lcode.c", "content": "/*\n** $Id: lcode.c,v 2.25.1.5 2011/01/31 14:53:16 roberto Exp $\n** Code generator for Lua\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lcode_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lcode.h\"\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lgc.h\"\n#include \"llex.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lparser.h\"\n#include \"ltable.h\"\n\n\n#define hasjumps(e)\t((e)->t != (e)->f)\n\n\nstatic int isnumeral(expdesc *e) {\n return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);\n}\n\n\nvoid luaK_nil (FuncState *fs, int from, int n) {\n Instruction *previous;\n if (fs->pc > fs->lasttarget) { /* no jumps to current position? */\n if (fs->pc == 0) { /* function start? */\n if (from >= fs->nactvar)\n return; /* positions are already clean */\n }\n else {\n previous = &fs->f->code[fs->pc-1];\n if (GET_OPCODE(*previous) == OP_LOADNIL) {\n int pfrom = GETARG_A(*previous);\n int pto = GETARG_B(*previous);\n if (pfrom <= from && from <= pto+1) { /* can connect both? */\n if (from+n-1 > pto)\n SETARG_B(*previous, from+n-1);\n return;\n }\n }\n }\n }\n luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0); /* else no optimization */\n}\n\n\nint luaK_jump (FuncState *fs) {\n int jpc = fs->jpc; /* save list of jumps to here */\n int j;\n fs->jpc = NO_JUMP;\n j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);\n luaK_concat(fs, &j, jpc); /* keep them on hold */\n return j;\n}\n\n\nvoid luaK_ret (FuncState *fs, int first, int nret) {\n luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);\n}\n\n\nstatic int condjump (FuncState *fs, OpCode op, int A, int B, int C) {\n luaK_codeABC(fs, op, A, B, C);\n return luaK_jump(fs);\n}\n\n\nstatic void fixjump (FuncState *fs, int pc, int dest) {\n Instruction *jmp = &fs->f->code[pc];\n int offset = dest-(pc+1);\n lua_assert(dest != NO_JUMP);\n if (abs(offset) > MAXARG_sBx)\n luaX_syntaxerror(fs->ls, \"control structure too long\");\n SETARG_sBx(*jmp, offset);\n}\n\n\n/*\n** returns current `pc' and marks it as a jump target (to avoid wrong\n** optimizations with consecutive instructions not in the same basic block).\n*/\nint luaK_getlabel (FuncState *fs) {\n fs->lasttarget = fs->pc;\n return fs->pc;\n}\n\n\nstatic int getjump (FuncState *fs, int pc) {\n int offset = GETARG_sBx(fs->f->code[pc]);\n if (offset == NO_JUMP) /* point to itself represents end of list */\n return NO_JUMP; /* end of list */\n else\n return (pc+1)+offset; /* turn offset into absolute position */\n}\n\n\nstatic Instruction *getjumpcontrol (FuncState *fs, int pc) {\n Instruction *pi = &fs->f->code[pc];\n if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))\n return pi-1;\n else\n return pi;\n}\n\n\n/*\n** check whether list has any jump that do not produce a value\n** (or produce an inverted value)\n*/\nstatic int need_value (FuncState *fs, int list) {\n for (; list != NO_JUMP; list = getjump(fs, list)) {\n Instruction i = *getjumpcontrol(fs, list);\n if (GET_OPCODE(i) != OP_TESTSET) return 1;\n }\n return 0; /* not found */\n}\n\n\nstatic int patchtestreg (FuncState *fs, int node, int reg) {\n Instruction *i = getjumpcontrol(fs, node);\n if (GET_OPCODE(*i) != OP_TESTSET)\n return 0; /* cannot patch other instructions */\n if (reg != NO_REG && reg != GETARG_B(*i))\n SETARG_A(*i, reg);\n else /* no register to put value or register already has the value */\n *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));\n\n return 1;\n}\n\n\nstatic void removevalues (FuncState *fs, int list) {\n for (; list != NO_JUMP; list = getjump(fs, list))\n patchtestreg(fs, list, NO_REG);\n}\n\n\nstatic void patchlistaux (FuncState *fs, int list, int vtarget, int reg,\n int dtarget) {\n while (list != NO_JUMP) {\n int next = getjump(fs, list);\n if (patchtestreg(fs, list, reg))\n fixjump(fs, list, vtarget);\n else\n fixjump(fs, list, dtarget); /* jump to default target */\n list = next;\n }\n}\n\n\nstatic void dischargejpc (FuncState *fs) {\n patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);\n fs->jpc = NO_JUMP;\n}\n\n\nvoid luaK_patchlist (FuncState *fs, int list, int target) {\n if (target == fs->pc)\n luaK_patchtohere(fs, list);\n else {\n lua_assert(target < fs->pc);\n patchlistaux(fs, list, target, NO_REG, target);\n }\n}\n\n\nvoid luaK_patchtohere (FuncState *fs, int list) {\n luaK_getlabel(fs);\n luaK_concat(fs, &fs->jpc, list);\n}\n\n\nvoid luaK_concat (FuncState *fs, int *l1, int l2) {\n if (l2 == NO_JUMP) return;\n else if (*l1 == NO_JUMP)\n *l1 = l2;\n else {\n int list = *l1;\n int next;\n while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */\n list = next;\n fixjump(fs, list, l2);\n }\n}\n\n\nvoid luaK_checkstack (FuncState *fs, int n) {\n int newstack = fs->freereg + n;\n if (newstack > fs->f->maxstacksize) {\n if (newstack >= MAXSTACK)\n luaX_syntaxerror(fs->ls, \"function or expression too complex\");\n fs->f->maxstacksize = cast_byte(newstack);\n }\n}\n\n\nvoid luaK_reserveregs (FuncState *fs, int n) {\n luaK_checkstack(fs, n);\n fs->freereg += n;\n}\n\n\nstatic void freereg (FuncState *fs, int reg) {\n if (!ISK(reg) && reg >= fs->nactvar) {\n fs->freereg--;\n lua_assert(reg == fs->freereg);\n }\n}\n\n\nstatic void freeexp (FuncState *fs, expdesc *e) {\n if (e->k == VNONRELOC)\n freereg(fs, e->u.s.info);\n}\n\n\nstatic int addk (FuncState *fs, TValue *k, TValue *v) {\n lua_State *L = fs->L;\n TValue *idx = luaH_set(L, fs->h, k);\n Proto *f = fs->f;\n int oldsize = f->sizek;\n if (ttisnumber(idx)) {\n lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));\n return cast_int(nvalue(idx));\n }\n else { /* constant not found; create a new entry */\n setnvalue(idx, cast_num(fs->nk));\n luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,\n MAXARG_Bx, \"constant table overflow\");\n while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);\n setobj(L, &f->k[fs->nk], v);\n luaC_barrier(L, f, v);\n return fs->nk++;\n }\n}\n\n\nint luaK_stringK (FuncState *fs, TString *s) {\n TValue o;\n setsvalue(fs->L, &o, s);\n return addk(fs, &o, &o);\n}\n\n\nint luaK_numberK (FuncState *fs, lua_Number r) {\n TValue o;\n setnvalue(&o, r);\n return addk(fs, &o, &o);\n}\n\n\nstatic int boolK (FuncState *fs, int b) {\n TValue o;\n setbvalue(&o, b);\n return addk(fs, &o, &o);\n}\n\n\nstatic int nilK (FuncState *fs) {\n TValue k, v;\n setnilvalue(&v);\n /* cannot use nil as key; instead use table itself to represent nil */\n sethvalue(fs->L, &k, fs->h);\n return addk(fs, &k, &v);\n}\n\n\nvoid luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {\n if (e->k == VCALL) { /* expression is an open function call? */\n SETARG_C(getcode(fs, e), nresults+1);\n }\n else if (e->k == VVARARG) {\n SETARG_B(getcode(fs, e), nresults+1);\n SETARG_A(getcode(fs, e), fs->freereg);\n luaK_reserveregs(fs, 1);\n }\n}\n\n\nvoid luaK_setoneret (FuncState *fs, expdesc *e) {\n if (e->k == VCALL) { /* expression is an open function call? */\n e->k = VNONRELOC;\n e->u.s.info = GETARG_A(getcode(fs, e));\n }\n else if (e->k == VVARARG) {\n SETARG_B(getcode(fs, e), 2);\n e->k = VRELOCABLE; /* can relocate its simple result */\n }\n}\n\n\nvoid luaK_dischargevars (FuncState *fs, expdesc *e) {\n switch (e->k) {\n case VLOCAL: {\n e->k = VNONRELOC;\n break;\n }\n case VUPVAL: {\n e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);\n e->k = VRELOCABLE;\n break;\n }\n case VGLOBAL: {\n e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);\n e->k = VRELOCABLE;\n break;\n }\n case VINDEXED: {\n freereg(fs, e->u.s.aux);\n freereg(fs, e->u.s.info);\n e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);\n e->k = VRELOCABLE;\n break;\n }\n case VVARARG:\n case VCALL: {\n luaK_setoneret(fs, e);\n break;\n }\n default: break; /* there is one value available (somewhere) */\n }\n}\n\n\nstatic int code_label (FuncState *fs, int A, int b, int jump) {\n luaK_getlabel(fs); /* those instructions may be jump targets */\n return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);\n}\n\n\nstatic void discharge2reg (FuncState *fs, expdesc *e, int reg) {\n luaK_dischargevars(fs, e);\n switch (e->k) {\n case VNIL: {\n luaK_nil(fs, reg, 1);\n break;\n }\n case VFALSE: case VTRUE: {\n luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);\n break;\n }\n case VK: {\n luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);\n break;\n }\n case VKNUM: {\n luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));\n break;\n }\n case VRELOCABLE: {\n Instruction *pc = &getcode(fs, e);\n SETARG_A(*pc, reg);\n break;\n }\n case VNONRELOC: {\n if (reg != e->u.s.info)\n luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);\n break;\n }\n default: {\n lua_assert(e->k == VVOID || e->k == VJMP);\n return; /* nothing to do... */\n }\n }\n e->u.s.info = reg;\n e->k = VNONRELOC;\n}\n\n\nstatic void discharge2anyreg (FuncState *fs, expdesc *e) {\n if (e->k != VNONRELOC) {\n luaK_reserveregs(fs, 1);\n discharge2reg(fs, e, fs->freereg-1);\n }\n}\n\n\nstatic void exp2reg (FuncState *fs, expdesc *e, int reg) {\n discharge2reg(fs, e, reg);\n if (e->k == VJMP)\n luaK_concat(fs, &e->t, e->u.s.info); /* put this jump in `t' list */\n if (hasjumps(e)) {\n int final; /* position after whole expression */\n int p_f = NO_JUMP; /* position of an eventual LOAD false */\n int p_t = NO_JUMP; /* position of an eventual LOAD true */\n if (need_value(fs, e->t) || need_value(fs, e->f)) {\n int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);\n p_f = code_label(fs, reg, 0, 1);\n p_t = code_label(fs, reg, 1, 0);\n luaK_patchtohere(fs, fj);\n }\n final = luaK_getlabel(fs);\n patchlistaux(fs, e->f, final, reg, p_f);\n patchlistaux(fs, e->t, final, reg, p_t);\n }\n e->f = e->t = NO_JUMP;\n e->u.s.info = reg;\n e->k = VNONRELOC;\n}\n\n\nvoid luaK_exp2nextreg (FuncState *fs, expdesc *e) {\n luaK_dischargevars(fs, e);\n freeexp(fs, e);\n luaK_reserveregs(fs, 1);\n exp2reg(fs, e, fs->freereg - 1);\n}\n\n\nint luaK_exp2anyreg (FuncState *fs, expdesc *e) {\n luaK_dischargevars(fs, e);\n if (e->k == VNONRELOC) {\n if (!hasjumps(e)) return e->u.s.info; /* exp is already in a register */\n if (e->u.s.info >= fs->nactvar) { /* reg. is not a local? */\n exp2reg(fs, e, e->u.s.info); /* put value on it */\n return e->u.s.info;\n }\n }\n luaK_exp2nextreg(fs, e); /* default */\n return e->u.s.info;\n}\n\n\nvoid luaK_exp2val (FuncState *fs, expdesc *e) {\n if (hasjumps(e))\n luaK_exp2anyreg(fs, e);\n else\n luaK_dischargevars(fs, e);\n}\n\n\nint luaK_exp2RK (FuncState *fs, expdesc *e) {\n luaK_exp2val(fs, e);\n switch (e->k) {\n case VKNUM:\n case VTRUE:\n case VFALSE:\n case VNIL: {\n if (fs->nk <= MAXINDEXRK) { /* constant fit in RK operand? */\n e->u.s.info = (e->k == VNIL) ? nilK(fs) :\n (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :\n boolK(fs, (e->k == VTRUE));\n e->k = VK;\n return RKASK(e->u.s.info);\n }\n else break;\n }\n case VK: {\n if (e->u.s.info <= MAXINDEXRK) /* constant fit in argC? */\n return RKASK(e->u.s.info);\n else break;\n }\n default: break;\n }\n /* not a constant in the right range: put it in a register */\n return luaK_exp2anyreg(fs, e);\n}\n\n\nvoid luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {\n switch (var->k) {\n case VLOCAL: {\n freeexp(fs, ex);\n exp2reg(fs, ex, var->u.s.info);\n return;\n }\n case VUPVAL: {\n int e = luaK_exp2anyreg(fs, ex);\n luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);\n break;\n }\n case VGLOBAL: {\n int e = luaK_exp2anyreg(fs, ex);\n luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);\n break;\n }\n case VINDEXED: {\n int e = luaK_exp2RK(fs, ex);\n luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);\n break;\n }\n default: {\n lua_assert(0); /* invalid var kind to store */\n break;\n }\n }\n freeexp(fs, ex);\n}\n\n\nvoid luaK_self (FuncState *fs, expdesc *e, expdesc *key) {\n int func;\n luaK_exp2anyreg(fs, e);\n freeexp(fs, e);\n func = fs->freereg;\n luaK_reserveregs(fs, 2);\n luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));\n freeexp(fs, key);\n e->u.s.info = func;\n e->k = VNONRELOC;\n}\n\n\nstatic void invertjump (FuncState *fs, expdesc *e) {\n Instruction *pc = getjumpcontrol(fs, e->u.s.info);\n lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&\n GET_OPCODE(*pc) != OP_TEST);\n SETARG_A(*pc, !(GETARG_A(*pc)));\n}\n\n\nstatic int jumponcond (FuncState *fs, expdesc *e, int cond) {\n if (e->k == VRELOCABLE) {\n Instruction ie = getcode(fs, e);\n if (GET_OPCODE(ie) == OP_NOT) {\n fs->pc--; /* remove previous OP_NOT */\n return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);\n }\n /* else go through */\n }\n discharge2anyreg(fs, e);\n freeexp(fs, e);\n return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);\n}\n\n\nvoid luaK_goiftrue (FuncState *fs, expdesc *e) {\n int pc; /* pc of last jump */\n luaK_dischargevars(fs, e);\n switch (e->k) {\n case VK: case VKNUM: case VTRUE: {\n pc = NO_JUMP; /* always true; do nothing */\n break;\n }\n case VJMP: {\n invertjump(fs, e);\n pc = e->u.s.info;\n break;\n }\n default: {\n pc = jumponcond(fs, e, 0);\n break;\n }\n }\n luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */\n luaK_patchtohere(fs, e->t);\n e->t = NO_JUMP;\n}\n\n\nstatic void luaK_goiffalse (FuncState *fs, expdesc *e) {\n int pc; /* pc of last jump */\n luaK_dischargevars(fs, e);\n switch (e->k) {\n case VNIL: case VFALSE: {\n pc = NO_JUMP; /* always false; do nothing */\n break;\n }\n case VJMP: {\n pc = e->u.s.info;\n break;\n }\n default: {\n pc = jumponcond(fs, e, 1);\n break;\n }\n }\n luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */\n luaK_patchtohere(fs, e->f);\n e->f = NO_JUMP;\n}\n\n\nstatic void codenot (FuncState *fs, expdesc *e) {\n luaK_dischargevars(fs, e);\n switch (e->k) {\n case VNIL: case VFALSE: {\n e->k = VTRUE;\n break;\n }\n case VK: case VKNUM: case VTRUE: {\n e->k = VFALSE;\n break;\n }\n case VJMP: {\n invertjump(fs, e);\n break;\n }\n case VRELOCABLE:\n case VNONRELOC: {\n discharge2anyreg(fs, e);\n freeexp(fs, e);\n e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);\n e->k = VRELOCABLE;\n break;\n }\n default: {\n lua_assert(0); /* cannot happen */\n break;\n }\n }\n /* interchange true and false lists */\n { int temp = e->f; e->f = e->t; e->t = temp; }\n removevalues(fs, e->f);\n removevalues(fs, e->t);\n}\n\n\nvoid luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {\n t->u.s.aux = luaK_exp2RK(fs, k);\n t->k = VINDEXED;\n}\n\n\nstatic int constfolding (OpCode op, expdesc *e1, expdesc *e2) {\n lua_Number v1, v2, r;\n if (!isnumeral(e1) || !isnumeral(e2)) return 0;\n v1 = e1->u.nval;\n v2 = e2->u.nval;\n switch (op) {\n case OP_ADD: r = luai_numadd(v1, v2); break;\n case OP_SUB: r = luai_numsub(v1, v2); break;\n case OP_MUL: r = luai_nummul(v1, v2); break;\n case OP_DIV:\n if (v2 == 0) return 0; /* do not attempt to divide by 0 */\n r = luai_numdiv(v1, v2); break;\n case OP_MOD:\n if (v2 == 0) return 0; /* do not attempt to divide by 0 */\n r = luai_nummod(v1, v2); break;\n case OP_POW: r = luai_numpow(v1, v2); break;\n case OP_UNM: r = luai_numunm(v1); break;\n case OP_LEN: return 0; /* no constant folding for 'len' */\n default: lua_assert(0); r = 0; break;\n }\n if (luai_numisnan(r)) return 0; /* do not attempt to produce NaN */\n e1->u.nval = r;\n return 1;\n}\n\n\nstatic void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {\n if (constfolding(op, e1, e2))\n return;\n else {\n int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;\n int o1 = luaK_exp2RK(fs, e1);\n if (o1 > o2) {\n freeexp(fs, e1);\n freeexp(fs, e2);\n }\n else {\n freeexp(fs, e2);\n freeexp(fs, e1);\n }\n e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);\n e1->k = VRELOCABLE;\n }\n}\n\n\nstatic void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,\n expdesc *e2) {\n int o1 = luaK_exp2RK(fs, e1);\n int o2 = luaK_exp2RK(fs, e2);\n freeexp(fs, e2);\n freeexp(fs, e1);\n if (cond == 0 && op != OP_EQ) {\n int temp; /* exchange args to replace by `<' or `<=' */\n temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */\n cond = 1;\n }\n e1->u.s.info = condjump(fs, op, cond, o1, o2);\n e1->k = VJMP;\n}\n\n\nvoid luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {\n expdesc e2;\n e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;\n switch (op) {\n case OPR_MINUS: {\n if (!isnumeral(e))\n luaK_exp2anyreg(fs, e); /* cannot operate on non-numeric constants */\n codearith(fs, OP_UNM, e, &e2);\n break;\n }\n case OPR_NOT: codenot(fs, e); break;\n case OPR_LEN: {\n luaK_exp2anyreg(fs, e); /* cannot operate on constants */\n codearith(fs, OP_LEN, e, &e2);\n break;\n }\n default: lua_assert(0);\n }\n}\n\n\nvoid luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {\n switch (op) {\n case OPR_AND: {\n luaK_goiftrue(fs, v);\n break;\n }\n case OPR_OR: {\n luaK_goiffalse(fs, v);\n break;\n }\n case OPR_CONCAT: {\n luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */\n break;\n }\n case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:\n case OPR_MOD: case OPR_POW: {\n if (!isnumeral(v)) luaK_exp2RK(fs, v);\n break;\n }\n default: {\n luaK_exp2RK(fs, v);\n break;\n }\n }\n}\n\n\nvoid luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {\n switch (op) {\n case OPR_AND: {\n lua_assert(e1->t == NO_JUMP); /* list must be closed */\n luaK_dischargevars(fs, e2);\n luaK_concat(fs, &e2->f, e1->f);\n *e1 = *e2;\n break;\n }\n case OPR_OR: {\n lua_assert(e1->f == NO_JUMP); /* list must be closed */\n luaK_dischargevars(fs, e2);\n luaK_concat(fs, &e2->t, e1->t);\n *e1 = *e2;\n break;\n }\n case OPR_CONCAT: {\n luaK_exp2val(fs, e2);\n if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {\n lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);\n freeexp(fs, e1);\n SETARG_B(getcode(fs, e2), e1->u.s.info);\n e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;\n }\n else {\n luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */\n codearith(fs, OP_CONCAT, e1, e2);\n }\n break;\n }\n case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;\n case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;\n case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;\n case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;\n case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;\n case OPR_POW: codearith(fs, OP_POW, e1, e2); break;\n case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;\n case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;\n case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;\n case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;\n case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;\n case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;\n default: lua_assert(0);\n }\n}\n\n\nvoid luaK_fixline (FuncState *fs, int line) {\n fs->f->lineinfo[fs->pc - 1] = line;\n}\n\n\nstatic int luaK_code (FuncState *fs, Instruction i, int line) {\n Proto *f = fs->f;\n dischargejpc(fs); /* `pc' will change */\n /* put new instruction in code array */\n luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,\n MAX_INT, \"code size overflow\");\n f->code[fs->pc] = i;\n /* save corresponding line information */\n luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,\n MAX_INT, \"code size overflow\");\n f->lineinfo[fs->pc] = line;\n return fs->pc++;\n}\n\n\nint luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {\n lua_assert(getOpMode(o) == iABC);\n lua_assert(getBMode(o) != OpArgN || b == 0);\n lua_assert(getCMode(o) != OpArgN || c == 0);\n return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);\n}\n\n\nint luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {\n lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);\n lua_assert(getCMode(o) == OpArgN);\n return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);\n}\n\n\nvoid luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {\n int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1;\n int b = (tostore == LUA_MULTRET) ? 0 : tostore;\n lua_assert(tostore != 0);\n if (c <= MAXARG_C)\n luaK_codeABC(fs, OP_SETLIST, base, b, c);\n else {\n luaK_codeABC(fs, OP_SETLIST, base, b, 0);\n luaK_code(fs, cast(Instruction, c), fs->ls->lastline);\n }\n fs->freereg = base + 1; /* free registers with list values */\n}\n\n" }, { "path": "deps/lua/src/lcode.h", "content": "/*\n** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $\n** Code generator for Lua\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lcode_h\n#define lcode_h\n\n#include \"llex.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lparser.h\"\n\n\n/*\n** Marks the end of a patch list. It is an invalid value both as an absolute\n** address, and as a list link (would link an element to itself).\n*/\n#define NO_JUMP (-1)\n\n\n/*\n** grep \"ORDER OPR\" if you change these enums\n*/\ntypedef enum BinOpr {\n OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,\n OPR_CONCAT,\n OPR_NE, OPR_EQ,\n OPR_LT, OPR_LE, OPR_GT, OPR_GE,\n OPR_AND, OPR_OR,\n OPR_NOBINOPR\n} BinOpr;\n\n\ntypedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;\n\n\n#define getcode(fs,e)\t((fs)->f->code[(e)->u.s.info])\n\n#define luaK_codeAsBx(fs,o,A,sBx)\tluaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)\n\n#define luaK_setmultret(fs,e)\tluaK_setreturns(fs, e, LUA_MULTRET)\n\nLUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);\nLUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);\nLUAI_FUNC void luaK_fixline (FuncState *fs, int line);\nLUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);\nLUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);\nLUAI_FUNC void luaK_checkstack (FuncState *fs, int n);\nLUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);\nLUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);\nLUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);\nLUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);\nLUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);\nLUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);\nLUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);\nLUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);\nLUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);\nLUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);\nLUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);\nLUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);\nLUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);\nLUAI_FUNC int luaK_jump (FuncState *fs);\nLUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);\nLUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);\nLUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);\nLUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);\nLUAI_FUNC int luaK_getlabel (FuncState *fs);\nLUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);\nLUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);\nLUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);\nLUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);\n\n\n#endif\n" }, { "path": "deps/lua/src/ldblib.c", "content": "/*\n** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $\n** Interface from Lua to its debug API\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n\n#define ldblib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n\nstatic int db_getregistry (lua_State *L) {\n lua_pushvalue(L, LUA_REGISTRYINDEX);\n return 1;\n}\n\n\nstatic int db_getmetatable (lua_State *L) {\n luaL_checkany(L, 1);\n if (!lua_getmetatable(L, 1)) {\n lua_pushnil(L); /* no metatable */\n }\n return 1;\n}\n\n\nstatic int db_setmetatable (lua_State *L) {\n int t = lua_type(L, 2);\n luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,\n \"nil or table expected\");\n lua_settop(L, 2);\n lua_pushboolean(L, lua_setmetatable(L, 1));\n return 1;\n}\n\n\nstatic int db_getfenv (lua_State *L) {\n luaL_checkany(L, 1);\n lua_getfenv(L, 1);\n return 1;\n}\n\n\nstatic int db_setfenv (lua_State *L) {\n luaL_checktype(L, 2, LUA_TTABLE);\n lua_settop(L, 2);\n if (lua_setfenv(L, 1) == 0)\n luaL_error(L, LUA_QL(\"setfenv\")\n \" cannot change environment of given object\");\n return 1;\n}\n\n\nstatic void settabss (lua_State *L, const char *i, const char *v) {\n lua_pushstring(L, v);\n lua_setfield(L, -2, i);\n}\n\n\nstatic void settabsi (lua_State *L, const char *i, int v) {\n lua_pushinteger(L, v);\n lua_setfield(L, -2, i);\n}\n\n\nstatic lua_State *getthread (lua_State *L, int *arg) {\n if (lua_isthread(L, 1)) {\n *arg = 1;\n return lua_tothread(L, 1);\n }\n else {\n *arg = 0;\n return L;\n }\n}\n\n\nstatic void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {\n if (L == L1) {\n lua_pushvalue(L, -2);\n lua_remove(L, -3);\n }\n else\n lua_xmove(L1, L, 1);\n lua_setfield(L, -2, fname);\n}\n\n\nstatic int db_getinfo (lua_State *L) {\n lua_Debug ar;\n int arg;\n lua_State *L1 = getthread(L, &arg);\n const char *options = luaL_optstring(L, arg+2, \"flnSu\");\n if (lua_isnumber(L, arg+1)) {\n if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {\n lua_pushnil(L); /* level out of range */\n return 1;\n }\n }\n else if (lua_isfunction(L, arg+1)) {\n lua_pushfstring(L, \">%s\", options);\n options = lua_tostring(L, -1);\n lua_pushvalue(L, arg+1);\n lua_xmove(L, L1, 1);\n }\n else\n return luaL_argerror(L, arg+1, \"function or level expected\");\n if (!lua_getinfo(L1, options, &ar))\n return luaL_argerror(L, arg+2, \"invalid option\");\n lua_createtable(L, 0, 2);\n if (strchr(options, 'S')) {\n settabss(L, \"source\", ar.source);\n settabss(L, \"short_src\", ar.short_src);\n settabsi(L, \"linedefined\", ar.linedefined);\n settabsi(L, \"lastlinedefined\", ar.lastlinedefined);\n settabss(L, \"what\", ar.what);\n }\n if (strchr(options, 'l'))\n settabsi(L, \"currentline\", ar.currentline);\n if (strchr(options, 'u'))\n settabsi(L, \"nups\", ar.nups);\n if (strchr(options, 'n')) {\n settabss(L, \"name\", ar.name);\n settabss(L, \"namewhat\", ar.namewhat);\n }\n if (strchr(options, 'L'))\n treatstackoption(L, L1, \"activelines\");\n if (strchr(options, 'f'))\n treatstackoption(L, L1, \"func\");\n return 1; /* return table */\n}\n \n\nstatic int db_getlocal (lua_State *L) {\n int arg;\n lua_State *L1 = getthread(L, &arg);\n lua_Debug ar;\n const char *name;\n if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */\n return luaL_argerror(L, arg+1, \"level out of range\");\n name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));\n if (name) {\n lua_xmove(L1, L, 1);\n lua_pushstring(L, name);\n lua_pushvalue(L, -2);\n return 2;\n }\n else {\n lua_pushnil(L);\n return 1;\n }\n}\n\n\nstatic int db_setlocal (lua_State *L) {\n int arg;\n lua_State *L1 = getthread(L, &arg);\n lua_Debug ar;\n if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */\n return luaL_argerror(L, arg+1, \"level out of range\");\n luaL_checkany(L, arg+3);\n lua_settop(L, arg+3);\n lua_xmove(L, L1, 1);\n lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));\n return 1;\n}\n\n\nstatic int auxupvalue (lua_State *L, int get) {\n const char *name;\n int n = luaL_checkint(L, 2);\n luaL_checktype(L, 1, LUA_TFUNCTION);\n if (lua_iscfunction(L, 1)) return 0; /* cannot touch C upvalues from Lua */\n name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);\n if (name == NULL) return 0;\n lua_pushstring(L, name);\n lua_insert(L, -(get+1));\n return get + 1;\n}\n\n\nstatic int db_getupvalue (lua_State *L) {\n return auxupvalue(L, 1);\n}\n\n\nstatic int db_setupvalue (lua_State *L) {\n luaL_checkany(L, 3);\n return auxupvalue(L, 0);\n}\n\n\n\nstatic const char KEY_HOOK = 'h';\n\n\nstatic void hookf (lua_State *L, lua_Debug *ar) {\n static const char *const hooknames[] =\n {\"call\", \"return\", \"line\", \"count\", \"tail return\"};\n lua_pushlightuserdata(L, (void *)&KEY_HOOK);\n lua_rawget(L, LUA_REGISTRYINDEX);\n lua_pushlightuserdata(L, L);\n lua_rawget(L, -2);\n if (lua_isfunction(L, -1)) {\n lua_pushstring(L, hooknames[(int)ar->event]);\n if (ar->currentline >= 0)\n lua_pushinteger(L, ar->currentline);\n else lua_pushnil(L);\n lua_assert(lua_getinfo(L, \"lS\", ar));\n lua_call(L, 2, 0);\n }\n}\n\n\nstatic int makemask (const char *smask, int count) {\n int mask = 0;\n if (strchr(smask, 'c')) mask |= LUA_MASKCALL;\n if (strchr(smask, 'r')) mask |= LUA_MASKRET;\n if (strchr(smask, 'l')) mask |= LUA_MASKLINE;\n if (count > 0) mask |= LUA_MASKCOUNT;\n return mask;\n}\n\n\nstatic char *unmakemask (int mask, char *smask) {\n int i = 0;\n if (mask & LUA_MASKCALL) smask[i++] = 'c';\n if (mask & LUA_MASKRET) smask[i++] = 'r';\n if (mask & LUA_MASKLINE) smask[i++] = 'l';\n smask[i] = '\\0';\n return smask;\n}\n\n\nstatic void gethooktable (lua_State *L) {\n lua_pushlightuserdata(L, (void *)&KEY_HOOK);\n lua_rawget(L, LUA_REGISTRYINDEX);\n if (!lua_istable(L, -1)) {\n lua_pop(L, 1);\n lua_createtable(L, 0, 1);\n lua_pushlightuserdata(L, (void *)&KEY_HOOK);\n lua_pushvalue(L, -2);\n lua_rawset(L, LUA_REGISTRYINDEX);\n }\n}\n\n\nstatic int db_sethook (lua_State *L) {\n int arg, mask, count;\n lua_Hook func;\n lua_State *L1 = getthread(L, &arg);\n if (lua_isnoneornil(L, arg+1)) {\n lua_settop(L, arg+1);\n func = NULL; mask = 0; count = 0; /* turn off hooks */\n }\n else {\n const char *smask = luaL_checkstring(L, arg+2);\n luaL_checktype(L, arg+1, LUA_TFUNCTION);\n count = luaL_optint(L, arg+3, 0);\n func = hookf; mask = makemask(smask, count);\n }\n gethooktable(L);\n lua_pushlightuserdata(L, L1);\n lua_pushvalue(L, arg+1);\n lua_rawset(L, -3); /* set new hook */\n lua_pop(L, 1); /* remove hook table */\n lua_sethook(L1, func, mask, count); /* set hooks */\n return 0;\n}\n\n\nstatic int db_gethook (lua_State *L) {\n int arg;\n lua_State *L1 = getthread(L, &arg);\n char buff[5];\n int mask = lua_gethookmask(L1);\n lua_Hook hook = lua_gethook(L1);\n if (hook != NULL && hook != hookf) /* external hook? */\n lua_pushliteral(L, \"external hook\");\n else {\n gethooktable(L);\n lua_pushlightuserdata(L, L1);\n lua_rawget(L, -2); /* get hook */\n lua_remove(L, -2); /* remove hook table */\n }\n lua_pushstring(L, unmakemask(mask, buff));\n lua_pushinteger(L, lua_gethookcount(L1));\n return 3;\n}\n\n\nstatic int db_debug (lua_State *L) {\n for (;;) {\n char buffer[250];\n fputs(\"lua_debug> \", stderr);\n if (fgets(buffer, sizeof(buffer), stdin) == 0 ||\n strcmp(buffer, \"cont\\n\") == 0)\n return 0;\n if (luaL_loadbuffer(L, buffer, strlen(buffer), \"=(debug command)\") ||\n lua_pcall(L, 0, 0, 0)) {\n fputs(lua_tostring(L, -1), stderr);\n fputs(\"\\n\", stderr);\n }\n lua_settop(L, 0); /* remove eventual returns */\n }\n}\n\n\n#define LEVELS1\t12\t/* size of the first part of the stack */\n#define LEVELS2\t10\t/* size of the second part of the stack */\n\nstatic int db_errorfb (lua_State *L) {\n int level;\n int firstpart = 1; /* still before eventual `...' */\n int arg;\n lua_State *L1 = getthread(L, &arg);\n lua_Debug ar;\n if (lua_isnumber(L, arg+2)) {\n level = (int)lua_tointeger(L, arg+2);\n lua_pop(L, 1);\n }\n else\n level = (L == L1) ? 1 : 0; /* level 0 may be this own function */\n if (lua_gettop(L) == arg)\n lua_pushliteral(L, \"\");\n else if (!lua_isstring(L, arg+1)) return 1; /* message is not a string */\n else lua_pushliteral(L, \"\\n\");\n lua_pushliteral(L, \"stack traceback:\");\n while (lua_getstack(L1, level++, &ar)) {\n if (level > LEVELS1 && firstpart) {\n /* no more than `LEVELS2' more levels? */\n if (!lua_getstack(L1, level+LEVELS2, &ar))\n level--; /* keep going */\n else {\n lua_pushliteral(L, \"\\n\\t...\"); /* too many levels */\n while (lua_getstack(L1, level+LEVELS2, &ar)) /* find last levels */\n level++;\n }\n firstpart = 0;\n continue;\n }\n lua_pushliteral(L, \"\\n\\t\");\n lua_getinfo(L1, \"Snl\", &ar);\n lua_pushfstring(L, \"%s:\", ar.short_src);\n if (ar.currentline > 0)\n lua_pushfstring(L, \"%d:\", ar.currentline);\n if (*ar.namewhat != '\\0') /* is there a name? */\n lua_pushfstring(L, \" in function \" LUA_QS, ar.name);\n else {\n if (*ar.what == 'm') /* main? */\n lua_pushfstring(L, \" in main chunk\");\n else if (*ar.what == 'C' || *ar.what == 't')\n lua_pushliteral(L, \" ?\"); /* C function or tail call */\n else\n lua_pushfstring(L, \" in function <%s:%d>\",\n ar.short_src, ar.linedefined);\n }\n lua_concat(L, lua_gettop(L) - arg);\n }\n lua_concat(L, lua_gettop(L) - arg);\n return 1;\n}\n\n\nstatic const luaL_Reg dblib[] = {\n {\"debug\", db_debug},\n {\"getfenv\", db_getfenv},\n {\"gethook\", db_gethook},\n {\"getinfo\", db_getinfo},\n {\"getlocal\", db_getlocal},\n {\"getregistry\", db_getregistry},\n {\"getmetatable\", db_getmetatable},\n {\"getupvalue\", db_getupvalue},\n {\"setfenv\", db_setfenv},\n {\"sethook\", db_sethook},\n {\"setlocal\", db_setlocal},\n {\"setmetatable\", db_setmetatable},\n {\"setupvalue\", db_setupvalue},\n {\"traceback\", db_errorfb},\n {NULL, NULL}\n};\n\n\nLUALIB_API int luaopen_debug (lua_State *L) {\n luaL_register(L, LUA_DBLIBNAME, dblib);\n return 1;\n}\n\n" }, { "path": "deps/lua/src/ldebug.c", "content": "/*\n** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $\n** Debug Interface\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n\n\n#define ldebug_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lapi.h\"\n#include \"lcode.h\"\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n#include \"lvm.h\"\n\n\n\nstatic const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);\n\n\nstatic int currentpc (lua_State *L, CallInfo *ci) {\n if (!isLua(ci)) return -1; /* function is not a Lua function? */\n if (ci == L->ci)\n ci->savedpc = L->savedpc;\n return pcRel(ci->savedpc, ci_func(ci)->l.p);\n}\n\n\nstatic int currentline (lua_State *L, CallInfo *ci) {\n int pc = currentpc(L, ci);\n if (pc < 0)\n return -1; /* only active lua functions have current-line information */\n else\n return getline(ci_func(ci)->l.p, pc);\n}\n\n\n/*\n** this function can be called asynchronous (e.g. during a signal)\n*/\nLUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {\n if (func == NULL || mask == 0) { /* turn off hooks? */\n mask = 0;\n func = NULL;\n }\n L->hook = func;\n L->basehookcount = count;\n resethookcount(L);\n L->hookmask = cast_byte(mask);\n return 1;\n}\n\n\nLUA_API lua_Hook lua_gethook (lua_State *L) {\n return L->hook;\n}\n\n\nLUA_API int lua_gethookmask (lua_State *L) {\n return L->hookmask;\n}\n\n\nLUA_API int lua_gethookcount (lua_State *L) {\n return L->basehookcount;\n}\n\nLUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {\n int status;\n CallInfo *ci;\n lua_lock(L);\n for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {\n level--;\n if (f_isLua(ci)) /* Lua function? */\n level -= ci->tailcalls; /* skip lost tail calls */\n }\n if (level == 0 && ci > L->base_ci) { /* level found? */\n status = 1;\n ar->i_ci = cast_int(ci - L->base_ci);\n }\n else if (level < 0) { /* level is of a lost tail call? */\n status = 1;\n ar->i_ci = 0;\n }\n else status = 0; /* no such level */\n lua_unlock(L);\n return status;\n}\n\n\nstatic Proto *getluaproto (CallInfo *ci) {\n return (isLua(ci) ? ci_func(ci)->l.p : NULL);\n}\n\n\nstatic const char *findlocal (lua_State *L, CallInfo *ci, int n) {\n const char *name;\n Proto *fp = getluaproto(ci);\n if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)\n return name; /* is a local variable in a Lua function */\n else {\n StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;\n if (limit - ci->base >= n && n > 0) /* is 'n' inside 'ci' stack? */\n return \"(*temporary)\";\n else\n return NULL;\n }\n}\n\n\nLUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {\n CallInfo *ci = L->base_ci + ar->i_ci;\n const char *name = findlocal(L, ci, n);\n lua_lock(L);\n if (name)\n luaA_pushobject(L, ci->base + (n - 1));\n lua_unlock(L);\n return name;\n}\n\n\nLUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {\n CallInfo *ci = L->base_ci + ar->i_ci;\n const char *name = findlocal(L, ci, n);\n lua_lock(L);\n if (name)\n setobjs2s(L, ci->base + (n - 1), L->top - 1);\n L->top--; /* pop value */\n lua_unlock(L);\n return name;\n}\n\n\nstatic void funcinfo (lua_Debug *ar, Closure *cl) {\n if (cl->c.isC) {\n ar->source = \"=[C]\";\n ar->linedefined = -1;\n ar->lastlinedefined = -1;\n ar->what = \"C\";\n }\n else {\n ar->source = getstr(cl->l.p->source);\n ar->linedefined = cl->l.p->linedefined;\n ar->lastlinedefined = cl->l.p->lastlinedefined;\n ar->what = (ar->linedefined == 0) ? \"main\" : \"Lua\";\n }\n luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);\n}\n\n\nstatic void info_tailcall (lua_Debug *ar) {\n ar->name = ar->namewhat = \"\";\n ar->what = \"tail\";\n ar->lastlinedefined = ar->linedefined = ar->currentline = -1;\n ar->source = \"=(tail call)\";\n luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);\n ar->nups = 0;\n}\n\n\nstatic void collectvalidlines (lua_State *L, Closure *f) {\n if (f == NULL || f->c.isC) {\n setnilvalue(L->top);\n }\n else {\n Table *t = luaH_new(L, 0, 0);\n int *lineinfo = f->l.p->lineinfo;\n int i;\n for (i=0; il.p->sizelineinfo; i++)\n setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);\n sethvalue(L, L->top, t); \n }\n incr_top(L);\n}\n\n\nstatic int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,\n Closure *f, CallInfo *ci) {\n int status = 1;\n if (f == NULL) {\n info_tailcall(ar);\n return status;\n }\n for (; *what; what++) {\n switch (*what) {\n case 'S': {\n funcinfo(ar, f);\n break;\n }\n case 'l': {\n ar->currentline = (ci) ? currentline(L, ci) : -1;\n break;\n }\n case 'u': {\n ar->nups = f->c.nupvalues;\n break;\n }\n case 'n': {\n ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;\n if (ar->namewhat == NULL) {\n ar->namewhat = \"\"; /* not found */\n ar->name = NULL;\n }\n break;\n }\n case 'L':\n case 'f': /* handled by lua_getinfo */\n break;\n default: status = 0; /* invalid option */\n }\n }\n return status;\n}\n\n\nLUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {\n int status;\n Closure *f = NULL;\n CallInfo *ci = NULL;\n lua_lock(L);\n if (*what == '>') {\n StkId func = L->top - 1;\n luai_apicheck(L, ttisfunction(func));\n what++; /* skip the '>' */\n f = clvalue(func);\n L->top--; /* pop function */\n }\n else if (ar->i_ci != 0) { /* no tail call? */\n ci = L->base_ci + ar->i_ci;\n lua_assert(ttisfunction(ci->func));\n f = clvalue(ci->func);\n }\n status = auxgetinfo(L, what, ar, f, ci);\n if (strchr(what, 'f')) {\n if (f == NULL) setnilvalue(L->top);\n else setclvalue(L, L->top, f);\n incr_top(L);\n }\n if (strchr(what, 'L'))\n collectvalidlines(L, f);\n lua_unlock(L);\n return status;\n}\n\n\n/*\n** {======================================================\n** Symbolic Execution and code checker\n** =======================================================\n*/\n\n#define check(x)\t\tif (!(x)) return 0;\n\n#define checkjump(pt,pc)\tcheck(0 <= pc && pc < pt->sizecode)\n\n#define checkreg(pt,reg)\tcheck((reg) < (pt)->maxstacksize)\n\n\n\nstatic int precheck (const Proto *pt) {\n check(pt->maxstacksize <= MAXSTACK);\n check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);\n check(!(pt->is_vararg & VARARG_NEEDSARG) ||\n (pt->is_vararg & VARARG_HASARG));\n check(pt->sizeupvalues <= pt->nups);\n check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);\n check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);\n return 1;\n}\n\n\n#define checkopenop(pt,pc)\tluaG_checkopenop((pt)->code[(pc)+1])\n\nint luaG_checkopenop (Instruction i) {\n switch (GET_OPCODE(i)) {\n case OP_CALL:\n case OP_TAILCALL:\n case OP_RETURN:\n case OP_SETLIST: {\n check(GETARG_B(i) == 0);\n return 1;\n }\n default: return 0; /* invalid instruction after an open call */\n }\n}\n\n\nstatic int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {\n switch (mode) {\n case OpArgN: check(r == 0); break;\n case OpArgU: break;\n case OpArgR: checkreg(pt, r); break;\n case OpArgK:\n check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);\n break;\n }\n return 1;\n}\n\n\nstatic Instruction symbexec (const Proto *pt, int lastpc, int reg) {\n int pc;\n int last; /* stores position of last instruction that changed `reg' */\n last = pt->sizecode-1; /* points to final return (a `neutral' instruction) */\n check(precheck(pt));\n for (pc = 0; pc < lastpc; pc++) {\n Instruction i = pt->code[pc];\n OpCode op = GET_OPCODE(i);\n int a = GETARG_A(i);\n int b = 0;\n int c = 0;\n check(op < NUM_OPCODES);\n checkreg(pt, a);\n switch (getOpMode(op)) {\n case iABC: {\n b = GETARG_B(i);\n c = GETARG_C(i);\n check(checkArgMode(pt, b, getBMode(op)));\n check(checkArgMode(pt, c, getCMode(op)));\n break;\n }\n case iABx: {\n b = GETARG_Bx(i);\n if (getBMode(op) == OpArgK) check(b < pt->sizek);\n break;\n }\n case iAsBx: {\n b = GETARG_sBx(i);\n if (getBMode(op) == OpArgR) {\n int dest = pc+1+b;\n check(0 <= dest && dest < pt->sizecode);\n if (dest > 0) {\n int j;\n /* check that it does not jump to a setlist count; this\n is tricky, because the count from a previous setlist may\n have the same value of an invalid setlist; so, we must\n go all the way back to the first of them (if any) */\n for (j = 0; j < dest; j++) {\n Instruction d = pt->code[dest-1-j];\n if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;\n }\n /* if 'j' is even, previous value is not a setlist (even if\n it looks like one) */\n check((j&1) == 0);\n }\n }\n break;\n }\n }\n if (testAMode(op)) {\n if (a == reg) last = pc; /* change register `a' */\n }\n if (testTMode(op)) {\n check(pc+2 < pt->sizecode); /* check skip */\n check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);\n }\n switch (op) {\n case OP_LOADBOOL: {\n if (c == 1) { /* does it jump? */\n check(pc+2 < pt->sizecode); /* check its jump */\n check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||\n GETARG_C(pt->code[pc+1]) != 0);\n }\n break;\n }\n case OP_LOADNIL: {\n if (a <= reg && reg <= b)\n last = pc; /* set registers from `a' to `b' */\n break;\n }\n case OP_GETUPVAL:\n case OP_SETUPVAL: {\n check(b < pt->nups);\n break;\n }\n case OP_GETGLOBAL:\n case OP_SETGLOBAL: {\n check(ttisstring(&pt->k[b]));\n break;\n }\n case OP_SELF: {\n checkreg(pt, a+1);\n if (reg == a+1) last = pc;\n break;\n }\n case OP_CONCAT: {\n check(b < c); /* at least two operands */\n break;\n }\n case OP_TFORLOOP: {\n check(c >= 1); /* at least one result (control variable) */\n checkreg(pt, a+2+c); /* space for results */\n if (reg >= a+2) last = pc; /* affect all regs above its base */\n break;\n }\n case OP_FORLOOP:\n case OP_FORPREP:\n checkreg(pt, a+3);\n /* go through */\n case OP_JMP: {\n int dest = pc+1+b;\n /* not full check and jump is forward and do not skip `lastpc'? */\n if (reg != NO_REG && pc < dest && dest <= lastpc)\n pc += b; /* do the jump */\n break;\n }\n case OP_CALL:\n case OP_TAILCALL: {\n if (b != 0) {\n checkreg(pt, a+b-1);\n }\n c--; /* c = num. returns */\n if (c == LUA_MULTRET) {\n check(checkopenop(pt, pc));\n }\n else if (c != 0)\n checkreg(pt, a+c-1);\n if (reg >= a) last = pc; /* affect all registers above base */\n break;\n }\n case OP_RETURN: {\n b--; /* b = num. returns */\n if (b > 0) checkreg(pt, a+b-1);\n break;\n }\n case OP_SETLIST: {\n if (b > 0) checkreg(pt, a + b);\n if (c == 0) {\n pc++;\n check(pc < pt->sizecode - 1);\n }\n break;\n }\n case OP_CLOSURE: {\n int nup, j;\n check(b < pt->sizep);\n nup = pt->p[b]->nups;\n check(pc + nup < pt->sizecode);\n for (j = 1; j <= nup; j++) {\n OpCode op1 = GET_OPCODE(pt->code[pc + j]);\n check(op1 == OP_GETUPVAL || op1 == OP_MOVE);\n }\n if (reg != NO_REG) /* tracing? */\n pc += nup; /* do not 'execute' these pseudo-instructions */\n break;\n }\n case OP_VARARG: {\n check((pt->is_vararg & VARARG_ISVARARG) &&\n !(pt->is_vararg & VARARG_NEEDSARG));\n b--;\n if (b == LUA_MULTRET) check(checkopenop(pt, pc));\n checkreg(pt, a+b-1);\n break;\n }\n default: break;\n }\n }\n return pt->code[last];\n}\n\n#undef check\n#undef checkjump\n#undef checkreg\n\n/* }====================================================== */\n\n\nint luaG_checkcode (const Proto *pt) {\n return (symbexec(pt, pt->sizecode, NO_REG) != 0);\n}\n\n\nstatic const char *kname (Proto *p, int c) {\n if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))\n return svalue(&p->k[INDEXK(c)]);\n else\n return \"?\";\n}\n\n\nstatic const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,\n const char **name) {\n if (isLua(ci)) { /* a Lua function? */\n Proto *p = ci_func(ci)->l.p;\n int pc = currentpc(L, ci);\n Instruction i;\n *name = luaF_getlocalname(p, stackpos+1, pc);\n if (*name) /* is a local? */\n return \"local\";\n i = symbexec(p, pc, stackpos); /* try symbolic execution */\n lua_assert(pc != -1);\n switch (GET_OPCODE(i)) {\n case OP_GETGLOBAL: {\n int g = GETARG_Bx(i); /* global index */\n lua_assert(ttisstring(&p->k[g]));\n *name = svalue(&p->k[g]);\n return \"global\";\n }\n case OP_MOVE: {\n int a = GETARG_A(i);\n int b = GETARG_B(i); /* move from `b' to `a' */\n if (b < a)\n return getobjname(L, ci, b, name); /* get name for `b' */\n break;\n }\n case OP_GETTABLE: {\n int k = GETARG_C(i); /* key index */\n *name = kname(p, k);\n return \"field\";\n }\n case OP_GETUPVAL: {\n int u = GETARG_B(i); /* upvalue index */\n *name = p->upvalues ? getstr(p->upvalues[u]) : \"?\";\n return \"upvalue\";\n }\n case OP_SELF: {\n int k = GETARG_C(i); /* key index */\n *name = kname(p, k);\n return \"method\";\n }\n default: break;\n }\n }\n return NULL; /* no useful name found */\n}\n\n\nstatic const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {\n Instruction i;\n if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))\n return NULL; /* calling function is not Lua (or is unknown) */\n ci--; /* calling function */\n i = ci_func(ci)->l.p->code[currentpc(L, ci)];\n if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||\n GET_OPCODE(i) == OP_TFORLOOP)\n return getobjname(L, ci, GETARG_A(i), name);\n else\n return NULL; /* no useful name can be found */\n}\n\n\n/* only ANSI way to check whether a pointer points to an array */\nstatic int isinstack (CallInfo *ci, const TValue *o) {\n StkId p;\n for (p = ci->base; p < ci->top; p++)\n if (o == p) return 1;\n return 0;\n}\n\n\nvoid luaG_typeerror (lua_State *L, const TValue *o, const char *op) {\n const char *name = NULL;\n const char *t = luaT_typenames[ttype(o)];\n const char *kind = (isinstack(L->ci, o)) ?\n getobjname(L, L->ci, cast_int(o - L->base), &name) :\n NULL;\n if (kind)\n luaG_runerror(L, \"attempt to %s %s \" LUA_QS \" (a %s value)\",\n op, kind, name, t);\n else\n luaG_runerror(L, \"attempt to %s a %s value\", op, t);\n}\n\n\nvoid luaG_concaterror (lua_State *L, StkId p1, StkId p2) {\n if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;\n lua_assert(!ttisstring(p1) && !ttisnumber(p1));\n luaG_typeerror(L, p1, \"concatenate\");\n}\n\n\nvoid luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {\n TValue temp;\n if (luaV_tonumber(p1, &temp) == NULL)\n p2 = p1; /* first operand is wrong */\n luaG_typeerror(L, p2, \"perform arithmetic on\");\n}\n\n\nint luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {\n const char *t1 = luaT_typenames[ttype(p1)];\n const char *t2 = luaT_typenames[ttype(p2)];\n if (t1[2] == t2[2])\n luaG_runerror(L, \"attempt to compare two %s values\", t1);\n else\n luaG_runerror(L, \"attempt to compare %s with %s\", t1, t2);\n return 0;\n}\n\n\nstatic void addinfo (lua_State *L, const char *msg) {\n CallInfo *ci = L->ci;\n if (isLua(ci)) { /* is Lua code? */\n char buff[LUA_IDSIZE]; /* add file:line information */\n int line = currentline(L, ci);\n luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);\n luaO_pushfstring(L, \"%s:%d: %s\", buff, line, msg);\n }\n}\n\n\nvoid luaG_errormsg (lua_State *L) {\n if (L->errfunc != 0) { /* is there an error handling function? */\n StkId errfunc = restorestack(L, L->errfunc);\n if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);\n setobjs2s(L, L->top, L->top - 1); /* move argument */\n setobjs2s(L, L->top - 1, errfunc); /* push function */\n incr_top(L);\n luaD_call(L, L->top - 2, 1); /* call it */\n }\n luaD_throw(L, LUA_ERRRUN);\n}\n\n\nvoid luaG_runerror (lua_State *L, const char *fmt, ...) {\n va_list argp;\n va_start(argp, fmt);\n addinfo(L, luaO_pushvfstring(L, fmt, argp));\n va_end(argp);\n luaG_errormsg(L);\n}\n\n" }, { "path": "deps/lua/src/ldebug.h", "content": "/*\n** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $\n** Auxiliary functions from Debug Interface module\n** See Copyright Notice in lua.h\n*/\n\n#ifndef ldebug_h\n#define ldebug_h\n\n\n#include \"lstate.h\"\n\n\n#define pcRel(pc, p)\t(cast(int, (pc) - (p)->code) - 1)\n\n#define getline(f,pc)\t(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)\n\n#define resethookcount(L)\t(L->hookcount = L->basehookcount)\n\n\nLUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,\n const char *opname);\nLUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);\nLUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,\n const TValue *p2);\nLUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,\n const TValue *p2);\nLUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);\nLUAI_FUNC void luaG_errormsg (lua_State *L);\nLUAI_FUNC int luaG_checkcode (const Proto *pt);\nLUAI_FUNC int luaG_checkopenop (Instruction i);\n\n#endif\n" }, { "path": "deps/lua/src/ldo.c", "content": "/*\n** $Id: ldo.c,v 2.38.1.4 2012/01/18 02:27:10 roberto Exp $\n** Stack and Call structure of Lua\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n\n#define ldo_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lparser.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n#include \"lundump.h\"\n#include \"lvm.h\"\n#include \"lzio.h\"\n\n\n\n\n/*\n** {======================================================\n** Error-recovery functions\n** =======================================================\n*/\n\n\n/* chain list of long jump buffers */\nstruct lua_longjmp {\n struct lua_longjmp *previous;\n luai_jmpbuf b;\n volatile int status; /* error code */\n};\n\n\nvoid luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {\n switch (errcode) {\n case LUA_ERRMEM: {\n setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));\n break;\n }\n case LUA_ERRERR: {\n setsvalue2s(L, oldtop, luaS_newliteral(L, \"error in error handling\"));\n break;\n }\n case LUA_ERRSYNTAX:\n case LUA_ERRRUN: {\n setobjs2s(L, oldtop, L->top - 1); /* error message on current top */\n break;\n }\n }\n L->top = oldtop + 1;\n}\n\n\nstatic void restore_stack_limit (lua_State *L) {\n lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);\n if (L->size_ci > LUAI_MAXCALLS) { /* there was an overflow? */\n int inuse = cast_int(L->ci - L->base_ci);\n if (inuse + 1 < LUAI_MAXCALLS) /* can `undo' overflow? */\n luaD_reallocCI(L, LUAI_MAXCALLS);\n }\n}\n\n\nstatic void resetstack (lua_State *L, int status) {\n L->ci = L->base_ci;\n L->base = L->ci->base;\n luaF_close(L, L->base); /* close eventual pending closures */\n luaD_seterrorobj(L, status, L->base);\n L->nCcalls = L->baseCcalls;\n L->allowhook = 1;\n restore_stack_limit(L);\n L->errfunc = 0;\n L->errorJmp = NULL;\n}\n\n\nvoid luaD_throw (lua_State *L, int errcode) {\n if (L->errorJmp) {\n L->errorJmp->status = errcode;\n LUAI_THROW(L, L->errorJmp);\n }\n else {\n L->status = cast_byte(errcode);\n if (G(L)->panic) {\n resetstack(L, errcode);\n lua_unlock(L);\n G(L)->panic(L);\n }\n exit(EXIT_FAILURE);\n }\n}\n\n\nint luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {\n struct lua_longjmp lj;\n lj.status = 0;\n lj.previous = L->errorJmp; /* chain new error handler */\n L->errorJmp = &lj;\n LUAI_TRY(L, &lj,\n (*f)(L, ud);\n );\n L->errorJmp = lj.previous; /* restore old error handler */\n return lj.status;\n}\n\n/* }====================================================== */\n\n\nstatic void correctstack (lua_State *L, TValue *oldstack) {\n CallInfo *ci;\n GCObject *up;\n L->top = (L->top - oldstack) + L->stack;\n for (up = L->openupval; up != NULL; up = up->gch.next)\n gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;\n for (ci = L->base_ci; ci <= L->ci; ci++) {\n ci->top = (ci->top - oldstack) + L->stack;\n ci->base = (ci->base - oldstack) + L->stack;\n ci->func = (ci->func - oldstack) + L->stack;\n }\n L->base = (L->base - oldstack) + L->stack;\n}\n\n\nvoid luaD_reallocstack (lua_State *L, int newsize) {\n TValue *oldstack = L->stack;\n int realsize = newsize + 1 + EXTRA_STACK;\n lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);\n luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);\n L->stacksize = realsize;\n L->stack_last = L->stack+newsize;\n correctstack(L, oldstack);\n}\n\n\nvoid luaD_reallocCI (lua_State *L, int newsize) {\n CallInfo *oldci = L->base_ci;\n luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);\n L->size_ci = newsize;\n L->ci = (L->ci - oldci) + L->base_ci;\n L->end_ci = L->base_ci + L->size_ci - 1;\n}\n\n\nvoid luaD_growstack (lua_State *L, int n) {\n if (n <= L->stacksize) /* double size is enough? */\n luaD_reallocstack(L, 2*L->stacksize);\n else\n luaD_reallocstack(L, L->stacksize + n);\n}\n\n\nstatic CallInfo *growCI (lua_State *L) {\n if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */\n luaD_throw(L, LUA_ERRERR);\n else {\n luaD_reallocCI(L, 2*L->size_ci);\n if (L->size_ci > LUAI_MAXCALLS)\n luaG_runerror(L, \"stack overflow\");\n }\n return ++L->ci;\n}\n\n\nvoid luaD_callhook (lua_State *L, int event, int line) {\n lua_Hook hook = L->hook;\n if (hook && L->allowhook) {\n ptrdiff_t top = savestack(L, L->top);\n ptrdiff_t ci_top = savestack(L, L->ci->top);\n lua_Debug ar;\n ar.event = event;\n ar.currentline = line;\n if (event == LUA_HOOKTAILRET)\n ar.i_ci = 0; /* tail call; no debug information about it */\n else\n ar.i_ci = cast_int(L->ci - L->base_ci);\n luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */\n L->ci->top = L->top + LUA_MINSTACK;\n lua_assert(L->ci->top <= L->stack_last);\n L->allowhook = 0; /* cannot call hooks inside a hook */\n lua_unlock(L);\n (*hook)(L, &ar);\n lua_lock(L);\n lua_assert(!L->allowhook);\n L->allowhook = 1;\n L->ci->top = restorestack(L, ci_top);\n L->top = restorestack(L, top);\n }\n}\n\n\nstatic StkId adjust_varargs (lua_State *L, Proto *p, int actual) {\n int i;\n int nfixargs = p->numparams;\n Table *htab = NULL;\n StkId base, fixed;\n for (; actual < nfixargs; ++actual)\n setnilvalue(L->top++);\n#if defined(LUA_COMPAT_VARARG)\n if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */\n int nvar = actual - nfixargs; /* number of extra arguments */\n lua_assert(p->is_vararg & VARARG_HASARG);\n luaC_checkGC(L);\n luaD_checkstack(L, p->maxstacksize);\n htab = luaH_new(L, nvar, 1); /* create `arg' table */\n for (i=0; itop - nvar + i);\n /* store counter in field `n' */\n setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, \"n\")), cast_num(nvar));\n }\n#endif\n /* move fixed parameters to final position */\n fixed = L->top - actual; /* first fixed argument */\n base = L->top; /* final position of first argument */\n for (i=0; itop++, fixed+i);\n setnilvalue(fixed+i);\n }\n /* add `arg' parameter */\n if (htab) {\n sethvalue(L, L->top++, htab);\n lua_assert(iswhite(obj2gco(htab)));\n }\n return base;\n}\n\n\nstatic StkId tryfuncTM (lua_State *L, StkId func) {\n const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);\n StkId p;\n ptrdiff_t funcr = savestack(L, func);\n if (!ttisfunction(tm))\n luaG_typeerror(L, func, \"call\");\n /* Open a hole inside the stack at `func' */\n for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);\n incr_top(L);\n func = restorestack(L, funcr); /* previous call may change stack */\n setobj2s(L, func, tm); /* tag method is the new function to be called */\n return func;\n}\n\n\n\n#define inc_ci(L) \\\n ((L->ci == L->end_ci) ? growCI(L) : \\\n (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))\n\n\nint luaD_precall (lua_State *L, StkId func, int nresults) {\n LClosure *cl;\n ptrdiff_t funcr;\n if (!ttisfunction(func)) /* `func' is not a function? */\n func = tryfuncTM(L, func); /* check the `function' tag method */\n funcr = savestack(L, func);\n cl = &clvalue(func)->l;\n L->ci->savedpc = L->savedpc;\n if (!cl->isC) { /* Lua function? prepare its call */\n CallInfo *ci;\n StkId st, base;\n Proto *p = cl->p;\n luaD_checkstack(L, p->maxstacksize + p->numparams);\n func = restorestack(L, funcr);\n if (!p->is_vararg) { /* no varargs? */\n base = func + 1;\n if (L->top > base + p->numparams)\n L->top = base + p->numparams;\n }\n else { /* vararg function */\n int nargs = cast_int(L->top - func) - 1;\n base = adjust_varargs(L, p, nargs);\n func = restorestack(L, funcr); /* previous call may change the stack */\n }\n ci = inc_ci(L); /* now `enter' new function */\n ci->func = func;\n L->base = ci->base = base;\n ci->top = L->base + p->maxstacksize;\n lua_assert(ci->top <= L->stack_last);\n L->savedpc = p->code; /* starting point */\n ci->tailcalls = 0;\n ci->nresults = nresults;\n for (st = L->top; st < ci->top; st++)\n setnilvalue(st);\n L->top = ci->top;\n if (L->hookmask & LUA_MASKCALL) {\n L->savedpc++; /* hooks assume 'pc' is already incremented */\n luaD_callhook(L, LUA_HOOKCALL, -1);\n L->savedpc--; /* correct 'pc' */\n }\n return PCRLUA;\n }\n else { /* if is a C function, call it */\n CallInfo *ci;\n int n;\n luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */\n ci = inc_ci(L); /* now `enter' new function */\n ci->func = restorestack(L, funcr);\n L->base = ci->base = ci->func + 1;\n ci->top = L->top + LUA_MINSTACK;\n lua_assert(ci->top <= L->stack_last);\n ci->nresults = nresults;\n if (L->hookmask & LUA_MASKCALL)\n luaD_callhook(L, LUA_HOOKCALL, -1);\n lua_unlock(L);\n n = (*curr_func(L)->c.f)(L); /* do the actual call */\n lua_lock(L);\n if (n < 0) /* yielding? */\n return PCRYIELD;\n else {\n luaD_poscall(L, L->top - n);\n return PCRC;\n }\n }\n}\n\n\nstatic StkId callrethooks (lua_State *L, StkId firstResult) {\n ptrdiff_t fr = savestack(L, firstResult); /* next call may change stack */\n luaD_callhook(L, LUA_HOOKRET, -1);\n if (f_isLua(L->ci)) { /* Lua function? */\n while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */\n luaD_callhook(L, LUA_HOOKTAILRET, -1);\n }\n return restorestack(L, fr);\n}\n\n\nint luaD_poscall (lua_State *L, StkId firstResult) {\n StkId res;\n int wanted, i;\n CallInfo *ci;\n if (L->hookmask & LUA_MASKRET)\n firstResult = callrethooks(L, firstResult);\n ci = L->ci--;\n res = ci->func; /* res == final position of 1st result */\n wanted = ci->nresults;\n L->base = (ci - 1)->base; /* restore base */\n L->savedpc = (ci - 1)->savedpc; /* restore savedpc */\n /* move results to correct place */\n for (i = wanted; i != 0 && firstResult < L->top; i--)\n setobjs2s(L, res++, firstResult++);\n while (i-- > 0)\n setnilvalue(res++);\n L->top = res;\n return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */\n}\n\n\n/*\n** Call a function (C or Lua). The function to be called is at *func.\n** The arguments are on the stack, right after the function.\n** When returns, all the results are on the stack, starting at the original\n** function position.\n*/ \nvoid luaD_call (lua_State *L, StkId func, int nResults) {\n if (++L->nCcalls >= LUAI_MAXCCALLS) {\n if (L->nCcalls == LUAI_MAXCCALLS)\n luaG_runerror(L, \"C stack overflow\");\n else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))\n luaD_throw(L, LUA_ERRERR); /* error while handing stack error */\n }\n if (luaD_precall(L, func, nResults) == PCRLUA) /* is a Lua function? */\n luaV_execute(L, 1); /* call it */\n L->nCcalls--;\n luaC_checkGC(L);\n}\n\n\nstatic void resume (lua_State *L, void *ud) {\n StkId firstArg = cast(StkId, ud);\n CallInfo *ci = L->ci;\n if (L->status == 0) { /* start coroutine? */\n lua_assert(ci == L->base_ci && firstArg > L->base);\n if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)\n return;\n }\n else { /* resuming from previous yield */\n lua_assert(L->status == LUA_YIELD);\n L->status = 0;\n if (!f_isLua(ci)) { /* `common' yield? */\n /* finish interrupted execution of `OP_CALL' */\n lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||\n GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);\n if (luaD_poscall(L, firstArg)) /* complete it... */\n L->top = L->ci->top; /* and correct top if not multiple results */\n }\n else /* yielded inside a hook: just continue its execution */\n L->base = L->ci->base;\n }\n luaV_execute(L, cast_int(L->ci - L->base_ci));\n}\n\n\nstatic int resume_error (lua_State *L, const char *msg) {\n L->top = L->ci->base;\n setsvalue2s(L, L->top, luaS_new(L, msg));\n incr_top(L);\n lua_unlock(L);\n return LUA_ERRRUN;\n}\n\n\nLUA_API int lua_resume (lua_State *L, int nargs) {\n int status;\n lua_lock(L);\n if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))\n return resume_error(L, \"cannot resume non-suspended coroutine\");\n if (L->nCcalls >= LUAI_MAXCCALLS)\n return resume_error(L, \"C stack overflow\");\n luai_userstateresume(L, nargs);\n lua_assert(L->errfunc == 0);\n L->baseCcalls = ++L->nCcalls;\n status = luaD_rawrunprotected(L, resume, L->top - nargs);\n if (status != 0) { /* error? */\n L->status = cast_byte(status); /* mark thread as `dead' */\n luaD_seterrorobj(L, status, L->top);\n L->ci->top = L->top;\n }\n else {\n lua_assert(L->nCcalls == L->baseCcalls);\n status = L->status;\n }\n --L->nCcalls;\n lua_unlock(L);\n return status;\n}\n\n\nLUA_API int lua_yield (lua_State *L, int nresults) {\n luai_userstateyield(L, nresults);\n lua_lock(L);\n if (L->nCcalls > L->baseCcalls)\n luaG_runerror(L, \"attempt to yield across metamethod/C-call boundary\");\n L->base = L->top - nresults; /* protect stack slots below */\n L->status = LUA_YIELD;\n lua_unlock(L);\n return -1;\n}\n\n\nint luaD_pcall (lua_State *L, Pfunc func, void *u,\n ptrdiff_t old_top, ptrdiff_t ef) {\n int status;\n unsigned short oldnCcalls = L->nCcalls;\n ptrdiff_t old_ci = saveci(L, L->ci);\n lu_byte old_allowhooks = L->allowhook;\n ptrdiff_t old_errfunc = L->errfunc;\n L->errfunc = ef;\n status = luaD_rawrunprotected(L, func, u);\n if (status != 0) { /* an error occurred? */\n StkId oldtop = restorestack(L, old_top);\n luaF_close(L, oldtop); /* close eventual pending closures */\n luaD_seterrorobj(L, status, oldtop);\n L->nCcalls = oldnCcalls;\n L->ci = restoreci(L, old_ci);\n L->base = L->ci->base;\n L->savedpc = L->ci->savedpc;\n L->allowhook = old_allowhooks;\n restore_stack_limit(L);\n }\n L->errfunc = old_errfunc;\n return status;\n}\n\n\n\n/*\n** Execute a protected parser.\n*/\nstruct SParser { /* data to `f_parser' */\n ZIO *z;\n Mbuffer buff; /* buffer to be used by the scanner */\n const char *name;\n};\n\nstatic void f_parser (lua_State *L, void *ud) {\n int i;\n Proto *tf;\n Closure *cl;\n struct SParser *p = cast(struct SParser *, ud);\n luaZ_lookahead(p->z);\n luaC_checkGC(L);\n tf = (luaY_parser)(L, p->z,\n &p->buff, p->name);\n cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));\n cl->l.p = tf;\n for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */\n cl->l.upvals[i] = luaF_newupval(L);\n setclvalue(L, L->top, cl);\n incr_top(L);\n}\n\n\nint luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {\n struct SParser p;\n int status;\n p.z = z; p.name = name;\n luaZ_initbuffer(L, &p.buff);\n status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);\n luaZ_freebuffer(L, &p.buff);\n return status;\n}\n\n\n" }, { "path": "deps/lua/src/ldo.h", "content": "/*\n** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $\n** Stack and Call structure of Lua\n** See Copyright Notice in lua.h\n*/\n\n#ifndef ldo_h\n#define ldo_h\n\n\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lzio.h\"\n\n\n#define luaD_checkstack(L,n)\t\\\n if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \\\n luaD_growstack(L, n); \\\n else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));\n\n\n#define incr_top(L) {luaD_checkstack(L,1); L->top++;}\n\n#define savestack(L,p)\t\t((char *)(p) - (char *)L->stack)\n#define restorestack(L,n)\t((TValue *)((char *)L->stack + (n)))\n\n#define saveci(L,p)\t\t((char *)(p) - (char *)L->base_ci)\n#define restoreci(L,n)\t\t((CallInfo *)((char *)L->base_ci + (n)))\n\n\n/* results from luaD_precall */\n#define PCRLUA\t\t0\t/* initiated a call to a Lua function */\n#define PCRC\t\t1\t/* did a call to a C function */\n#define PCRYIELD\t2\t/* C funtion yielded */\n\n\n/* type of protected functions, to be ran by `runprotected' */\ntypedef void (*Pfunc) (lua_State *L, void *ud);\n\nLUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);\nLUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);\nLUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);\nLUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);\nLUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,\n ptrdiff_t oldtop, ptrdiff_t ef);\nLUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);\nLUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);\nLUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);\nLUAI_FUNC void luaD_growstack (lua_State *L, int n);\n\nLUAI_FUNC void luaD_throw (lua_State *L, int errcode);\nLUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);\n\nLUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);\n\n#endif\n\n" }, { "path": "deps/lua/src/ldump.c", "content": "/*\n** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $\n** save precompiled Lua chunks\n** See Copyright Notice in lua.h\n*/\n\n#include \n\n#define ldump_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lundump.h\"\n\ntypedef struct {\n lua_State* L;\n lua_Writer writer;\n void* data;\n int strip;\n int status;\n} DumpState;\n\n#define DumpMem(b,n,size,D)\tDumpBlock(b,(n)*(size),D)\n#define DumpVar(x,D)\t \tDumpMem(&x,1,sizeof(x),D)\n\nstatic void DumpBlock(const void* b, size_t size, DumpState* D)\n{\n if (D->status==0)\n {\n lua_unlock(D->L);\n D->status=(*D->writer)(D->L,b,size,D->data);\n lua_lock(D->L);\n }\n}\n\nstatic void DumpChar(int y, DumpState* D)\n{\n char x=(char)y;\n DumpVar(x,D);\n}\n\nstatic void DumpInt(int x, DumpState* D)\n{\n DumpVar(x,D);\n}\n\nstatic void DumpNumber(lua_Number x, DumpState* D)\n{\n DumpVar(x,D);\n}\n\nstatic void DumpVector(const void* b, int n, size_t size, DumpState* D)\n{\n DumpInt(n,D);\n DumpMem(b,n,size,D);\n}\n\nstatic void DumpString(const TString* s, DumpState* D)\n{\n if (s==NULL)\n {\n size_t size=0;\n DumpVar(size,D);\n }\n else\n {\n size_t size=s->tsv.len+1;\t\t/* include trailing '\\0' */\n DumpVar(size,D);\n DumpBlock(getstr(s),size,D);\n }\n}\n\n#define DumpCode(f,D)\t DumpVector(f->code,f->sizecode,sizeof(Instruction),D)\n\nstatic void DumpFunction(const Proto* f, const TString* p, DumpState* D);\n\nstatic void DumpConstants(const Proto* f, DumpState* D)\n{\n int i,n=f->sizek;\n DumpInt(n,D);\n for (i=0; ik[i];\n DumpChar(ttype(o),D);\n switch (ttype(o))\n {\n case LUA_TNIL:\n\tbreak;\n case LUA_TBOOLEAN:\n\tDumpChar(bvalue(o),D);\n\tbreak;\n case LUA_TNUMBER:\n\tDumpNumber(nvalue(o),D);\n\tbreak;\n case LUA_TSTRING:\n\tDumpString(rawtsvalue(o),D);\n\tbreak;\n default:\n\tlua_assert(0);\t\t\t/* cannot happen */\n\tbreak;\n }\n }\n n=f->sizep;\n DumpInt(n,D);\n for (i=0; ip[i],f->source,D);\n}\n\nstatic void DumpDebug(const Proto* f, DumpState* D)\n{\n int i,n;\n n= (D->strip) ? 0 : f->sizelineinfo;\n DumpVector(f->lineinfo,n,sizeof(int),D);\n n= (D->strip) ? 0 : f->sizelocvars;\n DumpInt(n,D);\n for (i=0; ilocvars[i].varname,D);\n DumpInt(f->locvars[i].startpc,D);\n DumpInt(f->locvars[i].endpc,D);\n }\n n= (D->strip) ? 0 : f->sizeupvalues;\n DumpInt(n,D);\n for (i=0; iupvalues[i],D);\n}\n\nstatic void DumpFunction(const Proto* f, const TString* p, DumpState* D)\n{\n DumpString((f->source==p || D->strip) ? NULL : f->source,D);\n DumpInt(f->linedefined,D);\n DumpInt(f->lastlinedefined,D);\n DumpChar(f->nups,D);\n DumpChar(f->numparams,D);\n DumpChar(f->is_vararg,D);\n DumpChar(f->maxstacksize,D);\n DumpCode(f,D);\n DumpConstants(f,D);\n DumpDebug(f,D);\n}\n\nstatic void DumpHeader(DumpState* D)\n{\n char h[LUAC_HEADERSIZE];\n luaU_header(h);\n DumpBlock(h,LUAC_HEADERSIZE,D);\n}\n\n/*\n** dump Lua function as precompiled chunk\n*/\nint luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)\n{\n DumpState D;\n D.L=L;\n D.writer=w;\n D.data=data;\n D.strip=strip;\n D.status=0;\n DumpHeader(&D);\n DumpFunction(f,NULL,&D);\n return D.status;\n}\n" }, { "path": "deps/lua/src/lfunc.c", "content": "/*\n** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $\n** Auxiliary functions to manipulate prototypes and closures\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lfunc_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n\n\n\nClosure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {\n Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));\n luaC_link(L, obj2gco(c), LUA_TFUNCTION);\n c->c.isC = 1;\n c->c.env = e;\n c->c.nupvalues = cast_byte(nelems);\n return c;\n}\n\n\nClosure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {\n Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));\n luaC_link(L, obj2gco(c), LUA_TFUNCTION);\n c->l.isC = 0;\n c->l.env = e;\n c->l.nupvalues = cast_byte(nelems);\n while (nelems--) c->l.upvals[nelems] = NULL;\n return c;\n}\n\n\nUpVal *luaF_newupval (lua_State *L) {\n UpVal *uv = luaM_new(L, UpVal);\n luaC_link(L, obj2gco(uv), LUA_TUPVAL);\n uv->v = &uv->u.value;\n setnilvalue(uv->v);\n return uv;\n}\n\n\nUpVal *luaF_findupval (lua_State *L, StkId level) {\n global_State *g = G(L);\n GCObject **pp = &L->openupval;\n UpVal *p;\n UpVal *uv;\n while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {\n lua_assert(p->v != &p->u.value);\n if (p->v == level) { /* found a corresponding upvalue? */\n if (isdead(g, obj2gco(p))) /* is it dead? */\n changewhite(obj2gco(p)); /* ressurect it */\n return p;\n }\n pp = &p->next;\n }\n uv = luaM_new(L, UpVal); /* not found: create a new one */\n uv->tt = LUA_TUPVAL;\n uv->marked = luaC_white(g);\n uv->v = level; /* current value lives in the stack */\n uv->next = *pp; /* chain it in the proper position */\n *pp = obj2gco(uv);\n uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */\n uv->u.l.next = g->uvhead.u.l.next;\n uv->u.l.next->u.l.prev = uv;\n g->uvhead.u.l.next = uv;\n lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);\n return uv;\n}\n\n\nstatic void unlinkupval (UpVal *uv) {\n lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);\n uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */\n uv->u.l.prev->u.l.next = uv->u.l.next;\n}\n\n\nvoid luaF_freeupval (lua_State *L, UpVal *uv) {\n if (uv->v != &uv->u.value) /* is it open? */\n unlinkupval(uv); /* remove from open list */\n luaM_free(L, uv); /* free upvalue */\n}\n\n\nvoid luaF_close (lua_State *L, StkId level) {\n UpVal *uv;\n global_State *g = G(L);\n while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {\n GCObject *o = obj2gco(uv);\n lua_assert(!isblack(o) && uv->v != &uv->u.value);\n L->openupval = uv->next; /* remove from `open' list */\n if (isdead(g, o))\n luaF_freeupval(L, uv); /* free upvalue */\n else {\n unlinkupval(uv);\n setobj(L, &uv->u.value, uv->v);\n uv->v = &uv->u.value; /* now current value lives here */\n luaC_linkupval(L, uv); /* link upvalue into `gcroot' list */\n }\n }\n}\n\n\nProto *luaF_newproto (lua_State *L) {\n Proto *f = luaM_new(L, Proto);\n luaC_link(L, obj2gco(f), LUA_TPROTO);\n f->k = NULL;\n f->sizek = 0;\n f->p = NULL;\n f->sizep = 0;\n f->code = NULL;\n f->sizecode = 0;\n f->sizelineinfo = 0;\n f->sizeupvalues = 0;\n f->nups = 0;\n f->upvalues = NULL;\n f->numparams = 0;\n f->is_vararg = 0;\n f->maxstacksize = 0;\n f->lineinfo = NULL;\n f->sizelocvars = 0;\n f->locvars = NULL;\n f->linedefined = 0;\n f->lastlinedefined = 0;\n f->source = NULL;\n return f;\n}\n\n\nvoid luaF_freeproto (lua_State *L, Proto *f) {\n luaM_freearray(L, f->code, f->sizecode, Instruction);\n luaM_freearray(L, f->p, f->sizep, Proto *);\n luaM_freearray(L, f->k, f->sizek, TValue);\n luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);\n luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);\n luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);\n luaM_free(L, f);\n}\n\n\nvoid luaF_freeclosure (lua_State *L, Closure *c) {\n int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :\n sizeLclosure(c->l.nupvalues);\n luaM_freemem(L, c, size);\n}\n\n\n/*\n** Look for n-th local variable at line `line' in function `func'.\n** Returns NULL if not found.\n*/\nconst char *luaF_getlocalname (const Proto *f, int local_number, int pc) {\n int i;\n for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) {\n if (pc < f->locvars[i].endpc) { /* is variable active? */\n local_number--;\n if (local_number == 0)\n return getstr(f->locvars[i].varname);\n }\n }\n return NULL; /* not found */\n}\n\n" }, { "path": "deps/lua/src/lfunc.h", "content": "/*\n** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $\n** Auxiliary functions to manipulate prototypes and closures\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lfunc_h\n#define lfunc_h\n\n\n#include \"lobject.h\"\n\n\n#define sizeCclosure(n)\t(cast(int, sizeof(CClosure)) + \\\n cast(int, sizeof(TValue)*((n)-1)))\n\n#define sizeLclosure(n)\t(cast(int, sizeof(LClosure)) + \\\n cast(int, sizeof(TValue *)*((n)-1)))\n\n\nLUAI_FUNC Proto *luaF_newproto (lua_State *L);\nLUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);\nLUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);\nLUAI_FUNC UpVal *luaF_newupval (lua_State *L);\nLUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);\nLUAI_FUNC void luaF_close (lua_State *L, StkId level);\nLUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);\nLUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);\nLUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);\nLUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,\n int pc);\n\n\n#endif\n" }, { "path": "deps/lua/src/lgc.c", "content": "/*\n** $Id: lgc.c,v 2.38.1.2 2011/03/18 18:05:38 roberto Exp $\n** Garbage Collector\n** See Copyright Notice in lua.h\n*/\n\n#include \n\n#define lgc_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n\n\n#define GCSTEPSIZE\t1024u\n#define GCSWEEPMAX\t40\n#define GCSWEEPCOST\t10\n#define GCFINALIZECOST\t100\n\n\n#define maskmarks\tcast_byte(~(bitmask(BLACKBIT)|WHITEBITS))\n\n#define makewhite(g,x)\t\\\n ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))\n\n#define white2gray(x)\treset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)\n#define black2gray(x)\tresetbit((x)->gch.marked, BLACKBIT)\n\n#define stringmark(s)\treset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)\n\n\n#define isfinalized(u)\t\ttestbit((u)->marked, FINALIZEDBIT)\n#define markfinalized(u)\tl_setbit((u)->marked, FINALIZEDBIT)\n\n\n#define KEYWEAK bitmask(KEYWEAKBIT)\n#define VALUEWEAK bitmask(VALUEWEAKBIT)\n\n\n\n#define markvalue(g,o) { checkconsistency(o); \\\n if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }\n\n#define markobject(g,t) { if (iswhite(obj2gco(t))) \\\n\t\treallymarkobject(g, obj2gco(t)); }\n\n\n#define setthreshold(g) (g->GCthreshold = (g->estimate/100) * g->gcpause)\n\n\nstatic void removeentry (Node *n) {\n lua_assert(ttisnil(gval(n)));\n if (iscollectable(gkey(n)))\n setttype(gkey(n), LUA_TDEADKEY); /* dead key; remove it */\n}\n\n\nstatic void reallymarkobject (global_State *g, GCObject *o) {\n lua_assert(iswhite(o) && !isdead(g, o));\n white2gray(o);\n switch (o->gch.tt) {\n case LUA_TSTRING: {\n return;\n }\n case LUA_TUSERDATA: {\n Table *mt = gco2u(o)->metatable;\n gray2black(o); /* udata are never gray */\n if (mt) markobject(g, mt);\n markobject(g, gco2u(o)->env);\n return;\n }\n case LUA_TUPVAL: {\n UpVal *uv = gco2uv(o);\n markvalue(g, uv->v);\n if (uv->v == &uv->u.value) /* closed? */\n gray2black(o); /* open upvalues are never black */\n return;\n }\n case LUA_TFUNCTION: {\n gco2cl(o)->c.gclist = g->gray;\n g->gray = o;\n break;\n }\n case LUA_TTABLE: {\n gco2h(o)->gclist = g->gray;\n g->gray = o;\n break;\n }\n case LUA_TTHREAD: {\n gco2th(o)->gclist = g->gray;\n g->gray = o;\n break;\n }\n case LUA_TPROTO: {\n gco2p(o)->gclist = g->gray;\n g->gray = o;\n break;\n }\n default: lua_assert(0);\n }\n}\n\n\nstatic void marktmu (global_State *g) {\n GCObject *u = g->tmudata;\n if (u) {\n do {\n u = u->gch.next;\n makewhite(g, u); /* may be marked, if left from previous GC */\n reallymarkobject(g, u);\n } while (u != g->tmudata);\n }\n}\n\n\n/* move `dead' udata that need finalization to list `tmudata' */\nsize_t luaC_separateudata (lua_State *L, int all) {\n global_State *g = G(L);\n size_t deadmem = 0;\n GCObject **p = &g->mainthread->next;\n GCObject *curr;\n while ((curr = *p) != NULL) {\n if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))\n p = &curr->gch.next; /* don't bother with them */\n else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {\n markfinalized(gco2u(curr)); /* don't need finalization */\n p = &curr->gch.next;\n }\n else { /* must call its gc method */\n deadmem += sizeudata(gco2u(curr));\n markfinalized(gco2u(curr));\n *p = curr->gch.next;\n /* link `curr' at the end of `tmudata' list */\n if (g->tmudata == NULL) /* list is empty? */\n g->tmudata = curr->gch.next = curr; /* creates a circular list */\n else {\n curr->gch.next = g->tmudata->gch.next;\n g->tmudata->gch.next = curr;\n g->tmudata = curr;\n }\n }\n }\n return deadmem;\n}\n\n\nstatic int traversetable (global_State *g, Table *h) {\n int i;\n int weakkey = 0;\n int weakvalue = 0;\n const TValue *mode;\n if (h->metatable)\n markobject(g, h->metatable);\n mode = gfasttm(g, h->metatable, TM_MODE);\n if (mode && ttisstring(mode)) { /* is there a weak mode? */\n weakkey = (strchr(svalue(mode), 'k') != NULL);\n weakvalue = (strchr(svalue(mode), 'v') != NULL);\n if (weakkey || weakvalue) { /* is really weak? */\n h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */\n h->marked |= cast_byte((weakkey << KEYWEAKBIT) |\n (weakvalue << VALUEWEAKBIT));\n h->gclist = g->weak; /* must be cleared after GC, ... */\n g->weak = obj2gco(h); /* ... so put in the appropriate list */\n }\n }\n if (weakkey && weakvalue) return 1;\n if (!weakvalue) {\n i = h->sizearray;\n while (i--)\n markvalue(g, &h->array[i]);\n }\n i = sizenode(h);\n while (i--) {\n Node *n = gnode(h, i);\n lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));\n if (ttisnil(gval(n)))\n removeentry(n); /* remove empty entries */\n else {\n lua_assert(!ttisnil(gkey(n)));\n if (!weakkey) markvalue(g, gkey(n));\n if (!weakvalue) markvalue(g, gval(n));\n }\n }\n return weakkey || weakvalue;\n}\n\n\n/*\n** All marks are conditional because a GC may happen while the\n** prototype is still being created\n*/\nstatic void traverseproto (global_State *g, Proto *f) {\n int i;\n if (f->source) stringmark(f->source);\n for (i=0; isizek; i++) /* mark literals */\n markvalue(g, &f->k[i]);\n for (i=0; isizeupvalues; i++) { /* mark upvalue names */\n if (f->upvalues[i])\n stringmark(f->upvalues[i]);\n }\n for (i=0; isizep; i++) { /* mark nested protos */\n if (f->p[i])\n markobject(g, f->p[i]);\n }\n for (i=0; isizelocvars; i++) { /* mark local-variable names */\n if (f->locvars[i].varname)\n stringmark(f->locvars[i].varname);\n }\n}\n\n\n\nstatic void traverseclosure (global_State *g, Closure *cl) {\n markobject(g, cl->c.env);\n if (cl->c.isC) {\n int i;\n for (i=0; ic.nupvalues; i++) /* mark its upvalues */\n markvalue(g, &cl->c.upvalue[i]);\n }\n else {\n int i;\n lua_assert(cl->l.nupvalues == cl->l.p->nups);\n markobject(g, cl->l.p);\n for (i=0; il.nupvalues; i++) /* mark its upvalues */\n markobject(g, cl->l.upvals[i]);\n }\n}\n\n\nstatic void checkstacksizes (lua_State *L, StkId max) {\n int ci_used = cast_int(L->ci - L->base_ci); /* number of `ci' in use */\n int s_used = cast_int(max - L->stack); /* part of stack in use */\n if (L->size_ci > LUAI_MAXCALLS) /* handling overflow? */\n return; /* do not touch the stacks */\n if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)\n luaD_reallocCI(L, L->size_ci/2); /* still big enough... */\n condhardstacktests(luaD_reallocCI(L, ci_used + 1));\n if (4*s_used < L->stacksize &&\n 2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)\n luaD_reallocstack(L, L->stacksize/2); /* still big enough... */\n condhardstacktests(luaD_reallocstack(L, s_used));\n}\n\n\nstatic void traversestack (global_State *g, lua_State *l) {\n StkId o, lim;\n CallInfo *ci;\n markvalue(g, gt(l));\n lim = l->top;\n for (ci = l->base_ci; ci <= l->ci; ci++) {\n lua_assert(ci->top <= l->stack_last);\n if (lim < ci->top) lim = ci->top;\n }\n for (o = l->stack; o < l->top; o++)\n markvalue(g, o);\n for (; o <= lim; o++)\n setnilvalue(o);\n checkstacksizes(l, lim);\n}\n\n\n/*\n** traverse one gray object, turning it to black.\n** Returns `quantity' traversed.\n*/\nstatic l_mem propagatemark (global_State *g) {\n GCObject *o = g->gray;\n lua_assert(isgray(o));\n gray2black(o);\n switch (o->gch.tt) {\n case LUA_TTABLE: {\n Table *h = gco2h(o);\n g->gray = h->gclist;\n if (traversetable(g, h)) /* table is weak? */\n black2gray(o); /* keep it gray */\n return sizeof(Table) + sizeof(TValue) * h->sizearray +\n sizeof(Node) * sizenode(h);\n }\n case LUA_TFUNCTION: {\n Closure *cl = gco2cl(o);\n g->gray = cl->c.gclist;\n traverseclosure(g, cl);\n return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :\n sizeLclosure(cl->l.nupvalues);\n }\n case LUA_TTHREAD: {\n lua_State *th = gco2th(o);\n g->gray = th->gclist;\n th->gclist = g->grayagain;\n g->grayagain = o;\n black2gray(o);\n traversestack(g, th);\n return sizeof(lua_State) + sizeof(TValue) * th->stacksize +\n sizeof(CallInfo) * th->size_ci;\n }\n case LUA_TPROTO: {\n Proto *p = gco2p(o);\n g->gray = p->gclist;\n traverseproto(g, p);\n return sizeof(Proto) + sizeof(Instruction) * p->sizecode +\n sizeof(Proto *) * p->sizep +\n sizeof(TValue) * p->sizek + \n sizeof(int) * p->sizelineinfo +\n sizeof(LocVar) * p->sizelocvars +\n sizeof(TString *) * p->sizeupvalues;\n }\n default: lua_assert(0); return 0;\n }\n}\n\n\nstatic size_t propagateall (global_State *g) {\n size_t m = 0;\n while (g->gray) m += propagatemark(g);\n return m;\n}\n\n\n/*\n** The next function tells whether a key or value can be cleared from\n** a weak table. Non-collectable objects are never removed from weak\n** tables. Strings behave as `values', so are never removed too. for\n** other objects: if really collected, cannot keep them; for userdata\n** being finalized, keep them in keys, but not in values\n*/\nstatic int iscleared (const TValue *o, int iskey) {\n if (!iscollectable(o)) return 0;\n if (ttisstring(o)) {\n stringmark(rawtsvalue(o)); /* strings are `values', so are never weak */\n return 0;\n }\n return iswhite(gcvalue(o)) ||\n (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));\n}\n\n\n/*\n** clear collected entries from weaktables\n*/\nstatic void cleartable (GCObject *l) {\n while (l) {\n Table *h = gco2h(l);\n int i = h->sizearray;\n lua_assert(testbit(h->marked, VALUEWEAKBIT) ||\n testbit(h->marked, KEYWEAKBIT));\n if (testbit(h->marked, VALUEWEAKBIT)) {\n while (i--) {\n TValue *o = &h->array[i];\n if (iscleared(o, 0)) /* value was collected? */\n setnilvalue(o); /* remove value */\n }\n }\n i = sizenode(h);\n while (i--) {\n Node *n = gnode(h, i);\n if (!ttisnil(gval(n)) && /* non-empty entry? */\n (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {\n setnilvalue(gval(n)); /* remove value ... */\n removeentry(n); /* remove entry from table */\n }\n }\n l = h->gclist;\n }\n}\n\n\nstatic void freeobj (lua_State *L, GCObject *o) {\n switch (o->gch.tt) {\n case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;\n case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;\n case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;\n case LUA_TTABLE: luaH_free(L, gco2h(o)); break;\n case LUA_TTHREAD: {\n lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);\n luaE_freethread(L, gco2th(o));\n break;\n }\n case LUA_TSTRING: {\n G(L)->strt.nuse--;\n luaM_freemem(L, o, sizestring(gco2ts(o)));\n break;\n }\n case LUA_TUSERDATA: {\n luaM_freemem(L, o, sizeudata(gco2u(o)));\n break;\n }\n default: lua_assert(0);\n }\n}\n\n\n\n#define sweepwholelist(L,p)\tsweeplist(L,p,MAX_LUMEM)\n\n\nstatic GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {\n GCObject *curr;\n global_State *g = G(L);\n int deadmask = otherwhite(g);\n while ((curr = *p) != NULL && count-- > 0) {\n if (curr->gch.tt == LUA_TTHREAD) /* sweep open upvalues of each thread */\n sweepwholelist(L, &gco2th(curr)->openupval);\n if ((curr->gch.marked ^ WHITEBITS) & deadmask) { /* not dead? */\n lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));\n makewhite(g, curr); /* make it white (for next cycle) */\n p = &curr->gch.next;\n }\n else { /* must erase `curr' */\n lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));\n *p = curr->gch.next;\n if (curr == g->rootgc) /* is the first element of the list? */\n g->rootgc = curr->gch.next; /* adjust first */\n freeobj(L, curr);\n }\n }\n return p;\n}\n\n\nstatic void checkSizes (lua_State *L) {\n global_State *g = G(L);\n /* check size of string hash */\n if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&\n g->strt.size > MINSTRTABSIZE*2)\n luaS_resize(L, g->strt.size/2); /* table is too big */\n /* check size of buffer */\n if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) { /* buffer too big? */\n size_t newsize = luaZ_sizebuffer(&g->buff) / 2;\n luaZ_resizebuffer(L, &g->buff, newsize);\n }\n}\n\n\nstatic void GCTM (lua_State *L) {\n global_State *g = G(L);\n GCObject *o = g->tmudata->gch.next; /* get first element */\n Udata *udata = rawgco2u(o);\n const TValue *tm;\n /* remove udata from `tmudata' */\n if (o == g->tmudata) /* last element? */\n g->tmudata = NULL;\n else\n g->tmudata->gch.next = udata->uv.next;\n udata->uv.next = g->mainthread->next; /* return it to `root' list */\n g->mainthread->next = o;\n makewhite(g, o);\n tm = fasttm(L, udata->uv.metatable, TM_GC);\n if (tm != NULL) {\n lu_byte oldah = L->allowhook;\n lu_mem oldt = g->GCthreshold;\n L->allowhook = 0; /* stop debug hooks during GC tag method */\n g->GCthreshold = 2*g->totalbytes; /* avoid GC steps */\n setobj2s(L, L->top, tm);\n setuvalue(L, L->top+1, udata);\n L->top += 2;\n luaD_call(L, L->top - 2, 0);\n L->allowhook = oldah; /* restore hooks */\n g->GCthreshold = oldt; /* restore threshold */\n }\n}\n\n\n/*\n** Call all GC tag methods\n*/\nvoid luaC_callGCTM (lua_State *L) {\n while (G(L)->tmudata)\n GCTM(L);\n}\n\n\nvoid luaC_freeall (lua_State *L) {\n global_State *g = G(L);\n int i;\n g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT); /* mask to collect all elements */\n sweepwholelist(L, &g->rootgc);\n for (i = 0; i < g->strt.size; i++) /* free all string lists */\n sweepwholelist(L, &g->strt.hash[i]);\n}\n\n\nstatic void markmt (global_State *g) {\n int i;\n for (i=0; imt[i]) markobject(g, g->mt[i]);\n}\n\n\n/* mark root set */\nstatic void markroot (lua_State *L) {\n global_State *g = G(L);\n g->gray = NULL;\n g->grayagain = NULL;\n g->weak = NULL;\n markobject(g, g->mainthread);\n /* make global table be traversed before main stack */\n markvalue(g, gt(g->mainthread));\n markvalue(g, registry(L));\n markmt(g);\n g->gcstate = GCSpropagate;\n}\n\n\nstatic void remarkupvals (global_State *g) {\n UpVal *uv;\n for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {\n lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);\n if (isgray(obj2gco(uv)))\n markvalue(g, uv->v);\n }\n}\n\n\nstatic void atomic (lua_State *L) {\n global_State *g = G(L);\n size_t udsize; /* total size of userdata to be finalized */\n /* remark occasional upvalues of (maybe) dead threads */\n remarkupvals(g);\n /* traverse objects cautch by write barrier and by 'remarkupvals' */\n propagateall(g);\n /* remark weak tables */\n g->gray = g->weak;\n g->weak = NULL;\n lua_assert(!iswhite(obj2gco(g->mainthread)));\n markobject(g, L); /* mark running thread */\n markmt(g); /* mark basic metatables (again) */\n propagateall(g);\n /* remark gray again */\n g->gray = g->grayagain;\n g->grayagain = NULL;\n propagateall(g);\n udsize = luaC_separateudata(L, 0); /* separate userdata to be finalized */\n marktmu(g); /* mark `preserved' userdata */\n udsize += propagateall(g); /* remark, to propagate `preserveness' */\n cleartable(g->weak); /* remove collected objects from weak tables */\n /* flip current white */\n g->currentwhite = cast_byte(otherwhite(g));\n g->sweepstrgc = 0;\n g->sweepgc = &g->rootgc;\n g->gcstate = GCSsweepstring;\n g->estimate = g->totalbytes - udsize; /* first estimate */\n}\n\n\nstatic l_mem singlestep (lua_State *L) {\n global_State *g = G(L);\n /*lua_checkmemory(L);*/\n switch (g->gcstate) {\n case GCSpause: {\n markroot(L); /* start a new collection */\n return 0;\n }\n case GCSpropagate: {\n if (g->gray)\n return propagatemark(g);\n else { /* no more `gray' objects */\n atomic(L); /* finish mark phase */\n return 0;\n }\n }\n case GCSsweepstring: {\n lu_mem old = g->totalbytes;\n sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);\n if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */\n g->gcstate = GCSsweep; /* end sweep-string phase */\n lua_assert(old >= g->totalbytes);\n g->estimate -= old - g->totalbytes;\n return GCSWEEPCOST;\n }\n case GCSsweep: {\n lu_mem old = g->totalbytes;\n g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);\n if (*g->sweepgc == NULL) { /* nothing more to sweep? */\n checkSizes(L);\n g->gcstate = GCSfinalize; /* end sweep phase */\n }\n lua_assert(old >= g->totalbytes);\n g->estimate -= old - g->totalbytes;\n return GCSWEEPMAX*GCSWEEPCOST;\n }\n case GCSfinalize: {\n if (g->tmudata) {\n GCTM(L);\n if (g->estimate > GCFINALIZECOST)\n g->estimate -= GCFINALIZECOST;\n return GCFINALIZECOST;\n }\n else {\n g->gcstate = GCSpause; /* end collection */\n g->gcdept = 0;\n return 0;\n }\n }\n default: lua_assert(0); return 0;\n }\n}\n\n\nvoid luaC_step (lua_State *L) {\n global_State *g = G(L);\n l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;\n if (lim == 0)\n lim = (MAX_LUMEM-1)/2; /* no limit */\n g->gcdept += g->totalbytes - g->GCthreshold;\n do {\n lim -= singlestep(L);\n if (g->gcstate == GCSpause)\n break;\n } while (lim > 0);\n if (g->gcstate != GCSpause) {\n if (g->gcdept < GCSTEPSIZE)\n g->GCthreshold = g->totalbytes + GCSTEPSIZE; /* - lim/g->gcstepmul;*/\n else {\n g->gcdept -= GCSTEPSIZE;\n g->GCthreshold = g->totalbytes;\n }\n }\n else {\n setthreshold(g);\n }\n}\n\n\nvoid luaC_fullgc (lua_State *L) {\n global_State *g = G(L);\n if (g->gcstate <= GCSpropagate) {\n /* reset sweep marks to sweep all elements (returning them to white) */\n g->sweepstrgc = 0;\n g->sweepgc = &g->rootgc;\n /* reset other collector lists */\n g->gray = NULL;\n g->grayagain = NULL;\n g->weak = NULL;\n g->gcstate = GCSsweepstring;\n }\n lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);\n /* finish any pending sweep phase */\n while (g->gcstate != GCSfinalize) {\n lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);\n singlestep(L);\n }\n markroot(L);\n while (g->gcstate != GCSpause) {\n singlestep(L);\n }\n setthreshold(g);\n}\n\n\nvoid luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {\n global_State *g = G(L);\n lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));\n lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);\n lua_assert(ttype(&o->gch) != LUA_TTABLE);\n /* must keep invariant? */\n if (g->gcstate == GCSpropagate)\n reallymarkobject(g, v); /* restore invariant */\n else /* don't mind */\n makewhite(g, o); /* mark as white just to avoid other barriers */\n}\n\n\nvoid luaC_barrierback (lua_State *L, Table *t) {\n global_State *g = G(L);\n GCObject *o = obj2gco(t);\n lua_assert(isblack(o) && !isdead(g, o));\n lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);\n black2gray(o); /* make table gray (again) */\n t->gclist = g->grayagain;\n g->grayagain = o;\n}\n\n\nvoid luaC_link (lua_State *L, GCObject *o, lu_byte tt) {\n global_State *g = G(L);\n o->gch.next = g->rootgc;\n g->rootgc = o;\n o->gch.marked = luaC_white(g);\n o->gch.tt = tt;\n}\n\n\nvoid luaC_linkupval (lua_State *L, UpVal *uv) {\n global_State *g = G(L);\n GCObject *o = obj2gco(uv);\n o->gch.next = g->rootgc; /* link upvalue into `rootgc' list */\n g->rootgc = o;\n if (isgray(o)) { \n if (g->gcstate == GCSpropagate) {\n gray2black(o); /* closed upvalues need barrier */\n luaC_barrier(L, uv, uv->v);\n }\n else { /* sweep phase: sweep it (turning it into white) */\n makewhite(g, o);\n lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);\n }\n }\n}\n\n" }, { "path": "deps/lua/src/lgc.h", "content": "/*\n** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $\n** Garbage Collector\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lgc_h\n#define lgc_h\n\n\n#include \"lobject.h\"\n\n\n/*\n** Possible states of the Garbage Collector\n*/\n#define GCSpause\t0\n#define GCSpropagate\t1\n#define GCSsweepstring\t2\n#define GCSsweep\t3\n#define GCSfinalize\t4\n\n\n/*\n** some userful bit tricks\n*/\n#define resetbits(x,m)\t((x) &= cast(lu_byte, ~(m)))\n#define setbits(x,m)\t((x) |= (m))\n#define testbits(x,m)\t((x) & (m))\n#define bitmask(b)\t(1<<(b))\n#define bit2mask(b1,b2)\t(bitmask(b1) | bitmask(b2))\n#define l_setbit(x,b)\tsetbits(x, bitmask(b))\n#define resetbit(x,b)\tresetbits(x, bitmask(b))\n#define testbit(x,b)\ttestbits(x, bitmask(b))\n#define set2bits(x,b1,b2)\tsetbits(x, (bit2mask(b1, b2)))\n#define reset2bits(x,b1,b2)\tresetbits(x, (bit2mask(b1, b2)))\n#define test2bits(x,b1,b2)\ttestbits(x, (bit2mask(b1, b2)))\n\n\n\n/*\n** Layout for bit use in `marked' field:\n** bit 0 - object is white (type 0)\n** bit 1 - object is white (type 1)\n** bit 2 - object is black\n** bit 3 - for userdata: has been finalized\n** bit 3 - for tables: has weak keys\n** bit 4 - for tables: has weak values\n** bit 5 - object is fixed (should not be collected)\n** bit 6 - object is \"super\" fixed (only the main thread)\n*/\n\n\n#define WHITE0BIT\t0\n#define WHITE1BIT\t1\n#define BLACKBIT\t2\n#define FINALIZEDBIT\t3\n#define KEYWEAKBIT\t3\n#define VALUEWEAKBIT\t4\n#define FIXEDBIT\t5\n#define SFIXEDBIT\t6\n#define WHITEBITS\tbit2mask(WHITE0BIT, WHITE1BIT)\n\n\n#define iswhite(x) test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)\n#define isblack(x) testbit((x)->gch.marked, BLACKBIT)\n#define isgray(x)\t(!isblack(x) && !iswhite(x))\n\n#define otherwhite(g)\t(g->currentwhite ^ WHITEBITS)\n#define isdead(g,v)\t((v)->gch.marked & otherwhite(g) & WHITEBITS)\n\n#define changewhite(x)\t((x)->gch.marked ^= WHITEBITS)\n#define gray2black(x)\tl_setbit((x)->gch.marked, BLACKBIT)\n\n#define valiswhite(x)\t(iscollectable(x) && iswhite(gcvalue(x)))\n\n#define luaC_white(g)\tcast(lu_byte, (g)->currentwhite & WHITEBITS)\n\n\n#define luaC_checkGC(L) { \\\n condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \\\n if (G(L)->totalbytes >= G(L)->GCthreshold) \\\n\tluaC_step(L); }\n\n\n#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \\\n\tluaC_barrierf(L,obj2gco(p),gcvalue(v)); }\n\n#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t))) \\\n\tluaC_barrierback(L,t); }\n\n#define luaC_objbarrier(L,p,o) \\\n\t{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \\\n\t\tluaC_barrierf(L,obj2gco(p),obj2gco(o)); }\n\n#define luaC_objbarriert(L,t,o) \\\n { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }\n\nLUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);\nLUAI_FUNC void luaC_callGCTM (lua_State *L);\nLUAI_FUNC void luaC_freeall (lua_State *L);\nLUAI_FUNC void luaC_step (lua_State *L);\nLUAI_FUNC void luaC_fullgc (lua_State *L);\nLUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);\nLUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);\nLUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);\nLUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);\n\n\n#endif\n" }, { "path": "deps/lua/src/linit.c", "content": "/*\n** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $\n** Initialization of libraries for lua.c\n** See Copyright Notice in lua.h\n*/\n\n\n#define linit_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lualib.h\"\n#include \"lauxlib.h\"\n\n\nstatic const luaL_Reg lualibs[] = {\n {\"\", luaopen_base},\n {LUA_LOADLIBNAME, luaopen_package},\n {LUA_TABLIBNAME, luaopen_table},\n {LUA_IOLIBNAME, luaopen_io},\n {LUA_OSLIBNAME, luaopen_os},\n {LUA_STRLIBNAME, luaopen_string},\n {LUA_MATHLIBNAME, luaopen_math},\n {LUA_DBLIBNAME, luaopen_debug},\n {NULL, NULL}\n};\n\n\nLUALIB_API void luaL_openlibs (lua_State *L) {\n const luaL_Reg *lib = lualibs;\n for (; lib->func; lib++) {\n lua_pushcfunction(L, lib->func);\n lua_pushstring(L, lib->name);\n lua_call(L, 1, 0);\n }\n}\n\n" }, { "path": "deps/lua/src/liolib.c", "content": "/*\n** $Id: liolib.c,v 2.73.1.4 2010/05/14 15:33:51 roberto Exp $\n** Standard I/O (and system) library\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n\n#define liolib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n\n#define IO_INPUT\t1\n#define IO_OUTPUT\t2\n\n\nstatic const char *const fnames[] = {\"input\", \"output\"};\n\n\nstatic int pushresult (lua_State *L, int i, const char *filename) {\n int en = errno; /* calls to Lua API may change this value */\n if (i) {\n lua_pushboolean(L, 1);\n return 1;\n }\n else {\n lua_pushnil(L);\n if (filename)\n lua_pushfstring(L, \"%s: %s\", filename, strerror(en));\n else\n lua_pushfstring(L, \"%s\", strerror(en));\n lua_pushinteger(L, en);\n return 3;\n }\n}\n\n\nstatic void fileerror (lua_State *L, int arg, const char *filename) {\n lua_pushfstring(L, \"%s: %s\", filename, strerror(errno));\n luaL_argerror(L, arg, lua_tostring(L, -1));\n}\n\n\n#define tofilep(L)\t((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))\n\n\nstatic int io_type (lua_State *L) {\n void *ud;\n luaL_checkany(L, 1);\n ud = lua_touserdata(L, 1);\n lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);\n if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))\n lua_pushnil(L); /* not a file */\n else if (*((FILE **)ud) == NULL)\n lua_pushliteral(L, \"closed file\");\n else\n lua_pushliteral(L, \"file\");\n return 1;\n}\n\n\nstatic FILE *tofile (lua_State *L) {\n FILE **f = tofilep(L);\n if (*f == NULL)\n luaL_error(L, \"attempt to use a closed file\");\n return *f;\n}\n\n\n\n/*\n** When creating file handles, always creates a `closed' file handle\n** before opening the actual file; so, if there is a memory error, the\n** file is not left opened.\n*/\nstatic FILE **newfile (lua_State *L) {\n FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));\n *pf = NULL; /* file handle is currently `closed' */\n luaL_getmetatable(L, LUA_FILEHANDLE);\n lua_setmetatable(L, -2);\n return pf;\n}\n\n\n/*\n** function to (not) close the standard files stdin, stdout, and stderr\n*/\nstatic int io_noclose (lua_State *L) {\n lua_pushnil(L);\n lua_pushliteral(L, \"cannot close standard file\");\n return 2;\n}\n\n\n/*\n** function to close 'popen' files\n*/\nstatic int io_pclose (lua_State *L) {\n FILE **p = tofilep(L);\n int ok = lua_pclose(L, *p);\n *p = NULL;\n return pushresult(L, ok, NULL);\n}\n\n\n/*\n** function to close regular files\n*/\nstatic int io_fclose (lua_State *L) {\n FILE **p = tofilep(L);\n int ok = (fclose(*p) == 0);\n *p = NULL;\n return pushresult(L, ok, NULL);\n}\n\n\nstatic int aux_close (lua_State *L) {\n lua_getfenv(L, 1);\n lua_getfield(L, -1, \"__close\");\n return (lua_tocfunction(L, -1))(L);\n}\n\n\nstatic int io_close (lua_State *L) {\n if (lua_isnone(L, 1))\n lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);\n tofile(L); /* make sure argument is a file */\n return aux_close(L);\n}\n\n\nstatic int io_gc (lua_State *L) {\n FILE *f = *tofilep(L);\n /* ignore closed files */\n if (f != NULL)\n aux_close(L);\n return 0;\n}\n\n\nstatic int io_tostring (lua_State *L) {\n FILE *f = *tofilep(L);\n if (f == NULL)\n lua_pushliteral(L, \"file (closed)\");\n else\n lua_pushfstring(L, \"file (%p)\", f);\n return 1;\n}\n\n\nstatic int io_open (lua_State *L) {\n const char *filename = luaL_checkstring(L, 1);\n const char *mode = luaL_optstring(L, 2, \"r\");\n FILE **pf = newfile(L);\n *pf = fopen(filename, mode);\n return (*pf == NULL) ? pushresult(L, 0, filename) : 1;\n}\n\n\n/*\n** this function has a separated environment, which defines the\n** correct __close for 'popen' files\n*/\nstatic int io_popen (lua_State *L) {\n const char *filename = luaL_checkstring(L, 1);\n const char *mode = luaL_optstring(L, 2, \"r\");\n FILE **pf = newfile(L);\n *pf = lua_popen(L, filename, mode);\n return (*pf == NULL) ? pushresult(L, 0, filename) : 1;\n}\n\n\nstatic int io_tmpfile (lua_State *L) {\n FILE **pf = newfile(L);\n *pf = tmpfile();\n return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;\n}\n\n\nstatic FILE *getiofile (lua_State *L, int findex) {\n FILE *f;\n lua_rawgeti(L, LUA_ENVIRONINDEX, findex);\n f = *(FILE **)lua_touserdata(L, -1);\n if (f == NULL)\n luaL_error(L, \"standard %s file is closed\", fnames[findex - 1]);\n return f;\n}\n\n\nstatic int g_iofile (lua_State *L, int f, const char *mode) {\n if (!lua_isnoneornil(L, 1)) {\n const char *filename = lua_tostring(L, 1);\n if (filename) {\n FILE **pf = newfile(L);\n *pf = fopen(filename, mode);\n if (*pf == NULL)\n fileerror(L, 1, filename);\n }\n else {\n tofile(L); /* check that it's a valid file handle */\n lua_pushvalue(L, 1);\n }\n lua_rawseti(L, LUA_ENVIRONINDEX, f);\n }\n /* return current value */\n lua_rawgeti(L, LUA_ENVIRONINDEX, f);\n return 1;\n}\n\n\nstatic int io_input (lua_State *L) {\n return g_iofile(L, IO_INPUT, \"r\");\n}\n\n\nstatic int io_output (lua_State *L) {\n return g_iofile(L, IO_OUTPUT, \"w\");\n}\n\n\nstatic int io_readline (lua_State *L);\n\n\nstatic void aux_lines (lua_State *L, int idx, int toclose) {\n lua_pushvalue(L, idx);\n lua_pushboolean(L, toclose); /* close/not close file when finished */\n lua_pushcclosure(L, io_readline, 2);\n}\n\n\nstatic int f_lines (lua_State *L) {\n tofile(L); /* check that it's a valid file handle */\n aux_lines(L, 1, 0);\n return 1;\n}\n\n\nstatic int io_lines (lua_State *L) {\n if (lua_isnoneornil(L, 1)) { /* no arguments? */\n /* will iterate over default input */\n lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);\n return f_lines(L);\n }\n else {\n const char *filename = luaL_checkstring(L, 1);\n FILE **pf = newfile(L);\n *pf = fopen(filename, \"r\");\n if (*pf == NULL)\n fileerror(L, 1, filename);\n aux_lines(L, lua_gettop(L), 1);\n return 1;\n }\n}\n\n\n/*\n** {======================================================\n** READ\n** =======================================================\n*/\n\n\nstatic int read_number (lua_State *L, FILE *f) {\n lua_Number d;\n if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {\n lua_pushnumber(L, d);\n return 1;\n }\n else {\n lua_pushnil(L); /* \"result\" to be removed */\n return 0; /* read fails */\n }\n}\n\n\nstatic int test_eof (lua_State *L, FILE *f) {\n int c = getc(f);\n ungetc(c, f);\n lua_pushlstring(L, NULL, 0);\n return (c != EOF);\n}\n\n\nstatic int read_line (lua_State *L, FILE *f) {\n luaL_Buffer b;\n luaL_buffinit(L, &b);\n for (;;) {\n size_t l;\n char *p = luaL_prepbuffer(&b);\n if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */\n luaL_pushresult(&b); /* close buffer */\n return (lua_objlen(L, -1) > 0); /* check whether read something */\n }\n l = strlen(p);\n if (l == 0 || p[l-1] != '\\n')\n luaL_addsize(&b, l);\n else {\n luaL_addsize(&b, l - 1); /* do not include `eol' */\n luaL_pushresult(&b); /* close buffer */\n return 1; /* read at least an `eol' */\n }\n }\n}\n\n\nstatic int read_chars (lua_State *L, FILE *f, size_t n) {\n size_t rlen; /* how much to read */\n size_t nr; /* number of chars actually read */\n luaL_Buffer b;\n luaL_buffinit(L, &b);\n rlen = LUAL_BUFFERSIZE; /* try to read that much each time */\n do {\n char *p = luaL_prepbuffer(&b);\n if (rlen > n) rlen = n; /* cannot read more than asked */\n nr = fread(p, sizeof(char), rlen, f);\n luaL_addsize(&b, nr);\n n -= nr; /* still have to read `n' chars */\n } while (n > 0 && nr == rlen); /* until end of count or eof */\n luaL_pushresult(&b); /* close buffer */\n return (n == 0 || lua_objlen(L, -1) > 0);\n}\n\n\nstatic int g_read (lua_State *L, FILE *f, int first) {\n int nargs = lua_gettop(L) - 1;\n int success;\n int n;\n clearerr(f);\n if (nargs == 0) { /* no arguments? */\n success = read_line(L, f);\n n = first+1; /* to return 1 result */\n }\n else { /* ensure stack space for all results and for auxlib's buffer */\n luaL_checkstack(L, nargs+LUA_MINSTACK, \"too many arguments\");\n success = 1;\n for (n = first; nargs-- && success; n++) {\n if (lua_type(L, n) == LUA_TNUMBER) {\n size_t l = (size_t)lua_tointeger(L, n);\n success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);\n }\n else {\n const char *p = lua_tostring(L, n);\n luaL_argcheck(L, p && p[0] == '*', n, \"invalid option\");\n switch (p[1]) {\n case 'n': /* number */\n success = read_number(L, f);\n break;\n case 'l': /* line */\n success = read_line(L, f);\n break;\n case 'a': /* file */\n read_chars(L, f, ~((size_t)0)); /* read MAX_SIZE_T chars */\n success = 1; /* always success */\n break;\n default:\n return luaL_argerror(L, n, \"invalid format\");\n }\n }\n }\n }\n if (ferror(f))\n return pushresult(L, 0, NULL);\n if (!success) {\n lua_pop(L, 1); /* remove last result */\n lua_pushnil(L); /* push nil instead */\n }\n return n - first;\n}\n\n\nstatic int io_read (lua_State *L) {\n return g_read(L, getiofile(L, IO_INPUT), 1);\n}\n\n\nstatic int f_read (lua_State *L) {\n return g_read(L, tofile(L), 2);\n}\n\n\nstatic int io_readline (lua_State *L) {\n FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));\n int sucess;\n if (f == NULL) /* file is already closed? */\n luaL_error(L, \"file is already closed\");\n sucess = read_line(L, f);\n if (ferror(f))\n return luaL_error(L, \"%s\", strerror(errno));\n if (sucess) return 1;\n else { /* EOF */\n if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */\n lua_settop(L, 0);\n lua_pushvalue(L, lua_upvalueindex(1));\n aux_close(L); /* close it */\n }\n return 0;\n }\n}\n\n/* }====================================================== */\n\n\nstatic int g_write (lua_State *L, FILE *f, int arg) {\n int nargs = lua_gettop(L) - 1;\n int status = 1;\n for (; nargs--; arg++) {\n if (lua_type(L, arg) == LUA_TNUMBER) {\n /* optimization: could be done exactly as for strings */\n status = status &&\n fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;\n }\n else {\n size_t l;\n const char *s = luaL_checklstring(L, arg, &l);\n status = status && (fwrite(s, sizeof(char), l, f) == l);\n }\n }\n return pushresult(L, status, NULL);\n}\n\n\nstatic int io_write (lua_State *L) {\n return g_write(L, getiofile(L, IO_OUTPUT), 1);\n}\n\n\nstatic int f_write (lua_State *L) {\n return g_write(L, tofile(L), 2);\n}\n\n\nstatic int f_seek (lua_State *L) {\n static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};\n static const char *const modenames[] = {\"set\", \"cur\", \"end\", NULL};\n FILE *f = tofile(L);\n int op = luaL_checkoption(L, 2, \"cur\", modenames);\n long offset = luaL_optlong(L, 3, 0);\n op = fseek(f, offset, mode[op]);\n if (op)\n return pushresult(L, 0, NULL); /* error */\n else {\n lua_pushinteger(L, ftell(f));\n return 1;\n }\n}\n\n\nstatic int f_setvbuf (lua_State *L) {\n static const int mode[] = {_IONBF, _IOFBF, _IOLBF};\n static const char *const modenames[] = {\"no\", \"full\", \"line\", NULL};\n FILE *f = tofile(L);\n int op = luaL_checkoption(L, 2, NULL, modenames);\n lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);\n int res = setvbuf(f, NULL, mode[op], sz);\n return pushresult(L, res == 0, NULL);\n}\n\n\n\nstatic int io_flush (lua_State *L) {\n return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);\n}\n\n\nstatic int f_flush (lua_State *L) {\n return pushresult(L, fflush(tofile(L)) == 0, NULL);\n}\n\n\nstatic const luaL_Reg iolib[] = {\n {\"close\", io_close},\n {\"flush\", io_flush},\n {\"input\", io_input},\n {\"lines\", io_lines},\n {\"open\", io_open},\n {\"output\", io_output},\n {\"popen\", io_popen},\n {\"read\", io_read},\n {\"tmpfile\", io_tmpfile},\n {\"type\", io_type},\n {\"write\", io_write},\n {NULL, NULL}\n};\n\n\nstatic const luaL_Reg flib[] = {\n {\"close\", io_close},\n {\"flush\", f_flush},\n {\"lines\", f_lines},\n {\"read\", f_read},\n {\"seek\", f_seek},\n {\"setvbuf\", f_setvbuf},\n {\"write\", f_write},\n {\"__gc\", io_gc},\n {\"__tostring\", io_tostring},\n {NULL, NULL}\n};\n\n\nstatic void createmeta (lua_State *L) {\n luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */\n lua_pushvalue(L, -1); /* push metatable */\n lua_setfield(L, -2, \"__index\"); /* metatable.__index = metatable */\n luaL_register(L, NULL, flib); /* file methods */\n}\n\n\nstatic void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {\n *newfile(L) = f;\n if (k > 0) {\n lua_pushvalue(L, -1);\n lua_rawseti(L, LUA_ENVIRONINDEX, k);\n }\n lua_pushvalue(L, -2); /* copy environment */\n lua_setfenv(L, -2); /* set it */\n lua_setfield(L, -3, fname);\n}\n\n\nstatic void newfenv (lua_State *L, lua_CFunction cls) {\n lua_createtable(L, 0, 1);\n lua_pushcfunction(L, cls);\n lua_setfield(L, -2, \"__close\");\n}\n\n\nLUALIB_API int luaopen_io (lua_State *L) {\n createmeta(L);\n /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */\n newfenv(L, io_fclose);\n lua_replace(L, LUA_ENVIRONINDEX);\n /* open library */\n luaL_register(L, LUA_IOLIBNAME, iolib);\n /* create (and set) default files */\n newfenv(L, io_noclose); /* close function for default files */\n createstdfile(L, stdin, IO_INPUT, \"stdin\");\n createstdfile(L, stdout, IO_OUTPUT, \"stdout\");\n createstdfile(L, stderr, 0, \"stderr\");\n lua_pop(L, 1); /* pop environment for default files */\n lua_getfield(L, -1, \"popen\");\n newfenv(L, io_pclose); /* create environment for 'popen' */\n lua_setfenv(L, -2); /* set fenv for 'popen' */\n lua_pop(L, 1); /* pop 'popen' */\n return 1;\n}\n\n" }, { "path": "deps/lua/src/llex.c", "content": "/*\n** $Id: llex.c,v 2.20.1.2 2009/11/23 14:58:22 roberto Exp $\n** Lexical Analyzer\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n\n#define llex_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldo.h\"\n#include \"llex.h\"\n#include \"lobject.h\"\n#include \"lparser.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"lzio.h\"\n\n\n\n#define next(ls) (ls->current = zgetc(ls->z))\n\n\n\n\n#define currIsNewline(ls)\t(ls->current == '\\n' || ls->current == '\\r')\n\n\n/* ORDER RESERVED */\nconst char *const luaX_tokens [] = {\n \"and\", \"break\", \"do\", \"else\", \"elseif\",\n \"end\", \"false\", \"for\", \"function\", \"if\",\n \"in\", \"local\", \"nil\", \"not\", \"or\", \"repeat\",\n \"return\", \"then\", \"true\", \"until\", \"while\",\n \"..\", \"...\", \"==\", \">=\", \"<=\", \"~=\",\n \"\", \"\", \"\", \"\",\n NULL\n};\n\n\n#define save_and_next(ls) (save(ls, ls->current), next(ls))\n\n\nstatic void save (LexState *ls, int c) {\n Mbuffer *b = ls->buff;\n if (b->n + 1 > b->buffsize) {\n size_t newsize;\n if (b->buffsize >= MAX_SIZET/2)\n luaX_lexerror(ls, \"lexical element too long\", 0);\n newsize = b->buffsize * 2;\n luaZ_resizebuffer(ls->L, b, newsize);\n }\n b->buffer[b->n++] = cast(char, c);\n}\n\n\nvoid luaX_init (lua_State *L) {\n int i;\n for (i=0; itsv.reserved = cast_byte(i+1); /* reserved word */\n }\n}\n\n\n#define MAXSRC 80\n\n\nconst char *luaX_token2str (LexState *ls, int token) {\n if (token < FIRST_RESERVED) {\n lua_assert(token == cast(unsigned char, token));\n return (iscntrl(token)) ? luaO_pushfstring(ls->L, \"char(%d)\", token) :\n luaO_pushfstring(ls->L, \"%c\", token);\n }\n else\n return luaX_tokens[token-FIRST_RESERVED];\n}\n\n\nstatic const char *txtToken (LexState *ls, int token) {\n switch (token) {\n case TK_NAME:\n case TK_STRING:\n case TK_NUMBER:\n save(ls, '\\0');\n return luaZ_buffer(ls->buff);\n default:\n return luaX_token2str(ls, token);\n }\n}\n\n\nvoid luaX_lexerror (LexState *ls, const char *msg, int token) {\n char buff[MAXSRC];\n luaO_chunkid(buff, getstr(ls->source), MAXSRC);\n msg = luaO_pushfstring(ls->L, \"%s:%d: %s\", buff, ls->linenumber, msg);\n if (token)\n luaO_pushfstring(ls->L, \"%s near \" LUA_QS, msg, txtToken(ls, token));\n luaD_throw(ls->L, LUA_ERRSYNTAX);\n}\n\n\nvoid luaX_syntaxerror (LexState *ls, const char *msg) {\n luaX_lexerror(ls, msg, ls->t.token);\n}\n\n\nTString *luaX_newstring (LexState *ls, const char *str, size_t l) {\n lua_State *L = ls->L;\n TString *ts = luaS_newlstr(L, str, l);\n TValue *o = luaH_setstr(L, ls->fs->h, ts); /* entry for `str' */\n if (ttisnil(o)) {\n setbvalue(o, 1); /* make sure `str' will not be collected */\n luaC_checkGC(L);\n }\n return ts;\n}\n\n\nstatic void inclinenumber (LexState *ls) {\n int old = ls->current;\n lua_assert(currIsNewline(ls));\n next(ls); /* skip `\\n' or `\\r' */\n if (currIsNewline(ls) && ls->current != old)\n next(ls); /* skip `\\n\\r' or `\\r\\n' */\n if (++ls->linenumber >= MAX_INT)\n luaX_syntaxerror(ls, \"chunk has too many lines\");\n}\n\n\nvoid luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {\n ls->t.token = 0;\n ls->decpoint = '.';\n ls->L = L;\n ls->lookahead.token = TK_EOS; /* no look-ahead token */\n ls->z = z;\n ls->fs = NULL;\n ls->linenumber = 1;\n ls->lastline = 1;\n ls->source = source;\n luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */\n next(ls); /* read first char */\n}\n\n\n\n/*\n** =======================================================\n** LEXICAL ANALYZER\n** =======================================================\n*/\n\n\n\nstatic int check_next (LexState *ls, const char *set) {\n if (!strchr(set, ls->current))\n return 0;\n save_and_next(ls);\n return 1;\n}\n\n\nstatic void buffreplace (LexState *ls, char from, char to) {\n size_t n = luaZ_bufflen(ls->buff);\n char *p = luaZ_buffer(ls->buff);\n while (n--)\n if (p[n] == from) p[n] = to;\n}\n\n\nstatic void trydecpoint (LexState *ls, SemInfo *seminfo) {\n /* format error: try to update decimal point separator */\n struct lconv *cv = localeconv();\n char old = ls->decpoint;\n ls->decpoint = (cv ? cv->decimal_point[0] : '.');\n buffreplace(ls, old, ls->decpoint); /* try updated decimal separator */\n if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {\n /* format error with correct decimal point: no more options */\n buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */\n luaX_lexerror(ls, \"malformed number\", TK_NUMBER);\n }\n}\n\n\n/* LUA_NUMBER */\nstatic void read_numeral (LexState *ls, SemInfo *seminfo) {\n lua_assert(isdigit(ls->current));\n do {\n save_and_next(ls);\n } while (isdigit(ls->current) || ls->current == '.');\n if (check_next(ls, \"Ee\")) /* `E'? */\n check_next(ls, \"+-\"); /* optional exponent sign */\n while (isalnum(ls->current) || ls->current == '_')\n save_and_next(ls);\n save(ls, '\\0');\n buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */\n if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) /* format error? */\n trydecpoint(ls, seminfo); /* try to update decimal point separator */\n}\n\n/*\n** reads a sequence '[=*[' or ']=*]', leaving the last bracket.\n** If a sequence is well-formed, return its number of '='s + 2; otherwise,\n** return 1 if there is no '='s or 0 otherwise (an unfinished '[==...').\n*/\nstatic size_t skip_sep (LexState *ls) {\n size_t count = 0;\n int s = ls->current;\n lua_assert(s == '[' || s == ']');\n save_and_next(ls);\n while (ls->current == '=') {\n save_and_next(ls);\n count++;\n }\n return (ls->current == s) ? count + 2\n : (count == 0) ? 1\n : 0;\n}\n\n\nstatic void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {\n int cont = 0;\n (void)(cont); /* avoid warnings when `cont' is not used */\n save_and_next(ls); /* skip 2nd `[' */\n if (currIsNewline(ls)) /* string starts with a newline? */\n inclinenumber(ls); /* skip it */\n for (;;) {\n switch (ls->current) {\n case EOZ:\n luaX_lexerror(ls, (seminfo) ? \"unfinished long string\" :\n \"unfinished long comment\", TK_EOS);\n break; /* to avoid warnings */\n#if defined(LUA_COMPAT_LSTR)\n case '[': {\n if (skip_sep(ls) == sep) {\n save_and_next(ls); /* skip 2nd `[' */\n cont++;\n#if LUA_COMPAT_LSTR == 1\n if (sep == 0)\n luaX_lexerror(ls, \"nesting of [[...]] is deprecated\", '[');\n#endif\n }\n break;\n }\n#endif\n case ']': {\n if (skip_sep(ls) == sep) {\n save_and_next(ls); /* skip 2nd `]' */\n#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2\n cont--;\n if (sep == 0 && cont >= 0) break;\n#endif\n goto endloop;\n }\n break;\n }\n case '\\n':\n case '\\r': {\n save(ls, '\\n');\n inclinenumber(ls);\n if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */\n break;\n }\n default: {\n if (seminfo) save_and_next(ls);\n else next(ls);\n }\n }\n } endloop:\n if (seminfo)\n seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,\n luaZ_bufflen(ls->buff) - 2 * sep);\n}\n\n\nstatic void read_string (LexState *ls, int del, SemInfo *seminfo) {\n save_and_next(ls);\n while (ls->current != del) {\n switch (ls->current) {\n case EOZ:\n luaX_lexerror(ls, \"unfinished string\", TK_EOS);\n continue; /* to avoid warnings */\n case '\\n':\n case '\\r':\n luaX_lexerror(ls, \"unfinished string\", TK_STRING);\n continue; /* to avoid warnings */\n case '\\\\': {\n int c;\n next(ls); /* do not save the `\\' */\n switch (ls->current) {\n case 'a': c = '\\a'; break;\n case 'b': c = '\\b'; break;\n case 'f': c = '\\f'; break;\n case 'n': c = '\\n'; break;\n case 'r': c = '\\r'; break;\n case 't': c = '\\t'; break;\n case 'v': c = '\\v'; break;\n case '\\n': /* go through */\n case '\\r': save(ls, '\\n'); inclinenumber(ls); continue;\n case EOZ: continue; /* will raise an error next loop */\n default: {\n if (!isdigit(ls->current))\n save_and_next(ls); /* handles \\\\, \\\", \\', and \\? */\n else { /* \\xxx */\n int i = 0;\n c = 0;\n do {\n c = 10*c + (ls->current-'0');\n next(ls);\n } while (++i<3 && isdigit(ls->current));\n if (c > UCHAR_MAX)\n luaX_lexerror(ls, \"escape sequence too large\", TK_STRING);\n save(ls, c);\n }\n continue;\n }\n }\n save(ls, c);\n next(ls);\n continue;\n }\n default:\n save_and_next(ls);\n }\n }\n save_and_next(ls); /* skip delimiter */\n seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,\n luaZ_bufflen(ls->buff) - 2);\n}\n\n\nstatic int llex (LexState *ls, SemInfo *seminfo) {\n luaZ_resetbuffer(ls->buff);\n for (;;) {\n switch (ls->current) {\n case '\\n':\n case '\\r': {\n inclinenumber(ls);\n continue;\n }\n case '-': {\n next(ls);\n if (ls->current != '-') return '-';\n /* else is a comment */\n next(ls);\n if (ls->current == '[') {\n size_t sep = skip_sep(ls);\n luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */\n if (sep >= 2) {\n read_long_string(ls, NULL, sep); /* long comment */\n luaZ_resetbuffer(ls->buff);\n continue;\n }\n }\n /* else short comment */\n while (!currIsNewline(ls) && ls->current != EOZ)\n next(ls);\n continue;\n }\n case '[': {\n size_t sep = skip_sep(ls);\n if (sep >= 2) {\n read_long_string(ls, seminfo, sep);\n return TK_STRING;\n }\n else if (sep == 0) /* '[=...' missing second bracket */\n luaX_lexerror(ls, \"invalid long string delimiter\", TK_STRING);\n return '[';\n }\n case '=': {\n next(ls);\n if (ls->current != '=') return '=';\n else { next(ls); return TK_EQ; }\n }\n case '<': {\n next(ls);\n if (ls->current != '=') return '<';\n else { next(ls); return TK_LE; }\n }\n case '>': {\n next(ls);\n if (ls->current != '=') return '>';\n else { next(ls); return TK_GE; }\n }\n case '~': {\n next(ls);\n if (ls->current != '=') return '~';\n else { next(ls); return TK_NE; }\n }\n case '\"':\n case '\\'': {\n read_string(ls, ls->current, seminfo);\n return TK_STRING;\n }\n case '.': {\n save_and_next(ls);\n if (check_next(ls, \".\")) {\n if (check_next(ls, \".\"))\n return TK_DOTS; /* ... */\n else return TK_CONCAT; /* .. */\n }\n else if (!isdigit(ls->current)) return '.';\n else {\n read_numeral(ls, seminfo);\n return TK_NUMBER;\n }\n }\n case EOZ: {\n return TK_EOS;\n }\n default: {\n if (isspace(ls->current)) {\n lua_assert(!currIsNewline(ls));\n next(ls);\n continue;\n }\n else if (isdigit(ls->current)) {\n read_numeral(ls, seminfo);\n return TK_NUMBER;\n }\n else if (isalpha(ls->current) || ls->current == '_') {\n /* identifier or reserved word */\n TString *ts;\n do {\n save_and_next(ls);\n } while (isalnum(ls->current) || ls->current == '_');\n ts = luaX_newstring(ls, luaZ_buffer(ls->buff),\n luaZ_bufflen(ls->buff));\n if (ts->tsv.reserved > 0) /* reserved word? */\n return ts->tsv.reserved - 1 + FIRST_RESERVED;\n else {\n seminfo->ts = ts;\n return TK_NAME;\n }\n }\n else {\n int c = ls->current;\n next(ls);\n return c; /* single-char tokens (+ - / ...) */\n }\n }\n }\n }\n}\n\n\nvoid luaX_next (LexState *ls) {\n ls->lastline = ls->linenumber;\n if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */\n ls->t = ls->lookahead; /* use this one */\n ls->lookahead.token = TK_EOS; /* and discharge it */\n }\n else\n ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */\n}\n\n\nvoid luaX_lookahead (LexState *ls) {\n lua_assert(ls->lookahead.token == TK_EOS);\n ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);\n}\n\n" }, { "path": "deps/lua/src/llex.h", "content": "/*\n** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $\n** Lexical Analyzer\n** See Copyright Notice in lua.h\n*/\n\n#ifndef llex_h\n#define llex_h\n\n#include \"lobject.h\"\n#include \"lzio.h\"\n\n\n#define FIRST_RESERVED\t257\n\n/* maximum length of a reserved word */\n#define TOKEN_LEN\t(sizeof(\"function\")/sizeof(char))\n\n\n/*\n* WARNING: if you change the order of this enumeration,\n* grep \"ORDER RESERVED\"\n*/\nenum RESERVED {\n /* terminal symbols denoted by reserved words */\n TK_AND = FIRST_RESERVED, TK_BREAK,\n TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,\n TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,\n TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,\n /* other terminal symbols */\n TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,\n TK_NAME, TK_STRING, TK_EOS\n};\n\n/* number of reserved words */\n#define NUM_RESERVED\t(cast(int, TK_WHILE-FIRST_RESERVED+1))\n\n\n/* array with token `names' */\nLUAI_DATA const char *const luaX_tokens [];\n\n\ntypedef union {\n lua_Number r;\n TString *ts;\n} SemInfo; /* semantics information */\n\n\ntypedef struct Token {\n int token;\n SemInfo seminfo;\n} Token;\n\n\ntypedef struct LexState {\n int current; /* current character (charint) */\n int linenumber; /* input line counter */\n int lastline; /* line of last token `consumed' */\n Token t; /* current token */\n Token lookahead; /* look ahead token */\n struct FuncState *fs; /* `FuncState' is private to the parser */\n struct lua_State *L;\n ZIO *z; /* input stream */\n Mbuffer *buff; /* buffer for tokens */\n TString *source; /* current source name */\n char decpoint; /* locale decimal point */\n} LexState;\n\n\nLUAI_FUNC void luaX_init (lua_State *L);\nLUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,\n TString *source);\nLUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);\nLUAI_FUNC void luaX_next (LexState *ls);\nLUAI_FUNC void luaX_lookahead (LexState *ls);\nLUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);\nLUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);\nLUAI_FUNC const char *luaX_token2str (LexState *ls, int token);\n\n\n#endif\n" }, { "path": "deps/lua/src/llimits.h", "content": "/*\n** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $\n** Limits, basic types, and some other `installation-dependent' definitions\n** See Copyright Notice in lua.h\n*/\n\n#ifndef llimits_h\n#define llimits_h\n\n\n#include \n#include \n\n\n#include \"lua.h\"\n\n\ntypedef LUAI_UINT32 lu_int32;\n\ntypedef LUAI_UMEM lu_mem;\n\ntypedef LUAI_MEM l_mem;\n\n\n\n/* chars used as small naturals (so that `char' is reserved for characters) */\ntypedef unsigned char lu_byte;\n\n\n#define MAX_SIZET\t((size_t)(~(size_t)0)-2)\n\n#define MAX_LUMEM\t((lu_mem)(~(lu_mem)0)-2)\n\n\n#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */\n\n/*\n** conversion of pointer to integer\n** this is for hashing only; there is no problem if the integer\n** cannot hold the whole pointer value\n*/\n#define IntPoint(p) ((unsigned int)(lu_mem)(p))\n\n\n\n/* type to ensure maximum alignment */\ntypedef LUAI_USER_ALIGNMENT_T L_Umaxalign;\n\n\n/* result of a `usual argument conversion' over lua_Number */\ntypedef LUAI_UACNUMBER l_uacNumber;\n\n\n/* internal assertions for in-house debugging */\n#ifdef lua_assert\n\n#define check_exp(c,e)\t\t(lua_assert(c), (e))\n#define api_check(l,e)\t\tlua_assert(e)\n\n#else\n\n#define lua_assert(c)\t\t((void)0)\n#define check_exp(c,e)\t\t(e)\n#define api_check\t\tluai_apicheck\n\n#endif\n\n\n#ifndef UNUSED\n#define UNUSED(x)\t((void)(x))\t/* to avoid warnings */\n#endif\n\n\n#ifndef cast\n#define cast(t, exp)\t((t)(exp))\n#endif\n\n#define cast_byte(i)\tcast(lu_byte, (i))\n#define cast_num(i)\tcast(lua_Number, (i))\n#define cast_int(i)\tcast(int, (i))\n\n\n\n/*\n** type for virtual-machine instructions\n** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)\n*/\ntypedef lu_int32 Instruction;\n\n\n\n/* maximum stack for a Lua function */\n#define MAXSTACK\t250\n\n\n\n/* minimum size for the string table (must be power of 2) */\n#ifndef MINSTRTABSIZE\n#define MINSTRTABSIZE\t32\n#endif\n\n\n/* minimum size for string buffer */\n#ifndef LUA_MINBUFFER\n#define LUA_MINBUFFER\t32\n#endif\n\n\n#ifndef lua_lock\n#define lua_lock(L) ((void) 0) \n#define lua_unlock(L) ((void) 0)\n#endif\n\n#ifndef luai_threadyield\n#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);}\n#endif\n\n\n/*\n** macro to control inclusion of some hard tests on stack reallocation\n*/ \n#ifndef HARDSTACKTESTS\n#define condhardstacktests(x)\t((void)0)\n#else\n#define condhardstacktests(x)\tx\n#endif\n\n#endif\n" }, { "path": "deps/lua/src/lmathlib.c", "content": "/*\n** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $\n** Standard mathematical library\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n\n#define lmathlib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n#undef PI\n#define PI (3.14159265358979323846)\n#define RADIANS_PER_DEGREE (PI/180.0)\n\n\n\nstatic int math_abs (lua_State *L) {\n lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_sin (lua_State *L) {\n lua_pushnumber(L, sin(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_sinh (lua_State *L) {\n lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_cos (lua_State *L) {\n lua_pushnumber(L, cos(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_cosh (lua_State *L) {\n lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_tan (lua_State *L) {\n lua_pushnumber(L, tan(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_tanh (lua_State *L) {\n lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_asin (lua_State *L) {\n lua_pushnumber(L, asin(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_acos (lua_State *L) {\n lua_pushnumber(L, acos(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_atan (lua_State *L) {\n lua_pushnumber(L, atan(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_atan2 (lua_State *L) {\n lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));\n return 1;\n}\n\nstatic int math_ceil (lua_State *L) {\n lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_floor (lua_State *L) {\n lua_pushnumber(L, floor(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_fmod (lua_State *L) {\n lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));\n return 1;\n}\n\nstatic int math_modf (lua_State *L) {\n double ip;\n double fp = modf(luaL_checknumber(L, 1), &ip);\n lua_pushnumber(L, ip);\n lua_pushnumber(L, fp);\n return 2;\n}\n\nstatic int math_sqrt (lua_State *L) {\n lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_pow (lua_State *L) {\n lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));\n return 1;\n}\n\nstatic int math_log (lua_State *L) {\n lua_pushnumber(L, log(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_log10 (lua_State *L) {\n lua_pushnumber(L, log10(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_exp (lua_State *L) {\n lua_pushnumber(L, exp(luaL_checknumber(L, 1)));\n return 1;\n}\n\nstatic int math_deg (lua_State *L) {\n lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);\n return 1;\n}\n\nstatic int math_rad (lua_State *L) {\n lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);\n return 1;\n}\n\nstatic int math_frexp (lua_State *L) {\n int e;\n lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));\n lua_pushinteger(L, e);\n return 2;\n}\n\nstatic int math_ldexp (lua_State *L) {\n lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));\n return 1;\n}\n\n\n\nstatic int math_min (lua_State *L) {\n int n = lua_gettop(L); /* number of arguments */\n lua_Number dmin = luaL_checknumber(L, 1);\n int i;\n for (i=2; i<=n; i++) {\n lua_Number d = luaL_checknumber(L, i);\n if (d < dmin)\n dmin = d;\n }\n lua_pushnumber(L, dmin);\n return 1;\n}\n\n\nstatic int math_max (lua_State *L) {\n int n = lua_gettop(L); /* number of arguments */\n lua_Number dmax = luaL_checknumber(L, 1);\n int i;\n for (i=2; i<=n; i++) {\n lua_Number d = luaL_checknumber(L, i);\n if (d > dmax)\n dmax = d;\n }\n lua_pushnumber(L, dmax);\n return 1;\n}\n\n\nstatic int math_random (lua_State *L) {\n /* the `%' avoids the (rare) case of r==1, and is needed also because on\n some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */\n lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;\n switch (lua_gettop(L)) { /* check number of arguments */\n case 0: { /* no arguments */\n lua_pushnumber(L, r); /* Number between 0 and 1 */\n break;\n }\n case 1: { /* only upper limit */\n int u = luaL_checkint(L, 1);\n luaL_argcheck(L, 1<=u, 1, \"interval is empty\");\n lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */\n break;\n }\n case 2: { /* lower and upper limits */\n int l = luaL_checkint(L, 1);\n int u = luaL_checkint(L, 2);\n luaL_argcheck(L, l<=u, 2, \"interval is empty\");\n lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */\n break;\n }\n default: return luaL_error(L, \"wrong number of arguments\");\n }\n return 1;\n}\n\n\nstatic int math_randomseed (lua_State *L) {\n srand(luaL_checkint(L, 1));\n return 0;\n}\n\n\nstatic const luaL_Reg mathlib[] = {\n {\"abs\", math_abs},\n {\"acos\", math_acos},\n {\"asin\", math_asin},\n {\"atan2\", math_atan2},\n {\"atan\", math_atan},\n {\"ceil\", math_ceil},\n {\"cosh\", math_cosh},\n {\"cos\", math_cos},\n {\"deg\", math_deg},\n {\"exp\", math_exp},\n {\"floor\", math_floor},\n {\"fmod\", math_fmod},\n {\"frexp\", math_frexp},\n {\"ldexp\", math_ldexp},\n {\"log10\", math_log10},\n {\"log\", math_log},\n {\"max\", math_max},\n {\"min\", math_min},\n {\"modf\", math_modf},\n {\"pow\", math_pow},\n {\"rad\", math_rad},\n {\"random\", math_random},\n {\"randomseed\", math_randomseed},\n {\"sinh\", math_sinh},\n {\"sin\", math_sin},\n {\"sqrt\", math_sqrt},\n {\"tanh\", math_tanh},\n {\"tan\", math_tan},\n {NULL, NULL}\n};\n\n\n/*\n** Open math library\n*/\nLUALIB_API int luaopen_math (lua_State *L) {\n luaL_register(L, LUA_MATHLIBNAME, mathlib);\n lua_pushnumber(L, PI);\n lua_setfield(L, -2, \"pi\");\n lua_pushnumber(L, HUGE_VAL);\n lua_setfield(L, -2, \"huge\");\n#if defined(LUA_COMPAT_MOD)\n lua_getfield(L, -1, \"fmod\");\n lua_setfield(L, -2, \"mod\");\n#endif\n return 1;\n}\n\n" }, { "path": "deps/lua/src/lmem.c", "content": "/*\n** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $\n** Interface to Memory Manager\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lmem_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n\n\n\n/*\n** About the realloc function:\n** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);\n** (`osize' is the old size, `nsize' is the new size)\n**\n** Lua ensures that (ptr == NULL) iff (osize == 0).\n**\n** * frealloc(ud, NULL, 0, x) creates a new block of size `x'\n**\n** * frealloc(ud, p, x, 0) frees the block `p'\n** (in this specific case, frealloc must return NULL).\n** particularly, frealloc(ud, NULL, 0, 0) does nothing\n** (which is equivalent to free(NULL) in ANSI C)\n**\n** frealloc returns NULL if it cannot create or reallocate the area\n** (any reallocation to an equal or smaller size cannot fail!)\n*/\n\n\n\n#define MINSIZEARRAY\t4\n\n\nvoid *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,\n int limit, const char *errormsg) {\n void *newblock;\n int newsize;\n if (*size >= limit/2) { /* cannot double it? */\n if (*size >= limit) /* cannot grow even a little? */\n luaG_runerror(L, errormsg);\n newsize = limit; /* still have at least one free place */\n }\n else {\n newsize = (*size)*2;\n if (newsize < MINSIZEARRAY)\n newsize = MINSIZEARRAY; /* minimum size */\n }\n newblock = luaM_reallocv(L, block, *size, newsize, size_elems);\n *size = newsize; /* update only when everything else is OK */\n return newblock;\n}\n\n\nvoid *luaM_toobig (lua_State *L) {\n luaG_runerror(L, \"memory allocation error: block too big\");\n return NULL; /* to avoid warnings */\n}\n\n\n\n/*\n** generic allocation routine.\n*/\nvoid *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {\n global_State *g = G(L);\n lua_assert((osize == 0) == (block == NULL));\n block = (*g->frealloc)(g->ud, block, osize, nsize);\n if (block == NULL && nsize > 0)\n luaD_throw(L, LUA_ERRMEM);\n lua_assert((nsize == 0) == (block == NULL));\n g->totalbytes = (g->totalbytes - osize) + nsize;\n return block;\n}\n\n" }, { "path": "deps/lua/src/lmem.h", "content": "/*\n** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $\n** Interface to Memory Manager\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lmem_h\n#define lmem_h\n\n\n#include \n\n#include \"llimits.h\"\n#include \"lua.h\"\n\n#define MEMERRMSG\t\"not enough memory\"\n\n\n#define luaM_reallocv(L,b,on,n,e) \\\n\t((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ? /* +1 to avoid warnings */ \\\n\t\tluaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \\\n\t\tluaM_toobig(L))\n\n#define luaM_freemem(L, b, s)\tluaM_realloc_(L, (b), (s), 0)\n#define luaM_free(L, b)\t\tluaM_realloc_(L, (b), sizeof(*(b)), 0)\n#define luaM_freearray(L, b, n, t) luaM_reallocv(L, (b), n, 0, sizeof(t))\n\n#define luaM_malloc(L,t)\tluaM_realloc_(L, NULL, 0, (t))\n#define luaM_new(L,t)\t\tcast(t *, luaM_malloc(L, sizeof(t)))\n#define luaM_newvector(L,n,t) \\\n\t\tcast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))\n\n#define luaM_growvector(L,v,nelems,size,t,limit,e) \\\n if ((nelems)+1 > (size)) \\\n ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))\n\n#define luaM_reallocvector(L, v,oldn,n,t) \\\n ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))\n\n\nLUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,\n size_t size);\nLUAI_FUNC void *luaM_toobig (lua_State *L);\nLUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,\n size_t size_elem, int limit,\n const char *errormsg);\n\n#endif\n\n" }, { "path": "deps/lua/src/loadlib.c", "content": "/*\n** $Id: loadlib.c,v 1.52.1.4 2009/09/09 13:17:16 roberto Exp $\n** Dynamic library loader for Lua\n** See Copyright Notice in lua.h\n**\n** This module contains an implementation of loadlib for Unix systems\n** that have dlfcn, an implementation for Darwin (Mac OS X), an\n** implementation for Windows, and a stub for other systems.\n*/\n\n\n#include \n#include \n\n\n#define loadlib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n/* prefix for open functions in C libraries */\n#define LUA_POF\t\t\"luaopen_\"\n\n/* separator for open functions in C libraries */\n#define LUA_OFSEP\t\"_\"\n\n\n#define LIBPREFIX\t\"LOADLIB: \"\n\n#define POF\t\tLUA_POF\n#define LIB_FAIL\t\"open\"\n\n\n/* error codes for ll_loadfunc */\n#define ERRLIB\t\t1\n#define ERRFUNC\t\t2\n\n#define setprogdir(L)\t\t((void)0)\n\n\nstatic void ll_unloadlib (void *lib);\nstatic void *ll_load (lua_State *L, const char *path);\nstatic lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);\n\n\n\n#if defined(LUA_DL_DLOPEN)\n/*\n** {========================================================================\n** This is an implementation of loadlib based on the dlfcn interface.\n** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,\n** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least\n** as an emulation layer on top of native functions.\n** =========================================================================\n*/\n\n#include \n\nstatic void ll_unloadlib (void *lib) {\n dlclose(lib);\n}\n\n\nstatic void *ll_load (lua_State *L, const char *path) {\n void *lib = dlopen(path, RTLD_NOW);\n if (lib == NULL) lua_pushstring(L, dlerror());\n return lib;\n}\n\n\nstatic lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {\n lua_CFunction f = (lua_CFunction)dlsym(lib, sym);\n if (f == NULL) lua_pushstring(L, dlerror());\n return f;\n}\n\n/* }====================================================== */\n\n\n\n#elif defined(LUA_DL_DLL)\n/*\n** {======================================================================\n** This is an implementation of loadlib for Windows using native functions.\n** =======================================================================\n*/\n\n#include \n\n\n#undef setprogdir\n\nstatic void setprogdir (lua_State *L) {\n char buff[MAX_PATH + 1];\n char *lb;\n DWORD nsize = sizeof(buff)/sizeof(char);\n DWORD n = GetModuleFileNameA(NULL, buff, nsize);\n if (n == 0 || n == nsize || (lb = strrchr(buff, '\\\\')) == NULL)\n luaL_error(L, \"unable to get ModuleFileName\");\n else {\n *lb = '\\0';\n luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);\n lua_remove(L, -2); /* remove original string */\n }\n}\n\n\nstatic void pusherror (lua_State *L) {\n int error = GetLastError();\n char buffer[128];\n if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,\n NULL, error, 0, buffer, sizeof(buffer), NULL))\n lua_pushstring(L, buffer);\n else\n lua_pushfstring(L, \"system error %d\\n\", error);\n}\n\nstatic void ll_unloadlib (void *lib) {\n FreeLibrary((HINSTANCE)lib);\n}\n\n\nstatic void *ll_load (lua_State *L, const char *path) {\n HINSTANCE lib = LoadLibraryA(path);\n if (lib == NULL) pusherror(L);\n return lib;\n}\n\n\nstatic lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {\n lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);\n if (f == NULL) pusherror(L);\n return f;\n}\n\n/* }====================================================== */\n\n\n\n#elif defined(LUA_DL_DYLD)\n/*\n** {======================================================================\n** Native Mac OS X / Darwin Implementation\n** =======================================================================\n*/\n\n#include \n\n\n/* Mac appends a `_' before C function names */\n#undef POF\n#define POF\t\"_\" LUA_POF\n\n\nstatic void pusherror (lua_State *L) {\n const char *err_str;\n const char *err_file;\n NSLinkEditErrors err;\n int err_num;\n NSLinkEditError(&err, &err_num, &err_file, &err_str);\n lua_pushstring(L, err_str);\n}\n\n\nstatic const char *errorfromcode (NSObjectFileImageReturnCode ret) {\n switch (ret) {\n case NSObjectFileImageInappropriateFile:\n return \"file is not a bundle\";\n case NSObjectFileImageArch:\n return \"library is for wrong CPU type\";\n case NSObjectFileImageFormat:\n return \"bad format\";\n case NSObjectFileImageAccess:\n return \"cannot access file\";\n case NSObjectFileImageFailure:\n default:\n return \"unable to load library\";\n }\n}\n\n\nstatic void ll_unloadlib (void *lib) {\n NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);\n}\n\n\nstatic void *ll_load (lua_State *L, const char *path) {\n NSObjectFileImage img;\n NSObjectFileImageReturnCode ret;\n /* this would be a rare case, but prevents crashing if it happens */\n if(!_dyld_present()) {\n lua_pushliteral(L, \"dyld not present\");\n return NULL;\n }\n ret = NSCreateObjectFileImageFromFile(path, &img);\n if (ret == NSObjectFileImageSuccess) {\n NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |\n NSLINKMODULE_OPTION_RETURN_ON_ERROR);\n NSDestroyObjectFileImage(img);\n if (mod == NULL) pusherror(L);\n return mod;\n }\n lua_pushstring(L, errorfromcode(ret));\n return NULL;\n}\n\n\nstatic lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {\n NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);\n if (nss == NULL) {\n lua_pushfstring(L, \"symbol \" LUA_QS \" not found\", sym);\n return NULL;\n }\n return (lua_CFunction)NSAddressOfSymbol(nss);\n}\n\n/* }====================================================== */\n\n\n\n#else\n/*\n** {======================================================\n** Fallback for other systems\n** =======================================================\n*/\n\n#undef LIB_FAIL\n#define LIB_FAIL\t\"absent\"\n\n\n#define DLMSG\t\"dynamic libraries not enabled; check your Lua installation\"\n\n\nstatic void ll_unloadlib (void *lib) {\n (void)lib; /* to avoid warnings */\n}\n\n\nstatic void *ll_load (lua_State *L, const char *path) {\n (void)path; /* to avoid warnings */\n lua_pushliteral(L, DLMSG);\n return NULL;\n}\n\n\nstatic lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {\n (void)lib; (void)sym; /* to avoid warnings */\n lua_pushliteral(L, DLMSG);\n return NULL;\n}\n\n/* }====================================================== */\n#endif\n\n\n\nstatic void **ll_register (lua_State *L, const char *path) {\n void **plib;\n lua_pushfstring(L, \"%s%s\", LIBPREFIX, path);\n lua_gettable(L, LUA_REGISTRYINDEX); /* check library in registry? */\n if (!lua_isnil(L, -1)) /* is there an entry? */\n plib = (void **)lua_touserdata(L, -1);\n else { /* no entry yet; create one */\n lua_pop(L, 1);\n plib = (void **)lua_newuserdata(L, sizeof(const void *));\n *plib = NULL;\n luaL_getmetatable(L, \"_LOADLIB\");\n lua_setmetatable(L, -2);\n lua_pushfstring(L, \"%s%s\", LIBPREFIX, path);\n lua_pushvalue(L, -2);\n lua_settable(L, LUA_REGISTRYINDEX);\n }\n return plib;\n}\n\n\n/*\n** __gc tag method: calls library's `ll_unloadlib' function with the lib\n** handle\n*/\nstatic int gctm (lua_State *L) {\n void **lib = (void **)luaL_checkudata(L, 1, \"_LOADLIB\");\n if (*lib) ll_unloadlib(*lib);\n *lib = NULL; /* mark library as closed */\n return 0;\n}\n\n\nstatic int ll_loadfunc (lua_State *L, const char *path, const char *sym) {\n void **reg = ll_register(L, path);\n if (*reg == NULL) *reg = ll_load(L, path);\n if (*reg == NULL)\n return ERRLIB; /* unable to load library */\n else {\n lua_CFunction f = ll_sym(L, *reg, sym);\n if (f == NULL)\n return ERRFUNC; /* unable to find function */\n lua_pushcfunction(L, f);\n return 0; /* return function */\n }\n}\n\n\nstatic int ll_loadlib (lua_State *L) {\n const char *path = luaL_checkstring(L, 1);\n const char *init = luaL_checkstring(L, 2);\n int stat = ll_loadfunc(L, path, init);\n if (stat == 0) /* no errors? */\n return 1; /* return the loaded function */\n else { /* error; error message is on stack top */\n lua_pushnil(L);\n lua_insert(L, -2);\n lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : \"init\");\n return 3; /* return nil, error message, and where */\n }\n}\n\n\n\n/*\n** {======================================================\n** 'require' function\n** =======================================================\n*/\n\n\nstatic int readable (const char *filename) {\n FILE *f = fopen(filename, \"r\"); /* try to open file */\n if (f == NULL) return 0; /* open failed */\n fclose(f);\n return 1;\n}\n\n\nstatic const char *pushnexttemplate (lua_State *L, const char *path) {\n const char *l;\n while (*path == *LUA_PATHSEP) path++; /* skip separators */\n if (*path == '\\0') return NULL; /* no more templates */\n l = strchr(path, *LUA_PATHSEP); /* find next separator */\n if (l == NULL) l = path + strlen(path);\n lua_pushlstring(L, path, l - path); /* template */\n return l;\n}\n\n\nstatic const char *findfile (lua_State *L, const char *name,\n const char *pname) {\n const char *path;\n name = luaL_gsub(L, name, \".\", LUA_DIRSEP);\n lua_getfield(L, LUA_ENVIRONINDEX, pname);\n path = lua_tostring(L, -1);\n if (path == NULL)\n luaL_error(L, LUA_QL(\"package.%s\") \" must be a string\", pname);\n lua_pushliteral(L, \"\"); /* error accumulator */\n while ((path = pushnexttemplate(L, path)) != NULL) {\n const char *filename;\n filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);\n lua_remove(L, -2); /* remove path template */\n if (readable(filename)) /* does file exist and is readable? */\n return filename; /* return that file name */\n lua_pushfstring(L, \"\\n\\tno file \" LUA_QS, filename);\n lua_remove(L, -2); /* remove file name */\n lua_concat(L, 2); /* add entry to possible error message */\n }\n return NULL; /* not found */\n}\n\n\nstatic void loaderror (lua_State *L, const char *filename) {\n luaL_error(L, \"error loading module \" LUA_QS \" from file \" LUA_QS \":\\n\\t%s\",\n lua_tostring(L, 1), filename, lua_tostring(L, -1));\n}\n\n\nstatic int loader_Lua (lua_State *L) {\n const char *filename;\n const char *name = luaL_checkstring(L, 1);\n filename = findfile(L, name, \"path\");\n if (filename == NULL) return 1; /* library not found in this path */\n if (luaL_loadfile(L, filename) != 0)\n loaderror(L, filename);\n return 1; /* library loaded successfully */\n}\n\n\nstatic const char *mkfuncname (lua_State *L, const char *modname) {\n const char *funcname;\n const char *mark = strchr(modname, *LUA_IGMARK);\n if (mark) modname = mark + 1;\n funcname = luaL_gsub(L, modname, \".\", LUA_OFSEP);\n funcname = lua_pushfstring(L, POF\"%s\", funcname);\n lua_remove(L, -2); /* remove 'gsub' result */\n return funcname;\n}\n\n\nstatic int loader_C (lua_State *L) {\n const char *funcname;\n const char *name = luaL_checkstring(L, 1);\n const char *filename = findfile(L, name, \"cpath\");\n if (filename == NULL) return 1; /* library not found in this path */\n funcname = mkfuncname(L, name);\n if (ll_loadfunc(L, filename, funcname) != 0)\n loaderror(L, filename);\n return 1; /* library loaded successfully */\n}\n\n\nstatic int loader_Croot (lua_State *L) {\n const char *funcname;\n const char *filename;\n const char *name = luaL_checkstring(L, 1);\n const char *p = strchr(name, '.');\n int stat;\n if (p == NULL) return 0; /* is root */\n lua_pushlstring(L, name, p - name);\n filename = findfile(L, lua_tostring(L, -1), \"cpath\");\n if (filename == NULL) return 1; /* root not found */\n funcname = mkfuncname(L, name);\n if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {\n if (stat != ERRFUNC) loaderror(L, filename); /* real error */\n lua_pushfstring(L, \"\\n\\tno module \" LUA_QS \" in file \" LUA_QS,\n name, filename);\n return 1; /* function not found */\n }\n return 1;\n}\n\n\nstatic int loader_preload (lua_State *L) {\n const char *name = luaL_checkstring(L, 1);\n lua_getfield(L, LUA_ENVIRONINDEX, \"preload\");\n if (!lua_istable(L, -1))\n luaL_error(L, LUA_QL(\"package.preload\") \" must be a table\");\n lua_getfield(L, -1, name);\n if (lua_isnil(L, -1)) /* not found? */\n lua_pushfstring(L, \"\\n\\tno field package.preload['%s']\", name);\n return 1;\n}\n\n\nstatic const int sentinel_ = 0;\n#define sentinel\t((void *)&sentinel_)\n\n\nstatic int ll_require (lua_State *L) {\n const char *name = luaL_checkstring(L, 1);\n int i;\n lua_settop(L, 1); /* _LOADED table will be at index 2 */\n lua_getfield(L, LUA_REGISTRYINDEX, \"_LOADED\");\n lua_getfield(L, 2, name);\n if (lua_toboolean(L, -1)) { /* is it there? */\n if (lua_touserdata(L, -1) == sentinel) /* check loops */\n luaL_error(L, \"loop or previous error loading module \" LUA_QS, name);\n return 1; /* package is already loaded */\n }\n /* else must load it; iterate over available loaders */\n lua_getfield(L, LUA_ENVIRONINDEX, \"loaders\");\n if (!lua_istable(L, -1))\n luaL_error(L, LUA_QL(\"package.loaders\") \" must be a table\");\n lua_pushliteral(L, \"\"); /* error message accumulator */\n for (i=1; ; i++) {\n lua_rawgeti(L, -2, i); /* get a loader */\n if (lua_isnil(L, -1))\n luaL_error(L, \"module \" LUA_QS \" not found:%s\",\n name, lua_tostring(L, -2));\n lua_pushstring(L, name);\n lua_call(L, 1, 1); /* call it */\n if (lua_isfunction(L, -1)) /* did it find module? */\n break; /* module loaded successfully */\n else if (lua_isstring(L, -1)) /* loader returned error message? */\n lua_concat(L, 2); /* accumulate it */\n else\n lua_pop(L, 1);\n }\n lua_pushlightuserdata(L, sentinel);\n lua_setfield(L, 2, name); /* _LOADED[name] = sentinel */\n lua_pushstring(L, name); /* pass name as argument to module */\n lua_call(L, 1, 1); /* run loaded module */\n if (!lua_isnil(L, -1)) /* non-nil return? */\n lua_setfield(L, 2, name); /* _LOADED[name] = returned value */\n lua_getfield(L, 2, name);\n if (lua_touserdata(L, -1) == sentinel) { /* module did not set a value? */\n lua_pushboolean(L, 1); /* use true as result */\n lua_pushvalue(L, -1); /* extra copy to be returned */\n lua_setfield(L, 2, name); /* _LOADED[name] = true */\n }\n return 1;\n}\n\n/* }====================================================== */\n\n\n\n/*\n** {======================================================\n** 'module' function\n** =======================================================\n*/\n \n\nstatic void setfenv (lua_State *L) {\n lua_Debug ar;\n if (lua_getstack(L, 1, &ar) == 0 ||\n lua_getinfo(L, \"f\", &ar) == 0 || /* get calling function */\n lua_iscfunction(L, -1))\n luaL_error(L, LUA_QL(\"module\") \" not called from a Lua function\");\n lua_pushvalue(L, -2);\n lua_setfenv(L, -2);\n lua_pop(L, 1);\n}\n\n\nstatic void dooptions (lua_State *L, int n) {\n int i;\n for (i = 2; i <= n; i++) {\n lua_pushvalue(L, i); /* get option (a function) */\n lua_pushvalue(L, -2); /* module */\n lua_call(L, 1, 0);\n }\n}\n\n\nstatic void modinit (lua_State *L, const char *modname) {\n const char *dot;\n lua_pushvalue(L, -1);\n lua_setfield(L, -2, \"_M\"); /* module._M = module */\n lua_pushstring(L, modname);\n lua_setfield(L, -2, \"_NAME\");\n dot = strrchr(modname, '.'); /* look for last dot in module name */\n if (dot == NULL) dot = modname;\n else dot++;\n /* set _PACKAGE as package name (full module name minus last part) */\n lua_pushlstring(L, modname, dot - modname);\n lua_setfield(L, -2, \"_PACKAGE\");\n}\n\n\nstatic int ll_module (lua_State *L) {\n const char *modname = luaL_checkstring(L, 1);\n int loaded = lua_gettop(L) + 1; /* index of _LOADED table */\n lua_getfield(L, LUA_REGISTRYINDEX, \"_LOADED\");\n lua_getfield(L, loaded, modname); /* get _LOADED[modname] */\n if (!lua_istable(L, -1)) { /* not found? */\n lua_pop(L, 1); /* remove previous result */\n /* try global variable (and create one if it does not exist) */\n if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)\n return luaL_error(L, \"name conflict for module \" LUA_QS, modname);\n lua_pushvalue(L, -1);\n lua_setfield(L, loaded, modname); /* _LOADED[modname] = new table */\n }\n /* check whether table already has a _NAME field */\n lua_getfield(L, -1, \"_NAME\");\n if (!lua_isnil(L, -1)) /* is table an initialized module? */\n lua_pop(L, 1);\n else { /* no; initialize it */\n lua_pop(L, 1);\n modinit(L, modname);\n }\n lua_pushvalue(L, -1);\n setfenv(L);\n dooptions(L, loaded - 1);\n return 0;\n}\n\n\nstatic int ll_seeall (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n if (!lua_getmetatable(L, 1)) {\n lua_createtable(L, 0, 1); /* create new metatable */\n lua_pushvalue(L, -1);\n lua_setmetatable(L, 1);\n }\n lua_pushvalue(L, LUA_GLOBALSINDEX);\n lua_setfield(L, -2, \"__index\"); /* mt.__index = _G */\n return 0;\n}\n\n\n/* }====================================================== */\n\n\n\n/* auxiliary mark (for internal use) */\n#define AUXMARK\t\t\"\\1\"\n\nstatic void setpath (lua_State *L, const char *fieldname, const char *envname,\n const char *def) {\n const char *path = getenv(envname);\n if (path == NULL) /* no environment variable? */\n lua_pushstring(L, def); /* use default */\n else {\n /* replace \";;\" by \";AUXMARK;\" and then AUXMARK by default path */\n path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,\n LUA_PATHSEP AUXMARK LUA_PATHSEP);\n luaL_gsub(L, path, AUXMARK, def);\n lua_remove(L, -2);\n }\n setprogdir(L);\n lua_setfield(L, -2, fieldname);\n}\n\n\nstatic const luaL_Reg pk_funcs[] = {\n {\"loadlib\", ll_loadlib},\n {\"seeall\", ll_seeall},\n {NULL, NULL}\n};\n\n\nstatic const luaL_Reg ll_funcs[] = {\n {\"module\", ll_module},\n {\"require\", ll_require},\n {NULL, NULL}\n};\n\n\nstatic const lua_CFunction loaders[] =\n {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};\n\n\nLUALIB_API int luaopen_package (lua_State *L) {\n int i;\n /* create new type _LOADLIB */\n luaL_newmetatable(L, \"_LOADLIB\");\n lua_pushcfunction(L, gctm);\n lua_setfield(L, -2, \"__gc\");\n /* create `package' table */\n luaL_register(L, LUA_LOADLIBNAME, pk_funcs);\n#if defined(LUA_COMPAT_LOADLIB) \n lua_getfield(L, -1, \"loadlib\");\n lua_setfield(L, LUA_GLOBALSINDEX, \"loadlib\");\n#endif\n lua_pushvalue(L, -1);\n lua_replace(L, LUA_ENVIRONINDEX);\n /* create `loaders' table */\n lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);\n /* fill it with pre-defined loaders */\n for (i=0; loaders[i] != NULL; i++) {\n lua_pushcfunction(L, loaders[i]);\n lua_rawseti(L, -2, i+1);\n }\n lua_setfield(L, -2, \"loaders\"); /* put it in field `loaders' */\n setpath(L, \"path\", LUA_PATH, LUA_PATH_DEFAULT); /* set field `path' */\n setpath(L, \"cpath\", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */\n /* store config information */\n lua_pushliteral(L, LUA_DIRSEP \"\\n\" LUA_PATHSEP \"\\n\" LUA_PATH_MARK \"\\n\"\n LUA_EXECDIR \"\\n\" LUA_IGMARK);\n lua_setfield(L, -2, \"config\");\n /* set field `loaded' */\n luaL_findtable(L, LUA_REGISTRYINDEX, \"_LOADED\", 2);\n lua_setfield(L, -2, \"loaded\");\n /* set field `preload' */\n lua_newtable(L);\n lua_setfield(L, -2, \"preload\");\n lua_pushvalue(L, LUA_GLOBALSINDEX);\n luaL_register(L, NULL, ll_funcs); /* open lib into global table */\n lua_pop(L, 1);\n return 1; /* return 'package' table */\n}\n\n" }, { "path": "deps/lua/src/lobject.c", "content": "/*\n** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $\n** Some generic functions over Lua objects\n** See Copyright Notice in lua.h\n*/\n\n#include \n#include \n#include \n#include \n#include \n\n#define lobject_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldo.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"lvm.h\"\n\n\n\nconst TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};\n\n\n/*\n** converts an integer to a \"floating point byte\", represented as\n** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if\n** eeeee != 0 and (xxx) otherwise.\n*/\nint luaO_int2fb (unsigned int x) {\n int e = 0; /* expoent */\n while (x >= 16) {\n x = (x+1) >> 1;\n e++;\n }\n if (x < 8) return x;\n else return ((e+1) << 3) | (cast_int(x) - 8);\n}\n\n\n/* converts back */\nint luaO_fb2int (int x) {\n int e = (x >> 3) & 31;\n if (e == 0) return x;\n else return ((x & 7)+8) << (e - 1);\n}\n\n\nint luaO_log2 (unsigned int x) {\n static const lu_byte log_2[256] = {\n 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,\n 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,\n 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\n 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8\n };\n int l = -1;\n while (x >= 256) { l += 8; x >>= 8; }\n return l + log_2[x];\n\n}\n\n\nint luaO_rawequalObj (const TValue *t1, const TValue *t2) {\n if (ttype(t1) != ttype(t2)) return 0;\n else switch (ttype(t1)) {\n case LUA_TNIL:\n return 1;\n case LUA_TNUMBER:\n return luai_numeq(nvalue(t1), nvalue(t2));\n case LUA_TBOOLEAN:\n return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */\n case LUA_TLIGHTUSERDATA:\n return pvalue(t1) == pvalue(t2);\n default:\n lua_assert(iscollectable(t1));\n return gcvalue(t1) == gcvalue(t2);\n }\n}\n\n\nint luaO_str2d (const char *s, lua_Number *result) {\n char *endptr;\n *result = lua_str2number(s, &endptr);\n if (endptr == s) return 0; /* conversion failed */\n if (*endptr == 'x' || *endptr == 'X') /* maybe an hexadecimal constant? */\n *result = cast_num(strtoul(s, &endptr, 16));\n if (*endptr == '\\0') return 1; /* most common case */\n while (isspace(cast(unsigned char, *endptr))) endptr++;\n if (*endptr != '\\0') return 0; /* invalid trailing characters? */\n return 1;\n}\n\n\n\nstatic void pushstr (lua_State *L, const char *str) {\n setsvalue2s(L, L->top, luaS_new(L, str));\n incr_top(L);\n}\n\n\n/* this function handles only `%d', `%c', %f, %p, and `%s' formats */\nconst char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {\n int n = 1;\n pushstr(L, \"\");\n for (;;) {\n const char *e = strchr(fmt, '%');\n if (e == NULL) break;\n setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));\n incr_top(L);\n switch (*(e+1)) {\n case 's': {\n const char *s = va_arg(argp, char *);\n if (s == NULL) s = \"(null)\";\n pushstr(L, s);\n break;\n }\n case 'c': {\n char buff[2];\n buff[0] = cast(char, va_arg(argp, int));\n buff[1] = '\\0';\n pushstr(L, buff);\n break;\n }\n case 'd': {\n setnvalue(L->top, cast_num(va_arg(argp, int)));\n incr_top(L);\n break;\n }\n case 'f': {\n setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));\n incr_top(L);\n break;\n }\n case 'p': {\n char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */\n sprintf(buff, \"%p\", va_arg(argp, void *));\n pushstr(L, buff);\n break;\n }\n case '%': {\n pushstr(L, \"%\");\n break;\n }\n default: {\n char buff[3];\n buff[0] = '%';\n buff[1] = *(e+1);\n buff[2] = '\\0';\n pushstr(L, buff);\n break;\n }\n }\n n += 2;\n fmt = e+2;\n }\n pushstr(L, fmt);\n luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);\n L->top -= n;\n return svalue(L->top - 1);\n}\n\n\nconst char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {\n const char *msg;\n va_list argp;\n va_start(argp, fmt);\n msg = luaO_pushvfstring(L, fmt, argp);\n va_end(argp);\n return msg;\n}\n\n\nvoid luaO_chunkid (char *out, const char *source, size_t bufflen) {\n if (*source == '=') {\n strncpy(out, source+1, bufflen); /* remove first char */\n out[bufflen-1] = '\\0'; /* ensures null termination */\n }\n else { /* out = \"source\", or \"...source\" */\n if (*source == '@') {\n size_t l;\n source++; /* skip the `@' */\n bufflen -= sizeof(\" '...' \");\n l = strlen(source);\n strcpy(out, \"\");\n if (l > bufflen) {\n source += (l-bufflen); /* get last part of file name */\n strcat(out, \"...\");\n }\n strcat(out, source);\n }\n else { /* out = [string \"string\"] */\n size_t len = strcspn(source, \"\\n\\r\"); /* stop at first newline */\n bufflen -= sizeof(\" [string \\\"...\\\"] \");\n if (len > bufflen) len = bufflen;\n strcpy(out, \"[string \\\"\");\n if (source[len] != '\\0') { /* must truncate? */\n strncat(out, source, len);\n strcat(out, \"...\");\n }\n else\n strcat(out, source);\n strcat(out, \"\\\"]\");\n }\n }\n}\n" }, { "path": "deps/lua/src/lobject.h", "content": "/*\n** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $\n** Type definitions for Lua objects\n** See Copyright Notice in lua.h\n*/\n\n\n#ifndef lobject_h\n#define lobject_h\n\n\n#include \n\n\n#include \"llimits.h\"\n#include \"lua.h\"\n\n\n/* tags for values visible from Lua */\n#define LAST_TAG\tLUA_TTHREAD\n\n#define NUM_TAGS\t(LAST_TAG+1)\n\n\n/*\n** Extra tags for non-values\n*/\n#define LUA_TPROTO\t(LAST_TAG+1)\n#define LUA_TUPVAL\t(LAST_TAG+2)\n#define LUA_TDEADKEY\t(LAST_TAG+3)\n\n\n/*\n** Union of all collectable objects\n*/\ntypedef union GCObject GCObject;\n\n\n/*\n** Common Header for all collectable objects (in macro form, to be\n** included in other objects)\n*/\n#define CommonHeader\tGCObject *next; lu_byte tt; lu_byte marked\n\n\n/*\n** Common header in struct form\n*/\ntypedef struct GCheader {\n CommonHeader;\n} GCheader;\n\n\n\n\n/*\n** Union of all Lua values\n*/\ntypedef union {\n GCObject *gc;\n void *p;\n lua_Number n;\n int b;\n} Value;\n\n\n/*\n** Tagged Values\n*/\n\n#define TValuefields\tValue value; int tt\n\ntypedef struct lua_TValue {\n TValuefields;\n} TValue;\n\n\n/* Macros to test type */\n#define ttisnil(o)\t(ttype(o) == LUA_TNIL)\n#define ttisnumber(o)\t(ttype(o) == LUA_TNUMBER)\n#define ttisstring(o)\t(ttype(o) == LUA_TSTRING)\n#define ttistable(o)\t(ttype(o) == LUA_TTABLE)\n#define ttisfunction(o)\t(ttype(o) == LUA_TFUNCTION)\n#define ttisboolean(o)\t(ttype(o) == LUA_TBOOLEAN)\n#define ttisuserdata(o)\t(ttype(o) == LUA_TUSERDATA)\n#define ttisthread(o)\t(ttype(o) == LUA_TTHREAD)\n#define ttislightuserdata(o)\t(ttype(o) == LUA_TLIGHTUSERDATA)\n\n/* Macros to access values */\n#define ttype(o)\t((o)->tt)\n#define gcvalue(o)\tcheck_exp(iscollectable(o), (o)->value.gc)\n#define pvalue(o)\tcheck_exp(ttislightuserdata(o), (o)->value.p)\n#define nvalue(o)\tcheck_exp(ttisnumber(o), (o)->value.n)\n#define rawtsvalue(o)\tcheck_exp(ttisstring(o), &(o)->value.gc->ts)\n#define tsvalue(o)\t(&rawtsvalue(o)->tsv)\n#define rawuvalue(o)\tcheck_exp(ttisuserdata(o), &(o)->value.gc->u)\n#define uvalue(o)\t(&rawuvalue(o)->uv)\n#define clvalue(o)\tcheck_exp(ttisfunction(o), &(o)->value.gc->cl)\n#define hvalue(o)\tcheck_exp(ttistable(o), &(o)->value.gc->h)\n#define bvalue(o)\tcheck_exp(ttisboolean(o), (o)->value.b)\n#define thvalue(o)\tcheck_exp(ttisthread(o), &(o)->value.gc->th)\n\n#define l_isfalse(o)\t(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))\n\n/*\n** for internal debug only\n*/\n#define checkconsistency(obj) \\\n lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))\n\n#define checkliveness(g,obj) \\\n lua_assert(!iscollectable(obj) || \\\n ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))\n\n\n/* Macros to set values */\n#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)\n\n#define setnvalue(obj,x) \\\n { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }\n\n#define setpvalue(obj,x) \\\n { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }\n\n#define setbvalue(obj,x) \\\n { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }\n\n#define setsvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \\\n checkliveness(G(L),i_o); }\n\n#define setuvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \\\n checkliveness(G(L),i_o); }\n\n#define setthvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \\\n checkliveness(G(L),i_o); }\n\n#define setclvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \\\n checkliveness(G(L),i_o); }\n\n#define sethvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \\\n checkliveness(G(L),i_o); }\n\n#define setptvalue(L,obj,x) \\\n { TValue *i_o=(obj); \\\n i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \\\n checkliveness(G(L),i_o); }\n\n\n\n\n#define setobj(L,obj1,obj2) \\\n { const TValue *o2=(obj2); TValue *o1=(obj1); \\\n o1->value = o2->value; o1->tt=o2->tt; \\\n checkliveness(G(L),o1); }\n\n\n/*\n** different types of sets, according to destination\n*/\n\n/* from stack to (same) stack */\n#define setobjs2s\tsetobj\n/* to stack (not from same stack) */\n#define setobj2s\tsetobj\n#define setsvalue2s\tsetsvalue\n#define sethvalue2s\tsethvalue\n#define setptvalue2s\tsetptvalue\n/* from table to same table */\n#define setobjt2t\tsetobj\n/* to table */\n#define setobj2t\tsetobj\n/* to new object */\n#define setobj2n\tsetobj\n#define setsvalue2n\tsetsvalue\n\n#define setttype(obj, tt) (ttype(obj) = (tt))\n\n\n#define iscollectable(o)\t(ttype(o) >= LUA_TSTRING)\n\n\n\ntypedef TValue *StkId; /* index to stack elements */\n\n\n/*\n** String headers for string table\n*/\ntypedef union TString {\n L_Umaxalign dummy; /* ensures maximum alignment for strings */\n struct {\n CommonHeader;\n lu_byte reserved;\n unsigned int hash;\n size_t len;\n } tsv;\n} TString;\n\n\n#define getstr(ts)\tcast(const char *, (ts) + 1)\n#define svalue(o) getstr(rawtsvalue(o))\n\n\n\ntypedef union Udata {\n L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */\n struct {\n CommonHeader;\n struct Table *metatable;\n struct Table *env;\n size_t len;\n } uv;\n} Udata;\n\n\n\n\n/*\n** Function Prototypes\n*/\ntypedef struct Proto {\n CommonHeader;\n TValue *k; /* constants used by the function */\n Instruction *code;\n struct Proto **p; /* functions defined inside the function */\n int *lineinfo; /* map from opcodes to source lines */\n struct LocVar *locvars; /* information about local variables */\n TString **upvalues; /* upvalue names */\n TString *source;\n int sizeupvalues;\n int sizek; /* size of `k' */\n int sizecode;\n int sizelineinfo;\n int sizep; /* size of `p' */\n int sizelocvars;\n int linedefined;\n int lastlinedefined;\n GCObject *gclist;\n lu_byte nups; /* number of upvalues */\n lu_byte numparams;\n lu_byte is_vararg;\n lu_byte maxstacksize;\n} Proto;\n\n\n/* masks for new-style vararg */\n#define VARARG_HASARG\t\t1\n#define VARARG_ISVARARG\t\t2\n#define VARARG_NEEDSARG\t\t4\n\n\ntypedef struct LocVar {\n TString *varname;\n int startpc; /* first point where variable is active */\n int endpc; /* first point where variable is dead */\n} LocVar;\n\n\n\n/*\n** Upvalues\n*/\n\ntypedef struct UpVal {\n CommonHeader;\n TValue *v; /* points to stack or to its own value */\n union {\n TValue value; /* the value (when closed) */\n struct { /* double linked list (when open) */\n struct UpVal *prev;\n struct UpVal *next;\n } l;\n } u;\n} UpVal;\n\n\n/*\n** Closures\n*/\n\n#define ClosureHeader \\\n\tCommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \\\n\tstruct Table *env\n\ntypedef struct CClosure {\n ClosureHeader;\n lua_CFunction f;\n TValue upvalue[1];\n} CClosure;\n\n\ntypedef struct LClosure {\n ClosureHeader;\n struct Proto *p;\n UpVal *upvals[1];\n} LClosure;\n\n\ntypedef union Closure {\n CClosure c;\n LClosure l;\n} Closure;\n\n\n#define iscfunction(o)\t(ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)\n#define isLfunction(o)\t(ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)\n\n\n/*\n** Tables\n*/\n\ntypedef union TKey {\n struct {\n TValuefields;\n struct Node *next; /* for chaining */\n } nk;\n TValue tvk;\n} TKey;\n\n\ntypedef struct Node {\n TValue i_val;\n TKey i_key;\n} Node;\n\n\ntypedef struct Table {\n CommonHeader;\n lu_byte flags; /* 1<

lsizenode))\n\n\n#define luaO_nilobject\t\t(&luaO_nilobject_)\n\nLUAI_DATA const TValue luaO_nilobject_;\n\n#define ceillog2(x)\t(luaO_log2((x)-1) + 1)\n\nLUAI_FUNC int luaO_log2 (unsigned int x);\nLUAI_FUNC int luaO_int2fb (unsigned int x);\nLUAI_FUNC int luaO_fb2int (int x);\nLUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);\nLUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);\nLUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,\n va_list argp);\nLUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);\nLUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);\n\n\n#endif\n\n" }, { "path": "deps/lua/src/lopcodes.c", "content": "/*\n** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $\n** See Copyright Notice in lua.h\n*/\n\n\n#define lopcodes_c\n#define LUA_CORE\n\n\n#include \"lopcodes.h\"\n\n\n/* ORDER OP */\n\nconst char *const luaP_opnames[NUM_OPCODES+1] = {\n \"MOVE\",\n \"LOADK\",\n \"LOADBOOL\",\n \"LOADNIL\",\n \"GETUPVAL\",\n \"GETGLOBAL\",\n \"GETTABLE\",\n \"SETGLOBAL\",\n \"SETUPVAL\",\n \"SETTABLE\",\n \"NEWTABLE\",\n \"SELF\",\n \"ADD\",\n \"SUB\",\n \"MUL\",\n \"DIV\",\n \"MOD\",\n \"POW\",\n \"UNM\",\n \"NOT\",\n \"LEN\",\n \"CONCAT\",\n \"JMP\",\n \"EQ\",\n \"LT\",\n \"LE\",\n \"TEST\",\n \"TESTSET\",\n \"CALL\",\n \"TAILCALL\",\n \"RETURN\",\n \"FORLOOP\",\n \"FORPREP\",\n \"TFORLOOP\",\n \"SETLIST\",\n \"CLOSE\",\n \"CLOSURE\",\n \"VARARG\",\n NULL\n};\n\n\n#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))\n\nconst lu_byte luaP_opmodes[NUM_OPCODES] = {\n/* T A B C mode\t\t opcode\t*/\n opmode(0, 1, OpArgR, OpArgN, iABC) \t\t/* OP_MOVE */\n ,opmode(0, 1, OpArgK, OpArgN, iABx)\t\t/* OP_LOADK */\n ,opmode(0, 1, OpArgU, OpArgU, iABC)\t\t/* OP_LOADBOOL */\n ,opmode(0, 1, OpArgR, OpArgN, iABC)\t\t/* OP_LOADNIL */\n ,opmode(0, 1, OpArgU, OpArgN, iABC)\t\t/* OP_GETUPVAL */\n ,opmode(0, 1, OpArgK, OpArgN, iABx)\t\t/* OP_GETGLOBAL */\n ,opmode(0, 1, OpArgR, OpArgK, iABC)\t\t/* OP_GETTABLE */\n ,opmode(0, 0, OpArgK, OpArgN, iABx)\t\t/* OP_SETGLOBAL */\n ,opmode(0, 0, OpArgU, OpArgN, iABC)\t\t/* OP_SETUPVAL */\n ,opmode(0, 0, OpArgK, OpArgK, iABC)\t\t/* OP_SETTABLE */\n ,opmode(0, 1, OpArgU, OpArgU, iABC)\t\t/* OP_NEWTABLE */\n ,opmode(0, 1, OpArgR, OpArgK, iABC)\t\t/* OP_SELF */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_ADD */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_SUB */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_MUL */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_DIV */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_MOD */\n ,opmode(0, 1, OpArgK, OpArgK, iABC)\t\t/* OP_POW */\n ,opmode(0, 1, OpArgR, OpArgN, iABC)\t\t/* OP_UNM */\n ,opmode(0, 1, OpArgR, OpArgN, iABC)\t\t/* OP_NOT */\n ,opmode(0, 1, OpArgR, OpArgN, iABC)\t\t/* OP_LEN */\n ,opmode(0, 1, OpArgR, OpArgR, iABC)\t\t/* OP_CONCAT */\n ,opmode(0, 0, OpArgR, OpArgN, iAsBx)\t\t/* OP_JMP */\n ,opmode(1, 0, OpArgK, OpArgK, iABC)\t\t/* OP_EQ */\n ,opmode(1, 0, OpArgK, OpArgK, iABC)\t\t/* OP_LT */\n ,opmode(1, 0, OpArgK, OpArgK, iABC)\t\t/* OP_LE */\n ,opmode(1, 1, OpArgR, OpArgU, iABC)\t\t/* OP_TEST */\n ,opmode(1, 1, OpArgR, OpArgU, iABC)\t\t/* OP_TESTSET */\n ,opmode(0, 1, OpArgU, OpArgU, iABC)\t\t/* OP_CALL */\n ,opmode(0, 1, OpArgU, OpArgU, iABC)\t\t/* OP_TAILCALL */\n ,opmode(0, 0, OpArgU, OpArgN, iABC)\t\t/* OP_RETURN */\n ,opmode(0, 1, OpArgR, OpArgN, iAsBx)\t\t/* OP_FORLOOP */\n ,opmode(0, 1, OpArgR, OpArgN, iAsBx)\t\t/* OP_FORPREP */\n ,opmode(1, 0, OpArgN, OpArgU, iABC)\t\t/* OP_TFORLOOP */\n ,opmode(0, 0, OpArgU, OpArgU, iABC)\t\t/* OP_SETLIST */\n ,opmode(0, 0, OpArgN, OpArgN, iABC)\t\t/* OP_CLOSE */\n ,opmode(0, 1, OpArgU, OpArgN, iABx)\t\t/* OP_CLOSURE */\n ,opmode(0, 1, OpArgU, OpArgN, iABC)\t\t/* OP_VARARG */\n};\n\n" }, { "path": "deps/lua/src/lopcodes.h", "content": "/*\n** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $\n** Opcodes for Lua virtual machine\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lopcodes_h\n#define lopcodes_h\n\n#include \"llimits.h\"\n\n\n/*===========================================================================\n We assume that instructions are unsigned numbers.\n All instructions have an opcode in the first 6 bits.\n Instructions can have the following fields:\n\t`A' : 8 bits\n\t`B' : 9 bits\n\t`C' : 9 bits\n\t`Bx' : 18 bits (`B' and `C' together)\n\t`sBx' : signed Bx\n\n A signed argument is represented in excess K; that is, the number\n value is the unsigned value minus K. K is exactly the maximum value\n for that argument (so that -max is represented by 0, and +max is\n represented by 2*max), which is half the maximum for the corresponding\n unsigned argument.\n===========================================================================*/\n\n\nenum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */\n\n\n/*\n** size and position of opcode arguments.\n*/\n#define SIZE_C\t\t9\n#define SIZE_B\t\t9\n#define SIZE_Bx\t\t(SIZE_C + SIZE_B)\n#define SIZE_A\t\t8\n\n#define SIZE_OP\t\t6\n\n#define POS_OP\t\t0\n#define POS_A\t\t(POS_OP + SIZE_OP)\n#define POS_C\t\t(POS_A + SIZE_A)\n#define POS_B\t\t(POS_C + SIZE_C)\n#define POS_Bx\t\tPOS_C\n\n\n/*\n** limits for opcode arguments.\n** we use (signed) int to manipulate most arguments,\n** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)\n*/\n#if SIZE_Bx < LUAI_BITSINT-1\n#define MAXARG_Bx ((1<>1) /* `sBx' is signed */\n#else\n#define MAXARG_Bx MAX_INT\n#define MAXARG_sBx MAX_INT\n#endif\n\n\n#define MAXARG_A ((1<>POS_OP) & MASK1(SIZE_OP,0)))\n#define SET_OPCODE(i,o)\t((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \\\n\t\t((cast(Instruction, o)<>POS_A) & MASK1(SIZE_A,0)))\n#define SETARG_A(i,u)\t((i) = (((i)&MASK0(SIZE_A,POS_A)) | \\\n\t\t((cast(Instruction, u)<>POS_B) & MASK1(SIZE_B,0)))\n#define SETARG_B(i,b)\t((i) = (((i)&MASK0(SIZE_B,POS_B)) | \\\n\t\t((cast(Instruction, b)<>POS_C) & MASK1(SIZE_C,0)))\n#define SETARG_C(i,b)\t((i) = (((i)&MASK0(SIZE_C,POS_C)) | \\\n\t\t((cast(Instruction, b)<>POS_Bx) & MASK1(SIZE_Bx,0)))\n#define SETARG_Bx(i,b)\t((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \\\n\t\t((cast(Instruction, b)< C) then pc++\t\t\t*/ \nOP_TESTSET,/*\tA B C\tif (R(B) <=> C) then R(A) := R(B) else pc++\t*/ \n\nOP_CALL,/*\tA B C\tR(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */\nOP_TAILCALL,/*\tA B C\treturn R(A)(R(A+1), ... ,R(A+B-1))\t\t*/\nOP_RETURN,/*\tA B\treturn R(A), ... ,R(A+B-2)\t(see note)\t*/\n\nOP_FORLOOP,/*\tA sBx\tR(A)+=R(A+2);\n\t\t\tif R(A) =) R(A)*/\nOP_CLOSURE,/*\tA Bx\tR(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))\t*/\n\nOP_VARARG/*\tA B\tR(A), R(A+1), ..., R(A+B-1) = vararg\t\t*/\n} OpCode;\n\n\n#define NUM_OPCODES\t(cast(int, OP_VARARG) + 1)\n\n\n\n/*===========================================================================\n Notes:\n (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,\n and can be 0: OP_CALL then sets `top' to last_result+1, so\n next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.\n\n (*) In OP_VARARG, if (B == 0) then use actual number of varargs and\n set top (like in OP_CALL with C == 0).\n\n (*) In OP_RETURN, if (B == 0) then return up to `top'\n\n (*) In OP_SETLIST, if (B == 0) then B = `top';\n if (C == 0) then next `instruction' is real C\n\n (*) For comparisons, A specifies what condition the test should accept\n (true or false).\n\n (*) All `skips' (pc++) assume that next instruction is a jump\n===========================================================================*/\n\n\n/*\n** masks for instruction properties. The format is:\n** bits 0-1: op mode\n** bits 2-3: C arg mode\n** bits 4-5: B arg mode\n** bit 6: instruction set register A\n** bit 7: operator is a test\n*/ \n\nenum OpArgMask {\n OpArgN, /* argument is not used */\n OpArgU, /* argument is used */\n OpArgR, /* argument is a register or a jump offset */\n OpArgK /* argument is a constant or register/constant */\n};\n\nLUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];\n\n#define getOpMode(m)\t(cast(enum OpMode, luaP_opmodes[m] & 3))\n#define getBMode(m)\t(cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))\n#define getCMode(m)\t(cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))\n#define testAMode(m)\t(luaP_opmodes[m] & (1 << 6))\n#define testTMode(m)\t(luaP_opmodes[m] & (1 << 7))\n\n\nLUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */\n\n\n/* number of list items to accumulate before a SETLIST instruction */\n#define LFIELDS_PER_FLUSH\t50\n\n\n#endif\n" }, { "path": "deps/lua/src/loslib.c", "content": "/*\n** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $\n** Standard Operating System library\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n#include \n\n#define loslib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\nstatic int os_pushresult (lua_State *L, int i, const char *filename) {\n int en = errno; /* calls to Lua API may change this value */\n if (i) {\n lua_pushboolean(L, 1);\n return 1;\n }\n else {\n lua_pushnil(L);\n lua_pushfstring(L, \"%s: %s\", filename, strerror(en));\n lua_pushinteger(L, en);\n return 3;\n }\n}\n\n\nstatic int os_execute (lua_State *L) {\n lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));\n return 1;\n}\n\n\nstatic int os_remove (lua_State *L) {\n const char *filename = luaL_checkstring(L, 1);\n return os_pushresult(L, remove(filename) == 0, filename);\n}\n\n\nstatic int os_rename (lua_State *L) {\n const char *fromname = luaL_checkstring(L, 1);\n const char *toname = luaL_checkstring(L, 2);\n return os_pushresult(L, rename(fromname, toname) == 0, fromname);\n}\n\n\nstatic int os_tmpname (lua_State *L) {\n char buff[LUA_TMPNAMBUFSIZE];\n int err;\n lua_tmpnam(buff, err);\n if (err)\n return luaL_error(L, \"unable to generate a unique filename\");\n lua_pushstring(L, buff);\n return 1;\n}\n\n\nstatic int os_getenv (lua_State *L) {\n lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */\n return 1;\n}\n\n\nstatic int os_clock (lua_State *L) {\n lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);\n return 1;\n}\n\n\n/*\n** {======================================================\n** Time/Date operations\n** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,\n** wday=%w+1, yday=%j, isdst=? }\n** =======================================================\n*/\n\nstatic void setfield (lua_State *L, const char *key, int value) {\n lua_pushinteger(L, value);\n lua_setfield(L, -2, key);\n}\n\nstatic void setboolfield (lua_State *L, const char *key, int value) {\n if (value < 0) /* undefined? */\n return; /* does not set field */\n lua_pushboolean(L, value);\n lua_setfield(L, -2, key);\n}\n\nstatic int getboolfield (lua_State *L, const char *key) {\n int res;\n lua_getfield(L, -1, key);\n res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);\n lua_pop(L, 1);\n return res;\n}\n\n\nstatic int getfield (lua_State *L, const char *key, int d) {\n int res;\n lua_getfield(L, -1, key);\n if (lua_isnumber(L, -1))\n res = (int)lua_tointeger(L, -1);\n else {\n if (d < 0)\n return luaL_error(L, \"field \" LUA_QS \" missing in date table\", key);\n res = d;\n }\n lua_pop(L, 1);\n return res;\n}\n\n\nstatic int os_date (lua_State *L) {\n const char *s = luaL_optstring(L, 1, \"%c\");\n time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));\n struct tm *stm;\n if (*s == '!') { /* UTC? */\n stm = gmtime(&t);\n s++; /* skip `!' */\n }\n else\n stm = localtime(&t);\n if (stm == NULL) /* invalid date? */\n lua_pushnil(L);\n else if (strcmp(s, \"*t\") == 0) {\n lua_createtable(L, 0, 9); /* 9 = number of fields */\n setfield(L, \"sec\", stm->tm_sec);\n setfield(L, \"min\", stm->tm_min);\n setfield(L, \"hour\", stm->tm_hour);\n setfield(L, \"day\", stm->tm_mday);\n setfield(L, \"month\", stm->tm_mon+1);\n setfield(L, \"year\", stm->tm_year+1900);\n setfield(L, \"wday\", stm->tm_wday+1);\n setfield(L, \"yday\", stm->tm_yday+1);\n setboolfield(L, \"isdst\", stm->tm_isdst);\n }\n else {\n char cc[3];\n luaL_Buffer b;\n cc[0] = '%'; cc[2] = '\\0';\n luaL_buffinit(L, &b);\n for (; *s; s++) {\n if (*s != '%' || *(s + 1) == '\\0') /* no conversion specifier? */\n luaL_addchar(&b, *s);\n else {\n size_t reslen;\n char buff[200]; /* should be big enough for any conversion result */\n cc[1] = *(++s);\n reslen = strftime(buff, sizeof(buff), cc, stm);\n luaL_addlstring(&b, buff, reslen);\n }\n }\n luaL_pushresult(&b);\n }\n return 1;\n}\n\n\nstatic int os_time (lua_State *L) {\n time_t t;\n if (lua_isnoneornil(L, 1)) /* called without args? */\n t = time(NULL); /* get current time */\n else {\n struct tm ts;\n luaL_checktype(L, 1, LUA_TTABLE);\n lua_settop(L, 1); /* make sure table is at the top */\n ts.tm_sec = getfield(L, \"sec\", 0);\n ts.tm_min = getfield(L, \"min\", 0);\n ts.tm_hour = getfield(L, \"hour\", 12);\n ts.tm_mday = getfield(L, \"day\", -1);\n ts.tm_mon = getfield(L, \"month\", -1) - 1;\n ts.tm_year = getfield(L, \"year\", -1) - 1900;\n ts.tm_isdst = getboolfield(L, \"isdst\");\n t = mktime(&ts);\n }\n if (t == (time_t)(-1))\n lua_pushnil(L);\n else\n lua_pushnumber(L, (lua_Number)t);\n return 1;\n}\n\n\nstatic int os_difftime (lua_State *L) {\n lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),\n (time_t)(luaL_optnumber(L, 2, 0))));\n return 1;\n}\n\n/* }====================================================== */\n\n\nstatic int os_setlocale (lua_State *L) {\n static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,\n LC_NUMERIC, LC_TIME};\n static const char *const catnames[] = {\"all\", \"collate\", \"ctype\", \"monetary\",\n \"numeric\", \"time\", NULL};\n const char *l = luaL_optstring(L, 1, NULL);\n int op = luaL_checkoption(L, 2, \"all\", catnames);\n lua_pushstring(L, setlocale(cat[op], l));\n return 1;\n}\n\n\nstatic int os_exit (lua_State *L) {\n exit(luaL_optint(L, 1, EXIT_SUCCESS));\n}\n\nstatic const luaL_Reg syslib[] = {\n {\"clock\", os_clock},\n {\"date\", os_date},\n {\"difftime\", os_difftime},\n {\"execute\", os_execute},\n {\"exit\", os_exit},\n {\"getenv\", os_getenv},\n {\"remove\", os_remove},\n {\"rename\", os_rename},\n {\"setlocale\", os_setlocale},\n {\"time\", os_time},\n {\"tmpname\", os_tmpname},\n {NULL, NULL}\n};\n\n/* }====================================================== */\n\n#define UNUSED(V) ((void) V)\n\n/* Only a subset is loaded currently, for sandboxing concerns. */\nstatic const luaL_Reg sandbox_syslib[] = {\n {\"clock\", os_clock},\n {NULL, NULL}\n};\n\nLUALIB_API int luaopen_os (lua_State *L) {\n UNUSED(syslib);\n luaL_register(L, LUA_OSLIBNAME, sandbox_syslib);\n return 1;\n}\n\n" }, { "path": "deps/lua/src/lparser.c", "content": "/*\n** $Id: lparser.c,v 2.42.1.4 2011/10/21 19:31:42 roberto Exp $\n** Lua Parser\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lparser_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lcode.h\"\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"llex.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lparser.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n\n\n\n#define hasmultret(k)\t\t((k) == VCALL || (k) == VVARARG)\n\n#define getlocvar(fs, i)\t((fs)->f->locvars[(fs)->actvar[i]])\n\n#define luaY_checklimit(fs,v,l,m)\tif ((v)>(l)) errorlimit(fs,l,m)\n\n\n/*\n** nodes for block list (list of active blocks)\n*/\ntypedef struct BlockCnt {\n struct BlockCnt *previous; /* chain */\n int breaklist; /* list of jumps out of this loop */\n lu_byte nactvar; /* # active locals outside the breakable structure */\n lu_byte upval; /* true if some variable in the block is an upvalue */\n lu_byte isbreakable; /* true if `block' is a loop */\n} BlockCnt;\n\n\n\n/*\n** prototypes for recursive non-terminal functions\n*/\nstatic void chunk (LexState *ls);\nstatic void expr (LexState *ls, expdesc *v);\n\n\nstatic void anchor_token (LexState *ls) {\n if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {\n TString *ts = ls->t.seminfo.ts;\n luaX_newstring(ls, getstr(ts), ts->tsv.len);\n }\n}\n\n\nstatic void error_expected (LexState *ls, int token) {\n luaX_syntaxerror(ls,\n luaO_pushfstring(ls->L, LUA_QS \" expected\", luaX_token2str(ls, token)));\n}\n\n\nstatic void errorlimit (FuncState *fs, int limit, const char *what) {\n const char *msg = (fs->f->linedefined == 0) ?\n luaO_pushfstring(fs->L, \"main function has more than %d %s\", limit, what) :\n luaO_pushfstring(fs->L, \"function at line %d has more than %d %s\",\n fs->f->linedefined, limit, what);\n luaX_lexerror(fs->ls, msg, 0);\n}\n\n\nstatic int testnext (LexState *ls, int c) {\n if (ls->t.token == c) {\n luaX_next(ls);\n return 1;\n }\n else return 0;\n}\n\n\nstatic void check (LexState *ls, int c) {\n if (ls->t.token != c)\n error_expected(ls, c);\n}\n\nstatic void checknext (LexState *ls, int c) {\n check(ls, c);\n luaX_next(ls);\n}\n\n\n#define check_condition(ls,c,msg)\t{ if (!(c)) luaX_syntaxerror(ls, msg); }\n\n\n\nstatic void check_match (LexState *ls, int what, int who, int where) {\n if (!testnext(ls, what)) {\n if (where == ls->linenumber)\n error_expected(ls, what);\n else {\n luaX_syntaxerror(ls, luaO_pushfstring(ls->L,\n LUA_QS \" expected (to close \" LUA_QS \" at line %d)\",\n luaX_token2str(ls, what), luaX_token2str(ls, who), where));\n }\n }\n}\n\n\nstatic TString *str_checkname (LexState *ls) {\n TString *ts;\n check(ls, TK_NAME);\n ts = ls->t.seminfo.ts;\n luaX_next(ls);\n return ts;\n}\n\n\nstatic void init_exp (expdesc *e, expkind k, int i) {\n e->f = e->t = NO_JUMP;\n e->k = k;\n e->u.s.info = i;\n}\n\n\nstatic void codestring (LexState *ls, expdesc *e, TString *s) {\n init_exp(e, VK, luaK_stringK(ls->fs, s));\n}\n\n\nstatic void checkname(LexState *ls, expdesc *e) {\n codestring(ls, e, str_checkname(ls));\n}\n\n\nstatic int registerlocalvar (LexState *ls, TString *varname) {\n FuncState *fs = ls->fs;\n Proto *f = fs->f;\n int oldsize = f->sizelocvars;\n luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,\n LocVar, SHRT_MAX, \"too many local variables\");\n while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;\n f->locvars[fs->nlocvars].varname = varname;\n luaC_objbarrier(ls->L, f, varname);\n return fs->nlocvars++;\n}\n\n\n#define new_localvarliteral(ls,v,n) \\\n new_localvar(ls, luaX_newstring(ls, \"\" v, (sizeof(v)/sizeof(char))-1), n)\n\n\nstatic void new_localvar (LexState *ls, TString *name, int n) {\n FuncState *fs = ls->fs;\n luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, \"local variables\");\n fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));\n}\n\n\nstatic void adjustlocalvars (LexState *ls, int nvars) {\n FuncState *fs = ls->fs;\n fs->nactvar = cast_byte(fs->nactvar + nvars);\n for (; nvars; nvars--) {\n getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;\n }\n}\n\n\nstatic void removevars (LexState *ls, int tolevel) {\n FuncState *fs = ls->fs;\n while (fs->nactvar > tolevel)\n getlocvar(fs, --fs->nactvar).endpc = fs->pc;\n}\n\n\nstatic int indexupvalue (FuncState *fs, TString *name, expdesc *v) {\n int i;\n Proto *f = fs->f;\n int oldsize = f->sizeupvalues;\n for (i=0; inups; i++) {\n if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {\n lua_assert(f->upvalues[i] == name);\n return i;\n }\n }\n /* new one */\n luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, \"upvalues\");\n luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,\n TString *, MAX_INT, \"\");\n while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;\n f->upvalues[f->nups] = name;\n luaC_objbarrier(fs->L, f, name);\n lua_assert(v->k == VLOCAL || v->k == VUPVAL);\n fs->upvalues[f->nups].k = cast_byte(v->k);\n fs->upvalues[f->nups].info = cast_byte(v->u.s.info);\n return f->nups++;\n}\n\n\nstatic int searchvar (FuncState *fs, TString *n) {\n int i;\n for (i=fs->nactvar-1; i >= 0; i--) {\n if (n == getlocvar(fs, i).varname)\n return i;\n }\n return -1; /* not found */\n}\n\n\nstatic void markupval (FuncState *fs, int level) {\n BlockCnt *bl = fs->bl;\n while (bl && bl->nactvar > level) bl = bl->previous;\n if (bl) bl->upval = 1;\n}\n\n\nstatic int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {\n if (fs == NULL) { /* no more levels? */\n init_exp(var, VGLOBAL, NO_REG); /* default is global variable */\n return VGLOBAL;\n }\n else {\n int v = searchvar(fs, n); /* look up at current level */\n if (v >= 0) {\n init_exp(var, VLOCAL, v);\n if (!base)\n markupval(fs, v); /* local will be used as an upval */\n return VLOCAL;\n }\n else { /* not found at current level; try upper one */\n if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)\n return VGLOBAL;\n var->u.s.info = indexupvalue(fs, n, var); /* else was LOCAL or UPVAL */\n var->k = VUPVAL; /* upvalue in this level */\n return VUPVAL;\n }\n }\n}\n\n\nstatic void singlevar (LexState *ls, expdesc *var) {\n TString *varname = str_checkname(ls);\n FuncState *fs = ls->fs;\n if (singlevaraux(fs, varname, var, 1) == VGLOBAL)\n var->u.s.info = luaK_stringK(fs, varname); /* info points to global name */\n}\n\n\nstatic void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {\n FuncState *fs = ls->fs;\n int extra = nvars - nexps;\n if (hasmultret(e->k)) {\n extra++; /* includes call itself */\n if (extra < 0) extra = 0;\n luaK_setreturns(fs, e, extra); /* last exp. provides the difference */\n if (extra > 1) luaK_reserveregs(fs, extra-1);\n }\n else {\n if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */\n if (extra > 0) {\n int reg = fs->freereg;\n luaK_reserveregs(fs, extra);\n luaK_nil(fs, reg, extra);\n }\n }\n}\n\n\nstatic void enterlevel (LexState *ls) {\n if (++ls->L->nCcalls > LUAI_MAXCCALLS)\n\tluaX_lexerror(ls, \"chunk has too many syntax levels\", 0);\n}\n\n\n#define leavelevel(ls)\t((ls)->L->nCcalls--)\n\n\nstatic void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {\n bl->breaklist = NO_JUMP;\n bl->isbreakable = isbreakable;\n bl->nactvar = fs->nactvar;\n bl->upval = 0;\n bl->previous = fs->bl;\n fs->bl = bl;\n lua_assert(fs->freereg == fs->nactvar);\n}\n\n\nstatic void leaveblock (FuncState *fs) {\n BlockCnt *bl = fs->bl;\n fs->bl = bl->previous;\n removevars(fs->ls, bl->nactvar);\n if (bl->upval)\n luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);\n /* a block either controls scope or breaks (never both) */\n lua_assert(!bl->isbreakable || !bl->upval);\n lua_assert(bl->nactvar == fs->nactvar);\n fs->freereg = fs->nactvar; /* free registers */\n luaK_patchtohere(fs, bl->breaklist);\n}\n\n\nstatic void pushclosure (LexState *ls, FuncState *func, expdesc *v) {\n FuncState *fs = ls->fs;\n Proto *f = fs->f;\n int oldsize = f->sizep;\n int i;\n luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,\n MAXARG_Bx, \"constant table overflow\");\n while (oldsize < f->sizep) f->p[oldsize++] = NULL;\n f->p[fs->np++] = func->f;\n luaC_objbarrier(ls->L, f, func->f);\n init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));\n for (i=0; if->nups; i++) {\n OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;\n luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);\n }\n}\n\n\nstatic void open_func (LexState *ls, FuncState *fs) {\n lua_State *L = ls->L;\n Proto *f = luaF_newproto(L);\n fs->f = f;\n fs->prev = ls->fs; /* linked list of funcstates */\n fs->ls = ls;\n fs->L = L;\n ls->fs = fs;\n fs->pc = 0;\n fs->lasttarget = -1;\n fs->jpc = NO_JUMP;\n fs->freereg = 0;\n fs->nk = 0;\n fs->np = 0;\n fs->nlocvars = 0;\n fs->nactvar = 0;\n fs->bl = NULL;\n f->source = ls->source;\n f->maxstacksize = 2; /* registers 0/1 are always valid */\n fs->h = luaH_new(L, 0, 0);\n /* anchor table of constants and prototype (to avoid being collected) */\n sethvalue2s(L, L->top, fs->h);\n incr_top(L);\n setptvalue2s(L, L->top, f);\n incr_top(L);\n}\n\n\nstatic void close_func (LexState *ls) {\n lua_State *L = ls->L;\n FuncState *fs = ls->fs;\n Proto *f = fs->f;\n removevars(ls, 0);\n luaK_ret(fs, 0, 0); /* final return */\n luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);\n f->sizecode = fs->pc;\n luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);\n f->sizelineinfo = fs->pc;\n luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);\n f->sizek = fs->nk;\n luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);\n f->sizep = fs->np;\n luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);\n f->sizelocvars = fs->nlocvars;\n luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);\n f->sizeupvalues = f->nups;\n lua_assert(luaG_checkcode(f));\n lua_assert(fs->bl == NULL);\n ls->fs = fs->prev;\n /* last token read was anchored in defunct function; must reanchor it */\n if (fs) anchor_token(ls);\n L->top -= 2; /* remove table and prototype from the stack */\n}\n\n\nProto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {\n struct LexState lexstate;\n struct FuncState funcstate;\n lexstate.buff = buff;\n TString *tname = luaS_new(L, name);\n setsvalue2s(L, L->top, tname);\n incr_top(L);\n luaX_setinput(L, &lexstate, z, tname);\n open_func(&lexstate, &funcstate);\n funcstate.f->is_vararg = VARARG_ISVARARG; /* main func. is always vararg */\n luaX_next(&lexstate); /* read first token */\n chunk(&lexstate);\n check(&lexstate, TK_EOS);\n close_func(&lexstate);\n --L->top;\n lua_assert(funcstate.prev == NULL);\n lua_assert(funcstate.f->nups == 0);\n lua_assert(lexstate.fs == NULL);\n return funcstate.f;\n}\n\n\n\n/*============================================================*/\n/* GRAMMAR RULES */\n/*============================================================*/\n\n\nstatic void field (LexState *ls, expdesc *v) {\n /* field -> ['.' | ':'] NAME */\n FuncState *fs = ls->fs;\n expdesc key;\n luaK_exp2anyreg(fs, v);\n luaX_next(ls); /* skip the dot or colon */\n checkname(ls, &key);\n luaK_indexed(fs, v, &key);\n}\n\n\nstatic void yindex (LexState *ls, expdesc *v) {\n /* index -> '[' expr ']' */\n luaX_next(ls); /* skip the '[' */\n expr(ls, v);\n luaK_exp2val(ls->fs, v);\n checknext(ls, ']');\n}\n\n\n/*\n** {======================================================================\n** Rules for Constructors\n** =======================================================================\n*/\n\n\nstruct ConsControl {\n expdesc v; /* last list item read */\n expdesc *t; /* table descriptor */\n int nh; /* total number of `record' elements */\n int na; /* total number of array elements */\n int tostore; /* number of array elements pending to be stored */\n};\n\n\nstatic void recfield (LexState *ls, struct ConsControl *cc) {\n /* recfield -> (NAME | `['exp1`]') = exp1 */\n FuncState *fs = ls->fs;\n int reg = ls->fs->freereg;\n expdesc key, val;\n int rkkey;\n if (ls->t.token == TK_NAME) {\n luaY_checklimit(fs, cc->nh, MAX_INT, \"items in a constructor\");\n checkname(ls, &key);\n }\n else /* ls->t.token == '[' */\n yindex(ls, &key);\n cc->nh++;\n checknext(ls, '=');\n rkkey = luaK_exp2RK(fs, &key);\n expr(ls, &val);\n luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));\n fs->freereg = reg; /* free registers */\n}\n\n\nstatic void closelistfield (FuncState *fs, struct ConsControl *cc) {\n if (cc->v.k == VVOID) return; /* there is no list item */\n luaK_exp2nextreg(fs, &cc->v);\n cc->v.k = VVOID;\n if (cc->tostore == LFIELDS_PER_FLUSH) {\n luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore); /* flush */\n cc->tostore = 0; /* no more items pending */\n }\n}\n\n\nstatic void lastlistfield (FuncState *fs, struct ConsControl *cc) {\n if (cc->tostore == 0) return;\n if (hasmultret(cc->v.k)) {\n luaK_setmultret(fs, &cc->v);\n luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);\n cc->na--; /* do not count last expression (unknown number of elements) */\n }\n else {\n if (cc->v.k != VVOID)\n luaK_exp2nextreg(fs, &cc->v);\n luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);\n }\n}\n\n\nstatic void listfield (LexState *ls, struct ConsControl *cc) {\n expr(ls, &cc->v);\n luaY_checklimit(ls->fs, cc->na, MAX_INT, \"items in a constructor\");\n cc->na++;\n cc->tostore++;\n}\n\n\nstatic void constructor (LexState *ls, expdesc *t) {\n /* constructor -> ?? */\n FuncState *fs = ls->fs;\n int line = ls->linenumber;\n int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);\n struct ConsControl cc;\n cc.na = cc.nh = cc.tostore = 0;\n cc.t = t;\n init_exp(t, VRELOCABLE, pc);\n init_exp(&cc.v, VVOID, 0); /* no value (yet) */\n luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */\n checknext(ls, '{');\n do {\n lua_assert(cc.v.k == VVOID || cc.tostore > 0);\n if (ls->t.token == '}') break;\n closelistfield(fs, &cc);\n switch(ls->t.token) {\n case TK_NAME: { /* may be listfields or recfields */\n luaX_lookahead(ls);\n if (ls->lookahead.token != '=') /* expression? */\n listfield(ls, &cc);\n else\n recfield(ls, &cc);\n break;\n }\n case '[': { /* constructor_item -> recfield */\n recfield(ls, &cc);\n break;\n }\n default: { /* constructor_part -> listfield */\n listfield(ls, &cc);\n break;\n }\n }\n } while (testnext(ls, ',') || testnext(ls, ';'));\n check_match(ls, '}', '{', line);\n lastlistfield(fs, &cc);\n SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */\n SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */\n}\n\n/* }====================================================================== */\n\n\n\nstatic void parlist (LexState *ls) {\n /* parlist -> [ param { `,' param } ] */\n FuncState *fs = ls->fs;\n Proto *f = fs->f;\n int nparams = 0;\n f->is_vararg = 0;\n if (ls->t.token != ')') { /* is `parlist' not empty? */\n do {\n switch (ls->t.token) {\n case TK_NAME: { /* param -> NAME */\n new_localvar(ls, str_checkname(ls), nparams++);\n break;\n }\n case TK_DOTS: { /* param -> `...' */\n luaX_next(ls);\n#if defined(LUA_COMPAT_VARARG)\n /* use `arg' as default name */\n new_localvarliteral(ls, \"arg\", nparams++);\n f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;\n#endif\n f->is_vararg |= VARARG_ISVARARG;\n break;\n }\n default: luaX_syntaxerror(ls, \" or \" LUA_QL(\"...\") \" expected\");\n }\n } while (!f->is_vararg && testnext(ls, ','));\n }\n adjustlocalvars(ls, nparams);\n f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));\n luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */\n}\n\n\nstatic void body (LexState *ls, expdesc *e, int needself, int line) {\n /* body -> `(' parlist `)' chunk END */\n FuncState new_fs;\n open_func(ls, &new_fs);\n new_fs.f->linedefined = line;\n checknext(ls, '(');\n if (needself) {\n new_localvarliteral(ls, \"self\", 0);\n adjustlocalvars(ls, 1);\n }\n parlist(ls);\n checknext(ls, ')');\n chunk(ls);\n new_fs.f->lastlinedefined = ls->linenumber;\n check_match(ls, TK_END, TK_FUNCTION, line);\n close_func(ls);\n pushclosure(ls, &new_fs, e);\n}\n\n\nstatic int explist1 (LexState *ls, expdesc *v) {\n /* explist1 -> expr { `,' expr } */\n int n = 1; /* at least one expression */\n expr(ls, v);\n while (testnext(ls, ',')) {\n luaK_exp2nextreg(ls->fs, v);\n expr(ls, v);\n n++;\n }\n return n;\n}\n\n\nstatic void funcargs (LexState *ls, expdesc *f) {\n FuncState *fs = ls->fs;\n expdesc args;\n int base, nparams;\n int line = ls->linenumber;\n switch (ls->t.token) {\n case '(': { /* funcargs -> `(' [ explist1 ] `)' */\n if (line != ls->lastline)\n luaX_syntaxerror(ls,\"ambiguous syntax (function call x new statement)\");\n luaX_next(ls);\n if (ls->t.token == ')') /* arg list is empty? */\n args.k = VVOID;\n else {\n explist1(ls, &args);\n luaK_setmultret(fs, &args);\n }\n check_match(ls, ')', '(', line);\n break;\n }\n case '{': { /* funcargs -> constructor */\n constructor(ls, &args);\n break;\n }\n case TK_STRING: { /* funcargs -> STRING */\n codestring(ls, &args, ls->t.seminfo.ts);\n luaX_next(ls); /* must use `seminfo' before `next' */\n break;\n }\n default: {\n luaX_syntaxerror(ls, \"function arguments expected\");\n return;\n }\n }\n lua_assert(f->k == VNONRELOC);\n base = f->u.s.info; /* base register for call */\n if (hasmultret(args.k))\n nparams = LUA_MULTRET; /* open call */\n else {\n if (args.k != VVOID)\n luaK_exp2nextreg(fs, &args); /* close last argument */\n nparams = fs->freereg - (base+1);\n }\n init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));\n luaK_fixline(fs, line);\n fs->freereg = base+1; /* call remove function and arguments and leaves\n (unless changed) one result */\n}\n\n\n\n\n/*\n** {======================================================================\n** Expression parsing\n** =======================================================================\n*/\n\n\nstatic void prefixexp (LexState *ls, expdesc *v) {\n /* prefixexp -> NAME | '(' expr ')' */\n switch (ls->t.token) {\n case '(': {\n int line = ls->linenumber;\n luaX_next(ls);\n expr(ls, v);\n check_match(ls, ')', '(', line);\n luaK_dischargevars(ls->fs, v);\n return;\n }\n case TK_NAME: {\n singlevar(ls, v);\n return;\n }\n default: {\n luaX_syntaxerror(ls, \"unexpected symbol\");\n return;\n }\n }\n}\n\n\nstatic void primaryexp (LexState *ls, expdesc *v) {\n /* primaryexp ->\n prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */\n FuncState *fs = ls->fs;\n prefixexp(ls, v);\n for (;;) {\n switch (ls->t.token) {\n case '.': { /* field */\n field(ls, v);\n break;\n }\n case '[': { /* `[' exp1 `]' */\n expdesc key;\n luaK_exp2anyreg(fs, v);\n yindex(ls, &key);\n luaK_indexed(fs, v, &key);\n break;\n }\n case ':': { /* `:' NAME funcargs */\n expdesc key;\n luaX_next(ls);\n checkname(ls, &key);\n luaK_self(fs, v, &key);\n funcargs(ls, v);\n break;\n }\n case '(': case TK_STRING: case '{': { /* funcargs */\n luaK_exp2nextreg(fs, v);\n funcargs(ls, v);\n break;\n }\n default: return;\n }\n }\n}\n\n\nstatic void simpleexp (LexState *ls, expdesc *v) {\n /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |\n constructor | FUNCTION body | primaryexp */\n switch (ls->t.token) {\n case TK_NUMBER: {\n init_exp(v, VKNUM, 0);\n v->u.nval = ls->t.seminfo.r;\n break;\n }\n case TK_STRING: {\n codestring(ls, v, ls->t.seminfo.ts);\n break;\n }\n case TK_NIL: {\n init_exp(v, VNIL, 0);\n break;\n }\n case TK_TRUE: {\n init_exp(v, VTRUE, 0);\n break;\n }\n case TK_FALSE: {\n init_exp(v, VFALSE, 0);\n break;\n }\n case TK_DOTS: { /* vararg */\n FuncState *fs = ls->fs;\n check_condition(ls, fs->f->is_vararg,\n \"cannot use \" LUA_QL(\"...\") \" outside a vararg function\");\n fs->f->is_vararg &= ~VARARG_NEEDSARG; /* don't need 'arg' */\n init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));\n break;\n }\n case '{': { /* constructor */\n constructor(ls, v);\n return;\n }\n case TK_FUNCTION: {\n luaX_next(ls);\n body(ls, v, 0, ls->linenumber);\n return;\n }\n default: {\n primaryexp(ls, v);\n return;\n }\n }\n luaX_next(ls);\n}\n\n\nstatic UnOpr getunopr (int op) {\n switch (op) {\n case TK_NOT: return OPR_NOT;\n case '-': return OPR_MINUS;\n case '#': return OPR_LEN;\n default: return OPR_NOUNOPR;\n }\n}\n\n\nstatic BinOpr getbinopr (int op) {\n switch (op) {\n case '+': return OPR_ADD;\n case '-': return OPR_SUB;\n case '*': return OPR_MUL;\n case '/': return OPR_DIV;\n case '%': return OPR_MOD;\n case '^': return OPR_POW;\n case TK_CONCAT: return OPR_CONCAT;\n case TK_NE: return OPR_NE;\n case TK_EQ: return OPR_EQ;\n case '<': return OPR_LT;\n case TK_LE: return OPR_LE;\n case '>': return OPR_GT;\n case TK_GE: return OPR_GE;\n case TK_AND: return OPR_AND;\n case TK_OR: return OPR_OR;\n default: return OPR_NOBINOPR;\n }\n}\n\n\nstatic const struct {\n lu_byte left; /* left priority for each binary operator */\n lu_byte right; /* right priority */\n} priority[] = { /* ORDER OPR */\n {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `/' `%' */\n {10, 9}, {5, 4}, /* power and concat (right associative) */\n {3, 3}, {3, 3}, /* equality and inequality */\n {3, 3}, {3, 3}, {3, 3}, {3, 3}, /* order */\n {2, 2}, {1, 1} /* logical (and/or) */\n};\n\n#define UNARY_PRIORITY\t8 /* priority for unary operators */\n\n\n/*\n** subexpr -> (simpleexp | unop subexpr) { binop subexpr }\n** where `binop' is any binary operator with a priority higher than `limit'\n*/\nstatic BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {\n BinOpr op;\n UnOpr uop;\n enterlevel(ls);\n uop = getunopr(ls->t.token);\n if (uop != OPR_NOUNOPR) {\n luaX_next(ls);\n subexpr(ls, v, UNARY_PRIORITY);\n luaK_prefix(ls->fs, uop, v);\n }\n else simpleexp(ls, v);\n /* expand while operators have priorities higher than `limit' */\n op = getbinopr(ls->t.token);\n while (op != OPR_NOBINOPR && priority[op].left > limit) {\n expdesc v2;\n BinOpr nextop;\n luaX_next(ls);\n luaK_infix(ls->fs, op, v);\n /* read sub-expression with higher priority */\n nextop = subexpr(ls, &v2, priority[op].right);\n luaK_posfix(ls->fs, op, v, &v2);\n op = nextop;\n }\n leavelevel(ls);\n return op; /* return first untreated operator */\n}\n\n\nstatic void expr (LexState *ls, expdesc *v) {\n subexpr(ls, v, 0);\n}\n\n/* }==================================================================== */\n\n\n\n/*\n** {======================================================================\n** Rules for Statements\n** =======================================================================\n*/\n\n\nstatic int block_follow (int token) {\n switch (token) {\n case TK_ELSE: case TK_ELSEIF: case TK_END:\n case TK_UNTIL: case TK_EOS:\n return 1;\n default: return 0;\n }\n}\n\n\nstatic void block (LexState *ls) {\n /* block -> chunk */\n FuncState *fs = ls->fs;\n BlockCnt bl;\n enterblock(fs, &bl, 0);\n chunk(ls);\n lua_assert(bl.breaklist == NO_JUMP);\n leaveblock(fs);\n}\n\n\n/*\n** structure to chain all variables in the left-hand side of an\n** assignment\n*/\nstruct LHS_assign {\n struct LHS_assign *prev;\n expdesc v; /* variable (global, local, upvalue, or indexed) */\n};\n\n\n/*\n** check whether, in an assignment to a local variable, the local variable\n** is needed in a previous assignment (to a table). If so, save original\n** local value in a safe place and use this safe copy in the previous\n** assignment.\n*/\nstatic void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {\n FuncState *fs = ls->fs;\n int extra = fs->freereg; /* eventual position to save local variable */\n int conflict = 0;\n for (; lh; lh = lh->prev) {\n if (lh->v.k == VINDEXED) {\n if (lh->v.u.s.info == v->u.s.info) { /* conflict? */\n conflict = 1;\n lh->v.u.s.info = extra; /* previous assignment will use safe copy */\n }\n if (lh->v.u.s.aux == v->u.s.info) { /* conflict? */\n conflict = 1;\n lh->v.u.s.aux = extra; /* previous assignment will use safe copy */\n }\n }\n }\n if (conflict) {\n luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0); /* make copy */\n luaK_reserveregs(fs, 1);\n }\n}\n\n\nstatic void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {\n expdesc e;\n check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,\n \"syntax error\");\n if (testnext(ls, ',')) { /* assignment -> `,' primaryexp assignment */\n struct LHS_assign nv;\n nv.prev = lh;\n primaryexp(ls, &nv.v);\n if (nv.v.k == VLOCAL)\n check_conflict(ls, lh, &nv.v);\n luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,\n \"variables in assignment\");\n assignment(ls, &nv, nvars+1);\n }\n else { /* assignment -> `=' explist1 */\n int nexps;\n checknext(ls, '=');\n nexps = explist1(ls, &e);\n if (nexps != nvars) {\n adjust_assign(ls, nvars, nexps, &e);\n if (nexps > nvars)\n ls->fs->freereg -= nexps - nvars; /* remove extra values */\n }\n else {\n luaK_setoneret(ls->fs, &e); /* close last expression */\n luaK_storevar(ls->fs, &lh->v, &e);\n return; /* avoid default */\n }\n }\n init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */\n luaK_storevar(ls->fs, &lh->v, &e);\n}\n\n\nstatic int cond (LexState *ls) {\n /* cond -> exp */\n expdesc v;\n expr(ls, &v); /* read condition */\n if (v.k == VNIL) v.k = VFALSE; /* `falses' are all equal here */\n luaK_goiftrue(ls->fs, &v);\n return v.f;\n}\n\n\nstatic void breakstat (LexState *ls) {\n FuncState *fs = ls->fs;\n BlockCnt *bl = fs->bl;\n int upval = 0;\n while (bl && !bl->isbreakable) {\n upval |= bl->upval;\n bl = bl->previous;\n }\n if (!bl)\n luaX_syntaxerror(ls, \"no loop to break\");\n if (upval)\n luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);\n luaK_concat(fs, &bl->breaklist, luaK_jump(fs));\n}\n\n\nstatic void whilestat (LexState *ls, int line) {\n /* whilestat -> WHILE cond DO block END */\n FuncState *fs = ls->fs;\n int whileinit;\n int condexit;\n BlockCnt bl;\n luaX_next(ls); /* skip WHILE */\n whileinit = luaK_getlabel(fs);\n condexit = cond(ls);\n enterblock(fs, &bl, 1);\n checknext(ls, TK_DO);\n block(ls);\n luaK_patchlist(fs, luaK_jump(fs), whileinit);\n check_match(ls, TK_END, TK_WHILE, line);\n leaveblock(fs);\n luaK_patchtohere(fs, condexit); /* false conditions finish the loop */\n}\n\n\nstatic void repeatstat (LexState *ls, int line) {\n /* repeatstat -> REPEAT block UNTIL cond */\n int condexit;\n FuncState *fs = ls->fs;\n int repeat_init = luaK_getlabel(fs);\n BlockCnt bl1, bl2;\n enterblock(fs, &bl1, 1); /* loop block */\n enterblock(fs, &bl2, 0); /* scope block */\n luaX_next(ls); /* skip REPEAT */\n chunk(ls);\n check_match(ls, TK_UNTIL, TK_REPEAT, line);\n condexit = cond(ls); /* read condition (inside scope block) */\n if (!bl2.upval) { /* no upvalues? */\n leaveblock(fs); /* finish scope */\n luaK_patchlist(ls->fs, condexit, repeat_init); /* close the loop */\n }\n else { /* complete semantics when there are upvalues */\n breakstat(ls); /* if condition then break */\n luaK_patchtohere(ls->fs, condexit); /* else... */\n leaveblock(fs); /* finish scope... */\n luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init); /* and repeat */\n }\n leaveblock(fs); /* finish loop */\n}\n\n\nstatic int exp1 (LexState *ls) {\n expdesc e;\n int k;\n expr(ls, &e);\n k = e.k;\n luaK_exp2nextreg(ls->fs, &e);\n return k;\n}\n\n\nstatic void forbody (LexState *ls, int base, int line, int nvars, int isnum) {\n /* forbody -> DO block */\n BlockCnt bl;\n FuncState *fs = ls->fs;\n int prep, endfor;\n adjustlocalvars(ls, 3); /* control variables */\n checknext(ls, TK_DO);\n prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);\n enterblock(fs, &bl, 0); /* scope for declared variables */\n adjustlocalvars(ls, nvars);\n luaK_reserveregs(fs, nvars);\n block(ls);\n leaveblock(fs); /* end of scope for declared variables */\n luaK_patchtohere(fs, prep);\n endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :\n luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);\n luaK_fixline(fs, line); /* pretend that `OP_FOR' starts the loop */\n luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);\n}\n\n\nstatic void fornum (LexState *ls, TString *varname, int line) {\n /* fornum -> NAME = exp1,exp1[,exp1] forbody */\n FuncState *fs = ls->fs;\n int base = fs->freereg;\n new_localvarliteral(ls, \"(for index)\", 0);\n new_localvarliteral(ls, \"(for limit)\", 1);\n new_localvarliteral(ls, \"(for step)\", 2);\n new_localvar(ls, varname, 3);\n checknext(ls, '=');\n exp1(ls); /* initial value */\n checknext(ls, ',');\n exp1(ls); /* limit */\n if (testnext(ls, ','))\n exp1(ls); /* optional step */\n else { /* default step = 1 */\n luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));\n luaK_reserveregs(fs, 1);\n }\n forbody(ls, base, line, 1, 1);\n}\n\n\nstatic void forlist (LexState *ls, TString *indexname) {\n /* forlist -> NAME {,NAME} IN explist1 forbody */\n FuncState *fs = ls->fs;\n expdesc e;\n int nvars = 0;\n int line;\n int base = fs->freereg;\n /* create control variables */\n new_localvarliteral(ls, \"(for generator)\", nvars++);\n new_localvarliteral(ls, \"(for state)\", nvars++);\n new_localvarliteral(ls, \"(for control)\", nvars++);\n /* create declared variables */\n new_localvar(ls, indexname, nvars++);\n while (testnext(ls, ','))\n new_localvar(ls, str_checkname(ls), nvars++);\n checknext(ls, TK_IN);\n line = ls->linenumber;\n adjust_assign(ls, 3, explist1(ls, &e), &e);\n luaK_checkstack(fs, 3); /* extra space to call generator */\n forbody(ls, base, line, nvars - 3, 0);\n}\n\n\nstatic void forstat (LexState *ls, int line) {\n /* forstat -> FOR (fornum | forlist) END */\n FuncState *fs = ls->fs;\n TString *varname;\n BlockCnt bl;\n enterblock(fs, &bl, 1); /* scope for loop and control variables */\n luaX_next(ls); /* skip `for' */\n varname = str_checkname(ls); /* first variable name */\n switch (ls->t.token) {\n case '=': fornum(ls, varname, line); break;\n case ',': case TK_IN: forlist(ls, varname); break;\n default: luaX_syntaxerror(ls, LUA_QL(\"=\") \" or \" LUA_QL(\"in\") \" expected\");\n }\n check_match(ls, TK_END, TK_FOR, line);\n leaveblock(fs); /* loop scope (`break' jumps to this point) */\n}\n\n\nstatic int test_then_block (LexState *ls) {\n /* test_then_block -> [IF | ELSEIF] cond THEN block */\n int condexit;\n luaX_next(ls); /* skip IF or ELSEIF */\n condexit = cond(ls);\n checknext(ls, TK_THEN);\n block(ls); /* `then' part */\n return condexit;\n}\n\n\nstatic void ifstat (LexState *ls, int line) {\n /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */\n FuncState *fs = ls->fs;\n int flist;\n int escapelist = NO_JUMP;\n flist = test_then_block(ls); /* IF cond THEN block */\n while (ls->t.token == TK_ELSEIF) {\n luaK_concat(fs, &escapelist, luaK_jump(fs));\n luaK_patchtohere(fs, flist);\n flist = test_then_block(ls); /* ELSEIF cond THEN block */\n }\n if (ls->t.token == TK_ELSE) {\n luaK_concat(fs, &escapelist, luaK_jump(fs));\n luaK_patchtohere(fs, flist);\n luaX_next(ls); /* skip ELSE (after patch, for correct line info) */\n block(ls); /* `else' part */\n }\n else\n luaK_concat(fs, &escapelist, flist);\n luaK_patchtohere(fs, escapelist);\n check_match(ls, TK_END, TK_IF, line);\n}\n\n\nstatic void localfunc (LexState *ls) {\n expdesc v, b;\n FuncState *fs = ls->fs;\n new_localvar(ls, str_checkname(ls), 0);\n init_exp(&v, VLOCAL, fs->freereg);\n luaK_reserveregs(fs, 1);\n adjustlocalvars(ls, 1);\n body(ls, &b, 0, ls->linenumber);\n luaK_storevar(fs, &v, &b);\n /* debug information will only see the variable after this point! */\n getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;\n}\n\n\nstatic void localstat (LexState *ls) {\n /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */\n int nvars = 0;\n int nexps;\n expdesc e;\n do {\n new_localvar(ls, str_checkname(ls), nvars++);\n } while (testnext(ls, ','));\n if (testnext(ls, '='))\n nexps = explist1(ls, &e);\n else {\n e.k = VVOID;\n nexps = 0;\n }\n adjust_assign(ls, nvars, nexps, &e);\n adjustlocalvars(ls, nvars);\n}\n\n\nstatic int funcname (LexState *ls, expdesc *v) {\n /* funcname -> NAME {field} [`:' NAME] */\n int needself = 0;\n singlevar(ls, v);\n while (ls->t.token == '.')\n field(ls, v);\n if (ls->t.token == ':') {\n needself = 1;\n field(ls, v);\n }\n return needself;\n}\n\n\nstatic void funcstat (LexState *ls, int line) {\n /* funcstat -> FUNCTION funcname body */\n int needself;\n expdesc v, b;\n luaX_next(ls); /* skip FUNCTION */\n needself = funcname(ls, &v);\n body(ls, &b, needself, line);\n luaK_storevar(ls->fs, &v, &b);\n luaK_fixline(ls->fs, line); /* definition `happens' in the first line */\n}\n\n\nstatic void exprstat (LexState *ls) {\n /* stat -> func | assignment */\n FuncState *fs = ls->fs;\n struct LHS_assign v;\n primaryexp(ls, &v.v);\n if (v.v.k == VCALL) /* stat -> func */\n SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */\n else { /* stat -> assignment */\n v.prev = NULL;\n assignment(ls, &v, 1);\n }\n}\n\n\nstatic void retstat (LexState *ls) {\n /* stat -> RETURN explist */\n FuncState *fs = ls->fs;\n expdesc e;\n int first, nret; /* registers with returned values */\n luaX_next(ls); /* skip RETURN */\n if (block_follow(ls->t.token) || ls->t.token == ';')\n first = nret = 0; /* return no values */\n else {\n nret = explist1(ls, &e); /* optional return values */\n if (hasmultret(e.k)) {\n luaK_setmultret(fs, &e);\n if (e.k == VCALL && nret == 1) { /* tail call? */\n SET_OPCODE(getcode(fs,&e), OP_TAILCALL);\n lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);\n }\n first = fs->nactvar;\n nret = LUA_MULTRET; /* return all values */\n }\n else {\n if (nret == 1) /* only one single value? */\n first = luaK_exp2anyreg(fs, &e);\n else {\n luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */\n first = fs->nactvar; /* return all `active' values */\n lua_assert(nret == fs->freereg - first);\n }\n }\n }\n luaK_ret(fs, first, nret);\n}\n\n\nstatic int statement (LexState *ls) {\n int line = ls->linenumber; /* may be needed for error messages */\n switch (ls->t.token) {\n case TK_IF: { /* stat -> ifstat */\n ifstat(ls, line);\n return 0;\n }\n case TK_WHILE: { /* stat -> whilestat */\n whilestat(ls, line);\n return 0;\n }\n case TK_DO: { /* stat -> DO block END */\n luaX_next(ls); /* skip DO */\n block(ls);\n check_match(ls, TK_END, TK_DO, line);\n return 0;\n }\n case TK_FOR: { /* stat -> forstat */\n forstat(ls, line);\n return 0;\n }\n case TK_REPEAT: { /* stat -> repeatstat */\n repeatstat(ls, line);\n return 0;\n }\n case TK_FUNCTION: {\n funcstat(ls, line); /* stat -> funcstat */\n return 0;\n }\n case TK_LOCAL: { /* stat -> localstat */\n luaX_next(ls); /* skip LOCAL */\n if (testnext(ls, TK_FUNCTION)) /* local function? */\n localfunc(ls);\n else\n localstat(ls);\n return 0;\n }\n case TK_RETURN: { /* stat -> retstat */\n retstat(ls);\n return 1; /* must be last statement */\n }\n case TK_BREAK: { /* stat -> breakstat */\n luaX_next(ls); /* skip BREAK */\n breakstat(ls);\n return 1; /* must be last statement */\n }\n default: {\n exprstat(ls);\n return 0; /* to avoid warnings */\n }\n }\n}\n\n\nstatic void chunk (LexState *ls) {\n /* chunk -> { stat [`;'] } */\n int islast = 0;\n enterlevel(ls);\n while (!islast && !block_follow(ls->t.token)) {\n islast = statement(ls);\n testnext(ls, ';');\n lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&\n ls->fs->freereg >= ls->fs->nactvar);\n ls->fs->freereg = ls->fs->nactvar; /* free registers */\n }\n leavelevel(ls);\n}\n\n/* }====================================================================== */\n" }, { "path": "deps/lua/src/lparser.h", "content": "/*\n** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $\n** Lua Parser\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lparser_h\n#define lparser_h\n\n#include \"llimits.h\"\n#include \"lobject.h\"\n#include \"lzio.h\"\n\n\n/*\n** Expression descriptor\n*/\n\ntypedef enum {\n VVOID,\t/* no value */\n VNIL,\n VTRUE,\n VFALSE,\n VK,\t\t/* info = index of constant in `k' */\n VKNUM,\t/* nval = numerical value */\n VLOCAL,\t/* info = local register */\n VUPVAL, /* info = index of upvalue in `upvalues' */\n VGLOBAL,\t/* info = index of table; aux = index of global name in `k' */\n VINDEXED,\t/* info = table register; aux = index register (or `k') */\n VJMP,\t\t/* info = instruction pc */\n VRELOCABLE,\t/* info = instruction pc */\n VNONRELOC,\t/* info = result register */\n VCALL,\t/* info = instruction pc */\n VVARARG\t/* info = instruction pc */\n} expkind;\n\ntypedef struct expdesc {\n expkind k;\n union {\n struct { int info, aux; } s;\n lua_Number nval;\n } u;\n int t; /* patch list of `exit when true' */\n int f; /* patch list of `exit when false' */\n} expdesc;\n\n\ntypedef struct upvaldesc {\n lu_byte k;\n lu_byte info;\n} upvaldesc;\n\n\nstruct BlockCnt; /* defined in lparser.c */\n\n\n/* state needed to generate code for a given function */\ntypedef struct FuncState {\n Proto *f; /* current function header */\n Table *h; /* table to find (and reuse) elements in `k' */\n struct FuncState *prev; /* enclosing function */\n struct LexState *ls; /* lexical state */\n struct lua_State *L; /* copy of the Lua state */\n struct BlockCnt *bl; /* chain of current blocks */\n int pc; /* next position to code (equivalent to `ncode') */\n int lasttarget; /* `pc' of last `jump target' */\n int jpc; /* list of pending jumps to `pc' */\n int freereg; /* first free register */\n int nk; /* number of elements in `k' */\n int np; /* number of elements in `p' */\n short nlocvars; /* number of elements in `locvars' */\n lu_byte nactvar; /* number of active local variables */\n upvaldesc upvalues[LUAI_MAXUPVALUES]; /* upvalues */\n unsigned short actvar[LUAI_MAXVARS]; /* declared-variable stack */\n} FuncState;\n\n\nLUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,\n const char *name);\n\n\n#endif\n" }, { "path": "deps/lua/src/lstate.c", "content": "/*\n** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $\n** Global State\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lstate_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"llex.h\"\n#include \"lmem.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n\n\n#define state_size(x)\t(sizeof(x) + LUAI_EXTRASPACE)\n#define fromstate(l)\t(cast(lu_byte *, (l)) - LUAI_EXTRASPACE)\n#define tostate(l) (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))\n\n\n/*\n** Main thread combines a thread state and the global state\n*/\ntypedef struct LG {\n lua_State l;\n global_State g;\n} LG;\n \n\n\nstatic void stack_init (lua_State *L1, lua_State *L) {\n /* initialize CallInfo array */\n L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);\n L1->ci = L1->base_ci;\n L1->size_ci = BASIC_CI_SIZE;\n L1->end_ci = L1->base_ci + L1->size_ci - 1;\n /* initialize stack array */\n L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);\n L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;\n L1->top = L1->stack;\n L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;\n /* initialize first ci */\n L1->ci->func = L1->top;\n setnilvalue(L1->top++); /* `function' entry for this `ci' */\n L1->base = L1->ci->base = L1->top;\n L1->ci->top = L1->top + LUA_MINSTACK;\n}\n\n\nstatic void freestack (lua_State *L, lua_State *L1) {\n luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);\n luaM_freearray(L, L1->stack, L1->stacksize, TValue);\n}\n\n\n/*\n** open parts that may cause memory-allocation errors\n*/\nstatic void f_luaopen (lua_State *L, void *ud) {\n global_State *g = G(L);\n UNUSED(ud);\n stack_init(L, L); /* init stack */\n sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */\n sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */\n luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */\n luaT_init(L);\n luaX_init(L);\n luaS_fix(luaS_newliteral(L, MEMERRMSG));\n g->GCthreshold = 4*g->totalbytes;\n}\n\n\nstatic void preinit_state (lua_State *L, global_State *g) {\n G(L) = g;\n L->stack = NULL;\n L->stacksize = 0;\n L->errorJmp = NULL;\n L->hook = NULL;\n L->hookmask = 0;\n L->basehookcount = 0;\n L->allowhook = 1;\n resethookcount(L);\n L->openupval = NULL;\n L->size_ci = 0;\n L->nCcalls = L->baseCcalls = 0;\n L->status = 0;\n L->base_ci = L->ci = NULL;\n L->savedpc = NULL;\n L->errfunc = 0;\n setnilvalue(gt(L));\n}\n\n\nstatic void close_state (lua_State *L) {\n global_State *g = G(L);\n luaF_close(L, L->stack); /* close all upvalues for this thread */\n luaC_freeall(L); /* collect all objects */\n lua_assert(g->rootgc == obj2gco(L));\n lua_assert(g->strt.nuse == 0);\n luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);\n luaZ_freebuffer(L, &g->buff);\n freestack(L, L);\n lua_assert(g->totalbytes == sizeof(LG));\n (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);\n}\n\n\nlua_State *luaE_newthread (lua_State *L) {\n lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));\n luaC_link(L, obj2gco(L1), LUA_TTHREAD);\n preinit_state(L1, G(L));\n stack_init(L1, L); /* init stack */\n setobj2n(L, gt(L1), gt(L)); /* share table of globals */\n L1->hookmask = L->hookmask;\n L1->basehookcount = L->basehookcount;\n L1->hook = L->hook;\n resethookcount(L1);\n lua_assert(iswhite(obj2gco(L1)));\n return L1;\n}\n\n\nvoid luaE_freethread (lua_State *L, lua_State *L1) {\n luaF_close(L1, L1->stack); /* close all upvalues for this thread */\n lua_assert(L1->openupval == NULL);\n luai_userstatefree(L1);\n freestack(L, L1);\n luaM_freemem(L, fromstate(L1), state_size(lua_State));\n}\n\n\nLUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {\n int i;\n lua_State *L;\n global_State *g;\n void *l = (*f)(ud, NULL, 0, state_size(LG));\n if (l == NULL) return NULL;\n L = tostate(l);\n g = &((LG *)L)->g;\n L->next = NULL;\n L->tt = LUA_TTHREAD;\n g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);\n L->marked = luaC_white(g);\n set2bits(L->marked, FIXEDBIT, SFIXEDBIT);\n preinit_state(L, g);\n g->frealloc = f;\n g->ud = ud;\n g->mainthread = L;\n g->uvhead.u.l.prev = &g->uvhead;\n g->uvhead.u.l.next = &g->uvhead;\n g->GCthreshold = 0; /* mark it as unfinished state */\n g->strt.size = 0;\n g->strt.nuse = 0;\n g->strt.hash = NULL;\n setnilvalue(registry(L));\n luaZ_initbuffer(L, &g->buff);\n g->panic = NULL;\n g->gcstate = GCSpause;\n g->rootgc = obj2gco(L);\n g->sweepstrgc = 0;\n g->sweepgc = &g->rootgc;\n g->gray = NULL;\n g->grayagain = NULL;\n g->weak = NULL;\n g->tmudata = NULL;\n g->totalbytes = sizeof(LG);\n g->gcpause = LUAI_GCPAUSE;\n g->gcstepmul = LUAI_GCMUL;\n g->gcdept = 0;\n for (i=0; imt[i] = NULL;\n if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {\n /* memory allocation error: free partial state */\n close_state(L);\n L = NULL;\n }\n else\n luai_userstateopen(L);\n return L;\n}\n\n\nstatic void callallgcTM (lua_State *L, void *ud) {\n UNUSED(ud);\n luaC_callGCTM(L); /* call GC metamethods for all udata */\n}\n\n\nLUA_API void lua_close (lua_State *L) {\n L = G(L)->mainthread; /* only the main thread can be closed */\n lua_lock(L);\n luaF_close(L, L->stack); /* close all upvalues for this thread */\n luaC_separateudata(L, 1); /* separate udata that have GC metamethods */\n L->errfunc = 0; /* no error function during GC metamethods */\n do { /* repeat until no more errors */\n L->ci = L->base_ci;\n L->base = L->top = L->ci->base;\n L->nCcalls = L->baseCcalls = 0;\n } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);\n lua_assert(G(L)->tmudata == NULL);\n luai_userstateclose(L);\n close_state(L);\n}\n\n" }, { "path": "deps/lua/src/lstate.h", "content": "/*\n** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $\n** Global State\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lstate_h\n#define lstate_h\n\n#include \"lua.h\"\n\n#include \"lobject.h\"\n#include \"ltm.h\"\n#include \"lzio.h\"\n\n\n\nstruct lua_longjmp; /* defined in ldo.c */\n\n\n/* table of globals */\n#define gt(L)\t(&L->l_gt)\n\n/* registry */\n#define registry(L)\t(&G(L)->l_registry)\n\n\n/* extra stack space to handle TM calls and some other extras */\n#define EXTRA_STACK 5\n\n\n#define BASIC_CI_SIZE 8\n\n#define BASIC_STACK_SIZE (2*LUA_MINSTACK)\n\n\n\ntypedef struct stringtable {\n GCObject **hash;\n lu_int32 nuse; /* number of elements */\n int size;\n} stringtable;\n\n\n/*\n** informations about a call\n*/\ntypedef struct CallInfo {\n StkId base; /* base for this function */\n StkId func; /* function index in the stack */\n StkId\ttop; /* top for this function */\n const Instruction *savedpc;\n int nresults; /* expected number of results from this function */\n int tailcalls; /* number of tail calls lost under this entry */\n} CallInfo;\n\n\n\n#define curr_func(L)\t(clvalue(L->ci->func))\n#define ci_func(ci)\t(clvalue((ci)->func))\n#define f_isLua(ci)\t(!ci_func(ci)->c.isC)\n#define isLua(ci)\t(ttisfunction((ci)->func) && f_isLua(ci))\n\n\n/*\n** `global state', shared by all threads of this state\n*/\ntypedef struct global_State {\n stringtable strt; /* hash table for strings */\n lua_Alloc frealloc; /* function to reallocate memory */\n void *ud; /* auxiliary data to `frealloc' */\n lu_byte currentwhite;\n lu_byte gcstate; /* state of garbage collector */\n int sweepstrgc; /* position of sweep in `strt' */\n GCObject *rootgc; /* list of all collectable objects */\n GCObject **sweepgc; /* position of sweep in `rootgc' */\n GCObject *gray; /* list of gray objects */\n GCObject *grayagain; /* list of objects to be traversed atomically */\n GCObject *weak; /* list of weak tables (to be cleared) */\n GCObject *tmudata; /* last element of list of userdata to be GC */\n Mbuffer buff; /* temporary buffer for string concatentation */\n lu_mem GCthreshold;\n lu_mem totalbytes; /* number of bytes currently allocated */\n lu_mem estimate; /* an estimate of number of bytes actually in use */\n lu_mem gcdept; /* how much GC is `behind schedule' */\n int gcpause; /* size of pause between successive GCs */\n int gcstepmul; /* GC `granularity' */\n lua_CFunction panic; /* to be called in unprotected errors */\n TValue l_registry;\n struct lua_State *mainthread;\n UpVal uvhead; /* head of double-linked list of all open upvalues */\n struct Table *mt[NUM_TAGS]; /* metatables for basic types */\n TString *tmname[TM_N]; /* array with tag-method names */\n} global_State;\n\n\n/*\n** `per thread' state\n*/\nstruct lua_State {\n CommonHeader;\n lu_byte status;\n StkId top; /* first free slot in the stack */\n StkId base; /* base of current function */\n global_State *l_G;\n CallInfo *ci; /* call info for current function */\n const Instruction *savedpc; /* `savedpc' of current function */\n StkId stack_last; /* last free slot in the stack */\n StkId stack; /* stack base */\n CallInfo *end_ci; /* points after end of ci array*/\n CallInfo *base_ci; /* array of CallInfo's */\n int stacksize;\n int size_ci; /* size of array `base_ci' */\n unsigned short nCcalls; /* number of nested C calls */\n unsigned short baseCcalls; /* nested C calls when resuming coroutine */\n lu_byte hookmask;\n lu_byte allowhook;\n int basehookcount;\n int hookcount;\n lua_Hook hook;\n TValue l_gt; /* table of globals */\n TValue env; /* temporary place for environments */\n GCObject *openupval; /* list of open upvalues in this stack */\n GCObject *gclist;\n struct lua_longjmp *errorJmp; /* current error recover point */\n ptrdiff_t errfunc; /* current error handling function (stack index) */\n};\n\n\n#define G(L)\t(L->l_G)\n\n\n/*\n** Union of all collectable objects\n*/\nunion GCObject {\n GCheader gch;\n union TString ts;\n union Udata u;\n union Closure cl;\n struct Table h;\n struct Proto p;\n struct UpVal uv;\n struct lua_State th; /* thread */\n};\n\n\n/* macros to convert a GCObject into a specific value */\n#define rawgco2ts(o)\tcheck_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))\n#define gco2ts(o)\t(&rawgco2ts(o)->tsv)\n#define rawgco2u(o)\tcheck_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))\n#define gco2u(o)\t(&rawgco2u(o)->uv)\n#define gco2cl(o)\tcheck_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))\n#define gco2h(o)\tcheck_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))\n#define gco2p(o)\tcheck_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))\n#define gco2uv(o)\tcheck_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))\n#define ngcotouv(o) \\\n\tcheck_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))\n#define gco2th(o)\tcheck_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))\n\n/* macro to convert any Lua object into a GCObject */\n#define obj2gco(v)\t(cast(GCObject *, (v)))\n\n\nLUAI_FUNC lua_State *luaE_newthread (lua_State *L);\nLUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);\n\n#endif\n\n" }, { "path": "deps/lua/src/lstring.c", "content": "/*\n** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $\n** String table (keeps all strings handled by Lua)\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lstring_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n\n\n\nvoid luaS_resize (lua_State *L, int newsize) {\n GCObject **newhash;\n stringtable *tb;\n int i;\n if (G(L)->gcstate == GCSsweepstring)\n return; /* cannot resize during GC traverse */\n newhash = luaM_newvector(L, newsize, GCObject *);\n tb = &G(L)->strt;\n for (i=0; isize; i++) {\n GCObject *p = tb->hash[i];\n while (p) { /* for each node in the list */\n GCObject *next = p->gch.next; /* save next */\n unsigned int h = gco2ts(p)->hash;\n int h1 = lmod(h, newsize); /* new position */\n lua_assert(cast_int(h%newsize) == lmod(h, newsize));\n p->gch.next = newhash[h1]; /* chain it */\n newhash[h1] = p;\n p = next;\n }\n }\n luaM_freearray(L, tb->hash, tb->size, TString *);\n tb->size = newsize;\n tb->hash = newhash;\n}\n\n\nstatic TString *newlstr (lua_State *L, const char *str, size_t l,\n unsigned int h) {\n TString *ts;\n stringtable *tb;\n if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))\n luaM_toobig(L);\n ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));\n ts->tsv.len = l;\n ts->tsv.hash = h;\n ts->tsv.marked = luaC_white(G(L));\n ts->tsv.tt = LUA_TSTRING;\n ts->tsv.reserved = 0;\n memcpy(ts+1, str, l*sizeof(char));\n ((char *)(ts+1))[l] = '\\0'; /* ending 0 */\n tb = &G(L)->strt;\n h = lmod(h, tb->size);\n ts->tsv.next = tb->hash[h]; /* chain new entry */\n tb->hash[h] = obj2gco(ts);\n tb->nuse++;\n if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)\n luaS_resize(L, tb->size*2); /* too crowded */\n return ts;\n}\n\n\nTString *luaS_newlstr (lua_State *L, const char *str, size_t l) {\n GCObject *o;\n unsigned int h = cast(unsigned int, l); /* seed */\n size_t step = 1;\n size_t l1;\n for (l1=l; l1>=step; l1-=step) /* compute hash */\n h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));\n for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];\n o != NULL;\n o = o->gch.next) {\n TString *ts = rawgco2ts(o);\n if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {\n /* string may be dead */\n if (isdead(G(L), o)) changewhite(o);\n return ts;\n }\n }\n return newlstr(L, str, l, h); /* not found */\n}\n\n\nUdata *luaS_newudata (lua_State *L, size_t s, Table *e) {\n Udata *u;\n if (s > MAX_SIZET - sizeof(Udata))\n luaM_toobig(L);\n u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));\n u->uv.marked = luaC_white(G(L)); /* is not finalized */\n u->uv.tt = LUA_TUSERDATA;\n u->uv.len = s;\n u->uv.metatable = NULL;\n u->uv.env = e;\n /* chain it on udata list (after main thread) */\n u->uv.next = G(L)->mainthread->next;\n G(L)->mainthread->next = obj2gco(u);\n return u;\n}\n\n" }, { "path": "deps/lua/src/lstring.h", "content": "/*\n** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $\n** String table (keep all strings handled by Lua)\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lstring_h\n#define lstring_h\n\n\n#include \"lgc.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n\n\n#define sizestring(s)\t(sizeof(union TString)+((s)->len+1)*sizeof(char))\n\n#define sizeudata(u)\t(sizeof(union Udata)+(u)->len)\n\n#define luaS_new(L, s)\t(luaS_newlstr(L, s, strlen(s)))\n#define luaS_newliteral(L, s)\t(luaS_newlstr(L, \"\" s, \\\n (sizeof(s)/sizeof(char))-1))\n\n#define luaS_fix(s)\tl_setbit((s)->tsv.marked, FIXEDBIT)\n\nLUAI_FUNC void luaS_resize (lua_State *L, int newsize);\nLUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);\nLUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);\n\n\n#endif\n" }, { "path": "deps/lua/src/lstrlib.c", "content": "/*\n** $Id: lstrlib.c,v 1.132.1.5 2010/05/14 15:34:19 roberto Exp $\n** Standard library for string operations and pattern-matching\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n#include \n\n#define lstrlib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n/* macro to `unsign' a character */\n#define uchar(c) ((unsigned char)(c))\n\n\n\nstatic int str_len (lua_State *L) {\n size_t l;\n luaL_checklstring(L, 1, &l);\n lua_pushinteger(L, l);\n return 1;\n}\n\n\nstatic ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {\n /* relative string position: negative means back from end */\n if (pos < 0) pos += (ptrdiff_t)len + 1;\n return (pos >= 0) ? pos : 0;\n}\n\n\nstatic int str_sub (lua_State *L) {\n size_t l;\n const char *s = luaL_checklstring(L, 1, &l);\n ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);\n ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);\n if (start < 1) start = 1;\n if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;\n if (start <= end)\n lua_pushlstring(L, s+start-1, end-start+1);\n else lua_pushliteral(L, \"\");\n return 1;\n}\n\n\nstatic int str_reverse (lua_State *L) {\n size_t l;\n luaL_Buffer b;\n const char *s = luaL_checklstring(L, 1, &l);\n luaL_buffinit(L, &b);\n while (l--) luaL_addchar(&b, s[l]);\n luaL_pushresult(&b);\n return 1;\n}\n\n\nstatic int str_lower (lua_State *L) {\n size_t l;\n size_t i;\n luaL_Buffer b;\n const char *s = luaL_checklstring(L, 1, &l);\n luaL_buffinit(L, &b);\n for (i=0; i 0)\n luaL_addlstring(&b, s, l);\n luaL_pushresult(&b);\n return 1;\n}\n\n\nstatic int str_byte (lua_State *L) {\n size_t l;\n const char *s = luaL_checklstring(L, 1, &l);\n ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);\n ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);\n int n, i;\n if (posi <= 0) posi = 1;\n if ((size_t)pose > l) pose = l;\n if (posi > pose) return 0; /* empty interval; return no values */\n n = (int)(pose - posi + 1);\n if (posi + n <= pose) /* overflow? */\n luaL_error(L, \"string slice too long\");\n luaL_checkstack(L, n, \"string slice too long\");\n for (i=0; i= ms->level || ms->capture[l].len == CAP_UNFINISHED)\n return luaL_error(ms->L, \"invalid capture index\");\n return l;\n}\n\n\nstatic int capture_to_close (MatchState *ms) {\n int level = ms->level;\n for (level--; level>=0; level--)\n if (ms->capture[level].len == CAP_UNFINISHED) return level;\n return luaL_error(ms->L, \"invalid pattern capture\");\n}\n\n\nstatic const char *classend (MatchState *ms, const char *p) {\n switch (*p++) {\n case L_ESC: {\n if (*p == '\\0')\n luaL_error(ms->L, \"malformed pattern (ends with \" LUA_QL(\"%%\") \")\");\n return p+1;\n }\n case '[': {\n if (*p == '^') p++;\n do { /* look for a `]' */\n if (*p == '\\0')\n luaL_error(ms->L, \"malformed pattern (missing \" LUA_QL(\"]\") \")\");\n if (*(p++) == L_ESC && *p != '\\0')\n p++; /* skip escapes (e.g. `%]') */\n } while (*p != ']');\n return p+1;\n }\n default: {\n return p;\n }\n }\n}\n\n\nstatic int match_class (int c, int cl) {\n int res;\n switch (tolower(cl)) {\n case 'a' : res = isalpha(c); break;\n case 'c' : res = iscntrl(c); break;\n case 'd' : res = isdigit(c); break;\n case 'l' : res = islower(c); break;\n case 'p' : res = ispunct(c); break;\n case 's' : res = isspace(c); break;\n case 'u' : res = isupper(c); break;\n case 'w' : res = isalnum(c); break;\n case 'x' : res = isxdigit(c); break;\n case 'z' : res = (c == 0); break;\n default: return (cl == c);\n }\n return (islower(cl) ? res : !res);\n}\n\n\nstatic int matchbracketclass (int c, const char *p, const char *ec) {\n int sig = 1;\n if (*(p+1) == '^') {\n sig = 0;\n p++; /* skip the `^' */\n }\n while (++p < ec) {\n if (*p == L_ESC) {\n p++;\n if (match_class(c, uchar(*p)))\n return sig;\n }\n else if ((*(p+1) == '-') && (p+2 < ec)) {\n p+=2;\n if (uchar(*(p-2)) <= c && c <= uchar(*p))\n return sig;\n }\n else if (uchar(*p) == c) return sig;\n }\n return !sig;\n}\n\n\nstatic int singlematch (int c, const char *p, const char *ep) {\n switch (*p) {\n case '.': return 1; /* matches any char */\n case L_ESC: return match_class(c, uchar(*(p+1)));\n case '[': return matchbracketclass(c, p, ep-1);\n default: return (uchar(*p) == c);\n }\n}\n\n\nstatic const char *match (MatchState *ms, const char *s, const char *p);\n\n\nstatic const char *matchbalance (MatchState *ms, const char *s,\n const char *p) {\n if (*p == 0 || *(p+1) == 0)\n luaL_error(ms->L, \"unbalanced pattern\");\n if (*s != *p) return NULL;\n else {\n int b = *p;\n int e = *(p+1);\n int cont = 1;\n while (++s < ms->src_end) {\n if (*s == e) {\n if (--cont == 0) return s+1;\n }\n else if (*s == b) cont++;\n }\n }\n return NULL; /* string ends out of balance */\n}\n\n\nstatic const char *max_expand (MatchState *ms, const char *s,\n const char *p, const char *ep) {\n ptrdiff_t i = 0; /* counts maximum expand for item */\n while ((s+i)src_end && singlematch(uchar(*(s+i)), p, ep))\n i++;\n /* keeps trying to match with the maximum repetitions */\n while (i>=0) {\n const char *res = match(ms, (s+i), ep+1);\n if (res) return res;\n i--; /* else didn't match; reduce 1 repetition to try again */\n }\n return NULL;\n}\n\n\nstatic const char *min_expand (MatchState *ms, const char *s,\n const char *p, const char *ep) {\n for (;;) {\n const char *res = match(ms, s, ep+1);\n if (res != NULL)\n return res;\n else if (ssrc_end && singlematch(uchar(*s), p, ep))\n s++; /* try with one more repetition */\n else return NULL;\n }\n}\n\n\nstatic const char *start_capture (MatchState *ms, const char *s,\n const char *p, int what) {\n const char *res;\n int level = ms->level;\n if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, \"too many captures\");\n ms->capture[level].init = s;\n ms->capture[level].len = what;\n ms->level = level+1;\n if ((res=match(ms, s, p)) == NULL) /* match failed? */\n ms->level--; /* undo capture */\n return res;\n}\n\n\nstatic const char *end_capture (MatchState *ms, const char *s,\n const char *p) {\n int l = capture_to_close(ms);\n const char *res;\n ms->capture[l].len = s - ms->capture[l].init; /* close capture */\n if ((res = match(ms, s, p)) == NULL) /* match failed? */\n ms->capture[l].len = CAP_UNFINISHED; /* undo capture */\n return res;\n}\n\n\nstatic const char *match_capture (MatchState *ms, const char *s, int l) {\n size_t len;\n l = check_capture(ms, l);\n len = ms->capture[l].len;\n if ((size_t)(ms->src_end-s) >= len &&\n memcmp(ms->capture[l].init, s, len) == 0)\n return s+len;\n else return NULL;\n}\n\n\nstatic const char *match (MatchState *ms, const char *s, const char *p) {\n init: /* using goto's to optimize tail recursion */\n switch (*p) {\n case '(': { /* start capture */\n if (*(p+1) == ')') /* position capture? */\n return start_capture(ms, s, p+2, CAP_POSITION);\n else\n return start_capture(ms, s, p+1, CAP_UNFINISHED);\n }\n case ')': { /* end capture */\n return end_capture(ms, s, p+1);\n }\n case L_ESC: {\n switch (*(p+1)) {\n case 'b': { /* balanced string? */\n s = matchbalance(ms, s, p+2);\n if (s == NULL) return NULL;\n p+=4; goto init; /* else return match(ms, s, p+4); */\n }\n case 'f': { /* frontier? */\n const char *ep; char previous;\n p += 2;\n if (*p != '[')\n luaL_error(ms->L, \"missing \" LUA_QL(\"[\") \" after \"\n LUA_QL(\"%%f\") \" in pattern\");\n ep = classend(ms, p); /* points to what is next */\n previous = (s == ms->src_init) ? '\\0' : *(s-1);\n if (matchbracketclass(uchar(previous), p, ep-1) ||\n !matchbracketclass(uchar(*s), p, ep-1)) return NULL;\n p=ep; goto init; /* else return match(ms, s, ep); */\n }\n default: {\n if (isdigit(uchar(*(p+1)))) { /* capture results (%0-%9)? */\n s = match_capture(ms, s, uchar(*(p+1)));\n if (s == NULL) return NULL;\n p+=2; goto init; /* else return match(ms, s, p+2) */\n }\n goto dflt; /* case default */\n }\n }\n }\n case '\\0': { /* end of pattern */\n return s; /* match succeeded */\n }\n case '$': {\n if (*(p+1) == '\\0') /* is the `$' the last char in pattern? */\n return (s == ms->src_end) ? s : NULL; /* check end of string */\n else goto dflt;\n }\n default: dflt: { /* it is a pattern item */\n const char *ep = classend(ms, p); /* points to what is next */\n int m = ssrc_end && singlematch(uchar(*s), p, ep);\n switch (*ep) {\n case '?': { /* optional */\n const char *res;\n if (m && ((res=match(ms, s+1, ep+1)) != NULL))\n return res;\n p=ep+1; goto init; /* else return match(ms, s, ep+1); */\n }\n case '*': { /* 0 or more repetitions */\n return max_expand(ms, s, p, ep);\n }\n case '+': { /* 1 or more repetitions */\n return (m ? max_expand(ms, s+1, p, ep) : NULL);\n }\n case '-': { /* 0 or more repetitions (minimum) */\n return min_expand(ms, s, p, ep);\n }\n default: {\n if (!m) return NULL;\n s++; p=ep; goto init; /* else return match(ms, s+1, ep); */\n }\n }\n }\n }\n}\n\n\n\nstatic const char *lmemfind (const char *s1, size_t l1,\n const char *s2, size_t l2) {\n if (l2 == 0) return s1; /* empty strings are everywhere */\n else if (l2 > l1) return NULL; /* avoids a negative `l1' */\n else {\n const char *init; /* to search for a `*s2' inside `s1' */\n l2--; /* 1st char will be checked by `memchr' */\n l1 = l1-l2; /* `s2' cannot be found after that */\n while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {\n init++; /* 1st char is already checked */\n if (memcmp(init, s2+1, l2) == 0)\n return init-1;\n else { /* correct `l1' and `s1' to try again */\n l1 -= init-s1;\n s1 = init;\n }\n }\n return NULL; /* not found */\n }\n}\n\n\nstatic void push_onecapture (MatchState *ms, int i, const char *s,\n const char *e) {\n if (i >= ms->level) {\n if (i == 0) /* ms->level == 0, too */\n lua_pushlstring(ms->L, s, e - s); /* add whole match */\n else\n luaL_error(ms->L, \"invalid capture index\");\n }\n else {\n ptrdiff_t l = ms->capture[i].len;\n if (l == CAP_UNFINISHED) luaL_error(ms->L, \"unfinished capture\");\n if (l == CAP_POSITION)\n lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);\n else\n lua_pushlstring(ms->L, ms->capture[i].init, l);\n }\n}\n\n\nstatic int push_captures (MatchState *ms, const char *s, const char *e) {\n int i;\n int nlevels = (ms->level == 0 && s) ? 1 : ms->level;\n luaL_checkstack(ms->L, nlevels, \"too many captures\");\n for (i = 0; i < nlevels; i++)\n push_onecapture(ms, i, s, e);\n return nlevels; /* number of strings pushed */\n}\n\n\nstatic int str_find_aux (lua_State *L, int find) {\n size_t l1, l2;\n const char *s = luaL_checklstring(L, 1, &l1);\n const char *p = luaL_checklstring(L, 2, &l2);\n ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;\n if (init < 0) init = 0;\n else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;\n if (find && (lua_toboolean(L, 4) || /* explicit request? */\n strpbrk(p, SPECIALS) == NULL)) { /* or no special characters? */\n /* do a plain search */\n const char *s2 = lmemfind(s+init, l1-init, p, l2);\n if (s2) {\n lua_pushinteger(L, s2-s+1);\n lua_pushinteger(L, s2-s+l2);\n return 2;\n }\n }\n else {\n MatchState ms;\n int anchor = (*p == '^') ? (p++, 1) : 0;\n const char *s1=s+init;\n ms.L = L;\n ms.src_init = s;\n ms.src_end = s+l1;\n do {\n const char *res;\n ms.level = 0;\n if ((res=match(&ms, s1, p)) != NULL) {\n if (find) {\n lua_pushinteger(L, s1-s+1); /* start */\n lua_pushinteger(L, res-s); /* end */\n return push_captures(&ms, NULL, 0) + 2;\n }\n else\n return push_captures(&ms, s1, res);\n }\n } while (s1++ < ms.src_end && !anchor);\n }\n lua_pushnil(L); /* not found */\n return 1;\n}\n\n\nstatic int str_find (lua_State *L) {\n return str_find_aux(L, 1);\n}\n\n\nstatic int str_match (lua_State *L) {\n return str_find_aux(L, 0);\n}\n\n\nstatic int gmatch_aux (lua_State *L) {\n MatchState ms;\n size_t ls;\n const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);\n const char *p = lua_tostring(L, lua_upvalueindex(2));\n const char *src;\n ms.L = L;\n ms.src_init = s;\n ms.src_end = s+ls;\n for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));\n src <= ms.src_end;\n src++) {\n const char *e;\n ms.level = 0;\n if ((e = match(&ms, src, p)) != NULL) {\n lua_Integer newstart = e-s;\n if (e == src) newstart++; /* empty match? go at least one position */\n lua_pushinteger(L, newstart);\n lua_replace(L, lua_upvalueindex(3));\n return push_captures(&ms, src, e);\n }\n }\n return 0; /* not found */\n}\n\n\nstatic int gmatch (lua_State *L) {\n luaL_checkstring(L, 1);\n luaL_checkstring(L, 2);\n lua_settop(L, 2);\n lua_pushinteger(L, 0);\n lua_pushcclosure(L, gmatch_aux, 3);\n return 1;\n}\n\n\nstatic int gfind_nodef (lua_State *L) {\n return luaL_error(L, LUA_QL(\"string.gfind\") \" was renamed to \"\n LUA_QL(\"string.gmatch\"));\n}\n\n\nstatic void add_s (MatchState *ms, luaL_Buffer *b, const char *s,\n const char *e) {\n size_t l, i;\n const char *news = lua_tolstring(ms->L, 3, &l);\n for (i = 0; i < l; i++) {\n if (news[i] != L_ESC)\n luaL_addchar(b, news[i]);\n else {\n i++; /* skip ESC */\n if (!isdigit(uchar(news[i])))\n luaL_addchar(b, news[i]);\n else if (news[i] == '0')\n luaL_addlstring(b, s, e - s);\n else {\n push_onecapture(ms, news[i] - '1', s, e);\n luaL_addvalue(b); /* add capture to accumulated result */\n }\n }\n }\n}\n\n\nstatic void add_value (MatchState *ms, luaL_Buffer *b, const char *s,\n const char *e) {\n lua_State *L = ms->L;\n switch (lua_type(L, 3)) {\n case LUA_TNUMBER:\n case LUA_TSTRING: {\n add_s(ms, b, s, e);\n return;\n }\n case LUA_TFUNCTION: {\n int n;\n lua_pushvalue(L, 3);\n n = push_captures(ms, s, e);\n lua_call(L, n, 1);\n break;\n }\n case LUA_TTABLE: {\n push_onecapture(ms, 0, s, e);\n lua_gettable(L, 3);\n break;\n }\n }\n if (!lua_toboolean(L, -1)) { /* nil or false? */\n lua_pop(L, 1);\n lua_pushlstring(L, s, e - s); /* keep original text */\n }\n else if (!lua_isstring(L, -1))\n luaL_error(L, \"invalid replacement value (a %s)\", luaL_typename(L, -1)); \n luaL_addvalue(b); /* add result to accumulator */\n}\n\n\nstatic int str_gsub (lua_State *L) {\n size_t srcl;\n const char *src = luaL_checklstring(L, 1, &srcl);\n const char *p = luaL_checkstring(L, 2);\n int tr = lua_type(L, 3);\n int max_s = luaL_optint(L, 4, srcl+1);\n int anchor = (*p == '^') ? (p++, 1) : 0;\n int n = 0;\n MatchState ms;\n luaL_Buffer b;\n luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||\n tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,\n \"string/function/table expected\");\n luaL_buffinit(L, &b);\n ms.L = L;\n ms.src_init = src;\n ms.src_end = src+srcl;\n while (n < max_s) {\n const char *e;\n ms.level = 0;\n e = match(&ms, src, p);\n if (e) {\n n++;\n add_value(&ms, &b, src, e);\n }\n if (e && e>src) /* non empty match? */\n src = e; /* skip it */\n else if (src < ms.src_end)\n luaL_addchar(&b, *src++);\n else break;\n if (anchor) break;\n }\n luaL_addlstring(&b, src, ms.src_end-src);\n luaL_pushresult(&b);\n lua_pushinteger(L, n); /* number of substitutions */\n return 2;\n}\n\n/* }====================================================== */\n\n\n/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */\n#define MAX_ITEM\t512\n/* valid flags in a format specification */\n#define FLAGS\t\"-+ #0\"\n/*\n** maximum size of each format specification (such as '%-099.99d')\n** (+10 accounts for %99.99x plus margin of error)\n*/\n#define MAX_FORMAT\t(sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)\n\n\nstatic void addquoted (lua_State *L, luaL_Buffer *b, int arg) {\n size_t l;\n const char *s = luaL_checklstring(L, arg, &l);\n luaL_addchar(b, '\"');\n while (l--) {\n switch (*s) {\n case '\"': case '\\\\': case '\\n': {\n luaL_addchar(b, '\\\\');\n luaL_addchar(b, *s);\n break;\n }\n case '\\r': {\n luaL_addlstring(b, \"\\\\r\", 2);\n break;\n }\n case '\\0': {\n luaL_addlstring(b, \"\\\\000\", 4);\n break;\n }\n default: {\n luaL_addchar(b, *s);\n break;\n }\n }\n s++;\n }\n luaL_addchar(b, '\"');\n}\n\nstatic const char *scanformat (lua_State *L, const char *strfrmt, char *form) {\n const char *p = strfrmt;\n while (*p != '\\0' && strchr(FLAGS, *p) != NULL) p++; /* skip flags */\n if ((size_t)(p - strfrmt) >= sizeof(FLAGS))\n luaL_error(L, \"invalid format (repeated flags)\");\n if (isdigit(uchar(*p))) p++; /* skip width */\n if (isdigit(uchar(*p))) p++; /* (2 digits at most) */\n if (*p == '.') {\n p++;\n if (isdigit(uchar(*p))) p++; /* skip precision */\n if (isdigit(uchar(*p))) p++; /* (2 digits at most) */\n }\n if (isdigit(uchar(*p)))\n luaL_error(L, \"invalid format (width or precision too long)\");\n *(form++) = '%';\n strncpy(form, strfrmt, p - strfrmt + 1);\n form += p - strfrmt + 1;\n *form = '\\0';\n return p;\n}\n\n\nstatic void addintlen (char *form) {\n size_t l = strlen(form);\n char spec = form[l - 1];\n strcpy(form + l - 1, LUA_INTFRMLEN);\n form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;\n form[l + sizeof(LUA_INTFRMLEN) - 1] = '\\0';\n}\n\n\nstatic int str_format (lua_State *L) {\n int top = lua_gettop(L);\n int arg = 1;\n size_t sfl;\n const char *strfrmt = luaL_checklstring(L, arg, &sfl);\n const char *strfrmt_end = strfrmt+sfl;\n luaL_Buffer b;\n luaL_buffinit(L, &b);\n while (strfrmt < strfrmt_end) {\n if (*strfrmt != L_ESC)\n luaL_addchar(&b, *strfrmt++);\n else if (*++strfrmt == L_ESC)\n luaL_addchar(&b, *strfrmt++); /* %% */\n else { /* format item */\n char form[MAX_FORMAT]; /* to store the format (`%...') */\n char buff[MAX_ITEM]; /* to store the formatted item */\n if (++arg > top)\n luaL_argerror(L, arg, \"no value\");\n strfrmt = scanformat(L, strfrmt, form);\n switch (*strfrmt++) {\n case 'c': {\n sprintf(buff, form, (int)luaL_checknumber(L, arg));\n break;\n }\n case 'd': case 'i': {\n addintlen(form);\n sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));\n break;\n }\n case 'o': case 'u': case 'x': case 'X': {\n addintlen(form);\n sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));\n break;\n }\n case 'e': case 'E': case 'f':\n case 'g': case 'G': {\n sprintf(buff, form, (double)luaL_checknumber(L, arg));\n break;\n }\n case 'q': {\n addquoted(L, &b, arg);\n continue; /* skip the 'addsize' at the end */\n }\n case 's': {\n size_t l;\n const char *s = luaL_checklstring(L, arg, &l);\n if (!strchr(form, '.') && l >= 100) {\n /* no precision and string is too long to be formatted;\n keep original string */\n lua_pushvalue(L, arg);\n luaL_addvalue(&b);\n continue; /* skip the `addsize' at the end */\n }\n else {\n sprintf(buff, form, s);\n break;\n }\n }\n default: { /* also treat cases `pnLlh' */\n return luaL_error(L, \"invalid option \" LUA_QL(\"%%%c\") \" to \"\n LUA_QL(\"format\"), *(strfrmt - 1));\n }\n }\n luaL_addlstring(&b, buff, strlen(buff));\n }\n }\n luaL_pushresult(&b);\n return 1;\n}\n\n\nstatic const luaL_Reg strlib[] = {\n {\"byte\", str_byte},\n {\"char\", str_char},\n {\"dump\", str_dump},\n {\"find\", str_find},\n {\"format\", str_format},\n {\"gfind\", gfind_nodef},\n {\"gmatch\", gmatch},\n {\"gsub\", str_gsub},\n {\"len\", str_len},\n {\"lower\", str_lower},\n {\"match\", str_match},\n {\"rep\", str_rep},\n {\"reverse\", str_reverse},\n {\"sub\", str_sub},\n {\"upper\", str_upper},\n {NULL, NULL}\n};\n\n\nstatic void createmetatable (lua_State *L) {\n lua_createtable(L, 0, 1); /* create metatable for strings */\n lua_pushliteral(L, \"\"); /* dummy string */\n lua_pushvalue(L, -2);\n lua_setmetatable(L, -2); /* set string metatable */\n lua_pop(L, 1); /* pop dummy string */\n lua_pushvalue(L, -2); /* string library... */\n lua_setfield(L, -2, \"__index\"); /* ...is the __index metamethod */\n lua_pop(L, 1); /* pop metatable */\n}\n\n\n/*\n** Open string library\n*/\nLUALIB_API int luaopen_string (lua_State *L) {\n luaL_register(L, LUA_STRLIBNAME, strlib);\n#if defined(LUA_COMPAT_GFIND)\n lua_getfield(L, -1, \"gmatch\");\n lua_setfield(L, -2, \"gfind\");\n#endif\n createmetatable(L);\n return 1;\n}\n\n" }, { "path": "deps/lua/src/ltable.c", "content": "/*\n** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $\n** Lua tables (hash)\n** See Copyright Notice in lua.h\n*/\n\n\n/*\n** Implementation of tables (aka arrays, objects, or hash tables).\n** Tables keep its elements in two parts: an array part and a hash part.\n** Non-negative integer keys are all candidates to be kept in the array\n** part. The actual size of the array is the largest `n' such that at\n** least half the slots between 0 and n are in use.\n** Hash uses a mix of chained scatter table with Brent's variation.\n** A main invariant of these tables is that, if an element is not\n** in its main position (i.e. the `original' position that its hash gives\n** to it), then the colliding element is in its own main position.\n** Hence even when the load factor reaches 100%, performance remains good.\n*/\n\n#include \n#include \n\n#define ltable_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lgc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"ltable.h\"\n\n\n/*\n** max size of array part is 2^MAXBITS\n*/\n#if LUAI_BITSINT > 26\n#define MAXBITS\t\t26\n#else\n#define MAXBITS\t\t(LUAI_BITSINT-2)\n#endif\n\n#define MAXASIZE\t(1 << MAXBITS)\n\n\n#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t))))\n \n#define hashstr(t,str) hashpow2(t, (str)->tsv.hash)\n#define hashboolean(t,p) hashpow2(t, p)\n\n\n/*\n** for some types, it is better to avoid modulus by power of 2, as\n** they tend to have many 2 factors.\n*/\n#define hashmod(t,n)\t(gnode(t, ((n) % ((sizenode(t)-1)|1))))\n\n\n#define hashpointer(t,p)\thashmod(t, IntPoint(p))\n\n\n/*\n** number of ints inside a lua_Number\n*/\n#define numints\t\tcast_int(sizeof(lua_Number)/sizeof(int))\n\n\n\n#define dummynode\t\t(&dummynode_)\n\nstatic const Node dummynode_ = {\n {{NULL}, LUA_TNIL}, /* value */\n {{{NULL}, LUA_TNIL, NULL}} /* key */\n};\n\n\n/*\n** hash for lua_Numbers\n*/\nstatic Node *hashnum (const Table *t, lua_Number n) {\n unsigned int a[numints];\n int i;\n if (luai_numeq(n, 0)) /* avoid problems with -0 */\n return gnode(t, 0);\n memcpy(a, &n, sizeof(a));\n for (i = 1; i < numints; i++) a[0] += a[i];\n return hashmod(t, a[0]);\n}\n\n\n\n/*\n** returns the `main' position of an element in a table (that is, the index\n** of its hash value)\n*/\nstatic Node *mainposition (const Table *t, const TValue *key) {\n switch (ttype(key)) {\n case LUA_TNUMBER:\n return hashnum(t, nvalue(key));\n case LUA_TSTRING:\n return hashstr(t, rawtsvalue(key));\n case LUA_TBOOLEAN:\n return hashboolean(t, bvalue(key));\n case LUA_TLIGHTUSERDATA:\n return hashpointer(t, pvalue(key));\n default:\n return hashpointer(t, gcvalue(key));\n }\n}\n\n\n/*\n** returns the index for `key' if `key' is an appropriate key to live in\n** the array part of the table, -1 otherwise.\n*/\nstatic int arrayindex (const TValue *key) {\n if (ttisnumber(key)) {\n lua_Number n = nvalue(key);\n int k;\n lua_number2int(k, n);\n if (luai_numeq(cast_num(k), n))\n return k;\n }\n return -1; /* `key' did not match some condition */\n}\n\n\n/*\n** returns the index of a `key' for table traversals. First goes all\n** elements in the array part, then elements in the hash part. The\n** beginning of a traversal is signalled by -1.\n*/\nstatic int findindex (lua_State *L, Table *t, StkId key) {\n int i;\n if (ttisnil(key)) return -1; /* first iteration */\n i = arrayindex(key);\n if (0 < i && i <= t->sizearray) /* is `key' inside array part? */\n return i-1; /* yes; that's the index (corrected to C) */\n else {\n Node *n = mainposition(t, key);\n do { /* check whether `key' is somewhere in the chain */\n /* key may be dead already, but it is ok to use it in `next' */\n if (luaO_rawequalObj(key2tval(n), key) ||\n (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&\n gcvalue(gkey(n)) == gcvalue(key))) {\n i = cast_int(n - gnode(t, 0)); /* key index in hash table */\n /* hash elements are numbered after array ones */\n return i + t->sizearray;\n }\n else n = gnext(n);\n } while (n);\n luaG_runerror(L, \"invalid key to \" LUA_QL(\"next\")); /* key not found */\n return 0; /* to avoid warnings */\n }\n}\n\n\nint luaH_next (lua_State *L, Table *t, StkId key) {\n int i = findindex(L, t, key); /* find original element */\n for (i++; i < t->sizearray; i++) { /* try first array part */\n if (!ttisnil(&t->array[i])) { /* a non-nil value? */\n setnvalue(key, cast_num(i+1));\n setobj2s(L, key+1, &t->array[i]);\n return 1;\n }\n }\n for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */\n if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */\n setobj2s(L, key, key2tval(gnode(t, i)));\n setobj2s(L, key+1, gval(gnode(t, i)));\n return 1;\n }\n }\n return 0; /* no more elements */\n}\n\n\n/*\n** {=============================================================\n** Rehash\n** ==============================================================\n*/\n\n\nstatic int computesizes (int nums[], int *narray) {\n int i;\n int twotoi; /* 2^i */\n int a = 0; /* number of elements smaller than 2^i */\n int na = 0; /* number of elements to go to array part */\n int n = 0; /* optimal size for array part */\n for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {\n if (nums[i] > 0) {\n a += nums[i];\n if (a > twotoi/2) { /* more than half elements present? */\n n = twotoi; /* optimal size (till now) */\n na = a; /* all elements smaller than n will go to array part */\n }\n }\n if (a == *narray) break; /* all elements already counted */\n }\n *narray = n;\n lua_assert(*narray/2 <= na && na <= *narray);\n return na;\n}\n\n\nstatic int countint (const TValue *key, int *nums) {\n int k = arrayindex(key);\n if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */\n nums[ceillog2(k)]++; /* count as such */\n return 1;\n }\n else\n return 0;\n}\n\n\nstatic int numusearray (const Table *t, int *nums) {\n int lg;\n int ttlg; /* 2^lg */\n int ause = 0; /* summation of `nums' */\n int i = 1; /* count to traverse all array keys */\n for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) { /* for each slice */\n int lc = 0; /* counter */\n int lim = ttlg;\n if (lim > t->sizearray) {\n lim = t->sizearray; /* adjust upper limit */\n if (i > lim)\n break; /* no more elements to count */\n }\n /* count elements in range (2^(lg-1), 2^lg] */\n for (; i <= lim; i++) {\n if (!ttisnil(&t->array[i-1]))\n lc++;\n }\n nums[lg] += lc;\n ause += lc;\n }\n return ause;\n}\n\n\nstatic int numusehash (const Table *t, int *nums, int *pnasize) {\n int totaluse = 0; /* total number of elements */\n int ause = 0; /* summation of `nums' */\n int i = sizenode(t);\n while (i--) {\n Node *n = &t->node[i];\n if (!ttisnil(gval(n))) {\n ause += countint(key2tval(n), nums);\n totaluse++;\n }\n }\n *pnasize += ause;\n return totaluse;\n}\n\n\nstatic void setarrayvector (lua_State *L, Table *t, int size) {\n int i;\n luaM_reallocvector(L, t->array, t->sizearray, size, TValue);\n for (i=t->sizearray; iarray[i]);\n t->sizearray = size;\n}\n\n\nstatic void setnodevector (lua_State *L, Table *t, int size) {\n int lsize;\n if (size == 0) { /* no elements to hash part? */\n t->node = cast(Node *, dummynode); /* use common `dummynode' */\n lsize = 0;\n }\n else {\n int i;\n lsize = ceillog2(size);\n if (lsize > MAXBITS)\n luaG_runerror(L, \"table overflow\");\n size = twoto(lsize);\n t->node = luaM_newvector(L, size, Node);\n for (i=0; ilsizenode = cast_byte(lsize);\n t->lastfree = gnode(t, size); /* all positions are free */\n}\n\n\nstatic void resize (lua_State *L, Table *t, int nasize, int nhsize) {\n int i;\n int oldasize = t->sizearray;\n int oldhsize = t->lsizenode;\n Node *nold = t->node; /* save old hash ... */\n if (nasize > oldasize) /* array part must grow? */\n setarrayvector(L, t, nasize);\n /* create new hash part with appropriate size */\n setnodevector(L, t, nhsize); \n if (nasize < oldasize) { /* array part must shrink? */\n t->sizearray = nasize;\n /* re-insert elements from vanishing slice */\n for (i=nasize; iarray[i]))\n setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);\n }\n /* shrink array */\n luaM_reallocvector(L, t->array, oldasize, nasize, TValue);\n }\n /* re-insert elements from hash part */\n for (i = twoto(oldhsize) - 1; i >= 0; i--) {\n Node *old = nold+i;\n if (!ttisnil(gval(old)))\n setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));\n }\n if (nold != dummynode)\n luaM_freearray(L, nold, twoto(oldhsize), Node); /* free old array */\n}\n\n\nvoid luaH_resizearray (lua_State *L, Table *t, int nasize) {\n int nsize = (t->node == dummynode) ? 0 : sizenode(t);\n resize(L, t, nasize, nsize);\n}\n\n\nstatic void rehash (lua_State *L, Table *t, const TValue *ek) {\n int nasize, na;\n int nums[MAXBITS+1]; /* nums[i] = number of keys between 2^(i-1) and 2^i */\n int i;\n int totaluse;\n for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */\n nasize = numusearray(t, nums); /* count keys in array part */\n totaluse = nasize; /* all those keys are integer keys */\n totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */\n /* count extra key */\n nasize += countint(ek, nums);\n totaluse++;\n /* compute new size for array part */\n na = computesizes(nums, &nasize);\n /* resize the table to new computed sizes */\n resize(L, t, nasize, totaluse - na);\n}\n\n\n\n/*\n** }=============================================================\n*/\n\n\nTable *luaH_new (lua_State *L, int narray, int nhash) {\n Table *t = luaM_new(L, Table);\n luaC_link(L, obj2gco(t), LUA_TTABLE);\n t->metatable = NULL;\n t->flags = cast_byte(~0);\n /* temporary values (kept only if some malloc fails) */\n t->array = NULL;\n t->sizearray = 0;\n t->lsizenode = 0;\n t->readonly = 0;\n t->node = cast(Node *, dummynode);\n setarrayvector(L, t, narray);\n setnodevector(L, t, nhash);\n return t;\n}\n\n\nvoid luaH_free (lua_State *L, Table *t) {\n if (t->node != dummynode)\n luaM_freearray(L, t->node, sizenode(t), Node);\n luaM_freearray(L, t->array, t->sizearray, TValue);\n luaM_free(L, t);\n}\n\n\nstatic Node *getfreepos (Table *t) {\n while (t->lastfree-- > t->node) {\n if (ttisnil(gkey(t->lastfree)))\n return t->lastfree;\n }\n return NULL; /* could not find a free place */\n}\n\n\n\n/*\n** inserts a new key into a hash table; first, check whether key's main \n** position is free. If not, check whether colliding node is in its main \n** position or not: if it is not, move colliding node to an empty place and \n** put new key in its main position; otherwise (colliding node is in its main \n** position), new key goes to an empty position. \n*/\nstatic TValue *newkey (lua_State *L, Table *t, const TValue *key) {\n Node *mp = mainposition(t, key);\n if (!ttisnil(gval(mp)) || mp == dummynode) {\n Node *othern;\n Node *n = getfreepos(t); /* get a free place */\n if (n == NULL) { /* cannot find a free place? */\n rehash(L, t, key); /* grow table */\n return luaH_set(L, t, key); /* re-insert key into grown table */\n }\n lua_assert(n != dummynode);\n othern = mainposition(t, key2tval(mp));\n if (othern != mp) { /* is colliding node out of its main position? */\n /* yes; move colliding node into free position */\n while (gnext(othern) != mp) othern = gnext(othern); /* find previous */\n gnext(othern) = n; /* redo the chain with `n' in place of `mp' */\n *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */\n gnext(mp) = NULL; /* now `mp' is free */\n setnilvalue(gval(mp));\n }\n else { /* colliding node is in its own main position */\n /* new node will go into free position */\n gnext(n) = gnext(mp); /* chain new position */\n gnext(mp) = n;\n mp = n;\n }\n }\n gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;\n luaC_barriert(L, t, key);\n lua_assert(ttisnil(gval(mp)));\n return gval(mp);\n}\n\n\n/*\n** search function for integers\n*/\nconst TValue *luaH_getnum (Table *t, int key) {\n if (1 <= key && key <= t->sizearray)\n return &t->array[key-1];\n else {\n lua_Number nk = cast_num(key);\n Node *n = hashnum(t, nk);\n do { /* check whether `key' is somewhere in the chain */\n if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))\n return gval(n); /* that's it */\n else n = gnext(n);\n } while (n);\n return luaO_nilobject;\n }\n}\n\n\n/*\n** search function for strings\n*/\nconst TValue *luaH_getstr (Table *t, TString *key) {\n Node *n = hashstr(t, key);\n do { /* check whether `key' is somewhere in the chain */\n if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)\n return gval(n); /* that's it */\n else n = gnext(n);\n } while (n);\n return luaO_nilobject;\n}\n\n\n/*\n** main search function\n*/\nconst TValue *luaH_get (Table *t, const TValue *key) {\n switch (ttype(key)) {\n case LUA_TNIL: return luaO_nilobject;\n case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));\n case LUA_TNUMBER: {\n int k;\n lua_Number n = nvalue(key);\n lua_number2int(k, n);\n if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */\n return luaH_getnum(t, k); /* use specialized version */\n /* else go through */\n }\n default: {\n Node *n = mainposition(t, key);\n do { /* check whether `key' is somewhere in the chain */\n if (luaO_rawequalObj(key2tval(n), key))\n return gval(n); /* that's it */\n else n = gnext(n);\n } while (n);\n return luaO_nilobject;\n }\n }\n}\n\n\nTValue *luaH_set (lua_State *L, Table *t, const TValue *key) {\n const TValue *p = luaH_get(t, key);\n t->flags = 0;\n if (p != luaO_nilobject)\n return cast(TValue *, p);\n else {\n if (ttisnil(key)) luaG_runerror(L, \"table index is nil\");\n else if (ttisnumber(key) && luai_numisnan(nvalue(key)))\n luaG_runerror(L, \"table index is NaN\");\n return newkey(L, t, key);\n }\n}\n\n\nTValue *luaH_setnum (lua_State *L, Table *t, int key) {\n const TValue *p = luaH_getnum(t, key);\n if (p != luaO_nilobject)\n return cast(TValue *, p);\n else {\n TValue k;\n setnvalue(&k, cast_num(key));\n return newkey(L, t, &k);\n }\n}\n\n\nTValue *luaH_setstr (lua_State *L, Table *t, TString *key) {\n const TValue *p = luaH_getstr(t, key);\n if (p != luaO_nilobject)\n return cast(TValue *, p);\n else {\n TValue k;\n setsvalue(L, &k, key);\n return newkey(L, t, &k);\n }\n}\n\n\nstatic int unbound_search (Table *t, unsigned int j) {\n unsigned int i = j; /* i is zero or a present index */\n j++;\n /* find `i' and `j' such that i is present and j is not */\n while (!ttisnil(luaH_getnum(t, j))) {\n i = j;\n j *= 2;\n if (j > cast(unsigned int, MAX_INT)) { /* overflow? */\n /* table was built with bad purposes: resort to linear search */\n i = 1;\n while (!ttisnil(luaH_getnum(t, i))) i++;\n return i - 1;\n }\n }\n /* now do a binary search between them */\n while (j - i > 1) {\n unsigned int m = (i+j)/2;\n if (ttisnil(luaH_getnum(t, m))) j = m;\n else i = m;\n }\n return i;\n}\n\n\n/*\n** Try to find a boundary in table `t'. A `boundary' is an integer index\n** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).\n*/\nint luaH_getn (Table *t) {\n unsigned int j = t->sizearray;\n if (j > 0 && ttisnil(&t->array[j - 1])) {\n /* there is a boundary in the array part: (binary) search for it */\n unsigned int i = 0;\n while (j - i > 1) {\n unsigned int m = (i+j)/2;\n if (ttisnil(&t->array[m - 1])) j = m;\n else i = m;\n }\n return i;\n }\n /* else must find a boundary in hash part */\n else if (t->node == dummynode) /* hash part is empty? */\n return j; /* that is easy... */\n else return unbound_search(t, j);\n}\n\n\n\n#if defined(LUA_DEBUG)\n\nNode *luaH_mainposition (const Table *t, const TValue *key) {\n return mainposition(t, key);\n}\n\nint luaH_isdummy (Node *n) { return n == dummynode; }\n\n#endif\n" }, { "path": "deps/lua/src/ltable.h", "content": "/*\n** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $\n** Lua tables (hash)\n** See Copyright Notice in lua.h\n*/\n\n#ifndef ltable_h\n#define ltable_h\n\n#include \"lobject.h\"\n\n\n#define gnode(t,i)\t(&(t)->node[i])\n#define gkey(n)\t\t(&(n)->i_key.nk)\n#define gval(n)\t\t(&(n)->i_val)\n#define gnext(n)\t((n)->i_key.nk.next)\n\n#define key2tval(n)\t(&(n)->i_key.tvk)\n\n\nLUAI_FUNC const TValue *luaH_getnum (Table *t, int key);\nLUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);\nLUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);\nLUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);\nLUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);\nLUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);\nLUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);\nLUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);\nLUAI_FUNC void luaH_free (lua_State *L, Table *t);\nLUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);\nLUAI_FUNC int luaH_getn (Table *t);\n\n\n#if defined(LUA_DEBUG)\nLUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);\nLUAI_FUNC int luaH_isdummy (Node *n);\n#endif\n\n\n#endif\n" }, { "path": "deps/lua/src/ltablib.c", "content": "/*\n** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $\n** Library for Table Manipulation\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define ltablib_c\n#define LUA_LIB\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n#define aux_getn(L,n)\t(luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))\n\n\nstatic int foreachi (lua_State *L) {\n int i;\n int n = aux_getn(L, 1);\n luaL_checktype(L, 2, LUA_TFUNCTION);\n for (i=1; i <= n; i++) {\n lua_pushvalue(L, 2); /* function */\n lua_pushinteger(L, i); /* 1st argument */\n lua_rawgeti(L, 1, i); /* 2nd argument */\n lua_call(L, 2, 1);\n if (!lua_isnil(L, -1))\n return 1;\n lua_pop(L, 1); /* remove nil result */\n }\n return 0;\n}\n\n\nstatic int foreach (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n luaL_checktype(L, 2, LUA_TFUNCTION);\n lua_pushnil(L); /* first key */\n while (lua_next(L, 1)) {\n lua_pushvalue(L, 2); /* function */\n lua_pushvalue(L, -3); /* key */\n lua_pushvalue(L, -3); /* value */\n lua_call(L, 2, 1);\n if (!lua_isnil(L, -1))\n return 1;\n lua_pop(L, 2); /* remove value and result */\n }\n return 0;\n}\n\n\nstatic int maxn (lua_State *L) {\n lua_Number max = 0;\n luaL_checktype(L, 1, LUA_TTABLE);\n lua_pushnil(L); /* first key */\n while (lua_next(L, 1)) {\n lua_pop(L, 1); /* remove value */\n if (lua_type(L, -1) == LUA_TNUMBER) {\n lua_Number v = lua_tonumber(L, -1);\n if (v > max) max = v;\n }\n }\n lua_pushnumber(L, max);\n return 1;\n}\n\n\nstatic int getn (lua_State *L) {\n lua_pushinteger(L, aux_getn(L, 1));\n return 1;\n}\n\n\nstatic int setn (lua_State *L) {\n luaL_checktype(L, 1, LUA_TTABLE);\n#ifndef luaL_setn\n luaL_setn(L, 1, luaL_checkint(L, 2));\n#else\n luaL_error(L, LUA_QL(\"setn\") \" is obsolete\");\n#endif\n lua_pushvalue(L, 1);\n return 1;\n}\n\n\nstatic int tinsert (lua_State *L) {\n int e = aux_getn(L, 1) + 1; /* first empty element */\n int pos; /* where to insert new element */\n switch (lua_gettop(L)) {\n case 2: { /* called with only 2 arguments */\n pos = e; /* insert new element at the end */\n break;\n }\n case 3: {\n int i;\n pos = luaL_checkint(L, 2); /* 2nd argument is the position */\n if (pos > e) e = pos; /* `grow' array if necessary */\n for (i = e; i > pos; i--) { /* move up elements */\n lua_rawgeti(L, 1, i-1);\n lua_rawseti(L, 1, i); /* t[i] = t[i-1] */\n }\n break;\n }\n default: {\n return luaL_error(L, \"wrong number of arguments to \" LUA_QL(\"insert\"));\n }\n }\n luaL_setn(L, 1, e); /* new size */\n lua_rawseti(L, 1, pos); /* t[pos] = v */\n return 0;\n}\n\n\nstatic int tremove (lua_State *L) {\n int e = aux_getn(L, 1);\n int pos = luaL_optint(L, 2, e);\n if (!(1 <= pos && pos <= e)) /* position is outside bounds? */\n return 0; /* nothing to remove */\n luaL_setn(L, 1, e - 1); /* t.n = n-1 */\n lua_rawgeti(L, 1, pos); /* result = t[pos] */\n for ( ;pos= P */\n while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {\n if (i>u) luaL_error(L, \"invalid order function for sorting\");\n lua_pop(L, 1); /* remove a[i] */\n }\n /* repeat --j until a[j] <= P */\n while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {\n if (j\n\n#define ltm_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n\n\n\nconst char *const luaT_typenames[] = {\n \"nil\", \"boolean\", \"userdata\", \"number\",\n \"string\", \"table\", \"function\", \"userdata\", \"thread\",\n \"proto\", \"upval\"\n};\n\n\nvoid luaT_init (lua_State *L) {\n static const char *const luaT_eventname[] = { /* ORDER TM */\n \"__index\", \"__newindex\",\n \"__gc\", \"__mode\", \"__eq\",\n \"__add\", \"__sub\", \"__mul\", \"__div\", \"__mod\",\n \"__pow\", \"__unm\", \"__len\", \"__lt\", \"__le\",\n \"__concat\", \"__call\"\n };\n int i;\n for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]);\n luaS_fix(G(L)->tmname[i]); /* never collect these names */\n }\n}\n\n\n/*\n** function to be used with macro \"fasttm\": optimized for absence of\n** tag methods\n*/\nconst TValue *luaT_gettm (Table *events, TMS event, TString *ename) {\n const TValue *tm = luaH_getstr(events, ename);\n lua_assert(event <= TM_EQ);\n if (ttisnil(tm)) { /* no tag method? */\n events->flags |= cast_byte(1u<metatable;\n break;\n case LUA_TUSERDATA:\n mt = uvalue(o)->metatable;\n break;\n default:\n mt = G(L)->mt[ttype(o)];\n }\n return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);\n}\n\n" }, { "path": "deps/lua/src/ltm.h", "content": "/*\n** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $\n** Tag methods\n** See Copyright Notice in lua.h\n*/\n\n#ifndef ltm_h\n#define ltm_h\n\n\n#include \"lobject.h\"\n\n\n/*\n* WARNING: if you change the order of this enumeration,\n* grep \"ORDER TM\"\n*/\ntypedef enum {\n TM_INDEX,\n TM_NEWINDEX,\n TM_GC,\n TM_MODE,\n TM_EQ, /* last tag method with `fast' access */\n TM_ADD,\n TM_SUB,\n TM_MUL,\n TM_DIV,\n TM_MOD,\n TM_POW,\n TM_UNM,\n TM_LEN,\n TM_LT,\n TM_LE,\n TM_CONCAT,\n TM_CALL,\n TM_N\t\t/* number of elements in the enum */\n} TMS;\n\n\n\n#define gfasttm(g,et,e) ((et) == NULL ? NULL : \\\n ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))\n\n#define fasttm(l,et,e)\tgfasttm(G(l), et, e)\n\nLUAI_DATA const char *const luaT_typenames[];\n\n\nLUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);\nLUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,\n TMS event);\nLUAI_FUNC void luaT_init (lua_State *L);\n\n#endif\n" }, { "path": "deps/lua/src/lua.c", "content": "/*\n** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $\n** Lua stand-alone interpreter\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n#include \n\n#define lua_c\n\n#include \"lua.h\"\n\n#include \"lauxlib.h\"\n#include \"lualib.h\"\n\n\n\nstatic lua_State *globalL = NULL;\n\nstatic const char *progname = LUA_PROGNAME;\n\n\n\nstatic void lstop (lua_State *L, lua_Debug *ar) {\n (void)ar; /* unused arg. */\n lua_sethook(L, NULL, 0, 0);\n luaL_error(L, \"interrupted!\");\n}\n\n\nstatic void laction (int i) {\n signal(i, SIG_DFL); /* if another SIGINT happens before lstop,\n terminate process (default action) */\n lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);\n}\n\n\nstatic void print_usage (void) {\n fprintf(stderr,\n \"usage: %s [options] [script [args]].\\n\"\n \"Available options are:\\n\"\n \" -e stat execute string \" LUA_QL(\"stat\") \"\\n\"\n \" -l name require library \" LUA_QL(\"name\") \"\\n\"\n \" -i enter interactive mode after executing \" LUA_QL(\"script\") \"\\n\"\n \" -v show version information\\n\"\n \" -- stop handling options\\n\"\n \" - execute stdin and stop handling options\\n\"\n ,\n progname);\n fflush(stderr);\n}\n\n\nstatic void l_message (const char *pname, const char *msg) {\n if (pname) fprintf(stderr, \"%s: \", pname);\n fprintf(stderr, \"%s\\n\", msg);\n fflush(stderr);\n}\n\n\nstatic int report (lua_State *L, int status) {\n if (status && !lua_isnil(L, -1)) {\n const char *msg = lua_tostring(L, -1);\n if (msg == NULL) msg = \"(error object is not a string)\";\n l_message(progname, msg);\n lua_pop(L, 1);\n }\n return status;\n}\n\n\nstatic int traceback (lua_State *L) {\n if (!lua_isstring(L, 1)) /* 'message' not a string? */\n return 1; /* keep it intact */\n lua_getfield(L, LUA_GLOBALSINDEX, \"debug\");\n if (!lua_istable(L, -1)) {\n lua_pop(L, 1);\n return 1;\n }\n lua_getfield(L, -1, \"traceback\");\n if (!lua_isfunction(L, -1)) {\n lua_pop(L, 2);\n return 1;\n }\n lua_pushvalue(L, 1); /* pass error message */\n lua_pushinteger(L, 2); /* skip this function and traceback */\n lua_call(L, 2, 1); /* call debug.traceback */\n return 1;\n}\n\n\nstatic int docall (lua_State *L, int narg, int clear) {\n int status;\n int base = lua_gettop(L) - narg; /* function index */\n lua_pushcfunction(L, traceback); /* push traceback function */\n lua_insert(L, base); /* put it under chunk and args */\n signal(SIGINT, laction);\n status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);\n signal(SIGINT, SIG_DFL);\n lua_remove(L, base); /* remove traceback function */\n /* force a complete garbage collection in case of errors */\n if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);\n return status;\n}\n\n\nstatic void print_version (void) {\n l_message(NULL, LUA_RELEASE \" \" LUA_COPYRIGHT);\n}\n\n\nstatic int getargs (lua_State *L, char **argv, int n) {\n int narg;\n int i;\n int argc = 0;\n while (argv[argc]) argc++; /* count total number of arguments */\n narg = argc - (n + 1); /* number of arguments to the script */\n luaL_checkstack(L, narg + 3, \"too many arguments to script\");\n for (i=n+1; i < argc; i++)\n lua_pushstring(L, argv[i]);\n lua_createtable(L, narg, n + 1);\n for (i=0; i < argc; i++) {\n lua_pushstring(L, argv[i]);\n lua_rawseti(L, -2, i - n);\n }\n return narg;\n}\n\n\nstatic int dofile (lua_State *L, const char *name) {\n int status = luaL_loadfile(L, name) || docall(L, 0, 1);\n return report(L, status);\n}\n\n\nstatic int dostring (lua_State *L, const char *s, const char *name) {\n int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);\n return report(L, status);\n}\n\n\nstatic int dolibrary (lua_State *L, const char *name) {\n lua_getglobal(L, \"require\");\n lua_pushstring(L, name);\n return report(L, docall(L, 1, 1));\n}\n\n\nstatic const char *get_prompt (lua_State *L, int firstline) {\n const char *p;\n lua_getfield(L, LUA_GLOBALSINDEX, firstline ? \"_PROMPT\" : \"_PROMPT2\");\n p = lua_tostring(L, -1);\n if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);\n lua_pop(L, 1); /* remove global */\n return p;\n}\n\n\nstatic int incomplete (lua_State *L, int status) {\n if (status == LUA_ERRSYNTAX) {\n size_t lmsg;\n const char *msg = lua_tolstring(L, -1, &lmsg);\n const char *tp = msg + lmsg - (sizeof(LUA_QL(\"\")) - 1);\n if (strstr(msg, LUA_QL(\"\")) == tp) {\n lua_pop(L, 1);\n return 1;\n }\n }\n return 0; /* else... */\n}\n\n\nstatic int pushline (lua_State *L, int firstline) {\n char buffer[LUA_MAXINPUT];\n char *b = buffer;\n size_t l;\n const char *prmt = get_prompt(L, firstline);\n if (lua_readline(L, b, prmt) == 0)\n return 0; /* no input */\n l = strlen(b);\n if (l > 0 && b[l-1] == '\\n') /* line ends with newline? */\n b[l-1] = '\\0'; /* remove it */\n if (firstline && b[0] == '=') /* first line starts with `=' ? */\n lua_pushfstring(L, \"return %s\", b+1); /* change it to `return' */\n else\n lua_pushstring(L, b);\n lua_freeline(L, b);\n return 1;\n}\n\n\nstatic int loadline (lua_State *L) {\n int status;\n lua_settop(L, 0);\n if (!pushline(L, 1))\n return -1; /* no input */\n for (;;) { /* repeat until gets a complete line */\n status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), \"=stdin\");\n if (!incomplete(L, status)) break; /* cannot try to add lines? */\n if (!pushline(L, 0)) /* no more input? */\n return -1;\n lua_pushliteral(L, \"\\n\"); /* add a new line... */\n lua_insert(L, -2); /* ...between the two lines */\n lua_concat(L, 3); /* join them */\n }\n lua_saveline(L, 1);\n lua_remove(L, 1); /* remove line */\n return status;\n}\n\n\nstatic void dotty (lua_State *L) {\n int status;\n const char *oldprogname = progname;\n progname = NULL;\n while ((status = loadline(L)) != -1) {\n if (status == 0) status = docall(L, 0, 0);\n report(L, status);\n if (status == 0 && lua_gettop(L) > 0) { /* any result to print? */\n lua_getglobal(L, \"print\");\n lua_insert(L, 1);\n if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)\n l_message(progname, lua_pushfstring(L,\n \"error calling \" LUA_QL(\"print\") \" (%s)\",\n lua_tostring(L, -1)));\n }\n }\n lua_settop(L, 0); /* clear stack */\n fputs(\"\\n\", stdout);\n fflush(stdout);\n progname = oldprogname;\n}\n\n\nstatic int handle_script (lua_State *L, char **argv, int n) {\n int status;\n const char *fname;\n int narg = getargs(L, argv, n); /* collect arguments */\n lua_setglobal(L, \"arg\");\n fname = argv[n];\n if (strcmp(fname, \"-\") == 0 && strcmp(argv[n-1], \"--\") != 0) \n fname = NULL; /* stdin */\n status = luaL_loadfile(L, fname);\n lua_insert(L, -(narg+1));\n if (status == 0)\n status = docall(L, narg, 0);\n else\n lua_pop(L, narg); \n return report(L, status);\n}\n\n\n/* check that argument has no extra characters at the end */\n#define notail(x)\t{if ((x)[2] != '\\0') return -1;}\n\n\nstatic int collectargs (char **argv, int *pi, int *pv, int *pe) {\n int i;\n for (i = 1; argv[i] != NULL; i++) {\n if (argv[i][0] != '-') /* not an option? */\n return i;\n switch (argv[i][1]) { /* option */\n case '-':\n notail(argv[i]);\n return (argv[i+1] != NULL ? i+1 : 0);\n case '\\0':\n return i;\n case 'i':\n notail(argv[i]);\n *pi = 1; /* go through */\n case 'v':\n notail(argv[i]);\n *pv = 1;\n break;\n case 'e':\n *pe = 1; /* go through */\n case 'l':\n if (argv[i][2] == '\\0') {\n i++;\n if (argv[i] == NULL) return -1;\n }\n break;\n default: return -1; /* invalid option */\n }\n }\n return 0;\n}\n\n\nstatic int runargs (lua_State *L, char **argv, int n) {\n int i;\n for (i = 1; i < n; i++) {\n if (argv[i] == NULL) continue;\n lua_assert(argv[i][0] == '-');\n switch (argv[i][1]) { /* option */\n case 'e': {\n const char *chunk = argv[i] + 2;\n if (*chunk == '\\0') chunk = argv[++i];\n lua_assert(chunk != NULL);\n if (dostring(L, chunk, \"=(command line)\") != 0)\n return 1;\n break;\n }\n case 'l': {\n const char *filename = argv[i] + 2;\n if (*filename == '\\0') filename = argv[++i];\n lua_assert(filename != NULL);\n if (dolibrary(L, filename))\n return 1; /* stop if file fails */\n break;\n }\n default: break;\n }\n }\n return 0;\n}\n\n\nstatic int handle_luainit (lua_State *L) {\n const char *init = getenv(LUA_INIT);\n if (init == NULL) return 0; /* status OK */\n else if (init[0] == '@')\n return dofile(L, init+1);\n else\n return dostring(L, init, \"=\" LUA_INIT);\n}\n\n\nstruct Smain {\n int argc;\n char **argv;\n int status;\n};\n\n\nstatic int pmain (lua_State *L) {\n struct Smain *s = (struct Smain *)lua_touserdata(L, 1);\n char **argv = s->argv;\n int script;\n int has_i = 0, has_v = 0, has_e = 0;\n globalL = L;\n if (argv[0] && argv[0][0]) progname = argv[0];\n lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */\n luaL_openlibs(L); /* open libraries */\n lua_gc(L, LUA_GCRESTART, 0);\n s->status = handle_luainit(L);\n if (s->status != 0) return 0;\n script = collectargs(argv, &has_i, &has_v, &has_e);\n if (script < 0) { /* invalid args? */\n print_usage();\n s->status = 1;\n return 0;\n }\n if (has_v) print_version();\n s->status = runargs(L, argv, (script > 0) ? script : s->argc);\n if (s->status != 0) return 0;\n if (script)\n s->status = handle_script(L, argv, script);\n if (s->status != 0) return 0;\n if (has_i)\n dotty(L);\n else if (script == 0 && !has_e && !has_v) {\n if (lua_stdin_is_tty()) {\n print_version();\n dotty(L);\n }\n else dofile(L, NULL); /* executes stdin as a file */\n }\n return 0;\n}\n\n\nint main (int argc, char **argv) {\n int status;\n struct Smain s;\n lua_State *L = lua_open(); /* create state */\n if (L == NULL) {\n l_message(argv[0], \"cannot create state: not enough memory\");\n return EXIT_FAILURE;\n }\n s.argc = argc;\n s.argv = argv;\n status = lua_cpcall(L, &pmain, &s);\n report(L, status);\n lua_close(L);\n return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;\n}\n\n" }, { "path": "deps/lua/src/lua.h", "content": "/*\n** $Id: lua.h,v 1.218.1.7 2012/01/13 20:36:20 roberto Exp $\n** Lua - An Extensible Extension Language\n** Lua.org, PUC-Rio, Brazil (http://www.lua.org)\n** See Copyright Notice at the end of this file\n*/\n\n\n#ifndef lua_h\n#define lua_h\n\n#include \n#include \n\n\n#include \"luaconf.h\"\n\n\n#define LUA_VERSION\t\"Lua 5.1\"\n#define LUA_RELEASE\t\"Lua 5.1.5\"\n#define LUA_VERSION_NUM\t501\n#define LUA_COPYRIGHT\t\"Copyright (C) 1994-2012 Lua.org, PUC-Rio\"\n#define LUA_AUTHORS \t\"R. Ierusalimschy, L. H. de Figueiredo & W. Celes\"\n\n\n/* mark for precompiled code (`Lua') */\n#define\tLUA_SIGNATURE\t\"\\033Lua\"\n\n/* option for multiple returns in `lua_pcall' and `lua_call' */\n#define LUA_MULTRET\t(-1)\n\n\n/*\n** pseudo-indices\n*/\n#define LUA_REGISTRYINDEX\t(-10000)\n#define LUA_ENVIRONINDEX\t(-10001)\n#define LUA_GLOBALSINDEX\t(-10002)\n#define lua_upvalueindex(i)\t(LUA_GLOBALSINDEX-(i))\n\n\n/* thread status; 0 is OK */\n#define LUA_YIELD\t1\n#define LUA_ERRRUN\t2\n#define LUA_ERRSYNTAX\t3\n#define LUA_ERRMEM\t4\n#define LUA_ERRERR\t5\n\n\ntypedef struct lua_State lua_State;\n\ntypedef int (*lua_CFunction) (lua_State *L);\n\n\n/*\n** functions that read/write blocks when loading/dumping Lua chunks\n*/\ntypedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);\n\ntypedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);\n\n\n/*\n** prototype for memory-allocation functions\n*/\ntypedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);\n\n\n/*\n** basic types\n*/\n#define LUA_TNONE\t\t(-1)\n\n#define LUA_TNIL\t\t0\n#define LUA_TBOOLEAN\t\t1\n#define LUA_TLIGHTUSERDATA\t2\n#define LUA_TNUMBER\t\t3\n#define LUA_TSTRING\t\t4\n#define LUA_TTABLE\t\t5\n#define LUA_TFUNCTION\t\t6\n#define LUA_TUSERDATA\t\t7\n#define LUA_TTHREAD\t\t8\n\n\n\n/* minimum Lua stack available to a C function */\n#define LUA_MINSTACK\t20\n\n\n/*\n** generic extra include file\n*/\n#if defined(LUA_USER_H)\n#include LUA_USER_H\n#endif\n\n\n/* type of numbers in Lua */\ntypedef LUA_NUMBER lua_Number;\n\n\n/* type for integer functions */\ntypedef LUA_INTEGER lua_Integer;\n\n\n\n/*\n** state manipulation\n*/\nLUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);\nLUA_API void (lua_close) (lua_State *L);\nLUA_API lua_State *(lua_newthread) (lua_State *L);\n\nLUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);\n\n\n/*\n** basic stack manipulation\n*/\nLUA_API int (lua_gettop) (lua_State *L);\nLUA_API void (lua_settop) (lua_State *L, int idx);\nLUA_API void (lua_pushvalue) (lua_State *L, int idx);\nLUA_API void (lua_remove) (lua_State *L, int idx);\nLUA_API void (lua_insert) (lua_State *L, int idx);\nLUA_API void (lua_replace) (lua_State *L, int idx);\nLUA_API int (lua_checkstack) (lua_State *L, int sz);\n\nLUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);\n\n\n/*\n** access functions (stack -> C)\n*/\n\nLUA_API int (lua_isnumber) (lua_State *L, int idx);\nLUA_API int (lua_isstring) (lua_State *L, int idx);\nLUA_API int (lua_iscfunction) (lua_State *L, int idx);\nLUA_API int (lua_isuserdata) (lua_State *L, int idx);\nLUA_API int (lua_type) (lua_State *L, int idx);\nLUA_API const char *(lua_typename) (lua_State *L, int tp);\n\nLUA_API int (lua_equal) (lua_State *L, int idx1, int idx2);\nLUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);\nLUA_API int (lua_lessthan) (lua_State *L, int idx1, int idx2);\n\nLUA_API lua_Number (lua_tonumber) (lua_State *L, int idx);\nLUA_API lua_Integer (lua_tointeger) (lua_State *L, int idx);\nLUA_API int (lua_toboolean) (lua_State *L, int idx);\nLUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);\nLUA_API size_t (lua_objlen) (lua_State *L, int idx);\nLUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);\nLUA_API void\t *(lua_touserdata) (lua_State *L, int idx);\nLUA_API lua_State *(lua_tothread) (lua_State *L, int idx);\nLUA_API const void *(lua_topointer) (lua_State *L, int idx);\n\n\n/*\n** push functions (C -> stack)\n*/\nLUA_API void (lua_pushnil) (lua_State *L);\nLUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);\nLUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);\nLUA_API void (lua_pushlstring) (lua_State *L, const char *s, size_t l);\nLUA_API void (lua_pushstring) (lua_State *L, const char *s);\nLUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,\n va_list argp);\nLUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);\nLUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);\nLUA_API void (lua_pushboolean) (lua_State *L, int b);\nLUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);\nLUA_API int (lua_pushthread) (lua_State *L);\n\n\n/*\n** get functions (Lua -> stack)\n*/\nLUA_API void (lua_gettable) (lua_State *L, int idx);\nLUA_API void (lua_getfield) (lua_State *L, int idx, const char *k);\nLUA_API void (lua_rawget) (lua_State *L, int idx);\nLUA_API void (lua_rawgeti) (lua_State *L, int idx, int n);\nLUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);\nLUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);\nLUA_API int (lua_getmetatable) (lua_State *L, int objindex);\nLUA_API void (lua_getfenv) (lua_State *L, int idx);\n\n\n/*\n** set functions (stack -> Lua)\n*/\nLUA_API void (lua_settable) (lua_State *L, int idx);\nLUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);\nLUA_API void (lua_rawset) (lua_State *L, int idx);\nLUA_API void (lua_rawseti) (lua_State *L, int idx, int n);\nLUA_API int (lua_setmetatable) (lua_State *L, int objindex);\nLUA_API int (lua_setfenv) (lua_State *L, int idx);\n\n\n/*\n** `load' and `call' functions (load and run Lua code)\n*/\nLUA_API void (lua_call) (lua_State *L, int nargs, int nresults);\nLUA_API int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);\nLUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);\nLUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,\n const char *chunkname);\n\nLUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);\n\n\n/*\n** coroutine functions\n*/\nLUA_API int (lua_yield) (lua_State *L, int nresults);\nLUA_API int (lua_resume) (lua_State *L, int narg);\nLUA_API int (lua_status) (lua_State *L);\n\n/*\n** garbage-collection function and options\n*/\n\n#define LUA_GCSTOP\t\t0\n#define LUA_GCRESTART\t\t1\n#define LUA_GCCOLLECT\t\t2\n#define LUA_GCCOUNT\t\t3\n#define LUA_GCCOUNTB\t\t4\n#define LUA_GCSTEP\t\t5\n#define LUA_GCSETPAUSE\t\t6\n#define LUA_GCSETSTEPMUL\t7\n\nLUA_API int (lua_gc) (lua_State *L, int what, int data);\n\n\n/*\n** miscellaneous functions\n*/\n\nLUA_API int (lua_error) (lua_State *L);\n\nLUA_API int (lua_next) (lua_State *L, int idx);\n\nLUA_API void (lua_concat) (lua_State *L, int n);\n\nLUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);\nLUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);\n\n\n\n/* \n** ===============================================================\n** some useful macros\n** ===============================================================\n*/\n\n#define lua_pop(L,n)\t\tlua_settop(L, -(n)-1)\n\n#define lua_newtable(L)\t\tlua_createtable(L, 0, 0)\n\n#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))\n\n#define lua_pushcfunction(L,f)\tlua_pushcclosure(L, (f), 0)\n\n#define lua_strlen(L,i)\t\tlua_objlen(L, (i))\n\n#define lua_isfunction(L,n)\t(lua_type(L, (n)) == LUA_TFUNCTION)\n#define lua_istable(L,n)\t(lua_type(L, (n)) == LUA_TTABLE)\n#define lua_islightuserdata(L,n)\t(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)\n#define lua_isnil(L,n)\t\t(lua_type(L, (n)) == LUA_TNIL)\n#define lua_isboolean(L,n)\t(lua_type(L, (n)) == LUA_TBOOLEAN)\n#define lua_isthread(L,n)\t(lua_type(L, (n)) == LUA_TTHREAD)\n#define lua_isnone(L,n)\t\t(lua_type(L, (n)) == LUA_TNONE)\n#define lua_isnoneornil(L, n)\t(lua_type(L, (n)) <= 0)\n\n#define lua_pushliteral(L, s)\t\\\n\tlua_pushlstring(L, \"\" s, (sizeof(s)/sizeof(char))-1)\n\n#define lua_setglobal(L,s)\tlua_setfield(L, LUA_GLOBALSINDEX, (s))\n#define lua_getglobal(L,s)\tlua_getfield(L, LUA_GLOBALSINDEX, (s))\n\n#define lua_tostring(L,i)\tlua_tolstring(L, (i), NULL)\n\n\n\n/*\n** compatibility macros and functions\n*/\n\n#define lua_open()\tluaL_newstate()\n\n#define lua_getregistry(L)\tlua_pushvalue(L, LUA_REGISTRYINDEX)\n\n#define lua_getgccount(L)\tlua_gc(L, LUA_GCCOUNT, 0)\n\n#define lua_Chunkreader\t\tlua_Reader\n#define lua_Chunkwriter\t\tlua_Writer\n\n\n/* hack */\nLUA_API void lua_setlevel\t(lua_State *from, lua_State *to);\n\n\n/*\n** {======================================================================\n** Debug API\n** =======================================================================\n*/\n\n\n/*\n** Event codes\n*/\n#define LUA_HOOKCALL\t0\n#define LUA_HOOKRET\t1\n#define LUA_HOOKLINE\t2\n#define LUA_HOOKCOUNT\t3\n#define LUA_HOOKTAILRET 4\n\n\n/*\n** Event masks\n*/\n#define LUA_MASKCALL\t(1 << LUA_HOOKCALL)\n#define LUA_MASKRET\t(1 << LUA_HOOKRET)\n#define LUA_MASKLINE\t(1 << LUA_HOOKLINE)\n#define LUA_MASKCOUNT\t(1 << LUA_HOOKCOUNT)\n\ntypedef struct lua_Debug lua_Debug; /* activation record */\n\n\n/* Functions to be called by the debuger in specific events */\ntypedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);\n\n\nLUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);\nLUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);\nLUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);\nLUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);\nLUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);\nLUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);\n\nLUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);\nLUA_API lua_Hook lua_gethook (lua_State *L);\nLUA_API int lua_gethookmask (lua_State *L);\nLUA_API int lua_gethookcount (lua_State *L);\n\n\nstruct lua_Debug {\n int event;\n const char *name;\t/* (n) */\n const char *namewhat;\t/* (n) `global', `local', `field', `method' */\n const char *what;\t/* (S) `Lua', `C', `main', `tail' */\n const char *source;\t/* (S) */\n int currentline;\t/* (l) */\n int nups;\t\t/* (u) number of upvalues */\n int linedefined;\t/* (S) */\n int lastlinedefined;\t/* (S) */\n char short_src[LUA_IDSIZE]; /* (S) */\n /* private part */\n int i_ci; /* active function */\n};\n\nLUA_API void lua_enablereadonlytable (lua_State *L, int index, int enabled);\nLUA_API int lua_isreadonlytable (lua_State *L, int index);\n\n/* }====================================================================== */\n\n\n/******************************************************************************\n* Copyright (C) 1994-2012 Lua.org, PUC-Rio. All rights reserved.\n*\n* Permission is hereby granted, free of charge, to any person obtaining\n* a copy of this software and associated documentation files (the\n* \"Software\"), to deal in the Software without restriction, including\n* without limitation the rights to use, copy, modify, merge, publish,\n* distribute, sublicense, and/or sell copies of the Software, and to\n* permit persons to whom the Software is furnished to do so, subject to\n* the following conditions:\n*\n* The above copyright notice and this permission notice shall be\n* included in all copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n******************************************************************************/\n\n\n#endif\n" }, { "path": "deps/lua/src/lua_bit.c", "content": "/*\n** Lua BitOp -- a bit operations library for Lua 5.1/5.2.\n** http://bitop.luajit.org/\n**\n** Copyright (C) 2008-2012 Mike Pall. All rights reserved.\n**\n** Permission is hereby granted, free of charge, to any person obtaining\n** a copy of this software and associated documentation files (the\n** \"Software\"), to deal in the Software without restriction, including\n** without limitation the rights to use, copy, modify, merge, publish,\n** distribute, sublicense, and/or sell copies of the Software, and to\n** permit persons to whom the Software is furnished to do so, subject to\n** the following conditions:\n**\n** The above copyright notice and this permission notice shall be\n** included in all copies or substantial portions of the Software.\n**\n** THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n**\n** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]\n*/\n\n#define LUA_BITOP_VERSION\t\"1.0.2\"\n\n#define LUA_LIB\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\n#ifdef _MSC_VER\n/* MSVC is stuck in the last century and doesn't have C99's stdint.h. */\ntypedef __int32 int32_t;\ntypedef unsigned __int32 uint32_t;\ntypedef unsigned __int64 uint64_t;\n#else\n#include \n#endif\n\ntypedef int32_t SBits;\ntypedef uint32_t UBits;\n\ntypedef union {\n lua_Number n;\n#ifdef LUA_NUMBER_DOUBLE\n uint64_t b;\n#else\n UBits b;\n#endif\n} BitNum;\n\n/* Convert argument to bit type. */\nstatic UBits barg(lua_State *L, int idx)\n{\n BitNum bn;\n UBits b;\n#if LUA_VERSION_NUM < 502\n bn.n = lua_tonumber(L, idx);\n#else\n bn.n = luaL_checknumber(L, idx);\n#endif\n#if defined(LUA_NUMBER_DOUBLE)\n bn.n += 6755399441055744.0; /* 2^52+2^51 */\n#ifdef SWAPPED_DOUBLE\n b = (UBits)(bn.b >> 32);\n#else\n b = (UBits)bn.b;\n#endif\n#elif defined(LUA_NUMBER_INT) || defined(LUA_NUMBER_LONG) || \\\n defined(LUA_NUMBER_LONGLONG) || defined(LUA_NUMBER_LONG_LONG) || \\\n defined(LUA_NUMBER_LLONG)\n if (sizeof(UBits) == sizeof(lua_Number))\n b = bn.b;\n else\n b = (UBits)(SBits)bn.n;\n#elif defined(LUA_NUMBER_FLOAT)\n#error \"A 'float' lua_Number type is incompatible with this library\"\n#else\n#error \"Unknown number type, check LUA_NUMBER_* in luaconf.h\"\n#endif\n#if LUA_VERSION_NUM < 502\n if (b == 0 && !lua_isnumber(L, idx)) {\n luaL_typerror(L, idx, \"number\");\n }\n#endif\n return b;\n}\n\n/* Return bit type. */\n#define BRET(b) lua_pushnumber(L, (lua_Number)(SBits)(b)); return 1;\n\nstatic int bit_tobit(lua_State *L) { BRET(barg(L, 1)) }\nstatic int bit_bnot(lua_State *L) { BRET(~barg(L, 1)) }\n\n#define BIT_OP(func, opr) \\\n static int func(lua_State *L) { int i; UBits b = barg(L, 1); \\\n for (i = lua_gettop(L); i > 1; i--) b opr barg(L, i); \\\n BRET(b) }\nBIT_OP(bit_band, &=)\nBIT_OP(bit_bor, |=)\nBIT_OP(bit_bxor, ^=)\n\n#define bshl(b, n) (b << n)\n#define bshr(b, n) (b >> n)\n#define bsar(b, n) ((SBits)b >> n)\n#define brol(b, n) ((b << n) | (b >> (32-n)))\n#define bror(b, n) ((b << (32-n)) | (b >> n))\n#define BIT_SH(func, fn) \\\n static int func(lua_State *L) { \\\n UBits b = barg(L, 1); UBits n = barg(L, 2) & 31; BRET(fn(b, n)) }\nBIT_SH(bit_lshift, bshl)\nBIT_SH(bit_rshift, bshr)\nBIT_SH(bit_arshift, bsar)\nBIT_SH(bit_rol, brol)\nBIT_SH(bit_ror, bror)\n\nstatic int bit_bswap(lua_State *L)\n{\n UBits b = barg(L, 1);\n b = (b >> 24) | ((b >> 8) & 0xff00) | ((b & 0xff00) << 8) | (b << 24);\n BRET(b)\n}\n\nstatic int bit_tohex(lua_State *L)\n{\n UBits b = barg(L, 1);\n SBits n = lua_isnone(L, 2) ? 8 : (SBits)barg(L, 2);\n const char *hexdigits = \"0123456789abcdef\";\n char buf[8];\n int i;\n if (n == INT32_MIN) n = INT32_MIN+1;\n if (n < 0) { n = -n; hexdigits = \"0123456789ABCDEF\"; }\n if (n > 8) n = 8;\n for (i = (int)n; --i >= 0; ) { buf[i] = hexdigits[b & 15]; b >>= 4; }\n lua_pushlstring(L, buf, (size_t)n);\n return 1;\n}\n\nstatic const struct luaL_Reg bit_funcs[] = {\n { \"tobit\",\tbit_tobit },\n { \"bnot\",\tbit_bnot },\n { \"band\",\tbit_band },\n { \"bor\",\tbit_bor },\n { \"bxor\",\tbit_bxor },\n { \"lshift\",\tbit_lshift },\n { \"rshift\",\tbit_rshift },\n { \"arshift\",\tbit_arshift },\n { \"rol\",\tbit_rol },\n { \"ror\",\tbit_ror },\n { \"bswap\",\tbit_bswap },\n { \"tohex\",\tbit_tohex },\n { NULL, NULL }\n};\n\n/* Signed right-shifts are implementation-defined per C89/C99.\n** But the de facto standard are arithmetic right-shifts on two's\n** complement CPUs. This behaviour is required here, so test for it.\n*/\n#define BAD_SAR\t\t(bsar(-8, 2) != (SBits)-2)\n\nLUALIB_API int luaopen_bit(lua_State *L)\n{\n UBits b;\n lua_pushnumber(L, (lua_Number)1437217655L);\n b = barg(L, -1);\n if (b != (UBits)1437217655L || BAD_SAR) { /* Perform a simple self-test. */\n const char *msg = \"compiled with incompatible luaconf.h\";\n#ifdef LUA_NUMBER_DOUBLE\n#ifdef _WIN32\n if (b == (UBits)1610612736L)\n msg = \"use D3DCREATE_FPU_PRESERVE with DirectX\";\n#endif\n if (b == (UBits)1127743488L)\n msg = \"not compiled with SWAPPED_DOUBLE\";\n#endif\n if (BAD_SAR)\n msg = \"arithmetic right-shift broken\";\n luaL_error(L, \"bit library self-test failed (%s)\", msg);\n }\n#if LUA_VERSION_NUM < 502\n luaL_register(L, \"bit\", bit_funcs);\n#else\n luaL_newlib(L, bit_funcs);\n#endif\n return 1;\n}\n\n" }, { "path": "deps/lua/src/lua_cjson.c", "content": "/* Lua CJSON - JSON support for Lua\n *\n * Copyright (c) 2010-2012 Mark Pulford \n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n/* Caveats:\n * - JSON \"null\" values are represented as lightuserdata since Lua\n * tables cannot contain \"nil\". Compare with cjson.null.\n * - Invalid UTF-8 characters are not detected and will be passed\n * untouched. If required, UTF-8 error checking should be done\n * outside this library.\n * - Javascript comments are not part of the JSON spec, and are not\n * currently supported.\n *\n * Note: Decoding is slower than encoding. Lua spends significant\n * time (30%) managing tables when parsing JSON since it is\n * difficult to know object/array sizes ahead of time.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \"lua.h\"\n#include \"lauxlib.h\"\n\n#include \"strbuf.h\"\n#include \"fpconv.h\"\n\n#include \"../../../src/solarisfixes.h\"\n\n#ifndef CJSON_MODNAME\n#define CJSON_MODNAME \"cjson\"\n#endif\n\n#ifndef CJSON_VERSION\n#define CJSON_VERSION \"2.1.0\"\n#endif\n\n/* Workaround for Solaris platforms missing isinf() */\n#if !defined(isinf) && (defined(USE_INTERNAL_ISINF) || defined(MISSING_ISINF))\n#define isinf(x) (!isnan(x) && isnan((x) - (x)))\n#endif\n\n#define DEFAULT_SPARSE_CONVERT 0\n#define DEFAULT_SPARSE_RATIO 2\n#define DEFAULT_SPARSE_SAFE 10\n#define DEFAULT_ENCODE_MAX_DEPTH 1000\n#define DEFAULT_DECODE_MAX_DEPTH 1000\n#define DEFAULT_ENCODE_INVALID_NUMBERS 0\n#define DEFAULT_DECODE_INVALID_NUMBERS 1\n#define DEFAULT_ENCODE_KEEP_BUFFER 1\n#define DEFAULT_ENCODE_NUMBER_PRECISION 14\n#define DEFAULT_DECODE_ARRAY_WITH_ARRAY_MT 0\n\n#ifdef DISABLE_INVALID_NUMBERS\n#undef DEFAULT_DECODE_INVALID_NUMBERS\n#define DEFAULT_DECODE_INVALID_NUMBERS 0\n#endif\n\ntypedef enum {\n T_OBJ_BEGIN,\n T_OBJ_END,\n T_ARR_BEGIN,\n T_ARR_END,\n T_STRING,\n T_NUMBER,\n T_BOOLEAN,\n T_NULL,\n T_COLON,\n T_COMMA,\n T_END,\n T_WHITESPACE,\n T_ERROR,\n T_UNKNOWN\n} json_token_type_t;\n\nstatic const char *json_token_type_name[] = {\n \"T_OBJ_BEGIN\",\n \"T_OBJ_END\",\n \"T_ARR_BEGIN\",\n \"T_ARR_END\",\n \"T_STRING\",\n \"T_NUMBER\",\n \"T_BOOLEAN\",\n \"T_NULL\",\n \"T_COLON\",\n \"T_COMMA\",\n \"T_END\",\n \"T_WHITESPACE\",\n \"T_ERROR\",\n \"T_UNKNOWN\",\n NULL\n};\n\ntypedef struct {\n json_token_type_t ch2token[256];\n char escape2char[256]; /* Decoding */\n\n /* encode_buf is only allocated and used when\n * encode_keep_buffer is set */\n strbuf_t encode_buf;\n\n int encode_sparse_convert;\n int encode_sparse_ratio;\n int encode_sparse_safe;\n int encode_max_depth;\n int encode_invalid_numbers; /* 2 => Encode as \"null\" */\n int encode_number_precision;\n int encode_keep_buffer;\n\n int decode_invalid_numbers;\n int decode_max_depth;\n int decode_array_with_array_mt;\n} json_config_t;\n\ntypedef struct {\n const char *data;\n const char *ptr;\n strbuf_t *tmp; /* Temporary storage for strings */\n json_config_t *cfg;\n int current_depth;\n} json_parse_t;\n\ntypedef struct {\n json_token_type_t type;\n size_t index;\n union {\n const char *string;\n double number;\n int boolean;\n } value;\n size_t string_len;\n} json_token_t;\n\nstatic const char *char2escape[256] = {\n \"\\\\u0000\", \"\\\\u0001\", \"\\\\u0002\", \"\\\\u0003\",\n \"\\\\u0004\", \"\\\\u0005\", \"\\\\u0006\", \"\\\\u0007\",\n \"\\\\b\", \"\\\\t\", \"\\\\n\", \"\\\\u000b\",\n \"\\\\f\", \"\\\\r\", \"\\\\u000e\", \"\\\\u000f\",\n \"\\\\u0010\", \"\\\\u0011\", \"\\\\u0012\", \"\\\\u0013\",\n \"\\\\u0014\", \"\\\\u0015\", \"\\\\u0016\", \"\\\\u0017\",\n \"\\\\u0018\", \"\\\\u0019\", \"\\\\u001a\", \"\\\\u001b\",\n \"\\\\u001c\", \"\\\\u001d\", \"\\\\u001e\", \"\\\\u001f\",\n NULL, NULL, \"\\\\\\\"\", NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, \"\\\\/\",\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, \"\\\\\\\\\", NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, \"\\\\u007f\",\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,\n};\n\n/* ===== CONFIGURATION ===== */\n\nstatic json_config_t *json_fetch_config(lua_State *l)\n{\n json_config_t *cfg;\n\n cfg = lua_touserdata(l, lua_upvalueindex(1));\n if (!cfg)\n luaL_error(l, \"BUG: Unable to fetch CJSON configuration\");\n\n return cfg;\n}\n\n/* Ensure the correct number of arguments have been provided.\n * Pad with nil to allow other functions to simply check arg[i]\n * to find whether an argument was provided */\nstatic json_config_t *json_arg_init(lua_State *l, int args)\n{\n luaL_argcheck(l, lua_gettop(l) <= args, args + 1,\n \"found too many arguments\");\n\n while (lua_gettop(l) < args)\n lua_pushnil(l);\n\n return json_fetch_config(l);\n}\n\n/* Process integer options for configuration functions */\nstatic int json_integer_option(lua_State *l, int optindex, int *setting,\n int min, int max)\n{\n char errmsg[64];\n int value;\n\n if (!lua_isnil(l, optindex)) {\n value = luaL_checkinteger(l, optindex);\n snprintf(errmsg, sizeof(errmsg), \"expected integer between %d and %d\", min, max);\n luaL_argcheck(l, min <= value && value <= max, 1, errmsg);\n *setting = value;\n }\n\n lua_pushinteger(l, *setting);\n\n return 1;\n}\n\n/* Process enumerated arguments for a configuration function */\nstatic int json_enum_option(lua_State *l, int optindex, int *setting,\n const char **options, int bool_true)\n{\n static const char *bool_options[] = { \"off\", \"on\", NULL };\n\n if (!options) {\n options = bool_options;\n bool_true = 1;\n }\n\n if (!lua_isnil(l, optindex)) {\n if (bool_true && lua_isboolean(l, optindex))\n *setting = lua_toboolean(l, optindex) * bool_true;\n else\n *setting = luaL_checkoption(l, optindex, NULL, options);\n }\n\n if (bool_true && (*setting == 0 || *setting == bool_true))\n lua_pushboolean(l, *setting);\n else\n lua_pushstring(l, options[*setting]);\n\n return 1;\n}\n\n/* Configures handling of extremely sparse arrays:\n * convert: Convert extremely sparse arrays into objects? Otherwise error.\n * ratio: 0: always allow sparse; 1: never allow sparse; >1: use ratio\n * safe: Always use an array when the max index <= safe */\nstatic int json_cfg_encode_sparse_array(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 3);\n\n json_enum_option(l, 1, &cfg->encode_sparse_convert, NULL, 1);\n json_integer_option(l, 2, &cfg->encode_sparse_ratio, 0, INT_MAX);\n json_integer_option(l, 3, &cfg->encode_sparse_safe, 0, INT_MAX);\n\n return 3;\n}\n\n/* Configures the maximum number of nested arrays/objects allowed when\n * encoding */\nstatic int json_cfg_encode_max_depth(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n\n return json_integer_option(l, 1, &cfg->encode_max_depth, 1, INT_MAX);\n}\n\n/* Configures the maximum number of nested arrays/objects allowed when\n * encoding */\nstatic int json_cfg_decode_max_depth(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n\n return json_integer_option(l, 1, &cfg->decode_max_depth, 1, INT_MAX);\n}\n\n/* Configures number precision when converting doubles to text */\nstatic int json_cfg_encode_number_precision(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n\n return json_integer_option(l, 1, &cfg->encode_number_precision, 1, 14);\n}\n\n/* Configures how to decode arrays */\nstatic int json_cfg_decode_array_with_array_mt(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n\n return json_enum_option(l, 1, &cfg->decode_array_with_array_mt, NULL, 1);\n}\n\n/* Configures JSON encoding buffer persistence */\nstatic int json_cfg_encode_keep_buffer(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n int old_value;\n\n old_value = cfg->encode_keep_buffer;\n\n json_enum_option(l, 1, &cfg->encode_keep_buffer, NULL, 1);\n\n /* Init / free the buffer if the setting has changed */\n if (old_value ^ cfg->encode_keep_buffer) {\n if (cfg->encode_keep_buffer)\n strbuf_init(&cfg->encode_buf, 0);\n else\n strbuf_free(&cfg->encode_buf);\n }\n\n return 1;\n}\n\n#if defined(DISABLE_INVALID_NUMBERS) && !defined(USE_INTERNAL_FPCONV)\nvoid json_verify_invalid_number_setting(lua_State *l, int *setting)\n{\n if (*setting == 1) {\n *setting = 0;\n luaL_error(l, \"Infinity, NaN, and/or hexadecimal numbers are not supported.\");\n }\n}\n#else\n#define json_verify_invalid_number_setting(l, s) do { } while(0)\n#endif\n\nstatic int json_cfg_encode_invalid_numbers(lua_State *l)\n{\n static const char *options[] = { \"off\", \"on\", \"null\", NULL };\n json_config_t *cfg = json_arg_init(l, 1);\n\n json_enum_option(l, 1, &cfg->encode_invalid_numbers, options, 1);\n\n json_verify_invalid_number_setting(l, &cfg->encode_invalid_numbers);\n\n return 1;\n}\n\nstatic int json_cfg_decode_invalid_numbers(lua_State *l)\n{\n json_config_t *cfg = json_arg_init(l, 1);\n\n json_enum_option(l, 1, &cfg->decode_invalid_numbers, NULL, 1);\n\n json_verify_invalid_number_setting(l, &cfg->encode_invalid_numbers);\n\n return 1;\n}\n\nstatic int json_destroy_config(lua_State *l)\n{\n json_config_t *cfg;\n\n cfg = lua_touserdata(l, 1);\n if (cfg)\n strbuf_free(&cfg->encode_buf);\n cfg = NULL;\n\n return 0;\n}\n\nstatic void json_create_config(lua_State *l)\n{\n json_config_t *cfg;\n int i;\n\n cfg = lua_newuserdata(l, sizeof(*cfg));\n\n /* Create GC method to clean up strbuf */\n lua_newtable(l);\n lua_pushcfunction(l, json_destroy_config);\n lua_setfield(l, -2, \"__gc\");\n lua_setmetatable(l, -2);\n\n cfg->encode_sparse_convert = DEFAULT_SPARSE_CONVERT;\n cfg->encode_sparse_ratio = DEFAULT_SPARSE_RATIO;\n cfg->encode_sparse_safe = DEFAULT_SPARSE_SAFE;\n cfg->encode_max_depth = DEFAULT_ENCODE_MAX_DEPTH;\n cfg->decode_max_depth = DEFAULT_DECODE_MAX_DEPTH;\n cfg->encode_invalid_numbers = DEFAULT_ENCODE_INVALID_NUMBERS;\n cfg->decode_invalid_numbers = DEFAULT_DECODE_INVALID_NUMBERS;\n cfg->encode_keep_buffer = DEFAULT_ENCODE_KEEP_BUFFER;\n cfg->encode_number_precision = DEFAULT_ENCODE_NUMBER_PRECISION;\n cfg->decode_array_with_array_mt = DEFAULT_DECODE_ARRAY_WITH_ARRAY_MT;\n\n#if DEFAULT_ENCODE_KEEP_BUFFER > 0\n strbuf_init(&cfg->encode_buf, 0);\n#endif\n\n /* Decoding init */\n\n /* Tag all characters as an error */\n for (i = 0; i < 256; i++)\n cfg->ch2token[i] = T_ERROR;\n\n /* Set tokens that require no further processing */\n cfg->ch2token['{'] = T_OBJ_BEGIN;\n cfg->ch2token['}'] = T_OBJ_END;\n cfg->ch2token['['] = T_ARR_BEGIN;\n cfg->ch2token[']'] = T_ARR_END;\n cfg->ch2token[','] = T_COMMA;\n cfg->ch2token[':'] = T_COLON;\n cfg->ch2token['\\0'] = T_END;\n cfg->ch2token[' '] = T_WHITESPACE;\n cfg->ch2token['\\t'] = T_WHITESPACE;\n cfg->ch2token['\\n'] = T_WHITESPACE;\n cfg->ch2token['\\r'] = T_WHITESPACE;\n\n /* Update characters that require further processing */\n cfg->ch2token['f'] = T_UNKNOWN; /* false? */\n cfg->ch2token['i'] = T_UNKNOWN; /* inf, ininity? */\n cfg->ch2token['I'] = T_UNKNOWN;\n cfg->ch2token['n'] = T_UNKNOWN; /* null, nan? */\n cfg->ch2token['N'] = T_UNKNOWN;\n cfg->ch2token['t'] = T_UNKNOWN; /* true? */\n cfg->ch2token['\"'] = T_UNKNOWN; /* string? */\n cfg->ch2token['+'] = T_UNKNOWN; /* number? */\n cfg->ch2token['-'] = T_UNKNOWN;\n for (i = 0; i < 10; i++)\n cfg->ch2token['0' + i] = T_UNKNOWN;\n\n /* Lookup table for parsing escape characters */\n for (i = 0; i < 256; i++)\n cfg->escape2char[i] = 0; /* String error */\n cfg->escape2char['\"'] = '\"';\n cfg->escape2char['\\\\'] = '\\\\';\n cfg->escape2char['/'] = '/';\n cfg->escape2char['b'] = '\\b';\n cfg->escape2char['t'] = '\\t';\n cfg->escape2char['n'] = '\\n';\n cfg->escape2char['f'] = '\\f';\n cfg->escape2char['r'] = '\\r';\n cfg->escape2char['u'] = 'u'; /* Unicode parsing required */\n}\n\n/* ===== ENCODING ===== */\n\nstatic void json_encode_exception(lua_State *l, json_config_t *cfg, strbuf_t *json, int lindex,\n const char *reason)\n{\n if (!cfg->encode_keep_buffer)\n strbuf_free(json);\n luaL_error(l, \"Cannot serialise %s: %s\",\n lua_typename(l, lua_type(l, lindex)), reason);\n}\n\n/* json_append_string args:\n * - lua_State\n * - JSON strbuf\n * - String (Lua stack index)\n *\n * Returns nothing. Doesn't remove string from Lua stack */\nstatic void json_append_string(lua_State *l, strbuf_t *json, int lindex)\n{\n const char *escstr;\n const char *str;\n size_t i, len;\n\n str = lua_tolstring(l, lindex, &len);\n\n /* Worst case is len * 6 (all unicode escapes).\n * This buffer is reused constantly for small strings\n * If there are any excess pages, they won't be hit anyway.\n * This gains ~5% speedup. */\n if (len > SIZE_MAX / 6 - 3)\n abort(); /* Overflow check */\n strbuf_ensure_empty_length(json, len * 6 + 2);\n\n strbuf_append_char_unsafe(json, '\\\"');\n for (i = 0; i < len; i++) {\n escstr = char2escape[(unsigned char)str[i]];\n if (escstr)\n strbuf_append_string(json, escstr);\n else\n strbuf_append_char_unsafe(json, str[i]);\n }\n strbuf_append_char_unsafe(json, '\\\"');\n}\n\n/* Find the size of the array on the top of the Lua stack\n * -1 object (not a pure array)\n * >=0 elements in array\n */\nstatic int lua_array_length(lua_State *l, json_config_t *cfg, strbuf_t *json)\n{\n double k;\n int max;\n int items;\n\n max = 0;\n items = 0;\n\n lua_pushnil(l);\n /* table, startkey */\n while (lua_next(l, -2) != 0) {\n /* table, key, value */\n if (lua_type(l, -2) == LUA_TNUMBER &&\n (k = lua_tonumber(l, -2))) {\n /* Integer >= 1 ? */\n if (floor(k) == k && k >= 1) {\n if (k > max)\n max = k;\n items++;\n lua_pop(l, 1);\n continue;\n }\n }\n\n /* Must not be an array (non integer key) */\n lua_pop(l, 2);\n return -1;\n }\n\n /* Encode excessively sparse arrays as objects (if enabled) */\n if (cfg->encode_sparse_ratio > 0 &&\n max > items * cfg->encode_sparse_ratio &&\n max > cfg->encode_sparse_safe) {\n if (!cfg->encode_sparse_convert)\n json_encode_exception(l, cfg, json, -1, \"excessively sparse array\");\n\n return -1;\n }\n\n return max;\n}\n\nstatic void json_check_encode_depth(lua_State *l, json_config_t *cfg,\n int current_depth, strbuf_t *json)\n{\n /* Ensure there are enough slots free to traverse a table (key,\n * value) and push a string for a potential error message.\n *\n * Unlike \"decode\", the key and value are still on the stack when\n * lua_checkstack() is called. Hence an extra slot for luaL_error()\n * below is required just in case the next check to lua_checkstack()\n * fails.\n *\n * While this won't cause a crash due to the EXTRA_STACK reserve\n * slots, it would still be an improper use of the API. */\n if (current_depth <= cfg->encode_max_depth && lua_checkstack(l, 3))\n return;\n\n if (!cfg->encode_keep_buffer)\n strbuf_free(json);\n\n luaL_error(l, \"Cannot serialise, excessive nesting (%d)\",\n current_depth);\n}\n\nstatic void json_append_data(lua_State *l, json_config_t *cfg,\n int current_depth, strbuf_t *json);\n\n/* json_append_array args:\n * - lua_State\n * - JSON strbuf\n * - Size of passwd Lua array (top of stack) */\nstatic void json_append_array(lua_State *l, json_config_t *cfg, int current_depth,\n strbuf_t *json, int array_length)\n{\n int comma, i;\n\n strbuf_append_char(json, '[');\n\n comma = 0;\n for (i = 1; i <= array_length; i++) {\n if (comma)\n strbuf_append_char(json, ',');\n else\n comma = 1;\n\n lua_rawgeti(l, -1, i);\n json_append_data(l, cfg, current_depth, json);\n lua_pop(l, 1);\n }\n\n strbuf_append_char(json, ']');\n}\n\nstatic void json_append_number(lua_State *l, json_config_t *cfg,\n strbuf_t *json, int lindex)\n{\n double num = lua_tonumber(l, lindex);\n int len;\n\n if (cfg->encode_invalid_numbers == 0) {\n /* Prevent encoding invalid numbers */\n if (isinf(num) || isnan(num))\n json_encode_exception(l, cfg, json, lindex, \"must not be NaN or Inf\");\n } else if (cfg->encode_invalid_numbers == 1) {\n /* Encode invalid numbers, but handle \"nan\" separately\n * since some platforms may encode as \"-nan\". */\n if (isnan(num)) {\n strbuf_append_mem(json, \"nan\", 3);\n return;\n }\n } else {\n /* Encode invalid numbers as \"null\" */\n if (isinf(num) || isnan(num)) {\n strbuf_append_mem(json, \"null\", 4);\n return;\n }\n }\n\n strbuf_ensure_empty_length(json, FPCONV_G_FMT_BUFSIZE);\n len = fpconv_g_fmt(strbuf_empty_ptr(json), num, cfg->encode_number_precision);\n strbuf_extend_length(json, len);\n}\n\nstatic void json_append_object(lua_State *l, json_config_t *cfg,\n int current_depth, strbuf_t *json)\n{\n int comma, keytype;\n\n /* Object */\n strbuf_append_char(json, '{');\n\n lua_pushnil(l);\n /* table, startkey */\n comma = 0;\n while (lua_next(l, -2) != 0) {\n if (comma)\n strbuf_append_char(json, ',');\n else\n comma = 1;\n\n /* table, key, value */\n keytype = lua_type(l, -2);\n if (keytype == LUA_TNUMBER) {\n strbuf_append_char(json, '\"');\n json_append_number(l, cfg, json, -2);\n strbuf_append_mem(json, \"\\\":\", 2);\n } else if (keytype == LUA_TSTRING) {\n json_append_string(l, json, -2);\n strbuf_append_char(json, ':');\n } else {\n json_encode_exception(l, cfg, json, -2,\n \"table key must be a number or string\");\n /* never returns */\n }\n\n /* table, key, value */\n json_append_data(l, cfg, current_depth, json);\n lua_pop(l, 1);\n /* table, key */\n }\n\n strbuf_append_char(json, '}');\n}\n\n/* Serialise Lua data into JSON string. */\nstatic void json_append_data(lua_State *l, json_config_t *cfg,\n int current_depth, strbuf_t *json)\n{\n int len;\n\n switch (lua_type(l, -1)) {\n case LUA_TSTRING:\n json_append_string(l, json, -1);\n break;\n case LUA_TNUMBER:\n json_append_number(l, cfg, json, -1);\n break;\n case LUA_TBOOLEAN:\n if (lua_toboolean(l, -1))\n strbuf_append_mem(json, \"true\", 4);\n else\n strbuf_append_mem(json, \"false\", 5);\n break;\n case LUA_TTABLE:\n current_depth++;\n json_check_encode_depth(l, cfg, current_depth, json);\n\n /* Check if this is an array */\n int as_array = 0;\n if (!lua_checkstack(l, 2))\n luaL_error(l, \"max lua stack reached\");\n if (lua_getmetatable(l, -1)) {\n lua_getfield(l, -1, \"__is_cjson_array\");\n as_array = lua_toboolean(l, -1);\n lua_pop(l, 2); /* pop value and metatable */\n }\n\n if (as_array) {\n len = lua_objlen(l, -1);\n json_append_array(l, cfg, current_depth, json, len);\n break;\n }\n \n len = lua_array_length(l, cfg, json);\n if (len > 0)\n json_append_array(l, cfg, current_depth, json, len);\n else\n json_append_object(l, cfg, current_depth, json);\n break;\n case LUA_TNIL:\n strbuf_append_mem(json, \"null\", 4);\n break;\n case LUA_TLIGHTUSERDATA:\n if (lua_touserdata(l, -1) == NULL) {\n strbuf_append_mem(json, \"null\", 4);\n break;\n }\n default:\n /* Remaining types (LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,\n * and LUA_TLIGHTUSERDATA) cannot be serialised */\n json_encode_exception(l, cfg, json, -1, \"type not supported\");\n /* never returns */\n }\n}\n\nstatic int json_encode(lua_State *l)\n{\n json_config_t *cfg = json_fetch_config(l);\n strbuf_t local_encode_buf;\n strbuf_t *encode_buf;\n char *json;\n size_t len;\n\n luaL_argcheck(l, lua_gettop(l) == 1, 1, \"expected 1 argument\");\n\n if (!cfg->encode_keep_buffer) {\n /* Use private buffer */\n encode_buf = &local_encode_buf;\n strbuf_init(encode_buf, 0);\n } else {\n /* Reuse existing buffer */\n encode_buf = &cfg->encode_buf;\n strbuf_reset(encode_buf);\n }\n\n json_append_data(l, cfg, 0, encode_buf);\n json = strbuf_string(encode_buf, &len);\n\n lua_pushlstring(l, json, len);\n\n if (!cfg->encode_keep_buffer)\n strbuf_free(encode_buf);\n\n return 1;\n}\n\n/* ===== DECODING ===== */\n\nstatic void json_process_value(lua_State *l, json_parse_t *json,\n json_token_t *token);\n\nstatic int hexdigit2int(char hex)\n{\n if ('0' <= hex && hex <= '9')\n return hex - '0';\n\n /* Force lowercase */\n hex |= 0x20;\n if ('a' <= hex && hex <= 'f')\n return 10 + hex - 'a';\n\n return -1;\n}\n\nstatic int decode_hex4(const char *hex)\n{\n int digit[4];\n int i;\n\n /* Convert ASCII hex digit to numeric digit\n * Note: this returns an error for invalid hex digits, including\n * NULL */\n for (i = 0; i < 4; i++) {\n digit[i] = hexdigit2int(hex[i]);\n if (digit[i] < 0) {\n return -1;\n }\n }\n\n return (digit[0] << 12) +\n (digit[1] << 8) +\n (digit[2] << 4) +\n digit[3];\n}\n\n/* Converts a Unicode codepoint to UTF-8.\n * Returns UTF-8 string length, and up to 4 bytes in *utf8 */\nstatic int codepoint_to_utf8(char *utf8, int codepoint)\n{\n /* 0xxxxxxx */\n if (codepoint <= 0x7F) {\n utf8[0] = codepoint;\n return 1;\n }\n\n /* 110xxxxx 10xxxxxx */\n if (codepoint <= 0x7FF) {\n utf8[0] = (codepoint >> 6) | 0xC0;\n utf8[1] = (codepoint & 0x3F) | 0x80;\n return 2;\n }\n\n /* 1110xxxx 10xxxxxx 10xxxxxx */\n if (codepoint <= 0xFFFF) {\n utf8[0] = (codepoint >> 12) | 0xE0;\n utf8[1] = ((codepoint >> 6) & 0x3F) | 0x80;\n utf8[2] = (codepoint & 0x3F) | 0x80;\n return 3;\n }\n\n /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */\n if (codepoint <= 0x1FFFFF) {\n utf8[0] = (codepoint >> 18) | 0xF0;\n utf8[1] = ((codepoint >> 12) & 0x3F) | 0x80;\n utf8[2] = ((codepoint >> 6) & 0x3F) | 0x80;\n utf8[3] = (codepoint & 0x3F) | 0x80;\n return 4;\n }\n\n return 0;\n}\n\n\n/* Called when index pointing to beginning of UTF-16 code escape: \\uXXXX\n * \\u is guaranteed to exist, but the remaining hex characters may be\n * missing.\n * Translate to UTF-8 and append to temporary token string.\n * Must advance index to the next character to be processed.\n * Returns: 0 success\n * -1 error\n */\nstatic int json_append_unicode_escape(json_parse_t *json)\n{\n char utf8[4]; /* Surrogate pairs require 4 UTF-8 bytes */\n int codepoint;\n int surrogate_low;\n int len;\n int escape_len = 6;\n\n /* Fetch UTF-16 code unit */\n codepoint = decode_hex4(json->ptr + 2);\n if (codepoint < 0)\n return -1;\n\n /* UTF-16 surrogate pairs take the following 2 byte form:\n * 11011 x yyyyyyyyyy\n * When x = 0: y is the high 10 bits of the codepoint\n * x = 1: y is the low 10 bits of the codepoint\n *\n * Check for a surrogate pair (high or low) */\n if ((codepoint & 0xF800) == 0xD800) {\n /* Error if the 1st surrogate is not high */\n if (codepoint & 0x400)\n return -1;\n\n /* Ensure the next code is a unicode escape */\n if (*(json->ptr + escape_len) != '\\\\' ||\n *(json->ptr + escape_len + 1) != 'u') {\n return -1;\n }\n\n /* Fetch the next codepoint */\n surrogate_low = decode_hex4(json->ptr + 2 + escape_len);\n if (surrogate_low < 0)\n return -1;\n\n /* Error if the 2nd code is not a low surrogate */\n if ((surrogate_low & 0xFC00) != 0xDC00)\n return -1;\n\n /* Calculate Unicode codepoint */\n codepoint = (codepoint & 0x3FF) << 10;\n surrogate_low &= 0x3FF;\n codepoint = (codepoint | surrogate_low) + 0x10000;\n escape_len = 12;\n }\n\n /* Convert codepoint to UTF-8 */\n len = codepoint_to_utf8(utf8, codepoint);\n if (!len)\n return -1;\n\n /* Append bytes and advance parse index */\n strbuf_append_mem_unsafe(json->tmp, utf8, len);\n json->ptr += escape_len;\n\n return 0;\n}\n\nstatic void json_set_token_error(json_token_t *token, json_parse_t *json,\n const char *errtype)\n{\n token->type = T_ERROR;\n token->index = json->ptr - json->data;\n token->value.string = errtype;\n}\n\nstatic void json_next_string_token(json_parse_t *json, json_token_t *token)\n{\n char *escape2char = json->cfg->escape2char;\n char ch;\n\n /* Caller must ensure a string is next */\n assert(*json->ptr == '\"');\n\n /* Skip \" */\n json->ptr++;\n\n /* json->tmp is the temporary strbuf used to accumulate the\n * decoded string value.\n * json->tmp is sized to handle JSON containing only a string value.\n */\n strbuf_reset(json->tmp);\n\n while ((ch = *json->ptr) != '\"') {\n if (!ch) {\n /* Premature end of the string */\n json_set_token_error(token, json, \"unexpected end of string\");\n return;\n }\n\n /* Handle escapes */\n if (ch == '\\\\') {\n /* Fetch escape character */\n ch = *(json->ptr + 1);\n\n /* Translate escape code and append to tmp string */\n ch = escape2char[(unsigned char)ch];\n if (ch == 'u') {\n if (json_append_unicode_escape(json) == 0)\n continue;\n\n json_set_token_error(token, json,\n \"invalid unicode escape code\");\n return;\n }\n if (!ch) {\n json_set_token_error(token, json, \"invalid escape code\");\n return;\n }\n\n /* Skip '\\' */\n json->ptr++;\n }\n /* Append normal character or translated single character\n * Unicode escapes are handled above */\n strbuf_append_char_unsafe(json->tmp, ch);\n json->ptr++;\n }\n json->ptr++; /* Eat final quote (\") */\n\n strbuf_ensure_null(json->tmp);\n\n token->type = T_STRING;\n token->value.string = strbuf_string(json->tmp, &token->string_len);\n}\n\n/* JSON numbers should take the following form:\n * -?(0|[1-9]|[1-9][0-9]+)(.[0-9]+)?([eE][-+]?[0-9]+)?\n *\n * json_next_number_token() uses strtod() which allows other forms:\n * - numbers starting with '+'\n * - NaN, -NaN, infinity, -infinity\n * - hexadecimal numbers\n * - numbers with leading zeros\n *\n * json_is_invalid_number() detects \"numbers\" which may pass strtod()'s\n * error checking, but should not be allowed with strict JSON.\n *\n * json_is_invalid_number() may pass numbers which cause strtod()\n * to generate an error.\n */\nstatic int json_is_invalid_number(json_parse_t *json)\n{\n const char *p = json->ptr;\n\n /* Reject numbers starting with + */\n if (*p == '+')\n return 1;\n\n /* Skip minus sign if it exists */\n if (*p == '-')\n p++;\n\n /* Reject numbers starting with 0x, or leading zeros */\n if (*p == '0') {\n int ch2 = *(p + 1);\n\n if ((ch2 | 0x20) == 'x' || /* Hex */\n ('0' <= ch2 && ch2 <= '9')) /* Leading zero */\n return 1;\n\n return 0;\n } else if (*p <= '9') {\n return 0; /* Ordinary number */\n }\n\n /* Reject inf/nan */\n if (!strncasecmp(p, \"inf\", 3))\n return 1;\n if (!strncasecmp(p, \"nan\", 3))\n return 1;\n\n /* Pass all other numbers which may still be invalid, but\n * strtod() will catch them. */\n return 0;\n}\n\nstatic void json_next_number_token(json_parse_t *json, json_token_t *token)\n{\n char *endptr;\n\n token->type = T_NUMBER;\n token->value.number = fpconv_strtod(json->ptr, &endptr);\n if (json->ptr == endptr)\n json_set_token_error(token, json, \"invalid number\");\n else\n json->ptr = endptr; /* Skip the processed number */\n\n return;\n}\n\n/* Fills in the token struct.\n * T_STRING will return a pointer to the json_parse_t temporary string\n * T_ERROR will leave the json->ptr pointer at the error.\n */\nstatic void json_next_token(json_parse_t *json, json_token_t *token)\n{\n const json_token_type_t *ch2token = json->cfg->ch2token;\n int ch;\n\n /* Eat whitespace. */\n while (1) {\n ch = (unsigned char)*(json->ptr);\n token->type = ch2token[ch];\n if (token->type != T_WHITESPACE)\n break;\n json->ptr++;\n }\n\n /* Store location of new token. Required when throwing errors\n * for unexpected tokens (syntax errors). */\n token->index = json->ptr - json->data;\n\n /* Don't advance the pointer for an error or the end */\n if (token->type == T_ERROR) {\n json_set_token_error(token, json, \"invalid token\");\n return;\n }\n\n if (token->type == T_END) {\n return;\n }\n\n /* Found a known single character token, advance index and return */\n if (token->type != T_UNKNOWN) {\n json->ptr++;\n return;\n }\n\n /* Process characters which triggered T_UNKNOWN\n *\n * Must use strncmp() to match the front of the JSON string.\n * JSON identifier must be lowercase.\n * When strict_numbers if disabled, either case is allowed for\n * Infinity/NaN (since we are no longer following the spec..) */\n if (ch == '\"') {\n json_next_string_token(json, token);\n return;\n } else if (ch == '-' || ('0' <= ch && ch <= '9')) {\n if (!json->cfg->decode_invalid_numbers && json_is_invalid_number(json)) {\n json_set_token_error(token, json, \"invalid number\");\n return;\n }\n json_next_number_token(json, token);\n return;\n } else if (!strncmp(json->ptr, \"true\", 4)) {\n token->type = T_BOOLEAN;\n token->value.boolean = 1;\n json->ptr += 4;\n return;\n } else if (!strncmp(json->ptr, \"false\", 5)) {\n token->type = T_BOOLEAN;\n token->value.boolean = 0;\n json->ptr += 5;\n return;\n } else if (!strncmp(json->ptr, \"null\", 4)) {\n token->type = T_NULL;\n json->ptr += 4;\n return;\n } else if (json->cfg->decode_invalid_numbers &&\n json_is_invalid_number(json)) {\n /* When decode_invalid_numbers is enabled, only attempt to process\n * numbers we know are invalid JSON (Inf, NaN, hex)\n * This is required to generate an appropriate token error,\n * otherwise all bad tokens will register as \"invalid number\"\n */\n json_next_number_token(json, token);\n return;\n }\n\n /* Token starts with t/f/n but isn't recognised above. */\n json_set_token_error(token, json, \"invalid token\");\n}\n\n/* This function does not return.\n * DO NOT CALL WITH DYNAMIC MEMORY ALLOCATED.\n * The only supported exception is the temporary parser string\n * json->tmp struct.\n * json and token should exist on the stack somewhere.\n * luaL_error() will long_jmp and release the stack */\nstatic void json_throw_parse_error(lua_State *l, json_parse_t *json,\n const char *exp, json_token_t *token)\n{\n const char *found;\n\n strbuf_free(json->tmp);\n\n if (token->type == T_ERROR)\n found = token->value.string;\n else\n found = json_token_type_name[token->type];\n\n /* Note: token->index is 0 based, display starting from 1 */\n luaL_error(l, \"Expected %s but found %s at character %d\",\n exp, found, token->index + 1);\n}\n\nstatic inline void json_decode_ascend(json_parse_t *json)\n{\n json->current_depth--;\n}\n\nstatic void json_decode_descend(lua_State *l, json_parse_t *json, int slots)\n{\n json->current_depth++;\n\n if (json->current_depth <= json->cfg->decode_max_depth &&\n lua_checkstack(l, slots)) {\n return;\n }\n\n strbuf_free(json->tmp);\n luaL_error(l, \"Found too many nested data structures (%d) at character %d\",\n json->current_depth, json->ptr - json->data);\n}\n\nstatic void json_parse_object_context(lua_State *l, json_parse_t *json)\n{\n json_token_t token;\n\n /* 3 slots required:\n * .., table, key, value */\n json_decode_descend(l, json, 3);\n\n lua_newtable(l);\n\n json_next_token(json, &token);\n\n /* Handle empty objects */\n if (token.type == T_OBJ_END) {\n json_decode_ascend(json);\n return;\n }\n\n while (1) {\n if (token.type != T_STRING)\n json_throw_parse_error(l, json, \"object key string\", &token);\n\n /* Push key */\n lua_pushlstring(l, token.value.string, token.string_len);\n\n json_next_token(json, &token);\n if (token.type != T_COLON)\n json_throw_parse_error(l, json, \"colon\", &token);\n\n /* Fetch value */\n json_next_token(json, &token);\n json_process_value(l, json, &token);\n\n /* Set key = value */\n lua_rawset(l, -3);\n\n json_next_token(json, &token);\n\n if (token.type == T_OBJ_END) {\n json_decode_ascend(json);\n return;\n }\n\n if (token.type != T_COMMA)\n json_throw_parse_error(l, json, \"comma or object end\", &token);\n\n json_next_token(json, &token);\n }\n}\n\n/* Handle the array context */\nstatic void json_parse_array_context(lua_State *l, json_parse_t *json)\n{\n json_token_t token;\n int i;\n\n /* 2 slots required:\n * .., table, value */\n json_decode_descend(l, json, 2);\n\n lua_newtable(l);\n\n /* set array_mt on the table at the top of the stack */\n if (json->cfg->decode_array_with_array_mt) {\n /* Ensure sufficient stack space for metatable creation (metatable + boolean) */\n if (!lua_checkstack(l, 2))\n luaL_error(l, \"max lua stack reached\");\n /* Mark this table so encoder can emit [] for empty arrays */\n lua_newtable(l);\n lua_pushboolean(l, 1);\n lua_setfield(l, -2, \"__is_cjson_array\");\n lua_enablereadonlytable(l, -1, 1); /* protect the metatable. */\n lua_setmetatable(l, -2); /* set metatable for the array table */\n }\n\n json_next_token(json, &token);\n\n /* Handle empty arrays */\n if (token.type == T_ARR_END) {\n json_decode_ascend(json);\n return;\n }\n\n for (i = 1; ; i++) {\n json_process_value(l, json, &token);\n lua_rawseti(l, -2, i); /* arr[i] = value */\n\n json_next_token(json, &token);\n\n if (token.type == T_ARR_END) {\n json_decode_ascend(json);\n return;\n }\n\n if (token.type != T_COMMA)\n json_throw_parse_error(l, json, \"comma or array end\", &token);\n\n json_next_token(json, &token);\n }\n}\n\n/* Handle the \"value\" context */\nstatic void json_process_value(lua_State *l, json_parse_t *json,\n json_token_t *token)\n{\n switch (token->type) {\n case T_STRING:\n lua_pushlstring(l, token->value.string, token->string_len);\n break;;\n case T_NUMBER:\n lua_pushnumber(l, token->value.number);\n break;;\n case T_BOOLEAN:\n lua_pushboolean(l, token->value.boolean);\n break;;\n case T_OBJ_BEGIN:\n json_parse_object_context(l, json);\n break;;\n case T_ARR_BEGIN:\n json_parse_array_context(l, json);\n break;;\n case T_NULL:\n /* In Lua, setting \"t[k] = nil\" will delete k from the table.\n * Hence a NULL pointer lightuserdata object is used instead */\n lua_pushlightuserdata(l, NULL);\n break;;\n default:\n json_throw_parse_error(l, json, \"value\", token);\n }\n}\n\nstatic int json_decode(lua_State *l)\n{\n json_parse_t json;\n json_token_t token;\n size_t json_len;\n\n luaL_argcheck(l, lua_gettop(l) == 1, 1, \"expected 1 argument\");\n\n json.cfg = json_fetch_config(l);\n json.data = luaL_checklstring(l, 1, &json_len);\n json.current_depth = 0;\n json.ptr = json.data;\n\n /* Detect Unicode other than UTF-8 (see RFC 4627, Sec 3)\n *\n * CJSON can support any simple data type, hence only the first\n * character is guaranteed to be ASCII (at worst: '\"'). This is\n * still enough to detect whether the wrong encoding is in use. */\n if (json_len >= 2 && (!json.data[0] || !json.data[1]))\n luaL_error(l, \"JSON parser does not support UTF-16 or UTF-32\");\n\n /* Ensure the temporary buffer can hold the entire string.\n * This means we no longer need to do length checks since the decoded\n * string must be smaller than the entire json string */\n json.tmp = strbuf_new(json_len);\n\n json_next_token(&json, &token);\n json_process_value(l, &json, &token);\n\n /* Ensure there is no more input left */\n json_next_token(&json, &token);\n\n if (token.type != T_END)\n json_throw_parse_error(l, &json, \"the end\", &token);\n\n strbuf_free(json.tmp);\n\n return 1;\n}\n\n/* ===== INITIALISATION ===== */\n\n#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502\n/* Compatibility for Lua 5.1.\n *\n * luaL_setfuncs() is used to create a module table where the functions have\n * json_config_t as their first upvalue. Code borrowed from Lua 5.2 source. */\nstatic void luaL_setfuncs (lua_State *l, const luaL_Reg *reg, int nup)\n{\n int i;\n\n luaL_checkstack(l, nup, \"too many upvalues\");\n for (; reg->name != NULL; reg++) { /* fill the table with given functions */\n for (i = 0; i < nup; i++) /* copy upvalues to the top */\n lua_pushvalue(l, -nup);\n lua_pushcclosure(l, reg->func, nup); /* closure with those upvalues */\n lua_setfield(l, -(nup + 2), reg->name);\n }\n lua_pop(l, nup); /* remove upvalues */\n}\n#endif\n\n/* Call target function in protected mode with all supplied args.\n * Assumes target function only returns a single non-nil value.\n * Convert and return thrown errors as: nil, \"error message\" */\nstatic int json_protect_conversion(lua_State *l)\n{\n int err;\n\n /* Deliberately throw an error for invalid arguments */\n luaL_argcheck(l, lua_gettop(l) == 1, 1, \"expected 1 argument\");\n\n /* pcall() the function stored as upvalue(1) */\n lua_pushvalue(l, lua_upvalueindex(1));\n lua_insert(l, 1);\n err = lua_pcall(l, 1, 1, 0);\n if (!err)\n return 1;\n\n if (err == LUA_ERRRUN) {\n lua_pushnil(l);\n lua_insert(l, -2);\n return 2;\n }\n\n /* Since we are not using a custom error handler, the only remaining\n * errors are memory related */\n return luaL_error(l, \"Memory allocation error in CJSON protected call\");\n}\n\n/* Return cjson module table */\nstatic int lua_cjson_new(lua_State *l)\n{\n luaL_Reg reg[] = {\n { \"encode\", json_encode },\n { \"decode\", json_decode },\n { \"decode_array_with_array_mt\", json_cfg_decode_array_with_array_mt },\n { \"encode_sparse_array\", json_cfg_encode_sparse_array },\n { \"encode_max_depth\", json_cfg_encode_max_depth },\n { \"decode_max_depth\", json_cfg_decode_max_depth },\n { \"encode_number_precision\", json_cfg_encode_number_precision },\n { \"encode_keep_buffer\", json_cfg_encode_keep_buffer },\n { \"encode_invalid_numbers\", json_cfg_encode_invalid_numbers },\n { \"decode_invalid_numbers\", json_cfg_decode_invalid_numbers },\n { \"new\", lua_cjson_new },\n { NULL, NULL }\n };\n\n /* Initialise number conversions */\n fpconv_init();\n\n /* cjson module table */\n lua_newtable(l);\n\n /* Register functions with config data as upvalue */\n json_create_config(l);\n luaL_setfuncs(l, reg, 1);\n\n /* Set cjson.null */\n lua_pushlightuserdata(l, NULL);\n lua_setfield(l, -2, \"null\");\n\n /* Set module name / version fields */\n lua_pushliteral(l, CJSON_MODNAME);\n lua_setfield(l, -2, \"_NAME\");\n lua_pushliteral(l, CJSON_VERSION);\n lua_setfield(l, -2, \"_VERSION\");\n\n return 1;\n}\n\n/* Return cjson.safe module table */\nstatic int lua_cjson_safe_new(lua_State *l)\n{\n const char *func[] = { \"decode\", \"encode\", NULL };\n int i;\n\n lua_cjson_new(l);\n\n /* Fix new() method */\n lua_pushcfunction(l, lua_cjson_safe_new);\n lua_setfield(l, -2, \"new\");\n\n for (i = 0; func[i]; i++) {\n lua_getfield(l, -1, func[i]);\n lua_pushcclosure(l, json_protect_conversion, 1);\n lua_setfield(l, -2, func[i]);\n }\n\n return 1;\n}\n\nint luaopen_cjson(lua_State *l)\n{\n lua_cjson_new(l);\n\n#ifdef ENABLE_CJSON_GLOBAL\n /* Register a global \"cjson\" table. */\n lua_pushvalue(l, -1);\n lua_setglobal(l, CJSON_MODNAME);\n#endif\n\n /* Return cjson table */\n return 1;\n}\n\nint luaopen_cjson_safe(lua_State *l)\n{\n lua_cjson_safe_new(l);\n\n /* Return cjson.safe table */\n return 1;\n}\n\n/* vi:ai et sw=4 ts=4:\n */\n" }, { "path": "deps/lua/src/lua_cmsgpack.c", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\n#define LUACMSGPACK_NAME \"cmsgpack\"\n#define LUACMSGPACK_SAFE_NAME \"cmsgpack_safe\"\n#define LUACMSGPACK_VERSION \"lua-cmsgpack 0.4.0\"\n#define LUACMSGPACK_COPYRIGHT \"Copyright (C) 2012, Salvatore Sanfilippo\"\n#define LUACMSGPACK_DESCRIPTION \"MessagePack C implementation for Lua\"\n\n/* Allows a preprocessor directive to override MAX_NESTING */\n#ifndef LUACMSGPACK_MAX_NESTING\n #define LUACMSGPACK_MAX_NESTING 16 /* Max tables nesting. */\n#endif\n\n/* Check if float or double can be an integer without loss of precision */\n#define IS_INT_TYPE_EQUIVALENT(x, T) (!isinf(x) && (T)(x) == (x))\n\n#define IS_INT64_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int64_t)\n#define IS_INT_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int)\n\n/* If size of pointer is equal to a 4 byte integer, we're on 32 bits. */\n#if UINTPTR_MAX == UINT_MAX\n #define BITS_32 1\n#else\n #define BITS_32 0\n#endif\n\n#if BITS_32\n #define lua_pushunsigned(L, n) lua_pushnumber(L, n)\n#else\n #define lua_pushunsigned(L, n) lua_pushinteger(L, n)\n#endif\n\n/* =============================================================================\n * MessagePack implementation and bindings for Lua 5.1/5.2.\n * Copyright(C) 2012 Salvatore Sanfilippo \n *\n * http://github.com/antirez/lua-cmsgpack\n *\n * For MessagePack specification check the following web site:\n * http://wiki.msgpack.org/display/MSGPACK/Format+specification\n *\n * See Copyright Notice at the end of this file.\n *\n * CHANGELOG:\n * 19-Feb-2012 (ver 0.1.0): Initial release.\n * 20-Feb-2012 (ver 0.2.0): Tables encoding improved.\n * 20-Feb-2012 (ver 0.2.1): Minor bug fixing.\n * 20-Feb-2012 (ver 0.3.0): Module renamed lua-cmsgpack (was lua-msgpack).\n * 04-Apr-2014 (ver 0.3.1): Lua 5.2 support and minor bug fix.\n * 07-Apr-2014 (ver 0.4.0): Multiple pack/unpack, lua allocator, efficiency.\n * ========================================================================== */\n\n/* -------------------------- Endian conversion --------------------------------\n * We use it only for floats and doubles, all the other conversions performed\n * in an endian independent fashion. So the only thing we need is a function\n * that swaps a binary string if arch is little endian (and left it untouched\n * otherwise). */\n\n/* Reverse memory bytes if arch is little endian. Given the conceptual\n * simplicity of the Lua build system we prefer check for endianess at runtime.\n * The performance difference should be acceptable. */\nvoid memrevifle(void *ptr, size_t len) {\n unsigned char *p = (unsigned char *)ptr,\n *e = (unsigned char *)p+len-1,\n aux;\n int test = 1;\n unsigned char *testp = (unsigned char*) &test;\n\n if (testp[0] == 0) return; /* Big endian, nothing to do. */\n len /= 2;\n while(len--) {\n aux = *p;\n *p = *e;\n *e = aux;\n p++;\n e--;\n }\n}\n\n/* ---------------------------- String buffer ----------------------------------\n * This is a simple implementation of string buffers. The only operation\n * supported is creating empty buffers and appending bytes to it.\n * The string buffer uses 2x preallocation on every realloc for O(N) append\n * behavior. */\n\ntypedef struct mp_buf {\n unsigned char *b;\n size_t len, free;\n} mp_buf;\n\nvoid *mp_realloc(lua_State *L, void *target, size_t osize,size_t nsize) {\n void *(*local_realloc) (void *, void *, size_t osize, size_t nsize) = NULL;\n void *ud;\n\n local_realloc = lua_getallocf(L, &ud);\n\n return local_realloc(ud, target, osize, nsize);\n}\n\nmp_buf *mp_buf_new(lua_State *L) {\n mp_buf *buf = NULL;\n\n /* Old size = 0; new size = sizeof(*buf) */\n buf = (mp_buf*)mp_realloc(L, NULL, 0, sizeof(*buf));\n\n buf->b = NULL;\n buf->len = buf->free = 0;\n return buf;\n}\n\nvoid mp_buf_append(lua_State *L, mp_buf *buf, const unsigned char *s, size_t len) {\n if (buf->free < len) {\n size_t newsize = buf->len+len;\n if (newsize < buf->len || newsize >= SIZE_MAX/2) abort();\n newsize *= 2;\n\n buf->b = (unsigned char*)mp_realloc(L, buf->b, buf->len + buf->free, newsize);\n buf->free = newsize - buf->len;\n }\n memcpy(buf->b+buf->len,s,len);\n buf->len += len;\n buf->free -= len;\n}\n\nvoid mp_buf_free(lua_State *L, mp_buf *buf) {\n mp_realloc(L, buf->b, buf->len + buf->free, 0); /* realloc to 0 = free */\n mp_realloc(L, buf, sizeof(*buf), 0);\n}\n\n/* ---------------------------- String cursor ----------------------------------\n * This simple data structure is used for parsing. Basically you create a cursor\n * using a string pointer and a length, then it is possible to access the\n * current string position with cursor->p, check the remaining length\n * in cursor->left, and finally consume more string using\n * mp_cur_consume(cursor,len), to advance 'p' and subtract 'left'.\n * An additional field cursor->error is set to zero on initialization and can\n * be used to report errors. */\n\n#define MP_CUR_ERROR_NONE 0\n#define MP_CUR_ERROR_EOF 1 /* Not enough data to complete operation. */\n#define MP_CUR_ERROR_BADFMT 2 /* Bad data format */\n\ntypedef struct mp_cur {\n const unsigned char *p;\n size_t left;\n int err;\n} mp_cur;\n\nvoid mp_cur_init(mp_cur *cursor, const unsigned char *s, size_t len) {\n cursor->p = s;\n cursor->left = len;\n cursor->err = MP_CUR_ERROR_NONE;\n}\n\n#define mp_cur_consume(_c,_len) do { _c->p += _len; _c->left -= _len; } while(0)\n\n/* When there is not enough room we set an error in the cursor and return. This\n * is very common across the code so we have a macro to make the code look\n * a bit simpler. */\n#define mp_cur_need(_c,_len) do { \\\n if (_c->left < _len) { \\\n _c->err = MP_CUR_ERROR_EOF; \\\n return; \\\n } \\\n} while(0)\n\n/* ------------------------- Low level MP encoding -------------------------- */\n\nvoid mp_encode_bytes(lua_State *L, mp_buf *buf, const unsigned char *s, size_t len) {\n unsigned char hdr[5];\n size_t hdrlen;\n\n if (len < 32) {\n hdr[0] = 0xa0 | (len&0xff); /* fix raw */\n hdrlen = 1;\n } else if (len <= 0xff) {\n hdr[0] = 0xd9;\n hdr[1] = len;\n hdrlen = 2;\n } else if (len <= 0xffff) {\n hdr[0] = 0xda;\n hdr[1] = (len&0xff00)>>8;\n hdr[2] = len&0xff;\n hdrlen = 3;\n } else {\n hdr[0] = 0xdb;\n hdr[1] = (len&0xff000000)>>24;\n hdr[2] = (len&0xff0000)>>16;\n hdr[3] = (len&0xff00)>>8;\n hdr[4] = len&0xff;\n hdrlen = 5;\n }\n mp_buf_append(L,buf,hdr,hdrlen);\n mp_buf_append(L,buf,s,len);\n}\n\n/* we assume IEEE 754 internal format for single and double precision floats. */\nvoid mp_encode_double(lua_State *L, mp_buf *buf, double d) {\n unsigned char b[9];\n float f = d;\n\n assert(sizeof(f) == 4 && sizeof(d) == 8);\n if (d == (double)f) {\n b[0] = 0xca; /* float IEEE 754 */\n memcpy(b+1,&f,4);\n memrevifle(b+1,4);\n mp_buf_append(L,buf,b,5);\n } else if (sizeof(d) == 8) {\n b[0] = 0xcb; /* double IEEE 754 */\n memcpy(b+1,&d,8);\n memrevifle(b+1,8);\n mp_buf_append(L,buf,b,9);\n }\n}\n\nvoid mp_encode_int(lua_State *L, mp_buf *buf, int64_t n) {\n unsigned char b[9];\n size_t enclen;\n\n if (n >= 0) {\n if (n <= 127) {\n b[0] = n & 0x7f; /* positive fixnum */\n enclen = 1;\n } else if (n <= 0xff) {\n b[0] = 0xcc; /* uint 8 */\n b[1] = n & 0xff;\n enclen = 2;\n } else if (n <= 0xffff) {\n b[0] = 0xcd; /* uint 16 */\n b[1] = (n & 0xff00) >> 8;\n b[2] = n & 0xff;\n enclen = 3;\n } else if (n <= 0xffffffffLL) {\n b[0] = 0xce; /* uint 32 */\n b[1] = (n & 0xff000000) >> 24;\n b[2] = (n & 0xff0000) >> 16;\n b[3] = (n & 0xff00) >> 8;\n b[4] = n & 0xff;\n enclen = 5;\n } else {\n b[0] = 0xcf; /* uint 64 */\n b[1] = (n & 0xff00000000000000LL) >> 56;\n b[2] = (n & 0xff000000000000LL) >> 48;\n b[3] = (n & 0xff0000000000LL) >> 40;\n b[4] = (n & 0xff00000000LL) >> 32;\n b[5] = (n & 0xff000000) >> 24;\n b[6] = (n & 0xff0000) >> 16;\n b[7] = (n & 0xff00) >> 8;\n b[8] = n & 0xff;\n enclen = 9;\n }\n } else {\n if (n >= -32) {\n b[0] = ((signed char)n); /* negative fixnum */\n enclen = 1;\n } else if (n >= -128) {\n b[0] = 0xd0; /* int 8 */\n b[1] = n & 0xff;\n enclen = 2;\n } else if (n >= -32768) {\n b[0] = 0xd1; /* int 16 */\n b[1] = (n & 0xff00) >> 8;\n b[2] = n & 0xff;\n enclen = 3;\n } else if (n >= -2147483648LL) {\n b[0] = 0xd2; /* int 32 */\n b[1] = (n & 0xff000000) >> 24;\n b[2] = (n & 0xff0000) >> 16;\n b[3] = (n & 0xff00) >> 8;\n b[4] = n & 0xff;\n enclen = 5;\n } else {\n b[0] = 0xd3; /* int 64 */\n b[1] = (n & 0xff00000000000000LL) >> 56;\n b[2] = (n & 0xff000000000000LL) >> 48;\n b[3] = (n & 0xff0000000000LL) >> 40;\n b[4] = (n & 0xff00000000LL) >> 32;\n b[5] = (n & 0xff000000) >> 24;\n b[6] = (n & 0xff0000) >> 16;\n b[7] = (n & 0xff00) >> 8;\n b[8] = n & 0xff;\n enclen = 9;\n }\n }\n mp_buf_append(L,buf,b,enclen);\n}\n\nvoid mp_encode_array(lua_State *L, mp_buf *buf, uint64_t n) {\n unsigned char b[5];\n size_t enclen;\n\n if (n <= 15) {\n b[0] = 0x90 | (n & 0xf); /* fix array */\n enclen = 1;\n } else if (n <= 65535) {\n b[0] = 0xdc; /* array 16 */\n b[1] = (n & 0xff00) >> 8;\n b[2] = n & 0xff;\n enclen = 3;\n } else {\n b[0] = 0xdd; /* array 32 */\n b[1] = (n & 0xff000000) >> 24;\n b[2] = (n & 0xff0000) >> 16;\n b[3] = (n & 0xff00) >> 8;\n b[4] = n & 0xff;\n enclen = 5;\n }\n mp_buf_append(L,buf,b,enclen);\n}\n\nvoid mp_encode_map(lua_State *L, mp_buf *buf, uint64_t n) {\n unsigned char b[5];\n int enclen;\n\n if (n <= 15) {\n b[0] = 0x80 | (n & 0xf); /* fix map */\n enclen = 1;\n } else if (n <= 65535) {\n b[0] = 0xde; /* map 16 */\n b[1] = (n & 0xff00) >> 8;\n b[2] = n & 0xff;\n enclen = 3;\n } else {\n b[0] = 0xdf; /* map 32 */\n b[1] = (n & 0xff000000) >> 24;\n b[2] = (n & 0xff0000) >> 16;\n b[3] = (n & 0xff00) >> 8;\n b[4] = n & 0xff;\n enclen = 5;\n }\n mp_buf_append(L,buf,b,enclen);\n}\n\n/* --------------------------- Lua types encoding --------------------------- */\n\nvoid mp_encode_lua_string(lua_State *L, mp_buf *buf) {\n size_t len;\n const char *s;\n\n s = lua_tolstring(L,-1,&len);\n mp_encode_bytes(L,buf,(const unsigned char*)s,len);\n}\n\nvoid mp_encode_lua_bool(lua_State *L, mp_buf *buf) {\n unsigned char b = lua_toboolean(L,-1) ? 0xc3 : 0xc2;\n mp_buf_append(L,buf,&b,1);\n}\n\n/* Lua 5.3 has a built in 64-bit integer type */\nvoid mp_encode_lua_integer(lua_State *L, mp_buf *buf) {\n#if (LUA_VERSION_NUM < 503) && BITS_32\n lua_Number i = lua_tonumber(L,-1);\n#else\n lua_Integer i = lua_tointeger(L,-1);\n#endif\n mp_encode_int(L, buf, (int64_t)i);\n}\n\n/* Lua 5.2 and lower only has 64-bit doubles, so we need to\n * detect if the double may be representable as an int\n * for Lua < 5.3 */\nvoid mp_encode_lua_number(lua_State *L, mp_buf *buf) {\n lua_Number n = lua_tonumber(L,-1);\n\n if (IS_INT64_EQUIVALENT(n)) {\n mp_encode_lua_integer(L, buf);\n } else {\n mp_encode_double(L,buf,(double)n);\n }\n}\n\nvoid mp_encode_lua_type(lua_State *L, mp_buf *buf, int level);\n\n/* Convert a lua table into a message pack list. */\nvoid mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {\n#if LUA_VERSION_NUM < 502\n size_t len = lua_objlen(L,-1), j;\n#else\n size_t len = lua_rawlen(L,-1), j;\n#endif\n\n mp_encode_array(L,buf,len);\n luaL_checkstack(L, 1, \"in function mp_encode_lua_table_as_array\");\n for (j = 1; j <= len; j++) {\n lua_pushnumber(L,j);\n lua_gettable(L,-2);\n mp_encode_lua_type(L,buf,level+1);\n }\n}\n\n/* Convert a lua table into a message pack key-value map. */\nvoid mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {\n size_t len = 0;\n\n /* First step: count keys into table. No other way to do it with the\n * Lua API, we need to iterate a first time. Note that an alternative\n * would be to do a single run, and then hack the buffer to insert the\n * map opcodes for message pack. Too hackish for this lib. */\n luaL_checkstack(L, 3, \"in function mp_encode_lua_table_as_map\");\n lua_pushnil(L);\n while(lua_next(L,-2)) {\n lua_pop(L,1); /* remove value, keep key for next iteration. */\n len++;\n }\n\n /* Step two: actually encoding of the map. */\n mp_encode_map(L,buf,len);\n lua_pushnil(L);\n while(lua_next(L,-2)) {\n /* Stack: ... key value */\n lua_pushvalue(L,-2); /* Stack: ... key value key */\n mp_encode_lua_type(L,buf,level+1); /* encode key */\n mp_encode_lua_type(L,buf,level+1); /* encode val */\n }\n}\n\n/* Returns true if the Lua table on top of the stack is exclusively composed\n * of keys from numerical keys from 1 up to N, with N being the total number\n * of elements, without any hole in the middle. */\nint table_is_an_array(lua_State *L) {\n int count = 0, max = 0;\n#if LUA_VERSION_NUM < 503\n lua_Number n;\n#else\n lua_Integer n;\n#endif\n\n /* Stack top on function entry */\n int stacktop;\n\n stacktop = lua_gettop(L);\n\n luaL_checkstack(L, 2, \"in function table_is_an_array\");\n lua_pushnil(L);\n while(lua_next(L,-2)) {\n /* Stack: ... key value */\n lua_pop(L,1); /* Stack: ... key */\n /* The <= 0 check is valid here because we're comparing indexes. */\n#if LUA_VERSION_NUM < 503\n if ((LUA_TNUMBER != lua_type(L,-1)) || (n = lua_tonumber(L, -1)) <= 0 ||\n !IS_INT_EQUIVALENT(n))\n#else\n if (!lua_isinteger(L,-1) || (n = lua_tointeger(L, -1)) <= 0)\n#endif\n {\n lua_settop(L, stacktop);\n return 0;\n }\n max = (n > max ? n : max);\n count++;\n }\n /* We have the total number of elements in \"count\". Also we have\n * the max index encountered in \"max\". We can't reach this code\n * if there are indexes <= 0. If you also note that there can not be\n * repeated keys into a table, you have that if max==count you are sure\n * that there are all the keys form 1 to count (both included). */\n lua_settop(L, stacktop);\n return max == count;\n}\n\n/* If the length operator returns non-zero, that is, there is at least\n * an object at key '1', we serialize to message pack list. Otherwise\n * we use a map. */\nvoid mp_encode_lua_table(lua_State *L, mp_buf *buf, int level) {\n if (table_is_an_array(L))\n mp_encode_lua_table_as_array(L,buf,level);\n else\n mp_encode_lua_table_as_map(L,buf,level);\n}\n\nvoid mp_encode_lua_null(lua_State *L, mp_buf *buf) {\n unsigned char b[1];\n\n b[0] = 0xc0;\n mp_buf_append(L,buf,b,1);\n}\n\nvoid mp_encode_lua_type(lua_State *L, mp_buf *buf, int level) {\n int t = lua_type(L,-1);\n\n /* Limit the encoding of nested tables to a specified maximum depth, so that\n * we survive when called against circular references in tables. */\n if (t == LUA_TTABLE && level == LUACMSGPACK_MAX_NESTING) t = LUA_TNIL;\n switch(t) {\n case LUA_TSTRING: mp_encode_lua_string(L,buf); break;\n case LUA_TBOOLEAN: mp_encode_lua_bool(L,buf); break;\n case LUA_TNUMBER:\n #if LUA_VERSION_NUM < 503\n mp_encode_lua_number(L,buf); break;\n #else\n if (lua_isinteger(L, -1)) {\n mp_encode_lua_integer(L, buf);\n } else {\n mp_encode_lua_number(L, buf);\n }\n break;\n #endif\n case LUA_TTABLE: mp_encode_lua_table(L,buf,level); break;\n default: mp_encode_lua_null(L,buf); break;\n }\n lua_pop(L,1);\n}\n\n/*\n * Packs all arguments as a stream for multiple upacking later.\n * Returns error if no arguments provided.\n */\nint mp_pack(lua_State *L) {\n int nargs = lua_gettop(L);\n int i;\n mp_buf *buf;\n\n if (nargs == 0)\n return luaL_argerror(L, 0, \"MessagePack pack needs input.\");\n\n if (!lua_checkstack(L, nargs))\n return luaL_argerror(L, 0, \"Too many arguments for MessagePack pack.\");\n\n buf = mp_buf_new(L);\n for(i = 1; i <= nargs; i++) {\n /* Copy argument i to top of stack for _encode processing;\n * the encode function pops it from the stack when complete. */\n luaL_checkstack(L, 1, \"in function mp_check\");\n lua_pushvalue(L, i);\n\n mp_encode_lua_type(L,buf,0);\n\n lua_pushlstring(L,(char*)buf->b,buf->len);\n\n /* Reuse the buffer for the next operation by\n * setting its free count to the total buffer size\n * and the current position to zero. */\n buf->free += buf->len;\n buf->len = 0;\n }\n mp_buf_free(L, buf);\n\n /* Concatenate all nargs buffers together */\n lua_concat(L, nargs);\n return 1;\n}\n\n/* ------------------------------- Decoding --------------------------------- */\n\nvoid mp_decode_to_lua_type(lua_State *L, mp_cur *c);\n\nvoid mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {\n assert(len <= UINT_MAX);\n int index = 1;\n\n lua_newtable(L);\n luaL_checkstack(L, 1, \"in function mp_decode_to_lua_array\");\n while(len--) {\n lua_pushnumber(L,index++);\n mp_decode_to_lua_type(L,c);\n if (c->err) return;\n lua_settable(L,-3);\n }\n}\n\nvoid mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {\n assert(len <= UINT_MAX);\n lua_newtable(L);\n while(len--) {\n mp_decode_to_lua_type(L,c); /* key */\n if (c->err) return;\n mp_decode_to_lua_type(L,c); /* value */\n if (c->err) return;\n lua_settable(L,-3);\n }\n}\n\n/* Decode a Message Pack raw object pointed by the string cursor 'c' to\n * a Lua type, that is left as the only result on the stack. */\nvoid mp_decode_to_lua_type(lua_State *L, mp_cur *c) {\n mp_cur_need(c,1);\n\n /* If we return more than 18 elements, we must resize the stack to\n * fit all our return values. But, there is no way to\n * determine how many objects a msgpack will unpack to up front, so\n * we request a +1 larger stack on each iteration (noop if stack is\n * big enough, and when stack does require resize it doubles in size) */\n luaL_checkstack(L, 1,\n \"too many return values at once; \"\n \"use unpack_one or unpack_limit instead.\");\n\n switch(c->p[0]) {\n case 0xcc: /* uint 8 */\n mp_cur_need(c,2);\n lua_pushunsigned(L,c->p[1]);\n mp_cur_consume(c,2);\n break;\n case 0xd0: /* int 8 */\n mp_cur_need(c,2);\n lua_pushinteger(L,(signed char)c->p[1]);\n mp_cur_consume(c,2);\n break;\n case 0xcd: /* uint 16 */\n mp_cur_need(c,3);\n lua_pushunsigned(L,\n (c->p[1] << 8) |\n c->p[2]);\n mp_cur_consume(c,3);\n break;\n case 0xd1: /* int 16 */\n mp_cur_need(c,3);\n lua_pushinteger(L,(int16_t)\n (c->p[1] << 8) |\n c->p[2]);\n mp_cur_consume(c,3);\n break;\n case 0xce: /* uint 32 */\n mp_cur_need(c,5);\n lua_pushunsigned(L,\n ((uint32_t)c->p[1] << 24) |\n ((uint32_t)c->p[2] << 16) |\n ((uint32_t)c->p[3] << 8) |\n (uint32_t)c->p[4]);\n mp_cur_consume(c,5);\n break;\n case 0xd2: /* int 32 */\n mp_cur_need(c,5);\n lua_pushinteger(L,\n ((int32_t)c->p[1] << 24) |\n ((int32_t)c->p[2] << 16) |\n ((int32_t)c->p[3] << 8) |\n (int32_t)c->p[4]);\n mp_cur_consume(c,5);\n break;\n case 0xcf: /* uint 64 */\n mp_cur_need(c,9);\n lua_pushunsigned(L,\n ((uint64_t)c->p[1] << 56) |\n ((uint64_t)c->p[2] << 48) |\n ((uint64_t)c->p[3] << 40) |\n ((uint64_t)c->p[4] << 32) |\n ((uint64_t)c->p[5] << 24) |\n ((uint64_t)c->p[6] << 16) |\n ((uint64_t)c->p[7] << 8) |\n (uint64_t)c->p[8]);\n mp_cur_consume(c,9);\n break;\n case 0xd3: /* int 64 */\n mp_cur_need(c,9);\n#if LUA_VERSION_NUM < 503\n lua_pushnumber(L,\n#else\n lua_pushinteger(L,\n#endif\n ((int64_t)c->p[1] << 56) |\n ((int64_t)c->p[2] << 48) |\n ((int64_t)c->p[3] << 40) |\n ((int64_t)c->p[4] << 32) |\n ((int64_t)c->p[5] << 24) |\n ((int64_t)c->p[6] << 16) |\n ((int64_t)c->p[7] << 8) |\n (int64_t)c->p[8]);\n mp_cur_consume(c,9);\n break;\n case 0xc0: /* nil */\n lua_pushnil(L);\n mp_cur_consume(c,1);\n break;\n case 0xc3: /* true */\n lua_pushboolean(L,1);\n mp_cur_consume(c,1);\n break;\n case 0xc2: /* false */\n lua_pushboolean(L,0);\n mp_cur_consume(c,1);\n break;\n case 0xca: /* float */\n mp_cur_need(c,5);\n assert(sizeof(float) == 4);\n {\n float f;\n memcpy(&f,c->p+1,4);\n memrevifle(&f,4);\n lua_pushnumber(L,f);\n mp_cur_consume(c,5);\n }\n break;\n case 0xcb: /* double */\n mp_cur_need(c,9);\n assert(sizeof(double) == 8);\n {\n double d;\n memcpy(&d,c->p+1,8);\n memrevifle(&d,8);\n lua_pushnumber(L,d);\n mp_cur_consume(c,9);\n }\n break;\n case 0xd9: /* raw 8 */\n mp_cur_need(c,2);\n {\n size_t l = c->p[1];\n mp_cur_need(c,2+l);\n lua_pushlstring(L,(char*)c->p+2,l);\n mp_cur_consume(c,2+l);\n }\n break;\n case 0xda: /* raw 16 */\n mp_cur_need(c,3);\n {\n size_t l = (c->p[1] << 8) | c->p[2];\n mp_cur_need(c,3+l);\n lua_pushlstring(L,(char*)c->p+3,l);\n mp_cur_consume(c,3+l);\n }\n break;\n case 0xdb: /* raw 32 */\n mp_cur_need(c,5);\n {\n size_t l = ((size_t)c->p[1] << 24) |\n ((size_t)c->p[2] << 16) |\n ((size_t)c->p[3] << 8) |\n (size_t)c->p[4];\n mp_cur_consume(c,5);\n mp_cur_need(c,l);\n lua_pushlstring(L,(char*)c->p,l);\n mp_cur_consume(c,l);\n }\n break;\n case 0xdc: /* array 16 */\n mp_cur_need(c,3);\n {\n size_t l = (c->p[1] << 8) | c->p[2];\n mp_cur_consume(c,3);\n mp_decode_to_lua_array(L,c,l);\n }\n break;\n case 0xdd: /* array 32 */\n mp_cur_need(c,5);\n {\n size_t l = ((size_t)c->p[1] << 24) |\n ((size_t)c->p[2] << 16) |\n ((size_t)c->p[3] << 8) |\n (size_t)c->p[4];\n mp_cur_consume(c,5);\n mp_decode_to_lua_array(L,c,l);\n }\n break;\n case 0xde: /* map 16 */\n mp_cur_need(c,3);\n {\n size_t l = (c->p[1] << 8) | c->p[2];\n mp_cur_consume(c,3);\n mp_decode_to_lua_hash(L,c,l);\n }\n break;\n case 0xdf: /* map 32 */\n mp_cur_need(c,5);\n {\n size_t l = ((size_t)c->p[1] << 24) |\n ((size_t)c->p[2] << 16) |\n ((size_t)c->p[3] << 8) |\n (size_t)c->p[4];\n mp_cur_consume(c,5);\n mp_decode_to_lua_hash(L,c,l);\n }\n break;\n default: /* types that can't be idenitified by first byte value. */\n if ((c->p[0] & 0x80) == 0) { /* positive fixnum */\n lua_pushunsigned(L,c->p[0]);\n mp_cur_consume(c,1);\n } else if ((c->p[0] & 0xe0) == 0xe0) { /* negative fixnum */\n lua_pushinteger(L,(signed char)c->p[0]);\n mp_cur_consume(c,1);\n } else if ((c->p[0] & 0xe0) == 0xa0) { /* fix raw */\n size_t l = c->p[0] & 0x1f;\n mp_cur_need(c,1+l);\n lua_pushlstring(L,(char*)c->p+1,l);\n mp_cur_consume(c,1+l);\n } else if ((c->p[0] & 0xf0) == 0x90) { /* fix map */\n size_t l = c->p[0] & 0xf;\n mp_cur_consume(c,1);\n mp_decode_to_lua_array(L,c,l);\n } else if ((c->p[0] & 0xf0) == 0x80) { /* fix map */\n size_t l = c->p[0] & 0xf;\n mp_cur_consume(c,1);\n mp_decode_to_lua_hash(L,c,l);\n } else {\n c->err = MP_CUR_ERROR_BADFMT;\n }\n }\n}\n\nint mp_unpack_full(lua_State *L, lua_Integer limit, lua_Integer offset) {\n size_t len;\n const char *s;\n mp_cur c;\n int cnt; /* Number of objects unpacked */\n int decode_all = (!limit && !offset);\n\n s = luaL_checklstring(L,1,&len); /* if no match, exits */\n\n if (offset < 0 || limit < 0) /* requesting negative off or lim is invalid */\n return luaL_error(L,\n \"Invalid request to unpack with offset of %d and limit of %d.\",\n (int) offset, (int) len);\n else if (offset > len)\n return luaL_error(L,\n \"Start offset %d greater than input length %d.\", (int) offset, (int) len);\n\n if (decode_all) limit = INT_MAX;\n\n mp_cur_init(&c,(const unsigned char *)s+offset,len-offset);\n\n /* We loop over the decode because this could be a stream\n * of multiple top-level values serialized together */\n for(cnt = 0; c.left > 0 && cnt < limit; cnt++) {\n mp_decode_to_lua_type(L,&c);\n\n if (c.err == MP_CUR_ERROR_EOF) {\n return luaL_error(L,\"Missing bytes in input.\");\n } else if (c.err == MP_CUR_ERROR_BADFMT) {\n return luaL_error(L,\"Bad data format in input.\");\n }\n }\n\n if (!decode_all) {\n /* c->left is the remaining size of the input buffer.\n * subtract the entire buffer size from the unprocessed size\n * to get our next start offset */\n size_t new_offset = len - c.left;\n if (new_offset > LONG_MAX) abort();\n\n luaL_checkstack(L, 1, \"in function mp_unpack_full\");\n\n /* Return offset -1 when we have have processed the entire buffer. */\n lua_pushinteger(L, c.left == 0 ? -1 : (lua_Integer) new_offset);\n /* Results are returned with the arg elements still\n * in place. Lua takes care of only returning\n * elements above the args for us.\n * In this case, we have one arg on the stack\n * for this function, so we insert our first return\n * value at position 2. */\n lua_insert(L, 2);\n cnt += 1; /* increase return count by one to make room for offset */\n }\n\n return cnt;\n}\n\nint mp_unpack(lua_State *L) {\n return mp_unpack_full(L, 0, 0);\n}\n\nint mp_unpack_one(lua_State *L) {\n lua_Integer offset = luaL_optinteger(L, 2, 0);\n /* Variable pop because offset may not exist */\n lua_pop(L, lua_gettop(L)-1);\n return mp_unpack_full(L, 1, offset);\n}\n\nint mp_unpack_limit(lua_State *L) {\n lua_Integer limit = luaL_checkinteger(L, 2);\n lua_Integer offset = luaL_optinteger(L, 3, 0);\n /* Variable pop because offset may not exist */\n lua_pop(L, lua_gettop(L)-1);\n\n return mp_unpack_full(L, limit, offset);\n}\n\nint mp_safe(lua_State *L) {\n int argc, err, total_results;\n\n argc = lua_gettop(L);\n\n /* This adds our function to the bottom of the stack\n * (the \"call this function\" position) */\n lua_pushvalue(L, lua_upvalueindex(1));\n lua_insert(L, 1);\n\n err = lua_pcall(L, argc, LUA_MULTRET, 0);\n total_results = lua_gettop(L);\n\n if (!err) {\n return total_results;\n } else {\n lua_pushnil(L);\n lua_insert(L,-2);\n return 2;\n }\n}\n\n/* -------------------------------------------------------------------------- */\nconst struct luaL_Reg cmds[] = {\n {\"pack\", mp_pack},\n {\"unpack\", mp_unpack},\n {\"unpack_one\", mp_unpack_one},\n {\"unpack_limit\", mp_unpack_limit},\n {0}\n};\n\nint luaopen_create(lua_State *L) {\n int i;\n /* Manually construct our module table instead of\n * relying on _register or _newlib */\n lua_newtable(L);\n\n for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {\n lua_pushcfunction(L, cmds[i].func);\n lua_setfield(L, -2, cmds[i].name);\n }\n\n /* Add metadata */\n lua_pushliteral(L, LUACMSGPACK_NAME);\n lua_setfield(L, -2, \"_NAME\");\n lua_pushliteral(L, LUACMSGPACK_VERSION);\n lua_setfield(L, -2, \"_VERSION\");\n lua_pushliteral(L, LUACMSGPACK_COPYRIGHT);\n lua_setfield(L, -2, \"_COPYRIGHT\");\n lua_pushliteral(L, LUACMSGPACK_DESCRIPTION);\n lua_setfield(L, -2, \"_DESCRIPTION\");\n return 1;\n}\n\nLUALIB_API int luaopen_cmsgpack(lua_State *L) {\n luaopen_create(L);\n\n#if LUA_VERSION_NUM < 502\n /* Register name globally for 5.1 */\n lua_pushvalue(L, -1);\n lua_setglobal(L, LUACMSGPACK_NAME);\n#endif\n\n return 1;\n}\n\nLUALIB_API int luaopen_cmsgpack_safe(lua_State *L) {\n int i;\n\n luaopen_cmsgpack(L);\n\n /* Wrap all functions in the safe handler */\n for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {\n lua_getfield(L, -1, cmds[i].name);\n lua_pushcclosure(L, mp_safe, 1);\n lua_setfield(L, -2, cmds[i].name);\n }\n\n#if LUA_VERSION_NUM < 502\n /* Register name globally for 5.1 */\n lua_pushvalue(L, -1);\n lua_setglobal(L, LUACMSGPACK_SAFE_NAME);\n#endif\n\n return 1;\n}\n\n/******************************************************************************\n* Copyright (C) 2012 Salvatore Sanfilippo. All rights reserved.\n*\n* Permission is hereby granted, free of charge, to any person obtaining\n* a copy of this software and associated documentation files (the\n* \"Software\"), to deal in the Software without restriction, including\n* without limitation the rights to use, copy, modify, merge, publish,\n* distribute, sublicense, and/or sell copies of the Software, and to\n* permit persons to whom the Software is furnished to do so, subject to\n* the following conditions:\n*\n* The above copyright notice and this permission notice shall be\n* included in all copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n******************************************************************************/\n" }, { "path": "deps/lua/src/lua_struct.c", "content": "/*\n** {======================================================\n** Library for packing/unpacking structures.\n** $Id: struct.c,v 1.7 2018/05/11 22:04:31 roberto Exp $\n** See Copyright Notice at the end of this file\n** =======================================================\n*/\n/*\n** Valid formats:\n** > - big endian\n** < - little endian\n** ![num] - alignment\n** x - pading\n** b/B - signed/unsigned byte\n** h/H - signed/unsigned short\n** l/L - signed/unsigned long\n** T - size_t\n** i/In - signed/unsigned integer with size 'n' (default is size of int)\n** cn - sequence of 'n' chars (from/to a string); when packing, n==0 means\n the whole string; when unpacking, n==0 means use the previous\n read number as the string length\n** s - zero-terminated string\n** f - float\n** d - double\n** ' ' - ignored\n*/\n\n\n#include \n#include \n#include \n#include \n#include \n\n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\n\n#if (LUA_VERSION_NUM >= 502)\n\n#define luaL_register(L,n,f)\tluaL_newlib(L,f)\n\n#endif\n\n\n/* basic integer type */\n#if !defined(STRUCT_INT)\n#define STRUCT_INT\tlong\n#endif\n\ntypedef STRUCT_INT Inttype;\n\n/* corresponding unsigned version */\ntypedef unsigned STRUCT_INT Uinttype;\n\n\n/* maximum size (in bytes) for integral types */\n#define MAXINTSIZE\t32\n\n/* is 'x' a power of 2? */\n#define isp2(x)\t\t((x) > 0 && ((x) & ((x) - 1)) == 0)\n\n/* dummy structure to get alignment requirements */\nstruct cD {\n char c;\n double d;\n};\n\n\n#define PADDING\t\t(sizeof(struct cD) - sizeof(double))\n#define MAXALIGN \t(PADDING > sizeof(int) ? PADDING : sizeof(int))\n\n\n/* endian options */\n#define BIG\t0\n#define LITTLE\t1\n\n\nstatic union {\n int dummy;\n char endian;\n} const native = {1};\n\n\ntypedef struct Header {\n int endian;\n int align;\n} Header;\n\n\nstatic int getnum (lua_State *L, const char **fmt, int df) {\n if (!isdigit(**fmt)) /* no number? */\n return df; /* return default value */\n else {\n int a = 0;\n do {\n if (a > (INT_MAX / 10) || a * 10 > (INT_MAX - (**fmt - '0')))\n luaL_error(L, \"integral size overflow\");\n a = a*10 + *((*fmt)++) - '0';\n } while (isdigit(**fmt));\n return a;\n }\n}\n\n\n#define defaultoptions(h)\t((h)->endian = native.endian, (h)->align = 1)\n\n\n\nstatic size_t optsize (lua_State *L, char opt, const char **fmt) {\n switch (opt) {\n case 'B': case 'b': return sizeof(char);\n case 'H': case 'h': return sizeof(short);\n case 'L': case 'l': return sizeof(long);\n case 'T': return sizeof(size_t);\n case 'f': return sizeof(float);\n case 'd': return sizeof(double);\n case 'x': return 1;\n case 'c': return getnum(L, fmt, 1);\n case 'i': case 'I': {\n int sz = getnum(L, fmt, sizeof(int));\n if (sz > MAXINTSIZE)\n luaL_error(L, \"integral size %d is larger than limit of %d\",\n sz, MAXINTSIZE);\n return sz;\n }\n default: return 0; /* other cases do not need alignment */\n }\n}\n\n\n/*\n** return number of bytes needed to align an element of size 'size'\n** at current position 'len'\n*/\nstatic int gettoalign (size_t len, Header *h, int opt, size_t size) {\n if (size == 0 || opt == 'c') return 0;\n if (size > (size_t)h->align)\n size = h->align; /* respect max. alignment */\n return (size - (len & (size - 1))) & (size - 1);\n}\n\n\n/*\n** options to control endianess and alignment\n*/\nstatic void controloptions (lua_State *L, int opt, const char **fmt,\n Header *h) {\n switch (opt) {\n case ' ': return; /* ignore white spaces */\n case '>': h->endian = BIG; return;\n case '<': h->endian = LITTLE; return;\n case '!': {\n int a = getnum(L, fmt, MAXALIGN);\n if (!isp2(a))\n luaL_error(L, \"alignment %d is not a power of 2\", a);\n h->align = a;\n return;\n }\n default: {\n const char *msg = lua_pushfstring(L, \"invalid format option '%c'\", opt);\n luaL_argerror(L, 1, msg);\n }\n }\n}\n\n\nstatic void putinteger (lua_State *L, luaL_Buffer *b, int arg, int endian,\n int size) {\n lua_Number n = luaL_checknumber(L, arg);\n Uinttype value;\n char buff[MAXINTSIZE];\n if (n < 0)\n value = (Uinttype)(Inttype)n;\n else\n value = (Uinttype)n;\n if (endian == LITTLE) {\n int i;\n for (i = 0; i < size; i++) {\n buff[i] = (value & 0xff);\n value >>= 8;\n }\n }\n else {\n int i;\n for (i = size - 1; i >= 0; i--) {\n buff[i] = (value & 0xff);\n value >>= 8;\n }\n }\n luaL_addlstring(b, buff, size);\n}\n\n\nstatic void correctbytes (char *b, int size, int endian) {\n if (endian != native.endian) {\n int i = 0;\n while (i < --size) {\n char temp = b[i];\n b[i++] = b[size];\n b[size] = temp;\n }\n }\n}\n\n\nstatic int b_pack (lua_State *L) {\n luaL_Buffer b;\n const char *fmt = luaL_checkstring(L, 1);\n Header h;\n int arg = 2;\n size_t totalsize = 0;\n defaultoptions(&h);\n lua_pushnil(L); /* mark to separate arguments from string buffer */\n luaL_buffinit(L, &b);\n while (*fmt != '\\0') {\n int opt = *fmt++;\n size_t size = optsize(L, opt, &fmt);\n int toalign = gettoalign(totalsize, &h, opt, size);\n totalsize += toalign;\n while (toalign-- > 0) luaL_addchar(&b, '\\0');\n switch (opt) {\n case 'b': case 'B': case 'h': case 'H':\n case 'l': case 'L': case 'T': case 'i': case 'I': { /* integer types */\n putinteger(L, &b, arg++, h.endian, size);\n break;\n }\n case 'x': {\n luaL_addchar(&b, '\\0');\n break;\n }\n case 'f': {\n float f = (float)luaL_checknumber(L, arg++);\n correctbytes((char *)&f, size, h.endian);\n luaL_addlstring(&b, (char *)&f, size);\n break;\n }\n case 'd': {\n double d = luaL_checknumber(L, arg++);\n correctbytes((char *)&d, size, h.endian);\n luaL_addlstring(&b, (char *)&d, size);\n break;\n }\n case 'c': case 's': {\n size_t l;\n const char *s = luaL_checklstring(L, arg++, &l);\n if (size == 0) size = l;\n luaL_argcheck(L, l >= (size_t)size, arg, \"string too short\");\n luaL_addlstring(&b, s, size);\n if (opt == 's') {\n luaL_addchar(&b, '\\0'); /* add zero at the end */\n size++;\n }\n break;\n }\n default: controloptions(L, opt, &fmt, &h);\n }\n totalsize += size;\n }\n luaL_pushresult(&b);\n return 1;\n}\n\n\nstatic lua_Number getinteger (const char *buff, int endian,\n int issigned, int size) {\n Uinttype l = 0;\n int i;\n if (endian == BIG) {\n for (i = 0; i < size; i++) {\n l <<= 8;\n l |= (Uinttype)(unsigned char)buff[i];\n }\n }\n else {\n for (i = size - 1; i >= 0; i--) {\n l <<= 8;\n l |= (Uinttype)(unsigned char)buff[i];\n }\n }\n if (!issigned)\n return (lua_Number)l;\n else { /* signed format */\n Uinttype mask = (Uinttype)(~((Uinttype)0)) << (size*8 - 1);\n if (l & mask) /* negative value? */\n l |= mask; /* signal extension */\n return (lua_Number)(Inttype)l;\n }\n}\n\n\nstatic int b_unpack (lua_State *L) {\n Header h;\n const char *fmt = luaL_checkstring(L, 1);\n size_t ld;\n const char *data = luaL_checklstring(L, 2, &ld);\n size_t pos = luaL_optinteger(L, 3, 1);\n luaL_argcheck(L, pos > 0, 3, \"offset must be 1 or greater\");\n pos--; /* Lua indexes are 1-based, but here we want 0-based for C\n * pointer math. */\n int n = 0; /* number of results */\n defaultoptions(&h);\n while (*fmt) {\n int opt = *fmt++;\n size_t size = optsize(L, opt, &fmt);\n pos += gettoalign(pos, &h, opt, size);\n luaL_argcheck(L, size <= ld && pos <= ld - size,\n 2, \"data string too short\");\n /* stack space for item + next position */\n luaL_checkstack(L, 2, \"too many results\");\n switch (opt) {\n case 'b': case 'B': case 'h': case 'H':\n case 'l': case 'L': case 'T': case 'i': case 'I': { /* integer types */\n int issigned = islower(opt);\n lua_Number res = getinteger(data+pos, h.endian, issigned, size);\n lua_pushnumber(L, res); n++;\n break;\n }\n case 'x': {\n break;\n }\n case 'f': {\n float f;\n memcpy(&f, data+pos, size);\n correctbytes((char *)&f, sizeof(f), h.endian);\n lua_pushnumber(L, f); n++;\n break;\n }\n case 'd': {\n double d;\n memcpy(&d, data+pos, size);\n correctbytes((char *)&d, sizeof(d), h.endian);\n lua_pushnumber(L, d); n++;\n break;\n }\n case 'c': {\n if (size == 0) {\n if (n == 0 || !lua_isnumber(L, -1))\n luaL_error(L, \"format 'c0' needs a previous size\");\n size = lua_tonumber(L, -1);\n lua_pop(L, 1); n--;\n luaL_argcheck(L, size <= ld && pos <= ld - size,\n 2, \"data string too short\");\n }\n lua_pushlstring(L, data+pos, size); n++;\n break;\n }\n case 's': {\n const char *e = (const char *)memchr(data+pos, '\\0', ld - pos);\n if (e == NULL)\n luaL_error(L, \"unfinished string in data\");\n size = (e - (data+pos)) + 1;\n lua_pushlstring(L, data+pos, size - 1); n++;\n break;\n }\n default: controloptions(L, opt, &fmt, &h);\n }\n pos += size;\n }\n lua_pushinteger(L, pos + 1); /* next position */\n return n + 1;\n}\n\n\nstatic int b_size (lua_State *L) {\n Header h;\n const char *fmt = luaL_checkstring(L, 1);\n size_t pos = 0;\n defaultoptions(&h);\n while (*fmt) {\n int opt = *fmt++;\n size_t size = optsize(L, opt, &fmt);\n pos += gettoalign(pos, &h, opt, size);\n if (opt == 's')\n luaL_argerror(L, 1, \"option 's' has no fixed size\");\n else if (opt == 'c' && size == 0)\n luaL_argerror(L, 1, \"option 'c0' has no fixed size\");\n if (!isalnum(opt))\n controloptions(L, opt, &fmt, &h);\n pos += size;\n }\n lua_pushinteger(L, pos);\n return 1;\n}\n\n/* }====================================================== */\n\n\n\nstatic const struct luaL_Reg thislib[] = {\n {\"pack\", b_pack},\n {\"unpack\", b_unpack},\n {\"size\", b_size},\n {NULL, NULL}\n};\n\n\nLUALIB_API int luaopen_struct (lua_State *L);\n\nLUALIB_API int luaopen_struct (lua_State *L) {\n luaL_register(L, \"struct\", thislib);\n return 1;\n}\n\n\n/******************************************************************************\n* Copyright (C) 2010-2018 Lua.org, PUC-Rio. All rights reserved.\n*\n* Permission is hereby granted, free of charge, to any person obtaining\n* a copy of this software and associated documentation files (the\n* \"Software\"), to deal in the Software without restriction, including\n* without limitation the rights to use, copy, modify, merge, publish,\n* distribute, sublicense, and/or sell copies of the Software, and to\n* permit persons to whom the Software is furnished to do so, subject to\n* the following conditions:\n*\n* The above copyright notice and this permission notice shall be\n* included in all copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n******************************************************************************/\n\n" }, { "path": "deps/lua/src/luac.c", "content": "/*\n** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $\n** Lua compiler (saves bytecodes to files; also list bytecodes)\n** See Copyright Notice in lua.h\n*/\n\n#include \n#include \n#include \n#include \n\n#define luac_c\n#define LUA_CORE\n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lstring.h\"\n#include \"lundump.h\"\n\n#define PROGNAME\t\"luac\"\t\t/* default program name */\n#define\tOUTPUT\t\tPROGNAME \".out\"\t/* default output file */\n\nstatic int listing=0;\t\t\t/* list bytecodes? */\nstatic int dumping=1;\t\t\t/* dump bytecodes? */\nstatic int stripping=0;\t\t\t/* strip debug information? */\nstatic char Output[]={ OUTPUT };\t/* default output file name */\nstatic const char* output=Output;\t/* actual output file name */\nstatic const char* progname=PROGNAME;\t/* actual program name */\n\nstatic void fatal(const char* message)\n{\n fprintf(stderr,\"%s: %s\\n\",progname,message);\n exit(EXIT_FAILURE);\n}\n\nstatic void cannot(const char* what)\n{\n fprintf(stderr,\"%s: cannot %s %s: %s\\n\",progname,what,output,strerror(errno));\n exit(EXIT_FAILURE);\n}\n\nstatic void usage(const char* message)\n{\n if (*message=='-')\n fprintf(stderr,\"%s: unrecognized option \" LUA_QS \"\\n\",progname,message);\n else\n fprintf(stderr,\"%s: %s\\n\",progname,message);\n fprintf(stderr,\n \"usage: %s [options] [filenames].\\n\"\n \"Available options are:\\n\"\n \" - process stdin\\n\"\n \" -l list\\n\"\n \" -o name output to file \" LUA_QL(\"name\") \" (default is \\\"%s\\\")\\n\"\n \" -p parse only\\n\"\n \" -s strip debug information\\n\"\n \" -v show version information\\n\"\n \" -- stop handling options\\n\",\n progname,Output);\n exit(EXIT_FAILURE);\n}\n\n#define\tIS(s)\t(strcmp(argv[i],s)==0)\n\nstatic int doargs(int argc, char* argv[])\n{\n int i;\n int version=0;\n if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];\n for (i=1; itop+(i))->l.p)\n\nstatic const Proto* combine(lua_State* L, int n)\n{\n if (n==1)\n return toproto(L,-1);\n else\n {\n int i,pc;\n Proto* f=luaF_newproto(L);\n setptvalue2s(L,L->top,f); incr_top(L);\n f->source=luaS_newliteral(L,\"=(\" PROGNAME \")\");\n f->maxstacksize=1;\n pc=2*n+1;\n f->code=luaM_newvector(L,pc,Instruction);\n f->sizecode=pc;\n f->p=luaM_newvector(L,n,Proto*);\n f->sizep=n;\n pc=0;\n for (i=0; ip[i]=toproto(L,i-n-1);\n f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);\n f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);\n }\n f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);\n return f;\n }\n}\n\nstatic int writer(lua_State* L, const void* p, size_t size, void* u)\n{\n UNUSED(L);\n return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);\n}\n\nstruct Smain {\n int argc;\n char** argv;\n};\n\nstatic int pmain(lua_State* L)\n{\n struct Smain* s = (struct Smain*)lua_touserdata(L, 1);\n int argc=s->argc;\n char** argv=s->argv;\n const Proto* f;\n int i;\n if (!lua_checkstack(L,argc)) fatal(\"too many input files\");\n for (i=0; i1);\n if (dumping)\n {\n FILE* D= (output==NULL) ? stdout : fopen(output,\"wb\");\n if (D==NULL) cannot(\"open\");\n lua_lock(L);\n luaU_dump(L,f,writer,D,stripping);\n lua_unlock(L);\n if (ferror(D)) cannot(\"write\");\n if (fclose(D)) cannot(\"close\");\n }\n return 0;\n}\n\nint main(int argc, char* argv[])\n{\n lua_State* L;\n struct Smain s;\n int i=doargs(argc,argv);\n argc-=i; argv+=i;\n if (argc<=0) usage(\"no input files given\");\n L=lua_open();\n if (L==NULL) fatal(\"not enough memory for state\");\n s.argc=argc;\n s.argv=argv;\n if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));\n lua_close(L);\n return EXIT_SUCCESS;\n}\n" }, { "path": "deps/lua/src/luaconf.h", "content": "/*\n** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $\n** Configuration file for Lua\n** See Copyright Notice in lua.h\n*/\n\n\n#ifndef lconfig_h\n#define lconfig_h\n\n#include \n#include \n\n\n/*\n** ==================================================================\n** Search for \"@@\" to find all configurable definitions.\n** ===================================================================\n*/\n\n\n/*\n@@ LUA_ANSI controls the use of non-ansi features.\n** CHANGE it (define it) if you want Lua to avoid the use of any\n** non-ansi feature or library.\n*/\n#if defined(__STRICT_ANSI__)\n#define LUA_ANSI\n#endif\n\n\n#if !defined(LUA_ANSI) && defined(_WIN32)\n#define LUA_WIN\n#endif\n\n#if defined(LUA_USE_LINUX)\n#define LUA_USE_POSIX\n#define LUA_USE_DLOPEN\t\t/* needs an extra library: -ldl */\n#define LUA_USE_READLINE\t/* needs some extra libraries */\n#endif\n\n#if defined(LUA_USE_MACOSX)\n#define LUA_USE_POSIX\n#define LUA_DL_DYLD\t\t/* does not need extra library */\n#endif\n\n\n\n/*\n@@ LUA_USE_POSIX includes all functionallity listed as X/Open System\n@* Interfaces Extension (XSI).\n** CHANGE it (define it) if your system is XSI compatible.\n*/\n#if defined(LUA_USE_POSIX)\n#define LUA_USE_MKSTEMP\n#define LUA_USE_ISATTY\n#define LUA_USE_POPEN\n#define LUA_USE_ULONGJMP\n#endif\n\n\n/*\n@@ LUA_PATH and LUA_CPATH are the names of the environment variables that\n@* Lua check to set its paths.\n@@ LUA_INIT is the name of the environment variable that Lua\n@* checks for initialization code.\n** CHANGE them if you want different names.\n*/\n#define LUA_PATH \"LUA_PATH\"\n#define LUA_CPATH \"LUA_CPATH\"\n#define LUA_INIT\t\"LUA_INIT\"\n\n\n/*\n@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for\n@* Lua libraries.\n@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for\n@* C libraries.\n** CHANGE them if your machine has a non-conventional directory\n** hierarchy or if you want to install your libraries in\n** non-conventional directories.\n*/\n#if defined(_WIN32)\n/*\n** In Windows, any exclamation mark ('!') in the path is replaced by the\n** path of the directory of the executable file of the current process.\n*/\n#define LUA_LDIR\t\"!\\\\lua\\\\\"\n#define LUA_CDIR\t\"!\\\\\"\n#define LUA_PATH_DEFAULT \\\n\t\t\".\\\\?.lua;\" LUA_LDIR\"?.lua;\" LUA_LDIR\"?\\\\init.lua;\" \\\n\t\t LUA_CDIR\"?.lua;\" LUA_CDIR\"?\\\\init.lua\"\n#define LUA_CPATH_DEFAULT \\\n\t\".\\\\?.dll;\" LUA_CDIR\"?.dll;\" LUA_CDIR\"loadall.dll\"\n\n#else\n#define LUA_ROOT\t\"/usr/local/\"\n#define LUA_LDIR\tLUA_ROOT \"share/lua/5.1/\"\n#define LUA_CDIR\tLUA_ROOT \"lib/lua/5.1/\"\n#define LUA_PATH_DEFAULT \\\n\t\t\"./?.lua;\" LUA_LDIR\"?.lua;\" LUA_LDIR\"?/init.lua;\" \\\n\t\t LUA_CDIR\"?.lua;\" LUA_CDIR\"?/init.lua\"\n#define LUA_CPATH_DEFAULT \\\n\t\"./?.so;\" LUA_CDIR\"?.so;\" LUA_CDIR\"loadall.so\"\n#endif\n\n\n/*\n@@ LUA_DIRSEP is the directory separator (for submodules).\n** CHANGE it if your machine does not use \"/\" as the directory separator\n** and is not Windows. (On Windows Lua automatically uses \"\\\".)\n*/\n#if defined(_WIN32)\n#define LUA_DIRSEP\t\"\\\\\"\n#else\n#define LUA_DIRSEP\t\"/\"\n#endif\n\n\n/*\n@@ LUA_PATHSEP is the character that separates templates in a path.\n@@ LUA_PATH_MARK is the string that marks the substitution points in a\n@* template.\n@@ LUA_EXECDIR in a Windows path is replaced by the executable's\n@* directory.\n@@ LUA_IGMARK is a mark to ignore all before it when bulding the\n@* luaopen_ function name.\n** CHANGE them if for some reason your system cannot use those\n** characters. (E.g., if one of those characters is a common character\n** in file/directory names.) Probably you do not need to change them.\n*/\n#define LUA_PATHSEP\t\";\"\n#define LUA_PATH_MARK\t\"?\"\n#define LUA_EXECDIR\t\"!\"\n#define LUA_IGMARK\t\"-\"\n\n\n/*\n@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.\n** CHANGE that if ptrdiff_t is not adequate on your machine. (On most\n** machines, ptrdiff_t gives a good choice between int or long.)\n*/\n#define LUA_INTEGER\tptrdiff_t\n\n\n/*\n@@ LUA_API is a mark for all core API functions.\n@@ LUALIB_API is a mark for all standard library functions.\n** CHANGE them if you need to define those functions in some special way.\n** For instance, if you want to create one Windows DLL with the core and\n** the libraries, you may want to use the following definition (define\n** LUA_BUILD_AS_DLL to get it).\n*/\n#if defined(LUA_BUILD_AS_DLL)\n\n#if defined(LUA_CORE) || defined(LUA_LIB)\n#define LUA_API __declspec(dllexport)\n#else\n#define LUA_API __declspec(dllimport)\n#endif\n\n#else\n\n#define LUA_API\t\textern\n\n#endif\n\n/* more often than not the libs go together with the core */\n#define LUALIB_API\tLUA_API\n\n\n/*\n@@ LUAI_FUNC is a mark for all extern functions that are not to be\n@* exported to outside modules.\n@@ LUAI_DATA is a mark for all extern (const) variables that are not to\n@* be exported to outside modules.\n** CHANGE them if you need to mark them in some special way. Elf/gcc\n** (versions 3.2 and later) mark them as \"hidden\" to optimize access\n** when Lua is compiled as a shared library.\n*/\n#if defined(luaall_c)\n#define LUAI_FUNC\tstatic\n#define LUAI_DATA\t/* empty */\n\n#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \\\n defined(__ELF__)\n#define LUAI_FUNC\t__attribute__((visibility(\"hidden\"))) extern\n#define LUAI_DATA\tLUAI_FUNC\n\n#else\n#define LUAI_FUNC\textern\n#define LUAI_DATA\textern\n#endif\n\n\n\n/*\n@@ LUA_QL describes how error messages quote program elements.\n** CHANGE it if you want a different appearance.\n*/\n#define LUA_QL(x)\t\"'\" x \"'\"\n#define LUA_QS\t\tLUA_QL(\"%s\")\n\n\n/*\n@@ LUA_IDSIZE gives the maximum size for the description of the source\n@* of a function in debug information.\n** CHANGE it if you want a different size.\n*/\n#define LUA_IDSIZE\t60\n\n\n/*\n** {==================================================================\n** Stand-alone configuration\n** ===================================================================\n*/\n\n#if defined(lua_c) || defined(luaall_c)\n\n/*\n@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that\n@* is, whether we're running lua interactively).\n** CHANGE it if you have a better definition for non-POSIX/non-Windows\n** systems.\n*/\n#if defined(LUA_USE_ISATTY)\n#include \n#define lua_stdin_is_tty()\tisatty(0)\n#elif defined(LUA_WIN)\n#include \n#include \n#define lua_stdin_is_tty()\t_isatty(_fileno(stdin))\n#else\n#define lua_stdin_is_tty()\t1 /* assume stdin is a tty */\n#endif\n\n\n/*\n@@ LUA_PROMPT is the default prompt used by stand-alone Lua.\n@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.\n** CHANGE them if you want different prompts. (You can also change the\n** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)\n*/\n#define LUA_PROMPT\t\t\"> \"\n#define LUA_PROMPT2\t\t\">> \"\n\n\n/*\n@@ LUA_PROGNAME is the default name for the stand-alone Lua program.\n** CHANGE it if your stand-alone interpreter has a different name and\n** your system is not able to detect that name automatically.\n*/\n#define LUA_PROGNAME\t\t\"lua\"\n\n\n/*\n@@ LUA_MAXINPUT is the maximum length for an input line in the\n@* stand-alone interpreter.\n** CHANGE it if you need longer lines.\n*/\n#define LUA_MAXINPUT\t512\n\n\n/*\n@@ lua_readline defines how to show a prompt and then read a line from\n@* the standard input.\n@@ lua_saveline defines how to \"save\" a read line in a \"history\".\n@@ lua_freeline defines how to free a line read by lua_readline.\n** CHANGE them if you want to improve this functionality (e.g., by using\n** GNU readline and history facilities).\n*/\n#if defined(LUA_USE_READLINE)\n#include \n#include \n#include \n#define lua_readline(L,b,p)\t((void)L, ((b)=readline(p)) != NULL)\n#define lua_saveline(L,idx) \\\n\tif (lua_strlen(L,idx) > 0) /* non-empty line? */ \\\n\t add_history(lua_tostring(L, idx)); /* add it to history */\n#define lua_freeline(L,b)\t((void)L, free(b))\n#else\n#define lua_readline(L,b,p)\t\\\n\t((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \\\n\tfgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */\n#define lua_saveline(L,idx)\t{ (void)L; (void)idx; }\n#define lua_freeline(L,b)\t{ (void)L; (void)b; }\n#endif\n\n#endif\n\n/* }================================================================== */\n\n\n/*\n@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles\n@* as a percentage.\n** CHANGE it if you want the GC to run faster or slower (higher values\n** mean larger pauses which mean slower collection.) You can also change\n** this value dynamically.\n*/\n#define LUAI_GCPAUSE\t200 /* 200% (wait memory to double before next GC) */\n\n\n/*\n@@ LUAI_GCMUL defines the default speed of garbage collection relative to\n@* memory allocation as a percentage.\n** CHANGE it if you want to change the granularity of the garbage\n** collection. (Higher values mean coarser collections. 0 represents\n** infinity, where each step performs a full collection.) You can also\n** change this value dynamically.\n*/\n#define LUAI_GCMUL\t200 /* GC runs 'twice the speed' of memory allocation */\n\n\n\n/*\n@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.\n** CHANGE it (define it) if you want exact compatibility with the\n** behavior of setn/getn in Lua 5.0.\n*/\n#undef LUA_COMPAT_GETN\n\n/*\n@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.\n** CHANGE it to undefined as soon as you do not need a global 'loadlib'\n** function (the function is still available as 'package.loadlib').\n*/\n#undef LUA_COMPAT_LOADLIB\n\n/*\n@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.\n** CHANGE it to undefined as soon as your programs use only '...' to\n** access vararg parameters (instead of the old 'arg' table).\n*/\n#define LUA_COMPAT_VARARG\n\n/*\n@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.\n** CHANGE it to undefined as soon as your programs use 'math.fmod' or\n** the new '%' operator instead of 'math.mod'.\n*/\n#define LUA_COMPAT_MOD\n\n/*\n@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting\n@* facility.\n** CHANGE it to 2 if you want the old behaviour, or undefine it to turn\n** off the advisory error when nesting [[...]].\n*/\n#define LUA_COMPAT_LSTR\t\t1\n\n/*\n@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.\n** CHANGE it to undefined as soon as you rename 'string.gfind' to\n** 'string.gmatch'.\n*/\n#define LUA_COMPAT_GFIND\n\n/*\n@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'\n@* behavior.\n** CHANGE it to undefined as soon as you replace to 'luaL_register'\n** your uses of 'luaL_openlib'\n*/\n#define LUA_COMPAT_OPENLIB\n\n\n\n/*\n@@ luai_apicheck is the assert macro used by the Lua-C API.\n** CHANGE luai_apicheck if you want Lua to perform some checks in the\n** parameters it gets from API calls. This may slow down the interpreter\n** a bit, but may be quite useful when debugging C code that interfaces\n** with Lua. A useful redefinition is to use assert.h.\n*/\n#if defined(LUA_USE_APICHECK)\n#include \n#define luai_apicheck(L,o)\t{ (void)L; assert(o); }\n#else\n#define luai_apicheck(L,o)\t{ (void)L; }\n#endif\n\n\n/*\n@@ LUAI_BITSINT defines the number of bits in an int.\n** CHANGE here if Lua cannot automatically detect the number of bits of\n** your machine. Probably you do not need to change this.\n*/\n/* avoid overflows in comparison */\n#if INT_MAX-20 < 32760\n#define LUAI_BITSINT\t16\n#elif INT_MAX > 2147483640L\n/* int has at least 32 bits */\n#define LUAI_BITSINT\t32\n#else\n#error \"you must define LUA_BITSINT with number of bits in an integer\"\n#endif\n\n\n/*\n@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.\n@@ LUAI_INT32 is an signed integer with at least 32 bits.\n@@ LUAI_UMEM is an unsigned integer big enough to count the total\n@* memory used by Lua.\n@@ LUAI_MEM is a signed integer big enough to count the total memory\n@* used by Lua.\n** CHANGE here if for some weird reason the default definitions are not\n** good enough for your machine. (The definitions in the 'else'\n** part always works, but may waste space on machines with 64-bit\n** longs.) Probably you do not need to change this.\n*/\n#if LUAI_BITSINT >= 32\n#define LUAI_UINT32\tunsigned int\n#define LUAI_INT32\tint\n#define LUAI_MAXINT32\tINT_MAX\n#define LUAI_UMEM\tsize_t\n#define LUAI_MEM\tptrdiff_t\n#else\n/* 16-bit ints */\n#define LUAI_UINT32\tunsigned long\n#define LUAI_INT32\tlong\n#define LUAI_MAXINT32\tLONG_MAX\n#define LUAI_UMEM\tunsigned long\n#define LUAI_MEM\tlong\n#endif\n\n\n/*\n@@ LUAI_MAXCALLS limits the number of nested calls.\n** CHANGE it if you need really deep recursive calls. This limit is\n** arbitrary; its only purpose is to stop infinite recursion before\n** exhausting memory.\n*/\n#define LUAI_MAXCALLS\t20000\n\n\n/*\n@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function\n@* can use.\n** CHANGE it if you need lots of (Lua) stack space for your C\n** functions. This limit is arbitrary; its only purpose is to stop C\n** functions to consume unlimited stack space. (must be smaller than\n** -LUA_REGISTRYINDEX)\n*/\n#define LUAI_MAXCSTACK\t8000\n\n\n\n/*\n** {==================================================================\n** CHANGE (to smaller values) the following definitions if your system\n** has a small C stack. (Or you may want to change them to larger\n** values if your system has a large C stack and these limits are\n** too rigid for you.) Some of these constants control the size of\n** stack-allocated arrays used by the compiler or the interpreter, while\n** others limit the maximum number of recursive calls that the compiler\n** or the interpreter can perform. Values too large may cause a C stack\n** overflow for some forms of deep constructs.\n** ===================================================================\n*/\n\n\n/*\n@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and\n@* syntactical nested non-terminals in a program.\n*/\n#define LUAI_MAXCCALLS\t\t200\n\n\n/*\n@@ LUAI_MAXVARS is the maximum number of local variables per function\n@* (must be smaller than 250).\n*/\n#define LUAI_MAXVARS\t\t200\n\n\n/*\n@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function\n@* (must be smaller than 250).\n*/\n#define LUAI_MAXUPVALUES\t60\n\n\n/*\n@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.\n*/\n#define LUAL_BUFFERSIZE\t\tBUFSIZ\n\n/* }================================================================== */\n\n\n\n\n/*\n** {==================================================================\n@@ LUA_NUMBER is the type of numbers in Lua.\n** CHANGE the following definitions only if you want to build Lua\n** with a number type different from double. You may also need to\n** change lua_number2int & lua_number2integer.\n** ===================================================================\n*/\n\n#define LUA_NUMBER_DOUBLE\n#define LUA_NUMBER\tdouble\n\n/*\n@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'\n@* over a number.\n*/\n#define LUAI_UACNUMBER\tdouble\n\n\n/*\n@@ LUA_NUMBER_SCAN is the format for reading numbers.\n@@ LUA_NUMBER_FMT is the format for writing numbers.\n@@ lua_number2str converts a number to a string.\n@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.\n@@ lua_str2number converts a string to a number.\n*/\n#define LUA_NUMBER_SCAN\t\t\"%lf\"\n#define LUA_NUMBER_FMT\t\t\"%.14g\"\n#define lua_number2str(s,n)\tsprintf((s), LUA_NUMBER_FMT, (n))\n#define LUAI_MAXNUMBER2STR\t32 /* 16 digits, sign, point, and \\0 */\n#define lua_str2number(s,p)\tstrtod((s), (p))\n\n\n/*\n@@ The luai_num* macros define the primitive operations over numbers.\n*/\n#if defined(LUA_CORE)\n#include \n#define luai_numadd(a,b)\t((a)+(b))\n#define luai_numsub(a,b)\t((a)-(b))\n#define luai_nummul(a,b)\t((a)*(b))\n#define luai_numdiv(a,b)\t((a)/(b))\n#define luai_nummod(a,b)\t((a) - floor((a)/(b))*(b))\n#define luai_numpow(a,b)\t(pow(a,b))\n#define luai_numunm(a)\t\t(-(a))\n#define luai_numeq(a,b)\t\t((a)==(b))\n#define luai_numlt(a,b)\t\t((a)<(b))\n#define luai_numle(a,b)\t\t((a)<=(b))\n#define luai_numisnan(a)\t(!luai_numeq((a), (a)))\n#endif\n\n\n/*\n@@ lua_number2int is a macro to convert lua_Number to int.\n@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.\n** CHANGE them if you know a faster way to convert a lua_Number to\n** int (with any rounding method and without throwing errors) in your\n** system. In Pentium machines, a naive typecast from double to int\n** in C is extremely slow, so any alternative is worth trying.\n*/\n\n/* On a Pentium, resort to a trick */\n#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \\\n (defined(__i386) || defined (_M_IX86) || defined(__i386__))\n\n/* On a Microsoft compiler, use assembler */\n#if defined(_MSC_VER)\n\n#define lua_number2int(i,d) __asm fld d __asm fistp i\n#define lua_number2integer(i,n)\t\tlua_number2int(i, n)\n\n/* the next trick should work on any Pentium, but sometimes clashes\n with a DirectX idiosyncrasy */\n#else\n\nunion luai_Cast { double l_d; long l_l; };\n#define lua_number2int(i,d) \\\n { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }\n#define lua_number2integer(i,n)\t\tlua_number2int(i, n)\n\n#endif\n\n\n/* this option always works, but may be slow */\n#else\n#define lua_number2int(i,d)\t((i)=(int)(d))\n#define lua_number2integer(i,d)\t((i)=(lua_Integer)(d))\n\n#endif\n\n/* }================================================================== */\n\n\n/*\n@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.\n** CHANGE it if your system requires alignments larger than double. (For\n** instance, if your system supports long doubles and they must be\n** aligned in 16-byte boundaries, then you should add long double in the\n** union.) Probably you do not need to change this.\n*/\n#define LUAI_USER_ALIGNMENT_T\tunion { double u; void *s; long l; }\n\n\n/*\n@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.\n** CHANGE them if you prefer to use longjmp/setjmp even with C++\n** or if want/don't to use _longjmp/_setjmp instead of regular\n** longjmp/setjmp. By default, Lua handles errors with exceptions when\n** compiling as C++ code, with _longjmp/_setjmp when asked to use them,\n** and with longjmp/setjmp otherwise.\n*/\n#if defined(__cplusplus)\n/* C++ exceptions */\n#define LUAI_THROW(L,c)\tthrow(c)\n#define LUAI_TRY(L,c,a)\ttry { a } catch(...) \\\n\t{ if ((c)->status == 0) (c)->status = -1; }\n#define luai_jmpbuf\tint /* dummy variable */\n\n#elif defined(LUA_USE_ULONGJMP)\n/* in Unix, try _longjmp/_setjmp (more efficient) */\n#define LUAI_THROW(L,c)\t_longjmp((c)->b, 1)\n#define LUAI_TRY(L,c,a)\tif (_setjmp((c)->b) == 0) { a }\n#define luai_jmpbuf\tjmp_buf\n\n#else\n/* default handling with long jumps */\n#define LUAI_THROW(L,c)\tlongjmp((c)->b, 1)\n#define LUAI_TRY(L,c,a)\tif (setjmp((c)->b) == 0) { a }\n#define luai_jmpbuf\tjmp_buf\n\n#endif\n\n\n/*\n@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern\n@* can do during pattern-matching.\n** CHANGE it if you need more captures. This limit is arbitrary.\n*/\n#define LUA_MAXCAPTURES\t\t32\n\n\n/*\n@@ lua_tmpnam is the function that the OS library uses to create a\n@* temporary name.\n@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.\n** CHANGE them if you have an alternative to tmpnam (which is considered\n** insecure) or if you want the original tmpnam anyway. By default, Lua\n** uses tmpnam except when POSIX is available, where it uses mkstemp.\n*/\n#if defined(loslib_c) || defined(luaall_c)\n\n#if defined(LUA_USE_MKSTEMP)\n#include \n#define LUA_TMPNAMBUFSIZE\t32\n#define lua_tmpnam(b,e)\t{ \\\n\tstrcpy(b, \"/tmp/lua_XXXXXX\"); \\\n\te = mkstemp(b); \\\n\tif (e != -1) close(e); \\\n\te = (e == -1); }\n\n#else\n#define LUA_TMPNAMBUFSIZE\tL_tmpnam\n#define lua_tmpnam(b,e)\t\t{ e = (tmpnam(b) == NULL); }\n#endif\n\n#endif\n\n\n/*\n@@ lua_popen spawns a new process connected to the current one through\n@* the file streams.\n** CHANGE it if you have a way to implement it in your system.\n*/\n#if defined(LUA_USE_POPEN)\n\n#define lua_popen(L,c,m)\t((void)L, fflush(NULL), popen(c,m))\n#define lua_pclose(L,file)\t((void)L, (pclose(file) != -1))\n\n#elif defined(LUA_WIN)\n\n#define lua_popen(L,c,m)\t((void)L, _popen(c,m))\n#define lua_pclose(L,file)\t((void)L, (_pclose(file) != -1))\n\n#else\n\n#define lua_popen(L,c,m)\t((void)((void)c, m), \\\n\t\tluaL_error(L, LUA_QL(\"popen\") \" not supported\"), (FILE*)0)\n#define lua_pclose(L,file)\t\t((void)((void)L, file), 0)\n\n#endif\n\n/*\n@@ LUA_DL_* define which dynamic-library system Lua should use.\n** CHANGE here if Lua has problems choosing the appropriate\n** dynamic-library system for your platform (either Windows' DLL, Mac's\n** dyld, or Unix's dlopen). If your system is some kind of Unix, there\n** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for\n** it. To use dlopen you also need to adapt the src/Makefile (probably\n** adding -ldl to the linker options), so Lua does not select it\n** automatically. (When you change the makefile to add -ldl, you must\n** also add -DLUA_USE_DLOPEN.)\n** If you do not want any kind of dynamic library, undefine all these\n** options.\n** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.\n*/\n#if defined(LUA_USE_DLOPEN)\n#define LUA_DL_DLOPEN\n#endif\n\n#if defined(LUA_WIN)\n#define LUA_DL_DLL\n#endif\n\n\n/*\n@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State\n@* (the data goes just *before* the lua_State pointer).\n** CHANGE (define) this if you really need that. This value must be\n** a multiple of the maximum alignment required for your machine.\n*/\n#define LUAI_EXTRASPACE\t\t0\n\n\n/*\n@@ luai_userstate* allow user-specific actions on threads.\n** CHANGE them if you defined LUAI_EXTRASPACE and need to do something\n** extra when a thread is created/deleted/resumed/yielded.\n*/\n#define luai_userstateopen(L)\t\t((void)L)\n#define luai_userstateclose(L)\t\t((void)L)\n#define luai_userstatethread(L,L1)\t((void)L)\n#define luai_userstatefree(L)\t\t((void)L)\n#define luai_userstateresume(L,n)\t((void)L)\n#define luai_userstateyield(L,n)\t((void)L)\n\n\n/*\n@@ LUA_INTFRMLEN is the length modifier for integer conversions\n@* in 'string.format'.\n@@ LUA_INTFRM_T is the integer type correspoding to the previous length\n@* modifier.\n** CHANGE them if your system supports long long or does not support long.\n*/\n\n#if defined(LUA_USELONGLONG)\n\n#define LUA_INTFRMLEN\t\t\"ll\"\n#define LUA_INTFRM_T\t\tlong long\n\n#else\n\n#define LUA_INTFRMLEN\t\t\"l\"\n#define LUA_INTFRM_T\t\tlong\n\n#endif\n\n\n\n/* =================================================================== */\n\n/*\n** Local configuration. You can use this space to add your redefinitions\n** without modifying the main part of the file.\n*/\n\n\n\n#endif\n\n" }, { "path": "deps/lua/src/lualib.h", "content": "/*\n** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $\n** Lua standard libraries\n** See Copyright Notice in lua.h\n*/\n\n\n#ifndef lualib_h\n#define lualib_h\n\n#include \"lua.h\"\n\n\n/* Key to file-handle type */\n#define LUA_FILEHANDLE\t\t\"FILE*\"\n\n\n#define LUA_COLIBNAME\t\"coroutine\"\nLUALIB_API int (luaopen_base) (lua_State *L);\n\n#define LUA_TABLIBNAME\t\"table\"\nLUALIB_API int (luaopen_table) (lua_State *L);\n\n#define LUA_IOLIBNAME\t\"io\"\nLUALIB_API int (luaopen_io) (lua_State *L);\n\n#define LUA_OSLIBNAME\t\"os\"\nLUALIB_API int (luaopen_os) (lua_State *L);\n\n#define LUA_STRLIBNAME\t\"string\"\nLUALIB_API int (luaopen_string) (lua_State *L);\n\n#define LUA_MATHLIBNAME\t\"math\"\nLUALIB_API int (luaopen_math) (lua_State *L);\n\n#define LUA_DBLIBNAME\t\"debug\"\nLUALIB_API int (luaopen_debug) (lua_State *L);\n\n#define LUA_LOADLIBNAME\t\"package\"\nLUALIB_API int (luaopen_package) (lua_State *L);\n\n\n/* open all previous libraries */\nLUALIB_API void (luaL_openlibs) (lua_State *L); \n\n\n\n#ifndef lua_assert\n#define lua_assert(x)\t((void)0)\n#endif\n\n\n#endif\n" }, { "path": "deps/lua/src/lundump.c", "content": "/*\n** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $\n** load precompiled Lua chunks\n** See Copyright Notice in lua.h\n*/\n\n#include \n\n#define lundump_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lmem.h\"\n#include \"lobject.h\"\n#include \"lstring.h\"\n#include \"lundump.h\"\n#include \"lzio.h\"\n\ntypedef struct {\n lua_State* L;\n ZIO* Z;\n Mbuffer* b;\n const char* name;\n} LoadState;\n\n#ifdef LUAC_TRUST_BINARIES\n#define IF(c,s)\n#define error(S,s)\n#else\n#define IF(c,s)\t\tif (c) error(S,s)\n\nstatic void error(LoadState* S, const char* why)\n{\n luaO_pushfstring(S->L,\"%s: %s in precompiled chunk\",S->name,why);\n luaD_throw(S->L,LUA_ERRSYNTAX);\n}\n#endif\n\n#define LoadMem(S,b,n,size)\tLoadBlock(S,b,(n)*(size))\n#define\tLoadByte(S)\t\t(lu_byte)LoadChar(S)\n#define LoadVar(S,x)\t\tLoadMem(S,&x,1,sizeof(x))\n#define LoadVector(S,b,n,size)\tLoadMem(S,b,n,size)\n\nstatic void LoadBlock(LoadState* S, void* b, size_t size)\n{\n size_t r=luaZ_read(S->Z,b,size);\n IF (r!=0, \"unexpected end\");\n}\n\nstatic int LoadChar(LoadState* S)\n{\n char x;\n LoadVar(S,x);\n return x;\n}\n\nstatic int LoadInt(LoadState* S)\n{\n int x;\n LoadVar(S,x);\n IF (x<0, \"bad integer\");\n return x;\n}\n\nstatic lua_Number LoadNumber(LoadState* S)\n{\n lua_Number x;\n LoadVar(S,x);\n return x;\n}\n\nstatic TString* LoadString(LoadState* S)\n{\n size_t size;\n LoadVar(S,size);\n if (size==0)\n return NULL;\n else\n {\n char* s=luaZ_openspace(S->L,S->b,size);\n LoadBlock(S,s,size);\n return luaS_newlstr(S->L,s,size-1);\t\t/* remove trailing '\\0' */\n }\n}\n\nstatic void LoadCode(LoadState* S, Proto* f)\n{\n int n=LoadInt(S);\n f->code=luaM_newvector(S->L,n,Instruction);\n f->sizecode=n;\n LoadVector(S,f->code,n,sizeof(Instruction));\n}\n\nstatic Proto* LoadFunction(LoadState* S, TString* p);\n\nstatic void LoadConstants(LoadState* S, Proto* f)\n{\n int i,n;\n n=LoadInt(S);\n f->k=luaM_newvector(S->L,n,TValue);\n f->sizek=n;\n for (i=0; ik[i]);\n for (i=0; ik[i];\n int t=LoadChar(S);\n switch (t)\n {\n case LUA_TNIL:\n \tsetnilvalue(o);\n\tbreak;\n case LUA_TBOOLEAN:\n \tsetbvalue(o,LoadChar(S)!=0);\n\tbreak;\n case LUA_TNUMBER:\n\tsetnvalue(o,LoadNumber(S));\n\tbreak;\n case LUA_TSTRING:\n\tsetsvalue2n(S->L,o,LoadString(S));\n\tbreak;\n default:\n\terror(S,\"bad constant\");\n\tbreak;\n }\n }\n n=LoadInt(S);\n f->p=luaM_newvector(S->L,n,Proto*);\n f->sizep=n;\n for (i=0; ip[i]=NULL;\n for (i=0; ip[i]=LoadFunction(S,f->source);\n}\n\nstatic void LoadDebug(LoadState* S, Proto* f)\n{\n int i,n;\n n=LoadInt(S);\n f->lineinfo=luaM_newvector(S->L,n,int);\n f->sizelineinfo=n;\n LoadVector(S,f->lineinfo,n,sizeof(int));\n n=LoadInt(S);\n f->locvars=luaM_newvector(S->L,n,LocVar);\n f->sizelocvars=n;\n for (i=0; ilocvars[i].varname=NULL;\n for (i=0; ilocvars[i].varname=LoadString(S);\n f->locvars[i].startpc=LoadInt(S);\n f->locvars[i].endpc=LoadInt(S);\n }\n n=LoadInt(S);\n f->upvalues=luaM_newvector(S->L,n,TString*);\n f->sizeupvalues=n;\n for (i=0; iupvalues[i]=NULL;\n for (i=0; iupvalues[i]=LoadString(S);\n}\n\nstatic Proto* LoadFunction(LoadState* S, TString* p)\n{\n Proto* f;\n if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,\"code too deep\");\n f=luaF_newproto(S->L);\n setptvalue2s(S->L,S->L->top,f); incr_top(S->L);\n f->source=LoadString(S); if (f->source==NULL) f->source=p;\n f->linedefined=LoadInt(S);\n f->lastlinedefined=LoadInt(S);\n f->nups=LoadByte(S);\n f->numparams=LoadByte(S);\n f->is_vararg=LoadByte(S);\n f->maxstacksize=LoadByte(S);\n LoadCode(S,f);\n LoadConstants(S,f);\n LoadDebug(S,f);\n IF (!luaG_checkcode(f), \"bad code\");\n S->L->top--;\n S->L->nCcalls--;\n return f;\n}\n\nstatic void LoadHeader(LoadState* S)\n{\n char h[LUAC_HEADERSIZE];\n char s[LUAC_HEADERSIZE];\n luaU_header(h);\n LoadBlock(S,s,LUAC_HEADERSIZE);\n IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, \"bad header\");\n}\n\n/*\n** load precompiled chunk\n*/\nProto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)\n{\n LoadState S;\n if (*name=='@' || *name=='=')\n S.name=name+1;\n else if (*name==LUA_SIGNATURE[0])\n S.name=\"binary string\";\n else\n S.name=name;\n S.L=L;\n S.Z=Z;\n S.b=buff;\n LoadHeader(&S);\n return LoadFunction(&S,luaS_newliteral(L,\"=?\"));\n}\n\n/*\n* make header\n*/\nvoid luaU_header (char* h)\n{\n int x=1;\n memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);\n h+=sizeof(LUA_SIGNATURE)-1;\n *h++=(char)LUAC_VERSION;\n *h++=(char)LUAC_FORMAT;\n *h++=(char)*(char*)&x;\t\t\t\t/* endianness */\n *h++=(char)sizeof(int);\n *h++=(char)sizeof(size_t);\n *h++=(char)sizeof(Instruction);\n *h++=(char)sizeof(lua_Number);\n *h++=(char)(((lua_Number)0.5)==0);\t\t/* is lua_Number integral? */\n}\n" }, { "path": "deps/lua/src/lundump.h", "content": "/*\n** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $\n** load precompiled Lua chunks\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lundump_h\n#define lundump_h\n\n#include \"lobject.h\"\n#include \"lzio.h\"\n\n/* load one chunk; from lundump.c */\nLUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);\n\n/* make header; from lundump.c */\nLUAI_FUNC void luaU_header (char* h);\n\n/* dump one chunk; from ldump.c */\nLUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);\n\n#ifdef luac_c\n/* print one chunk; from print.c */\nLUAI_FUNC void luaU_print (const Proto* f, int full);\n#endif\n\n/* for header of binary files -- this is Lua 5.1 */\n#define LUAC_VERSION\t\t0x51\n\n/* for header of binary files -- this is the official format */\n#define LUAC_FORMAT\t\t0\n\n/* size of header of binary files */\n#define LUAC_HEADERSIZE\t\t12\n\n#endif\n" }, { "path": "deps/lua/src/lvm.c", "content": "/*\n** $Id: lvm.c,v 2.63.1.5 2011/08/17 20:43:11 roberto Exp $\n** Lua virtual machine\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n#include \n#include \n\n#define lvm_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"ldebug.h\"\n#include \"ldo.h\"\n#include \"lfunc.h\"\n#include \"lgc.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lstate.h\"\n#include \"lstring.h\"\n#include \"ltable.h\"\n#include \"ltm.h\"\n#include \"lvm.h\"\n\n\n\n/* limit for table tag-method chains (to avoid loops) */\n#define MAXTAGLOOP\t100\n\n\nconst TValue *luaV_tonumber (const TValue *obj, TValue *n) {\n lua_Number num;\n if (ttisnumber(obj)) return obj;\n if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {\n setnvalue(n, num);\n return n;\n }\n else\n return NULL;\n}\n\n\nint luaV_tostring (lua_State *L, StkId obj) {\n if (!ttisnumber(obj))\n return 0;\n else {\n char s[LUAI_MAXNUMBER2STR];\n lua_Number n = nvalue(obj);\n lua_number2str(s, n);\n setsvalue2s(L, obj, luaS_new(L, s));\n return 1;\n }\n}\n\n\nstatic void traceexec (lua_State *L, const Instruction *pc) {\n lu_byte mask = L->hookmask;\n const Instruction *oldpc = L->savedpc;\n L->savedpc = pc;\n if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {\n resethookcount(L);\n luaD_callhook(L, LUA_HOOKCOUNT, -1);\n }\n if (mask & LUA_MASKLINE) {\n Proto *p = ci_func(L->ci)->l.p;\n int npc = pcRel(pc, p);\n int newline = getline(p, npc);\n /* call linehook when enter a new function, when jump back (loop),\n or when enter a new line */\n if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))\n luaD_callhook(L, LUA_HOOKLINE, newline);\n }\n}\n\n\nstatic void callTMres (lua_State *L, StkId res, const TValue *f,\n const TValue *p1, const TValue *p2) {\n ptrdiff_t result = savestack(L, res);\n setobj2s(L, L->top, f); /* push function */\n setobj2s(L, L->top+1, p1); /* 1st argument */\n setobj2s(L, L->top+2, p2); /* 2nd argument */\n luaD_checkstack(L, 3);\n L->top += 3;\n luaD_call(L, L->top - 3, 1);\n res = restorestack(L, result);\n L->top--;\n setobjs2s(L, res, L->top);\n}\n\n\n\nstatic void callTM (lua_State *L, const TValue *f, const TValue *p1,\n const TValue *p2, const TValue *p3) {\n setobj2s(L, L->top, f); /* push function */\n setobj2s(L, L->top+1, p1); /* 1st argument */\n setobj2s(L, L->top+2, p2); /* 2nd argument */\n setobj2s(L, L->top+3, p3); /* 3th argument */\n luaD_checkstack(L, 4);\n L->top += 4;\n luaD_call(L, L->top - 4, 0);\n}\n\n\nvoid luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {\n int loop;\n for (loop = 0; loop < MAXTAGLOOP; loop++) {\n const TValue *tm;\n if (ttistable(t)) { /* `t' is a table? */\n Table *h = hvalue(t);\n const TValue *res = luaH_get(h, key); /* do a primitive get */\n if (!ttisnil(res) || /* result is no nil? */\n (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */\n setobj2s(L, val, res);\n return;\n }\n /* else will try the tag method */\n }\n else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))\n luaG_typeerror(L, t, \"index\");\n if (ttisfunction(tm)) {\n callTMres(L, val, tm, t, key);\n return;\n }\n t = tm; /* else repeat with `tm' */ \n }\n luaG_runerror(L, \"loop in gettable\");\n}\n\n\nvoid luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {\n int loop;\n TValue temp;\n for (loop = 0; loop < MAXTAGLOOP; loop++) {\n const TValue *tm;\n if (ttistable(t)) { /* `t' is a table? */\n Table *h = hvalue(t);\n if (h->readonly)\n luaG_runerror(L, \"Attempt to modify a readonly table\");\n TValue *oldval = luaH_set(L, h, key); /* do a primitive set */\n if (!ttisnil(oldval) || /* result is no nil? */\n (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */\n setobj2t(L, oldval, val);\n h->flags = 0;\n luaC_barriert(L, h, val);\n return;\n }\n /* else will try the tag method */\n }\n else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))\n luaG_typeerror(L, t, \"index\");\n if (ttisfunction(tm)) {\n callTM(L, tm, t, key, val);\n return;\n }\n /* else repeat with `tm' */\n setobj(L, &temp, tm); /* avoid pointing inside table (may rehash) */\n t = &temp;\n }\n luaG_runerror(L, \"loop in settable\");\n}\n\n\nstatic int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,\n StkId res, TMS event) {\n const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */\n if (ttisnil(tm))\n tm = luaT_gettmbyobj(L, p2, event); /* try second operand */\n if (ttisnil(tm)) return 0;\n callTMres(L, res, tm, p1, p2);\n return 1;\n}\n\n\nstatic const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,\n TMS event) {\n const TValue *tm1 = fasttm(L, mt1, event);\n const TValue *tm2;\n if (tm1 == NULL) return NULL; /* no metamethod */\n if (mt1 == mt2) return tm1; /* same metatables => same metamethods */\n tm2 = fasttm(L, mt2, event);\n if (tm2 == NULL) return NULL; /* no metamethod */\n if (luaO_rawequalObj(tm1, tm2)) /* same metamethods? */\n return tm1;\n return NULL;\n}\n\n\nstatic int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,\n TMS event) {\n const TValue *tm1 = luaT_gettmbyobj(L, p1, event);\n const TValue *tm2;\n if (ttisnil(tm1)) return -1; /* no metamethod? */\n tm2 = luaT_gettmbyobj(L, p2, event);\n if (!luaO_rawequalObj(tm1, tm2)) /* different metamethods? */\n return -1;\n callTMres(L, L->top, tm1, p1, p2);\n return !l_isfalse(L->top);\n}\n\n\nstatic int l_strcmp (const TString *ls, const TString *rs) {\n const char *l = getstr(ls);\n size_t ll = ls->tsv.len;\n const char *r = getstr(rs);\n size_t lr = rs->tsv.len;\n for (;;) {\n int temp = strcoll(l, r);\n if (temp != 0) return temp;\n else { /* strings are equal up to a `\\0' */\n size_t len = strlen(l); /* index of first `\\0' in both strings */\n if (len == lr) /* r is finished? */\n return (len == ll) ? 0 : 1;\n else if (len == ll) /* l is finished? */\n return -1; /* l is smaller than r (because r is not finished) */\n /* both strings longer than `len'; go on comparing (after the `\\0') */\n len++;\n l += len; ll -= len; r += len; lr -= len;\n }\n }\n}\n\n\nint luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {\n int res;\n if (ttype(l) != ttype(r))\n return luaG_ordererror(L, l, r);\n else if (ttisnumber(l))\n return luai_numlt(nvalue(l), nvalue(r));\n else if (ttisstring(l))\n return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;\n else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)\n return res;\n return luaG_ordererror(L, l, r);\n}\n\n\nstatic int lessequal (lua_State *L, const TValue *l, const TValue *r) {\n int res;\n if (ttype(l) != ttype(r))\n return luaG_ordererror(L, l, r);\n else if (ttisnumber(l))\n return luai_numle(nvalue(l), nvalue(r));\n else if (ttisstring(l))\n return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;\n else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */\n return res;\n else if ((res = call_orderTM(L, r, l, TM_LT)) != -1) /* else try `lt' */\n return !res;\n return luaG_ordererror(L, l, r);\n}\n\n\nint luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {\n const TValue *tm;\n lua_assert(ttype(t1) == ttype(t2));\n switch (ttype(t1)) {\n case LUA_TNIL: return 1;\n case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));\n case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */\n case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);\n case LUA_TUSERDATA: {\n if (uvalue(t1) == uvalue(t2)) return 1;\n tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,\n TM_EQ);\n break; /* will try TM */\n }\n case LUA_TTABLE: {\n if (hvalue(t1) == hvalue(t2)) return 1;\n tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);\n break; /* will try TM */\n }\n default: return gcvalue(t1) == gcvalue(t2);\n }\n if (tm == NULL) return 0; /* no TM? */\n callTMres(L, L->top, tm, t1, t2); /* call TM */\n return !l_isfalse(L->top);\n}\n\n\nvoid luaV_concat (lua_State *L, int total, int last) {\n do {\n StkId top = L->base + last + 1;\n int n = 2; /* number of elements handled in this pass (at least 2) */\n if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {\n if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))\n luaG_concaterror(L, top-2, top-1);\n } else if (tsvalue(top-1)->len == 0) /* second op is empty? */\n (void)tostring(L, top - 2); /* result is first op (as string) */\n else {\n /* at least two string values; get as many as possible */\n size_t tl = tsvalue(top-1)->len;\n char *buffer;\n int i;\n /* collect total length */\n for (n = 1; n < total && tostring(L, top-n-1); n++) {\n size_t l = tsvalue(top-n-1)->len;\n if (l >= MAX_SIZET - tl) luaG_runerror(L, \"string length overflow\");\n tl += l;\n }\n buffer = luaZ_openspace(L, &G(L)->buff, tl);\n tl = 0;\n for (i=n; i>0; i--) { /* concat all strings */\n size_t l = tsvalue(top-i)->len;\n memcpy(buffer+tl, svalue(top-i), l);\n tl += l;\n }\n setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));\n }\n total -= n-1; /* got `n' strings to create 1 new */\n last -= n-1;\n } while (total > 1); /* repeat until only 1 result left */\n}\n\n\nstatic void Arith (lua_State *L, StkId ra, const TValue *rb,\n const TValue *rc, TMS op) {\n TValue tempb, tempc;\n const TValue *b, *c;\n if ((b = luaV_tonumber(rb, &tempb)) != NULL &&\n (c = luaV_tonumber(rc, &tempc)) != NULL) {\n lua_Number nb = nvalue(b), nc = nvalue(c);\n switch (op) {\n case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;\n case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;\n case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;\n case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;\n case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;\n case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;\n case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;\n default: lua_assert(0); break;\n }\n }\n else if (!call_binTM(L, rb, rc, ra, op))\n luaG_aritherror(L, rb, rc);\n}\n\n\n\n/*\n** some macros for common tasks in `luaV_execute'\n*/\n\n#define runtime_check(L, c)\t{ if (!(c)) break; }\n\n#define RA(i)\t(base+GETARG_A(i))\n/* to be used after possible stack reallocation */\n#define RB(i)\tcheck_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))\n#define RC(i)\tcheck_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))\n#define RKB(i)\tcheck_exp(getBMode(GET_OPCODE(i)) == OpArgK, \\\n\tISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))\n#define RKC(i)\tcheck_exp(getCMode(GET_OPCODE(i)) == OpArgK, \\\n\tISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))\n#define KBx(i)\tcheck_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))\n\n\n#define dojump(L,pc,i)\t{(pc) += (i); luai_threadyield(L);}\n\n\n#define Protect(x)\t{ L->savedpc = pc; {x;}; base = L->base; }\n\n\n#define arith_op(op,tm) { \\\n TValue *rb = RKB(i); \\\n TValue *rc = RKC(i); \\\n if (ttisnumber(rb) && ttisnumber(rc)) { \\\n lua_Number nb = nvalue(rb), nc = nvalue(rc); \\\n setnvalue(ra, op(nb, nc)); \\\n } \\\n else \\\n Protect(Arith(L, ra, rb, rc, tm)); \\\n }\n\n\n\nvoid luaV_execute (lua_State *L, int nexeccalls) {\n LClosure *cl;\n StkId base;\n TValue *k;\n const Instruction *pc;\n reentry: /* entry point */\n lua_assert(isLua(L->ci));\n pc = L->savedpc;\n cl = &clvalue(L->ci->func)->l;\n base = L->base;\n k = cl->p->k;\n /* main loop of interpreter */\n for (;;) {\n const Instruction i = *pc++;\n StkId ra;\n if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&\n (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {\n traceexec(L, pc);\n if (L->status == LUA_YIELD) { /* did hook yield? */\n L->savedpc = pc - 1;\n return;\n }\n base = L->base;\n }\n /* warning!! several calls may realloc the stack and invalidate `ra' */\n ra = RA(i);\n lua_assert(base == L->base && L->base == L->ci->base);\n lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);\n lua_assert(L->top == L->ci->top || luaG_checkopenop(i));\n switch (GET_OPCODE(i)) {\n case OP_MOVE: {\n setobjs2s(L, ra, RB(i));\n continue;\n }\n case OP_LOADK: {\n setobj2s(L, ra, KBx(i));\n continue;\n }\n case OP_LOADBOOL: {\n setbvalue(ra, GETARG_B(i));\n if (GETARG_C(i)) pc++; /* skip next instruction (if C) */\n continue;\n }\n case OP_LOADNIL: {\n TValue *rb = RB(i);\n do {\n setnilvalue(rb--);\n } while (rb >= ra);\n continue;\n }\n case OP_GETUPVAL: {\n int b = GETARG_B(i);\n setobj2s(L, ra, cl->upvals[b]->v);\n continue;\n }\n case OP_GETGLOBAL: {\n TValue g;\n TValue *rb = KBx(i);\n sethvalue(L, &g, cl->env);\n lua_assert(ttisstring(rb));\n Protect(luaV_gettable(L, &g, rb, ra));\n continue;\n }\n case OP_GETTABLE: {\n Protect(luaV_gettable(L, RB(i), RKC(i), ra));\n continue;\n }\n case OP_SETGLOBAL: {\n TValue g;\n sethvalue(L, &g, cl->env);\n lua_assert(ttisstring(KBx(i)));\n Protect(luaV_settable(L, &g, KBx(i), ra));\n continue;\n }\n case OP_SETUPVAL: {\n UpVal *uv = cl->upvals[GETARG_B(i)];\n setobj(L, uv->v, ra);\n luaC_barrier(L, uv, ra);\n continue;\n }\n case OP_SETTABLE: {\n Protect(luaV_settable(L, ra, RKB(i), RKC(i)));\n continue;\n }\n case OP_NEWTABLE: {\n int b = GETARG_B(i);\n int c = GETARG_C(i);\n sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));\n Protect(luaC_checkGC(L));\n continue;\n }\n case OP_SELF: {\n StkId rb = RB(i);\n setobjs2s(L, ra+1, rb);\n Protect(luaV_gettable(L, rb, RKC(i), ra));\n continue;\n }\n case OP_ADD: {\n arith_op(luai_numadd, TM_ADD);\n continue;\n }\n case OP_SUB: {\n arith_op(luai_numsub, TM_SUB);\n continue;\n }\n case OP_MUL: {\n arith_op(luai_nummul, TM_MUL);\n continue;\n }\n case OP_DIV: {\n arith_op(luai_numdiv, TM_DIV);\n continue;\n }\n case OP_MOD: {\n arith_op(luai_nummod, TM_MOD);\n continue;\n }\n case OP_POW: {\n arith_op(luai_numpow, TM_POW);\n continue;\n }\n case OP_UNM: {\n TValue *rb = RB(i);\n if (ttisnumber(rb)) {\n lua_Number nb = nvalue(rb);\n setnvalue(ra, luai_numunm(nb));\n }\n else {\n Protect(Arith(L, ra, rb, rb, TM_UNM));\n }\n continue;\n }\n case OP_NOT: {\n int res = l_isfalse(RB(i)); /* next assignment may change this value */\n setbvalue(ra, res);\n continue;\n }\n case OP_LEN: {\n const TValue *rb = RB(i);\n switch (ttype(rb)) {\n case LUA_TTABLE: {\n setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));\n break;\n }\n case LUA_TSTRING: {\n setnvalue(ra, cast_num(tsvalue(rb)->len));\n break;\n }\n default: { /* try metamethod */\n Protect(\n if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))\n luaG_typeerror(L, rb, \"get length of\");\n )\n }\n }\n continue;\n }\n case OP_CONCAT: {\n int b = GETARG_B(i);\n int c = GETARG_C(i);\n Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));\n setobjs2s(L, RA(i), base+b);\n continue;\n }\n case OP_JMP: {\n dojump(L, pc, GETARG_sBx(i));\n continue;\n }\n case OP_EQ: {\n TValue *rb = RKB(i);\n TValue *rc = RKC(i);\n Protect(\n if (equalobj(L, rb, rc) == GETARG_A(i))\n dojump(L, pc, GETARG_sBx(*pc));\n )\n pc++;\n continue;\n }\n case OP_LT: {\n Protect(\n if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))\n dojump(L, pc, GETARG_sBx(*pc));\n )\n pc++;\n continue;\n }\n case OP_LE: {\n Protect(\n if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))\n dojump(L, pc, GETARG_sBx(*pc));\n )\n pc++;\n continue;\n }\n case OP_TEST: {\n if (l_isfalse(ra) != GETARG_C(i))\n dojump(L, pc, GETARG_sBx(*pc));\n pc++;\n continue;\n }\n case OP_TESTSET: {\n TValue *rb = RB(i);\n if (l_isfalse(rb) != GETARG_C(i)) {\n setobjs2s(L, ra, rb);\n dojump(L, pc, GETARG_sBx(*pc));\n }\n pc++;\n continue;\n }\n case OP_CALL: {\n int b = GETARG_B(i);\n int nresults = GETARG_C(i) - 1;\n if (b != 0) L->top = ra+b; /* else previous instruction set top */\n L->savedpc = pc;\n switch (luaD_precall(L, ra, nresults)) {\n case PCRLUA: {\n nexeccalls++;\n goto reentry; /* restart luaV_execute over new Lua function */\n }\n case PCRC: {\n /* it was a C function (`precall' called it); adjust results */\n if (nresults >= 0) L->top = L->ci->top;\n base = L->base;\n continue;\n }\n default: {\n return; /* yield */\n }\n }\n }\n case OP_TAILCALL: {\n int b = GETARG_B(i);\n if (b != 0) L->top = ra+b; /* else previous instruction set top */\n L->savedpc = pc;\n lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);\n switch (luaD_precall(L, ra, LUA_MULTRET)) {\n case PCRLUA: {\n /* tail call: put new frame in place of previous one */\n CallInfo *ci = L->ci - 1; /* previous frame */\n int aux;\n StkId func = ci->func;\n StkId pfunc = (ci+1)->func; /* previous function index */\n if (L->openupval) luaF_close(L, ci->base);\n L->base = ci->base = ci->func + ((ci+1)->base - pfunc);\n for (aux = 0; pfunc+aux < L->top; aux++) /* move frame down */\n setobjs2s(L, func+aux, pfunc+aux);\n ci->top = L->top = func+aux; /* correct top */\n lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);\n ci->savedpc = L->savedpc;\n ci->tailcalls++; /* one more call lost */\n L->ci--; /* remove new frame */\n goto reentry;\n }\n case PCRC: { /* it was a C function (`precall' called it) */\n base = L->base;\n continue;\n }\n default: {\n return; /* yield */\n }\n }\n }\n case OP_RETURN: {\n int b = GETARG_B(i);\n if (b != 0) L->top = ra+b-1;\n if (L->openupval) luaF_close(L, base);\n L->savedpc = pc;\n b = luaD_poscall(L, ra);\n if (--nexeccalls == 0) /* was previous function running `here'? */\n return; /* no: return */\n else { /* yes: continue its execution */\n if (b) L->top = L->ci->top;\n lua_assert(isLua(L->ci));\n lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);\n goto reentry;\n }\n }\n case OP_FORLOOP: {\n lua_Number step = nvalue(ra+2);\n lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */\n lua_Number limit = nvalue(ra+1);\n if (luai_numlt(0, step) ? luai_numle(idx, limit)\n : luai_numle(limit, idx)) {\n dojump(L, pc, GETARG_sBx(i)); /* jump back */\n setnvalue(ra, idx); /* update internal index... */\n setnvalue(ra+3, idx); /* ...and external index */\n }\n continue;\n }\n case OP_FORPREP: {\n const TValue *init = ra;\n const TValue *plimit = ra+1;\n const TValue *pstep = ra+2;\n L->savedpc = pc; /* next steps may throw errors */\n if (!tonumber(init, ra))\n luaG_runerror(L, LUA_QL(\"for\") \" initial value must be a number\");\n else if (!tonumber(plimit, ra+1))\n luaG_runerror(L, LUA_QL(\"for\") \" limit must be a number\");\n else if (!tonumber(pstep, ra+2))\n luaG_runerror(L, LUA_QL(\"for\") \" step must be a number\");\n setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));\n dojump(L, pc, GETARG_sBx(i));\n continue;\n }\n case OP_TFORLOOP: {\n StkId cb = ra + 3; /* call base */\n setobjs2s(L, cb+2, ra+2);\n setobjs2s(L, cb+1, ra+1);\n setobjs2s(L, cb, ra);\n L->top = cb+3; /* func. + 2 args (state and index) */\n Protect(luaD_call(L, cb, GETARG_C(i)));\n L->top = L->ci->top;\n cb = RA(i) + 3; /* previous call may change the stack */\n if (!ttisnil(cb)) { /* continue loop? */\n setobjs2s(L, cb-1, cb); /* save control variable */\n dojump(L, pc, GETARG_sBx(*pc)); /* jump back */\n }\n pc++;\n continue;\n }\n case OP_SETLIST: {\n int n = GETARG_B(i);\n int c = GETARG_C(i);\n int last;\n Table *h;\n if (n == 0) {\n n = cast_int(L->top - ra) - 1;\n L->top = L->ci->top;\n }\n if (c == 0) c = cast_int(*pc++);\n runtime_check(L, ttistable(ra));\n h = hvalue(ra);\n last = ((c-1)*LFIELDS_PER_FLUSH) + n;\n if (last > h->sizearray) /* needs more space? */\n luaH_resizearray(L, h, last); /* pre-alloc it at once */\n for (; n > 0; n--) {\n TValue *val = ra+n;\n setobj2t(L, luaH_setnum(L, h, last--), val);\n luaC_barriert(L, h, val);\n }\n continue;\n }\n case OP_CLOSE: {\n luaF_close(L, ra);\n continue;\n }\n case OP_CLOSURE: {\n Proto *p;\n Closure *ncl;\n int nup, j;\n p = cl->p->p[GETARG_Bx(i)];\n nup = p->nups;\n ncl = luaF_newLclosure(L, nup, cl->env);\n ncl->l.p = p;\n for (j=0; jl.upvals[j] = cl->upvals[GETARG_B(*pc)];\n else {\n lua_assert(GET_OPCODE(*pc) == OP_MOVE);\n ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));\n }\n }\n setclvalue(L, ra, ncl);\n Protect(luaC_checkGC(L));\n continue;\n }\n case OP_VARARG: {\n int b = GETARG_B(i) - 1;\n int j;\n CallInfo *ci = L->ci;\n int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;\n if (b == LUA_MULTRET) {\n Protect(luaD_checkstack(L, n));\n ra = RA(i); /* previous call may change the stack */\n b = n;\n L->top = ra + n;\n }\n for (j = 0; j < b; j++) {\n if (j < n) {\n setobjs2s(L, ra + j, ci->base - n + j);\n }\n else {\n setnilvalue(ra + j);\n }\n }\n continue;\n }\n }\n }\n}\n\n" }, { "path": "deps/lua/src/lvm.h", "content": "/*\n** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $\n** Lua virtual machine\n** See Copyright Notice in lua.h\n*/\n\n#ifndef lvm_h\n#define lvm_h\n\n\n#include \"ldo.h\"\n#include \"lobject.h\"\n#include \"ltm.h\"\n\n\n#define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o)))\n\n#define tonumber(o,n)\t(ttype(o) == LUA_TNUMBER || \\\n (((o) = luaV_tonumber(o,n)) != NULL))\n\n#define equalobj(L,o1,o2) \\\n\t(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))\n\n\nLUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);\nLUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);\nLUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);\nLUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);\nLUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,\n StkId val);\nLUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,\n StkId val);\nLUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);\nLUAI_FUNC void luaV_concat (lua_State *L, int total, int last);\n\n#endif\n" }, { "path": "deps/lua/src/lzio.c", "content": "/*\n** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $\n** a generic input stream interface\n** See Copyright Notice in lua.h\n*/\n\n\n#include \n\n#define lzio_c\n#define LUA_CORE\n\n#include \"lua.h\"\n\n#include \"llimits.h\"\n#include \"lmem.h\"\n#include \"lstate.h\"\n#include \"lzio.h\"\n\n\nint luaZ_fill (ZIO *z) {\n size_t size;\n lua_State *L = z->L;\n const char *buff;\n lua_unlock(L);\n buff = z->reader(L, z->data, &size);\n lua_lock(L);\n if (buff == NULL || size == 0) return EOZ;\n z->n = size - 1;\n z->p = buff;\n return char2int(*(z->p++));\n}\n\n\nint luaZ_lookahead (ZIO *z) {\n if (z->n == 0) {\n if (luaZ_fill(z) == EOZ)\n return EOZ;\n else {\n z->n++; /* luaZ_fill removed first byte; put back it */\n z->p--;\n }\n }\n return char2int(*z->p);\n}\n\n\nvoid luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {\n z->L = L;\n z->reader = reader;\n z->data = data;\n z->n = 0;\n z->p = NULL;\n}\n\n\n/* --------------------------------------------------------------- read --- */\nsize_t luaZ_read (ZIO *z, void *b, size_t n) {\n while (n) {\n size_t m;\n if (luaZ_lookahead(z) == EOZ)\n return n; /* return number of missing bytes */\n m = (n <= z->n) ? n : z->n; /* min. between n and z->n */\n memcpy(b, z->p, m);\n z->n -= m;\n z->p += m;\n b = (char *)b + m;\n n -= m;\n }\n return 0;\n}\n\n/* ------------------------------------------------------------------------ */\nchar *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {\n if (n > buff->buffsize) {\n if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;\n luaZ_resizebuffer(L, buff, n);\n }\n return buff->buffer;\n}\n\n\n" }, { "path": "deps/lua/src/lzio.h", "content": "/*\n** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $\n** Buffered streams\n** See Copyright Notice in lua.h\n*/\n\n\n#ifndef lzio_h\n#define lzio_h\n\n#include \"lua.h\"\n\n#include \"lmem.h\"\n\n\n#define EOZ\t(-1)\t\t\t/* end of stream */\n\ntypedef struct Zio ZIO;\n\n#define char2int(c)\tcast(int, cast(unsigned char, (c)))\n\n#define zgetc(z) (((z)->n--)>0 ? char2int(*(z)->p++) : luaZ_fill(z))\n\ntypedef struct Mbuffer {\n char *buffer;\n size_t n;\n size_t buffsize;\n} Mbuffer;\n\n#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)\n\n#define luaZ_buffer(buff)\t((buff)->buffer)\n#define luaZ_sizebuffer(buff)\t((buff)->buffsize)\n#define luaZ_bufflen(buff)\t((buff)->n)\n\n#define luaZ_resetbuffer(buff) ((buff)->n = 0)\n\n\n#define luaZ_resizebuffer(L, buff, size) \\\n\t(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \\\n\t(buff)->buffsize = size)\n\n#define luaZ_freebuffer(L, buff)\tluaZ_resizebuffer(L, buff, 0)\n\n\nLUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);\nLUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,\n void *data);\nLUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);\t/* read next n bytes */\nLUAI_FUNC int luaZ_lookahead (ZIO *z);\n\n\n\n/* --------- Private Part ------------------ */\n\nstruct Zio {\n size_t n;\t\t\t/* bytes still unread */\n const char *p;\t\t/* current position in buffer */\n lua_Reader reader;\n void* data;\t\t\t/* additional data */\n lua_State *L;\t\t\t/* Lua state (for reader) */\n};\n\n\nLUAI_FUNC int luaZ_fill (ZIO *z);\n\n#endif\n" }, { "path": "deps/lua/src/print.c", "content": "/*\n** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $\n** print bytecodes\n** See Copyright Notice in lua.h\n*/\n\n#include \n#include \n\n#define luac_c\n#define LUA_CORE\n\n#include \"ldebug.h\"\n#include \"lobject.h\"\n#include \"lopcodes.h\"\n#include \"lundump.h\"\n\n#define PrintFunction\tluaU_print\n\n#define Sizeof(x)\t((int)sizeof(x))\n#define VOID(p)\t\t((const void*)(p))\n\nstatic void PrintString(const TString* ts)\n{\n const char* s=getstr(ts);\n size_t i,n=ts->tsv.len;\n putchar('\"');\n for (i=0; ik[i];\n switch (ttype(o))\n {\n case LUA_TNIL:\n\tprintf(\"nil\");\n\tbreak;\n case LUA_TBOOLEAN:\n\tprintf(bvalue(o) ? \"true\" : \"false\");\n\tbreak;\n case LUA_TNUMBER:\n\tprintf(LUA_NUMBER_FMT,nvalue(o));\n\tbreak;\n case LUA_TSTRING:\n\tPrintString(rawtsvalue(o));\n\tbreak;\n default:\t\t\t\t/* cannot happen */\n\tprintf(\"? type=%d\",ttype(o));\n\tbreak;\n }\n}\n\nstatic void PrintCode(const Proto* f)\n{\n const Instruction* code=f->code;\n int pc,n=f->sizecode;\n for (pc=0; pc0) printf(\"[%d]\\t\",line); else printf(\"[-]\\t\");\n printf(\"%-9s\\t\",luaP_opnames[o]);\n switch (getOpMode(o))\n {\n case iABC:\n printf(\"%d\",a);\n if (getBMode(o)!=OpArgN) printf(\" %d\",ISK(b) ? (-1-INDEXK(b)) : b);\n if (getCMode(o)!=OpArgN) printf(\" %d\",ISK(c) ? (-1-INDEXK(c)) : c);\n break;\n case iABx:\n if (getBMode(o)==OpArgK) printf(\"%d %d\",a,-1-bx); else printf(\"%d %d\",a,bx);\n break;\n case iAsBx:\n if (o==OP_JMP) printf(\"%d\",sbx); else printf(\"%d %d\",a,sbx);\n break;\n }\n switch (o)\n {\n case OP_LOADK:\n printf(\"\\t; \"); PrintConstant(f,bx);\n break;\n case OP_GETUPVAL:\n case OP_SETUPVAL:\n printf(\"\\t; %s\", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : \"-\");\n break;\n case OP_GETGLOBAL:\n case OP_SETGLOBAL:\n printf(\"\\t; %s\",svalue(&f->k[bx]));\n break;\n case OP_GETTABLE:\n case OP_SELF:\n if (ISK(c)) { printf(\"\\t; \"); PrintConstant(f,INDEXK(c)); }\n break;\n case OP_SETTABLE:\n case OP_ADD:\n case OP_SUB:\n case OP_MUL:\n case OP_DIV:\n case OP_POW:\n case OP_EQ:\n case OP_LT:\n case OP_LE:\n if (ISK(b) || ISK(c))\n {\n printf(\"\\t; \");\n if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf(\"-\");\n printf(\" \");\n if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf(\"-\");\n }\n break;\n case OP_JMP:\n case OP_FORLOOP:\n case OP_FORPREP:\n printf(\"\\t; to %d\",sbx+pc+2);\n break;\n case OP_CLOSURE:\n printf(\"\\t; %p\",VOID(f->p[bx]));\n break;\n case OP_SETLIST:\n if (c==0) printf(\"\\t; %d\",(int)code[++pc]);\n else printf(\"\\t; %d\",c);\n break;\n default:\n break;\n }\n printf(\"\\n\");\n }\n}\n\n#define SS(x)\t(x==1)?\"\":\"s\"\n#define S(x)\tx,SS(x)\n\nstatic void PrintHeader(const Proto* f)\n{\n const char* s=getstr(f->source);\n if (*s=='@' || *s=='=')\n s++;\n else if (*s==LUA_SIGNATURE[0])\n s=\"(bstring)\";\n else\n s=\"(string)\";\n printf(\"\\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\\n\",\n \t(f->linedefined==0)?\"main\":\"function\",s,\n\tf->linedefined,f->lastlinedefined,\n\tS(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));\n printf(\"%d%s param%s, %d slot%s, %d upvalue%s, \",\n\tf->numparams,f->is_vararg?\"+\":\"\",SS(f->numparams),\n\tS(f->maxstacksize),S(f->nups));\n printf(\"%d local%s, %d constant%s, %d function%s\\n\",\n\tS(f->sizelocvars),S(f->sizek),S(f->sizep));\n}\n\nstatic void PrintConstants(const Proto* f)\n{\n int i,n=f->sizek;\n printf(\"constants (%d) for %p:\\n\",n,VOID(f));\n for (i=0; isizelocvars;\n printf(\"locals (%d) for %p:\\n\",n,VOID(f));\n for (i=0; ilocvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);\n }\n}\n\nstatic void PrintUpvalues(const Proto* f)\n{\n int i,n=f->sizeupvalues;\n printf(\"upvalues (%d) for %p:\\n\",n,VOID(f));\n if (f->upvalues==NULL) return;\n for (i=0; iupvalues[i]));\n }\n}\n\nvoid PrintFunction(const Proto* f, int full)\n{\n int i,n=f->sizep;\n PrintHeader(f);\n PrintCode(f);\n if (full)\n {\n PrintConstants(f);\n PrintLocals(f);\n PrintUpvalues(f);\n }\n for (i=0; ip[i],full);\n}\n" }, { "path": "deps/lua/src/strbuf.c", "content": "/* strbuf - String buffer routines\n *\n * Copyright (c) 2010-2012 Mark Pulford \n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"strbuf.h\"\n\nstatic void die(const char *fmt, ...)\n{\n va_list arg;\n\n va_start(arg, fmt);\n vfprintf(stderr, fmt, arg);\n va_end(arg);\n fprintf(stderr, \"\\n\");\n\n abort();\n}\n\nvoid strbuf_init(strbuf_t *s, size_t len)\n{\n size_t size;\n\n if (!len)\n size = STRBUF_DEFAULT_SIZE;\n else\n size = len + 1;\n if (size < len)\n die(\"Overflow, len: %zu\", len);\n s->buf = NULL;\n s->size = size;\n s->length = 0;\n s->dynamic = 0;\n s->reallocs = 0;\n s->debug = 0;\n\n s->buf = malloc(size);\n if (!s->buf)\n die(\"Out of memory\");\n\n strbuf_ensure_null(s);\n}\n\nstrbuf_t *strbuf_new(size_t len)\n{\n strbuf_t *s;\n\n s = malloc(sizeof(strbuf_t));\n if (!s)\n die(\"Out of memory\");\n\n strbuf_init(s, len);\n\n /* Dynamic strbuf allocation / deallocation */\n s->dynamic = 1;\n\n return s;\n}\n\nstatic inline void debug_stats(strbuf_t *s)\n{\n if (s->debug) {\n fprintf(stderr, \"strbuf(%lx) reallocs: %d, length: %zd, size: %zd\\n\",\n (long)s, s->reallocs, s->length, s->size);\n }\n}\n\n/* If strbuf_t has not been dynamically allocated, strbuf_free() can\n * be called any number of times strbuf_init() */\nvoid strbuf_free(strbuf_t *s)\n{\n debug_stats(s);\n\n if (s->buf) {\n free(s->buf);\n s->buf = NULL;\n }\n if (s->dynamic)\n free(s);\n}\n\nchar *strbuf_free_to_string(strbuf_t *s, size_t *len)\n{\n char *buf;\n\n debug_stats(s);\n\n strbuf_ensure_null(s);\n\n buf = s->buf;\n if (len)\n *len = s->length;\n\n if (s->dynamic)\n free(s);\n\n return buf;\n}\n\nstatic size_t calculate_new_size(strbuf_t *s, size_t len)\n{\n size_t reqsize, newsize;\n\n if (len <= 0)\n die(\"BUG: Invalid strbuf length requested\");\n\n /* Ensure there is room for optional NULL termination */\n reqsize = len + 1;\n if (reqsize < len)\n die(\"Overflow, len: %zu\", len);\n\n /* If the user has requested to shrink the buffer, do it exactly */\n if (s->size > reqsize)\n return reqsize;\n\n newsize = s->size;\n if (reqsize >= SIZE_MAX / 2) {\n newsize = reqsize;\n } else {\n /* Exponential sizing */\n while (newsize < reqsize)\n newsize *= 2;\n }\n\n if (newsize < reqsize)\n die(\"BUG: strbuf length would overflow, len: %zu\", len);\n\n return newsize;\n}\n\n\n/* Ensure strbuf can handle a string length bytes long (ignoring NULL\n * optional termination). */\nvoid strbuf_resize(strbuf_t *s, size_t len)\n{\n size_t newsize;\n\n newsize = calculate_new_size(s, len);\n\n if (s->debug > 1) {\n fprintf(stderr, \"strbuf(%lx) resize: %zd => %zd\\n\",\n (long)s, s->size, newsize);\n }\n\n s->size = newsize;\n s->buf = realloc(s->buf, s->size);\n if (!s->buf)\n die(\"Out of memory, len: %zu\", len);\n s->reallocs++;\n}\n\nvoid strbuf_append_string(strbuf_t *s, const char *str)\n{\n size_t i, space;\n\n space = strbuf_empty_length(s);\n\n for (i = 0; str[i]; i++) {\n if (space < 1) {\n strbuf_resize(s, s->length + 1);\n space = strbuf_empty_length(s);\n }\n\n s->buf[s->length] = str[i];\n s->length++;\n space--;\n }\n}\n\n\n/* vi:ai et sw=4 ts=4:\n */\n" }, { "path": "deps/lua/src/strbuf.h", "content": "/* strbuf - String buffer routines\n *\n * Copyright (c) 2010-2012 Mark Pulford \n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n#include \n#include \n\n/* Size: Total bytes allocated to *buf\n * Length: String length, excluding optional NULL terminator.\n * Dynamic: True if created via strbuf_new()\n */\n\ntypedef struct {\n char *buf;\n size_t size;\n size_t length;\n int dynamic;\n int reallocs;\n int debug;\n} strbuf_t;\n\n#ifndef STRBUF_DEFAULT_SIZE\n#define STRBUF_DEFAULT_SIZE 1023\n#endif\n\n/* Initialise */\nextern strbuf_t *strbuf_new(size_t len);\nextern void strbuf_init(strbuf_t *s, size_t len);\n\n/* Release */\nextern void strbuf_free(strbuf_t *s);\nextern char *strbuf_free_to_string(strbuf_t *s, size_t *len);\n\n/* Management */\nextern void strbuf_resize(strbuf_t *s, size_t len);\nstatic size_t strbuf_empty_length(strbuf_t *s);\nstatic size_t strbuf_length(strbuf_t *s);\nstatic char *strbuf_string(strbuf_t *s, size_t *len);\nstatic void strbuf_ensure_empty_length(strbuf_t *s, size_t len);\nstatic char *strbuf_empty_ptr(strbuf_t *s);\nstatic void strbuf_extend_length(strbuf_t *s, size_t len);\n\n/* Update */\nstatic void strbuf_append_mem(strbuf_t *s, const char *c, size_t len);\nextern void strbuf_append_string(strbuf_t *s, const char *str);\nstatic void strbuf_append_char(strbuf_t *s, const char c);\nstatic void strbuf_ensure_null(strbuf_t *s);\n\n/* Reset string for before use */\nstatic inline void strbuf_reset(strbuf_t *s)\n{\n s->length = 0;\n}\n\nstatic inline int strbuf_allocated(strbuf_t *s)\n{\n return s->buf != NULL;\n}\n\n/* Return bytes remaining in the string buffer\n * Ensure there is space for a NULL terminator. */\nstatic inline size_t strbuf_empty_length(strbuf_t *s)\n{\n return s->size - s->length - 1;\n}\n\nstatic inline void strbuf_ensure_empty_length(strbuf_t *s, size_t len)\n{\n if (len > strbuf_empty_length(s))\n strbuf_resize(s, s->length + len);\n}\n\nstatic inline char *strbuf_empty_ptr(strbuf_t *s)\n{\n return s->buf + s->length;\n}\n\nstatic inline void strbuf_extend_length(strbuf_t *s, size_t len)\n{\n s->length += len;\n}\n\nstatic inline size_t strbuf_length(strbuf_t *s)\n{\n return s->length;\n}\n\nstatic inline void strbuf_append_char(strbuf_t *s, const char c)\n{\n strbuf_ensure_empty_length(s, 1);\n s->buf[s->length++] = c;\n}\n\nstatic inline void strbuf_append_char_unsafe(strbuf_t *s, const char c)\n{\n s->buf[s->length++] = c;\n}\n\nstatic inline void strbuf_append_mem(strbuf_t *s, const char *c, size_t len)\n{\n strbuf_ensure_empty_length(s, len);\n memcpy(s->buf + s->length, c, len);\n s->length += len;\n}\n\nstatic inline void strbuf_append_mem_unsafe(strbuf_t *s, const char *c, size_t len)\n{\n memcpy(s->buf + s->length, c, len);\n s->length += len;\n}\n\nstatic inline void strbuf_ensure_null(strbuf_t *s)\n{\n s->buf[s->length] = 0;\n}\n\nstatic inline char *strbuf_string(strbuf_t *s, size_t *len)\n{\n if (len)\n *len = s->length;\n\n return s->buf;\n}\n\n/* vi:ai et sw=4 ts=4:\n */\n" }, { "path": "deps/lua/test/README", "content": "These are simple tests for Lua. Some of them contain useful code.\nThey are meant to be run to make sure Lua is built correctly and also\nto be read, to see how Lua programs look.\n\nHere is a one-line summary of each program:\n\n bisect.lua\t\tbisection method for solving non-linear equations\n cf.lua\t\ttemperature conversion table (celsius to farenheit)\n echo.lua echo command line arguments\n env.lua environment variables as automatic global variables\n factorial.lua\tfactorial without recursion\n fib.lua\t\tfibonacci function with cache\n fibfor.lua\t\tfibonacci numbers with coroutines and generators\n globals.lua\t\treport global variable usage\n hello.lua\t\tthe first program in every language\n life.lua\t\tConway's Game of Life\n luac.lua\t \tbare-bones luac\n printf.lua\t\tan implementation of printf\n readonly.lua\t\tmake global variables readonly\n sieve.lua\t\tthe sieve of of Eratosthenes programmed with coroutines\n sort.lua\t\ttwo implementations of a sort function\n table.lua\t\tmake table, grouping all data for the same item\n trace-calls.lua\ttrace calls\n trace-globals.lua\ttrace assigments to global variables\n xd.lua\t\thex dump\n\n" }, { "path": "deps/lua/test/bisect.lua", "content": "-- bisection method for solving non-linear equations\n\ndelta=1e-6\t-- tolerance\n\nfunction bisect(f,a,b,fa,fb)\n local c=(a+b)/2\n io.write(n,\" c=\",c,\" a=\",a,\" b=\",b,\"\\n\")\n if c==a or c==b or math.abs(a-b) posted to lua-l\n-- modified to use ANSI terminal escape sequences\n-- modified to use for instead of while\n\nlocal write=io.write\n\nALIVE=\"\"\tDEAD=\"\"\nALIVE=\"O\"\tDEAD=\"-\"\n\nfunction delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary\n for i=1,10000 do end\n -- local i=os.clock()+1 while(os.clock() 0 do\n local xm1,x,xp1,xi=self.w-1,self.w,1,self.w\n while xi > 0 do\n local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +\n self[y][xm1] + self[y][xp1] +\n self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]\n next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0\n xm1,x,xp1,xi = x,xp1,xp1+1,xi-1\n end\n ym1,y,yp1,yi = y,yp1,yp1+1,yi-1\n end\nend\n\n-- output the array to screen\nfunction _CELLS:draw()\n local out=\"\" -- accumulate to reduce flicker\n for y=1,self.h do\n for x=1,self.w do\n out=out..(((self[y][x]>0) and ALIVE) or DEAD)\n end\n out=out..\"\\n\"\n end\n write(out)\nend\n\n-- constructor\nfunction CELLS(w,h)\n local c = ARRAY2D(w,h)\n c.spawn = _CELLS.spawn\n c.evolve = _CELLS.evolve\n c.draw = _CELLS.draw\n return c\nend\n\n--\n-- shapes suitable for use with spawn() above\n--\nHEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }\nGLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }\nEXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }\nFISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }\nBUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }\n\n-- the main routine\nfunction LIFE(w,h)\n -- create two arrays\n local thisgen = CELLS(w,h)\n local nextgen = CELLS(w,h)\n\n -- create some life\n -- about 1000 generations of fun, then a glider steady-state\n thisgen:spawn(GLIDER,5,4)\n thisgen:spawn(EXPLODE,25,10)\n thisgen:spawn(FISH,4,12)\n\n -- run until break\n local gen=1\n write(\"\\027[2J\")\t-- ANSI clear screen\n while 1 do\n thisgen:evolve(nextgen)\n thisgen,nextgen = nextgen,thisgen\n write(\"\\027[H\")\t-- ANSI home cursor\n thisgen:draw()\n write(\"Life - generation \",gen,\"\\n\")\n gen=gen+1\n if gen>2000 then break end\n --delay()\t\t-- no delay\n end\nend\n\nLIFE(40,20)\n" }, { "path": "deps/lua/test/luac.lua", "content": "-- bare-bones luac in Lua\n-- usage: lua luac.lua file.lua\n\nassert(arg[1]~=nil and arg[2]==nil,\"usage: lua luac.lua file.lua\")\nf=assert(io.open(\"luac.out\",\"wb\"))\nassert(f:write(string.dump(assert(loadfile(arg[1])))))\nassert(f:close())\n" }, { "path": "deps/lua/test/printf.lua", "content": "-- an implementation of printf\n\nfunction printf(...)\n io.write(string.format(...))\nend\n\nprintf(\"Hello %s from %s on %s\\n\",os.getenv\"USER\" or \"there\",_VERSION,os.date())\n" }, { "path": "deps/lua/test/readonly.lua", "content": "-- make global variables readonly\n\nlocal f=function (t,i) error(\"cannot redefine global variable `\"..i..\"'\",2) end\nlocal g={}\nlocal G=getfenv()\nsetmetatable(g,{__index=G,__newindex=f})\nsetfenv(1,g)\n\n-- an example\nrawset(g,\"x\",3)\nx=2\ny=1\t-- cannot redefine `y'\n" }, { "path": "deps/lua/test/sieve.lua", "content": "-- the sieve of of Eratosthenes programmed with coroutines\n-- typical usage: lua -e N=1000 sieve.lua | column\n\n-- generate all the numbers from 2 to n\nfunction gen (n)\n return coroutine.wrap(function ()\n for i=2,n do coroutine.yield(i) end\n end)\nend\n\n-- filter the numbers generated by `g', removing multiples of `p'\nfunction filter (p, g)\n return coroutine.wrap(function ()\n while 1 do\n local n = g()\n if n == nil then return end\n if math.mod(n, p) ~= 0 then coroutine.yield(n) end\n end\n end)\nend\n\nN=N or 1000\t\t-- from command line\nx = gen(N)\t\t-- generate primes up to N\nwhile 1 do\n local n = x()\t\t-- pick a number until done\n if n == nil then break end\n print(n)\t\t-- must be a prime number\n x = filter(n, x)\t-- now remove its multiples\nend\n" }, { "path": "deps/lua/test/sort.lua", "content": "-- two implementations of a sort function\n-- this is an example only. Lua has now a built-in function \"sort\"\n\n-- extracted from Programming Pearls, page 110\nfunction qsort(x,l,u,f)\n if ly end)\n show(\"after reverse selection sort\",x)\n qsort(x,1,n,function (x,y) return x>> \",string.rep(\" \",level))\n if t~=nil and t.currentline>=0 then io.write(t.short_src,\":\",t.currentline,\" \") end\n t=debug.getinfo(2)\n if event==\"call\" then\n level=level+1\n else\n level=level-1 if level<0 then level=0 end\n end\n if t.what==\"main\" then\n if event==\"call\" then\n io.write(\"begin \",t.short_src)\n else\n io.write(\"end \",t.short_src)\n end\n elseif t.what==\"Lua\" then\n-- table.foreach(t,print)\n io.write(event,\" \",t.name or \"(Lua)\",\" <\",t.linedefined,\":\",t.short_src,\">\")\n else\n io.write(event,\" \",t.name or \"(C)\",\" [\",t.what,\"] \")\n end\n io.write(\"\\n\")\nend\n\ndebug.sethook(hook,\"cr\")\nlevel=0\n" }, { "path": "deps/lua/test/trace-globals.lua", "content": "-- trace assigments to global variables\n\ndo\n -- a tostring that quotes strings. note the use of the original tostring.\n local _tostring=tostring\n local tostring=function(a)\n if type(a)==\"string\" then\n return string.format(\"%q\",a)\n else\n return _tostring(a)\n end\n end\n\n local log=function (name,old,new)\n local t=debug.getinfo(3,\"Sl\")\n local line=t.currentline\n io.write(t.short_src)\n if line>=0 then io.write(\":\",line) end\n io.write(\": \",name,\" is now \",tostring(new),\" (was \",tostring(old),\")\",\"\\n\")\n end\n\n local g={}\n local set=function (t,name,value)\n log(name,g[name],value)\n g[name]=value\n end\n setmetatable(getfenv(),{__index=g,__newindex=set})\nend\n\n-- an example\n\na=1\nb=2\na=10\nb=20\nb=nil\nb=200\nprint(a,b,c)\n" }, { "path": "deps/lua/test/xd.lua", "content": "-- hex dump\n-- usage: lua xd.lua < file\n\nlocal offset=0\nwhile true do\n local s=io.read(16)\n if s==nil then return end\n io.write(string.format(\"%08X \",offset))\n string.gsub(s,\"(.)\",\n\tfunction (c) io.write(string.format(\"%02X \",string.byte(c))) end)\n io.write(string.rep(\" \",3*(16-string.len(s))))\n io.write(\" \",string.gsub(s,\"%c\",\".\"),\"\\n\") \n offset=offset+16\nend\n" }, { "path": "deps/xxhash/.gitignore", "content": "# Ignore:\nlibxxhash.*\nxxh*sum\n\n# But include:\n!libxxhash.pc.in\n" }, { "path": "deps/xxhash/LICENSE", "content": "xxHash Library\nCopyright (c) 2012-2021 Yann Collet\nAll rights reserved.\n\nBSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)\n\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice, this\n list of conditions and the following disclaimer in the documentation and/or\n other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\nANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "deps/xxhash/Makefile", "content": "# ################################################################\n# xxHash Makefile\n# Copyright (C) 2012-2024 Yann Collet\n#\n# GPL v2 License\n#\n# This program is free software; you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation; either version 2 of the License, or\n# (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License along\n# with this program; if not, write to the Free Software Foundation, Inc.,\n# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n#\n# You can contact the author at:\n# - xxHash homepage: https://www.xxhash.com\n# - xxHash source repository: https://github.com/Cyan4973/xxHash\n# ################################################################\n# xxhsum: provides 32/64 bits hash of one or multiple files, or stdin\n# ################################################################\n\n# Version numbers\nSED ?= sed\nSED_ERE_OPT ?= -E\nLIBVER_MAJOR_SCRIPT:=`$(SED) -n '/define XXH_VERSION_MAJOR/s/.*[[:blank:]]\\([0-9][0-9]*\\).*/\\1/p' < xxhash.h`\nLIBVER_MINOR_SCRIPT:=`$(SED) -n '/define XXH_VERSION_MINOR/s/.*[[:blank:]]\\([0-9][0-9]*\\).*/\\1/p' < xxhash.h`\nLIBVER_PATCH_SCRIPT:=`$(SED) -n '/define XXH_VERSION_RELEASE/s/.*[[:blank:]]\\([0-9][0-9]*\\).*/\\1/p' < xxhash.h`\nLIBVER_MAJOR := $(shell echo $(LIBVER_MAJOR_SCRIPT))\nLIBVER_MINOR := $(shell echo $(LIBVER_MINOR_SCRIPT))\nLIBVER_PATCH := $(shell echo $(LIBVER_PATCH_SCRIPT))\nLIBVER := $(LIBVER_MAJOR).$(LIBVER_MINOR).$(LIBVER_PATCH)\n\nMAKEFLAGS += --no-print-directory\nCFLAGS ?= -O3\nDEBUGFLAGS+=-Wall -Wextra -Wconversion -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \\\n -Wstrict-prototypes -Wundef -Wpointer-arith -Wformat-security \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -Wredundant-decls -Wstrict-overflow=2\nCFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)\nFLAGS = $(CFLAGS) $(CPPFLAGS)\nXXHSUM_VERSION = $(LIBVER)\n\n# Define *.exe as extension for Windows systems\nifneq (,$(filter Windows%,$(OS)))\nEXT =.exe\nelse\nEXT =\nendif\n\n# automatically enable runtime vector dispatch on x86/64 targets\ndetect_x86_arch = $(shell $(CC) -dumpmachine | grep -E 'i[3-6]86|x86_64')\nifneq ($(strip $(call detect_x86_arch)),)\n #note: can be overridden at compile time, by setting DISPATCH=0\n DISPATCH ?= 1\nelse\n ifeq ($(DISPATCH),1)\n $(info \"Note: DISPATCH=1 is only supported on x86/x64 targets\")\n endif\n override DISPATCH := 0\nendif\n\nifeq ($(NODE_JS),1)\n # Link in unrestricted filesystem support\n LDFLAGS += -sNODERAWFS\n # Set flag to fix isatty() support\n CPPFLAGS += -DXSUM_NODE_JS=1\nendif\n\n# OS X linker doesn't support -soname, and use different extension\n# see: https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html\nUNAME ?= $(shell uname)\nifeq ($(UNAME), Darwin)\n\tSHARED_EXT = dylib\n\tSHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT)\n\tSHARED_EXT_VER = $(LIBVER).$(SHARED_EXT)\n\tSONAME_FLAGS = -install_name $(LIBDIR)/libxxhash.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER)\nelse\n\tSONAME_FLAGS = -Wl,-soname=libxxhash.$(SHARED_EXT).$(LIBVER_MAJOR)\n\tSHARED_EXT = so\n\tSHARED_EXT_MAJOR = $(SHARED_EXT).$(LIBVER_MAJOR)\n\tSHARED_EXT_VER = $(SHARED_EXT).$(LIBVER)\nendif\n\nLIBXXH = libxxhash.$(SHARED_EXT_VER)\n\nCLI_DIR = cli\nCLI_SRCS = $(wildcard $(CLI_DIR)/*.c)\nCLI_OBJS = $(CLI_SRCS:.c=.o)\n\n## define default before including multiconf.make\n## generate CLI and libraries in release mode (default for `make`)\n.PHONY: default\ndefault: DEBUGFLAGS=\ndefault: lib xxhsum_and_links\n\nC_SRCDIRS = . $(CLI_DIR) fuzz\ninclude build/make/multiconf.make\n\n.PHONY: all\nall: lib xxhsum xxhsum_inlinedXXH\n\n## xxhsum is the command line interface (CLI)\nifeq ($(DISPATCH),1)\nxxhsum: CPPFLAGS += -DXXHSUM_DISPATCH=1\nXXHSUM_ADD_O = xxh_x86dispatch.o\nendif\n$(eval $(call c_program,xxhsum,xxhash.o $(CLI_OBJS) $(XXHSUM_ADD_O)))\n\n.PHONY: xxhsum_and_links\nxxhsum_and_links: xxhsum xxh32sum xxh64sum xxh128sum xxh3sum\n\nLN ?= ln\n\nxxh32sum xxh64sum xxh128sum xxh3sum: xxhsum\n\t$(LN) -sf $<$(EXT) $@$(EXT)\n\n## generate CLI in 32-bits mode\nxxhsum32: CFLAGS += -m32\nifeq ($(DISPATCH),1)\nxxhsum32: CPPFLAGS += -DXXHSUM_DISPATCH=1\nendif\n$(eval $(call c_program,xxhsum32,xxhash.o $(CLI_OBJS) $(XXHSUM_ADD_O)))\n\n## Warning: dispatch only works for x86/x64 systems\ndispatch: CPPFLAGS += -DXXHSUM_DISPATCH=1\n$(eval $(call c_program,dispatch,xxhash.o xxh_x86dispatch.o $(CLI_OBJS)))\n\nxxhsum_inlinedXXH: CPPFLAGS += -DXXH_INLINE_ALL\n$(eval $(call c_program,xxhsum_inlinedXXH,$(CLI_OBJS)))\n\n\n# =================================================\n# library\n\nlibxxhash.a:\n$(eval $(call static_library,libxxhash.a,xxhash.o))\n\n$(LIBXXH): LDFLAGS += $(SONAME_FLAGS)\nifeq (,$(filter Windows%,$(OS)))\n$(LIBXXH): CFLAGS += -fPIC\nendif\nLIBXXHASH_OBJS := xxhash.o $(if $(filter 1,$(LIBXXH_DISPATCH)),xxh_x86dispatch.o)\n$(eval $(call c_dynamic_library,$(LIBXXH),$(LIBXXHASH_OBJS)))\n\nlibxxhash.$(SHARED_EXT_MAJOR): $(LIBXXH)\n\t$(LN) -sf $< $@\n\nlibxxhash.$(SHARED_EXT): libxxhash.$(SHARED_EXT_MAJOR)\n\t$(LN) -sf $< $@\n\n.PHONY: libxxhash ## generate dynamic xxhash library\nlibxxhash: $(LIBXXH) libxxhash.$(SHARED_EXT_MAJOR) libxxhash.$(SHARED_EXT)\n\n.PHONY: lib ## generate static and dynamic xxhash libraries\nlib: libxxhash.a libxxhash\n\n\n# helper targets\n\nAWK ?= awk\nGREP ?= grep\nSORT ?= sort\nNM ?= nm\n\n.PHONY: list\nlist: ## list all Makefile targets\n\t$(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null | $(AWK) -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ \"^[#.]\") {print $$1}}' | $(SORT) | egrep -v -e '^[^[:alnum:]]' -e '^$@$$' | xargs\n\n.PHONY: help\nhelp: ## list documented targets\n\t$(GREP) -E '^[0-9a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \\\n\t$(SORT) | \\\n\t$(AWK) 'BEGIN {FS = \":.*?## \"}; {printf \"\\033[36m%-30s\\033[0m %s\\n\", $$1, $$2}'\n\n.PHONY: clean\nclean:\n\t$(RM) -r *.dSYM # Mac OS-X specific\n\t$(RM) core *.o *.obj *.$(SHARED_EXT) *.$(SHARED_EXT).* *.a libxxhash.pc\n\t$(RM) xxhsum.wasm xxhsum.js xxhsum.html\n\t$(RM) xxh32sum$(EXT) xxh64sum$(EXT) xxh128sum$(EXT) xxh3sum$(EXT)\n\t$(RM) fuzzer\n\t$(MAKE) -C tests clean\n\t$(MAKE) -C tests/bench clean\n\t$(MAKE) -C tests/collisions clean\n\t@echo cleaning completed\n\n\n# =================================================\n# tests\n# =================================================\n\n# make check can be run with cross-compiled binaries on emulated environments (qemu user mode)\n# by setting $(RUN_ENV) to the target emulation environment\n.PHONY: check\ncheck: xxhsum test_sanity ## basic tests for xxhsum CLI, set RUN_ENV for emulated environments\n\t# stdin\n\t# If you get \"Wrong parameters\" on Emscripten+Node.js, recompile with `NODE_JS=1`\n\t$(RUN_ENV) ./xxhsum$(EXT) < xxhash.c\n\t# multiple files\n\t$(RUN_ENV) ./xxhsum$(EXT) xxhash.*\n\t# internal bench\n\t$(RUN_ENV) ./xxhsum$(EXT) -bi0\n\t# long bench command\n\t$(RUN_ENV) ./xxhsum$(EXT) --benchmark-all -i0\n\t# bench multiple variants\n\t$(RUN_ENV) ./xxhsum$(EXT) -b1,2,3 -i0\n\t# file bench\n\t$(RUN_ENV) ./xxhsum$(EXT) -bi0 xxhash.c\n\t# 32-bit\n\t$(RUN_ENV) ./xxhsum$(EXT) -H0 xxhash.c\n\t# 128-bit\n\t$(RUN_ENV) ./xxhsum$(EXT) -H2 xxhash.c\n\t# XXH3 (enforce BSD style)\n\t$(RUN_ENV) ./xxhsum$(EXT) -H3 xxhash.c | grep \"XXH3\"\n\t# request incorrect variant\n\t$(RUN_ENV) ./xxhsum$(EXT) -H9 xxhash.c ; test $$? -eq 1\n\t@printf \"\\n ....... checks completed successfully ....... \\n\"\n\n.PHONY: test-unicode\ntest-unicode:\n\t$(MAKE) -C tests test_unicode\n\n.PHONY: test_sanity\ntest_sanity:\n\t$(MAKE) -C tests test_sanity\n\n.PHONY: test-mem\nVALGRIND = valgrind --leak-check=yes --error-exitcode=1\ntest-mem: RUN_ENV = $(VALGRIND)\ntest-mem: xxhsum check\n\n.PHONY: test32\ntest32: xxhsum32\n\t@echo ---- test 32-bit ----\n\t./xxhsum32 -bi0 xxhash.c\n\nTEST_FILES = xxhsum$(EXT) xxhash.c xxhash.h\n.PHONY: test-xxhsum-c\ntest-xxhsum-c: xxhsum\n\t# xxhsum to/from pipe\n\t./xxhsum $(TEST_FILES) | ./xxhsum -c -\n\t./xxhsum -H0 $(TEST_FILES) | ./xxhsum -c -\n\t# xxhsum -c is unable to verify checksum of file from STDIN (#470)\n\t./xxhsum < README.md > .test.README.md.xxh\n\t./xxhsum -c .test.README.md.xxh < README.md\n\t# xxhsum -q does not display \"Loading\" message into stderr (#251)\n\t! ./xxhsum -q $(TEST_FILES) 2>&1 | grep Loading\n\t# xxhsum does not display \"Loading\" message into stderr either\n\t! ./xxhsum $(TEST_FILES) 2>&1 | grep Loading\n\t# Check that xxhsum do display filename that it failed to open.\n\tLC_ALL=C ./xxhsum nonexistent 2>&1 | grep \"Error: Could not open 'nonexistent'\"\n\t# xxhsum to/from file, shell redirection\n\t./xxhsum $(TEST_FILES) > .test.xxh64\n\t./xxhsum --tag $(TEST_FILES) > .test.xxh64_tag\n\t./xxhsum --little-endian $(TEST_FILES) > .test.le_xxh64\n\t./xxhsum --tag --little-endian $(TEST_FILES) > .test.le_xxh64_tag\n\t./xxhsum -H0 $(TEST_FILES) > .test.xxh32\n\t./xxhsum -H0 --tag $(TEST_FILES) > .test.xxh32_tag\n\t./xxhsum -H0 --little-endian $(TEST_FILES) > .test.le_xxh32\n\t./xxhsum -H0 --tag --little-endian $(TEST_FILES) > .test.le_xxh32_tag\n\t./xxhsum -H2 $(TEST_FILES) > .test.xxh128\n\t./xxhsum -H2 --tag $(TEST_FILES) > .test.xxh128_tag\n\t./xxhsum -H2 --little-endian $(TEST_FILES) > .test.le_xxh128\n\t./xxhsum -H2 --tag --little-endian $(TEST_FILES) > .test.le_xxh128_tag\n\t./xxhsum -H3 $(TEST_FILES) > .test.xxh3\n\t./xxhsum -H3 --tag $(TEST_FILES) > .test.xxh3_tag\n\t./xxhsum -H3 --little-endian $(TEST_FILES) > .test.le_xxh3\n\t./xxhsum -H3 --tag --little-endian $(TEST_FILES) > .test.le_xxh3_tag\n\t./xxhsum -c .test.xxh*\n\t./xxhsum -c --little-endian .test.le_xxh*\n\t./xxhsum -c .test.*_tag\n\t# read list of files from stdin\n\t./xxhsum -c < .test.xxh32\n\t./xxhsum -c < .test.xxh64\n\t./xxhsum -c < .test.xxh128\n\t./xxhsum -c < .test.xxh3\n\tcat .test.xxh* | ./xxhsum -c -\n\t# check variant with '*' marker as second separator\n\t$(SED) 's/ / \\*/' .test.xxh32 | ./xxhsum -c\n\t# bsd-style output\n\t./xxhsum --tag xxhsum* | $(GREP) XXH64\n\t./xxhsum --tag -H0 xxhsum* | $(GREP) XXH32\n\t./xxhsum --tag -H1 xxhsum* | $(GREP) XXH64\n\t./xxhsum --tag -H2 xxhsum* | $(GREP) XXH128\n\t./xxhsum --tag -H3 xxhsum* | $(GREP) XXH3\n\t./xxhsum -H3 xxhsum* | $(GREP) XXH3_ # prefix for GNU format\n\t./xxhsum --tag -H32 xxhsum* | $(GREP) XXH32\n\t./xxhsum --tag -H64 xxhsum* | $(GREP) XXH64\n\t./xxhsum --tag -H128 xxhsum* | $(GREP) XXH128\n\t./xxhsum --tag -H0 --little-endian xxhsum* | $(GREP) XXH32_LE\n\t./xxhsum --tag -H1 --little-endian xxhsum* | $(GREP) XXH64_LE\n\t./xxhsum --tag -H2 --little-endian xxhsum* | $(GREP) XXH128_LE\n\t./xxhsum --tag -H3 --little-endian xxhsum* | $(GREP) XXH3_LE\n\t./xxhsum --tag -H32 --little-endian xxhsum* | $(GREP) XXH32_LE\n\t./xxhsum --tag -H64 --little-endian xxhsum* | $(GREP) XXH64_LE\n\t./xxhsum --tag -H128 --little-endian xxhsum* | $(GREP) XXH128_LE\n\t# check bsd-style\n\t./xxhsum --tag xxhsum* | ./xxhsum -c\n\t./xxhsum --tag -H32 --little-endian xxhsum* | ./xxhsum -c\n\t# xxhsum -c warns improperly format lines.\n\techo '12345678 ' >>.test.xxh32\n\t./xxhsum -c .test.xxh32 | $(GREP) improperly\n\techo '123456789 file' >>.test.xxh64\n\t./xxhsum -c .test.xxh64 | $(GREP) improperly\n\t# Expects \"FAILED\"\n\techo \"0000000000000000 LICENSE\" | ./xxhsum -c -; test $$? -eq 1\n\techo \"00000000 LICENSE\" | ./xxhsum -c -; test $$? -eq 1\n\t# Expects \"FAILED open or read\"\n\techo \"0000000000000000 test-expects-file-not-found\" | ./xxhsum -c -; test $$? -eq 1\n\techo \"00000000 test-expects-file-not-found\" | ./xxhsum -c -; test $$? -eq 1\n\t# --filelist\n\techo xxhash.c > .test.filenames\n\t$(RUN_ENV) ./xxhsum$(EXT) --filelist .test.filenames\n\t# --filelist from stdin\n\tcat .test.filenames | $(RUN_ENV) ./xxhsum$(EXT) --filelist\n\t@$(RM) .test.*\n\nCC_VERSION := $(shell $(CC) --version 2>/dev/null)\nifneq (,$(findstring clang,$(CC_VERSION)))\nfuzzer: CFLAGS += -fsanitize=fuzzer\n$(eval $(call c_program,fuzzer, fuzz/fuzzer.o xxhash.o))\nelse\nfuzzer: this_target_requires_clang # intentional fail\nendif\n\n.PHONY: test-filename-escape\ntest-filename-escape:\n\t$(MAKE) -C tests test_filename_escape\n\n.PHONY: test-cli-comment-line\ntest-cli-comment-line:\n\t$(MAKE) -C tests test_cli_comment_line\n\n.PHONY: test-cli-ignore-missing\ntest-cli-ignore-missing:\n\t$(MAKE) -C tests test_cli_ignore_missing\n\n.PHONY: armtest\narmtest:\n\t@echo ---- test ARM compilation ----\n\tCC=arm-linux-gnueabi-gcc MOREFLAGS=\"-Werror -static\" $(MAKE) xxhsum\n\n.PHONY: arm64test\narm64test:\n\t@echo ---- test ARM64 compilation ----\n\tCC=aarch64-linux-gnu-gcc MOREFLAGS=\"-Werror -static\" $(MAKE) xxhsum\n\n.PHONY: clangtest\nclangtest:\n\t@echo ---- test clang compilation ----\n\tCC=clang MOREFLAGS=\"-Werror -Wconversion -Wno-sign-conversion\" $(MAKE) all\n\n.PHONY: gcc-og-test\ngcc-og-test:\n\t@echo ---- test gcc -Og compilation ----\n\tCFLAGS=\"-Og -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror -fPIC\" CPPFLAGS=\"-DXXH_NO_INLINE_HINTS\" MOREFLAGS=\"-Werror\" $(MAKE) all\n\n.PHONY: cxxtest\ncxxtest:\n\t@echo ---- test C++ compilation ----\n\tCC=\"$(CXX) -Wno-deprecated\" $(MAKE) all CFLAGS=\"-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror -fPIC\"\n\n# In strict C90 mode, there is no `long long` type support,\n# consequently, only XXH32 can be compiled.\n.PHONY: c90test\nifeq ($(NO_C90_TEST),true)\nc90test:\n\t@echo no c90 compatibility test\nelse\nc90test: CPPFLAGS += -DXXH_NO_LONG_LONG\nc90test: CFLAGS += -std=c90 -Werror -pedantic\nc90test: xxhash.c\n\t@echo ---- test strict C90 compilation [xxh32 only] ----\n\t$(RM) xxhash.o\n\t$(CC) $(FLAGS) $^ -c\n\t$(NM) xxhash.o | $(GREP) XXH64 ; test $$? -eq 1\n\t$(RM) xxhash.o\nendif\n\n.PHONY: noxxh3test\nnoxxh3test: CPPFLAGS += -DXXH_NO_XXH3\nnoxxh3test: CFLAGS += -Werror -pedantic -Wno-long-long # XXH64 requires long long support\nnoxxh3test: OFILE = xxh_noxxh3.o\nnoxxh3test: xxhash.c\n\t@echo ---- test compilation without XXH3 ----\n\t$(CC) $(FLAGS) -c $^ -o $(OFILE)\n\t$(NM) $(OFILE) | $(GREP) XXH3_ ; test $$? -eq 1\n\t$(RM) $(OFILE)\n\n.PHONY: nostreamtest\nnostreamtest: CPPFLAGS += -DXXH_NO_STREAM\nnostreamtest: CFLAGS += -Werror -pedantic -Wno-long-long # XXH64 requires long long support\nnostreamtest: OFILE = xxh_nostream.o\nnostreamtest: xxhash.c\n\t@echo ---- test compilation without streaming ----\n\t$(CC) $(FLAGS) -c $^ -o $(OFILE)\n\t$(NM) $(OFILE) | $(GREP) update ; test $$? -eq 1\n\t$(RM) $(OFILE)\n\n.PHONY: nostdlibtest\nnostdlibtest: CPPFLAGS += -DXXH_NO_STDLIB\nnostdlibtest: CFLAGS += -Werror -pedantic -Wno-long-long # XXH64 requires long long support\nnostdlibtest: OFILE = xxh_nostdlib.o\nnostdlibtest: xxhash.c\n\t@echo ---- test compilation without \\ ----\n\t$(CC) $(FLAGS) -c $^ -o $(OFILE)\n\t$(NM) $(OFILE) | $(GREP) \"U _free\\|U free\" ; test $$? -eq 1\n\t$(RM) $(OFILE)\n\n.PHONY: usan\nusan: CC=clang\nusan: CXX=clang++\nusan: ## check CLI runtime for undefined behavior, using clang's sanitizer\n\t@echo ---- check undefined behavior - sanitize ----\n\t$(MAKE) test CC=$(CC) CXX=$(CXX) MOREFLAGS=\"-g -fsanitize=undefined -fno-sanitize-recover=all\"\n\n.PHONY: staticAnalyze\nSCANBUILD ?= scan-build\nstaticAnalyze: clean ## check C source files using $(SCANBUILD) static analyzer\n\t@echo ---- static analyzer - $(SCANBUILD) ----\n\tCFLAGS=\"-g -Werror\" $(SCANBUILD) --status-bugs -v $(MAKE) all\n\nCPPCHECK ?= cppcheck\n.PHONY: cppcheck\ncppcheck: ## check C source files using $(CPPCHECK) static analyzer\n\t@echo ---- static analyzer - $(CPPCHECK) ----\n\t$(CPPCHECK) . --force --enable=warning,portability,performance,style --error-exitcode=1 > /dev/null\n\n.PHONY: namespaceTest\nnamespaceTest: ## ensure XXH_NAMESPACE redefines all public symbols\n\t$(CC) -c xxhash.c\n\t$(CC) -DXXH_NAMESPACE=TEST_ -c xxhash.c -o xxhash2.o\n\t$(CC) xxhash.o xxhash2.o $(CLI_SRCS) -o xxhsum2 # will fail if one namespace missing (symbol collision)\n\t$(RM) *.o xxhsum2 # clean\n\nMAN = $(CLI_DIR)/xxhsum.1\nMD2ROFF ?= ronn\nMD2ROFF_FLAGS ?= --roff --warnings --manual=\"User Commands\" --organization=\"xxhsum $(XXHSUM_VERSION)\"\n$(MAN): $(CLI_DIR)/xxhsum.1.md xxhash.h\n\tcat $< | $(MD2ROFF) $(MD2ROFF_FLAGS) | $(SED) -n '/^\\.\\\\\\\".*/!p' > $@\n\n.PHONY: man\nman: $(MAN) ## generate man page from markdown source\n\n.PHONY: clean-man\nclean-man:\n\t$(RM) xxhsum.1\n\n.PHONY: preview-man\npreview-man: man\n\tman ./xxhsum.1\n\n.PHONY: test\ntest: DEBUGFLAGS += -DXXH_DEBUGLEVEL=1\ntest: all namespaceTest check test-xxhsum-c c90test test-tools noxxh3test nostdlibtest\n\n# this test checks that including \"xxhash.h\" multiple times and with different directives still compiles properly\n.PHONY: test-multiInclude\ntest-multiInclude:\n\t$(MAKE) -C tests test_multiInclude\n\n.PHONY: test-inline-notexposed\ntest-inline-notexposed: xxhsum_inlinedXXH\n\t$(NM) xxhsum_inlinedXXH | $(GREP) \"t _XXH32_\" ; test $$? -eq 1 # no XXH32 symbol should be left\n\t$(NM) xxhsum_inlinedXXH | $(GREP) \"t _XXH64_\" ; test $$? -eq 1 # no XXH64 symbol should be left\n\n.PHONY: test-inline\ntest-inline: test-inline-notexposed test-multiInclude\n\n\n.PHONY: test-all\ntest-all: CFLAGS += -Werror\ntest-all: test test32 test-unicode clangtest gcc-og-test cxxtest usan test-inline listL120 trailingWhitespace test-xxh-nnn-sums\n\n.PHONY: test-tools\ntest-tools:\n\tCFLAGS=-Werror $(MAKE) -C tests/bench\n\tCFLAGS=-Werror $(MAKE) -C tests/collisions check\n\n.PHONY: test-xxh-nnn-sums\ntest-xxh-nnn-sums: xxhsum_and_links\n\t./xxhsum README.md > tmp.xxhsum.out # xxhsum outputs xxh64\n\t./xxh32sum README.md > tmp.xxh32sum.out\n\t./xxh64sum README.md > tmp.xxh64sum.out\n\t./xxh128sum README.md > tmp.xxh128sum.out\n\t./xxh3sum README.md > tmp.xxh3sum.out\n\tcat tmp.xxhsum.out\n\tcat tmp.xxh32sum.out\n\tcat tmp.xxh64sum.out\n\tcat tmp.xxh128sum.out\n\tcat tmp.xxh3sum.out\n\t./xxhsum -c tmp.xxhsum.out\n\t./xxhsum -c tmp.xxh32sum.out\n\t./xxhsum -c tmp.xxh64sum.out\n\t./xxhsum -c tmp.xxh128sum.out\n\t./xxhsum -c tmp.xxh3sum.out\n\t./xxh32sum -c tmp.xxhsum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh32sum -c tmp.xxh32sum.out\n\t./xxh32sum -c tmp.xxh64sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh32sum -c tmp.xxh128sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh32sum -c tmp.xxh3sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh64sum -c tmp.xxhsum.out\n\t./xxh64sum -c tmp.xxh32sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh64sum -c tmp.xxh64sum.out\n\t./xxh64sum -c tmp.xxh128sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh64sum -c tmp.xxh3sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh128sum -c tmp.xxhsum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh128sum -c tmp.xxh32sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh128sum -c tmp.xxh64sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh128sum -c tmp.xxh128sum.out\n\t./xxh128sum -c tmp.xxh3sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh3sum -c tmp.xxhsum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh3sum -c tmp.xxh32sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh3sum -c tmp.xxh64sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh3sum -c tmp.xxh128sum.out ; test $$? -eq 1 # expects \"no properly formatted\"\n\t./xxh3sum -c tmp.xxh3sum.out\n\n.PHONY: listL120\nlistL120: # extract lines >= 120 characters in *.{c,h}, by Takayuki Matsuoka (note: $$, for Makefile compatibility)\n\tfind . -type f -name '*.c' -o -name '*.h' | while read -r filename; do awk 'length > 120 {print FILENAME \"(\" FNR \"): \" $$0}' $$filename; done\n\n.PHONY: trailingWhitespace\ntrailingWhitespace:\n\t! $(GREP) -E \"`printf '[ \\\\t]$$'`\" cli/*.c cli/*.h cli/*.1 *.c *.h LICENSE Makefile build/cmake/CMakeLists.txt\n\n.PHONY: lint-unicode\nlint-unicode:\n\t./tests/unicode_lint.sh\n\n# =========================================================\n# make install is validated only for the following targets\n# =========================================================\nifneq (,$(filter Linux Darwin GNU/kFreeBSD GNU Haiku OpenBSD FreeBSD NetBSD DragonFly SunOS CYGWIN% , $(UNAME)))\n\nDESTDIR ?=\n# directory variables: GNU conventions prefer lowercase\n# see https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html\n# support both lower and uppercase (BSD), use uppercase in script\nprefix ?= /usr/local\nPREFIX ?= $(prefix)\nexec_prefix ?= $(PREFIX)\nEXEC_PREFIX ?= $(exec_prefix)\nlibdir ?= $(EXEC_PREFIX)/lib\nLIBDIR ?= $(libdir)\nincludedir ?= $(PREFIX)/include\nINCLUDEDIR ?= $(includedir)\nbindir ?= $(EXEC_PREFIX)/bin\nBINDIR ?= $(bindir)\ndatarootdir ?= $(PREFIX)/share\nmandir ?= $(datarootdir)/man\nman1dir ?= $(mandir)/man1\n\nifneq (,$(filter $(UNAME),FreeBSD NetBSD DragonFly))\nPKGCONFIGDIR ?= $(PREFIX)/libdata/pkgconfig\nelse\nPKGCONFIGDIR ?= $(LIBDIR)/pkgconfig\nendif\n\nifneq (,$(filter $(UNAME),OpenBSD NetBSD DragonFly SunOS))\nMANDIR ?= $(PREFIX)/man/man1\nelse\nMANDIR ?= $(man1dir)\nendif\n\nifneq (,$(filter $(UNAME),SunOS))\nINSTALL ?= ginstall\nelse\nINSTALL ?= install\nendif\n\nINSTALL_PROGRAM ?= $(INSTALL)\nINSTALL_DATA ?= $(INSTALL) -m 644\nMAKE_DIR ?= $(INSTALL) -d -m 755\n\n\n# Escape special symbols by putting each character into its separate class\nEXEC_PREFIX_REGEX ?= $(shell echo \"$(EXEC_PREFIX)\" | $(SED) $(SED_ERE_OPT) -e \"s/([^^])/[\\1]/g\" -e \"s/\\\\^/\\\\\\\\^/g\")\nPREFIX_REGEX ?= $(shell echo \"$(PREFIX)\" | $(SED) $(SED_ERE_OPT) -e \"s/([^^])/[\\1]/g\" -e \"s/\\\\^/\\\\\\\\^/g\")\n\nPCLIBDIR ?= $(shell echo \"$(LIBDIR)\" | $(SED) -n $(SED_ERE_OPT) -e \"s@^$(EXEC_PREFIX_REGEX)(/|$$)@@p\")\nPCINCDIR ?= $(shell echo \"$(INCLUDEDIR)\" | $(SED) -n $(SED_ERE_OPT) -e \"s@^$(PREFIX_REGEX)(/|$$)@@p\")\nPCEXECDIR?= $(if $(filter $(PREFIX),$(EXEC_PREFIX)),$$\\{prefix\\},$(EXEC_PREFIX))\n\nifeq (,$(PCLIBDIR))\n# Additional prefix check is required, since the empty string is technically a\n# valid PCLIBDIR\nifeq (,$(shell echo \"$(LIBDIR)\" | $(SED) -n $(SED_ERE_OPT) -e \"\\\\@^$(EXEC_PREFIX_REGEX)(/|$$)@ p\"))\n$(error configured libdir ($(LIBDIR)) is outside of exec_prefix ($(EXEC_PREFIX)), can't generate pkg-config file)\nendif\nendif\n\nifeq (,$(PCINCDIR))\n# Additional prefix check is required, since the empty string is technically a\n# valid PCINCDIR\nifeq (,$(shell echo \"$(INCLUDEDIR)\" | $(SED) -n $(SED_ERE_OPT) -e \"\\\\@^$(PREFIX_REGEX)(/|$$)@ p\"))\n$(error configured includedir ($(INCLUDEDIR)) is outside of prefix ($(PREFIX)), can't generate pkg-config file)\nendif\nendif\n\nlibxxhash.pc: libxxhash.pc.in\n\t@echo creating pkgconfig\n\t$(SED) $(SED_ERE_OPT) -e 's|@PREFIX@|$(PREFIX)|' \\\n -e 's|@EXECPREFIX@|$(PCEXECDIR)|' \\\n -e 's|@LIBDIR@|$$\\{exec_prefix\\}/$(PCLIBDIR)|' \\\n -e 's|@INCLUDEDIR@|$$\\{prefix\\}/$(PCINCDIR)|' \\\n -e 's|@VERSION@|$(LIBVER)|' \\\n $< > $@\n\n\ninstall_libxxhash.a: libxxhash.a\n\t@echo Installing libxxhash.a\n\t$(MAKE_DIR) $(DESTDIR)$(LIBDIR)\n\t$(INSTALL_DATA) libxxhash.a $(DESTDIR)$(LIBDIR)\n\ninstall_libxxhash: libxxhash\n\t@echo Installing libxxhash\n\t$(MAKE_DIR) $(DESTDIR)$(LIBDIR)\n\t$(INSTALL_PROGRAM) $(LIBXXH) $(DESTDIR)$(LIBDIR)\n\tln -sf $(LIBXXH) $(DESTDIR)$(LIBDIR)/libxxhash.$(SHARED_EXT_MAJOR)\n\tln -sf libxxhash.$(SHARED_EXT_MAJOR) $(DESTDIR)$(LIBDIR)/libxxhash.$(SHARED_EXT)\n\ninstall_libxxhash.includes:\n\t$(INSTALL) -d -m 755 $(DESTDIR)$(INCLUDEDIR) # includes\n\t$(INSTALL_DATA) xxhash.h $(DESTDIR)$(INCLUDEDIR)\n\t$(INSTALL_DATA) xxh3.h $(DESTDIR)$(INCLUDEDIR) # for compatibility, will be removed in v0.9.0\nifeq ($(LIBXXH_DISPATCH),1)\n\t$(INSTALL_DATA) xxh_x86dispatch.h $(DESTDIR)$(INCLUDEDIR)\nendif\n\ninstall_libxxhash.pc: libxxhash.pc\n\t@echo Installing pkgconfig\n\t$(MAKE_DIR) $(DESTDIR)$(PKGCONFIGDIR)/\n\t$(INSTALL_DATA) libxxhash.pc $(DESTDIR)$(PKGCONFIGDIR)/\n\ninstall_xxhsum: xxhsum\n\t@echo Installing xxhsum\n\t$(MAKE_DIR) $(DESTDIR)$(BINDIR)/\n\t$(INSTALL_PROGRAM) xxhsum$(EXT) $(DESTDIR)$(BINDIR)/xxhsum$(EXT)\n\tln -sf xxhsum$(EXT) $(DESTDIR)$(BINDIR)/xxh32sum$(EXT)\n\tln -sf xxhsum$(EXT) $(DESTDIR)$(BINDIR)/xxh64sum$(EXT)\n\tln -sf xxhsum$(EXT) $(DESTDIR)$(BINDIR)/xxh128sum$(EXT)\n\tln -sf xxhsum$(EXT) $(DESTDIR)$(BINDIR)/xxh3sum$(EXT)\n\ninstall_man:\n\t@echo Installing man pages\n\t$(MAKE_DIR) $(DESTDIR)$(MANDIR)/\n\t$(INSTALL_DATA) $(MAN) $(DESTDIR)$(MANDIR)/xxhsum.1\n\tln -sf xxhsum.1 $(DESTDIR)$(MANDIR)/xxh32sum.1\n\tln -sf xxhsum.1 $(DESTDIR)$(MANDIR)/xxh64sum.1\n\tln -sf xxhsum.1 $(DESTDIR)$(MANDIR)/xxh128sum.1\n\tln -sf xxhsum.1 $(DESTDIR)$(MANDIR)/xxh3sum.1\n\n.PHONY: install\n## install libraries, CLI, links and man pages\ninstall: install_libxxhash.a install_libxxhash install_libxxhash.includes install_libxxhash.pc install_xxhsum install_man\n\t@echo xxhash installation completed\n\n.PHONY: uninstall\nuninstall: ## uninstall libraries, CLI, links and man page\n\t$(RM) $(DESTDIR)$(LIBDIR)/libxxhash.a\n\t$(RM) $(DESTDIR)$(LIBDIR)/libxxhash.$(SHARED_EXT)\n\t$(RM) $(DESTDIR)$(LIBDIR)/libxxhash.$(SHARED_EXT_MAJOR)\n\t$(RM) $(DESTDIR)$(LIBDIR)/$(LIBXXH)\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/xxhash.h\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/xxh3.h\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/xxh_x86dispatch.h\n\t$(RM) $(DESTDIR)$(PKGCONFIGDIR)/libxxhash.pc\n\t$(RM) $(DESTDIR)$(BINDIR)/xxh32sum\n\t$(RM) $(DESTDIR)$(BINDIR)/xxh64sum\n\t$(RM) $(DESTDIR)$(BINDIR)/xxh128sum\n\t$(RM) $(DESTDIR)$(BINDIR)/xxh3sum\n\t$(RM) $(DESTDIR)$(BINDIR)/xxhsum\n\t$(RM) $(DESTDIR)$(MANDIR)/xxh32sum.1\n\t$(RM) $(DESTDIR)$(MANDIR)/xxh64sum.1\n\t$(RM) $(DESTDIR)$(MANDIR)/xxh128sum.1\n\t$(RM) $(DESTDIR)$(MANDIR)/xxh3sum.1\n\t$(RM) $(DESTDIR)$(MANDIR)/xxhsum.1\n\t@echo xxhsum successfully uninstalled\n\nendif\n" }, { "path": "deps/xxhash/build/make/README.md", "content": "# multiconf.make\n\n**multiconf.make** is a self-contained Makefile include that lets you build the **same targets under many different flag sets**. For example debug vs release, ASan vs UBSan, GCC vs Clang.\nEach different set of flags generates object files into its own **dedicated cache directory**, so objects compiled with one configuration are never reused by another.\nObject files from previous configurations are preserved, so swapping back to a previous configuration only requires compiling objects which have actually changed.\n\n---\n\n## Benefits at a glance\n\n| Benefit | What `multiconf.make` does |\n| --- | --- |\n| **Isolated configs** | Stores objects into `cachedObjs//`, one directory per unique flag set. |\n| **Fast switching** | Reusing an old config is instant—link only, no recompilation. |\n| **Header deps** | Edits to headers trigger only needed rebuilds. |\n| **One-liner targets** | Macros (`c_program`, `cxx_program`, …) hide all rule boilerplate. |\n| **Parallel-ready** | Safe with `make -j`, no duplicate compiles of shared sources. |\n| **Controlled verbosity** | Default only lists objects, while `V=1` display full commands. |\n| **`clean` included** | `make clean` deletes all objects, binaries and links. |\n\n---\n\n## Quick Start\n\n### 1 · List your sources\n\n```make\nC_SRCDIRS := src src/cdeps # all .c are in these directories\nCXX_SRCDIRS := src src/cxxdeps # all .cpp are in these directories\n```\n\n### 2 · Add and include\n\n```make\n# root/Makefile\ninclude multiconf.make\n```\n\n### 3 · Declare targets\n\n```make\napp:\n$(eval $(call c_program,app,app.o cdeps/obj.o))\n\ntest:\n$(eval $(call cxx_program,test, test.o cxxdeps/objcxx.o))\n\nlib.a:\n$(eval $(call static_library,lib.a, lib.o cdeps/obj.o))\n\nlib.so:\n$(eval $(call c_dynamic_library,lib.so, lib.o cdeps/obj.o))\n```\n\n### 4 · Build any config you like\n\n```sh\n# Release with GCC\nmake CFLAGS=\"-O3\"\n\n# Debug with Clang + AddressSanitizer (new cache dir)\nmake CC=clang CFLAGS=\"-g -O0 -fsanitize=address\"\n\n# Switch back to GCC release (objects still valid, relink only)\nmake CFLAGS=\"-O3\"\n```\n\nObjects for each command live in different sub-folders; nothing overlaps.\n\n---\n\n" }, { "path": "deps/xxhash/build/make/multiconf.make", "content": "# ##########################################################################\n# multiconf.make\n# Copyright (C) Yann Collet\n#\n# GPL v2 License\n#\n# This program is free software; you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation; either version 2 of the License, or\n# (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License along\n# with this program; if not, write to the Free Software Foundation, Inc.,\n# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n#\n# ##########################################################################\n\n\n# Provides c_program(_shared_o) and cxx_program(_shared_o) target generation macros\n# Provides static_library and c_dynamic_library target generation macros\n# Support recompilation of only impacted units when an associated *.h is updated.\n# Provides V=1 / VERBOSE=1 support. V=2 is used for debugging purposes.\n# Complement target clean: delete objects and binaries created by this script\n\n# Requires:\n# - C_SRCDIRS, CXX_SRCDIRS, ASM_SRCDIRS defined\n# OR\n# C_SRCS, CXX_SRCS and ASM_SRCS variables defined\n# *and* vpath set to find all source files\n# OR\n# C_OBJS, CXX_OBJS and ASM_OBJS variables defined\n# *and* vpath set to find all source files\n# - directory `cachedObjs/` available to cache object files.\n# alternatively: set CACHE_ROOT to some different value.\n# Optional:\n# - HASH can be set to a different custom hash program.\n\n# *_program*: generates a recipe for a target that will be built in a cache directory.\n# The cache directory is automatically derived from CACHE_ROOT and list of flags and compilers.\n# *_shared_o* variants are optional optimization variants, that share the same objects across multiple targets.\n# However, as a consequence, all these objects must have exactly the same list of flags,\n# which in practice means that there must be no target-level modification (like: target: CFLAGS += someFlag).\n# If unsure, only use the standard variants, c_program and cxx_program.\n\n# All *_program* macro functions take up to 4 argument:\n# - The name of the target\n# - The list of object files to build in the cache directory\n# - An optional list of dependencies for linking, that will not be built\n# - An optional complementary recipe code, that will run after compilation and link\n\n\n# Silent mode is default; use V = 1 or VERBOSE = 1 to see compilation lines\nVERBOSE ?= $(V)\n$(VERBOSE).SILENT:\n\n# Directory where object files will be built\nCACHE_ROOT ?= cachedObjs\n\n# --------------------------------------------------------------------------------------------\n\n# Dependency management\nDEPFLAGS = -MT $@ -MMD -MP -MF\n\n# Include dependency files\ninclude $(wildcard $(CACHE_ROOT)/**/*.d)\ninclude $(wildcard $(CACHE_ROOT)/generic/*/*.d)\n\n# --------------------------------------------------------------------------------------------\n\n# Automatic determination of build artifacts cache directory, keyed on build\n# flags, so that we can do incremental, parallel builds of different binaries\n# with different build flags without collisions.\n\nUNAME ?= $(shell uname)\nifeq ($(UNAME), Darwin)\n HASH ?= md5\nelse ifeq ($(UNAME), FreeBSD)\n HASH ?= gmd5sum\nelse ifeq ($(UNAME), OpenBSD)\n HASH ?= md5\nendif\nHASH ?= md5sum\n\nHAVE_HASH := $(shell echo 1 | $(HASH) > /dev/null && echo 1 || echo 0)\nifeq ($(HAVE_HASH),0)\n $(info warning : could not find HASH ($(HASH)), required to differentiate builds using different flags)\n HASH_FUNC = generic/$(1)\nelse\n HASH_FUNC = $(firstword $(shell echo $(2) | $(HASH) ))\nendif\n\n\nMKDIR ?= mkdir\nLN ?= ln\n\n# --------------------------------------------------------------------------------------------\n# The following macros are used to create object files in the cache directory.\n# The object files are named after the source file, but with a different path.\n\n# Create build directories on-demand.\n#\n# For some reason, make treats the directory as an intermediate file and tries\n# to delete it. So we work around that by marking it \"precious\". Solution found\n# here:\n# http://ismail.badawi.io/blog/2017/03/28/automatic-directory-creation-in-make/\n.PRECIOUS: $(CACHE_ROOT)/%/.\n$(CACHE_ROOT)/%/. :\n\t$(MKDIR) -p $@\n\n\ndefine addTargetAsmObject # targetName, addlDeps\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2))))\n\n.PRECIOUS: $$(CACHE_ROOT)/%/$(1)\n$$(CACHE_ROOT)/%/$(1) : $(1:.o=.S) $(2) | $$(CACHE_ROOT)/%/.\n\t@echo AS $$@\n\t$$(CC) $$(CPPFLAGS) $$(CXXFLAGS) $$(DEPFLAGS) $$(CACHE_ROOT)/$$*/$(1:.o=.d) -c $$< -o $$@\n\nendef # addTargetAsmObject\n\ndefine addTargetCObject # targetName, addlDeps\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2)))) #debug print\n\n.PRECIOUS: $$(CACHE_ROOT)/%/$(1)\n$$(CACHE_ROOT)/%/$(1) : $(1:.o=.c) $(2) | $$(CACHE_ROOT)/%/.\n\t@echo CC $$@\n\t$$(CC) $$(CPPFLAGS) $$(CFLAGS) $$(DEPFLAGS) $$(CACHE_ROOT)/$$*/$(1:.o=.d) -c $$< -o $$@\n\nendef # addTargetCObject\n\ndefine addTargetCxxObject # targetName, suffix, addlDeps\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2),$(3))))\n\n.PRECIOUS: $$(CACHE_ROOT)/%/$(1)\n$$(CACHE_ROOT)/%/$(1) : $(1:.o=.$(2)) $(3) | $$(CACHE_ROOT)/%/.\n\t@echo CXX $$@\n\t$$(CXX) $$(CPPFLAGS) $$(CXXFLAGS) $$(DEPFLAGS) $$(CACHE_ROOT)/$$*/$(1:.o=.d) -c $$< -o $$@\n\nendef # addTargetCxxObject\n\n# Create targets for individual object files\nC_SRCDIRS += .\nvpath %.c $(C_SRCDIRS)\nCXX_SRCDIRS += .\nvpath %.cpp $(CXX_SRCDIRS)\nvpath %.cc $(CXX_SRCDIRS)\nASM_SRCDIRS += .\nvpath %.S $(ASM_SRCDIRS)\n\n# If C_SRCDIRS, CXX_SRCDIRS and ASM_SRCDIRS are not defined, use C_SRCS, CXX_SRCS and ASM_SRCS\nC_SRCS ?= $(notdir $(foreach dir,$(C_SRCDIRS),$(wildcard $(dir)/*.c)))\nCPP_SRCS ?= $(notdir $(foreach dir,$(CXX_SRCDIRS),$(wildcard $(dir)/*.cpp)))\nCC_SRCS ?= $(notdir $(foreach dir,$(CXX_SRCDIRS),$(wildcard $(dir)/*.cc)))\nCXX_SRCS ?= $(CPP_SRCS) $(CC_SRCS)\nASM_SRCS ?= $(notdir $(foreach dir,$(ASM_SRCDIRS),$(wildcard $(dir)/*.S)))\n\n# If C_SRCS, CXX_SRCS and ASM_SRCS are not defined, use C_OBJS, CXX_OBJS and ASM_OBJS\nC_OBJS ?= $(patsubst %.c,%.o,$(C_SRCS))\nCPP_OBJS ?= $(patsubst %.cpp,%.o,$(CPP_SRCS))\nCC_OBJS ?= $(patsubst %.cc,%.o,$(CC_SRCS))\nCXX_OBJS ?= $(CPP_OBJS) $(CC_OBJS) # Note: not used\nASM_OBJS ?= $(patsubst %.S,%.o,$(ASM_SRCS))\n\n$(foreach OBJ,$(C_OBJS),$(eval $(call addTargetCObject,$(OBJ))))\n$(foreach OBJ,$(CPP_OBJS),$(eval $(call addTargetCxxObject,$(OBJ),cpp)))\n$(foreach OBJ,$(CC_OBJS),$(eval $(call addTargetCxxObject,$(OBJ),cc)))\n$(foreach OBJ,$(ASM_OBJS),$(eval $(call addTargetAsmObject,$(OBJ))))\n\n# --------------------------------------------------------------------------------------------\n# The following macros are used to create targets in the user Makefile.\n# Binaries are built in the cache directory, and then symlinked to the current directory.\n# The cache directory is automatically derived from CACHE_ROOT and list of flags and compilers.\n\n\n# static_library - Create build rules for a static library with caching\n# Parameters:\n# 1. libName - Library name (becomes output file and phony target)\n# 2. objectDeps - Object file dependencies (will be built in cache path)\n# The following parameters are all optional:\n# 3. extraDeps - Additional dependencies (no cache path prefix)\n# 4. postBuildCmds - Extra commands to run after AR\n# 5. extraHash - Additional key to compute the unique cache path\n# Example:\n# $(call static_library,libmath.a,vector.o matrix.o,$(CONFIG_H),strip $@,$(VERSION))\ndefine static_library # libName, objectDeps, extraDeps, postBuildCmds, extraHash\n\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2),$(3),$(4),$(5))))\nMCM_ALL_BINS += $(1)\n\n$$(CACHE_ROOT)/%/$(1) : $$(addprefix $$(CACHE_ROOT)/%/,$(2)) $(3)\n\t@echo AR $$@\n\t$$(AR) $$(ARFLAGS) $$@ $$^\n\t$(4)\n\n.PHONY: $(1)\n$(1) : ARFLAGS = rcs\n$(1) : $$(CACHE_ROOT)/$$(call HASH_FUNC,$(1),$(2) $$(CPPFLAGS) $$(CC) $$(CFLAGS) $$(CXX) $$(CXXFLAGS) $$(AR) $$(ARFLAGS) $(5))/$(1)\n\t$$(LN) -sf $$< $$@\n\nendef # static_library\n\n\n# c_dynamic_library - Create build rules for a C dynamic/shared library with caching\n# Parameters:\n# 1. libName - Library name (becomes output file and phony target)\n# 2. objectDeps - Object file dependencies (will be built in cache path)\n# The following parameters are all optional:\n# 3. extraDeps - Additional dependencies (no cache path prefix)\n# 4. postLinkCmds - Extra commands to run after linking\n# 5. extraHash - Additional key to compute the unique cache path\n# Example:\n# $(call c_dynamic_library,libmath.so,vector.o matrix.o,$(CONFIG_H),strip $@,$(VERSION))\ndefine c_dynamic_library # libName, objectDeps, extraDeps, postLinkCmds, extraHash\n\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2),$(3),$(4),$(5))))\nMCM_ALL_BINS += $(1)\n\n$$(CACHE_ROOT)/%/$(1) : $$(addprefix $$(CACHE_ROOT)/%/,$(2)) $(3)\n\t@echo LD $$@\n\t$$(CC) $$(CPPFLAGS) $$(CFLAGS) $$(LDFLAGS) -shared -o $$@ $$^ $$(LDLIBS)\n\t$(4)\n\n.PHONY: $(1)\n$(1) : CFLAGS += -fPIC\n$(1) : $$(CACHE_ROOT)/$$(call HASH_FUNC,$(1),$(2) $$(CPPFLAGS) $$(CC) $$(CFLAGS) $$(LDFLAGS) $$(LDLIBS) $(5))/$(1)\n\t$$(LN) -sf $$< $$@\n\nendef # c_dynamic_library\n\n\n# program_base - Create build rules for an executable program with caching\n# Parameters:\n# 1. progName - Executable name (becomes output file and phony target)\n# 2. objectDeps - Object file dependencies (will be prefixed with cache path)\n# Parameters 3 to 5 are optional:\n# 3. extraDeps - Additional dependencies (without cache path prefix)\n# 4. postLinkCmds - Extra commands to run after linking\n# 5. extraHash - Additional data to include in cache path hash\n# Parameters 6 & 7 are compulsory:\n# 6. compiler - Variable name of compiler to use (CC or CXX)\n# 7. compilerFlags - Variable name of compiler flags to use (CFLAGS or CXXFLAGS)\n# Example:\n# $(call program_base,myapp,main.o utils.o,$(CONFIG_H),strip $@,$(VERSION),CC,CFLAGS)\n# $(call program_base,mycppapp,main.o utils.o,$(CONFIG_H),strip $@,$(VERSION),CXX,CXXFLAGS)\ndefine program_base # progName, objectDeps, extraDeps, postLinkCmds, extraHash, compiler, compilerFlags\n\n$$(if $$(filter 2,$$(V)),$$(info $$(call $(0),$(1),$(2),$(3),$(4),$(5),$(6),$(7))))\nMCM_ALL_BINS += $(1)\n\n$$(CACHE_ROOT)/%/$(1) : $$(addprefix $$(CACHE_ROOT)/%/,$(2)) $(3)\n\t@echo LD $$@\n\t$$($(6)) $$(CPPFLAGS) $$($(7)) $$^ -o $$@ $$(LDFLAGS) $$(LDLIBS)\n\t$(4)\n\n.PHONY: $(1)\n$(1) : $$(CACHE_ROOT)/$$(call HASH_FUNC,$(1),$$($(6)) $$(CPPFLAGS) $$($(7)) $$(LDFLAGS) $$(LDLIBS) $(5))/$(1)\n\t$$(LN) -sf $$< $$@$(EXT)\n\nendef # program_base\n# Note: $(EXT) must be set to .exe for Windows\n\ndefine c_program # progName, objectDeps, extraDeps, postLinkCmds\n$$(eval $$(call program_base,$(1),$(2),$(3),$(4),$(1)$(2),CC,CFLAGS))\nendef # c_program\n\ndefine c_program_shared_o # progName, objectDeps, extraDeps, postLinkCmds\n$$(eval $$(call program_base,$(1),$(2),$(3),$(4),,CC,CFLAGS))\nendef # c_program_shared_o\n\ndefine cxx_program # progName, objectDeps, extraDeps, postLinkCmds\n$$(eval $$(call program_base,$(1),$(2),$(3),$(4),$(1)$(2),CXX,CXXFLAGS))\nendef # cxx_program\n\ndefine cxx_program_shared_o # progName, objectDeps, extraDeps, postLinkCmds\n$$(eval $$(call program_base,$(1),$(2),$(3),$(4),,CXX,CXXFLAGS))\nendef # cxx_program_shared_o\n\n# --------------------------------------------------------------------------------------------\n\n# Cleaning: delete all objects and binaries created by this script\n.PHONY: clean_cache\nclean_cache:\n\t$(RM) -rf $(CACHE_ROOT)\n\t$(RM) $(MCM_ALL_BINS)\n\n# automatically attach to standard clean target\n.PHONY: clean\nclean: clean_cache\n" }, { "path": "deps/xxhash/xxhash.c", "content": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Copyright (C) 2012-2023 Yann Collet\n *\n * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following disclaimer\n * in the documentation and/or other materials provided with the\n * distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * You can contact the author at:\n * - xxHash homepage: https://www.xxhash.com\n * - xxHash source repository: https://github.com/Cyan4973/xxHash\n */\n\n/*\n * xxhash.c instantiates functions defined in xxhash.h\n */\n\n#define XXH_STATIC_LINKING_ONLY /* access advanced declarations */\n#define XXH_IMPLEMENTATION /* access definitions */\n\n#include \"xxhash.h\"\n" }, { "path": "deps/xxhash/xxhash.h", "content": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Header File\n * Copyright (C) 2012-2023 Yann Collet\n *\n * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following disclaimer\n * in the documentation and/or other materials provided with the\n * distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * You can contact the author at:\n * - xxHash homepage: https://www.xxhash.com\n * - xxHash source repository: https://github.com/Cyan4973/xxHash\n */\n\n/*!\n * @mainpage xxHash\n *\n * xxHash is an extremely fast non-cryptographic hash algorithm, working at RAM speed\n * limits.\n *\n * It is proposed in four flavors, in three families:\n * 1. @ref XXH32_family\n * - Classic 32-bit hash function. Simple, compact, and runs on almost all\n * 32-bit and 64-bit systems.\n * 2. @ref XXH64_family\n * - Classic 64-bit adaptation of XXH32. Just as simple, and runs well on most\n * 64-bit systems (but _not_ 32-bit systems).\n * 3. @ref XXH3_family\n * - Modern 64-bit and 128-bit hash function family which features improved\n * strength and performance across the board, especially on smaller data.\n * It benefits greatly from SIMD and 64-bit without requiring it.\n *\n * Benchmarks\n * ---\n * The reference system uses an Intel i7-9700K CPU, and runs Ubuntu x64 20.04.\n * The open source benchmark program is compiled with clang v10.0 using -O3 flag.\n *\n * | Hash Name | ISA ext | Width | Large Data Speed | Small Data Velocity |\n * | -------------------- | ------- | ----: | ---------------: | ------------------: |\n * | XXH3_64bits() | @b AVX2 | 64 | 59.4 GB/s | 133.1 |\n * | MeowHash | AES-NI | 128 | 58.2 GB/s | 52.5 |\n * | XXH3_128bits() | @b AVX2 | 128 | 57.9 GB/s | 118.1 |\n * | CLHash | PCLMUL | 64 | 37.1 GB/s | 58.1 |\n * | XXH3_64bits() | @b SSE2 | 64 | 31.5 GB/s | 133.1 |\n * | XXH3_128bits() | @b SSE2 | 128 | 29.6 GB/s | 118.1 |\n * | RAM sequential read | | N/A | 28.0 GB/s | N/A |\n * | ahash | AES-NI | 64 | 22.5 GB/s | 107.2 |\n * | City64 | | 64 | 22.0 GB/s | 76.6 |\n * | T1ha2 | | 64 | 22.0 GB/s | 99.0 |\n * | City128 | | 128 | 21.7 GB/s | 57.7 |\n * | FarmHash | AES-NI | 64 | 21.3 GB/s | 71.9 |\n * | XXH64() | | 64 | 19.4 GB/s | 71.0 |\n * | SpookyHash | | 64 | 19.3 GB/s | 53.2 |\n * | Mum | | 64 | 18.0 GB/s | 67.0 |\n * | CRC32C | SSE4.2 | 32 | 13.0 GB/s | 57.9 |\n * | XXH32() | | 32 | 9.7 GB/s | 71.9 |\n * | City32 | | 32 | 9.1 GB/s | 66.0 |\n * | Blake3* | @b AVX2 | 256 | 4.4 GB/s | 8.1 |\n * | Murmur3 | | 32 | 3.9 GB/s | 56.1 |\n * | SipHash* | | 64 | 3.0 GB/s | 43.2 |\n * | Blake3* | @b SSE2 | 256 | 2.4 GB/s | 8.1 |\n * | HighwayHash | | 64 | 1.4 GB/s | 6.0 |\n * | FNV64 | | 64 | 1.2 GB/s | 62.7 |\n * | Blake2* | | 256 | 1.1 GB/s | 5.1 |\n * | SHA1* | | 160 | 0.8 GB/s | 5.6 |\n * | MD5* | | 128 | 0.6 GB/s | 7.8 |\n * @note\n * - Hashes which require a specific ISA extension are noted. SSE2 is also noted,\n * even though it is mandatory on x64.\n * - Hashes with an asterisk are cryptographic. Note that MD5 is non-cryptographic\n * by modern standards.\n * - Small data velocity is a rough average of algorithm's efficiency for small\n * data. For more accurate information, see the wiki.\n * - More benchmarks and strength tests are found on the wiki:\n * https://github.com/Cyan4973/xxHash/wiki\n *\n * Usage\n * ------\n * All xxHash variants use a similar API. Changing the algorithm is a trivial\n * substitution.\n *\n * @pre\n * For functions which take an input and length parameter, the following\n * requirements are assumed:\n * - The range from [`input`, `input + length`) is valid, readable memory.\n * - The only exception is if the `length` is `0`, `input` may be `NULL`.\n * - For C++, the objects must have the *TriviallyCopyable* property, as the\n * functions access bytes directly as if it was an array of `unsigned char`.\n *\n * @anchor single_shot_example\n * **Single Shot**\n *\n * These functions are stateless functions which hash a contiguous block of memory,\n * immediately returning the result. They are the easiest and usually the fastest\n * option.\n *\n * XXH32(), XXH64(), XXH3_64bits(), XXH3_128bits()\n *\n * @code{.c}\n * #include \n * #include \"xxhash.h\"\n *\n * // Example for a function which hashes a null terminated string with XXH32().\n * XXH32_hash_t hash_string(const char* string, XXH32_hash_t seed)\n * {\n * // NULL pointers are only valid if the length is zero\n * size_t length = (string == NULL) ? 0 : strlen(string);\n * return XXH32(string, length, seed);\n * }\n * @endcode\n *\n *\n * @anchor streaming_example\n * **Streaming**\n *\n * These groups of functions allow incremental hashing of unknown size, even\n * more than what would fit in a size_t.\n *\n * XXH32_reset(), XXH64_reset(), XXH3_64bits_reset(), XXH3_128bits_reset()\n *\n * @code{.c}\n * #include \n * #include \n * #include \"xxhash.h\"\n * // Example for a function which hashes a FILE incrementally with XXH3_64bits().\n * XXH64_hash_t hashFile(FILE* f)\n * {\n * // Allocate a state struct. Do not just use malloc() or new.\n * XXH3_state_t* state = XXH3_createState();\n * assert(state != NULL && \"Out of memory!\");\n * // Reset the state to start a new hashing session.\n * XXH3_64bits_reset(state);\n * char buffer[4096];\n * size_t count;\n * // Read the file in chunks\n * while ((count = fread(buffer, 1, sizeof(buffer), f)) != 0) {\n * // Run update() as many times as necessary to process the data\n * XXH3_64bits_update(state, buffer, count);\n * }\n * // Retrieve the finalized hash. This will not change the state.\n * XXH64_hash_t result = XXH3_64bits_digest(state);\n * // Free the state. Do not use free().\n * XXH3_freeState(state);\n * return result;\n * }\n * @endcode\n *\n * Streaming functions generate the xxHash value from an incremental input.\n * This method is slower than single-call functions, due to state management.\n * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.\n *\n * An XXH state must first be allocated using `XXH*_createState()`.\n *\n * Start a new hash by initializing the state with a seed using `XXH*_reset()`.\n *\n * Then, feed the hash state by calling `XXH*_update()` as many times as necessary.\n *\n * The function returns an error code, with 0 meaning OK, and any other value\n * meaning there is an error.\n *\n * Finally, a hash value can be produced anytime, by using `XXH*_digest()`.\n * This function returns the nn-bits hash as an int or long long.\n *\n * It's still possible to continue inserting input into the hash state after a\n * digest, and generate new hash values later on by invoking `XXH*_digest()`.\n *\n * When done, release the state using `XXH*_freeState()`.\n *\n *\n * @anchor canonical_representation_example\n * **Canonical Representation**\n *\n * The default return values from XXH functions are unsigned 32, 64 and 128 bit\n * integers.\n * This the simplest and fastest format for further post-processing.\n *\n * However, this leaves open the question of what is the order on the byte level,\n * since little and big endian conventions will store the same number differently.\n *\n * The canonical representation settles this issue by mandating big-endian\n * convention, the same convention as human-readable numbers (large digits first).\n *\n * When writing hash values to storage, sending them over a network, or printing\n * them, it's highly recommended to use the canonical representation to ensure\n * portability across a wider range of systems, present and future.\n *\n * The following functions allow transformation of hash values to and from\n * canonical format.\n *\n * XXH32_canonicalFromHash(), XXH32_hashFromCanonical(),\n * XXH64_canonicalFromHash(), XXH64_hashFromCanonical(),\n * XXH128_canonicalFromHash(), XXH128_hashFromCanonical(),\n *\n * @code{.c}\n * #include \n * #include \"xxhash.h\"\n *\n * // Example for a function which prints XXH32_hash_t in human readable format\n * void printXxh32(XXH32_hash_t hash)\n * {\n * XXH32_canonical_t cano;\n * XXH32_canonicalFromHash(&cano, hash);\n * size_t i;\n * for(i = 0; i < sizeof(cano.digest); ++i) {\n * printf(\"%02x\", cano.digest[i]);\n * }\n * printf(\"\\n\");\n * }\n *\n * // Example for a function which converts XXH32_canonical_t to XXH32_hash_t\n * XXH32_hash_t convertCanonicalToXxh32(XXH32_canonical_t cano)\n * {\n * XXH32_hash_t hash = XXH32_hashFromCanonical(&cano);\n * return hash;\n * }\n * @endcode\n *\n *\n * @file xxhash.h\n * xxHash prototypes and implementation\n */\n\n#if defined(__cplusplus) && !defined(XXH_NO_EXTERNC_GUARD)\nextern \"C\" {\n#endif\n\n/* ****************************\n * INLINE mode\n ******************************/\n/*!\n * @defgroup public Public API\n * Contains details on the public xxHash functions.\n * @{\n */\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Gives access to internal state declaration, required for static allocation.\n *\n * Incompatible with dynamic linking, due to risks of ABI changes.\n *\n * Usage:\n * @code{.c}\n * #define XXH_STATIC_LINKING_ONLY\n * #include \"xxhash.h\"\n * @endcode\n */\n# define XXH_STATIC_LINKING_ONLY\n/* Do not undef XXH_STATIC_LINKING_ONLY for Doxygen */\n\n/*!\n * @brief Gives access to internal definitions.\n *\n * Usage:\n * @code{.c}\n * #define XXH_STATIC_LINKING_ONLY\n * #define XXH_IMPLEMENTATION\n * #include \"xxhash.h\"\n * @endcode\n */\n# define XXH_IMPLEMENTATION\n/* Do not undef XXH_IMPLEMENTATION for Doxygen */\n\n/*!\n * @brief Exposes the implementation and marks all functions as `inline`.\n *\n * Use these build macros to inline xxhash into the target unit.\n * Inlining improves performance on small inputs, especially when the length is\n * expressed as a compile-time constant:\n *\n * https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html\n *\n * It also keeps xxHash symbols private to the unit, so they are not exported.\n *\n * Usage:\n * @code{.c}\n * #define XXH_INLINE_ALL\n * #include \"xxhash.h\"\n * @endcode\n * Do not compile and link xxhash.o as a separate object, as it is not useful.\n */\n# define XXH_INLINE_ALL\n# undef XXH_INLINE_ALL\n/*!\n * @brief Exposes the implementation without marking functions as inline.\n */\n# define XXH_PRIVATE_API\n# undef XXH_PRIVATE_API\n/*!\n * @brief Emulate a namespace by transparently prefixing all symbols.\n *\n * If you want to include _and expose_ xxHash functions from within your own\n * library, but also want to avoid symbol collisions with other libraries which\n * may also include xxHash, you can use @ref XXH_NAMESPACE to automatically prefix\n * any public symbol from xxhash library with the value of @ref XXH_NAMESPACE\n * (therefore, avoid empty or numeric values).\n *\n * Note that no change is required within the calling program as long as it\n * includes `xxhash.h`: Regular symbol names will be automatically translated\n * by this header.\n */\n# define XXH_NAMESPACE /* YOUR NAME HERE */\n# undef XXH_NAMESPACE\n#endif\n\n#if (defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)) \\\n && !defined(XXH_INLINE_ALL_31684351384)\n /* this section should be traversed only once */\n# define XXH_INLINE_ALL_31684351384\n /* give access to the advanced API, required to compile implementations */\n# undef XXH_STATIC_LINKING_ONLY /* avoid macro redef */\n# define XXH_STATIC_LINKING_ONLY\n /* make all functions private */\n# undef XXH_PUBLIC_API\n# if defined(__GNUC__)\n# define XXH_PUBLIC_API static __inline __attribute__((__unused__))\n# elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n# define XXH_PUBLIC_API static inline\n# elif defined(_MSC_VER)\n# define XXH_PUBLIC_API static __inline\n# else\n /* note: this version may generate warnings for unused static functions */\n# define XXH_PUBLIC_API static\n# endif\n\n /*\n * This part deals with the special case where a unit wants to inline xxHash,\n * but \"xxhash.h\" has previously been included without XXH_INLINE_ALL,\n * such as part of some previously included *.h header file.\n * Without further action, the new include would just be ignored,\n * and functions would effectively _not_ be inlined (silent failure).\n * The following macros solve this situation by prefixing all inlined names,\n * avoiding naming collision with previous inclusions.\n */\n /* Before that, we unconditionally #undef all symbols,\n * in case they were already defined with XXH_NAMESPACE.\n * They will then be redefined for XXH_INLINE_ALL\n */\n# undef XXH_versionNumber\n /* XXH32 */\n# undef XXH32\n# undef XXH32_createState\n# undef XXH32_freeState\n# undef XXH32_reset\n# undef XXH32_update\n# undef XXH32_digest\n# undef XXH32_copyState\n# undef XXH32_canonicalFromHash\n# undef XXH32_hashFromCanonical\n /* XXH64 */\n# undef XXH64\n# undef XXH64_createState\n# undef XXH64_freeState\n# undef XXH64_reset\n# undef XXH64_update\n# undef XXH64_digest\n# undef XXH64_copyState\n# undef XXH64_canonicalFromHash\n# undef XXH64_hashFromCanonical\n /* XXH3_64bits */\n# undef XXH3_64bits\n# undef XXH3_64bits_withSecret\n# undef XXH3_64bits_withSeed\n# undef XXH3_64bits_withSecretandSeed\n# undef XXH3_createState\n# undef XXH3_freeState\n# undef XXH3_copyState\n# undef XXH3_64bits_reset\n# undef XXH3_64bits_reset_withSeed\n# undef XXH3_64bits_reset_withSecret\n# undef XXH3_64bits_update\n# undef XXH3_64bits_digest\n# undef XXH3_generateSecret\n /* XXH3_128bits */\n# undef XXH128\n# undef XXH3_128bits\n# undef XXH3_128bits_withSeed\n# undef XXH3_128bits_withSecret\n# undef XXH3_128bits_reset\n# undef XXH3_128bits_reset_withSeed\n# undef XXH3_128bits_reset_withSecret\n# undef XXH3_128bits_reset_withSecretandSeed\n# undef XXH3_128bits_update\n# undef XXH3_128bits_digest\n# undef XXH128_isEqual\n# undef XXH128_cmp\n# undef XXH128_canonicalFromHash\n# undef XXH128_hashFromCanonical\n /* Finally, free the namespace itself */\n# undef XXH_NAMESPACE\n\n /* employ the namespace for XXH_INLINE_ALL */\n# define XXH_NAMESPACE XXH_INLINE_\n /*\n * Some identifiers (enums, type names) are not symbols,\n * but they must nonetheless be renamed to avoid redeclaration.\n * Alternative solution: do not redeclare them.\n * However, this requires some #ifdefs, and has a more dispersed impact.\n * Meanwhile, renaming can be achieved in a single place.\n */\n# define XXH_IPREF(Id) XXH_NAMESPACE ## Id\n# define XXH_OK XXH_IPREF(XXH_OK)\n# define XXH_ERROR XXH_IPREF(XXH_ERROR)\n# define XXH_errorcode XXH_IPREF(XXH_errorcode)\n# define XXH32_canonical_t XXH_IPREF(XXH32_canonical_t)\n# define XXH64_canonical_t XXH_IPREF(XXH64_canonical_t)\n# define XXH128_canonical_t XXH_IPREF(XXH128_canonical_t)\n# define XXH32_state_s XXH_IPREF(XXH32_state_s)\n# define XXH32_state_t XXH_IPREF(XXH32_state_t)\n# define XXH64_state_s XXH_IPREF(XXH64_state_s)\n# define XXH64_state_t XXH_IPREF(XXH64_state_t)\n# define XXH3_state_s XXH_IPREF(XXH3_state_s)\n# define XXH3_state_t XXH_IPREF(XXH3_state_t)\n# define XXH128_hash_t XXH_IPREF(XXH128_hash_t)\n /* Ensure the header is parsed again, even if it was previously included */\n# undef XXHASH_H_5627135585666179\n# undef XXHASH_H_STATIC_13879238742\n#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */\n\n/* ****************************************************************\n * Stable API\n *****************************************************************/\n#ifndef XXHASH_H_5627135585666179\n#define XXHASH_H_5627135585666179 1\n\n/*! @brief Marks a global symbol. */\n#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)\n# if defined(_WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))\n# ifdef XXH_EXPORT\n# define XXH_PUBLIC_API __declspec(dllexport)\n# elif XXH_IMPORT\n# define XXH_PUBLIC_API __declspec(dllimport)\n# endif\n# else\n# define XXH_PUBLIC_API /* do nothing */\n# endif\n#endif\n\n#ifdef XXH_NAMESPACE\n# define XXH_CAT(A,B) A##B\n# define XXH_NAME2(A,B) XXH_CAT(A,B)\n# define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)\n/* XXH32 */\n# define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)\n# define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)\n# define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)\n# define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)\n# define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)\n# define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)\n# define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)\n# define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)\n# define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)\n/* XXH64 */\n# define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)\n# define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)\n# define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)\n# define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)\n# define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)\n# define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)\n# define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)\n# define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)\n# define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)\n/* XXH3_64bits */\n# define XXH3_64bits XXH_NAME2(XXH_NAMESPACE, XXH3_64bits)\n# define XXH3_64bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecret)\n# define XXH3_64bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSeed)\n# define XXH3_64bits_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecretandSeed)\n# define XXH3_createState XXH_NAME2(XXH_NAMESPACE, XXH3_createState)\n# define XXH3_freeState XXH_NAME2(XXH_NAMESPACE, XXH3_freeState)\n# define XXH3_copyState XXH_NAME2(XXH_NAMESPACE, XXH3_copyState)\n# define XXH3_64bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset)\n# define XXH3_64bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSeed)\n# define XXH3_64bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecret)\n# define XXH3_64bits_reset_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecretandSeed)\n# define XXH3_64bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_update)\n# define XXH3_64bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_digest)\n# define XXH3_generateSecret XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret)\n# define XXH3_generateSecret_fromSeed XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret_fromSeed)\n/* XXH3_128bits */\n# define XXH128 XXH_NAME2(XXH_NAMESPACE, XXH128)\n# define XXH3_128bits XXH_NAME2(XXH_NAMESPACE, XXH3_128bits)\n# define XXH3_128bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSeed)\n# define XXH3_128bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecret)\n# define XXH3_128bits_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecretandSeed)\n# define XXH3_128bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset)\n# define XXH3_128bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSeed)\n# define XXH3_128bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecret)\n# define XXH3_128bits_reset_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecretandSeed)\n# define XXH3_128bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_update)\n# define XXH3_128bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_digest)\n# define XXH128_isEqual XXH_NAME2(XXH_NAMESPACE, XXH128_isEqual)\n# define XXH128_cmp XXH_NAME2(XXH_NAMESPACE, XXH128_cmp)\n# define XXH128_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH128_canonicalFromHash)\n# define XXH128_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH128_hashFromCanonical)\n#endif\n\n\n/* *************************************\n* Compiler specifics\n***************************************/\n\n/* specific declaration modes for Windows */\n#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)\n# if defined(_WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))\n# ifdef XXH_EXPORT\n# define XXH_PUBLIC_API __declspec(dllexport)\n# elif XXH_IMPORT\n# define XXH_PUBLIC_API __declspec(dllimport)\n# endif\n# else\n# define XXH_PUBLIC_API /* do nothing */\n# endif\n#endif\n\n#if defined (__GNUC__)\n# define XXH_CONSTF __attribute__((__const__))\n# define XXH_PUREF __attribute__((__pure__))\n# define XXH_MALLOCF __attribute__((__malloc__))\n#else\n# define XXH_CONSTF /* disable */\n# define XXH_PUREF\n# define XXH_MALLOCF\n#endif\n\n/* *************************************\n* Version\n***************************************/\n#define XXH_VERSION_MAJOR 0\n#define XXH_VERSION_MINOR 8\n#define XXH_VERSION_RELEASE 3\n/*! @brief Version number, encoded as two digits each */\n#define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)\n\n/*!\n * @brief Obtains the xxHash version.\n *\n * This is mostly useful when xxHash is compiled as a shared library,\n * since the returned value comes from the library, as opposed to header file.\n *\n * @return @ref XXH_VERSION_NUMBER of the invoked library.\n */\nXXH_PUBLIC_API XXH_CONSTF unsigned XXH_versionNumber (void);\n\n\n/* ****************************\n* Common basic types\n******************************/\n#include /* size_t */\n/*!\n * @brief Exit code for the streaming API.\n */\ntypedef enum {\n XXH_OK = 0, /*!< OK */\n XXH_ERROR /*!< Error */\n} XXH_errorcode;\n\n\n/*-**********************************************************************\n* 32-bit hash\n************************************************************************/\n#if defined(XXH_DOXYGEN) /* Don't show include */\n/*!\n * @brief An unsigned 32-bit integer.\n *\n * Not necessarily defined to `uint32_t` but functionally equivalent.\n */\ntypedef uint32_t XXH32_hash_t;\n\n#elif !defined (__VMS) \\\n && (defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n# ifdef _AIX\n# include \n# else\n# include \n# endif\n typedef uint32_t XXH32_hash_t;\n\n#else\n# include \n# if UINT_MAX == 0xFFFFFFFFUL\n typedef unsigned int XXH32_hash_t;\n# elif ULONG_MAX == 0xFFFFFFFFUL\n typedef unsigned long XXH32_hash_t;\n# else\n# error \"unsupported platform: need a 32-bit type\"\n# endif\n#endif\n\n/*!\n * @}\n *\n * @defgroup XXH32_family XXH32 family\n * @ingroup public\n * Contains functions used in the classic 32-bit xxHash algorithm.\n *\n * @note\n * XXH32 is useful for older platforms, with no or poor 64-bit performance.\n * Note that the @ref XXH3_family provides competitive speed for both 32-bit\n * and 64-bit systems, and offers true 64/128 bit hash results.\n *\n * @see @ref XXH64_family, @ref XXH3_family : Other xxHash families\n * @see @ref XXH32_impl for implementation details\n * @{\n */\n\n/*!\n * @brief Calculates the 32-bit hash of @p input using xxHash32.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed The 32-bit seed to alter the hash's output predictably.\n *\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 32-bit xxHash32 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);\n\n#ifndef XXH_NO_STREAM\n/*!\n * @typedef struct XXH32_state_s XXH32_state_t\n * @brief The opaque state struct for the XXH32 streaming API.\n *\n * @see XXH32_state_s for details.\n * @see @ref streaming_example \"Streaming Example\"\n */\ntypedef struct XXH32_state_s XXH32_state_t;\n\n/*!\n * @brief Allocates an @ref XXH32_state_t.\n *\n * @return An allocated pointer of @ref XXH32_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH32_freeState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_MALLOCF XXH32_state_t* XXH32_createState(void);\n/*!\n * @brief Frees an @ref XXH32_state_t.\n *\n * @param statePtr A pointer to an @ref XXH32_state_t allocated with @ref XXH32_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note @p statePtr must be allocated with XXH32_createState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr);\n/*!\n * @brief Copies one @ref XXH32_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n * @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH32_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 32-bit seed to alter the hash result predictably.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note This function resets and seeds a state. Call it before @ref XXH32_update().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, XXH32_hash_t seed);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH32_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated hash value from an @ref XXH32_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return The calculated 32-bit xxHash32 value from that state.\n *\n * @note\n * Calling XXH32_digest() will not affect @p statePtr, so you can update,\n * digest, and update again.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/******* Canonical representation *******/\n\n/*!\n * @brief Canonical (big endian) representation of @ref XXH32_hash_t.\n */\ntypedef struct {\n unsigned char digest[4]; /*!< Hash bytes, big endian */\n} XXH32_canonical_t;\n\n/*!\n * @brief Converts an @ref XXH32_hash_t to a big endian @ref XXH32_canonical_t.\n *\n * @param dst The @ref XXH32_canonical_t pointer to be stored to.\n * @param hash The @ref XXH32_hash_t to be converted.\n *\n * @pre\n * @p dst must not be `NULL`.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH32_canonical_t to a native @ref XXH32_hash_t.\n *\n * @param src The @ref XXH32_canonical_t to convert.\n *\n * @pre\n * @p src must not be `NULL`.\n *\n * @return The converted hash.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);\n\n\n/*! @cond Doxygen ignores this part */\n#ifdef __has_attribute\n# define XXH_HAS_ATTRIBUTE(x) __has_attribute(x)\n#else\n# define XXH_HAS_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/* C-language Attributes are added in C23. */\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L) && defined(__has_c_attribute)\n# define XXH_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)\n#else\n# define XXH_HAS_C_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n#if defined(__cplusplus) && defined(__has_cpp_attribute)\n# define XXH_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n# define XXH_HAS_CPP_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/*\n * Define XXH_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute\n * introduced in CPP17 and C23.\n * CPP17 : https://en.cppreference.com/w/cpp/language/attributes/fallthrough\n * C23 : https://en.cppreference.com/w/c/language/attributes/fallthrough\n */\n#if XXH_HAS_C_ATTRIBUTE(fallthrough) || XXH_HAS_CPP_ATTRIBUTE(fallthrough)\n# define XXH_FALLTHROUGH [[fallthrough]]\n#elif XXH_HAS_ATTRIBUTE(__fallthrough__)\n# define XXH_FALLTHROUGH __attribute__ ((__fallthrough__))\n#else\n# define XXH_FALLTHROUGH /* fallthrough */\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/*\n * Define XXH_NOESCAPE for annotated pointers in public API.\n * https://clang.llvm.org/docs/AttributeReference.html#noescape\n * As of writing this, only supported by clang.\n */\n#if XXH_HAS_ATTRIBUTE(noescape)\n# define XXH_NOESCAPE __attribute__((__noescape__))\n#else\n# define XXH_NOESCAPE\n#endif\n/*! @endcond */\n\n\n/*!\n * @}\n * @ingroup public\n * @{\n */\n\n#ifndef XXH_NO_LONG_LONG\n/*-**********************************************************************\n* 64-bit hash\n************************************************************************/\n#if defined(XXH_DOXYGEN) /* don't include */\n/*!\n * @brief An unsigned 64-bit integer.\n *\n * Not necessarily defined to `uint64_t` but functionally equivalent.\n */\ntypedef uint64_t XXH64_hash_t;\n#elif !defined (__VMS) \\\n && (defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n# ifdef _AIX\n# include \n# else\n# include \n# endif\n typedef uint64_t XXH64_hash_t;\n#else\n# include \n# if defined(__LP64__) && ULONG_MAX == 0xFFFFFFFFFFFFFFFFULL\n /* LP64 ABI says uint64_t is unsigned long */\n typedef unsigned long XXH64_hash_t;\n# else\n /* the following type must have a width of 64-bit */\n typedef unsigned long long XXH64_hash_t;\n# endif\n#endif\n\n/*!\n * @}\n *\n * @defgroup XXH64_family XXH64 family\n * @ingroup public\n * @{\n * Contains functions used in the classic 64-bit xxHash algorithm.\n *\n * @note\n * XXH3 provides competitive speed for both 32-bit and 64-bit systems,\n * and offers true 64/128 bit hash results.\n * It provides better speed for systems with vector processing capabilities.\n */\n\n/*!\n * @brief Calculates the 64-bit hash of @p input using xxHash64.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed The 64-bit seed to alter the hash's output predictably.\n *\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit xxHash64 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);\n\n/******* Streaming *******/\n#ifndef XXH_NO_STREAM\n/*!\n * @brief The opaque state struct for the XXH64 streaming API.\n *\n * @see XXH64_state_s for details.\n * @see @ref streaming_example \"Streaming Example\"\n */\ntypedef struct XXH64_state_s XXH64_state_t; /* incomplete type */\n\n/*!\n * @brief Allocates an @ref XXH64_state_t.\n *\n * @return An allocated pointer of @ref XXH64_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH64_freeState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_MALLOCF XXH64_state_t* XXH64_createState(void);\n\n/*!\n * @brief Frees an @ref XXH64_state_t.\n *\n * @param statePtr A pointer to an @ref XXH64_state_t allocated with @ref XXH64_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note @p statePtr must be allocated with XXH64_createState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr);\n\n/*!\n * @brief Copies one @ref XXH64_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n * @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dst_state, const XXH64_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH64_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note This function resets and seeds a state. Call it before @ref XXH64_update().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH64_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH64_update (XXH_NOESCAPE XXH64_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated hash value from an @ref XXH64_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return The calculated 64-bit xxHash64 value from that state.\n *\n * @note\n * Calling XXH64_digest() will not affect @p statePtr, so you can update,\n * digest, and update again.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_digest (XXH_NOESCAPE const XXH64_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n/******* Canonical representation *******/\n\n/*!\n * @brief Canonical (big endian) representation of @ref XXH64_hash_t.\n */\ntypedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_canonical_t;\n\n/*!\n * @brief Converts an @ref XXH64_hash_t to a big endian @ref XXH64_canonical_t.\n *\n * @param dst The @ref XXH64_canonical_t pointer to be stored to.\n * @param hash The @ref XXH64_hash_t to be converted.\n *\n * @pre\n * @p dst must not be `NULL`.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH64_canonical_t to a native @ref XXH64_hash_t.\n *\n * @param src The @ref XXH64_canonical_t to convert.\n *\n * @pre\n * @p src must not be `NULL`.\n *\n * @return The converted hash.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src);\n\n#ifndef XXH_NO_XXH3\n\n/*!\n * @}\n * ************************************************************************\n * @defgroup XXH3_family XXH3 family\n * @ingroup public\n * @{\n *\n * XXH3 is a more recent hash algorithm featuring:\n * - Improved speed for both small and large inputs\n * - True 64-bit and 128-bit outputs\n * - SIMD acceleration\n * - Improved 32-bit viability\n *\n * Speed analysis methodology is explained here:\n *\n * https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html\n *\n * Compared to XXH64, expect XXH3 to run approximately\n * ~2x faster on large inputs and >3x faster on small ones,\n * exact differences vary depending on platform.\n *\n * XXH3's speed benefits greatly from SIMD and 64-bit arithmetic,\n * but does not require it.\n * Most 32-bit and 64-bit targets that can run XXH32 smoothly can run XXH3\n * at competitive speeds, even without vector support. Further details are\n * explained in the implementation.\n *\n * XXH3 has a fast scalar implementation, but it also includes accelerated SIMD\n * implementations for many common platforms:\n * - AVX512\n * - AVX2\n * - SSE2\n * - ARM NEON\n * - WebAssembly SIMD128\n * - POWER8 VSX\n * - s390x ZVector\n * This can be controlled via the @ref XXH_VECTOR macro, but it automatically\n * selects the best version according to predefined macros. For the x86 family, an\n * automatic runtime dispatcher is included separately in @ref xxh_x86dispatch.c.\n *\n * XXH3 implementation is portable:\n * it has a generic C90 formulation that can be compiled on any platform,\n * all implementations generate exactly the same hash value on all platforms.\n * Starting from v0.8.0, it's also labelled \"stable\", meaning that\n * any future version will also generate the same hash value.\n *\n * XXH3 offers 2 variants, _64bits and _128bits.\n *\n * When only 64 bits are needed, prefer invoking the _64bits variant, as it\n * reduces the amount of mixing, resulting in faster speed on small inputs.\n * It's also generally simpler to manipulate a scalar return type than a struct.\n *\n * The API supports one-shot hashing, streaming mode, and custom secrets.\n */\n\n/*!\n * @ingroup tuning\n * @brief Possible values for @ref XXH_VECTOR.\n *\n * Unless set explicitly, determined automatically.\n */\n# define XXH_SCALAR 0 /*!< Portable scalar version */\n# define XXH_SSE2 1 /*!< SSE2 for Pentium 4, Opteron, all x86_64. */\n# define XXH_AVX2 2 /*!< AVX2 for Haswell and Bulldozer */\n# define XXH_AVX512 3 /*!< AVX512 for Skylake and Icelake */\n# define XXH_NEON 4 /*!< NEON for most ARMv7-A, all AArch64, and WASM SIMD128 */\n# define XXH_VSX 5 /*!< VSX and ZVector for POWER8/z13 (64-bit) */\n# define XXH_SVE 6 /*!< SVE for some ARMv8-A and ARMv9-A */\n# define XXH_LSX 7 /*!< LSX (128-bit SIMD) for LoongArch64 */\n# define XXH_LASX 8 /*!< LASX (256-bit SIMD) for LoongArch64 */\n# define XXH_RVV 9 /*!< RVV (RISC-V Vector) for RISC-V */\n\n/*-**********************************************************************\n* XXH3 64-bit variant\n************************************************************************/\n\n/*!\n * @brief Calculates 64-bit unseeded variant of XXH3 hash of @p input.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @note\n * This is equivalent to @ref XXH3_64bits_withSeed() with a seed of `0`, however\n * it may have slightly better performance due to constant propagation of the\n * defaults.\n *\n * @see\n * XXH3_64bits_withSeed(), XXH3_64bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Calculates 64-bit seeded variant of XXH3 hash of @p input.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @note\n * seed == 0 produces the same results as @ref XXH3_64bits().\n *\n * This variant generates a custom secret on the fly based on default secret\n * altered using the @p seed value.\n *\n * While this operation is decently fast, note that it's not completely free.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);\n\n/*!\n * The bare minimum size for a custom secret.\n *\n * @see\n * XXH3_64bits_withSecret(), XXH3_64bits_reset_withSecret(),\n * XXH3_128bits_withSecret(), XXH3_128bits_reset_withSecret().\n */\n#define XXH3_SECRET_SIZE_MIN 136\n\n/*!\n * @brief Calculates 64-bit variant of XXH3 with a custom \"secret\".\n *\n * @param data The block of data to be hashed, at least @p len bytes in size.\n * @param len The length of @p data, in bytes.\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @pre\n * The memory between @p data and @p data + @p len must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p data may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * It's possible to provide any blob of bytes as a \"secret\" to generate the hash.\n * This makes it more difficult for an external actor to prepare an intentional collision.\n * The main condition is that @p secretSize *must* be large enough (>= @ref XXH3_SECRET_SIZE_MIN).\n * However, the quality of the secret impacts the dispersion of the hash algorithm.\n * Therefore, the secret _must_ look like a bunch of random bytes.\n * Avoid \"trivial\" or structured data such as repeated sequences or a text document.\n * Whenever in doubt about the \"randomness\" of the blob of bytes,\n * consider employing @ref XXH3_generateSecret() instead (see below).\n * It will generate a proper high entropy secret derived from the blob of bytes.\n * Another advantage of using XXH3_generateSecret() is that\n * it guarantees that all bits within the initial blob of bytes\n * will impact every bit of the output.\n * This is not necessarily the case when using the blob of bytes directly\n * because, when hashing _small_ inputs, only a portion of the secret is employed.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n\n/******* Streaming *******/\n#ifndef XXH_NO_STREAM\n/*\n * Streaming requires state maintenance.\n * This operation costs memory and CPU.\n * As a consequence, streaming is slower than one-shot hashing.\n * For better performance, prefer one-shot functions whenever applicable.\n */\n\n/*!\n * @brief The opaque state struct for the XXH3 streaming API.\n *\n * @see XXH3_state_s for details.\n * @see @ref streaming_example \"Streaming Example\"\n */\ntypedef struct XXH3_state_s XXH3_state_t;\nXXH_PUBLIC_API XXH_MALLOCF XXH3_state_t* XXH3_createState(void);\nXXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr);\n\n/*!\n * @brief Copies one @ref XXH3_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n * @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH3_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * - This function resets `statePtr` and generate a secret with default parameters.\n * - Call this function before @ref XXH3_64bits_update().\n * - Digest will be equivalent to `XXH3_64bits()`.\n *\n * @see @ref streaming_example \"Streaming Example\"\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * - This function resets `statePtr` and generate a secret from `seed`.\n * - Call this function before @ref XXH3_64bits_update().\n * - Digest will be equivalent to `XXH3_64bits_withSeed()`.\n *\n * @see @ref streaming_example \"Streaming Example\"\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * `secret` is referenced, it _must outlive_ the hash streaming session.\n *\n * Similar to one-shot API, `secretSize` must be >= @ref XXH3_SECRET_SIZE_MIN,\n * and the quality of produced hash values depends on secret's entropy\n * (secret's content should look like a bunch of random bytes).\n * When in doubt about the randomness of a candidate `secret`,\n * consider employing `XXH3_generateSecret()` instead (see below).\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n * @pre\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated XXH3 64-bit hash value from an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return The calculated XXH3 64-bit hash value from that state.\n *\n * @note\n * Calling XXH3_64bits_digest() will not affect @p statePtr, so you can update,\n * digest, and update again.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/* note : canonical representation of XXH3 is the same as XXH64\n * since they both produce XXH64_hash_t values */\n\n\n/*-**********************************************************************\n* XXH3 128-bit variant\n************************************************************************/\n\n/*!\n * @brief The return value from 128-bit hashes.\n *\n * Stored in little endian order, although the fields themselves are in native\n * endianness.\n */\ntypedef struct {\n XXH64_hash_t low64; /*!< `value & 0xFFFFFFFFFFFFFFFF` */\n XXH64_hash_t high64; /*!< `value >> 64` */\n} XXH128_hash_t;\n\n/*!\n * @brief Calculates 128-bit unseeded variant of XXH3 of @p data.\n *\n * @param data The block of data to be hashed, at least @p length bytes in size.\n * @param len The length of @p data, in bytes.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * The 128-bit variant of XXH3 has more strength, but it has a bit of overhead\n * for shorter inputs.\n *\n * This is equivalent to @ref XXH3_128bits_withSeed() with a seed of `0`, however\n * it may have slightly better performance due to constant propagation of the\n * defaults.\n *\n * @see XXH3_128bits_withSeed(), XXH3_128bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* data, size_t len);\n/*! @brief Calculates 128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param data The block of data to be hashed, at least @p length bytes in size.\n * @param len The length of @p data, in bytes.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * @note\n * seed == 0 produces the same results as @ref XXH3_64bits().\n *\n * This variant generates a custom secret on the fly based on default secret\n * altered using the @p seed value.\n *\n * While this operation is decently fast, note that it's not completely free.\n *\n * @see XXH3_128bits(), XXH3_128bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSeed(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);\n/*!\n * @brief Calculates 128-bit variant of XXH3 with a custom \"secret\".\n *\n * @param data The block of data to be hashed, at least @p len bytes in size.\n * @param len The length of @p data, in bytes.\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * It's possible to provide any blob of bytes as a \"secret\" to generate the hash.\n * This makes it more difficult for an external actor to prepare an intentional collision.\n * The main condition is that @p secretSize *must* be large enough (>= @ref XXH3_SECRET_SIZE_MIN).\n * However, the quality of the secret impacts the dispersion of the hash algorithm.\n * Therefore, the secret _must_ look like a bunch of random bytes.\n * Avoid \"trivial\" or structured data such as repeated sequences or a text document.\n * Whenever in doubt about the \"randomness\" of the blob of bytes,\n * consider employing @ref XXH3_generateSecret() instead (see below).\n * It will generate a proper high entropy secret derived from the blob of bytes.\n * Another advantage of using XXH3_generateSecret() is that\n * it guarantees that all bits within the initial blob of bytes\n * will impact every bit of the output.\n * This is not necessarily the case when using the blob of bytes directly\n * because, when hashing _small_ inputs, only a portion of the secret is employed.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/******* Streaming *******/\n#ifndef XXH_NO_STREAM\n/*\n * Streaming requires state maintenance.\n * This operation costs memory and CPU.\n * As a consequence, streaming is slower than one-shot hashing.\n * For better performance, prefer one-shot functions whenever applicable.\n *\n * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits().\n * Use already declared XXH3_createState() and XXH3_freeState().\n *\n * All reset and streaming functions have same meaning as their 64-bit counterpart.\n */\n\n/*!\n * @brief Resets an @ref XXH3_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * - This function resets `statePtr` and generate a secret with default parameters.\n * - Call it before @ref XXH3_128bits_update().\n * - Digest will be equivalent to `XXH3_128bits()`.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * - This function resets `statePtr` and generate a secret from `seed`.\n * - Call it before @ref XXH3_128bits_update().\n * - Digest will be equivalent to `XXH3_128bits_withSeed()`.\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * `secret` is referenced, it _must outlive_ the hash streaming session.\n * Similar to one-shot API, `secretSize` must be >= @ref XXH3_SECRET_SIZE_MIN,\n * and the quality of produced hash values depends on secret's entropy\n * (secret's content should look like a bunch of random bytes).\n * When in doubt about the randomness of a candidate `secret`,\n * consider employing `XXH3_generateSecret()` instead (see below).\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH3_state_t.\n *\n * Call this to incrementally consume blocks of data.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n * The memory between @p input and @p input + @p length must be valid,\n * readable, contiguous memory. However, if @p length is `0`, @p input may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated XXH3 128-bit hash value from an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n * @p statePtr must not be `NULL`.\n *\n * @return The calculated XXH3 128-bit hash value from that state.\n *\n * @note\n * Calling XXH3_128bits_digest() will not affect @p statePtr, so you can update,\n * digest, and update again.\n *\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/* Following helper functions make it possible to compare XXH128_hast_t values.\n * Since XXH128_hash_t is a structure, this capability is not offered by the language.\n * Note: For better performance, these functions can be inlined using XXH_INLINE_ALL */\n\n/*!\n * @brief Check equality of two XXH128_hash_t values\n *\n * @param h1 The 128-bit hash value.\n * @param h2 Another 128-bit hash value.\n *\n * @return `1` if `h1` and `h2` are equal.\n * @return `0` if they are not.\n */\nXXH_PUBLIC_API XXH_PUREF int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);\n\n/*!\n * @brief Compares two @ref XXH128_hash_t\n *\n * This comparator is compatible with stdlib's `qsort()`/`bsearch()`.\n *\n * @param h128_1 Left-hand side value\n * @param h128_2 Right-hand side value\n *\n * @return >0 if @p h128_1 > @p h128_2\n * @return =0 if @p h128_1 == @p h128_2\n * @return <0 if @p h128_1 < @p h128_2\n */\nXXH_PUBLIC_API XXH_PUREF int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2);\n\n\n/******* Canonical representation *******/\ntypedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_canonical_t;\n\n\n/*!\n * @brief Converts an @ref XXH128_hash_t to a big endian @ref XXH128_canonical_t.\n *\n * @param dst The @ref XXH128_canonical_t pointer to be stored to.\n * @param hash The @ref XXH128_hash_t to be converted.\n *\n * @pre\n * @p dst must not be `NULL`.\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH128_canonical_t to a native @ref XXH128_hash_t.\n *\n * @param src The @ref XXH128_canonical_t to convert.\n *\n * @pre\n * @p src must not be `NULL`.\n *\n * @return The converted hash.\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src);\n\n\n#endif /* !XXH_NO_XXH3 */\n#endif /* XXH_NO_LONG_LONG */\n\n/*!\n * @}\n */\n#endif /* XXHASH_H_5627135585666179 */\n\n\n\n#if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742)\n#define XXHASH_H_STATIC_13879238742\n/* ****************************************************************************\n * This section contains declarations which are not guaranteed to remain stable.\n * They may change in future versions, becoming incompatible with a different\n * version of the library.\n * These declarations should only be used with static linking.\n * Never use them in association with dynamic linking!\n ***************************************************************************** */\n\n/*\n * These definitions are only present to allow static allocation\n * of XXH states, on stack or in a struct, for example.\n * Never **ever** access their members directly.\n */\n\n/*!\n * @internal\n * @brief Structure for XXH32 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is\n * an opaque type. This allows fields to safely be changed.\n *\n * Typedef'd to @ref XXH32_state_t.\n * Do not access the members of this struct directly.\n * @see XXH64_state_s, XXH3_state_s\n */\nstruct XXH32_state_s {\n XXH32_hash_t total_len_32; /*!< Total length hashed, modulo 2^32 */\n XXH32_hash_t large_len; /*!< Whether the hash is >= 16 (handles @ref total_len_32 overflow) */\n XXH32_hash_t acc[4]; /*!< Accumulator lanes */\n unsigned char buffer[16]; /*!< Internal buffer for partial reads. */\n XXH32_hash_t bufferedSize; /*!< Amount of data in @ref buffer */\n XXH32_hash_t reserved; /*!< Reserved field. Do not read nor write to it. */\n}; /* typedef'd to XXH32_state_t */\n\n\n#ifndef XXH_NO_LONG_LONG /* defined when there is no 64-bit support */\n\n/*!\n * @internal\n * @brief Structure for XXH64 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is\n * an opaque type. This allows fields to safely be changed.\n *\n * Typedef'd to @ref XXH64_state_t.\n * Do not access the members of this struct directly.\n * @see XXH32_state_s, XXH3_state_s\n */\nstruct XXH64_state_s {\n XXH64_hash_t total_len; /*!< Total length hashed. This is always 64-bit. */\n XXH64_hash_t acc[4]; /*!< Accumulator lanes */\n unsigned char buffer[32]; /*!< Internal buffer for partial reads.. */\n XXH32_hash_t bufferedSize; /*!< Amount of data in @ref buffer */\n XXH32_hash_t reserved32; /*!< Reserved field, needed for padding anyways*/\n XXH64_hash_t reserved64; /*!< Reserved field. Do not read or write to it. */\n}; /* typedef'd to XXH64_state_t */\n\n#ifndef XXH_NO_XXH3\n\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* >= C11 */\n# define XXH_ALIGN(n) _Alignas(n)\n#elif defined(__cplusplus) && (__cplusplus >= 201103L) /* >= C++11 */\n/* In C++ alignas() is a keyword */\n# define XXH_ALIGN(n) alignas(n)\n#elif defined(__GNUC__)\n# define XXH_ALIGN(n) __attribute__ ((aligned(n)))\n#elif defined(_MSC_VER)\n# define XXH_ALIGN(n) __declspec(align(n))\n#else\n# define XXH_ALIGN(n) /* disabled */\n#endif\n\n/* Old GCC versions only accept the attribute after the type in structures. */\n#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) /* C11+ */ \\\n && ! (defined(__cplusplus) && (__cplusplus >= 201103L)) /* >= C++11 */ \\\n && defined(__GNUC__)\n# define XXH_ALIGN_MEMBER(align, type) type XXH_ALIGN(align)\n#else\n# define XXH_ALIGN_MEMBER(align, type) XXH_ALIGN(align) type\n#endif\n\n/*!\n * @internal\n * @brief The size of the internal XXH3 buffer.\n *\n * This is the optimal update size for incremental hashing.\n *\n * @see XXH3_64b_update(), XXH3_128b_update().\n */\n#define XXH3_INTERNALBUFFER_SIZE 256\n\n/*!\n * @def XXH3_SECRET_DEFAULT_SIZE\n * @brief Default Secret's size\n *\n * This is the size of internal XXH3_kSecret\n * and is needed by XXH3_generateSecret_fromSeed().\n *\n * Not to be confused with @ref XXH3_SECRET_SIZE_MIN.\n */\n#define XXH3_SECRET_DEFAULT_SIZE 192\n\n/*!\n * @internal\n * @brief Structure for XXH3 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined.\n * Otherwise it is an opaque type.\n * Never use this definition in combination with dynamic library.\n * This allows fields to safely be changed in the future.\n *\n * @note ** This structure has a strict alignment requirement of 64 bytes!! **\n * Do not allocate this with `malloc()` or `new`,\n * it will not be sufficiently aligned.\n * Use @ref XXH3_createState() and @ref XXH3_freeState(), or stack allocation.\n *\n * Typedef'd to @ref XXH3_state_t.\n * Do never access the members of this struct directly.\n *\n * @see XXH3_INITSTATE() for stack initialization.\n * @see XXH3_createState(), XXH3_freeState().\n * @see XXH32_state_s, XXH64_state_s\n */\nstruct XXH3_state_s {\n XXH_ALIGN_MEMBER(64, XXH64_hash_t acc[8]);\n /*!< The 8 accumulators. See @ref XXH32_state_s::acc and @ref XXH64_state_s::acc */\n XXH_ALIGN_MEMBER(64, unsigned char customSecret[XXH3_SECRET_DEFAULT_SIZE]);\n /*!< Used to store a custom secret generated from a seed. */\n XXH_ALIGN_MEMBER(64, unsigned char buffer[XXH3_INTERNALBUFFER_SIZE]);\n /*!< The internal buffer. @see XXH32_state_s::mem32 */\n XXH32_hash_t bufferedSize;\n /*!< The amount of memory in @ref buffer, @see XXH32_state_s::memsize */\n XXH32_hash_t useSeed;\n /*!< Reserved field. Needed for padding on 64-bit. */\n size_t nbStripesSoFar;\n /*!< Number or stripes processed. */\n XXH64_hash_t totalLen;\n /*!< Total length hashed. 64-bit even on 32-bit targets. */\n size_t nbStripesPerBlock;\n /*!< Number of stripes per block. */\n size_t secretLimit;\n /*!< Size of @ref customSecret or @ref extSecret */\n XXH64_hash_t seed;\n /*!< Seed for _withSeed variants. Must be zero otherwise, @see XXH3_INITSTATE() */\n XXH64_hash_t reserved64;\n /*!< Reserved field. */\n const unsigned char* extSecret;\n /*!< Reference to an external secret for the _withSecret variants, NULL\n * for other variants. */\n /* note: there may be some padding at the end due to alignment on 64 bytes */\n}; /* typedef'd to XXH3_state_t */\n\n#undef XXH_ALIGN_MEMBER\n\n/*!\n * @brief Initializes a stack-allocated `XXH3_state_s`.\n *\n * When the @ref XXH3_state_t structure is merely emplaced on stack,\n * it should be initialized with XXH3_INITSTATE() or a memset()\n * in case its first reset uses XXH3_NNbits_reset_withSeed().\n * This init can be omitted if the first reset uses default or _withSecret mode.\n * This operation isn't necessary when the state is created with XXH3_createState().\n * Note that this doesn't prepare the state for a streaming operation,\n * it's still necessary to use XXH3_NNbits_reset*() afterwards.\n */\n#define XXH3_INITSTATE(XXH3_state_ptr) \\\n do { \\\n XXH3_state_t* tmp_xxh3_state_ptr = (XXH3_state_ptr); \\\n tmp_xxh3_state_ptr->seed = 0; \\\n tmp_xxh3_state_ptr->extSecret = NULL; \\\n } while(0)\n\n\n/*!\n * @brief Calculates the 128-bit hash of @p data using XXH3.\n *\n * @param data The block of data to be hashed, at least @p len bytes in size.\n * @param len The length of @p data, in bytes.\n * @param seed The 64-bit seed to alter the hash's output predictably.\n *\n * @pre\n * The memory between @p data and @p data + @p len must be valid,\n * readable, contiguous memory. However, if @p len is `0`, @p data may be\n * `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 128-bit XXH3 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);\n\n\n/* === Experimental API === */\n/* Symbols defined below must be considered tied to a specific library version. */\n\n/*!\n * @brief Derive a high-entropy secret from any user-defined content, named customSeed.\n *\n * @param secretBuffer A writable buffer for derived high-entropy secret data.\n * @param secretSize Size of secretBuffer, in bytes. Must be >= XXH3_SECRET_SIZE_MIN.\n * @param customSeed A user-defined content.\n * @param customSeedSize Size of customSeed, in bytes.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * The generated secret can be used in combination with `*_withSecret()` functions.\n * The `_withSecret()` variants are useful to provide a higher level of protection\n * than 64-bit seed, as it becomes much more difficult for an external actor to\n * guess how to impact the calculation logic.\n *\n * The function accepts as input a custom seed of any length and any content,\n * and derives from it a high-entropy secret of length @p secretSize into an\n * already allocated buffer @p secretBuffer.\n *\n * The generated secret can then be used with any `*_withSecret()` variant.\n * The functions @ref XXH3_128bits_withSecret(), @ref XXH3_64bits_withSecret(),\n * @ref XXH3_128bits_reset_withSecret() and @ref XXH3_64bits_reset_withSecret()\n * are part of this list. They all accept a `secret` parameter\n * which must be large enough for implementation reasons (>= @ref XXH3_SECRET_SIZE_MIN)\n * _and_ feature very high entropy (consist of random-looking bytes).\n * These conditions can be a high bar to meet, so @ref XXH3_generateSecret() can\n * be employed to ensure proper quality.\n *\n * @p customSeed can be anything. It can have any size, even small ones,\n * and its content can be anything, even \"poor entropy\" sources such as a bunch\n * of zeroes. The resulting `secret` will nonetheless provide all required qualities.\n *\n * @pre\n * - @p secretSize must be >= @ref XXH3_SECRET_SIZE_MIN\n * - When @p customSeedSize > 0, supplying NULL as customSeed is undefined behavior.\n *\n * Example code:\n * @code{.c}\n * #include \n * #include \n * #include \n * #define XXH_STATIC_LINKING_ONLY // expose unstable API\n * #include \"xxhash.h\"\n * // Hashes argv[2] using the entropy from argv[1].\n * int main(int argc, char* argv[])\n * {\n * char secret[XXH3_SECRET_SIZE_MIN];\n * if (argv != 3) { return 1; }\n * XXH3_generateSecret(secret, sizeof(secret), argv[1], strlen(argv[1]));\n * XXH64_hash_t h = XXH3_64bits_withSecret(\n * argv[2], strlen(argv[2]),\n * secret, sizeof(secret)\n * );\n * printf(\"%016llx\\n\", (unsigned long long) h);\n * }\n * @endcode\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize);\n\n/*!\n * @brief Generate the same secret as the _withSeed() variants.\n *\n * @param secretBuffer A writable buffer of @ref XXH3_SECRET_DEFAULT_SIZE bytes\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * The generated secret can be used in combination with\n *`*_withSecret()` and `_withSecretandSeed()` variants.\n *\n * Example C++ `std::string` hash class:\n * @code{.cpp}\n * #include \n * #define XXH_STATIC_LINKING_ONLY // expose unstable API\n * #include \"xxhash.h\"\n * // Slow, seeds each time\n * class HashSlow {\n * XXH64_hash_t seed;\n * public:\n * HashSlow(XXH64_hash_t s) : seed{s} {}\n * size_t operator()(const std::string& x) const {\n * return size_t{XXH3_64bits_withSeed(x.c_str(), x.length(), seed)};\n * }\n * };\n * // Fast, caches the seeded secret for future uses.\n * class HashFast {\n * unsigned char secret[XXH3_SECRET_DEFAULT_SIZE];\n * public:\n * HashFast(XXH64_hash_t s) {\n * XXH3_generateSecret_fromSeed(secret, seed);\n * }\n * size_t operator()(const std::string& x) const {\n * return size_t{\n * XXH3_64bits_withSecret(x.c_str(), x.length(), secret, sizeof(secret))\n * };\n * }\n * };\n * @endcode\n */\nXXH_PUBLIC_API void XXH3_generateSecret_fromSeed(XXH_NOESCAPE void* secretBuffer, XXH64_hash_t seed);\n\n/*!\n * @brief Maximum size of \"short\" key in bytes.\n */\n#define XXH3_MIDSIZE_MAX 240\n\n/*!\n * @brief Calculates 64/128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param data The block of data to be hashed, at least @p len bytes in size.\n * @param len The length of @p data, in bytes.\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * These variants generate hash values using either:\n * - @p seed for \"short\" keys (< @ref XXH3_MIDSIZE_MAX = 240 bytes)\n * - @p secret for \"large\" keys (>= @ref XXH3_MIDSIZE_MAX).\n *\n * This generally benefits speed, compared to `_withSeed()` or `_withSecret()`.\n * `_withSeed()` has to generate the secret on the fly for \"large\" keys.\n * It's fast, but can be perceptible for \"not so large\" keys (< 1 KB).\n * `_withSecret()` has to generate the masks on the fly for \"small\" keys,\n * which requires more instructions than _withSeed() variants.\n * Therefore, _withSecretandSeed variant combines the best of both worlds.\n *\n * When @p secret has been generated by XXH3_generateSecret_fromSeed(),\n * this variant produces *exactly* the same results as `_withSeed()` variant,\n * hence offering only a pure speed benefit on \"large\" input,\n * by skipping the need to regenerate the secret for every large input.\n *\n * Another usage scenario is to hash the secret to a 64-bit hash value,\n * for example with XXH3_64bits(), which then becomes the seed,\n * and then employ both the seed and the secret in _withSecretandSeed().\n * On top of speed, an added benefit is that each bit in the secret\n * has a 50% chance to swap each bit in the output, via its impact to the seed.\n *\n * This is not guaranteed when using the secret directly in \"small data\" scenarios,\n * because only portions of the secret are employed for small data.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t\nXXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* data, size_t len,\n XXH_NOESCAPE const void* secret, size_t secretSize,\n XXH64_hash_t seed);\n\n/*!\n * @brief Calculates 128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param input The memory segment to be hashed, at least @p len bytes in size.\n * @param length The length of @p data, in bytes.\n * @param secret The secret used to alter hash result predictably.\n * @param secretSize The length of @p secret, in bytes (must be >= XXH3_SECRET_SIZE_MIN)\n * @param seed64 The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed(): contract is the same.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t\nXXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length,\n XXH_NOESCAPE const void* secret, size_t secretSize,\n XXH64_hash_t seed64);\n\n#ifndef XXH_NO_STREAM\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed64 The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed(). Contract is identical.\n */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,\n XXH_NOESCAPE const void* secret, size_t secretSize,\n XXH64_hash_t seed64);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n * @param secret The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed64 The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed(). Contract is identical.\n *\n * Note: there was a bug in an earlier version of this function (<= v0.8.2)\n * that would make it generate an incorrect hash value\n * when @p seed == 0 and @p length < XXH3_MIDSIZE_MAX\n * and @p secret is different from XXH3_generateSecret_fromSeed().\n * As stated in the contract, the correct hash result must be\n * the same as XXH3_128bits_withSeed() when @p length <= XXH3_MIDSIZE_MAX.\n * Results generated by this older version are wrong, hence not comparable.\n */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,\n XXH_NOESCAPE const void* secret, size_t secretSize,\n XXH64_hash_t seed64);\n\n#endif /* !XXH_NO_STREAM */\n\n#endif /* !XXH_NO_XXH3 */\n#endif /* XXH_NO_LONG_LONG */\n#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)\n# define XXH_IMPLEMENTATION\n#endif\n\n#endif /* defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742) */\n\n\n/* ======================================================================== */\n/* ======================================================================== */\n/* ======================================================================== */\n\n\n/*-**********************************************************************\n * xxHash implementation\n *-**********************************************************************\n * xxHash's implementation used to be hosted inside xxhash.c.\n *\n * However, inlining requires implementation to be visible to the compiler,\n * hence be included alongside the header.\n * Previously, implementation was hosted inside xxhash.c,\n * which was then #included when inlining was activated.\n * This construction created issues with a few build and install systems,\n * as it required xxhash.c to be stored in /include directory.\n *\n * xxHash implementation is now directly integrated within xxhash.h.\n * As a consequence, xxhash.c is no longer needed in /include.\n *\n * xxhash.c is still available and is still useful.\n * In a \"normal\" setup, when xxhash is not inlined,\n * xxhash.h only exposes the prototypes and public symbols,\n * while xxhash.c can be built into an object file xxhash.o\n * which can then be linked into the final binary.\n ************************************************************************/\n\n#if ( defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API) \\\n || defined(XXH_IMPLEMENTATION) ) && !defined(XXH_IMPLEM_13a8737387)\n# define XXH_IMPLEM_13a8737387\n\n/* *************************************\n* Tuning parameters\n***************************************/\n\n/*!\n * @defgroup tuning Tuning parameters\n * @{\n *\n * Various macros to control xxHash's behavior.\n */\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Define this to disable 64-bit code.\n *\n * Useful if only using the @ref XXH32_family and you have a strict C90 compiler.\n */\n# define XXH_NO_LONG_LONG\n# undef XXH_NO_LONG_LONG /* don't actually */\n/*!\n * @brief Controls how unaligned memory is accessed.\n *\n * By default, access to unaligned memory is controlled by `memcpy()`, which is\n * safe and portable.\n *\n * Unfortunately, on some target/compiler combinations, the generated assembly\n * is sub-optimal.\n *\n * The below switch allow selection of a different access method\n * in the search for improved performance.\n *\n * @par Possible options:\n *\n * - `XXH_FORCE_MEMORY_ACCESS=0` (default): `memcpy`\n * @par\n * Use `memcpy()`. Safe and portable. Note that most modern compilers will\n * eliminate the function call and treat it as an unaligned access.\n *\n * - `XXH_FORCE_MEMORY_ACCESS=1`: `__attribute__((aligned(1)))`\n * @par\n * Depends on compiler extensions and is therefore not portable.\n * This method is safe _if_ your compiler supports it,\n * and *generally* as fast or faster than `memcpy`.\n *\n * - `XXH_FORCE_MEMORY_ACCESS=2`: Direct cast\n * @par\n * Casts directly and dereferences. This method doesn't depend on the\n * compiler, but it violates the C standard as it directly dereferences an\n * unaligned pointer. It can generate buggy code on targets which do not\n * support unaligned memory accesses, but in some circumstances, it's the\n * only known way to get the most performance.\n *\n * - `XXH_FORCE_MEMORY_ACCESS=3`: Byteshift\n * @par\n * Also portable. This can generate the best code on old compilers which don't\n * inline small `memcpy()` calls, and it might also be faster on big-endian\n * systems which lack a native byteswap instruction. However, some compilers\n * will emit literal byteshifts even if the target supports unaligned access.\n *\n *\n * @warning\n * Methods 1 and 2 rely on implementation-defined behavior. Use these with\n * care, as what works on one compiler/platform/optimization level may cause\n * another to read garbage data or even crash.\n *\n * See https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.\n *\n * Prefer these methods in priority order (0 > 3 > 1 > 2)\n */\n# define XXH_FORCE_MEMORY_ACCESS 0\n\n/*!\n * @def XXH_SIZE_OPT\n * @brief Controls how much xxHash optimizes for size.\n *\n * xxHash, when compiled, tends to result in a rather large binary size. This\n * is mostly due to heavy usage to forced inlining and constant folding of the\n * @ref XXH3_family to increase performance.\n *\n * However, some developers prefer size over speed. This option can\n * significantly reduce the size of the generated code. When using the `-Os`\n * or `-Oz` options on GCC or Clang, this is defined to 1 by default,\n * otherwise it is defined to 0.\n *\n * Most of these size optimizations can be controlled manually.\n *\n * This is a number from 0-2.\n * - `XXH_SIZE_OPT` == 0: Default. xxHash makes no size optimizations. Speed\n * comes first.\n * - `XXH_SIZE_OPT` == 1: Default for `-Os` and `-Oz`. xxHash is more\n * conservative and disables hacks that increase code size. It implies the\n * options @ref XXH_NO_INLINE_HINTS == 1, @ref XXH_FORCE_ALIGN_CHECK == 0,\n * and @ref XXH3_NEON_LANES == 8 if they are not already defined.\n * - `XXH_SIZE_OPT` == 2: xxHash tries to make itself as small as possible.\n * Performance may cry. For example, the single shot functions just use the\n * streaming API.\n */\n# define XXH_SIZE_OPT 0\n\n/*!\n * @def XXH_FORCE_ALIGN_CHECK\n * @brief If defined to non-zero, adds a special path for aligned inputs (XXH32()\n * and XXH64() only).\n *\n * This is an important performance trick for architectures without decent\n * unaligned memory access performance.\n *\n * It checks for input alignment, and when conditions are met, uses a \"fast\n * path\" employing direct 32-bit/64-bit reads, resulting in _dramatically\n * faster_ read speed.\n *\n * The check costs one initial branch per hash, which is generally negligible,\n * but not zero.\n *\n * Moreover, it's not useful to generate an additional code path if memory\n * access uses the same instruction for both aligned and unaligned\n * addresses (e.g. x86 and aarch64).\n *\n * In these cases, the alignment check can be removed by setting this macro to 0.\n * Then the code will always use unaligned memory access.\n * Align check is automatically disabled on x86, x64, ARM64, and some ARM chips\n * which are platforms known to offer good unaligned memory accesses performance.\n *\n * It is also disabled by default when @ref XXH_SIZE_OPT >= 1.\n *\n * This option does not affect XXH3 (only XXH32 and XXH64).\n */\n# define XXH_FORCE_ALIGN_CHECK 0\n\n/*!\n * @def XXH_NO_INLINE_HINTS\n * @brief When non-zero, sets all functions to `static`.\n *\n * By default, xxHash tries to force the compiler to inline almost all internal\n * functions.\n *\n * This can usually improve performance due to reduced jumping and improved\n * constant folding, but significantly increases the size of the binary which\n * might not be favorable.\n *\n * Additionally, sometimes the forced inlining can be detrimental to performance,\n * depending on the architecture.\n *\n * XXH_NO_INLINE_HINTS marks all internal functions as static, giving the\n * compiler full control on whether to inline or not.\n *\n * When not optimizing (-O0), using `-fno-inline` with GCC or Clang, or if\n * @ref XXH_SIZE_OPT >= 1, this will automatically be defined.\n */\n# define XXH_NO_INLINE_HINTS 0\n\n/*!\n * @def XXH3_INLINE_SECRET\n * @brief Determines whether to inline the XXH3 withSecret code.\n *\n * When the secret size is known, the compiler can improve the performance\n * of XXH3_64bits_withSecret() and XXH3_128bits_withSecret().\n *\n * However, if the secret size is not known, it doesn't have any benefit. This\n * happens when xxHash is compiled into a global symbol. Therefore, if\n * @ref XXH_INLINE_ALL is *not* defined, this will be defined to 0.\n *\n * Additionally, this defaults to 0 on GCC 12+, which has an issue with function pointers\n * that are *sometimes* force inline on -Og, and it is impossible to automatically\n * detect this optimization level.\n */\n# define XXH3_INLINE_SECRET 0\n\n/*!\n * @def XXH32_ENDJMP\n * @brief Whether to use a jump for `XXH32_finalize`.\n *\n * For performance, `XXH32_finalize` uses multiple branches in the finalizer.\n * This is generally preferable for performance,\n * but depending on exact architecture, a jmp may be preferable.\n *\n * This setting is only possibly making a difference for very small inputs.\n */\n# define XXH32_ENDJMP 0\n\n/*!\n * @internal\n * @brief Redefines old internal names.\n *\n * For compatibility with code that uses xxHash's internals before the names\n * were changed to improve namespacing. There is no other reason to use this.\n */\n# define XXH_OLD_NAMES\n# undef XXH_OLD_NAMES /* don't actually use, it is ugly. */\n\n/*!\n * @def XXH_NO_STREAM\n * @brief Disables the streaming API.\n *\n * When xxHash is not inlined and the streaming functions are not used, disabling\n * the streaming functions can improve code size significantly, especially with\n * the @ref XXH3_family which tends to make constant folded copies of itself.\n */\n# define XXH_NO_STREAM\n# undef XXH_NO_STREAM /* don't actually */\n#endif /* XXH_DOXYGEN */\n/*!\n * @}\n */\n\n#ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */\n /* prefer __packed__ structures (method 1) for GCC\n * < ARMv7 with unaligned access (e.g. Raspbian armhf) still uses byte shifting, so we use memcpy\n * which for some reason does unaligned loads. */\n# if defined(__GNUC__) && !(defined(__ARM_ARCH) && __ARM_ARCH < 7 && defined(__ARM_FEATURE_UNALIGNED))\n# define XXH_FORCE_MEMORY_ACCESS 1\n# endif\n#endif\n\n#ifndef XXH_SIZE_OPT\n /* default to 1 for -Os or -Oz */\n# if (defined(__GNUC__) || defined(__clang__)) && defined(__OPTIMIZE_SIZE__)\n# define XXH_SIZE_OPT 1\n# else\n# define XXH_SIZE_OPT 0\n# endif\n#endif\n\n#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */\n /* don't check on sizeopt, x86, aarch64, or arm when unaligned access is available */\n# if XXH_SIZE_OPT >= 1 || \\\n defined(__i386) || defined(__x86_64__) || defined(__aarch64__) || defined(__ARM_FEATURE_UNALIGNED) \\\n || defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64) || defined(_M_ARM) /* visual */\n# define XXH_FORCE_ALIGN_CHECK 0\n# else\n# define XXH_FORCE_ALIGN_CHECK 1\n# endif\n#endif\n\n#ifndef XXH_NO_INLINE_HINTS\n# if XXH_SIZE_OPT >= 1 || defined(__NO_INLINE__) /* -O0, -fno-inline */\n# define XXH_NO_INLINE_HINTS 1\n# else\n# define XXH_NO_INLINE_HINTS 0\n# endif\n#endif\n\n#ifndef XXH3_INLINE_SECRET\n# if (defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 12) \\\n || !defined(XXH_INLINE_ALL)\n# define XXH3_INLINE_SECRET 0\n# else\n# define XXH3_INLINE_SECRET 1\n# endif\n#endif\n\n#ifndef XXH32_ENDJMP\n/* generally preferable for performance */\n# define XXH32_ENDJMP 0\n#endif\n\n/*!\n * @defgroup impl Implementation\n * @{\n */\n\n\n/* *************************************\n* Includes & Memory related functions\n***************************************/\n#if defined(XXH_NO_STREAM)\n/* nothing */\n#elif defined(XXH_NO_STDLIB)\n\n/* When requesting to disable any mention of stdlib,\n * the library loses the ability to invoked malloc / free.\n * In practice, it means that functions like `XXH*_createState()`\n * will always fail, and return NULL.\n * This flag is useful in situations where\n * xxhash.h is integrated into some kernel, embedded or limited environment\n * without access to dynamic allocation.\n */\n\nstatic XXH_CONSTF void* XXH_malloc(size_t s) { (void)s; return NULL; }\nstatic void XXH_free(void* p) { (void)p; }\n\n#else\n\n/*\n * Modify the local functions below should you wish to use\n * different memory routines for malloc() and free()\n */\n#include \n\n/*!\n * @internal\n * @brief Modify this function to use a different routine than malloc().\n */\nstatic XXH_MALLOCF void* XXH_malloc(size_t s) { return malloc(s); }\n\n/*!\n * @internal\n * @brief Modify this function to use a different routine than free().\n */\nstatic void XXH_free(void* p) { free(p); }\n\n#endif /* XXH_NO_STDLIB */\n\n#ifndef XXH_memcpy\n/*!\n * @internal\n * @brief XXH_memcpy() macro can be redirected at compile time\n */\n# include \n# define XXH_memcpy memcpy\n#endif\n\n#ifndef XXH_memset\n/*!\n * @internal\n * @brief XXH_memset() macro can be redirected at compile time\n */\n# include \n# define XXH_memset memset\n#endif\n\n#ifndef XXH_memcmp\n/*!\n * @internal\n * @brief XXH_memcmp() macro can be redirected at compile time\n * Note: only needed by XXH128.\n */\n# include \n# define XXH_memcmp memcmp\n#endif\n\n\n\n#include /* ULLONG_MAX */\n\n\n/* *************************************\n* Compiler Specific Options\n***************************************/\n#ifdef _MSC_VER /* Visual Studio warning fix */\n# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */\n#endif\n\n#if XXH_NO_INLINE_HINTS /* disable inlining hints */\n# if defined(__GNUC__) || defined(__clang__)\n# define XXH_FORCE_INLINE static __attribute__((__unused__))\n# else\n# define XXH_FORCE_INLINE static\n# endif\n# define XXH_NO_INLINE static\n/* enable inlining hints */\n#elif defined(__GNUC__) || defined(__clang__)\n# define XXH_FORCE_INLINE static __inline__ __attribute__((__always_inline__, __unused__))\n# define XXH_NO_INLINE static __attribute__((__noinline__))\n#elif defined(_MSC_VER) /* Visual Studio */\n# define XXH_FORCE_INLINE static __forceinline\n# define XXH_NO_INLINE static __declspec(noinline)\n#elif defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) /* C99 */\n# define XXH_FORCE_INLINE static inline\n# define XXH_NO_INLINE static\n#else\n# define XXH_FORCE_INLINE static\n# define XXH_NO_INLINE static\n#endif\n\n#if defined(XXH_INLINE_ALL)\n# define XXH_STATIC XXH_FORCE_INLINE\n#else\n# define XXH_STATIC static\n#endif\n\n#if XXH3_INLINE_SECRET\n# define XXH3_WITH_SECRET_INLINE XXH_FORCE_INLINE\n#else\n# define XXH3_WITH_SECRET_INLINE XXH_NO_INLINE\n#endif\n\n#if ((defined(sun) || defined(__sun)) && __cplusplus) /* Solaris includes __STDC_VERSION__ with C++. Tested with GCC 5.5 */\n# define XXH_RESTRICT /* disable */\n#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* >= C99 */\n# define XXH_RESTRICT restrict\n#elif (defined (__GNUC__) && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))) \\\n || (defined (__clang__)) \\\n || (defined (_MSC_VER) && (_MSC_VER >= 1400)) \\\n || (defined (__INTEL_COMPILER) && (__INTEL_COMPILER >= 1300))\n/*\n * There are a LOT more compilers that recognize __restrict but this\n * covers the major ones.\n */\n# define XXH_RESTRICT __restrict\n#else\n# define XXH_RESTRICT /* disable */\n#endif\n\n/* *************************************\n* Debug\n***************************************/\n/*!\n * @ingroup tuning\n * @def XXH_DEBUGLEVEL\n * @brief Sets the debugging level.\n *\n * XXH_DEBUGLEVEL is expected to be defined externally, typically via the\n * compiler's command line options. The value must be a number.\n */\n#ifndef XXH_DEBUGLEVEL\n# ifdef DEBUGLEVEL /* backwards compat */\n# define XXH_DEBUGLEVEL DEBUGLEVEL\n# else\n# define XXH_DEBUGLEVEL 0\n# endif\n#endif\n\n#if (XXH_DEBUGLEVEL>=1)\n# include /* note: can still be disabled with NDEBUG */\n# define XXH_ASSERT(c) assert(c)\n#else\n# if defined(__INTEL_COMPILER)\n# define XXH_ASSERT(c) XXH_ASSUME((unsigned char) (c))\n# else\n# define XXH_ASSERT(c) XXH_ASSUME(c)\n# endif\n#endif\n\n/* note: use after variable declarations */\n#ifndef XXH_STATIC_ASSERT\n# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* C11 */\n# define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { _Static_assert((c),m); } while(0)\n# elif defined(__cplusplus) && (__cplusplus >= 201103L) /* C++11 */\n# define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { static_assert((c),m); } while(0)\n# else\n# define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { struct xxh_sa { char x[(c) ? 1 : -1]; }; } while(0)\n# endif\n# define XXH_STATIC_ASSERT(c) XXH_STATIC_ASSERT_WITH_MESSAGE((c),#c)\n#endif\n\n/*!\n * @internal\n * @def XXH_COMPILER_GUARD(var)\n * @brief Used to prevent unwanted optimizations for @p var.\n *\n * It uses an empty GCC inline assembly statement with a register constraint\n * which forces @p var into a general purpose register (eg eax, ebx, ecx\n * on x86) and marks it as modified.\n *\n * This is used in a few places to avoid unwanted autovectorization (e.g.\n * XXH32_round()). All vectorization we want is explicit via intrinsics,\n * and _usually_ isn't wanted elsewhere.\n *\n * We also use it to prevent unwanted constant folding for AArch64 in\n * XXH3_initCustomSecret_scalar().\n */\n#if defined(__GNUC__) || defined(__clang__)\n# define XXH_COMPILER_GUARD(var) __asm__(\"\" : \"+r\" (var))\n#else\n# define XXH_COMPILER_GUARD(var) ((void)0)\n#endif\n\n/* Specifically for NEON vectors which use the \"w\" constraint, on\n * Clang. */\n#if defined(__clang__) && defined(__ARM_ARCH) && !defined(__wasm__)\n# define XXH_COMPILER_GUARD_CLANG_NEON(var) __asm__(\"\" : \"+w\" (var))\n#else\n# define XXH_COMPILER_GUARD_CLANG_NEON(var) ((void)0)\n#endif\n\n/* *************************************\n* Basic Types\n***************************************/\n#if !defined (__VMS) \\\n && (defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n# ifdef _AIX\n# include \n# else\n# include \n# endif\n typedef uint8_t xxh_u8;\n#else\n typedef unsigned char xxh_u8;\n#endif\ntypedef XXH32_hash_t xxh_u32;\n\n#ifdef XXH_OLD_NAMES\n# warning \"XXH_OLD_NAMES is planned to be removed starting v0.9. If the program depends on it, consider moving away from it by employing newer type names directly\"\n# define BYTE xxh_u8\n# define U8 xxh_u8\n# define U32 xxh_u32\n#endif\n\n/* *** Memory access *** */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_read32(const void* ptr)\n * @brief Reads an unaligned 32-bit integer from @p ptr in native endianness.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit native endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readLE32(const void* ptr)\n * @brief Reads an unaligned 32-bit little endian integer from @p ptr.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit little endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readBE32(const void* ptr)\n * @brief Reads an unaligned 32-bit big endian integer from @p ptr.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit big endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readLE32_align(const void* ptr, XXH_alignment align)\n * @brief Like @ref XXH_readLE32(), but has an option for aligned reads.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n * Note that when @ref XXH_FORCE_ALIGN_CHECK == 0, the @p align parameter is\n * always @ref XXH_alignment::XXH_unaligned.\n *\n * @param ptr The pointer to read from.\n * @param align Whether @p ptr is aligned.\n * @pre\n * If @p align == @ref XXH_alignment::XXH_aligned, @p ptr must be 4 byte\n * aligned.\n * @return The 32-bit little endian integer from the bytes at @p ptr.\n */\n\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n/*\n * Manual byteshift. Best for old compilers which don't inline memcpy.\n * We actually directly use XXH_readLE32 and XXH_readBE32.\n */\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))\n\n/*\n * Force direct memory access. Only works on CPU which support unaligned memory\n * access in hardware.\n */\nstatic xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*) memPtr; }\n\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))\n\n/*\n * __attribute__((aligned(1))) is supported by gcc and clang. Originally the\n * documentation claimed that it only increased the alignment, but actually it\n * can decrease it on gcc, clang, and icc:\n * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,\n * https://gcc.godbolt.org/z/xYez1j67Y.\n */\n#ifdef XXH_OLD_NAMES\ntypedef union { xxh_u32 u32; } __attribute__((__packed__)) unalign;\n#endif\nstatic xxh_u32 XXH_read32(const void* ptr)\n{\n typedef __attribute__((__aligned__(1))) __attribute__((__may_alias__)) xxh_u32 xxh_unalign32;\n return *((const xxh_unalign32*)ptr);\n}\n\n#else\n\n/*\n * Portable and safe solution. Generally efficient.\n * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html\n */\nstatic xxh_u32 XXH_read32(const void* memPtr)\n{\n xxh_u32 val;\n XXH_memcpy(&val, memPtr, sizeof(val));\n return val;\n}\n\n#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */\n\n\n/* *** Endianness *** */\n\n/*!\n * @ingroup tuning\n * @def XXH_CPU_LITTLE_ENDIAN\n * @brief Whether the target is little endian.\n *\n * Defined to 1 if the target is little endian, or 0 if it is big endian.\n * It can be defined externally, for example on the compiler command line.\n *\n * If it is not defined,\n * a runtime check (which is usually constant folded) is used instead.\n *\n * @note\n * This is not necessarily defined to an integer constant.\n *\n * @see XXH_isLittleEndian() for the runtime check.\n */\n#ifndef XXH_CPU_LITTLE_ENDIAN\n/*\n * Try to detect endianness automatically, to avoid the nonstandard behavior\n * in `XXH_isLittleEndian()`\n */\n# if defined(_WIN32) /* Windows is always little endian */ \\\n || defined(__LITTLE_ENDIAN__) \\\n || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n# define XXH_CPU_LITTLE_ENDIAN 1\n# elif defined(__BIG_ENDIAN__) \\\n || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n# define XXH_CPU_LITTLE_ENDIAN 0\n# else\n/*!\n * @internal\n * @brief Runtime check for @ref XXH_CPU_LITTLE_ENDIAN.\n *\n * Most compilers will constant fold this.\n */\nstatic int XXH_isLittleEndian(void)\n{\n /*\n * Portable and well-defined behavior.\n * Don't use static: it is detrimental to performance.\n */\n const union { xxh_u32 u; xxh_u8 c[4]; } one = { 1 };\n return one.c[0];\n}\n# define XXH_CPU_LITTLE_ENDIAN XXH_isLittleEndian()\n# endif\n#endif\n\n\n\n\n/* ****************************************\n* Compiler-specific Functions and Macros\n******************************************/\n#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)\n\n#ifdef __has_builtin\n# define XXH_HAS_BUILTIN(x) __has_builtin(x)\n#else\n# define XXH_HAS_BUILTIN(x) 0\n#endif\n\n\n\n/*\n * C23 and future versions have standard \"unreachable()\".\n * Once it has been implemented reliably we can add it as an\n * additional case:\n *\n * ```\n * #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L)\n * # include \n * # ifdef unreachable\n * # define XXH_UNREACHABLE() unreachable()\n * # endif\n * #endif\n * ```\n *\n * Note C++23 also has std::unreachable() which can be detected\n * as follows:\n * ```\n * #if defined(__cpp_lib_unreachable) && (__cpp_lib_unreachable >= 202202L)\n * # include \n * # define XXH_UNREACHABLE() std::unreachable()\n * #endif\n * ```\n * NB: `__cpp_lib_unreachable` is defined in the `` header.\n * We don't use that as including `` in `extern \"C\"` blocks\n * doesn't work on GCC12\n */\n\n#if XXH_HAS_BUILTIN(__builtin_unreachable)\n# define XXH_UNREACHABLE() __builtin_unreachable()\n\n#elif defined(_MSC_VER)\n# define XXH_UNREACHABLE() __assume(0)\n\n#else\n# define XXH_UNREACHABLE()\n#endif\n\n#if XXH_HAS_BUILTIN(__builtin_assume)\n# define XXH_ASSUME(c) __builtin_assume(c)\n#else\n# define XXH_ASSUME(c) if (!(c)) { XXH_UNREACHABLE(); }\n#endif\n\n/*!\n * @internal\n * @def XXH_rotl32(x,r)\n * @brief 32-bit rotate left.\n *\n * @param x The 32-bit integer to be rotated.\n * @param r The number of bits to rotate.\n * @pre\n * @p r > 0 && @p r < 32\n * @note\n * @p x and @p r may be evaluated multiple times.\n * @return The rotated result.\n */\n#if !defined(NO_CLANG_BUILTIN) && XXH_HAS_BUILTIN(__builtin_rotateleft32) \\\n && XXH_HAS_BUILTIN(__builtin_rotateleft64)\n# define XXH_rotl32 __builtin_rotateleft32\n# define XXH_rotl64 __builtin_rotateleft64\n#elif XXH_HAS_BUILTIN(__builtin_stdc_rotate_left)\n# define XXH_rotl32 __builtin_stdc_rotate_left\n# define XXH_rotl64 __builtin_stdc_rotate_left\n/* Note: although _rotl exists for minGW (GCC under windows), performance seems poor */\n#elif defined(_MSC_VER)\n# define XXH_rotl32(x,r) _rotl(x,r)\n# define XXH_rotl64(x,r) _rotl64(x,r)\n#else\n# define XXH_rotl32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))\n# define XXH_rotl64(x,r) (((x) << (r)) | ((x) >> (64 - (r))))\n#endif\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_swap32(xxh_u32 x)\n * @brief A 32-bit byteswap.\n *\n * @param x The 32-bit integer to byteswap.\n * @return @p x, byteswapped.\n */\n#if defined(_MSC_VER) /* Visual Studio */\n# define XXH_swap32 _byteswap_ulong\n#elif XXH_GCC_VERSION >= 403\n# define XXH_swap32 __builtin_bswap32\n#else\nstatic xxh_u32 XXH_swap32 (xxh_u32 x)\n{\n return ((x << 24) & 0xff000000 ) |\n ((x << 8) & 0x00ff0000 ) |\n ((x >> 8) & 0x0000ff00 ) |\n ((x >> 24) & 0x000000ff );\n}\n#endif\n\n\n/* ***************************\n* Memory reads\n*****************************/\n\n/*!\n * @internal\n * @brief Enum to indicate whether a pointer is aligned.\n */\ntypedef enum {\n XXH_aligned, /*!< Aligned */\n XXH_unaligned /*!< Possibly unaligned */\n} XXH_alignment;\n\n/*\n * XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load.\n *\n * This is ideal for older compilers which don't inline memcpy.\n */\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n\nXXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr)\n{\n const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n return bytePtr[0]\n | ((xxh_u32)bytePtr[1] << 8)\n | ((xxh_u32)bytePtr[2] << 16)\n | ((xxh_u32)bytePtr[3] << 24);\n}\n\nXXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr)\n{\n const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n return bytePtr[3]\n | ((xxh_u32)bytePtr[2] << 8)\n | ((xxh_u32)bytePtr[1] << 16)\n | ((xxh_u32)bytePtr[0] << 24);\n}\n\n#else\nXXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr)\n{\n return XXH_CPU_LITTLE_ENDIAN ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));\n}\n\nstatic xxh_u32 XXH_readBE32(const void* ptr)\n{\n return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);\n}\n#endif\n\nXXH_FORCE_INLINE xxh_u32\nXXH_readLE32_align(const void* ptr, XXH_alignment align)\n{\n if (align==XXH_unaligned) {\n return XXH_readLE32(ptr);\n } else {\n return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u32*)ptr : XXH_swap32(*(const xxh_u32*)ptr);\n }\n}\n\n\n/* *************************************\n* Misc\n***************************************/\n/*! @ingroup public */\nXXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }\n\n\n/* *******************************************************************\n* 32-bit hash functions\n*********************************************************************/\n/*!\n * @}\n * @defgroup XXH32_impl XXH32 implementation\n * @ingroup impl\n *\n * Details on the XXH32 implementation.\n * @{\n */\n /* #define instead of static const, to be used as initializers */\n#define XXH_PRIME32_1 0x9E3779B1U /*!< 0b10011110001101110111100110110001 */\n#define XXH_PRIME32_2 0x85EBCA77U /*!< 0b10000101111010111100101001110111 */\n#define XXH_PRIME32_3 0xC2B2AE3DU /*!< 0b11000010101100101010111000111101 */\n#define XXH_PRIME32_4 0x27D4EB2FU /*!< 0b00100111110101001110101100101111 */\n#define XXH_PRIME32_5 0x165667B1U /*!< 0b00010110010101100110011110110001 */\n\n#ifdef XXH_OLD_NAMES\n# define PRIME32_1 XXH_PRIME32_1\n# define PRIME32_2 XXH_PRIME32_2\n# define PRIME32_3 XXH_PRIME32_3\n# define PRIME32_4 XXH_PRIME32_4\n# define PRIME32_5 XXH_PRIME32_5\n#endif\n\n/*!\n * @internal\n * @brief Normal stripe processing routine.\n *\n * This shuffles the bits so that any bit from @p input impacts several bits in\n * @p acc.\n *\n * @param acc The accumulator lane.\n * @param input The stripe of input to mix.\n * @return The mixed accumulator lane.\n */\nstatic xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)\n{\n acc += input * XXH_PRIME32_2;\n acc = XXH_rotl32(acc, 13);\n acc *= XXH_PRIME32_1;\n#if (defined(__SSE4_1__) || defined(__aarch64__) || defined(__wasm_simd128__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)\n /*\n * UGLY HACK:\n * A compiler fence is used to prevent GCC and Clang from\n * autovectorizing the XXH32 loop (pragmas and attributes don't work for some\n * reason) without globally disabling SSE4.1.\n *\n * The reason we want to avoid vectorization is because despite working on\n * 4 integers at a time, there are multiple factors slowing XXH32 down on\n * SSE4:\n * - There's a ridiculous amount of lag from pmulld (10 cycles of latency on\n * newer chips!) making it slightly slower to multiply four integers at\n * once compared to four integers independently. Even when pmulld was\n * fastest, Sandy/Ivy Bridge, it is still not worth it to go into SSE\n * just to multiply unless doing a long operation.\n *\n * - Four instructions are required to rotate,\n * movqda tmp, v // not required with VEX encoding\n * pslld tmp, 13 // tmp <<= 13\n * psrld v, 19 // x >>= 19\n * por v, tmp // x |= tmp\n * compared to one for scalar:\n * roll v, 13 // reliably fast across the board\n * shldl v, v, 13 // Sandy Bridge and later prefer this for some reason\n *\n * - Instruction level parallelism is actually more beneficial here because\n * the SIMD actually serializes this operation: While v1 is rotating, v2\n * can load data, while v3 can multiply. SSE forces them to operate\n * together.\n *\n * This is also enabled on AArch64, as Clang is *very aggressive* in vectorizing\n * the loop. NEON is only faster on the A53, and with the newer cores, it is less\n * than half the speed.\n *\n * Additionally, this is used on WASM SIMD128 because it JITs to the same\n * SIMD instructions and has the same issue.\n */\n XXH_COMPILER_GUARD(acc);\n#endif\n return acc;\n}\n\n/*!\n * @internal\n * @brief Mixes all bits to finalize the hash.\n *\n * The final mix ensures that all input bits have a chance to impact any bit in\n * the output digest, resulting in an unbiased distribution.\n *\n * @param hash The hash to avalanche.\n * @return The avalanched hash.\n */\nstatic xxh_u32 XXH32_avalanche(xxh_u32 hash)\n{\n hash ^= hash >> 15;\n hash *= XXH_PRIME32_2;\n hash ^= hash >> 13;\n hash *= XXH_PRIME32_3;\n hash ^= hash >> 16;\n return hash;\n}\n\n#define XXH_get32bits(p) XXH_readLE32_align(p, align)\n\n/*!\n * @internal\n * @brief Sets up the initial accumulator state for XXH32().\n */\nXXH_FORCE_INLINE void\nXXH32_initAccs(xxh_u32 *acc, xxh_u32 seed)\n{\n XXH_ASSERT(acc != NULL);\n acc[0] = seed + XXH_PRIME32_1 + XXH_PRIME32_2;\n acc[1] = seed + XXH_PRIME32_2;\n acc[2] = seed + 0;\n acc[3] = seed - XXH_PRIME32_1;\n}\n\n/*!\n * @internal\n * @brief Consumes a block of data for XXH32().\n *\n * @return the end input pointer.\n */\nXXH_FORCE_INLINE const xxh_u8 *\nXXH32_consumeLong(\n xxh_u32 *XXH_RESTRICT acc,\n xxh_u8 const *XXH_RESTRICT input,\n size_t len,\n XXH_alignment align\n)\n{\n const xxh_u8* const bEnd = input + len;\n const xxh_u8* const limit = bEnd - 15;\n XXH_ASSERT(acc != NULL);\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(len >= 16);\n do {\n acc[0] = XXH32_round(acc[0], XXH_get32bits(input)); input += 4;\n acc[1] = XXH32_round(acc[1], XXH_get32bits(input)); input += 4;\n acc[2] = XXH32_round(acc[2], XXH_get32bits(input)); input += 4;\n acc[3] = XXH32_round(acc[3], XXH_get32bits(input)); input += 4;\n } while (input < limit);\n\n return input;\n}\n\n/*!\n * @internal\n * @brief Merges the accumulator lanes together for XXH32()\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u32\nXXH32_mergeAccs(const xxh_u32 *acc)\n{\n XXH_ASSERT(acc != NULL);\n return XXH_rotl32(acc[0], 1) + XXH_rotl32(acc[1], 7)\n + XXH_rotl32(acc[2], 12) + XXH_rotl32(acc[3], 18);\n}\n\n/*!\n * @internal\n * @brief Processes the last 0-15 bytes of @p ptr.\n *\n * There may be up to 15 bytes remaining to consume from the input.\n * This final stage will digest them to ensure that all input bytes are present\n * in the final mix.\n *\n * @param hash The hash to finalize.\n * @param ptr The pointer to the remaining input.\n * @param len The remaining length, modulo 16.\n * @param align Whether @p ptr is aligned.\n * @return The finalized hash.\n * @see XXH64_finalize().\n */\nstatic XXH_PUREF xxh_u32\nXXH32_finalize(xxh_u32 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)\n{\n#define XXH_PROCESS1 do { \\\n hash += (*ptr++) * XXH_PRIME32_5; \\\n hash = XXH_rotl32(hash, 11) * XXH_PRIME32_1; \\\n} while (0)\n\n#define XXH_PROCESS4 do { \\\n hash += XXH_get32bits(ptr) * XXH_PRIME32_3; \\\n ptr += 4; \\\n hash = XXH_rotl32(hash, 17) * XXH_PRIME32_4; \\\n} while (0)\n\n if (ptr==NULL) XXH_ASSERT(len == 0);\n\n /* Compact rerolled version; generally faster */\n if (!XXH32_ENDJMP) {\n len &= 15;\n while (len >= 4) {\n XXH_PROCESS4;\n len -= 4;\n }\n while (len > 0) {\n XXH_PROCESS1;\n --len;\n }\n return XXH32_avalanche(hash);\n } else {\n switch(len&15) /* or switch(bEnd - p) */ {\n case 12: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 8: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 4: XXH_PROCESS4;\n return XXH32_avalanche(hash);\n\n case 13: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 9: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 5: XXH_PROCESS4;\n XXH_PROCESS1;\n return XXH32_avalanche(hash);\n\n case 14: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 10: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 6: XXH_PROCESS4;\n XXH_PROCESS1;\n XXH_PROCESS1;\n return XXH32_avalanche(hash);\n\n case 15: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 11: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 7: XXH_PROCESS4;\n XXH_FALLTHROUGH; /* fallthrough */\n case 3: XXH_PROCESS1;\n XXH_FALLTHROUGH; /* fallthrough */\n case 2: XXH_PROCESS1;\n XXH_FALLTHROUGH; /* fallthrough */\n case 1: XXH_PROCESS1;\n XXH_FALLTHROUGH; /* fallthrough */\n case 0: return XXH32_avalanche(hash);\n }\n XXH_ASSERT(0);\n return hash; /* reaching this point is deemed impossible */\n }\n}\n\n#ifdef XXH_OLD_NAMES\n# define PROCESS1 XXH_PROCESS1\n# define PROCESS4 XXH_PROCESS4\n#else\n# undef XXH_PROCESS1\n# undef XXH_PROCESS4\n#endif\n\n/*!\n * @internal\n * @brief The implementation for @ref XXH32().\n *\n * @param input , len , seed Directly passed from @ref XXH32().\n * @param align Whether @p input is aligned.\n * @return The calculated hash.\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u32\nXXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align)\n{\n xxh_u32 h32;\n\n if (input==NULL) XXH_ASSERT(len == 0);\n\n if (len>=16) {\n xxh_u32 acc[4];\n XXH32_initAccs(acc, seed);\n\n input = XXH32_consumeLong(acc, input, len, align);\n\n h32 = XXH32_mergeAccs(acc);\n } else {\n h32 = seed + XXH_PRIME32_5;\n }\n\n h32 += (xxh_u32)len;\n\n return XXH32_finalize(h32, input, len&15, align);\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)\n{\n#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2\n /* Simple version, good for code maintenance, but unfortunately slow for small inputs */\n XXH32_state_t state;\n XXH32_reset(&state, seed);\n XXH32_update(&state, (const xxh_u8*)input, len);\n return XXH32_digest(&state);\n#else\n if (XXH_FORCE_ALIGN_CHECK) {\n if ((((size_t)input) & 3) == 0) { /* Input is 4-bytes aligned, leverage the speed benefit */\n return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);\n } }\n\n return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);\n#endif\n}\n\n\n\n/******* Hash streaming *******/\n#ifndef XXH_NO_STREAM\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)\n{\n return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));\n}\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)\n{\n XXH_free(statePtr);\n return XXH_OK;\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)\n{\n XXH_memcpy(dstState, srcState, sizeof(*dstState));\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed)\n{\n XXH_ASSERT(statePtr != NULL);\n XXH_memset(statePtr, 0, sizeof(*statePtr));\n XXH32_initAccs(statePtr->acc, seed);\n return XXH_OK;\n}\n\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH32_update(XXH32_state_t* state, const void* input, size_t len)\n{\n if (input==NULL) {\n XXH_ASSERT(len == 0);\n return XXH_OK;\n }\n\n state->total_len_32 += (XXH32_hash_t)len;\n state->large_len |= (XXH32_hash_t)((len>=16) | (state->total_len_32>=16));\n\n XXH_ASSERT(state->bufferedSize < sizeof(state->buffer));\n if (len < sizeof(state->buffer) - state->bufferedSize) { /* fill in tmp buffer */\n XXH_memcpy(state->buffer + state->bufferedSize, input, len);\n state->bufferedSize += (XXH32_hash_t)len;\n return XXH_OK;\n }\n\n { const xxh_u8* xinput = (const xxh_u8*)input;\n const xxh_u8* const bEnd = xinput + len;\n\n if (state->bufferedSize) { /* non-empty buffer: complete first */\n XXH_memcpy(state->buffer + state->bufferedSize, xinput, sizeof(state->buffer) - state->bufferedSize);\n xinput += sizeof(state->buffer) - state->bufferedSize;\n /* then process one round */\n (void)XXH32_consumeLong(state->acc, state->buffer, sizeof(state->buffer), XXH_aligned);\n state->bufferedSize = 0;\n }\n\n XXH_ASSERT(xinput <= bEnd);\n if ((size_t)(bEnd - xinput) >= sizeof(state->buffer)) {\n /* Process the remaining data */\n xinput = XXH32_consumeLong(state->acc, xinput, (size_t)(bEnd - xinput), XXH_unaligned);\n }\n\n if (xinput < bEnd) {\n /* Copy the leftover to the tmp buffer */\n XXH_memcpy(state->buffer, xinput, (size_t)(bEnd-xinput));\n state->bufferedSize = (unsigned)(bEnd-xinput);\n }\n }\n\n return XXH_OK;\n}\n\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state)\n{\n xxh_u32 h32;\n\n if (state->large_len) {\n h32 = XXH32_mergeAccs(state->acc);\n } else {\n h32 = state->acc[2] /* == seed */ + XXH_PRIME32_5;\n }\n\n h32 += state->total_len_32;\n\n return XXH32_finalize(h32, state->buffer, state->bufferedSize, XXH_aligned);\n}\n#endif /* !XXH_NO_STREAM */\n\n/******* Canonical representation *******/\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)\n{\n XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));\n if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);\n XXH_memcpy(dst, &hash, sizeof(*dst));\n}\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)\n{\n return XXH_readBE32(src);\n}\n\n\n#ifndef XXH_NO_LONG_LONG\n\n/* *******************************************************************\n* 64-bit hash functions\n*********************************************************************/\n/*!\n * @}\n * @ingroup impl\n * @{\n */\n/******* Memory access *******/\n\ntypedef XXH64_hash_t xxh_u64;\n\n#ifdef XXH_OLD_NAMES\n# define U64 xxh_u64\n#endif\n\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n/*\n * Manual byteshift. Best for old compilers which don't inline memcpy.\n * We actually directly use XXH_readLE64 and XXH_readBE64.\n */\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))\n\n/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */\nstatic xxh_u64 XXH_read64(const void* memPtr)\n{\n return *(const xxh_u64*) memPtr;\n}\n\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))\n\n/*\n * __attribute__((aligned(1))) is supported by gcc and clang. Originally the\n * documentation claimed that it only increased the alignment, but actually it\n * can decrease it on gcc, clang, and icc:\n * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,\n * https://gcc.godbolt.org/z/xYez1j67Y.\n */\n#ifdef XXH_OLD_NAMES\ntypedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((__packed__)) unalign64;\n#endif\nstatic xxh_u64 XXH_read64(const void* ptr)\n{\n typedef __attribute__((__aligned__(1))) __attribute__((__may_alias__)) xxh_u64 xxh_unalign64;\n return *((const xxh_unalign64*)ptr);\n}\n\n#else\n\n/*\n * Portable and safe solution. Generally efficient.\n * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html\n */\nstatic xxh_u64 XXH_read64(const void* memPtr)\n{\n xxh_u64 val;\n XXH_memcpy(&val, memPtr, sizeof(val));\n return val;\n}\n\n#endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */\n\n#if defined(_MSC_VER) /* Visual Studio */\n# define XXH_swap64 _byteswap_uint64\n#elif XXH_GCC_VERSION >= 403\n# define XXH_swap64 __builtin_bswap64\n#else\nstatic xxh_u64 XXH_swap64(xxh_u64 x)\n{\n return ((x << 56) & 0xff00000000000000ULL) |\n ((x << 40) & 0x00ff000000000000ULL) |\n ((x << 24) & 0x0000ff0000000000ULL) |\n ((x << 8) & 0x000000ff00000000ULL) |\n ((x >> 8) & 0x00000000ff000000ULL) |\n ((x >> 24) & 0x0000000000ff0000ULL) |\n ((x >> 40) & 0x000000000000ff00ULL) |\n ((x >> 56) & 0x00000000000000ffULL);\n}\n#endif\n\n\n/* XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load. */\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n\nXXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr)\n{\n const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n return bytePtr[0]\n | ((xxh_u64)bytePtr[1] << 8)\n | ((xxh_u64)bytePtr[2] << 16)\n | ((xxh_u64)bytePtr[3] << 24)\n | ((xxh_u64)bytePtr[4] << 32)\n | ((xxh_u64)bytePtr[5] << 40)\n | ((xxh_u64)bytePtr[6] << 48)\n | ((xxh_u64)bytePtr[7] << 56);\n}\n\nXXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr)\n{\n const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n return bytePtr[7]\n | ((xxh_u64)bytePtr[6] << 8)\n | ((xxh_u64)bytePtr[5] << 16)\n | ((xxh_u64)bytePtr[4] << 24)\n | ((xxh_u64)bytePtr[3] << 32)\n | ((xxh_u64)bytePtr[2] << 40)\n | ((xxh_u64)bytePtr[1] << 48)\n | ((xxh_u64)bytePtr[0] << 56);\n}\n\n#else\nXXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr)\n{\n return XXH_CPU_LITTLE_ENDIAN ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));\n}\n\nstatic xxh_u64 XXH_readBE64(const void* ptr)\n{\n return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);\n}\n#endif\n\nXXH_FORCE_INLINE xxh_u64\nXXH_readLE64_align(const void* ptr, XXH_alignment align)\n{\n if (align==XXH_unaligned)\n return XXH_readLE64(ptr);\n else\n return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u64*)ptr : XXH_swap64(*(const xxh_u64*)ptr);\n}\n\n\n/******* xxh64 *******/\n/*!\n * @}\n * @defgroup XXH64_impl XXH64 implementation\n * @ingroup impl\n *\n * Details on the XXH64 implementation.\n * @{\n */\n/* #define rather that static const, to be used as initializers */\n#define XXH_PRIME64_1 0x9E3779B185EBCA87ULL /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */\n#define XXH_PRIME64_2 0xC2B2AE3D27D4EB4FULL /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */\n#define XXH_PRIME64_3 0x165667B19E3779F9ULL /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */\n#define XXH_PRIME64_4 0x85EBCA77C2B2AE63ULL /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */\n#define XXH_PRIME64_5 0x27D4EB2F165667C5ULL /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */\n\n#ifdef XXH_OLD_NAMES\n# define PRIME64_1 XXH_PRIME64_1\n# define PRIME64_2 XXH_PRIME64_2\n# define PRIME64_3 XXH_PRIME64_3\n# define PRIME64_4 XXH_PRIME64_4\n# define PRIME64_5 XXH_PRIME64_5\n#endif\n\n/*! @copydoc XXH32_round */\nstatic xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)\n{\n acc += input * XXH_PRIME64_2;\n acc = XXH_rotl64(acc, 31);\n acc *= XXH_PRIME64_1;\n#if (defined(__AVX512F__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)\n /*\n * DISABLE AUTOVECTORIZATION:\n * A compiler fence is used to prevent GCC and Clang from\n * autovectorizing the XXH64 loop (pragmas and attributes don't work for some\n * reason) without globally disabling AVX512.\n *\n * Autovectorization of XXH64 tends to be detrimental,\n * though the exact outcome may change depending on exact cpu and compiler version.\n * For information, it has been reported as detrimental for Skylake-X,\n * but possibly beneficial for Zen4.\n *\n * The default is to disable auto-vectorization,\n * but you can select to enable it instead using `XXH_ENABLE_AUTOVECTORIZE` build variable.\n */\n XXH_COMPILER_GUARD(acc);\n#endif\n return acc;\n}\n\nstatic xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)\n{\n val = XXH64_round(0, val);\n acc ^= val;\n acc = acc * XXH_PRIME64_1 + XXH_PRIME64_4;\n return acc;\n}\n\n/*! @copydoc XXH32_avalanche */\nstatic xxh_u64 XXH64_avalanche(xxh_u64 hash)\n{\n hash ^= hash >> 33;\n hash *= XXH_PRIME64_2;\n hash ^= hash >> 29;\n hash *= XXH_PRIME64_3;\n hash ^= hash >> 32;\n return hash;\n}\n\n\n#define XXH_get64bits(p) XXH_readLE64_align(p, align)\n\n/*!\n * @internal\n * @brief Sets up the initial accumulator state for XXH64().\n */\nXXH_FORCE_INLINE void\nXXH64_initAccs(xxh_u64 *acc, xxh_u64 seed)\n{\n XXH_ASSERT(acc != NULL);\n acc[0] = seed + XXH_PRIME64_1 + XXH_PRIME64_2;\n acc[1] = seed + XXH_PRIME64_2;\n acc[2] = seed + 0;\n acc[3] = seed - XXH_PRIME64_1;\n}\n\n/*!\n * @internal\n * @brief Consumes a block of data for XXH64().\n *\n * @return the end input pointer.\n */\nXXH_FORCE_INLINE const xxh_u8 *\nXXH64_consumeLong(\n xxh_u64 *XXH_RESTRICT acc,\n xxh_u8 const *XXH_RESTRICT input,\n size_t len,\n XXH_alignment align\n)\n{\n const xxh_u8* const bEnd = input + len;\n const xxh_u8* const limit = bEnd - 31;\n XXH_ASSERT(acc != NULL);\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(len >= 32);\n do {\n /* reroll on 32-bit */\n if (sizeof(void *) < sizeof(xxh_u64)) {\n size_t i;\n for (i = 0; i < 4; i++) {\n acc[i] = XXH64_round(acc[i], XXH_get64bits(input));\n input += 8;\n }\n } else {\n acc[0] = XXH64_round(acc[0], XXH_get64bits(input)); input += 8;\n acc[1] = XXH64_round(acc[1], XXH_get64bits(input)); input += 8;\n acc[2] = XXH64_round(acc[2], XXH_get64bits(input)); input += 8;\n acc[3] = XXH64_round(acc[3], XXH_get64bits(input)); input += 8;\n }\n } while (input < limit);\n\n return input;\n}\n\n/*!\n * @internal\n * @brief Merges the accumulator lanes together for XXH64()\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u64\nXXH64_mergeAccs(const xxh_u64 *acc)\n{\n XXH_ASSERT(acc != NULL);\n {\n xxh_u64 h64 = XXH_rotl64(acc[0], 1) + XXH_rotl64(acc[1], 7)\n + XXH_rotl64(acc[2], 12) + XXH_rotl64(acc[3], 18);\n /* reroll on 32-bit */\n if (sizeof(void *) < sizeof(xxh_u64)) {\n size_t i;\n for (i = 0; i < 4; i++) {\n h64 = XXH64_mergeRound(h64, acc[i]);\n }\n } else {\n h64 = XXH64_mergeRound(h64, acc[0]);\n h64 = XXH64_mergeRound(h64, acc[1]);\n h64 = XXH64_mergeRound(h64, acc[2]);\n h64 = XXH64_mergeRound(h64, acc[3]);\n }\n return h64;\n }\n}\n\n/*!\n * @internal\n * @brief Processes the last 0-31 bytes of @p ptr.\n *\n * There may be up to 31 bytes remaining to consume from the input.\n * This final stage will digest them to ensure that all input bytes are present\n * in the final mix.\n *\n * @param hash The hash to finalize.\n * @param ptr The pointer to the remaining input.\n * @param len The remaining length, modulo 32.\n * @param align Whether @p ptr is aligned.\n * @return The finalized hash\n * @see XXH32_finalize().\n */\nXXH_STATIC XXH_PUREF xxh_u64\nXXH64_finalize(xxh_u64 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)\n{\n if (ptr==NULL) XXH_ASSERT(len == 0);\n len &= 31;\n while (len >= 8) {\n xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr));\n ptr += 8;\n hash ^= k1;\n hash = XXH_rotl64(hash,27) * XXH_PRIME64_1 + XXH_PRIME64_4;\n len -= 8;\n }\n if (len >= 4) {\n hash ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;\n ptr += 4;\n hash = XXH_rotl64(hash, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;\n len -= 4;\n }\n while (len > 0) {\n hash ^= (*ptr++) * XXH_PRIME64_5;\n hash = XXH_rotl64(hash, 11) * XXH_PRIME64_1;\n --len;\n }\n return XXH64_avalanche(hash);\n}\n\n#ifdef XXH_OLD_NAMES\n# define PROCESS1_64 XXH_PROCESS1_64\n# define PROCESS4_64 XXH_PROCESS4_64\n# define PROCESS8_64 XXH_PROCESS8_64\n#else\n# undef XXH_PROCESS1_64\n# undef XXH_PROCESS4_64\n# undef XXH_PROCESS8_64\n#endif\n\n/*!\n * @internal\n * @brief The implementation for @ref XXH64().\n *\n * @param input , len , seed Directly passed from @ref XXH64().\n * @param align Whether @p input is aligned.\n * @return The calculated hash.\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u64\nXXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment align)\n{\n xxh_u64 h64;\n if (input==NULL) XXH_ASSERT(len == 0);\n\n if (len>=32) { /* Process a large block of data */\n xxh_u64 acc[4];\n XXH64_initAccs(acc, seed);\n\n input = XXH64_consumeLong(acc, input, len, align);\n\n h64 = XXH64_mergeAccs(acc);\n } else {\n h64 = seed + XXH_PRIME64_5;\n }\n\n h64 += (xxh_u64) len;\n\n return XXH64_finalize(h64, input, len, align);\n}\n\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH64_hash_t XXH64 (XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)\n{\n#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2\n /* Simple version, good for code maintenance, but unfortunately slow for small inputs */\n XXH64_state_t state;\n XXH64_reset(&state, seed);\n XXH64_update(&state, (const xxh_u8*)input, len);\n return XXH64_digest(&state);\n#else\n if (XXH_FORCE_ALIGN_CHECK) {\n if ((((size_t)input) & 7)==0) { /* Input is aligned, let's leverage the speed advantage */\n return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);\n } }\n\n return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);\n\n#endif\n}\n\n/******* Hash Streaming *******/\n#ifndef XXH_NO_STREAM\n/*! @ingroup XXH64_family*/\nXXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)\n{\n return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));\n}\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)\n{\n XXH_free(statePtr);\n return XXH_OK;\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dstState, const XXH64_state_t* srcState)\n{\n XXH_memcpy(dstState, srcState, sizeof(*dstState));\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed)\n{\n XXH_ASSERT(statePtr != NULL);\n XXH_memset(statePtr, 0, sizeof(*statePtr));\n XXH64_initAccs(statePtr->acc, seed);\n return XXH_OK;\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH64_update (XXH_NOESCAPE XXH64_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n if (input==NULL) {\n XXH_ASSERT(len == 0);\n return XXH_OK;\n }\n\n state->total_len += len;\n\n XXH_ASSERT(state->bufferedSize <= sizeof(state->buffer));\n if (len < sizeof(state->buffer) - state->bufferedSize) { /* fill in tmp buffer */\n XXH_memcpy(state->buffer + state->bufferedSize, input, len);\n state->bufferedSize += (XXH32_hash_t)len;\n return XXH_OK;\n }\n\n { const xxh_u8* xinput = (const xxh_u8*)input;\n const xxh_u8* const bEnd = xinput + len;\n\n if (state->bufferedSize) { /* non-empty buffer => complete first */\n XXH_memcpy(state->buffer + state->bufferedSize, xinput, sizeof(state->buffer) - state->bufferedSize);\n xinput += sizeof(state->buffer) - state->bufferedSize;\n /* and process one round */\n (void)XXH64_consumeLong(state->acc, state->buffer, sizeof(state->buffer), XXH_aligned);\n state->bufferedSize = 0;\n }\n\n XXH_ASSERT(xinput <= bEnd);\n if ((size_t)(bEnd - xinput) >= sizeof(state->buffer)) {\n /* Process the remaining data */\n xinput = XXH64_consumeLong(state->acc, xinput, (size_t)(bEnd - xinput), XXH_unaligned);\n }\n\n if (xinput < bEnd) {\n /* Copy the leftover to the tmp buffer */\n XXH_memcpy(state->buffer, xinput, (size_t)(bEnd-xinput));\n state->bufferedSize = (unsigned)(bEnd-xinput);\n }\n }\n\n return XXH_OK;\n}\n\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH64_hash_t XXH64_digest(XXH_NOESCAPE const XXH64_state_t* state)\n{\n xxh_u64 h64;\n\n if (state->total_len >= 32) {\n h64 = XXH64_mergeAccs(state->acc);\n } else {\n h64 = state->acc[2] /*seed*/ + XXH_PRIME64_5;\n }\n\n h64 += (xxh_u64) state->total_len;\n\n return XXH64_finalize(h64, state->buffer, (size_t)state->total_len, XXH_aligned);\n}\n#endif /* !XXH_NO_STREAM */\n\n/******* Canonical representation *******/\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash)\n{\n XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));\n if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);\n XXH_memcpy(dst, &hash, sizeof(*dst));\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src)\n{\n return XXH_readBE64(src);\n}\n\n#ifndef XXH_NO_XXH3\n\n/* *********************************************************************\n* XXH3\n* New generation hash designed for speed on small keys and vectorization\n************************************************************************ */\n/*!\n * @}\n * @defgroup XXH3_impl XXH3 implementation\n * @ingroup impl\n * @{\n */\n\n/* === Compiler specifics === */\n\n\n#if (defined(__GNUC__) && (__GNUC__ >= 3)) \\\n || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) \\\n || defined(__clang__)\n# define XXH_likely(x) __builtin_expect(x, 1)\n# define XXH_unlikely(x) __builtin_expect(x, 0)\n#else\n# define XXH_likely(x) (x)\n# define XXH_unlikely(x) (x)\n#endif\n\n#ifndef XXH_HAS_INCLUDE\n# ifdef __has_include\n/*\n * Not defined as XXH_HAS_INCLUDE(x) (function-like) because\n * this causes segfaults in Apple Clang 4.2 (on Mac OS X 10.7 Lion)\n */\n# define XXH_HAS_INCLUDE __has_include\n# else\n# define XXH_HAS_INCLUDE(x) 0\n# endif\n#endif\n\n#if defined(__GNUC__) || defined(__clang__)\n# if defined(__ARM_FEATURE_SVE)\n# include \n# endif\n# if defined(__ARM_NEON__) || defined(__ARM_NEON) \\\n || (defined(_M_ARM) && _M_ARM >= 7) \\\n || defined(_M_ARM64) || defined(_M_ARM64EC) \\\n || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE()) /* WASM SIMD128 via SIMDe */\n# define inline __inline__ /* circumvent a clang bug */\n# include \n# undef inline\n# elif defined(__AVX2__)\n# include \n# elif defined(__SSE2__)\n# include \n# elif defined(__loongarch_asx)\n# include \n# include \n# elif defined(__loongarch_sx)\n# include \n# elif defined(__riscv_vector)\n# include \n# endif\n#endif\n\n#if defined(_MSC_VER)\n# include \n#endif\n\n/*\n * One goal of XXH3 is to make it fast on both 32-bit and 64-bit, while\n * remaining a true 64-bit/128-bit hash function.\n *\n * This is done by prioritizing a subset of 64-bit operations that can be\n * emulated without too many steps on the average 32-bit machine.\n *\n * For example, these two lines seem similar, and run equally fast on 64-bit:\n *\n * xxh_u64 x;\n * x ^= (x >> 47); // good\n * x ^= (x >> 13); // bad\n *\n * However, to a 32-bit machine, there is a major difference.\n *\n * x ^= (x >> 47) looks like this:\n *\n * x.lo ^= (x.hi >> (47 - 32));\n *\n * while x ^= (x >> 13) looks like this:\n *\n * // note: funnel shifts are not usually cheap.\n * x.lo ^= (x.lo >> 13) | (x.hi << (32 - 13));\n * x.hi ^= (x.hi >> 13);\n *\n * The first one is significantly faster than the second, simply because the\n * shift is larger than 32. This means:\n * - All the bits we need are in the upper 32 bits, so we can ignore the lower\n * 32 bits in the shift.\n * - The shift result will always fit in the lower 32 bits, and therefore,\n * we can ignore the upper 32 bits in the xor.\n *\n * Thanks to this optimization, XXH3 only requires these features to be efficient:\n *\n * - Usable unaligned access\n * - A 32-bit or 64-bit ALU\n * - If 32-bit, a decent ADC instruction\n * - A 32 or 64-bit multiply with a 64-bit result\n * - For the 128-bit variant, a decent byteswap helps short inputs.\n *\n * The first two are already required by XXH32, and almost all 32-bit and 64-bit\n * platforms which can run XXH32 can run XXH3 efficiently.\n *\n * Thumb-1, the classic 16-bit only subset of ARM's instruction set, is one\n * notable exception.\n *\n * First of all, Thumb-1 lacks support for the UMULL instruction which\n * performs the important long multiply. This means numerous __aeabi_lmul\n * calls.\n *\n * Second of all, the 8 functional registers are just not enough.\n * Setup for __aeabi_lmul, byteshift loads, pointers, and all arithmetic need\n * Lo registers, and this shuffling results in thousands more MOVs than A32.\n *\n * A32 and T32 don't have this limitation. They can access all 14 registers,\n * do a 32->64 multiply with UMULL, and the flexible operand allowing free\n * shifts is helpful, too.\n *\n * Therefore, we do a quick sanity check.\n *\n * If compiling Thumb-1 for a target which supports ARM instructions, we will\n * emit a warning, as it is not a \"sane\" platform to compile for.\n *\n * Usually, if this happens, it is because of an accident and you probably need\n * to specify -march, as you likely meant to compile for a newer architecture.\n *\n * Credit: large sections of the vectorial and asm source code paths\n * have been contributed by @easyaspi314\n */\n#if defined(__thumb__) && !defined(__thumb2__) && defined(__ARM_ARCH_ISA_ARM)\n# warning \"XXH3 is highly inefficient without ARM or Thumb-2.\"\n#endif\n\n/* ==========================================\n * Vectorization detection\n * ========================================== */\n\n#ifdef XXH_DOXYGEN\n/*!\n * @ingroup tuning\n * @brief Overrides the vectorization implementation chosen for XXH3.\n *\n * Can be defined to 0 to disable SIMD,\n * or any other authorized value of @ref XXH_VECTOR.\n *\n * If this is not defined, it uses predefined macros to determine the best\n * implementation.\n */\n# define XXH_VECTOR XXH_SCALAR\n/*!\n * @ingroup tuning\n * @brief Selects the minimum alignment for XXH3's accumulators.\n *\n * When using SIMD, this should match the alignment required for said vector\n * type, so, for example, 32 for AVX2.\n *\n * Default: Auto detected.\n */\n# define XXH_ACC_ALIGN 8\n#endif\n\n/* Actual definition */\n#ifndef XXH_DOXYGEN\n#endif\n\n#ifndef XXH_VECTOR /* can be defined on command line */\n# if ( \\\n defined(__ARM_NEON__) || defined(__ARM_NEON) /* gcc */ \\\n || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) /* msvc */ \\\n || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE()) /* wasm simd128 via SIMDe */ \\\n ) && ( \\\n defined(_WIN32) || defined(__LITTLE_ENDIAN__) /* little endian only */ \\\n || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \\\n )\n# define XXH_VECTOR XXH_NEON\n# elif defined(__ARM_FEATURE_SVE)\n# define XXH_VECTOR XXH_SVE\n# elif defined(__AVX512F__)\n# define XXH_VECTOR XXH_AVX512\n# elif defined(__AVX2__)\n# define XXH_VECTOR XXH_AVX2\n# elif defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))\n# define XXH_VECTOR XXH_SSE2\n# elif (defined(__PPC64__) && defined(__POWER8_VECTOR__)) \\\n || (defined(__s390x__) && defined(__VEC__)) \\\n && defined(__GNUC__) /* TODO: IBM XL */\n# define XXH_VECTOR XXH_VSX\n# elif defined(__loongarch_asx)\n# define XXH_VECTOR XXH_LASX\n# elif defined(__loongarch_sx)\n# define XXH_VECTOR XXH_LSX\n# elif defined(__riscv_vector)\n# define XXH_VECTOR XXH_RVV\n# else\n# define XXH_VECTOR XXH_SCALAR\n# endif\n#endif\n\n/* __ARM_FEATURE_SVE is only supported by GCC & Clang. */\n#if (XXH_VECTOR == XXH_SVE) && !defined(__ARM_FEATURE_SVE)\n# ifdef _MSC_VER\n# pragma warning(once : 4606)\n# else\n# warning \"__ARM_FEATURE_SVE isn't supported. Use SCALAR instead.\"\n# endif\n# undef XXH_VECTOR\n# define XXH_VECTOR XXH_SCALAR\n#endif\n\n/*\n * Controls the alignment of the accumulator,\n * for compatibility with aligned vector loads, which are usually faster.\n */\n#ifndef XXH_ACC_ALIGN\n# if defined(XXH_X86DISPATCH)\n# define XXH_ACC_ALIGN 64 /* for compatibility with avx512 */\n# elif XXH_VECTOR == XXH_SCALAR /* scalar */\n# define XXH_ACC_ALIGN 8\n# elif XXH_VECTOR == XXH_SSE2 /* sse2 */\n# define XXH_ACC_ALIGN 16\n# elif XXH_VECTOR == XXH_AVX2 /* avx2 */\n# define XXH_ACC_ALIGN 32\n# elif XXH_VECTOR == XXH_NEON /* neon */\n# define XXH_ACC_ALIGN 16\n# elif XXH_VECTOR == XXH_VSX /* vsx */\n# define XXH_ACC_ALIGN 16\n# elif XXH_VECTOR == XXH_AVX512 /* avx512 */\n# define XXH_ACC_ALIGN 64\n# elif XXH_VECTOR == XXH_SVE /* sve */\n# define XXH_ACC_ALIGN 64\n# elif XXH_VECTOR == XXH_LASX /* lasx */\n# define XXH_ACC_ALIGN 64\n# elif XXH_VECTOR == XXH_LSX /* lsx */\n# define XXH_ACC_ALIGN 64\n# elif XXH_VECTOR == XXH_RVV /* rvv */\n# define XXH_ACC_ALIGN 64 /* could be 8, but 64 may be faster */\n# endif\n#endif\n\n#if defined(XXH_X86DISPATCH) || XXH_VECTOR == XXH_SSE2 \\\n || XXH_VECTOR == XXH_AVX2 || XXH_VECTOR == XXH_AVX512\n# define XXH_SEC_ALIGN XXH_ACC_ALIGN\n#elif XXH_VECTOR == XXH_SVE\n# define XXH_SEC_ALIGN XXH_ACC_ALIGN\n#elif XXH_VECTOR == XXH_RVV\n# define XXH_SEC_ALIGN XXH_ACC_ALIGN\n#else\n# define XXH_SEC_ALIGN 8\n#endif\n\n#if defined(__GNUC__) || defined(__clang__)\n# define XXH_ALIASING __attribute__((__may_alias__))\n#else\n# define XXH_ALIASING /* nothing */\n#endif\n\n/*\n * UGLY HACK:\n * GCC usually generates the best code with -O3 for xxHash.\n *\n * However, when targeting AVX2, it is overzealous in its unrolling resulting\n * in code roughly 3/4 the speed of Clang.\n *\n * There are other issues, such as GCC splitting _mm256_loadu_si256 into\n * _mm_loadu_si128 + _mm256_inserti128_si256. This is an optimization which\n * only applies to Sandy and Ivy Bridge... which don't even support AVX2.\n *\n * That is why when compiling the AVX2 version, it is recommended to use either\n * -O2 -mavx2 -march=haswell\n * or\n * -O2 -mavx2 -mno-avx256-split-unaligned-load\n * for decent performance, or to use Clang instead.\n *\n * Fortunately, we can control the first one with a pragma that forces GCC into\n * -O2, but the other one we can't control without \"failed to inline always\n * inline function due to target mismatch\" warnings.\n */\n#if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \\\n && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \\\n && defined(__OPTIMIZE__) && XXH_SIZE_OPT <= 0 /* respect -O0 and -Os */\n# pragma GCC push_options\n# pragma GCC optimize(\"-O2\")\n#endif\n\n#if XXH_VECTOR == XXH_NEON\n\n/*\n * UGLY HACK: While AArch64 GCC on Linux does not seem to care, on macOS, GCC -O3\n * optimizes out the entire hashLong loop because of the aliasing violation.\n *\n * However, GCC is also inefficient at load-store optimization with vld1q/vst1q,\n * so the only option is to mark it as aliasing.\n */\ntypedef uint64x2_t xxh_aliasing_uint64x2_t XXH_ALIASING;\n\n/*!\n * @internal\n * @brief `vld1q_u64` but faster and alignment-safe.\n *\n * On AArch64, unaligned access is always safe, but on ARMv7-a, it is only\n * *conditionally* safe (`vld1` has an alignment bit like `movdq[ua]` in x86).\n *\n * GCC for AArch64 sees `vld1q_u8` as an intrinsic instead of a load, so it\n * prohibits load-store optimizations. Therefore, a direct dereference is used.\n *\n * Otherwise, `vld1q_u8` is used with `vreinterpretq_u8_u64` to do a safe\n * unaligned load.\n */\n#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__)\nXXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr) /* silence -Wcast-align */\n{\n return *(xxh_aliasing_uint64x2_t const *)ptr;\n}\n#else\nXXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr)\n{\n return vreinterpretq_u64_u8(vld1q_u8((uint8_t const*)ptr));\n}\n#endif\n\n/*!\n * @internal\n * @brief `vmlal_u32` on low and high halves of a vector.\n *\n * This is a workaround for AArch64 GCC < 11 which implemented arm_neon.h with\n * inline assembly and were therefore incapable of merging the `vget_{low, high}_u32`\n * with `vmlal_u32`.\n */\n#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 11\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n /* Inline assembly is the only way */\n __asm__(\"umlal %0.2d, %1.2s, %2.2s\" : \"+w\" (acc) : \"w\" (lhs), \"w\" (rhs));\n return acc;\n}\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n /* This intrinsic works as expected */\n return vmlal_high_u32(acc, lhs, rhs);\n}\n#else\n/* Portable intrinsic versions */\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n return vmlal_u32(acc, vget_low_u32(lhs), vget_low_u32(rhs));\n}\n/*! @copydoc XXH_vmlal_low_u32\n * Assume the compiler converts this to vmlal_high_u32 on aarch64 */\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n return vmlal_u32(acc, vget_high_u32(lhs), vget_high_u32(rhs));\n}\n#endif\n\n/*!\n * @ingroup tuning\n * @brief Controls the NEON to scalar ratio for XXH3\n *\n * This can be set to 2, 4, 6, or 8.\n *\n * ARM Cortex CPUs are _very_ sensitive to how their pipelines are used.\n *\n * For example, the Cortex-A73 can dispatch 3 micro-ops per cycle, but only 2 of those\n * can be NEON. If you are only using NEON instructions, you are only using 2/3 of the CPU\n * bandwidth.\n *\n * This is even more noticeable on the more advanced cores like the Cortex-A76 which\n * can dispatch 8 micro-ops per cycle, but still only 2 NEON micro-ops at once.\n *\n * Therefore, to make the most out of the pipeline, it is beneficial to run 6 NEON lanes\n * and 2 scalar lanes, which is chosen by default.\n *\n * This does not apply to Apple processors or 32-bit processors, which run better with\n * full NEON. These will default to 8. Additionally, size-optimized builds run 8 lanes.\n *\n * This change benefits CPUs with large micro-op buffers without negatively affecting\n * most other CPUs:\n *\n * | Chipset | Dispatch type | NEON only | 6:2 hybrid | Diff. |\n * |:----------------------|:--------------------|----------:|-----------:|------:|\n * | Snapdragon 730 (A76) | 2 NEON/8 micro-ops | 8.8 GB/s | 10.1 GB/s | ~16% |\n * | Snapdragon 835 (A73) | 2 NEON/3 micro-ops | 5.1 GB/s | 5.3 GB/s | ~5% |\n * | Marvell PXA1928 (A53) | In-order dual-issue | 1.9 GB/s | 1.9 GB/s | 0% |\n * | Apple M1 | 4 NEON/8 micro-ops | 37.3 GB/s | 36.1 GB/s | ~-3% |\n *\n * It also seems to fix some bad codegen on GCC, making it almost as fast as clang.\n *\n * When using WASM SIMD128, if this is 2 or 6, SIMDe will scalarize 2 of the lanes meaning\n * it effectively becomes worse 4.\n *\n * @see XXH3_accumulate_512_neon()\n */\n# ifndef XXH3_NEON_LANES\n# if (defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64) || defined(_M_ARM64EC)) \\\n && !defined(__APPLE__) && XXH_SIZE_OPT <= 0\n# define XXH3_NEON_LANES 6\n# else\n# define XXH3_NEON_LANES XXH_ACC_NB\n# endif\n# endif\n#endif /* XXH_VECTOR == XXH_NEON */\n\n/*\n * VSX and Z Vector helpers.\n *\n * This is very messy, and any pull requests to clean this up are welcome.\n *\n * There are a lot of problems with supporting VSX and s390x, due to\n * inconsistent intrinsics, spotty coverage, and multiple endiannesses.\n */\n#if XXH_VECTOR == XXH_VSX\n/* Annoyingly, these headers _may_ define three macros: `bool`, `vector`,\n * and `pixel`. This is a problem for obvious reasons.\n *\n * These keywords are unnecessary; the spec literally says they are\n * equivalent to `__bool`, `__vector`, and `__pixel` and may be undef'd\n * after including the header.\n *\n * We use pragma push_macro/pop_macro to keep the namespace clean. */\n# pragma push_macro(\"bool\")\n# pragma push_macro(\"vector\")\n# pragma push_macro(\"pixel\")\n/* silence potential macro redefined warnings */\n# undef bool\n# undef vector\n# undef pixel\n\n# if defined(__s390x__)\n# include \n# else\n# include \n# endif\n\n/* Restore the original macro values, if applicable. */\n# pragma pop_macro(\"pixel\")\n# pragma pop_macro(\"vector\")\n# pragma pop_macro(\"bool\")\n\ntypedef __vector unsigned long long xxh_u64x2;\ntypedef __vector unsigned char xxh_u8x16;\ntypedef __vector unsigned xxh_u32x4;\n\n/*\n * UGLY HACK: Similar to aarch64 macOS GCC, s390x GCC has the same aliasing issue.\n */\ntypedef xxh_u64x2 xxh_aliasing_u64x2 XXH_ALIASING;\n\n# ifndef XXH_VSX_BE\n# if defined(__BIG_ENDIAN__) \\\n || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n# define XXH_VSX_BE 1\n# elif defined(__VEC_ELEMENT_REG_ORDER__) && __VEC_ELEMENT_REG_ORDER__ == __ORDER_BIG_ENDIAN__\n# warning \"-maltivec=be is not recommended. Please use native endianness.\"\n# define XXH_VSX_BE 1\n# else\n# define XXH_VSX_BE 0\n# endif\n# endif /* !defined(XXH_VSX_BE) */\n\n# if XXH_VSX_BE\n# if defined(__POWER9_VECTOR__) || (defined(__clang__) && defined(__s390x__))\n# define XXH_vec_revb vec_revb\n# else\n/*!\n * A polyfill for POWER9's vec_revb().\n */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val)\n{\n xxh_u8x16 const vByteSwap = { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,\n 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08 };\n return vec_perm(val, val, vByteSwap);\n}\n# endif\n# endif /* XXH_VSX_BE */\n\n/*!\n * Performs an unaligned vector load and byte swaps it on big endian.\n */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)\n{\n xxh_u64x2 ret;\n XXH_memcpy(&ret, ptr, sizeof(xxh_u64x2));\n# if XXH_VSX_BE\n ret = XXH_vec_revb(ret);\n# endif\n return ret;\n}\n\n/*\n * vec_mulo and vec_mule are very problematic intrinsics on PowerPC\n *\n * These intrinsics weren't added until GCC 8, despite existing for a while,\n * and they are endian dependent. Also, their meaning swap depending on version.\n * */\n# if defined(__s390x__)\n /* s390x is always big endian, no issue on this platform */\n# define XXH_vec_mulo vec_mulo\n# define XXH_vec_mule vec_mule\n# elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw) && !defined(__ibmxl__)\n/* Clang has a better way to control this, we can just use the builtin which doesn't swap. */\n /* The IBM XL Compiler (which defined __clang__) only implements the vec_* operations */\n# define XXH_vec_mulo __builtin_altivec_vmulouw\n# define XXH_vec_mule __builtin_altivec_vmuleuw\n# else\n/* gcc needs inline assembly */\n/* Adapted from https://github.com/google/highwayhash/blob/master/highwayhash/hh_vsx.h. */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b)\n{\n xxh_u64x2 result;\n __asm__(\"vmulouw %0, %1, %2\" : \"=v\" (result) : \"v\" (a), \"v\" (b));\n return result;\n}\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)\n{\n xxh_u64x2 result;\n __asm__(\"vmuleuw %0, %1, %2\" : \"=v\" (result) : \"v\" (a), \"v\" (b));\n return result;\n}\n# endif /* XXH_vec_mulo, XXH_vec_mule */\n#endif /* XXH_VECTOR == XXH_VSX */\n\n#if XXH_VECTOR == XXH_SVE\n#define ACCRND(acc, offset) \\\ndo { \\\n svuint64_t input_vec = svld1_u64(mask, xinput + offset); \\\n svuint64_t secret_vec = svld1_u64(mask, xsecret + offset); \\\n svuint64_t mixed = sveor_u64_x(mask, secret_vec, input_vec); \\\n svuint64_t swapped = svtbl_u64(input_vec, kSwap); \\\n svuint64_t mixed_lo = svextw_u64_x(mask, mixed); \\\n svuint64_t mixed_hi = svlsr_n_u64_x(mask, mixed, 32); \\\n svuint64_t mul = svmad_u64_x(mask, mixed_lo, mixed_hi, swapped); \\\n acc = svadd_u64_x(mask, acc, mul); \\\n} while (0)\n#endif /* XXH_VECTOR == XXH_SVE */\n\n/* prefetch\n * can be disabled, by declaring XXH_NO_PREFETCH build macro */\n#if defined(XXH_NO_PREFETCH)\n# define XXH_PREFETCH(ptr) (void)(ptr) /* disabled */\n#else\n# if XXH_SIZE_OPT >= 1\n# define XXH_PREFETCH(ptr) (void)(ptr)\n# elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86)) /* _mm_prefetch() not defined outside of x86/x64 */\n# include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */\n# define XXH_PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0)\n# elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )\n# define XXH_PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)\n# else\n# define XXH_PREFETCH(ptr) (void)(ptr) /* disabled */\n# endif\n#endif /* XXH_NO_PREFETCH */\n\n\n/* ==========================================\n * XXH3 default settings\n * ========================================== */\n\n#define XXH_SECRET_DEFAULT_SIZE 192 /* minimum XXH3_SECRET_SIZE_MIN */\n\n#if (XXH_SECRET_DEFAULT_SIZE < XXH3_SECRET_SIZE_MIN)\n# error \"default keyset is not large enough\"\n#endif\n\n/*!\n * @internal\n * @def XXH3_kSecret\n * @brief Pseudorandom secret taken directly from FARSH. */\nXXH_ALIGN(64) static const xxh_u8 XXH3_kSecret[XXH_SECRET_DEFAULT_SIZE] = {\n 0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,\n 0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,\n 0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,\n 0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,\n 0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,\n 0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,\n 0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,\n 0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,\n 0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,\n 0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,\n 0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,\n 0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,\n};\n\nstatic const xxh_u64 PRIME_MX1 = 0x165667919E3779F9ULL; /*!< 0b0001011001010110011001111001000110011110001101110111100111111001 */\nstatic const xxh_u64 PRIME_MX2 = 0x9FB21C651E98DF25ULL; /*!< 0b1001111110110010000111000110010100011110100110001101111100100101 */\n\n#ifdef XXH_OLD_NAMES\n# define kSecret XXH3_kSecret\n#endif\n\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Calculates a 32-bit to 64-bit long multiply.\n *\n * Implemented as a macro.\n *\n * Wraps `__emulu` on MSVC x86 because it tends to call `__allmul` when it doesn't\n * need to (but it shouldn't need to anyways, it is about 7 instructions to do\n * a 64x64 multiply...). Since we know that this will _always_ emit `MULL`, we\n * use that instead of the normal method.\n *\n * If you are compiling for platforms like Thumb-1 and don't have a better option,\n * you may also want to write your own long multiply routine here.\n *\n * @param x, y Numbers to be multiplied\n * @return 64-bit product of the low 32 bits of @p x and @p y.\n */\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64(xxh_u64 x, xxh_u64 y)\n{\n return (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF);\n}\n#elif defined(_MSC_VER) && defined(_M_IX86)\n# define XXH_mult32to64(x, y) __emulu((unsigned)(x), (unsigned)(y))\n#else\n/*\n * Downcast + upcast is usually better than masking on older compilers like\n * GCC 4.2 (especially 32-bit ones), all without affecting newer compilers.\n *\n * The other method, (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF), will AND both operands\n * and perform a full 64x64 multiply -- entirely redundant on 32-bit.\n */\n# define XXH_mult32to64(x, y) ((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y))\n#endif\n\n/*!\n * @brief Calculates a 64->128-bit long multiply.\n *\n * Uses `__uint128_t` and `_umul128` if available, otherwise uses a scalar\n * version.\n *\n * @param lhs , rhs The 64-bit integers to be multiplied\n * @return The 128-bit result represented in an @ref XXH128_hash_t.\n */\nstatic XXH128_hash_t\nXXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)\n{\n /*\n * GCC/Clang __uint128_t method.\n *\n * On most 64-bit targets, GCC and Clang define a __uint128_t type.\n * This is usually the best way as it usually uses a native long 64-bit\n * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64.\n *\n * Usually.\n *\n * Despite being a 32-bit platform, Clang (and emscripten) define this type\n * despite not having the arithmetic for it. This results in a laggy\n * compiler builtin call which calculates a full 128-bit multiply.\n * In that case it is best to use the portable one.\n * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677\n */\n#if (defined(__GNUC__) || defined(__clang__)) && !defined(__wasm__) \\\n && defined(__SIZEOF_INT128__) \\\n || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)\n\n __uint128_t const product = (__uint128_t)lhs * (__uint128_t)rhs;\n XXH128_hash_t r128;\n r128.low64 = (xxh_u64)(product);\n r128.high64 = (xxh_u64)(product >> 64);\n return r128;\n\n /*\n * MSVC for x64's _umul128 method.\n *\n * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct);\n *\n * This compiles to single operand MUL on x64.\n */\n#elif (defined(_M_X64) || defined(_M_IA64)) && !defined(_M_ARM64EC)\n\n#ifndef _MSC_VER\n# pragma intrinsic(_umul128)\n#endif\n xxh_u64 product_high;\n xxh_u64 const product_low = _umul128(lhs, rhs, &product_high);\n XXH128_hash_t r128;\n r128.low64 = product_low;\n r128.high64 = product_high;\n return r128;\n\n /*\n * MSVC for ARM64's __umulh method.\n *\n * This compiles to the same MUL + UMULH as GCC/Clang's __uint128_t method.\n */\n#elif defined(_M_ARM64) || defined(_M_ARM64EC)\n\n#ifndef _MSC_VER\n# pragma intrinsic(__umulh)\n#endif\n XXH128_hash_t r128;\n r128.low64 = lhs * rhs;\n r128.high64 = __umulh(lhs, rhs);\n return r128;\n\n#else\n /*\n * Portable scalar method. Optimized for 32-bit and 64-bit ALUs.\n *\n * This is a fast and simple grade school multiply, which is shown below\n * with base 10 arithmetic instead of base 0x100000000.\n *\n * 9 3 // D2 lhs = 93\n * x 7 5 // D2 rhs = 75\n * ----------\n * 1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15\n * 4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45\n * 2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21\n * + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63\n * ---------\n * 2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27\n * + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67\n * ---------\n * 6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975\n *\n * The reasons for adding the products like this are:\n * 1. It avoids manual carry tracking. Just like how\n * (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX.\n * This avoids a lot of complexity.\n *\n * 2. It hints for, and on Clang, compiles to, the powerful UMAAL\n * instruction available in ARM's Digital Signal Processing extension\n * in 32-bit ARMv6 and later, which is shown below:\n *\n * void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm)\n * {\n * xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm;\n * *RdLo = (xxh_u32)(product & 0xFFFFFFFF);\n * *RdHi = (xxh_u32)(product >> 32);\n * }\n *\n * This instruction was designed for efficient long multiplication, and\n * allows this to be calculated in only 4 instructions at speeds\n * comparable to some 64-bit ALUs.\n *\n * 3. It isn't terrible on other platforms. Usually this will be a couple\n * of 32-bit ADD/ADCs.\n */\n\n /* First calculate all of the cross products. */\n xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);\n xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32, rhs & 0xFFFFFFFF);\n xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);\n xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32, rhs >> 32);\n\n /* Now add the products together. These will never overflow. */\n xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;\n xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32) + hi_hi;\n xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);\n\n XXH128_hash_t r128;\n r128.low64 = lower;\n r128.high64 = upper;\n return r128;\n#endif\n}\n\n/*!\n * @brief Calculates a 64-bit to 128-bit multiply, then XOR folds it.\n *\n * The reason for the separate function is to prevent passing too many structs\n * around by value. This will hopefully inline the multiply, but we don't force it.\n *\n * @param lhs , rhs The 64-bit integers to multiply\n * @return The low 64 bits of the product XOR'd by the high 64 bits.\n * @see XXH_mult64to128()\n */\nstatic xxh_u64\nXXH3_mul128_fold64(xxh_u64 lhs, xxh_u64 rhs)\n{\n XXH128_hash_t product = XXH_mult64to128(lhs, rhs);\n return product.low64 ^ product.high64;\n}\n\n/*! Seems to produce slightly better code on GCC for some reason. */\nXXH_FORCE_INLINE XXH_CONSTF xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)\n{\n XXH_ASSERT(0 <= shift && shift < 64);\n return v64 ^ (v64 >> shift);\n}\n\n/*\n * This is a fast avalanche stage,\n * suitable when input bits are already partially mixed\n */\nstatic XXH64_hash_t XXH3_avalanche(xxh_u64 h64)\n{\n h64 = XXH_xorshift64(h64, 37);\n h64 *= PRIME_MX1;\n h64 = XXH_xorshift64(h64, 32);\n return h64;\n}\n\n/*\n * This is a stronger avalanche,\n * inspired by Pelle Evensen's rrmxmx\n * preferable when input has not been previously mixed\n */\nstatic XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)\n{\n /* this mix is inspired by Pelle Evensen's rrmxmx */\n h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);\n h64 *= PRIME_MX2;\n h64 ^= (h64 >> 35) + len ;\n h64 *= PRIME_MX2;\n return XXH_xorshift64(h64, 28);\n}\n\n\n/* ==========================================\n * Short keys\n * ==========================================\n * One of the shortcomings of XXH32 and XXH64 was that their performance was\n * sub-optimal on short lengths. It used an iterative algorithm which strongly\n * favored lengths that were a multiple of 4 or 8.\n *\n * Instead of iterating over individual inputs, we use a set of single shot\n * functions which piece together a range of lengths and operate in constant time.\n *\n * Additionally, the number of multiplies has been significantly reduced. This\n * reduces latency, especially when emulating 64-bit multiplies on 32-bit.\n *\n * Depending on the platform, this may or may not be faster than XXH32, but it\n * is almost guaranteed to be faster than XXH64.\n */\n\n/*\n * At very short lengths, there isn't enough input to fully hide secrets, or use\n * the entire secret.\n *\n * There is also only a limited amount of mixing we can do before significantly\n * impacting performance.\n *\n * Therefore, we use different sections of the secret and always mix two secret\n * samples with an XOR. This should have no effect on performance on the\n * seedless or withSeed variants because everything _should_ be constant folded\n * by modern compilers.\n *\n * The XOR mixing hides individual parts of the secret and increases entropy.\n *\n * This adds an extra layer of strength for custom secrets.\n */\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(1 <= len && len <= 3);\n XXH_ASSERT(secret != NULL);\n /*\n * len = 1: combined = { input[0], 0x01, input[0], input[0] }\n * len = 2: combined = { input[1], 0x02, input[0], input[1] }\n * len = 3: combined = { input[2], 0x03, input[0], input[1] }\n */\n { xxh_u8 const c1 = input[0];\n xxh_u8 const c2 = input[len >> 1];\n xxh_u8 const c3 = input[len - 1];\n xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2 << 24)\n | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8);\n xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;\n xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;\n return XXH64_avalanche(keyed);\n }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(secret != NULL);\n XXH_ASSERT(4 <= len && len <= 8);\n seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;\n { xxh_u32 const input1 = XXH_readLE32(input);\n xxh_u32 const input2 = XXH_readLE32(input + len - 4);\n xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed;\n xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32);\n xxh_u64 const keyed = input64 ^ bitflip;\n return XXH3_rrmxmx(keyed, len);\n }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(secret != NULL);\n XXH_ASSERT(9 <= len && len <= 16);\n { xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;\n xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;\n xxh_u64 const input_lo = XXH_readLE64(input) ^ bitflip1;\n xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2;\n xxh_u64 const acc = len\n + XXH_swap64(input_lo) + input_hi\n + XXH3_mul128_fold64(input_lo, input_hi);\n return XXH3_avalanche(acc);\n }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(len <= 16);\n { if (XXH_likely(len > 8)) return XXH3_len_9to16_64b(input, len, secret, seed);\n if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed);\n if (len) return XXH3_len_1to3_64b(input, len, secret, seed);\n return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64)));\n }\n}\n\n/*\n * DISCLAIMER: There are known *seed-dependent* multicollisions here due to\n * multiplication by zero, affecting hashes of lengths 17 to 240.\n *\n * However, they are very unlikely.\n *\n * Keep this in mind when using the unseeded XXH3_64bits() variant: As with all\n * unseeded non-cryptographic hashes, it does not attempt to defend itself\n * against specially crafted inputs, only random inputs.\n *\n * Compared to classic UMAC where a 1 in 2^31 chance of 4 consecutive bytes\n * cancelling out the secret is taken an arbitrary number of times (addressed\n * in XXH3_accumulate_512), this collision is very unlikely with random inputs\n * and/or proper seeding:\n *\n * This only has a 1 in 2^63 chance of 8 consecutive bytes cancelling out, in a\n * function that is only called up to 16 times per hash with up to 240 bytes of\n * input.\n *\n * This is not too bad for a non-cryptographic hash function, especially with\n * only 64 bit outputs.\n *\n * The 128-bit variant (which trades some speed for strength) is NOT affected\n * by this, although it is always a good idea to use a proper seed if you care\n * about strength.\n */\nXXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,\n const xxh_u8* XXH_RESTRICT secret, xxh_u64 seed64)\n{\n#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \\\n && defined(__i386__) && defined(__SSE2__) /* x86 + SSE2 */ \\\n && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable like XXH32 hack */\n /*\n * UGLY HACK:\n * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in\n * slower code.\n *\n * By forcing seed64 into a register, we disrupt the cost model and\n * cause it to scalarize. See `XXH32_round()`\n *\n * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,\n * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on\n * GCC 9.2, despite both emitting scalar code.\n *\n * GCC generates much better scalar code than Clang for the rest of XXH3,\n * which is why finding a more optimal codepath is an interest.\n */\n XXH_COMPILER_GUARD(seed64);\n#endif\n { xxh_u64 const input_lo = XXH_readLE64(input);\n xxh_u64 const input_hi = XXH_readLE64(input+8);\n return XXH3_mul128_fold64(\n input_lo ^ (XXH_readLE64(secret) + seed64),\n input_hi ^ (XXH_readLE64(secret+8) - seed64)\n );\n }\n}\n\n/* For mid range keys, XXH3 uses a Mum-hash variant. */\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH64_hash_t seed)\n{\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n XXH_ASSERT(16 < len && len <= 128);\n\n { xxh_u64 acc = len * XXH_PRIME64_1;\n#if XXH_SIZE_OPT >= 1\n /* Smaller and cleaner, but slightly slower. */\n unsigned int i = (unsigned int)(len - 1) / 32;\n do {\n acc += XXH3_mix16B(input+16 * i, secret+32*i, seed);\n acc += XXH3_mix16B(input+len-16*(i+1), secret+32*i+16, seed);\n } while (i-- != 0);\n#else\n if (len > 32) {\n if (len > 64) {\n if (len > 96) {\n acc += XXH3_mix16B(input+48, secret+96, seed);\n acc += XXH3_mix16B(input+len-64, secret+112, seed);\n }\n acc += XXH3_mix16B(input+32, secret+64, seed);\n acc += XXH3_mix16B(input+len-48, secret+80, seed);\n }\n acc += XXH3_mix16B(input+16, secret+32, seed);\n acc += XXH3_mix16B(input+len-32, secret+48, seed);\n }\n acc += XXH3_mix16B(input+0, secret+0, seed);\n acc += XXH3_mix16B(input+len-16, secret+16, seed);\n#endif\n return XXH3_avalanche(acc);\n }\n}\n\nXXH_NO_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH64_hash_t seed)\n{\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n\n #define XXH3_MIDSIZE_STARTOFFSET 3\n #define XXH3_MIDSIZE_LASTOFFSET 17\n\n { xxh_u64 acc = len * XXH_PRIME64_1;\n xxh_u64 acc_end;\n unsigned int const nbRounds = (unsigned int)len / 16;\n unsigned int i;\n XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n for (i=0; i<8; i++) {\n acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed);\n }\n /* last bytes */\n acc_end = XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);\n XXH_ASSERT(nbRounds >= 8);\n acc = XXH3_avalanche(acc);\n#if defined(__clang__) /* Clang */ \\\n && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \\\n && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable */\n /*\n * UGLY HACK:\n * Clang for ARMv7-A tries to vectorize this loop, similar to GCC x86.\n * In everywhere else, it uses scalar code.\n *\n * For 64->128-bit multiplies, even if the NEON was 100% optimal, it\n * would still be slower than UMAAL (see XXH_mult64to128).\n *\n * Unfortunately, Clang doesn't handle the long multiplies properly and\n * converts them to the nonexistent \"vmulq_u64\" intrinsic, which is then\n * scalarized into an ugly mess of VMOV.32 instructions.\n *\n * This mess is difficult to avoid without turning autovectorization\n * off completely, but they are usually relatively minor and/or not\n * worth it to fix.\n *\n * This loop is the easiest to fix, as unlike XXH32, this pragma\n * _actually works_ because it is a loop vectorization instead of an\n * SLP vectorization.\n */\n #pragma clang loop vectorize(disable)\n#endif\n for (i=8 ; i < nbRounds; i++) {\n /*\n * Prevents clang for unrolling the acc loop and interleaving with this one.\n */\n XXH_COMPILER_GUARD(acc);\n acc_end += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);\n }\n return XXH3_avalanche(acc + acc_end);\n }\n}\n\n\n/* ======= Long Keys ======= */\n\n#define XXH_STRIPE_LEN 64\n#define XXH_SECRET_CONSUME_RATE 8 /* nb of secret bytes consumed at each accumulation */\n#define XXH_ACC_NB (XXH_STRIPE_LEN / sizeof(xxh_u64))\n\n#ifdef XXH_OLD_NAMES\n# define STRIPE_LEN XXH_STRIPE_LEN\n# define ACC_NB XXH_ACC_NB\n#endif\n\n#ifndef XXH_PREFETCH_DIST\n# ifdef __clang__\n# define XXH_PREFETCH_DIST 320\n# else\n# if (XXH_VECTOR == XXH_AVX512)\n# define XXH_PREFETCH_DIST 512\n# else\n# define XXH_PREFETCH_DIST 384\n# endif\n# endif /* __clang__ */\n#endif /* XXH_PREFETCH_DIST */\n\n/*\n * These macros are to generate an XXH3_accumulate() function.\n * The two arguments select the name suffix and target attribute.\n *\n * The name of this symbol is XXH3_accumulate_() and it calls\n * XXH3_accumulate_512_().\n *\n * It may be useful to hand implement this function if the compiler fails to\n * optimize the inline function.\n */\n#define XXH3_ACCUMULATE_TEMPLATE(name) \\\nvoid \\\nXXH3_accumulate_##name(xxh_u64* XXH_RESTRICT acc, \\\n const xxh_u8* XXH_RESTRICT input, \\\n const xxh_u8* XXH_RESTRICT secret, \\\n size_t nbStripes) \\\n{ \\\n size_t n; \\\n for (n = 0; n < nbStripes; n++ ) { \\\n const xxh_u8* const in = input + n*XXH_STRIPE_LEN; \\\n XXH_PREFETCH(in + XXH_PREFETCH_DIST); \\\n XXH3_accumulate_512_##name( \\\n acc, \\\n in, \\\n secret + n*XXH_SECRET_CONSUME_RATE); \\\n } \\\n}\n\n\nXXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)\n{\n if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64);\n XXH_memcpy(dst, &v64, sizeof(v64));\n}\n\n/* Several intrinsic functions below are supposed to accept __int64 as argument,\n * as documented in https://software.intel.com/sites/landingpage/IntrinsicsGuide/ .\n * However, several environments do not define __int64 type,\n * requiring a workaround.\n */\n#if !defined (__VMS) \\\n && (defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n typedef int64_t xxh_i64;\n#else\n /* the following type must have a width of 64-bit */\n typedef long long xxh_i64;\n#endif\n\n\n/*\n * XXH3_accumulate_512 is the tightest loop for long inputs, and it is the most optimized.\n *\n * It is a hardened version of UMAC, based off of FARSH's implementation.\n *\n * This was chosen because it adapts quite well to 32-bit, 64-bit, and SIMD\n * implementations, and it is ridiculously fast.\n *\n * We harden it by mixing the original input to the accumulators as well as the product.\n *\n * This means that in the (relatively likely) case of a multiply by zero, the\n * original input is preserved.\n *\n * On 128-bit inputs, we swap 64-bit pairs when we add the input to improve\n * cross-pollination, as otherwise the upper and lower halves would be\n * essentially independent.\n *\n * This doesn't matter on 64-bit hashes since they all get merged together in\n * the end, so we skip the extra step.\n *\n * Both XXH3_64bits and XXH3_128bits use this subroutine.\n */\n\n#if (XXH_VECTOR == XXH_AVX512) \\\n || (defined(XXH_DISPATCH_AVX512) && XXH_DISPATCH_AVX512 != 0)\n\n#ifndef XXH_TARGET_AVX512\n# define XXH_TARGET_AVX512 /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_accumulate_512_avx512(void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n __m512i* const xacc = (__m512i *) acc;\n XXH_ASSERT((((size_t)acc) & 63) == 0);\n XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));\n\n {\n /* data_vec = input[0]; */\n __m512i const data_vec = _mm512_loadu_si512 (input);\n /* key_vec = secret[0]; */\n __m512i const key_vec = _mm512_loadu_si512 (secret);\n /* data_key = data_vec ^ key_vec; */\n __m512i const data_key = _mm512_xor_si512 (data_vec, key_vec);\n /* data_key_lo = data_key >> 32; */\n __m512i const data_key_lo = _mm512_srli_epi64 (data_key, 32);\n /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n __m512i const product = _mm512_mul_epu32 (data_key, data_key_lo);\n /* xacc[0] += swap(data_vec); */\n __m512i const data_swap = _mm512_shuffle_epi32(data_vec, (_MM_PERM_ENUM)_MM_SHUFFLE(1, 0, 3, 2));\n __m512i const sum = _mm512_add_epi64(*xacc, data_swap);\n /* xacc[0] += product; */\n *xacc = _mm512_add_epi64(product, sum);\n }\n}\nXXH_FORCE_INLINE XXH_TARGET_AVX512 XXH3_ACCUMULATE_TEMPLATE(avx512)\n\n/*\n * XXH3_scrambleAcc: Scrambles the accumulators to improve mixing.\n *\n * Multiplication isn't perfect, as explained by Google in HighwayHash:\n *\n * // Multiplication mixes/scrambles bytes 0-7 of the 64-bit result to\n * // varying degrees. In descending order of goodness, bytes\n * // 3 4 2 5 1 6 0 7 have quality 228 224 164 160 100 96 36 32.\n * // As expected, the upper and lower bytes are much worse.\n *\n * Source: https://github.com/google/highwayhash/blob/0aaf66b/highwayhash/hh_avx2.h#L291\n *\n * Since our algorithm uses a pseudorandom secret to add some variance into the\n * mix, we don't need to (or want to) mix as often or as much as HighwayHash does.\n *\n * This isn't as tight as XXH3_accumulate, but still written in SIMD to avoid\n * extraction.\n *\n * Both XXH3_64bits and XXH3_128bits use this subroutine.\n */\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_scrambleAcc_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 63) == 0);\n XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));\n { __m512i* const xacc = (__m512i*) acc;\n const __m512i prime32 = _mm512_set1_epi32((int)XXH_PRIME32_1);\n\n /* xacc[0] ^= (xacc[0] >> 47) */\n __m512i const acc_vec = *xacc;\n __m512i const shifted = _mm512_srli_epi64 (acc_vec, 47);\n /* xacc[0] ^= secret; */\n __m512i const key_vec = _mm512_loadu_si512 (secret);\n __m512i const data_key = _mm512_ternarylogic_epi32(key_vec, acc_vec, shifted, 0x96 /* key_vec ^ acc_vec ^ shifted */);\n\n /* xacc[0] *= XXH_PRIME32_1; */\n __m512i const data_key_hi = _mm512_srli_epi64 (data_key, 32);\n __m512i const prod_lo = _mm512_mul_epu32 (data_key, prime32);\n __m512i const prod_hi = _mm512_mul_epu32 (data_key_hi, prime32);\n *xacc = _mm512_add_epi64(prod_lo, _mm512_slli_epi64(prod_hi, 32));\n }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 63) == 0);\n XXH_STATIC_ASSERT(XXH_SEC_ALIGN == 64);\n XXH_ASSERT(((size_t)customSecret & 63) == 0);\n (void)(&XXH_writeLE64);\n { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m512i);\n __m512i const seed_pos = _mm512_set1_epi64((xxh_i64)seed64);\n __m512i const seed = _mm512_mask_sub_epi64(seed_pos, 0xAA, _mm512_set1_epi8(0), seed_pos);\n\n const __m512i* const src = (const __m512i*) ((const void*) XXH3_kSecret);\n __m512i* const dest = ( __m512i*) customSecret;\n int i;\n XXH_ASSERT(((size_t)src & 63) == 0); /* control alignment */\n XXH_ASSERT(((size_t)dest & 63) == 0);\n for (i=0; i < nbRounds; ++i) {\n dest[i] = _mm512_add_epi64(_mm512_load_si512(src + i), seed);\n } }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_AVX2) \\\n || (defined(XXH_DISPATCH_AVX2) && XXH_DISPATCH_AVX2 != 0)\n\n#ifndef XXH_TARGET_AVX2\n# define XXH_TARGET_AVX2 /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void\nXXH3_accumulate_512_avx2( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 31) == 0);\n { __m256i* const xacc = (__m256i *) acc;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */\n const __m256i* const xinput = (const __m256i *) input;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */\n const __m256i* const xsecret = (const __m256i *) secret;\n\n size_t i;\n for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {\n /* data_vec = xinput[i]; */\n __m256i const data_vec = _mm256_loadu_si256 (xinput+i);\n /* key_vec = xsecret[i]; */\n __m256i const key_vec = _mm256_loadu_si256 (xsecret+i);\n /* data_key = data_vec ^ key_vec; */\n __m256i const data_key = _mm256_xor_si256 (data_vec, key_vec);\n /* data_key_lo = data_key >> 32; */\n __m256i const data_key_lo = _mm256_srli_epi64 (data_key, 32);\n /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n __m256i const product = _mm256_mul_epu32 (data_key, data_key_lo);\n /* xacc[i] += swap(data_vec); */\n __m256i const data_swap = _mm256_shuffle_epi32(data_vec, _MM_SHUFFLE(1, 0, 3, 2));\n __m256i const sum = _mm256_add_epi64(xacc[i], data_swap);\n /* xacc[i] += product; */\n xacc[i] = _mm256_add_epi64(product, sum);\n } }\n}\nXXH_FORCE_INLINE XXH_TARGET_AVX2 XXH3_ACCUMULATE_TEMPLATE(avx2)\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void\nXXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 31) == 0);\n { __m256i* const xacc = (__m256i*) acc;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */\n const __m256i* const xsecret = (const __m256i *) secret;\n const __m256i prime32 = _mm256_set1_epi32((int)XXH_PRIME32_1);\n\n size_t i;\n for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {\n /* xacc[i] ^= (xacc[i] >> 47) */\n __m256i const acc_vec = xacc[i];\n __m256i const shifted = _mm256_srli_epi64 (acc_vec, 47);\n __m256i const data_vec = _mm256_xor_si256 (acc_vec, shifted);\n /* xacc[i] ^= xsecret; */\n __m256i const key_vec = _mm256_loadu_si256 (xsecret+i);\n __m256i const data_key = _mm256_xor_si256 (data_vec, key_vec);\n\n /* xacc[i] *= XXH_PRIME32_1; */\n __m256i const data_key_hi = _mm256_srli_epi64 (data_key, 32);\n __m256i const prod_lo = _mm256_mul_epu32 (data_key, prime32);\n __m256i const prod_hi = _mm256_mul_epu32 (data_key_hi, prime32);\n xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32));\n }\n }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 31) == 0);\n XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE / sizeof(__m256i)) == 6);\n XXH_STATIC_ASSERT(XXH_SEC_ALIGN <= 64);\n (void)(&XXH_writeLE64);\n XXH_PREFETCH(customSecret);\n { __m256i const seed = _mm256_set_epi64x((xxh_i64)(0U - seed64), (xxh_i64)seed64, (xxh_i64)(0U - seed64), (xxh_i64)seed64);\n\n const __m256i* const src = (const __m256i*) ((const void*) XXH3_kSecret);\n __m256i* dest = ( __m256i*) customSecret;\n\n# if defined(__GNUC__) || defined(__clang__)\n /*\n * On GCC & Clang, marking 'dest' as modified will cause the compiler:\n * - do not extract the secret from sse registers in the internal loop\n * - use less common registers, and avoid pushing these reg into stack\n */\n XXH_COMPILER_GUARD(dest);\n# endif\n XXH_ASSERT(((size_t)src & 31) == 0); /* control alignment */\n XXH_ASSERT(((size_t)dest & 31) == 0);\n\n /* GCC -O2 need unroll loop manually */\n dest[0] = _mm256_add_epi64(_mm256_load_si256(src+0), seed);\n dest[1] = _mm256_add_epi64(_mm256_load_si256(src+1), seed);\n dest[2] = _mm256_add_epi64(_mm256_load_si256(src+2), seed);\n dest[3] = _mm256_add_epi64(_mm256_load_si256(src+3), seed);\n dest[4] = _mm256_add_epi64(_mm256_load_si256(src+4), seed);\n dest[5] = _mm256_add_epi64(_mm256_load_si256(src+5), seed);\n }\n}\n\n#endif\n\n/* x86dispatch always generates SSE2 */\n#if (XXH_VECTOR == XXH_SSE2) || defined(XXH_X86DISPATCH)\n\n#ifndef XXH_TARGET_SSE2\n# define XXH_TARGET_SSE2 /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void\nXXH3_accumulate_512_sse2( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n /* SSE2 is just a half-scale version of the AVX2 version. */\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n { __m128i* const xacc = (__m128i *) acc;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n const __m128i* const xinput = (const __m128i *) input;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n const __m128i* const xsecret = (const __m128i *) secret;\n\n size_t i;\n for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {\n /* data_vec = xinput[i]; */\n __m128i const data_vec = _mm_loadu_si128 (xinput+i);\n /* key_vec = xsecret[i]; */\n __m128i const key_vec = _mm_loadu_si128 (xsecret+i);\n /* data_key = data_vec ^ key_vec; */\n __m128i const data_key = _mm_xor_si128 (data_vec, key_vec);\n /* data_key_lo = data_key >> 32; */\n __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));\n /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n __m128i const product = _mm_mul_epu32 (data_key, data_key_lo);\n /* xacc[i] += swap(data_vec); */\n __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2));\n __m128i const sum = _mm_add_epi64(xacc[i], data_swap);\n /* xacc[i] += product; */\n xacc[i] = _mm_add_epi64(product, sum);\n } }\n}\nXXH_FORCE_INLINE XXH_TARGET_SSE2 XXH3_ACCUMULATE_TEMPLATE(sse2)\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void\nXXH3_scrambleAcc_sse2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n { __m128i* const xacc = (__m128i*) acc;\n /* Unaligned. This is mainly for pointer arithmetic, and because\n * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n const __m128i* const xsecret = (const __m128i *) secret;\n const __m128i prime32 = _mm_set1_epi32((int)XXH_PRIME32_1);\n\n size_t i;\n for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {\n /* xacc[i] ^= (xacc[i] >> 47) */\n __m128i const acc_vec = xacc[i];\n __m128i const shifted = _mm_srli_epi64 (acc_vec, 47);\n __m128i const data_vec = _mm_xor_si128 (acc_vec, shifted);\n /* xacc[i] ^= xsecret[i]; */\n __m128i const key_vec = _mm_loadu_si128 (xsecret+i);\n __m128i const data_key = _mm_xor_si128 (data_vec, key_vec);\n\n /* xacc[i] *= XXH_PRIME32_1; */\n __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));\n __m128i const prod_lo = _mm_mul_epu32 (data_key, prime32);\n __m128i const prod_hi = _mm_mul_epu32 (data_key_hi, prime32);\n xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32));\n }\n }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);\n (void)(&XXH_writeLE64);\n { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i);\n\n# if defined(_MSC_VER) && defined(_M_IX86) && _MSC_VER <= 1900\n /* MSVC 32bit mode does not support _mm_set_epi64x before 2015\n * and some specific variants of 2015 may also lack it */\n /* Cast to unsigned 64-bit first to avoid signed arithmetic issues */\n xxh_u64 const seed64_unsigned = (xxh_u64)seed64;\n xxh_u64 const neg_seed64 = (xxh_u64)(0ULL - seed64_unsigned);\n __m128i const seed = _mm_set_epi32(\n (int)(neg_seed64 >> 32), /* high 32 bits of negated seed */\n (int)(neg_seed64), /* low 32 bits of negated seed */\n (int)(seed64_unsigned >> 32), /* high 32 bits of original seed */\n (int)(seed64_unsigned) /* low 32 bits of original seed */\n );\n# else\n __m128i const seed = _mm_set_epi64x((xxh_i64)(0U - seed64), (xxh_i64)seed64);\n# endif\n int i;\n\n const void* const src16 = XXH3_kSecret;\n __m128i* dst16 = (__m128i*) customSecret;\n# if defined(__GNUC__) || defined(__clang__)\n /*\n * On GCC & Clang, marking 'dest' as modified will cause the compiler:\n * - do not extract the secret from sse registers in the internal loop\n * - use less common registers, and avoid pushing these reg into stack\n */\n XXH_COMPILER_GUARD(dst16);\n# endif\n XXH_ASSERT(((size_t)src16 & 15) == 0); /* control alignment */\n XXH_ASSERT(((size_t)dst16 & 15) == 0);\n\n for (i=0; i < nbRounds; ++i) {\n dst16[i] = _mm_add_epi64(_mm_load_si128((const __m128i *)src16+i), seed);\n } }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_NEON)\n\n/* forward declarations for the scalar routines */\nXXH_FORCE_INLINE void\nXXH3_scalarRound(void* XXH_RESTRICT acc, void const* XXH_RESTRICT input,\n void const* XXH_RESTRICT secret, size_t lane);\n\nXXH_FORCE_INLINE void\nXXH3_scalarScrambleRound(void* XXH_RESTRICT acc,\n void const* XXH_RESTRICT secret, size_t lane);\n\n/*!\n * @internal\n * @brief The bulk processing loop for NEON and WASM SIMD128.\n *\n * The NEON code path is actually partially scalar when running on AArch64. This\n * is to optimize the pipelining and can have up to 15% speedup depending on the\n * CPU, and it also mitigates some GCC codegen issues.\n *\n * @see XXH3_NEON_LANES for configuring this and details about this optimization.\n *\n * NEON's 32-bit to 64-bit long multiply takes a half vector of 32-bit\n * integers instead of the other platforms which mask full 64-bit vectors,\n * so the setup is more complicated than just shifting right.\n *\n * Additionally, there is an optimization for 4 lanes at once noted below.\n *\n * Since, as stated, the most optimal amount of lanes for Cortexes is 6,\n * there needs to be *three* versions of the accumulate operation used\n * for the remaining 2 lanes.\n *\n * WASM's SIMD128 uses SIMDe's arm_neon.h polyfill because the intrinsics overlap\n * nearly perfectly.\n */\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_neon( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n XXH_STATIC_ASSERT(XXH3_NEON_LANES > 0 && XXH3_NEON_LANES <= XXH_ACC_NB && XXH3_NEON_LANES % 2 == 0);\n { /* GCC for darwin arm64 does not like aliasing here */\n xxh_aliasing_uint64x2_t* const xacc = (xxh_aliasing_uint64x2_t*) acc;\n /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */\n uint8_t const* xinput = (const uint8_t *) input;\n uint8_t const* xsecret = (const uint8_t *) secret;\n\n size_t i;\n#ifdef __wasm_simd128__\n /*\n * On WASM SIMD128, Clang emits direct address loads when XXH3_kSecret\n * is constant propagated, which results in it converting it to this\n * inside the loop:\n *\n * a = v128.load(XXH3_kSecret + 0 + $secret_offset, offset = 0)\n * b = v128.load(XXH3_kSecret + 16 + $secret_offset, offset = 0)\n * ...\n *\n * This requires a full 32-bit address immediate (and therefore a 6 byte\n * instruction) as well as an add for each offset.\n *\n * Putting an asm guard prevents it from folding (at the cost of losing\n * the alignment hint), and uses the free offset in `v128.load` instead\n * of adding secret_offset each time which overall reduces code size by\n * about a kilobyte and improves performance.\n */\n XXH_COMPILER_GUARD(xsecret);\n#endif\n /* Scalar lanes use the normal scalarRound routine */\n for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {\n XXH3_scalarRound(acc, input, secret, i);\n }\n i = 0;\n /* 4 NEON lanes at a time. */\n for (; i+1 < XXH3_NEON_LANES / 2; i+=2) {\n /* data_vec = xinput[i]; */\n uint64x2_t data_vec_1 = XXH_vld1q_u64(xinput + (i * 16));\n uint64x2_t data_vec_2 = XXH_vld1q_u64(xinput + ((i+1) * 16));\n /* key_vec = xsecret[i]; */\n uint64x2_t key_vec_1 = XXH_vld1q_u64(xsecret + (i * 16));\n uint64x2_t key_vec_2 = XXH_vld1q_u64(xsecret + ((i+1) * 16));\n /* data_swap = swap(data_vec) */\n uint64x2_t data_swap_1 = vextq_u64(data_vec_1, data_vec_1, 1);\n uint64x2_t data_swap_2 = vextq_u64(data_vec_2, data_vec_2, 1);\n /* data_key = data_vec ^ key_vec; */\n uint64x2_t data_key_1 = veorq_u64(data_vec_1, key_vec_1);\n uint64x2_t data_key_2 = veorq_u64(data_vec_2, key_vec_2);\n\n /*\n * If we reinterpret the 64x2 vectors as 32x4 vectors, we can use a\n * de-interleave operation for 4 lanes in 1 step with `vuzpq_u32` to\n * get one vector with the low 32 bits of each lane, and one vector\n * with the high 32 bits of each lane.\n *\n * The intrinsic returns a double vector because the original ARMv7-a\n * instruction modified both arguments in place. AArch64 and SIMD128 emit\n * two instructions from this intrinsic.\n *\n * [ dk11L | dk11H | dk12L | dk12H ] -> [ dk11L | dk12L | dk21L | dk22L ]\n * [ dk21L | dk21H | dk22L | dk22H ] -> [ dk11H | dk12H | dk21H | dk22H ]\n */\n uint32x4x2_t unzipped = vuzpq_u32(\n vreinterpretq_u32_u64(data_key_1),\n vreinterpretq_u32_u64(data_key_2)\n );\n /* data_key_lo = data_key & 0xFFFFFFFF */\n uint32x4_t data_key_lo = unzipped.val[0];\n /* data_key_hi = data_key >> 32 */\n uint32x4_t data_key_hi = unzipped.val[1];\n /*\n * Then, we can split the vectors horizontally and multiply which, as for most\n * widening intrinsics, have a variant that works on both high half vectors\n * for free on AArch64. A similar instruction is available on SIMD128.\n *\n * sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi\n */\n uint64x2_t sum_1 = XXH_vmlal_low_u32(data_swap_1, data_key_lo, data_key_hi);\n uint64x2_t sum_2 = XXH_vmlal_high_u32(data_swap_2, data_key_lo, data_key_hi);\n /*\n * Clang reorders\n * a += b * c; // umlal swap.2d, dkl.2s, dkh.2s\n * c += a; // add acc.2d, acc.2d, swap.2d\n * to\n * c += a; // add acc.2d, acc.2d, swap.2d\n * c += b * c; // umlal acc.2d, dkl.2s, dkh.2s\n *\n * While it would make sense in theory since the addition is faster,\n * for reasons likely related to umlal being limited to certain NEON\n * pipelines, this is worse. A compiler guard fixes this.\n */\n XXH_COMPILER_GUARD_CLANG_NEON(sum_1);\n XXH_COMPILER_GUARD_CLANG_NEON(sum_2);\n /* xacc[i] = acc_vec + sum; */\n xacc[i] = vaddq_u64(xacc[i], sum_1);\n xacc[i+1] = vaddq_u64(xacc[i+1], sum_2);\n }\n /* Operate on the remaining NEON lanes 2 at a time. */\n for (; i < XXH3_NEON_LANES / 2; i++) {\n /* data_vec = xinput[i]; */\n uint64x2_t data_vec = XXH_vld1q_u64(xinput + (i * 16));\n /* key_vec = xsecret[i]; */\n uint64x2_t key_vec = XXH_vld1q_u64(xsecret + (i * 16));\n /* acc_vec_2 = swap(data_vec) */\n uint64x2_t data_swap = vextq_u64(data_vec, data_vec, 1);\n /* data_key = data_vec ^ key_vec; */\n uint64x2_t data_key = veorq_u64(data_vec, key_vec);\n /* For two lanes, just use VMOVN and VSHRN. */\n /* data_key_lo = data_key & 0xFFFFFFFF; */\n uint32x2_t data_key_lo = vmovn_u64(data_key);\n /* data_key_hi = data_key >> 32; */\n uint32x2_t data_key_hi = vshrn_n_u64(data_key, 32);\n /* sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi; */\n uint64x2_t sum = vmlal_u32(data_swap, data_key_lo, data_key_hi);\n /* Same Clang workaround as before */\n XXH_COMPILER_GUARD_CLANG_NEON(sum);\n /* xacc[i] = acc_vec + sum; */\n xacc[i] = vaddq_u64 (xacc[i], sum);\n }\n }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(neon)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_neon(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n\n { xxh_aliasing_uint64x2_t* xacc = (xxh_aliasing_uint64x2_t*) acc;\n uint8_t const* xsecret = (uint8_t const*) secret;\n\n size_t i;\n /* WASM uses operator overloads and doesn't need these. */\n#ifndef __wasm_simd128__\n /* { prime32_1, prime32_1 } */\n uint32x2_t const kPrimeLo = vdup_n_u32(XXH_PRIME32_1);\n /* { 0, prime32_1, 0, prime32_1 } */\n uint32x4_t const kPrimeHi = vreinterpretq_u32_u64(vdupq_n_u64((xxh_u64)XXH_PRIME32_1 << 32));\n#endif\n\n /* AArch64 uses both scalar and neon at the same time */\n for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {\n XXH3_scalarScrambleRound(acc, secret, i);\n }\n for (i=0; i < XXH3_NEON_LANES / 2; i++) {\n /* xacc[i] ^= (xacc[i] >> 47); */\n uint64x2_t acc_vec = xacc[i];\n uint64x2_t shifted = vshrq_n_u64(acc_vec, 47);\n uint64x2_t data_vec = veorq_u64(acc_vec, shifted);\n\n /* xacc[i] ^= xsecret[i]; */\n uint64x2_t key_vec = XXH_vld1q_u64(xsecret + (i * 16));\n uint64x2_t data_key = veorq_u64(data_vec, key_vec);\n /* xacc[i] *= XXH_PRIME32_1 */\n#ifdef __wasm_simd128__\n /* SIMD128 has multiply by u64x2, use it instead of expanding and scalarizing */\n xacc[i] = data_key * XXH_PRIME32_1;\n#else\n /*\n * Expanded version with portable NEON intrinsics\n *\n * lo(x) * lo(y) + (hi(x) * lo(y) << 32)\n *\n * prod_hi = hi(data_key) * lo(prime) << 32\n *\n * Since we only need 32 bits of this multiply a trick can be used, reinterpreting the vector\n * as a uint32x4_t and multiplying by { 0, prime, 0, prime } to cancel out the unwanted bits\n * and avoid the shift.\n */\n uint32x4_t prod_hi = vmulq_u32 (vreinterpretq_u32_u64(data_key), kPrimeHi);\n /* Extract low bits for vmlal_u32 */\n uint32x2_t data_key_lo = vmovn_u64(data_key);\n /* xacc[i] = prod_hi + lo(data_key) * XXH_PRIME32_1; */\n xacc[i] = vmlal_u32(vreinterpretq_u64_u32(prod_hi), data_key_lo, kPrimeLo);\n#endif\n }\n }\n}\n#endif\n\n#if (XXH_VECTOR == XXH_VSX)\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_vsx( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n /* presumed aligned */\n xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;\n xxh_u8 const* const xinput = (xxh_u8 const*) input; /* no alignment restriction */\n xxh_u8 const* const xsecret = (xxh_u8 const*) secret; /* no alignment restriction */\n xxh_u64x2 const v32 = { 32, 32 };\n size_t i;\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {\n /* data_vec = xinput[i]; */\n xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + 16*i);\n /* key_vec = xsecret[i]; */\n xxh_u64x2 const key_vec = XXH_vec_loadu(xsecret + 16*i);\n xxh_u64x2 const data_key = data_vec ^ key_vec;\n /* shuffled = (data_key << 32) | (data_key >> 32); */\n xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32);\n /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */\n xxh_u64x2 const product = XXH_vec_mulo((xxh_u32x4)data_key, shuffled);\n /* acc_vec = xacc[i]; */\n xxh_u64x2 acc_vec = xacc[i];\n acc_vec += product;\n\n /* swap high and low halves */\n#ifdef __s390x__\n acc_vec += vec_permi(data_vec, data_vec, 2);\n#else\n acc_vec += vec_xxpermdi(data_vec, data_vec, 2);\n#endif\n xacc[i] = acc_vec;\n }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(vsx)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n\n { xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;\n const xxh_u8* const xsecret = (const xxh_u8*) secret;\n /* constants */\n xxh_u64x2 const v32 = { 32, 32 };\n xxh_u64x2 const v47 = { 47, 47 };\n xxh_u32x4 const prime = { XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1 };\n size_t i;\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {\n /* xacc[i] ^= (xacc[i] >> 47); */\n xxh_u64x2 const acc_vec = xacc[i];\n xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47);\n\n /* xacc[i] ^= xsecret[i]; */\n xxh_u64x2 const key_vec = XXH_vec_loadu(xsecret + 16*i);\n xxh_u64x2 const data_key = data_vec ^ key_vec;\n\n /* xacc[i] *= XXH_PRIME32_1 */\n /* prod_lo = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)prime & 0xFFFFFFFF); */\n xxh_u64x2 const prod_even = XXH_vec_mule((xxh_u32x4)data_key, prime);\n /* prod_hi = ((xxh_u64x2)data_key >> 32) * ((xxh_u64x2)prime >> 32); */\n xxh_u64x2 const prod_odd = XXH_vec_mulo((xxh_u32x4)data_key, prime);\n xacc[i] = prod_odd + (prod_even << v32);\n } }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_SVE)\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_sve( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n uint64_t *xacc = (uint64_t *)acc;\n const uint64_t *xinput = (const uint64_t *)(const void *)input;\n const uint64_t *xsecret = (const uint64_t *)(const void *)secret;\n svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);\n uint64_t element_count = svcntd();\n if (element_count >= 8) {\n svbool_t mask = svptrue_pat_b64(SV_VL8);\n svuint64_t vacc = svld1_u64(mask, xacc);\n ACCRND(vacc, 0);\n svst1_u64(mask, xacc, vacc);\n } else if (element_count == 2) { /* sve128 */\n svbool_t mask = svptrue_pat_b64(SV_VL2);\n svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n svuint64_t acc1 = svld1_u64(mask, xacc + 2);\n svuint64_t acc2 = svld1_u64(mask, xacc + 4);\n svuint64_t acc3 = svld1_u64(mask, xacc + 6);\n ACCRND(acc0, 0);\n ACCRND(acc1, 2);\n ACCRND(acc2, 4);\n ACCRND(acc3, 6);\n svst1_u64(mask, xacc + 0, acc0);\n svst1_u64(mask, xacc + 2, acc1);\n svst1_u64(mask, xacc + 4, acc2);\n svst1_u64(mask, xacc + 6, acc3);\n } else {\n svbool_t mask = svptrue_pat_b64(SV_VL4);\n svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n svuint64_t acc1 = svld1_u64(mask, xacc + 4);\n ACCRND(acc0, 0);\n ACCRND(acc1, 4);\n svst1_u64(mask, xacc + 0, acc0);\n svst1_u64(mask, xacc + 4, acc1);\n }\n}\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_sve(xxh_u64* XXH_RESTRICT acc,\n const xxh_u8* XXH_RESTRICT input,\n const xxh_u8* XXH_RESTRICT secret,\n size_t nbStripes)\n{\n if (nbStripes != 0) {\n uint64_t *xacc = (uint64_t *)acc;\n const uint64_t *xinput = (const uint64_t *)(const void *)input;\n const uint64_t *xsecret = (const uint64_t *)(const void *)secret;\n svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);\n uint64_t element_count = svcntd();\n if (element_count >= 8) {\n svbool_t mask = svptrue_pat_b64(SV_VL8);\n svuint64_t vacc = svld1_u64(mask, xacc + 0);\n do {\n /* svprfd(svbool_t, void *, enum svfprop); */\n svprfd(mask, xinput + 128, SV_PLDL1STRM);\n ACCRND(vacc, 0);\n xinput += 8;\n xsecret += 1;\n nbStripes--;\n } while (nbStripes != 0);\n\n svst1_u64(mask, xacc + 0, vacc);\n } else if (element_count == 2) { /* sve128 */\n svbool_t mask = svptrue_pat_b64(SV_VL2);\n svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n svuint64_t acc1 = svld1_u64(mask, xacc + 2);\n svuint64_t acc2 = svld1_u64(mask, xacc + 4);\n svuint64_t acc3 = svld1_u64(mask, xacc + 6);\n do {\n svprfd(mask, xinput + 128, SV_PLDL1STRM);\n ACCRND(acc0, 0);\n ACCRND(acc1, 2);\n ACCRND(acc2, 4);\n ACCRND(acc3, 6);\n xinput += 8;\n xsecret += 1;\n nbStripes--;\n } while (nbStripes != 0);\n\n svst1_u64(mask, xacc + 0, acc0);\n svst1_u64(mask, xacc + 2, acc1);\n svst1_u64(mask, xacc + 4, acc2);\n svst1_u64(mask, xacc + 6, acc3);\n } else {\n svbool_t mask = svptrue_pat_b64(SV_VL4);\n svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n svuint64_t acc1 = svld1_u64(mask, xacc + 4);\n do {\n svprfd(mask, xinput + 128, SV_PLDL1STRM);\n ACCRND(acc0, 0);\n ACCRND(acc1, 4);\n xinput += 8;\n xsecret += 1;\n nbStripes--;\n } while (nbStripes != 0);\n\n svst1_u64(mask, xacc + 0, acc0);\n svst1_u64(mask, xacc + 4, acc1);\n }\n }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_LSX)\n#define _LSX_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_lsx( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n {\n __m128i* const xacc = (__m128i *) acc;\n const __m128i* const xinput = (const __m128i *) input;\n const __m128i* const xsecret = (const __m128i *) secret;\n size_t i;\n\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m128i); i++) {\n /* data_vec = xinput[i]; */\n __m128i const data_vec = __lsx_vld(xinput + i, 0);\n /* key_vec = xsecret[i]; */\n __m128i const key_vec = __lsx_vld(xsecret + i, 0);\n /* data_key = data_vec ^ key_vec; */\n __m128i const data_key = __lsx_vxor_v(data_vec, key_vec);\n /* data_key_lo = data_key >> 32; */\n __m128i const data_key_lo = __lsx_vsrli_d(data_key, 32);\n // __m128i const data_key_lo = __lsx_vsrli_d(data_key, 32);\n /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n __m128i const product = __lsx_vmulwev_d_wu(data_key, data_key_lo);\n /* xacc[i] += swap(data_vec); */\n __m128i const data_swap = __lsx_vshuf4i_w(data_vec, _LSX_SHUFFLE(1, 0, 3, 2));\n __m128i const sum = __lsx_vadd_d(xacc[i], data_swap);\n /* xacc[i] += product; */\n xacc[i] = __lsx_vadd_d(product, sum);\n }\n }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(lsx)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_lsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n {\n __m128i* const xacc = (__m128i*) acc;\n const __m128i* const xsecret = (const __m128i *) secret;\n const __m128i prime32 = __lsx_vreplgr2vr_d(XXH_PRIME32_1);\n size_t i;\n\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m128i); i++) {\n /* xacc[i] ^= (xacc[i] >> 47) */\n __m128i const acc_vec = xacc[i];\n __m128i const shifted = __lsx_vsrli_d(acc_vec, 47);\n __m128i const data_vec = __lsx_vxor_v(acc_vec, shifted);\n /* xacc[i] ^= xsecret[i]; */\n __m128i const key_vec = __lsx_vld(xsecret + i, 0);\n __m128i const data_key = __lsx_vxor_v(data_vec, key_vec);\n\n /* xacc[i] *= XXH_PRIME32_1; */\n xacc[i] = __lsx_vmul_d(data_key, prime32);\n }\n }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_LASX)\n#define _LASX_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_lasx( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 31) == 0);\n {\n size_t i;\n __m256i* const xacc = (__m256i *) acc;\n const __m256i* const xinput = (const __m256i *) input;\n const __m256i* const xsecret = (const __m256i *) secret;\n\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m256i); i++) {\n /* data_vec = xinput[i]; */\n __m256i const data_vec = __lasx_xvld(xinput + i, 0);\n /* key_vec = xsecret[i]; */\n __m256i const key_vec = __lasx_xvld(xsecret + i, 0);\n /* data_key = data_vec ^ key_vec; */\n __m256i const data_key = __lasx_xvxor_v(data_vec, key_vec);\n /* data_key_lo = data_key >> 32; */\n __m256i const data_key_lo = __lasx_xvsrli_d(data_key, 32);\n // __m256i const data_key_lo = __lasx_xvsrli_d(data_key, 32);\n /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n __m256i const product = __lasx_xvmulwev_d_wu(data_key, data_key_lo);\n /* xacc[i] += swap(data_vec); */\n __m256i const data_swap = __lasx_xvshuf4i_w(data_vec, _LASX_SHUFFLE(1, 0, 3, 2));\n __m256i const sum = __lasx_xvadd_d(xacc[i], data_swap);\n /* xacc[i] += product; */\n xacc[i] = __lasx_xvadd_d(product, sum);\n }\n }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(lasx)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_lasx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 31) == 0);\n {\n __m256i* const xacc = (__m256i*) acc;\n const __m256i* const xsecret = (const __m256i *) secret;\n const __m256i prime32 = __lasx_xvreplgr2vr_d(XXH_PRIME32_1);\n size_t i;\n\n for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m256i); i++) {\n /* xacc[i] ^= (xacc[i] >> 47) */\n __m256i const acc_vec = xacc[i];\n __m256i const shifted = __lasx_xvsrli_d(acc_vec, 47);\n __m256i const data_vec = __lasx_xvxor_v(acc_vec, shifted);\n /* xacc[i] ^= xsecret[i]; */\n __m256i const key_vec = __lasx_xvld(xsecret + i, 0);\n __m256i const data_key = __lasx_xvxor_v(data_vec, key_vec);\n\n /* xacc[i] *= XXH_PRIME32_1; */\n xacc[i] = __lasx_xvmul_d(data_key, prime32);\n }\n }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_RVV)\n #define XXH_CONCAT2(X, Y) X ## Y\n #define XXH_CONCAT(X, Y) XXH_CONCAT2(X, Y)\n#if ((defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 13) || \\\n (defined(__clang__) && __clang_major__ < 16))\n #define XXH_RVOP(op) op\n #define XXH_RVCAST(op) XXH_CONCAT(vreinterpret_v_, op)\n#else\n #define XXH_RVOP(op) XXH_CONCAT(__riscv_, op)\n #define XXH_RVCAST(op) XXH_CONCAT(__riscv_vreinterpret_v_, op)\n#endif\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_rvv( void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 63) == 0);\n {\n // Try to set vector lenght to 512 bits.\n // If this length is unavailable, then maximum available will be used\n size_t vl = XXH_RVOP(vsetvl_e64m2)(8);\n\n uint64_t* xacc = (uint64_t*) acc;\n const uint64_t* xinput = (const uint64_t*) input;\n const uint64_t* xsecret = (const uint64_t*) secret;\n static const uint64_t swap_mask[16] = {1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14};\n vuint64m2_t xswap_mask = XXH_RVOP(vle64_v_u64m2)(swap_mask, vl);\n\n size_t i;\n for (i = 0; i < XXH_STRIPE_LEN/8; i += vl) {\n /* data_vec = xinput[i]; */\n vuint64m2_t data_vec = XXH_RVCAST(u8m2_u64m2)(XXH_RVOP(vle8_v_u8m2)((const uint8_t*)(xinput + i), vl * 8));\n /* key_vec = xsecret[i]; */\n vuint64m2_t key_vec = XXH_RVCAST(u8m2_u64m2)(XXH_RVOP(vle8_v_u8m2)((const uint8_t*)(xsecret + i), vl * 8));\n /* acc_vec = xacc[i]; */\n vuint64m2_t acc_vec = XXH_RVOP(vle64_v_u64m2)(xacc + i, vl);\n /* data_key = data_vec ^ key_vec; */\n vuint64m2_t data_key = XXH_RVOP(vxor_vv_u64m2)(data_vec, key_vec, vl);\n /* data_key_hi = data_key >> 32; */\n vuint64m2_t data_key_hi = XXH_RVOP(vsrl_vx_u64m2)(data_key, 32, vl);\n /* data_key_lo = data_key & 0xffffffff; */\n vuint64m2_t data_key_lo = XXH_RVOP(vand_vx_u64m2)(data_key, 0xffffffff, vl);\n /* swap high and low halves */\n vuint64m2_t data_swap = XXH_RVOP(vrgather_vv_u64m2)(data_vec, xswap_mask, vl);\n /* acc_vec += data_key_lo * data_key_hi; */\n acc_vec = XXH_RVOP(vmacc_vv_u64m2)(acc_vec, data_key_lo, data_key_hi, vl);\n /* acc_vec += data_swap; */\n acc_vec = XXH_RVOP(vadd_vv_u64m2)(acc_vec, data_swap, vl);\n /* xacc[i] = acc_vec; */\n XXH_RVOP(vse64_v_u64m2)(xacc + i, acc_vec, vl);\n }\n }\n}\n\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(rvv)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_rvv(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n XXH_ASSERT((((size_t)acc) & 15) == 0);\n {\n size_t count = XXH_STRIPE_LEN/8;\n uint64_t* xacc = (uint64_t*)acc;\n const uint8_t* xsecret = (const uint8_t *)secret;\n size_t vl;\n for (; count > 0; count -= vl, xacc += vl, xsecret += vl*8) {\n vl = XXH_RVOP(vsetvl_e64m2)(count);\n {\n /* key_vec = xsecret[i]; */\n vuint64m2_t key_vec = XXH_RVCAST(u8m2_u64m2)(XXH_RVOP(vle8_v_u8m2)(xsecret, vl*8));\n /* acc_vec = xacc[i]; */\n vuint64m2_t acc_vec = XXH_RVOP(vle64_v_u64m2)(xacc, vl);\n /* acc_vec ^= acc_vec >> 47; */\n vuint64m2_t vsrl = XXH_RVOP(vsrl_vx_u64m2)(acc_vec, 47, vl);\n acc_vec = XXH_RVOP(vxor_vv_u64m2)(acc_vec, vsrl, vl);\n /* acc_vec ^= key_vec; */\n acc_vec = XXH_RVOP(vxor_vv_u64m2)(acc_vec, key_vec, vl);\n /* acc_vec *= XXH_PRIME32_1; */\n acc_vec = XXH_RVOP(vmul_vx_u64m2)(acc_vec, XXH_PRIME32_1, vl);\n /* xacc[i] *= acc_vec; */\n XXH_RVOP(vse64_v_u64m2)(xacc, acc_vec, vl);\n }\n }\n }\n}\n\nXXH_FORCE_INLINE void\nXXH3_initCustomSecret_rvv(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n XXH_STATIC_ASSERT(XXH_SEC_ALIGN >= 8);\n XXH_ASSERT(((size_t)customSecret & 7) == 0);\n (void)(&XXH_writeLE64);\n {\n size_t count = XXH_SECRET_DEFAULT_SIZE/8;\n size_t vl;\n size_t VLMAX = XXH_RVOP(vsetvlmax_e64m2)();\n int64_t* cSecret = (int64_t*)customSecret;\n const int64_t* kSecret = (const int64_t*)(const void*)XXH3_kSecret;\n\n#if __riscv_v_intrinsic >= 1000000\n // ratified v1.0 intrinics version\n vbool32_t mneg = XXH_RVCAST(u8m1_b32)(\n XXH_RVOP(vmv_v_x_u8m1)(0xaa, XXH_RVOP(vsetvlmax_e8m1)()));\n#else\n // support pre-ratification intrinics, which lack mask to vector casts\n size_t vlmax = XXH_RVOP(vsetvlmax_e8m1)();\n vbool32_t mneg = XXH_RVOP(vmseq_vx_u8mf4_b32)(\n XXH_RVOP(vand_vx_u8mf4)(\n XXH_RVOP(vid_v_u8mf4)(vlmax), 1, vlmax), 1, vlmax);\n#endif\n vint64m2_t seed = XXH_RVOP(vmv_v_x_i64m2)((int64_t)seed64, VLMAX);\n seed = XXH_RVOP(vneg_v_i64m2_mu)(mneg, seed, seed, VLMAX);\n\n for (; count > 0; count -= vl, cSecret += vl, kSecret += vl) {\n /* make sure vl=VLMAX until last iteration */\n vl = XXH_RVOP(vsetvl_e64m2)(count < VLMAX ? count : VLMAX);\n {\n vint64m2_t src = XXH_RVOP(vle64_v_i64m2)(kSecret, vl);\n vint64m2_t res = XXH_RVOP(vadd_vv_i64m2)(src, seed, vl);\n XXH_RVOP(vse64_v_i64m2)(cSecret, res, vl);\n }\n }\n }\n}\n#endif\n\n\n/* scalar variants - universal */\n\n#if defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__))\n/*\n * In XXH3_scalarRound(), GCC and Clang have a similar codegen issue, where they\n * emit an excess mask and a full 64-bit multiply-add (MADD X-form).\n *\n * While this might not seem like much, as AArch64 is a 64-bit architecture, only\n * big Cortex designs have a full 64-bit multiplier.\n *\n * On the little cores, the smaller 32-bit multiplier is used, and full 64-bit\n * multiplies expand to 2-3 multiplies in microcode. This has a major penalty\n * of up to 4 latency cycles and 2 stall cycles in the multiply pipeline.\n *\n * Thankfully, AArch64 still provides the 32-bit long multiply-add (UMADDL) which does\n * not have this penalty and does the mask automatically.\n */\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)\n{\n xxh_u64 ret;\n /* note: %x = 64-bit register, %w = 32-bit register */\n __asm__(\"umaddl %x0, %w1, %w2, %x3\" : \"=r\" (ret) : \"r\" (lhs), \"r\" (rhs), \"r\" (acc));\n return ret;\n}\n#else\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)\n{\n return XXH_mult32to64((xxh_u32)lhs, (xxh_u32)rhs) + acc;\n}\n#endif\n\n/*!\n * @internal\n * @brief Scalar round for @ref XXH3_accumulate_512_scalar().\n *\n * This is extracted to its own function because the NEON path uses a combination\n * of NEON and scalar.\n */\nXXH_FORCE_INLINE void\nXXH3_scalarRound(void* XXH_RESTRICT acc,\n void const* XXH_RESTRICT input,\n void const* XXH_RESTRICT secret,\n size_t lane)\n{\n xxh_u64* xacc = (xxh_u64*) acc;\n xxh_u8 const* xinput = (xxh_u8 const*) input;\n xxh_u8 const* xsecret = (xxh_u8 const*) secret;\n XXH_ASSERT(lane < XXH_ACC_NB);\n XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);\n {\n xxh_u64 const data_val = XXH_readLE64(xinput + lane * 8);\n xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + lane * 8);\n xacc[lane ^ 1] += data_val; /* swap adjacent lanes */\n xacc[lane] = XXH_mult32to64_add64(data_key /* & 0xFFFFFFFF */, data_key >> 32, xacc[lane]);\n }\n}\n\n/*!\n * @internal\n * @brief Processes a 64 byte block of data using the scalar path.\n */\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_scalar(void* XXH_RESTRICT acc,\n const void* XXH_RESTRICT input,\n const void* XXH_RESTRICT secret)\n{\n size_t i;\n /* ARM GCC refuses to unroll this loop, resulting in a 24% slowdown on ARMv6. */\n#if defined(__GNUC__) && !defined(__clang__) \\\n && (defined(__arm__) || defined(__thumb2__)) \\\n && defined(__ARM_FEATURE_UNALIGNED) /* no unaligned access just wastes bytes */ \\\n && XXH_SIZE_OPT <= 0\n# pragma GCC unroll 8\n#endif\n for (i=0; i < XXH_ACC_NB; i++) {\n XXH3_scalarRound(acc, input, secret, i);\n }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(scalar)\n\n/*!\n * @internal\n * @brief Scalar scramble step for @ref XXH3_scrambleAcc_scalar().\n *\n * This is extracted to its own function because the NEON path uses a combination\n * of NEON and scalar.\n */\nXXH_FORCE_INLINE void\nXXH3_scalarScrambleRound(void* XXH_RESTRICT acc,\n void const* XXH_RESTRICT secret,\n size_t lane)\n{\n xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */\n const xxh_u8* const xsecret = (const xxh_u8*) secret; /* no alignment restriction */\n XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0);\n XXH_ASSERT(lane < XXH_ACC_NB);\n {\n xxh_u64 const key64 = XXH_readLE64(xsecret + lane * 8);\n xxh_u64 acc64 = xacc[lane];\n acc64 = XXH_xorshift64(acc64, 47);\n acc64 ^= key64;\n acc64 *= XXH_PRIME32_1;\n xacc[lane] = acc64;\n }\n}\n\n/*!\n * @internal\n * @brief Scrambles the accumulators after a large chunk has been read\n */\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n size_t i;\n for (i=0; i < XXH_ACC_NB; i++) {\n XXH3_scalarScrambleRound(acc, secret, i);\n }\n}\n\nXXH_FORCE_INLINE void\nXXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n /*\n * We need a separate pointer for the hack below,\n * which requires a non-const pointer.\n * Any decent compiler will optimize this out otherwise.\n */\n const xxh_u8* kSecretPtr = XXH3_kSecret;\n XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);\n\n#if defined(__GNUC__) && defined(__aarch64__)\n /*\n * UGLY HACK:\n * GCC and Clang generate a bunch of MOV/MOVK pairs for aarch64, and they are\n * placed sequentially, in order, at the top of the unrolled loop.\n *\n * While MOVK is great for generating constants (2 cycles for a 64-bit\n * constant compared to 4 cycles for LDR), it fights for bandwidth with\n * the arithmetic instructions.\n *\n * I L S\n * MOVK\n * MOVK\n * MOVK\n * MOVK\n * ADD\n * SUB STR\n * STR\n * By forcing loads from memory (as the asm line causes the compiler to assume\n * that XXH3_kSecretPtr has been changed), the pipelines are used more\n * efficiently:\n * I L S\n * LDR\n * ADD LDR\n * SUB STR\n * STR\n *\n * See XXH3_NEON_LANES for details on the pipeline.\n *\n * XXH3_64bits_withSeed, len == 256, Snapdragon 835\n * without hack: 2654.4 MB/s\n * with hack: 3202.9 MB/s\n */\n XXH_COMPILER_GUARD(kSecretPtr);\n#endif\n { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16;\n int i;\n for (i=0; i < nbRounds; i++) {\n /*\n * The asm hack causes the compiler to assume that kSecretPtr aliases with\n * customSecret, and on aarch64, this prevented LDP from merging two\n * loads together for free. Putting the loads together before the stores\n * properly generates LDP.\n */\n xxh_u64 lo = XXH_readLE64(kSecretPtr + 16*i) + seed64;\n xxh_u64 hi = XXH_readLE64(kSecretPtr + 16*i + 8) - seed64;\n XXH_writeLE64((xxh_u8*)customSecret + 16*i, lo);\n XXH_writeLE64((xxh_u8*)customSecret + 16*i + 8, hi);\n } }\n}\n\n\ntypedef void (*XXH3_f_accumulate)(xxh_u64* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, size_t);\ntypedef void (*XXH3_f_scrambleAcc)(void* XXH_RESTRICT, const void*);\ntypedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64);\n\n\n#if (XXH_VECTOR == XXH_AVX512)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_avx512\n#define XXH3_accumulate XXH3_accumulate_avx512\n#define XXH3_scrambleAcc XXH3_scrambleAcc_avx512\n#define XXH3_initCustomSecret XXH3_initCustomSecret_avx512\n\n#elif (XXH_VECTOR == XXH_AVX2)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_avx2\n#define XXH3_accumulate XXH3_accumulate_avx2\n#define XXH3_scrambleAcc XXH3_scrambleAcc_avx2\n#define XXH3_initCustomSecret XXH3_initCustomSecret_avx2\n\n#elif (XXH_VECTOR == XXH_SSE2)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_sse2\n#define XXH3_accumulate XXH3_accumulate_sse2\n#define XXH3_scrambleAcc XXH3_scrambleAcc_sse2\n#define XXH3_initCustomSecret XXH3_initCustomSecret_sse2\n\n#elif (XXH_VECTOR == XXH_NEON)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_neon\n#define XXH3_accumulate XXH3_accumulate_neon\n#define XXH3_scrambleAcc XXH3_scrambleAcc_neon\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_VSX)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_vsx\n#define XXH3_accumulate XXH3_accumulate_vsx\n#define XXH3_scrambleAcc XXH3_scrambleAcc_vsx\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_SVE)\n#define XXH3_accumulate_512 XXH3_accumulate_512_sve\n#define XXH3_accumulate XXH3_accumulate_sve\n#define XXH3_scrambleAcc XXH3_scrambleAcc_scalar\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_LASX)\n#define XXH3_accumulate_512 XXH3_accumulate_512_lasx\n#define XXH3_accumulate XXH3_accumulate_lasx\n#define XXH3_scrambleAcc XXH3_scrambleAcc_lasx\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_LSX)\n#define XXH3_accumulate_512 XXH3_accumulate_512_lsx\n#define XXH3_accumulate XXH3_accumulate_lsx\n#define XXH3_scrambleAcc XXH3_scrambleAcc_lsx\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_RVV)\n#define XXH3_accumulate_512 XXH3_accumulate_512_rvv\n#define XXH3_accumulate XXH3_accumulate_rvv\n#define XXH3_scrambleAcc XXH3_scrambleAcc_rvv\n#define XXH3_initCustomSecret XXH3_initCustomSecret_rvv\n\n#else /* scalar */\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_scalar\n#define XXH3_accumulate XXH3_accumulate_scalar\n#define XXH3_scrambleAcc XXH3_scrambleAcc_scalar\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#endif\n\n#if XXH_SIZE_OPT >= 1 /* don't do SIMD for initialization */\n# undef XXH3_initCustomSecret\n# define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n#endif\n\nXXH_FORCE_INLINE void\nXXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,\n const xxh_u8* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble)\n{\n size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;\n size_t const block_len = XXH_STRIPE_LEN * nbStripesPerBlock;\n size_t const nb_blocks = (len - 1) / block_len;\n\n size_t n;\n\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n\n for (n = 0; n < nb_blocks; n++) {\n f_acc(acc, input + n*block_len, secret, nbStripesPerBlock);\n f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN);\n }\n\n /* last partial block */\n XXH_ASSERT(len > XXH_STRIPE_LEN);\n { size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN;\n XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE));\n f_acc(acc, input + nb_blocks*block_len, secret, nbStripes);\n\n /* last stripe */\n { const xxh_u8* const p = input + len - XXH_STRIPE_LEN;\n#define XXH_SECRET_LASTACC_START 7 /* not aligned on 8, last secret is different from acc & scrambler */\n XXH3_accumulate_512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);\n } }\n}\n\nXXH_FORCE_INLINE xxh_u64\nXXH3_mix2Accs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret)\n{\n return XXH3_mul128_fold64(\n acc[0] ^ XXH_readLE64(secret),\n acc[1] ^ XXH_readLE64(secret+8) );\n}\n\nstatic XXH_PUREF XXH64_hash_t\nXXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 start)\n{\n xxh_u64 result64 = start;\n size_t i = 0;\n\n for (i = 0; i < 4; i++) {\n result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i);\n#if defined(__clang__) /* Clang */ \\\n && (defined(__arm__) || defined(__thumb__)) /* ARMv7 */ \\\n && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \\\n && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable */\n /*\n * UGLY HACK:\n * Prevent autovectorization on Clang ARMv7-a. Exact same problem as\n * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b.\n * XXH3_64bits, len == 256, Snapdragon 835:\n * without hack: 2063.7 MB/s\n * with hack: 2560.7 MB/s\n */\n XXH_COMPILER_GUARD(result64);\n#endif\n }\n\n return XXH3_avalanche(result64);\n}\n\n/* do not align on 8, so that the secret is different from the accumulator */\n#define XXH_SECRET_MERGEACCS_START 11\n\nstatic XXH_PUREF XXH64_hash_t\nXXH3_finalizeLong_64b(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 len)\n{\n return XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, len * XXH_PRIME64_1);\n}\n\n#define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \\\n XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 }\n\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,\n const void* XXH_RESTRICT secret, size_t secretSize,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble)\n{\n XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;\n\n XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc, f_scramble);\n\n /* converge into final hash */\n XXH_STATIC_ASSERT(sizeof(acc) == 64);\n XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n return XXH3_finalizeLong_64b(acc, (const xxh_u8*)secret, (xxh_u64)len);\n}\n\n/*\n * It's important for performance to transmit secret's size (when it's static)\n * so that the compiler can properly optimize the vectorized loop.\n * This makes a big performance difference for \"medium\" keys (<1 KB) when using AVX instruction set.\n * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE\n * breaks -Og, this is XXH_NO_INLINE.\n */\nXXH3_WITH_SECRET_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)seed64;\n return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * It's preferable for performance that XXH3_hashLong is not inlined,\n * as it results in a smaller function for small data, easier to the instruction cache.\n * Note that inside this no_inline function, we do inline the internal loop,\n * and provide a statically defined secret size to allow optimization of vector loop.\n */\nXXH_NO_INLINE XXH_PUREF XXH64_hash_t\nXXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)seed64; (void)secret; (void)secretLen;\n return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * XXH3_hashLong_64b_withSeed():\n * Generate a custom key based on alteration of default XXH3_kSecret with the seed,\n * and then use this key for long mode hashing.\n *\n * This operation is decently fast but nonetheless costs a little bit of time.\n * Try to avoid it whenever possible (typically when seed==0).\n *\n * It's important for performance that XXH3_hashLong is not inlined. Not sure\n * why (uop cache maybe?), but the difference is large and easily measurable.\n */\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,\n XXH64_hash_t seed,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble,\n XXH3_f_initCustomSecret f_initSec)\n{\n#if XXH_SIZE_OPT <= 0\n if (seed == 0)\n return XXH3_hashLong_64b_internal(input, len,\n XXH3_kSecret, sizeof(XXH3_kSecret),\n f_acc, f_scramble);\n#endif\n { XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];\n f_initSec(secret, seed);\n return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret),\n f_acc, f_scramble);\n }\n}\n\n/*\n * It's important for performance that XXH3_hashLong is not inlined.\n */\nXXH_NO_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSeed(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)secret; (void)secretLen;\n return XXH3_hashLong_64b_withSeed_internal(input, len, seed,\n XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);\n}\n\n\ntypedef XXH64_hash_t (*XXH3_hashLong64_f)(const void* XXH_RESTRICT, size_t,\n XXH64_hash_t, const xxh_u8* XXH_RESTRICT, size_t);\n\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,\n XXH3_hashLong64_f f_hashLong)\n{\n XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);\n /*\n * If an action is to be taken if `secretLen` condition is not respected,\n * it should be done here.\n * For now, it's a contract pre-condition.\n * Adding a check and a branch here would cost performance at every hash.\n * Also, note that function signature doesn't offer room to return an error.\n */\n if (len <= 16)\n return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);\n if (len <= 128)\n return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n if (len <= XXH3_MIDSIZE_MAX)\n return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen);\n}\n\n\n/* === Public entry point === */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length)\n{\n return XXH3_64bits_internal(input, length, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSecret(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n return XXH3_64bits_internal(input, length, 0, secret, secretSize, XXH3_hashLong_64b_withSecret);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed)\n{\n return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed);\n}\n\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n if (length <= XXH3_MIDSIZE_MAX)\n return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);\n return XXH3_hashLong_64b_withSecret(input, length, seed, (const xxh_u8*)secret, secretSize);\n}\n\n\n/* === XXH3 streaming === */\n#ifndef XXH_NO_STREAM\n/*\n * Malloc's a pointer that is always aligned to @align.\n *\n * This must be freed with `XXH_alignedFree()`.\n *\n * malloc typically guarantees 16 byte alignment on 64-bit systems and 8 byte\n * alignment on 32-bit. This isn't enough for the 32 byte aligned loads in AVX2\n * or on 32-bit, the 16 byte aligned loads in SSE2 and NEON.\n *\n * This underalignment previously caused a rather obvious crash which went\n * completely unnoticed due to XXH3_createState() not actually being tested.\n * Credit to RedSpah for noticing this bug.\n *\n * The alignment is done manually: Functions like posix_memalign or _mm_malloc\n * are avoided: To maintain portability, we would have to write a fallback\n * like this anyways, and besides, testing for the existence of library\n * functions without relying on external build tools is impossible.\n *\n * The method is simple: Overallocate, manually align, and store the offset\n * to the original behind the returned pointer.\n *\n * Align must be a power of 2 and 8 <= align <= 128.\n */\nstatic XXH_MALLOCF void* XXH_alignedMalloc(size_t s, size_t align)\n{\n XXH_ASSERT(align <= 128 && align >= 8); /* range check */\n XXH_ASSERT((align & (align-1)) == 0); /* power of 2 */\n XXH_ASSERT(s != 0 && s < (s + align)); /* empty/overflow */\n { /* Overallocate to make room for manual realignment and an offset byte */\n xxh_u8* base = (xxh_u8*)XXH_malloc(s + align);\n if (base != NULL) {\n /*\n * Get the offset needed to align this pointer.\n *\n * Even if the returned pointer is aligned, there will always be\n * at least one byte to store the offset to the original pointer.\n */\n size_t offset = align - ((size_t)base & (align - 1)); /* base % align */\n /* Add the offset for the now-aligned pointer */\n xxh_u8* ptr = base + offset;\n\n XXH_ASSERT((size_t)ptr % align == 0);\n\n /* Store the offset immediately before the returned pointer. */\n ptr[-1] = (xxh_u8)offset;\n return ptr;\n }\n return NULL;\n }\n}\n/*\n * Frees an aligned pointer allocated by XXH_alignedMalloc(). Don't pass\n * normal malloc'd pointers, XXH_alignedMalloc has a specific data layout.\n */\nstatic void XXH_alignedFree(void* p)\n{\n if (p != NULL) {\n xxh_u8* ptr = (xxh_u8*)p;\n /* Get the offset byte we added in XXH_malloc. */\n xxh_u8 offset = ptr[-1];\n /* Free the original malloc'd pointer */\n xxh_u8* base = ptr - offset;\n XXH_free(base);\n }\n}\n/*! @ingroup XXH3_family */\n/*!\n * @brief Allocate an @ref XXH3_state_t.\n *\n * @return An allocated pointer of @ref XXH3_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH3_freeState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)\n{\n XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64);\n if (state==NULL) return NULL;\n XXH3_INITSTATE(state);\n return state;\n}\n\n/*! @ingroup XXH3_family */\n/*!\n * @brief Frees an @ref XXH3_state_t.\n *\n * @param statePtr A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note Must be allocated with XXH3_createState().\n *\n * @see @ref streaming_example \"Streaming Example\"\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)\n{\n XXH_alignedFree(statePtr);\n return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API void\nXXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state)\n{\n XXH_memcpy(dst_state, src_state, sizeof(*dst_state));\n}\n\nstatic void\nXXH3_reset_internal(XXH3_state_t* statePtr,\n XXH64_hash_t seed,\n const void* secret, size_t secretSize)\n{\n size_t const initStart = offsetof(XXH3_state_t, bufferedSize);\n size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;\n XXH_ASSERT(offsetof(XXH3_state_t, nbStripesPerBlock) > initStart);\n XXH_ASSERT(statePtr != NULL);\n /* set members from bufferedSize to nbStripesPerBlock (excluded) to 0 */\n XXH_memset((char*)statePtr + initStart, 0, initLength);\n statePtr->acc[0] = XXH_PRIME32_3;\n statePtr->acc[1] = XXH_PRIME64_1;\n statePtr->acc[2] = XXH_PRIME64_2;\n statePtr->acc[3] = XXH_PRIME64_3;\n statePtr->acc[4] = XXH_PRIME64_4;\n statePtr->acc[5] = XXH_PRIME32_2;\n statePtr->acc[6] = XXH_PRIME64_5;\n statePtr->acc[7] = XXH_PRIME32_1;\n statePtr->seed = seed;\n statePtr->useSeed = (seed != 0);\n statePtr->extSecret = (const unsigned char*)secret;\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n statePtr->secretLimit = secretSize - XXH_STRIPE_LEN;\n statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)\n{\n if (statePtr == NULL) return XXH_ERROR;\n XXH3_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);\n return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n if (statePtr == NULL) return XXH_ERROR;\n XXH3_reset_internal(statePtr, 0, secret, secretSize);\n if (secret == NULL) return XXH_ERROR;\n if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)\n{\n if (statePtr == NULL) return XXH_ERROR;\n if (seed==0) return XXH3_64bits_reset(statePtr);\n if ((seed != statePtr->seed) || (statePtr->extSecret != NULL))\n XXH3_initCustomSecret(statePtr->customSecret, seed);\n XXH3_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE);\n return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed64)\n{\n if (statePtr == NULL) return XXH_ERROR;\n if (secret == NULL) return XXH_ERROR;\n if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n XXH3_reset_internal(statePtr, seed64, secret, secretSize);\n statePtr->useSeed = 1; /* always, even if seed64==0 */\n return XXH_OK;\n}\n\n/*!\n * @internal\n * @brief Processes a large input for XXH3_update() and XXH3_digest_long().\n *\n * Unlike XXH3_hashLong_internal_loop(), this can process data that overlaps a block.\n *\n * @param acc Pointer to the 8 accumulator lanes\n * @param nbStripesSoFarPtr In/out pointer to the number of leftover stripes in the block*\n * @param nbStripesPerBlock Number of stripes in a block\n * @param input Input pointer\n * @param nbStripes Number of stripes to process\n * @param secret Secret pointer\n * @param secretLimit Offset of the last block in @p secret\n * @param f_acc Pointer to an XXH3_accumulate implementation\n * @param f_scramble Pointer to an XXH3_scrambleAcc implementation\n * @return Pointer past the end of @p input after processing\n */\nXXH_FORCE_INLINE const xxh_u8 *\nXXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc,\n size_t* XXH_RESTRICT nbStripesSoFarPtr, size_t nbStripesPerBlock,\n const xxh_u8* XXH_RESTRICT input, size_t nbStripes,\n const xxh_u8* XXH_RESTRICT secret, size_t secretLimit,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble)\n{\n const xxh_u8* initialSecret = secret + *nbStripesSoFarPtr * XXH_SECRET_CONSUME_RATE;\n /* Process full blocks */\n if (nbStripes >= (nbStripesPerBlock - *nbStripesSoFarPtr)) {\n /* Process the initial partial block... */\n size_t nbStripesThisIter = nbStripesPerBlock - *nbStripesSoFarPtr;\n\n do {\n /* Accumulate and scramble */\n f_acc(acc, input, initialSecret, nbStripesThisIter);\n f_scramble(acc, secret + secretLimit);\n input += nbStripesThisIter * XXH_STRIPE_LEN;\n nbStripes -= nbStripesThisIter;\n /* Then continue the loop with the full block size */\n nbStripesThisIter = nbStripesPerBlock;\n initialSecret = secret;\n } while (nbStripes >= nbStripesPerBlock);\n *nbStripesSoFarPtr = 0;\n }\n /* Process a partial block */\n if (nbStripes > 0) {\n f_acc(acc, input, initialSecret, nbStripes);\n input += nbStripes * XXH_STRIPE_LEN;\n *nbStripesSoFarPtr += nbStripes;\n }\n /* Return end pointer */\n return input;\n}\n\n#ifndef XXH3_STREAM_USE_STACK\n# if XXH_SIZE_OPT <= 0 && !defined(__clang__) /* clang doesn't need additional stack space */\n# define XXH3_STREAM_USE_STACK 1\n# endif\n#endif\n/* This function accepts f_acc and f_scramble as function pointers,\n * making it possible to implement multiple variants with different acc & scramble stages.\n * This is notably useful to implement multiple vector variants with different intrinsics.\n */\nXXH_FORCE_INLINE XXH_errorcode\nXXH3_update(XXH3_state_t* XXH_RESTRICT const state,\n const xxh_u8* XXH_RESTRICT input, size_t len,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble)\n{\n if (input==NULL) {\n XXH_ASSERT(len == 0);\n return XXH_OK;\n }\n\n XXH_ASSERT(state != NULL);\n state->totalLen += len;\n\n /* small input : just fill in tmp buffer */\n XXH_ASSERT(state->bufferedSize <= XXH3_INTERNALBUFFER_SIZE);\n if (len <= XXH3_INTERNALBUFFER_SIZE - state->bufferedSize) {\n XXH_memcpy(state->buffer + state->bufferedSize, input, len);\n state->bufferedSize += (XXH32_hash_t)len;\n return XXH_OK;\n }\n\n { const xxh_u8* const bEnd = input + len;\n const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n#if defined(XXH3_STREAM_USE_STACK) && XXH3_STREAM_USE_STACK >= 1\n /* For some reason, gcc and MSVC seem to suffer greatly\n * when operating accumulators directly into state.\n * Operating into stack space seems to enable proper optimization.\n * clang, on the other hand, doesn't seem to need this trick */\n XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[8];\n XXH_memcpy(acc, state->acc, sizeof(acc));\n#else\n xxh_u64* XXH_RESTRICT const acc = state->acc;\n#endif\n\n /* total input is now > XXH3_INTERNALBUFFER_SIZE */\n #define XXH3_INTERNALBUFFER_STRIPES (XXH3_INTERNALBUFFER_SIZE / XXH_STRIPE_LEN)\n XXH_STATIC_ASSERT(XXH3_INTERNALBUFFER_SIZE % XXH_STRIPE_LEN == 0); /* clean multiple */\n\n /*\n * Internal buffer is partially filled (always, except at beginning)\n * Complete it, then consume it.\n */\n if (state->bufferedSize) {\n size_t const loadSize = XXH3_INTERNALBUFFER_SIZE - state->bufferedSize;\n XXH_memcpy(state->buffer + state->bufferedSize, input, loadSize);\n input += loadSize;\n XXH3_consumeStripes(acc,\n &state->nbStripesSoFar, state->nbStripesPerBlock,\n state->buffer, XXH3_INTERNALBUFFER_STRIPES,\n secret, state->secretLimit,\n f_acc, f_scramble);\n state->bufferedSize = 0;\n }\n XXH_ASSERT(input < bEnd);\n if (bEnd - input > XXH3_INTERNALBUFFER_SIZE) {\n size_t nbStripes = (size_t)(bEnd - 1 - input) / XXH_STRIPE_LEN;\n input = XXH3_consumeStripes(acc,\n &state->nbStripesSoFar, state->nbStripesPerBlock,\n input, nbStripes,\n secret, state->secretLimit,\n f_acc, f_scramble);\n XXH_memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);\n\n }\n /* Some remaining input (always) : buffer it */\n XXH_ASSERT(input < bEnd);\n XXH_ASSERT(bEnd - input <= XXH3_INTERNALBUFFER_SIZE);\n XXH_ASSERT(state->bufferedSize == 0);\n XXH_memcpy(state->buffer, input, (size_t)(bEnd-input));\n state->bufferedSize = (XXH32_hash_t)(bEnd-input);\n#if defined(XXH3_STREAM_USE_STACK) && XXH3_STREAM_USE_STACK >= 1\n /* save stack accumulators into state */\n XXH_memcpy(state->acc, acc, sizeof(acc));\n#endif\n }\n\n return XXH_OK;\n}\n\n/*\n * Both XXH3_64bits_update and XXH3_128bits_update use this routine.\n */\nXXH_NO_INLINE XXH_errorcode\nXXH3_update_regular(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n return XXH3_update(state, (const xxh_u8*)input, len,\n XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n return XXH3_update_regular(state, input, len);\n}\n\n\nXXH_FORCE_INLINE void\nXXH3_digest_long (XXH64_hash_t* acc,\n const XXH3_state_t* state,\n const unsigned char* secret)\n{\n xxh_u8 lastStripe[XXH_STRIPE_LEN];\n const xxh_u8* lastStripePtr;\n\n /*\n * Digest on a local copy. This way, the state remains unaltered, and it can\n * continue ingesting more input afterwards.\n */\n XXH_memcpy(acc, state->acc, sizeof(state->acc));\n if (state->bufferedSize >= XXH_STRIPE_LEN) {\n /* Consume remaining stripes then point to remaining data in buffer */\n size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN;\n size_t nbStripesSoFar = state->nbStripesSoFar;\n XXH3_consumeStripes(acc,\n &nbStripesSoFar, state->nbStripesPerBlock,\n state->buffer, nbStripes,\n secret, state->secretLimit,\n XXH3_accumulate, XXH3_scrambleAcc);\n lastStripePtr = state->buffer + state->bufferedSize - XXH_STRIPE_LEN;\n } else { /* bufferedSize < XXH_STRIPE_LEN */\n /* Copy to temp buffer */\n size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize;\n XXH_ASSERT(state->bufferedSize > 0); /* there is always some input buffered */\n XXH_memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);\n XXH_memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);\n lastStripePtr = lastStripe;\n }\n /* Last stripe */\n XXH3_accumulate_512(acc,\n lastStripePtr,\n secret + state->secretLimit - XXH_SECRET_LASTACC_START);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* state)\n{\n const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n if (state->totalLen > XXH3_MIDSIZE_MAX) {\n XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];\n XXH3_digest_long(acc, state, secret);\n return XXH3_finalizeLong_64b(acc, secret, (xxh_u64)state->totalLen);\n }\n /* totalLen <= XXH3_MIDSIZE_MAX: digesting a short input */\n if (state->useSeed)\n return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);\n return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen),\n secret, state->secretLimit + XXH_STRIPE_LEN);\n}\n#endif /* !XXH_NO_STREAM */\n\n\n/* ==========================================\n * XXH3 128 bits (a.k.a XXH128)\n * ==========================================\n * XXH3's 128-bit variant has better mixing and strength than the 64-bit variant,\n * even without counting the significantly larger output size.\n *\n * For example, extra steps are taken to avoid the seed-dependent collisions\n * in 17-240 byte inputs (See XXH3_mix16B and XXH128_mix32B).\n *\n * This strength naturally comes at the cost of some speed, especially on short\n * lengths. Note that longer hashes are about as fast as the 64-bit version\n * due to it using only a slight modification of the 64-bit loop.\n *\n * XXH128 is also more oriented towards 64-bit machines. It is still extremely\n * fast for a _128-bit_ hash on 32-bit (it usually clears XXH64).\n */\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n /* A doubled version of 1to3_64b with different constants. */\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(1 <= len && len <= 3);\n XXH_ASSERT(secret != NULL);\n /*\n * len = 1: combinedl = { input[0], 0x01, input[0], input[0] }\n * len = 2: combinedl = { input[1], 0x02, input[0], input[1] }\n * len = 3: combinedl = { input[2], 0x03, input[0], input[1] }\n */\n { xxh_u8 const c1 = input[0];\n xxh_u8 const c2 = input[len >> 1];\n xxh_u8 const c3 = input[len - 1];\n xxh_u32 const combinedl = ((xxh_u32)c1 <<16) | ((xxh_u32)c2 << 24)\n | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8);\n xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);\n xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;\n xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed;\n xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl;\n xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph;\n XXH128_hash_t h128;\n h128.low64 = XXH64_avalanche(keyed_lo);\n h128.high64 = XXH64_avalanche(keyed_hi);\n return h128;\n }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(secret != NULL);\n XXH_ASSERT(4 <= len && len <= 8);\n seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;\n { xxh_u32 const input_lo = XXH_readLE32(input);\n xxh_u32 const input_hi = XXH_readLE32(input + len - 4);\n xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32);\n xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed;\n xxh_u64 const keyed = input_64 ^ bitflip;\n\n /* Shift len to the left to ensure it is even, this avoids even multiplies. */\n XXH128_hash_t m128 = XXH_mult64to128(keyed, XXH_PRIME64_1 + (len << 2));\n\n m128.high64 += (m128.low64 << 1);\n m128.low64 ^= (m128.high64 >> 3);\n\n m128.low64 = XXH_xorshift64(m128.low64, 35);\n m128.low64 *= PRIME_MX2;\n m128.low64 = XXH_xorshift64(m128.low64, 28);\n m128.high64 = XXH3_avalanche(m128.high64);\n return m128;\n }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(input != NULL);\n XXH_ASSERT(secret != NULL);\n XXH_ASSERT(9 <= len && len <= 16);\n { xxh_u64 const bitflipl = (XXH_readLE64(secret+32) ^ XXH_readLE64(secret+40)) - seed;\n xxh_u64 const bitfliph = (XXH_readLE64(secret+48) ^ XXH_readLE64(secret+56)) + seed;\n xxh_u64 const input_lo = XXH_readLE64(input);\n xxh_u64 input_hi = XXH_readLE64(input + len - 8);\n XXH128_hash_t m128 = XXH_mult64to128(input_lo ^ input_hi ^ bitflipl, XXH_PRIME64_1);\n /*\n * Put len in the middle of m128 to ensure that the length gets mixed to\n * both the low and high bits in the 128x64 multiply below.\n */\n m128.low64 += (xxh_u64)(len - 1) << 54;\n input_hi ^= bitfliph;\n /*\n * Add the high 32 bits of input_hi to the high 32 bits of m128, then\n * add the long product of the low 32 bits of input_hi and XXH_PRIME32_2 to\n * the high 64 bits of m128.\n *\n * The best approach to this operation is different on 32-bit and 64-bit.\n */\n if (sizeof(void *) < sizeof(xxh_u64)) { /* 32-bit */\n /*\n * 32-bit optimized version, which is more readable.\n *\n * On 32-bit, it removes an ADC and delays a dependency between the two\n * halves of m128.high64, but it generates an extra mask on 64-bit.\n */\n m128.high64 += (input_hi & 0xFFFFFFFF00000000ULL) + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2);\n } else {\n /*\n * 64-bit optimized (albeit more confusing) version.\n *\n * Uses some properties of addition and multiplication to remove the mask:\n *\n * Let:\n * a = input_hi.lo = (input_hi & 0x00000000FFFFFFFF)\n * b = input_hi.hi = (input_hi & 0xFFFFFFFF00000000)\n * c = XXH_PRIME32_2\n *\n * a + (b * c)\n * Inverse Property: x + y - x == y\n * a + (b * (1 + c - 1))\n * Distributive Property: x * (y + z) == (x * y) + (x * z)\n * a + (b * 1) + (b * (c - 1))\n * Identity Property: x * 1 == x\n * a + b + (b * (c - 1))\n *\n * Substitute a, b, and c:\n * input_hi.hi + input_hi.lo + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))\n *\n * Since input_hi.hi + input_hi.lo == input_hi, we get this:\n * input_hi + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))\n */\n m128.high64 += input_hi + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2 - 1);\n }\n /* m128 ^= XXH_swap64(m128 >> 64); */\n m128.low64 ^= XXH_swap64(m128.high64);\n\n { /* 128x64 multiply: h128 = m128 * XXH_PRIME64_2; */\n XXH128_hash_t h128 = XXH_mult64to128(m128.low64, XXH_PRIME64_2);\n h128.high64 += m128.high64 * XXH_PRIME64_2;\n\n h128.low64 = XXH3_avalanche(h128.low64);\n h128.high64 = XXH3_avalanche(h128.high64);\n return h128;\n } }\n}\n\n/*\n * Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN\n */\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n XXH_ASSERT(len <= 16);\n { if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed);\n if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed);\n if (len) return XXH3_len_1to3_128b(input, len, secret, seed);\n { XXH128_hash_t h128;\n xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72);\n xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88);\n h128.low64 = XXH64_avalanche(seed ^ bitflipl);\n h128.high64 = XXH64_avalanche( seed ^ bitfliph);\n return h128;\n } }\n}\n\n/*\n * A bit slower than XXH3_mix16B, but handles multiply by zero better.\n */\nXXH_FORCE_INLINE XXH128_hash_t\nXXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,\n const xxh_u8* secret, XXH64_hash_t seed)\n{\n acc.low64 += XXH3_mix16B (input_1, secret+0, seed);\n acc.low64 ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);\n acc.high64 += XXH3_mix16B (input_2, secret+16, seed);\n acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);\n return acc;\n}\n\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH64_hash_t seed)\n{\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n XXH_ASSERT(16 < len && len <= 128);\n\n { XXH128_hash_t acc;\n acc.low64 = len * XXH_PRIME64_1;\n acc.high64 = 0;\n\n#if XXH_SIZE_OPT >= 1\n {\n /* Smaller, but slightly slower. */\n unsigned int i = (unsigned int)(len - 1) / 32;\n do {\n acc = XXH128_mix32B(acc, input+16*i, input+len-16*(i+1), secret+32*i, seed);\n } while (i-- != 0);\n }\n#else\n if (len > 32) {\n if (len > 64) {\n if (len > 96) {\n acc = XXH128_mix32B(acc, input+48, input+len-64, secret+96, seed);\n }\n acc = XXH128_mix32B(acc, input+32, input+len-48, secret+64, seed);\n }\n acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed);\n }\n acc = XXH128_mix32B(acc, input, input+len-16, secret, seed);\n#endif\n { XXH128_hash_t h128;\n h128.low64 = acc.low64 + acc.high64;\n h128.high64 = (acc.low64 * XXH_PRIME64_1)\n + (acc.high64 * XXH_PRIME64_4)\n + ((len - seed) * XXH_PRIME64_2);\n h128.low64 = XXH3_avalanche(h128.low64);\n h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);\n return h128;\n }\n }\n}\n\nXXH_NO_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH64_hash_t seed)\n{\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n\n { XXH128_hash_t acc;\n unsigned i;\n acc.low64 = len * XXH_PRIME64_1;\n acc.high64 = 0;\n /*\n * We set as `i` as offset + 32. We do this so that unchanged\n * `len` can be used as upper bound. This reaches a sweet spot\n * where both x86 and aarch64 get simple agen and good codegen\n * for the loop.\n */\n for (i = 32; i < 160; i += 32) {\n acc = XXH128_mix32B(acc,\n input + i - 32,\n input + i - 16,\n secret + i - 32,\n seed);\n }\n acc.low64 = XXH3_avalanche(acc.low64);\n acc.high64 = XXH3_avalanche(acc.high64);\n /*\n * NB: `i <= len` will duplicate the last 32-bytes if\n * len % 32 was zero. This is an unfortunate necessity to keep\n * the hash result stable.\n */\n for (i=160; i <= len; i += 32) {\n acc = XXH128_mix32B(acc,\n input + i - 32,\n input + i - 16,\n secret + XXH3_MIDSIZE_STARTOFFSET + i - 160,\n seed);\n }\n /* last bytes */\n acc = XXH128_mix32B(acc,\n input + len - 16,\n input + len - 32,\n secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16,\n (XXH64_hash_t)0 - seed);\n\n { XXH128_hash_t h128;\n h128.low64 = acc.low64 + acc.high64;\n h128.high64 = (acc.low64 * XXH_PRIME64_1)\n + (acc.high64 * XXH_PRIME64_4)\n + ((len - seed) * XXH_PRIME64_2);\n h128.low64 = XXH3_avalanche(h128.low64);\n h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);\n return h128;\n }\n }\n}\n\nstatic XXH_PUREF XXH128_hash_t\nXXH3_finalizeLong_128b(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, xxh_u64 len)\n{\n XXH128_hash_t h128;\n h128.low64 = XXH3_finalizeLong_64b(acc, secret, len);\n h128.high64 = XXH3_mergeAccs(acc, secret + secretSize\n - XXH_STRIPE_LEN - XXH_SECRET_MERGEACCS_START,\n ~(len * XXH_PRIME64_2));\n return h128;\n}\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,\n const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble)\n{\n XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;\n\n XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc, f_scramble);\n\n /* converge into final hash */\n XXH_STATIC_ASSERT(sizeof(acc) == 64);\n XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n return XXH3_finalizeLong_128b(acc, secret, secretSize, (xxh_u64)len);\n}\n\n/*\n * It's important for performance that XXH3_hashLong() is not inlined.\n */\nXXH_NO_INLINE XXH_PUREF XXH128_hash_t\nXXH3_hashLong_128b_default(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64,\n const void* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)seed64; (void)secret; (void)secretLen;\n return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret),\n XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * It's important for performance to pass @p secretLen (when it's static)\n * to the compiler, so that it can properly optimize the vectorized loop.\n *\n * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE\n * breaks -Og, this is XXH_NO_INLINE.\n */\nXXH3_WITH_SECRET_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSecret(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64,\n const void* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)seed64;\n return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, secretLen,\n XXH3_accumulate, XXH3_scrambleAcc);\n}\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,\n XXH64_hash_t seed64,\n XXH3_f_accumulate f_acc,\n XXH3_f_scrambleAcc f_scramble,\n XXH3_f_initCustomSecret f_initSec)\n{\n if (seed64 == 0)\n return XXH3_hashLong_128b_internal(input, len,\n XXH3_kSecret, sizeof(XXH3_kSecret),\n f_acc, f_scramble);\n { XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];\n f_initSec(secret, seed64);\n return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),\n f_acc, f_scramble);\n }\n}\n\n/*\n * It's important for performance that XXH3_hashLong is not inlined.\n */\nXXH_NO_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSeed(const void* input, size_t len,\n XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen)\n{\n (void)secret; (void)secretLen;\n return XXH3_hashLong_128b_withSeed_internal(input, len, seed64,\n XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);\n}\n\ntypedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, size_t,\n XXH64_hash_t, const void* XXH_RESTRICT, size_t);\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_128bits_internal(const void* input, size_t len,\n XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,\n XXH3_hashLong128_f f_hl128)\n{\n XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);\n /*\n * If an action is to be taken if `secret` conditions are not respected,\n * it should be done here.\n * For now, it's a contract pre-condition.\n * Adding a check and a branch here would cost performance at every hash.\n */\n if (len <= 16)\n return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);\n if (len <= 128)\n return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n if (len <= XXH3_MIDSIZE_MAX)\n return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n return f_hl128(input, len, seed64, secret, secretLen);\n}\n\n\n/* === Public XXH128 API === */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* input, size_t len)\n{\n return XXH3_128bits_internal(input, len, 0,\n XXH3_kSecret, sizeof(XXH3_kSecret),\n XXH3_hashLong_128b_default);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSecret(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n return XXH3_128bits_internal(input, len, 0,\n (const xxh_u8*)secret, secretSize,\n XXH3_hashLong_128b_withSecret);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSeed(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)\n{\n return XXH3_128bits_internal(input, len, seed,\n XXH3_kSecret, sizeof(XXH3_kSecret),\n XXH3_hashLong_128b_withSeed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n if (len <= XXH3_MIDSIZE_MAX)\n return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);\n return XXH3_hashLong_128b_withSecret(input, len, seed, secret, secretSize);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH128(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)\n{\n return XXH3_128bits_withSeed(input, len, seed);\n}\n\n\n/* === XXH3 128-bit streaming === */\n#ifndef XXH_NO_STREAM\n/*\n * All initialization and update functions are identical to 64-bit streaming variant.\n * The only difference is the finalization routine.\n */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)\n{\n return XXH3_64bits_reset(statePtr);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n return XXH3_64bits_reset_withSecret(statePtr, secret, secretSize);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)\n{\n return XXH3_64bits_reset_withSeed(statePtr, seed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n return XXH3_64bits_reset_withSecretandSeed(statePtr, secret, secretSize, seed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n return XXH3_update_regular(state, input, len);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* state)\n{\n const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n if (state->totalLen > XXH3_MIDSIZE_MAX) {\n XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];\n XXH3_digest_long(acc, state, secret);\n XXH_ASSERT(state->secretLimit + XXH_STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n return XXH3_finalizeLong_128b(acc, secret, state->secretLimit + XXH_STRIPE_LEN, (xxh_u64)state->totalLen);\n }\n /* len <= XXH3_MIDSIZE_MAX : short code */\n if (state->useSeed)\n return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);\n return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen),\n secret, state->secretLimit + XXH_STRIPE_LEN);\n}\n#endif /* !XXH_NO_STREAM */\n/* 128-bit utility functions */\n\n/* return : 1 is equal, 0 if different */\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)\n{\n /* note : XXH128_hash_t is compact, it has no padding byte */\n return !(XXH_memcmp(&h1, &h2, sizeof(h1)));\n}\n\n/* This prototype is compatible with stdlib's qsort().\n * @return : >0 if *h128_1 > *h128_2\n * <0 if *h128_1 < *h128_2\n * =0 if *h128_1 == *h128_2 */\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2)\n{\n XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;\n XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;\n int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64);\n /* note : bets that, in most cases, hash values are different */\n if (hcmp) return hcmp;\n return (h1.low64 > h2.low64) - (h2.low64 > h1.low64);\n}\n\n\n/*====== Canonical representation ======*/\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API void\nXXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash)\n{\n XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));\n if (XXH_CPU_LITTLE_ENDIAN) {\n hash.high64 = XXH_swap64(hash.high64);\n hash.low64 = XXH_swap64(hash.low64);\n }\n XXH_memcpy(dst, &hash.high64, sizeof(hash.high64));\n XXH_memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src)\n{\n XXH128_hash_t h;\n h.high64 = XXH_readBE64(src);\n h.low64 = XXH_readBE64(src->digest + 8);\n return h;\n}\n\n\n\n/* ==========================================\n * Secret generators\n * ==========================================\n */\n#define XXH_MIN(x, y) (((x) > (y)) ? (y) : (x))\n\nXXH_FORCE_INLINE void XXH3_combine16(void* dst, XXH128_hash_t h128)\n{\n XXH_writeLE64( dst, XXH_readLE64(dst) ^ h128.low64 );\n XXH_writeLE64( (char*)dst+8, XXH_readLE64((char*)dst+8) ^ h128.high64 );\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize)\n{\n#if (XXH_DEBUGLEVEL >= 1)\n XXH_ASSERT(secretBuffer != NULL);\n XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n#else\n /* production mode, assert() are disabled */\n if (secretBuffer == NULL) return XXH_ERROR;\n if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n#endif\n\n if (customSeedSize == 0) {\n customSeed = XXH3_kSecret;\n customSeedSize = XXH_SECRET_DEFAULT_SIZE;\n }\n#if (XXH_DEBUGLEVEL >= 1)\n XXH_ASSERT(customSeed != NULL);\n#else\n if (customSeed == NULL) return XXH_ERROR;\n#endif\n\n /* Fill secretBuffer with a copy of customSeed - repeat as needed */\n { size_t pos = 0;\n while (pos < secretSize) {\n size_t const toCopy = XXH_MIN((secretSize - pos), customSeedSize);\n XXH_memcpy((char*)secretBuffer + pos, customSeed, toCopy);\n pos += toCopy;\n } }\n\n { size_t const nbSeg16 = secretSize / 16;\n size_t n;\n XXH128_canonical_t scrambler;\n XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0));\n for (n=0; n&1 | grep -q musl; then LIBC_TYPE=\"musl\"; else LIBC_TYPE=\"gnu\"; fi; \\\n\techo \"Detected architecture: $${ARCH} and libc: $${LIBC_TYPE}\"; \\\n\tcase \"$${ARCH}\" in \\\n\t\t'x86_64') \\\n\t\t\tif [ \"$${LIBC_TYPE}\" = \"musl\" ]; then \\\n\t\t\t\tRUST_INSTALLER=\"rust-$${RUST_VERSION}-x86_64-unknown-linux-musl\"; \\\n\t\t\t\tRUST_SHA256=\"9a358120ce1491a4d5b7f71a41e4e97b380b5db5d4ec31f7110f5b3090bd3d55\"; \\\n\t\t\telse \\\n\t\t\t\tRUST_INSTALLER=\"rust-$${RUST_VERSION}-x86_64-unknown-linux-gnu\"; \\\n\t\t\t\tRUST_SHA256=\"e8fa4185f3ef6ae32725ff638b1ecdbff28f5d651dc0b3111e2539350d03b15a\"; \\\n\t\t\tfi ;; \\\n\t\t'aarch64') \\\n\t\t\tif [ \"$${LIBC_TYPE}\" = \"musl\" ]; then \\\n\t\t\t\tRUST_INSTALLER=\"rust-$${RUST_VERSION}-aarch64-unknown-linux-musl\"; \\\n\t\t\t\tRUST_SHA256=\"008b3f0fc4175c956ecbfa4e0c48865ec3f953741b2926e75e8ded7e3adfdb19\"; \\\n\t\t\telse \\\n\t\t\t\tRUST_INSTALLER=\"rust-$${RUST_VERSION}-aarch64-unknown-linux-gnu\"; \\\n\t\t\t\tRUST_SHA256=\"c6fd6d1c925ed986df3b2c0b89bbc90ce15afb62e4d522a054e7d50c856b3c1a\"; \\\n\t\t\tfi ;; \\\n\t\t*) echo >&2 \"Unsupported architecture: '$${ARCH}'\"; exit 1 ;; \\\n\tesac; \\\n\techo \"Downloading and installing Rust standalone installer: $${RUST_INSTALLER}\"; \\\n\twget --quiet -O $${RUST_INSTALLER}.tar.xz https://static.rust-lang.org/dist/$${RUST_INSTALLER}.tar.xz; \\\n\techo \"$${RUST_SHA256} $${RUST_INSTALLER}.tar.xz\" | sha256sum -c --status || { echo \"Rust standalone installer checksum failed!\"; exit 1; }; \\\n\ttar -xf $${RUST_INSTALLER}.tar.xz; \\\n\t(cd $${RUST_INSTALLER} && ./install.sh); \\\n\trm -rf $${RUST_INSTALLER}\nendif\n\nuninstall-rust:\nifeq ($(INSTALL_RUST_TOOLCHAIN),yes)\n\t@if [ -x \"/usr/local/lib/rustlib/uninstall.sh\" ]; then \\\n\t\techo \"Uninstalling Rust using uninstall.sh script\"; \\\n\t\trm -rf ~/.cargo; \\\n\t\t/usr/local/lib/rustlib/uninstall.sh; \\\n\telse \\\n\t\techo \"WARNING: Rust toolchain not found or uninstall script is missing.\"; \\\n\tfi\nendif\n\nhandle-werrors: get_source\nifeq ($(DISABLE_WERRORS),yes)\n\t@echo \"Disabling -Werror for all modules\"\n\t@for dir in $(SUBDIRS); do \\\n\t\techo \"Processing $$dir\"; \\\n\t\tfind $$dir/src -type f \\\n\t\t\t\\( -name \"Makefile\" \\\n\t\t\t-o -name \"*.mk\" \\\n\t\t\t-o -name \"CMakeLists.txt\" \\) \\\n\t\t\t-exec sed -i 's/-Werror//g' {} +; \\\n\tdone\nendif\n\n.PHONY: all clean distclean install $(SUBDIRS) setup_environment clean_environment install-rust uninstall-rust handle-werrors\n" }, { "path": "modules/common.mk", "content": "PREFIX ?= /usr/local\nINSTALL_DIR ?= $(DESTDIR)$(PREFIX)/lib/redis/modules\nINSTALL ?= install\n\n# This logic *partially* follows the current module build system. It is a bit awkward and\n# should be changed if/when the modules' build process is refactored.\n\nARCH_MAP_x86_64 := x64\nARCH_MAP_i386 := x86\nARCH_MAP_i686 := x86\nARCH_MAP_aarch64 := arm64v8\nARCH_MAP_arm64 := arm64v8\n\nOS := $(shell uname -s | tr '[:upper:]' '[:lower:]')\nARCH := $(ARCH_MAP_$(shell uname -m))\nifeq ($(ARCH),)\n\t$(error Unrecognized CPU architecture $(shell uname -m))\nendif\n\nFULL_VARIANT := $(OS)-$(ARCH)-release\n\n# Common rules for all modules, based on per-module configuration\n\nall: $(TARGET_MODULE)\n\n$(TARGET_MODULE): get_source\n\t$(MAKE) -C $(SRC_DIR)\n\tcp ${TARGET_MODULE} ./\n\nget_source: $(SRC_DIR)/.prepared\n\n$(SRC_DIR)/.prepared:\n\tmkdir -p $(SRC_DIR)\n\tgit clone --recursive --depth 1 --branch $(MODULE_VERSION) $(MODULE_REPO) $(SRC_DIR)\n\ttouch $@\n\nclean:\n\t-$(MAKE) -C $(SRC_DIR) clean\n\t-rm -f ./*.so\n\ndistclean: clean\n\t-$(MAKE) -C $(SRC_DIR) distclean\n\npristine:\n\t-rm -rf $(SRC_DIR)\n\ninstall: $(TARGET_MODULE)\n\tmkdir -p $(INSTALL_DIR)\n\t$(INSTALL) -m 0755 -D $(TARGET_MODULE) $(INSTALL_DIR)\n\n.PHONY: all clean distclean pristine install\n" }, { "path": "modules/redisbloom/Makefile", "content": "SRC_DIR = src\nMODULE_VERSION = v8.7.90\nMODULE_REPO = https://github.com/redisbloom/redisbloom\nTARGET_MODULE = $(SRC_DIR)/bin/$(FULL_VARIANT)/redisbloom.so\n\ninclude ../common.mk\n" }, { "path": "modules/redisearch/Makefile", "content": "SRC_DIR = src\nMODULE_VERSION = v8.7.90\nMODULE_REPO = https://github.com/redisearch/redisearch\nTARGET_MODULE = $(SRC_DIR)/bin/$(FULL_VARIANT)/search-community/redisearch.so\n\ninclude ../common.mk\n\n" }, { "path": "modules/redisjson/Makefile", "content": "SRC_DIR = src\nMODULE_VERSION = v8.7.90\nMODULE_REPO = https://github.com/redisjson/redisjson\nTARGET_MODULE = $(SRC_DIR)/bin/$(FULL_VARIANT)/rejson.so\n\ninclude ../common.mk\n\n$(SRC_DIR)/.cargo_fetched:\n\tcd $(SRC_DIR) && cargo fetch\n\nget_source: $(SRC_DIR)/.cargo_fetched\n" }, { "path": "modules/redistimeseries/Makefile", "content": "SRC_DIR = src\nMODULE_VERSION = v8.7.90\nMODULE_REPO = https://github.com/redistimeseries/redistimeseries\nTARGET_MODULE = $(SRC_DIR)/bin/$(FULL_VARIANT)/redistimeseries.so\n\ninclude ../common.mk\n" }, { "path": "modules/vector-sets/.gitignore", "content": "__pycache__\nmisc\n*.so\n*.xo\n*.o\n.DS_Store\nw2v\nword2vec.bin\nTODO\n*.txt\n*.rdb\n" }, { "path": "modules/vector-sets/Makefile", "content": "# Compiler settings\nCC = cc\n\nifdef SANITIZER\nifeq ($(SANITIZER),address)\n\tSAN=-fsanitize=address\nelse\nifeq ($(SANITIZER),undefined)\n\tSAN=-fsanitize=undefined\nelse\nifeq ($(SANITIZER),thread)\n\tSAN=-fsanitize=thread\nelse\n $(error \"unknown sanitizer=${SANITIZER}\")\nendif\nendif\nendif\nendif\n\nCFLAGS = -O2 -Wall -Wextra -g $(SAN) -std=c11\nLDFLAGS = -lm $(SAN)\n\n# Detect OS\nuname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\nuname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')\n\n# Shared library compile flags for linux / osx\nifeq ($(uname_S),Linux)\n\tSHOBJ_CFLAGS ?= -W -Wall -fno-common -g -ggdb -std=c11 -O2\n\tSHOBJ_LDFLAGS ?= -shared\nifneq (,$(findstring armv,$(uname_M)))\n\tSHOBJ_LDFLAGS += -latomic\nendif\nifneq (,$(findstring aarch64,$(uname_M)))\n\tSHOBJ_LDFLAGS += -latomic\nendif\nelse\n\tSHOBJ_CFLAGS ?= -W -Wall -dynamic -fno-common -g -ggdb -std=c11 -O3\n\tSHOBJ_LDFLAGS ?= -bundle -undefined dynamic_lookup\nendif\n\n# OS X 11.x doesn't have /usr/lib/libSystem.dylib and needs an explicit setting.\nifeq ($(uname_S),Darwin)\nifeq (\"$(wildcard /usr/lib/libSystem.dylib)\",\"\")\nLIBS = -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib -lsystem\nendif\nendif\n\n.SUFFIXES: .c .so .xo .o\n\nall: vset.so\n\n.c.xo:\n\t$(CC) -I. $(CFLAGS) $(SHOBJ_CFLAGS) -fPIC -c $< -o $@\n\nvset.xo: ../../src/redismodule.h expr.c\n\nvset.so: vset.xo hnsw.xo vset_config.xo\n\t$(CC) -o $@ $^ $(SHOBJ_LDFLAGS) $(LIBS) $(SAN) -lc\n\n# Example sources / objects\nSRCS = hnsw.c w2v.c vset_config.c\nOBJS = $(SRCS:.c=.o)\n\nTARGET = w2v\nMODULE = vset.so\n\n# Default target\nall: $(TARGET) $(MODULE)\n\n# Example linking rule\n$(TARGET): $(OBJS)\n\t$(CC) $(OBJS) $(LDFLAGS) -o $(TARGET)\n\n# Compilation rule for object files\n%.o: %.c\n\t$(CC) $(CFLAGS) -c $< -o $@\n\nexpr-test: expr.c fastjson.c fastjson_test.c\n\t$(CC) $(CFLAGS) expr.c -o expr-test -DTEST_MAIN -lm\n\n# Clean rule\nclean:\n\trm -f $(TARGET) $(OBJS) *.xo *.so\n\n# Declare phony targets\n.PHONY: all clean\n" }, { "path": "modules/vector-sets/README.md", "content": "**IMPORTANT:** *Please note that this is a merged module, it's part of the Redis binary now, and you don't need to build it and load it into Redis. Compiling Redis version 8 or greater will result into having the Vector Sets commands available. However, you could compile this module as a shared library in order to load it in older versions of Redis.*\n\nThis module implements Vector Sets for Redis, a new Redis data type similar\nto Sorted Sets but having string elements associated to a vector instead of\na score. The fundamental goal of Vector Sets is to make possible adding items,\nand later get a subset of the added items that are the most similar to a\nspecified vector (often a learned embedding), or the most similar to the vector\nof an element that is already part of the Vector Set.\n\nMoreover, Vector sets implement optional filtered search capabilities: it is possible to associate attributes to all or to a subset of elements in the set, and then, using the `FILTER` option of the `VSIM` command, to ask for items similar to a given vector but also passing a filter specified as a simple mathematical expression (Like `\".year > 1950\"` or similar). This means that **you can have vector similarity and scalar filters at the same time**.\n\n## Installation\n\n**WARNING:** If you are running **Redis 8.0 RC1 or greater** you don't need to install anything, just compile Redis, and the Vector Sets commands will be part of the default install. Otherwise to test Vector Sets with older Redis versions follow the following instructions.\n\nBuild with:\n\n make\n\nThen load the module with the following command line, or by inserting the needed directives in the `redis.conf` file.\n\n ./redis-server --loadmodule vset.so\n\nTo run tests, I suggest using this:\n\n ./redis-server --save \"\" --enable-debug-command yes\n\nThe execute the tests with:\n\n ./test.py\n\n## Reference of available commands\n\n**VADD: add items into a vector set**\n\n VADD key [REDUCE dim] FP32|VALUES vector element [CAS] [NOQUANT | Q8 | BIN]\n [EF build-exploration-factor] [SETATTR ] [M ]\n\nAdd a new element into the vector set specified by the key.\nThe vector can be provided as FP32 blob of values, or as floating point\nnumbers as strings, prefixed by the number of elements (3 in the example):\n\n VADD mykey VALUES 3 0.1 1.2 0.5 my-element\n\nMeaning of the options:\n\n`REDUCE` implements random projection, in order to reduce the\ndimensionality of the vector. The projection matrix is saved and reloaded\nalong with the vector set. **Please note that** the `REDUCE` option must be passed immediately before the vector, like in `REDUCE 50 VALUES ...`.\n\n`CAS` performs the operation partially using threads, in a\ncheck-and-set style. The neighbor candidates collection, which is slow, is\nperformed in the background, while the command is executed in the main thread.\n\n`NOQUANT` forces the vector to be created (in the first VADD call to a given key) without integer 8 quantization, which is otherwise the default.\n\n`BIN` forces the vector to use binary quantization instead of int8. This is much faster and uses less memory, but has impacts on the recall quality. The distance is computed as normalized Hamming distance (`hamming_bits * 2 / dim`), yielding values in [0, 2] consistent with cosine distance semantics, not raw Hamming bit counts.\n\n`Q8` forces the vector to use signed 8 bit quantization. This is the default, and the option only exists in order to make sure to check at insertion time if the vector set is of the same format.\n\n`EF` plays a role in the effort made to find good candidates when connecting the new node to the existing HNSW graph. The default is 200. Using a larger value, may help to have a better recall. To improve the recall it is also possible to increase `EF` during `VSIM` searches.\n\n`SETATTR` associates attributes to the newly created entry or update the entry attributes (if it already exists). It is the same as calling the `VSETATTR` attribute separately, so please check the documentation of that command in the filtered search section of this documentation.\n\n`M` defaults to 16 and is the HNSW famous `M` parameters. It is the maximum number of connections that each node of the graph have with other nodes: more connections mean more memory, but a better ability to explore the graph. Nodes at layer zero (every node exists at least at layer zero) have `M*2` connections, while the other layers only have `M` connections. This means that, for instance, an `M` of 64 will use at least 1024 bytes of memory for each node! That is, `64 links * 2 times * 8 bytes pointers`, and even more, since on average each node has something like 1.33 layers (but the other layers have just `M` connections, instead of `M*2`). If you don't have a recall quality problem, the default is fine, and uses a limited amount of memory.\n\n**VSIM: return elements by vector similarity**\n\n VSIM key [ELE|FP32|VALUES] [WITHSCORES] [WITHATTRIBS] [COUNT num] [EPSILON delta] [EF search-exploration-factor] [FILTER expression] [FILTER-EF max-filtering-effort] [TRUTH] [NOTHREAD]\n\nThe command returns similar vectors, for simplicity (and verbosity) in the following example, instead of providing a vector using FP32 or VALUES (like in `VADD`), we will ask for elements having a vector similar to a given element already in the sorted set:\n\n > VSIM word_embeddings ELE apple\n 1) \"apple\"\n 2) \"apples\"\n 3) \"pear\"\n 4) \"fruit\"\n 5) \"berry\"\n 6) \"pears\"\n 7) \"strawberry\"\n 8) \"peach\"\n 9) \"potato\"\n 10) \"grape\"\n\nIt is possible to specify a `COUNT` and also to get the similarity score (from 1 to 0, where 1 is identical, 0 is opposite vector) between the query and the returned items.\n\n > VSIM word_embeddings ELE apple WITHSCORES COUNT 3\n 1) \"apple\"\n 2) \"0.9998867657923256\"\n 3) \"apples\"\n 4) \"0.8598527610301971\"\n 5) \"pear\"\n 6) \"0.8226882219314575\"\n\nIt is also possible to specify a `EPSILON`, that is a floating point number between 0 and 1 in order to only return elements that have a distance that is no further than the specified one. In vector sets, the returned elements have a similarity score (when compared to the query vector) that is between 1 and 0, where 1 means identical, 0 opposite vectors. If for instance the `EPSILON` option is specified with an argument of 0.2, it means that we will get only elements that have a similarity of 0.8 or better (a distance < 0.2). This is useful when a large `COUNT` is specified, yet we don't want elements that are too far away our query vector.\n\nThe `EF` argument is the exploration factor: the higher it is, the slower the command becomes, but the better the index is explored to find nodes that are near to our query. Sensible values are from 50 to 1000.\n\nThe `TRUTH` option forces the command to perform a linear scan of all the entries inside the set, without using the graph search inside the HNSW, so it returns the best matching elements (the perfect result set) that can be used in order to easily calculate the recall. Of course the linear scan is `O(N)`, so it is much slower than the `log(N)` (considering a small `COUNT`) provided by the HNSW index.\n\nThe `NOTHREAD` option forces the command to execute the search on the data structure in the main thread. Normally `VSIM` spawns a thread instead. This may be useful for benchmarking purposes, or when we work with extremely small vector sets and don't want to pay the cost of spawning a thread. It is possible that in the future this option will be automatically used by Redis when we detect small vector sets. Note that this option blocks the server for all the time needed to complete the command, so it is a source of potential latency issues: if you are in doubt, never use it.\n\nThe `WITHSCORES` option returns, for each returned element, a floating point number representing how near the element is from the query, as a similarity between 0 and 1, where 0 means the vectors are opposite, and 1 means they are pointing exactly in the same direction (maximum similarity).\n\nThe `WITHATTRIBS` option returns, for each element, the JSON attribute associated with the element, or NULL for the elements missing an attribute.\n\nFor `FILTER` and `FILTER-EF` options, please check the filtered search section of this documentation.\n\nNote that when `WITHSCORES` and `WITHATTRIBS` are provided at the same time, the RESP2 reply guarantees that the returned elements are always in the sequence *ele*,*score*,*attribs*, while RESP3 replies will be in the form *ele > score|attrib* when just one is provided, or *ele -> [score,attrib]* when both are provided, that is, when both options are used and RESP3 is used the score and attribute will be a two-items array associated to the element key.\n\n**VDIM: return the dimension of the vectors inside the vector set**\n\n VDIM keyname\n\nExample:\n\n > VDIM word_embeddings\n (integer) 300\n\nNote that in the case of vectors that were populated using the `REDUCE`\noption, for random projection, the vector set will report the size of\nthe projected (reduced) dimension. Yet the user should perform all the\nqueries using full-size vectors.\n\n**VCARD: return the number of elements in a vector set**\n\n VCARD key\n\nExample:\n\n > VCARD word_embeddings\n (integer) 3000000\n\n\n**VREM: remove elements from vector set**\n\n VREM key element\n\nExample:\n\n > VADD vset VALUES 3 1 0 1 bar\n (integer) 1\n > VREM vset bar\n (integer) 1\n > VREM vset bar\n (integer) 0\n\nVREM does not perform thumstone / logical deletion, but will actually reclaim\nthe memory from the vector set, so it is save to add and remove elements\nin a vector set in the context of long running applications that continuously\nupdate the same index.\n\n**VEMB: return the approximated vector of an element**\n\n VEMB key element\n\nExample:\n\n > VEMB word_embeddings SQL\n 1) \"0.18208661675453186\"\n 2) \"0.08535309880971909\"\n 3) \"0.1365649551153183\"\n 4) \"-0.16501599550247192\"\n 5) \"0.14225517213344574\"\n ... 295 more elements ...\n\nBecause vector sets perform insertion time normalization and optional\nquantization, the returned vector could be approximated. `VEMB` will take\ncare to de-quantized and de-normalize the vector before returning it.\n\nIt is possible to ask VEMB to return raw data, that is, the internal representation used by the vector: fp32, int8, or a bitmap for binary quantization. This behavior is triggered by the `RAW` option of of VEMB:\n\n VEMB word_embedding apple RAW\n\nIn this case the return value of the command is an array of three or more elements:\n1. The name of the quantization used, that is one of: \"fp32\", \"bin\", \"q8\".\n2. The a string blob containing the raw data, 4 bytes fp32 floats for fp32, a bitmap for binary quants, or int8 bytes array for q8 quants.\n3. A float representing the l2 of the vector before normalization. You need to multiply by this vector if you want to de-normalize the value for any reason.\n\nFor q8 quantization, an additional elements is also returned: the quantization\nrange, so the integers from -127 to 127 represent (normalized) components\nin the range `-range`, `+range`.\n\n**VISMEMBER: test if a given element already exists**\n\nThis command will return 1 (or true) if the specified element is already in the vector set, otherwise 0 (or false) is returned.\n\n VISMEMBER key element\n\nAs with other existence check Redis commands, if the key does not exist it is considered as if it was empty, thus the element is reported as non existing.\n\n**VRANGE: return elements in a lexicographical range\n\n VRANGE key start end count\n\nThe `VRANGE` command has many different use cases, but its main goal is to\nprovide a stateless iterator for the elements inside a vector set: that is,\nit allows to retrieve all the elements inside a vector set in small amounts\nfor each call, without an explicit cursor, and with guarantees about what\nthe user will miss in case the vector set is changing (elements added and/or\nremoved) during the iteration.\n\nThe command usage is straightforward:\n\n```\n> VRANGE word_embeddings_int8 [Redis + 10\n 1) \"Redis\"\n 2) \"Rediscover\"\n 3) \"Rediscover_Ashland\"\n 4) \"Rediscover_Northern_Ireland\"\n 5) \"Rediscovered\"\n 6) \"Rediscovered_Bookshop\"\n 7) \"Rediscovering\"\n 8) \"Rediscovering_God\"\n 9) \"Rediscovering_Lost\"\n10) \"Rediscovers\"\n```\n\nThe above command returns 10 (or less, if less are available in the specified range) elements from \"Redis\" (inclusive) to the maximum possible element. The comparison is performed byte by byte, as `memcmp()` would do, in this way the elements have a total order. The start and end range can be either a string, prefixed by `[` or `(` (the prefix is mandatory) to tell the command if the range is inclusive or exclusive, or can be the special symbols `-` and `+` that means the maximum and minimum element.\n\nSo for instance if I want to iterate all the elements, ten elements for each call, I'll proceed as such:\n\n```\n> VRANGE mykey - + 10\n 1) \"a\"\n 2) \"a-league\"\n 3) \"a.\"\n 4) \"a.d.\"\n 5) \"a.k.a.\"\n 6) \"a.m.\"\n 7) \"a1\"\n 8) \"a2\"\n 9) \"a3\"\n10) \"a7\"\n```\n\nThis will give me the first 10 elements. Then I want the next ten elements\nstarting from the last element in the previous result, but *excluding* it,\nso the next range will use the `(` prefix with the last element of the\nprevious call, that was `\"a7\"`:\n\n```\n> VRANGE mykey (a7 + 10\n 1) \"a930913\"\n 2) \"aa\"\n 3) \"aaa\"\n 4) \"aaron\"\n 5) \"ab\"\n 6) \"aba\"\n 7) \"abandon\"\n 8) \"abandoned\"\n 9) \"abandoning\"\n10) \"abandonment\"\n```\n\nAnd so forth.\n\nThe command count is mandatory, however a negative count means to return all the elements in the set. This means that `VRANGE mykey - + -1` will return every element. Of course, iterating like that means that it is possible to block the server for a long time.\n\nThe command time complexity is O(1) to seek to the element (considering the element would be of reasonable size), since we use a Radix Tree in the underlying implementation, plus the time to yield \"M\" elements. So if M is small, each call is just executed in constant time. However the iteration of a total set (via multiple calls) of N elements is O(N). Basically: this command, with a small count, will never produce latency issues in the Redis server.\n\nIn case the elements are changing continuously as the set is iterated, the guarantees are very simple: each range will produce exactly the elements that were present in the range in the moment the `VRANGE` command was executed. In other words, an iteration performed in this way is *guaranteed* to return all the elements that stayed within the vector set from the start to the end of the iteration. Elements removed or added in the meantime may be returned or not depending on the moment they were added or removed.\n\n**VLINKS: introspection command that shows neighbors for a node**\n\n VLINKS key element [WITHSCORES]\n\nThe command reports the neighbors for each level.\n\n**VINFO: introspection command that shows info about a vector set**\n\n VINFO key\n\nExample:\n\n > VINFO word_embeddings\n 1) quant-type\n 2) int8\n 3) vector-dim\n 4) (integer) 300\n 5) size\n 6) (integer) 3000000\n 7) max-level\n 8) (integer) 12\n 9) vset-uid\n 10) (integer) 1\n 11) hnsw-max-node-uid\n 12) (integer) 3000000\n\n**VSETATTR: associate or remove the JSON attributes of elements**\n\n VSETATTR key element \"{... json ...}\"\n\nEach element of a vector set can be optionally associated with a JSON string\nin order to use the `FILTER` option of `VSIM` to filter elements by scalars\n(see the filtered search section for more information). This command can set,\nupdate (if already set) or delete (if you set to an empty string) the\nassociated JSON attributes of an element.\n\nThe command returns 0 if the element or the key don't exist, without\nraising an error, otherwise 1 is returned, and the element attributes\nare set or updated.\n\n**VGETATTR: retrieve the JSON attributes of elements**\n\n VGETATTR key element\n\nThe command returns the JSON attribute associated with an element, or\nnull if there is no element associated, or no element at all, or no key.\n\n**VRANDMEMBER: return random members from a vector set**\n\n VRANDMEMBER key [count]\n\nReturn one or more random elements from a vector set.\n\nThe semantics of this command are similar to Redis's native SRANDMEMBER command:\n\n- When called without count, returns a single random element from the set, as a single string (no array reply).\n- When called with a positive count, returns up to count distinct random elements (no duplicates).\n- When called with a negative count, returns count random elements, potentially with duplicates.\n- If the count value is larger than the set size (and positive), only the entire set is returned.\n\nIf the key doesn't exist, returns a Null reply if count is not given, or an empty array if a count is provided.\n\nExamples:\n\n > VADD vset VALUES 3 1 0 0 elem1\n (integer) 1\n > VADD vset VALUES 3 0 1 0 elem2\n (integer) 1\n > VADD vset VALUES 3 0 0 1 elem3\n (integer) 1\n\n # Return a single random element\n > VRANDMEMBER vset\n \"elem2\"\n\n # Return 2 distinct random elements\n > VRANDMEMBER vset 2\n 1) \"elem1\"\n 2) \"elem3\"\n\n # Return 3 random elements with possible duplicates\n > VRANDMEMBER vset -3\n 1) \"elem2\"\n 2) \"elem2\"\n 3) \"elem1\"\n\n # Return more elements than in the set (returns all elements)\n > VRANDMEMBER vset 10\n 1) \"elem1\"\n 2) \"elem2\"\n 3) \"elem3\"\n\n # When key doesn't exist\n > VRANDMEMBER nonexistent\n (nil)\n > VRANDMEMBER nonexistent 3\n (empty array)\n\nThis command is particularly useful for:\n\n1. Selecting random samples from a vector set for testing or training.\n2. Performance testing by retrieving random elements for subsequent similarity searches.\n\nWhen the user asks for unique elements (positev count) the implementation optimizes for two scenarios:\n- For small sample sizes (less than 20% of the set size), it uses a dictionary to avoid duplicates, and performs a real random walk inside the graph.\n- For large sample sizes (more than 20% of the set size), it starts from a random node and sequentially traverses the internal list, providing faster performances but not really \"random\" elements.\n\nThe command has `O(N)` worst-case time complexity when requesting many unique elements (it uses linear scanning), or `O(M*log(N))` complexity when the users asks for `M` random elements in a sorted set of `N` elements, with `M` much smaller than `N`.\n\n# Filtered search\n\nEach element of the vector set can be associated with a set of attributes specified as a JSON blob:\n\n > VADD vset VALUES 3 1 1 1 a SETATTR '{\"year\": 1950}'\n (integer) 1\n > VADD vset VALUES 3 -1 -1 -1 b SETATTR '{\"year\": 1951}'\n (integer) 1\n\nSpecifying an attribute with the `SETATTR` option of `VADD` is exactly equivalent to adding an element and then setting (or updating, if already set) the attributes JSON string. Also the symmetrical `VGETATTR` command returns the attribute associated to a given element.\n\n > VADD vset VALUES 3 0 1 0 c\n (integer) 1\n > VSETATTR vset c '{\"year\": 1952}'\n (integer) 1\n > VGETATTR vset c\n \"{\\\"year\\\": 1952}\"\n\nAt this point, I may use the FILTER option of VSIM to only ask for the subset of elements that are verified by my expression:\n\n > VSIM vset VALUES 3 0 0 0 FILTER '.year > 1950'\n 1) \"c\"\n 2) \"b\"\n\nThe items will be returned again in order of similarity (most similar first), but only the items with the year field matching the expression is returned.\n\nThe expressions are similar to what you would write inside the `if` statement of JavaScript or other familiar programming languages: you can use `and`, `or`, the obvious math operators like `+`, `-`, `/`, `>=`, `<`, ... and so forth (see the expressions section for more info). The selectors of the JSON object attributes start with a dot followed by the name of the key inside the JSON objects.\n\nElements with invalid JSON or not having a given specified field **are considered as not matching** the expression, but will not generate any error at runtime.\n\n## FILTER expressions capabilities\n\nFILTER expressions allow you to perform complex filtering on vector similarity results using a JavaScript-like syntax. The expression is evaluated against each element's JSON attributes, with only elements that satisfy the expression being included in the results.\n\n### Expression Syntax\n\nExpressions support the following operators and capabilities:\n\n1. **Arithmetic operators**: `+`, `-`, `*`, `/`, `%` (modulo), `**` (exponentiation)\n2. **Comparison operators**: `>`, `>=`, `<`, `<=`, `==`, `!=`\n3. **Logical operators**: `and`/`&&`, `or`/`||`, `!`/`not`\n4. **Containment operator**: `in`\n5. **Parentheses** for grouping: `(...)`\n\n### Selector Notation\n\nAttributes are accessed using dot notation:\n\n- `.year` references the \"year\" attribute\n- `.movie.year` would **NOT** reference the \"year\" field inside a \"movie\" object, only keys that are at the first level of the JSON object are accessible.\n\n### JSON and expressions data types\n\nExpressions can work with:\n\n- Numbers (dobule precision floats)\n- Strings (enclosed in single or double quotes)\n- Booleans (no native type: they are represented as 1 for true, 0 for false)\n- Arrays (for use with the `in` operator: `value in [1, 2, 3]`)\n\nJSON attributes are converted in this way:\n\n- Numbers will be converted to numbers.\n- Strings to strings.\n- Booleans to 0 or 1 number.\n- Arrays to tuples (for \"in\" operator), but only if composed of just numbers and strings.\n\nAny other type is ignored, and accessig it will make the expression evaluate to false.\n\n### The IN operator\n\nThe `IN` operator works in two ways, it can test for membership in an array, like in:\n\n 5 in [1, 2, 3]\n \"foo\" in [1, \"foo\", \"bar\"]\n\nBut can also check for substrings, in case the A and B operators are both strings.\n\n \"foo\" in \"barfoobar\" # Will evaluate to true\n \"zap\" in \"foobar\" # Will evaluate to false\n\n### Examples\n\n```\n# Find items from the 1980s\nVSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.year >= 1980 and .year < 1990'\n\n# Find action movies with high ratings\nVSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.genre == \"action\" and .rating > 8.0'\n\n# Find movies directed by either Spielberg or Nolan\nVSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.director in [\"Spielberg\", \"Nolan\"]'\n\n# Complex condition with numerical operations\nVSIM movies VALUES 3 0.5 0.8 0.2 FILTER '(.year - 2000) ** 2 < 100 and .rating / 2 > 4'\n```\n\n### Error Handling\n\nElements with any of the following conditions are considered not matching:\n- Missing the queried JSON attribute\n- Having invalid JSON in their attributes\n- Having a JSON value that cannot be converted to the expected type\n\nThis behavior allows you to safely filter on optional attributes without generating errors.\n\n### FILTER effort\n\nThe `FILTER-EF` option controls the maximum effort spent when filtering vector search results.\n\nWhen performing vector similarity search with filtering, Vector Sets perform the standard similarity search as they apply the filter expression to each node. Since many results might be filtered out, Vector Sets may need to examine a lot more candidates than the requested `COUNT` to ensure sufficient matching results are returned. Actually, if the elements matching the filter are very rare or if there are less than elements matching than the specified count, this would trigger a full scan of the HNSW graph.\n\nFor this reason, by default, the maximum effort is limited to a reasonable amount of nodes explored.\n\n### Modifying the FILTER effort\n\n1. By default, Vector Sets will explore up to `COUNT * 100` candidates to find matching results.\n2. You can control this exploration with the `FILTER-EF` parameter.\n3. A higher `FILTER-EF` value increases the chances of finding all relevant matches at the cost of increased processing time.\n4. A `FILTER-EF` of zero will explore as many nodes as needed in order to actually return the number of elements specified by `COUNT`.\n5. Even when a high `FILTER-EF` value is specified **the implementation will do a lot less work** if the elements passing the filter are very common, because of the early stop conditions of the HNSW implementation (once the specified amount of elements is reached and the quality check of the other candidates trigger an early stop).\n\n```\nVSIM key [ELE|FP32|VALUES] COUNT 10 FILTER '.year > 2000' FILTER-EF 500\n```\n\nIn this example, Vector Sets will examine up to 500 potential nodes. Of course if count is reached before exploring 500 nodes, and the quality checks show that it is not possible to make progresses on similarity, the search is ended sooner.\n\n### Performance Considerations\n\n- If you have highly selective filters (few items match), use a higher `FILTER-EF`, or just design your application in order to handle a result set that is smaller than the requested count. Note that anyway the additional elements may be too distant than the query vector.\n- For less selective filters, the default should be sufficient.\n- Very selective filters with low `FILTER-EF` values may return fewer items than requested.\n- Extremely high values may impact performance without significantly improving results.\n\nThe optimal `FILTER-EF` value depends on:\n1. The selectivity of your filter.\n2. The distribution of your data.\n3. The required recall quality.\n\nA good practice is to start with the default and increase if needed when you observe fewer results than expected.\n\n### Testing a larg-ish data set\n\nTo really see how things work at scale, you can [download](https://antirez.com/word2vec_with_attribs.rdb) the following dataset:\n\n wget https://antirez.com/word2vec_with_attribs.rdb\n\nIt contains the 3 million words in Word2Vec having as attribute a JSON with just the length of the word. Because of the length distribution of words in large amounts of texts, where longer words become less and less common, this is ideal to check how filtering behaves with a filter verifying as true with less and less elements in a vector set.\n\nFor instance:\n\n > VSIM word_embeddings_bin ele \"pasta\" FILTER \".len == 6\"\n 1) \"pastas\"\n 2) \"rotini\"\n 3) \"gnocci\"\n 4) \"panino\"\n 5) \"salads\"\n 6) \"breads\"\n 7) \"salame\"\n 8) \"sauces\"\n 9) \"cheese\"\n 10) \"fritti\"\n\nThis will easily retrieve the desired amount of items (`COUNT` is 10 by default) since there are many items of length 6. However:\n\n > VSIM word_embeddings_bin ele \"pasta\" FILTER \".len == 33\"\n 1) \"skinless_boneless_chicken_breasts\"\n 2) \"boneless_skinless_chicken_breasts\"\n 3) \"Boneless_skinless_chicken_breasts\"\n\nThis time even if we asked for 10 items, we only get 3, since the default filter effort will be `10*100 = 1000`. We can tune this giving the effort in an explicit way, with the risk of our query being slower, of course:\n\n > VSIM word_embeddings_bin ele \"pasta\" FILTER \".len == 33\" FILTER-EF 10000\n 1) \"skinless_boneless_chicken_breasts\"\n 2) \"boneless_skinless_chicken_breasts\"\n 3) \"Boneless_skinless_chicken_breasts\"\n 4) \"mozzarella_feta_provolone_cheddar\"\n 5) \"Greatfood.com_R_www.greatfood.com\"\n 6) \"Pepperidge_Farm_Goldfish_crackers\"\n 7) \"Prosecuted_Mobsters_Rebuilt_Dying\"\n 8) \"Crispy_Snacker_Sandwiches_Popcorn\"\n 9) \"risultati_delle_partite_disputate\"\n 10) \"Peppermint_Mocha_Twist_Gingersnap\"\n\nThis time we get all the ten items, even if the last one will be quite far from our query vector. We encourage to experiment with this test dataset in order to understand better the dynamics of the implementation and the natural tradeoffs of filtered search.\n\n**Keep in mind** that by default, Redis Vector Sets will try to avoid a likely very useless huge scan of the HNSW graph, and will be more happy to return few or no elements at all, since this is almost always what the user actually wants in the context of retrieving *similar* items to the query.\n\n# Single Instance Scalability and Latency\n\nVector Sets implement a threading model that allows Redis to handle many concurrent requests: by default `VSIM` is always threaded, and `VADD` is not (but can be partially threaded using the `CAS` option). This section explains how the threading and locking mechanisms work, and what to expect in terms of performance.\n\n## Threading Model\n\n- The `VSIM` command runs in a separate thread by default, allowing Redis to continue serving other commands.\n- A maximum of 32 threads can run concurrently (defined by `HNSW_MAX_THREADS`).\n- When this limit is reached, additional `VSIM` requests are queued - Redis remains responsive, no latency event is generated.\n- The `VADD` command with the `CAS` option also leverages threading for the computation-heavy candidate search phase, but the insertion itself is performed in the main thread. `VADD` always runs in a sub-millisecond time, so this is not a source of latency, but having too many hundreds of writes per second can be challenging to handle with a single instance. Please, look at the next section about multiple instances scalability.\n- Commands run within Lua scripts, MULTI/EXEC blocks, or from replication are executed in the main thread to ensure consistency.\n\n```\n> VSIM vset VALUES 3 1 1 1 FILTER '.year > 2000' # This runs in a thread.\n> VADD vset VALUES 3 1 1 1 element CAS # Candidate search runs in a thread.\n```\n\n## Locking Mechanism\n\nVector Sets use a read/write locking mechanism to coordinate access:\n\n- Reads (`VSIM`, `VEMB`, etc.) acquire a read lock, allowing multiple concurrent reads.\n- Writes (`VADD`, `VREM`, etc.) acquire a write lock, temporarily blocking all reads.\n- When a write lock is requested while reads are in progress, the write operation waits for all reads to complete.\n- Once a write lock is granted, all reads are blocked until the write completes.\n- Each thread has a dedicated slot for tracking visited nodes during graph traversal, avoiding contention. This improves performances but limits the maximum number of concurrent threads, since each node has a memory cost proportional to the number of slots.\n\n## DEL latency\n\nDeleting a very large vector set (millions of elements) can cause latency spikes, as deletion rebuilds connections between nodes. This may change in the future.\nThe deletion latency is most noticeable when using `DEL` on a key containing a large vector set or when the key expires.\n\n## Performance Characteristics\n\n- Search operations (`VSIM`) scale almost linearly with the number of CPU cores available, up to the thread limit. You can expect a Vector Set composed of million of items associated with components of dimension 300, with the default int8 quantization, to deliver around 50k VSIM operations per second in a single host.\n- Insertion operations (`VADD`) are more computationally expensive than searches, and can't be threaded: expect much lower throughput, in the range of a few thousands inserts per second.\n- Binary quantization offers significantly faster search performance at the cost of some recall quality, while int8 quantization, the default, seems to have very small impacts on recall quality, while it significantly improves performances and space efficiency.\n- The `EF` parameter has a major impact on both search quality and performance - higher values mean better recall but slower searches.\n- Graph traversal time scales logarithmically with the number of elements, making Vector Sets efficient even with millions of vectors\n\n## Loading / Saving performances\n\nVector Sets are able to serialize on disk the graph structure as it is in memory, so loading back the data does not need to rebuild the HNSW graph. This means that Redis can load millions of items per minute. For instance 3 million items with 300 components vectors can be loaded back into memory into around 15 seconds.\n\n# Scaling vector sets to multiple instances\n\nThe fundamental way vector sets can be scaled to very large data sets\nand to many Redis instances is that a given very large set of vectors\ncan be partitioned into N different Redis keys, that can also live into\ndifferent Redis instances.\n\nFor instance, I could add my elements into `key0`, `key1`, `key2`, by hashing\nthe item in some way, like doing `crc32(item)%3`, effectively splitting\nthe dataset into three different parts. However once I want all the vectors\nof my dataset near to a given query vector, I could simply perform the\n`VSIM` command against all the three keys, merging the results by\nscore (so the commands must be called using the `WITHSCORES` option) on\nthe client side: once the union of the results are ordered by the\nsimilarity score, the query is equivalent to having a single key `key1+2+3`\ncontaining all the items.\n\nThere are a few interesting facts to note about this pattern:\n\n1. It is possible to have a logical sorted set that is as big as the sum of all the Redis instances we are using.\n2. Deletion operations remain simple, we can hash the key and select the key where our item belongs.\n3. However, even if I use 10 different Redis instances, I'm not going to reach 10x the **read** operations per second, compared to using a single server: for each logical query, I need to query all the instances. Yet, smaller graphs are faster to navigate, so there is some win even from the point of view of CPU usage.\n4. Insertions, so **write** queries, will be scaled linearly: I can add N items against N instances at the same time, splitting the insertion load evenly. This is very important since vector sets, being based on HNSW data structures, are slower to add items than to query similar items, by a very big factor.\n5. While it cannot guarantee always the best results, with proper timeout management this system may be considered *highly available*, since if a subset of N instances are reachable, I'll be still be able to return similar items to my query vector.\n\nNotably, this pattern can be implemented in a way that avoids paying the sum of the round trip time with all the servers: it is possible to send the queries at the same time to all the instances, so that latency will be equal the slower reply out of of the N servers queries.\n\n# Optimizing memory usage\n\nVector Sets, or better, HNSWs, the underlying data structure used by Vector Sets, combined with the features provided by the Vector Sets themselves (quantization, random projection, filtering, ...) form an implementation that has a non-trivial space of parameters that can be tuned. Despite to the complexity of the implementation and of vector similarity problems, here there is a list of simple ideas that can drive the user to pick the best settings:\n\n* 8 bit quantization (the default) is almost always a win. It reduces the memory usage of vectors by a factor of 4, yet the performance penalty in terms of recall is minimal. It also reduces insertion and search time by around 2 times or more.\n* Binary quantization is much more extreme: it makes vector sets a lot faster, but increases the recall error in a sensible way, for instance from 95% to 80% if all the parameters remain the same. Yet, the speedup is really big, and the memory usage of vectors, compaerd to full precision vectors, 32 times smaller.\n* Vectors memory usage are not the only responsible for Vector Set high memory usage per entry: nodes contain, on average `M*2 + M*0.33` pointers, where M is by default 16 (but can be tuned in `VADD`, see the `M` option). Also each node has the string item and the optional JSON attributes: those should be as small as possible in order to avoid contributing more to the memory usage.\n* The `M` parameter should be increased to 32 or more only when a near perfect recall is really needed.\n* It is possible to gain space (less memory usage) sacrificing time (more CPU time) by using a low `M` (the default of 16, for instance) and a high `EF` (the effort parameter of `VSIM`) in order to scan the graph more deeply.\n* When memory usage is seriosu concern, and there is the suspect the vectors we are storing don't contain as much information - at least for our use case - to justify the number of components they feature, random projection (the `REDUCE` option of `VADD`) could be tested to see if dimensionality reduction is possible with acceptable precision loss.\n\n## Random projection tradeoffs\n\nSometimes learned vectors are not as information dense as we could guess, that\nis there are components having similar meanings in the space, and components\nhaving values that don't really represent features that matter in our use case.\n\nAt the same time, certain vectors are very big, 1024 components or more. In this cases, it is possible to use the random projection feature of Redis Vector Sets in order to reduce both space (less RAM used) and space (more operstions per second). The feature is accessible via the `REDUCE` option of the `VADD` command. However, keep in mind that you need to test how much reduction impacts the performances of your vectors in term of recall and quality of the results you get back.\n\n## What is a random projection?\n\nThe concept of Random Projection is relatively simple to grasp. For instance, a projection that turns a 100 components vector into a 10 components vector will perform a different linear transformation between the 100 components and each of the target 10 components. Please note that *each of the target components* will get some random amount of all the 100 original components. It is mathematically proved that this process results in a vector space where elements still have similar distances among them, but still some information will get lost.\n\n## Examples of projections and loss of precision\n\nTo show you a bit of a extreme case, let's take Word2Vec 3 million items and compress them from 300 to 100, 50 and 25 components vectors. Then, we check the recall compared to the ground truth against each of the vector sets produced in this way (using different `REDUCE` parameters of `VADD`). This is the result, obtained asking for the top 10 elements.\n\n```\n----------------------------------------------------------------------\nKey Average Recall % Std Dev\n----------------------------------------------------------------------\nword_embeddings_int8 95.98 12.14\n ^ This is the same key used for ground truth, but without TRUTH option\nword_embeddings_reduced_100 40.20 20.13\nword_embeddings_reduced_50 24.42 16.89\nword_embeddings_reduced_25 14.31 9.99\n```\n\nHere the dimensionality reduction we are using is quite extreme: from 300 to 100 means that 66.6% of the original information is lost. The recall drops from 96% to 40%, down to 24% and 14% for even more extreme dimension reduction.\n\nReducing the dimension of vectors that are already relatively small, like the above example, of 300 components, will provide only relatively small memory savings, especially because by default Vector Sets use `int8` quantization, that will use only one byte per component:\n\n```\n> MEMORY USAGE word_embeddings_int8\n(integer) 3107002888\n> MEMORY USAGE word_embeddings_reduced_100\n(integer) 2507122888\n```\n\nOf course going, for example, from 2048 component vectors to 1024 would provide a much more sensible memory saving, even with the `int8` quantization used by Vector Sets, assuming the recall loss is acceptable. Other than the memory saving, there is also the reduction in CPU time, translating to more operations per second.\n\nAnother thing to note is that, with certain embedding models, binary quantization (that offers a 8x reduction of memory usage compared to 8 bit quants, and a very big speedup in computation) performs much better than reducing the dimension of vectors of the same amount via random projections:\n\n```\nword_embeddings_bin 35.48 19.78\n```\n\nHere in the same test did above: we have a 35% recall which is not too far than the 40% obtained with a random projection from 300 to 100 components. However, while the first technique reduces the size by 3 times, the size reduced of binary quantization is by 8 times.\n\n```\n> memory usage word_embeddings_bin\n(integer) 2327002888\n```\n\nIn this specific case the key uses JSON attributes and has a graph connection overhead that is much bigger than the 300 bits each vector takes, but, as already said, for big vectors (1024 components, for instance) or for lower values of `M` (see `VADD`, the `M` parameter connects the level of connectivity, so it changes the amount of pointers used per node) the memory saving is much stronger.\n\n# Vector Sets troubleshooting and understandability\n\n## Debugging poor recall or unexpected results\n\nVector graphs and similarity queries pose many challenges mainly due to the following three problems:\n\n1. The error due to the approximated nature of Vector Sets is hard to evaluate.\n2. The error added by the quantization is often depends on the exact vector space (the embedding we are using **and** how far apart the elements we represent into such embeddings are).\n3. We live in the illusion that learned embeddings capture the best similarity possible among elements, which is obviously not always true, and highly application dependent.\n\nThe only way to debug such problems, is the ability to inspect step by step what is happening inside our application, and the structure of the HNSW graph itself. To do so, we suggest to consider the following tools:\n\n1. The `TRUTH` option of the `VSIM` command is able to return the ground truth of the most similar elements, without using the HNSW graph, but doing a linear scan.\n2. The `VLINKS` command allows to explore the graph to see if the connections among nodes make sense, and to investigate why a given node may be more isolated than expected. Such command can also be used in a different way, when we want very fast \"similar items\" without paying the HNSW traversal time. It exploits the fact that we have a direct reference from each element in our vector set to each node in our HNSW graph.\n3. The `WITHSCORES` option, in the supported commands, return a value that is directly related to the *cosine similarity* between the query and the items vectors, the interval of the similarity is simply rescaled from the -1, 1 original range to 0, 1, otherwise the metric is identical.\n\n## Clients, latency and bandwidth usage\n\nDuring Vector Sets testing, we discovered that often clients introduce considerable latecy and CPU usage (in the client side, not in Redis) for two main reasons:\n\n1. Often the serialization to `VALUES ... list of floats ...` can be very slow.\n2. The vector payload of floats represented as strings is very large, resulting in high bandwidth usage and latency, compared to other Redis commands.\n\nSwitching from `VALUES` to `FP32` as a method for transmitting vectors may easily provide 10-20x speedups.\n\n# Implementation details\n\nVector sets are based on the `hnsw.c` implementation of the HNSW data structure with extensions for speed and functionality.\n\nThe main features are:\n\n* Proper nodes deletion with relinking.\n* 8 bits and binary quantization.\n* Threaded queries.\n* Filtered search with predicate callback.\n" }, { "path": "modules/vector-sets/commands.json", "content": "{\n \"VADD\": {\n \"summary\": \"Add one or more elements to a vector set, or update its vector if it already exists\",\n \"complexity\": \"O(log(N)) for each element added, where N is the number of elements in the vector set.\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": -5,\n \"function\": \"vaddCommand\",\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"token\": \"REDUCE\",\n \"name\": \"reduce\",\n \"type\": \"block\",\n \"optional\": true,\n \"arguments\": [\n {\n \"name\": \"dim\",\n \"type\": \"integer\"\n }\n ]\n },\n {\n \"name\": \"format\",\n \"type\": \"oneof\",\n \"arguments\": [\n {\n \"name\": \"fp32\",\n \"type\": \"pure-token\",\n \"token\": \"FP32\"\n },\n {\n \"name\": \"values\",\n \"type\": \"pure-token\",\n \"token\": \"VALUES\"\n }\n ]\n },\n {\n \"name\": \"vector\",\n \"type\": \"string\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n },\n {\n \"token\": \"CAS\",\n \"name\": \"cas\",\n \"type\": \"pure-token\",\n \"optional\": true\n },\n {\n \"name\": \"quant_type\",\n \"type\": \"oneof\",\n \"optional\": true,\n \"arguments\": [\n {\n \"name\": \"noquant\",\n \"type\": \"pure-token\",\n \"token\": \"NOQUANT\"\n },\n {\n \"name\": \"bin\",\n \"type\": \"pure-token\",\n \"token\": \"BIN\"\n },\n {\n \"name\": \"q8\",\n \"type\": \"pure-token\",\n \"token\": \"Q8\"\n }\n ]\n },\n {\n \"token\": \"EF\",\n \"name\": \"build-exploration-factor\",\n \"type\": \"integer\",\n \"optional\": true\n },\n {\n \"token\": \"SETATTR\",\n \"name\": \"attributes\",\n \"type\": \"string\",\n \"optional\": true\n },\n {\n \"token\": \"M\",\n \"name\": \"numlinks\",\n \"type\": \"integer\",\n \"optional\": true\n }\n ],\n \"command_flags\": [\n \"WRITE\",\n \"DENYOOM\"\n ]\n },\n \"VREM\": {\n \"summary\": \"Remove an element from a vector set\",\n \"complexity\": \"O(log(N)) for each element removed, where N is the number of elements in the vector set.\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 3,\n \"function\": \"vremCommand\",\n \"command_flags\": [\n \"WRITE\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n }\n ]\n },\n \"VSIM\": {\n \"summary\": \"Return elements by vector similarity\",\n \"complexity\": \"O(log(N)) where N is the number of elements in the vector set.\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": -4,\n \"function\": \"vsimCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"format\",\n \"type\": \"oneof\",\n \"arguments\": [\n {\n \"name\": \"ele\",\n \"type\": \"pure-token\",\n \"token\": \"ELE\"\n },\n {\n \"name\": \"fp32\",\n \"type\": \"pure-token\",\n \"token\": \"FP32\"\n },\n {\n \"name\": \"values\",\n \"type\": \"pure-token\",\n \"token\": \"VALUES\"\n }\n ]\n },\n {\n \"name\": \"vector_or_element\",\n \"type\": \"string\"\n },\n {\n \"token\": \"WITHSCORES\",\n \"name\": \"withscores\",\n \"type\": \"pure-token\",\n \"optional\": true\n },\n {\n \"token\": \"WITHATTRIBS\",\n \"name\": \"withattribs\",\n \"type\": \"pure-token\",\n \"optional\": true\n },\n {\n \"token\": \"COUNT\",\n \"name\": \"count\",\n \"type\": \"integer\",\n \"optional\": true\n },\n {\n \"token\": \"EPSILON\",\n \"name\": \"max_distance\",\n \"type\": \"double\",\n \"optional\": true\n },\n {\n \"token\": \"EF\",\n \"name\": \"search-exploration-factor\",\n \"type\": \"integer\",\n \"optional\": true\n },\n {\n \"token\": \"FILTER\",\n \"name\": \"expression\",\n \"type\": \"string\",\n \"optional\": true\n },\n {\n \"token\": \"FILTER-EF\",\n \"name\": \"max-filtering-effort\",\n \"type\": \"integer\",\n \"optional\": true\n },\n {\n \"token\": \"TRUTH\",\n \"name\": \"truth\",\n \"type\": \"pure-token\",\n \"optional\": true\n },\n {\n \"token\": \"NOTHREAD\",\n \"name\": \"nothread\",\n \"type\": \"pure-token\",\n \"optional\": true\n }\n ]\n },\n \"VDIM\": {\n \"summary\": \"Return the dimension of vectors in the vector set\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 2,\n \"function\": \"vdimCommand\",\n \"command_flags\": [\n \"READONLY\",\n \"FAST\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n }\n ]\n },\n \"VCARD\": {\n \"summary\": \"Return the number of elements in a vector set\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 2,\n \"function\": \"vcardCommand\",\n \"command_flags\": [\n \"READONLY\",\n \"FAST\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n }\n ]\n },\n \"VEMB\": {\n \"summary\": \"Return the vector associated with an element\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": -3,\n \"function\": \"vembCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n },\n {\n \"token\": \"RAW\",\n \"name\": \"raw\",\n \"type\": \"pure-token\",\n \"optional\": true\n }\n ]\n },\n \"VLINKS\": {\n \"summary\": \"Return the neighbors of an element at each layer in the HNSW graph\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": -3,\n \"function\": \"vlinksCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n },\n {\n \"token\": \"WITHSCORES\",\n \"name\": \"withscores\",\n \"type\": \"pure-token\",\n \"optional\": true\n }\n ]\n },\n \"VINFO\": {\n \"summary\": \"Return information about a vector set\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 2,\n \"function\": \"vinfoCommand\",\n \"command_flags\": [\n \"READONLY\",\n \"FAST\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n }\n ]\n },\n \"VSETATTR\": {\n \"summary\": \"Associate or remove the JSON attributes of elements\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 4,\n \"function\": \"vsetattrCommand\",\n \"command_flags\": [\n \"WRITE\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n },\n {\n \"name\": \"json\",\n \"type\": \"string\"\n }\n ]\n },\n \"VGETATTR\": {\n \"summary\": \"Retrieve the JSON attributes of elements\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": 3,\n \"function\": \"vgetattrCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n }\n ]\n },\n \"VRANDMEMBER\": {\n \"summary\": \"Return one or multiple random members from a vector set\",\n \"complexity\": \"O(N) where N is the absolute value of the count argument.\",\n \"group\": \"vector_set\",\n \"since\": \"8.0.0\",\n \"arity\": -2,\n \"function\": \"vrandmemberCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"count\",\n \"type\": \"integer\",\n \"optional\": true\n }\n ]\n },\n \"VISMEMBER\": {\n \"summary\": \"Check if an element exists in a vector set\",\n \"complexity\": \"O(1)\",\n \"group\": \"vector_set\",\n \"since\": \"8.2.0\",\n \"arity\": 3,\n \"function\": \"vismemberCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"element\",\n \"type\": \"string\"\n }\n ]\n },\n \"VRANGE\": {\n \"summary\": \"Return elements in a lexicographical range\",\n \"complexity\": \"O(log(K)+M) where K is the number of elements in the start prefix, and M is the number of elements returned. In practical terms, the command is just O(M)\",\n \"group\": \"vector_set\",\n \"since\": \"8.4.0\",\n \"arity\": -4,\n \"function\": \"vrangeCommand\",\n \"command_flags\": [\n \"READONLY\"\n ],\n \"arguments\": [\n {\n \"name\": \"key\",\n \"type\": \"key\"\n },\n {\n \"name\": \"start\",\n \"type\": \"string\"\n },\n {\n \"name\": \"end\",\n \"type\": \"string\"\n },\n {\n \"name\": \"count\",\n \"type\": \"integer\",\n \"optional\": true\n }\n ]\n }\n}\n" }, { "path": "modules/vector-sets/examples/cli-tool/.gitignore", "content": "venv\n" }, { "path": "modules/vector-sets/examples/cli-tool/README.md", "content": "This tool is similar to redis-cli (but very basic) but allows\nto specify arguments that are expanded as vectors by calling\nollama to get the embedding.\n\nWhatever is passed as !\"foo bar\" gets expanded into\n VALUES ... embedding ...\n\nYou must have ollama running with the mxbai-emb-large model\nalready installed for this to work.\n\nExample:\n\n redis> KEYS *\n 1) food_items\n 2) glove_embeddings_bin\n 3) many_movies_mxbai-embed-large_BIN\n 4) many_movies_mxbai-embed-large_NOQUANT\n 5) word_embeddings\n 6) word_embeddings_bin\n 7) glove_embeddings_fp32\n\n redis> VSIM food_items !\"drinks with fruit\"\n 1) (Fruit)Juices,Lemonade,100ml,50 cal,210 kJ\n 2) (Fruit)Juices,Limeade,100ml,128 cal,538 kJ\n 3) CannedFruit,Canned Fruit Cocktail,100g,81 cal,340 kJ\n 4) (Fruit)Juices,Energy-Drink,100ml,87 cal,365 kJ\n 5) Fruits,Lime,100g,30 cal,126 kJ\n 6) (Fruit)Juices,Coconut Water,100ml,19 cal,80 kJ\n 7) Fruits,Lemon,100g,29 cal,122 kJ\n 8) (Fruit)Juices,Clamato,100ml,60 cal,252 kJ\n 9) Fruits,Fruit salad,100g,50 cal,210 kJ\n 10) (Fruit)Juices,Capri-Sun,100ml,41 cal,172 kJ\n\n redis> vsim food_items !\"barilla\"\n 1) Pasta&Noodles,Spirelli,100g,367 cal,1541 kJ\n 2) Pasta&Noodles,Farfalle,100g,358 cal,1504 kJ\n 3) Pasta&Noodles,Capellini,100g,353 cal,1483 kJ\n 4) Pasta&Noodles,Spaetzle,100g,368 cal,1546 kJ\n 5) Pasta&Noodles,Cappelletti,100g,164 cal,689 kJ\n 6) Pasta&Noodles,Penne,100g,351 cal,1474 kJ\n 7) Pasta&Noodles,Shells,100g,353 cal,1483 kJ\n 8) Pasta&Noodles,Linguine,100g,357 cal,1499 kJ\n 9) Pasta&Noodles,Rotini,100g,353 cal,1483 kJ\n 10) Pasta&Noodles,Rigatoni,100g,353 cal,1483 kJ\n" }, { "path": "modules/vector-sets/examples/cli-tool/cli.py", "content": "#\n# Copyright (c) 2009-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n\n#!/usr/bin/env python3\nimport argparse\nimport redis\nimport requests\nimport re\nimport shlex\nfrom prompt_toolkit import PromptSession\nfrom prompt_toolkit.history import InMemoryHistory\n\n# Default Ollama embeddings URL (can be overridden with --ollama-url)\nOLLAMA_URL = \"http://localhost:11434/api/embeddings\"\n\ndef get_embedding(text):\n \"\"\"Get embedding from local Ollama API\"\"\"\n url = OLLAMA_URL\n payload = {\n \"model\": \"mxbai-embed-large\",\n \"prompt\": text\n }\n try:\n response = requests.post(url, json=payload)\n response.raise_for_status()\n return response.json()['embedding']\n except requests.exceptions.RequestException as e:\n raise Exception(f\"Failed to get embedding: {str(e)}\")\n\ndef process_embedding_patterns(text):\n \"\"\"Process !\"text\" and !!\"text\" patterns in the command\"\"\"\n\n def replace_with_embedding(match):\n text = match.group(1)\n embedding = get_embedding(text)\n return f\"VALUES {len(embedding)} {' '.join(map(str, embedding))}\"\n\n def replace_with_embedding_and_text(match):\n text = match.group(1)\n embedding = get_embedding(text)\n # Return both the embedding values and the original text as next argument\n return f'VALUES {len(embedding)} {\" \".join(map(str, embedding))} \"{text}\"'\n\n # First handle !!\"text\" pattern (must be done before !\"text\")\n text = re.sub(r'!!\"([^\"]*)\"', replace_with_embedding_and_text, text)\n # Then handle !\"text\" pattern\n text = re.sub(r'!\"([^\"]*)\"', replace_with_embedding, text)\n return text\n\ndef parse_command(command):\n \"\"\"Parse command respecting quoted strings\"\"\"\n try:\n # Use shlex to properly handle quoted strings\n return shlex.split(command)\n except ValueError as e:\n raise Exception(f\"Invalid command syntax: {str(e)}\")\n\ndef format_response(response):\n \"\"\"Format the response to match Redis protocol style\"\"\"\n if response is None:\n return \"(nil)\"\n elif isinstance(response, bool):\n return \"+OK\" if response else \"(error) Operation failed\"\n elif isinstance(response, (list, set)):\n if not response:\n return \"(empty list or set)\"\n return \"\\n\".join(f\"{i+1}) {item}\" for i, item in enumerate(response))\n elif isinstance(response, int):\n return f\"(integer) {response}\"\n else:\n return str(response)\n\ndef main():\n global OLLAMA_URL\n\n parser = argparse.ArgumentParser(prog=\"cli.py\", add_help=False)\n parser.add_argument(\"--ollama-url\", dest=\"ollama_url\",\n help=\"Ollama embeddings API URL (default: {OLLAMA_URL})\",\n default=OLLAMA_URL)\n args, _ = parser.parse_known_args()\n OLLAMA_URL = args.ollama_url\n\n # Default connection to localhost:6379\n r = redis.Redis(host='localhost', port=6379, decode_responses=True)\n\n try:\n # Test connection\n r.ping()\n print(\"Connected to Redis. Type your commands (CTRL+D to exit):\")\n print(\"Special syntax:\")\n print(\" !\\\"text\\\" - Replace with embedding\")\n print(\" !!\\\"text\\\" - Replace with embedding and append text as value\")\n print(\" \\\"text\\\" - Quote strings containing spaces\")\n except redis.ConnectionError:\n print(\"Error: Could not connect to Redis server\")\n return\n\n # Setup prompt session with history\n session = PromptSession(history=InMemoryHistory())\n\n # Main loop\n while True:\n try:\n # Read input with line editing support\n command = session.prompt(\"redis> \")\n\n # Skip empty commands\n if not command.strip():\n continue\n\n # Process any embedding patterns before parsing\n try:\n processed_command = process_embedding_patterns(command)\n except Exception as e:\n print(f\"(error) Embedding processing failed: {str(e)}\")\n continue\n\n # Parse the command respecting quoted strings\n try:\n parts = parse_command(processed_command)\n except Exception as e:\n print(f\"(error) {str(e)}\")\n continue\n\n if not parts:\n continue\n\n cmd = parts[0].lower()\n args = parts[1:]\n\n # Execute command\n try:\n method = getattr(r, cmd, None)\n if method is not None:\n result = method(*args)\n else:\n # Use execute_command for unknown commands\n result = r.execute_command(cmd, *args)\n print(format_response(result))\n except AttributeError:\n print(f\"(error) Unknown command '{cmd}'\")\n\n except EOFError:\n print(\"\\nGoodbye!\")\n break\n except KeyboardInterrupt:\n continue # Allow Ctrl+C to clear current line\n except redis.RedisError as e:\n print(f\"(error) {str(e)}\")\n except Exception as e:\n print(f\"(error) {str(e)}\")\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "modules/vector-sets/examples/glove-100/README", "content": "wget http://ann-benchmarks.com/glove-100-angular.hdf5\npython insert.py\npython recall.py (use --k optionally, default top-10)\n" }, { "path": "modules/vector-sets/examples/glove-100/insert.py", "content": "#\n# Copyright (c) 2009-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n\nimport h5py\nimport redis\nfrom tqdm import tqdm\n\n# Initialize Redis connection\nredis_client = redis.Redis(host='localhost', port=6379, decode_responses=True, encoding='utf-8')\n\ndef add_to_redis(index, embedding):\n \"\"\"Add embedding to Redis using VADD command\"\"\"\n args = [\"VADD\", \"glove_embeddings\", \"VALUES\", \"100\"] # 100 is vector dimension\n args.extend(map(str, embedding))\n args.append(f\"{index}\") # Using index as identifier since we don't have words\n args.append(\"EF\")\n args.append(\"200\")\n # args.append(\"NOQUANT\")\n # args.append(\"BIN\")\n redis_client.execute_command(*args)\n\ndef main():\n with h5py.File('glove-100-angular.hdf5', 'r') as f:\n # Get the train dataset\n train_vectors = f['train']\n total_vectors = train_vectors.shape[0]\n\n print(f\"Starting to process {total_vectors} vectors...\")\n\n # Process in batches to avoid memory issues\n batch_size = 1000\n\n for i in tqdm(range(0, total_vectors, batch_size)):\n batch_end = min(i + batch_size, total_vectors)\n batch = train_vectors[i:batch_end]\n\n for j, vector in enumerate(batch):\n try:\n current_index = i + j\n add_to_redis(current_index, vector)\n\n except Exception as e:\n print(f\"Error processing vector {current_index}: {str(e)}\")\n continue\n\n if (i + batch_size) % 10000 == 0:\n print(f\"Processed {i + batch_size} vectors\")\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "modules/vector-sets/examples/glove-100/recall.py", "content": "#\n# Copyright (c) 2009-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n\nimport h5py\nimport redis\nimport numpy as np\nfrom tqdm import tqdm\nimport argparse\n\n# Initialize Redis connection\nredis_client = redis.Redis(host='localhost', port=6379, decode_responses=True, encoding='utf-8')\n\ndef get_redis_neighbors(query_vector, k):\n \"\"\"Get nearest neighbors using Redis VSIM command\"\"\"\n args = [\"VSIM\", \"glove_embeddings_bin\", \"VALUES\", \"100\"]\n args.extend(map(str, query_vector))\n args.extend([\"COUNT\", str(k)])\n args.extend([\"EF\", 100])\n if False:\n print(args)\n exit(1)\n results = redis_client.execute_command(*args)\n return [int(res) for res in results]\n\ndef calculate_recall(ground_truth, predicted, k):\n \"\"\"Calculate recall@k\"\"\"\n relevant = set(ground_truth[:k])\n retrieved = set(predicted[:k])\n return len(relevant.intersection(retrieved)) / len(relevant)\n\ndef main():\n parser = argparse.ArgumentParser(description='Evaluate Redis VSIM recall')\n parser.add_argument('--k', type=int, default=10, help='Number of neighbors to evaluate (default: 10)')\n parser.add_argument('--batch', type=int, default=100, help='Progress update frequency (default: 100)')\n args = parser.parse_args()\n\n k = args.k\n batch_size = args.batch\n\n with h5py.File('glove-100-angular.hdf5', 'r') as f:\n test_vectors = f['test'][:]\n ground_truth_neighbors = f['neighbors'][:]\n \n num_queries = len(test_vectors)\n recalls = []\n \n print(f\"Evaluating recall@{k} for {num_queries} test queries...\")\n \n for i in tqdm(range(num_queries)):\n try:\n # Get Redis results\n redis_neighbors = get_redis_neighbors(test_vectors[i], k)\n \n # Get ground truth for this query\n true_neighbors = ground_truth_neighbors[i]\n \n # Calculate recall\n recall = calculate_recall(true_neighbors, redis_neighbors, k)\n recalls.append(recall)\n \n if (i + 1) % batch_size == 0:\n current_avg_recall = np.mean(recalls)\n print(f\"Current average recall@{k} after {i+1} queries: {current_avg_recall:.4f}\")\n \n except Exception as e:\n print(f\"Error processing query {i}: {str(e)}\")\n continue\n \n final_recall = np.mean(recalls)\n print(\"\\nFinal Results:\")\n print(f\"Average recall@{k}: {final_recall:.4f}\")\n print(f\"Total queries evaluated: {len(recalls)}\")\n \n # Save detailed results\n with open(f'recall_evaluation_results_k{k}.txt', 'w') as f:\n f.write(f\"Average recall@{k}: {final_recall:.4f}\\n\")\n f.write(f\"Total queries evaluated: {len(recalls)}\\n\")\n f.write(f\"Individual query recalls: {recalls}\\n\")\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "modules/vector-sets/examples/movies/.gitignore", "content": "mpst_full_data.csv\npartition.json\n" }, { "path": "modules/vector-sets/examples/movies/README", "content": "This example maps long form movies plots to movies titles.\nIt will create fp32 and binary vectors (the two extremes).\n\n1. Install ollama, and install the embedding model \"mxbai-embed-large\"\n2. Download mpst_full_data.csv from https://www.kaggle.com/datasets/cryptexcode/mpst-movie-plot-synopses-with-tags\n3. python insert.py\n\n127.0.0.1:6379> VSIM many_movies_mxbai-embed-large_NOQUANT ELE \"The Matrix\"\n 1) \"The Matrix\"\n 2) \"The Matrix Reloaded\"\n 3) \"The Matrix Revolutions\"\n 4) \"Commando\"\n 5) \"Avatar\"\n 6) \"Forbidden Planet\"\n 7) \"Terminator Salvation\"\n 8) \"Mandroid\"\n 9) \"The Omega Code\"\n10) \"Coherence\"\n\n127.0.0.1:6379> VSIM many_movies_mxbai-embed-large_BIN ELE \"The Matrix\"\n 1) \"The Matrix\"\n 2) \"The Matrix Reloaded\"\n 3) \"The Matrix Revolutions\"\n 4) \"The Omega Code\"\n 5) \"Forbidden Planet\"\n 6) \"Avatar\"\n 7) \"John Carter\"\n 8) \"System Shock 2\"\n 9) \"Coherence\"\n10) \"Tomorrowland\"\n" }, { "path": "modules/vector-sets/examples/movies/insert.py", "content": "#\n# Copyright (c) 2009-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n\nimport csv\nimport requests\nimport redis\n\nModelName=\"mxbai-embed-large\"\n\n# Initialize Redis connection, setting encoding to utf-8\nredis_client = redis.Redis(host='localhost', port=6379, decode_responses=True, encoding='utf-8')\n\ndef get_embedding(text):\n \"\"\"Get embedding from local API\"\"\"\n url = \"http://localhost:11434/api/embeddings\"\n payload = {\n \"model\": ModelName,\n \"prompt\": \"Represent this movie plot and genre: \"+text\n }\n response = requests.post(url, json=payload)\n return response.json()['embedding']\n\ndef add_to_redis(title, embedding, quant_type):\n \"\"\"Add embedding to Redis using VADD command\"\"\"\n args = [\"VADD\", \"many_movies_\"+ModelName+\"_\"+quant_type, \"VALUES\", str(len(embedding))]\n args.extend(map(str, embedding))\n args.append(title)\n args.append(quant_type)\n redis_client.execute_command(*args)\n\ndef main():\n with open('mpst_full_data.csv', 'r', encoding='utf-8') as file:\n reader = csv.DictReader(file)\n\n for movie in reader:\n try:\n text_to_embed = f\"{movie['title']} {movie['plot_synopsis']} {movie['tags']}\"\n\n print(f\"Getting embedding for: {movie['title']}\")\n embedding = get_embedding(text_to_embed)\n\n add_to_redis(movie['title'], embedding, \"BIN\")\n add_to_redis(movie['title'], embedding, \"NOQUANT\")\n print(f\"Successfully processed: {movie['title']}\")\n\n except Exception as e:\n print(f\"Error processing {movie['title']}: {str(e)}\")\n continue\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "modules/vector-sets/expr.c", "content": "/* Filtering of objects based on simple expressions.\n * This powers the FILTER option of Vector Sets, but it is otherwise\n * general code to be used when we want to tell if a given object (with fields)\n * passes or fails a given test for scalars, strings, ...\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo.\n */\n\n#ifdef TEST_MAIN\n#define RedisModule_Alloc malloc\n#define RedisModule_Realloc realloc\n#define RedisModule_Free free\n#define RedisModule_Strdup strdup\n#define RedisModule_Assert assert\n#define _DEFAULT_SOURCE\n#define _USE_MATH_DEFINES\n#include \n#include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#define EXPR_TOKEN_EOF 0\n#define EXPR_TOKEN_NUM 1\n#define EXPR_TOKEN_STR 2\n#define EXPR_TOKEN_TUPLE 3\n#define EXPR_TOKEN_SELECTOR 4\n#define EXPR_TOKEN_OP 5\n#define EXPR_TOKEN_NULL 6\n\n#define EXPR_OP_OPAREN 0 /* ( */\n#define EXPR_OP_CPAREN 1 /* ) */\n#define EXPR_OP_NOT 2 /* ! */\n#define EXPR_OP_POW 3 /* ** */\n#define EXPR_OP_MULT 4 /* * */\n#define EXPR_OP_DIV 5 /* / */\n#define EXPR_OP_MOD 6 /* % */\n#define EXPR_OP_SUM 7 /* + */\n#define EXPR_OP_DIFF 8 /* - */\n#define EXPR_OP_GT 9 /* > */\n#define EXPR_OP_GTE 10 /* >= */\n#define EXPR_OP_LT 11 /* < */\n#define EXPR_OP_LTE 12 /* <= */\n#define EXPR_OP_EQ 13 /* == */\n#define EXPR_OP_NEQ 14 /* != */\n#define EXPR_OP_IN 15 /* in */\n#define EXPR_OP_AND 16 /* and */\n#define EXPR_OP_OR 17 /* or */\n\n/* This structure represents a token in our expression. It's either\n * literals like 4, \"foo\", or operators like \"+\", \"-\", \"and\", or\n * json selectors, that start with a dot: \".age\", \".properties.somearray[1]\" */\ntypedef struct exprtoken {\n int refcount; // Reference counting for memory reclaiming.\n int token_type; // Token type of the just parsed token.\n int offset; // Chars offset in expression.\n union {\n double num; // Value for EXPR_TOKEN_NUM.\n struct {\n char *start; // String pointer for EXPR_TOKEN_STR / SELECTOR.\n size_t len; // String len for EXPR_TOKEN_STR / SELECTOR.\n char *heapstr; // True if we have a private allocation for this\n // string. When possible, it just references to the\n // string expression we compiled, exprstate->expr.\n } str;\n int opcode; // Opcode ID for EXPR_TOKEN_OP.\n struct {\n struct exprtoken **ele;\n size_t len;\n } tuple; // Tuples are like [1, 2, 3] for \"in\" operator.\n };\n} exprtoken;\n\n/* Simple stack of expr tokens. This is used both to represent the stack\n * of values and the stack of operands during VM execution. */\ntypedef struct exprstack {\n exprtoken **items;\n int numitems;\n int allocsize;\n} exprstack;\n\ntypedef struct exprstate {\n char *expr; /* Expression string to compile. Note that\n * expression token strings point directly to this\n * string. */\n char *p; // Current position inside 'expr', while parsing.\n\n // Virtual machine state.\n exprstack values_stack;\n exprstack ops_stack; // Operator stack used during compilation.\n exprstack tokens; // Expression processed into a sequence of tokens.\n exprstack program; // Expression compiled into opcodes and values.\n} exprstate;\n\n/* Valid operators. */\nstruct {\n char *opname;\n int oplen;\n int opcode;\n int precedence;\n int arity;\n} ExprOptable[] = {\n {\"(\", 1, EXPR_OP_OPAREN, 7, 0},\n {\")\", 1, EXPR_OP_CPAREN, 7, 0},\n {\"!\", 1, EXPR_OP_NOT, 6, 1},\n {\"not\", 3, EXPR_OP_NOT, 6, 1},\n {\"**\", 2, EXPR_OP_POW, 5, 2},\n {\"*\", 1, EXPR_OP_MULT, 4, 2},\n {\"/\", 1, EXPR_OP_DIV, 4, 2},\n {\"%\", 1, EXPR_OP_MOD, 4, 2},\n {\"+\", 1, EXPR_OP_SUM, 3, 2},\n {\"-\", 1, EXPR_OP_DIFF, 3, 2},\n {\">\", 1, EXPR_OP_GT, 2, 2},\n {\">=\", 2, EXPR_OP_GTE, 2, 2},\n {\"<\", 1, EXPR_OP_LT, 2, 2},\n {\"<=\", 2, EXPR_OP_LTE, 2, 2},\n {\"==\", 2, EXPR_OP_EQ, 2, 2},\n {\"!=\", 2, EXPR_OP_NEQ, 2, 2},\n {\"in\", 2, EXPR_OP_IN, 2, 2},\n {\"and\", 3, EXPR_OP_AND, 1, 2},\n {\"&&\", 2, EXPR_OP_AND, 1, 2},\n {\"or\", 2, EXPR_OP_OR, 0, 2},\n {\"||\", 2, EXPR_OP_OR, 0, 2},\n {NULL, 0, 0, 0, 0} // Terminator.\n};\n\n#define EXPR_OP_SPECIALCHARS \"+-*%/!()<>=|&\"\n#define EXPR_SELECTOR_SPECIALCHARS \"_-\"\n\n/* ================================ Expr token ============================== */\n\n/* Return an heap allocated token of the specified type, setting the\n * reference count to 1. */\nexprtoken *exprNewToken(int type) {\n exprtoken *t = RedisModule_Alloc(sizeof(exprtoken));\n memset(t,0,sizeof(*t));\n t->token_type = type;\n t->refcount = 1;\n return t;\n}\n\n/* Generic free token function, can be used to free stack allocated\n * objects (in this case the pointer itself will not be freed) or\n * heap allocated objects. See the wrappers below. */\nvoid exprTokenRelease(exprtoken *t) {\n if (t == NULL) return;\n\n RedisModule_Assert(t->refcount > 0); // Catch double free & more.\n t->refcount--;\n if (t->refcount > 0) return;\n\n // We reached refcount 0: free the object.\n if (t->token_type == EXPR_TOKEN_STR) {\n if (t->str.heapstr != NULL) RedisModule_Free(t->str.heapstr);\n } else if (t->token_type == EXPR_TOKEN_TUPLE) {\n for (size_t j = 0; j < t->tuple.len; j++)\n exprTokenRelease(t->tuple.ele[j]);\n if (t->tuple.ele) RedisModule_Free(t->tuple.ele);\n }\n RedisModule_Free(t);\n}\n\nvoid exprTokenRetain(exprtoken *t) {\n t->refcount++;\n}\n\n/* ============================== Stack handling ============================ */\n\n#include \n#include \n\n#define EXPR_STACK_INITIAL_SIZE 16\n\n/* Initialize a new expression stack. */\nvoid exprStackInit(exprstack *stack) {\n stack->items = RedisModule_Alloc(sizeof(exprtoken*) * EXPR_STACK_INITIAL_SIZE);\n stack->numitems = 0;\n stack->allocsize = EXPR_STACK_INITIAL_SIZE;\n}\n\n/* Push a token pointer onto the stack. Does not increment the refcount\n * of the token: it is up to the caller doing this. */\nvoid exprStackPush(exprstack *stack, exprtoken *token) {\n /* Check if we need to grow the stack. */\n if (stack->numitems == stack->allocsize) {\n size_t newsize = stack->allocsize * 2;\n exprtoken **newitems =\n RedisModule_Realloc(stack->items, sizeof(exprtoken*) * newsize);\n stack->items = newitems;\n stack->allocsize = newsize;\n }\n stack->items[stack->numitems] = token;\n stack->numitems++;\n}\n\n/* Pop a token pointer from the stack. Return NULL if the stack is\n * empty. Does NOT recrement the refcount of the token, it's up to the\n * caller to do so, as the new owner of the reference. */\nexprtoken *exprStackPop(exprstack *stack) {\n if (stack->numitems == 0) return NULL;\n stack->numitems--;\n return stack->items[stack->numitems];\n}\n\n/* Just return the last element pushed, without consuming it nor altering\n * the reference count. */\nexprtoken *exprStackPeek(exprstack *stack) {\n if (stack->numitems == 0) return NULL;\n return stack->items[stack->numitems-1];\n}\n\n/* Free the stack structure state, including the items it contains, that are\n * assumed to be heap allocated. The passed pointer itself is not freed. */\nvoid exprStackFree(exprstack *stack) {\n for (int j = 0; j < stack->numitems; j++)\n exprTokenRelease(stack->items[j]);\n RedisModule_Free(stack->items);\n}\n\n/* Just reset the stack removing all the items, but leaving it in a state\n * that makes it still usable for new elements. */\nvoid exprStackReset(exprstack *stack) {\n for (int j = 0; j < stack->numitems; j++)\n exprTokenRelease(stack->items[j]);\n stack->numitems = 0;\n}\n\n/* =========================== Expression compilation ======================= */\n\nvoid exprConsumeSpaces(exprstate *es) {\n while(es->p[0] && isspace(es->p[0])) es->p++;\n}\n\n/* Parse an operator or a literal (just \"null\" currently).\n * When parsing operators, the function will try to match the longest match\n * in the operators table. */\nexprtoken *exprParseOperatorOrLiteral(exprstate *es) {\n exprtoken *t = exprNewToken(EXPR_TOKEN_OP);\n char *start = es->p;\n\n while(es->p[0] &&\n (isalpha(es->p[0]) ||\n strchr(EXPR_OP_SPECIALCHARS,es->p[0]) != NULL))\n {\n es->p++;\n }\n\n int matchlen = es->p - start;\n int bestlen = 0;\n int j;\n\n // Check if it's a literal.\n if (matchlen == 4 && !memcmp(\"null\",start,4)) {\n t->token_type = EXPR_TOKEN_NULL;\n return t;\n }\n\n // Find the longest matching operator.\n for (j = 0; ExprOptable[j].opname != NULL; j++) {\n if (ExprOptable[j].oplen > matchlen) continue;\n if (memcmp(ExprOptable[j].opname, start, ExprOptable[j].oplen) != 0)\n {\n continue;\n }\n if (ExprOptable[j].oplen > bestlen) {\n t->opcode = ExprOptable[j].opcode;\n bestlen = ExprOptable[j].oplen;\n }\n }\n if (bestlen == 0) {\n exprTokenRelease(t);\n return NULL;\n } else {\n es->p = start + bestlen;\n }\n return t;\n}\n\n// Valid selector charset.\nstatic int is_selector_char(int c) {\n return (isalpha(c) ||\n isdigit(c) ||\n strchr(EXPR_SELECTOR_SPECIALCHARS,c) != NULL);\n}\n\n/* Parse selectors, they start with a dot and can have alphanumerical\n * or few special chars. */\nexprtoken *exprParseSelector(exprstate *es) {\n exprtoken *t = exprNewToken(EXPR_TOKEN_SELECTOR);\n es->p++; // Skip dot.\n char *start = es->p;\n\n while(es->p[0] && is_selector_char(es->p[0])) es->p++;\n int matchlen = es->p - start;\n t->str.start = start;\n t->str.len = matchlen;\n return t;\n}\n\nexprtoken *exprParseNumber(exprstate *es) {\n exprtoken *t = exprNewToken(EXPR_TOKEN_NUM);\n char num[256];\n int idx = 0;\n while(isdigit(es->p[0]) || es->p[0] == '.' || es->p[0] == 'e' ||\n es->p[0] == 'E' || (idx == 0 && es->p[0] == '-'))\n {\n if (idx >= (int)sizeof(num)-1) {\n exprTokenRelease(t);\n return NULL;\n }\n num[idx++] = es->p[0];\n es->p++;\n }\n num[idx] = 0;\n\n char *endptr;\n t->num = strtod(num, &endptr);\n if (*endptr != '\\0') {\n exprTokenRelease(t);\n return NULL;\n }\n return t;\n}\n\nexprtoken *exprParseString(exprstate *es) {\n char quote = es->p[0]; /* Store the quote type (' or \"). */\n es->p++; /* Skip opening quote. */\n\n exprtoken *t = exprNewToken(EXPR_TOKEN_STR);\n t->str.start = es->p;\n\n while(es->p[0] != '\\0') {\n if (es->p[0] == '\\\\' && es->p[1] != '\\0') {\n es->p += 2; // Skip escaped char.\n continue;\n }\n if (es->p[0] == quote) {\n t->str.len = es->p - t->str.start;\n es->p++; // Skip closing quote.\n return t;\n }\n es->p++;\n }\n /* If we reach here, string was not terminated. */\n exprTokenRelease(t);\n return NULL;\n}\n\n/* Parse a tuple of the form [1, \"foo\", 42]. No nested tuples are\n * supported. This type is useful mostly to be used with the \"IN\"\n * operator. */\nexprtoken *exprParseTuple(exprstate *es) {\n exprtoken *t = exprNewToken(EXPR_TOKEN_TUPLE);\n t->tuple.ele = NULL;\n t->tuple.len = 0;\n es->p++; /* Skip opening '['. */\n\n size_t allocated = 0;\n while(1) {\n exprConsumeSpaces(es);\n\n /* Check for empty tuple or end. */\n if (es->p[0] == ']') {\n es->p++;\n break;\n }\n\n /* Grow tuple array if needed. */\n if (t->tuple.len == allocated) {\n size_t newsize = allocated == 0 ? 4 : allocated * 2;\n exprtoken **newele = RedisModule_Realloc(t->tuple.ele,\n sizeof(exprtoken*) * newsize);\n t->tuple.ele = newele;\n allocated = newsize;\n }\n\n /* Parse tuple element. */\n exprtoken *ele = NULL;\n if (isdigit(es->p[0]) || es->p[0] == '-') {\n ele = exprParseNumber(es);\n } else if (es->p[0] == '\"' || es->p[0] == '\\'') {\n ele = exprParseString(es);\n } else {\n exprTokenRelease(t);\n return NULL;\n }\n\n /* Error parsing number/string? */\n if (ele == NULL) {\n exprTokenRelease(t);\n return NULL;\n }\n\n /* Store element if no error was detected. */\n t->tuple.ele[t->tuple.len] = ele;\n t->tuple.len++;\n\n /* Check for next element. */\n exprConsumeSpaces(es);\n if (es->p[0] == ']') {\n es->p++;\n break;\n }\n if (es->p[0] != ',') {\n exprTokenRelease(t);\n return NULL;\n }\n es->p++; /* Skip comma. */\n }\n return t;\n}\n\n/* Deallocate the object returned by exprCompile(). */\nvoid exprFree(exprstate *es) {\n if (es == NULL) return;\n\n /* Free the original expression string. */\n if (es->expr) RedisModule_Free(es->expr);\n\n /* Free all stacks. */\n exprStackFree(&es->values_stack);\n exprStackFree(&es->ops_stack);\n exprStackFree(&es->tokens);\n exprStackFree(&es->program);\n\n /* Free the state object itself. */\n RedisModule_Free(es);\n}\n\n/* Split the provided expression into a stack of tokens. Returns\n * 0 on success, 1 on error. */\nint exprTokenize(exprstate *es, int *errpos) {\n /* Main parsing loop. */\n while(1) {\n exprConsumeSpaces(es);\n\n /* Set a flag to see if we can consider the - part of the\n * number, or an operator. */\n int minus_is_number = 0; // By default is an operator.\n\n exprtoken *last = exprStackPeek(&es->tokens);\n if (last == NULL) {\n /* If we are at the start of an expression, the minus is\n * considered a number. */\n minus_is_number = 1;\n } else if (last->token_type == EXPR_TOKEN_OP &&\n last->opcode != EXPR_OP_CPAREN)\n {\n /* Also, if the previous token was an operator, the minus\n * is considered a number, unless the previous operator is\n * a closing parens. In such case it's like (...) -5, or alike\n * and we want to emit an operator. */\n minus_is_number = 1;\n }\n\n /* Parse based on the current character. */\n exprtoken *current = NULL;\n if (*es->p == '\\0') {\n current = exprNewToken(EXPR_TOKEN_EOF);\n } else if (isdigit(*es->p) ||\n (minus_is_number && *es->p == '-' && isdigit(es->p[1])))\n {\n current = exprParseNumber(es);\n } else if (*es->p == '\"' || *es->p == '\\'') {\n current = exprParseString(es);\n } else if (*es->p == '.' && is_selector_char(es->p[1])) {\n current = exprParseSelector(es);\n } else if (*es->p == '[') {\n current = exprParseTuple(es);\n } else if (isalpha(*es->p) || strchr(EXPR_OP_SPECIALCHARS, *es->p)) {\n current = exprParseOperatorOrLiteral(es);\n }\n\n if (current == NULL) {\n if (errpos) *errpos = es->p - es->expr;\n return 1; // Syntax Error.\n }\n\n /* Push the current token to tokens stack. */\n exprStackPush(&es->tokens, current);\n if (current->token_type == EXPR_TOKEN_EOF) break;\n }\n return 0;\n}\n\n/* Helper function to get operator precedence from the operator table. */\nint exprGetOpPrecedence(int opcode) {\n for (int i = 0; ExprOptable[i].opname != NULL; i++) {\n if (ExprOptable[i].opcode == opcode)\n return ExprOptable[i].precedence;\n }\n return -1;\n}\n\n/* Helper function to get operator arity from the operator table. */\nint exprGetOpArity(int opcode) {\n for (int i = 0; ExprOptable[i].opname != NULL; i++) {\n if (ExprOptable[i].opcode == opcode)\n return ExprOptable[i].arity;\n }\n return -1;\n}\n\n/* Process an operator during compilation. Returns 0 on success, 1 on error.\n * This function will retain a reference of the operator 'op' in case it\n * is pushed on the operators stack. */\nint exprProcessOperator(exprstate *es, exprtoken *op, int *stack_items, int *errpos) {\n if (op->opcode == EXPR_OP_OPAREN) {\n\t// This is just a marker for us. Do nothing.\n exprStackPush(&es->ops_stack, op);\n exprTokenRetain(op);\n return 0;\n }\n\n if (op->opcode == EXPR_OP_CPAREN) {\n /* Process operators until we find the matching opening parenthesis. */\n while (1) {\n exprtoken *top_op = exprStackPop(&es->ops_stack);\n if (top_op == NULL) {\n if (errpos) *errpos = op->offset;\n return 1;\n }\n\n if (top_op->opcode == EXPR_OP_OPAREN) {\n /* Open parethesis found. Our work finished. */\n exprTokenRelease(top_op);\n return 0;\n }\n\n int arity = exprGetOpArity(top_op->opcode);\n if (*stack_items < arity) {\n exprTokenRelease(top_op);\n if (errpos) *errpos = top_op->offset;\n return 1;\n }\n\n /* Move the operator on the program stack. */\n exprStackPush(&es->program, top_op);\n *stack_items = *stack_items - arity + 1;\n }\n }\n\n int curr_prec = exprGetOpPrecedence(op->opcode);\n\n /* Process operators with higher or equal precedence. */\n while (1) {\n exprtoken *top_op = exprStackPeek(&es->ops_stack);\n if (top_op == NULL || top_op->opcode == EXPR_OP_OPAREN) break;\n\n int top_prec = exprGetOpPrecedence(top_op->opcode);\n if (top_prec < curr_prec) break;\n /* Special case for **: only pop if precedence is strictly higher\n * so that the operator is right associative, that is:\n * 2 ** 3 ** 2 is evaluated as 2 ** (3 ** 2) == 512 instead\n * of (2 ** 3) ** 2 == 64. */\n if (op->opcode == EXPR_OP_POW && top_prec <= curr_prec) break;\n\n /* Pop and add to program. */\n top_op = exprStackPop(&es->ops_stack);\n int arity = exprGetOpArity(top_op->opcode);\n if (*stack_items < arity) {\n exprTokenRelease(top_op);\n if (errpos) *errpos = top_op->offset;\n return 1;\n }\n\n /* Move to the program stack. */\n exprStackPush(&es->program, top_op);\n *stack_items = *stack_items - arity + 1;\n }\n\n /* Push current operator. */\n exprStackPush(&es->ops_stack, op);\n exprTokenRetain(op);\n return 0;\n}\n\n/* Compile the expression into a set of push-value and exec-operator\n * that exprRun() can execute. The function returns an expstate object\n * that can be used for execution of the program. On error, NULL\n * is returned, and optionally the position of the error into the\n * expression is returned by reference. */\nexprstate *exprCompile(char *expr, int *errpos) {\n /* Initialize expression state. */\n exprstate *es = RedisModule_Alloc(sizeof(exprstate));\n es->expr = RedisModule_Strdup(expr);\n es->p = es->expr;\n\n /* Initialize all stacks. */\n exprStackInit(&es->values_stack);\n exprStackInit(&es->ops_stack);\n exprStackInit(&es->tokens);\n exprStackInit(&es->program);\n\n /* Tokenization. */\n if (exprTokenize(es, errpos)) {\n exprFree(es);\n return NULL;\n }\n\n /* Compile the expression into a sequence of operations. */\n int stack_items = 0; // Track # of items that would be on the stack\n // during execution. This way we can detect arity\n // issues at compile time.\n\n /* Process each token. */\n for (int i = 0; i < es->tokens.numitems; i++) {\n exprtoken *token = es->tokens.items[i];\n\n if (token->token_type == EXPR_TOKEN_EOF) break;\n\n /* Handle values (numbers, strings, selectors, null). */\n if (token->token_type == EXPR_TOKEN_NUM ||\n token->token_type == EXPR_TOKEN_STR ||\n token->token_type == EXPR_TOKEN_TUPLE ||\n token->token_type == EXPR_TOKEN_SELECTOR ||\n token->token_type == EXPR_TOKEN_NULL)\n {\n exprStackPush(&es->program, token);\n exprTokenRetain(token);\n stack_items++;\n continue;\n }\n\n /* Handle operators. */\n if (token->token_type == EXPR_TOKEN_OP) {\n if (exprProcessOperator(es, token, &stack_items, errpos)) {\n exprFree(es);\n return NULL;\n }\n continue;\n }\n }\n\n /* Process remaining operators on the stack. */\n while (es->ops_stack.numitems > 0) {\n exprtoken *op = exprStackPop(&es->ops_stack);\n if (op->opcode == EXPR_OP_OPAREN) {\n if (errpos) *errpos = op->offset;\n exprTokenRelease(op);\n exprFree(es);\n return NULL;\n }\n\n int arity = exprGetOpArity(op->opcode);\n if (stack_items < arity) {\n if (errpos) *errpos = op->offset;\n exprTokenRelease(op);\n exprFree(es);\n return NULL;\n }\n\n exprStackPush(&es->program, op);\n stack_items = stack_items - arity + 1;\n }\n\n /* Verify that exactly one value would remain on the stack after\n * execution. We could also check that such value is a number, but this\n * would make the code more complex without much gains. */\n if (stack_items != 1) {\n if (errpos) {\n /* Point to the last token's offset for error reporting. */\n exprtoken *last = es->tokens.items[es->tokens.numitems - 1];\n *errpos = last->offset;\n }\n exprFree(es);\n return NULL;\n }\n return es;\n}\n\n/* ============================ Expression execution ======================== */\n\n/* Convert a token to its numeric value. For strings we attempt to parse them\n * as numbers, returning 0 if conversion fails. */\ndouble exprTokenToNum(exprtoken *t) {\n char buf[256];\n if (t->token_type == EXPR_TOKEN_NUM) {\n return t->num;\n } else if (t->token_type == EXPR_TOKEN_STR && t->str.len < sizeof(buf)) {\n memcpy(buf, t->str.start, t->str.len);\n buf[t->str.len] = '\\0';\n char *endptr;\n double val = strtod(buf, &endptr);\n return *endptr == '\\0' ? val : 0;\n } else {\n return 0;\n }\n}\n\n/* Convert object to true/false (0 or 1) */\ndouble exprTokenToBool(exprtoken *t) {\n if (t->token_type == EXPR_TOKEN_NUM) {\n return t->num != 0;\n } else if (t->token_type == EXPR_TOKEN_STR && t->str.len == 0) {\n return 0; // Empty string are false, like in Javascript.\n } else if (t->token_type == EXPR_TOKEN_NULL) {\n return 0; // Null is surely more false than true...\n } else {\n return 1; // Every non numerical type is true.\n }\n}\n\n/* Compare two tokens. Returns true if they are equal. */\nint exprTokensEqual(exprtoken *a, exprtoken *b) {\n // If both are strings, do string comparison.\n if (a->token_type == EXPR_TOKEN_STR && b->token_type == EXPR_TOKEN_STR) {\n return a->str.len == b->str.len &&\n memcmp(a->str.start, b->str.start, a->str.len) == 0;\n }\n\n // If both are numbers, do numeric comparison.\n if (a->token_type == EXPR_TOKEN_NUM && b->token_type == EXPR_TOKEN_NUM) {\n return a->num == b->num;\n }\n\n /* If one of the two is null, the expression is true only if\n * both are null. */\n if (a->token_type == EXPR_TOKEN_NULL || b->token_type == EXPR_TOKEN_NULL) {\n return a->token_type == b->token_type;\n }\n\n // Mixed types - convert to numbers and compare.\n return exprTokenToNum(a) == exprTokenToNum(b);\n}\n\n/* Return true if the string a is a substring of b. */\nint exprTokensStringIn(exprtoken *a, exprtoken *b) {\n RedisModule_Assert(a->token_type == EXPR_TOKEN_STR &&\n b->token_type == EXPR_TOKEN_STR);\n if (a->str.len > b->str.len) return 0; // A is bigger, can't be a substring.\n for (size_t i = 0; i <= b->str.len - a->str.len; i++) {\n if (memcmp(b->str.start+i,a->str.start,a->str.len) == 0) return 1;\n }\n return 0;\n}\n\n#include \"fastjson.c\" // JSON parser implementation used by exprRun().\n\n/* Execute the compiled expression program. Returns 1 if the final stack value\n * evaluates to true, 0 otherwise. Also returns 0 if any selector callback\n * fails. */\nint exprRun(exprstate *es, char *json, size_t json_len) {\n exprStackReset(&es->values_stack);\n\n // Execute each instruction in the program.\n for (int i = 0; i < es->program.numitems; i++) {\n exprtoken *t = es->program.items[i];\n\n // Handle selectors by calling the callback.\n if (t->token_type == EXPR_TOKEN_SELECTOR) {\n exprtoken *obj = NULL;\n if (t->str.len > 0)\n obj = jsonExtractField(json,json_len,t->str.start,t->str.len);\n\n // Selector not found or JSON object not convertible to\n // expression tokens. Evaluate the expression to false.\n if (obj == NULL) return 0;\n exprStackPush(&es->values_stack, obj);\n continue;\n }\n\n // Push non-operator values directly onto the stack.\n if (t->token_type != EXPR_TOKEN_OP) {\n exprStackPush(&es->values_stack, t);\n exprTokenRetain(t);\n continue;\n }\n\n // Handle operators.\n exprtoken *result = exprNewToken(EXPR_TOKEN_NUM);\n\n // Pop operands - we know we have enough from compile-time checks.\n exprtoken *b = exprStackPop(&es->values_stack);\n exprtoken *a = NULL;\n if (exprGetOpArity(t->opcode) == 2) {\n a = exprStackPop(&es->values_stack);\n }\n\n switch(t->opcode) {\n case EXPR_OP_NOT:\n result->num = exprTokenToBool(b) == 0 ? 1 : 0;\n break;\n case EXPR_OP_POW: {\n double base = exprTokenToNum(a);\n double exp = exprTokenToNum(b);\n result->num = pow(base, exp);\n break;\n }\n case EXPR_OP_MULT:\n result->num = exprTokenToNum(a) * exprTokenToNum(b);\n break;\n case EXPR_OP_DIV:\n result->num = exprTokenToNum(a) / exprTokenToNum(b);\n break;\n case EXPR_OP_MOD: {\n double va = exprTokenToNum(a);\n double vb = exprTokenToNum(b);\n result->num = fmod(va, vb);\n break;\n }\n case EXPR_OP_SUM:\n result->num = exprTokenToNum(a) + exprTokenToNum(b);\n break;\n case EXPR_OP_DIFF:\n result->num = exprTokenToNum(a) - exprTokenToNum(b);\n break;\n case EXPR_OP_GT:\n result->num = exprTokenToNum(a) > exprTokenToNum(b) ? 1 : 0;\n break;\n case EXPR_OP_GTE:\n result->num = exprTokenToNum(a) >= exprTokenToNum(b) ? 1 : 0;\n break;\n case EXPR_OP_LT:\n result->num = exprTokenToNum(a) < exprTokenToNum(b) ? 1 : 0;\n break;\n case EXPR_OP_LTE:\n result->num = exprTokenToNum(a) <= exprTokenToNum(b) ? 1 : 0;\n break;\n case EXPR_OP_EQ:\n result->num = exprTokensEqual(a, b) ? 1 : 0;\n break;\n case EXPR_OP_NEQ:\n result->num = !exprTokensEqual(a, b) ? 1 : 0;\n break;\n case EXPR_OP_IN: {\n /* For 'in' operator, b must be a tuple, and we check for\n * membership. Otherwise both a and b must be strings, and\n * in this case we check if a is a substring of b. */\n result->num = 0; // Default to false.\n if (b->token_type == EXPR_TOKEN_TUPLE) {\n for (size_t j = 0; j < b->tuple.len; j++) {\n if (exprTokensEqual(a, b->tuple.ele[j])) {\n result->num = 1; // Found a match.\n break;\n }\n }\n } else if (a->token_type == EXPR_TOKEN_STR &&\n b->token_type == EXPR_TOKEN_STR)\n {\n result->num = exprTokensStringIn(a,b);\n }\n break;\n }\n case EXPR_OP_AND:\n result->num =\n exprTokenToBool(a) != 0 && exprTokenToBool(b) != 0 ? 1 : 0;\n break;\n case EXPR_OP_OR:\n result->num =\n exprTokenToBool(a) != 0 || exprTokenToBool(b) != 0 ? 1 : 0;\n break;\n default:\n // Do nothing: we don't want runtime errors.\n break;\n }\n\n // Free operands and push result.\n if (a) exprTokenRelease(a);\n exprTokenRelease(b);\n exprStackPush(&es->values_stack, result);\n }\n\n // Get final result from stack.\n exprtoken *final = exprStackPop(&es->values_stack);\n if (final == NULL) return 0;\n\n // Convert result to boolean.\n int retval = exprTokenToBool(final);\n exprTokenRelease(final);\n return retval;\n}\n\n/* ============================ Simple test main ============================ */\n\n#ifdef TEST_MAIN\n#include \"fastjson_test.c\"\n\nvoid exprPrintToken(exprtoken *t) {\n switch(t->token_type) {\n case EXPR_TOKEN_EOF:\n printf(\"EOF\");\n break;\n case EXPR_TOKEN_NUM:\n printf(\"NUM:%g\", t->num);\n break;\n case EXPR_TOKEN_STR:\n printf(\"STR:\\\"%.*s\\\"\", (int)t->str.len, t->str.start);\n break;\n case EXPR_TOKEN_SELECTOR:\n printf(\"SEL:%.*s\", (int)t->str.len, t->str.start);\n break;\n case EXPR_TOKEN_OP:\n printf(\"OP:\");\n for (int i = 0; ExprOptable[i].opname != NULL; i++) {\n if (ExprOptable[i].opcode == t->opcode) {\n printf(\"%s\", ExprOptable[i].opname);\n break;\n }\n }\n break;\n default:\n printf(\"UNKNOWN\");\n break;\n }\n}\n\nvoid exprPrintStack(exprstack *stack, const char *name) {\n printf(\"%s (%d items):\", name, stack->numitems);\n for (int j = 0; j < stack->numitems; j++) {\n printf(\" \");\n exprPrintToken(stack->items[j]);\n }\n printf(\"\\n\");\n}\n\nint main(int argc, char **argv) {\n /* Check for JSON parser test mode. */\n if (argc >= 2 && strcmp(argv[1], \"--test-json-parser\") == 0) {\n run_fastjson_test();\n return 0;\n }\n\n char *testexpr = \"(5+2)*3 and .year > 1980 and 'foo' == 'foo'\";\n char *testjson = \"{\\\"year\\\": 1984, \\\"name\\\": \\\"The Matrix\\\"}\";\n if (argc >= 2) testexpr = argv[1];\n if (argc >= 3) testjson = argv[2];\n\n printf(\"Compiling expression: %s\\n\", testexpr);\n\n int errpos = 0;\n exprstate *es = exprCompile(testexpr,&errpos);\n if (es == NULL) {\n printf(\"Compilation failed near \\\"...%s\\\"\\n\", testexpr+errpos);\n return 1;\n }\n\n exprPrintStack(&es->tokens, \"Tokens\");\n exprPrintStack(&es->program, \"Program\");\n printf(\"Running against object: %s\\n\", testjson);\n int result = exprRun(es,testjson,strlen(testjson));\n printf(\"Result1: %s\\n\", result ? \"True\" : \"False\");\n result = exprRun(es,testjson,strlen(testjson));\n printf(\"Result2: %s\\n\", result ? \"True\" : \"False\");\n\n exprFree(es);\n return 0;\n}\n#endif\n" }, { "path": "modules/vector-sets/fastjson.c", "content": "/* Ultra‑lightweight top‑level JSON field extractor.\n * Return the element directly as an expr.c token.\n * This code is directly included inside expr.c.\n *\n * Copyright (c) 2025-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of the Redis Source Available License 2.0\n * (RSALv2) or the Server Side Public License v1 (SSPLv1).\n *\n * Originally authored by: Salvatore Sanfilippo.\n *\n * ------------------------------------------------------------------\n *\n * DESIGN GOALS:\n *\n * 1. Zero heap allocations while seeking the requested key.\n * 2. A single parse (and therefore a single allocation, if needed)\n * when the key finally matches.\n * 3. Same subset‑of‑JSON coverage needed by expr.c:\n * - Strings (escapes: \\\" \\\\ \\n \\r \\t).\n * - Numbers (double).\n * - Booleans.\n * - Null.\n * - Flat arrays of the above primitives.\n *\n * Any other value (nested object, unicode escape, etc.) returns NULL.\n * Should be very easy to extend it in case in the future we want\n * more for the FILTER option of VSIM.\n * 4. No global state, so this file can be #included directly in expr.c.\n *\n * The only API expr.c uses directly is:\n *\n * exprtoken *jsonExtractField(const char *json, size_t json_len,\n * const char *field, size_t field_len);\n * ------------------------------------------------------------------ */\n\n#include \n#include \n\n// Forward declarations.\nstatic int jsonSkipValue(const char **p, const char *end);\nstatic exprtoken *jsonParseValueToken(const char **p, const char *end);\n\n/* Similar to ctype.h isdigit() but covers the whole JSON number charset,\n * including exp form. */\nstatic int jsonIsNumberChar(int c) {\n return isdigit(c) || c=='-' || c=='+' || c=='.' || c=='e' || c=='E';\n}\n\n/* ========================== Fast skipping of JSON =========================\n * The helpers here are designed to skip values without performing any\n * allocation. This way, for the use case of this JSON parser, we are able\n * to easily (and with good speed) skip fields and values we are not\n * interested in. Then, later in the code, when we find the field we want\n * to obtain, we finally call the functions that turn a given JSON value\n * associated to a field into our of our expressions token.\n * ========================================================================== */\n\n/* Advance *p consuming all the spaces. */\nstatic inline void jsonSkipWhiteSpaces(const char **p, const char *end) {\n while (*p < end && isspace((unsigned char)**p)) (*p)++;\n}\n\n/* Advance *p past a JSON string. Returns 1 on success, 0 on error. */\nstatic int jsonSkipString(const char **p, const char *end) {\n if (*p >= end || **p != '\"') return 0;\n (*p)++; /* Skip opening quote. */\n while (*p < end) {\n if (**p == '\\\\') {\n (*p) += 2;\n continue;\n }\n if (**p == '\"') {\n (*p)++; /* Skip closing quote. */\n return 1;\n }\n (*p)++;\n }\n return 0; /* unterminated */\n}\n\n/* Skip an array or object generically using depth counter.\n * Opener and closer tells the function how the aggregated\n * data type starts/stops, basically [] or {}. */\nstatic int jsonSkipBracketed(const char **p, const char *end,\n char opener, char closer) {\n int depth = 1;\n (*p)++; /* Skip opener. */\n\n /* Loop until we reach the end of the input or find the matching\n * closer (depth becomes 0). */\n while (*p < end && depth > 0) {\n char c = **p;\n\n if (c == '\"') {\n // Found a string, delegate skipping to jsonSkipString().\n if (!jsonSkipString(p, end)) {\n return 0; // String skipping failed (e.g., unterminated)\n }\n /* jsonSkipString() advances *p past the closing quote.\n * Continue the loop to process the character *after* the string. */\n continue;\n }\n\n /* If it's not a string, check if it affects the depth for the\n * specific brackets we are currently tracking. */\n if (c == opener) {\n depth++;\n } else if (c == closer) {\n depth--;\n }\n\n /* Always advance the pointer for any non-string character.\n * This handles commas, colons, whitespace, numbers, literals,\n * and even nested brackets of a *different* type than the\n * one we are currently skipping (e.g. skipping a { inside []). */\n (*p)++;\n }\n\n /* Return 1 (true) if we successfully found the matching closer,\n * otherwise there is a parse error and we return 0. */\n return depth == 0;\n}\n\n/* Skip a single JSON literal (true, null, ...) starting at *p.\n * Returns 1 on success, 0 on failure. */\nstatic int jsonSkipLiteral(const char **p, const char *end, const char *lit) {\n size_t l = strlen(lit);\n if (*p + l > end) return 0;\n if (strncmp(*p, lit, l) == 0) { *p += l; return 1; }\n return 0;\n}\n\n/* Skip number, don't check that number format is correct, just consume\n * number-alike characters.\n *\n * Note: More robust number skipping might check validity,\n * but for skipping, just consuming plausible characters is enough. */\nstatic int jsonSkipNumber(const char **p, const char *end) {\n const char *num_start = *p;\n while (*p < end && jsonIsNumberChar(**p)) (*p)++;\n return *p > num_start; // Any progress made? Otherwise no number found.\n}\n\n/* Skip any JSON value. 1 = success, 0 = error. */\nstatic int jsonSkipValue(const char **p, const char *end) {\n jsonSkipWhiteSpaces(p, end);\n if (*p >= end) return 0;\n switch (**p) {\n case '\"': return jsonSkipString(p, end);\n case '{': return jsonSkipBracketed(p, end, '{', '}');\n case '[': return jsonSkipBracketed(p, end, '[', ']');\n case 't': return jsonSkipLiteral(p, end, \"true\");\n case 'f': return jsonSkipLiteral(p, end, \"false\");\n case 'n': return jsonSkipLiteral(p, end, \"null\");\n default: return jsonSkipNumber(p, end);\n }\n}\n\n/* =========================== JSON to exprtoken ============================\n * The functions below convert a given json value to the equivalent\n * expression token structure.\n * ========================================================================== */\n\nstatic exprtoken *jsonParseStringToken(const char **p, const char *end) {\n if (*p >= end || **p != '\"') return NULL;\n const char *start = ++(*p);\n int esc = 0; size_t len = 0; int has_esc = 0;\n const char *q = *p;\n while (q < end) {\n if (esc) { esc = 0; q++; len++; has_esc = 1; continue; }\n if (*q == '\\\\') { esc = 1; q++; continue; }\n if (*q == '\"') break;\n q++; len++;\n }\n if (q >= end || *q != '\"') return NULL; // Unterminated string\n exprtoken *t = exprNewToken(EXPR_TOKEN_STR);\n\n if (!has_esc) {\n // No escapes, we can point directly into the original JSON string.\n t->str.start = (char*)start; t->str.len = len; t->str.heapstr = NULL;\n } else {\n // Escapes present, need to allocate and copy/process escapes.\n char *dst = RedisModule_Alloc(len + 1);\n\n t->str.start = t->str.heapstr = dst; t->str.len = len;\n const char *r = start; esc = 0;\n while (r < q) {\n if (esc) {\n switch (*r) {\n // Supported escapes from Goal 3.\n case 'n': *dst='\\n'; break;\n case 'r': *dst='\\r'; break;\n case 't': *dst='\\t'; break;\n case '\\\\': *dst='\\\\'; break;\n case '\"': *dst='\\\"'; break;\n // Escapes (like \\uXXXX, \\b, \\f) are not supported for now,\n // we just copy them verbatim.\n default: *dst=*r; break;\n }\n dst++; esc = 0; r++; continue;\n }\n if (*r == '\\\\') { esc = 1; r++; continue; }\n *dst++ = *r++;\n }\n *dst = '\\0'; // Null-terminate the allocated string.\n }\n *p = q + 1; // Advance the main pointer past the closing quote.\n return t;\n}\n\nstatic exprtoken *jsonParseNumberToken(const char **p, const char *end) {\n // Use a buffer to extract the number literal for parsing with strtod().\n char buf[256]; int idx = 0;\n const char *start = *p; // For strtod partial failures check.\n\n // Copy potential number characters to buffer.\n while (*p < end && idx < (int)sizeof(buf)-1 && jsonIsNumberChar(**p)) {\n buf[idx++] = **p;\n (*p)++;\n }\n buf[idx]='\\0'; // Null-terminate buffer.\n\n if (idx==0) return NULL; // No number characters found.\n\n char *ep; // End pointer for strtod validation.\n double v = strtod(buf, &ep);\n\n /* Check if strtod() consumed the entire buffer content.\n * If not, the number format was invalid. */\n if (*ep!='\\0') {\n // strtod() failed; rewind p to the start and return NULL\n *p = start;\n return NULL;\n }\n\n // If strtod() succeeded, create and return the token..\n exprtoken *t = exprNewToken(EXPR_TOKEN_NUM);\n t->num = v;\n return t;\n}\n\nstatic exprtoken *jsonParseLiteralToken(const char **p, const char *end, const char *lit, int type, double num) {\n size_t l = strlen(lit);\n\n // Ensure we don't read past 'end'.\n if ((*p + l) > end) return NULL;\n\n if (strncmp(*p, lit, l) != 0) return NULL; // Literal doesn't match.\n\n // Check that the character *after* the literal is a valid JSON delimiter\n // (whitespace, comma, closing bracket/brace, or end of input)\n // This prevents matching \"trueblabla\" as \"true\".\n if ((*p + l) < end) {\n char next_char = *(*p + l);\n if (!isspace((unsigned char)next_char) && next_char!=',' &&\n next_char!=']' && next_char!='}') {\n return NULL; // Invalid character following literal.\n }\n }\n\n // Literal matched and is correctly terminated.\n *p += l;\n exprtoken *t = exprNewToken(type);\n t->num = num;\n return t;\n}\n\nstatic exprtoken *jsonParseArrayToken(const char **p, const char *end) {\n if (*p >= end || **p != '[') return NULL;\n (*p)++; // Skip '['.\n jsonSkipWhiteSpaces(p,end);\n\n exprtoken *t = exprNewToken(EXPR_TOKEN_TUPLE);\n t->tuple.len = 0; t->tuple.ele = NULL; size_t alloc = 0;\n\n // Handle empty array [].\n if (*p < end && **p == ']') {\n (*p)++; // Skip ']'.\n return t;\n }\n\n // Parse array elements.\n while (1) {\n exprtoken *ele = jsonParseValueToken(p,end);\n if (!ele) {\n exprTokenRelease(t); // Clean up partially built array token.\n return NULL;\n }\n\n // Grow allocated space for elements if needed.\n if (t->tuple.len == alloc) {\n size_t newsize = alloc ? alloc * 2 : 4;\n // Check for potential overflow if newsize becomes huge.\n if (newsize < alloc) {\n exprTokenRelease(ele);\n exprTokenRelease(t);\n return NULL;\n }\n exprtoken **newele = RedisModule_Realloc(t->tuple.ele,\n sizeof(exprtoken*)*newsize);\n t->tuple.ele = newele;\n alloc = newsize;\n }\n t->tuple.ele[t->tuple.len++] = ele; // Add element.\n\n jsonSkipWhiteSpaces(p,end);\n if (*p>=end) {\n // Unterminated array. Note that this check is crucial because\n // previous value parsed may seek 'p' to 'end'.\n exprTokenRelease(t);\n return NULL;\n }\n\n // Check for comma (more elements) or closing bracket.\n if (**p == ',') {\n (*p)++; // Skip ','\n jsonSkipWhiteSpaces(p,end); // Skip whitespace before next element\n continue; // Parse next element\n } else if (**p == ']') {\n (*p)++; // Skip ']'\n return t; // End of array\n } else {\n // Unexpected character (not ',' or ']')\n exprTokenRelease(t);\n return NULL;\n }\n }\n}\n\n/* Turn a JSON value into an expr token. */\nstatic exprtoken *jsonParseValueToken(const char **p, const char *end) {\n jsonSkipWhiteSpaces(p,end);\n if (*p >= end) return NULL;\n\n switch (**p) {\n case '\"': return jsonParseStringToken(p,end);\n case '[': return jsonParseArrayToken(p,end);\n case '{': return NULL; // No nested elements support for now.\n case 't': return jsonParseLiteralToken(p,end,\"true\",EXPR_TOKEN_NUM,1);\n case 'f': return jsonParseLiteralToken(p,end,\"false\",EXPR_TOKEN_NUM,0);\n case 'n': return jsonParseLiteralToken(p,end,\"null\",EXPR_TOKEN_NULL,0);\n default:\n // Check if it starts like a number.\n if (isdigit((unsigned char)**p) || **p=='-' || **p=='+') {\n return jsonParseNumberToken(p,end);\n }\n // Anything else is an unsupported type or malformed JSON.\n return NULL;\n }\n}\n\n/* ============================== Fast key seeking ========================== */\n\n/* Finds the start of the value for a given field key within a JSON object.\n * Returns pointer to the first char of the value, or NULL if not found/error.\n * This function does not perform any allocation and is optimized to seek\n * the specified *toplevel* filed as fast as possible. */\nstatic const char *jsonSeekField(const char *json, const char *end,\n const char *field, size_t flen) {\n const char *p = json;\n jsonSkipWhiteSpaces(&p,end);\n if (p >= end || *p != '{') return NULL; // Must start with '{'.\n p++; // skip '{'.\n\n while (1) {\n jsonSkipWhiteSpaces(&p,end);\n if (p >= end) return NULL; // Reached end within object.\n\n if (*p == '}') return NULL; // End of object, field not found.\n\n // Expecting a key (string).\n if (*p != '\"') return NULL; // Key must be a string.\n\n // --- Key Matching using jsonSkipString ---\n const char *key_start = p + 1; // Start of key content.\n const char *key_end_p = p; // Will later contain the end.\n\n // Use jsonSkipString() to find the end.\n if (!jsonSkipString(&key_end_p, end)) {\n // Unterminated / invalid key string.\n return NULL;\n }\n\n // Calculate the length of the key's content.\n size_t klen = (key_end_p - 1) - key_start;\n\n /* Perform the comparison using the raw key content.\n * WARNING: This uses memcmp(), so we don't handle escaped chars\n * within the key matching against unescaped chars in 'field'. */\n int match = klen == flen && !memcmp(key_start, field, flen);\n\n // Update the main pointer 'p' to be after the key string.\n p = key_end_p;\n\n // Now we expect to find a \":\" followed by a value.\n jsonSkipWhiteSpaces(&p,end);\n if (p>=end || *p!=':') return NULL; // Expect ':' after key\n p++; // Skip ':'.\n\n\t// Seek value.\n jsonSkipWhiteSpaces(&p,end);\n if (p>=end) return NULL; // Expect value after ':'\n\n if (match) {\n // Found the matching key, p now points to the start of the value.\n return p;\n } else {\n // Key didn't match, skip the corresponding value.\n if (!jsonSkipValue(&p,end)) return NULL; // Syntax error.\n }\n\n\n // Look for comma or a closing brace.\n jsonSkipWhiteSpaces(&p,end);\n if (p>=end) return NULL; // Reached end after value.\n\n if (*p == ',') {\n p++; // Skip comma, continue loop to find next key.\n continue;\n } else if (*p == '}') {\n return NULL; // Reached end of object, field not found.\n }\n return NULL; // Malformed JSON (unexpected char after value).\n }\n}\n\n/* This is the only real API that this file conceptually exports (it is\n * inlined, actually). */\nexprtoken *jsonExtractField(const char *json, size_t json_len,\n const char *field, size_t field_len)\n{\n const char *end = json + json_len;\n const char *valptr = jsonSeekField(json,end,field,field_len);\n if (!valptr) return NULL;\n\n /* Key found, valptr points to the start of the value.\n * Convert it into an expression token object. */\n return jsonParseValueToken(&valptr,end);\n}\n" }, { "path": "modules/vector-sets/fastjson_test.c", "content": "/* fastjson_test.c - Stress test for fastjson.c\n *\n * This performs boundary and corruption tests to ensure\n * the JSON parser handles edge cases without accessing\n * memory outside the bounds of the input.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* Page size constant - typically 4096 or 16k bytes (Apple Silicon).\n * We use 16k so that it will work on both, but not with Linux huge pages. */\n#define PAGE_SIZE 4096*4\n#define MAX_JSON_SIZE (PAGE_SIZE - 128) /* Keep some margin */\n#define MAX_FIELD_SIZE 64\n#define NUM_TEST_ITERATIONS 100000\n#define NUM_CORRUPTION_TESTS 10000\n#define NUM_BOUNDARY_TESTS 10000\n\n/* Test state tracking */\nstatic char *safe_page = NULL; /* Start of readable/writable page */\nstatic char *unsafe_page = NULL; /* Start of inaccessible guard page */\nstatic int boundary_violation = 0; /* Flag for boundary violations */\nstatic jmp_buf jmpbuf; /* For signal handling */\nstatic int tests_passed = 0;\nstatic int tests_failed = 0;\nstatic int corruptions_passed = 0;\nstatic int boundary_tests_passed = 0;\n\n/* Test metadata for tracking */\ntypedef struct {\n char *json;\n size_t json_len;\n char field[MAX_FIELD_SIZE];\n size_t field_len;\n int expected_result;\n} test_case_t;\n\n/* Forward declarations for test JSON generation */\nchar *generate_random_json(size_t *len, char *field, size_t *field_len, int *has_field);\nvoid corrupt_json(char *json, size_t len);\nvoid setup_test_memory(void);\nvoid cleanup_test_memory(void);\nvoid run_normal_tests(void);\nvoid run_corruption_tests(void);\nvoid run_boundary_tests(void);\nvoid print_test_summary(void);\n\n/* Signal handler for segmentation violations */\nstatic void sigsegv_handler(int sig) {\n boundary_violation = 1;\n printf(\"Boundary violation detected! Caught signal %d\\n\", sig);\n longjmp(jmpbuf, 1);\n}\n\n/* Wrapper for jsonExtractField to check for boundary violations */\nexprtoken *safe_extract_field(const char *json, size_t json_len,\n const char *field, size_t field_len) {\n boundary_violation = 0;\n\n if (setjmp(jmpbuf) == 0) {\n return jsonExtractField(json, json_len, field, field_len);\n } else {\n return NULL; /* Return NULL if boundary violation occurred */\n }\n}\n\n/* Setup two adjacent memory pages - one readable/writable, one inaccessible */\nvoid setup_test_memory(void) {\n /* Request a page of memory, with specific alignment. We rely on the\n * fact that hopefully the page after that will cause a segfault if\n * accessed. */\n void *region = mmap(NULL, PAGE_SIZE,\n PROT_READ | PROT_WRITE,\n MAP_PRIVATE | MAP_ANONYMOUS,\n -1, 0);\n\n if (region == MAP_FAILED) {\n perror(\"mmap failed\");\n exit(EXIT_FAILURE);\n }\n\n safe_page = (char*)region;\n unsafe_page = safe_page + PAGE_SIZE;\n // Uncomment to make sure it crashes :D\n // printf(\"%d\\n\", unsafe_page[5]);\n\n /* Set up signal handlers for memory access violations */\n struct sigaction sa;\n sa.sa_handler = sigsegv_handler;\n sigemptyset(&sa.sa_mask);\n sa.sa_flags = 0;\n\n sigaction(SIGSEGV, &sa, NULL);\n sigaction(SIGBUS, &sa, NULL);\n}\n\nvoid cleanup_test_memory(void) {\n if (safe_page != NULL) {\n munmap(safe_page, PAGE_SIZE);\n safe_page = NULL;\n unsafe_page = NULL;\n }\n}\n\n/* Generate random strings with proper escaping for JSON */\nvoid generate_random_string(char *buffer, size_t max_len) {\n static const char charset[] = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\";\n size_t len = 1 + rand() % (max_len - 2); /* Ensure at least 1 char */\n\n for (size_t i = 0; i < len; i++) {\n buffer[i] = charset[rand() % (sizeof(charset) - 1)];\n }\n buffer[len] = '\\0';\n}\n\n/* Generate random numbers as strings */\nvoid generate_random_number(char *buffer, size_t max_len) {\n double num = (double)rand() / RAND_MAX * 1000.0;\n\n /* Occasionally make it negative or add decimal places */\n if (rand() % 5 == 0) num = -num;\n if (rand() % 3 != 0) num += (double)(rand() % 100) / 100.0;\n\n snprintf(buffer, max_len, \"%.6g\", num);\n}\n\n/* Generate a random field name */\nvoid generate_random_field(char *field, size_t *field_len) {\n generate_random_string(field, MAX_FIELD_SIZE / 2);\n *field_len = strlen(field);\n}\n\n/* Generate a random JSON object with fields */\nchar *generate_random_json(size_t *len, char *field, size_t *field_len, int *has_field) {\n char *json = malloc(MAX_JSON_SIZE);\n if (json == NULL) {\n perror(\"malloc\");\n exit(EXIT_FAILURE);\n }\n\n char buffer[MAX_JSON_SIZE / 4]; /* Buffer for generating values */\n int pos = 0;\n int num_fields = 1 + rand() % 10; /* Random number of fields */\n int target_field_index = rand() % num_fields; /* Which field to return */\n\n /* Start the JSON object */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"{\");\n\n /* Generate random field/value pairs */\n for (int i = 0; i < num_fields; i++) {\n /* Add a comma if not the first field */\n if (i > 0) {\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \", \");\n }\n\n /* Generate a field name */\n if (i == target_field_index) {\n /* This is our target field - save it for the caller */\n generate_random_field(field, field_len);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"\\\"%s\\\": \", field);\n *has_field = 1;\n /* Sometimes change the last char so that it will not match. */\n if (rand() % 2) {\n *has_field = 0;\n field[*field_len-1] = '!';\n }\n } else {\n generate_random_string(buffer, MAX_FIELD_SIZE / 4);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"\\\"%s\\\": \", buffer);\n }\n\n /* Generate a random value type */\n int value_type = rand() % 5;\n switch (value_type) {\n case 0: /* String */\n generate_random_string(buffer, MAX_JSON_SIZE / 8);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"\\\"%s\\\"\", buffer);\n break;\n\n case 1: /* Number */\n generate_random_number(buffer, MAX_JSON_SIZE / 8);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"%s\", buffer);\n break;\n\n case 2: /* Boolean: true */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"true\");\n break;\n\n case 3: /* Boolean: false */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"false\");\n break;\n\n case 4: /* Null */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"null\");\n break;\n\n case 5: /* Array (simple) */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"[\");\n int array_items = 1 + rand() % 5;\n for (int j = 0; j < array_items; j++) {\n if (j > 0) pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \", \");\n\n /* Array items - either number or string */\n if (rand() % 2) {\n generate_random_number(buffer, MAX_JSON_SIZE / 16);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"%s\", buffer);\n } else {\n generate_random_string(buffer, MAX_JSON_SIZE / 16);\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"\\\"%s\\\"\", buffer);\n }\n }\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"]\");\n break;\n }\n }\n\n /* Close the JSON object */\n pos += snprintf(json + pos, MAX_JSON_SIZE - pos, \"}\");\n *len = pos;\n\n return json;\n}\n\n/* Corrupt JSON by replacing random characters */\nvoid corrupt_json(char *json, size_t len) {\n if (len < 2) return; /* Too short to corrupt safely */\n\n /* Corrupt 1-3 characters */\n int num_corruptions = 1 + rand() % 3;\n for (int i = 0; i < num_corruptions; i++) {\n size_t pos = rand() % len;\n char corruption = \" \\t\\n{}[]\\\":,0123456789abcdefXYZ\"[rand() % 30];\n json[pos] = corruption;\n }\n}\n\n/* Run standard parser tests with generated valid JSON */\nvoid run_normal_tests(void) {\n printf(\"Running normal JSON extraction tests...\\n\");\n\n for (int i = 0; i < NUM_TEST_ITERATIONS; i++) {\n char field[MAX_FIELD_SIZE] = {0};\n size_t field_len = 0;\n size_t json_len = 0;\n int has_field = 0;\n\n /* Generate random JSON */\n char *json = generate_random_json(&json_len, field, &field_len, &has_field);\n\n /* Use valid field to test parser */\n exprtoken *token = safe_extract_field(json, json_len, field, field_len);\n\n /* Check if we got a token as expected */\n if (has_field && token != NULL) {\n exprTokenRelease(token);\n tests_passed++;\n } else if (!has_field && token == NULL) {\n tests_passed++;\n } else {\n tests_failed++;\n }\n\n /* Test with a non-existent field */\n char nonexistent_field[MAX_FIELD_SIZE] = \"nonexistent_field\";\n token = safe_extract_field(json, json_len, nonexistent_field, strlen(nonexistent_field));\n\n if (token == NULL) {\n tests_passed++;\n } else {\n exprTokenRelease(token);\n tests_failed++;\n }\n\n free(json);\n }\n}\n\n/* Run tests with corrupted JSON */\nvoid run_corruption_tests(void) {\n printf(\"Running JSON corruption tests...\\n\");\n\n for (int i = 0; i < NUM_CORRUPTION_TESTS; i++) {\n char field[MAX_FIELD_SIZE] = {0};\n size_t field_len = 0;\n size_t json_len = 0;\n int has_field = 0;\n\n /* Generate random JSON */\n char *json = generate_random_json(&json_len, field, &field_len, &has_field);\n\n /* Make a copy and corrupt it */\n char *corrupted = malloc(json_len + 1);\n if (!corrupted) {\n perror(\"malloc\");\n free(json);\n exit(EXIT_FAILURE);\n }\n\n memcpy(corrupted, json, json_len + 1);\n corrupt_json(corrupted, json_len);\n\n /* Test with corrupted JSON */\n exprtoken *token = safe_extract_field(corrupted, json_len, field, field_len);\n\n /* We're just testing that it doesn't crash or access invalid memory */\n if (boundary_violation) {\n printf(\"Boundary violation with corrupted JSON!\\n\");\n tests_failed++;\n } else {\n if (token != NULL) {\n exprTokenRelease(token);\n }\n corruptions_passed++;\n }\n\n free(corrupted);\n free(json);\n }\n}\n\n/* Run tests at memory boundaries */\nvoid run_boundary_tests(void) {\n printf(\"Running memory boundary tests...\\n\");\n\n for (int i = 0; i < NUM_BOUNDARY_TESTS; i++) {\n char field[MAX_FIELD_SIZE] = {0};\n size_t field_len = 0;\n size_t json_len = 0;\n int has_field = 0;\n\n /* Generate random JSON */\n char *temp_json = generate_random_json(&json_len, field, &field_len, &has_field);\n\n /* Truncate the JSON to a random length */\n size_t truncated_len = 1 + rand() % json_len;\n\n /* Place at the edge of the safe page */\n size_t offset = PAGE_SIZE - truncated_len;\n memcpy(safe_page + offset, temp_json, truncated_len);\n\n /* Test parsing with non-existent field (forcing it to scan to end) */\n char nonexistent_field[MAX_FIELD_SIZE] = \"nonexistent_field\";\n exprtoken *token = safe_extract_field(safe_page + offset, truncated_len,\n nonexistent_field, strlen(nonexistent_field));\n\n /* We're just testing that it doesn't access memory beyond the boundary */\n if (boundary_violation) {\n printf(\"Boundary violation at edge of memory page!\\n\");\n tests_failed++;\n } else {\n if (token != NULL) {\n exprTokenRelease(token);\n }\n boundary_tests_passed++;\n }\n\n free(temp_json);\n }\n}\n\n/* Print summary of test results */\nvoid print_test_summary(void) {\n printf(\"\\n===== FASTJSON PARSER TEST SUMMARY =====\\n\");\n printf(\"Normal tests passed: %d/%d\\n\", tests_passed, NUM_TEST_ITERATIONS * 2);\n printf(\"Corruption tests passed: %d/%d\\n\", corruptions_passed, NUM_CORRUPTION_TESTS);\n printf(\"Boundary tests passed: %d/%d\\n\", boundary_tests_passed, NUM_BOUNDARY_TESTS);\n printf(\"Failed tests: %d\\n\", tests_failed);\n\n if (tests_failed == 0) {\n printf(\"\\nALL TESTS PASSED! The JSON parser appears to be robust.\\n\");\n } else {\n printf(\"\\nSome tests FAILED. The JSON parser may be vulnerable.\\n\");\n }\n}\n\n/* Entry point for fastjson parser test */\nvoid run_fastjson_test(void) {\n printf(\"Starting fastjson parser stress test...\\n\");\n\n /* Seed the random number generator */\n srand(time(NULL));\n\n /* Setup test memory environment */\n setup_test_memory();\n\n /* Run the various test phases */\n run_normal_tests();\n run_corruption_tests();\n run_boundary_tests();\n\n /* Print summary */\n print_test_summary();\n\n /* Cleanup */\n cleanup_test_memory();\n}\n" }, { "path": "modules/vector-sets/hnsw.c", "content": "/* HNSW (Hierarchical Navigable Small World) Implementation.\n *\n * Based on the paper by Yu. A. Malkov, D. A. Yashunin.\n *\n * Many details of this implementation, not covered in the paper, were\n * obtained simulating different workloads and checking the connection\n * quality of the graph.\n *\n * Notably, this implementation:\n *\n * 1. Only uses bi-directional links, implementing strategies in order to\n * link new nodes even when candidates are full, and our new node would\n * be not close enough to replace old links in candidate.\n *\n * 2. We normalize on-insert, making cosine similarity and dot product the\n * same. This means we can't use euclidean distance or alike here.\n * Together with quantization, this provides an important speedup that\n * makes HNSW more practical.\n *\n * 3. The quantization used is int8. And it is performed per-vector, so the\n * \"range\" (max abs value) is also stored alongside with the quantized data.\n *\n * 4. This library implements true elements deletion, not just marking the\n * element as deleted, but removing it (we can do it since our links are\n * bidirectional), and reliking the nodes orphaned of one link among\n * them.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo.\n */\n\n#define _DEFAULT_SOURCE\n#define _POSIX_C_SOURCE 200809L\n\n#include \n#include \n#include \n#include \n#include \n#include /* for INFINITY if not in math.h */\n#include \n#include \"hnsw.h\"\n#include \"mixer.h\"\n\n/* Check if we can compile SIMD code with function attributes.\n * This defines HAVE_AVX2, HAVE_AVX512, and HAVE_POPCNT when the compiler\n * supports the target() attribute for runtime CPU feature dispatch. */\n#if defined(__x86_64__) && ((defined(__GNUC__) && __GNUC__ >= 5) || (defined(__clang__) && __clang_major__ >= 4))\n #if defined(__has_attribute) && __has_attribute(target)\n #define HAVE_AVX2\n #define HAVE_AVX512\n #define HAVE_POPCNT\n #endif\n#endif\n\n#if defined(HAVE_POPCNT)\n #define ATTRIBUTE_TARGET_POPCNT __attribute__((target(\"popcnt\")))\n #define VSET_USE_POPCNT __builtin_cpu_supports(\"popcnt\")\n#else\n #define ATTRIBUTE_TARGET_POPCNT\n #define VSET_USE_POPCNT 0\n#endif\n\n#if defined(HAVE_AVX2)\n#define ATTRIBUTE_TARGET_AVX2 __attribute__((target(\"avx2,fma\")))\n#define ATTRIBUTE_TARGET_AVX2_POPCNT __attribute__((target(\"avx2,fma,popcnt\")))\n#define VSET_USE_AVX2 (__builtin_cpu_supports(\"avx2\") && __builtin_cpu_supports(\"fma\"))\n#else\n#define ATTRIBUTE_TARGET_AVX2\n#define ATTRIBUTE_TARGET_AVX2_POPCNT\n#define VSET_USE_AVX2 0\n#endif\n\n#if defined (HAVE_AVX512)\n#define ATTRIBUTE_TARGET_AVX512 __attribute__((target(\"avx512f,avx512bw,fma\")))\n#define ATTRIBUTE_TARGET_AVX512_VPOPCNT __attribute__((target(\"avx512f,fma,avx512vpopcntdq,popcnt\")))\n#define VSET_USE_AVX512 (__builtin_cpu_supports(\"avx512f\") && __builtin_cpu_supports(\"avx512bw\"))\n#define VSET_USE_AVX512_VPOPCNT (__builtin_cpu_supports(\"avx512f\") && __builtin_cpu_supports(\"avx512vpopcntdq\"))\n#else\n#define ATTRIBUTE_TARGET_AVX512\n#define ATTRIBUTE_TARGET_AVX512_VPOPCNT\n#define VSET_USE_AVX512 0\n#define VSET_USE_AVX512_VPOPCNT 0\n#endif\n\n/* Include SIMD headers when supported */\n#if defined(HAVE_AVX2) || defined(HAVE_AVX512)\n#include \n#endif\n\n#if 0\n#define debugmsg printf\n#else\n#define debugmsg if(0) printf\n#endif\n\n#ifndef INFINITY\n#define INFINITY (1.0/0.0)\n#endif\n\n#define MIN(a,b) ((a) < (b) ? (a) : (b))\n\n/* Define likely macro if not already defined */\n#ifndef likely\n#if __GNUC__ >= 3\n#define likely(x) __builtin_expect(!!(x), 1)\n#else\n#define likely(x) (x)\n#endif\n#endif\n\n/* Algorithm parameters. */\n\n#define HNSW_P 0.25 /* Probability of level increase. */\n#define HNSW_MAX_LEVEL 16 /* Max level nodes can reach. */\n#define HNSW_EF_C 200 /* Default size of dynamic candidate list while\n * inserting a new node, in case 0 is passed to\n * the 'ef' argument while inserting. This is also\n * used when deleting nodes for the search step\n * needed sometimes to reconnect nodes that remain\n * orphaned of one link. */\n\nstatic void (*hfree)(void *p) = free;\nstatic void *(*hmalloc)(size_t s) = malloc;\nstatic void *(*hrealloc)(void *old, size_t s) = realloc;\n\nvoid hnsw_set_allocator(void (*free_ptr)(void*), void *(*malloc_ptr)(size_t),\n void *(*realloc_ptr)(void*, size_t))\n{\n hfree = free_ptr;\n hmalloc = malloc_ptr;\n hrealloc = realloc_ptr;\n}\n\n// Get a warning if you use the libc allocator functions for mistake.\n#define malloc use_hmalloc_instead\n#define realloc use_hrealloc_instead\n#define free use_hfree_instead\n\n/* ============================== Prototypes ================================ */\nvoid hnsw_cursor_element_deleted(HNSW *index, hnswNode *deleted);\n\n/* ============================ Priority queue ================================\n * We need a priority queue to take an ordered list of candidates. Right now\n * it is implemented as a linear array, since it is relatively small.\n *\n * You may find it to be odd that we take the best element (smaller distance)\n * at the end of the array, but this way popping from the pqueue is O(1), as\n * we need to just decrement the count, and this is a very used operation\n * in a critical code path. This makes the priority queue implementation a\n * bit more complex in the insertion, but for good reasons. */\n\n/* Maximum number of candidates we'll ever need (cit. Bill Gates). */\n#define HNSW_MAX_CANDIDATES 256\n\ntypedef struct {\n hnswNode *node;\n float distance;\n} pqitem;\n\ntypedef struct {\n pqitem *items; /* Array of items. */\n uint32_t count; /* Current number of items. */\n uint32_t cap; /* Maximum capacity. */\n} pqueue;\n\n/* The HNSW algorithms access the pqueue conceptually from nearest (index 0)\n * to farthest (larger indexes) node, so the following macros are used to\n * access the pqueue in this fashion, even if the internal order is\n * actually reversed. */\n#define pq_get_node(q,i) ((q)->items[(q)->count-(i+1)].node)\n#define pq_get_distance(q,i) ((q)->items[(q)->count-(i+1)].distance)\n\n/* Create a new priority queue with given capacity. Adding to the\n * pqueue only retains 'capacity' elements with the shortest distance. */\npqueue *pq_new(uint32_t capacity) {\n pqueue *pq = hmalloc(sizeof(*pq));\n if (!pq) return NULL;\n\n pq->items = hmalloc(sizeof(pqitem) * capacity);\n if (!pq->items) {\n hfree(pq);\n return NULL;\n }\n\n pq->count = 0;\n pq->cap = capacity;\n return pq;\n}\n\n/* Free a priority queue. */\nvoid pq_free(pqueue *pq) {\n if (!pq) return;\n hfree(pq->items);\n hfree(pq);\n}\n\n/* Insert maintaining distance order (higher distances first). */\nvoid pq_push(pqueue *pq, hnswNode *node, float distance) {\n if (pq->count < pq->cap) {\n /* Queue not full: shift right from high distances to make room. */\n uint32_t i = pq->count;\n while (i > 0 && pq->items[i-1].distance < distance) {\n pq->items[i] = pq->items[i-1];\n i--;\n }\n pq->items[i].node = node;\n pq->items[i].distance = distance;\n pq->count++;\n } else {\n /* Queue full: if new item is worse than worst, ignore it. */\n if (distance >= pq->items[0].distance) return;\n\n /* Otherwise shift left from low distances to drop worst. */\n uint32_t i = 0;\n while (i < pq->cap-1 && pq->items[i+1].distance > distance) {\n pq->items[i] = pq->items[i+1];\n i++;\n }\n pq->items[i].node = node;\n pq->items[i].distance = distance;\n }\n}\n\n/* Remove and return the top (closest) element, which is at count-1\n * since we store elements with higher distances first.\n * Runs in constant time. */\nhnswNode *pq_pop(pqueue *pq, float *distance) {\n if (pq->count == 0) return NULL;\n pq->count--;\n *distance = pq->items[pq->count].distance;\n return pq->items[pq->count].node;\n}\n\n/* Get distance of the furthest element.\n * An empty priority queue has infinite distance as its furthest element,\n * note that this behavior is needed by the algorithms below. */\nfloat pq_max_distance(pqueue *pq) {\n if (pq->count == 0) return INFINITY;\n return pq->items[0].distance;\n}\n\n/* ============================ HNSW algorithm ============================== */\n\n/* Check if CPU supports POPCNT instruction - cached per thread */\nstatic inline int hnsw_cpu_supports_popcnt(void) {\n#if defined(HAVE_POPCNT)\n static __thread int popcnt_supported = -1;\n if (popcnt_supported == -1) {\n popcnt_supported = __builtin_cpu_supports(\"popcnt\");\n }\n return popcnt_supported;\n#else\n return 0; /* Assume CPU does not support POPCNT if __builtin_cpu_supports() is not available. */\n#endif\n}\n\n/* Manual popcount implementation for platforms without POPCNT support */\nstatic inline int hnsw_popcount64(uint64_t x) {\n x = (x & 0x5555555555555555) + ((x >> 1) & 0x5555555555555555);\n x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);\n x = (x & 0x0F0F0F0F0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F0F0F0F0F);\n x = (x & 0x00FF00FF00FF00FF) + ((x >> 8) & 0x00FF00FF00FF00FF);\n x = (x & 0x0000FFFF0000FFFF) + ((x >> 16) & 0x0000FFFF0000FFFF);\n x = (x & 0x00000000FFFFFFFF) + ((x >> 32) & 0x00000000FFFFFFFF);\n return x;\n}\n\n/* Optimized popcount function that uses hardware POPCNT instruction when available,\n * falling back to a software implementation when necessary. The CPU feature detection\n * result is cached per thread for better performance. */\nATTRIBUTE_TARGET_POPCNT\nstatic inline int hnsw_popcount(uint64_t x) {\n if (likely(hnsw_cpu_supports_popcnt())) {\n return __builtin_popcountll(x);\n } else {\n return hnsw_popcount64(x);\n }\n}\n\n/* Binary vectors distance function that uses POPCNT when available */\nATTRIBUTE_TARGET_POPCNT\nstatic inline float hnsw_vectors_distance_bin(const uint64_t *x, const uint64_t *y, uint32_t dim) {\n uint32_t len = (dim+63)/64;\n uint32_t opposite = 0;\n\n for (uint32_t j = 0; j < len; j++) {\n uint64_t xor = x[j]^y[j];\n opposite += hnsw_popcount(xor);\n }\n return (float)opposite*2/dim;\n}\n\n#if defined(HAVE_AVX512)\n/* AVX512 optimized dot product for float vectors */\nATTRIBUTE_TARGET_AVX512\nfloat vectors_distance_float_avx512(const float *x, const float *y, uint32_t dim) {\n __m512 sum = _mm512_setzero_ps();\n uint32_t i;\n \n /* Process 16 floats at a time with AVX512 */\n for (i = 0; i + 15 < dim; i += 16) {\n __m512 vx = _mm512_loadu_ps(&x[i]);\n __m512 vy = _mm512_loadu_ps(&y[i]);\n sum = _mm512_fmadd_ps(vx, vy, sum);\n }\n \n /* Horizontal sum of the 16 elements in sum */\n float dot = _mm512_reduce_add_ps(sum);\n \n /* Handle remaining elements */\n for (; i < dim; i++) {\n dot += x[i] * y[i];\n }\n \n return 1.0f - dot;\n}\n#endif /* HAVE_AVX512 */\n\n#if defined(HAVE_AVX2)\n/* AVX2 optimized dot product for float vectors */\nATTRIBUTE_TARGET_AVX2\nfloat vectors_distance_float_avx2(const float *x, const float *y, uint32_t dim) {\n __m256 sum1 = _mm256_setzero_ps();\n __m256 sum2 = _mm256_setzero_ps();\n uint32_t i;\n \n /* Process 16 floats at a time with two AVX2 registers */\n for (i = 0; i + 15 < dim; i += 16) {\n __m256 vx1 = _mm256_loadu_ps(&x[i]);\n __m256 vy1 = _mm256_loadu_ps(&y[i]);\n __m256 vx2 = _mm256_loadu_ps(&x[i + 8]);\n __m256 vy2 = _mm256_loadu_ps(&y[i + 8]);\n \n sum1 = _mm256_fmadd_ps(vx1, vy1, sum1);\n sum2 = _mm256_fmadd_ps(vx2, vy2, sum2);\n }\n \n /* Combine the two sums */\n __m256 combined = _mm256_add_ps(sum1, sum2);\n \n /* Horizontal sum of the 8 elements */\n __m128 sum_high = _mm256_extractf128_ps(combined, 1);\n __m128 sum_low = _mm256_castps256_ps128(combined);\n __m128 sum_128 = _mm_add_ps(sum_high, sum_low);\n \n sum_128 = _mm_hadd_ps(sum_128, sum_128);\n sum_128 = _mm_hadd_ps(sum_128, sum_128);\n \n float dot = _mm_cvtss_f32(sum_128);\n \n /* Handle remaining elements */\n for (; i < dim; i++) {\n dot += x[i] * y[i];\n }\n \n return 1.0f - dot;\n}\n#endif /* HAVE_AVX2 */\n\n/* Optimized dot product: automatically selects best available implementation \n * Dot product: our vectors are already normalized.\n * Version for not quantized vectors of floats. */\nfloat vectors_distance_float(const float *x, const float *y, uint32_t dim) {\n#if defined(HAVE_AVX512)\n if (dim >= 16 && VSET_USE_AVX512) {\n return vectors_distance_float_avx512(x, y, dim);\n }\n#endif\n\n#if defined(HAVE_AVX2)\n if (VSET_USE_AVX2 && dim >= 16) {\n return vectors_distance_float_avx2(x, y, dim);\n }\n#endif\n\n /* Fallback to original scalar implementation */\n float dot0 = 0.0f, dot1 = 0.0f;\n uint32_t i;\n\n /* Use two accumulators to reduce dependencies among multiplications.\n * This provides a clear speed boost in Apple silicon, but should be\n * help in general. */\n for (i = 0; i + 7 < dim; i += 8) {\n dot0 += x[i] * y[i] +\n x[i+1] * y[i+1] +\n x[i+2] * y[i+2] +\n x[i+3] * y[i+3];\n\n dot1 += x[i+4] * y[i+4] +\n x[i+5] * y[i+5] +\n x[i+6] * y[i+6] +\n x[i+7] * y[i+7];\n }\n\n /* Handle the remaining elements. These are a minority in the case\n * of a small vector, don't optimize this part. */\n for (; i < dim; i++) dot0 += x[i] * y[i];\n\n /* The following line may be counter intuitive. The dot product of\n * normalized vectors is equivalent to their cosine similarity. The\n * cosine will be from -1 (vectors facing opposite directions in the\n * N-dim space) to 1 (vectors are facing in the same direction).\n *\n * We kinda want a \"score\" of distance from 0 to 2 (this is a distance\n * function and we want minimize the distance for K-NN searches), so we\n * can't just add 1: that would return a number in the 0-2 range, with\n * 0 meaning opposite vectors and 2 identical vectors, so this is\n * similarity, not distance.\n *\n * Returning instead (1 - dotprod) inverts the meaning: 0 is identical\n * and 2 is opposite, hence it is their distance.\n *\n * Why don't normalize the similarity right now, and return from 0 to\n * 1? Because division is costly. */\n return 1.0f - (dot0 + dot1);\n}\n\n/* Q8 quants dotproduct. We do integer math and later fix it by range. */\n#if defined(HAVE_AVX512)\n/* AVX512 optimized dot product for Q8 vectors */\nATTRIBUTE_TARGET_AVX512\nfloat vectors_distance_q8_avx512(const int8_t *x, const int8_t *y, uint32_t dim,\n float range_a, float range_b) {\n // Handle zero vectors special case.\n if (range_a == 0 || range_b == 0) {\n return 1.0f;\n }\n\n const float scale_product = (range_a/127) * (range_b/127);\n __m512i sum = _mm512_setzero_si512();\n uint32_t i;\n\n /* Process 64 int8 elements at a time with AVX512 */\n for (i = 0; i + 63 < dim; i += 64) {\n /* Load 64 int8 values */\n __m512i vx = _mm512_loadu_si512((__m512i*)&x[i]);\n __m512i vy = _mm512_loadu_si512((__m512i*)&y[i]);\n \n /* Unpack and multiply-add in 32-bit precision\n * This is done in two steps: lower 32 bytes and upper 32 bytes */\n \n /* Process lower 32 bytes (256 bits) */\n __m256i vx_lo = _mm512_extracti64x4_epi64(vx, 0);\n __m256i vy_lo = _mm512_extracti64x4_epi64(vy, 0);\n \n /* Extend int8 to int16 */\n __m512i vx_lo_16 = _mm512_cvtepi8_epi16(vx_lo);\n __m512i vy_lo_16 = _mm512_cvtepi8_epi16(vy_lo);\n \n /* Multiply and accumulate to int32 */\n __m512i prod_lo = _mm512_madd_epi16(vx_lo_16, vy_lo_16);\n sum = _mm512_add_epi32(sum, prod_lo);\n \n /* Process upper 32 bytes (256 bits) */\n __m256i vx_hi = _mm512_extracti64x4_epi64(vx, 1);\n __m256i vy_hi = _mm512_extracti64x4_epi64(vy, 1);\n \n __m512i vx_hi_16 = _mm512_cvtepi8_epi16(vx_hi);\n __m512i vy_hi_16 = _mm512_cvtepi8_epi16(vy_hi);\n \n __m512i prod_hi = _mm512_madd_epi16(vx_hi_16, vy_hi_16);\n sum = _mm512_add_epi32(sum, prod_hi);\n }\n\n /* Horizontal sum of the 16 int32 elements in sum */\n int32_t dot = _mm512_reduce_add_epi32(sum);\n\n /* Handle remaining elements */\n for (; i < dim; i++) {\n dot += ((int32_t)x[i]) * ((int32_t)y[i]);\n }\n\n /* Convert to original range */\n float dotf = dot * scale_product;\n float distance = 1.0f - dotf;\n\n /* Clamp distance to [0, 2] */\n if (distance < 0) distance = 0;\n else if (distance > 2) distance = 2;\n return distance;\n}\n#endif /* HAVE_AVX512 */\n\n#if defined(HAVE_AVX2)\n/* AVX2 optimized dot product for Q8 vectors */\nATTRIBUTE_TARGET_AVX2\nfloat vectors_distance_q8_avx2(const int8_t *x, const int8_t *y, uint32_t dim,\n float range_a, float range_b) {\n // Handle zero vectors special case.\n if (range_a == 0 || range_b == 0) {\n return 1.0f;\n }\n\n const float scale_product = (range_a/127) * (range_b/127);\n __m256i sum = _mm256_setzero_si256();\n uint32_t i;\n\n /* Process 32 int8 elements at a time with AVX2 */\n for (i = 0; i + 31 < dim; i += 32) {\n /* Load 32 int8 values */\n __m256i vx = _mm256_loadu_si256((__m256i*)&x[i]);\n __m256i vy = _mm256_loadu_si256((__m256i*)&y[i]);\n \n /* Split into lower and upper 16 bytes */\n __m128i vx_lo = _mm256_extracti128_si256(vx, 0);\n __m128i vy_lo = _mm256_extracti128_si256(vy, 0);\n __m128i vx_hi = _mm256_extracti128_si256(vx, 1);\n __m128i vy_hi = _mm256_extracti128_si256(vy, 1);\n \n /* Extend int8 to int16 for lower half */\n __m256i vx_lo_16 = _mm256_cvtepi8_epi16(vx_lo);\n __m256i vy_lo_16 = _mm256_cvtepi8_epi16(vy_lo);\n \n /* Multiply and accumulate (madd does multiply adjacent pairs and add) */\n __m256i prod_lo = _mm256_madd_epi16(vx_lo_16, vy_lo_16);\n sum = _mm256_add_epi32(sum, prod_lo);\n \n /* Extend int8 to int16 for upper half */\n __m256i vx_hi_16 = _mm256_cvtepi8_epi16(vx_hi);\n __m256i vy_hi_16 = _mm256_cvtepi8_epi16(vy_hi);\n \n __m256i prod_hi = _mm256_madd_epi16(vx_hi_16, vy_hi_16);\n sum = _mm256_add_epi32(sum, prod_hi);\n }\n\n /* Horizontal sum of the 8 int32 elements in sum */\n __m128i sum_hi = _mm256_extracti128_si256(sum, 1);\n __m128i sum_lo = _mm256_castsi256_si128(sum);\n __m128i sum_128 = _mm_add_epi32(sum_hi, sum_lo);\n \n sum_128 = _mm_hadd_epi32(sum_128, sum_128);\n sum_128 = _mm_hadd_epi32(sum_128, sum_128);\n \n int32_t dot = _mm_cvtsi128_si32(sum_128);\n\n /* Handle remaining elements */\n for (; i < dim; i++) {\n dot += ((int32_t)x[i]) * ((int32_t)y[i]);\n }\n\n /* Convert to original range */\n float dotf = dot * scale_product;\n float distance = 1.0f - dotf;\n\n /* Clamp distance to [0, 2] */\n if (distance < 0) distance = 0;\n else if (distance > 2) distance = 2;\n return distance;\n}\n#endif /* HAVE_AVX2 */\n\n/* Q8 dot product: automatically selects best available implementation */\nfloat vectors_distance_q8(const int8_t *x, const int8_t *y, uint32_t dim,\n float range_a, float range_b) {\n#if defined(HAVE_AVX512)\n if (dim >= 64 && VSET_USE_AVX512) {\n return vectors_distance_q8_avx512(x, y, dim, range_a, range_b);\n }\n#endif\n\n#if defined(HAVE_AVX2)\n if (dim >= 32 && VSET_USE_AVX2) {\n return vectors_distance_q8_avx2(x, y, dim, range_a, range_b);\n }\n#endif\n\n /* Fallback to scalar implementation */\n // Handle zero vectors special case.\n if (range_a == 0 || range_b == 0) {\n /* Zero vector distance from anything is 1.0\n * (since 1.0 - dot_product where dot_product = 0). */\n return 1.0f;\n }\n\n /* Each vector is quantized from [-max_abs, +max_abs] to [-127, 127]\n * where range = 2*max_abs. */\n const float scale_product = (range_a/127) * (range_b/127);\n\n int32_t dot0 = 0, dot1 = 0;\n uint32_t i;\n\n // Process 8 elements at a time for better pipeline utilization.\n for (i = 0; i + 7 < dim; i += 8) {\n dot0 += ((int32_t)x[i]) * ((int32_t)y[i]) +\n ((int32_t)x[i+1]) * ((int32_t)y[i+1]) +\n ((int32_t)x[i+2]) * ((int32_t)y[i+2]) +\n ((int32_t)x[i+3]) * ((int32_t)y[i+3]);\n\n dot1 += ((int32_t)x[i+4]) * ((int32_t)y[i+4]) +\n ((int32_t)x[i+5]) * ((int32_t)y[i+5]) +\n ((int32_t)x[i+6]) * ((int32_t)y[i+6]) +\n ((int32_t)x[i+7]) * ((int32_t)y[i+7]);\n }\n\n // Handle remaining elements.\n for (; i < dim; i++) dot0 += ((int32_t)x[i]) * ((int32_t)y[i]);\n\n // Convert to original range.\n float dotf = (dot0 + dot1) * scale_product;\n float distance = 1.0f - dotf;\n\n // Clamp distance to [0, 2].\n if (distance < 0) distance = 0;\n else if (distance > 2) distance = 2;\n return distance;\n}\n\n#if defined(HAVE_AVX512) && defined(HAVE_POPCNT)\n/* AVX-512 vectorized binary distance calculation using VPOPCNTDQ.\n * Processes 8 uint64_t (512 bits) per iteration.\n * \n * Uses _mm512_popcnt_epi64 hardware popcount instruction which requires\n * AVX512VPOPCNTDQ extension\n */\nATTRIBUTE_TARGET_AVX512_VPOPCNT\nstatic float vectors_distance_bin_avx512_vpopcnt(const uint64_t *x, const uint64_t *y, uint32_t dim) {\n uint32_t len = (dim+63)/64;\n uint32_t opposite = 0;\n uint32_t j = 0;\n\n /* Process 8 uint64_t (512 bits) at a time with hardware popcount */\n if (len >= 8) {\n __m512i sum = _mm512_setzero_si512();\n \n for (; j + 7 < len; j += 8) {\n __m512i vx = _mm512_loadu_si512((__m512i*)&x[j]);\n __m512i vy = _mm512_loadu_si512((__m512i*)&y[j]);\n __m512i vxor = _mm512_xor_si512(vx, vy);\n \n /* Hardware popcount for 64-bit integers (AVX512VPOPCNTDQ) */\n __m512i popcnt = _mm512_popcnt_epi64(vxor);\n sum = _mm512_add_epi64(sum, popcnt);\n }\n \n /* Horizontal sum: reduce 8x 64-bit integers to scalar */\n opposite = _mm512_reduce_add_epi64(sum);\n }\n\n /* Handle remaining elements */\n for (; j < len; j++) {\n uint64_t xor = x[j] ^ y[j];\n opposite += __builtin_popcountll(xor);\n }\n\n return (float)opposite * 2.0f / dim;\n}\n#endif\n\n#if defined(HAVE_AVX2) && defined(HAVE_POPCNT)\n/* AVX2 vectorized binary distance calculation.\n * Processes 4 uint64_t (256 bits) per iteration. */\nATTRIBUTE_TARGET_AVX2_POPCNT\nstatic float vectors_distance_bin_avx2(const uint64_t *x, const uint64_t *y, uint32_t dim) {\n uint32_t len = (dim+63)/64;\n uint32_t opposite = 0;\n uint32_t j = 0;\n\n /* Process 4 uint64_t (256 bits) at a time */\n if (len >= 4) {\n for (; j + 3 < len; j += 4) {\n __m256i vx = _mm256_loadu_si256((__m256i*)&x[j]);\n __m256i vy = _mm256_loadu_si256((__m256i*)&y[j]);\n __m256i vxor = _mm256_xor_si256(vx, vy);\n \n /* Extract and use hardware POPCNT instruction */\n uint64_t xor_vals[4];\n _mm256_storeu_si256((__m256i*)xor_vals, vxor);\n \n opposite += __builtin_popcountll(xor_vals[0]);\n opposite += __builtin_popcountll(xor_vals[1]);\n opposite += __builtin_popcountll(xor_vals[2]);\n opposite += __builtin_popcountll(xor_vals[3]);\n }\n }\n\n /* Handle remaining elements */\n for (; j < len; j++) {\n uint64_t xor = x[j] ^ y[j];\n opposite += __builtin_popcountll(xor);\n }\n\n return (float)opposite * 2.0f / dim;\n}\n#endif\n\n/* Binary vectors distance with SIMD dispatch. */\nATTRIBUTE_TARGET_POPCNT\nfloat vectors_distance_bin(const uint64_t *x, const uint64_t *y, uint32_t dim) {\n#if defined(HAVE_AVX512) && defined(HAVE_POPCNT)\n /* AVX-512 with VPOPCNTDQ */\n if (dim >= 512 && VSET_USE_AVX512_VPOPCNT) {\n return vectors_distance_bin_avx512_vpopcnt(x, y, dim);\n }\n#endif\n\n#if defined(HAVE_AVX2) && defined(HAVE_POPCNT)\n /* AVX2 path: processes 4 uint64_t (256 bits) per iteration */\n if (dim >= 256 && VSET_USE_AVX2 && VSET_USE_POPCNT) {\n return vectors_distance_bin_avx2(x, y, dim);\n }\n#endif\n\n /* Fallback to scalar implementation with runtime POPCNT detection */\n return hnsw_vectors_distance_bin(x, y, dim);\n}\n\n/* Dot product between nodes. Will call the right version depending on the\n * quantization used. */\nfloat hnsw_distance(HNSW *index, hnswNode *a, hnswNode *b) {\n switch(index->quant_type) {\n case HNSW_QUANT_NONE:\n return vectors_distance_float(a->vector,b->vector,index->vector_dim);\n case HNSW_QUANT_Q8:\n return vectors_distance_q8(a->vector,b->vector,index->vector_dim,a->quants_range,b->quants_range);\n case HNSW_QUANT_BIN:\n return vectors_distance_bin(a->vector,b->vector,index->vector_dim);\n default:\n assert(1 != 1);\n return 0;\n }\n}\n\n/* This do Q8 'range' quantization.\n * For people looking at this code thinking: Oh, I could use min/max\n * quants instead! Well: I tried with min/max normalization but the dot\n * product needs to accumulate the sum for later correction, and it's slower. */\nvoid quantize_to_q8(float *src, int8_t *dst, uint32_t dim, float *rangeptr) {\n float max_abs = 0;\n for (uint32_t j = 0; j < dim; j++) {\n if (src[j] > max_abs) max_abs = src[j];\n if (-src[j] > max_abs) max_abs = -src[j];\n }\n\n if (max_abs == 0) {\n if (rangeptr) *rangeptr = 0;\n memset(dst, 0, dim);\n return;\n }\n\n const float scale = 127.0f / max_abs; // Scale to map to [-127, 127].\n\n for (uint32_t j = 0; j < dim; j++) {\n dst[j] = (int8_t)roundf(src[j] * scale);\n }\n if (rangeptr) *rangeptr = max_abs; // Return max_abs instead of 2*max_abs.\n}\n\n/* Binary quantization of vector 'src' to 'dst'. We use full words of\n * 64 bit as smallest unit, we will just set all the unused bits to 0\n * so that they'll be the same in all the vectors, and when xor+popcount\n * is used to compute the distance, such bits are not considered. This\n * allows to go faster. */\nvoid quantize_to_bin(float *src, uint64_t *dst, uint32_t dim) {\n memset(dst,0,(dim+63)/64*sizeof(uint64_t));\n for (uint32_t j = 0; j < dim; j++) {\n uint32_t word = j/64;\n uint32_t bit = j&63;\n /* Since cosine similarity checks the vector direction and\n * not magnitudo, we do likewise in the binary quantization and\n * just remember if the component is positive or negative. */\n if (src[j] > 0) dst[word] |= 1ULL< HNSW_MAX_M) m = HNSW_MAX_M;\n\n index->M = m;\n index->quant_type = quant_type;\n index->enter_point = NULL;\n index->max_level = 0;\n index->vector_dim = vector_dim;\n index->node_count = 0;\n index->last_id = 0;\n index->head = NULL;\n index->cursors = NULL;\n\n /* Initialize epochs array. */\n for (int i = 0; i < HNSW_MAX_THREADS; i++)\n index->current_epoch[i] = 0;\n\n /* Initialize locks. */\n if (pthread_rwlock_init(&index->global_lock, NULL) != 0) {\n hfree(index);\n return NULL;\n }\n\n for (int i = 0; i < HNSW_MAX_THREADS; i++) {\n if (pthread_mutex_init(&index->slot_locks[i], NULL) != 0) {\n /* Clean up previously initialized mutexes. */\n for (int j = 0; j < i; j++)\n pthread_mutex_destroy(&index->slot_locks[j]);\n pthread_rwlock_destroy(&index->global_lock);\n hfree(index);\n return NULL;\n }\n }\n\n /* Initialize atomic variables. */\n index->next_slot = 0;\n index->version = 0;\n return index;\n}\n\n/* Fill 'vec' with the node vector, de-normalizing and de-quantizing it\n * as needed. Note that this function will return an approximated version\n * of the original vector. */\nvoid hnsw_get_node_vector(HNSW *index, hnswNode *node, float *vec) {\n if (index->quant_type == HNSW_QUANT_NONE) {\n memcpy(vec,node->vector,index->vector_dim*sizeof(float));\n } else if (index->quant_type == HNSW_QUANT_Q8) {\n int8_t *quants = node->vector;\n for (uint32_t j = 0; j < index->vector_dim; j++)\n vec[j] = (quants[j]*node->quants_range)/127;\n } else if (index->quant_type == HNSW_QUANT_BIN) {\n uint64_t *bits = node->vector;\n for (uint32_t j = 0; j < index->vector_dim; j++) {\n uint32_t word = j/64;\n uint32_t bit = j&63;\n vec[j] = (bits[word] & (1ULL<quant_type != HNSW_QUANT_BIN) {\n for (uint32_t j = 0; j < index->vector_dim; j++)\n vec[j] *= node->l2;\n }\n}\n\n/* Return the number of bytes needed to represent a vector in the index,\n * that is function of the dimension of the vectors and the quantization\n * type used. */\nuint32_t hnsw_quants_bytes(HNSW *index) {\n switch(index->quant_type) {\n case HNSW_QUANT_NONE: return index->vector_dim * sizeof(float);\n case HNSW_QUANT_Q8: return index->vector_dim;\n case HNSW_QUANT_BIN: return (index->vector_dim+63)/64*8;\n default: assert(0 && \"Quantization type not supported.\");\n }\n}\n\n/* Create new node. Returns NULL on out of memory.\n * It is possible to pass the vector as floats or, in case this index\n * was already stored on disk and is being loaded, or serialized and\n * transmitted in any form, the already quantized version in\n * 'qvector'.\n *\n * Only vector or qvector should be non-NULL. The reason why passing\n * a quantized vector is useful, is that because re-normalizing and\n * re-quantizing several times the same vector may accumulate rounding\n * errors. So if you work with quantized indexes, you should save\n * the quantized indexes.\n *\n * Note that, together with qvector, the quantization range is needed,\n * since this library uses per-vector quantization. In case of quantized\n * vectors the l2 is considered to be '1', so if you want to restore\n * the right l2 (to use the API that returns an approximation of the\n * original vector) make sure to save the l2 on disk and set it back\n * after the node creation (see later for the serialization API that\n * handles this and more). */\nhnswNode *hnsw_node_new(HNSW *index, uint64_t id, const float *vector, const int8_t *qvector, float qrange, uint32_t level, int normalize) {\n hnswNode *node = hmalloc(sizeof(hnswNode)+(sizeof(hnswNodeLayer)*(level+1)));\n if (!node) return NULL;\n\n if (id == 0) id = ++index->last_id;\n node->level = level;\n node->id = id;\n node->next = NULL;\n node->vector = NULL;\n node->l2 = 1; // Default in case of already quantized vectors. It is\n // up to the caller to fill this later, if needed.\n\n /* Initialize visited epoch array. */\n for (int i = 0; i < HNSW_MAX_THREADS; i++)\n node->visited_epoch[i] = 0;\n\n if (qvector == NULL) {\n /* Copy input vector. */\n node->vector = hmalloc(sizeof(float) * index->vector_dim);\n if (!node->vector) {\n hfree(node);\n return NULL;\n }\n memcpy(node->vector, vector, sizeof(float) * index->vector_dim);\n if (normalize)\n hnsw_normalize_vector(node->vector,&node->l2,index->vector_dim);\n\n /* Handle quantization. */\n if (index->quant_type != HNSW_QUANT_NONE) {\n void *quants = hmalloc(hnsw_quants_bytes(index));\n if (quants == NULL) {\n hfree(node->vector);\n hfree(node);\n return NULL;\n }\n\n // Quantize.\n switch(index->quant_type) {\n case HNSW_QUANT_Q8:\n quantize_to_q8(node->vector,quants,index->vector_dim,&node->quants_range);\n break;\n case HNSW_QUANT_BIN:\n quantize_to_bin(node->vector,quants,index->vector_dim);\n break;\n default:\n assert(0 && \"Quantization type not handled.\");\n break;\n }\n\n // Discard the full precision vector.\n hfree(node->vector);\n node->vector = quants;\n }\n } else {\n // We got the already quantized vector. Just copy it.\n assert(index->quant_type != HNSW_QUANT_NONE);\n uint32_t vector_bytes = hnsw_quants_bytes(index);\n node->vector = hmalloc(vector_bytes);\n node->quants_range = qrange;\n if (node->vector == NULL) {\n hfree(node);\n return NULL;\n }\n memcpy(node->vector,qvector,vector_bytes);\n }\n\n /* Initialize each layer. */\n for (uint32_t i = 0; i <= level; i++) {\n uint32_t max_links = (i == 0) ? index->M*2 : index->M;\n node->layers[i].max_links = max_links;\n node->layers[i].num_links = 0;\n node->layers[i].worst_distance = 0;\n node->layers[i].worst_idx = 0;\n node->layers[i].links = hmalloc(sizeof(hnswNode*) * max_links);\n if (!node->layers[i].links) {\n for (uint32_t j = 0; j < i; j++) hfree(node->layers[j].links);\n hfree(node->vector);\n hfree(node);\n return NULL;\n }\n }\n\n return node;\n}\n\n/* Free a node. */\nvoid hnsw_node_free(hnswNode *node) {\n if (!node) return;\n\n for (uint32_t i = 0; i <= node->level; i++)\n hfree(node->layers[i].links);\n\n hfree(node->vector);\n hfree(node);\n}\n\n/* Free the entire index. */\nvoid hnsw_free(HNSW *index,void(*free_value)(void*value)) {\n if (!index) return;\n\n hnswNode *current = index->head;\n while (current) {\n hnswNode *next = current->next;\n if (free_value) free_value(current->value);\n hnsw_node_free(current);\n current = next;\n }\n\n /* Destroy locks */\n pthread_rwlock_destroy(&index->global_lock);\n for (int i = 0; i < HNSW_MAX_THREADS; i++) {\n pthread_mutex_destroy(&index->slot_locks[i]);\n }\n\n hfree(index);\n}\n\n/* Add node to linked list of nodes. We may need to scan the whole\n * HNSW graph for several reasons. The list is doubly linked since we\n * also need the ability to remove a node without scanning the whole thing. */\nvoid hnsw_add_node(HNSW *index, hnswNode *node) {\n node->next = index->head;\n node->prev = NULL;\n if (index->head)\n index->head->prev = node;\n index->head = node;\n index->node_count++;\n}\n\n/* Search the specified layer starting from the specified entry point\n * to collect 'ef' nodes that are near to 'query'.\n *\n * This function implements optional hybrid search, so that each node\n * can be accepted or not based on its associated value. In this case\n * a callback 'filter_callback' should be passed, together with a maximum\n * effort for the search (number of candidates to evaluate), since even\n * with a a low \"EF\" value we risk that there are too few nodes that satisfy\n * the provided filter, and we could trigger a full scan. */\npqueue *search_layer_with_filter(\n HNSW *index, hnswNode *query, hnswNode *entry_point,\n uint32_t ef, uint32_t layer, uint32_t slot,\n int (*filter_callback)(void *value, void *privdata),\n void *filter_privdata, uint32_t max_candidates)\n{\n // Mark visited nodes with a never seen epoch.\n index->current_epoch[slot]++;\n\n pqueue *candidates = pq_new(HNSW_MAX_CANDIDATES);\n pqueue *results = pq_new(ef);\n if (!candidates || !results) {\n if (candidates) pq_free(candidates);\n if (results) pq_free(results);\n return NULL;\n }\n\n // Take track of the total effort: only used when filtering via\n // a callback to have a bound effort.\n uint32_t evaluated_candidates = 1;\n\n // Add entry point.\n float dist = hnsw_distance(index, query, entry_point);\n pq_push(candidates, entry_point, dist);\n if (filter_callback == NULL ||\n filter_callback(entry_point->value, filter_privdata))\n {\n pq_push(results, entry_point, dist);\n }\n entry_point->visited_epoch[slot] = index->current_epoch[slot];\n\n // Process candidates.\n while (candidates->count > 0) {\n // Max effort. If zero, we keep scanning.\n if (filter_callback &&\n max_candidates &&\n evaluated_candidates >= max_candidates) break;\n\n float cur_dist;\n hnswNode *current = pq_pop(candidates, &cur_dist);\n evaluated_candidates++;\n\n float furthest = pq_max_distance(results);\n if (results->count >= ef && cur_dist > furthest) break;\n\n /* Check neighbors. */\n for (uint32_t i = 0; i < current->layers[layer].num_links; i++) {\n hnswNode *neighbor = current->layers[layer].links[i];\n\n if (neighbor->visited_epoch[slot] == index->current_epoch[slot])\n continue; // Already visited during this scan.\n\n neighbor->visited_epoch[slot] = index->current_epoch[slot];\n float neighbor_dist = hnsw_distance(index, query, neighbor);\n\n furthest = pq_max_distance(results);\n if (filter_callback == NULL) {\n /* Original HNSW logic when no filtering:\n * Add to results if better than current max or\n * results not full. */\n if (neighbor_dist < furthest || results->count < ef) {\n pq_push(candidates, neighbor, neighbor_dist);\n pq_push(results, neighbor, neighbor_dist);\n }\n } else {\n /* With filtering: we add candidates even if doesn't match\n * the filter, in order to continue to explore the graph. */\n if (neighbor_dist < furthest || candidates->count < ef) {\n pq_push(candidates, neighbor, neighbor_dist);\n }\n\n /* Add results only if passes filter. */\n if (filter_callback(neighbor->value, filter_privdata)) {\n if (neighbor_dist < furthest || results->count < ef) {\n pq_push(results, neighbor, neighbor_dist);\n }\n }\n }\n }\n }\n\n pq_free(candidates);\n return results;\n}\n\n/* Just a wrapper without hybrid search callback. */\npqueue *search_layer(HNSW *index, hnswNode *query, hnswNode *entry_point,\n uint32_t ef, uint32_t layer, uint32_t slot)\n{\n return search_layer_with_filter(index, query, entry_point, ef, layer, slot,\n NULL, NULL, 0);\n}\n\n/* This function is used in order to initialize a node allocated in the\n * function stack with the specified vector. The idea is that we can\n * easily use hnsw_distance() from a vector and the HNSW nodes this way:\n *\n * hnswNode myQuery;\n * hnsw_init_tmp_node(myIndex,&myQuery,0,some_vector);\n * hnsw_distance(&myQuery, some_hnsw_node);\n *\n * Make sure to later free the node with:\n *\n * hnsw_free_tmp_node(&myQuery,some_vector);\n * You have to pass the vector to the free function, because sometimes\n * hnsw_init_tmp_node() may just avoid allocating a vector at all,\n * just reusing 'some_vector' pointer.\n *\n * Return 0 on out of memory, 1 on success.\n */\nint hnsw_init_tmp_node(HNSW *index, hnswNode *node, int is_normalized, const float *vector) {\n node->vector = NULL;\n\n /* Work on a normalized query vector if the input vector is\n * not normalized. */\n if (!is_normalized) {\n node->vector = hmalloc(sizeof(float)*index->vector_dim);\n if (node->vector == NULL) return 0;\n memcpy(node->vector,vector,sizeof(float)*index->vector_dim);\n hnsw_normalize_vector(node->vector,NULL,index->vector_dim);\n } else {\n node->vector = (float*)vector;\n }\n\n /* If quantization is enabled, our query fake node should be\n * quantized as well. */\n if (index->quant_type != HNSW_QUANT_NONE) {\n void *quants = hmalloc(hnsw_quants_bytes(index));\n if (quants == NULL) {\n if (node->vector != vector) hfree(node->vector);\n return 0;\n }\n switch(index->quant_type) {\n case HNSW_QUANT_Q8:\n quantize_to_q8(node->vector, quants, index->vector_dim, &node->quants_range);\n break;\n case HNSW_QUANT_BIN:\n quantize_to_bin(node->vector, quants, index->vector_dim);\n }\n if (node->vector != vector) hfree(node->vector);\n node->vector = quants;\n }\n return 1;\n}\n\n/* Free the stack allocated node initialized by hnsw_init_tmp_node(). */\nvoid hnsw_free_tmp_node(hnswNode *node, const float *vector) {\n if (node->vector != vector) hfree(node->vector);\n}\n\n/* Return approximated K-NN items. Note that neighbors and distances\n * arrays must have space for at least 'k' items.\n * norm_query should be set to 1 if the query vector is already\n * normalized, otherwise, if 0, the function will copy the vector,\n * L2-normalize the copy and search using the normalized version.\n *\n * If the filter_privdata callback is passed, only elements passing the\n * specified filter (invoked with privdata and the value associated\n * to the node as arguments) are returned. In such case, if max_candidates\n * is not NULL, it represents the maximum number of nodes to explore, since\n * the search may be otherwise unbound if few or no elements pass the\n * filter. */\nint hnsw_search_with_filter\n (HNSW *index, const float *query_vector, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized,\n int (*filter_callback)(void *value, void *privdata),\n void *filter_privdata, uint32_t max_candidates)\n\n{\n if (!index || !query_vector || !neighbors || k == 0) return -1;\n if (!index->enter_point) return 0; // Empty index.\n\n /* Use a fake node that holds the query vector, this way we can\n * use our normal node to node distance functions when checking\n * the distance between query and graph nodes. */\n hnswNode query;\n if (hnsw_init_tmp_node(index,&query,query_vector_is_normalized,query_vector) == 0) return -1;\n\n // Start searching from the entry point.\n hnswNode *curr_ep = index->enter_point;\n\n /* Start from higher layer to layer 1 (layer 0 is handled later)\n * in the next section. Descend to the most similar node found\n * so far. */\n for (int lc = index->max_level; lc > 0; lc--) {\n pqueue *results = search_layer(index, &query, curr_ep, 1, lc, slot);\n if (!results) continue;\n\n if (results->count > 0) {\n curr_ep = pq_get_node(results,0);\n }\n pq_free(results);\n }\n\n /* Search bottom layer (the most densely populated) with ef = k */\n pqueue *results = search_layer_with_filter(\n index, &query, curr_ep, k, 0, slot, filter_callback,\n filter_privdata, max_candidates);\n if (!results) {\n hnsw_free_tmp_node(&query, query_vector);\n return -1;\n }\n\n /* Copy results. */\n uint32_t found = MIN(k, results->count);\n for (uint32_t i = 0; i < found; i++) {\n neighbors[i] = pq_get_node(results,i);\n if (distances) {\n distances[i] = pq_get_distance(results,i);\n }\n }\n\n pq_free(results);\n hnsw_free_tmp_node(&query, query_vector);\n return found;\n}\n\n/* Wrapper to hnsw_search_with_filter() when no filter is needed. */\nint hnsw_search(HNSW *index, const float *query_vector, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized)\n{\n return hnsw_search_with_filter(index,query_vector,k,neighbors,\n distances,slot,query_vector_is_normalized,\n NULL,NULL,0);\n}\n\n/* Rescan a node and update the wortst neighbor index.\n * The followinng two functions are variants of this function to be used\n * when links are added or removed: they may do less work than a full scan. */\nvoid hnsw_update_worst_neighbor(HNSW *index, hnswNode *node, uint32_t layer) {\n float worst_dist = 0;\n uint32_t worst_idx = 0;\n for (uint32_t i = 0; i < node->layers[layer].num_links; i++) {\n float dist = hnsw_distance(index, node, node->layers[layer].links[i]);\n if (dist > worst_dist) {\n worst_dist = dist;\n worst_idx = i;\n }\n }\n node->layers[layer].worst_distance = worst_dist;\n node->layers[layer].worst_idx = worst_idx;\n}\n\n/* Update node worst neighbor distance information when a new neighbor\n * is added. */\nvoid hnsw_update_worst_neighbor_on_add(HNSW *index, hnswNode *node, uint32_t layer, uint32_t added_index, float distance) {\n (void) index; // Unused but here for API symmetry.\n if (node->layers[layer].num_links == 1 || // First neighbor?\n distance > node->layers[layer].worst_distance) // New worst?\n {\n node->layers[layer].worst_distance = distance;\n node->layers[layer].worst_idx = added_index;\n }\n}\n\n/* Update node worst neighbor distance information when a linked neighbor\n * is removed. */\nvoid hnsw_update_worst_neighbor_on_remove(HNSW *index, hnswNode *node, uint32_t layer, uint32_t removed_idx)\n{\n if (node->layers[layer].num_links == 0) {\n node->layers[layer].worst_distance = 0;\n node->layers[layer].worst_idx = 0;\n } else if (removed_idx == node->layers[layer].worst_idx) {\n hnsw_update_worst_neighbor(index,node,layer);\n } else if (removed_idx < node->layers[layer].worst_idx) {\n // Just update index if we removed element before worst.\n node->layers[layer].worst_idx--;\n }\n}\n\n/* We have a list of candidate nodes to link to the new node, when inserting\n * one. This function selects which nodes to link and performs the linking.\n *\n * Parameters:\n *\n * - 'candidates' is the priority queue of potential good nodes to link to the\n * new node 'new_node'.\n * - 'required_links' is as many links we would like our new_node to get\n * at the specified layer.\n * - 'aggressive' changes the strategy used to find good neighbors as follows:\n *\n * This function is called with aggressive=0 for all the layers, including\n * layer 0. When called like that, it will use the diversity of links and\n * quality of links checks before linking our new node with some candidate.\n *\n * However if the insert function finds that at layer 0, with aggressive=0,\n * few connections were made, it calls this function again with aggressiveness\n * levels greater up to 2.\n *\n * At aggressive=1, the diversity checks are disabled, and the candidate\n * node for linking is accepted even if it is nearest to an already accepted\n * neighbor than it is to the new node.\n *\n * When we link our new node by replacing the link of a candidate neighbor\n * that already has the max number of links, inevitably some other node loses\n * a connection (to make space for our new node link). In this case:\n *\n * 1. If such \"dropped\" node would remain with too little links, we try with\n * some different neighbor instead, however as the 'aggressive' parameter\n * has incremental values (0, 1, 2) we are more and more willing to leave\n * the dropped node with fever connections.\n * 2. If aggressive=2, we will scan the candidate neighbor node links to\n * find a different linked-node to replace, one better connected even if\n * its distance is not the worse.\n *\n * Note: this function is also called during deletion of nodes in order to\n * provide certain nodes with additional links.\n */\nvoid select_neighbors(HNSW *index, pqueue *candidates, hnswNode *new_node,\n uint32_t layer, uint32_t required_links, int aggressive)\n{\n for (uint32_t i = 0; i < candidates->count; i++) {\n hnswNode *neighbor = pq_get_node(candidates,i);\n if (neighbor == new_node) continue; // Don't link node with itself.\n\n /* Use our cached distance among the new node and the candidate. */\n float dist = pq_get_distance(candidates,i);\n\n /* First of all, since our links are all bidirectional, if the\n * new node for any reason has no longer room, or if it accumulated\n * the required number of links, return ASAP. */\n if (new_node->layers[layer].num_links >= new_node->layers[layer].max_links ||\n new_node->layers[layer].num_links >= required_links) return;\n\n /* If aggressive is true, it is possible that the new node\n * already got some link among the candidates (see the top comment,\n * this function gets re-called in case of too few links).\n * So we need to check if this candidate is already linked to\n * the new node. */\n if (aggressive) {\n int duplicated = 0;\n for (uint32_t j = 0; j < new_node->layers[layer].num_links; j++) {\n if (new_node->layers[layer].links[j] == neighbor) {\n duplicated = 1;\n break;\n }\n }\n if (duplicated) continue;\n }\n\n /* Diversity check. We accept new candidates\n * only if there is no element already accepted that is nearest\n * to the candidate than the new element itself.\n * However this check is disabled if we have pressure to find\n * new links (aggressive != 0) */\n if (!aggressive) {\n int diversity_failed = 0;\n for (uint32_t j = 0; j < new_node->layers[layer].num_links; j++) {\n float link_dist = hnsw_distance(index, neighbor,\n new_node->layers[layer].links[j]);\n if (link_dist < dist) {\n diversity_failed = 1;\n break;\n }\n }\n if (diversity_failed) continue;\n }\n\n /* If potential neighbor node has space, simply add the new link.\n * We will have space as well. */\n uint32_t n = neighbor->layers[layer].num_links;\n if (n < neighbor->layers[layer].max_links) {\n /* Link candidate to new node. */\n neighbor->layers[layer].links[n] = new_node;\n neighbor->layers[layer].num_links++;\n\n /* Update candidate worst link info. */\n hnsw_update_worst_neighbor_on_add(index,neighbor,layer,n,dist);\n\n /* Link new node to candidate. */\n uint32_t new_links = new_node->layers[layer].num_links;\n new_node->layers[layer].links[new_links] = neighbor;\n new_node->layers[layer].num_links++;\n\n /* Update new node worst link info. */\n hnsw_update_worst_neighbor_on_add(index,new_node,layer,new_links,dist);\n continue;\n }\n\n /* ====================================================================\n * Replacing existing candidate neighbor link step.\n * ================================================================== */\n\n /* If we are here, our accepted candidate for linking is full.\n *\n * If new node is more distant to candidate than its current worst link\n * then we skip it: we would not be able to establish a bidirectional\n * connection without compromising link quality of candidate.\n *\n * At aggressiveness > 0 we don't care about this check. */\n if (!aggressive && dist >= neighbor->layers[layer].worst_distance)\n continue;\n\n /* We can add it: we are ready to replace the candidate neighbor worst\n * link with the new node, assuming certain conditions are met. */\n hnswNode *worst_node = neighbor->layers[layer].links[neighbor->layers[layer].worst_idx];\n\n /* The worst node linked to our candidate may remain too disconnected\n * if we remove the candidate node as its link. Let's check if\n * this is the case: */\n if (aggressive == 0 &&\n worst_node->layers[layer].num_links <= index->M/2)\n continue;\n\n /* Aggressive level = 1. It's ok if the node remains with just\n * HNSW_M/4 links. */\n else if (aggressive == 1 &&\n worst_node->layers[layer].num_links <= index->M/4)\n continue;\n\n /* If aggressive is set to 2, then the new node we are adding failed\n * to find enough neighbors. We can't insert an almost orphaned new\n * node, so let's see if the target node has some other link\n * that is well connected in the graph: we could drop it instead\n * of the worst link. */\n if (aggressive == 2 && worst_node->layers[layer].num_links <=\n index->M/4)\n {\n /* Let's see if we can find at least a candidate link that\n * would remain with a few connections. Track the one\n * that is the farthest away (worst distance) from our candidate\n * neighbor (in order to remove the less interesting link). */\n worst_node = NULL;\n uint32_t worst_idx = 0;\n float max_dist = 0;\n for (uint32_t j = 0; j < neighbor->layers[layer].num_links; j++) {\n hnswNode *to_drop = neighbor->layers[layer].links[j];\n\n /* Skip this if it would remain too disconnected as well.\n *\n * NOTE about index->M/4 min connections requirement:\n *\n * It is not too strict, since leaving a node with just a\n * single link does not just leave it too weakly connected, but\n * also sometimes creates cycles with few disconnected\n * nodes linked among them. */\n if (to_drop->layers[layer].num_links <= index->M/4) continue;\n\n float link_dist = hnsw_distance(index, neighbor, to_drop);\n if (worst_node == NULL || link_dist > max_dist) {\n worst_node = to_drop;\n max_dist = link_dist;\n worst_idx = j;\n }\n }\n\n if (worst_node != NULL) {\n /* We found a node that we can drop. Let's pretend this is\n * the worst node of the candidate to unify the following\n * code path. Later we will fix the worst node info anyway. */\n neighbor->layers[layer].worst_distance = max_dist;\n neighbor->layers[layer].worst_idx = worst_idx;\n } else {\n /* Otherwise we have no other option than reallocating\n * the max number of links for this target node, and\n * ensure at least a few connections for our new node. */\n uint32_t reallocation_limit = layer == 0 ?\n index->M * 3 : index->M *2;\n if (neighbor->layers[layer].max_links >= reallocation_limit)\n continue;\n\n uint32_t new_max_links = neighbor->layers[layer].max_links+1;\n hnswNode **new_links = hrealloc(neighbor->layers[layer].links,\n sizeof(hnswNode*) * new_max_links);\n if (new_links == NULL) continue; // Non critical.\n\n /* Update neighbor's link capacity. */\n neighbor->layers[layer].links = new_links;\n neighbor->layers[layer].max_links = new_max_links;\n\n /* Establish bidirectional link. */\n uint32_t n = neighbor->layers[layer].num_links;\n neighbor->layers[layer].links[n] = new_node;\n neighbor->layers[layer].num_links++;\n hnsw_update_worst_neighbor_on_add(index, neighbor, layer,\n n, dist);\n\n n = new_node->layers[layer].num_links;\n new_node->layers[layer].links[n] = neighbor;\n new_node->layers[layer].num_links++;\n hnsw_update_worst_neighbor_on_add(index, new_node, layer,\n n, dist);\n continue;\n }\n }\n\n // Remove backlink from the worst node of our candidate.\n for (uint64_t j = 0; j < worst_node->layers[layer].num_links; j++) {\n if (worst_node->layers[layer].links[j] == neighbor) {\n memmove(&worst_node->layers[layer].links[j],\n &worst_node->layers[layer].links[j+1],\n (worst_node->layers[layer].num_links - j - 1) * sizeof(hnswNode*));\n worst_node->layers[layer].num_links--;\n hnsw_update_worst_neighbor_on_remove(index,worst_node,layer,j);\n break;\n }\n }\n\n /* Replace worst link with the new node. */\n neighbor->layers[layer].links[neighbor->layers[layer].worst_idx] = new_node;\n\n /* Update the worst link in the target node, at this point\n * the link that we replaced may no longer be the worst. */\n hnsw_update_worst_neighbor(index,neighbor,layer);\n\n // Add new node -> candidate link.\n uint32_t new_links = new_node->layers[layer].num_links;\n new_node->layers[layer].links[new_links] = neighbor;\n new_node->layers[layer].num_links++;\n\n // Update new node worst link.\n hnsw_update_worst_neighbor_on_add(index,new_node,layer,new_links,dist);\n }\n}\n\n/* This function implements node reconnection after a node deletion in HNSW.\n * When a node is deleted, other nodes at the specified layer lose one\n * connection (all the neighbors of the deleted node). This function attempts\n * to pair such nodes together in a way that maximizes connection quality\n * among the M nodes that were former neighbors of our deleted node.\n *\n * The algorithm works by first building a distance matrix among the nodes:\n *\n * N0 N1 N2 N3\n * N0 0 1.2 0.4 0.9\n * N1 1.2 0 0.8 0.5\n * N2 0.4 0.8 0 1.1\n * N3 0.9 0.5 1.1 0\n *\n * For each potential pairing (i,j) we compute a score that combines:\n * 1. The direct cosine distance between the two nodes\n * 2. The average distance to other nodes that would no longer be\n * available for pairing if we select this pair\n *\n * We want to balance local node-to-node requirements and global requirements.\n * For instance sometimes connecting A with B, while optimal, would leave\n * C and D to be connected without other choices, and this could be a very\n * bad connection. Maybe instead A and C and B and D are both relatively high\n * quality connections.\n *\n * The formula used to calculate the score of each connection is:\n *\n * score[i,j] = W1*(2-distance[i,j]) + W2*((new_avg_i + new_avg_j)/2)\n * where new_avg_x is the average of distances in row x excluding distance[i,j]\n *\n * So the score is directly proportional to the SIMILARITY of the two nodes\n * and also directly proportional to the DISTANCE of the potential other\n * connections that we lost by pairign i,j. So we have a cost for missed\n * opportunities, or better, in this case, a reward if the missing\n * opportunities are not so good (big average distance).\n *\n * W1 and W2 are weights (defaults: 0.7 and 0.3) that determine the relative\n * importance of immediate connection quality vs future pairing potential.\n *\n * After the initial pairing phase, any nodes that couldn't be paired\n * (due to odd count or existing connections) are handled by searching\n * the broader graph using the standard HNSW neighbor selection logic.\n */\nvoid hnsw_reconnect_nodes(HNSW *index, hnswNode **nodes, int count, uint32_t layer) {\n if (count <= 0) return;\n debugmsg(\"Reconnecting %d nodes\\n\", count);\n\n /* Step 1: Build the distance matrix between all nodes.\n * Since distance(i,j) = distance(j,i), we only compute the upper triangle\n * and mirror it to the lower triangle. */\n float *distances = hmalloc((unsigned long) count * count * sizeof(float));\n if (!distances) return;\n\n for (int i = 0; i < count; i++) {\n distances[i*count + i] = 0; // Distance to self is 0\n for (int j = i+1; j < count; j++) {\n float dist = hnsw_distance(index, nodes[i], nodes[j]);\n distances[i*count + j] = dist; // Upper triangle.\n distances[j*count + i] = dist; // Lower triangle.\n }\n }\n\n /* Step 2: Calculate row averages (will be used in scoring):\n * please note that we just calculate row averages and not\n * columns averages since the matrix is symmetrical, so those\n * are the same: check the image in the top comment if you have any\n * doubt about this. */\n float *row_avgs = hmalloc(count * sizeof(float));\n if (!row_avgs) {\n hfree(distances);\n return;\n }\n\n for (int i = 0; i < count; i++) {\n float sum = 0;\n int valid_count = 0;\n for (int j = 0; j < count; j++) {\n if (i != j) {\n sum += distances[i*count + j];\n valid_count++;\n }\n }\n row_avgs[i] = valid_count ? sum / valid_count : 0;\n }\n\n /* Step 3: Build scoring matrix. What we do here is to combine how\n * good is a given i,j nodes connection, with how badly connecting\n * i,j will affect the remaining quality of connections left to\n * pair the other nodes. */\n float *scores = hmalloc((unsigned long) count * count * sizeof(float));\n if (!scores) {\n hfree(distances);\n hfree(row_avgs);\n return;\n }\n\n /* Those weights were obtained manually... No guarantee that they\n * are optimal. However with these values the algorithm is certain\n * better than its greedy version that just attempts to pick the\n * best pair each time (verified experimentally). */\n const float W1 = 0.7; // Weight for immediate distance.\n const float W2 = 0.3; // Weight for future potential.\n\n for (int i = 0; i < count; i++) {\n for (int j = 0; j < count; j++) {\n if (i == j) {\n scores[i*count + j] = -1; // Invalid pairing.\n continue;\n }\n\n // Check for existing connection between i and j.\n int already_linked = 0;\n for (uint32_t k = 0; k < nodes[i]->layers[layer].num_links; k++)\n {\n if (nodes[i]->layers[layer].links[k] == nodes[j]) {\n scores[i*count + j] = -1; // Already linked.\n already_linked = 1;\n break;\n }\n }\n if (already_linked) continue;\n\n float dist = distances[i*count + j];\n\n /* Calculate new averages excluding this pair.\n * Handle edge case where we might have too few elements.\n * Note that it would be not very smart to recompute the average\n * each time scanning the row, we can remove the element\n * and adjust the average without it. */\n float new_avg_i = 0, new_avg_j = 0;\n if (count > 2) {\n new_avg_i = (row_avgs[i] * (count-1) - dist) / (count-2);\n new_avg_j = (row_avgs[j] * (count-1) - dist) / (count-2);\n }\n\n /* Final weighted score: the more similar i,j, the better\n * the score. The more distant are the pairs we lose by\n * connecting i,j, the better the score. */\n scores[i*count + j] = W1*(2-dist) + W2*((new_avg_i + new_avg_j)/2);\n }\n }\n\n // Step 5: Pair nodes greedily based on scores.\n int *used = hmalloc(count*sizeof(int));\n memset(used,0,count*sizeof(int));\n if (!used) {\n hfree(distances);\n hfree(row_avgs);\n hfree(scores);\n return;\n }\n\n /* Scan the matrix looking each time for the potential\n * link with the best score. */\n while(1) {\n float max_score = -1;\n int best_j = -1, best_i = -1;\n\n // Seek best score i,j values.\n for (int i = 0; i < count; i++) {\n if (used[i]) continue; // Already connected.\n\n /* No space left? Not possible after a node deletion but makes\n * this function more future-proof. */\n if (nodes[i]->layers[layer].num_links >=\n nodes[i]->layers[layer].max_links) continue;\n\n for (int j = 0; j < count; j++) {\n if (i == j) continue; // Same node, skip.\n if (used[j]) continue; // Already connected.\n float score = scores[i*count + j];\n if (score < 0) continue; // Invalid link.\n\n /* If the target node has space, and its score is better\n * than any other seen so far... remember it is the best. */\n if (score > max_score &&\n nodes[j]->layers[layer].num_links <\n nodes[j]->layers[layer].max_links)\n {\n // Track the best connection found so far.\n max_score = score;\n best_j = j;\n best_i = i;\n }\n }\n }\n\n // Possible link found? Connect i and j.\n if (best_j != -1) {\n debugmsg(\"[%d] linking %d with %d: %f\\n\", layer, (int)best_i, (int)best_j, max_score);\n // Link i -> j.\n int link_idx = nodes[best_i]->layers[layer].num_links;\n nodes[best_i]->layers[layer].links[link_idx] = nodes[best_j];\n nodes[best_i]->layers[layer].num_links++;\n\n // Update worst distance if needed.\n float dist = distances[best_i*count + best_j];\n hnsw_update_worst_neighbor_on_add(index,nodes[best_i],layer,link_idx,dist);\n\n // Link j -> i.\n link_idx = nodes[best_j]->layers[layer].num_links;\n nodes[best_j]->layers[layer].links[link_idx] = nodes[best_i];\n nodes[best_j]->layers[layer].num_links++;\n\n // Update worst distance if needed.\n hnsw_update_worst_neighbor_on_add(index,nodes[best_j],layer,link_idx,dist);\n\n // Mark connection as used.\n used[best_i] = used[best_j] = 1;\n } else {\n break; // No more valid connections available.\n }\n }\n\n /* Step 6: Handle remaining unpaired nodes using the standard HNSW\n * neighbor selection. */\n for (int i = 0; i < count; i++) {\n if (used[i]) continue;\n\n // Skip if node is already at max connections.\n if (nodes[i]->layers[layer].num_links >=\n nodes[i]->layers[layer].max_links)\n continue;\n\n debugmsg(\"[%d] Force linking %d\\n\", layer, i);\n\n /* First, try with local nodes as candidates.\n * Some candidate may have space. */\n pqueue *candidates = pq_new(count);\n if (!candidates) continue;\n\n /* Add all the local nodes having some space as candidates\n * to be linked with this node. */\n for (int j = 0; j < count; j++) {\n if (i != j && // Must not be itself.\n nodes[j]->layers[layer].num_links < // Must not be full.\n nodes[j]->layers[layer].max_links)\n {\n float dist = distances[i*count + j];\n pq_push(candidates, nodes[j], dist);\n }\n }\n\n /* Try local candidates first with aggressive = 1.\n * So we will link only if there is space.\n * We want one link more than the links we already have. */\n uint32_t wanted_links = nodes[i]->layers[layer].num_links+1;\n if (candidates->count > 0) {\n select_neighbors(index, candidates, nodes[i], layer,\n wanted_links, 1);\n debugmsg(\"Final links after attempt with local nodes: %d (wanted: %d)\\n\", (int)nodes[i]->layers[layer].num_links, wanted_links);\n }\n\n // If still no connection, search the broader graph.\n if (nodes[i]->layers[layer].num_links != wanted_links) {\n debugmsg(\"No force linking possible with local candidates\\n\");\n pq_free(candidates);\n\n // Find entry point for target layer by descending through levels.\n hnswNode *curr_ep = index->enter_point;\n for (uint32_t lc = index->max_level; lc > layer; lc--) {\n pqueue *results = search_layer(index, nodes[i], curr_ep, 1, lc, 0);\n if (results) {\n if (results->count > 0) {\n curr_ep = pq_get_node(results,0);\n }\n pq_free(results);\n }\n }\n\n if (curr_ep) {\n /* Search this layer for candidates.\n * Use the default EF_C in this case, since it's not an\n * \"insert\" operation, and we don't know the user\n * specified \"EF\". */\n candidates = search_layer(index, nodes[i], curr_ep, HNSW_EF_C, layer, 0);\n if (candidates) {\n /* Try to connect with aggressiveness proportional to the\n * node linking condition. */\n int aggressiveness =\n (nodes[i]->layers[layer].num_links > index->M / 2)\n ? 1 : 2;\n select_neighbors(index, candidates, nodes[i], layer,\n wanted_links, aggressiveness);\n debugmsg(\"Final links with broader search: %d (wanted: %d)\\n\", (int)nodes[i]->layers[layer].num_links, wanted_links);\n pq_free(candidates);\n }\n }\n } else {\n pq_free(candidates);\n }\n }\n\n // Cleanup.\n hfree(distances);\n hfree(row_avgs);\n hfree(scores);\n hfree(used);\n}\n\n/* This is an helper function in order to support node deletion.\n * It's goal is just to:\n *\n * 1. Remove the node from the bidirectional links of neighbors in the graph.\n * 2. Remove the node from the linked list of nodes.\n * 3. Fix the entry point in the graph. We just select one of the neighbors\n * of the deleted node at a lower level. If none is found, we do\n * a full scan.\n * 4. The node itself amd its aux value field are NOT freed. It's up to the\n * caller to do it, by using hnsw_node_free().\n * 5. The node associated value (node->value) is NOT freed.\n *\n * Why this function will not free the node? Because in node updates it\n * could be a good idea to reuse the node allocation for different reasons\n * (currently not implemented).\n * In general it is more future-proof to be able to reuse the node if\n * needed. Right now this library reuses the node only when links are\n * not touched (see hnsw_update() for more information). */\nvoid hnsw_unlink_node(HNSW *index, hnswNode *node) {\n if (!index || !node) return;\n\n index->version++; // This node may be missing in an already compiled list\n // of neighbors. Make optimistic concurrent inserts fail.\n\n /* Remove all bidirectional links at each level.\n * Note that in this implementation all the\n * links are guaranteed to be bedirectional. */\n\n /* For each level of the deleted node... */\n for (uint32_t level = 0; level <= node->level; level++) {\n /* For each linked node of the deleted node... */\n for (uint32_t i = 0; i < node->layers[level].num_links; i++) {\n hnswNode *linked = node->layers[level].links[i];\n /* Find and remove the backlink in the linked node */\n for (uint32_t j = 0; j < linked->layers[level].num_links; j++) {\n if (linked->layers[level].links[j] == node) {\n /* Remove by shifting remaining links left */\n memmove(&linked->layers[level].links[j],\n &linked->layers[level].links[j + 1],\n (linked->layers[level].num_links - j - 1) * sizeof(hnswNode*));\n linked->layers[level].num_links--;\n hnsw_update_worst_neighbor_on_remove(index,linked,level,j);\n break;\n }\n }\n }\n }\n\n /* Update cursors pointing at this element. */\n if (index->cursors) hnsw_cursor_element_deleted(index,node);\n\n /* Update the previous node's next pointer. */\n if (node->prev) {\n node->prev->next = node->next;\n } else {\n /* If there's no previous node, this is the head. */\n index->head = node->next;\n }\n\n /* Update the next node's prev pointer. */\n if (node->next) node->next->prev = node->prev;\n\n /* Update node count. */\n index->node_count--;\n\n /* If this node was the enter_point, we need to update it. */\n if (node == index->enter_point) {\n /* Reset entry point - we'll find a new one (unless the HNSW is\n * now empty) */\n index->enter_point = NULL;\n index->max_level = 0;\n\n /* Step 1: Try to find a replacement by scanning levels\n * from top to bottom. Under normal conditions, if there is\n * any other node at the same level, we have a link. Anyway\n * we descend levels to find any neighbor at the higher level\n * possible. */\n for (int level = node->level; level >= 0; level--) {\n if (node->layers[level].num_links > 0) {\n index->enter_point = node->layers[level].links[0];\n break;\n }\n }\n\n /* Step 2: If no links were found at any level, do a full scan.\n * This should never happen in practice if the HNSW is not\n * empty. */\n if (!index->enter_point) {\n uint32_t new_max_level = 0;\n hnswNode *current = index->head;\n\n while (current) {\n if (current != node && current->level >= new_max_level) {\n new_max_level = current->level;\n index->enter_point = current;\n }\n current = current->next;\n }\n }\n\n /* Update max_level. */\n if (index->enter_point)\n index->max_level = index->enter_point->level;\n }\n\n /* Clear the node's links but don't free the node itself */\n node->prev = node->next = NULL;\n}\n\n/* Higher level API for hnsw_unlink_node() + hnsw_reconnect_nodes() actual work.\n * This will get the write lock, will delete the node, free it,\n * reconnect the node neighbors among themselves, and unlock again.\n * If free_value function pointer is not NULL, then the function provided is\n * used to free node->value.\n *\n * The function returns 0 on error (inability to acquire the lock), otherwise\n * 1 is returned. */\nint hnsw_delete_node(HNSW *index, hnswNode *node, void(*free_value)(void*value)) {\n if (pthread_rwlock_wrlock(&index->global_lock) != 0) return 0;\n hnsw_unlink_node(index,node);\n if (free_value && node->value) free_value(node->value);\n\n /* Relink all the nodes orphaned of this node link.\n * Do it for all the levels. */\n for (unsigned int j = 0; j <= node->level; j++) {\n hnsw_reconnect_nodes(index, node->layers[j].links,\n node->layers[j].num_links, j);\n }\n hnsw_node_free(node);\n pthread_rwlock_unlock(&index->global_lock);\n return 1;\n}\n\n/* ============================ Threaded API ================================\n * Concurrent readers should use the following API to get a slot assigned\n * (and a lock, too), do their read-only call, and unlock the slot.\n *\n * There is a reason why read operations don't implement opaque transparent\n * locking directly on behalf of the user: when we return a result set\n * with hnsw_search(), we report a set of nodes. The caller will do something\n * with the nodes and the associated values, so the unlocking of the\n * slot should happen AFTER the result was already used, otherwise we may\n * have changes to the HNSW nodes as the result is being accessed. */\n\n/* Try to acquire a read slot. Returns the slot number (0 to HNSW_MAX_THREADS-1)\n * on success, -1 on error (pthread mutex errors). */\nint hnsw_acquire_read_slot(HNSW *index) {\n /* First try a non-blocking approach on all slots. */\n for (uint32_t i = 0; i < HNSW_MAX_THREADS; i++) {\n if (pthread_mutex_trylock(&index->slot_locks[i]) == 0) {\n if (pthread_rwlock_rdlock(&index->global_lock) != 0) {\n pthread_mutex_unlock(&index->slot_locks[i]);\n return -1;\n }\n return i;\n }\n }\n\n /* All trylock attempts failed, use atomic increment to select slot. */\n uint32_t slot = index->next_slot++ % HNSW_MAX_THREADS;\n\n /* Try to lock the selected slot. */\n if (pthread_mutex_lock(&index->slot_locks[slot]) != 0) return -1;\n\n /* Get read lock. */\n if (pthread_rwlock_rdlock(&index->global_lock) != 0) {\n pthread_mutex_unlock(&index->slot_locks[slot]);\n return -1;\n }\n\n return slot;\n}\n\n/* Release a previously acquired read slot: note that it is important that\n * nodes returned by hnsw_search() are accessed while the read lock is\n * still active, to be sure that nodes are not freed. */\nvoid hnsw_release_read_slot(HNSW *index, int slot) {\n if (slot < 0 || slot >= HNSW_MAX_THREADS) return;\n pthread_rwlock_unlock(&index->global_lock);\n pthread_mutex_unlock(&index->slot_locks[slot]);\n}\n\n/* ============================ Nodes insertion =============================\n * We have an optimistic API separating the read-only candidates search\n * and the write side (actual node insertion). We internally also use\n * this API to provide the plain hnsw_insert() function for code unification. */\n\nstruct InsertContext {\n pqueue *level_queues[HNSW_MAX_LEVEL]; /* Candidates for each level. */\n hnswNode *node; /* Pre-allocated node ready for insertion */\n uint64_t version; /* Index version at preparation time. This is used\n * for CAS-like locking during change commit. */\n};\n\n/* Optimistic insertion API.\n *\n * WARNING: Note that this is an internal function: users should call\n * hnsw_prepare_insert() instead.\n *\n * This is how it works: you use hnsw_prepare_insert() and it will return\n * a context where good candidate neighbors are already pre-selected.\n * This step only uses read locks.\n *\n * Then finally you try to actually commit the new node with\n * hnsw_try_commit_insert(): this time we will require a write lock, but\n * for less time than it would be otherwise needed if using directly\n * hnsw_insert(). When you try to commit the write, if no node was deleted in\n * the meantime, your operation will succeed, otherwise it will fail, and\n * you should try to just use the hnsw_insert() API, since there is\n * contention.\n *\n * See hnsw_node_new() for information about 'vector' and 'qvector'\n * arguments, and which one to pass. */\nInsertContext *hnsw_prepare_insert_nolock(HNSW *index, const float *vector,\n const int8_t *qvector, float qrange, uint64_t id,\n int slot, int ef)\n{\n InsertContext *ctx = hmalloc(sizeof(*ctx));\n if (!ctx) return NULL;\n\n memset(ctx, 0, sizeof(*ctx));\n ctx->version = index->version;\n\n /* Crete a new node that we may be able to insert into the\n * graph later, when calling the commit function. */\n uint32_t level = random_level();\n ctx->node = hnsw_node_new(index, id, vector, qvector, qrange, level, 1);\n if (!ctx->node) {\n hfree(ctx);\n return NULL;\n }\n\n hnswNode *curr_ep = index->enter_point;\n\n /* Empty graph, no need to collect candidates. */\n if (curr_ep == NULL) return ctx;\n\n /* Phase 1: Find good entry point on the highest level of the new\n * node we are going to insert. */\n for (unsigned int lc = index->max_level; lc > level; lc--) {\n pqueue *results = search_layer(index, ctx->node, curr_ep, 1, lc, slot);\n\n if (results) {\n if (results->count > 0) curr_ep = pq_get_node(results,0);\n pq_free(results);\n }\n }\n\n /* Phase 2: Collect a set of potential connections for each layer of\n * the new node. */\n for (int lc = MIN(level, index->max_level); lc >= 0; lc--) {\n pqueue *candidates =\n search_layer(index, ctx->node, curr_ep, ef, lc, slot);\n\n if (!candidates) continue;\n curr_ep = (candidates->count > 0) ? pq_get_node(candidates,0) : curr_ep;\n ctx->level_queues[lc] = candidates;\n }\n\n return ctx;\n}\n\n/* External API for hnsw_prepare_insert_nolock(), handling locking. */\nInsertContext *hnsw_prepare_insert(HNSW *index, const float *vector,\n const int8_t *qvector, float qrange, uint64_t id,\n int ef)\n{\n InsertContext *ctx;\n int slot = hnsw_acquire_read_slot(index);\n ctx = hnsw_prepare_insert_nolock(index,vector,qvector,qrange,id,slot,ef);\n hnsw_release_read_slot(index,slot);\n return ctx;\n}\n\n/* Free an insert context and all its resources. */\nvoid hnsw_free_insert_context(InsertContext *ctx) {\n if (!ctx) return;\n for (uint32_t i = 0; i < HNSW_MAX_LEVEL; i++) {\n if (ctx->level_queues[i]) pq_free(ctx->level_queues[i]);\n }\n if (ctx->node) hnsw_node_free(ctx->node);\n hfree(ctx);\n}\n\n/* Commit a prepared insert operation. This function is a low level API that\n * should not be called by the user. See instead hnsw_try_commit_insert(), that\n * will perform the CAS check and acquire the write lock.\n *\n * See the top comment in hnsw_prepare_insert() for more information\n * on the optimistic insertion API.\n *\n * This function can't fail and always returns the pointer to the\n * just inserted node. Out of memory is not possible since no critical\n * allocation is never performed in this code path: we populate links\n * on already allocated nodes. */\nhnswNode *hnsw_commit_insert_nolock(HNSW *index, InsertContext *ctx, void *value) {\n hnswNode *node = ctx->node;\n node->value = value;\n\n /* Handle first node case. */\n if (index->enter_point == NULL) {\n index->version++; // First node, make concurrent inserts fail.\n index->enter_point = node;\n index->max_level = node->level;\n hnsw_add_node(index, node);\n ctx->node = NULL; // So hnsw_free_insert_context() will not free it.\n hnsw_free_insert_context(ctx);\n return node;\n }\n\n /* Connect the node with near neighbors at each level. */\n for (int lc = MIN(node->level,index->max_level); lc >= 0; lc--) {\n if (ctx->level_queues[lc] == NULL) continue;\n\n /* Try to provide index->M connections to our node. The call\n * is not guaranteed to be able to provide all the links we would\n * like to have for the new node: they must be bi-directional, obey\n * certain quality checks, and so forth, so later there are further\n * calls to force the hand a bit if needed.\n *\n * Let's start with aggressiveness = 0. */\n select_neighbors(index, ctx->level_queues[lc], node, lc, index->M, 0);\n\n /* Layer 0 and too few connections? Let's be more aggressive. */\n if (lc == 0 && node->layers[0].num_links < index->M/2) {\n select_neighbors(index, ctx->level_queues[lc], node, lc,\n index->M, 1);\n\n /* Still too few connections? Let's go to\n * aggressiveness level '2' in linking strategy. */\n if (node->layers[0].num_links < index->M/4) {\n select_neighbors(index, ctx->level_queues[lc], node, lc,\n index->M/4, 2);\n }\n }\n }\n\n /* If new node level is higher than current max, update entry point. */\n if (node->level > index->max_level) {\n index->version++; // Entry point changed, make concurrent inserts fail.\n index->enter_point = node;\n index->max_level = node->level;\n }\n\n /* Add node to the linked list. */\n hnsw_add_node(index, node);\n ctx->node = NULL; // So hnsw_free_insert_context() will not free the node.\n hnsw_free_insert_context(ctx);\n return node;\n}\n\n/* If the context obtained with hnsw_prepare_insert() is still valid\n * (nodes not deleted in the meantime) then add the new node to the HNSW\n * index and return its pointer. Otherwise NULL is returned and the operation\n * should be either performed with the blocking API hnsw_insert() or attempted\n * again. */\nhnswNode *hnsw_try_commit_insert(HNSW *index, InsertContext *ctx, void *value) {\n /* Check if the version changed since preparation. Note that we\n * should access index->version under the write lock in order to\n * be sure we can safely commit the write: this is just a fast-path\n * in order to return ASAP without acquiring the write lock in case\n * the version changed. */\n if (ctx->version != index->version) {\n hnsw_free_insert_context(ctx);\n return NULL;\n }\n\n /* Try to acquire write lock. */\n if (pthread_rwlock_wrlock(&index->global_lock) != 0) {\n hnsw_free_insert_context(ctx);\n return NULL;\n }\n\n /* Check version again under write lock. */\n if (ctx->version != index->version) {\n pthread_rwlock_unlock(&index->global_lock);\n hnsw_free_insert_context(ctx);\n return NULL;\n }\n\n /* Commit the change: note that it's up to hnsw_commit_insert_nolock()\n * to free the insertion context. */\n hnswNode *node = hnsw_commit_insert_nolock(index, ctx, value);\n\n /* Release the write lock. */\n pthread_rwlock_unlock(&index->global_lock);\n return node;\n}\n\n/* Insert a new element into the graph.\n * See hnsw_node_new() for information about 'vector' and 'qvector'\n * arguments, and which one to pass.\n *\n * Return NULL on out of memory during insert. Otherwise the newly\n * inserted node pointer is returned. */\nhnswNode *hnsw_insert(HNSW *index, const float *vector, const int8_t *qvector, float qrange, uint64_t id, void *value, int ef) {\n /* Write lock. We acquire the write lock even for the prepare()\n * operation (that is a read-only operation) since we want this function\n * to don't fail in the check-and-set stage of commit().\n *\n * Basically here we are using the optimistic API in a non-optimistinc\n * way in order to have a single insertion code in the implementation. */\n if (pthread_rwlock_wrlock(&index->global_lock) != 0) return NULL;\n\n // Prepare the insertion - note we pass slot 0 since we're single threaded.\n InsertContext *ctx = hnsw_prepare_insert_nolock(index, vector, qvector,\n qrange, id, 0, ef);\n if (!ctx) {\n pthread_rwlock_unlock(&index->global_lock);\n return NULL;\n }\n\n // Commit the prepared insertion without version checking.\n hnswNode *node = hnsw_commit_insert_nolock(index, ctx, value);\n\n // Release write lock and return our node pointer.\n pthread_rwlock_unlock(&index->global_lock);\n return node;\n}\n\n/* Helper function for qsort call in hnsw_should_reuse_node(). */\nstatic int compare_floats(const float *a, const float *b) {\n if (*a < *b) return 1;\n if (*a > *b) return -1;\n return 0;\n}\n\n/* This function determines if a node can be reused with a new vector by:\n *\n * 1. Computing average of worst 25% of current distances.\n * 2. Checking if at least 50% of new distances stay below this threshold.\n * 3. Requiring a minimum number of links for the check to be meaningful.\n *\n * This check is useful when we want to just update a node that already\n * exists in the graph. Often the new vector is a learned embedding generated\n * by some model, and the embedding represents some document that perhaps\n * changed just slightly compared to the past, so the new embedding will\n * be very nearby. We need to find a way do determine if the current node\n * neighbors (practically speaking its location in the grapb) are good\n * enough even with the new vector.\n *\n * XXX: this function needs improvements: successive updates to the same\n * node with more and more distant vectors will make the node drift away\n * from its neighbors. One of the additional metrics used could be\n * neighbor-to-neighbor distance, that represents a more absolute check\n * of fit for the new vector. */\nint hnsw_should_reuse_node(HNSW *index, hnswNode *node, int is_normalized, const float *new_vector) {\n /* Step 1: Not enough links? Advice to avoid reuse. */\n const uint32_t min_links_for_reuse = 4;\n uint32_t layer0_connections = node->layers[0].num_links;\n if (layer0_connections < min_links_for_reuse) return 0;\n\n /* Step2: get all current distances and run our heuristic. */\n float *old_distances = hmalloc(sizeof(float) * layer0_connections);\n if (!old_distances) return 0;\n\n // Temporary node with the new vector, to simplify the next logic.\n hnswNode tmp_node;\n if (hnsw_init_tmp_node(index,&tmp_node,is_normalized,new_vector) == 0) {\n hfree(old_distances);\n return 0;\n }\n\n /* Get old dinstances and sort them to access the 25% worst\n * (bigger) ones. */\n for (uint32_t i = 0; i < layer0_connections; i++) {\n old_distances[i] = hnsw_distance(index, node, node->layers[0].links[i]);\n }\n qsort(old_distances, layer0_connections, sizeof(float),\n (int (*)(const void*, const void*))(&compare_floats));\n\n uint32_t count = (layer0_connections+3)/4; // 25% approx to larger int.\n if (count > layer0_connections) count = layer0_connections; // Futureproof.\n float worst_avg = 0;\n\n // Compute average of 25% worst dinstances.\n for (uint32_t i = 0; i < count; i++) worst_avg += old_distances[i];\n worst_avg /= count;\n hfree(old_distances);\n\n // Count how many new distances stay below the threshold.\n uint32_t good_distances = 0;\n for (uint32_t i = 0; i < layer0_connections; i++) {\n float new_dist = hnsw_distance(index, &tmp_node, node->layers[0].links[i]);\n if (new_dist <= worst_avg) good_distances++;\n }\n hnsw_free_tmp_node(&tmp_node,new_vector);\n\n /* At least 50% of the nodes should pass our quality test, for the\n * node to be reused. */\n return good_distances >= layer0_connections/2;\n}\n\n/**\n * Return a random node from the HNSW graph.\n *\n * This function performs a random walk starting from the entry point,\n * using only level 0 connections for navigation. It uses log^2(N) steps\n * to ensure proper mixing time.\n */\n\nhnswNode *hnsw_random_node(HNSW *index, int slot) {\n if (index->node_count == 0 || index->enter_point == NULL)\n return NULL;\n\n (void)slot; // Unused, but we need the caller to acquire the lock.\n\n /* First phase: descend from max level to level 0 taking random paths.\n * Note that we don't need a more conservative log^2(N) steps for\n * proper mixing, since we already descend to a random cluster here. */\n hnswNode *current = index->enter_point;\n for (uint32_t level = index->max_level; level > 0; level--) {\n /* If current node doesn't have this level or no links, continue\n\t * to lower level. */\n if (current->level < level || current->layers[level].num_links == 0)\n continue;\n\n /* Choose random neighbor at this level. */\n uint32_t rand_neighbor = rand() % current->layers[level].num_links;\n current = current->layers[level].links[rand_neighbor];\n }\n\n /* Second phase: at level 0, take log(N) * c random steps. */\n const int c = 3; // Multiplier for more thorough exploration.\n double logN = log2(index->node_count + 1);\n uint32_t num_walks = (uint32_t)(logN * c);\n\n /* Avoid the ping-pong effect: imagine there are just two nodes and\n * the number of walks selected is even. We will select always the\n * first element of the graph; conversely, if it is odd, we will always\n * select the other element. One way to add more selection randomness is\n * to randomly add '1' or '0' to the number of walks to perform. */\n num_walks += rand() & 1;\n\n // Perform random walk at level 0.\n for (uint32_t i = 0; i < num_walks; i++) {\n if (current->layers[0].num_links == 0) return current;\n\n // Choose random neighbor.\n uint32_t rand_neighbor = rand() % current->layers[0].num_links;\n current = current->layers[0].links[rand_neighbor];\n }\n return current;\n}\n\n/* ============================= Serialization ==============================\n *\n * TO SERIALIZE\n * ============\n *\n * To serialize on disk, you need to persist the vector dimension, number\n * of elements, and the quantization type index->quant_type. These are\n * global values for the whole index.\n *\n * Then, to serialize each node:\n *\n * call hnsw_serialize_node() with each node you find in the linked list\n * of nodes, starting at index->head (each node has a next pointer).\n * The function will return an hnswSerNode structure, you will need\n * to store the following on disk (for each node):\n *\n * - The sernode->vector data, that is sernode->vector_size bytes.\n * - The sernode->params array, that points to an array of uint64_t\n * integers. There are sernode->params_count total items. These\n * parameters contain everything there is to need about your node: how\n * many levels it has, its ID, the list of neighbors for each level (as node\n * IDs), and so forth.\n *\n * You need to to save your own node->value in some way as well, but it already\n * belongs to the user of the API, since, for this library, it's just a pointer,\n * so the user should know how to serialized its private data.\n *\n * RELOADING FROM DISK / NET\n * =========================\n *\n * When reloading nodes, you first load the index vector dimension and\n * quantization type, and create the index with:\n *\n * HNSW *hnsw_new(uint32_t vector_dim, uint32_t quant_type);\n *\n * Then you load back, for each node (you stored how many nodes you had)\n * the vector and the params array / count.\n * You also load the value associated with your node.\n *\n * At this point you add back the loaded elements into the index with:\n *\n * hnsw_insert_serialized(HNSW *index, void *vector, uint64_t params,\n * uint32_t params_len, void *value);\n *\n * Once you added all the nodes back, you need to resolve the pointers\n * (since so far they are added just with the node IDs as reference), so\n * you call:\n *\n * hnsw_deserialize_index(index);\n *\n * The index is now ready to be used like if it has been always in memory.\n *\n * DESIGN NOTES\n * ============\n *\n * Why this API does not just give you a binary blob to save? Because in\n * many systems (and in Redis itself) to save integers / floats can have\n * more interesting encodings that just storing a 64 bit value. Many vector\n * indexes will be small, and their IDs will be small numbers, so the storage\n * system can exploit that and use less disk space, less network bandwidth\n * and so forth.\n *\n * How is the data stored in these arrays of numbers? Oh well, we have\n * things that are obviously numbers like node ID, number of levels for the\n * node and so forth. Also each of our nodes have an unique incremental ID,\n * so we can store a node set of links in terms of linked node IDs. This\n * data is put directly in the loaded node pointer space! We just cast the\n * integer to the pointer (so THIS IS NOT SAFE for 32 bit systems). Then\n * we want to translate such IDs into pointers. To do that, we build an\n * hash table, then scan all the nodes again and fix all the links converting\n * the ID to the pointer. */\n\n/* History of serialization versions:\n * version 0: the first implementation, lacking worst node id/info.\n * version 1: includes worst link id/info. */\n#define HNSW_SERIALIZATION_VERSION 1\n\n/* This is a special worst link index that is set when loading a serialized\n * node with version 0 (this version of the serialization lacked explicit\n * information about the worst link index/distance). This way, later, the\n * function that fixes a deserialized index will know to compute the worst\n * index info at runtime. */\n#define HNSW_SER_WORSTLINK_MISSING UINT32_MAX\n\n/* Return the serialized node information as specified in the top comment\n * above. Note that the returned information is true as long as the node\n * provided is not deleted or modified, so this function should be called\n * when there are no concurrent writes.\n *\n * The function hnsw_serialize_node() should be called in order to\n * free the result of this function. */\nhnswSerNode *hnsw_serialize_node(HNSW *index, hnswNode *node) {\n /* The first step is calculating the number of uint64_t parameters\n * that we need in order to serialize the node. */\n uint32_t num_params = 0;\n num_params += 2; // node ID, number of layers.\n for (uint32_t i = 0; i <= node->level; i++) {\n num_params += 2; // max_links and num_links info for this layer.\n num_params += node->layers[i].num_links; // The IDs of linked nodes.\n num_params += 1; // worst link id/distance parameter.\n }\n\n /* We use another 64bit value to store two floats that are about\n * the vector: l2 and quantization range (that is only used if the\n * vector is quantized). */\n num_params++;\n\n /* Allocate the return object and the parameters array. */\n hnswSerNode *sn = hmalloc(sizeof(hnswSerNode));\n if (sn == NULL) return NULL;\n sn->params = hmalloc(sizeof(uint64_t)*num_params);\n if (sn->params == NULL) {\n hfree(sn);\n return NULL;\n }\n\n /* Fill data. */\n sn->params_count = num_params;\n sn->vector = node->vector;\n sn->vector_size = hnsw_quants_bytes(index);\n\n uint32_t param_idx = 0;\n sn->params[param_idx++] = node->id;\n /* The second parameter contains information about the serialization\n * version of this node, the node level and some unused field:\n *\n * +--------+--------+--------+--------+\n * |VVVVVVVV|........|........|LLLLLLLL|\n * +--------+--------+--------+--------+\n *\n * V is the version, 8 bits.\n * L is the node level, 8 bits (but actually 16 is the max so far).\n * The middle two bytes are reserved for future uses. */\n sn->params[param_idx] = node->level & 0xff;\n sn->params[param_idx] |= HNSW_SERIALIZATION_VERSION << 24;\n param_idx++;\n for (uint32_t i = 0; i <= node->level; i++) {\n sn->params[param_idx++] = node->layers[i].num_links;\n sn->params[param_idx++] = node->layers[i].max_links;\n for (uint32_t j = 0; j < node->layers[i].num_links; j++) {\n sn->params[param_idx++] = node->layers[i].links[j]->id;\n }\n /* Since version 1: pack and store worst_idx and worst_distance. */\n uint32_t worst_distance_bits;\n memcpy(&worst_distance_bits, &node->layers[i].worst_distance,\n sizeof(float));\n uint64_t wi =\n (((uint64_t)worst_distance_bits) << 32) | node->layers[i].worst_idx;\n sn->params[param_idx++] = wi;\n }\n\n /* Store l2 and range as uint32_t, in a way that is endian-safe.\n * Note that in big endian archs both are reversed: integers and\n * also the bytes of floats, so they will match. */\n uint64_t l2_and_range;\n uint32_t l2_bits, range_bits;\n memcpy(&l2_bits,&node->l2,sizeof(float));\n memcpy(&range_bits,&node->quants_range,sizeof(float));\n l2_and_range = ((uint64_t)range_bits<<32) | l2_bits;\n\n sn->params[param_idx++] = l2_and_range;\n\n /* Better safe than sorry: */\n assert(param_idx == num_params);\n return sn;\n}\n\n/* This is needed in order to free hnsw_serialize_node() returned\n * structure. */\nvoid hnsw_free_serialized_node(hnswSerNode *sn) {\n hfree(sn->params);\n hfree(sn);\n}\n\n/* Load a serialized node. See the top comment in this section of code\n * for the documentation about how to use this.\n *\n * The function returns NULL both on out of memory and if the remaining\n * parameters length does not match the number of links or other items\n * to load. */\nhnswNode *hnsw_insert_serialized(HNSW *index, void *vector, uint64_t *params, uint32_t params_len, void *value)\n{\n if (params_len < 2) return NULL;\n\n uint64_t id = params[0];\n /* Check the node serialization function for the specific layout\n * of param[1] fields. */\n uint32_t level = params[1] & 0xff; // Node level.\n uint32_t version = (params[1] & 0xff000000) >> 24; // Format version.\n\n if (version > HNSW_SERIALIZATION_VERSION) return NULL;\n int has_worst_link_info = version > 0;\n\n /* Keep track of maximum ID seen while loading. */\n if (id >= index->last_id) index->last_id = id;\n\n /* Create node, passing vector data directly based on quantization type. */\n hnswNode *node;\n if (index->quant_type != HNSW_QUANT_NONE) {\n node = hnsw_node_new(index, id, NULL, vector, 0, level, 0);\n } else {\n node = hnsw_node_new(index, id, vector, NULL, 0, level, 0);\n }\n if (!node) return NULL;\n\n /* Load params array into the node. */\n uint32_t param_idx = 2;\n for (uint32_t i = 0; i <= level; i++) {\n /* Sanity check. */\n if (param_idx + 2 + has_worst_link_info > params_len) {\n hnsw_node_free(node);\n return NULL;\n }\n\n uint32_t num_links = params[param_idx++];\n uint32_t max_links = params[param_idx++];\n\n /* Sanity check: links should be less than max links and\n * in general a reasonable amount. */\n if (num_links > max_links || max_links > HNSW_MAX_M*4) {\n hnsw_node_free(node);\n return NULL;\n }\n\n /* If max_links is larger than current allocation, reallocate.\n * It could happen in select_neighbors() that we over-allocate the\n * node under very unlikely to happen conditions. */\n if (max_links > node->layers[i].max_links) {\n hnswNode **new_links = hrealloc(node->layers[i].links, \n sizeof(hnswNode*) * max_links);\n if (!new_links) {\n hnsw_node_free(node);\n return NULL;\n }\n node->layers[i].links = new_links;\n node->layers[i].max_links = max_links;\n }\n node->layers[i].num_links = num_links;\n\n /* Sanity check. */\n if (param_idx + num_links + has_worst_link_info > params_len) {\n hnsw_node_free(node);\n return NULL;\n }\n\n /* Fill links for this layer with the IDs. Note that this\n * is going to not work in 32 bit systems. Deleting / adding-back\n * nodes can produce IDs larger than 2^32-1 even if we can't never\n * fit more than 2^32 nodes in a 32 bit system. */\n for (uint32_t j = 0; j < num_links; j++)\n node->layers[i].links[j] = (hnswNode*)params[param_idx++];\n\n if (has_worst_link_info) {\n uint64_t wi = params[param_idx++];\n uint32_t worst_idx = wi & 0xffffffff;\n uint32_t worst_distance_bits = wi >> 32;\n float worst_distance;\n memcpy(&worst_distance,&worst_distance_bits,sizeof(float));\n node->layers[i].worst_idx = worst_idx;\n node->layers[i].worst_distance = worst_distance;\n\n // Sanity check the worst ID range.\n if (node->layers[i].num_links > 0 &&\n node->layers[i].worst_idx >= node->layers[i].num_links)\n {\n hnsw_node_free(node);\n return NULL;\n }\n } else {\n node->layers[i].worst_idx = HNSW_SER_WORSTLINK_MISSING;\n node->layers[i].worst_distance = 0;\n }\n }\n\n /* Get l2 and quantization range. */\n if (param_idx >= params_len) {\n hnsw_node_free(node);\n return NULL;\n }\n\n /* Load l2 and range packed into an uint64_t in an endian safe way. */\n uint64_t l2_and_range = params[param_idx];\n uint32_t l2_bits, range_bits;\n l2_bits = l2_and_range & 0xffffffff;\n range_bits = l2_and_range >> 32;\n memcpy(&node->l2, &l2_bits, sizeof(float));\n memcpy(&node->quants_range, &range_bits, sizeof(float));\n\n node->value = value;\n hnsw_add_node(index, node);\n\n /* Keep track of higher node level and set the entry point to the\n * greatest level node seen so far: thanks to this check we don't\n * need to remember what our entry point was during serialization. */\n if (index->enter_point == NULL || level > index->max_level) {\n index->max_level = level;\n index->enter_point = node;\n }\n return node;\n}\n\n/* Integer hashing, used by hnsw_deserialize_index().\n * MurmurHash3's 64-bit finalizer function. */\nuint64_t hnsw_hash_node_id(uint64_t id) {\n id ^= id >> 33;\n id *= 0xff51afd7ed558ccd;\n id ^= id >> 33;\n id *= 0xc4ceb9fe1a85ec53;\n id ^= id >> 33;\n return id;\n}\n\n/* Helper for duplicated link detection in hnsw_deserialize_index(). */\nstatic int qsort_compare_pointers(const void *aptr, const void *bptr) {\n uintptr_t a = *((uintptr_t*)aptr);\n uintptr_t b = *((uintptr_t*)bptr);\n if (a > b) return 1;\n if (a < b) return -1;\n return 0;\n}\n\n/* Fix pointers of neighbors nodes: after loading the serialized nodes, the\n * neighbors links are just IDs (casted to pointers), instead of the actual\n * pointers. We need to resolve IDs into pointers.\n *\n * The two integers salt0 and salt1 are used to make the internal state\n * of the function unguessable to an external attacker, in order to protect\n * from corruptions. Show be two random numbers from /dev/urandom if possible\n * otherwise can be just 0,0 if the application is not security critical and\n * never processes untrusted inputs.\n *\n * Return 0 on error (out of memory or some ID that can't be resolved), 1 on\n * success. */\nint hnsw_deserialize_index(HNSW *index, uint64_t salt0, uint64_t salt1) {\n /* We will use simple linear probing, so over-allocating is a good\n * idea: anyway this flat array of pointers will consume a fraction\n * of the memory of the loaded index. */\n uint64_t min_size = index->node_count*2;\n uint64_t table_size = 1;\n while(table_size < min_size) table_size <<= 1;\n\n hnswNode **table = hmalloc(sizeof(hnswNode*) * table_size);\n if (table == NULL) return 0;\n memset(table,0,sizeof(hnswNode*) * table_size);\n\n /* First pass: populate the ID -> pointer hash table. */\n hnswNode *node = index->head;\n while(node) {\n uint64_t bucket = hnsw_hash_node_id(node->id) & (table_size-1);\n for (uint64_t j = 0; j < table_size; j++) {\n if (table[bucket] == NULL) {\n table[bucket] = node;\n break;\n }\n bucket = (bucket+1) & (table_size-1);\n }\n node = node->next;\n }\n\n /* Second pass: fix pointers of all the neighbors links.\n * As we scan and fix the links, we also compute the accumulator\n * register \"reciprocal\", that is used in order to guarantee that all\n * the links are reciprocal.\n *\n * This is how it works, we hash (using a strong hash function) the\n * following key for each link that we see from A to B (or vice versa):\n *\n * hash(salt || A || B || link-level)\n *\n * We always sort A and B, so the same link from A to B and from B to A\n * will hash the same. The we xor the result into the 128 bit accumulator.\n * If each link has its own backlink, the accumulator is guaranteed to\n * be zero at the end.\n *\n * Collisions are extremely unlikely to happen, and an external attacker\n * can't easily control the hash function output, since the salt is\n * unknown, and also there would be to control the pointers.\n *\n * This algorithm is O(1) for each node so it is basically free for\n * us, as we scan the list of nodes, and runs on constant and very\n * small memory. */\n uint64_t accumulator[2] = {0,0};\n\n node = index->head; // Rewind.\n while(node) {\n uint64_t this_node_id = node->id;\n for (uint32_t i = 0; i <= node->level; i++) {\n // Check if there are duplicated links: those are\n // also corruptions of the on-disk serialization format.\n if (node->layers[i].num_links > 0) {\n qsort(node->layers[i].links, node->layers[i].num_links,\n sizeof(void*), qsort_compare_pointers);\n for (uint32_t j = 0; j < node->layers[i].num_links-1; j++) {\n if (node->layers[i].links[j] == node->layers[i].links[j+1])\n goto corrupted;\n }\n }\n\n // Resolve pointers.\n for (uint32_t j = 0; j < node->layers[i].num_links; j++) {\n uint64_t linked_id = (uint64_t) node->layers[i].links[j];\n\n // We can't link to our own node.\n if (linked_id == this_node_id) goto corrupted;\n\n // Compute accumulator for reciprocal links check.\n uint64_t mixed_h1, mixed_h2;\n secure_pair_mixer_128(salt0, salt1, this_node_id, linked_id, (uint64_t)i, &mixed_h1, &mixed_h2);\n\n accumulator[0] ^= mixed_h1;\n accumulator[1] ^= mixed_h2;\n\n // Fix links.\n uint64_t bucket = hnsw_hash_node_id(linked_id) & (table_size-1);\n hnswNode *neighbor = NULL;\n for (uint64_t k = 0; k < table_size; k++) {\n if (table[bucket] && table[bucket]->id == linked_id) {\n neighbor = table[bucket];\n break;\n }\n bucket = (bucket+1) & (table_size-1);\n }\n\n /* The neighbor must exist and also exist at the right\n * level. */\n if (neighbor == NULL || neighbor->level < i) {\n /* Unresolved link! Either a bug in this code\n * or broken serialization data. */\n goto corrupted;\n }\n node->layers[i].links[j] = neighbor;\n }\n\n /* The worst link information was missing from older\n * serialization formats. Compute it on the fly if needed. */\n if (node->layers[i].worst_idx == HNSW_SER_WORSTLINK_MISSING) {\n hnsw_update_worst_neighbor(index,node,i);\n }\n }\n node = node->next;\n }\n\n /* Check that links are reciprocal, otherwise fail. */\n if (accumulator[0] || accumulator[1]) goto corrupted;\n\n /* Everything fine. Return success. */\n hfree(table);\n return 1;\n\ncorrupted:\n /* Some corruption error detected. */\n hfree(table);\n return 0;\n}\n\n/* ================================ Iterator ================================ */\n\n/* Get a cursor that can be used as argument of hnsw_cursor_next() to iterate\n * all the elements that remain there from the start to the end of the\n * iteration, excluding newly added elements.\n *\n * The function returns NULL on out of memory. */\nhnswCursor *hnsw_cursor_init(HNSW *index) {\n if (pthread_rwlock_wrlock(&index->global_lock) != 0) return NULL;\n hnswCursor *cursor = hmalloc(sizeof(*cursor));\n if (cursor == NULL) {\n pthread_rwlock_unlock(&index->global_lock);\n return NULL;\n }\n cursor->index = index;\n cursor->next = index->cursors;\n cursor->current = index->head;\n index->cursors = cursor;\n pthread_rwlock_unlock(&index->global_lock);\n return cursor;\n}\n\n/* Free the cursor. Can be called both at the end of the iteration, when\n * hnsw_cursor_next() returned NULL, or before. */\nvoid hnsw_cursor_free(hnswCursor *cursor) {\n HNSW *index = cursor->index;\n if (pthread_rwlock_wrlock(&index->global_lock) != 0) {\n // No easy way to recover from that. We will leak memory.\n return;\n }\n\n hnswCursor *x = index->cursors;\n hnswCursor *prev = NULL;\n while(x) {\n if (x == cursor) {\n if (prev)\n prev->next = cursor->next;\n else\n index->cursors = cursor->next;\n hfree(cursor);\n break;\n }\n prev = x;\n x = x->next;\n }\n pthread_rwlock_unlock(&index->global_lock);\n}\n\n/* Acquire a lock to use the cursor. Returns 1 if the lock was acquired\n * with success, otherwise zero is returned. The returned element is\n * protected after calling hnsw_cursor_next() for all the time required to\n * access it, then hnsw_cursor_release_lock() should be called in order\n * to unlock the HNSW index. */\nint hnsw_cursor_acquire_lock(hnswCursor *cursor) {\n return pthread_rwlock_rdlock(&cursor->index->global_lock) == 0;\n}\n\n/* Release the cursor lock, see hnsw_cursor_acquire_lock() top comment\n * for more information. */\nvoid hnsw_cursor_release_lock(hnswCursor *cursor) {\n pthread_rwlock_unlock(&cursor->index->global_lock);\n}\n\n/* Return the next element of the HNSW. See hnsw_cursor_init() for\n * the guarantees of the function. */\nhnswNode *hnsw_cursor_next(hnswCursor *cursor) {\n hnswNode *ret = cursor->current;\n if (ret) cursor->current = ret->next;\n return ret;\n}\n\n/* Called by hnsw_unlink_node() if there is at least an active cursor.\n * Will scan the cursors to see if any cursor is going to yield this\n * one, and in this case, updates the current element to the next. */\nvoid hnsw_cursor_element_deleted(HNSW *index, hnswNode *deleted) {\n hnswCursor *x = index->cursors;\n while(x) {\n if (x->current == deleted) x->current = deleted->next;\n x = x->next;\n }\n}\n\n/* ============================ Debugging stuff ============================= */\n\n/* Show stats about nodes connections. */\nvoid hnsw_print_stats(HNSW *index) {\n if (!index || !index->head) {\n printf(\"Empty index or NULL pointer passed\\n\");\n return;\n }\n\n long long total_links = 0;\n int min_links = -1; // We'll set this to first node's count.\n int isolated_nodes = 0;\n uint32_t node_count = 0;\n\n // Iterate through all nodes using the linked list.\n hnswNode *current = index->head;\n while (current) {\n // Count total links for this node across all layers.\n int node_total_links = 0;\n for (uint32_t layer = 0; layer <= current->level; layer++)\n node_total_links += current->layers[layer].num_links;\n\n // Update statistics.\n total_links += node_total_links;\n\n // Initialize or update minimum links.\n if (min_links == -1 || node_total_links < min_links) {\n min_links = node_total_links;\n }\n\n // Check if node is isolated (no links at all).\n if (node_total_links == 0) isolated_nodes++;\n\n node_count++;\n current = current->next;\n }\n\n // Print statistics\n printf(\"HNSW Graph Statistics:\\n\");\n printf(\"----------------------\\n\");\n printf(\"Total nodes: %u\\n\", node_count);\n if (node_count > 0) {\n printf(\"Average links per node: %.2f\\n\",\n\t\t(float)total_links / node_count);\n printf(\"Minimum links in a single node: %d\\n\", min_links);\n printf(\"Number of isolated nodes: %d (%.1f%%)\\n\",\n isolated_nodes,\n (float)isolated_nodes * 100 / node_count);\n }\n}\n\n/* Validate graph connectivity and link reciprocity. Takes pointers to store results:\n * - connected_nodes: will contain number of reachable nodes from entry point.\n * - reciprocal_links: will contain 1 if all links are reciprocal, 0 otherwise.\n * Returns 0 on success, -1 on error (NULL parameters and such).\n */\nint hnsw_validate_graph(HNSW *index, uint64_t *connected_nodes, int *reciprocal_links) {\n if (!index || !connected_nodes || !reciprocal_links) return -1;\n if (!index->enter_point) {\n *connected_nodes = 0;\n *reciprocal_links = 1; // Empty graph is valid.\n return 0;\n }\n\n // Initialize connectivity check.\n index->current_epoch[0]++;\n *connected_nodes = 0;\n *reciprocal_links = 1;\n\n // Initialize node stack.\n uint64_t stack_size = index->node_count;\n hnswNode **stack = hmalloc(sizeof(hnswNode*) * stack_size);\n if (!stack) return -1;\n uint64_t stack_top = 0;\n\n // Start from entry point.\n index->enter_point->visited_epoch[0] = index->current_epoch[0];\n (*connected_nodes)++;\n stack[stack_top++] = index->enter_point;\n\n // Process all reachable nodes.\n while (stack_top > 0) {\n hnswNode *current = stack[--stack_top];\n\n // Explore all neighbors at each level.\n for (uint32_t level = 0; level <= current->level; level++) {\n for (uint64_t i = 0; i < current->layers[level].num_links; i++) {\n hnswNode *neighbor = current->layers[level].links[i];\n\n // Check reciprocity.\n int found_backlink = 0;\n for (uint64_t j = 0; j < neighbor->layers[level].num_links; j++) {\n if (neighbor->layers[level].links[j] == current) {\n found_backlink = 1;\n break;\n }\n }\n if (!found_backlink) {\n *reciprocal_links = 0;\n }\n\n // If we haven't visited this neighbor yet.\n if (neighbor->visited_epoch[0] != index->current_epoch[0]) {\n neighbor->visited_epoch[0] = index->current_epoch[0];\n (*connected_nodes)++;\n if (stack_top < stack_size) {\n stack[stack_top++] = neighbor;\n } else {\n // This should never happen in a valid graph.\n hfree(stack);\n return -1;\n }\n }\n }\n }\n }\n\n hfree(stack);\n\n // Now scan for unreachable nodes and print debug info.\n printf(\"\\nUnreachable nodes debug information:\\n\");\n printf(\"=====================================\\n\");\n\n hnswNode *current = index->head;\n while (current) {\n if (current->visited_epoch[0] != index->current_epoch[0]) {\n printf(\"\\nUnreachable node found:\\n\");\n printf(\"- Node pointer: %p\\n\", (void*)current);\n printf(\"- Node ID: %llu\\n\", (unsigned long long)current->id);\n printf(\"- Node level: %u\\n\", current->level);\n\n // Print info about all its links at each level.\n for (uint32_t level = 0; level <= current->level; level++) {\n printf(\" Level %u links (%u):\\n\", level,\n current->layers[level].num_links);\n for (uint64_t i = 0; i < current->layers[level].num_links; i++) {\n hnswNode *neighbor = current->layers[level].links[i];\n // Check reciprocity for this specific link\n int found_backlink = 0;\n for (uint64_t j = 0; j < neighbor->layers[level].num_links; j++) {\n if (neighbor->layers[level].links[j] == current) {\n found_backlink = 1;\n break;\n }\n }\n printf(\" - Link %llu: pointer=%p, id=%llu, visited=%s,recpr=%s\\n\",\n (unsigned long long)i, (void*)neighbor,\n (unsigned long long)neighbor->id,\n neighbor->visited_epoch[0] == index->current_epoch[0] ?\n \"yes\" : \"no\",\n found_backlink ? \"yes\" : \"no\");\n }\n }\n }\n current = current->next;\n }\n\n printf(\"Total connected nodes: %llu\\n\", (unsigned long long)*connected_nodes);\n printf(\"All links are bi-directiona? %s\\n\", (*reciprocal_links)?\"yes\":\"no\");\n return 0;\n}\n\n/* Test graph recall ability by verifying each node can be found searching\n * for its own vector. This helps validate that the majority of nodes are\n * properly connected and easily reachable in the graph structure. Every\n * unreachable node is reported.\n *\n * Normally only a small percentage of nodes will be not reachable when\n * visited. This is expected and part of the statistical properties\n * of HNSW. This happens especially with entries that have an ambiguous\n * meaning in the represented space, and are across two or multiple clusters\n * of items.\n *\n * The function works by:\n * 1. Iterating through all nodes in the linked list\n * 2. Using each node's vector to perform a search with specified EF\n * 3. Verifying the node can find itself as nearest neighbor\n * 4. Collecting and reporting statistics about reachability\n *\n * This is just a debugging function that reports stuff in the standard\n * output, part of the implementation because this kind of functions\n * provide some visibility on what happens inside the HNSW.\n */\nvoid hnsw_test_graph_recall(HNSW *index, int test_ef, int verbose) {\n // Stats\n uint32_t total_nodes = 0;\n uint32_t unreachable_nodes = 0;\n uint32_t perfectly_reachable = 0; // Node finds itself as first result\n\n // For storing search results\n hnswNode **neighbors = hmalloc(sizeof(hnswNode*) * test_ef);\n float *distances = hmalloc(sizeof(float) * test_ef);\n float *test_vector = hmalloc(sizeof(float) * index->vector_dim);\n if (!neighbors || !distances || !test_vector) {\n hfree(neighbors);\n hfree(distances);\n hfree(test_vector);\n return;\n }\n\n // Get a read slot for searching (even if it's highly unlikely that\n // this test will be run threaded...).\n int slot = hnsw_acquire_read_slot(index);\n if (slot < 0) {\n hfree(neighbors);\n hfree(distances);\n return;\n }\n\n printf(\"\\nTesting graph recall\\n\");\n printf(\"====================\\n\");\n\n // Process one node at a time using the linked list\n hnswNode *current = index->head;\n while (current) {\n total_nodes++;\n\n // If using quantization, we need to reconstruct the normalized vector\n if (index->quant_type == HNSW_QUANT_Q8) {\n int8_t *quants = current->vector;\n // Reconstruct normalized vector from quantized data\n for (uint32_t j = 0; j < index->vector_dim; j++) {\n test_vector[j] = (quants[j] * current->quants_range) / 127;\n }\n } else if (index->quant_type == HNSW_QUANT_NONE) {\n memcpy(test_vector,current->vector,sizeof(float)*index->vector_dim);\n } else {\n assert(0 && \"Quantization type not supported.\");\n }\n\n // Search using the node's own vector with high ef\n int found = hnsw_search(index, test_vector, test_ef, neighbors,\n distances, slot, 1);\n\n if (found == 0) continue; // Empty HNSW?\n\n // Look for the node itself in the results\n int found_self = 0;\n int self_position = -1;\n for (int i = 0; i < found; i++) {\n if (neighbors[i] == current) {\n found_self = 1;\n self_position = i;\n break;\n }\n }\n\n if (!found_self || self_position != 0) {\n unreachable_nodes++;\n if (verbose) {\n if (!found_self)\n printf(\"\\nNode %s cannot find itself:\\n\", (char*)current->value);\n else\n printf(\"\\nNode %s is not top result:\\n\", (char*)current->value);\n printf(\"- Node ID: %llu\\n\", (unsigned long long)current->id);\n printf(\"- Node level: %u\\n\", current->level);\n printf(\"- Found %d neighbors but self not among them\\n\", found);\n printf(\"- Closest neighbor distance: %f\\n\", distances[0]);\n printf(\"- Neighbors: \");\n for (uint32_t i = 0; i < current->layers[0].num_links; i++) {\n printf(\"%s \", (char*)current->layers[0].links[i]->value);\n }\n printf(\"\\n\");\n printf(\"\\nFound instead: \");\n for (int j = 0; j < found && j < 10; j++) {\n printf(\"%s \", (char*)neighbors[j]->value);\n }\n printf(\"\\n\");\n }\n } else {\n perfectly_reachable++;\n }\n current = current->next;\n }\n\n // Release read slot\n hnsw_release_read_slot(index, slot);\n\n // Free resources\n hfree(neighbors);\n hfree(distances);\n hfree(test_vector);\n\n // Print final statistics\n printf(\"Total nodes tested: %u\\n\", total_nodes);\n printf(\"Perfectly reachable nodes: %u (%.1f%%)\\n\",\n perfectly_reachable,\n total_nodes ? (float)perfectly_reachable * 100 / total_nodes : 0);\n printf(\"Unreachable/suboptimal nodes: %u (%.1f%%)\\n\",\n unreachable_nodes,\n total_nodes ? (float)unreachable_nodes * 100 / total_nodes : 0);\n}\n\n/* Return exact K-NN items by performing a linear scan of all nodes.\n * This function has the same signature as hnsw_search_with_filter() but\n * instead of using the graph structure, it scans all nodes to find the\n * true nearest neighbors.\n *\n * Note that neighbors and distances arrays must have space for at least 'k' items.\n * norm_query should be set to 1 if the query vector is already normalized.\n *\n * If the filter_callback is passed, only elements passing the specified filter\n * are returned. The slot parameter is ignored but kept for API consistency. */\nint hnsw_ground_truth_with_filter\n (HNSW *index, const float *query_vector, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized,\n int (*filter_callback)(void *value, void *privdata),\n void *filter_privdata)\n{\n /* Note that we don't really use the slot here: it's a linear scan.\n * Yet we want the user to acquire the slot as this will hold the\n * global lock in read only mode. */\n (void) slot;\n\n /* Take our query vector into a temporary node. */\n hnswNode query;\n if (hnsw_init_tmp_node(index, &query, query_vector_is_normalized, query_vector) == 0) return -1;\n\n /* Accumulate best results into a priority queue. */\n pqueue *results = pq_new(k);\n if (!results) {\n hnsw_free_tmp_node(&query, query_vector);\n return -1;\n }\n\n /* Scan all nodes linearly. */\n hnswNode *current = index->head;\n while (current) {\n /* Apply filter if needed. */\n if (filter_callback &&\n !filter_callback(current->value, filter_privdata))\n {\n current = current->next;\n continue;\n }\n\n /* Calculate distance to query. */\n float dist = hnsw_distance(index, &query, current);\n\n /* Add to results to pqueue. Will be accepted only if better than\n * the current worse or pqueue not full. */\n pq_push(results, current, dist);\n current = current->next;\n }\n\n /* Copy results to output arrays. */\n uint32_t found = MIN(k, results->count);\n for (uint32_t i = 0; i < found; i++) {\n neighbors[i] = pq_get_node(results, i);\n if (distances) distances[i] = pq_get_distance(results, i);\n }\n\n /* Clean up. */\n pq_free(results);\n hnsw_free_tmp_node(&query, query_vector);\n return found;\n}\n" }, { "path": "modules/vector-sets/hnsw.h", "content": "/*\n * HNSW (Hierarchical Navigable Small World) Implementation\n * Based on the paper by Yu. A. Malkov, D. A. Yashunin\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo.\n */\n\n#ifndef HNSW_H\n#define HNSW_H\n\n#include \n#include \n\n#define HNSW_DEFAULT_M 16 /* Used when 0 is given at creation time. */\n#define HNSW_MIN_M 4 /* Probably even too low already. */\n#define HNSW_MAX_M 4096 /* Safeguard sanity limit. */\n#define HNSW_MAX_THREADS 32 /* Maximum number of concurrent threads */\n\n/* Quantization types you can enable at creation time in hnsw_new() */\n#define HNSW_QUANT_NONE 0 // No quantization.\n#define HNSW_QUANT_Q8 1 // Q8 quantization.\n#define HNSW_QUANT_BIN 2 // Binary quantization.\n\n/* Layer structure for HNSW nodes. Each node will have from one to a few\n * of this depending on its level. */\ntypedef struct {\n struct hnswNode **links; /* Array of neighbors for this layer */\n uint32_t num_links; /* Number of used links */\n uint32_t max_links; /* Maximum links for this layer. We may\n * reallocate the node in very particular\n * conditions in order to allow linking of\n * new inserted nodes, so this may change\n * dynamically and be > M*2 for a small set of\n * nodes. */\n float worst_distance; /* Distance to the worst neighbor */\n uint32_t worst_idx; /* Index of the worst neighbor */\n} hnswNodeLayer;\n\n/* Node structure for HNSW graph */\ntypedef struct hnswNode {\n uint32_t level; /* Node's maximum level */\n uint64_t id; /* Unique identifier, may be useful in order to\n * have a bitmap of visited notes to use as\n * alternative to epoch / visited_epoch.\n * Also used in serialization in order to retain\n * links specifying IDs. */\n void *vector; /* The vector, quantized or not. */\n float quants_range; /* Quantization range for this vector:\n * min/max values will be in the range\n * -quants_range, +quants_range */\n float l2; /* L2 before normalization. */\n\n /* Last time (epoch) this node was visited. We need one per thread.\n * This avoids having a different data structure where we track\n * visited nodes, but costs memory per node. */\n uint64_t visited_epoch[HNSW_MAX_THREADS];\n\n void *value; /* Associated value */\n struct hnswNode *prev, *next; /* Prev/Next node in the list starting at\n * HNSW->head. */\n\n /* Links (and links info) per each layer. Note that this is part\n * of the node allocation to be more cache friendly: reliable 3% speedup\n * on Apple silicon, and does not make anything more complex. */\n hnswNodeLayer layers[];\n} hnswNode;\n\nstruct HNSW;\n\n/* It is possible to navigate an HNSW with a cursor that guarantees\n * visiting all the elements that remain in the HNSW from the start to the\n * end of the process (but not the new ones, so that the process will\n * eventually finish). Check hnsw_cursor_init(), hnsw_cursor_next() and\n * hnsw_cursor_free(). */\ntypedef struct hnswCursor {\n struct HNSW *index; // Reference to the index of this cursor.\n hnswNode *current; // Element to report when hnsw_cursor_next() is called.\n struct hnswCursor *next; // Next cursor active.\n} hnswCursor;\n\n/* Main HNSW index structure */\ntypedef struct HNSW {\n hnswNode *enter_point; /* Entry point for the graph */\n uint32_t M; /* M as in the paper: layer 0 has M*2 max\n neighbors (M populated at insertion time)\n while all the other layers have M neighbors. */\n uint32_t max_level; /* Current maximum level in the graph */\n uint32_t vector_dim; /* Dimensionality of stored vectors */\n uint64_t node_count; /* Total number of nodes */\n _Atomic uint64_t last_id; /* Last node ID used */\n uint64_t current_epoch[HNSW_MAX_THREADS]; /* Current epoch for visit tracking */\n hnswNode *head; /* Linked list of nodes. Last first */\n\n /* We have two locks here:\n * 1. A global_lock that is used to perform write operations blocking all\n * the readers.\n * 2. One mutex per epoch slot, in order for read operations to acquire\n * a lock on a specific slot to use epochs tracking of visited nodes. */\n pthread_rwlock_t global_lock; /* Global read-write lock */\n pthread_mutex_t slot_locks[HNSW_MAX_THREADS]; /* Per-slot locks */\n\n _Atomic uint32_t next_slot; /* Next thread slot to try */\n _Atomic uint64_t version; /* Version for optimistic concurrency, this is\n * incremented on deletions and entry point\n * updates. */\n uint32_t quant_type; /* Quantization used. HNSW_QUANT_... */\n hnswCursor *cursors;\n} HNSW;\n\n/* Serialized node. This structure is used as return value of\n * hnsw_serialize_node(). */\ntypedef struct hnswSerNode {\n void *vector;\n uint32_t vector_size;\n uint64_t *params;\n uint32_t params_count;\n} hnswSerNode;\n\n/* Insert preparation context */\ntypedef struct InsertContext InsertContext;\n\n/* Core HNSW functions */\nHNSW *hnsw_new(uint32_t vector_dim, uint32_t quant_type, uint32_t m);\nvoid hnsw_free(HNSW *index,void(*free_value)(void*value));\nvoid hnsw_node_free(hnswNode *node);\nvoid hnsw_print_stats(HNSW *index);\nhnswNode *hnsw_insert(HNSW *index, const float *vector, const int8_t *qvector,\n float qrange, uint64_t id, void *value, int ef);\nint hnsw_search(HNSW *index, const float *query, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized);\nint hnsw_search_with_filter\n (HNSW *index, const float *query_vector, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized,\n int (*filter_callback)(void *value, void *privdata),\n void *filter_privdata, uint32_t max_candidates);\nvoid hnsw_get_node_vector(HNSW *index, hnswNode *node, float *vec);\nint hnsw_delete_node(HNSW *index, hnswNode *node, void(*free_value)(void*value));\nhnswNode *hnsw_random_node(HNSW *index, int slot);\n\n/* Thread safety functions. */\nint hnsw_acquire_read_slot(HNSW *index);\nvoid hnsw_release_read_slot(HNSW *index, int slot);\n\n/* Optimistic insertion API. */\nInsertContext *hnsw_prepare_insert(HNSW *index, const float *vector, const int8_t *qvector, float qrange, uint64_t id, int ef);\nhnswNode *hnsw_try_commit_insert(HNSW *index, InsertContext *ctx, void *value);\nvoid hnsw_free_insert_context(InsertContext *ctx);\n\n/* Serialization. */\nhnswSerNode *hnsw_serialize_node(HNSW *index, hnswNode *node);\nvoid hnsw_free_serialized_node(hnswSerNode *sn);\nhnswNode *hnsw_insert_serialized(HNSW *index, void *vector, uint64_t *params, uint32_t params_len, void *value);\nint hnsw_deserialize_index(HNSW *index, uint64_t salt0, uint64_t salt1);\n\n// Helper function in case the user wants to directly copy\n// the vector bytes.\nuint32_t hnsw_quants_bytes(HNSW *index);\n\n/* Cursors. */\nhnswCursor *hnsw_cursor_init(HNSW *index);\nvoid hnsw_cursor_free(hnswCursor *cursor);\nhnswNode *hnsw_cursor_next(hnswCursor *cursor);\nint hnsw_cursor_acquire_lock(hnswCursor *cursor);\nvoid hnsw_cursor_release_lock(hnswCursor *cursor);\n\n/* Allocator selection. */\nvoid hnsw_set_allocator(void (*free_ptr)(void*), void *(*malloc_ptr)(size_t),\n void *(*realloc_ptr)(void*, size_t));\n\n/* Testing. */\nint hnsw_validate_graph(HNSW *index, uint64_t *connected_nodes, int *reciprocal_links);\nvoid hnsw_test_graph_recall(HNSW *index, int test_ef, int verbose);\nfloat hnsw_distance(HNSW *index, hnswNode *a, hnswNode *b);\nint hnsw_ground_truth_with_filter\n (HNSW *index, const float *query_vector, uint32_t k,\n hnswNode **neighbors, float *distances, uint32_t slot,\n int query_vector_is_normalized,\n int (*filter_callback)(void *value, void *privdata),\n void *filter_privdata);\n\n#endif /* HNSW_H */\n" }, { "path": "modules/vector-sets/mixer.h", "content": "/* Redis implementation for vector sets. The data structure itself\n * is implemented in hnsw.c.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo.\n *\n * =============================================================================\n *\n * Mixing function for HNSW link integrity verification\n * Designed to resist collision attacks when salts are unknown.\n */\n\n#include \n#include \n\nstatic inline uint64_t ROTL64(uint64_t x, int r) {\n return (x << r) | (x >> (64 - r));\n}\n\n// Use more rounds and stronger constants\n#define MIX_PRIME_1 0xFF51AFD7ED558CCDULL\n#define MIX_PRIME_2 0xC4CEB9FE1A85EC53ULL\n#define MIX_PRIME_3 0x9E3779B97F4A7C15ULL\n#define MIX_PRIME_4 0xBF58476D1CE4E5B9ULL\n#define MIX_PRIME_5 0x94D049BB133111EBULL\n#define MIX_PRIME_6 0x2B7E151628AED2A7ULL\n\n/* Mixer design goals:\n * 1. Thorough mixing of the level parameter.\n * 2. Enough rounds of mixing.\n * 3. Cross-influence between h1 and h2.\n * 4. Domain separation to prevent related-key attacks.\n */\nvoid secure_pair_mixer_128(uint64_t salt0, uint64_t salt1,\n uint64_t id1_in, uint64_t id2_in, uint64_t level,\n uint64_t* out_h1, uint64_t* out_h2) {\n // Order independence (A -> B links should hash as B -> A links).\n uint64_t id_a = (id1_in < id2_in) ? id1_in : id2_in;\n uint64_t id_b = (id1_in < id2_in) ? id2_in : id1_in;\n\n // Domain separation: mix salts with a constant to prevent\n // related-key attacks.\n uint64_t h1 = salt0 ^ 0xDEADBEEFDEADBEEFULL;\n uint64_t h2 = salt1 ^ 0xCAFEBABECAFEBABEULL;\n\n // First, thoroughly mix the level into both accumulators\n // This prevents predictable level values from being a weakness\n uint64_t level_mix = level;\n level_mix *= MIX_PRIME_5;\n level_mix ^= level_mix >> 32;\n level_mix *= MIX_PRIME_6;\n\n h1 ^= level_mix;\n h2 ^= ROTL64(level_mix, 31);\n\n // Mix in id_a with strong diffusion.\n h1 ^= id_a;\n h1 *= MIX_PRIME_1;\n h1 = ROTL64(h1, 23);\n h1 *= MIX_PRIME_2;\n\n // Mix in id_b.\n h2 ^= id_b;\n h2 *= MIX_PRIME_3;\n h2 = ROTL64(h2, 29);\n h2 *= MIX_PRIME_4;\n\n // Three rounds of cross-mixing for better security.\n for (int i = 0; i < 3; i++) {\n // Cross-influence.\n uint64_t tmp = h1;\n h1 += h2;\n h2 += tmp;\n\n // Mix h1.\n h1 ^= ROTL64(h1, 31);\n h1 *= MIX_PRIME_1;\n h1 ^= salt0;\n\n // Mix h2.\n h2 ^= ROTL64(h2, 37);\n h2 *= MIX_PRIME_2;\n h2 ^= salt1;\n }\n\n // Finalization with avalanche rounds.\n h1 ^= h1 >> 33;\n h1 *= MIX_PRIME_3;\n h1 ^= h1 >> 29;\n h1 *= MIX_PRIME_4;\n h1 ^= h1 >> 32;\n\n h2 ^= h2 >> 33;\n h2 *= MIX_PRIME_5;\n h2 ^= h2 >> 29;\n h2 *= MIX_PRIME_6;\n h2 ^= h2 >> 32;\n\n *out_h1 = h1;\n *out_h2 = h2;\n}\n" }, { "path": "modules/vector-sets/test.py", "content": "#!/usr/bin/env python3\n#\n# Vector set tests.\n# A Redis instance should be running in the default port.\n#\n# Copyright (c) 2009-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n\nimport redis\nimport random\nimport struct\nimport math\nimport time\nimport sys\nimport os\nimport importlib\nimport inspect\nimport argparse\nfrom typing import List, Tuple, Optional\nfrom dataclasses import dataclass\n\ndef colored(text: str, color: str) -> str:\n colors = {\n 'red': '\\033[91m',\n 'green': '\\033[92m',\n 'yellow': '\\033[93m',\n 'blue': '\\033[94m',\n 'magenta': '\\033[95m',\n 'cyan': '\\033[96m',\n }\n reset = '\\033[0m'\n return f\"{colors.get(color, '')}{text}{reset}\"\n\n@dataclass\nclass VectorData:\n vectors: List[List[float]]\n names: List[str]\n\n def find_k_nearest(self, query_vector: List[float], k: int) -> List[Tuple[str, float]]:\n \"\"\"Find k-nearest neighbors using the same scoring as Redis VSIM WITHSCORES.\"\"\"\n similarities = []\n query_norm = math.sqrt(sum(x*x for x in query_vector))\n if query_norm == 0:\n return []\n\n for i, vec in enumerate(self.vectors):\n vec_norm = math.sqrt(sum(x*x for x in vec))\n if vec_norm == 0:\n continue\n\n dot_product = sum(a*b for a,b in zip(query_vector, vec))\n cosine_sim = dot_product / (query_norm * vec_norm)\n distance = 1.0 - cosine_sim\n redis_similarity = 1.0 - (distance/2.0)\n similarities.append((self.names[i], redis_similarity))\n\n similarities.sort(key=lambda x: x[1], reverse=True)\n return similarities[:k]\n\ndef generate_random_vector(dim: int) -> List[float]:\n \"\"\"Generate a random normalized vector.\"\"\"\n vec = [random.gauss(0, 1) for _ in range(dim)]\n norm = math.sqrt(sum(x*x for x in vec))\n return [x/norm for x in vec]\n\ndef fill_redis_with_vectors(r: redis.Redis, key: str, count: int, dim: int,\n with_reduce: Optional[int] = None) -> VectorData:\n \"\"\"Fill Redis with random vectors and return a VectorData object for verification.\"\"\"\n vectors = []\n names = []\n\n r.delete(key)\n for i in range(count):\n vec = generate_random_vector(dim)\n name = f\"{key}:item:{i}\"\n vectors.append(vec)\n names.append(name)\n\n vec_bytes = struct.pack(f'{dim}f', *vec)\n args = [key]\n if with_reduce:\n args.extend(['REDUCE', with_reduce])\n args.extend(['FP32', vec_bytes, name])\n r.execute_command('VADD', *args)\n\n return VectorData(vectors=vectors, names=names)\n\nclass TestCase:\n def __init__(self, primary_port=6379, replica_port=6380):\n self.error_msg = None\n self.error_details = None\n self.test_key = f\"test:{self.__class__.__name__.lower()}\"\n # Primary Redis instance\n self.redis = redis.Redis(port=primary_port,db=9)\n self.redis3 = redis.Redis(port=primary_port,protocol=3,db=9)\n # Replica Redis instance\n self.replica = redis.Redis(port=replica_port,db=9)\n # Replication status\n self.replication_setup = False\n # Ports\n self.primary_port = primary_port\n self.replica_port = replica_port\n\n def setup(self):\n self.redis.delete(self.test_key)\n\n def teardown(self):\n self.redis.delete(self.test_key)\n\n def setup_replication(self) -> bool:\n \"\"\"\n Setup replication between primary and replica Redis instances.\n Returns True if replication is successfully established, False otherwise.\n \"\"\"\n # Configure replica to replicate from primary\n self.replica.execute_command('REPLICAOF', '127.0.0.1', self.primary_port)\n\n # Wait for replication to be established\n max_attempts = 50\n for attempt in range(max_attempts):\n # Check replication info\n repl_info = self.replica.info('replication')\n\n # Check if replication is established\n if (repl_info.get('role') == 'slave' and\n repl_info.get('master_host') == '127.0.0.1' and\n repl_info.get('master_port') == self.primary_port and\n repl_info.get('master_link_status') == 'up'):\n\n self.replication_setup = True\n return True\n\n # Wait before next attempt\n print(colored(\".\",'cyan'),end=\"\",flush=True)\n time.sleep(0.5)\n\n # If we get here, replication wasn't established\n self.error_msg = \"Failed to establish replication between primary and replica\"\n return False\n\n def test(self):\n raise NotImplementedError(\"Subclasses must implement test method\")\n\n def run(self):\n try:\n self.setup()\n self.test()\n return True\n except AssertionError as e:\n self.error_msg = str(e)\n import traceback\n self.error_details = traceback.format_exc()\n return False\n except Exception as e:\n self.error_msg = f\"Unexpected error: {str(e)}\"\n import traceback\n self.error_details = traceback.format_exc()\n return False\n finally:\n self.teardown()\n\n def getname(self):\n \"\"\"Each test class should override this to provide its name\"\"\"\n return self.__class__.__name__\n\n def estimated_runtime(self):\n \"\"\"\"Each test class should override this if it takes a significant amount of time to run. Default is 100ms\"\"\"\n return 0.1\n\ndef find_test_classes(primary_port, replica_port):\n test_classes = []\n script_dir = os.path.dirname(os.path.abspath(__file__))\n tests_dir = os.path.join(script_dir, 'tests')\n\n if not os.path.exists(tests_dir):\n return []\n\n for file in os.listdir(tests_dir):\n if file.endswith('.py'):\n module_name = f\"tests.{file[:-3]}\"\n try:\n module = importlib.import_module(module_name)\n for name, obj in inspect.getmembers(module):\n if inspect.isclass(obj) and obj.__name__ != 'TestCase' and hasattr(obj, 'test'):\n # Create test instance with specified ports\n test_instance = obj(primary_port,replica_port)\n test_classes.append(test_instance)\n except Exception as e:\n print(f\"Error loading {file}: {e}\")\n\n return test_classes\n\ndef check_redis_empty(r, instance_name):\n \"\"\"Check if Redis instance is empty\"\"\"\n try:\n dbsize = r.dbsize()\n if dbsize > 0:\n print(colored(f\"ERROR: {instance_name} Redis instance DB 9 is not empty (dbsize: {dbsize}).\", \"red\"))\n print(colored(\"Make sure you're not using a production instance and that all data is safe to delete.\", \"red\"))\n sys.exit(1)\n except redis.exceptions.ConnectionError:\n print(colored(f\"ERROR: Cannot connect to {instance_name} Redis instance.\", \"red\"))\n sys.exit(1)\n\ndef check_replica_running(replica_port):\n \"\"\"Check if replica Redis instance is running\"\"\"\n r = redis.Redis(port=replica_port)\n try:\n r.ping()\n return True\n except redis.exceptions.ConnectionError:\n print(colored(f\"WARNING: Replica Redis instance (port {replica_port}) is not running.\", \"yellow\"))\n print(colored(\"Replication tests will be skipped. Make sure to start the replica instance.\", \"yellow\"))\n return False\n\ndef run_tests():\n # Parse command line arguments\n parser = argparse.ArgumentParser(description='Run Redis vector tests.')\n parser.add_argument('--primary-port', type=int, default=6379, help='Primary Redis instance port (default: 6379)')\n parser.add_argument('--replica-port', type=int, default=6380, help='Replica Redis instance port (default: 6380)')\n args = parser.parse_args()\n\n print(\"================================================\")\n print(f\"Make sure to have Redis running on localhost\")\n print(f\"Primary port: {args.primary_port}\")\n print(f\"Replica port: {args.replica_port}\")\n print(\"with --enable-debug-command yes\")\n print(\"================================================\\n\")\n\n # Check if Redis instances are empty\n primary = redis.Redis(port=args.primary_port,db=9)\n replica = redis.Redis(port=args.replica_port,db=9)\n\n check_redis_empty(primary, \"Primary\")\n\n # Check if replica is running\n replica_running = check_replica_running(args.replica_port)\n if replica_running:\n check_redis_empty(replica, \"Replica\")\n\n tests = find_test_classes(args.primary_port, args.replica_port)\n if not tests:\n print(\"No tests found!\")\n return\n\n # Sort tests by estimated runtime\n tests.sort(key=lambda t: t.estimated_runtime())\n\n passed = 0\n skipped = 0\n total = len(tests)\n\n for test in tests:\n print(f\"{test.getname()}: \", end=\"\")\n sys.stdout.flush()\n\n if not replica_running and test.getname().lower().find(\"replication\") != -1:\n print(colored(\"SKIPPING\",\"yellow\"))\n skipped += 1\n continue\n\n start_time = time.time()\n success = test.run()\n duration = time.time() - start_time\n\n if success:\n print(colored(\"OK\", \"green\"), f\"({duration:.2f}s)\")\n passed += 1\n else:\n print(colored(\"ERR\", \"red\"), f\"({duration:.2f}s)\")\n print(f\"Error: {test.error_msg}\")\n if test.error_details:\n print(\"\\nTraceback:\")\n print(test.error_details)\n\n print(\"\\n\" + \"=\"*50)\n print(f\"\\nTest Summary: {passed}/{total} tests passed\")\n\n if passed == total:\n print(colored(\"ALL TESTS PASSED!\", \"green\"))\n else:\n if total-skipped-passed > 0:\n print(colored(f\"{total-skipped-passed} TESTS FAILED!\", \"red\"))\n sys.exit(1)\n if skipped > 0:\n print(colored(f\"{skipped} TESTS SKIPPED!\", \"yellow\"))\n\nif __name__ == \"__main__\":\n run_tests()\n" }, { "path": "modules/vector-sets/tests/basic_commands.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass BasicCommands(TestCase):\n def getname(self):\n return \"VADD, VDIM, VCARD basic usage\"\n\n def test(self):\n # Test VADD\n vec = generate_random_vector(4)\n vec_bytes = struct.pack('4f', *vec)\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:1')\n assert result == 1, \"VADD should return 1 for first item\"\n\n # Test VDIM\n dim = self.redis.execute_command('VDIM', self.test_key)\n assert dim == 4, f\"VDIM should return 4, got {dim}\"\n\n # Test VCARD\n card = self.redis.execute_command('VCARD', self.test_key)\n assert card == 1, f\"VCARD should return 1, got {card}\"\n" }, { "path": "modules/vector-sets/tests/basic_similarity.py", "content": "from test import TestCase\n\nclass BasicSimilarity(TestCase):\n def getname(self):\n return \"VSIM reported distance makes sense with 4D vectors\"\n\n def test(self):\n # Add two very similar vectors, one different\n vec1 = [1, 0, 0, 0]\n vec2 = [0.99, 0.01, 0, 0]\n vec3 = [0.1, 1, -1, 0.5]\n\n # Add vectors using VALUES format\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec1], f'{self.test_key}:item:1')\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec2], f'{self.test_key}:item:2')\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec3], f'{self.test_key}:item:3')\n\n # Query similarity with vec1\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec1], 'WITHSCORES')\n\n # Convert results to dictionary\n results_dict = {}\n for i in range(0, len(result), 2):\n key = result[i].decode()\n score = float(result[i+1])\n results_dict[key] = score\n\n # Verify results\n assert results_dict[f'{self.test_key}:item:1'] > 0.99, \"Self-similarity should be very high\"\n assert results_dict[f'{self.test_key}:item:2'] > 0.99, \"Similar vector should have high similarity\"\n assert results_dict[f'{self.test_key}:item:3'] < 0.8, \"Not very similar vector should have low similarity\"\n" }, { "path": "modules/vector-sets/tests/bin_vectorization.py", "content": "from test import TestCase\n\nclass BinVectorization(TestCase):\n def getname(self):\n return \"Binary quantization: verify vectorized vs scalar paths produce consistent results\"\n\n def test(self):\n # Test with different dimensions to exercise different code paths:\n # - dim=1: Edge case for minimal valid dimension (scalar path)\n # - dim=64: Exact alignment boundary, one uint64_t word (scalar path)\n # - dim=128: Scalar path (< 256)\n # - dim=384: AVX2 path if available (>= 256, < 512)\n # - dim=768: AVX512 path if available (>= 512)\n # Note: dim=0 is not tested as it's invalid input (division by zero)\n \n test_dims = [1, 64, 128, 384, 768]\n \n for dim in test_dims:\n # Add two very similar vectors, one different\n vec1 = [1.0] * dim\n vec2 = [0.99] * dim # Very similar to vec1\n vec3 = [-1.0] * dim # Opposite direction - should have low similarity\n \n # Add vectors with binary quantization\n self.redis.execute_command('VADD', f'{self.test_key}:dim{dim}', 'VALUES', dim, \n *[str(x) for x in vec1], f'{self.test_key}:dim{dim}:item:1', 'BIN')\n self.redis.execute_command('VADD', f'{self.test_key}:dim{dim}', 'VALUES', dim, \n *[str(x) for x in vec2], f'{self.test_key}:dim{dim}:item:2', 'BIN')\n self.redis.execute_command('VADD', f'{self.test_key}:dim{dim}', 'VALUES', dim, \n *[str(x) for x in vec3], f'{self.test_key}:dim{dim}:item:3', 'BIN')\n \n # Query similarity\n result = self.redis.execute_command('VSIM', f'{self.test_key}:dim{dim}', 'VALUES', dim, \n *[str(x) for x in vec1], 'WITHSCORES')\n \n # Convert results to dictionary\n results_dict = {}\n for i in range(0, len(result), 2):\n key = result[i].decode()\n score = float(result[i+1])\n results_dict[key] = score\n \n # Verify results are consistent across dimensions\n # Self-similarity should be very high (binary quantization is less precise)\n assert results_dict[f'{self.test_key}:dim{dim}:item:1'] > 0.99, \\\n f\"Dim {dim}: Self-similarity too low: {results_dict[f'{self.test_key}:dim{dim}:item:1']}\"\n \n # Similar vector should have high similarity (binary quant loses some precision)\n assert results_dict[f'{self.test_key}:dim{dim}:item:2'] > 0.95, \\\n f\"Dim {dim}: Similar vector similarity too low: {results_dict[f'{self.test_key}:dim{dim}:item:2']}\"\n \n # Opposite vector should have very low similarity\n assert results_dict[f'{self.test_key}:dim{dim}:item:3'] < 0.1, \\\n f\"Dim {dim}: Opposite vector similarity too high: {results_dict[f'{self.test_key}:dim{dim}:item:3']}\"\n" }, { "path": "modules/vector-sets/tests/concurrent_vadd_cas_del_vsim.py", "content": "from test import TestCase, generate_random_vector\nimport threading\nimport time\nimport struct\n\nclass ThreadingStressTest(TestCase):\n def getname(self):\n return \"Concurrent VADD/DEL/VSIM operations stress test\"\n\n def estimated_runtime(self):\n return 10 # Test runs for 10 seconds\n\n def test(self):\n # Constants - easy to modify if needed\n NUM_VADD_THREADS = 10\n NUM_VSIM_THREADS = 1\n NUM_DEL_THREADS = 1\n TEST_DURATION = 10 # seconds\n VECTOR_DIM = 100\n DEL_INTERVAL = 1 # seconds\n\n # Shared flags and state\n stop_event = threading.Event()\n error_list = []\n error_lock = threading.Lock()\n\n def log_error(thread_name, error):\n with error_lock:\n error_list.append(f\"{thread_name}: {error}\")\n\n def vadd_worker(thread_id):\n \"\"\"Thread function to perform VADD operations\"\"\"\n thread_name = f\"VADD-{thread_id}\"\n try:\n vector_count = 0\n while not stop_event.is_set():\n try:\n # Generate random vector\n vec = generate_random_vector(VECTOR_DIM)\n vec_bytes = struct.pack(f'{VECTOR_DIM}f', *vec)\n\n # Add vector with CAS option\n self.redis.execute_command(\n 'VADD',\n self.test_key,\n 'FP32',\n vec_bytes,\n f'{self.test_key}:item:{thread_id}:{vector_count}',\n 'CAS'\n )\n\n vector_count += 1\n\n # Small sleep to reduce CPU pressure\n if vector_count % 10 == 0:\n time.sleep(0.001)\n except Exception as e:\n log_error(thread_name, f\"Error: {str(e)}\")\n time.sleep(0.1) # Slight backoff on error\n except Exception as e:\n log_error(thread_name, f\"Thread error: {str(e)}\")\n\n def del_worker():\n \"\"\"Thread function that deletes the key periodically\"\"\"\n thread_name = \"DEL\"\n try:\n del_count = 0\n while not stop_event.is_set():\n try:\n # Sleep first, then delete\n time.sleep(DEL_INTERVAL)\n if stop_event.is_set():\n break\n\n self.redis.delete(self.test_key)\n del_count += 1\n except Exception as e:\n log_error(thread_name, f\"Error: {str(e)}\")\n except Exception as e:\n log_error(thread_name, f\"Thread error: {str(e)}\")\n\n def vsim_worker(thread_id):\n \"\"\"Thread function to perform VSIM operations\"\"\"\n thread_name = f\"VSIM-{thread_id}\"\n try:\n search_count = 0\n while not stop_event.is_set():\n try:\n # Generate query vector\n query_vec = generate_random_vector(VECTOR_DIM)\n query_str = [str(x) for x in query_vec]\n\n # Perform similarity search\n args = ['VSIM', self.test_key, 'VALUES', VECTOR_DIM]\n args.extend(query_str)\n args.extend(['COUNT', 10])\n self.redis.execute_command(*args)\n\n search_count += 1\n\n # Small sleep to reduce CPU pressure\n if search_count % 10 == 0:\n time.sleep(0.005)\n except Exception as e:\n # Don't log empty array errors, as they're expected when key doesn't exist\n if \"empty array\" not in str(e).lower():\n log_error(thread_name, f\"Error: {str(e)}\")\n time.sleep(0.1) # Slight backoff on error\n except Exception as e:\n log_error(thread_name, f\"Thread error: {str(e)}\")\n\n # Start all threads\n threads = []\n\n # VADD threads\n for i in range(NUM_VADD_THREADS):\n thread = threading.Thread(target=vadd_worker, args=(i,))\n thread.start()\n threads.append(thread)\n\n # DEL threads\n for _ in range(NUM_DEL_THREADS):\n thread = threading.Thread(target=del_worker)\n thread.start()\n threads.append(thread)\n\n # VSIM threads\n for i in range(NUM_VSIM_THREADS):\n thread = threading.Thread(target=vsim_worker, args=(i,))\n thread.start()\n threads.append(thread)\n\n # Let the test run for the specified duration\n time.sleep(TEST_DURATION)\n\n # Signal all threads to stop\n stop_event.set()\n\n # Wait for threads to finish\n for thread in threads:\n thread.join(timeout=2.0)\n\n # Check if Redis is still responsive\n try:\n ping_result = self.redis.ping()\n assert ping_result, \"Redis did not respond to PING after stress test\"\n except Exception as e:\n assert False, f\"Redis connection failed after stress test: {str(e)}\"\n\n # Report any errors for diagnosis, but don't fail the test unless PING fails\n if error_list:\n error_count = len(error_list)\n print(f\"\\nEncountered {error_count} errors during stress test.\")\n print(\"First 5 errors:\")\n for error in error_list[:5]:\n print(f\"- {error}\")\n" }, { "path": "modules/vector-sets/tests/concurrent_vsim_and_del.py", "content": "from test import TestCase, fill_redis_with_vectors, generate_random_vector\nimport threading, time\n\nclass ConcurrentVSIMAndDEL(TestCase):\n def getname(self):\n return \"Concurrent VSIM and DEL operations\"\n\n def estimated_runtime(self):\n return 2\n\n def test(self):\n # Fill the key with 5000 random vectors\n dim = 128\n count = 5000\n fill_redis_with_vectors(self.redis, self.test_key, count, dim)\n\n # List to store results from threads\n thread_results = []\n\n def vsim_thread():\n \"\"\"Thread function to perform VSIM operations until the key is deleted\"\"\"\n while True:\n query_vec = generate_random_vector(dim)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in query_vec], 'COUNT', 10)\n if not result:\n # Empty array detected, key is deleted\n thread_results.append(True)\n break\n\n # Start multiple threads to perform VSIM operations\n threads = []\n for _ in range(4): # Start 4 threads\n t = threading.Thread(target=vsim_thread)\n t.start()\n threads.append(t)\n\n # Delete the key while threads are still running\n time.sleep(1)\n self.redis.delete(self.test_key)\n\n # Wait for all threads to finish (they will exit once they detect the key is deleted)\n for t in threads:\n t.join()\n\n # Verify that all threads detected an empty array or error\n assert len(thread_results) == len(threads), \"Not all threads detected the key deletion\"\n assert all(thread_results), \"Some threads did not detect an empty array or error after DEL\"\n" }, { "path": "modules/vector-sets/tests/debug_digest.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass DebugDigestTest(TestCase):\n def getname(self):\n return \"[regression] DEBUG DIGEST-VALUE with attributes\"\n\n def test(self):\n # Generate random vectors\n vec1 = generate_random_vector(4)\n vec2 = generate_random_vector(4)\n vec_bytes1 = struct.pack('4f', *vec1)\n vec_bytes2 = struct.pack('4f', *vec2)\n\n # Add vectors to the key, one with attribute, one without\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes1, f'{self.test_key}:item:1')\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes2, f'{self.test_key}:item:2', 'SETATTR', '{\"color\":\"red\"}')\n\n # Call DEBUG DIGEST-VALUE on the key\n try:\n digest1 = self.redis.execute_command('DEBUG', 'DIGEST-VALUE', self.test_key)\n assert digest1 is not None, \"DEBUG DIGEST-VALUE should return a value\"\n\n # Change attribute and verify digest changes\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:2', '{\"color\":\"blue\"}')\n\n digest2 = self.redis.execute_command('DEBUG', 'DIGEST-VALUE', self.test_key)\n assert digest2 is not None, \"DEBUG DIGEST-VALUE should return a value after attribute change\"\n assert digest1 != digest2, \"Digest should change when an attribute is modified\"\n\n # Remove attribute and verify digest changes again\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:2', '')\n\n digest3 = self.redis.execute_command('DEBUG', 'DIGEST-VALUE', self.test_key)\n assert digest3 is not None, \"DEBUG DIGEST-VALUE should return a value after attribute removal\"\n assert digest2 != digest3, \"Digest should change when an attribute is removed\"\n\n except Exception as e:\n raise AssertionError(f\"DEBUG DIGEST-VALUE command failed: {str(e)}\")\n" }, { "path": "modules/vector-sets/tests/deletion.py", "content": "from test import TestCase, fill_redis_with_vectors, generate_random_vector\nimport random\n\n\"\"\"\nA note about this test:\nIt was experimentally tried to modify hnsw.c in order to\navoid calling hnsw_reconnect_nodes(). In this case, the test\nfails very often with EF set to 250, while it hardly\nfails at all with the same parameters if hnsw_reconnect_nodes()\nis called.\n\nNote that for the nature of the test (it is very strict) it can\nstill fail from time to time, without this signaling any\nactual bug.\n\"\"\"\n\nclass VREM(TestCase):\n def getname(self):\n return \"Deletion and graph state after deletion\"\n\n def estimated_runtime(self):\n return 2.0\n\n def format_neighbors_with_scores(self, links_result, old_links=None, items_to_remove=None):\n \"\"\"Format neighbors with their similarity scores and status indicators\"\"\"\n if not links_result:\n return \"No neighbors\"\n\n output = []\n for level, neighbors in enumerate(links_result):\n level_num = len(links_result) - level - 1\n output.append(f\"Level {level_num}:\")\n\n # Get neighbors and scores\n neighbors_with_scores = []\n for i in range(0, len(neighbors), 2):\n neighbor = neighbors[i].decode() if isinstance(neighbors[i], bytes) else neighbors[i]\n score = float(neighbors[i+1]) if i+1 < len(neighbors) else None\n status = \"\"\n\n # For old links, mark deleted ones\n if items_to_remove and neighbor in items_to_remove:\n status = \" [lost]\"\n # For new links, mark newly added ones\n elif old_links is not None:\n # Check if this neighbor was in the old links at this level\n was_present = False\n if old_links and level < len(old_links):\n old_neighbors = [n.decode() if isinstance(n, bytes) else n\n for n in old_links[level]]\n was_present = neighbor in old_neighbors\n if not was_present:\n status = \" [gained]\"\n\n if score is not None:\n neighbors_with_scores.append(f\"{len(neighbors_with_scores)+1}. {neighbor} ({score:.6f}){status}\")\n else:\n neighbors_with_scores.append(f\"{len(neighbors_with_scores)+1}. {neighbor}{status}\")\n\n output.extend([\" \" + n for n in neighbors_with_scores])\n return \"\\n\".join(output)\n\n def test(self):\n # 1. Fill server with random elements\n dim = 128\n count = 5000\n data = fill_redis_with_vectors(self.redis, self.test_key, count, dim)\n\n # 2. Do VSIM to get 200 items\n query_vec = generate_random_vector(dim)\n results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in query_vec],\n 'COUNT', 200, 'WITHSCORES')\n\n # Convert results to list of (item, score) pairs, sorted by score\n items = []\n for i in range(0, len(results), 2):\n item = results[i].decode()\n score = float(results[i+1])\n items.append((item, score))\n items.sort(key=lambda x: x[1], reverse=True) # Sort by similarity\n\n # Store the graph structure for all items before deletion\n neighbors_before = {}\n for item, _ in items:\n links = self.redis.execute_command('VLINKS', self.test_key, item, 'WITHSCORES')\n if links: # Some items might not have links\n neighbors_before[item] = links\n\n # 3. Remove 100 random items\n items_to_remove = set(item for item, _ in random.sample(items, 100))\n # Keep track of top 10 non-removed items\n top_remaining = []\n for item, score in items:\n if item not in items_to_remove:\n top_remaining.append((item, score))\n if len(top_remaining) == 10:\n break\n\n # Remove the items\n for item in items_to_remove:\n result = self.redis.execute_command('VREM', self.test_key, item)\n assert result == 1, f\"VREM failed to remove {item}\"\n\n # 4. Do VSIM again with same vector\n new_results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in query_vec],\n 'COUNT', 200, 'WITHSCORES',\n 'EF', 500)\n\n # Convert new results to dict of item -> score\n new_scores = {}\n for i in range(0, len(new_results), 2):\n item = new_results[i].decode()\n score = float(new_results[i+1])\n new_scores[item] = score\n\n failure = False\n failed_item = None\n failed_reason = None\n # 5. Verify all top 10 non-removed items are still found with similar scores\n for item, old_score in top_remaining:\n if item not in new_scores:\n failure = True\n failed_item = item\n failed_reason = \"missing\"\n break\n new_score = new_scores[item]\n if abs(new_score - old_score) >= 0.01:\n failure = True\n failed_item = item\n failed_reason = f\"score changed: {old_score:.6f} -> {new_score:.6f}\"\n break\n\n if failure:\n print(\"\\nTest failed!\")\n print(f\"Problem with item: {failed_item} ({failed_reason})\")\n\n print(\"\\nOriginal neighbors (with similarity scores):\")\n if failed_item in neighbors_before:\n print(self.format_neighbors_with_scores(\n neighbors_before[failed_item], \n items_to_remove=items_to_remove))\n else:\n print(\"No neighbors found in original graph\")\n\n print(\"\\nCurrent neighbors (with similarity scores):\")\n current_links = self.redis.execute_command('VLINKS', self.test_key, \n failed_item, 'WITHSCORES')\n if current_links:\n print(self.format_neighbors_with_scores(\n current_links,\n old_links=neighbors_before.get(failed_item)))\n else:\n print(\"No neighbors in current graph\")\n\n print(\"\\nOriginal results (top 20):\")\n for item, score in items[:20]:\n deleted = \"[deleted]\" if item in items_to_remove else \"\"\n print(f\"{item}: {score:.6f} {deleted}\")\n\n print(\"\\nNew results after removal (top 20):\")\n new_items = []\n for i in range(0, len(new_results), 2):\n item = new_results[i].decode()\n score = float(new_results[i+1])\n new_items.append((item, score))\n new_items.sort(key=lambda x: x[1], reverse=True)\n for item, score in new_items[:20]:\n print(f\"{item}: {score:.6f}\")\n\n raise AssertionError(f\"Test failed: Problem with item {failed_item} ({failed_reason}). *** IMPORTANT *** This test may fail from time to time without indicating that there is a bug. However normally it should pass. The fact is that it's a quite extreme test where we destroy 50% of nodes of top results and still expect perfect recall, with vectors that are very hostile because of the distribution used.\")\n\n" }, { "path": "modules/vector-sets/tests/dimension_validation.py", "content": "from test import TestCase, generate_random_vector\nimport struct\nimport redis.exceptions\n\nclass DimensionValidation(TestCase):\n def getname(self):\n return \"[regression] Dimension Validation with Projection\"\n\n def estimated_runtime(self):\n return 0.5\n\n def test(self):\n # Test scenario 1: Create a set with projection\n original_dim = 100\n reduced_dim = 50\n\n # Create the initial vector and set with projection\n vec1 = generate_random_vector(original_dim)\n vec1_bytes = struct.pack(f'{original_dim}f', *vec1)\n\n # Add first vector with projection\n result = self.redis.execute_command('VADD', self.test_key,\n 'REDUCE', reduced_dim,\n 'FP32', vec1_bytes, f'{self.test_key}:item:1')\n assert result == 1, \"First VADD with REDUCE should return 1\"\n\n # Check VINFO returns the correct projection information\n info = self.redis.execute_command('VINFO', self.test_key)\n info_map = {k.decode('utf-8'): v for k, v in zip(info[::2], info[1::2])}\n assert 'vector-dim' in info_map, \"VINFO should contain vector-dim\"\n assert info_map['vector-dim'] == reduced_dim, f\"Expected reduced dimension {reduced_dim}, got {info['vector-dim']}\"\n assert 'projection-input-dim' in info_map, \"VINFO should contain projection-input-dim\"\n assert info_map['projection-input-dim'] == original_dim, f\"Expected original dimension {original_dim}, got {info['projection-input-dim']}\"\n\n # Test scenario 2: Try adding a mismatched vector - should fail\n wrong_dim = 80\n wrong_vec = generate_random_vector(wrong_dim)\n wrong_vec_bytes = struct.pack(f'{wrong_dim}f', *wrong_vec)\n\n # This should fail with dimension mismatch error\n try:\n self.redis.execute_command('VADD', self.test_key,\n 'REDUCE', reduced_dim,\n 'FP32', wrong_vec_bytes, f'{self.test_key}:item:2')\n assert False, \"VADD with wrong dimension should fail\"\n except redis.exceptions.ResponseError as e:\n assert \"Input dimension mismatch for projection\" in str(e), f\"Expected dimension mismatch error, got: {e}\"\n\n # Test scenario 3: Add a correctly-sized vector\n vec2 = generate_random_vector(original_dim)\n vec2_bytes = struct.pack(f'{original_dim}f', *vec2)\n\n # This should succeed\n result = self.redis.execute_command('VADD', self.test_key,\n 'REDUCE', reduced_dim,\n 'FP32', vec2_bytes, f'{self.test_key}:item:3')\n assert result == 1, \"VADD with correct dimensions should succeed\"\n\n # Check VSIM also validates input dimensions\n wrong_query = generate_random_vector(wrong_dim)\n try:\n self.redis.execute_command('VSIM', self.test_key,\n 'VALUES', wrong_dim, *[str(x) for x in wrong_query],\n 'COUNT', 10)\n assert False, \"VSIM with wrong dimension should fail\"\n except redis.exceptions.ResponseError as e:\n assert \"Input dimension mismatch for projection\" in str(e), f\"Expected dimension mismatch error in VSIM, got: {e}\"\n" }, { "path": "modules/vector-sets/tests/epsilon.py", "content": "from test import TestCase\n\nclass EpsilonOption(TestCase):\n def getname(self):\n return \"VSIM EPSILON option filtering\"\n\n def estimated_runtime(self):\n return 0.1\n\n def test(self):\n # Add vectors as shown in the example\n # Vector 'a' at (1, 1) - normalized to (0.707, 0.707)\n result = self.redis.execute_command('VADD', self.test_key, 'VALUES', '2', '1', '1', 'a')\n assert result == 1, \"VADD should return 1 for item 'a'\"\n\n # Vector 'b' at (0, 1) - normalized to (0, 1)\n result = self.redis.execute_command('VADD', self.test_key, 'VALUES', '2', '0', '1', 'b')\n assert result == 1, \"VADD should return 1 for item 'b'\"\n\n # Vector 'c' at (0, 0) - this will be a zero vector, might be handled specially\n result = self.redis.execute_command('VADD', self.test_key, 'VALUES', '2', '0', '0', 'c')\n assert result == 1, \"VADD should return 1 for item 'c'\"\n\n # Vector 'd' at (0, -1) - normalized to (0, -1)\n result = self.redis.execute_command('VADD', self.test_key, 'VALUES', '2', '0', '-1', 'd')\n assert result == 1, \"VADD should return 1 for item 'd'\"\n\n # Vector 'e' at (-1, -1) - normalized to (-0.707, -0.707)\n result = self.redis.execute_command('VADD', self.test_key, 'VALUES', '2', '-1', '-1', 'e')\n assert result == 1, \"VADD should return 1 for item 'e'\"\n\n # Test without EPSILON - should return all items\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', '2', '1', '1', 'WITHSCORES')\n # Result is a flat list: [elem1, score1, elem2, score2, ...]\n elements_all = [result[i].decode() for i in range(0, len(result), 2)]\n scores_all = [float(result[i]) for i in range(1, len(result), 2)]\n\n assert len(elements_all) == 5, f\"Should return 5 elements without EPSILON, got {len(elements_all)}\"\n assert elements_all[0] == 'a', \"First element should be 'a' (most similar)\"\n assert scores_all[0] == 1.0, \"Score for 'a' should be 1.0 (identical)\"\n\n # Test with EPSILON 0.5 - should return only elements with similarity >= 0.5 (distance < 0.5)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', '2', '1', '1', 'WITHSCORES', 'EPSILON', '0.5')\n elements_epsilon_0_5 = [result[i].decode() for i in range(0, len(result), 2)]\n scores_epsilon_0_5 = [float(result[i]) for i in range(1, len(result), 2)]\n\n assert len(elements_epsilon_0_5) == 3, f\"With EPSILON 0.5, should return 3 elements, got {len(elements_epsilon_0_5)}\"\n assert set(elements_epsilon_0_5) == {'a', 'b', 'c'}, f\"With EPSILON 0.5, should get a, b, c, got {elements_epsilon_0_5}\"\n\n # Verify all returned scores are >= 0.5\n for i, score in enumerate(scores_epsilon_0_5):\n assert score >= 0.5, f\"Element {elements_epsilon_0_5[i]} has score {score} which is < 0.5\"\n\n # Test with EPSILON 0.2 - should return only elements with similarity >= 0.8 (distance < 0.2)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', '2', '1', '1', 'WITHSCORES', 'EPSILON', '0.2')\n elements_epsilon_0_2 = [result[i].decode() for i in range(0, len(result), 2)]\n scores_epsilon_0_2 = [float(result[i]) for i in range(1, len(result), 2)]\n\n assert len(elements_epsilon_0_2) == 2, f\"With EPSILON 0.2, should return 2 elements, got {len(elements_epsilon_0_2)}\"\n assert set(elements_epsilon_0_2) == {'a', 'b'}, f\"With EPSILON 0.2, should get a, b, got {elements_epsilon_0_2}\"\n\n # Verify all returned scores are >= 0.8 (since distance < 0.2 means similarity > 0.8)\n for i, score in enumerate(scores_epsilon_0_2):\n assert score >= 0.8, f\"Element {elements_epsilon_0_2[i]} has score {score} which is < 0.8\"\n\n # Test with very small EPSILON - should return only the exact match\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', '2', '1', '1', 'WITHSCORES', 'EPSILON', '0.001')\n elements_epsilon_small = [result[i].decode() for i in range(0, len(result), 2)]\n\n assert len(elements_epsilon_small) == 1, f\"With EPSILON 0.001, should return only 1 element, got {len(elements_epsilon_small)}\"\n assert elements_epsilon_small[0] == 'a', \"With very small EPSILON, should only get 'a'\"\n\n # Test with EPSILON 1.0 - should return all elements (since all similarities are between 0 and 1)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', '2', '1', '1', 'WITHSCORES', 'EPSILON', '1.0')\n elements_epsilon_1 = [result[i].decode() for i in range(0, len(result), 2)]\n\n assert len(elements_epsilon_1) == 5, f\"With EPSILON 1.0, should return all 5 elements, got {len(elements_epsilon_1)}\"\n" }, { "path": "modules/vector-sets/tests/evict_empty.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass VREM_LastItemDeletesKey(TestCase):\n def getname(self):\n return \"VREM last item deletes key\"\n\n def test(self):\n # Generate a random vector\n vec = generate_random_vector(4)\n vec_bytes = struct.pack('4f', *vec)\n\n # Add the vector to the key\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:1')\n assert result == 1, \"VADD should return 1 for first item\"\n\n # Verify the key exists\n exists = self.redis.exists(self.test_key)\n assert exists == 1, \"Key should exist after VADD\"\n\n # Remove the item\n result = self.redis.execute_command('VREM', self.test_key, f'{self.test_key}:item:1')\n assert result == 1, \"VREM should return 1 for successful removal\"\n\n # Verify the key no longer exists\n exists = self.redis.exists(self.test_key)\n assert exists == 0, \"Key should no longer exist after VREM of last item\"\n" }, { "path": "modules/vector-sets/tests/filter_expr.py", "content": "from test import TestCase\n\nclass VSIMFilterExpressions(TestCase):\n def getname(self):\n return \"VSIM FILTER expressions basic functionality\"\n\n def test(self):\n # Create a small set of vectors with different attributes\n\n # Basic vectors for testing - all orthogonal for clear results\n vec1 = [1, 0, 0, 0]\n vec2 = [0, 1, 0, 0]\n vec3 = [0, 0, 1, 0]\n vec4 = [0, 0, 0, 1]\n vec5 = [0.5, 0.5, 0, 0]\n\n # Add vectors with various attributes\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1], f'{self.test_key}:item:1')\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:1',\n '{\"age\": 25, \"name\": \"Alice\", \"active\": true, \"scores\": [85, 90, 95], \"city\": \"New York\"}')\n\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec2], f'{self.test_key}:item:2')\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:2',\n '{\"age\": 30, \"name\": \"Bob\", \"active\": false, \"scores\": [70, 75, 80], \"city\": \"Boston\"}')\n\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec3], f'{self.test_key}:item:3')\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:3',\n '{\"age\": 35, \"name\": \"Charlie\", \"scores\": [60, 65, 70], \"city\": \"Seattle\"}')\n\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec4], f'{self.test_key}:item:4')\n # Item 4 has no attribute at all\n\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec5], f'{self.test_key}:item:5')\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:5',\n 'invalid json') # Intentionally malformed JSON\n\n # Basic equality with numbers\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age == 25')\n assert len(result) == 1, \"Expected 1 result for age == 25\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1 for age == 25\"\n\n # Greater than\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age > 25')\n assert len(result) == 2, \"Expected 2 results for age > 25\"\n\n # Less than or equal\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age <= 30')\n assert len(result) == 2, \"Expected 2 results for age <= 30\"\n\n # String equality\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.name == \"Alice\"')\n assert len(result) == 1, \"Expected 1 result for name == Alice\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1 for name == Alice\"\n\n # String inequality\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.name != \"Alice\"')\n assert len(result) == 2, \"Expected 2 results for name != Alice\"\n\n # Boolean value\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.active')\n assert len(result) == 1, \"Expected 1 result for .active being true\"\n\n # Logical AND\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age > 20 and .age < 30')\n assert len(result) == 1, \"Expected 1 result for 20 < age < 30\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1 for 20 < age < 30\"\n\n # Logical OR\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age < 30 or .age > 35')\n assert len(result) == 1, \"Expected 1 result for age < 30 or age > 35\"\n\n # Logical NOT\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '!(.age == 25)')\n assert len(result) == 2, \"Expected 2 results for NOT(age == 25)\"\n\n # The \"in\" operator with array\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age in [25, 35]')\n assert len(result) == 2, \"Expected 2 results for age in [25, 35]\"\n\n # The \"in\" operator with strings in array\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.name in [\"Alice\", \"David\"]')\n assert len(result) == 1, \"Expected 1 result for name in [Alice, David]\"\n\n # The \"in\" operator for substring matching\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"lic\" in .name')\n assert len(result) == 1, \"Expected 1 result for 'lic' in name\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1 (Alice)\"\n\n # The \"in\" operator with city substring\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"ork\" in .city')\n assert len(result) == 1, \"Expected 1 result for 'ork' in city\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1 (New York)\"\n\n # The \"in\" operator with no matches\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"xyz\" in .name')\n assert len(result) == 0, \"Expected 0 results for 'xyz' in name\"\n\n # Off-by-one tests - substring at the beginning\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"Ali\" in .name')\n assert len(result) == 1, \"Expected 1 result for 'Ali' at beginning of 'Alice'\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1\"\n\n # Off-by-one tests - substring at the end\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"ice\" in .name')\n assert len(result) == 1, \"Expected 1 result for 'ice' at end of 'Alice'\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1\"\n\n # Off-by-one tests - exact match (entire string)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"Alice\" in .name')\n assert len(result) == 1, \"Expected 1 result for exact match 'Alice' in 'Alice'\"\n assert result[0].decode() == f'{self.test_key}:item:1', \"Expected item:1\"\n\n # Off-by-one tests - single character\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"A\" in .name')\n assert len(result) == 1, \"Expected 1 result for single char 'A' in 'Alice'\"\n\n # Off-by-one tests - empty string (should match all strings)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"\" in .name')\n assert len(result) == 3, \"Expected 3 results for empty string (matches all strings)\"\n\n # Off-by-one tests - non-empty strings are never substrings of \"\"\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.name in \"\"')\n assert len(result) == 0, \"Expected 0 results for empty string on the right of IN operator\"\n\n # Off-by-one tests - empty string match empty string.\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '\"\" in .name && \"\" in \"\"')\n assert len(result) == 3, \"Expected empty string matching empty string\"\n\n # Arithmetic operations - addition\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age + 10 > 40')\n assert len(result) == 1, \"Expected 1 result for age + 10 > 40\"\n\n # Arithmetic operations - multiplication\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age * 2 > 60')\n assert len(result) == 1, \"Expected 1 result for age * 2 > 60\"\n\n # Arithmetic operations - division\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age / 5 == 5')\n assert len(result) == 1, \"Expected 1 result for age / 5 == 5\"\n\n # Arithmetic operations - modulo\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age % 2 == 0')\n assert len(result) == 1, \"Expected 1 result for age % 2 == 0\"\n\n # Power operator\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age ** 2 > 900')\n assert len(result) == 1, \"Expected 1 result for age^2 > 900\"\n\n # Missing attribute (should exclude items missing that attribute)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.missing_field == \"value\"')\n assert len(result) == 0, \"Expected 0 results for missing_field == value\"\n\n # No attribute set at all\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.any_field')\n assert f'{self.test_key}:item:4' not in [item.decode() for item in result], \"Item with no attribute should be excluded\"\n\n # Malformed JSON\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.any_field')\n assert f'{self.test_key}:item:5' not in [item.decode() for item in result], \"Item with malformed JSON should be excluded\"\n\n # Complex expression combining multiple operators\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '(.age > 20 and .age < 40) and (.city == \"Boston\" or .city == \"New York\")')\n assert len(result) == 2, \"Expected 2 results for the complex expression\"\n expected_items = [f'{self.test_key}:item:1', f'{self.test_key}:item:2']\n assert set([item.decode() for item in result]) == set(expected_items), \"Expected item:1 and item:2 for the complex expression\"\n\n # Parentheses to control operator precedence\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.age > (20 + 10)')\n assert len(result) == 1, \"Expected 1 result for age > (20 + 10)\"\n\n # Array access (arrays evaluate to true)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4,\n *[str(x) for x in vec1],\n 'FILTER', '.scores')\n assert len(result) == 3, \"Expected 3 results for .scores (arrays evaluate to true)\"\n" }, { "path": "modules/vector-sets/tests/filter_int.py", "content": "from test import TestCase, generate_random_vector\nimport struct\nimport random\nimport math\nimport json\nimport time\n\nclass VSIMFilterAdvanced(TestCase):\n def getname(self):\n return \"VSIM FILTER comprehensive functionality testing\"\n\n def estimated_runtime(self):\n return 15 # This test might take up to 15 seconds for the large dataset\n\n def setup(self):\n super().setup()\n self.dim = 32 # Vector dimension\n self.count = 5000 # Number of vectors for large tests\n self.small_count = 50 # Number of vectors for small/quick tests\n\n # Categories for attributes\n self.categories = [\"electronics\", \"furniture\", \"clothing\", \"books\", \"food\"]\n self.cities = [\"New York\", \"London\", \"Tokyo\", \"Paris\", \"Berlin\", \"Sydney\", \"Toronto\", \"Singapore\"]\n self.price_ranges = [(10, 50), (50, 200), (200, 1000), (1000, 5000)]\n self.years = list(range(2000, 2025))\n\n def create_attributes(self, index):\n \"\"\"Create realistic attributes for a vector\"\"\"\n category = random.choice(self.categories)\n city = random.choice(self.cities)\n min_price, max_price = random.choice(self.price_ranges)\n price = round(random.uniform(min_price, max_price), 2)\n year = random.choice(self.years)\n in_stock = random.random() > 0.3 # 70% chance of being in stock\n rating = round(random.uniform(1, 5), 1)\n views = int(random.expovariate(1/1000)) # Exponential distribution for page views\n tags = random.sample([\"popular\", \"sale\", \"new\", \"limited\", \"exclusive\", \"clearance\"],\n k=random.randint(0, 3))\n\n # Add some specific patterns for testing\n # Every 10th item has a specific property combination for testing\n is_premium = (index % 10 == 0)\n\n # Create attributes dictionary\n attrs = {\n \"id\": index,\n \"category\": category,\n \"location\": city,\n \"price\": price,\n \"year\": year,\n \"in_stock\": in_stock,\n \"rating\": rating,\n \"views\": views,\n \"tags\": tags\n }\n\n if is_premium:\n attrs[\"is_premium\"] = True\n attrs[\"special_features\"] = [\"premium\", \"warranty\", \"support\"]\n\n # Add sub-categories for more complex filters\n if category == \"electronics\":\n attrs[\"subcategory\"] = random.choice([\"phones\", \"computers\", \"cameras\", \"audio\"])\n elif category == \"furniture\":\n attrs[\"subcategory\"] = random.choice([\"chairs\", \"tables\", \"sofas\", \"beds\"])\n elif category == \"clothing\":\n attrs[\"subcategory\"] = random.choice([\"shirts\", \"pants\", \"dresses\", \"shoes\"])\n\n # Add some intentionally missing fields for testing\n if random.random() > 0.9: # 10% chance of missing price\n del attrs[\"price\"]\n\n # Some items have promotion field\n if random.random() > 0.7: # 30% chance of having a promotion\n attrs[\"promotion\"] = random.choice([\"discount\", \"bundle\", \"gift\"])\n\n # Create invalid JSON for a small percentage of vectors\n if random.random() > 0.98: # 2% chance of having invalid JSON\n return \"{{invalid json}}\"\n\n return json.dumps(attrs)\n\n def create_vectors_with_attributes(self, key, count):\n \"\"\"Create vectors and add attributes to them\"\"\"\n vectors = []\n names = []\n attribute_map = {} # To store attributes for verification\n\n # Create vectors\n for i in range(count):\n vec = generate_random_vector(self.dim)\n vectors.append(vec)\n name = f\"{key}:item:{i}\"\n names.append(name)\n\n # Add to Redis\n vec_bytes = struct.pack(f'{self.dim}f', *vec)\n self.redis.execute_command('VADD', key, 'FP32', vec_bytes, name)\n\n # Create and add attributes\n attrs = self.create_attributes(i)\n self.redis.execute_command('VSETATTR', key, name, attrs)\n\n # Store attributes for later verification\n try:\n attribute_map[name] = json.loads(attrs) if '{' in attrs else None\n except json.JSONDecodeError:\n attribute_map[name] = None\n\n return vectors, names, attribute_map\n\n def filter_linear_search(self, vectors, names, query_vector, filter_expr, attribute_map, k=10):\n \"\"\"Perform a linear search with filtering for verification\"\"\"\n similarities = []\n query_norm = math.sqrt(sum(x*x for x in query_vector))\n\n if query_norm == 0:\n return []\n\n for i, vec in enumerate(vectors):\n name = names[i]\n attributes = attribute_map.get(name)\n\n # Skip if doesn't match filter\n if not self.matches_filter(attributes, filter_expr):\n continue\n\n vec_norm = math.sqrt(sum(x*x for x in vec))\n if vec_norm == 0:\n continue\n\n dot_product = sum(a*b for a,b in zip(query_vector, vec))\n cosine_sim = dot_product / (query_norm * vec_norm)\n distance = 1.0 - cosine_sim\n redis_similarity = 1.0 - (distance/2.0)\n similarities.append((name, redis_similarity))\n\n similarities.sort(key=lambda x: x[1], reverse=True)\n return similarities[:k]\n\n def matches_filter(self, attributes, filter_expr):\n \"\"\"Filter matching for verification - uses Python eval to handle complex expressions\"\"\"\n if attributes is None:\n return False # No attributes or invalid JSON\n\n # Replace JSON path selectors with Python dictionary access\n py_expr = filter_expr\n\n # Handle `.field` notation (replace with attributes['field'])\n i = 0\n while i < len(py_expr):\n if py_expr[i] == '.' and (i == 0 or not py_expr[i-1].isalnum()):\n # Find the end of the selector (stops at operators or whitespace)\n j = i + 1\n while j < len(py_expr) and (py_expr[j].isalnum() or py_expr[j] == '_'):\n j += 1\n\n if j > i + 1: # Found a valid selector\n field = py_expr[i+1:j]\n # Use a safe access pattern that returns a default value based on context\n py_expr = py_expr[:i] + f\"attributes.get('{field}')\" + py_expr[j:]\n i = i + len(f\"attributes.get('{field}')\")\n else:\n i += 1\n else:\n i += 1\n\n # Convert not operator if needed\n py_expr = py_expr.replace('!', ' not ')\n\n try:\n # Custom evaluation that handles exceptions for missing fields\n # by returning False for the entire expression\n\n # Split the expression on logical operators\n parts = []\n for op in [' and ', ' or ']:\n if op in py_expr:\n parts = py_expr.split(op)\n break\n\n if not parts: # No logical operators found\n parts = [py_expr]\n\n # Try to evaluate each part - if any part fails,\n # the whole expression should fail\n try:\n result = eval(py_expr, {\"attributes\": attributes})\n return bool(result)\n except (TypeError, AttributeError):\n # This typically happens when trying to compare None with\n # numbers or other types, or when an attribute doesn't exist\n return False\n except Exception as e:\n print(f\"Error evaluating filter expression '{filter_expr}' as '{py_expr}': {e}\")\n return False\n\n except Exception as e:\n print(f\"Error evaluating filter expression '{filter_expr}' as '{py_expr}': {e}\")\n return False\n\n def safe_decode(self,item):\n return item.decode() if isinstance(item, bytes) else item\n\n def calculate_recall(self, redis_results, linear_results, k=10):\n \"\"\"Calculate recall (percentage of correct results retrieved)\"\"\"\n redis_set = set(self.safe_decode(item) for item in redis_results)\n linear_set = set(item[0] for item in linear_results[:k])\n\n if not linear_set:\n return 1.0 # If no linear results, consider it perfect recall\n\n intersection = redis_set.intersection(linear_set)\n return len(intersection) / len(linear_set)\n\n def test_recall_with_filter(self, filter_expr, ef=500, filter_ef=None):\n \"\"\"Test recall for a given filter expression\"\"\"\n # Create query vector\n query_vec = generate_random_vector(self.dim)\n\n # First, get ground truth using linear scan\n linear_results = self.filter_linear_search(\n self.vectors, self.names, query_vec, filter_expr, self.attribute_map, k=50)\n\n # Calculate true selectivity from ground truth\n true_selectivity = len(linear_results) / len(self.names) if self.names else 0\n\n # Perform Redis search with filter\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 50, 'WITHSCORES', 'EF', ef, 'FILTER', filter_expr])\n if filter_ef:\n cmd_args.extend(['FILTER-EF', filter_ef])\n\n start_time = time.time()\n redis_results = self.redis.execute_command(*cmd_args)\n query_time = time.time() - start_time\n\n # Convert Redis results to dict\n redis_items = {}\n for i in range(0, len(redis_results), 2):\n key = redis_results[i].decode() if isinstance(redis_results[i], bytes) else redis_results[i]\n score = float(redis_results[i+1])\n redis_items[key] = score\n\n # Calculate metrics\n recall = self.calculate_recall(redis_items.keys(), linear_results)\n selectivity = len(redis_items) / len(self.names) if redis_items else 0\n\n # Compare against the true selectivity from linear scan\n assert abs(selectivity - true_selectivity) < 0.1, \\\n f\"Redis selectivity {selectivity:.3f} differs significantly from ground truth {true_selectivity:.3f}\"\n\n # We expect high recall for standard parameters\n if ef >= 500 and (filter_ef is None or filter_ef >= 1000):\n try:\n assert recall >= 0.7, \\\n f\"Low recall {recall:.2f} for filter '{filter_expr}'\"\n except AssertionError as e:\n # Get items found in each set\n redis_items_set = set(redis_items.keys())\n linear_items_set = set(item[0] for item in linear_results)\n\n # Find items in each set\n only_in_redis = redis_items_set - linear_items_set\n only_in_linear = linear_items_set - redis_items_set\n in_both = redis_items_set & linear_items_set\n\n # Build comprehensive debug message\n debug = f\"\\nGround Truth: {len(linear_results)} matching items (total vectors: {len(self.vectors)})\"\n debug += f\"\\nRedis Found: {len(redis_items)} items with FILTER-EF: {filter_ef or 'default'}\"\n debug += f\"\\nItems in both sets: {len(in_both)} (recall: {recall:.4f})\"\n debug += f\"\\nItems only in Redis: {len(only_in_redis)}\"\n debug += f\"\\nItems only in Ground Truth: {len(only_in_linear)}\"\n\n # Show some example items from each set with their scores\n if only_in_redis:\n debug += \"\\n\\nTOP 5 ITEMS ONLY IN REDIS:\"\n sorted_redis = sorted([(k, v) for k, v in redis_items.items()], key=lambda x: x[1], reverse=True)\n for i, (item, score) in enumerate(sorted_redis[:5]):\n if item in only_in_redis:\n debug += f\"\\n {i+1}. {item} (Score: {score:.4f})\"\n\n # Show attribute that should match filter\n attr = self.attribute_map.get(item)\n if attr:\n debug += f\" - Attrs: {attr.get('category', 'N/A')}, Price: {attr.get('price', 'N/A')}\"\n\n if only_in_linear:\n debug += \"\\n\\nTOP 5 ITEMS ONLY IN GROUND TRUTH:\"\n for i, (item, score) in enumerate(linear_results[:5]):\n if item in only_in_linear:\n debug += f\"\\n {i+1}. {item} (Score: {score:.4f})\"\n\n # Show attribute that should match filter\n attr = self.attribute_map.get(item)\n if attr:\n debug += f\" - Attrs: {attr.get('category', 'N/A')}, Price: {attr.get('price', 'N/A')}\"\n\n # Help identify parsing issues\n debug += \"\\n\\nPARSING CHECK:\"\n debug += f\"\\nRedis command: VSIM {self.test_key} VALUES {self.dim} [...] FILTER '{filter_expr}'\"\n\n # Check for WITHSCORES handling issues\n if len(redis_results) > 0 and len(redis_results) % 2 == 0:\n debug += f\"\\nRedis returned {len(redis_results)} items (looks like item,score pairs)\"\n debug += f\"\\nFirst few results: {redis_results[:4]}\"\n\n # Check the filter implementation\n debug += \"\\n\\nFILTER IMPLEMENTATION CHECK:\"\n debug += f\"\\nFilter expression: '{filter_expr}'\"\n debug += \"\\nSample attribute matches from attribute_map:\"\n count_matching = 0\n for i, (name, attrs) in enumerate(self.attribute_map.items()):\n if attrs and self.matches_filter(attrs, filter_expr):\n count_matching += 1\n if i < 3: # Show first 3 matches\n debug += f\"\\n - {name}: {attrs}\"\n debug += f\"\\nTotal items matching filter in attribute_map: {count_matching}\"\n\n # Check if results array handling could be wrong\n debug += \"\\n\\nRESULT ARRAYS CHECK:\"\n if len(linear_results) >= 1:\n debug += f\"\\nlinear_results[0]: {linear_results[0]}\"\n if isinstance(linear_results[0], tuple) and len(linear_results[0]) == 2:\n debug += \" (correct tuple format: (name, score))\"\n else:\n debug += \" (UNEXPECTED FORMAT!)\"\n\n # Debug sort order\n debug += \"\\n\\nSORTING CHECK:\"\n if len(linear_results) >= 2:\n debug += f\"\\nGround truth first item score: {linear_results[0][1]}\"\n debug += f\"\\nGround truth second item score: {linear_results[1][1]}\"\n debug += f\"\\nCorrectly sorted by similarity? {linear_results[0][1] >= linear_results[1][1]}\"\n\n # Re-raise with detailed information\n raise AssertionError(str(e) + debug)\n\n return recall, selectivity, query_time, len(redis_items)\n\n def test(self):\n print(f\"\\nRunning comprehensive VSIM FILTER tests...\")\n\n # Create a larger dataset for testing\n print(f\"Creating dataset with {self.count} vectors and attributes...\")\n self.vectors, self.names, self.attribute_map = self.create_vectors_with_attributes(\n self.test_key, self.count)\n\n # ==== 1. Recall and Precision Testing ====\n print(\"Testing recall for various filters...\")\n\n # Test basic filters with different selectivity\n results = {}\n results[\"category\"] = self.test_recall_with_filter('.category == \"electronics\"')\n results[\"price_high\"] = self.test_recall_with_filter('.price > 1000')\n results[\"in_stock\"] = self.test_recall_with_filter('.in_stock')\n results[\"rating\"] = self.test_recall_with_filter('.rating >= 4')\n results[\"complex1\"] = self.test_recall_with_filter('.category == \"electronics\" and .price < 500')\n\n print(\"Filter | Recall | Selectivity | Time (ms) | Results\")\n print(\"----------------------------------------------------\")\n for name, (recall, selectivity, time_ms, count) in results.items():\n print(f\"{name:7} | {recall:.3f} | {selectivity:.3f} | {time_ms*1000:.1f} | {count}\")\n\n # ==== 2. Filter Selectivity Performance ====\n print(\"\\nTesting filter selectivity performance...\")\n\n # High selectivity (very few matches)\n high_sel_recall, _, high_sel_time, _ = self.test_recall_with_filter('.is_premium')\n\n # Medium selectivity\n med_sel_recall, _, med_sel_time, _ = self.test_recall_with_filter('.price > 100 and .price < 1000')\n\n # Low selectivity (many matches)\n low_sel_recall, _, low_sel_time, _ = self.test_recall_with_filter('.year > 2000')\n\n print(f\"High selectivity recall: {high_sel_recall:.3f}, time: {high_sel_time*1000:.1f}ms\")\n print(f\"Med selectivity recall: {med_sel_recall:.3f}, time: {med_sel_time*1000:.1f}ms\")\n print(f\"Low selectivity recall: {low_sel_recall:.3f}, time: {low_sel_time*1000:.1f}ms\")\n\n # ==== 3. FILTER-EF Parameter Testing ====\n print(\"\\nTesting FILTER-EF parameter...\")\n\n # Test with different FILTER-EF values\n filter_expr = '.category == \"electronics\" and .price > 200'\n ef_values = [100, 500, 2000, 5000]\n\n print(\"FILTER-EF | Recall | Time (ms)\")\n print(\"-----------------------------\")\n for filter_ef in ef_values:\n recall, _, query_time, _ = self.test_recall_with_filter(\n filter_expr, ef=500, filter_ef=filter_ef)\n print(f\"{filter_ef:9} | {recall:.3f} | {query_time*1000:.1f}\")\n\n # Assert that higher FILTER-EF generally gives better recall\n low_ef_recall, _, _, _ = self.test_recall_with_filter(filter_expr, filter_ef=100)\n high_ef_recall, _, _, _ = self.test_recall_with_filter(filter_expr, filter_ef=5000)\n\n # This might not always be true due to randomness, but generally holds\n # We use a softer assertion to avoid flaky tests\n assert high_ef_recall >= low_ef_recall * 0.8, \\\n f\"Higher FILTER-EF should generally give better recall: {high_ef_recall:.3f} vs {low_ef_recall:.3f}\"\n\n # ==== 4. Complex Filter Expressions ====\n print(\"\\nTesting complex filter expressions...\")\n\n # Test a variety of complex expressions\n complex_filters = [\n '.price > 100 and (.category == \"electronics\" or .category == \"furniture\")',\n '(.rating > 4 and .in_stock) or (.price < 50 and .views > 1000)',\n '.category in [\"electronics\", \"clothing\"] and .price > 200 and .rating >= 3',\n '(.category == \"electronics\" and .subcategory == \"phones\") or (.category == \"furniture\" and .price > 1000)',\n '.year > 2010 and !(.price < 100) and .in_stock'\n ]\n\n print(\"Expression | Results | Time (ms)\")\n print(\"-----------------------------\")\n for i, expr in enumerate(complex_filters):\n try:\n _, _, query_time, result_count = self.test_recall_with_filter(expr)\n print(f\"Complex {i+1} | {result_count:7} | {query_time*1000:.1f}\")\n except Exception as e:\n print(f\"Complex {i+1} | Error: {str(e)}\")\n\n # ==== 5. Attribute Type Testing ====\n print(\"\\nTesting different attribute types...\")\n\n type_filters = [\n ('.price > 500', \"Numeric\"),\n ('.category == \"books\"', \"String equality\"),\n ('.in_stock', \"Boolean\"),\n ('.tags in [\"sale\", \"new\"]', \"Array membership\"),\n ('.rating * 2 > 8', \"Arithmetic\")\n ]\n\n for expr, type_name in type_filters:\n try:\n _, _, query_time, result_count = self.test_recall_with_filter(expr)\n print(f\"{type_name:16} | {expr:30} | {result_count:5} results | {query_time*1000:.1f}ms\")\n except Exception as e:\n print(f\"{type_name:16} | {expr:30} | Error: {str(e)}\")\n\n # ==== 6. Filter + Count Interaction ====\n print(\"\\nTesting COUNT parameter with filters...\")\n\n filter_expr = '.category == \"electronics\"'\n counts = [5, 20, 100]\n\n for count in counts:\n query_vec = generate_random_vector(self.dim)\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', count, 'WITHSCORES', 'FILTER', filter_expr])\n\n results = self.redis.execute_command(*cmd_args)\n result_count = len(results) // 2 # Divide by 2 because WITHSCORES returns pairs\n\n # We expect result count to be at most the requested count\n assert result_count <= count, f\"Got {result_count} results with COUNT {count}\"\n print(f\"COUNT {count:3} | Got {result_count:3} results\")\n\n # ==== 7. Edge Cases ====\n print(\"\\nTesting edge cases...\")\n\n # Test with no matching items\n no_match_expr = '.category == \"nonexistent_category\"'\n results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', self.dim,\n *[str(x) for x in generate_random_vector(self.dim)],\n 'FILTER', no_match_expr)\n assert len(results) == 0, f\"Expected 0 results for non-matching filter, got {len(results)}\"\n print(f\"No matching items: {len(results)} results (expected 0)\")\n\n # Test with invalid filter syntax\n try:\n self.redis.execute_command('VSIM', self.test_key, 'VALUES', self.dim,\n *[str(x) for x in generate_random_vector(self.dim)],\n 'FILTER', '.category === \"books\"') # Triple equals is invalid\n assert False, \"Expected error for invalid filter syntax\"\n except:\n print(\"Invalid filter syntax correctly raised an error\")\n\n # Test with extremely long complex expression\n long_expr = ' and '.join([f'.rating > {i/10}' for i in range(10)])\n try:\n results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', self.dim,\n *[str(x) for x in generate_random_vector(self.dim)],\n 'FILTER', long_expr)\n print(f\"Long expression: {len(results)} results\")\n except Exception as e:\n print(f\"Long expression error: {str(e)}\")\n\n print(\"\\nComprehensive VSIM FILTER tests completed successfully\")\n\n\nclass VSIMFilterSelectivityTest(TestCase):\n def getname(self):\n return \"VSIM FILTER selectivity performance benchmark\"\n\n def estimated_runtime(self):\n return 8 # This test might take up to 8 seconds\n\n def setup(self):\n super().setup()\n self.dim = 32\n self.count = 10000\n self.test_key = f\"{self.test_key}:selectivity\" # Use a different key\n\n def create_vector_with_age_attribute(self, name, age):\n \"\"\"Create a vector with a specific age attribute\"\"\"\n vec = generate_random_vector(self.dim)\n vec_bytes = struct.pack(f'{self.dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, name)\n self.redis.execute_command('VSETATTR', self.test_key, name, json.dumps({\"age\": age}))\n\n def test(self):\n print(\"\\nRunning VSIM FILTER selectivity benchmark...\")\n\n # Create a dataset where we control the exact selectivity\n print(f\"Creating controlled dataset with {self.count} vectors...\")\n\n # Create vectors with age attributes from 1 to 100\n for i in range(self.count):\n age = (i % 100) + 1 # Ages from 1 to 100\n name = f\"{self.test_key}:item:{i}\"\n self.create_vector_with_age_attribute(name, age)\n\n # Create a query vector\n query_vec = generate_random_vector(self.dim)\n\n # Test filters with different selectivities\n selectivities = [0.01, 0.05, 0.10, 0.25, 0.50, 0.75, 0.99]\n results = []\n\n print(\"\\nSelectivity | Filter | Results | Time (ms)\")\n print(\"--------------------------------------------------\")\n\n for target_selectivity in selectivities:\n # Calculate age threshold for desired selectivity\n # For example, age <= 10 gives 10% selectivity\n age_threshold = int(target_selectivity * 100)\n filter_expr = f'.age <= {age_threshold}'\n\n # Run query and measure time\n start_time = time.time()\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 100, 'FILTER', filter_expr])\n\n results = self.redis.execute_command(*cmd_args)\n query_time = time.time() - start_time\n\n actual_selectivity = len(results) / min(100, int(target_selectivity * self.count))\n print(f\"{target_selectivity:.2f} | {filter_expr:15} | {len(results):7} | {query_time*1000:.1f}\")\n\n # Add assertion to ensure reasonable performance for different selectivities\n # For very selective queries (1%), we might need more exploration\n if target_selectivity <= 0.05:\n # For very selective queries, ensure we can find some results\n assert len(results) > 0, f\"No results found for {filter_expr}\"\n else:\n # For less selective queries, performance should be reasonable\n assert query_time < 1.0, f\"Query too slow: {query_time:.3f}s for {filter_expr}\"\n\n print(\"\\nSelectivity benchmark completed successfully\")\n\n\nclass VSIMFilterComparisonTest(TestCase):\n def getname(self):\n return \"VSIM FILTER EF parameter comparison\"\n\n def estimated_runtime(self):\n return 8 # This test might take up to 8 seconds\n\n def setup(self):\n super().setup()\n self.dim = 32\n self.count = 5000\n self.test_key = f\"{self.test_key}:efparams\" # Use a different key\n\n def create_dataset(self):\n \"\"\"Create a dataset with specific attribute patterns for testing FILTER-EF\"\"\"\n vectors = []\n names = []\n\n # Create vectors with category and quality score attributes\n for i in range(self.count):\n vec = generate_random_vector(self.dim)\n name = f\"{self.test_key}:item:{i}\"\n\n # Add vector to Redis\n vec_bytes = struct.pack(f'{self.dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, name)\n\n # Create attributes - we want a very selective filter\n # Only 2% of items have category=premium AND quality>90\n category = \"premium\" if random.random() < 0.1 else random.choice([\"standard\", \"economy\", \"basic\"])\n quality = random.randint(1, 100)\n\n attrs = {\n \"id\": i,\n \"category\": category,\n \"quality\": quality\n }\n\n self.redis.execute_command('VSETATTR', self.test_key, name, json.dumps(attrs))\n vectors.append(vec)\n names.append(name)\n\n return vectors, names\n\n def test(self):\n print(\"\\nRunning VSIM FILTER-EF parameter comparison...\")\n\n # Create dataset\n vectors, names = self.create_dataset()\n\n # Create a selective filter that matches ~2% of items\n filter_expr = '.category == \"premium\" and .quality > 90'\n\n # Create query vector\n query_vec = generate_random_vector(self.dim)\n\n # Test different FILTER-EF values\n ef_values = [50, 100, 500, 1000, 5000]\n results = []\n\n print(\"\\nFILTER-EF | Results | Time (ms) | Notes\")\n print(\"---------------------------------------\")\n\n baseline_count = None\n\n for ef in ef_values:\n # Run query and measure time\n start_time = time.time()\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 100, 'FILTER', filter_expr, 'FILTER-EF', ef])\n\n query_results = self.redis.execute_command(*cmd_args)\n query_time = time.time() - start_time\n\n # Set baseline for comparison\n if baseline_count is None:\n baseline_count = len(query_results)\n\n recall_rate = len(query_results) / max(1, baseline_count) if baseline_count > 0 else 1.0\n\n notes = \"\"\n if ef == 5000:\n notes = \"Baseline\"\n elif recall_rate < 0.5:\n notes = \"Low recall!\"\n\n print(f\"{ef:9} | {len(query_results):7} | {query_time*1000:.1f} | {notes}\")\n results.append((ef, len(query_results), query_time))\n\n # If we have enough results at highest EF, check that recall improves with higher EF\n if results[-1][1] >= 5: # At least 5 results for highest EF\n # Extract result counts\n result_counts = [r[1] for r in results]\n\n # The last result (highest EF) should typically find more results than the first (lowest EF)\n # but we use a soft assertion to avoid flaky tests\n assert result_counts[-1] >= result_counts[0], \\\n f\"Higher FILTER-EF should find at least as many results: {result_counts[-1]} vs {result_counts[0]}\"\n\n print(\"\\nFILTER-EF parameter comparison completed successfully\")\n" }, { "path": "modules/vector-sets/tests/large_scale.py", "content": "from test import TestCase, fill_redis_with_vectors, generate_random_vector\nimport random\n\nclass LargeScale(TestCase):\n def getname(self):\n return \"Large Scale Comparison\"\n\n def estimated_runtime(self):\n return 10\n\n def test(self):\n dim = 300\n count = 20000\n k = 50\n\n # Fill Redis and get reference data for comparison\n random.seed(42) # Make test deterministic\n data = fill_redis_with_vectors(self.redis, self.test_key, count, dim)\n\n # Generate query vector\n query_vec = generate_random_vector(dim)\n\n # Get results from Redis with good exploration factor\n redis_raw = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim, \n *[str(x) for x in query_vec],\n 'COUNT', k, 'WITHSCORES', 'EF', 500)\n\n # Convert Redis results to dict\n redis_results = {}\n for i in range(0, len(redis_raw), 2):\n key = redis_raw[i].decode()\n score = float(redis_raw[i+1])\n redis_results[key] = score\n\n # Get results from linear scan\n linear_results = data.find_k_nearest(query_vec, k)\n linear_items = {name: score for name, score in linear_results}\n\n # Compare overlap\n redis_set = set(redis_results.keys())\n linear_set = set(linear_items.keys())\n overlap = len(redis_set & linear_set)\n\n # If test fails, print comparison for debugging\n if overlap < k * 0.7:\n data.print_comparison({'items': redis_results, 'query_vector': query_vec}, k)\n\n assert overlap >= k * 0.7, \\\n f\"Expected at least 70% overlap in top {k} results, got {overlap/k*100:.1f}%\"\n\n # Verify scores for common items\n for item in redis_set & linear_set:\n redis_score = redis_results[item]\n linear_score = linear_items[item]\n assert abs(redis_score - linear_score) < 0.01, \\\n f\"Score mismatch for {item}: Redis={redis_score:.3f} Linear={linear_score:.3f}\"\n" }, { "path": "modules/vector-sets/tests/memory_usage.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass MemoryUsageTest(TestCase):\n def getname(self):\n return \"[regression] MEMORY USAGE with attributes\"\n\n def test(self):\n # Generate random vectors\n vec1 = generate_random_vector(4)\n vec2 = generate_random_vector(4)\n vec_bytes1 = struct.pack('4f', *vec1)\n vec_bytes2 = struct.pack('4f', *vec2)\n\n # Add vectors to the key, one with attribute, one without\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes1, f'{self.test_key}:item:1')\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes2, f'{self.test_key}:item:2', 'SETATTR', '{\"color\":\"red\"}')\n\n # Get memory usage for the key\n try:\n memory_usage = self.redis.execute_command('MEMORY', 'USAGE', self.test_key)\n # If we got here without exception, the command worked\n assert memory_usage > 0, \"MEMORY USAGE should return a positive value\"\n\n # Add more attributes to increase complexity\n self.redis.execute_command('VSETATTR', self.test_key, f'{self.test_key}:item:1', '{\"color\":\"blue\",\"size\":10}')\n\n # Check memory usage again\n new_memory_usage = self.redis.execute_command('MEMORY', 'USAGE', self.test_key)\n assert new_memory_usage > 0, \"MEMORY USAGE should still return a positive value after setting attributes\"\n\n # Memory usage should be higher after adding attributes\n assert new_memory_usage > memory_usage, \"Memory usage increase after adding attributes\"\n\n except Exception as e:\n raise AssertionError(f\"MEMORY USAGE command failed: {str(e)}\")\n" }, { "path": "modules/vector-sets/tests/node_update.py", "content": "from test import TestCase, generate_random_vector\nimport struct\nimport math\nimport random\n\nclass VectorUpdateAndClusters(TestCase):\n def getname(self):\n return \"VADD vector update with cluster relocation\"\n\n def estimated_runtime(self):\n return 2.0 # Should take around 2 seconds\n\n def generate_cluster_vector(self, base_vec, noise=0.1):\n \"\"\"Generate a vector that's similar to base_vec with some noise.\"\"\"\n vec = [x + random.gauss(0, noise) for x in base_vec]\n # Normalize\n norm = math.sqrt(sum(x*x for x in vec))\n return [x/norm for x in vec]\n\n def test(self):\n dim = 128\n vectors_per_cluster = 5000\n\n # Create two very different base vectors for our clusters\n cluster1_base = generate_random_vector(dim)\n cluster2_base = [-x for x in cluster1_base] # Opposite direction\n\n # Add vectors from first cluster\n for i in range(vectors_per_cluster):\n vec = self.generate_cluster_vector(cluster1_base)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes,\n f'{self.test_key}:cluster1:{i}')\n\n # Add vectors from second cluster\n for i in range(vectors_per_cluster):\n vec = self.generate_cluster_vector(cluster2_base)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes,\n f'{self.test_key}:cluster2:{i}')\n\n # Pick a test vector from cluster1\n test_key = f'{self.test_key}:cluster1:0'\n\n # Verify it's in cluster1 using VSIM\n initial_vec = self.generate_cluster_vector(cluster1_base)\n results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in initial_vec],\n 'COUNT', 100, 'WITHSCORES')\n\n # Count how many cluster1 items are in top results\n cluster1_count = sum(1 for i in range(0, len(results), 2)\n if b'cluster1' in results[i])\n assert cluster1_count > 80, \"Initial clustering check failed\"\n\n # Now update the test vector to be in cluster2\n new_vec = self.generate_cluster_vector(cluster2_base, noise=0.05)\n vec_bytes = struct.pack(f'{dim}f', *new_vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, test_key)\n\n # Verify the embedding was actually updated using VEMB\n emb_result = self.redis.execute_command('VEMB', self.test_key, test_key)\n updated_vec = [float(x) for x in emb_result]\n\n # Verify updated vector matches what we inserted\n dot_product = sum(a*b for a,b in zip(updated_vec, new_vec))\n similarity = dot_product / (math.sqrt(sum(x*x for x in updated_vec)) *\n math.sqrt(sum(x*x for x in new_vec)))\n assert similarity > 0.9, \"Vector was not properly updated\"\n\n # Verify it's now in cluster2 using VSIM\n results = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in cluster2_base],\n 'COUNT', 100, 'WITHSCORES')\n\n # Verify our updated vector is among top results\n found = False\n for i in range(0, len(results), 2):\n if results[i].decode() == test_key:\n found = True\n similarity = float(results[i+1])\n assert similarity > 0.80, f\"Updated vector has low similarity: {similarity}\"\n break\n\n assert found, \"Updated vector not found in cluster2 proximity\"\n" }, { "path": "modules/vector-sets/tests/persistence.py", "content": "from test import TestCase, fill_redis_with_vectors, generate_random_vector\nimport random\n\nclass HNSWPersistence(TestCase):\n def getname(self):\n return \"HNSW Persistence\"\n\n def estimated_runtime(self):\n return 30\n\n def _verify_results(self, key, dim, query_vec, reduced_dim=None):\n \"\"\"Run a query and return results dict\"\"\"\n k = 10\n args = ['VSIM', key]\n\n if reduced_dim:\n args.extend(['VALUES', dim])\n args.extend([str(x) for x in query_vec])\n else:\n args.extend(['VALUES', dim])\n args.extend([str(x) for x in query_vec])\n\n args.extend(['COUNT', k, 'WITHSCORES'])\n results = self.redis.execute_command(*args)\n\n results_dict = {}\n for i in range(0, len(results), 2):\n key = results[i].decode()\n score = float(results[i+1])\n results_dict[key] = score\n return results_dict\n\n def test(self):\n # Setup dimensions\n dim = 128\n reduced_dim = 32\n count = 5000\n random.seed(42)\n\n # Create two datasets - one normal and one with dimension reduction\n normal_data = fill_redis_with_vectors(self.redis, f\"{self.test_key}:normal\", count, dim)\n projected_data = fill_redis_with_vectors(self.redis, f\"{self.test_key}:projected\",\n count, dim, reduced_dim)\n\n # Generate query vectors we'll use before and after reload\n query_vec_normal = generate_random_vector(dim)\n query_vec_projected = generate_random_vector(dim)\n\n # Get initial results for both sets\n initial_normal = self._verify_results(f\"{self.test_key}:normal\", \n dim, query_vec_normal)\n initial_projected = self._verify_results(f\"{self.test_key}:projected\", \n dim, query_vec_projected, reduced_dim)\n\n # Force Redis to save and reload the dataset\n self.redis.execute_command('DEBUG', 'RELOAD')\n\n # Verify results after reload\n reloaded_normal = self._verify_results(f\"{self.test_key}:normal\", \n dim, query_vec_normal)\n reloaded_projected = self._verify_results(f\"{self.test_key}:projected\", \n dim, query_vec_projected, reduced_dim)\n\n # Verify normal vectors results\n assert len(initial_normal) == len(reloaded_normal), \\\n \"Normal vectors: Result count mismatch before/after reload\"\n\n for key in initial_normal:\n assert key in reloaded_normal, f\"Normal vectors: Missing item after reload: {key}\"\n assert abs(initial_normal[key] - reloaded_normal[key]) < 0.0001, \\\n f\"Normal vectors: Score mismatch for {key}: \" + \\\n f\"before={initial_normal[key]:.6f}, after={reloaded_normal[key]:.6f}\"\n\n # Verify projected vectors results\n assert len(initial_projected) == len(reloaded_projected), \\\n \"Projected vectors: Result count mismatch before/after reload\"\n\n for key in initial_projected:\n assert key in reloaded_projected, \\\n f\"Projected vectors: Missing item after reload: {key}\"\n assert abs(initial_projected[key] - reloaded_projected[key]) < 0.0001, \\\n f\"Projected vectors: Score mismatch for {key}: \" + \\\n f\"before={initial_projected[key]:.6f}, after={reloaded_projected[key]:.6f}\"\n\n self.redis.delete(f\"{self.test_key}:normal\")\n self.redis.delete(f\"{self.test_key}:projected\")\n" }, { "path": "modules/vector-sets/tests/q8_similarity.py", "content": "from test import TestCase\n\nclass Q8Similarity(TestCase):\n def getname(self):\n return \"Q8 quantization: VSIM reported distance makes sense with 4D vectors\"\n\n def test(self):\n # Add two very similar vectors, one different\n # Using same test vectors as basic_similarity.py for comparison\n vec1 = [1, 0, 0, 0]\n vec2 = [0.99, 0.01, 0, 0]\n vec3 = [0.1, 1, -1, 0.5]\n\n # Add vectors using VALUES format with Q8 quantization\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec1], f'{self.test_key}:item:1', 'Q8')\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec2], f'{self.test_key}:item:2', 'Q8')\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec3], f'{self.test_key}:item:3', 'Q8')\n\n # Query similarity with vec1\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', 4, \n *[str(x) for x in vec1], 'WITHSCORES')\n\n # Convert results to dictionary\n results_dict = {}\n for i in range(0, len(result), 2):\n key = result[i].decode()\n score = float(result[i+1])\n results_dict[key] = score\n\n # Verify results (same expectations as float32, allowing for quantization error)\n assert results_dict[f'{self.test_key}:item:1'] > 0.99, \"Self-similarity should be very high (Q8)\"\n assert results_dict[f'{self.test_key}:item:2'] > 0.99, \"Similar vector should have high similarity (Q8)\"\n assert results_dict[f'{self.test_key}:item:3'] < 0.80, \"Not very similar vector should have low similarity (Q8)\"\n\n # Test extreme values with 512 dimensions to stress-test overflow safety\n vec4 = [1.0] * 512 # All +127 after quantization\n vec5 = [-1.0] * 512 # All -127 after quantization\n vec6 = [1.0, -1.0] * 256 # Alternating +127, -127\n\n # Add vectors using VALUES format with Q8 quantization\n self.redis.execute_command('VADD', f'{self.test_key}:extreme', 'VALUES', 512,\n *[str(x) for x in vec4], f'{self.test_key}:extreme:vec4', 'Q8')\n self.redis.execute_command('VADD', f'{self.test_key}:extreme', 'VALUES', 512,\n *[str(x) for x in vec5], f'{self.test_key}:extreme:vec5', 'Q8')\n self.redis.execute_command('VADD', f'{self.test_key}:extreme', 'VALUES', 512,\n *[str(x) for x in vec6], f'{self.test_key}:extreme:vec6', 'Q8')\n\n # Query vec4 against itself - worst-case positive accumulation (512 * 127 * 127 = 8,258,048)\n result_vec4 = self.redis.execute_command('VSIM', f'{self.test_key}:extreme', 'VALUES', 512,\n *[str(x) for x in vec4], 'WITHSCORES')\n results_vec4 = {}\n for i in range(0, len(result_vec4), 2):\n key = result_vec4[i].decode()\n score = float(result_vec4[i+1])\n results_vec4[key] = score\n\n # Verify extreme value handling\n # VSIM returns similarity = 1.0 - distance/2.0, so:\n # - Distance 0 (identical) → similarity 1.0\n # - Distance 2 (opposite) → similarity 0.0\n assert results_vec4[f'{self.test_key}:extreme:vec4'] > 0.999, \\\n f\"vec4 self-similarity should be very high, got {results_vec4[f'{self.test_key}:extreme:vec4']}\"\n assert results_vec4[f'{self.test_key}:extreme:vec5'] < 0.01, \\\n f\"vec4 vs vec5 (opposite extremes) should be near 0, got {results_vec4[f'{self.test_key}:extreme:vec5']}\"\n \n # Alternating pattern should result in mid-range similarity (perpendicular)\n assert 0.4 < results_vec4[f'{self.test_key}:extreme:vec6'] < 0.6, \\\n f\"vec4 vs vec6 (alternating) should be near 0.5, got {results_vec4[f'{self.test_key}:extreme:vec6']}\"\n" }, { "path": "modules/vector-sets/tests/q8_vectorization.py", "content": "from test import TestCase\n\nclass Q8Vectorization(TestCase):\n def getname(self):\n return \"Q8 quantization: verify vectorized vs scalar paths produce consistent results\"\n\n def test(self):\n # Test with different dimensions to exercise different code paths and boundaries:\n # - dim=16: Scalar path (< 32)\n # - dim=31: Largest scalar-only dimension (boundary)\n # - dim=32: Smallest AVX2 dimension, no remainder (boundary)\n # - dim=33: AVX2 with 1-element remainder\n # - dim=63: AVX2 with 31-element remainder (largest AVX2-only)\n # - dim=64: Smallest AVX512 dimension, no remainder (boundary)\n # - dim=65: AVX512 with 1-element remainder\n # - dim=128: AVX512 path with no remainder\n # - dim=256, dim=512: Large dimensions to test overflow prevention\n \n test_dims = [16, 31, 32, 33, 63, 64, 65, 128, 256, 512]\n \n for dim in test_dims:\n key = f'{self.test_key}:dim{dim}'\n \n # Test vectors with extreme values to verify overflow prevention:\n # vec1: all +1.0 -> quantizes to +127 (max positive int8)\n # vec2: all +0.99 -> quantizes to ~+126 (similar to vec1)\n # vec3: all -1.0 -> quantizes to -127/-128 (max negative int8)\n # vec4: alternating +1.0/-1.0 -> alternating +127/-127 (tests mixed signs)\n vec1 = [1.0] * dim # All max positive\n vec2 = [0.99] * dim # Similar to vec1\n vec3 = [-1.0] * dim # All max negative (opposite direction)\n vec4 = [1.0 if i % 2 == 0 else -1.0 for i in range(dim)] # Alternating extreme values\n \n # Add vectors with Q8 quantization\n self.redis.execute_command('VADD', key, 'VALUES', dim, \n *[str(x) for x in vec1], f'{key}:item:1', 'Q8')\n self.redis.execute_command('VADD', key, 'VALUES', dim, \n *[str(x) for x in vec2], f'{key}:item:2', 'Q8')\n self.redis.execute_command('VADD', key, 'VALUES', dim, \n *[str(x) for x in vec3], f'{key}:item:3', 'Q8')\n self.redis.execute_command('VADD', key, 'VALUES', dim, \n *[str(x) for x in vec4], f'{key}:item:4', 'Q8')\n \n # Query similarity using vec1 (all max positive values)\n # This exercises worst-case positive accumulation: dim * 127 * 127\n result = self.redis.execute_command('VSIM', key, 'VALUES', dim, \n *[str(x) for x in vec1], 'WITHSCORES')\n \n # Convert results to dictionary\n results_dict = {}\n for i in range(0, len(result), 2):\n k = result[i].decode()\n score = float(result[i+1])\n results_dict[k] = score\n \n # Verify results - these would be wrong if overflow occurred\n # Self-similarity should be ~1.0 (identical vectors)\n assert results_dict[f'{key}:item:1'] > 0.99, \\\n f\"Dim {dim}: Self-similarity too low: {results_dict[f'{key}:item:1']}\"\n \n # Similar vector should have high similarity\n assert results_dict[f'{key}:item:2'] > 0.99, \\\n f\"Dim {dim}: Similar vector similarity too low: {results_dict[f'{key}:item:2']}\"\n \n # Opposite vector should have very low similarity (~0.0)\n # With overflow bug, this could give incorrect positive values\n assert results_dict[f'{key}:item:3'] < 0.1, \\\n f\"Dim {dim}: Opposite vector similarity too high: {results_dict[f'{key}:item:3']}\"\n \n # Alternating vector: dot product sums to ~0, so similarity ~0.5\n # (127*127) + (127*-127) + ... = 0, normalized gives ~0.5\n assert 0.4 < results_dict[f'{key}:item:4'] < 0.6, \\\n f\"Dim {dim}: Alternating vector similarity unexpected: {results_dict[f'{key}:item:4']}\"\n \n # Also query with the alternating pattern to verify its self-similarity\n result_alt = self.redis.execute_command('VSIM', key, 'VALUES', dim,\n *[str(x) for x in vec4], 'WITHSCORES')\n results_alt = {}\n for i in range(0, len(result_alt), 2):\n k = result_alt[i].decode()\n score = float(result_alt[i+1])\n results_alt[k] = score\n \n assert results_alt[f'{key}:item:4'] > 0.99, \\\n f\"Dim {dim}: Alternating self-similarity too low: {results_alt[f'{key}:item:4']}\"\n" }, { "path": "modules/vector-sets/tests/reduce.py", "content": "from test import TestCase, fill_redis_with_vectors, generate_random_vector\n\nclass Reduce(TestCase):\n def getname(self):\n return \"Dimension Reduction\"\n\n def estimated_runtime(self):\n return 0.2\n\n def test(self):\n original_dim = 100\n reduced_dim = 80\n count = 1000\n k = 50 # Number of nearest neighbors to check\n\n # Fill Redis with vectors using REDUCE and get reference data\n data = fill_redis_with_vectors(self.redis, self.test_key, count, original_dim, reduced_dim)\n\n # Verify dimension is reduced\n dim = self.redis.execute_command('VDIM', self.test_key)\n assert dim == reduced_dim, f\"Expected dimension {reduced_dim}, got {dim}\"\n\n # Generate query vector and get nearest neighbors using Redis\n query_vec = generate_random_vector(original_dim)\n redis_raw = self.redis.execute_command('VSIM', self.test_key, 'VALUES', \n original_dim, *[str(x) for x in query_vec],\n 'COUNT', k, 'WITHSCORES')\n\n # Convert Redis results to dict\n redis_results = {}\n for i in range(0, len(redis_raw), 2):\n key = redis_raw[i].decode()\n score = float(redis_raw[i+1])\n redis_results[key] = score\n\n # Get results from linear scan with original vectors\n linear_results = data.find_k_nearest(query_vec, k)\n linear_items = {name: score for name, score in linear_results}\n\n # Compare overlap between reduced and non-reduced results\n redis_set = set(redis_results.keys())\n linear_set = set(linear_items.keys())\n overlap = len(redis_set & linear_set)\n overlap_ratio = overlap / k\n\n # With random projection, we expect some loss of accuracy but should\n # maintain at least some similarity structure.\n # Note that gaussian distribution is the worse with this test, so\n # in real world practice, things will be better.\n min_expected_overlap = 0.1 # At least 10% overlap in top-k\n assert overlap_ratio >= min_expected_overlap, \\\n f\"Dimension reduction lost too much structure. Only {overlap_ratio*100:.1f}% overlap in top {k}\"\n\n # For items that appear in both results, scores should be reasonably correlated\n common_items = redis_set & linear_set\n for item in common_items:\n redis_score = redis_results[item]\n linear_score = linear_items[item]\n # Allow for some deviation due to dimensionality reduction\n assert abs(redis_score - linear_score) < 0.2, \\\n f\"Score mismatch too high for {item}: Redis={redis_score:.3f} Linear={linear_score:.3f}\"\n\n # If test fails, print comparison for debugging\n if overlap_ratio < min_expected_overlap:\n print(\"\\nLow overlap in results. Details:\")\n print(\"\\nTop results from linear scan (original vectors):\")\n for name, score in linear_results:\n print(f\"{name}: {score:.3f}\")\n print(\"\\nTop results from Redis (reduced vectors):\")\n for item, score in sorted(redis_results.items(), key=lambda x: x[1], reverse=True):\n print(f\"{item}: {score:.3f}\")\n" }, { "path": "modules/vector-sets/tests/replication.py", "content": "from test import TestCase, generate_random_vector\nimport struct\nimport random\nimport time\n\nclass ComprehensiveReplicationTest(TestCase):\n def getname(self):\n return \"Comprehensive Replication Test with mixed operations\"\n\n def estimated_runtime(self):\n # This test will take longer than the default 100ms\n return 20.0 # 20 seconds estimate\n\n def test(self):\n # Setup replication between primary and replica\n assert self.setup_replication(), \"Failed to setup replication\"\n\n # Test parameters\n num_vectors = 5000\n vector_dim = 8\n delete_probability = 0.1\n cas_probability = 0.3\n\n # Keep track of added items for potential deletion\n added_items = []\n\n # Add vectors and occasionally delete\n for i in range(num_vectors):\n # Generate a random vector\n vec = generate_random_vector(vector_dim)\n vec_bytes = struct.pack(f'{vector_dim}f', *vec)\n item_name = f\"{self.test_key}:item:{i}\"\n\n # Decide whether to use CAS or not\n use_cas = random.random() < cas_probability\n\n if use_cas and added_items:\n # Get an existing item for CAS reference (if available)\n cas_item = random.choice(added_items)\n try:\n # Add with CAS\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes,\n item_name, 'CAS')\n # Only add to our list if actually added (CAS might fail)\n if result == 1:\n added_items.append(item_name)\n except Exception as e:\n print(f\" CAS VADD failed: {e}\")\n else:\n try:\n # Add without CAS\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, item_name)\n # Only add to our list if actually added\n if result == 1:\n added_items.append(item_name)\n except Exception as e:\n print(f\" VADD failed: {e}\")\n\n # Randomly delete items (with 10% probability)\n if random.random() < delete_probability and added_items:\n try:\n # Select a random item to delete\n item_to_delete = random.choice(added_items)\n # Delete the item using VREM (not VDEL)\n self.redis.execute_command('VREM', self.test_key, item_to_delete)\n # Remove from our list\n added_items.remove(item_to_delete)\n except Exception as e:\n print(f\" VREM failed: {e}\")\n\n # Allow time for replication to complete\n time.sleep(2.0)\n\n # Verify final VCARD matches\n primary_card = self.redis.execute_command('VCARD', self.test_key)\n replica_card = self.replica.execute_command('VCARD', self.test_key)\n assert primary_card == replica_card, f\"Final VCARD mismatch: primary={primary_card}, replica={replica_card}\"\n\n # Verify VDIM matches\n primary_dim = self.redis.execute_command('VDIM', self.test_key)\n replica_dim = self.replica.execute_command('VDIM', self.test_key)\n assert primary_dim == replica_dim, f\"VDIM mismatch: primary={primary_dim}, replica={replica_dim}\"\n\n # Verify digests match using DEBUG DIGEST\n primary_digest = self.redis.execute_command('DEBUG', 'DIGEST-VALUE', self.test_key)\n replica_digest = self.replica.execute_command('DEBUG', 'DIGEST-VALUE', self.test_key)\n assert primary_digest == replica_digest, f\"Digest mismatch: primary={primary_digest}, replica={replica_digest}\"\n\n # Print summary\n print(f\"\\n Added and maintained {len(added_items)} vectors with dimension {vector_dim}\")\n print(f\" Final vector count: {primary_card}\")\n print(f\" Final digest: {primary_digest[0].decode()}\")\n" }, { "path": "modules/vector-sets/tests/threading_config.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\n\nclass ThreadingConfigTest(TestCase):\n \"\"\"\n Test suite for vset-force-single-threaded-execution configuration.\n\n This test validates the behavior of VADD and VSIM commands under different\n threading configurations. The new configuration is MUTABLE and BINARY:\n - false (0): Multi-threaded execution enabled (default)\n - true (1): Force single-threaded execution\n\n Key behaviors tested:\n - VADD with and without CAS option under both threading modes\n - VSIM with and without NOTHREAD option under both threading modes\n - Configuration reading, validation, and runtime modification\n - Thread behavior switching (multi-threaded vs forced single-threaded)\n \"\"\"\n\n def getname(self):\n return \"vset-force-single-threaded-execution configuration testing\"\n\n def estimated_runtime(self):\n return 0.5 # Updated for mutable config testing with mode switching\n\n def get_config_value(self):\n \"\"\"Get current vset-force-single-threaded-execution config value\"\"\"\n try:\n result = self.redis.execute_command('CONFIG', 'GET', 'vset-force-single-threaded-execution')\n if len(result) >= 2:\n # Redis returns 'yes'/'no' for boolean configs\n return result[1].decode() if isinstance(result[1], bytes) else result[1]\n return None\n except Exception:\n return None\n\n def set_config_value(self, value):\n \"\"\"Set vset-force-single-threaded-execution config value\"\"\"\n try:\n # Convert boolean to yes/no string\n str_value = 'yes' if value else 'no'\n result = self.redis.execute_command('CONFIG', 'SET', 'vset-force-single-threaded-execution', str_value)\n return result == b'OK' or result == 'OK'\n except Exception as e:\n print(f\"Failed to set config: {e}\")\n return False\n\n def test_config_access_and_mutability(self):\n \"\"\"Test 1: Configuration access and mutability\"\"\"\n # Get initial value\n initial_value = self.get_config_value()\n assert initial_value is not None, \"Should be able to read vset-force-single-threaded-execution config\"\n assert initial_value in ['yes', 'no'], f\"Config value should be yes/no, got {initial_value}\"\n\n # Test mutability by toggling the value\n new_value = 'no' if initial_value == 'yes' else 'yes'\n assert self.set_config_value(new_value == 'yes'), \"Should be able to change config value\"\n\n # Verify the change\n current_value = self.get_config_value()\n assert current_value == new_value, f\"Config should be {new_value}, got {current_value}\"\n\n # Restore original value\n assert self.set_config_value(initial_value == 'yes'), \"Should be able to restore original value\"\n\n return initial_value == 'yes'\n\n def test_vadd_without_cas(self, force_single_threaded=False):\n \"\"\"Test 2: VADD command without CAS option\"\"\"\n # Set threading mode\n self.set_config_value(force_single_threaded)\n\n # Clear test data to avoid dimension conflicts\n self.redis.delete(self.test_key)\n\n dim = 64\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:1')\n assert result == 1, f\"VADD should return 1 for new item, got {result}\"\n\n # Verify the vector was added\n card = self.redis.execute_command('VCARD', self.test_key)\n assert card == 1, f\"VCARD should return 1, got {card}\"\n\n def test_vadd_with_cas(self, force_single_threaded=False):\n \"\"\"Test 3: VADD command with CAS option\"\"\"\n # Set threading mode\n self.set_config_value(force_single_threaded)\n\n # Clear test data to avoid dimension conflicts\n self.redis.delete(self.test_key)\n\n dim = 64\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n\n # First insertion with CAS should succeed\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:cas', 'CAS')\n assert result == 1, f\"First VADD with CAS should return 1, got {result}\"\n\n # Second insertion of same item with CAS should return 0\n result = self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:cas', 'CAS')\n assert result == 0, f\"Duplicate VADD with CAS should return 0, got {result}\"\n\n def test_vsim_without_nothread(self, force_single_threaded=False):\n \"\"\"Test 4: VSIM command without NOTHREAD\"\"\"\n # Set threading mode\n self.set_config_value(force_single_threaded)\n\n # Clear test data to avoid dimension conflicts\n self.redis.delete(self.test_key)\n\n dim = 64\n\n # Add test vectors\n for i in range(5):\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:{i}')\n\n # Test VSIM without NOTHREAD\n query_vec = generate_random_vector(dim)\n args = ['VSIM', self.test_key, 'VALUES', dim] + [str(x) for x in query_vec] + ['COUNT', 3]\n result = self.redis.execute_command(*args)\n\n assert isinstance(result, list), f\"VSIM should return a list, got {type(result)}\"\n assert len(result) <= 3, f\"VSIM should return at most 3 results, got {len(result)}\"\n\n def test_vsim_with_nothread(self, force_single_threaded=False):\n \"\"\"Test 5: VSIM command with NOTHREAD\"\"\"\n # Set threading mode\n self.set_config_value(force_single_threaded)\n\n dim = 64\n\n # Ensure we have vectors to search (use existing vectors from previous test)\n card = self.redis.execute_command('VCARD', self.test_key)\n if card == 0:\n # Add test vectors if none exist\n for i in range(5):\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:{i}')\n\n # Test VSIM with NOTHREAD\n query_vec = generate_random_vector(dim)\n args = ['VSIM', self.test_key, 'VALUES', dim] + [str(x) for x in query_vec] + ['COUNT', 3, 'NOTHREAD']\n result = self.redis.execute_command(*args)\n\n assert isinstance(result, list), f\"VSIM with NOTHREAD should return a list, got {type(result)}\"\n assert len(result) <= 3, f\"VSIM with NOTHREAD should return at most 3 results, got {len(result)}\"\n\n def test_threading_mode_comparison(self):\n \"\"\"Test 6: Compare behavior between threading modes\"\"\"\n dim = 64\n\n # Clear test data\n self.redis.delete(self.test_key)\n\n # Test multi-threaded mode (default)\n self.set_config_value(False) # Multi-threaded\n self.test_vadd_without_cas(False)\n self.test_vadd_with_cas(False)\n multi_threaded_card = self.redis.execute_command('VCARD', self.test_key)\n\n # Clear and test single-threaded mode\n self.redis.delete(self.test_key)\n self.set_config_value(True) # Single-threaded\n self.test_vadd_without_cas(True)\n self.test_vadd_with_cas(True)\n single_threaded_card = self.redis.execute_command('VCARD', self.test_key)\n\n # Both modes should produce same results\n assert multi_threaded_card == single_threaded_card, \\\n f\"Both modes should produce same results: multi={multi_threaded_card}, single={single_threaded_card}\"\n\n def test_nothread_override_behavior(self):\n \"\"\"Test 7: NOTHREAD option should work regardless of config\"\"\"\n dim = 64\n\n # Test with both config modes\n for force_single in [False, True]:\n self.set_config_value(force_single)\n self.redis.delete(self.test_key)\n\n # Add test vectors\n for i in range(3):\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:{i}')\n\n # NOTHREAD should work regardless of config\n query_vec = generate_random_vector(dim)\n args = ['VSIM', self.test_key, 'VALUES', dim] + [str(x) for x in query_vec] + ['COUNT', 2, 'NOTHREAD']\n result = self.redis.execute_command(*args)\n\n assert isinstance(result, list), f\"NOTHREAD should work with force_single={force_single}\"\n assert len(result) <= 2, f\"NOTHREAD should return ≤2 results with force_single={force_single}\"\n\n def test(self):\n \"\"\"Main test method - runs all threading configuration tests\"\"\"\n # Get initial configuration\n initial_force_single = self.test_config_access_and_mutability()\n print(f\"Initial vset-force-single-threaded-execution: {'yes' if initial_force_single else 'no'}\")\n\n # Clear test data\n self.redis.delete(self.test_key)\n\n # Test both threading modes\n print(\"Testing multi-threaded mode...\")\n self.set_config_value(False)\n self.test_vadd_without_cas(False)\n self.test_vadd_with_cas(False)\n self.test_vsim_without_nothread(False)\n self.test_vsim_with_nothread(False)\n\n print(\"Testing single-threaded mode...\")\n self.set_config_value(True)\n self.test_vadd_without_cas(True)\n self.test_vadd_with_cas(True)\n self.test_vsim_without_nothread(True)\n self.test_vsim_with_nothread(True)\n\n # Test mode comparison and NOTHREAD override\n self.test_threading_mode_comparison()\n self.test_nothread_override_behavior()\n\n # Restore initial configuration\n self.set_config_value(initial_force_single)\n\n # Print summary\n self._print_test_summary(initial_force_single)\n\n def _print_test_summary(self, initial_force_single):\n \"\"\"Print a summary of what was tested\"\"\"\n print(f\"\\nThreading Configuration Test Summary:\")\n print(f\" Configuration: vset-force-single-threaded-execution\")\n print(f\" Type: Boolean, Mutable\")\n print(f\" Initial value: {'yes' if initial_force_single else 'no'}\")\n print(f\" Tested modes: Both multi-threaded (no) and single-threaded (yes)\")\n print(f\" VADD: Works correctly in both modes\")\n print(f\" VADD with CAS: Works correctly in both modes\")\n print(f\" VSIM: Works correctly in both modes\")\n print(f\" NOTHREAD option: Overrides config in both modes\")\n print(f\" Configuration mutability: ✅ Successfully changed at runtime\")\n print(f\" All tests passed successfully!\")\n" }, { "path": "modules/vector-sets/tests/vadd_cas.py", "content": "from test import TestCase, generate_random_vector\nimport threading\nimport struct\nimport math\nimport time\nimport random\nfrom typing import List, Dict\n\nclass ConcurrentCASTest(TestCase):\n def getname(self):\n return \"Concurrent VADD with CAS\"\n\n def estimated_runtime(self):\n return 1.5\n\n def worker(self, vectors: List[List[float]], start_idx: int, end_idx: int,\n dim: int, results: Dict[str, bool]):\n \"\"\"Worker thread that adds a subset of vectors using VADD CAS\"\"\"\n for i in range(start_idx, end_idx):\n vec = vectors[i]\n name = f\"{self.test_key}:item:{i}\"\n vec_bytes = struct.pack(f'{dim}f', *vec)\n\n # Try to add the vector with CAS\n try:\n result = self.redis.execute_command('VADD', self.test_key, 'FP32',\n vec_bytes, name, 'CAS')\n results[name] = (result == 1) # Store if it was actually added\n except Exception as e:\n results[name] = False\n print(f\"Error adding {name}: {e}\")\n\n def verify_vector_similarity(self, vec1: List[float], vec2: List[float]) -> float:\n \"\"\"Calculate cosine similarity between two vectors\"\"\"\n dot_product = sum(a*b for a,b in zip(vec1, vec2))\n norm1 = math.sqrt(sum(x*x for x in vec1))\n norm2 = math.sqrt(sum(x*x for x in vec2))\n return dot_product / (norm1 * norm2) if norm1 > 0 and norm2 > 0 else 0\n\n def test(self):\n # Test parameters\n dim = 128\n total_vectors = 5000\n num_threads = 8\n vectors_per_thread = total_vectors // num_threads\n\n # Generate all vectors upfront\n random.seed(42) # For reproducibility\n vectors = [generate_random_vector(dim) for _ in range(total_vectors)]\n\n # Prepare threads and results dictionary\n threads = []\n results = {} # Will store success/failure for each vector\n\n # Launch threads\n for i in range(num_threads):\n start_idx = i * vectors_per_thread\n end_idx = start_idx + vectors_per_thread if i < num_threads-1 else total_vectors\n thread = threading.Thread(target=self.worker,\n args=(vectors, start_idx, end_idx, dim, results))\n threads.append(thread)\n thread.start()\n\n # Wait for all threads to complete\n for thread in threads:\n thread.join()\n\n # Verify cardinality\n card = self.redis.execute_command('VCARD', self.test_key)\n assert card == total_vectors, \\\n f\"Expected {total_vectors} elements, but found {card}\"\n\n # Verify each vector\n num_verified = 0\n for i in range(total_vectors):\n name = f\"{self.test_key}:item:{i}\"\n\n # Verify the item was successfully added\n assert results[name], f\"Vector {name} was not successfully added\"\n\n # Get the stored vector\n stored_vec_raw = self.redis.execute_command('VEMB', self.test_key, name)\n stored_vec = [float(x) for x in stored_vec_raw]\n\n # Verify vector dimensions\n assert len(stored_vec) == dim, \\\n f\"Stored vector dimension mismatch for {name}: {len(stored_vec)} != {dim}\"\n\n # Calculate similarity with original vector\n similarity = self.verify_vector_similarity(vectors[i], stored_vec)\n assert similarity > 0.99, \\\n f\"Low similarity ({similarity}) for {name}\"\n\n num_verified += 1\n\n # Final verification\n assert num_verified == total_vectors, \\\n f\"Only verified {num_verified} out of {total_vectors} vectors\"\n" }, { "path": "modules/vector-sets/tests/vemb.py", "content": "from test import TestCase\nimport struct\nimport math\n\nclass VEMB(TestCase):\n def getname(self):\n return \"VEMB Command\"\n\n def test(self):\n dim = 4\n\n # Add same vector in both formats\n vec = [1, 0, 0, 0]\n norm = math.sqrt(sum(x*x for x in vec))\n vec = [x/norm for x in vec] # Normalize the vector\n\n # Add using FP32\n vec_bytes = struct.pack(f'{dim}f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:1')\n\n # Add using VALUES\n self.redis.execute_command('VADD', self.test_key, 'VALUES', dim, \n *[str(x) for x in vec], f'{self.test_key}:item:2')\n\n # Get both back with VEMB\n result1 = self.redis.execute_command('VEMB', self.test_key, f'{self.test_key}:item:1')\n result2 = self.redis.execute_command('VEMB', self.test_key, f'{self.test_key}:item:2')\n\n retrieved_vec1 = [float(x) for x in result1]\n retrieved_vec2 = [float(x) for x in result2]\n\n # Compare both vectors with original (allow for small quantization errors)\n for i in range(dim):\n assert abs(vec[i] - retrieved_vec1[i]) < 0.01, \\\n f\"FP32 vector component {i} mismatch: expected {vec[i]}, got {retrieved_vec1[i]}\"\n assert abs(vec[i] - retrieved_vec2[i]) < 0.01, \\\n f\"VALUES vector component {i} mismatch: expected {vec[i]}, got {retrieved_vec2[i]}\"\n\n # Test non-existent item\n result = self.redis.execute_command('VEMB', self.test_key, 'nonexistent')\n assert result is None, \"Non-existent item should return nil\"\n" }, { "path": "modules/vector-sets/tests/vismember.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass BasicVISMEMBER(TestCase):\n def getname(self):\n return \"VISMEMBER basic functionality\"\n\n def test(self):\n # Add multiple vectors to the vector set\n vec1 = generate_random_vector(4)\n vec2 = generate_random_vector(4)\n vec_bytes1 = struct.pack('4f', *vec1)\n vec_bytes2 = struct.pack('4f', *vec2)\n\n # Create item keys\n item1 = f'{self.test_key}:item:1'\n item2 = f'{self.test_key}:item:2'\n nonexistent_item = f'{self.test_key}:item:nonexistent'\n\n # Add the vectors\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes1, item1)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes2, item2)\n\n # Test VISMEMBER with existing elements\n result1 = self.redis.execute_command('VISMEMBER', self.test_key, item1)\n assert result1 == 1, f\"VISMEMBER should return 1 for existing item, got {result1}\"\n\n result2 = self.redis.execute_command('VISMEMBER', self.test_key, item2)\n assert result2 == 1, f\"VISMEMBER should return 1 for existing item, got {result2}\"\n\n # Test VISMEMBER with non-existent element\n result3 = self.redis.execute_command('VISMEMBER', self.test_key, nonexistent_item)\n assert result3 == 0, f\"VISMEMBER should return 0 for non-existent item, got {result3}\"\n\n # Test VISMEMBER with non-existent key\n nonexistent_key = f'{self.test_key}_nonexistent'\n result4 = self.redis.execute_command('VISMEMBER', nonexistent_key, item1)\n assert result4 == 0, f\"VISMEMBER should return 0 for non-existent key, got {result4}\"\n\n # Test VISMEMBER after removing an element\n self.redis.execute_command('VREM', self.test_key, item1)\n result5 = self.redis.execute_command('VISMEMBER', self.test_key, item1)\n assert result5 == 0, f\"VISMEMBER should return 0 after element removal, got {result5}\"\n\n # Verify item2 still exists\n result6 = self.redis.execute_command('VISMEMBER', self.test_key, item2)\n assert result6 == 1, f\"VISMEMBER should still return 1 for remaining item, got {result6}\"\n" }, { "path": "modules/vector-sets/tests/vrand-ping-pong.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass VRANDMEMBERPingPongRegressionTest(TestCase):\n def getname(self):\n return \"[regression] VRANDMEMBER ping-pong\"\n\n def test(self):\n \"\"\"\n This test ensures that when only two vectors exist, VRANDMEMBER\n does not get stuck returning only one of them due to the \"ping-pong\" issue.\n \"\"\"\n self.redis.delete(self.test_key) # Clean up before test\n dim = 4\n\n # Add exactly two vectors\n vec1_name = \"vec1\"\n vec1_data = generate_random_vector(dim)\n self.redis.execute_command('VADD', self.test_key, 'VALUES', dim, *vec1_data, vec1_name)\n\n vec2_name = \"vec2\"\n vec2_data = generate_random_vector(dim)\n self.redis.execute_command('VADD', self.test_key, 'VALUES', dim, *vec2_data, vec2_name)\n\n # Call VRANDMEMBER many times and check for distribution\n iterations = 100\n results = []\n for _ in range(iterations):\n member = self.redis.execute_command('VRANDMEMBER', self.test_key)\n results.append(member.decode())\n\n # Verify that both members were returned, proving it's not stuck\n unique_results = set(results)\n\n assert len(unique_results) == 2, f\"Ping-pong test failed: should have returned 2 unique members, but got {len(unique_results)}.\"\n" }, { "path": "modules/vector-sets/tests/vrandmember.py", "content": "from test import TestCase, generate_random_vector, fill_redis_with_vectors\nimport struct\n\nclass VRANDMEMBERTest(TestCase):\n def getname(self):\n return \"VRANDMEMBER basic functionality\"\n\n def test(self):\n # Test with empty key\n result = self.redis.execute_command('VRANDMEMBER', self.test_key)\n assert result is None, \"VRANDMEMBER on non-existent key should return NULL\"\n\n result = self.redis.execute_command('VRANDMEMBER', self.test_key, 5)\n assert isinstance(result, list) and len(result) == 0, \"VRANDMEMBER with count on non-existent key should return empty array\"\n\n # Fill with vectors\n dim = 4\n count = 100\n data = fill_redis_with_vectors(self.redis, self.test_key, count, dim)\n\n # Test single random member\n result = self.redis.execute_command('VRANDMEMBER', self.test_key)\n assert result is not None, \"VRANDMEMBER should return a random member\"\n assert result.decode() in data.names, \"Random member should be in the set\"\n\n # Test multiple unique members (positive count)\n positive_count = 10\n result = self.redis.execute_command('VRANDMEMBER', self.test_key, positive_count)\n assert isinstance(result, list), \"VRANDMEMBER with positive count should return an array\"\n assert len(result) == positive_count, f\"Should return {positive_count} members\"\n\n # Check for uniqueness\n decoded_results = [r.decode() for r in result]\n assert len(decoded_results) == len(set(decoded_results)), \"Results should be unique with positive count\"\n for item in decoded_results:\n assert item in data.names, \"All returned items should be in the set\"\n\n # Test more members than in the set\n result = self.redis.execute_command('VRANDMEMBER', self.test_key, count + 10)\n assert len(result) == count, \"Should return only the available members when asking for more than exist\"\n\n # Test with duplicates (negative count)\n negative_count = -20\n result = self.redis.execute_command('VRANDMEMBER', self.test_key, negative_count)\n assert isinstance(result, list), \"VRANDMEMBER with negative count should return an array\"\n assert len(result) == abs(negative_count), f\"Should return {abs(negative_count)} members\"\n\n # Check that all returned elements are valid\n decoded_results = [r.decode() for r in result]\n for item in decoded_results:\n assert item in data.names, \"All returned items should be in the set\"\n\n # Test with count = 0 (edge case)\n result = self.redis.execute_command('VRANDMEMBER', self.test_key, 0)\n assert isinstance(result, list) and len(result) == 0, \"VRANDMEMBER with count=0 should return empty array\"\n" }, { "path": "modules/vector-sets/tests/vrange.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass BasicVRANGE(TestCase):\n def getname(self):\n return \"VRANGE basic functionality and iteration\"\n\n def test(self):\n # Add multiple elements with different names for lexicographical ordering\n elements = [\n \"apple\", \"apricot\", \"banana\", \"cherry\", \"date\",\n \"elderberry\", \"fig\", \"grape\", \"honeydew\", \"kiwi\",\n \"lemon\", \"mango\", \"nectarine\", \"orange\", \"papaya\",\n \"quince\", \"raspberry\", \"strawberry\", \"tangerine\", \"watermelon\"\n ]\n\n # Add all elements to the vector set\n for elem in elements:\n vec = generate_random_vector(4)\n vec_bytes = struct.pack('4f', *vec)\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, elem)\n\n # Test 1: Basic range with inclusive boundaries\n result = self.redis.execute_command('VRANGE', self.test_key, '[apple', '[grape', '5')\n result = [r.decode() for r in result]\n assert result == ['apple', 'apricot', 'banana', 'cherry', 'date'], f\"Expected first 5 elements from apple, got {result}\"\n\n # Test 2: Exclusive start boundary\n result = self.redis.execute_command('VRANGE', self.test_key, '(apple', '[cherry', '10')\n result = [r.decode() for r in result]\n assert result == ['apricot', 'banana', 'cherry'], f\"Expected elements after apple up to cherry inclusive, got {result}\"\n\n # Test 3: Exclusive end boundary\n result = self.redis.execute_command('VRANGE', self.test_key, '[banana', '(cherry', '10')\n result = [r.decode() for r in result]\n assert result == ['banana'], f\"Expected only banana (cherry excluded), got {result}\"\n\n # Test 4: Using '-' for minimum element\n result = self.redis.execute_command('VRANGE', self.test_key, '-', '[banana', '10')\n result = [r.decode() for r in result]\n assert result[0] == 'apple', \"Should start from the first element\"\n assert result[-1] == 'banana', \"Should end at banana\"\n\n # Test 5: Using '+' for maximum element\n result = self.redis.execute_command('VRANGE', self.test_key, '[raspberry', '+', '10')\n result = [r.decode() for r in result]\n assert 'raspberry' in result and 'strawberry' in result and 'tangerine' in result and 'watermelon' in result, \"Should include all elements from raspberry onwards\"\n\n # Test 6: Full range with '-' and '+'\n result = self.redis.execute_command('VRANGE', self.test_key, '-', '+', '100')\n result = [r.decode() for r in result]\n assert len(result) == len(elements), f\"Should return all {len(elements)} elements\"\n assert result == sorted(elements), \"Elements should be in lexicographical order\"\n\n # Test 7: Iterator pattern - verify each element appears exactly once\n seen = set()\n batch_size = 3\n current = '-'\n\n while True:\n if current == '-':\n # First iteration\n result = self.redis.execute_command('VRANGE', self.test_key, '-', '+', str(batch_size))\n else:\n # Subsequent iterations - exclusive start from last element\n result = self.redis.execute_command('VRANGE', self.test_key, f'({current}', '+', str(batch_size))\n\n result = [r.decode() for r in result]\n\n if not result:\n break\n\n # Check no duplicates in this batch\n for elem in result:\n assert elem not in seen, f\"Element {elem} appeared more than once\"\n seen.add(elem)\n\n # Update current to last element\n current = result[-1]\n\n # Break if we got less than requested (end of set)\n if len(result) < batch_size:\n break\n\n # Verify we saw all elements exactly once\n assert seen == set(elements), f\"Iterator should visit all elements exactly once. Missing: {set(elements) - seen}, Extra: {seen - set(elements)}\"\n\n # Test 8: Count of 0 returns empty array\n result = self.redis.execute_command('VRANGE', self.test_key, '-', '+', '0')\n assert result == [], f\"Count of 0 should return empty array, got {result}\"\n\n # Test 9: Range with no matching elements\n result = self.redis.execute_command('VRANGE', self.test_key, '[zebra', '+', '10')\n assert result == [], f\"Range beyond all elements should return empty array, got {result}\"\n\n # Test 10: Non-existent key\n result = self.redis.execute_command('VRANGE', 'nonexistent_key', '-', '+', '10')\n assert result == [], f\"Non-existent key should return empty array, got {result}\"\n\n # Test 11: Partial word boundaries\n result = self.redis.execute_command('VRANGE', self.test_key, '[app', '[apr', '10')\n result = [r.decode() for r in result]\n assert 'apple' in result, \"Should include 'apple' which starts with 'app'\"\n assert 'apricot' not in result, \"Should not include 'apricot' as it's >= 'apr'\"\n\n # Test 12: Single element range\n result = self.redis.execute_command('VRANGE', self.test_key, '[cherry', '[cherry', '10')\n result = [r.decode() for r in result]\n assert result == ['cherry'], f\"Inclusive single element range should return that element, got {result}\"\n\n # Test 13: Empty range (start > end)\n result = self.redis.execute_command('VRANGE', self.test_key, '[grape', '[apple', '10')\n assert result == [], f\"Range where start > end should return empty array, got {result}\"\n" }, { "path": "modules/vector-sets/tests/vsim_duplicate_filter.py", "content": "from test import TestCase\n\nclass VSIMDuplicateFilterLeak(TestCase):\n def getname(self):\n return \"[regression] VSIM duplicate FILTER should not leak memory\"\n\n def test(self):\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 3, 0.5774, 0.5774, 0.5774, 'elem1')\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 3, 0.7071, 0.7071, 0.0, 'elem2')\n self.redis.execute_command('VSETATTR', self.test_key, 'elem1', '{\"a\": 1, \"b\": 2}')\n self.redis.execute_command('VSETATTR', self.test_key, 'elem2', '{\"a\": 2, \"b\": 3}')\n\n # Duplicate FILTER: before the fix the first exprstate was\n # overwritten without exprFree(), leaking ~760 bytes per call.\n # Under ASAN/valgrind this shows up as a leak at server exit.\n for _ in range(100):\n self.redis.execute_command(\n 'VSIM', self.test_key, 'VALUES', 3, 0.5774, 0.5774, 0.5774,\n 'FILTER', '.a == 1', 'FILTER', '.b >= 1')\n" }, { "path": "modules/vector-sets/tests/vsim_filter_error_leak.py", "content": "from test import TestCase\nimport redis as redis_module\n\nclass VSIMFilterLeakOnOptionError(TestCase):\n def getname(self):\n return \"[regression] VSIM FILTER expr freed on option parse error\"\n\n def test(self):\n self.redis.execute_command('VADD', self.test_key, 'VALUES', 3, 1, 0, 0, 'elem1')\n\n # Valid FILTER followed by invalid option values. Before the fix,\n # error paths freed vec but not filter_expr, leaking the compiled\n # exprstate. Under ASAN/valgrind this shows up at server exit.\n error_cmds = [\n # invalid COUNT (0)\n ['VSIM', self.test_key, 'VALUES', 3, 0, 0, 0, 'FILTER', '.a > 0', 'COUNT', 0],\n # invalid EF (0)\n ['VSIM', self.test_key, 'VALUES', 3, 0, 0, 0, 'FILTER', '.a > 0', 'EF', 0],\n # invalid EPSILON (0)\n ['VSIM', self.test_key, 'VALUES', 3, 0, 0, 0, 'FILTER', '.a > 0', 'EPSILON', 0],\n # invalid FILTER-EF (0)\n ['VSIM', self.test_key, 'VALUES', 3, 0, 0, 0, 'FILTER', '.a > 0', 'FILTER-EF', 0],\n # unknown option\n ['VSIM', self.test_key, 'VALUES', 3, 0, 0, 0, 'FILTER', '.a > 0', 'BADOPT', 1],\n ]\n\n for cmd in error_cmds:\n for _ in range(20):\n try:\n self.redis.execute_command(*cmd)\n except redis_module.exceptions.ResponseError:\n pass\n" }, { "path": "modules/vector-sets/tests/vsim_limit_efsearch.py", "content": "from test import TestCase, generate_random_vector\nimport struct\n\nclass VSIMLimitEFSearch(TestCase):\n def getname(self):\n return \"VSIM Limit EF Search\"\n\n def estimated_runtime(self):\n return 0.2\n\n def test(self):\n dim = 32\n vec = generate_random_vector(dim)\n vec_bytes = struct.pack(f'{dim}f', *vec)\n\n # Add test vector\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, f'{self.test_key}:item:1')\n\n query_vec = generate_random_vector(dim)\n\n # Test EF upper bound (should accept 1000000)\n result = self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in query_vec], 'EF', 1000000)\n assert isinstance(result, list), \"EF=1000000 should be accepted\"\n\n # Test EF over limit (should reject > 1000000)\n try:\n self.redis.execute_command('VSIM', self.test_key, 'VALUES', dim,\n *[str(x) for x in query_vec], 'EF', 1000001)\n assert False, \"EF=1000001 should be rejected\"\n except Exception as e:\n assert \"invalid EF\" in str(e), f\"Expected EF validation error, got: {e}\"\n" }, { "path": "modules/vector-sets/tests/with.py", "content": "from test import TestCase, generate_random_vector\nimport struct\nimport json\nimport random\n\nclass VSIMWithAttribs(TestCase):\n def getname(self):\n return \"VSIM WITHATTRIBS/WITHSCORES functionality testing\"\n\n def setup(self):\n super().setup()\n self.dim = 8\n self.count = 20\n\n # Create vectors with attributes\n for i in range(self.count):\n vec = generate_random_vector(self.dim)\n vec_bytes = struct.pack(f'{self.dim}f', *vec)\n\n # Item name\n name = f\"{self.test_key}:item:{i}\"\n\n # Add to Redis\n self.redis.execute_command('VADD', self.test_key, 'FP32', vec_bytes, name)\n\n # Create and add attribute\n if i % 5 == 0:\n # Every 5th item has no attribute (for testing NULL responses)\n continue\n\n category = random.choice([\"electronics\", \"furniture\", \"clothing\"])\n price = random.randint(50, 1000)\n attrs = {\"category\": category, \"price\": price, \"id\": i}\n\n self.redis.execute_command('VSETATTR', self.test_key, name, json.dumps(attrs))\n\n def is_numeric(self, value):\n \"\"\"Check if a value can be converted to float\"\"\"\n try:\n if isinstance(value, (int, float)):\n return True\n if isinstance(value, bytes):\n float(value.decode('utf-8'))\n return True\n if isinstance(value, str):\n float(value)\n return True\n return False\n except (ValueError, TypeError):\n return False\n\n def test(self):\n # Create query vector\n query_vec = generate_random_vector(self.dim)\n\n # Test 1: VSIM with no additional options (should be same for RESP2 and RESP3)\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 5])\n\n results_resp2 = self.redis.execute_command(*cmd_args)\n results_resp3 = self.redis3.execute_command(*cmd_args)\n\n # Both should return simple arrays of item names\n assert len(results_resp2) == 5, f\"RESP2: Expected 5 results, got {len(results_resp2)}\"\n assert len(results_resp3) == 5, f\"RESP3: Expected 5 results, got {len(results_resp3)}\"\n assert all(isinstance(item, bytes) for item in results_resp2), \"RESP2: Results should be byte strings\"\n assert all(isinstance(item, bytes) for item in results_resp3), \"RESP3: Results should be byte strings\"\n\n # Test 2: VSIM with WITHSCORES only\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 5, 'WITHSCORES'])\n\n results_resp2 = self.redis.execute_command(*cmd_args)\n results_resp3 = self.redis3.execute_command(*cmd_args)\n\n # RESP2: Should be a flat array alternating item, score\n assert len(results_resp2) == 10, f\"RESP2: Expected 10 elements (5 items × 2), got {len(results_resp2)}\"\n for i in range(0, len(results_resp2), 2):\n assert isinstance(results_resp2[i], bytes), f\"RESP2: Item at {i} should be bytes\"\n assert self.is_numeric(results_resp2[i+1]), f\"RESP2: Score at {i+1} should be numeric\"\n score = float(results_resp2[i+1]) if isinstance(results_resp2[i+1], bytes) else results_resp2[i+1]\n assert 0 <= score <= 1, f\"RESP2: Score {score} should be between 0 and 1\"\n\n # RESP3: Should be a dict/map with items as keys and scores as DIRECT values (not arrays)\n assert isinstance(results_resp3, dict), f\"RESP3: Expected dict, got {type(results_resp3)}\"\n assert len(results_resp3) == 5, f\"RESP3: Expected 5 entries, got {len(results_resp3)}\"\n for item, score in results_resp3.items():\n assert isinstance(item, bytes), f\"RESP3: Key should be bytes\"\n # Score should be a direct value, NOT an array\n assert not isinstance(score, list), f\"RESP3: With single WITH option, value should not be array\"\n assert self.is_numeric(score), f\"RESP3: Score should be numeric, got {type(score)}\"\n score_val = float(score) if isinstance(score, bytes) else score\n assert 0 <= score_val <= 1, f\"RESP3: Score {score_val} should be between 0 and 1\"\n\n # Test 3: VSIM with WITHATTRIBS only\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 5, 'WITHATTRIBS'])\n\n results_resp2 = self.redis.execute_command(*cmd_args)\n results_resp3 = self.redis3.execute_command(*cmd_args)\n\n # RESP2: Should be a flat array alternating item, attribute\n assert len(results_resp2) == 10, f\"RESP2: Expected 10 elements (5 items × 2), got {len(results_resp2)}\"\n for i in range(0, len(results_resp2), 2):\n assert isinstance(results_resp2[i], bytes), f\"RESP2: Item at {i} should be bytes\"\n attr = results_resp2[i+1]\n assert attr is None or isinstance(attr, bytes), f\"RESP2: Attribute at {i+1} should be None or bytes\"\n if attr is not None:\n # Verify it's valid JSON\n json.loads(attr)\n\n # RESP3: Should be a dict/map with items as keys and attributes as DIRECT values (not arrays)\n assert isinstance(results_resp3, dict), f\"RESP3: Expected dict, got {type(results_resp3)}\"\n assert len(results_resp3) == 5, f\"RESP3: Expected 5 entries, got {len(results_resp3)}\"\n for item, attr in results_resp3.items():\n assert isinstance(item, bytes), f\"RESP3: Key should be bytes\"\n # Attribute should be a direct value, NOT an array\n assert not isinstance(attr, list), f\"RESP3: With single WITH option, value should not be array\"\n assert attr is None or isinstance(attr, bytes), f\"RESP3: Attribute should be None or bytes\"\n if attr is not None:\n # Verify it's valid JSON\n json.loads(attr)\n\n # Test 4: VSIM with both WITHSCORES and WITHATTRIBS\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 5, 'WITHSCORES', 'WITHATTRIBS'])\n\n results_resp2 = self.redis.execute_command(*cmd_args)\n results_resp3 = self.redis3.execute_command(*cmd_args)\n\n # RESP2: Should be a flat array with pattern: item, score, attribute\n assert len(results_resp2) == 15, f\"RESP2: Expected 15 elements (5 items × 3), got {len(results_resp2)}\"\n for i in range(0, len(results_resp2), 3):\n assert isinstance(results_resp2[i], bytes), f\"RESP2: Item at {i} should be bytes\"\n assert self.is_numeric(results_resp2[i+1]), f\"RESP2: Score at {i+1} should be numeric\"\n score = float(results_resp2[i+1]) if isinstance(results_resp2[i+1], bytes) else results_resp2[i+1]\n assert 0 <= score <= 1, f\"RESP2: Score {score} should be between 0 and 1\"\n attr = results_resp2[i+2]\n assert attr is None or isinstance(attr, bytes), f\"RESP2: Attribute at {i+2} should be None or bytes\"\n\n # RESP3: Should be a dict where each value is a 2-element array [score, attribute]\n assert isinstance(results_resp3, dict), f\"RESP3: Expected dict, got {type(results_resp3)}\"\n assert len(results_resp3) == 5, f\"RESP3: Expected 5 entries, got {len(results_resp3)}\"\n for item, value in results_resp3.items():\n assert isinstance(item, bytes), f\"RESP3: Key should be bytes\"\n # With BOTH options, value MUST be an array\n assert isinstance(value, list), f\"RESP3: With both WITH options, value should be a list, got {type(value)}\"\n assert len(value) == 2, f\"RESP3: Value should have 2 elements [score, attr], got {len(value)}\"\n\n score, attr = value\n assert self.is_numeric(score), f\"RESP3: Score should be numeric\"\n score_val = float(score) if isinstance(score, bytes) else score\n assert 0 <= score_val <= 1, f\"RESP3: Score {score_val} should be between 0 and 1\"\n assert attr is None or isinstance(attr, bytes), f\"RESP3: Attribute should be None or bytes\"\n\n # Test 5: Verify consistency - same items returned in same order\n cmd_args = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args.extend([str(x) for x in query_vec])\n cmd_args.extend(['COUNT', 5, 'WITHSCORES', 'WITHATTRIBS'])\n\n results_resp2 = self.redis.execute_command(*cmd_args)\n results_resp3 = self.redis3.execute_command(*cmd_args)\n\n # Extract items from RESP2 (every 3rd element starting from 0)\n items_resp2 = [results_resp2[i] for i in range(0, len(results_resp2), 3)]\n\n # Extract items from RESP3 (keys of the dict)\n items_resp3 = list(results_resp3.keys())\n\n # Verify same items returned\n assert set(items_resp2) == set(items_resp3), \"RESP2 and RESP3 should return the same items\"\n\n # Build a mapping from items to scores and attributes for comparison\n data_resp2 = {}\n for i in range(0, len(results_resp2), 3):\n item = results_resp2[i]\n score = float(results_resp2[i+1]) if isinstance(results_resp2[i+1], bytes) else results_resp2[i+1]\n attr = results_resp2[i+2]\n data_resp2[item] = (score, attr)\n\n data_resp3 = {}\n for item, value in results_resp3.items():\n score = float(value[0]) if isinstance(value[0], bytes) else value[0]\n attr = value[1]\n data_resp3[item] = (score, attr)\n\n # Verify scores and attributes match for each item\n for item in data_resp2:\n score_resp2, attr_resp2 = data_resp2[item]\n score_resp3, attr_resp3 = data_resp3[item]\n\n assert abs(score_resp2 - score_resp3) < 0.0001, \\\n f\"Scores for {item} don't match: RESP2={score_resp2}, RESP3={score_resp3}\"\n assert attr_resp2 == attr_resp3, \\\n f\"Attributes for {item} don't match: RESP2={attr_resp2}, RESP3={attr_resp3}\"\n\n # Test 6: Test ordering of WITHSCORES and WITHATTRIBS doesn't matter\n cmd_args1 = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args1.extend([str(x) for x in query_vec])\n cmd_args1.extend(['COUNT', 3, 'WITHSCORES', 'WITHATTRIBS'])\n\n cmd_args2 = ['VSIM', self.test_key, 'VALUES', self.dim]\n cmd_args2.extend([str(x) for x in query_vec])\n cmd_args2.extend(['COUNT', 3, 'WITHATTRIBS', 'WITHSCORES']) # Reversed order\n\n results1_resp3 = self.redis3.execute_command(*cmd_args1)\n results2_resp3 = self.redis3.execute_command(*cmd_args2)\n\n # Both should return the same structure\n assert results1_resp3 == results2_resp3, \"Order of WITH options shouldn't matter\"\n" }, { "path": "modules/vector-sets/vset.c", "content": "/* Redis implementation for vector sets. The data structure itself\n * is implemented in hnsw.c.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo.\n *\n * ======================== Understand threading model =========================\n * This code implements threaded operarations for two of the commands:\n *\n * 1. VSIM, by default.\n * 2. VADD, if the CAS option is specified.\n *\n * Note that even if the second operation, VADD, is a write operation, only\n * the neighbors collection for the new node is performed in a thread: then,\n * the actual insert is performed in the reply callback VADD_CASReply(),\n * which is executed in the main thread.\n *\n * Threaded operations need us to protect various operations with mutexes,\n * even if a certain degree of protection is already provided by the HNSW\n * library. Here are a few very important things about this implementation\n * and the way locking is performed.\n *\n * 1. All the write operations are performed in the main Redis thread:\n * this also include VADD_CASReply() callback, that is called by Redis\n * internals only in the context of the main thread. However the HNSW\n * library allows background threads in hnsw_search() (VSIM) to modify\n * nodes metadata to speedup search (to understand if a node was already\n * visited), but this only happens after acquiring a specific lock\n * for a given \"read slot\".\n *\n * 2. We use a global lock for each Vector Set object, called \"in_use\". This\n * lock is a read-write lock, and is acquired in read mode by all the\n * threads that perform reads in the background. It is only acquired in\n * write mode by vectorSetWaitAllBackgroundClients(): the function acquires\n * the lock and immediately releases it, with the effect of waiting all the\n * background threads still running from ending their execution.\n *\n * Note that no thread can be spawned, since we only call\n * vectorSetWaitAllBackgroundClients() from the main Redis thread, that\n * is also the only thread spawning other threads.\n *\n * vectorSetWaitAllBackgroundClients() is used in two ways:\n * A) When we need to delete a vector set because of (DEL) or other\n * operations destroying the object, we need to wait that all the\n * background threads working with this object finished their work.\n * B) When we modify the HNSW nodes bypassing the normal locking\n * provided by the HNSW library. This only happens when we update\n * an existing node attribute so far, in VSETATTR and when we call\n * VADD to update a node with the SETATTR option.\n *\n * 3. Often during read operations performed by Redis commands in the\n * main thread (VCARD, VEMB, VRANDMEMBER, ...) we don't acquire any\n * lock at all. The commands run in the main Redis thread, we can only\n * have, at the same time, background reads against the same data\n * structure. Note that VSIM_thread() and VADD_thread() still modify the\n * read slot metadata, that is node->visited_epoch[slot], but as long as\n * our read commands running in the main thread don't need to use\n * hnsw_search() or other HNSW functions using the visited epochs slots\n * we are safe.\n *\n * 4. There is a race from the moment we create a thread, passing the\n * vector set object, to the moment the thread can actually lock the\n * result win the in_use_lock mutex: as the thread starts, in the meanwhile\n * a DEL/expire could trigger and remove the object. For this reason\n * we use an atomic counter that protects our object for this small\n * time in vectorSetWaitAllBackgroundClients(). This prevents removal\n * of objects that are about to be taken by threads.\n *\n * Note that other competing solutions could be used to fix the problem\n * but have their set of issues, however they are worth documenting here\n * and evaluating in the future:\n *\n * A. Using a conditional variable we could \"wait\" for the thread to\n * acquire the lock. However this means waiting before returning\n * to the event loop, and would make the command execution slower.\n * B. We could use again an atomic variable, like we did, but this time\n * as a refcount for the object, with a vsetAcquire() vsetRelease().\n * In this case, the command could retain the object in the main thread\n * before starting the thread, and the thread, after the work is done,\n * could release it. This way sometimes the object would be freed by\n * the thread, and it's while now can be safe to do the kind of resource\n * deallocation that vectorSetReleaseObject() does, given that the\n * Redis Modules API is not always thread safe this solution may not\n * be future-proof. However there is to evaluate it better in the\n * future.\n * C. We could use the \"B\" solution but instead of freeing the object\n * in the thread, in this specific case we could just put it into a\n * list and defer it for later freeing (for instance in the reply\n * callback), so that the object is always freed in the main thread.\n * This would require a list of objects to free.\n *\n * However the current solution only disadvantage is the potential busy\n * loop, but this busy loop in practical terms will almost never do\n * much: to trigger it, a number of circumnstances must happen: deleting\n * Vector Set keys while using them, hitting the small window needed to\n * start the thread and read-lock the mutex.\n */\n\n#define _DEFAULT_SOURCE\n#define _USE_MATH_DEFINES\n#define _POSIX_C_SOURCE 200809L\n\n#include \"../../src/redismodule.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"hnsw.h\"\n#include \"vset_config.h\"\n\n// We inline directly the expression implementation here so that building\n// the module is trivial.\n#include \"expr.c\"\n\nstatic RedisModuleType *VectorSetType;\nstatic uint64_t VectorSetTypeNextId = 0;\n\n// Default EF value if not specified during creation.\n#define VSET_DEFAULT_C_EF 200\n\n// Default EF value if not specified during search.\n#define VSET_DEFAULT_SEARCH_EF 100\n\n// Default num elements returned by VSIM.\n#define VSET_DEFAULT_COUNT 10\n\n/* ========================== Internal data structure ====================== */\n\n/* Our abstract data type needs a dual representation similar to Redis\n * sorted set: the proximity graph, and also a element -> graph-node map\n * that will allow us to perform deletions and other operations that have\n * as input the element itself. */\nstruct vsetObject {\n HNSW *hnsw; // Proximity graph.\n RedisModuleDict *dict; // Element -> node mapping.\n float *proj_matrix; // Random projection matrix, NULL if no projection\n uint32_t proj_input_size; // Input dimension after projection.\n // Output dimension is implicit in\n // hnsw->vector_dim.\n pthread_rwlock_t in_use_lock; // Lock needed to destroy the object safely.\n uint64_t id; // Unique ID used by threaded VADD to know the\n // object is still the same.\n uint64_t numattribs; // Number of nodes associated with an attribute.\n atomic_int thread_creation_pending; // Number of threads that are currently\n // pending to lock the object.\n};\n\n/* Each node has two associated values: the associated string (the item\n * in the set) and potentially a JSON string, that is, the attributes, used\n * for hybrid search with the VSIM FILTER option. */\nstruct vsetNodeVal {\n RedisModuleString *item;\n RedisModuleString *attrib;\n};\n\n/* Count the number of set bits in an integer (population count/Hamming weight).\n * This is a portable implementation that doesn't rely on compiler\n * extensions. */\nstatic inline uint32_t bit_count(uint32_t n) {\n uint32_t count = 0;\n while (n) {\n count += n & 1;\n n >>= 1;\n }\n return count;\n}\n\n/* Create a Hadamard-based projection matrix for dimensionality reduction.\n * Uses {-1, +1} entries with a pattern based on bit operations.\n * The pattern is matrix[i][j] = (i & j) % 2 == 0 ? 1 : -1\n * Matrix is scaled by 1/sqrt(input_dim) for normalization.\n * Returns NULL on allocation failure.\n *\n * Note that compared to other approaches (random gaussian weights), what\n * we have here is deterministic, it means that our replicas will have\n * the same set of weights. Also this approach seems to work much better\n * in practice, and the distances between elements are better guaranteed.\n *\n * Note that we still save the projection matrix in the RDB file, because\n * in the future we may change the weights generation, and we want everything\n * to be backward compatible. */\nfloat *createProjectionMatrix(uint32_t input_dim, uint32_t output_dim) {\n float *matrix = RedisModule_Alloc(sizeof(float) * input_dim * output_dim);\n\n /* Scale factor to normalize the projection. */\n const float scale = 1.0f / sqrt(input_dim);\n\n /* Fill the matrix using Hadamard pattern. */\n for (uint32_t i = 0; i < output_dim; i++) {\n for (uint32_t j = 0; j < input_dim; j++) {\n /* Calculate position in the flattened matrix. */\n uint32_t pos = i * input_dim + j;\n\n /* Hadamard pattern: use bit operations to determine sign\n * If the count of 1-bits in the bitwise AND of i and j is even,\n * the value is 1, otherwise -1. */\n int value = (bit_count(i & j) % 2 == 0) ? 1 : -1;\n\n /* Store the scaled value. */\n matrix[pos] = value * scale;\n }\n }\n return matrix;\n}\n\n/* Apply random projection to input vector. Returns new allocated vector. */\nfloat *applyProjection(const float *input, const float *proj_matrix,\n uint32_t input_dim, uint32_t output_dim)\n{\n float *output = RedisModule_Alloc(sizeof(float) * output_dim);\n\n for (uint32_t i = 0; i < output_dim; i++) {\n const float *row = &proj_matrix[i * input_dim];\n float sum = 0.0f;\n for (uint32_t j = 0; j < input_dim; j++) {\n sum += row[j] * input[j];\n }\n output[i] = sum;\n }\n return output;\n}\n\n/* Create the vector as HNSW+Dictionary combined data structure. */\nstruct vsetObject *createVectorSetObject(unsigned int dim, uint32_t quant_type, uint32_t hnsw_M) {\n struct vsetObject *o;\n o = RedisModule_Alloc(sizeof(*o));\n\n o->id = VectorSetTypeNextId++;\n o->hnsw = hnsw_new(dim,quant_type,hnsw_M);\n if (!o->hnsw) { // May fail because of mutex creation.\n RedisModule_Free(o);\n return NULL;\n }\n\n o->dict = RedisModule_CreateDict(NULL);\n o->proj_matrix = NULL;\n o->proj_input_size = 0;\n o->numattribs = 0;\n o->thread_creation_pending = 0;\n RedisModule_Assert(pthread_rwlock_init(&o->in_use_lock,NULL) == 0);\n return o;\n}\n\nvoid vectorSetReleaseNodeValue(void *v) {\n struct vsetNodeVal *nv = v;\n RedisModule_FreeString(NULL,nv->item);\n if (nv->attrib) RedisModule_FreeString(NULL,nv->attrib);\n RedisModule_Free(nv);\n}\n\n/* Free the vector set object. */\nvoid vectorSetReleaseObject(struct vsetObject *o) {\n if (!o) return;\n if (o->hnsw) hnsw_free(o->hnsw,vectorSetReleaseNodeValue);\n if (o->dict) RedisModule_FreeDict(NULL,o->dict);\n if (o->proj_matrix) RedisModule_Free(o->proj_matrix);\n pthread_rwlock_destroy(&o->in_use_lock);\n RedisModule_Free(o);\n}\n\n/* Wait for all the threads performing operations on this\n * index to terminate their work (locking for write will\n * wait for all the other threads).\n *\n * if 'for_del' is set to 1, we also wait for all the pending threads\n * that still didn't acquire the lock to finish their work. This\n * is useful only if we are going to call this function to delete\n * the object, and not if we want to just to modify it. */\nvoid vectorSetWaitAllBackgroundClients(struct vsetObject *vset, int for_del) {\n if (for_del) {\n // If we are going to destroy the object, after this call, let's\n // wait for threads that are being created and still didn't had\n // a chance to acquire the lock.\n while (vset->thread_creation_pending > 0);\n }\n RedisModule_Assert(pthread_rwlock_wrlock(&vset->in_use_lock) == 0);\n pthread_rwlock_unlock(&vset->in_use_lock);\n}\n\n/* Return a string representing the quantization type name of a vector set. */\nconst char *vectorSetGetQuantName(struct vsetObject *o) {\n switch(o->hnsw->quant_type) {\n case HNSW_QUANT_NONE: return \"f32\";\n case HNSW_QUANT_Q8: return \"int8\";\n case HNSW_QUANT_BIN: return \"bin\";\n default: return \"unknown\";\n }\n}\n\n/* Insert the specified element into the Vector Set.\n * If update is '1', the existing node will be updated.\n *\n * Returns 1 if the element was added, or 0 if the element was already there\n * and was just updated. */\nint vectorSetInsert(struct vsetObject *o, float *vec, int8_t *qvec, float qrange, RedisModuleString *val, RedisModuleString *attrib, int update, int ef)\n{\n hnswNode *node = RedisModule_DictGet(o->dict,val,NULL);\n if (node != NULL) {\n if (update) {\n /* Wait for clients in the background: background VSIM\n * operations touch the nodes attributes we are going\n * to touch. */\n vectorSetWaitAllBackgroundClients(o,0);\n\n struct vsetNodeVal *nv = node->value;\n /* Pass NULL as value-free function. We want to reuse\n * the old value. */\n hnsw_delete_node(o->hnsw, node, NULL);\n node = hnsw_insert(o->hnsw,vec,qvec,qrange,0,nv,ef);\n RedisModule_Assert(node != NULL);\n RedisModule_DictReplace(o->dict,val,node);\n\n /* If attrib != NULL, the user wants that in case of an update we\n * update the attribute as well (otherwise it remains as it was).\n * Note that the order of operations is conceinved so that it\n * works in case the old attrib and the new attrib pointer is the\n * same. */\n if (attrib) {\n // Empty attribute string means: unset the attribute during\n // the update.\n size_t attrlen;\n RedisModule_StringPtrLen(attrib,&attrlen);\n if (attrlen != 0) {\n RedisModule_RetainString(NULL,attrib);\n o->numattribs++;\n } else {\n attrib = NULL;\n }\n\n if (nv->attrib) {\n o->numattribs--;\n RedisModule_FreeString(NULL,nv->attrib);\n }\n nv->attrib = attrib;\n }\n }\n return 0;\n }\n\n struct vsetNodeVal *nv = RedisModule_Alloc(sizeof(*nv));\n nv->item = val;\n nv->attrib = attrib;\n node = hnsw_insert(o->hnsw,vec,qvec,qrange,0,nv,ef);\n if (node == NULL) {\n // XXX Technically in Redis-land we don't have out of memory, as we\n // crash on OOM. However the HNSW library may fail for error in the\n // locking libc call. Probably impossible in practical terms.\n RedisModule_Free(nv);\n return 0;\n }\n if (attrib != NULL) o->numattribs++;\n RedisModule_DictSet(o->dict,val,node);\n RedisModule_RetainString(NULL,val);\n if (attrib) RedisModule_RetainString(NULL,attrib);\n return 1;\n}\n\n/* Parse vector from FP32 blob or VALUES format, with optional REDUCE.\n * Format: [REDUCE dim] FP32|VALUES ...\n * Returns allocated vector and sets dimension in *dim.\n * If reduce_dim is not NULL, sets it to the requested reduction dimension.\n * Returns NULL on parsing error.\n *\n * The function sets as a reference *consumed_args, so that the caller\n * knows how many arguments we consumed in order to parse the input\n * vector. Remaining arguments are often command options. */\nfloat *parseVector(RedisModuleString **argv, int argc, int start_idx,\n size_t *dim, uint32_t *reduce_dim, int *consumed_args)\n{\n int consumed = 0; // Arguments consumed\n\n /* Check for REDUCE option first. */\n if (reduce_dim) *reduce_dim = 0;\n if (reduce_dim && argc > start_idx + 2 &&\n !strcasecmp(RedisModule_StringPtrLen(argv[start_idx],NULL),\"REDUCE\"))\n {\n long long rdim;\n if (RedisModule_StringToLongLong(argv[start_idx+1],&rdim)\n != REDISMODULE_OK || rdim <= 0)\n {\n return NULL;\n }\n if (reduce_dim) *reduce_dim = rdim;\n start_idx += 2; // Skip REDUCE and its argument.\n consumed += 2;\n }\n\n /* Now parse the vector format as before. */\n float *vec = NULL;\n const char *vec_format = RedisModule_StringPtrLen(argv[start_idx],NULL);\n\n if (!strcasecmp(vec_format,\"FP32\")) {\n if (argc < start_idx + 2) return NULL; // Need FP32 + vector + value.\n size_t vec_raw_len;\n const char *blob =\n RedisModule_StringPtrLen(argv[start_idx+1],&vec_raw_len);\n\n // Must be 4 bytes per component.\n if (vec_raw_len % 4 || vec_raw_len < 4) return NULL;\n *dim = vec_raw_len/4;\n\n vec = RedisModule_Alloc(vec_raw_len);\n if (!vec) return NULL;\n memcpy(vec,blob,vec_raw_len);\n consumed += 2;\n } else if (!strcasecmp(vec_format,\"VALUES\")) {\n if (argc < start_idx + 2) return NULL; // Need at least the dimension.\n long long vdim; // Vector dimension passed by the user.\n if (RedisModule_StringToLongLong(argv[start_idx+1],&vdim)\n != REDISMODULE_OK || vdim < 1) return NULL;\n\n // Check that all the arguments are available.\n if (argc < start_idx + 2 + vdim) return NULL;\n\n *dim = vdim;\n vec = RedisModule_Alloc(sizeof(float) * vdim);\n if (!vec) return NULL;\n\n for (int j = 0; j < vdim; j++) {\n double val;\n if (RedisModule_StringToDouble(argv[start_idx+2+j],&val)\n != REDISMODULE_OK)\n {\n RedisModule_Free(vec);\n return NULL;\n }\n vec[j] = val;\n }\n consumed += vdim + 2;\n } else {\n return NULL; // Unknown format.\n }\n\n if (consumed_args) *consumed_args = consumed;\n return vec;\n}\n\n/* ========================== Commands implementation ======================= */\n\n/* VADD thread handling the \"CAS\" version of the command, that is\n * performed blocking the client, accumulating here, in the thread, the\n * set of potential candidates, and later inserting the element in the\n * key (if it still exists, and if it is still the *same* vector set)\n * in the Reply callback. */\nvoid *VADD_thread(void *arg) {\n pthread_detach(pthread_self());\n\n void **targ = (void**)arg;\n RedisModuleBlockedClient *bc = targ[0];\n struct vsetObject *vset = targ[1];\n float *vec = targ[3];\n int ef = (uint64_t)targ[6];\n\n /* Lock the object and signal that we are no longer pending\n * the lock acquisition. */\n RedisModule_Assert(pthread_rwlock_rdlock(&vset->in_use_lock) == 0);\n vset->thread_creation_pending--;\n\n /* Look for candidates... */\n InsertContext *ic = hnsw_prepare_insert(vset->hnsw, vec, NULL, 0, 0, ef);\n targ[5] = ic; // Pass the context to the reply callback.\n\n /* Unblock the client so that our read reply will be invoked. */\n pthread_rwlock_unlock(&vset->in_use_lock);\n RedisModule_BlockedClientMeasureTimeEnd(bc);\n RedisModule_UnblockClient(bc,targ); // Use targ as privdata.\n return NULL;\n}\n\n/* Reply callback for CAS variant of VADD.\n * Note: this is called in the main thread, in the background thread\n * we just do the read operation of gathering the neighbors. */\nint VADD_CASReply(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n (void)argc;\n RedisModule_AutoMemory(ctx); /* Use automatic memory management. */\n\n int retval = REDISMODULE_OK;\n void **targ = (void**)RedisModule_GetBlockedClientPrivateData(ctx);\n uint64_t vset_id = (unsigned long) targ[2];\n float *vec = targ[3];\n RedisModuleString *val = targ[4];\n InsertContext *ic = targ[5];\n int ef = (uint64_t)targ[6];\n RedisModuleString *attrib = targ[7];\n RedisModule_Free(targ);\n\n /* Open the key: there are no guarantees it still exists, or contains\n * a vector set, or even the SAME vector set. */\n RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],\n REDISMODULE_READ|REDISMODULE_WRITE);\n int type = RedisModule_KeyType(key);\n struct vsetObject *vset = NULL;\n\n if (type != REDISMODULE_KEYTYPE_EMPTY &&\n RedisModule_ModuleTypeGetType(key) == VectorSetType)\n {\n vset = RedisModule_ModuleTypeGetValue(key);\n // Same vector set?\n if (vset->id != vset_id) vset = NULL;\n\n /* Also, if the element was already inserted, we just pretend\n * the other insert won. We don't even start a threaded VADD\n * if this was an update, since the deletion of the element itself\n * in order to perform the update would invalidate the CAS state. */\n if (vset && RedisModule_DictGet(vset->dict,val,NULL) != NULL)\n vset = NULL;\n }\n\n if (vset == NULL) {\n /* If the object does not match the start of the operation, we\n * just pretend the VADD was performed BEFORE the key was deleted\n * or replaced. We return success but don't do anything. */\n hnsw_free_insert_context(ic);\n } else {\n /* Otherwise try to insert the new element with the neighbors\n * collected in background. If we fail, do it synchronously again\n * from scratch. */\n\n // First: allocate the dual-ported value for the node.\n struct vsetNodeVal *nv = RedisModule_Alloc(sizeof(*nv));\n nv->item = val;\n nv->attrib = attrib;\n\n /* Then: insert the node in the HNSW data structure. Note that\n * 'ic' could be NULL in case hnsw_prepare_insert() failed because of\n * locking failure (likely impossible in practical terms). */\n hnswNode *newnode;\n if (ic == NULL ||\n (newnode = hnsw_try_commit_insert(vset->hnsw, ic, nv)) == NULL)\n {\n /* If we are here, the CAS insert failed. We need to insert\n * again with full locking for neighbors selection and\n * actual insertion. This time we can't fail: */\n newnode = hnsw_insert(vset->hnsw, vec, NULL, 0, 0, nv, ef);\n RedisModule_Assert(newnode != NULL);\n }\n RedisModule_DictSet(vset->dict,val,newnode);\n val = NULL; // Don't free it later.\n attrib = NULL; // Don't free it later.\n\n RedisModule_ReplicateVerbatim(ctx);\n }\n\n // Whatever happens is a success... :D\n RedisModule_ReplyWithBool(ctx,1);\n if (val) RedisModule_FreeString(ctx,val); // Not added? Free it.\n if (attrib) RedisModule_FreeString(ctx,attrib); // Not added? Free it.\n RedisModule_Free(vec);\n return retval;\n}\n\n/* VADD key [REDUCE dim] FP32|VALUES vector value [CAS] [NOQUANT] [BIN] [Q8]\n * [M count] */\nint VADD_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx); /* Use automatic memory management. */\n\n if (argc < 5) return RedisModule_WrongArity(ctx);\n\n /* Parse vector with optional REDUCE */\n size_t dim = 0;\n uint32_t reduce_dim = 0;\n int consumed_args;\n int cas = 0; // Threaded check-and-set style insert.\n long long ef = VSET_DEFAULT_C_EF; // HNSW creation time EF for new nodes.\n long long hnsw_create_M = HNSW_DEFAULT_M; // HNSW creation default M value.\n float *vec = parseVector(argv, argc, 2, &dim, &reduce_dim, &consumed_args);\n RedisModuleString *attrib = NULL; // Attributes if passed via ATTRIB.\n if (!vec)\n return RedisModule_ReplyWithError(ctx,\"ERR invalid vector specification\");\n\n /* Missing element string at the end? */\n if (argc-2-consumed_args < 1) {\n RedisModule_Free(vec);\n return RedisModule_WrongArity(ctx);\n }\n\n /* Parse options after the element string. */\n uint32_t quant_type = HNSW_QUANT_Q8; // Default quantization type.\n\n for (int j = 2 + consumed_args + 1; j < argc; j++) {\n const char *opt = RedisModule_StringPtrLen(argv[j], NULL);\n if (!strcasecmp(opt, \"CAS\")) {\n cas = 1;\n } else if (!strcasecmp(opt, \"EF\") && j+1 < argc) {\n if (RedisModule_StringToLongLong(argv[j+1], &ef)\n != REDISMODULE_OK || ef <= 0 || ef > 1000000)\n {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid EF\");\n }\n j++; // skip argument.\n } else if (!strcasecmp(opt, \"M\") && j+1 < argc) {\n if (RedisModule_StringToLongLong(argv[j+1], &hnsw_create_M)\n != REDISMODULE_OK || hnsw_create_M < HNSW_MIN_M ||\n hnsw_create_M > HNSW_MAX_M)\n {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid M\");\n }\n j++; // skip argument.\n } else if (!strcasecmp(opt, \"SETATTR\") && j+1 < argc) {\n attrib = argv[j+1];\n j++; // skip argument.\n } else if (!strcasecmp(opt, \"NOQUANT\")) {\n quant_type = HNSW_QUANT_NONE;\n } else if (!strcasecmp(opt, \"BIN\")) {\n quant_type = HNSW_QUANT_BIN;\n } else if (!strcasecmp(opt, \"Q8\")) {\n quant_type = HNSW_QUANT_Q8;\n } else {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\"ERR invalid option after element\");\n }\n }\n\n /* Drop CAS if this is a replica and we are getting the command from the\n * replication link: we want to add/delete items in the same order as\n * the master, while with CAS the timing would be different.\n *\n * Also for Lua scripts and MULTI/EXEC, we want to run the command\n * on the main thread. */\n if (RedisModule_GetContextFlags(ctx) &\n (REDISMODULE_CTX_FLAGS_REPLICATED|\n REDISMODULE_CTX_FLAGS_LUA|\n REDISMODULE_CTX_FLAGS_MULTI))\n {\n cas = 0;\n }\n\n if (VSGlobalConfig.forceSingleThreadExec) {\n cas = 0;\n }\n\n /* Open/create key */\n RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],\n REDISMODULE_READ|REDISMODULE_WRITE);\n int type = RedisModule_KeyType(key);\n if (type != REDISMODULE_KEYTYPE_EMPTY &&\n RedisModule_ModuleTypeGetType(key) != VectorSetType)\n {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n /* Get the correct value argument based on format and REDUCE */\n RedisModuleString *val = argv[2 + consumed_args];\n\n /* Create or get existing vector set */\n struct vsetObject *vset;\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n cas = 0; /* Do synchronous insert at creation, otherwise the\n * key would be left empty until the threaded part\n * does not return. It's also pointless to try try\n * doing threaded first element insertion. */\n vset = createVectorSetObject(reduce_dim ? reduce_dim : dim, quant_type, hnsw_create_M);\n if (vset == NULL) {\n // We can't fail for OOM in Redis, but the mutex initialization\n // at least theoretically COULD fail. Likely this code path\n // is not reachable in practical terms.\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR unable to create a Vector Set: system resources issue?\");\n }\n\n /* Initialize projection if requested */\n if (reduce_dim) {\n vset->proj_matrix = createProjectionMatrix(dim, reduce_dim);\n vset->proj_input_size = dim;\n\n /* Project the vector */\n float *projected = applyProjection(vec, vset->proj_matrix,\n dim, reduce_dim);\n RedisModule_Free(vec);\n vec = projected;\n }\n RedisModule_ModuleTypeSetValue(key,VectorSetType,vset);\n } else {\n vset = RedisModule_ModuleTypeGetValue(key);\n\n if (vset->hnsw->quant_type != quant_type) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR asked quantization mismatch with existing vector set\");\n }\n\n if (vset->hnsw->M != hnsw_create_M) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR asked M value mismatch with existing vector set\");\n }\n\n if ((vset->proj_matrix == NULL && vset->hnsw->vector_dim != dim) ||\n (vset->proj_matrix && vset->hnsw->vector_dim != reduce_dim))\n {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithErrorFormat(ctx,\n \"ERR Vector dimension mismatch - got %d but set has %d\",\n (int)dim, (int)vset->hnsw->vector_dim);\n }\n\n /* Check REDUCE compatibility */\n if (reduce_dim) {\n if (!vset->proj_matrix) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR cannot add projection to existing set without projection\");\n }\n if (reduce_dim != vset->hnsw->vector_dim) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR projection dimension mismatch with existing set\");\n }\n }\n\n /* Apply projection if needed */\n if (vset->proj_matrix) {\n /* Ensure input dimension matches the projection matrix's expected input dimension */\n if (dim != vset->proj_input_size) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithErrorFormat(ctx,\n \"ERR Input dimension mismatch for projection - got %d but projection expects %d\",\n (int)dim, (int)vset->proj_input_size);\n }\n\n float *projected = applyProjection(vec, vset->proj_matrix,\n vset->proj_input_size,\n vset->hnsw->vector_dim);\n RedisModule_Free(vec);\n vec = projected;\n dim = vset->hnsw->vector_dim;\n }\n }\n\n /* For existing keys don't do CAS updates. For how things work now, the\n * CAS state would be invalidated by the deletion before adding back. */\n if (cas && RedisModule_DictGet(vset->dict,val,NULL) != NULL)\n cas = 0;\n\n /* Here depending on the CAS option we directly insert in a blocking\n * way, or use a thread to do candidate neighbors selection and only\n * later, in the reply callback, actually add the element. */\n if (cas) {\n RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx,VADD_CASReply,NULL,NULL,0);\n pthread_t tid;\n void **targ = RedisModule_Alloc(sizeof(void*)*8);\n targ[0] = bc;\n targ[1] = vset;\n targ[2] = (void*)(unsigned long)vset->id;\n targ[3] = vec;\n targ[4] = val;\n targ[5] = NULL; // Used later for insertion context.\n targ[6] = (void*)(unsigned long)ef;\n targ[7] = attrib;\n RedisModule_RetainString(ctx,val);\n if (attrib) RedisModule_RetainString(ctx,attrib);\n RedisModule_BlockedClientMeasureTimeStart(bc);\n vset->thread_creation_pending++;\n if (pthread_create(&tid,NULL,VADD_thread,targ) != 0) {\n vset->thread_creation_pending--;\n RedisModule_AbortBlock(bc);\n RedisModule_Free(targ);\n RedisModule_FreeString(ctx,val);\n if (attrib) RedisModule_FreeString(ctx,attrib);\n\n // Fall back to synchronous insert, see later in the code.\n } else {\n return REDISMODULE_OK;\n }\n }\n\n /* Insert vector synchronously: we reach this place even\n * if cas was true but thread creation failed. */\n int added = vectorSetInsert(vset,vec,NULL,0,val,attrib,1,ef);\n RedisModule_Free(vec);\n\n RedisModule_ReplyWithBool(ctx,added);\n if (added) RedisModule_ReplicateVerbatim(ctx);\n return REDISMODULE_OK;\n}\n\n/* HNSW callback to filter items according to a predicate function\n * (our FILTER expression in this case). */\nint vectorSetFilterCallback(void *value, void *privdata) {\n exprstate *expr = privdata;\n struct vsetNodeVal *nv = value;\n if (nv->attrib == NULL) return 0; // No attributes? No match.\n size_t json_len;\n char *json = (char*)RedisModule_StringPtrLen(nv->attrib,&json_len);\n return exprRun(expr,json,json_len);\n}\n\n/* Common path for the execution of the VSIM command both threaded and\n * not threaded. Note that 'ctx' may be normal context of a thread safe\n * context obtained from a blocked client. The locking that is specific\n * to the vset object is handled by the caller, however the function\n * handles the HNSW locking explicitly. */\nvoid VSIM_execute(RedisModuleCtx *ctx, struct vsetObject *vset,\n float *vec, unsigned long count, float epsilon, unsigned long withscores,\n unsigned long withattribs, unsigned long ef, exprstate *filter_expr,\n unsigned long filter_ef, int ground_truth)\n{\n /* In our scan, we can't just collect 'count' elements as\n * if count is small we would explore the graph in an insufficient\n * way to provide enough recall.\n *\n * If the user didn't asked for a specific exploration, we use\n * VSET_DEFAULT_SEARCH_EF as minimum, or we match count if count\n * is greater than that. Otherwise the minumim will be the specified\n * EF argument. */\n if (ef == 0) ef = VSET_DEFAULT_SEARCH_EF;\n if (count > ef) ef = count;\n\n int slot = hnsw_acquire_read_slot(vset->hnsw);\n if (ef > vset->hnsw->node_count) ef = vset->hnsw->node_count;\n\n /* Perform search */\n hnswNode **neighbors = RedisModule_Alloc(sizeof(hnswNode*)*ef);\n float *distances = RedisModule_Alloc(sizeof(float)*ef);\n unsigned int found;\n if (ground_truth) {\n found = hnsw_ground_truth_with_filter(vset->hnsw, vec, ef, neighbors,\n distances, slot, 0,\n filter_expr ? vectorSetFilterCallback : NULL,\n filter_expr);\n } else {\n if (filter_expr == NULL) {\n found = hnsw_search(vset->hnsw, vec, ef, neighbors,\n distances, slot, 0);\n } else {\n found = hnsw_search_with_filter(vset->hnsw, vec, ef, neighbors,\n distances, slot, 0, vectorSetFilterCallback,\n filter_expr, filter_ef);\n }\n }\n\n /* Return results */\n int resp3 = RedisModule_GetContextFlags(ctx) & REDISMODULE_CTX_FLAGS_RESP3;\n int reply_with_map = resp3 && (withscores || withattribs);\n\n if (reply_with_map)\n RedisModule_ReplyWithMap(ctx, REDISMODULE_POSTPONED_LEN);\n else\n RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);\n\n long long arraylen = 0;\n for (unsigned int i = 0; i < found && i < count; i++) {\n if (distances[i]/2 > epsilon) break;\n struct vsetNodeVal *nv = neighbors[i]->value;\n RedisModule_ReplyWithString(ctx, nv->item);\n arraylen++;\n\n /* If the user asked for multiple properties at the same time using\n * the RESP3 protocol, we wrap the value of the map into an N-items\n * array. Two for now, since we have just two properties that can be\n * requested.\n *\n * So in the case of RESP2 we will just have the flat reply:\n * item, score, attribute. For RESP3 instead item -> [score, attribute]\n */\n if (resp3 && withscores && withattribs)\n RedisModule_ReplyWithArray(ctx,2);\n\n if (withscores) {\n /* The similarity score is provided in a 0-1 range. */\n RedisModule_ReplyWithDouble(ctx, 1.0 - distances[i]/2.0);\n }\n if (withattribs) {\n /* Return the attributes as well, if any. */\n if (nv->attrib)\n RedisModule_ReplyWithString(ctx, nv->attrib);\n else\n RedisModule_ReplyWithNull(ctx);\n }\n }\n hnsw_release_read_slot(vset->hnsw,slot);\n\n if (reply_with_map) {\n RedisModule_ReplySetMapLength(ctx, arraylen);\n } else {\n int items_per_ele = 1+withattribs+withscores;\n RedisModule_ReplySetArrayLength(ctx, arraylen * items_per_ele);\n }\n\n RedisModule_Free(vec);\n RedisModule_Free(neighbors);\n RedisModule_Free(distances);\n if (filter_expr) exprFree(filter_expr);\n}\n\n/* VSIM thread handling the blocked client request. */\nvoid *VSIM_thread(void *arg) {\n pthread_detach(pthread_self());\n\n // Extract arguments.\n void **targ = (void**)arg;\n RedisModuleBlockedClient *bc = targ[0];\n struct vsetObject *vset = targ[1];\n float *vec = targ[2];\n unsigned long count = (unsigned long)targ[3];\n float epsilon = *((float*)targ[4]);\n unsigned long withscores = (unsigned long)targ[5];\n unsigned long withattribs = (unsigned long)targ[6];\n unsigned long ef = (unsigned long)targ[7];\n exprstate *filter_expr = targ[8];\n unsigned long filter_ef = (unsigned long)targ[9];\n unsigned long ground_truth = (unsigned long)targ[10];\n RedisModule_Free(targ[4]);\n RedisModule_Free(targ);\n\n /* Lock the object and signal that we are no longer pending\n * the lock acquisition. */\n RedisModule_Assert(pthread_rwlock_rdlock(&vset->in_use_lock) == 0);\n vset->thread_creation_pending--;\n\n // Accumulate reply in a thread safe context: no contention.\n RedisModuleCtx *ctx = RedisModule_GetThreadSafeContext(bc);\n\n // Run the query.\n VSIM_execute(ctx, vset, vec, count, epsilon, withscores, withattribs, ef, filter_expr, filter_ef, ground_truth);\n pthread_rwlock_unlock(&vset->in_use_lock);\n\n // Cleanup.\n RedisModule_FreeThreadSafeContext(ctx);\n RedisModule_BlockedClientMeasureTimeEnd(bc);\n RedisModule_UnblockClient(bc,NULL);\n return NULL;\n}\n\n/* VSIM key [ELE|FP32|VALUES] [WITHSCORES] [WITHATTRIBS] [COUNT num] [EPSILON eps] [EF exploration-factor] [FILTER expression] [FILTER-EF exploration-factor] */\nint VSIM_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n /* Basic argument check: need at least key and vector specification\n * method. */\n if (argc < 4) return RedisModule_WrongArity(ctx);\n\n /* Defaults */\n int withscores = 0;\n int withattribs = 0;\n long long count = VSET_DEFAULT_COUNT; /* New default value */\n long long ef = 0; /* Exploration factor (see HNSW paper) */\n double epsilon = 2.0; /* Max cosine distance */\n long long ground_truth = 0; /* Linear scan instead of HNSW search? */\n int no_thread = 0; /* NOTHREAD option: exec on main thread. */\n\n /* Things computed later. */\n long long filter_ef = 0;\n exprstate *filter_expr = NULL;\n\n /* Get key and vector type */\n RedisModuleString *key = argv[1];\n const char *vectorType = RedisModule_StringPtrLen(argv[2], NULL);\n\n /* Get vector set */\n RedisModuleKey *keyptr = RedisModule_OpenKey(ctx, key, REDISMODULE_READ);\n int type = RedisModule_KeyType(keyptr);\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithEmptyArray(ctx);\n\n if (RedisModule_ModuleTypeGetType(keyptr) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(keyptr);\n\n /* Vector parsing stage */\n float *vec = NULL;\n size_t dim = 0;\n int vector_args = 0; /* Number of args consumed by vector specification */\n\n if (!strcasecmp(vectorType, \"ELE\")) {\n /* Get vector from existing element */\n RedisModuleString *ele = argv[3];\n hnswNode *node = RedisModule_DictGet(vset->dict, ele, NULL);\n if (!node) {\n return RedisModule_ReplyWithError(ctx, \"ERR element not found in set\");\n }\n vec = RedisModule_Alloc(sizeof(float) * vset->hnsw->vector_dim);\n hnsw_get_node_vector(vset->hnsw,node,vec);\n dim = vset->hnsw->vector_dim;\n vector_args = 2; /* ELE + element name */\n } else {\n /* Parse vector. */\n int consumed_args;\n\n vec = parseVector(argv, argc, 2, &dim, NULL, &consumed_args);\n if (!vec) {\n return RedisModule_ReplyWithError(ctx,\n \"ERR invalid vector specification\");\n }\n vector_args = consumed_args;\n\n /* Apply projection if the set uses it, with the exception\n * of ELE type, that will already have the right dimension. */\n if (vset->proj_matrix && dim != vset->hnsw->vector_dim) {\n /* Ensure input dimension matches the projection matrix's expected input dimension */\n if (dim != vset->proj_input_size) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithErrorFormat(ctx,\n \"ERR Input dimension mismatch for projection - got %d but projection expects %d\",\n (int)dim, (int)vset->proj_input_size);\n }\n\n float *projected = applyProjection(vec, vset->proj_matrix,\n vset->proj_input_size,\n vset->hnsw->vector_dim);\n RedisModule_Free(vec);\n vec = projected;\n dim = vset->hnsw->vector_dim;\n }\n\n /* Count consumed arguments */\n if (!strcasecmp(vectorType, \"FP32\")) {\n vector_args = 2; /* FP32 + vector blob */\n } else if (!strcasecmp(vectorType, \"VALUES\")) {\n long long vdim;\n if (RedisModule_StringToLongLong(argv[3], &vdim) != REDISMODULE_OK) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid vector dimension\");\n }\n vector_args = 2 + vdim; /* VALUES + dim + values */\n } else {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithError(ctx,\n \"ERR vector type must be ELE, FP32 or VALUES\");\n }\n }\n\n /* Check vector dimension matches set */\n if (dim != vset->hnsw->vector_dim) {\n RedisModule_Free(vec);\n return RedisModule_ReplyWithErrorFormat(ctx,\n \"ERR Vector dimension mismatch - got %d but set has %d\",\n (int)dim, (int)vset->hnsw->vector_dim);\n }\n\n /* Parse optional arguments - start after vector specification */\n int j = 2 + vector_args;\n while (j < argc) {\n const char *opt = RedisModule_StringPtrLen(argv[j], NULL);\n if (!strcasecmp(opt, \"WITHSCORES\")) {\n withscores = 1;\n j++;\n } else if (!strcasecmp(opt, \"WITHATTRIBS\")) {\n withattribs = 1;\n j++;\n } else if (!strcasecmp(opt, \"TRUTH\")) {\n ground_truth = 1;\n j++;\n } else if (!strcasecmp(opt, \"NOTHREAD\")) {\n no_thread = 1;\n j++;\n } else if (!strcasecmp(opt, \"COUNT\") && j+1 < argc) {\n if (RedisModule_StringToLongLong(argv[j+1], &count)\n != REDISMODULE_OK || count <= 0)\n {\n RedisModule_Free(vec);\n if (filter_expr) exprFree(filter_expr);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid COUNT\");\n }\n j += 2;\n } else if (!strcasecmp(opt, \"EPSILON\") && j+1 < argc) {\n if (RedisModule_StringToDouble(argv[j+1], &epsilon) !=\n REDISMODULE_OK || epsilon <= 0)\n {\n RedisModule_Free(vec);\n if (filter_expr) exprFree(filter_expr);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid EPSILON\");\n }\n j += 2;\n } else if (!strcasecmp(opt, \"EF\") && j+1 < argc) {\n if (RedisModule_StringToLongLong(argv[j+1], &ef) !=\n REDISMODULE_OK || ef <= 0 || ef > 1000000)\n {\n RedisModule_Free(vec);\n if (filter_expr) exprFree(filter_expr);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid EF\");\n }\n j += 2;\n } else if (!strcasecmp(opt, \"FILTER-EF\") && j+1 < argc) {\n if (RedisModule_StringToLongLong(argv[j+1], &filter_ef) !=\n REDISMODULE_OK || filter_ef <= 0)\n {\n RedisModule_Free(vec);\n if (filter_expr) exprFree(filter_expr);\n return RedisModule_ReplyWithError(ctx, \"ERR invalid FILTER-EF\");\n }\n j += 2;\n } else if (!strcasecmp(opt, \"FILTER\") && j+1 < argc) {\n RedisModuleString *exprarg = argv[j+1];\n size_t exprlen;\n char *exprstr = (char*)RedisModule_StringPtrLen(exprarg,&exprlen);\n int errpos;\n if (filter_expr) exprFree(filter_expr);\n filter_expr = exprCompile(exprstr,&errpos);\n if (filter_expr == NULL) {\n if ((size_t)errpos >= exprlen) errpos = 0;\n RedisModule_Free(vec);\n return RedisModule_ReplyWithErrorFormat(ctx,\n \"ERR syntax error in FILTER expression near: %s\",\n exprstr+errpos);\n }\n j += 2;\n } else {\n RedisModule_Free(vec);\n if (filter_expr) exprFree(filter_expr);\n return RedisModule_ReplyWithError(ctx,\n \"ERR syntax error in VSIM command\");\n }\n }\n\n int threaded_request = 1; // Run on a thread, by default.\n if (filter_ef == 0) filter_ef = count * 100; // Max filter visited nodes.\n\n /* Disable threaded for MULTI/EXEC and Lua, or if explicitly\n * requested by the user via the NOTHREAD option. */\n if (no_thread || VSGlobalConfig.forceSingleThreadExec ||\n (RedisModule_GetContextFlags(ctx) &\n (REDISMODULE_CTX_FLAGS_LUA | REDISMODULE_CTX_FLAGS_MULTI)))\n {\n threaded_request = 0;\n }\n\n if (threaded_request) {\n /* Note: even if we create one thread per request, the underlying\n * HNSW library has a fixed number of slots for the threads, as it's\n * defined in HNSW_MAX_THREADS (beware that if you increase it,\n * every node will use more memory). This means that while this request\n * is threaded, and will NOT block Redis, it may end waiting for a\n * free slot if all the HNSW_MAX_THREADS slots are used. */\n RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx,NULL,NULL,NULL,0);\n pthread_t tid;\n void **targ = RedisModule_Alloc(sizeof(void*)*11);\n targ[0] = bc;\n targ[1] = vset;\n targ[2] = vec;\n targ[3] = (void*)count;\n targ[4] = RedisModule_Alloc(sizeof(float));\n *((float*)targ[4]) = epsilon;\n targ[5] = (void*)(unsigned long)withscores;\n targ[6] = (void*)(unsigned long)withattribs;\n targ[7] = (void*)(unsigned long)ef;\n targ[8] = (void*)filter_expr;\n targ[9] = (void*)(unsigned long)filter_ef;\n targ[10] = (void*)(unsigned long)ground_truth;\n RedisModule_BlockedClientMeasureTimeStart(bc);\n vset->thread_creation_pending++;\n if (pthread_create(&tid,NULL,VSIM_thread,targ) != 0) {\n vset->thread_creation_pending--;\n RedisModule_AbortBlock(bc);\n RedisModule_Free(targ[4]);\n RedisModule_Free(targ);\n VSIM_execute(ctx, vset, vec, count, epsilon, withscores, withattribs, ef, filter_expr, filter_ef, ground_truth);\n }\n } else {\n VSIM_execute(ctx, vset, vec, count, epsilon, withscores, withattribs, ef, filter_expr, filter_ef, ground_truth);\n }\n\n return REDISMODULE_OK;\n}\n\n/* VDIM : return the dimension of vectors in the vector set. */\nint VDIM_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc != 2) return RedisModule_WrongArity(ctx);\n\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithError(ctx, \"ERR key does not exist\");\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n return RedisModule_ReplyWithLongLong(ctx, vset->hnsw->vector_dim);\n}\n\n/* VCARD : return cardinality (num of elements) of the vector set. */\nint VCARD_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc != 2) return RedisModule_WrongArity(ctx);\n\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithLongLong(ctx, 0);\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n return RedisModule_ReplyWithLongLong(ctx, vset->hnsw->node_count);\n}\n\n/* VREM key element\n * Remove an element from a vector set.\n * Returns 1 if the element was found and removed, 0 if not found. */\nint VREM_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx); /* Use automatic memory management. */\n\n if (argc != 3) return RedisModule_WrongArity(ctx);\n\n /* Get key and value */\n RedisModuleString *key = argv[1];\n RedisModuleString *element = argv[2];\n\n /* Open key */\n RedisModuleKey *keyptr = RedisModule_OpenKey(ctx, key,\n REDISMODULE_READ|REDISMODULE_WRITE);\n int type = RedisModule_KeyType(keyptr);\n\n /* Handle non-existing key or wrong type */\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n return RedisModule_ReplyWithBool(ctx, 0);\n }\n if (RedisModule_ModuleTypeGetType(keyptr) != VectorSetType) {\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n /* Get vector set from key */\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(keyptr);\n\n /* Find the node for this element */\n hnswNode *node = RedisModule_DictGet(vset->dict, element, NULL);\n if (!node) {\n return RedisModule_ReplyWithBool(ctx, 0);\n }\n\n /* Remove from dictionary */\n RedisModule_DictDel(vset->dict, element, NULL);\n\n /* Remove from HNSW graph using the high-level API that handles\n * locking and cleanup. We pass RedisModule_FreeString as the value\n * free function since the strings were retained at insertion time. */\n struct vsetNodeVal *nv = node->value;\n if (nv->attrib != NULL) vset->numattribs--;\n RedisModule_Assert(hnsw_delete_node(vset->hnsw, node, vectorSetReleaseNodeValue) == 1);\n\n /* Destroy empty vector set. */\n if (RedisModule_DictSize(vset->dict) == 0) {\n RedisModule_DeleteKey(keyptr);\n }\n\n /* Reply and propagate the command */\n RedisModule_ReplyWithBool(ctx, 1);\n RedisModule_ReplicateVerbatim(ctx);\n return REDISMODULE_OK;\n}\n\n/* VEMB key element\n * Returns the embedding vector associated with an element, or NIL if not\n * found. The vector is returned in the same format it was added, but the\n * return value will have some lack of precision due to quantization and\n * normalization of vectors. Also, if items were added using REDUCE, the\n * reduced vector is returned instead. */\nint VEMB_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n int raw_output = 0; // RAW option.\n\n if (argc < 3) return RedisModule_WrongArity(ctx);\n\n /* Parse arguments. */\n for (int j = 3; j < argc; j++) {\n const char *opt = RedisModule_StringPtrLen(argv[j], NULL);\n if (!strcasecmp(opt,\"raw\")) {\n raw_output = 1;\n } else {\n return RedisModule_ReplyWithError(ctx,\"ERR invalid option\");\n }\n }\n\n /* Get key and element. */\n RedisModuleString *key = argv[1];\n RedisModuleString *element = argv[2];\n\n /* Open key. */\n RedisModuleKey *keyptr = RedisModule_OpenKey(ctx, key, REDISMODULE_READ);\n int type = RedisModule_KeyType(keyptr);\n\n /* Handle non-existing key and key of wrong type. */\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n return RedisModule_ReplyWithNull(ctx);\n } else if (RedisModule_ModuleTypeGetType(keyptr) != VectorSetType) {\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n /* Lookup the node about the specified element. */\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(keyptr);\n hnswNode *node = RedisModule_DictGet(vset->dict, element, NULL);\n if (!node) {\n return RedisModule_ReplyWithNull(ctx);\n }\n\n if (raw_output) {\n int output_qrange = vset->hnsw->quant_type == HNSW_QUANT_Q8;\n RedisModule_ReplyWithArray(ctx, 3+output_qrange);\n RedisModule_ReplyWithSimpleString(ctx, vectorSetGetQuantName(vset));\n RedisModule_ReplyWithStringBuffer(ctx, node->vector, hnsw_quants_bytes(vset->hnsw));\n RedisModule_ReplyWithDouble(ctx, node->l2);\n if (output_qrange) RedisModule_ReplyWithDouble(ctx, node->quants_range);\n } else {\n /* Get the vector associated with the node. */\n float *vec = RedisModule_Alloc(sizeof(float) * vset->hnsw->vector_dim);\n hnsw_get_node_vector(vset->hnsw, node, vec); // May dequantize/denorm.\n\n /* Return as array of doubles. */\n RedisModule_ReplyWithArray(ctx, vset->hnsw->vector_dim);\n for (uint32_t i = 0; i < vset->hnsw->vector_dim; i++)\n RedisModule_ReplyWithDouble(ctx, vec[i]);\n RedisModule_Free(vec);\n }\n return REDISMODULE_OK;\n}\n\n/* VSETATTR key element json\n * Set or remove the JSON attribute associated with an element.\n * Setting an empty string removes the attribute.\n * The command returns one if the attribute was actually updated or\n * zero if there is no key or element. */\nint VSETATTR_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc != 4) return RedisModule_WrongArity(ctx);\n\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1],\n REDISMODULE_READ|REDISMODULE_WRITE);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithBool(ctx, 0);\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n hnswNode *node = RedisModule_DictGet(vset->dict, argv[2], NULL);\n if (!node)\n return RedisModule_ReplyWithBool(ctx, 0);\n\n struct vsetNodeVal *nv = node->value;\n RedisModuleString *new_attr = argv[3];\n\n /* Background VSIM operations use the node attributes, so\n * wait for background operations before messing with them. */\n vectorSetWaitAllBackgroundClients(vset,0);\n\n /* Set or delete the attribute based on the fact it's an empty\n * string or not. */\n size_t attrlen;\n RedisModule_StringPtrLen(new_attr, &attrlen);\n if (attrlen == 0) {\n // If we had an attribute before, decrease the count and free it.\n if (nv->attrib) {\n vset->numattribs--;\n RedisModule_FreeString(NULL, nv->attrib);\n nv->attrib = NULL;\n }\n } else {\n // If we didn't have an attribute before, increase the count.\n // Otherwise free the old one.\n if (nv->attrib) {\n RedisModule_FreeString(NULL, nv->attrib);\n } else {\n vset->numattribs++;\n }\n // Set new attribute.\n RedisModule_RetainString(NULL, new_attr);\n nv->attrib = new_attr;\n }\n\n RedisModule_ReplyWithBool(ctx, 1);\n RedisModule_ReplicateVerbatim(ctx);\n return REDISMODULE_OK;\n}\n\n/* VGETATTR key element\n * Get the JSON attribute associated with an element.\n * Returns NIL if the element has no attribute or doesn't exist. */\nint VGETATTR_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc != 3) return RedisModule_WrongArity(ctx);\n\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithNull(ctx);\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n hnswNode *node = RedisModule_DictGet(vset->dict, argv[2], NULL);\n if (!node)\n return RedisModule_ReplyWithNull(ctx);\n\n struct vsetNodeVal *nv = node->value;\n if (!nv->attrib)\n return RedisModule_ReplyWithNull(ctx);\n\n return RedisModule_ReplyWithString(ctx, nv->attrib);\n}\n\n/* ============================== Reflection ================================ */\n\n/* VLINKS key element [WITHSCORES]\n * Returns the neighbors of an element at each layer in the HNSW graph.\n * Reply is an array of arrays, where each nested array represents one level\n * of neighbors, from highest level to level 0. If WITHSCORES is specified,\n * each neighbor is followed by its distance from the element. */\nint VLINKS_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc < 3 || argc > 4) return RedisModule_WrongArity(ctx);\n\n RedisModuleString *key = argv[1];\n RedisModuleString *element = argv[2];\n\n /* Parse WITHSCORES option. */\n int withscores = 0;\n if (argc == 4) {\n const char *opt = RedisModule_StringPtrLen(argv[3], NULL);\n if (strcasecmp(opt, \"WITHSCORES\") != 0) {\n return RedisModule_WrongArity(ctx);\n }\n withscores = 1;\n }\n\n RedisModuleKey *keyptr = RedisModule_OpenKey(ctx, key, REDISMODULE_READ);\n int type = RedisModule_KeyType(keyptr);\n\n /* Handle non-existing key or wrong type. */\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithNull(ctx);\n\n if (RedisModule_ModuleTypeGetType(keyptr) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n /* Find the node for this element. */\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(keyptr);\n hnswNode *node = RedisModule_DictGet(vset->dict, element, NULL);\n if (!node)\n return RedisModule_ReplyWithNull(ctx);\n\n /* Reply with array of arrays, one per level. */\n RedisModule_ReplyWithArray(ctx, node->level + 1);\n\n /* For each level, from highest to lowest: */\n for (int i = node->level; i >= 0; i--) {\n /* Reply with array of neighbors at this level. */\n if (withscores)\n RedisModule_ReplyWithMap(ctx,node->layers[i].num_links);\n else\n RedisModule_ReplyWithArray(ctx,node->layers[i].num_links);\n\n /* Add each neighbor's element value to the array. */\n for (uint32_t j = 0; j < node->layers[i].num_links; j++) {\n struct vsetNodeVal *nv = node->layers[i].links[j]->value;\n RedisModule_ReplyWithString(ctx, nv->item);\n if (withscores) {\n float distance = hnsw_distance(vset->hnsw, node, node->layers[i].links[j]);\n /* Convert distance to similarity score to match\n * VSIM behavior.*/\n float similarity = 1.0 - distance/2.0;\n RedisModule_ReplyWithDouble(ctx, similarity);\n }\n }\n }\n return REDISMODULE_OK;\n}\n\n/* VINFO key\n * Returns information about a vector set, both visible and hidden\n * features of the HNSW data structure. */\nint VINFO_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n if (argc != 2) return RedisModule_WrongArity(ctx);\n\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY)\n return RedisModule_ReplyWithNullArray(ctx);\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType)\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n\n /* Reply with hash */\n RedisModule_ReplyWithMap(ctx, 9);\n\n /* Quantization type */\n RedisModule_ReplyWithSimpleString(ctx, \"quant-type\");\n RedisModule_ReplyWithSimpleString(ctx, vectorSetGetQuantName(vset));\n\n /* HNSW M value */\n RedisModule_ReplyWithSimpleString(ctx, \"hnsw-m\");\n RedisModule_ReplyWithLongLong(ctx, vset->hnsw->M);\n\n /* Vector dimensionality. */\n RedisModule_ReplyWithSimpleString(ctx, \"vector-dim\");\n RedisModule_ReplyWithLongLong(ctx, vset->hnsw->vector_dim);\n\n /* Original input dimension before projection.\n * This is zero for vector sets without a random projection matrix. */\n RedisModule_ReplyWithSimpleString(ctx, \"projection-input-dim\");\n RedisModule_ReplyWithLongLong(ctx, vset->proj_input_size);\n\n /* Number of elements. */\n RedisModule_ReplyWithSimpleString(ctx, \"size\");\n RedisModule_ReplyWithLongLong(ctx, vset->hnsw->node_count);\n\n /* Max level of HNSW. */\n RedisModule_ReplyWithSimpleString(ctx, \"max-level\");\n RedisModule_ReplyWithLongLong(ctx, vset->hnsw->max_level);\n\n /* Number of nodes with attributes. */\n RedisModule_ReplyWithSimpleString(ctx, \"attributes-count\");\n RedisModule_ReplyWithLongLong(ctx, vset->numattribs);\n\n /* Vector set ID. */\n RedisModule_ReplyWithSimpleString(ctx, \"vset-uid\");\n RedisModule_ReplyWithLongLong(ctx, vset->id);\n\n /* HNSW max node ID. */\n RedisModule_ReplyWithSimpleString(ctx, \"hnsw-max-node-uid\");\n RedisModule_ReplyWithLongLong(ctx, vset->hnsw->last_id);\n\n return REDISMODULE_OK;\n}\n\n/* VRANDMEMBER key [count]\n * Return random members from a vector set.\n *\n * Without count: returns a single random member.\n * With positive count: N unique random members (no duplicates).\n * With negative count: N random members (with possible duplicates).\n *\n * If the key doesn't exist, returns NULL if count is not given, or\n * an empty array if a count was given. */\nint VRANDMEMBER_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx); /* Use automatic memory management. */\n\n /* Check arguments. */\n if (argc != 2 && argc != 3) return RedisModule_WrongArity(ctx);\n\n /* Parse optional count argument. */\n long long count = 1; /* Default is to return a single element. */\n int with_count = (argc == 3);\n\n if (with_count) {\n if (RedisModule_StringToLongLong(argv[2], &count) != REDISMODULE_OK) {\n return RedisModule_ReplyWithError(ctx,\n \"ERR COUNT value is not an integer\");\n }\n /* Count = 0 is a special case, return empty array */\n if (count == 0) {\n return RedisModule_ReplyWithEmptyArray(ctx);\n }\n }\n\n /* Open key. */\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n /* Handle non-existing key. */\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n if (!with_count) {\n return RedisModule_ReplyWithNull(ctx);\n } else {\n return RedisModule_ReplyWithEmptyArray(ctx);\n }\n }\n\n /* Check key type. */\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType) {\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n /* Get vector set from key. */\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n uint64_t set_size = vset->hnsw->node_count;\n\n /* No elements in the set? */\n if (set_size == 0) {\n if (!with_count) {\n return RedisModule_ReplyWithNull(ctx);\n } else {\n return RedisModule_ReplyWithEmptyArray(ctx);\n }\n }\n\n /* Case 1: No count specified: return a single element. */\n if (!with_count) {\n hnswNode *random_node = hnsw_random_node(vset->hnsw, 0);\n if (random_node) {\n struct vsetNodeVal *nv = random_node->value;\n return RedisModule_ReplyWithString(ctx, nv->item);\n } else {\n return RedisModule_ReplyWithNull(ctx);\n }\n }\n\n /* Case 2: COUNT option given, return an array of elements. */\n int allow_duplicates = (count < 0);\n long long abs_count = (count < 0) ? -count : count;\n\n /* Cap the count to the set size if we are not allowing duplicates. */\n if (!allow_duplicates && abs_count > (long long)set_size)\n abs_count = set_size;\n\n /* Prepare reply. */\n RedisModule_ReplyWithArray(ctx, abs_count);\n\n if (allow_duplicates) {\n /* Simple case: With duplicates, just pick random nodes\n * abs_count times. */\n for (long long i = 0; i < abs_count; i++) {\n hnswNode *random_node = hnsw_random_node(vset->hnsw,0);\n struct vsetNodeVal *nv = random_node->value;\n RedisModule_ReplyWithString(ctx, nv->item);\n }\n } else {\n /* Case where count is positive: we need unique elements.\n * But, if the user asked for many elements, selecting so\n * many (> 20%) random nodes may be too expansive: we just start\n * from a random element and follow the next link.\n *\n * Otherwisem for the <= 20% case, a dictionary is used to\n * reject duplicates. */\n int use_dict = (abs_count <= set_size * 0.2);\n\n if (use_dict) {\n RedisModuleDict *returned = RedisModule_CreateDict(ctx);\n\n long long returned_count = 0;\n while (returned_count < abs_count) {\n hnswNode *random_node = hnsw_random_node(vset->hnsw, 0);\n struct vsetNodeVal *nv = random_node->value;\n\n /* Check if we've already returned this element. */\n if (RedisModule_DictGet(returned, nv->item, NULL) == NULL) {\n /* Mark as returned and add to results. */\n RedisModule_DictSet(returned, nv->item, (void*)1);\n RedisModule_ReplyWithString(ctx, nv->item);\n returned_count++;\n }\n }\n RedisModule_FreeDict(ctx, returned);\n } else {\n /* For large samples, get a random starting node and walk\n * the list.\n *\n * IMPORTANT: doing so does not really generate random\n * elements: it's just a linear scan, but we have no choices.\n * If we generate too many random elements, more and more would\n * fail the check of being novel (not yet collected in the set\n * to return) if the % of elements to emit is too large, we would\n * spend too much CPU. */\n hnswNode *start_node = hnsw_random_node(vset->hnsw, 0);\n hnswNode *current = start_node;\n\n long long returned_count = 0;\n while (returned_count < abs_count) {\n if (current == NULL) {\n /* Restart from head if we hit the end. */\n current = vset->hnsw->head;\n }\n struct vsetNodeVal *nv = current->value;\n RedisModule_ReplyWithString(ctx, nv->item);\n returned_count++;\n current = current->next;\n }\n }\n }\n return REDISMODULE_OK;\n}\n\n/* VISMEMBER key element\n * Check if an element exists in a vector set.\n * Returns 1 if the element exists, 0 if not. */\nint VISMEMBER_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n if (argc != 3) return RedisModule_WrongArity(ctx);\n\n RedisModuleString *key = argv[1];\n RedisModuleString *element = argv[2];\n\n /* Open key. */\n RedisModuleKey *keyptr = RedisModule_OpenKey(ctx, key, REDISMODULE_READ);\n int type = RedisModule_KeyType(keyptr);\n\n /* Handle non-existing key or wrong type. */\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n /* An element of a non existing key does not exist, like\n * SISMEMBER & similar. */\n return RedisModule_ReplyWithBool(ctx, 0);\n }\n if (RedisModule_ModuleTypeGetType(keyptr) != VectorSetType) {\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n /* Get the object and test membership via the dictionary in constant\n * time (assuming a member of average size). */\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(keyptr);\n hnswNode *node = RedisModule_DictGet(vset->dict, element, NULL);\n return RedisModule_ReplyWithBool(ctx, node != NULL);\n}\n\n/* Structure to represent a range boundary. */\nstruct vsetRangeOp {\n int incl; /* 1 if inclusive ([), 0 if exclusive ((). */\n int min; /* 1 if this is \"-\" (minimum). */\n int max; /* 1 if this is \"+\" (maximum). */\n unsigned char *ele; /* The actual element, NULL if min/max. */\n size_t ele_len; /* Length of the element. */\n};\n\n/* Parse a range specification like \"[foo\" or \"(bar\" or \"-\" or \"+\".\n * Returns 1 on success, 0 on error. */\nint vsetParseRangeOp(RedisModuleString *arg, struct vsetRangeOp *op) {\n size_t len;\n const char *str = RedisModule_StringPtrLen(arg, &len);\n\n if (len == 0) return 0;\n\n /* Initialize the structure. */\n op->incl = 0;\n op->min = 0;\n op->max = 0;\n op->ele = NULL;\n op->ele_len = 0;\n\n /* Check for special cases \"-\" and \"+\". */\n if (len == 1 && str[0] == '-') {\n op->min = 1;\n return 1;\n }\n if (len == 1 && str[0] == '+') {\n op->max = 1;\n return 1;\n }\n\n /* Otherwise, must start with ( or [. */\n if (str[0] == '[') {\n op->incl = 1;\n } else if (str[0] == '(') {\n op->incl = 0;\n } else {\n return 0; /* Invalid format. */\n }\n\n /* Extract the string part after the bracket. */\n if (len > 1) {\n op->ele = (unsigned char *)(str + 1);\n op->ele_len = len - 1;\n } else {\n return 0; /* Just a bracket with no string. */\n }\n\n return 1;\n}\n\n/* Check if the current element is within the range defined by the end operator.\n * Returns 1 if the element is within range, 0 if it has passed the end. */\nint vsetIsElementInRange(const void *ele, size_t ele_len, struct vsetRangeOp *end_op) {\n /* If end is \"+\", element is always in range. */\n if (end_op->max) return 1;\n\n /* Compare current element with end boundary. */\n size_t minlen = ele_len < end_op->ele_len ? ele_len : end_op->ele_len;\n int cmp = memcmp(ele, end_op->ele, minlen);\n\n if (cmp == 0) {\n /* If equal up to minlen, shorter string is smaller. */\n if (ele_len < end_op->ele_len) {\n cmp = -1;\n } else if (ele_len > end_op->ele_len) {\n cmp = 1;\n }\n }\n\n /* Check based on inclusive/exclusive. */\n if (end_op->incl) {\n return cmp <= 0; /* Inclusive: element <= end. */\n } else {\n return cmp < 0; /* Exclusive: element < end. */\n }\n}\n\n/* VRANGE key start end [count]\n * Returns elements in the lexicographical range [start, end]\n *\n * Elements must be specified in one of the following forms:\n *\n * [myelement\n * (myelement\n * +\n * -\n *\n * Elements starting with [ are inclusive, so \"myelement\" would be\n * returned if present in the set. Elements starting with ( are exclusive\n * ranges instead. The special - and + elements mean the minimum and maximum\n * possible element (inclusive), so \"VRANGE key - +\" will return everything\n * (depending on COUNT of course). The special - element can be used only\n * as starting element, the special + element only as ending element. */\nint VRANGE_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n RedisModule_AutoMemory(ctx);\n\n /* Check arguments. */\n if (argc < 4 || argc > 5) return RedisModule_WrongArity(ctx);\n\n /* Parse COUNT if provided. */\n long long count = -1; /* Default: return all elements. */\n if (argc == 5) {\n if (RedisModule_StringToLongLong(argv[4], &count) != REDISMODULE_OK) {\n return RedisModule_ReplyWithError(ctx, \"ERR invalid COUNT value\");\n }\n }\n\n /* Parse range operators. */\n struct vsetRangeOp start_op, end_op;\n if (!vsetParseRangeOp(argv[2], &start_op)) {\n return RedisModule_ReplyWithError(ctx, \"ERR invalid start range format\");\n }\n if (!vsetParseRangeOp(argv[3], &end_op)) {\n return RedisModule_ReplyWithError(ctx, \"ERR invalid end range format\");\n }\n\n /* Validate: \"-\" can only be first arg, \"+\" can only be second. */\n if (start_op.max || end_op.min) {\n return RedisModule_ReplyWithError(ctx,\n \"ERR '-' can only be used as first argument, '+' only as second\");\n }\n\n /* Open the key. */\n RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);\n int type = RedisModule_KeyType(key);\n\n if (type == REDISMODULE_KEYTYPE_EMPTY) {\n return RedisModule_ReplyWithEmptyArray(ctx);\n }\n\n if (RedisModule_ModuleTypeGetType(key) != VectorSetType) {\n return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);\n }\n\n struct vsetObject *vset = RedisModule_ModuleTypeGetValue(key);\n\n /* Start the iterator. */\n RedisModuleDictIter *iter;\n if (start_op.min) {\n /* Start from the beginning. */\n iter = RedisModule_DictIteratorStartC(vset->dict, \"^\", NULL, 0);\n } else {\n /* Start from the specified element. */\n const char *op = start_op.incl ? \">=\" : \">\";\n iter = RedisModule_DictIteratorStartC(vset->dict, op, start_op.ele, start_op.ele_len);\n }\n\n /* Collect results. */\n RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);\n long long returned = 0;\n\n void *key_data;\n size_t key_len;\n while ((key_data = RedisModule_DictNextC(iter, &key_len, NULL)) != NULL) {\n /* Check if we've collected enough elements. */\n if (count >= 0 && returned >= count) break;\n\n /* Check if we've passed the end range. */\n if (!vsetIsElementInRange(key_data, key_len, &end_op)) break;\n\n /* Add this element to the result. */\n RedisModule_ReplyWithStringBuffer(ctx, key_data, key_len);\n returned++;\n }\n\n RedisModule_ReplySetArrayLength(ctx, returned);\n\n /* Cleanup. */\n RedisModule_DictIteratorStop(iter);\n\n return REDISMODULE_OK;\n}\n\n/* ============================== vset type methods ========================= */\n\n#define SAVE_FLAG_HAS_PROJMATRIX (1<<0)\n#define SAVE_FLAG_HAS_ATTRIBS (1<<1)\n\n/* Save object to RDB */\nvoid VectorSetRdbSave(RedisModuleIO *rdb, void *value) {\n struct vsetObject *vset = value;\n RedisModule_SaveUnsigned(rdb, vset->hnsw->vector_dim);\n RedisModule_SaveUnsigned(rdb, vset->hnsw->node_count);\n\n uint32_t hnsw_config = (vset->hnsw->quant_type & 0xff) |\n ((vset->hnsw->M & 0xffff) << 8);\n RedisModule_SaveUnsigned(rdb, hnsw_config);\n\n uint32_t save_flags = 0;\n if (vset->proj_matrix) save_flags |= SAVE_FLAG_HAS_PROJMATRIX;\n if (vset->numattribs != 0) save_flags |= SAVE_FLAG_HAS_ATTRIBS;\n RedisModule_SaveUnsigned(rdb, save_flags);\n\n /* Save projection matrix if present */\n if (vset->proj_matrix) {\n uint32_t input_dim = vset->proj_input_size;\n uint32_t output_dim = vset->hnsw->vector_dim;\n RedisModule_SaveUnsigned(rdb, input_dim);\n // Output dim is the same as the first value saved\n // above, so we don't save it.\n\n // Save projection matrix as binary blob\n size_t matrix_size = sizeof(float) * input_dim * output_dim;\n RedisModule_SaveStringBuffer(rdb, (const char *)vset->proj_matrix, matrix_size);\n }\n\n hnswNode *node = vset->hnsw->head;\n while(node) {\n struct vsetNodeVal *nv = node->value;\n RedisModule_SaveString(rdb, nv->item);\n if (vset->numattribs) {\n if (nv->attrib)\n RedisModule_SaveString(rdb, nv->attrib);\n else\n RedisModule_SaveStringBuffer(rdb, \"\", 0);\n }\n hnswSerNode *sn = hnsw_serialize_node(vset->hnsw,node);\n RedisModule_SaveStringBuffer(rdb, (const char *)sn->vector, sn->vector_size);\n RedisModule_SaveUnsigned(rdb, sn->params_count);\n for (uint32_t j = 0; j < sn->params_count; j++)\n RedisModule_SaveUnsigned(rdb, sn->params[j]);\n hnsw_free_serialized_node(sn);\n node = node->next;\n }\n}\n\n/* Load object from RDB. Recover from recoverable errors (read errors)\n * by performing cleanup. */\nvoid *VectorSetRdbLoad(RedisModuleIO *rdb, int encver) {\n if (encver != 0) return NULL; // Invalid version\n\n uint32_t dim = RedisModule_LoadUnsigned(rdb);\n uint64_t elements = RedisModule_LoadUnsigned(rdb);\n uint32_t hnsw_config = RedisModule_LoadUnsigned(rdb);\n if (RedisModule_IsIOError(rdb)) return NULL;\n uint32_t quant_type = hnsw_config & 0xff;\n uint32_t hnsw_m = (hnsw_config >> 8) & 0xffff;\n\n /* Check that the quantization type is correct. Otherwise\n * return ASAP signaling the error. */\n if (quant_type != HNSW_QUANT_NONE &&\n quant_type != HNSW_QUANT_Q8 &&\n quant_type != HNSW_QUANT_BIN) return NULL;\n\n if (hnsw_m == 0) hnsw_m = 16; // Default, useful for RDB files predating\n // this configuration parameter: it was fixed\n // to 16.\n struct vsetObject *vset = createVectorSetObject(dim,quant_type,hnsw_m);\n RedisModule_Assert(vset != NULL);\n\n /* Load projection matrix if present */\n uint32_t save_flags = RedisModule_LoadUnsigned(rdb);\n if (RedisModule_IsIOError(rdb)) goto ioerr;\n int has_projection = save_flags & SAVE_FLAG_HAS_PROJMATRIX;\n int has_attribs = save_flags & SAVE_FLAG_HAS_ATTRIBS;\n if (has_projection) {\n uint32_t input_dim = RedisModule_LoadUnsigned(rdb);\n if (RedisModule_IsIOError(rdb)) goto ioerr;\n uint32_t output_dim = dim;\n size_t matrix_size = sizeof(float) * input_dim * output_dim;\n\n vset->proj_matrix = RedisModule_Alloc(matrix_size);\n vset->proj_input_size = input_dim;\n\n // Load projection matrix as a binary blob\n char *matrix_blob = RedisModule_LoadStringBuffer(rdb, NULL);\n if (matrix_blob == NULL) goto ioerr;\n memcpy(vset->proj_matrix, matrix_blob, matrix_size);\n RedisModule_Free(matrix_blob);\n }\n\n while(elements--) {\n // Load associated string element.\n RedisModuleString *ele = RedisModule_LoadString(rdb);\n if (RedisModule_IsIOError(rdb)) goto ioerr;\n RedisModuleString *attrib = NULL;\n if (has_attribs) {\n attrib = RedisModule_LoadString(rdb);\n if (RedisModule_IsIOError(rdb)) {\n RedisModule_FreeString(NULL,ele);\n goto ioerr;\n }\n size_t attrlen;\n RedisModule_StringPtrLen(attrib,&attrlen);\n if (attrlen == 0) {\n RedisModule_FreeString(NULL,attrib);\n attrib = NULL;\n }\n }\n size_t vector_len;\n void *vector = RedisModule_LoadStringBuffer(rdb, &vector_len);\n if (RedisModule_IsIOError(rdb)) {\n RedisModule_FreeString(NULL,ele);\n if (attrib) RedisModule_FreeString(NULL,attrib);\n goto ioerr;\n }\n uint32_t vector_bytes = hnsw_quants_bytes(vset->hnsw);\n if (vector_len != vector_bytes) {\n RedisModule_LogIOError(rdb,\"warning\",\n \"Mismatching vector dimension\");\n RedisModule_FreeString(NULL,ele);\n if (attrib) RedisModule_FreeString(NULL,attrib);\n RedisModule_Free(vector);\n goto ioerr;\n }\n\n // Load node parameters back.\n uint32_t params_count = RedisModule_LoadUnsigned(rdb);\n if (RedisModule_IsIOError(rdb)) {\n RedisModule_FreeString(NULL,ele);\n if (attrib) RedisModule_FreeString(NULL,attrib);\n RedisModule_Free(vector);\n goto ioerr;\n }\n\n uint64_t *params = RedisModule_Alloc(params_count*sizeof(uint64_t));\n for (uint32_t j = 0; j < params_count; j++) {\n // Ignore loading errors here: handled at the end of the loop.\n params[j] = RedisModule_LoadUnsigned(rdb);\n }\n if (RedisModule_IsIOError(rdb)) {\n RedisModule_FreeString(NULL,ele);\n if (attrib) RedisModule_FreeString(NULL,attrib);\n RedisModule_Free(vector);\n RedisModule_Free(params);\n goto ioerr;\n }\n\n struct vsetNodeVal *nv = RedisModule_Alloc(sizeof(*nv));\n nv->item = ele;\n nv->attrib = attrib;\n hnswNode *node = hnsw_insert_serialized(vset->hnsw, vector, params, params_count, nv);\n if (node == NULL) {\n RedisModule_LogIOError(rdb,\"warning\",\n \"Vector set node index loading error\");\n vectorSetReleaseNodeValue(nv);\n RedisModule_Free(vector);\n RedisModule_Free(params);\n goto ioerr;\n }\n if (nv->attrib) vset->numattribs++;\n RedisModule_DictSet(vset->dict,ele,node);\n RedisModule_Free(vector);\n RedisModule_Free(params);\n }\n\n uint64_t salt[2];\n RedisModule_GetRandomBytes((unsigned char*)salt,sizeof(salt));\n if (!hnsw_deserialize_index(vset->hnsw, salt[0], salt[1])) goto ioerr;\n\n return vset;\n\nioerr:\n /* We want to recover from I/O errors and free the partially allocated\n * data structure to support diskless replication. */\n vectorSetReleaseObject(vset);\n return NULL;\n}\n\n/* Calculate memory usage */\nsize_t VectorSetMemUsage(const void *value) {\n const struct vsetObject *vset = value;\n size_t size = sizeof(*vset);\n\n /* Account for HNSW index base structure */\n size += sizeof(HNSW);\n\n /* Account for projection matrix if present */\n if (vset->proj_matrix) {\n /* For the matrix size, we need the input dimension. We can get it\n * from the first node if the set is not empty. */\n uint32_t input_dim = vset->proj_input_size;\n uint32_t output_dim = vset->hnsw->vector_dim;\n size += sizeof(float) * input_dim * output_dim;\n }\n\n /* Account for each node's memory usage. */\n hnswNode *node = vset->hnsw->head;\n if (node == NULL) return size;\n\n /* Base node structure. */\n size += sizeof(*node) * vset->hnsw->node_count;\n\n /* Vector storage. */\n uint64_t vec_storage = hnsw_quants_bytes(vset->hnsw);\n size += vec_storage * vset->hnsw->node_count;\n\n /* Layers array. We use 1.33 as average nodes layers count. */\n uint64_t layers_storage = sizeof(hnswNodeLayer) * vset->hnsw->node_count;\n layers_storage = layers_storage * 4 / 3; // 1.33 times.\n size += layers_storage;\n\n /* All the nodes have layer 0 links. */\n uint64_t level0_links = node->layers[0].max_links;\n uint64_t other_levels_links = level0_links/2;\n size += sizeof(hnswNode*) * level0_links * vset->hnsw->node_count;\n\n /* Add the 0.33 remaining part, but upper layers have less links. */\n size += (sizeof(hnswNode*) * other_levels_links * vset->hnsw->node_count)/3;\n\n /* Associated string value and attributres.\n * Use Redis Module API to get string size, and guess that all the\n * elements have similar size as the first few. */\n size_t items_scanned = 0, items_size = 0;\n size_t attribs_scanned = 0, attribs_size = 0;\n int scan_effort = 20;\n while(scan_effort > 0 && node) {\n struct vsetNodeVal *nv = node->value;\n items_size += RedisModule_MallocSizeString(nv->item);\n items_scanned++;\n if (nv->attrib) {\n attribs_size += RedisModule_MallocSizeString(nv->attrib);\n attribs_scanned++;\n }\n scan_effort--;\n node = node->next;\n }\n\n /* Add the memory usage due to items. */\n if (items_scanned)\n size += items_size / items_scanned * vset->hnsw->node_count;\n\n /* Add memory usage due to attributres. */\n if (attribs_scanned == 0) {\n /* We were not lucky enough to find a single attribute in the\n * first few items? Let's use a fixed arbitrary value. */\n attribs_scanned = 1;\n attribs_size = 64;\n }\n size += attribs_size / attribs_scanned * vset->numattribs;\n\n /* Account for dictionary overhead - this is an approximation. */\n size += RedisModule_DictSize(vset->dict) * (sizeof(void*) * 2);\n\n return size;\n}\n\n/* Free the entire data structure */\nvoid VectorSetFree(void *value) {\n struct vsetObject *vset = value;\n\n vectorSetWaitAllBackgroundClients(vset,1);\n vectorSetReleaseObject(value);\n}\n\n/* Add object digest to the digest context */\nvoid VectorSetDigest(RedisModuleDigest *md, void *value) {\n struct vsetObject *vset = value;\n\n /* Add consistent order-independent hash of all vectors */\n hnswNode *node = vset->hnsw->head;\n\n /* Hash the vector dimension and number of nodes. */\n RedisModule_DigestAddLongLong(md, vset->hnsw->node_count);\n RedisModule_DigestAddLongLong(md, vset->hnsw->vector_dim);\n RedisModule_DigestEndSequence(md);\n\n while(node) {\n struct vsetNodeVal *nv = node->value;\n /* Hash each vector component */\n RedisModule_DigestAddStringBuffer(md, node->vector, hnsw_quants_bytes(vset->hnsw));\n /* Hash the associated value */\n size_t len;\n const char *str = RedisModule_StringPtrLen(nv->item, &len);\n RedisModule_DigestAddStringBuffer(md, (char*)str, len);\n if (nv->attrib) {\n str = RedisModule_StringPtrLen(nv->attrib, &len);\n RedisModule_DigestAddStringBuffer(md, (char*)str, len);\n }\n node = node->next;\n RedisModule_DigestEndSequence(md);\n }\n}\n\n// int VectorSets_InitModuleConfig(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\nint VectorSets_InitModuleConfig(RedisModuleCtx *ctx) {\n if (RegisterModuleConfig(ctx) == REDISMODULE_ERR) {\n RedisModule_Log(ctx, \"warning\", \"Error registering module configuration\");\n return REDISMODULE_ERR;\n }\n // Load default values\n if (RedisModule_LoadDefaultConfigs(ctx) == REDISMODULE_ERR) {\n RedisModule_Log(ctx, \"warning\", \"Error loading default module configuration\");\n return REDISMODULE_ERR;\n } else {\n RedisModule_Log(ctx, \"verbose\", \"Successfully loaded default module configuration\");\n }\n if (RedisModule_LoadConfigs(ctx) == REDISMODULE_ERR) {\n RedisModule_Log(ctx, \"warning\", \"Error loading user module configuration\");\n return REDISMODULE_ERR;\n } else {\n RedisModule_Log(ctx, \"verbose\", \"Successfully loaded user module configuration\");\n }\n return REDISMODULE_OK;\n}\n\n/* This function must be present on each Redis module. It is used in order to\n * register the commands into the Redis server. */\nint RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n REDISMODULE_NOT_USED(argv);\n REDISMODULE_NOT_USED(argc);\n\n if (RedisModule_Init(ctx,\"vectorset\",1,REDISMODULE_APIVER_1)\n == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n if (VectorSets_InitModuleConfig(ctx) == REDISMODULE_ERR) {\n return REDISMODULE_ERR;\n }\n\n RedisModule_SetModuleOptions(ctx, REDISMODULE_OPTIONS_HANDLE_IO_ERRORS|REDISMODULE_OPTIONS_HANDLE_REPL_ASYNC_LOAD);\n\n RedisModuleTypeMethods tm = {\n .version = REDISMODULE_TYPE_METHOD_VERSION,\n .rdb_load = VectorSetRdbLoad,\n .rdb_save = VectorSetRdbSave,\n .aof_rewrite = NULL,\n .mem_usage = VectorSetMemUsage,\n .free = VectorSetFree,\n .digest = VectorSetDigest\n };\n\n VectorSetType = RedisModule_CreateDataType(ctx,\"vectorset\",0,&tm);\n if (VectorSetType == NULL) return REDISMODULE_ERR;\n\n // Register command VADD\n if (RedisModule_CreateCommand(ctx,\"VADD\",\n VADD_RedisCommand,\"write deny-oom\",1,1,1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vadd_cmd = RedisModule_GetCommand(ctx, \"VADD\");\n if (vadd_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vadd_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"reduce\", .type = REDISMODULE_ARG_TYPE_BLOCK, .token = \"REDUCE\", .flags = REDISMODULE_CMD_ARG_OPTIONAL,\n .subargs = (RedisModuleCommandArg[]) {\n { .name = \"dim\", .type = REDISMODULE_ARG_TYPE_INTEGER },\n { .name = NULL }\n }\n },\n { .name = \"format\", .type = REDISMODULE_ARG_TYPE_ONEOF, .subargs = (RedisModuleCommandArg[]) {\n { .name = \"fp32\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"FP32\" },\n { .name = \"values\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"VALUES\" },\n { .name = NULL }\n }\n },\n { .name = \"vector\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"cas\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"CAS\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"quant_type\", .type = REDISMODULE_ARG_TYPE_ONEOF, .flags = REDISMODULE_CMD_ARG_OPTIONAL, .subargs = (RedisModuleCommandArg[]) {\n { .name = \"noquant\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"NOQUANT\" },\n { .name = \"bin\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"BIN\" },\n { .name = \"q8\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"Q8\" },\n { .name = NULL }\n }\n },\n { .name = \"build-exploration-factor\", .type = REDISMODULE_ARG_TYPE_INTEGER, .token = \"EF\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"attributes\", .type = REDISMODULE_ARG_TYPE_STRING, .token = \"SETATTR\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"numlinks\", .type = REDISMODULE_ARG_TYPE_INTEGER, .token = \"M\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vadd_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Add one or more elements to a vector set, or update its vector if it already exists\",\n .since = \"8.0.0\",\n .arity = -5,\n .args = vadd_args,\n };\n if (RedisModule_SetCommandInfo(vadd_cmd, &vadd_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VREM\n if (RedisModule_CreateCommand(ctx,\"VREM\",\n VREM_RedisCommand,\"write\",1,1,1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vrem_cmd = RedisModule_GetCommand(ctx, \"VREM\");\n if (vrem_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vrem_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = NULL }\n };\n RedisModuleCommandInfo vrem_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Remove an element from a vector set\",\n .since = \"8.0.0\",\n .arity = 3,\n .args = vrem_args,\n };\n if (RedisModule_SetCommandInfo(vrem_cmd, &vrem_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VSIM\n if (RedisModule_CreateCommand(ctx,\"VSIM\",\n VSIM_RedisCommand,\"readonly\",1,1,1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vsim_cmd = RedisModule_GetCommand(ctx, \"VSIM\");\n if (vsim_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vsim_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"format\", .type = REDISMODULE_ARG_TYPE_ONEOF, .subargs = (RedisModuleCommandArg[]) {\n { .name = \"ele\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"ELE\" },\n { .name = \"fp32\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"FP32\" },\n { .name = \"values\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"VALUES\" },\n { .name = NULL }\n }\n },\n { .name = \"vector_or_element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"withscores\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"WITHSCORES\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"withattribs\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"WITHATTRIBS\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"count\", .type = REDISMODULE_ARG_TYPE_INTEGER, .token = \"COUNT\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"max_distance\", .type = REDISMODULE_ARG_TYPE_DOUBLE, .token = \"EPSILON\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"search-exploration-factor\", .type = REDISMODULE_ARG_TYPE_INTEGER, .token = \"EF\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"expression\", .type = REDISMODULE_ARG_TYPE_STRING, .token = \"FILTER\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"max-filtering-effort\", .type = REDISMODULE_ARG_TYPE_INTEGER, .token = \"FILTER-EF\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"truth\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"TRUTH\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = \"nothread\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"NOTHREAD\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vsim_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return elements by vector similarity\",\n .since = \"8.0.0\",\n .arity = -4,\n .args = vsim_args,\n };\n if (RedisModule_SetCommandInfo(vsim_cmd, &vsim_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VDIM\n if (RedisModule_CreateCommand(ctx, \"VDIM\",\n VDIM_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vdim_cmd = RedisModule_GetCommand(ctx, \"VDIM\");\n if (vdim_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vdim_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = NULL }\n };\n RedisModuleCommandInfo vdim_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return the dimension of vectors in the vector set\",\n .since = \"8.0.0\",\n .arity = 2,\n .args = vdim_args,\n };\n if (RedisModule_SetCommandInfo(vdim_cmd, &vdim_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VCARD\n if (RedisModule_CreateCommand(ctx, \"VCARD\",\n VCARD_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vcard_cmd = RedisModule_GetCommand(ctx, \"VCARD\");\n if (vcard_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vcard_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = NULL }\n };\n RedisModuleCommandInfo vcard_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return the number of elements in a vector set\",\n .since = \"8.0.0\",\n .arity = 2,\n .args = vcard_args,\n };\n if (RedisModule_SetCommandInfo(vcard_cmd, &vcard_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VEMB\n if (RedisModule_CreateCommand(ctx, \"VEMB\",\n VEMB_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vemb_cmd = RedisModule_GetCommand(ctx, \"VEMB\");\n if (vemb_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vemb_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"raw\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"RAW\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vemb_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return the vector associated with an element\",\n .since = \"8.0.0\",\n .arity = -3,\n .args = vemb_args,\n };\n if (RedisModule_SetCommandInfo(vemb_cmd, &vemb_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VLINKS\n if (RedisModule_CreateCommand(ctx, \"VLINKS\",\n VLINKS_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vlinks_cmd = RedisModule_GetCommand(ctx, \"VLINKS\");\n if (vlinks_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vlinks_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"withscores\", .type = REDISMODULE_ARG_TYPE_PURE_TOKEN, .token = \"WITHSCORES\", .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vlinks_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return the neighbors of an element at each layer in the HNSW graph\",\n .since = \"8.0.0\",\n .arity = -3,\n .args = vlinks_args,\n };\n if (RedisModule_SetCommandInfo(vlinks_cmd, &vlinks_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VINFO\n if (RedisModule_CreateCommand(ctx, \"VINFO\",\n VINFO_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vinfo_cmd = RedisModule_GetCommand(ctx, \"VINFO\");\n if (vinfo_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vinfo_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = NULL }\n };\n RedisModuleCommandInfo vinfo_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return information about a vector set\",\n .since = \"8.0.0\",\n .arity = 2,\n .args = vinfo_args,\n };\n if (RedisModule_SetCommandInfo(vinfo_cmd, &vinfo_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VSETATTR\n if (RedisModule_CreateCommand(ctx, \"VSETATTR\",\n VSETATTR_RedisCommand, \"write fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vsetattr_cmd = RedisModule_GetCommand(ctx, \"VSETATTR\");\n if (vsetattr_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vsetattr_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"json\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = NULL }\n };\n RedisModuleCommandInfo vsetattr_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Associate or remove the JSON attributes of elements\",\n .since = \"8.0.0\",\n .arity = 4,\n .args = vsetattr_args,\n };\n if (RedisModule_SetCommandInfo(vsetattr_cmd, &vsetattr_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VGETATTR\n if (RedisModule_CreateCommand(ctx, \"VGETATTR\",\n VGETATTR_RedisCommand, \"readonly fast\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vgetattr_cmd = RedisModule_GetCommand(ctx, \"VGETATTR\");\n if (vgetattr_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vgetattr_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = NULL }\n };\n RedisModuleCommandInfo vgetattr_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Retrieve the JSON attributes of elements\",\n .since = \"8.0.0\",\n .arity = 3,\n .args = vgetattr_args,\n };\n if (RedisModule_SetCommandInfo(vgetattr_cmd, &vgetattr_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VRANDMEMBER\n if (RedisModule_CreateCommand(ctx, \"VRANDMEMBER\",\n VRANDMEMBER_RedisCommand, \"readonly\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vrandmember_cmd = RedisModule_GetCommand(ctx, \"VRANDMEMBER\");\n if (vrandmember_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vrandmember_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"count\", .type = REDISMODULE_ARG_TYPE_INTEGER, .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vrandmember_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return one or multiple random members from a vector set\",\n .since = \"8.0.0\",\n .arity = -2,\n .args = vrandmember_args,\n };\n if (RedisModule_SetCommandInfo(vrandmember_cmd, &vrandmember_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VISMEMBER\n if (RedisModule_CreateCommand(ctx, \"VISMEMBER\",\n VISMEMBER_RedisCommand, \"readonly\", 1, 1, 1) == REDISMODULE_ERR)\n return REDISMODULE_ERR;\n\n RedisModuleCommand *vismember_cmd = RedisModule_GetCommand(ctx, \"VISMEMBER\");\n if (vismember_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vismember_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"element\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = NULL }\n };\n RedisModuleCommandInfo vismember_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Check if an element exists in a vector set\",\n .since = \"8.2.0\",\n .arity = 3,\n .args = vismember_args,\n };\n if (RedisModule_SetCommandInfo(vismember_cmd, &vismember_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Register command VRANGE\n if (RedisModule_CreateCommand(ctx, \"VRANGE\",\n\tVRANGE_RedisCommand, \"readonly\", 1, 1, 1) == REDISMODULE_ERR)\n\treturn REDISMODULE_ERR;\n\n RedisModuleCommand *vrange_cmd = RedisModule_GetCommand(ctx, \"VRANGE\");\n if (vrange_cmd == NULL) return REDISMODULE_ERR;\n\n RedisModuleCommandArg vrange_args[] = {\n { .name = \"key\", .type = REDISMODULE_ARG_TYPE_KEY, .key_spec_index = 0 },\n { .name = \"start\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"end\", .type = REDISMODULE_ARG_TYPE_STRING },\n { .name = \"count\", .type = REDISMODULE_ARG_TYPE_INTEGER, .flags = REDISMODULE_CMD_ARG_OPTIONAL },\n { .name = NULL }\n };\n RedisModuleCommandInfo vrange_info = {\n .version = REDISMODULE_COMMAND_INFO_VERSION,\n .summary = \"Return vector set elements in a lex range\",\n .since = \"8.4.0\",\n .arity = -4,\n .args = vrange_args,\n };\n if (RedisModule_SetCommandInfo(vrange_cmd, &vrange_info) == REDISMODULE_ERR) return REDISMODULE_ERR;\n\n // Set the allocator for the HNSW library, so that memory tracking\n // is correct in Redis.\n hnsw_set_allocator(RedisModule_Free, RedisModule_Alloc,\n RedisModule_Realloc);\n\n return REDISMODULE_OK;\n}\n\nint VectorSets_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {\n return RedisModule_OnLoad(ctx, argv, argc);\n}\n" }, { "path": "modules/vector-sets/vset_config.c", "content": "/* vector set module configuration.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n*/\n\n#include \"vset_config.h\"\n\n/* Define __STRING macro for portability (not available in all environments) */\n#ifndef __STRING\n#define __STRING(x) #x\n#endif\n\n#define RM_TRY(expr) \\\n if (expr == REDISMODULE_ERR) { \\\n RedisModule_Log(ctx, \"warning\", \"Could not run \" __STRING(expr)); \\\n return REDISMODULE_ERR; \\\n }\n\nVSConfig VSGlobalConfig;\n\nint set_bool_config(const char *name, int val, void *privdata,\n RedisModuleString **err) {\n REDISMODULE_NOT_USED(name);\n REDISMODULE_NOT_USED(err);\n *(int *)privdata = val;\n return REDISMODULE_OK;\n}\n\nint get_bool_config(const char *name, void *privdata) {\n REDISMODULE_NOT_USED(name);\n return *(int *)privdata;\n}\n\nint RegisterModuleConfig(RedisModuleCtx *ctx) {\n // Numeric parameters\n RM_TRY(\n RedisModule_RegisterBoolConfig(\n ctx, \"vset-force-single-threaded-execution\", 0,\n REDISMODULE_CONFIG_UNPREFIXED,\n get_bool_config, set_bool_config, NULL,\n (void *)&(VSGlobalConfig.forceSingleThreadExec)\n )\n )\n\n return REDISMODULE_OK;\n}\n" }, { "path": "modules/vector-sets/vset_config.h", "content": "/* vector set module configuration.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n*/\n\n#ifndef VSET_CONFIG_H\n#define VSET_CONFIG_H\n\n#include \"../../src/redismodule.h\"\n\ntypedef struct {\n int forceSingleThreadExec;\n} VSConfig;\n\nextern VSConfig VSGlobalConfig;\n\nint RegisterModuleConfig(RedisModuleCtx *ctx);\n\n#endif\n" }, { "path": "modules/vector-sets/w2v.c", "content": "/*\n * HNSW (Hierarchical Navigable Small World) Implementation\n * Based on the paper by Yu. A. Malkov, D. A. Yashunin\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * Originally authored by: Salvatore Sanfilippo\n */\n\n#define _DEFAULT_SOURCE\n#define _USE_MATH_DEFINES\n#define _POSIX_C_SOURCE 200809L\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"hnsw.h\"\n\n/* Get current time in milliseconds */\nuint64_t ms_time(void) {\n struct timeval tv;\n gettimeofday(&tv, NULL);\n return (uint64_t)tv.tv_sec * 1000 + (tv.tv_usec / 1000);\n}\n\n/* Implementation of the recall test with random vectors. */\nvoid test_recall(HNSW *index, int ef) {\n const int num_test_vectors = 10000;\n const int k = 100; // Number of nearest neighbors to find.\n if (ef < k) ef = k;\n\n // Add recall distribution counters (2% bins from 0-100%).\n int recall_bins[50] = {0};\n\n // Create array to store vectors for mixing.\n int num_source_vectors = 1000; // Enough, since we mix them.\n float **source_vectors = malloc(sizeof(float*) * num_source_vectors);\n if (!source_vectors) {\n printf(\"Failed to allocate memory for source vectors\\n\");\n return;\n }\n\n // Allocate memory for each source vector.\n for (int i = 0; i < num_source_vectors; i++) {\n source_vectors[i] = malloc(sizeof(float) * 300);\n if (!source_vectors[i]) {\n printf(\"Failed to allocate memory for source vector %d\\n\", i);\n // Clean up already allocated vectors.\n for (int j = 0; j < i; j++) free(source_vectors[j]);\n free(source_vectors);\n return;\n }\n }\n\n /* Populate source vectors from the index, we just scan the\n * first N items. */\n int source_count = 0;\n hnswNode *current = index->head;\n while (current && source_count < num_source_vectors) {\n hnsw_get_node_vector(index, current, source_vectors[source_count]);\n source_count++;\n current = current->next;\n }\n\n if (source_count < num_source_vectors) {\n printf(\"Warning: Only found %d nodes for source vectors\\n\",\n source_count);\n num_source_vectors = source_count;\n }\n\n // Allocate memory for test vector.\n float *test_vector = malloc(sizeof(float) * 300);\n if (!test_vector) {\n printf(\"Failed to allocate memory for test vector\\n\");\n for (int i = 0; i < num_source_vectors; i++) {\n free(source_vectors[i]);\n }\n free(source_vectors);\n return;\n }\n\n // Allocate memory for results.\n hnswNode **hnsw_results = malloc(sizeof(hnswNode*) * ef);\n hnswNode **linear_results = malloc(sizeof(hnswNode*) * ef);\n float *hnsw_distances = malloc(sizeof(float) * ef);\n float *linear_distances = malloc(sizeof(float) * ef);\n\n if (!hnsw_results || !linear_results || !hnsw_distances || !linear_distances) {\n printf(\"Failed to allocate memory for results\\n\");\n if (hnsw_results) free(hnsw_results);\n if (linear_results) free(linear_results);\n if (hnsw_distances) free(hnsw_distances);\n if (linear_distances) free(linear_distances);\n for (int i = 0; i < num_source_vectors; i++) free(source_vectors[i]);\n free(source_vectors);\n free(test_vector);\n return;\n }\n\n // Initialize random seed.\n srand(time(NULL));\n\n // Perform recall test.\n printf(\"\\nPerforming recall test with EF=%d on %d random vectors...\\n\",\n ef, num_test_vectors);\n double total_recall = 0.0;\n\n for (int t = 0; t < num_test_vectors; t++) {\n // Create a random vector by mixing 3 existing vectors.\n float weights[3] = {0.0};\n int src_indices[3] = {0};\n\n // Generate random weights.\n float weight_sum = 0.0;\n for (int i = 0; i < 3; i++) {\n weights[i] = (float)rand() / RAND_MAX;\n weight_sum += weights[i];\n src_indices[i] = rand() % num_source_vectors;\n }\n\n // Normalize weights.\n for (int i = 0; i < 3; i++) weights[i] /= weight_sum;\n\n // Mix vectors.\n memset(test_vector, 0, sizeof(float) * 300);\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 300; j++) {\n test_vector[j] +=\n weights[i] * source_vectors[src_indices[i]][j];\n }\n }\n\n // Perform HNSW search with the specified EF parameter.\n int slot = hnsw_acquire_read_slot(index);\n int hnsw_found = hnsw_search(index, test_vector, ef, hnsw_results, hnsw_distances, slot, 0);\n\n // Perform linear search (ground truth).\n int linear_found = hnsw_ground_truth_with_filter(index, test_vector, ef, linear_results, linear_distances, slot, 0, NULL, NULL);\n hnsw_release_read_slot(index, slot);\n\n // Calculate recall for this query (intersection size / k).\n if (hnsw_found > k) hnsw_found = k;\n if (linear_found > k) linear_found = k;\n int intersection_count = 0;\n for (int i = 0; i < linear_found; i++) {\n for (int j = 0; j < hnsw_found; j++) {\n if (linear_results[i] == hnsw_results[j]) {\n intersection_count++;\n break;\n }\n }\n }\n\n double recall = (double)intersection_count / linear_found;\n total_recall += recall;\n\n // Add to distribution bins (2% steps)\n int bin_index = (int)(recall * 50);\n if (bin_index >= 50) bin_index = 49; // Handle 100% recall case\n recall_bins[bin_index]++;\n\n // Show progress.\n if ((t+1) % 1000 == 0 || t == num_test_vectors-1) {\n printf(\"Processed %d/%d queries, current avg recall: %.2f%%\\n\",\n t+1, num_test_vectors, (total_recall / (t+1)) * 100);\n }\n }\n\n // Calculate and print final average recall.\n double avg_recall = (total_recall / num_test_vectors) * 100;\n printf(\"\\nRecall Test Results:\\n\");\n printf(\"Average recall@%d (EF=%d): %.2f%%\\n\", k, ef, avg_recall);\n\n // Print recall distribution histogram.\n printf(\"\\nRecall Distribution (2%% bins):\\n\");\n printf(\"================================\\n\");\n\n // Find the maximum bin count for scaling.\n int max_count = 0;\n for (int i = 0; i < 50; i++) {\n if (recall_bins[i] > max_count) max_count = recall_bins[i];\n }\n\n // Scale factor for histogram (max 50 chars wide)\n const int max_bars = 50;\n double scale = (max_count > max_bars) ? (double)max_bars / max_count : 1.0;\n\n // Print the histogram.\n for (int i = 0; i < 50; i++) {\n int bar_len = (int)(recall_bins[i] * scale);\n printf(\"%3d%%-%-3d%% | %-6d |\", i*2, (i+1)*2, recall_bins[i]);\n for (int j = 0; j < bar_len; j++) printf(\"#\");\n printf(\"\\n\");\n }\n\n // Cleanup.\n free(hnsw_results);\n free(linear_results);\n free(hnsw_distances);\n free(linear_distances);\n free(test_vector);\n for (int i = 0; i < num_source_vectors; i++) free(source_vectors[i]);\n free(source_vectors);\n}\n\n/* Example usage in main() */\nint w2v_single_thread(int m_param, int quantization, uint64_t numele, int massdel, int self_recall, int recall_ef) {\n /* Create index */\n HNSW *index = hnsw_new(300, quantization, m_param);\n float v[300];\n uint16_t wlen;\n\n FILE *fp = fopen(\"word2vec.bin\",\"rb\");\n if (fp == NULL) {\n perror(\"word2vec.bin file missing\");\n exit(1);\n }\n unsigned char header[8];\n if (fread(header,8,1,fp) <= 0) { // Skip header\n perror(\"Unexpected EOF\");\n exit(1);\n }\n\n uint64_t id = 0;\n uint64_t start_time = ms_time();\n char *word = NULL;\n hnswNode *search_node = NULL;\n\n while(id < numele) {\n if (fread(&wlen,2,1,fp) == 0) break;\n word = malloc(wlen+1);\n if (fread(word,wlen,1,fp) <= 0) {\n perror(\"unexpected EOF\");\n exit(1);\n }\n word[wlen] = 0;\n if (fread(v,300*sizeof(float),1,fp) <= 0) {\n perror(\"unexpected EOF\");\n exit(1);\n }\n\n // Plain API that acquires a write lock for the whole time.\n hnswNode *added = hnsw_insert(index, v, NULL, 0, id++, word, 200);\n\n if (!strcmp(word,\"banana\")) search_node = added;\n if (!(id % 10000)) printf(\"%llu added\\n\", (unsigned long long)id);\n }\n uint64_t elapsed = ms_time() - start_time;\n fclose(fp);\n\n printf(\"%llu words added (%llu words/sec), last word: %s\\n\",\n (unsigned long long)index->node_count,\n (unsigned long long)id*1000/elapsed, word);\n\n /* Search query */\n if (search_node == NULL) search_node = index->head;\n hnsw_get_node_vector(index,search_node,v);\n hnswNode *neighbors[10];\n float distances[10];\n\n int found, j;\n start_time = ms_time();\n for (j = 0; j < 20000; j++)\n found = hnsw_search(index, v, 10, neighbors, distances, 0, 0);\n elapsed = ms_time() - start_time;\n printf(\"%d searches performed (%llu searches/sec), nodes found: %d\\n\",\n j, (unsigned long long)j*1000/elapsed, found);\n\n if (found > 0) {\n printf(\"Found %d neighbors:\\n\", found);\n for (int i = 0; i < found; i++) {\n printf(\"Node ID: %llu, distance: %f, word: %s\\n\",\n (unsigned long long)neighbors[i]->id,\n distances[i], (char*)neighbors[i]->value);\n }\n }\n\n // Self-recall test (ability to find the node by its own vector).\n if (self_recall) {\n hnsw_print_stats(index);\n hnsw_test_graph_recall(index,200,0);\n }\n\n // Recall test with random vectors.\n if (recall_ef > 0) {\n test_recall(index, recall_ef);\n }\n\n uint64_t connected_nodes;\n int reciprocal_links;\n hnsw_validate_graph(index, &connected_nodes, &reciprocal_links);\n\n if (massdel) {\n int remove_perc = 95;\n printf(\"\\nRemoving %d%% of nodes...\\n\", remove_perc);\n uint64_t initial_nodes = index->node_count;\n\n hnswNode *current = index->head;\n while (current && index->node_count > initial_nodes*(100-remove_perc)/100) {\n hnswNode *next = current->next;\n hnsw_delete_node(index,current,free);\n current = next;\n // In order to don't remove only contiguous nodes, from time\n // skip a node.\n if (current && !(random() % remove_perc)) current = current->next;\n }\n printf(\"%llu nodes left\\n\", (unsigned long long)index->node_count);\n\n // Test again.\n hnsw_validate_graph(index, &connected_nodes, &reciprocal_links);\n hnsw_test_graph_recall(index,200,0);\n }\n\n hnsw_free(index,free);\n return 0;\n}\n\nstruct threadContext {\n pthread_mutex_t FileAccessMutex;\n uint64_t numele;\n _Atomic uint64_t SearchesDone;\n _Atomic uint64_t id;\n FILE *fp;\n HNSW *index;\n float *search_vector;\n};\n\n// Note that in practical terms inserting with many concurrent threads\n// may be *slower* and not faster, because there is a lot of\n// contention. So this is more a robustness test than anything else.\n//\n// The optimistic commit API goal is actually to exploit the ability to\n// add faster when there are many concurrent reads.\nvoid *threaded_insert(void *ctxptr) {\n struct threadContext *ctx = ctxptr;\n char *word;\n float v[300];\n uint16_t wlen;\n\n while(1) {\n pthread_mutex_lock(&ctx->FileAccessMutex);\n if (fread(&wlen,2,1,ctx->fp) == 0) break;\n pthread_mutex_unlock(&ctx->FileAccessMutex);\n word = malloc(wlen+1);\n if (fread(word,wlen,1,ctx->fp) <= 0) {\n perror(\"Unexpected EOF\");\n exit(1);\n }\n\n word[wlen] = 0;\n if (fread(v,300*sizeof(float),1,ctx->fp) <= 0) {\n perror(\"Unexpected EOF\");\n exit(1);\n }\n\n // Check-and-set API that performs the costly scan for similar\n // nodes concurrently with other read threads, and finally\n // applies the check if the graph wasn't modified.\n InsertContext *ic;\n uint64_t next_id = ctx->id++;\n ic = hnsw_prepare_insert(ctx->index, v, NULL, 0, next_id, 200);\n if (hnsw_try_commit_insert(ctx->index, ic, word) == NULL) {\n // This time try locking since the start.\n hnsw_insert(ctx->index, v, NULL, 0, next_id, word, 200);\n }\n\n if (next_id >= ctx->numele) break;\n if (!((next_id+1) % 10000))\n printf(\"%llu added\\n\", (unsigned long long)next_id+1);\n }\n return NULL;\n}\n\nvoid *threaded_search(void *ctxptr) {\n struct threadContext *ctx = ctxptr;\n\n /* Search query */\n hnswNode *neighbors[10];\n float distances[10];\n int found = 0;\n uint64_t last_id = 0;\n\n while(ctx->id < 1000000) {\n int slot = hnsw_acquire_read_slot(ctx->index);\n found = hnsw_search(ctx->index, ctx->search_vector, 10, neighbors, distances, slot, 0);\n hnsw_release_read_slot(ctx->index,slot);\n last_id = ++ctx->id;\n }\n\n if (found > 0 && last_id == 1000000) {\n printf(\"Found %d neighbors:\\n\", found);\n for (int i = 0; i < found; i++) {\n printf(\"Node ID: %llu, distance: %f, word: %s\\n\",\n (unsigned long long)neighbors[i]->id,\n distances[i], (char*)neighbors[i]->value);\n }\n }\n return NULL;\n}\n\nint w2v_multi_thread(int m_param, int numthreads, int quantization, uint64_t numele) {\n /* Create index */\n struct threadContext ctx;\n\n ctx.index = hnsw_new(300, quantization, m_param);\n\n ctx.fp = fopen(\"word2vec.bin\",\"rb\");\n if (ctx.fp == NULL) {\n perror(\"word2vec.bin file missing\");\n exit(1);\n }\n\n unsigned char header[8];\n if (fread(header,8,1,ctx.fp) <= 0) { // Skip header\n perror(\"Unexpected EOF\");\n exit(1);\n }\n pthread_mutex_init(&ctx.FileAccessMutex,NULL);\n\n uint64_t start_time = ms_time();\n ctx.id = 0;\n ctx.numele = numele;\n pthread_t threads[numthreads];\n for (int j = 0; j < numthreads; j++)\n pthread_create(&threads[j], NULL, threaded_insert, &ctx);\n\n // Wait for all the threads to terminate adding items.\n for (int j = 0; j < numthreads; j++)\n pthread_join(threads[j],NULL);\n\n uint64_t elapsed = ms_time() - start_time;\n fclose(ctx.fp);\n\n // Obtain the last word.\n hnswNode *node = ctx.index->head;\n char *word = node->value;\n\n // We will search this last inserted word in the next test.\n // Let's save its embedding.\n ctx.search_vector = malloc(sizeof(float)*300);\n hnsw_get_node_vector(ctx.index,node,ctx.search_vector);\n\n printf(\"%llu words added (%llu words/sec), last word: %s\\n\",\n (unsigned long long)ctx.index->node_count,\n (unsigned long long)ctx.id*1000/elapsed, word);\n\n /* Search query */\n start_time = ms_time();\n ctx.id = 0; // We will use this atomic field to stop at N queries done.\n\n for (int j = 0; j < numthreads; j++)\n pthread_create(&threads[j], NULL, threaded_search, &ctx);\n\n // Wait for all the threads to terminate searching.\n for (int j = 0; j < numthreads; j++)\n pthread_join(threads[j],NULL);\n\n elapsed = ms_time() - start_time;\n printf(\"%llu searches performed (%llu searches/sec)\\n\",\n (unsigned long long)ctx.id,\n (unsigned long long)ctx.id*1000/elapsed);\n\n hnsw_print_stats(ctx.index);\n uint64_t connected_nodes;\n int reciprocal_links;\n hnsw_validate_graph(ctx.index, &connected_nodes, &reciprocal_links);\n printf(\"%llu connected nodes. Links all reciprocal: %d\\n\",\n (unsigned long long)connected_nodes, reciprocal_links);\n hnsw_free(ctx.index,free);\n return 0;\n}\n\nint main(int argc, char **argv) {\n int quantization = HNSW_QUANT_NONE;\n int numthreads = 0;\n uint64_t numele = 20000;\n int m_param = 0; // Default value (0 means use HNSW_DEFAULT_M)\n\n /* This you can enable in single thread mode for testing: */\n int massdel = 0; // If true, does the mass deletion test.\n int self_recall = 0; // If true, does the self-recall test.\n int recall_ef = 0; // If not 0, does the recall test with this EF value.\n\n for (int j = 1; j < argc; j++) {\n int moreargs = argc-j-1;\n\n if (!strcasecmp(argv[j],\"--quant\")) {\n quantization = HNSW_QUANT_Q8;\n } else if (!strcasecmp(argv[j],\"--bin\")) {\n quantization = HNSW_QUANT_BIN;\n } else if (!strcasecmp(argv[j],\"--mass-del\")) {\n massdel = 1;\n } else if (!strcasecmp(argv[j],\"--self-recall\")) {\n self_recall = 1;\n } else if (moreargs >= 1 && !strcasecmp(argv[j],\"--recall\")) {\n recall_ef = atoi(argv[j+1]);\n j++;\n } else if (moreargs >= 1 && !strcasecmp(argv[j],\"--threads\")) {\n numthreads = atoi(argv[j+1]);\n j++;\n } else if (moreargs >= 1 && !strcasecmp(argv[j],\"--numele\")) {\n numele = strtoll(argv[j+1],NULL,0);\n j++;\n if (numele < 1) numele = 1;\n } else if (moreargs >= 1 && !strcasecmp(argv[j],\"--m\")) {\n m_param = atoi(argv[j+1]);\n j++;\n } else if (!strcasecmp(argv[j],\"--help\")) {\n printf(\"%s [--quant] [--bin] [--thread ] [--numele ] [--m ] [--mass-del] [--self-recall] [--recall ]\\n\", argv[0]);\n exit(0);\n } else {\n printf(\"Unrecognized option or wrong number of arguments: %s\\n\", argv[j]);\n exit(1);\n }\n }\n\n if (quantization == HNSW_QUANT_NONE) {\n printf(\"You can enable quantization with --quant\\n\");\n }\n\n if (numthreads > 0) {\n w2v_multi_thread(m_param, numthreads, quantization, numele);\n } else {\n printf(\"Single thread execution. Use --threads 4 for concurrent API\\n\");\n w2v_single_thread(m_param, quantization, numele, massdel, self_recall, recall_ef);\n }\n}\n" }, { "path": "redis-full.conf", "content": "include redis.conf\n\nloadmodule ./modules/redisbloom/redisbloom.so\nloadmodule ./modules/redisearch/redisearch.so\nloadmodule ./modules/redisjson/rejson.so\nloadmodule ./modules/redistimeseries/redistimeseries.so\n\n############################## QUERY ENGINE CONFIG ############################\n\n# Keep numeric ranges in numeric tree parent nodes of leafs for `x` generations.\n# numeric, valid range: [0, 2], default: 0\n#\n# search-_numeric-ranges-parents 0\n\n# The number of iterations to run while performing background indexing\n# before we call usleep(1) (sleep for 1 micro-second) and make sure that we\n# allow redis to process other commands.\n# numeric, valid range: [1, UINT32_MAX], default: 100\n#\n# search-bg-index-sleep-gap 100\n\n# The default dialect used in search queries.\n# numeric, valid range: [1, 4], default: 1\n#\n# search-default-dialect 1\n\n# the fork gc will only start to clean when the number of not cleaned document\n# will exceed this threshold.\n# numeric, valid range: [1, LLONG_MAX], default: 100\n#\n# search-fork-gc-clean-threshold 100\n\n# interval (in seconds) in which to retry running the forkgc after failure.\n# numeric, valid range: [1, LLONG_MAX], default: 5\n#\n# search-fork-gc-retry-interval 5\n\n# interval (in seconds) in which to run the fork gc (relevant only when fork\n# gc is used).\n# numeric, valid range: [1, LLONG_MAX], default: 30\n#\n# search-fork-gc-run-interval 30\n\n# the amount of seconds for the fork GC to sleep before exiting.\n# numeric, valid range: [0, LLONG_MAX], default: 0\n#\n# search-fork-gc-sleep-before-exit 0\n\n# Scan this many documents at a time during every GC iteration.\n# numeric, valid range: [1, LLONG_MAX], default: 100\n#\n# search-gc-scan-size 100\n\n# Max number of cursors for a given index that can be opened inside of a shard.\n# numeric, valid range: [0, LLONG_MAX], default: 128\n#\n# search-index-cursor-limit 128\n\n# Maximum number of results from ft.aggregate command.\n# numeric, valid range: [0, (1ULL << 31)], default: 1ULL << 31\n#\n# search-max-aggregate-results 2147483648\n\n# Maximum prefix expansions to be used in a query.\n# numeric, valid range: [1, LLONG_MAX], default: 200\n#\n# search-max-prefix-expansions 200\n\n# Maximum runtime document table size (for this process).\n# numeric, valid range: [1, 100000000], default: 1000000\n#\n# search-max-doctablesize 1000000\n\n# max idle time allowed to be set for cursor, setting it high might cause\n# high memory consumption.\n# numeric, valid range: [1, LLONG_MAX], default: 300000\n#\n# search-cursor-max-idle 300000\n\n# Maximum number of results from ft.search command.\n# numeric, valid range: [0, 1ULL << 31], default: 1000000\n#\n# search-max-search-results 1000000\n\n# Number of worker threads to use for background tasks when the server is\n# in an operation event.\n# numeric, valid range: [1, 16], default: 4\n#\n# search-min-operation-workers 4\n\n# Minimum length of term to be considered for phonetic matching.\n# numeric, valid range: [1, LLONG_MAX], default: 3\n#\n# search-min-phonetic-term-len 3\n\n# the minimum prefix for expansions (`*`).\n# numeric, valid range: [1, LLONG_MAX], default: 2\n#\n# search-min-prefix 2\n\n# the minimum word length to stem.\n# numeric, valid range: [2, UINT32_MAX], default: 4\n#\n# search-min-stem-len 4\n\n# Delta used to increase positional offsets between array\n# slots for multi text values.\n# Can control the level of separation between phrases in different\n# array slots (related to the SLOP parameter of ft.search command)\"\n# numeric, valid range: [1, UINT32_MAX], default: 100\n#\n# search-multi-text-slop 100\n\n# Used for setting the buffer limit threshold for vector similarity tiered\n# HNSW index, so that if we are using WORKERS for indexing, and the\n# number of vectors waiting in the buffer to be indexed exceeds this limit,\n# we insert new vectors directly into HNSW.\n# numeric, valid range: [0, LLONG_MAX], default: 1024\n#\n# search-tiered-hnsw-buffer-limit 1024\n\n# Query timeout.\n# numeric, valid range: [1, LLONG_MAX], default: 500\n#\n# search-timeout 500\n\n# minimum number of iterators in a union from which the iterator will\n# will switch to heap-based implementation.\n# numeric, valid range: [1, LLONG_MAX], default: 20\n# switch to heap based implementation.\n#\n# search-union-iterator-heap 20\n\n# The maximum memory resize for vector similarity indexes (in bytes).\n# numeric, valid range: [0, UINT32_MAX], default: 0\n#\n# search-vss-max-resize 0\n\n# Number of worker threads to use for query processing and background tasks.\n# numeric, valid range: [0, 16], default: 0\n# This configuration also affects the number of connections per shard.\n#\n# search-workers 0\n\n# The number of high priority tasks to be executed at any given time by the\n# worker thread pool, before executing low priority tasks. After this number\n# of high priority tasks are being executed, the worker thread pool will\n# execute high and low priority tasks alternately.\n# numeric, valid range: [0, LLONG_MAX], default: 1\n#\n# search-workers-priority-bias-threshold 1\n\n# Load extension scoring/expansion module. Immutable.\n# string, default: \"\"\n#\n# search-ext-load \"\"\n\n# Path to Chinese dictionary configuration file (for Chinese tokenization). Immutable.\n# string, default: \"\"\n#\n# search-friso-ini \"\"\n\n# Action to perform when search timeout is exceeded (choose RETURN or FAIL).\n# enum, valid values: [\"return\", \"fail\"], default: \"fail\"\n#\n# search-on-timeout fail\n\n# Determine whether some index resources are free on a second thread.\n# bool, default: yes\n#\n# search-_free-resource-on-thread yes\n\n# Enable legacy compression of double to float.\n# bool, default: no\n#\n# search-_numeric-compress no\n\n# Disable print of time for ft.profile. For testing only.\n# bool, default: yes\n#\n# search-_print-profile-clock yes\n\n# Intersection iterator orders the children iterators by their relative estimated\n# number of results in ascending order, so that if we see first iterators with\n# a lower count of results we will skip a larger number of results, which\n# translates into faster iteration. If this flag is set, we use this\n# optimization in a way where union iterators are being factorize by the number\n# of their own children, so that we sort by the number of children times the\n# overall estimated number of results instead.\n# bool, default: no\n#\n# search-_prioritize-intersect-union-children no\n\n# Set to run without memory pools.\n# bool, default: no\n#\n# search-no-mem-pools no\n\n# Disable garbage collection (for this process).\n# bool, default: no\n#\n# search-no-gc no\n\n# Enable commands filter which optimize indexing on partial hash updates.\n# bool, default: no\n#\n# search-partial-indexed-docs no\n\n# Disable compression for DocID inverted index. Boost CPU performance.\n# bool, default: no\n#\n# search-raw-docid-encoding no\n\n# Number of search threads in the coordinator thread pool.\n# numeric, valid range: [1, LLONG_MAX], default: 20\n#\n# search-threads 20\n\n# Timeout for topology validation (in milliseconds). After this timeout,\n# any pending requests will be processed, even if the topology is not fully connected.\n# numeric, valid range: [0, LLONG_MAX], default: 30000\n#\n# search-topology-validation-timeout 30000\n\n\n############################## TIME SERIES CONFIG #############################\n\n# The maximal number of per-shard threads for cross-key queries when using cluster mode\n# (TS.MRANGE, TS.MREVRANGE, TS.MGET, and TS.QUERYINDEX).\n# Note: increasing this value may either increase or decrease the performance.\n# integer, valid range: [1..16], default: 3\n# This is a load-time configuration parameter.\n#\n# ts-num-threads 3\n\n\n# Default compaction rules for newly created key with TS.ADD, TS.INCRBY, and TS.DECRBY.\n# Has no effect on keys created with TS.CREATE.\n# This default value is applied to each new time series upon its creation.\n# string, see documentation for rules format, default: no compaction rules\n#\n# ts-compaction-policy \"\"\n\n# Default chunk encoding for automatically-created compacted time series.\n# This default value is applied to each new compacted time series automatically\n# created when ts-compaction-policy is specified.\n# valid values: COMPRESSED, UNCOMPRESSED, default: COMPRESSED\n#\n# ts-encoding COMPRESSED\n\n\n# Default retention period, in milliseconds. 0 means no expiration.\n# This default value is applied to each new time series upon its creation.\n# If ts-compaction-policy is specified - it is overridden for created\n# compactions as specified in ts-compaction-policy.\n# integer, valid range: [0 .. LLONG_MAX], default: 0\n#\n# ts-retention-policy 0\n\n# Default policy for handling insertion (TS.ADD and TS.MADD) of multiple\n# samples with identical timestamps.\n# This default value is applied to each new time series upon its creation.\n# string, valid values: BLOCK, FIRST, LAST, MIN, MAX, SUM, default: BLOCK\n#\n# ts-duplicate-policy BLOCK\n\n# Default initial allocation size, in bytes, for the data part of each new chunk\n# This default value is applied to each new time series upon its creation.\n# integer, valid range: [48 .. 1048576]; must be a multiple of 8, default: 4096\n#\n# ts-chunk-size-bytes 4096\n\n# Default values for newly created time series.\n# Many sensors report data periodically. Often, the difference between the measured\n# value and the previous measured value is negligible and related to random noise\n# or to measurement accuracy limitations. In such situations it may be preferable\n# not to add the new measurement to the time series.\n# A new sample is considered a duplicate and is ignored if the following conditions are met:\n# - The time series is not a compaction;\n# - The time series' DUPLICATE_POLICY IS LAST;\n# - The sample is added in-order (timestamp >= max_timestamp);\n# - The difference of the current timestamp from the previous timestamp\n# (timestamp - max_timestamp) is less than or equal to ts-ignore-max-time-diff\n# - The absolute value difference of the current value from the value at the previous maximum timestamp\n# (abs(value - value_at_max_timestamp) is less than or equal to ts-ignore-max-val-diff.\n# where max_timestamp is the timestamp of the sample with the largest timestamp in the time series,\n# and value_at_max_timestamp is the value at max_timestamp.\n# ts-ignore-max-time-diff: integer, valid range: [0 .. LLONG_MAX], default: 0\n# ts-ignore-max-val-diff: double, Valid range: [0 .. DBL_MAX], default: 0\n#\n# ts-ignore-max-time-diff 0\n# ts-ignore-max-val-diff 0\n\n\n########################### BLOOM FILTERS CONFIG ##############################\n\n# Defaults values for new Bloom filters created with BF.ADD, BF.MADD, BF.INSERT, and BF.RESERVE\n# These defaults are applied to each new Bloom filter upon its creation.\n\n# Error ratio\n# The desired probability for false positives.\n# For a false positive rate of 0.1% (1 in 1000) - the value should be 0.001.\n# double, Valid range: (0 .. 1), value greater than 0.25 is treated as 0.25, default: 0.01\n#\n# bf-error-rate 0.01\n\n# Initial capacity\n# The number of entries intended to be added to the filter.\n# integer, valid range: [1 .. 1GB], default: 100\n#\n# bf-initial-size 100\n\n# Expansion factor\n# When capacity is reached, an additional sub-filter is created.\n# The size of the new sub-filter is the size of the last sub-filter multiplied\n# by expansion.\n# integer, [0 .. 32768]. 0 is equivalent to NONSCALING. default: 2\n#\n# bf-expansion-factor 2\n\n\n########################### CUCKOO FILTERS CONFIG #############################\n\n# Defaults values for new Cuckoo filters created with\n# CF.ADD, CF.ADDNX, CF.INSERT, CF.INSERTNX, and CF.RESERVE\n# These defaults are applied to each new Cuckoo filter upon its creation.\n\n# Initial capacity\n# A filter will likely not fill up to 100% of its capacity.\n# Make sure to reserve extra capacity if you want to avoid expansions.\n# value is rounded to the next 2^n integer.\n# integer, valid range: [2*cf-bucket-size .. 1GB], default: 1024\n#\n# cf-initial-size 1024\n\n# Number of items in each bucket\n# The minimal false positive rate is 2/255 ~ 0.78% when bucket size of 1 is used.\n# Larger buckets increase the error rate linearly, but improve the fill rate.\n# integer, valid range: [1 .. 255], default: 2\n#\n# cf-bucket-size 2\n\n# Maximum iterations\n# Number of attempts to swap items between buckets before declaring filter\n# as full and creating an additional filter.\n# A lower value improves performance. A higher value improves fill rate.\n# integer, Valid range: [1 .. 65535], default: 20\n#\n# cf-max-iterations 20\n\n# Expansion factor\n# When a new filter is created, its size is the size of the current filter\n# multiplied by this factor.\n# integer, Valid range: [0 .. 32768], 0 is equivalent to NONSCALING, default: 1\n#\n# cf-expansion-factor 1\n\n# Maximum expansions\n# integer, Valid range: [1 .. 65536], default: 32\n#\n# cf-max-expansions 32\n\n\n################################## SECURITY ###################################\n#\n# The following is a list of command categories and their meanings:\n#\n# * search - Query engine related.\n# * json - Data type: JSON related.\n# * timeseries - Data type: time series related.\n# * bloom - Data type: Bloom filter related.\n# * cuckoo - Data type: cuckoo filter related.\n# * topk - Data type: top-k related.\n# * cms - Data type: count-min sketch related.\n# * tdigest - Data type: t-digest related.\n\n" }, { "path": "redis.conf", "content": "# Redis configuration file example.\n#\n# Note that in order to read the configuration file, Redis must be\n# started with the file path as first argument:\n#\n# ./redis-server /path/to/redis.conf\n\n# Note on units: when memory size is needed, it is possible to specify\n# it in the usual form of 1k 5GB 4M and so forth:\n#\n# 1k => 1000 bytes\n# 1kb => 1024 bytes\n# 1m => 1000000 bytes\n# 1mb => 1024*1024 bytes\n# 1g => 1000000000 bytes\n# 1gb => 1024*1024*1024 bytes\n#\n# units are case insensitive so 1GB 1Gb 1gB are all the same.\n\n################################## INCLUDES ###################################\n\n# Include one or more other config files here. This is useful if you\n# have a standard template that goes to all Redis servers but also need\n# to customize a few per-server settings. Include files can include\n# other files, so use this wisely.\n#\n# Note that option \"include\" won't be rewritten by command \"CONFIG REWRITE\"\n# from admin or Redis Sentinel. Since Redis always uses the last processed\n# line as value of a configuration directive, you'd better put includes\n# at the beginning of this file to avoid overwriting config change at runtime.\n#\n# If instead you are interested in using includes to override configuration\n# options, it is better to use include as the last line.\n#\n# Included paths may contain wildcards. All files matching the wildcards will\n# be included in alphabetical order.\n# Note that if an include path contains a wildcards but no files match it when\n# the server is started, the include statement will be ignored and no error will\n# be emitted. It is safe, therefore, to include wildcard files from empty\n# directories.\n#\n# include /path/to/local.conf\n# include /path/to/other.conf\n# include /path/to/fragments/*.conf\n#\n\n################################## MODULES #####################################\n\n# Load modules at startup. If the server is not able to load modules\n# it will abort. It is possible to use multiple loadmodule directives.\n#\n# loadmodule /path/to/my_module.so\n# loadmodule /path/to/other_module.so\n# loadmodule /path/to/args_module.so [arg [arg ...]]\n\n################################## NETWORK #####################################\n\n# By default, if no \"bind\" configuration directive is specified, Redis listens\n# for connections from all available network interfaces on the host machine.\n# It is possible to listen to just one or multiple selected interfaces using\n# the \"bind\" configuration directive, followed by one or more IP addresses.\n# Each address can be prefixed by \"-\", which means that redis will not fail to\n# start if the address is not available. Being not available only refers to\n# addresses that does not correspond to any network interface. Addresses that\n# are already in use will always fail, and unsupported protocols will always BE\n# silently skipped.\n#\n# Examples:\n#\n# bind 192.168.1.100 10.0.0.1 # listens on two specific IPv4 addresses\n# bind 127.0.0.1 ::1 # listens on loopback IPv4 and IPv6\n# bind * -::* # like the default, all available interfaces\n#\n# ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the\n# internet, binding to all the interfaces is dangerous and will expose the\n# instance to everybody on the internet. So by default we uncomment the\n# following bind directive, that will force Redis to listen only on the\n# IPv4 and IPv6 (if available) loopback interface addresses (this means Redis\n# will only be able to accept client connections from the same host that it is\n# running on).\n#\n# IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES\n# COMMENT OUT THE FOLLOWING LINE.\n#\n# You will also need to set a password unless you explicitly disable protected\n# mode.\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nbind 127.0.0.1 -::1\n\n# By default, outgoing connections (from replica to master, from Sentinel to\n# instances, cluster bus, etc.) are not bound to a specific local address. In\n# most cases, this means the operating system will handle that based on routing\n# and the interface through which the connection goes out.\n#\n# Using bind-source-addr it is possible to configure a specific address to bind\n# to, which may also affect how the connection gets routed.\n#\n# Example:\n#\n# bind-source-addr 10.0.0.1\n\n# Protected mode is a layer of security protection, in order to avoid that\n# Redis instances left open on the internet are accessed and exploited.\n#\n# When protected mode is on and the default user has no password, the server\n# only accepts local connections from the IPv4 address (127.0.0.1), IPv6 address\n# (::1) or Unix domain sockets.\n#\n# By default protected mode is enabled. You should disable it only if\n# you are sure you want clients from other hosts to connect to Redis\n# even if no authentication is configured.\nprotected-mode yes\n\n# Redis uses default hardened security configuration directives to reduce the\n# attack surface on innocent users. Therefore, several sensitive configuration\n# directives are immutable, and some potentially-dangerous commands are blocked.\n#\n# Configuration directives that control files that Redis writes to (e.g., 'dir'\n# and 'dbfilename') and that aren't usually modified during runtime\n# are protected by making them immutable.\n#\n# Commands that can increase the attack surface of Redis and that aren't usually\n# called by users are blocked by default.\n#\n# These can be exposed to either all connections or just local ones by setting\n# each of the configs listed below to either of these values:\n#\n# no - Block for any connection (remain immutable)\n# yes - Allow for any connection (no protection)\n# local - Allow only for local connections. Ones originating from the\n# IPv4 address (127.0.0.1), IPv6 address (::1) or Unix domain sockets.\n#\n# enable-protected-configs no\n# enable-debug-command no\n# enable-module-command no\n\n# Accept connections on the specified port, default is 6379 (IANA #815344).\n# If port 0 is specified Redis will not listen on a TCP socket.\nport 6379\n\n# TCP listen() backlog.\n#\n# In high requests-per-second environments you need a high backlog in order\n# to avoid slow clients connection issues. Note that the Linux kernel\n# will silently truncate it to the value of /proc/sys/net/core/somaxconn so\n# make sure to raise both the value of somaxconn and tcp_max_syn_backlog\n# in order to get the desired effect.\ntcp-backlog 511\n\n# Unix socket.\n#\n# Specify the path for the Unix socket that will be used to listen for\n# incoming connections. There is no default, so Redis will not listen\n# on a unix socket when not specified.\n#\n# unixsocket /run/redis.sock\n# unixsocketperm 700\n\n# Close the connection after a client is idle for N seconds (0 to disable)\ntimeout 0\n\n# TCP keepalive.\n#\n# If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence\n# of communication. This is useful for two reasons:\n#\n# 1) Detect dead peers.\n# 2) Force network equipment in the middle to consider the connection to be\n# alive.\n#\n# On Linux, the specified value (in seconds) is the period used to send ACKs.\n# Note that to close the connection the double of the time is needed.\n# On other kernels the period depends on the kernel configuration.\n#\n# A reasonable value for this option is 300 seconds, which is the new\n# Redis default starting with Redis 3.2.1.\ntcp-keepalive 300\n\n# Apply OS-specific mechanism to mark the listening socket with the specified\n# ID, to support advanced routing and filtering capabilities.\n#\n# On Linux, the ID represents a connection mark.\n# On FreeBSD, the ID represents a socket cookie ID.\n# On OpenBSD, the ID represents a route table ID.\n#\n# The default value is 0, which implies no marking is required.\n# socket-mark-id 0\n\n################################# TLS/SSL #####################################\n\n# By default, TLS/SSL is disabled. To enable it, the \"tls-port\" configuration\n# directive can be used to define TLS-listening ports. To enable TLS on the\n# default port, use:\n#\n# port 0\n# tls-port 6379\n\n# Configure a X.509 certificate and private key to use for authenticating the\n# server to connected clients, masters or cluster peers. These files should be\n# PEM formatted.\n#\n# tls-cert-file redis.crt\n# tls-key-file redis.key\n#\n# If the key file is encrypted using a passphrase, it can be included here\n# as well.\n#\n# tls-key-file-pass secret\n\n# Normally Redis uses the same certificate for both server functions (accepting\n# connections) and client functions (replicating from a master, establishing\n# cluster bus connections, etc.).\n#\n# Sometimes certificates are issued with attributes that designate them as\n# client-only or server-only certificates. In that case it may be desired to use\n# different certificates for incoming (server) and outgoing (client)\n# connections. To do that, use the following directives:\n#\n# tls-client-cert-file client.crt\n# tls-client-key-file client.key\n#\n# If the key file is encrypted using a passphrase, it can be included here\n# as well.\n#\n# tls-client-key-file-pass secret\n\n# Configure a DH parameters file to enable Diffie-Hellman (DH) key exchange,\n# required by older versions of OpenSSL (<3.0). Newer versions do not require\n# this configuration and recommend against it.\n#\n# tls-dh-params-file redis.dh\n\n# Configure a CA certificate(s) bundle or directory to authenticate TLS/SSL\n# clients and peers. Redis requires an explicit configuration of at least one\n# of these, and will not implicitly use the system wide configuration.\n#\n# tls-ca-cert-file ca.crt\n# tls-ca-cert-dir /etc/ssl/certs\n\n# By default, clients (including replica servers) on a TLS port are required\n# to authenticate using valid client side certificates.\n#\n# If \"no\" is specified, client certificates are not required and not accepted.\n# If \"optional\" is specified, client certificates are accepted and must be\n# valid if provided, but are not required.\n#\n# tls-auth-clients no\n# tls-auth-clients optional\n\n# Automatically authenticate TLS clients as Redis users based on their\n# certificates.\n#\n# If set to a field like \"CN\", the server will extract the corresponding field\n# from the client's TLS certificate and attempt to find a Redis user with the\n# same name. If a matching user is found, the client is automatically\n# authenticated as that user during the TLS handshake. If no matching user is\n# found, the client is connected as the unauthenticated default user. Set to\n# \"off\" to disable automatic user authentication via certificate fields.\n#\n# Supported values: CN, off. Default: off.\n#\n# Matches certificate CN to Redis username (exact match only).\n# Example: Cert CN=myapp -> authenticates as user \"myapp\"\n#\n# tls-auth-clients-user CN\n\n# By default, a Redis replica does not attempt to establish a TLS connection\n# with its master.\n#\n# Use the following directive to enable TLS on replication links.\n#\n# tls-replication yes\n\n# By default, the Redis Cluster bus uses a plain TCP connection. To enable\n# TLS for the bus protocol, use the following directive:\n#\n# tls-cluster yes\n\n# By default, only TLSv1.2 and TLSv1.3 are enabled and it is highly recommended\n# that older formally deprecated versions are kept disabled to reduce the attack surface.\n# You can explicitly specify TLS versions to support.\n# Allowed values are case insensitive and include \"TLSv1\", \"TLSv1.1\", \"TLSv1.2\",\n# \"TLSv1.3\" (OpenSSL >= 1.1.1) or any combination.\n# To enable only TLSv1.2 and TLSv1.3, use:\n#\n# tls-protocols \"TLSv1.2 TLSv1.3\"\n\n# Configure allowed ciphers. See the ciphers(1ssl) manpage for more information\n# about the syntax of this string.\n#\n# Note: this configuration applies only to <= TLSv1.2.\n#\n# tls-ciphers DEFAULT:!MEDIUM\n\n# Configure allowed TLSv1.3 ciphersuites. See the ciphers(1ssl) manpage for more\n# information about the syntax of this string, and specifically for TLSv1.3\n# ciphersuites.\n#\n# tls-ciphersuites TLS_CHACHA20_POLY1305_SHA256\n\n# When choosing a cipher, use the server's preference instead of the client\n# preference. By default, the server follows the client's preference.\n#\n# tls-prefer-server-ciphers yes\n\n# By default, TLS session caching is enabled to allow faster and less expensive\n# reconnections by clients that support it. Use the following directive to disable\n# caching.\n#\n# tls-session-caching no\n\n# Change the default number of TLS sessions cached. A zero value sets the cache\n# to unlimited size. The default size is 20480.\n#\n# tls-session-cache-size 5000\n\n# Change the default timeout of cached TLS sessions. The default timeout is 300\n# seconds.\n#\n# tls-session-cache-timeout 60\n\n################################# GENERAL #####################################\n\n# By default Redis does not run as a daemon. Use 'yes' if you need it.\n# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.\n# When Redis is supervised by upstart or systemd, this parameter has no impact.\ndaemonize no\n\n# If you run Redis from upstart or systemd, Redis can interact with your\n# supervision tree. Options:\n# supervised no - no supervision interaction\n# supervised upstart - signal upstart by putting Redis into SIGSTOP mode\n# requires \"expect stop\" in your upstart job config\n# supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET\n# on startup, and updating Redis status on a regular\n# basis.\n# supervised auto - detect upstart or systemd method based on\n# UPSTART_JOB or NOTIFY_SOCKET environment variables\n# Note: these supervision methods only signal \"process is ready.\"\n# They do not enable continuous pings back to your supervisor.\n#\n# The default is \"no\". To run under upstart/systemd, you can simply uncomment\n# the line below:\n#\n# supervised auto\n\n# If a pid file is specified, Redis writes it where specified at startup\n# and removes it at exit.\n#\n# When the server runs non daemonized, no pid file is created if none is\n# specified in the configuration. When the server is daemonized, the pid file\n# is used even if not specified, defaulting to \"/var/run/redis.pid\".\n#\n# Creating a pid file is best effort: if Redis is not able to create it\n# nothing bad happens, the server will start and run normally.\n#\n# Note that on modern Linux systems \"/run/redis.pid\" is more conforming\n# and should be used instead.\npidfile /var/run/redis_6379.pid\n\n# Specify the server verbosity level.\n# This can be one of:\n# debug (a lot of information, useful for development/testing)\n# verbose (many rarely useful info, but not a mess like the debug level)\n# notice (moderately verbose, what you want in production probably)\n# warning (only very important / critical messages are logged)\n# nothing (nothing is logged)\nloglevel notice\n\n# Specify the log file name. Also the empty string can be used to force\n# Redis to log on the standard output. Note that if you use standard\n# output for logging but daemonize, logs will be sent to /dev/null\nlogfile \"\"\n\n# To enable logging to the system logger, just set 'syslog-enabled' to yes,\n# and optionally update the other syslog parameters to suit your needs.\n# syslog-enabled no\n\n# Specify the syslog identity.\n# syslog-ident redis\n\n# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.\n# syslog-facility local0\n\n# To disable the built in crash log, which will possibly produce cleaner core\n# dumps when they are needed, uncomment the following:\n#\n# crash-log-enabled no\n\n# To disable the fast memory check that's run as part of the crash log, which\n# will possibly let redis terminate sooner, uncomment the following:\n#\n# crash-memcheck-enabled no\n\n# Set the number of databases. The default database is DB 0, you can select\n# a different one on a per-connection basis using SELECT where\n# dbid is a number between 0 and 'databases'-1\ndatabases 16\n\n# By default Redis shows an ASCII art logo only when started to log to the\n# standard output and if the standard output is a TTY and syslog logging is\n# disabled. Basically this means that normally a logo is displayed only in\n# interactive sessions.\n#\n# However it is possible to force the pre-4.0 behavior and always show a\n# ASCII art logo in startup logs by setting the following option to yes.\nalways-show-logo no\n\n# To avoid logging personal identifiable information (PII) into server log file,\n# uncomment the following:\n#\n# hide-user-data-from-log yes\n\n# By default, Redis modifies the process title (as seen in 'top' and 'ps') to\n# provide some runtime information. It is possible to disable this and leave\n# the process name as executed by setting the following to no.\nset-proc-title yes\n\n# When changing the process title, Redis uses the following template to construct\n# the modified title.\n#\n# Template variables are specified in curly brackets. The following variables are\n# supported:\n#\n# {title} Name of process as executed if parent, or type of child process.\n# {listen-addr} Bind address or '*' followed by TCP or TLS port listening on, or\n# Unix socket if only that's available.\n# {server-mode} Special mode, i.e. \"[sentinel]\" or \"[cluster]\".\n# {port} TCP port listening on, or 0.\n# {tls-port} TLS port listening on, or 0.\n# {unixsocket} Unix domain socket listening on, or \"\".\n# {config-file} Name of configuration file used.\n#\nproc-title-template \"{title} {listen-addr} {server-mode}\"\n\n# Set the local environment which is used for string comparison operations, and \n# also affect the performance of Lua scripts. Empty String indicates the locale \n# is derived from the environment variables.\nlocale-collate \"\"\n\n################################ SNAPSHOTTING ################################\n\n# Save the DB to disk.\n#\n# save [ ...]\n#\n# Redis will save the DB if the given number of seconds elapsed and it\n# surpassed the given number of write operations against the DB.\n#\n# Snapshotting can be completely disabled with a single empty string argument\n# as in following example:\n#\n# save \"\"\n#\n# Unless specified otherwise, by default Redis will save the DB:\n# * After 3600 seconds (an hour) if at least 1 change was performed\n# * After 300 seconds (5 minutes) if at least 100 changes were performed\n# * After 60 seconds if at least 10000 changes were performed\n#\n# You can set these explicitly by uncommenting the following line.\n#\n# save 3600 1 300 100 60 10000\n\n# By default Redis will stop accepting writes if RDB snapshots are enabled\n# (at least one save point) and the latest background save failed.\n# This will make the user aware (in a hard way) that data is not persisting\n# on disk properly, otherwise chances are that no one will notice and some\n# disaster will happen.\n#\n# If the background saving process will start working again Redis will\n# automatically allow writes again.\n#\n# However if you have setup your proper monitoring of the Redis server\n# and persistence, you may want to disable this feature so that Redis will\n# continue to work as usual even if there are problems with disk,\n# permissions, and so forth.\nstop-writes-on-bgsave-error yes\n\n# Compress string objects using LZF when dump .rdb databases?\n# By default compression is enabled as it's almost always a win.\n# If you want to save some CPU in the saving child set it to 'no' but\n# the dataset will likely be bigger if you have compressible values or keys.\nrdbcompression yes\n\n# Since version 5 of RDB a CRC64 checksum is placed at the end of the file.\n# This makes the format more resistant to corruption but there is a performance\n# hit to pay (around 10%) when saving and loading RDB files, so you can disable it\n# for maximum performances.\n#\n# RDB files created with checksum disabled have a checksum of zero that will\n# tell the loading code to skip the check.\nrdbchecksum yes\n\n# Enables or disables full sanitization checks for ziplist and listpack etc when\n# loading an RDB or RESTORE payload. This reduces the chances of a assertion or\n# crash later on while processing commands.\n# Options:\n# no - Never perform full sanitization\n# yes - Always perform full sanitization\n# clients - Perform full sanitization only for user connections.\n# Excludes: RDB files, RESTORE commands received from the master\n# connection, and client connections which have the\n# skip-sanitize-payload ACL flag.\n# The default should be 'clients' but since it currently affects cluster\n# resharding via MIGRATE, it is temporarily set to 'no' by default.\n#\n# sanitize-dump-payload no\n\n# The filename where to dump the DB\ndbfilename dump.rdb\n\n# Remove RDB files used by replication in instances without persistence\n# enabled. By default this option is disabled, however there are environments\n# where for regulations or other security concerns, RDB files persisted on\n# disk by masters in order to feed replicas, or stored on disk by replicas\n# in order to load them for the initial synchronization, should be deleted\n# ASAP. Note that this option ONLY WORKS in instances that have both AOF\n# and RDB persistence disabled, otherwise is completely ignored.\n#\n# An alternative (and sometimes better) way to obtain the same effect is\n# to use diskless replication on both master and replicas instances. However\n# in the case of replicas, diskless is not always an option.\nrdb-del-sync-files no\n\n# The working directory.\n#\n# The DB will be written inside this directory, with the filename specified\n# above using the 'dbfilename' configuration directive.\n#\n# The Append Only File will also be created inside this directory.\n#\n# Note that you must specify a directory here, not a file name.\ndir ./\n\n################################# REPLICATION #################################\n\n# Master-Replica replication. Use replicaof to make a Redis instance a copy of\n# another Redis server. A few things to understand ASAP about Redis replication.\n#\n# +------------------+ +---------------+\n# | Master | ---> | Replica |\n# | (receive writes) | | (exact copy) |\n# +------------------+ +---------------+\n#\n# 1) Redis replication is asynchronous, but you can configure a master to\n# stop accepting writes if it appears to be not connected with at least\n# a given number of replicas.\n# 2) Redis replicas are able to perform a partial resynchronization with the\n# master if the replication link is lost for a relatively small amount of\n# time. You may want to configure the replication backlog size (see the next\n# sections of this file) with a sensible value depending on your needs.\n# 3) Replication is automatic and does not need user intervention. After a\n# network partition replicas automatically try to reconnect to masters\n# and resynchronize with them.\n#\n# replicaof \n\n# If the master is password protected (using the \"requirepass\" configuration\n# directive below) it is possible to tell the replica to authenticate before\n# starting the replication synchronization process, otherwise the master will\n# refuse the replica request.\n#\n# masterauth \n#\n# However this is not enough if you are using Redis ACLs (for Redis version\n# 6 or greater), and the default user is not capable of running the PSYNC\n# command and/or other commands needed for replication. In this case it's\n# better to configure a special user to use with replication, and specify the\n# masteruser configuration as such:\n#\n# masteruser \n#\n# When masteruser is specified, the replica will authenticate against its\n# master using the new AUTH form: AUTH .\n\n# When a replica loses its connection with the master, or when the replication\n# is still in progress, the replica can act in two different ways:\n#\n# 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will\n# still reply to client requests, possibly with out of date data, or the\n# data set may just be empty if this is the first synchronization.\n#\n# 2) If replica-serve-stale-data is set to 'no' the replica will reply with error\n# \"MASTERDOWN Link with MASTER is down and replica-serve-stale-data is set to 'no'\"\n# to all data access commands, excluding commands such as:\n# INFO, REPLICAOF, AUTH, SHUTDOWN, REPLCONF, ROLE, CONFIG, SUBSCRIBE,\n# UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB, COMMAND, POST,\n# HOST and LATENCY.\n#\nreplica-serve-stale-data yes\n\n# You can configure a replica instance to accept writes or not. Writing against\n# a replica instance may be useful to store some ephemeral data (because data\n# written on a replica will be easily deleted after resync with the master) but\n# may also cause problems if clients are writing to it because of a\n# misconfiguration.\n#\n# Since Redis 2.6 by default replicas are read-only.\n#\n# Note: read only replicas are not designed to be exposed to untrusted clients\n# on the internet. It's just a protection layer against misuse of the instance.\n# Still a read only replica exports by default all the administrative commands\n# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve\n# security of read only replicas using 'rename-command' to shadow all the\n# administrative / dangerous commands.\nreplica-read-only yes\n\n# Replication SYNC strategy: disk or socket.\n#\n# New replicas and reconnecting replicas that are not able to continue the\n# replication process just receiving differences, need to do what is called a\n# \"full synchronization\". An RDB file is transmitted from the master to the\n# replicas.\n#\n# The transmission can happen in two different ways:\n#\n# 1) Disk-backed: The Redis master creates a new process that writes the RDB\n# file on disk. Later the file is transferred by the parent\n# process to the replicas incrementally.\n# 2) Diskless: The Redis master creates a new process that directly writes the\n# RDB file to replica sockets, without touching the disk at all.\n#\n# With disk-backed replication, while the RDB file is generated, more replicas\n# can be queued and served with the RDB file as soon as the current child\n# producing the RDB file finishes its work. With diskless replication instead\n# once the transfer starts, new replicas arriving will be queued and a new\n# transfer will start when the current one terminates.\n#\n# When diskless replication is used, the master waits a configurable amount of\n# time (in seconds) before starting the transfer in the hope that multiple\n# replicas will arrive and the transfer can be parallelized.\n#\n# With slow disks and fast (large bandwidth) networks, diskless replication\n# works better.\nrepl-diskless-sync yes\n\n# When diskless replication is enabled, it is possible to configure the delay\n# the server waits in order to spawn the child that transfers the RDB via socket\n# to the replicas.\n#\n# This is important since once the transfer starts, it is not possible to serve\n# new replicas arriving, that will be queued for the next RDB transfer, so the\n# server waits a delay in order to let more replicas arrive.\n#\n# The delay is specified in seconds, and by default is 5 seconds. To disable\n# it entirely just set it to 0 seconds and the transfer will start ASAP.\nrepl-diskless-sync-delay 5\n\n# When diskless replication is enabled with a delay, it is possible to let\n# the replication start before the maximum delay is reached if the maximum\n# number of replicas expected have connected. Default of 0 means that the\n# maximum is not defined and Redis will wait the full delay.\nrepl-diskless-sync-max-replicas 0\n\n# -----------------------------------------------------------------------------\n# WARNING: Since in this setup the replica does not immediately store an RDB on\n# disk, it may cause data loss during failovers. RDB diskless load + Redis\n# modules not handling I/O reads may cause Redis to abort in case of I/O errors\n# during the initial synchronization stage with the master.\n# -----------------------------------------------------------------------------\n#\n# Replica can load the RDB it reads from the replication link directly from the\n# socket, or store the RDB to a file and read that file after it was completely\n# received from the master.\n#\n# In many cases the disk is slower than the network, and storing and loading\n# the RDB file may increase replication time (and even increase the master's\n# Copy on Write memory and replica buffers).\n# However, when parsing the RDB file directly from the socket, in order to avoid\n# data loss it's only safe to flush the current dataset when the new dataset is\n# fully loaded in memory, resulting in higher memory usage.\n# For this reason we have the following options:\n#\n# \"disabled\" - Don't use diskless load (store the rdb file to the disk first)\n# \"swapdb\" - Keep current db contents in RAM while parsing the data directly\n# from the socket. Replicas in this mode can keep serving current\n# dataset while replication is in progress, except for cases where\n# they can't recognize master as having a data set from same\n# replication history.\n# Note that this requires sufficient memory, if you don't have it,\n# you risk an OOM kill.\n# \"flushdb\" - Always flush the entire dataset before diskless load.\n# Note that if the diskless load fails, the replica will lose all\n# existing data.\n# \"on-empty-db\" - Use diskless load only when current dataset is empty. This is \n# safer and avoid having old and new dataset loaded side by side\n# during replication.\nrepl-diskless-load disabled\n\n# Master send PINGs to its replicas in a predefined interval. It's possible to\n# change this interval with the repl-ping-replica-period option. The default\n# value is 10 seconds.\n#\n# repl-ping-replica-period 10\n\n# The following option sets the replication timeout for:\n#\n# 1) Bulk transfer I/O during SYNC, from the point of view of replica.\n# 2) Master timeout from the point of view of replicas (data, pings).\n# 3) Replica timeout from the point of view of masters (REPLCONF ACK pings).\n#\n# It is important to make sure that this value is greater than the value\n# specified for repl-ping-replica-period otherwise a timeout will be detected\n# every time there is low traffic between the master and the replica. The default\n# value is 60 seconds.\n#\n# repl-timeout 60\n\n# Disable TCP_NODELAY on the replica socket after SYNC?\n#\n# If you select \"yes\" Redis will use a smaller number of TCP packets and\n# less bandwidth to send data to replicas. But this can add a delay for\n# the data to appear on the replica side, up to 40 milliseconds with\n# Linux kernels using a default configuration.\n#\n# If you select \"no\" the delay for data to appear on the replica side will\n# be reduced but more bandwidth will be used for replication.\n#\n# By default we optimize for low latency, but in very high traffic conditions\n# or when the master and replicas are many hops away, turning this to \"yes\" may\n# be a good idea.\nrepl-disable-tcp-nodelay no\n\n# Set the replication backlog size. The backlog is a buffer that accumulates\n# replica data when replicas are disconnected for some time, so that when a\n# replica wants to reconnect again, often a full resync is not needed, but a\n# partial resync is enough, just passing the portion of data the replica\n# missed while disconnected.\n#\n# The bigger the replication backlog, the longer the replica can endure the\n# disconnect and later be able to perform a partial resynchronization.\n#\n# The backlog is only allocated if there is at least one replica connected.\n#\n# repl-backlog-size 1mb\n\n# After a master has no connected replicas for some time, the backlog will be\n# freed. The following option configures the amount of seconds that need to\n# elapse, starting from the time the last replica disconnected, for the backlog\n# buffer to be freed.\n#\n# Note that replicas never free the backlog for timeout, since they may be\n# promoted to masters later, and should be able to correctly \"partially\n# resynchronize\" with other replicas: hence they should always accumulate backlog.\n#\n# A value of 0 means to never release the backlog.\n#\n# repl-backlog-ttl 3600\n\n# During a fullsync, the master may decide to send both the RDB file and the\n# replication stream to the replica in parallel. This approach shifts the\n# responsibility of buffering the replication stream to the replica during the\n# fullsync process. The replica accumulates the replication stream data until\n# the RDB file is fully loaded. Once the RDB delivery is completed and\n# successfully loaded, the replica begins processing and applying the\n# accumulated replication data to the db. The configuration below controls how\n# much replication data the replica can accumulate during a fullsync.\n#\n# When the replica reaches this limit, it will stop accumulating further data.\n# At this point, additional data accumulation may occur on the master side\n# depending on the 'client-output-buffer-limit ' config of master.\n#\n# A value of 0 means replica inherits hard limit of\n# 'client-output-buffer-limit ' config to limit accumulation size.\n#\n# replica-full-sync-buffer-limit 0\n\n# The replica priority is an integer number published by Redis in the INFO\n# output. It is used by Redis Sentinel in order to select a replica to promote\n# into a master if the master is no longer working correctly.\n#\n# A replica with a low priority number is considered better for promotion, so\n# for instance if there are three replicas with priority 10, 100, 25 Sentinel\n# will pick the one with priority 10, that is the lowest.\n#\n# However a special priority of 0 marks the replica as not able to perform the\n# role of master, so a replica with priority of 0 will never be selected by\n# Redis Sentinel for promotion.\n#\n# By default the priority is 100.\nreplica-priority 100\n\n# The propagation error behavior controls how Redis will behave when it is\n# unable to handle a command being processed in the replication stream from a master\n# or processed while reading from an AOF file. Errors that occur during propagation\n# are unexpected, and can cause data inconsistency. However, there are edge cases\n# in earlier versions of Redis where it was possible for the server to replicate or persist\n# commands that would fail on future versions. For this reason the default behavior\n# is to ignore such errors and continue processing commands.\n#\n# If an application wants to ensure there is no data divergence, this configuration\n# should be set to 'panic' instead. The value can also be set to 'panic-on-replicas'\n# to only panic when a replica encounters an error on the replication stream. One of\n# these two panic values will become the default value in the future once there are\n# sufficient safety mechanisms in place to prevent false positive crashes.\n#\n# propagation-error-behavior ignore\n\n# Replica ignore disk write errors controls the behavior of a replica when it is\n# unable to persist a write command received from its master to disk. By default,\n# this configuration is set to 'no' and will crash the replica in this condition.\n# It is not recommended to change this default, however in order to be compatible\n# with older versions of Redis this config can be toggled to 'yes' which will just\n# log a warning and execute the write command it got from the master.\n#\n# replica-ignore-disk-write-errors no\n\n# -----------------------------------------------------------------------------\n# By default, Redis Sentinel includes all replicas in its reports. A replica\n# can be excluded from Redis Sentinel's announcements. An unannounced replica\n# will be ignored by the 'sentinel replicas ' command and won't be\n# exposed to Redis Sentinel's clients.\n#\n# This option does not change the behavior of replica-priority. Even with\n# replica-announced set to 'no', the replica can be promoted to master. To\n# prevent this behavior, set replica-priority to 0.\n#\n# replica-announced yes\n\n# It is possible for a master to stop accepting writes if there are less than\n# N replicas connected, having a lag less or equal than M seconds.\n#\n# The N replicas need to be in \"online\" state.\n#\n# The lag in seconds, that must be <= the specified value, is calculated from\n# the last ping received from the replica, that is usually sent every second.\n#\n# This option does not GUARANTEE that N replicas will accept the write, but\n# will limit the window of exposure for lost writes in case not enough replicas\n# are available, to the specified number of seconds.\n#\n# For example to require at least 3 replicas with a lag <= 10 seconds use:\n#\n# min-replicas-to-write 3\n# min-replicas-max-lag 10\n#\n# Setting one or the other to 0 disables the feature.\n#\n# By default min-replicas-to-write is set to 0 (feature disabled) and\n# min-replicas-max-lag is set to 10.\n\n# A Redis master is able to list the address and port of the attached\n# replicas in different ways. For example the \"INFO replication\" section\n# offers this information, which is used, among other tools, by\n# Redis Sentinel in order to discover replica instances.\n# Another place where this info is available is in the output of the\n# \"ROLE\" command of a master.\n#\n# The listed IP address and port normally reported by a replica is\n# obtained in the following way:\n#\n# IP: The address is auto detected by checking the peer address\n# of the socket used by the replica to connect with the master.\n#\n# Port: The port is communicated by the replica during the replication\n# handshake, and is normally the port that the replica is using to\n# listen for connections.\n#\n# However when port forwarding or Network Address Translation (NAT) is\n# used, the replica may actually be reachable via different IP and port\n# pairs. The following two options can be used by a replica in order to\n# report to its master a specific set of IP and port, so that both INFO\n# and ROLE will report those values.\n#\n# There is no need to use both the options if you need to override just\n# the port or the IP address.\n#\n# replica-announce-ip 5.5.5.5\n# replica-announce-port 1234\n\n############################### KEYS TRACKING #################################\n\n# Redis implements server assisted support for client side caching of values.\n# This is implemented using an invalidation table that remembers, using\n# a radix key indexed by key name, what clients have which keys. In turn\n# this is used in order to send invalidation messages to clients. Please\n# check this page to understand more about the feature:\n#\n# https://redis.io/docs/latest/develop/use/client-side-caching/\n#\n# When tracking is enabled for a client, all the read only queries are assumed\n# to be cached: this will force Redis to store information in the invalidation\n# table. When keys are modified, such information is flushed away, and\n# invalidation messages are sent to the clients. However if the workload is\n# heavily dominated by reads, Redis could use more and more memory in order\n# to track the keys fetched by many clients.\n#\n# For this reason it is possible to configure a maximum fill value for the\n# invalidation table. By default it is set to 1M of keys, and once this limit\n# is reached, Redis will start to evict keys in the invalidation table\n# even if they were not modified, just to reclaim memory: this will in turn\n# force the clients to invalidate the cached values. Basically the table\n# maximum size is a trade off between the memory you want to spend server\n# side to track information about who cached what, and the ability of clients\n# to retain cached objects in memory.\n#\n# If you set the value to 0, it means there are no limits, and Redis will\n# retain as many keys as needed in the invalidation table.\n# In the \"stats\" INFO section, you can find information about the number of\n# keys in the invalidation table at every given moment.\n#\n# Note: when key tracking is used in broadcasting mode, no memory is used\n# in the server side so this setting is useless.\n#\n# tracking-table-max-keys 1000000\n\n################################## SECURITY ###################################\n\n# Warning: since Redis is pretty fast, an outside user can try up to\n# 1 million passwords per second against a modern box. This means that you\n# should use very strong passwords, otherwise they will be very easy to break.\n# Note that because the password is really a shared secret between the client\n# and the server, and should not be memorized by any human, the password\n# can be easily a long string from /dev/urandom or whatever, so by using a\n# long and unguessable password no brute force attack will be possible.\n\n# Redis ACL users are defined in the following format:\n#\n# user ... acl rules ...\n#\n# For example:\n#\n# user worker +@list +@connection ~jobs:* on >ffa9203c493aa99\n#\n# The special username \"default\" is used for new connections. If this user\n# has the \"nopass\" rule, then new connections will be immediately authenticated\n# as the \"default\" user without the need of any password provided via the\n# AUTH command. Otherwise if the \"default\" user is not flagged with \"nopass\"\n# the connections will start in not authenticated state, and will require\n# AUTH (or the HELLO command AUTH option) in order to be authenticated and\n# start to work.\n#\n# The ACL rules that describe what a user can do are the following:\n#\n# on Enable the user: it is possible to authenticate as this user.\n# off Disable the user: it's no longer possible to authenticate\n# with this user, however the already authenticated connections\n# will still work.\n# skip-sanitize-payload RESTORE dump-payload sanitization is skipped.\n# sanitize-payload RESTORE dump-payload is sanitized (default).\n# + Allow the execution of that command.\n# May be used with `|` for allowing subcommands (e.g \"+config|get\")\n# - Disallow the execution of that command.\n# May be used with `|` for blocking subcommands (e.g \"-config|set\")\n# +@ Allow the execution of all the commands in such category\n# with valid categories are like @admin, @set, @sortedset, ...\n# and so forth, see the full list in the server.c file where\n# the Redis command table is described and defined.\n# The special category @all means all the commands, but currently\n# present in the server, and that will be loaded in the future\n# via modules.\n# +|first-arg Allow a specific first argument of an otherwise\n# disabled command. It is only supported on commands with\n# no sub-commands, and is not allowed as negative form\n# like -SELECT|1, only additive starting with \"+\". This\n# feature is deprecated and may be removed in the future.\n# allcommands Alias for +@all. Note that it implies the ability to execute\n# all the future commands loaded via the modules system.\n# nocommands Alias for -@all.\n# ~ Add a pattern of keys that can be mentioned as part of\n# commands. For instance ~* allows all the keys. The pattern\n# is a glob-style pattern like the one of KEYS.\n# It is possible to specify multiple patterns.\n# %R~ Add key read pattern that specifies which keys can be read \n# from.\n# %W~ Add key write pattern that specifies which keys can be\n# written to. \n# allkeys Alias for ~*\n# resetkeys Flush the list of allowed keys patterns.\n# & Add a glob-style pattern of Pub/Sub channels that can be\n# accessed by the user. It is possible to specify multiple channel\n# patterns.\n# allchannels Alias for &*\n# resetchannels Flush the list of allowed channel patterns.\n# > Add this password to the list of valid password for the user.\n# For example >mypass will add \"mypass\" to the list.\n# This directive clears the \"nopass\" flag (see later).\n# < Remove this password from the list of valid passwords.\n# nopass All the set passwords of the user are removed, and the user\n# is flagged as requiring no password: it means that every\n# password will work against this user. If this directive is\n# used for the default user, every new connection will be\n# immediately authenticated with the default user without\n# any explicit AUTH command required. Note that the \"resetpass\"\n# directive will clear this condition.\n# resetpass Flush the list of allowed passwords. Moreover removes the\n# \"nopass\" status. After \"resetpass\" the user has no associated\n# passwords and there is no way to authenticate without adding\n# some password (or setting it as \"nopass\" later).\n# reset Performs the following actions: resetpass, resetkeys, resetchannels,\n# allchannels (if acl-pubsub-default is set), off, clearselectors, -@all.\n# The user returns to the same state it has immediately after its creation.\n# () Create a new selector with the options specified within the\n# parentheses and attach it to the user. Each option should be \n# space separated. The first character must be ( and the last \n# character must be ).\n# clearselectors Remove all of the currently attached selectors. \n# Note this does not change the \"root\" user permissions,\n# which are the permissions directly applied onto the\n# user (outside the parentheses).\n#\n# ACL rules can be specified in any order: for instance you can start with\n# passwords, then flags, or key patterns. However note that the additive\n# and subtractive rules will CHANGE MEANING depending on the ordering.\n# For instance see the following example:\n#\n# user alice on +@all -DEBUG ~* >somepassword\n#\n# This will allow \"alice\" to use all the commands with the exception of the\n# DEBUG command, since +@all added all the commands to the set of the commands\n# alice can use, and later DEBUG was removed. However if we invert the order\n# of two ACL rules the result will be different:\n#\n# user alice on -DEBUG +@all ~* >somepassword\n#\n# Now DEBUG was removed when alice had yet no commands in the set of allowed\n# commands, later all the commands are added, so the user will be able to\n# execute everything.\n#\n# Basically ACL rules are processed left-to-right.\n#\n# The following is a list of command categories and their meanings:\n# * keyspace - Writing or reading from keys, databases, or their metadata \n# in a type agnostic way. Includes DEL, RESTORE, DUMP, RENAME, EXISTS, DBSIZE,\n# KEYS, EXPIRE, TTL, FLUSHALL, etc. Commands that may modify the keyspace,\n# key or metadata will also have `write` category. Commands that only read\n# the keyspace, key or metadata will have the `read` category.\n# * read - Reading from keys (values or metadata). Note that commands that don't\n# interact with keys, will not have either `read` or `write`.\n# * write - Writing to keys (values or metadata)\n# * admin - Administrative commands. Normal applications will never need to use\n# these. Includes REPLICAOF, CONFIG, DEBUG, SAVE, MONITOR, ACL, SHUTDOWN, etc.\n# * dangerous - Potentially dangerous (each should be considered with care for\n# various reasons). This includes FLUSHALL, MIGRATE, RESTORE, SORT, KEYS,\n# CLIENT, DEBUG, INFO, CONFIG, SAVE, REPLICAOF, etc.\n# * connection - Commands affecting the connection or other connections.\n# This includes AUTH, SELECT, COMMAND, CLIENT, ECHO, PING, etc.\n# * blocking - Potentially blocking the connection until released by another\n# command.\n# * fast - Fast O(1) commands. May loop on the number of arguments, but not the\n# number of elements in the key.\n# * slow - All commands that are not Fast.\n# * pubsub - PUBLISH / SUBSCRIBE related\n# * transaction - WATCH / MULTI / EXEC related commands.\n# * scripting - Scripting related.\n# * set - Data type: sets related.\n# * sortedset - Data type: zsets related.\n# * list - Data type: lists related.\n# * hash - Data type: hashes related.\n# * string - Data type: strings related.\n# * bitmap - Data type: bitmaps related.\n# * hyperloglog - Data type: hyperloglog related.\n# * geo - Data type: geo related.\n# * stream - Data type: streams related.\n#\n# For more information about ACL configuration please refer to\n# the Redis web site at https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/\n\n# ACL LOG\n#\n# The ACL Log tracks failed commands and authentication events associated\n# with ACLs. The ACL Log is useful to troubleshoot failed commands blocked\n# by ACLs. The ACL Log is stored in memory. You can reclaim memory with\n# ACL LOG RESET. Define the maximum entry length of the ACL Log below.\nacllog-max-len 128\n\n# Using an external ACL file\n#\n# Instead of configuring users here in this file, it is possible to use\n# a stand-alone file just listing users. The two methods cannot be mixed:\n# if you configure users here and at the same time you activate the external\n# ACL file, the server will refuse to start.\n#\n# The format of the external ACL user file is exactly the same as the\n# format that is used inside redis.conf to describe users.\n#\n# aclfile /etc/redis/users.acl\n\n# IMPORTANT NOTE: starting with Redis 6 \"requirepass\" is just a compatibility\n# layer on top of the new ACL system. The option effect will be just setting\n# the password for the default user. Clients will still authenticate using\n# AUTH as usually, or more explicitly with AUTH default \n# if they follow the new protocol: both will work.\n#\n# The requirepass is not compatible with aclfile option and the ACL LOAD\n# command, these will cause requirepass to be ignored.\n#\n# requirepass foobared\n\n# New users are initialized with restrictive permissions by default, via the\n# equivalent of this ACL rule 'off resetkeys -@all'. Starting with Redis 6.2, it\n# is possible to manage access to Pub/Sub channels with ACL rules as well. The\n# default Pub/Sub channels permission if new users is controlled by the\n# acl-pubsub-default configuration directive, which accepts one of these values:\n#\n# allchannels: grants access to all Pub/Sub channels\n# resetchannels: revokes access to all Pub/Sub channels\n#\n# From Redis 7.0, acl-pubsub-default defaults to 'resetchannels' permission.\n#\n# acl-pubsub-default resetchannels\n\n# Command renaming (DEPRECATED).\n#\n# ------------------------------------------------------------------------\n# WARNING: avoid using this option if possible. Instead use ACLs to remove\n# commands from the default user, and put them only in some admin user you\n# create for administrative purposes.\n# ------------------------------------------------------------------------\n#\n# It is possible to change the name of dangerous commands in a shared\n# environment. For instance the CONFIG command may be renamed into something\n# hard to guess so that it will still be available for internal-use tools\n# but not available for general clients.\n#\n# Example:\n#\n# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52\n#\n# It is also possible to completely kill a command by renaming it into\n# an empty string:\n#\n# rename-command CONFIG \"\"\n#\n# Please note that changing the name of commands that are logged into the\n# AOF file or transmitted to replicas may cause problems.\n\n################################### CLIENTS ####################################\n\n# Set the max number of connected clients at the same time. By default\n# this limit is set to 10000 clients, however if the Redis server is not\n# able to configure the process file limit to allow for the specified limit\n# the max number of allowed clients is set to the current file limit\n# minus 32 (as Redis reserves a few file descriptors for internal uses).\n#\n# Once the limit is reached Redis will close all the new connections sending\n# an error 'max number of clients reached'.\n#\n# IMPORTANT: When Redis Cluster is used, the max number of connections is also\n# shared with the cluster bus: every node in the cluster will use two\n# connections, one incoming and another outgoing. It is important to size the\n# limit accordingly in case of very large clusters.\n#\n# maxclients 10000\n\n############################## MEMORY MANAGEMENT ################################\n\n# Set a memory usage limit to the specified amount of bytes.\n# When the memory limit is reached Redis will try to remove keys\n# according to the eviction policy selected (see maxmemory-policy).\n#\n# If Redis can't remove keys according to the policy, or if the policy is\n# set to 'noeviction', Redis will start to reply with errors to commands\n# that would use more memory, like SET, LPUSH, and so on, and will continue\n# to reply to read-only commands like GET.\n#\n# This option is usually useful when using Redis as an LRU or LFU cache, or to\n# set a hard memory limit for an instance (using the 'noeviction' policy).\n#\n# WARNING: If you have replicas attached to an instance with maxmemory on,\n# the size of the output buffers needed to feed the replicas are subtracted\n# from the used memory count, so that network problems / resyncs will\n# not trigger a loop where keys are evicted, and in turn the output\n# buffer of replicas is full with DELs of keys evicted triggering the deletion\n# of more keys, and so forth until the database is completely emptied.\n#\n# In short... if you have replicas attached it is suggested that you set a lower\n# limit for maxmemory so that there is some free RAM on the system for replica\n# output buffers (but this is not needed if the policy is 'noeviction').\n#\n# maxmemory \n\n# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory\n# is reached. You can select one from the following behaviors:\n#\n# volatile-lru -> Evict using approximated LRU, only keys with an expire set.\n# allkeys-lru -> Evict any key using approximated LRU.\n# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.\n# allkeys-lfu -> Evict any key using approximated LFU.\n# volatile-lrm -> Evict using approximated LRM, only keys with an expire set.\n# allkeys-lrm -> Evict any key using approximated LRM.\n# volatile-random -> Remove a random key having an expire set.\n# allkeys-random -> Remove a random key, any key.\n# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)\n# noeviction -> Don't evict anything, just return an error on write operations.\n#\n# LRU means Least Recently Used\n# LFU means Least Frequently Used\n# LRM means Least Recently Modified (only write operations update the timestamp)\n#\n# LRU, LFU, LRM and volatile-ttl are implemented using approximated\n# randomized algorithms.\n#\n# LRU vs LRM: Both use similar eviction logic based on access time, but:\n# - LRU updates the timestamp on both read (GET) and write (SET) operations\n# - LRM only updates the timestamp on write (SET, INCR, etc.) operations\n# This makes LRM useful when you want to evict keys that haven't been updated\n# recently, regardless of how often they are read.\n#\n# Note: with any of the above policies, when there are no suitable keys for\n# eviction, Redis will return an error on write operations that require\n# more memory. These are usually commands that create new keys, add data or\n# modify existing keys. A few examples are: SET, INCR, HSET, LPUSH, SUNIONSTORE,\n# SORT (due to the STORE argument), and EXEC (if the transaction includes any\n# command that requires memory).\n#\n# The default is:\n#\n# maxmemory-policy noeviction\n\n# LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated\n# algorithms (in order to save memory), so you can tune it for speed or\n# accuracy. By default Redis will check five keys and pick the one that was\n# used least recently, you can change the sample size using the following\n# configuration directive.\n#\n# The default of 5 produces good enough results. 10 Approximates very closely\n# true LRU but costs more CPU. 3 is faster but not very accurate. The maximum\n# value that can be set is 64.\n#\n# maxmemory-samples 5\n\n# Eviction processing is designed to function well with the default setting.\n# If there is an unusually large amount of write traffic, this value may need to\n# be increased. Decreasing this value may reduce latency at the risk of\n# eviction processing effectiveness\n# 0 = minimum latency, 10 = default, 100 = process without regard to latency\n#\n# maxmemory-eviction-tenacity 10\n\n# Starting from Redis 5, by default a replica will ignore its maxmemory setting\n# (unless it is promoted to master after a failover or manually). It means\n# that the eviction of keys will be just handled by the master, sending the\n# DEL commands to the replica as keys evict in the master side.\n#\n# This behavior ensures that masters and replicas stay consistent, and is usually\n# what you want, however if your replica is writable, or you want the replica\n# to have a different memory setting, and you are sure all the writes performed\n# to the replica are idempotent, then you may change this default (but be sure\n# to understand what you are doing).\n#\n# Note that since the replica by default does not evict, it may end using more\n# memory than the one set via maxmemory (there are certain buffers that may\n# be larger on the replica, or data structures may sometimes take more memory\n# and so forth). So make sure you monitor your replicas and make sure they\n# have enough memory to never hit a real out-of-memory condition before the\n# master hits the configured maxmemory setting.\n#\n# replica-ignore-maxmemory yes\n\n# Redis reclaims expired keys in two ways: upon access when those keys are\n# found to be expired, and also in background, in what is called the\n# \"active expire key\". The key space is slowly and interactively scanned\n# looking for expired keys to reclaim, so that it is possible to free memory\n# of keys that are expired and will never be accessed again in a short time.\n#\n# The default effort of the expire cycle will try to avoid having more than\n# ten percent of expired keys still in memory, and will try to avoid consuming\n# more than 25% of total memory and to add latency to the system. However\n# it is possible to increase the expire \"effort\" that is normally set to\n# \"1\", to a greater value, up to the value \"10\". At its maximum value the\n# system will use more CPU, longer cycles (and technically may introduce\n# more latency), and will tolerate less already expired keys still present\n# in the system. It's a tradeoff between memory, CPU and latency.\n#\n# active-expire-effort 1\n\n############################# LAZY FREEING ####################################\n\n# Redis has two primitives to delete keys. One is called DEL and is a blocking\n# deletion of the object. It means that the server stops processing new commands\n# in order to reclaim all the memory associated with an object in a synchronous\n# way. If the key deleted is associated with a small object, the time needed\n# in order to execute the DEL command is very small and comparable to most other\n# O(1) or O(log_N) commands in Redis. However if the key is associated with an\n# aggregated value containing millions of elements, the server can block for\n# a long time (even seconds) in order to complete the operation.\n#\n# For the above reasons Redis also offers non blocking deletion primitives\n# such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and\n# FLUSHDB commands, in order to reclaim memory in background. Those commands\n# are executed in constant time. Another thread will incrementally free the\n# object in the background as fast as possible.\n#\n# DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.\n# It's up to the design of the application to understand when it is a good\n# idea to use one or the other. However the Redis server sometimes has to\n# delete keys or flush the whole database as a side effect of other operations.\n# Specifically Redis deletes objects independently of a user call in the\n# following scenarios:\n#\n# 1) On eviction, because of the maxmemory and maxmemory policy configurations,\n# in order to make room for new data, without going over the specified\n# memory limit.\n# 2) Because of expire: when a key with an associated time to live (see the\n# EXPIRE command) must be deleted from memory.\n# 3) Because of a side effect of a command that stores data on a key that may\n# already exist. For example the RENAME command may delete the old key\n# content when it is replaced with another one. Similarly SUNIONSTORE\n# or SORT with STORE option may delete existing keys. The SET command\n# itself removes any old content of the specified key in order to replace\n# it with the specified string.\n# 4) During replication, when a replica performs a full resynchronization with\n# its master, the content of the whole database is removed in order to\n# load the RDB file just transferred.\n#\n# In all the above cases the default is to delete objects in a blocking way,\n# like if DEL was called. However you can configure each case specifically\n# in order to instead release memory in a non-blocking way like if UNLINK\n# was called, using the following configuration directives.\n\nlazyfree-lazy-eviction no\nlazyfree-lazy-expire no\nlazyfree-lazy-server-del no\nreplica-lazy-flush no\n\n# It is also possible, for the case when to replace the user code DEL calls\n# with UNLINK calls is not easy, to modify the default behavior of the DEL\n# command to act exactly like UNLINK, using the following configuration\n# directive:\n\nlazyfree-lazy-user-del no\n\n# FLUSHDB, FLUSHALL, SCRIPT FLUSH and FUNCTION FLUSH support both asynchronous and synchronous\n# deletion, which can be controlled by passing the [SYNC|ASYNC] flags into the\n# commands. When neither flag is passed, this directive will be used to determine\n# if the data should be deleted asynchronously.\n\nlazyfree-lazy-user-flush no\n\n################################ THREADED I/O #################################\n\n# Redis is mostly single threaded, however there are certain threaded\n# operations such as UNLINK, slow I/O accesses and other things that are\n# performed on side threads.\n#\n# Now it is also possible to handle Redis clients socket reads and writes\n# in different I/O threads. Since especially writing is so slow, normally\n# Redis users use pipelining in order to speed up the Redis performances per\n# core, and spawn multiple instances in order to scale more. Using I/O\n# threads it is possible to easily speedup several times Redis without resorting\n# to pipelining nor sharding of the instance.\n#\n# By default threading is disabled, we suggest enabling it only in machines\n# that have at least 4 or more cores, leaving at least one spare core.\n# We also recommend using threaded I/O only if you actually have performance\n# problems, with Redis instances being able to use a quite big percentage of\n# CPU time, otherwise there is no point in using this feature.\n#\n# So for instance if you have a four cores boxes, try to use 3 I/O\n# threads, if you have a 8 cores, try to use 7 threads. In order to\n# enable I/O threads use the following configuration directive:\n#\n# io-threads 4\n#\n# Setting io-threads to 1 will just use the main thread as usual.\n# When I/O threads are enabled, we not only use threads for writes, that\n# is to thread the write(2) syscall and transfer the client buffers to the\n# socket, but also use threads for reads and protocol parsing.\n#\n# NOTE: If you want to test the Redis speedup using redis-benchmark, make\n# sure you also run the benchmark itself in threaded mode, using the\n# --threads option to match the number of Redis threads, otherwise you'll not\n# be able to notice the improvements.\n\n############################ KERNEL OOM CONTROL ##############################\n\n# On Linux, it is possible to hint the kernel OOM killer on what processes\n# should be killed first when out of memory.\n#\n# Enabling this feature makes Redis actively control the oom_score_adj value\n# for all its processes, depending on their role. The default scores will\n# attempt to have background child processes killed before all others, and\n# replicas killed before masters.\n#\n# Redis supports these options:\n#\n# no: Don't make changes to oom-score-adj (default).\n# yes: Alias to \"relative\" see below.\n# absolute: Values in oom-score-adj-values are written as is to the kernel.\n# relative: Values are used relative to the initial value of oom_score_adj when\n# the server starts and are then clamped to a range of -1000 to 1000.\n# Because typically the initial value is 0, they will often match the\n# absolute values.\noom-score-adj no\n\n# When oom-score-adj is used, this directive controls the specific values used\n# for master, replica and background child processes. Values range -2000 to\n# 2000 (higher means more likely to be killed).\n#\n# Unprivileged processes (not root, and without CAP_SYS_RESOURCE capabilities)\n# can freely increase their value, but not decrease it below its initial\n# settings. This means that setting oom-score-adj to \"relative\" and setting the\n# oom-score-adj-values to positive values will always succeed.\noom-score-adj-values 0 200 800\n\n\n#################### KERNEL transparent hugepage CONTROL ######################\n\n# Usually the kernel Transparent Huge Pages control is set to \"madvise\" or\n# \"never\" by default (/sys/kernel/mm/transparent_hugepage/enabled), in which\n# case this config has no effect. On systems in which it is set to \"always\",\n# redis will attempt to disable it specifically for the redis process in order\n# to avoid latency problems specifically with fork(2) and CoW.\n# If for some reason you prefer to keep it enabled, you can set this config to\n# \"no\" and the kernel global to \"always\".\n\ndisable-thp yes\n\n############################## APPEND ONLY MODE ###############################\n\n# By default Redis asynchronously dumps the dataset on disk. This mode is\n# good enough in many applications, but an issue with the Redis process or\n# a power outage may result into a few minutes of writes lost (depending on\n# the configured save points).\n#\n# The Append Only File is an alternative persistence mode that provides\n# much better durability. For instance using the default data fsync policy\n# (see later in the config file) Redis can lose just one second of writes in a\n# dramatic event like a server power outage, or a single write if something\n# wrong with the Redis process itself happens, but the operating system is\n# still running correctly.\n#\n# AOF and RDB persistence can be enabled at the same time without problems.\n# If the AOF is enabled on startup Redis will load the AOF, that is the file\n# with the better durability guarantees.\n#\n# Note that changing this value in a config file of an existing database and\n# restarting the server can lead to data loss. A conversion needs to be done\n# by setting it via CONFIG command on a live server first.\n#\n# Please check https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/ for more information.\n\nappendonly no\n\n# The base name of the append only file.\n#\n# Redis 7 and newer use a set of append-only files to persist the dataset\n# and changes applied to it. There are two basic types of files in use:\n#\n# - Base files, which are a snapshot representing the complete state of the\n# dataset at the time the file was created. Base files can be either in\n# the form of RDB (binary serialized) or AOF (textual commands).\n# - Incremental files, which contain additional commands that were applied\n# to the dataset following the previous file.\n#\n# In addition, manifest files are used to track the files and the order in\n# which they were created and should be applied.\n#\n# Append-only file names are created by Redis following a specific pattern.\n# The file name's prefix is based on the 'appendfilename' configuration\n# parameter, followed by additional information about the sequence and type.\n#\n# For example, if appendfilename is set to appendonly.aof, the following file\n# names could be derived:\n#\n# - appendonly.aof.1.base.rdb as a base file.\n# - appendonly.aof.1.incr.aof, appendonly.aof.2.incr.aof as incremental files.\n# - appendonly.aof.manifest as a manifest file.\n\nappendfilename \"appendonly.aof\"\n\n# For convenience, Redis stores all persistent append-only files in a dedicated\n# directory. The name of the directory is determined by the appenddirname\n# configuration parameter.\n\nappenddirname \"appendonlydir\"\n\n# The fsync() call tells the Operating System to actually write data on disk\n# instead of waiting for more data in the output buffer. Some OS will really flush\n# data on disk, some other OS will just try to do it ASAP.\n#\n# Redis supports three different modes:\n#\n# no: don't fsync, just let the OS flush the data when it wants. Faster.\n# always: fsync after every write to the append only log. Slow, Safest.\n# everysec: fsync only one time every second. Compromise.\n#\n# The default is \"everysec\", as that's usually the right compromise between\n# speed and data safety. It's up to you to understand if you can relax this to\n# \"no\" that will let the operating system flush the output buffer when\n# it wants, for better performances (but if you can live with the idea of\n# some data loss consider the default persistence mode that's snapshotting),\n# or on the contrary, use \"always\" that's very slow but a bit safer than\n# everysec.\n#\n# More details please check the following article:\n# http://antirez.com/post/redis-persistence-demystified.html\n#\n# If unsure, use \"everysec\".\n\n# appendfsync always\nappendfsync everysec\n# appendfsync no\n\n# When the AOF fsync policy is set to always or everysec, and a background\n# saving process (a background save or AOF log background rewriting) is\n# performing a lot of I/O against the disk, in some Linux configurations\n# Redis may block too long on the fsync() call. Note that there is no fix for\n# this currently, as even performing fsync in a different thread will block\n# our synchronous write(2) call.\n#\n# In order to mitigate this problem it's possible to use the following option\n# that will prevent fsync() from being called in the main process while a\n# BGSAVE or BGREWRITEAOF is in progress.\n#\n# This means that while another child is saving, the durability of Redis is\n# the same as \"appendfsync no\". In practical terms, this means that it is\n# possible to lose up to 30 seconds of log in the worst scenario (with the\n# default Linux settings).\n#\n# If you have latency problems turn this to \"yes\". Otherwise leave it as\n# \"no\" that is the safest pick from the point of view of durability.\n\nno-appendfsync-on-rewrite no\n\n# Automatic rewrite of the append only file.\n# Redis is able to automatically rewrite the log file implicitly calling\n# BGREWRITEAOF when the AOF log size grows by the specified percentage.\n#\n# This is how it works: Redis remembers the size of the AOF file after the\n# latest rewrite (if no rewrite has happened since the restart, the size of\n# the AOF at startup is used).\n#\n# This base size is compared to the current size. If the current size is\n# bigger than the specified percentage, the rewrite is triggered. Also\n# you need to specify a minimal size for the AOF file to be rewritten, this\n# is useful to avoid rewriting the AOF file even if the percentage increase\n# is reached but it is still pretty small.\n#\n# Specify a percentage of zero in order to disable the automatic AOF\n# rewrite feature.\n\nauto-aof-rewrite-percentage 100\nauto-aof-rewrite-min-size 64mb\n\n# An AOF file may be found to be truncated at the end during the Redis\n# startup process, when the AOF data gets loaded back into memory.\n# This may happen when the system where Redis is running\n# crashes, especially when an ext4 filesystem is mounted without the\n# data=ordered option (however this can't happen when Redis itself\n# crashes or aborts but the operating system still works correctly).\n#\n# Redis can either exit with an error when this happens, or load as much\n# data as possible (the default now) and start if the AOF file is found\n# to be truncated at the end. The following option controls this behavior.\n#\n# If aof-load-truncated is set to yes, a truncated AOF file is loaded and\n# the Redis server starts emitting a log to inform the user of the event.\n# Otherwise if the option is set to no, the server aborts with an error\n# and refuses to start. When the option is set to no, the user requires\n# to fix the AOF file using the \"redis-check-aof\" utility before to restart\n# the server.\n#\n# Note that if the AOF file will be found to be corrupted in the middle\n# the server will still exit with an error. This option only applies when\n# Redis will try to read more data from the AOF file but not enough bytes\n# will be found.\naof-load-truncated yes\n\n# An AOF file may be found to be corrupted at the end during the Redis\n# startup process, when the AOF data gets loaded back into memory.\n# This may happen when the system where Redis is running crashes.\n#\n# The aof-load-corrupt-tail-max-size option allows Redis to automatically recover\n# from small amounts of corruption at the end of the AOF file by truncating the\n# corrupted portion and continuing with startup.\n#\n# Set this to the maximum number of bytes of corruption you're willing to\n# lose from the end of the AOF file. If the corrupted portion is larger than\n# this value, Redis will refuse to start and require manual intervention.\n#\n# Setting this to 0 (default) disables automatic recovery from corruption.\n# Redis will exit with an error and suggest using redis-check-aof --fix.\n#\n# Note: This is different from aof-load-truncated, which handles missing data\n# (unexpected EOF) rather than corrupted data (format errors).\n# aof-load-corrupt-tail-max-size 4096\n\n# Redis can create append-only base files in either RDB or AOF formats. Using\n# the RDB format is always faster and more efficient, and disabling it is only\n# supported for backward compatibility purposes.\naof-use-rdb-preamble yes\n\n# Redis supports recording timestamp annotations in the AOF to support restoring\n# the data from a specific point-in-time. However, using this capability changes\n# the AOF format in a way that may not be compatible with existing AOF parsers.\naof-timestamp-enabled no\n\n################################ SHUTDOWN #####################################\n\n# Maximum time to wait for replicas when shutting down, in seconds.\n#\n# During shut down, a grace period allows any lagging replicas to catch up with\n# the latest replication offset before the master exists. This period can\n# prevent data loss, especially for deployments without configured disk backups.\n#\n# The 'shutdown-timeout' value is the grace period's duration in seconds. It is\n# only applicable when the instance has replicas. To disable the feature, set\n# the value to 0.\n#\n# shutdown-timeout 10\n\n# When Redis receives a SIGINT or SIGTERM, shutdown is initiated and by default\n# an RDB snapshot is written to disk in a blocking operation if save points are configured.\n# The options used on signaled shutdown can include the following values:\n# default: Saves RDB snapshot only if save points are configured.\n# Waits for lagging replicas to catch up.\n# save: Forces a DB saving operation even if no save points are configured.\n# nosave: Prevents DB saving operation even if one or more save points are configured.\n# now: Skips waiting for lagging replicas.\n# force: Ignores any errors that would normally prevent the server from exiting.\n#\n# Any combination of values is allowed as long as \"save\" and \"nosave\" are not set simultaneously.\n# Example: \"nosave force now\"\n#\n# shutdown-on-sigint default\n# shutdown-on-sigterm default\n\n################ NON-DETERMINISTIC LONG BLOCKING COMMANDS #####################\n\n# Maximum time in milliseconds for EVAL scripts, functions and in some cases\n# modules' commands before Redis can start processing or rejecting other clients.\n#\n# If the maximum execution time is reached Redis will start to reply to most\n# commands with a BUSY error.\n#\n# In this state Redis will only allow a handful of commands to be executed.\n# For instance, SCRIPT KILL, FUNCTION KILL, SHUTDOWN NOSAVE and possibly some\n# module specific 'allow-busy' commands.\n#\n# SCRIPT KILL and FUNCTION KILL will only be able to stop a script that did not\n# yet call any write commands, so SHUTDOWN NOSAVE may be the only way to stop\n# the server in the case a write command was already issued by the script when\n# the user doesn't want to wait for the natural termination of the script.\n#\n# The default is 5 seconds. It is possible to set it to 0 or a negative value\n# to disable this mechanism (uninterrupted execution). Note that in the past\n# this config had a different name, which is now an alias, so both of these do\n# the same:\n# lua-time-limit 5000\n# busy-reply-threshold 5000\n\n################################ REDIS CLUSTER ###############################\n\n# Normal Redis instances can't be part of a Redis Cluster; only nodes that are\n# started as cluster nodes can. In order to start a Redis instance as a\n# cluster node enable the cluster support uncommenting the following:\n#\n# cluster-enabled yes\n\n# Every cluster node has a cluster configuration file. This file is not\n# intended to be edited by hand. It is created and updated by Redis nodes.\n# Every Redis Cluster node requires a different cluster configuration file.\n# Make sure that instances running in the same system do not have\n# overlapping cluster configuration file names.\n#\n# cluster-config-file nodes-6379.conf\n\n# Cluster node timeout is the amount of milliseconds a node must be unreachable\n# for it to be considered in failure state.\n# Most other internal time limits are a multiple of the node timeout.\n#\n# cluster-node-timeout 15000\n\n# The cluster port is the port that the cluster bus will listen for inbound connections on. When set \n# to the default value, 0, it will be bound to the command port + 10000. Setting this value requires \n# you to specify the cluster bus port when executing cluster meet.\n# cluster-port 0\n\n# A replica of a failing master will avoid to start a failover if its data\n# looks too old.\n#\n# There is no simple way for a replica to actually have an exact measure of\n# its \"data age\", so the following two checks are performed:\n#\n# 1) If there are multiple replicas able to failover, they exchange messages\n# in order to try to give an advantage to the replica with the best\n# replication offset (more data from the master processed).\n# Replicas will try to get their rank by offset, and apply to the start\n# of the failover a delay proportional to their rank.\n#\n# 2) Every single replica computes the time of the last interaction with\n# its master. This can be the last ping or command received (if the master\n# is still in the \"connected\" state), or the time that elapsed since the\n# disconnection with the master (if the replication link is currently down).\n# If the last interaction is too old, the replica will not try to failover\n# at all.\n#\n# The point \"2\" can be tuned by user. Specifically a replica will not perform\n# the failover if, since the last interaction with the master, the time\n# elapsed is greater than:\n#\n# (node-timeout * cluster-replica-validity-factor) + repl-ping-replica-period\n#\n# So for example if node-timeout is 30 seconds, and the cluster-replica-validity-factor\n# is 10, and assuming a default repl-ping-replica-period of 10 seconds, the\n# replica will not try to failover if it was not able to talk with the master\n# for longer than 310 seconds.\n#\n# A large cluster-replica-validity-factor may allow replicas with too old data to failover\n# a master, while a too small value may prevent the cluster from being able to\n# elect a replica at all.\n#\n# For maximum availability, it is possible to set the cluster-replica-validity-factor\n# to a value of 0, which means, that replicas will always try to failover the\n# master regardless of the last time they interacted with the master.\n# (However they'll always try to apply a delay proportional to their\n# offset rank).\n#\n# Zero is the only value able to guarantee that when all the partitions heal\n# the cluster will always be able to continue.\n#\n# cluster-replica-validity-factor 10\n\n# Cluster replicas are able to migrate to orphaned masters, that are masters\n# that are left without working replicas. This improves the cluster ability\n# to resist to failures as otherwise an orphaned master can't be failed over\n# in case of failure if it has no working replicas.\n#\n# Replicas migrate to orphaned masters only if there are still at least a\n# given number of other working replicas for their old master. This number\n# is the \"migration barrier\". A migration barrier of 1 means that a replica\n# will migrate only if there is at least 1 other working replica for its master\n# and so forth. It usually reflects the number of replicas you want for every\n# master in your cluster.\n#\n# Default is 1 (replicas migrate only if their masters remain with at least\n# one replica). To disable migration just set it to a very large value or\n# set cluster-allow-replica-migration to 'no'.\n# A value of 0 can be set but is useful only for debugging and dangerous\n# in production.\n#\n# cluster-migration-barrier 1\n\n# Turning off this option allows to use less automatic cluster configuration.\n# It both disables migration to orphaned masters and migration from masters\n# that became empty.\n#\n# Default is 'yes' (allow automatic migrations).\n#\n# cluster-allow-replica-migration yes\n\n# By default Redis Cluster nodes stop accepting queries if they detect there\n# is at least a hash slot uncovered (no available node is serving it).\n# This way if the cluster is partially down (for example a range of hash slots\n# are no longer covered) all the cluster becomes, eventually, unavailable.\n# It automatically returns available as soon as all the slots are covered again.\n#\n# However sometimes you want the subset of the cluster which is working,\n# to continue to accept queries for the part of the key space that is still\n# covered. In order to do so, just set the cluster-require-full-coverage\n# option to no.\n#\n# cluster-require-full-coverage yes\n\n# This option, when set to yes, prevents replicas from trying to failover its\n# master during master failures. However the replica can still perform a\n# manual failover, if forced to do so.\n#\n# This is useful in different scenarios, especially in the case of multiple\n# data center operations, where we want one side to never be promoted if not\n# in the case of a total DC failure.\n#\n# cluster-replica-no-failover no\n\n# This option, when set to yes, allows nodes to serve read traffic while the\n# cluster is in a down state, as long as it believes it owns the slots.\n#\n# This is useful for two cases. The first case is for when an application\n# doesn't require consistency of data during node failures or network partitions.\n# One example of this is a cache, where as long as the node has the data it\n# should be able to serve it.\n#\n# The second use case is for configurations that don't meet the recommended\n# three shards but want to enable cluster mode and scale later. A\n# master outage in a 1 or 2 shard configuration causes a read/write outage to the\n# entire cluster without this option set, with it set there is only a write outage.\n# Without a quorum of masters, slot ownership will not change automatically.\n#\n# cluster-allow-reads-when-down no\n\n# This option, when set to yes, allows nodes to serve pubsub shard traffic while\n# the cluster is in a down state, as long as it believes it owns the slots.\n#\n# This is useful if the application would like to use the pubsub feature even when\n# the cluster global stable state is not OK. If the application wants to make sure only\n# one shard is serving a given channel, this feature should be kept as yes.\n#\n# cluster-allow-pubsubshard-when-down yes\n\n# Cluster link send buffer limit is the limit on the memory usage of an individual\n# cluster bus link's send buffer in bytes. Cluster links would be freed if they exceed\n# this limit. This is to primarily prevent send buffers from growing unbounded on links\n# toward slow peers (E.g. PubSub messages being piled up).\n# This limit is disabled by default. Enable this limit when 'mem_cluster_links' INFO field\n# and/or 'send-buffer-allocated' entries in the 'CLUSTER LINKS` command output continuously increase.\n# Minimum limit of 1gb is recommended so that cluster link buffer can fit in at least a single\n# PubSub message by default. (client-query-buffer-limit default value is 1gb)\n#\n# cluster-link-sendbuf-limit 0\n \n# Clusters can configure their announced hostname using this config. This is a common use case for \n# applications that need to use TLS Server Name Indication (SNI) or dealing with DNS based\n# routing. By default this value is only shown as additional metadata in the CLUSTER SLOTS\n# command, but can be changed using 'cluster-preferred-endpoint-type' config. This value is \n# communicated along the clusterbus to all nodes, setting it to an empty string will remove \n# the hostname and also propagate the removal.\n#\n# cluster-announce-hostname \"\"\n\n# Clusters can configure an optional nodename to be used in addition to the node ID for\n# debugging and admin information. This name is broadcasted between nodes, so will be used\n# in addition to the node ID when reporting cross node events such as node failures.\n# cluster-announce-human-nodename \"\"\n\n# Clusters can advertise how clients should connect to them using either their IP address,\n# a user defined hostname, or by declaring they have no endpoint. Which endpoint is\n# shown as the preferred endpoint is set by using the cluster-preferred-endpoint-type\n# config with values 'ip', 'hostname', or 'unknown-endpoint'. This value controls how\n# the endpoint returned for MOVED/ASKING requests as well as the first field of CLUSTER SLOTS. \n# If the preferred endpoint type is set to hostname, but no announced hostname is set, a '?' \n# will be returned instead.\n#\n# When a cluster advertises itself as having an unknown endpoint, it's indicating that\n# the server doesn't know how clients can reach the cluster. This can happen in certain \n# networking situations where there are multiple possible routes to the node, and the \n# server doesn't know which one the client took. In this case, the server is expecting\n# the client to reach out on the same endpoint it used for making the last request, but use\n# the port provided in the response.\n#\n# cluster-preferred-endpoint-type ip\n\n# This configuration defines the sampling ratio (0-100) for checking command\n# compatibility in cluster mode. When a command is executed, it is sampled at\n# the specified ratio to determine if it complies with Redis cluster constraints,\n# such as cross-slot restrictions.\n#\n# - A value of 0 means no commands are sampled for compatibility checks.\n# - A value of 100 means all commands are checked.\n# - Intermediate values (e.g., 10) mean that approximately 10% of the commands\n# are randomly selected for compatibility verification.\n#\n# Higher sampling ratios may introduce additional performance overhead, especially\n# under high QPS. The default value is 0 (no sampling).\n#\n# cluster-compatibility-sample-ratio 0\n\n# Clusters can be configured to track per-slot resource statistics,\n# which are accessible by the CLUSTER SLOT-STATS command.\n#\n# By default, the 'cluster-slot-stats-enabled' is disabled, and only 'key-count' is captured.\n# By enabling the 'cluster-slot-stats-enabled' config, the cluster will begin to capture advanced statistics.\n# These statistics can be leveraged to assess general slot usage trends, identify hot / cold slots,\n# migrate slots for a balanced cluster workload, and / or re-write application logic to better utilize slots.\n#\n# The config accepts multiple values as a space-separated list:\n# - cpu: Track CPU usage per slot (cpu-usec metric)\n# - net: Track network bytes per slot (network-bytes-in, network-bytes-out metrics)\n# - mem: Track memory usage per slot (memory-bytes metric)\n# - yes: Enable all tracking (equivalent to \"cpu net mem\")\n# - no: Disable all tracking (default)\n#\n# Example: cluster-slot-stats-enabled \"cpu net\"\n#\n# Note: Memory tracking (mem) can ONLY be enabled at startup. If you try to enable\n# memory tracking via CONFIG SET when it wasn't enabled at startup, the command will\n# fail. However, you can disable memory tracking at runtime by removing the 'mem' flag.\n# Once disabled, memory tracking cannot be re-enabled without restarting the server.\n#\n# cluster-slot-stats-enabled no\n\n# Slot migration write pause timeout controls how long the source node will\n# pause write operations during slot migration handoff phase. This usually\n# finishes in a few milliseconds, depending on traffic and load. When the source\n# node pauses writes to allow the destination to catch up and take the ownership\n# of the slots, this timeout prevents writes from being blocked indefinitely.\n#\n# If the destination node fails to complete the slot ownership takeover within\n# this timeout, the source node will resume accepting writes and assume the\n# migration task is failed. This prevents the source node from being permanently\n# blocked if the destination node becomes unresponsive or fails during migration.\n#\n# If this timeout is set too low, the source may resume writes and assume that\n# the slot migration has failed while the destination is still in the process of\n# draining the replication stream and publishing the configuration update.\n# During this window, writes accepted by the source will not be replicated to\n# the destination; if the destination later publishes the updated config and\n# takes ownership, those writes could be lost. Therefore, avoid setting this\n# timeout too low.\n#\n# This timeout is specified in milliseconds.\n#\n# cluster-slot-migration-write-pause-timeout 10000\n\n# This config controls the maximum acceptable lag in bytes between source and\n# destination nodes during slot migration before triggering the slot handoff\n# phase. If the remaining replication stream size falls below this threshold,\n# the source node pauses writes and then signals destination that it can take\n# over the slot ownership after draining the remaining replication stream.\n#\n# A smaller value means potentially shorter write pause duration, but it may\n# take longer for the destination to catch up. A larger value means handoff can\n# be triggered earlier, but the write pause may potentially be longer.\n#\n# cluster-slot-migration-handoff-max-lag-bytes 1mb\n\n# In order to setup your cluster make sure to read the documentation\n# available at https://redis.io web site.\n\n########################## CLUSTER DOCKER/NAT support ########################\n\n# In certain deployments, Redis Cluster nodes address discovery fails, because\n# addresses are NAT-ted or because ports are forwarded (the typical case is\n# Docker and other containers).\n#\n# In order to make Redis Cluster working in such environments, a static\n# configuration where each node knows its public address is needed. The\n# following four options are used for this scope, and are:\n#\n# * cluster-announce-ip\n# * cluster-announce-port\n# * cluster-announce-tls-port\n# * cluster-announce-bus-port\n#\n# Each instructs the node about its address, client ports (for connections\n# without and with TLS) and cluster message bus port. The information is then\n# published in the header of the bus packets so that other nodes will be able to\n# correctly map the address of the node publishing the information.\n#\n# If tls-cluster is set to yes and cluster-announce-tls-port is omitted or set\n# to zero, then cluster-announce-port refers to the TLS port. Note also that\n# cluster-announce-tls-port has no effect if tls-cluster is set to no.\n#\n# If the above options are not used, the normal Redis Cluster auto-detection\n# will be used instead.\n#\n# Note that when remapped, the bus port may not be at the fixed offset of\n# clients port + 10000, so you can specify any port and bus-port depending\n# on how they get remapped. If the bus-port is not set, a fixed offset of\n# 10000 will be used as usual.\n#\n# Example:\n#\n# cluster-announce-ip 10.1.1.5\n# cluster-announce-tls-port 6379\n# cluster-announce-port 0\n# cluster-announce-bus-port 6380\n\n################################## SLOW LOG ###################################\n\n# The Redis Slow Log is a system to log queries that exceeded a specified\n# execution time. The execution time does not include the I/O operations\n# like talking with the client, sending the reply and so forth,\n# but just the time needed to actually execute the command (this is the only\n# stage of command execution where the thread is blocked and can not serve\n# other requests in the meantime).\n#\n# You can configure the slow log with two parameters: one tells Redis\n# what is the execution time, in microseconds, to exceed in order for the\n# command to get logged, and the other parameter is the length of the\n# slow log. When a new command is logged the oldest one is removed from the\n# queue of logged commands.\n\n# The following time is expressed in microseconds, so 1000000 is equivalent\n# to one second. Note that a negative number disables the slow log, while\n# a value of zero forces the logging of every command.\nslowlog-log-slower-than 10000\n\n# There is no limit to this length. Just be aware that it will consume memory.\n# You can reclaim memory used by the slow log with SLOWLOG RESET.\nslowlog-max-len 128\n\n################################ LATENCY MONITOR ##############################\n\n# The Redis latency monitoring subsystem samples different operations\n# at runtime in order to collect data related to possible sources of\n# latency of a Redis instance.\n#\n# Via the LATENCY command this information is available to the user that can\n# print graphs and obtain reports.\n#\n# The system only logs operations that were performed in a time equal or\n# greater than the amount of milliseconds specified via the\n# latency-monitor-threshold configuration directive. When its value is set\n# to zero, the latency monitor is turned off.\n#\n# By default latency monitoring is disabled since it is mostly not needed\n# if you don't have latency issues, and collecting data has a performance\n# impact, that while very small, can be measured under big load. Latency\n# monitoring can easily be enabled at runtime using the command\n# \"CONFIG SET latency-monitor-threshold \" if needed.\nlatency-monitor-threshold 0\n\n################################ LATENCY TRACKING ##############################\n\n# The Redis extended latency monitoring tracks the per command latencies and enables\n# exporting the percentile distribution via the INFO latencystats command,\n# and cumulative latency distributions (histograms) via the LATENCY command.\n#\n# By default, the extended latency monitoring is enabled since the overhead\n# of keeping track of the command latency is very small.\n# latency-tracking yes\n\n# By default the exported latency percentiles via the INFO latencystats command\n# are the p50, p99, and p999.\n# latency-tracking-info-percentiles 50 99 99.9\n\n############################# EVENT NOTIFICATION ##############################\n\n# Redis can notify Pub/Sub clients about events happening in the key space.\n# This feature is documented at https://redis.io/docs/latest/develop/use/keyspace-notifications/\n#\n# For instance if keyspace events notification is enabled, and a client\n# performs a DEL operation on key \"foo\" stored in the Database 0, two\n# messages will be published via Pub/Sub:\n#\n# PUBLISH __keyspace@0__:foo del\n# PUBLISH __keyevent@0__:del foo\n#\n# It is possible to select the events that Redis will notify among a set\n# of classes. Every class is identified by a single character:\n#\n# K Keyspace events, published with __keyspace@__ prefix.\n# E Keyevent events, published with __keyevent@__ prefix.\n# g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...\n# $ String commands\n# l List commands\n# s Set commands\n# h Hash commands\n# z Sorted set commands\n# x Expired events (events generated every time a key expires)\n# e Evicted events (events generated when a key is evicted for maxmemory)\n# n New key events (Note: not included in the 'A' class)\n# t Stream commands\n# d Module key type events\n# m Key-miss events (Note: It is not included in the 'A' class)\n# o Overwritten events generated every time a key is overwritten.\n# (Note: not included in the 'A' class)\n# c Type-changed events generated every time a key's type changes\n# (Note: not included in the 'A' class)\n# r rate limit event\n# S Subkeyspace events, published with __subkeyspace@__: prefix.\n# T Subkeyevent events, published with __subkeyevent@__: prefix.\n# I Subkeyspaceitem events, published per subkey with\n# __subkeyspaceitem@__:\\n prefix.\n# V Subkeyspaceevent events, published with\n# __subkeyspaceevent@__:| prefix.\n# A Alias for g$lshzxetd, so that the \"AKE\" string means all the events\n# except key-miss, new key, overwritten, type-changed and rate-limit.\n#\n# The \"notify-keyspace-events\" takes as argument a string that is composed\n# of zero or multiple characters. The empty string means that notifications\n# are disabled.\n#\n# Example: to enable list and generic events, from the point of view of the\n# event name, use:\n#\n# notify-keyspace-events Elg\n#\n# Example 2: to get the stream of the expired keys subscribing to channel\n# name __keyevent@0__:expired use:\n#\n# notify-keyspace-events Ex\n#\n# By default all notifications are disabled because most users don't need\n# this feature and the feature has some overhead. Note that if you don't\n# specify at least one of K or E, no events will be delivered.\nnotify-keyspace-events \"\"\n\n############################### ADVANCED CONFIG ###############################\n\n# Hashes are encoded using a memory efficient data structure when they have a\n# small number of entries, and the biggest entry does not exceed a given\n# threshold. These thresholds can be configured using the following directives.\nhash-max-listpack-entries 512\nhash-max-listpack-value 64\n\n# Lists are also encoded in a special way to save a lot of space.\n# The number of entries allowed per internal list node can be specified\n# as a fixed maximum size or a maximum number of elements.\n# For a fixed maximum size, use -5 through -1, meaning:\n# -5: max size: 64 Kb <-- not recommended for normal workloads\n# -4: max size: 32 Kb <-- not recommended\n# -3: max size: 16 Kb <-- probably not recommended\n# -2: max size: 8 Kb <-- good\n# -1: max size: 4 Kb <-- good\n# Positive numbers mean store up to _exactly_ that number of elements\n# per list node.\n# The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),\n# but if your use case is unique, adjust the settings as necessary.\nlist-max-listpack-size -2\n\n# Lists may also be compressed.\n# Compress depth is the number of quicklist ziplist nodes from *each* side of\n# the list to *exclude* from compression. The head and tail of the list\n# are always uncompressed for fast push/pop operations. Settings are:\n# 0: disable all list compression\n# 1: depth 1 means \"don't start compressing until after 1 node into the list,\n# going from either the head or tail\"\n# So: [head]->node->node->...->node->[tail]\n# [head], [tail] will always be uncompressed; inner nodes will compress.\n# 2: [head]->[next]->node->node->...->node->[prev]->[tail]\n# 2 here means: don't compress head or head->next or tail->prev or tail,\n# but compress all nodes between them.\n# 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]\n# etc.\nlist-compress-depth 0\n\n# Sets have a special encoding when a set is composed\n# of just strings that happen to be integers in radix 10 in the range\n# of 64 bit signed integers.\n# The following configuration setting sets the limit in the size of the\n# set in order to use this special memory saving encoding.\nset-max-intset-entries 512\n\n# Sets containing non-integer values are also encoded using a memory efficient\n# data structure when they have a small number of entries, and the biggest entry\n# does not exceed a given threshold. These thresholds can be configured using\n# the following directives.\nset-max-listpack-entries 128\nset-max-listpack-value 64\n\n# Similarly to hashes and lists, sorted sets are also specially encoded in\n# order to save a lot of space. This encoding is only used when the length and\n# elements of a sorted set are below the following limits:\nzset-max-listpack-entries 128\nzset-max-listpack-value 64\n\n# HyperLogLog sparse representation bytes limit. The limit includes the\n# 16 bytes header. When a HyperLogLog using the sparse representation crosses\n# this limit, it is converted into the dense representation.\n#\n# A value greater than 16000 is totally useless, since at that point the\n# dense representation is more memory efficient.\n#\n# The suggested value is ~ 3000 in order to have the benefits of\n# the space efficient encoding without slowing down too much PFADD,\n# which is O(N) with the sparse encoding. The value can be raised to\n# ~ 10000 when CPU is not a concern, but space is, and the data set is\n# composed of many HyperLogLogs with cardinality in the 0 - 15000 range.\nhll-sparse-max-bytes 3000\n\n# Streams macro node max size / items. The stream data structure is a radix\n# tree of big nodes that encode multiple items inside. Using this configuration\n# it is possible to configure how big a single node can be in bytes, and the\n# maximum number of items it may contain before switching to a new node when\n# appending new stream entries. If any of the following settings are set to\n# zero, the limit is ignored, so for instance it is possible to set just a\n# max entries limit by setting max-bytes to 0 and max-entries to the desired\n# value.\nstream-node-max-bytes 4096\nstream-node-max-entries 100\n\n# Redis Streams support Idempotent Message Producer (IDMP) tracking to prevent\n# duplicate message delivery. When producers send messages with IDMP identifiers\n# (using XADD with IDMP or IDMPAUTO parameters), Redis tracks these identifiers to\n# detect and reject duplicates within a configurable time window.\n#\n# stream-idmp-duration: Specifies how long (in seconds) Redis should remember\n# IDMP identifiers for duplicate detection. After this duration expires, old\n# identifiers are automatically removed. This prevents unbounded memory growth\n# while allowing reasonable duplicate detection windows.\n# Valid range: 1 to 86400 seconds (1 second to 24 hours)\n# Default: 100 seconds\n#\n# stream-idmp-maxsize: Maximum number of IDMP identifiers to track per producer\n# per stream. Once this limit is reached, the oldest identifiers are evicted to\n# make room for new ones. This caps memory usage for IDMP tracking.\n# Valid range: 1 to 10000 entries\n# Default: 100 entries\n#\n# Note: These are default values for new streams. Individual streams can override\n# these settings using the XCFGSET command.\n#\n# stream-idmp-duration 100\n# stream-idmp-maxsize 100\n\n# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in\n# order to help rehashing the main Redis hash table (the one mapping top-level\n# keys to values). The hash table implementation Redis uses (see dict.c)\n# performs a lazy rehashing: the more operation you run into a hash table\n# that is rehashing, the more rehashing \"steps\" are performed, so if the\n# server is idle the rehashing is never complete and some more memory is used\n# by the hash table.\n#\n# The default is to use this millisecond 10 times every second in order to\n# actively rehash the main dictionaries, freeing memory when possible.\n#\n# If unsure:\n# use \"activerehashing no\" if you have hard latency requirements and it is\n# not a good thing in your environment that Redis can reply from time to time\n# to queries with 2 milliseconds delay.\n#\n# use \"activerehashing yes\" if you don't have such hard requirements but\n# want to free memory asap when possible.\nactiverehashing yes\n\n# The client output buffer limits can be used to force disconnection of clients\n# that are not reading data from the server fast enough for some reason (a\n# common reason is that a Pub/Sub client can't consume messages as fast as the\n# publisher can produce them).\n#\n# The limit can be set differently for the three different classes of clients:\n#\n# normal -> normal clients including MONITOR clients\n# replica -> replica clients\n# pubsub -> clients subscribed to at least one pubsub channel or pattern\n#\n# The syntax of every client-output-buffer-limit directive is the following:\n#\n# client-output-buffer-limit \n#\n# A client is immediately disconnected once the hard limit is reached, or if\n# the soft limit is reached and remains reached for the specified number of\n# seconds (continuously).\n# So for instance if the hard limit is 32 megabytes and the soft limit is\n# 16 megabytes / 10 seconds, the client will get disconnected immediately\n# if the size of the output buffers reach 32 megabytes, but will also get\n# disconnected if the client reaches 16 megabytes and continuously overcomes\n# the limit for 10 seconds.\n#\n# By default normal clients are not limited because they don't receive data\n# without asking (in a push way), but just after a request, so only\n# asynchronous clients may create a scenario where data is requested faster\n# than it can read.\n#\n# Instead there is a default limit for pubsub and replica clients, since\n# subscribers and replicas receive data in a push fashion.\n#\n# Note that it doesn't make sense to set the replica clients output buffer\n# limit lower than the repl-backlog-size config (partial sync will succeed\n# and then replica will get disconnected).\n# Such a configuration is ignored (the size of repl-backlog-size will be used).\n# This doesn't have memory consumption implications since the replica client\n# will share the backlog buffers memory.\n#\n# Both the hard or the soft limit can be disabled by setting them to zero.\nclient-output-buffer-limit normal 0 0 0\nclient-output-buffer-limit replica 256mb 64mb 60\nclient-output-buffer-limit pubsub 32mb 8mb 60\n\n# Client query buffers accumulate new commands. They are limited to a fixed\n# amount by default in order to avoid that a protocol desynchronization (for\n# instance due to a bug in the client) will lead to unbound memory usage in\n# the query buffer. However you can configure it here if you have very special\n# needs, such as a command with huge argument, or huge multi/exec requests or alike.\n#\n# client-query-buffer-limit 1gb\n\n# Defines how many commands in each client pipeline to decode and prefetch\n# lookahead 16\n\n# In some scenarios client connections can hog up memory leading to OOM\n# errors or data eviction. To avoid this we can cap the accumulated memory\n# used by all client connections (all pubsub and normal clients). Once we\n# reach that limit connections will be dropped by the server freeing up\n# memory. The server will attempt to drop the connections using the most \n# memory first. We call this mechanism \"client eviction\".\n#\n# Client eviction is configured using the maxmemory-clients setting as follows:\n# 0 - client eviction is disabled (default)\n#\n# A memory value can be used for the client eviction threshold,\n# for example:\n# maxmemory-clients 1g\n#\n# A percentage value (between 1% and 100%) means the client eviction threshold\n# is based on a percentage of the maxmemory setting. For example to set client\n# eviction at 5% of maxmemory:\n# maxmemory-clients 5%\n\n# In the Redis protocol, bulk requests, that are, elements representing single\n# strings, are normally limited to 512 mb. However you can change this limit\n# here, but must be 1mb or greater\n#\n# proto-max-bulk-len 512mb\n\n# Redis calls an internal function to perform many background tasks, like\n# closing connections of clients in timeout, purging expired keys that are\n# never requested, and so forth.\n#\n# Not all tasks are performed with the same frequency, but Redis checks for\n# tasks to perform according to the specified \"hz\" value.\n#\n# By default \"hz\" is set to 10. Raising the value will use more CPU when\n# Redis is idle, but at the same time will make Redis more responsive when\n# there are many keys expiring at the same time, and timeouts may be\n# handled with more precision.\n#\n# The range is between 1 and 500, however a value over 100 is usually not\n# a good idea. Most users should use the default of 10 and raise this up to\n# 100 only in environments where very low latency is required.\nhz 10\n\n# Normally it is useful to have an HZ value which is proportional to the\n# number of clients connected. This is useful in order, for instance, to\n# avoid too many clients are processed for each background task invocation\n# in order to avoid latency spikes.\n#\n# Since the default HZ value by default is conservatively set to 10, Redis\n# offers, and enables by default, the ability to use an adaptive HZ value\n# which will temporarily raise when there are many connected clients.\n#\n# When dynamic HZ is enabled, the actual configured HZ will be used\n# as a baseline, but multiples of the configured HZ value will be actually\n# used as needed once more clients are connected. In this way an idle\n# instance will use very little CPU time while a busy instance will be\n# more responsive.\ndynamic-hz yes\n\n# When a child rewrites the AOF file, if the following option is enabled\n# the file will be fsync-ed every 4 MB of data generated. This is useful\n# in order to commit the file to the disk more incrementally and avoid\n# big latency spikes.\naof-rewrite-incremental-fsync yes\n\n# When redis saves RDB file, if the following option is enabled\n# the file will be fsync-ed every 4 MB of data generated. This is useful\n# in order to commit the file to the disk more incrementally and avoid\n# big latency spikes.\nrdb-save-incremental-fsync yes\n\n# Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good\n# idea to start with the default settings and only change them after investigating\n# how to improve the performances and how the keys LFU change over time, which\n# is possible to inspect via the OBJECT FREQ command.\n#\n# There are two tunable parameters in the Redis LFU implementation: the\n# counter logarithm factor and the counter decay time. It is important to\n# understand what the two parameters mean before changing them.\n#\n# The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis\n# uses a probabilistic increment with logarithmic behavior. Given the value\n# of the old counter, when a key is accessed, the counter is incremented in\n# this way:\n#\n# 1. A random number R between 0 and 1 is extracted.\n# 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).\n# 3. The counter is incremented only if R < P.\n#\n# The default lfu-log-factor is 10. This is a table of how the frequency\n# counter changes with a different number of accesses with different\n# logarithmic factors:\n#\n# +--------+------------+------------+------------+------------+------------+\n# | factor | 100 hits | 1000 hits | 100K hits | 1M hits | 10M hits |\n# +--------+------------+------------+------------+------------+------------+\n# | 0 | 104 | 255 | 255 | 255 | 255 |\n# +--------+------------+------------+------------+------------+------------+\n# | 1 | 18 | 49 | 255 | 255 | 255 |\n# +--------+------------+------------+------------+------------+------------+\n# | 10 | 10 | 18 | 142 | 255 | 255 |\n# +--------+------------+------------+------------+------------+------------+\n# | 100 | 8 | 11 | 49 | 143 | 255 |\n# +--------+------------+------------+------------+------------+------------+\n#\n# NOTE: The above table was obtained by running the following commands:\n#\n# redis-benchmark -n 1000000 incr foo\n# redis-cli object freq foo\n#\n# NOTE 2: The counter initial value is 5 in order to give new objects a chance\n# to accumulate hits.\n#\n# The counter decay time is the time, in minutes, that must elapse in order\n# for the key counter to be decremented.\n#\n# The default value for the lfu-decay-time is 1. A special value of 0 means we\n# will never decay the counter.\n#\n# lfu-log-factor 10\n# lfu-decay-time 1\n\n\n# The maximum number of new client connections accepted per event-loop cycle. This configuration\n# is set independently for TLS connections.\n#\n# By default, up to 10 new connection will be accepted per event-loop cycle for normal connections\n# and up to 1 new connection per event-loop cycle for TLS connections.\n#\n# Adjusting this to a larger number can slightly improve efficiency for new connections\n# at the risk of causing timeouts for regular commands on established connections. It is\n# not advised to change this without ensuring that all clients have limited connection\n# pools and exponential backoff in the case of command/connection timeouts. \n#\n# If your application is establishing a large number of new connections per second you should\n# also consider tuning the value of tcp-backlog, which allows the kernel to buffer more\n# pending connections before dropping or rejecting connections. \n#\n# max-new-connections-per-cycle 10\n# max-new-tls-connections-per-cycle 1\n\n\n########################### ACTIVE DEFRAGMENTATION #######################\n#\n# What is active defragmentation?\n# -------------------------------\n#\n# Active (online) defragmentation allows a Redis server to compact the\n# spaces left between small allocations and deallocations of data in memory,\n# thus allowing to reclaim back memory.\n#\n# Fragmentation is a natural process that happens with every allocator (but\n# less so with Jemalloc, fortunately) and certain workloads. Normally a server\n# restart is needed in order to lower the fragmentation, or at least to flush\n# away all the data and create it again. However thanks to this feature\n# implemented by Oran Agra for Redis 4.0 this process can happen at runtime\n# in a \"hot\" way, while the server is running.\n#\n# Basically when the fragmentation is over a certain level (see the\n# configuration options below) Redis will start to create new copies of the\n# values in contiguous memory regions by exploiting certain specific Jemalloc\n# features (in order to understand if an allocation is causing fragmentation\n# and to allocate it in a better place), and at the same time, will release the\n# old copies of the data. This process, repeated incrementally for all the keys\n# will cause the fragmentation to drop back to normal values.\n#\n# Important things to understand:\n#\n# 1. This feature is disabled by default, and only works if you compiled Redis\n# to use the copy of Jemalloc we ship with the source code of Redis.\n# This is the default with Linux builds.\n#\n# 2. You never need to enable this feature if you don't have fragmentation\n# issues.\n#\n# 3. Once you experience fragmentation, you can enable this feature when\n# needed with the command \"CONFIG SET activedefrag yes\".\n#\n# The configuration parameters are able to fine tune the behavior of the\n# defragmentation process. If you are not sure about what they mean it is\n# a good idea to leave the defaults untouched.\n\n# Active defragmentation is disabled by default\n# activedefrag no\n\n# Minimum amount of fragmentation waste to start active defrag\n# active-defrag-ignore-bytes 100mb\n\n# Minimum percentage of fragmentation to start active defrag\n# active-defrag-threshold-lower 10\n\n# Maximum percentage of fragmentation at which we use maximum effort\n# active-defrag-threshold-upper 100\n\n# Minimal effort for defrag in CPU percentage, to be used when the lower\n# threshold is reached\n# active-defrag-cycle-min 1\n\n# Maximal effort for defrag in CPU percentage, to be used when the upper\n# threshold is reached\n# active-defrag-cycle-max 25\n\n# Maximum number of set/hash/zset/list fields that will be processed from\n# the main dictionary scan\n# active-defrag-max-scan-fields 1000\n\n# Jemalloc background thread for purging will be enabled by default\njemalloc-bg-thread yes\n\n# It is possible to pin different threads and processes of Redis to specific\n# CPUs in your system, in order to maximize the performances of the server.\n# This is useful both in order to pin different Redis threads in different\n# CPUs, but also in order to make sure that multiple Redis instances running\n# in the same host will be pinned to different CPUs.\n#\n# Normally you can do this using the \"taskset\" command, however it is also\n# possible to this via Redis configuration directly, both in Linux and FreeBSD.\n#\n# You can pin the server/IO threads, bio threads, aof rewrite child process, and\n# the bgsave child process. The syntax to specify the cpu list is the same as\n# the taskset command:\n#\n# Set redis server/io threads to cpu affinity 0,2,4,6:\n# server-cpulist 0-7:2\n#\n# Set bio threads to cpu affinity 1,3:\n# bio-cpulist 1,3\n#\n# Set aof rewrite child process to cpu affinity 8,9,10,11:\n# aof-rewrite-cpulist 8-11\n#\n# Set bgsave child process to cpu affinity 1,10,11\n# bgsave-cpulist 1,10-11\n\n# In some cases redis will emit warnings and even refuse to start if it detects\n# that the system is in bad state, it is possible to suppress these warnings\n# by setting the following config which takes a space delimited list of warnings\n# to suppress\n#\n# ignore-warnings ARM64-COW-BUG\n\n# When enabled, 'key-memory-histograms' adds per-type memory allocation histograms\n# (distrib_*_sizes fields in bytes) to INFO keysizes output, complementing the\n# existing size/item histograms with actual memory usage data.\n#\n# This setting must be enabled at startup; later config changes have no effect.\n# It is also implicitly enabled when 'cluster-slot-stats-enabled' is set.\n#\n# key-memory-histograms no\n" }, { "path": "runtest", "content": "#!/bin/sh\nTCL_VERSIONS=\"8.5 8.6 8.7 9.0\"\nTCLSH=\"\"\n\nfor VERSION in $TCL_VERSIONS; do\n\tTCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL\ndone\n\nif [ -z $TCLSH ]\nthen\n echo \"You need tcl 8.5 or newer in order to run the Redis test\"\n exit 1\nfi\n$TCLSH tests/test_helper.tcl \"${@}\"\n" }, { "path": "runtest-cluster", "content": "#!/bin/sh\nTCL_VERSIONS=\"8.5 8.6 8.7 9.0\"\nTCLSH=\"\"\n\nfor VERSION in $TCL_VERSIONS; do\n\tTCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL\ndone\n\nif [ -z $TCLSH ]\nthen\n echo \"You need tcl 8.5 or newer in order to run the Redis Cluster test\"\n exit 1\nfi\n$TCLSH tests/cluster/run.tcl $*\n" }, { "path": "runtest-moduleapi", "content": "#!/bin/sh\nTCL_VERSIONS=\"8.5 8.6 8.7 9.0\"\nTCLSH=\"\"\n[ -z \"$MAKE\" ] && MAKE=make\n\nfor VERSION in $TCL_VERSIONS; do\n\tTCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL\ndone\n\nif [ -z $TCLSH ]\nthen\n echo \"You need tcl 8.5 or newer in order to run the Redis ModuleApi test\"\n exit 1\nfi\n\n$MAKE -C tests/modules && \\\n$TCLSH tests/test_helper.tcl \\\n--single unit/moduleapi/commandfilter \\\n--single unit/moduleapi/basics \\\n--single unit/moduleapi/fork \\\n--single unit/moduleapi/testrdb \\\n--single unit/moduleapi/infotest \\\n--single unit/moduleapi/moduleconfigs \\\n--single unit/moduleapi/infra \\\n--single unit/moduleapi/propagate \\\n--single unit/moduleapi/hooks \\\n--single unit/moduleapi/misc \\\n--single unit/moduleapi/blockonkeys \\\n--single unit/moduleapi/blockonbackground \\\n--single unit/moduleapi/scan \\\n--single unit/moduleapi/datatype \\\n--single unit/moduleapi/auth \\\n--single unit/moduleapi/keyspace_events \\\n--single unit/moduleapi/blockedclient \\\n--single unit/moduleapi/getchannels \\\n--single unit/moduleapi/getkeys \\\n--single unit/moduleapi/test_lazyfree \\\n--single unit/moduleapi/defrag \\\n--single unit/moduleapi/keyspecs \\\n--single unit/moduleapi/hash \\\n--single unit/moduleapi/zset \\\n--single unit/moduleapi/list \\\n--single unit/moduleapi/stream \\\n--single unit/moduleapi/mallocsize \\\n--single unit/moduleapi/datatype2 \\\n--single unit/moduleapi/cluster \\\n--single unit/moduleapi/aclcheck \\\n--single unit/moduleapi/subcommands \\\n--single unit/moduleapi/reply \\\n--single unit/moduleapi/cmdintrospection \\\n--single unit/moduleapi/eventloop \\\n--single unit/moduleapi/timer \\\n--single unit/moduleapi/publish \\\n--single unit/moduleapi/usercall \\\n--single unit/moduleapi/postnotifications \\\n--single unit/moduleapi/async_rm_call \\\n--single unit/moduleapi/moduleauth \\\n--single unit/moduleapi/rdbloadsave \\\n--single unit/moduleapi/crash \\\n--single unit/moduleapi/internalsecret \\\n--single unit/moduleapi/configaccess \\\n--single unit/moduleapi/keymeta \\\n--single unit/moduleapi/ksn_notify_side_effect \\\n\"${@}\"\n" }, { "path": "runtest-sentinel", "content": "#!/bin/sh\nTCL_VERSIONS=\"8.5 8.6 8.7 9.0\"\nTCLSH=\"\"\n\nfor VERSION in $TCL_VERSIONS; do\n\tTCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL\ndone\n\nif [ -z $TCLSH ]\nthen\n echo \"You need tcl 8.5 or newer in order to run the Redis Sentinel test\"\n exit 1\nfi\n$TCLSH tests/sentinel/run.tcl $*\n" }, { "path": "sentinel.conf", "content": "# Example sentinel.conf\n\n# By default protected mode is disabled in sentinel mode. Sentinel is reachable\n# from interfaces different than localhost. Make sure the sentinel instance is\n# protected from the outside world via firewalling or other means.\nprotected-mode no\n\n# port \n# The port that this sentinel instance will run on\nport 26379\n\n# By default Redis Sentinel does not run as a daemon. Use 'yes' if you need it.\n# Note that Redis will write a pid file in /var/run/redis-sentinel.pid when\n# daemonized.\ndaemonize no\n\n# When running daemonized, Redis Sentinel writes a pid file in\n# /var/run/redis-sentinel.pid by default. You can specify a custom pid file\n# location here.\npidfile /var/run/redis-sentinel.pid\n\n# Specify the server verbosity level.\n# This can be one of:\n# debug (a lot of information, useful for development/testing)\n# verbose (many rarely useful info, but not a mess like the debug level)\n# notice (moderately verbose, what you want in production probably)\n# warning (only very important / critical messages are logged)\n# nothing (nothing is logged)\nloglevel notice\n\n# Specify the log file name. Also the empty string can be used to force\n# Sentinel to log on the standard output. Note that if you use standard\n# output for logging but daemonize, logs will be sent to /dev/null\nlogfile \"\"\n\n# To enable logging to the system logger, just set 'syslog-enabled' to yes,\n# and optionally update the other syslog parameters to suit your needs.\n# syslog-enabled no\n\n# Specify the syslog identity.\n# syslog-ident sentinel\n\n# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.\n# syslog-facility local0\n\n# sentinel announce-ip \n# sentinel announce-port \n#\n# The above two configuration directives are useful in environments where,\n# because of NAT, Sentinel is reachable from outside via a non-local address.\n#\n# When announce-ip is provided, the Sentinel will claim the specified IP address\n# in HELLO messages used to gossip its presence, instead of auto-detecting the\n# local address as it usually does.\n#\n# Similarly when announce-port is provided and is valid and non-zero, Sentinel\n# will announce the specified TCP port.\n#\n# The two options don't need to be used together, if only announce-ip is\n# provided, the Sentinel will announce the specified IP and the server port\n# as specified by the \"port\" option. If only announce-port is provided, the\n# Sentinel will announce the auto-detected local IP and the specified port.\n#\n# Example:\n#\n# sentinel announce-ip 1.2.3.4\n\n# dir \n# Every long running process should have a well-defined working directory.\n# For Redis Sentinel to chdir to /tmp at startup is the simplest thing\n# for the process to don't interfere with administrative tasks such as\n# unmounting filesystems.\ndir /tmp\n\n# sentinel monitor \n#\n# Tells Sentinel to monitor this master, and to consider it in O_DOWN\n# (Objectively Down) state only if at least sentinels agree.\n#\n# Note that whatever is the ODOWN quorum, a Sentinel will require to\n# be elected by the majority of the known Sentinels in order to\n# start a failover, so no failover can be performed in minority.\n#\n# Replicas are auto-discovered, so you don't need to specify replicas in\n# any way. Sentinel itself will rewrite this configuration file adding\n# the replicas using additional configuration options.\n# Also note that the configuration file is rewritten when a\n# replica is promoted to master.\n#\n# Note: master name should not include special characters or spaces.\n# The valid charset is A-z 0-9 and the three characters \".-_\".\nsentinel monitor mymaster 127.0.0.1 6379 2\n\n# sentinel auth-pass \n#\n# Set the password to use to authenticate with the master and replicas.\n# Useful if there is a password set in the Redis instances to monitor.\n#\n# Note that the master password is also used for replicas, so it is not\n# possible to set a different password in masters and replicas instances\n# if you want to be able to monitor these instances with Sentinel.\n#\n# However you can have Redis instances without the authentication enabled\n# mixed with Redis instances requiring the authentication (as long as the\n# password set is the same for all the instances requiring the password) as\n# the AUTH command will have no effect in Redis instances with authentication\n# switched off.\n#\n# Example:\n#\n# sentinel auth-pass mymaster MySUPER--secret-0123passw0rd\n\n# sentinel auth-user \n#\n# This is useful in order to authenticate to instances having ACL capabilities,\n# that is, running Redis 6.0 or greater. When just auth-pass is provided the\n# Sentinel instance will authenticate to Redis using the old \"AUTH \"\n# method. When also an username is provided, it will use \"AUTH \".\n# In the Redis servers side, the ACL to provide just minimal access to\n# Sentinel instances, should be configured along the following lines:\n#\n# user sentinel-user >somepassword +client +subscribe +publish \\\n# +ping +info +multi +slaveof +config +client +exec on\n\n# sentinel down-after-milliseconds \n#\n# Number of milliseconds the master (or any attached replica or sentinel) should\n# be unreachable (as in, not acceptable reply to PING, continuously, for the\n# specified period) in order to consider it in S_DOWN state (Subjectively\n# Down).\n#\n# Default is 30 seconds.\nsentinel down-after-milliseconds mymaster 30000\n\n# IMPORTANT NOTE: starting with Redis 6.2 ACL capability is supported for\n# Sentinel mode, please refer to the Redis website https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/\n# for more details.\n\n# Sentinel's ACL users are defined in the following format:\n#\n# user ... acl rules ...\n#\n# For example:\n#\n# user worker +@admin +@connection ~* on >ffa9203c493aa99\n#\n# For more information about ACL configuration please refer to the Redis\n# website at https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/ and redis server configuration \n# template redis.conf.\n\n# ACL LOG\n#\n# The ACL Log tracks failed commands and authentication events associated\n# with ACLs. The ACL Log is useful to troubleshoot failed commands blocked \n# by ACLs. The ACL Log is stored in memory. You can reclaim memory with \n# ACL LOG RESET. Define the maximum entry length of the ACL Log below.\nacllog-max-len 128\n\n# Using an external ACL file\n#\n# Instead of configuring users here in this file, it is possible to use\n# a stand-alone file just listing users. The two methods cannot be mixed:\n# if you configure users here and at the same time you activate the external\n# ACL file, the server will refuse to start.\n#\n# The format of the external ACL user file is exactly the same as the\n# format that is used inside redis.conf to describe users.\n#\n# aclfile /etc/redis/sentinel-users.acl\n\n# requirepass \n#\n# You can configure Sentinel itself to require a password, however when doing\n# so Sentinel will try to authenticate with the same password to all the\n# other Sentinels. So you need to configure all your Sentinels in a given\n# group with the same \"requirepass\" password. Check the following documentation\n# for more info: https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/\n#\n# IMPORTANT NOTE: starting with Redis 6.2 \"requirepass\" is a compatibility\n# layer on top of the ACL system. The option effect will be just setting\n# the password for the default user. Clients will still authenticate using\n# AUTH as usually, or more explicitly with AUTH default \n# if they follow the new protocol: both will work.\n#\n# New config files are advised to use separate authentication control for\n# incoming connections (via ACL), and for outgoing connections (via\n# sentinel-user and sentinel-pass) \n#\n# The requirepass is not compatible with aclfile option and the ACL LOAD\n# command, these will cause requirepass to be ignored.\n\n# sentinel sentinel-user \n#\n# You can configure Sentinel to authenticate with other Sentinels with specific\n# user name. \n\n# sentinel sentinel-pass \n#\n# The password for Sentinel to authenticate with other Sentinels. If sentinel-user\n# is not configured, Sentinel will use 'default' user with sentinel-pass to authenticate.\n\n# sentinel parallel-syncs \n#\n# How many replicas we can reconfigure to point to the new replica simultaneously\n# during the failover. Use a low number if you use the replicas to serve query\n# to avoid that all the replicas will be unreachable at about the same\n# time while performing the synchronization with the master.\nsentinel parallel-syncs mymaster 1\n\n# sentinel failover-timeout \n#\n# Specifies the failover timeout in milliseconds. It is used in many ways:\n#\n# - The time needed to re-start a failover after a previous failover was\n# already tried against the same master by a given Sentinel, is two\n# times the failover timeout.\n#\n# - The time needed for a replica replicating to a wrong master according\n# to a Sentinel current configuration, to be forced to replicate\n# with the right master, is exactly the failover timeout (counting since\n# the moment a Sentinel detected the misconfiguration).\n#\n# - The time needed to cancel a failover that is already in progress but\n# did not produced any configuration change (SLAVEOF NO ONE yet not\n# acknowledged by the promoted replica).\n#\n# - The maximum time a failover in progress waits for all the replicas to be\n# reconfigured as replicas of the new master. However even after this time\n# the replicas will be reconfigured by the Sentinels anyway, but not with\n# the exact parallel-syncs progression as specified.\n#\n# Default is 3 minutes.\nsentinel failover-timeout mymaster 180000\n\n# SCRIPTS EXECUTION\n#\n# sentinel notification-script and sentinel reconfig-script are used in order\n# to configure scripts that are called to notify the system administrator\n# or to reconfigure clients after a failover. The scripts are executed\n# with the following rules for error handling:\n#\n# If script exits with \"1\" the execution is retried later (up to a maximum\n# number of times currently set to 10).\n#\n# If script exits with \"2\" (or an higher value) the script execution is\n# not retried.\n#\n# If script terminates because it receives a signal the behavior is the same\n# as exit code 1.\n#\n# A script has a maximum running time of 60 seconds. After this limit is\n# reached the script is terminated with a SIGKILL and the execution retried.\n\n# NOTIFICATION SCRIPT\n#\n# sentinel notification-script \n# \n# Call the specified notification script for any sentinel event that is\n# generated in the WARNING level (for instance -sdown, -odown, and so forth).\n# This script should notify the system administrator via email, SMS, or any\n# other messaging system, that there is something wrong with the monitored\n# Redis systems.\n#\n# The script is called with just two arguments: the first is the event type\n# and the second the event description.\n#\n# The script must exist and be executable in order for sentinel to start if\n# this option is provided.\n#\n# Example:\n#\n# sentinel notification-script mymaster /var/redis/notify.sh\n\n# CLIENTS RECONFIGURATION SCRIPT\n#\n# sentinel client-reconfig-script \n#\n# When the master changed because of a failover a script can be called in\n# order to perform application-specific tasks to notify the clients that the\n# configuration has changed and the master is at a different address.\n# \n# The following arguments are passed to the script:\n#\n# \n#\n# is currently always \"start\"\n# is either \"leader\" or \"observer\"\n# \n# The arguments from-ip, from-port, to-ip, to-port are used to communicate\n# the old address of the master and the new address of the elected replica\n# (now a master).\n#\n# This script should be resistant to multiple invocations.\n#\n# Example:\n#\n# sentinel client-reconfig-script mymaster /var/redis/reconfig.sh\n\n# SECURITY\n#\n# By default SENTINEL SET will not be able to change the notification-script\n# and client-reconfig-script at runtime. This avoids a trivial security issue\n# where clients can set the script to anything and trigger a failover in order\n# to get the program executed.\n\nsentinel deny-scripts-reconfig yes\n\n# REDIS COMMANDS RENAMING (DEPRECATED)\n#\n# WARNING: avoid using this option if possible, instead use ACLs.\n#\n# Sometimes the Redis server has certain commands, that are needed for Sentinel\n# to work correctly, renamed to unguessable strings. This is often the case\n# of CONFIG and SLAVEOF in the context of providers that provide Redis as\n# a service, and don't want the customers to reconfigure the instances outside\n# of the administration console.\n#\n# In such case it is possible to tell Sentinel to use different command names\n# instead of the normal ones. For example if the master \"mymaster\", and the\n# associated replicas, have \"CONFIG\" all renamed to \"GUESSME\", I could use:\n#\n# SENTINEL rename-command mymaster CONFIG GUESSME\n#\n# After such configuration is set, every time Sentinel would use CONFIG it will\n# use GUESSME instead. Note that there is no actual need to respect the command\n# case, so writing \"config guessme\" is the same in the example above.\n#\n# SENTINEL SET can also be used in order to perform this configuration at runtime.\n#\n# In order to set a command back to its original name (undo the renaming), it\n# is possible to just rename a command to itself:\n#\n# SENTINEL rename-command mymaster CONFIG CONFIG\n\n# HOSTNAMES SUPPORT\n#\n# Normally Sentinel uses only IP addresses and requires SENTINEL MONITOR\n# to specify an IP address. Also, it requires the Redis replica-announce-ip\n# keyword to specify only IP addresses.\n#\n# You may enable hostnames support by enabling resolve-hostnames. Note\n# that you must make sure your DNS is configured properly and that DNS\n# resolution does not introduce very long delays.\n#\nSENTINEL resolve-hostnames no\n\n# When resolve-hostnames is enabled, Sentinel still uses IP addresses\n# when exposing instances to users, configuration files, etc. If you want\n# to retain the hostnames when announced, enable announce-hostnames below.\n#\nSENTINEL announce-hostnames no\n\n# When master_reboot_down_after_period is set to 0, Sentinel does not fail over\n# when receiving a -LOADING response from a master. This was the only supported\n# behavior before version 7.0.\n#\n# Otherwise, Sentinel will use this value as the time (in ms) it is willing to\n# accept a -LOADING response after a master has been rebooted, before failing\n# over.\n\nSENTINEL master-reboot-down-after-period mymaster 0\n" }, { "path": "src/.gitignore", "content": "*.gcda\n*.gcno\n*.gcov\nredis.info\nlcov-html\n" }, { "path": "src/Makefile", "content": "# Redis Makefile\n# Copyright (c) 2011-Present, Redis Ltd.\n# All rights reserved.\n#\n# Licensed under your choice of (a) the Redis Source Available License 2.0\n# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n# GNU Affero General Public License v3 (AGPLv3).\n#\n# The Makefile composes the final FINAL_CFLAGS and FINAL_LDFLAGS using\n# what is needed for Redis plus the standard CFLAGS and LDFLAGS passed.\n# However when building the dependencies (Jemalloc, Lua, Hiredis, ...)\n# CFLAGS and LDFLAGS are propagated to the dependencies, so to pass\n# flags only to be used when compiling / linking Redis itself REDIS_CFLAGS\n# and REDIS_LDFLAGS are used instead (this is the case of 'make gcov').\n#\n# Dependencies are stored in the Makefile.dep file. To rebuild this file\n# Just use 'make dep', but this is only needed by developers.\n\nrelease_hdr := $(shell sh -c './mkreleasehdr.sh')\nuname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\nuname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')\nCLANG := $(findstring clang,$(shell sh -c '$(CC) --version | head -1'))\n\n# Optimization flags. To override, the OPTIMIZATION variable can be passed, but\n# some automatic defaults are added to it. To specify optimization flags\n# explicitly without any defaults added, pass the OPT variable instead.\nOPTIMIZATION?=-O3\nifeq ($(OPTIMIZATION),-O3)\n\tifeq (clang,$(CLANG))\n\t\tOPTIMIZATION+=-flto\n\telse\n\t\tOPTIMIZATION+=-flto=auto\n\tendif\nendif\nifneq ($(OPTIMIZATION),-O0)\n\tOPTIMIZATION+=-fno-omit-frame-pointer\nendif\nDEPENDENCY_TARGETS=hiredis linenoise lua hdr_histogram fpconv xxhash\nNODEPS:=clean distclean\n\n# Default settings\nSTD=-pedantic -DREDIS_STATIC=''\n\n# Use -Wno-c11-extensions on clang, either where explicitly used or on\n# platforms we can assume it's being used.\nifeq (clang,$(CLANG))\n STD+=-Wno-c11-extensions\nelse\nifneq (,$(findstring FreeBSD,$(uname_S)))\n STD+=-Wno-c11-extensions\nendif\nendif\nWARN=-Wall -W -Wno-missing-field-initializers -Werror=deprecated-declarations -Wstrict-prototypes\nOPT=$(OPTIMIZATION)\n\nSKIP_VEC_SETS?=no\n# Detect if the compiler supports C11 _Atomic.\n# NUMBER_SIGN_CHAR is a workaround to support both GNU Make 4.3 and older versions.\nNUMBER_SIGN_CHAR := \\#\nC11_ATOMIC := $(shell sh -c 'echo \"$(NUMBER_SIGN_CHAR)include \" > foo.c; \\\n\t$(CC) -std=gnu11 -c foo.c -o foo.o > /dev/null 2>&1; \\\n\tif [ -f foo.o ]; then echo \"yes\"; rm foo.o; fi; rm foo.c')\nifeq ($(C11_ATOMIC),yes)\n\tSTD+=-std=gnu11\nelse\n\tSKIP_VEC_SETS=yes\n\tSTD+=-std=c99\nendif\n\nPREFIX?=/usr/local\nINSTALL_BIN=$(PREFIX)/bin\nINSTALL=install\nPKG_CONFIG?=pkg-config\n\nifndef PYTHON\nPYTHON := $(shell which python3 || which python)\nendif\n\n# Default allocator defaults to Jemalloc on Linux and libc otherwise\nMALLOC=libc\nifeq ($(uname_S),Linux)\n\tMALLOC=jemalloc\nendif\n\n# To get ARM stack traces if Redis crashes we need a special C flag.\nifneq (,$(filter aarch64 armv%,$(uname_M)))\n CFLAGS+=-funwind-tables\nendif\n\n# Backwards compatibility for selecting an allocator\nifeq ($(USE_TCMALLOC),yes)\n\tMALLOC=tcmalloc\nendif\n\nifeq ($(USE_TCMALLOC_MINIMAL),yes)\n\tMALLOC=tcmalloc_minimal\nendif\n\nifeq ($(USE_JEMALLOC),yes)\n\tMALLOC=jemalloc\nendif\n\nifeq ($(USE_JEMALLOC),no)\n\tMALLOC=libc\nendif\n\nifdef SANITIZER\nifeq ($(SANITIZER),address)\n\tMALLOC=libc\n\tCFLAGS+=-fsanitize=address -fno-sanitize-recover=all -fno-omit-frame-pointer\n\tLDFLAGS+=-fsanitize=address\nelse\nifeq ($(SANITIZER),undefined)\n\tMALLOC=libc\n\tCFLAGS+=-fsanitize=undefined -fno-sanitize-recover=all -fno-omit-frame-pointer\n\tLDFLAGS+=-fsanitize=undefined\nelse\nifeq ($(SANITIZER),thread)\n\tCFLAGS+=-fsanitize=thread -fno-sanitize-recover=all -fno-omit-frame-pointer\n\tLDFLAGS+=-fsanitize=thread\nelse\nifeq ($(SANITIZER),memory)\nifeq (clang, $(CLANG))\n\texport CXX:=clang\n\texport LD:=clang\n\tMALLOC=libc # MSan provides its own allocator so make sure not to use jemalloc as they clash\n\tCFLAGS+=-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-sanitize-recover=all -fno-omit-frame-pointer\n\tLDFLAGS+=-fsanitize=memory\nelse\n $(error \"MemorySanitizer needs to be compiled and linked with clang. Please use CC=clang\")\nendif\nelse\n $(error \"unknown sanitizer=${SANITIZER}\")\nendif\nendif\nendif\nendif\nendif\n\n# Special case of forcing defrag to run even though we have no Jemlloc support\nifeq ($(DEBUG_DEFRAG), force)\n\tCFLAGS +=-DDEBUG_DEFRAG_FORCE\nelse ifeq ($(DEBUG_DEFRAG), fully)\n\tCFLAGS +=-DDEBUG_DEFRAG_FORCE -DDEBUG_DEFRAG_FULLY\nendif\n\n# Override default settings if possible\n-include .make-settings\n\nFINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)\nFINAL_LDFLAGS=$(LDFLAGS) $(OPT) $(REDIS_LDFLAGS) $(DEBUG)\nFINAL_LIBS=-lm\nDEBUG=-g -ggdb\n\n# Linux ARM32 needs -latomic at linking time\nifneq (,$(findstring armv,$(uname_M)))\n FINAL_LIBS+=-latomic\nendif\n\nifeq ($(uname_S),SunOS)\n\t# SunOS\n\tifeq ($(findstring -m32,$(FINAL_CFLAGS)),)\n\t\tCFLAGS+=-m64\n\tendif\n\tifeq ($(findstring -m32,$(FINAL_LDFLAGS)),)\n\t\tLDFLAGS+=-m64\n\tendif\n\tDEBUG=-g\n\tDEBUG_FLAGS=-g\n\texport CFLAGS LDFLAGS DEBUG DEBUG_FLAGS\n\tINSTALL=cp -pf\n\tFINAL_CFLAGS+= -D__EXTENSIONS__ -D_XPG6\n\tFINAL_LIBS+= -ldl -lnsl -lsocket -lresolv -lpthread -lrt\n\tifeq ($(USE_BACKTRACE),yes)\n\t FINAL_CFLAGS+= -DUSE_BACKTRACE\n\tendif\nelse\nifeq ($(uname_S),Darwin)\n\t# Darwin\n\tFINAL_LIBS+= -ldl\n\t# Homebrew's OpenSSL is not linked to /usr/local to avoid\n\t# conflicts with the system's LibreSSL installation so it\n\t# must be referenced explicitly during build.\nifeq ($(uname_M),arm64)\n\t# Homebrew arm64 uses /opt/homebrew as HOMEBREW_PREFIX\n\tOPENSSL_PREFIX?=/opt/homebrew/opt/openssl\nelse\n\t# Homebrew x86/ppc uses /usr/local as HOMEBREW_PREFIX\n\tOPENSSL_PREFIX?=/usr/local/opt/openssl\nendif\nelse\nifeq ($(uname_S),AIX)\n # AIX\n FINAL_LDFLAGS+= -Wl,-bexpall\n FINAL_LIBS+=-ldl -pthread -lcrypt -lbsd\nelse\nifeq ($(uname_S),OpenBSD)\n\t# OpenBSD\n\tFINAL_LIBS+= -lpthread\n\tifeq ($(USE_BACKTRACE),yes)\n\t FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/local/include\n\t FINAL_LDFLAGS+= -L/usr/local/lib\n\t FINAL_LIBS+= -lexecinfo\n \tendif\n\nelse\nifeq ($(uname_S),NetBSD)\n\t# NetBSD\n\tFINAL_LIBS+= -lpthread\n\tifeq ($(USE_BACKTRACE),yes)\n\t FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/pkg/include\n\t FINAL_LDFLAGS+= -L/usr/pkg/lib\n\t FINAL_LIBS+= -lexecinfo\n \tendif\nelse\nifeq ($(uname_S),FreeBSD)\n\t# FreeBSD\n\tFINAL_LIBS+= -lpthread -lexecinfo\nelse\nifeq ($(uname_S),DragonFly)\n\t# DragonFly\n\tFINAL_LIBS+= -lpthread -lexecinfo\nelse\nifeq ($(uname_S),OpenBSD)\n\t# OpenBSD\n\tFINAL_LIBS+= -lpthread -lexecinfo\nelse\nifeq ($(uname_S),NetBSD)\n\t# NetBSD\n\tFINAL_LIBS+= -lpthread -lexecinfo\nelse\nifeq ($(uname_S),Haiku)\n\t# Haiku\n\tFINAL_CFLAGS+= -DBSD_SOURCE\n\tFINAL_LDFLAGS+= -lbsd -lnetwork\n\tFINAL_LIBS+= -lpthread\nelse\n\t# All the other OSes (notably Linux)\n\tFINAL_LDFLAGS+= -rdynamic\n\tFINAL_LIBS+=-ldl -pthread -lrt\nendif\nendif\nendif\nendif\nendif\nendif\nendif\nendif\nendif\nendif\n\nifdef OPENSSL_PREFIX\n\tOPENSSL_CFLAGS=-I$(OPENSSL_PREFIX)/include\n\tOPENSSL_LDFLAGS=-L$(OPENSSL_PREFIX)/lib\n\t# Also export OPENSSL_PREFIX so it ends up in deps sub-Makefiles\n\texport OPENSSL_PREFIX\nendif\n\n# Include paths to dependencies\nFINAL_CFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src -I../deps/hdr_histogram -I../deps/fpconv -I../deps/xxhash\n\n# Determine systemd support and/or build preference (defaulting to auto-detection)\nBUILD_WITH_SYSTEMD=no\nLIBSYSTEMD_LIBS=-lsystemd\n\n# If 'USE_SYSTEMD' in the environment is neither \"no\" nor \"yes\", try to\n# auto-detect libsystemd's presence and link accordingly.\nifneq ($(USE_SYSTEMD),no)\n\tLIBSYSTEMD_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libsystemd && echo $$?)\n# If libsystemd cannot be detected, continue building without support for it\n# (unless a later check tells us otherwise)\nifeq ($(LIBSYSTEMD_PKGCONFIG),0)\n\tBUILD_WITH_SYSTEMD=yes\n\tLIBSYSTEMD_LIBS=$(shell $(PKG_CONFIG) --libs libsystemd)\nendif\nendif\n\n# If 'USE_SYSTEMD' is set to \"yes\" use pkg-config if available or fall back to\n# default -lsystemd.\nifeq ($(USE_SYSTEMD),yes)\n\tBUILD_WITH_SYSTEMD=yes\nendif\n\nifeq ($(BUILD_WITH_SYSTEMD),yes)\n\tFINAL_LIBS+=$(LIBSYSTEMD_LIBS)\n\tFINAL_CFLAGS+= -DHAVE_LIBSYSTEMD\nendif\n\nifeq ($(MALLOC),tcmalloc)\n\tFINAL_CFLAGS+= -DUSE_TCMALLOC\n\tFINAL_LIBS+= -ltcmalloc\nendif\n\nifeq ($(MALLOC),tcmalloc_minimal)\n\tFINAL_CFLAGS+= -DUSE_TCMALLOC\n\tFINAL_LIBS+= -ltcmalloc_minimal\nendif\n\nifeq ($(MALLOC),jemalloc)\n\tDEPENDENCY_TARGETS+= jemalloc\n\tFINAL_CFLAGS+= -DUSE_JEMALLOC -I../deps/jemalloc/include\n\tFINAL_LIBS := ../deps/jemalloc/lib/libjemalloc.a $(FINAL_LIBS)\nendif\n\n# LIBSSL & LIBCRYPTO\nLIBSSL_LIBS=\nLIBSSL_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libssl && echo $$?)\nifeq ($(LIBSSL_PKGCONFIG),0)\n\tLIBSSL_LIBS=$(shell $(PKG_CONFIG) --libs libssl)\nelse\n\tLIBSSL_LIBS=-lssl\nendif\nLIBCRYPTO_LIBS=\nLIBCRYPTO_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libcrypto && echo $$?)\nifeq ($(LIBCRYPTO_PKGCONFIG),0)\n\tLIBCRYPTO_LIBS=$(shell $(PKG_CONFIG) --libs libcrypto)\nelse\n\tLIBCRYPTO_LIBS=-lcrypto\nendif\n\nBUILD_NO:=0\nBUILD_YES:=1\nBUILD_MODULE:=2\nifeq ($(BUILD_TLS),yes)\n\tFINAL_CFLAGS+=-DUSE_OPENSSL=$(BUILD_YES) $(OPENSSL_CFLAGS) -DBUILD_TLS_MODULE=$(BUILD_NO)\n\tFINAL_LDFLAGS+=$(OPENSSL_LDFLAGS)\n\tFINAL_LIBS += ../deps/hiredis/libhiredis_ssl.a $(LIBSSL_LIBS) $(LIBCRYPTO_LIBS)\nendif\n\nTLS_MODULE=\nTLS_MODULE_NAME:=redis-tls$(PROG_SUFFIX).so\nTLS_MODULE_CFLAGS:=$(FINAL_CFLAGS)\nifeq ($(BUILD_TLS),module)\n\tFINAL_CFLAGS+=-DUSE_OPENSSL=$(BUILD_MODULE) $(OPENSSL_CFLAGS)\n\tTLS_CLIENT_LIBS = ../deps/hiredis/libhiredis_ssl.a $(LIBSSL_LIBS) $(LIBCRYPTO_LIBS)\n\tTLS_MODULE=$(TLS_MODULE_NAME)\n\tTLS_MODULE_CFLAGS+=-DUSE_OPENSSL=$(BUILD_MODULE) $(OPENSSL_CFLAGS) -DBUILD_TLS_MODULE=$(BUILD_MODULE)\nendif\n\nifneq ($(SKIP_VEC_SETS),yes)\n\tvpath %.c ../modules/vector-sets\n\tREDIS_VEC_SETS_OBJ=hnsw.o vset.o vset_config.o\n\tFINAL_CFLAGS+=-DINCLUDE_VEC_SETS=1\nendif\n\nifndef V\n define MAKE_INSTALL\n @printf ' %b %b\\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$(1)$(ENDCOLOR) 1>&2\n @$(INSTALL) $(1) $(2)\n endef\nelse\n define MAKE_INSTALL\n $(INSTALL) $(1) $(2)\n endef\nendif\n\nREDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)\nREDIS_LD=$(QUIET_LINK)$(CC) $(FINAL_LDFLAGS)\nREDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)\n\nCCCOLOR=\"\\033[34m\"\nLINKCOLOR=\"\\033[34;1m\"\nSRCCOLOR=\"\\033[33m\"\nBINCOLOR=\"\\033[37;1m\"\nMAKECOLOR=\"\\033[32;1m\"\nENDCOLOR=\"\\033[0m\"\n\nifndef V\nQUIET_CC = @printf ' %b %b\\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;\nQUIET_GEN = @printf ' %b %b\\n' $(CCCOLOR)GEN$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;\nQUIET_LINK = @printf ' %b %b\\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;\nQUIET_INSTALL = @printf ' %b %b\\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;\nendif\n\nifneq (, $(findstring LOG_REQ_RES, $(REDIS_CFLAGS)))\n\tCOMMANDS_DEF_FILENAME=commands_with_reply_schema\n\tGEN_COMMANDS_FLAGS=--with-reply-schema\nelse\n\tCOMMANDS_DEF_FILENAME=commands\n\tGEN_COMMANDS_FLAGS=\nendif\n\nREDIS_SERVER_NAME=redis-server$(PROG_SUFFIX)\nREDIS_SENTINEL_NAME=redis-sentinel$(PROG_SUFFIX)\nREDIS_SERVER_OBJ=threads_mngr.o memory_prefetch.o adlist.o quicklist.o ae.o anet.o dict.o ebuckets.o eventnotifier.o iothread.o mstr.o entry.o kvstore.o fwtree.o estore.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o cluster_asm.o cluster_legacy.o cluster_slot_stats.o crc16.o endianconv.o slowlog.o eval.o bio.o rio.o rand.o memtest.o syscheck.o crcspeed.o crccombine.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o lolwut.o lolwut5.o lolwut6.o lolwut8.o acl.o tracking.o socket.o tls.o sha256.o timeout.o setcpuaffinity.o monotonic.o mt19937-64.o resp_parser.o call_reply.o script_lua.o script.o functions.o function_lua.o commands.o strl.o connection.o unix.o logreqres.o keymeta.o chk.o hotkeys.o gcra.o vector.o fast_float_strtod.o\nREDIS_CLI_NAME=redis-cli$(PROG_SUFFIX)\nREDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o zmalloc.o release.o ae.o redisassert.o crcspeed.o crccombine.o crc64.o siphash.o crc16.o monotonic.o cli_common.o mt19937-64.o strl.o cli_commands.o\nREDIS_BENCHMARK_NAME=redis-benchmark$(PROG_SUFFIX)\nREDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o redisassert.o release.o crcspeed.o crccombine.o crc64.o siphash.o crc16.o monotonic.o cli_common.o mt19937-64.o strl.o\nREDIS_CHECK_RDB_NAME=redis-check-rdb$(PROG_SUFFIX)\nREDIS_CHECK_AOF_NAME=redis-check-aof$(PROG_SUFFIX)\nALL_SOURCES=$(sort $(patsubst %.o,%.c,$(REDIS_SERVER_OBJ) $(REDIS_VEC_SETS_OBJ) $(REDIS_CLI_OBJ) $(REDIS_BENCHMARK_OBJ)))\n\nall: $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) $(TLS_MODULE) module_tests\n\t@echo \"\"\n\t@echo \"Hint: It's a good idea to run 'make test' ;)\"\n\t@echo \"\"\n\nMakefile.dep:\n\t-$(REDIS_CC) -MM $(ALL_SOURCES) > Makefile.dep 2> /dev/null || true\n\nifeq (0, $(words $(findstring $(MAKECMDGOALS), $(NODEPS))))\n-include Makefile.dep\nendif\n\n.PHONY: all\n\nmodule_tests: $(REDIS_SERVER_NAME)\n\t$(MAKE) -C ../tests/modules\n\n.PHONY: module_tests\n\npersist-settings: distclean\n\techo STD=$(STD) >> .make-settings\n\techo WARN=$(WARN) >> .make-settings\n\techo OPT=$(OPT) >> .make-settings\n\techo MALLOC=$(MALLOC) >> .make-settings\n\techo BUILD_TLS=$(BUILD_TLS) >> .make-settings\n\techo USE_SYSTEMD=$(USE_SYSTEMD) >> .make-settings\n\techo CFLAGS=$(CFLAGS) >> .make-settings\n\techo LDFLAGS=$(LDFLAGS) >> .make-settings\n\techo REDIS_CFLAGS=$(REDIS_CFLAGS) >> .make-settings\n\techo REDIS_LDFLAGS=$(REDIS_LDFLAGS) >> .make-settings\n\techo PREV_FINAL_CFLAGS=$(FINAL_CFLAGS) >> .make-settings\n\techo PREV_FINAL_LDFLAGS=$(FINAL_LDFLAGS) >> .make-settings\n\t-(cd ../deps && $(MAKE) $(DEPENDENCY_TARGETS))\n\n.PHONY: persist-settings\n\n# Prerequisites target\n.make-prerequisites:\n\t@touch $@\n\n# Clean everything, persist settings and build dependencies if anything changed\nifneq ($(strip $(PREV_FINAL_CFLAGS)), $(strip $(FINAL_CFLAGS)))\n.make-prerequisites: persist-settings\nendif\n\nifneq ($(strip $(PREV_FINAL_LDFLAGS)), $(strip $(FINAL_LDFLAGS)))\n.make-prerequisites: persist-settings\nendif\n\n# redis-server\n$(REDIS_SERVER_NAME): $(REDIS_SERVER_OBJ) $(REDIS_VEC_SETS_OBJ)\n\t$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/lua/src/liblua.a ../deps/hdr_histogram/libhdrhistogram.a ../deps/fpconv/libfpconv.a ../deps/xxhash/libxxhash.a $(FINAL_LIBS)\n\n# redis-sentinel\n$(REDIS_SENTINEL_NAME): $(REDIS_SERVER_NAME)\n\t$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME)\n\n# redis-check-rdb\n$(REDIS_CHECK_RDB_NAME): $(REDIS_SERVER_NAME)\n\t$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_CHECK_RDB_NAME)\n\n# redis-check-aof\n$(REDIS_CHECK_AOF_NAME): $(REDIS_SERVER_NAME)\n\t$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_CHECK_AOF_NAME)\n\n# redis-tls.so\n$(TLS_MODULE_NAME): $(REDIS_SERVER_NAME)\n\t$(QUIET_CC)$(CC) -o $@ tls.c -shared -fPIC $(TLS_MODULE_CFLAGS) $(TLS_CLIENT_LIBS)\n\n# redis-cli\n$(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)\n\t$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o ../deps/hdr_histogram/libhdrhistogram.a $(FINAL_LIBS) $(TLS_CLIENT_LIBS)\n\n# redis-benchmark\n$(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)\n\t$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/hdr_histogram/libhdrhistogram.a $(FINAL_LIBS) $(TLS_CLIENT_LIBS)\n\nDEP = $(REDIS_SERVER_OBJ:%.o=%.d) $(REDIS_VEC_SETS_OBJ:%.o=%.d) $(REDIS_CLI_OBJ:%.o=%.d) $(REDIS_BENCHMARK_OBJ:%.o=%.d)\n-include $(DEP)\n\n# Because the jemalloc.h header is generated as a part of the jemalloc build,\n# building it should complete before building any other object. Instead of\n# depending on a single artifact, build all dependencies first.\n%.o: %.c .make-prerequisites\n\t$(REDIS_CC) -MMD -o $@ -c $<\n\n# The following files are checked in and don't normally need to be rebuilt. They\n# are built only if python is available and their prereqs are modified.\nifneq (,$(PYTHON))\n$(COMMANDS_DEF_FILENAME).def: commands/*.json ../utils/generate-command-code.py\n\t$(QUIET_GEN)$(PYTHON) ../utils/generate-command-code.py $(GEN_COMMANDS_FLAGS)\n\nfmtargs.h: ../utils/generate-fmtargs.py\n\t$(QUITE_GEN)sed '/Everything below this line/,$$d' $@ > $@.tmp\n\t$(QUITE_GEN)$(PYTHON) ../utils/generate-fmtargs.py >> $@.tmp\n\t$(QUITE_GEN)mv $@.tmp $@\nendif\n\ncommands.c: $(COMMANDS_DEF_FILENAME).def\n\nclean:\n\trm -rf $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep *.so\n\trm -f $(DEP)\n\t-(cd ../tests/modules && $(MAKE) clean)\n\n.PHONY: clean\n\ndistclean: clean\n\t-(cd ../deps && $(MAKE) distclean)\n\t-(cd modules && $(MAKE) clean)\n\t-(cd ../tests/modules && $(MAKE) clean)\n\t-(rm -f .make-*)\n\n.PHONY: distclean\n\ntest: $(REDIS_SERVER_NAME) $(REDIS_CHECK_AOF_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) module_tests\n\t@(cd ..; ./runtest)\n\ntest-modules: $(REDIS_SERVER_NAME)\n\t@(cd ..; ./runtest-moduleapi)\n\ntest-sentinel: $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME)\n\t@(cd ..; ./runtest-sentinel)\n\ntest-cluster: $(REDIS_SERVER_NAME) $(REDIS_CLI_NAME)\n\t@(cd ..; ./runtest-cluster)\n\ncheck: test\n\nlcov:\n\t@lcov --version\n\t$(MAKE) gcov\n\t@(set -e; cd ..; ./runtest)\n\t@geninfo -o redis.info .\n\t@genhtml --legend -o lcov-html redis.info\n\n.PHONY: lcov\n\nbench: $(REDIS_BENCHMARK_NAME)\n\t./$(REDIS_BENCHMARK_NAME)\n\n32bit:\n\t@echo \"\"\n\t@echo \"WARNING: if it fails under Linux you probably need to install libc6-dev-i386\"\n\t@echo \"\"\n\t$(MAKE) CFLAGS=\"-m32\" LDFLAGS=\"-m32\" SKIP_VEC_SETS=\"yes\"\n\ngcov:\n\t$(MAKE) REDIS_CFLAGS=\"-fprofile-arcs -ftest-coverage -DCOVERAGE_TEST\" REDIS_LDFLAGS=\"-fprofile-arcs -ftest-coverage\"\n\nnoopt:\n\t$(MAKE) OPTIMIZATION=\"-O0\"\n\nvalgrind:\n\t$(MAKE) OPTIMIZATION=\"-O0\" MALLOC=\"libc\"\n\nhelgrind:\n\t$(MAKE) OPTIMIZATION=\"-O0\" MALLOC=\"libc\" CFLAGS=\"-D__ATOMIC_VAR_FORCE_SYNC_MACROS\" REDIS_CFLAGS=\"-I/usr/local/include\" REDIS_LDFLAGS=\"-L/usr/local/lib\"\n\ninstall: all\n\t@mkdir -p $(INSTALL_BIN)\n\t$(call MAKE_INSTALL,$(REDIS_SERVER_NAME),$(INSTALL_BIN))\n\t$(call MAKE_INSTALL,$(REDIS_BENCHMARK_NAME),$(INSTALL_BIN))\n\t$(call MAKE_INSTALL,$(REDIS_CLI_NAME),$(INSTALL_BIN))\n\t@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_CHECK_RDB_NAME)\n\t@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_CHECK_AOF_NAME)\n\t@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_SENTINEL_NAME)\n\nuninstall:\n\trm -f $(INSTALL_BIN)/{$(REDIS_SERVER_NAME),$(REDIS_BENCHMARK_NAME),$(REDIS_CLI_NAME),$(REDIS_CHECK_RDB_NAME),$(REDIS_CHECK_AOF_NAME),$(REDIS_SENTINEL_NAME)}\n" }, { "path": "src/acl.c", "content": "/*\n * Copyright (c) 2018-Present, Redis Ltd.\n * All rights reserved.\n *\n * Copyright (c) 2024-present, Valkey contributors.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \"cluster.h\"\n#include \"sha256.h\"\n#include \n#include \n\n/* =============================================================================\n * Global state for ACLs\n * ==========================================================================*/\n\nrax *Users; /* Table mapping usernames to user structures. */\n\nuser *DefaultUser; /* Global reference to the default user.\n Every new connection is associated to it, if no\n AUTH or HELLO is used to authenticate with a\n different user. */\n\nlist *UsersToLoad; /* This is a list of users found in the configuration file\n that we'll need to load in the final stage of Redis\n initialization, after all the modules are already\n loaded. Every list element is a NULL terminated\n array of SDS pointers: the first is the user name,\n all the remaining pointers are ACL rules in the same\n format as ACLSetUser(). */\nlist *ACLLog; /* Our security log, the user is able to inspect that\n using the ACL LOG command .*/\n\nlong long ACLLogEntryCount = 0; /* Number of ACL log entries created */\n\nstatic rax *commandId = NULL; /* Command name to id mapping */\n\nstatic unsigned long nextid = 0; /* Next command id that has not been assigned */\n\n#define ACL_MAX_CATEGORIES 64 /* Maximum number of command categories */\n\nstruct ACLCategoryItem {\n char *name;\n uint64_t flag;\n} ACLDefaultCommandCategories[] = { /* See redis.conf for details on each category. */\n {\"keyspace\", ACL_CATEGORY_KEYSPACE},\n {\"read\", ACL_CATEGORY_READ},\n {\"write\", ACL_CATEGORY_WRITE},\n {\"set\", ACL_CATEGORY_SET},\n {\"sortedset\", ACL_CATEGORY_SORTEDSET},\n {\"list\", ACL_CATEGORY_LIST},\n {\"hash\", ACL_CATEGORY_HASH},\n {\"string\", ACL_CATEGORY_STRING},\n {\"bitmap\", ACL_CATEGORY_BITMAP},\n {\"hyperloglog\", ACL_CATEGORY_HYPERLOGLOG},\n {\"geo\", ACL_CATEGORY_GEO},\n {\"stream\", ACL_CATEGORY_STREAM},\n {\"pubsub\", ACL_CATEGORY_PUBSUB},\n {\"admin\", ACL_CATEGORY_ADMIN},\n {\"fast\", ACL_CATEGORY_FAST},\n {\"slow\", ACL_CATEGORY_SLOW},\n {\"blocking\", ACL_CATEGORY_BLOCKING},\n {\"dangerous\", ACL_CATEGORY_DANGEROUS},\n {\"connection\", ACL_CATEGORY_CONNECTION},\n {\"transaction\", ACL_CATEGORY_TRANSACTION},\n {\"scripting\", ACL_CATEGORY_SCRIPTING},\n {\"ratelimit\", ACL_CATEGORY_RATE_LIMIT},\n {NULL,0} /* Terminator. */\n};\n\nstatic struct ACLCategoryItem *ACLCommandCategories = NULL;\nstatic size_t nextCommandCategory = 0; /* Index of the next command category to be added */\n\n/* Implements the ability to add to the list of ACL categories at runtime. Since each ACL category\n * also requires a bit in the acl_categories flag, there is a limit to the number that can be added.\n * The new ACL categories occupy the remaining bits of acl_categories flag, other than the bits\n * occupied by the default ACL command categories.\n * \n * The optional `flag` argument allows the assignment of the `acl_categories` flag bit to the ACL category.\n * When adding a new category, except for the default ACL command categories, this arguments should be `0`\n * to allow the function to assign the next available `acl_categories` flag bit to the new ACL category.\n *\n * returns 1 -> Added, 0 -> Failed (out of space)\n *\n * This function is present here to gain access to the ACLCommandCategories array and add a new ACL category.\n */\nint ACLAddCommandCategory(const char *name, uint64_t flag) {\n if (nextCommandCategory >= ACL_MAX_CATEGORIES) return 0;\n ACLCommandCategories[nextCommandCategory].name = zstrdup(name);\n ACLCommandCategories[nextCommandCategory].flag = flag != 0 ? flag : (1ULL<>4)];\n hex[j*2+1] = cset[(hash[j]&0xF)];\n }\n return sdsnewlen(hex,HASH_PASSWORD_LEN);\n}\n\n/* Given a hash and the hash length, returns C_OK if it is a valid password\n * hash, or C_ERR otherwise. */\nint ACLCheckPasswordHash(unsigned char *hash, int hashlen) {\n if (hashlen != HASH_PASSWORD_LEN) {\n return C_ERR;\n }\n\n /* Password hashes can only be characters that represent\n * hexadecimal values, which are numbers and lowercase\n * characters 'a' through 'f'. */\n for(int i = 0; i < HASH_PASSWORD_LEN; i++) {\n char c = hash[i];\n if ((c < 'a' || c > 'f') && (c < '0' || c > '9')) {\n return C_ERR;\n }\n }\n return C_OK;\n}\n\n/* =============================================================================\n * Low level ACL API\n * ==========================================================================*/\n\n/* Return 1 if the specified string contains spaces or null characters.\n * We do this for usernames and key patterns for simpler rewriting of\n * ACL rules, presentation on ACL list, and to avoid subtle security bugs\n * that may arise from parsing the rules in presence of escapes.\n * The function returns 0 if the string has no spaces. */\nint ACLStringHasSpaces(const char *s, size_t len) {\n for (size_t i = 0; i < len; i++) {\n if (isspace(s[i]) || s[i] == 0) return 1;\n }\n return 0;\n}\n\n/* Given the category name the command returns the corresponding flag, or\n * zero if there is no match. */\nuint64_t ACLGetCommandCategoryFlagByName(const char *name) {\n for (int j = 0; ACLCommandCategories[j].flag != 0; j++) {\n if (!strcasecmp(name,ACLCommandCategories[j].name)) {\n return ACLCommandCategories[j].flag;\n }\n }\n return 0; /* No match. */\n}\n\n/* Method for searching for a user within a list of user definitions. The\n * list contains an array of user arguments, and we are only\n * searching the first argument, the username, for a match. */\nint ACLListMatchLoadedUser(void *definition, void *user) {\n sds *user_definition = definition;\n return sdscmp(user_definition[0], user) == 0;\n}\n\n/* Method for passwords/pattern comparison used for the user->passwords list\n * so that we can search for items with listSearchKey(). */\nint ACLListMatchSds(void *a, void *b) {\n return sdscmp(a,b) == 0;\n}\n\n/* Method to free list elements from ACL users password/patterns lists. */\nvoid ACLListFreeSds(void *item) {\n sdsfreegeneric(item);\n}\n\n/* Method to duplicate list elements from ACL users password/patterns lists. */\nvoid *ACLListDupSds(void *item) {\n return sdsdup(item);\n}\n\n/* Structure used for handling key patterns with different key\n * based permissions. */\ntypedef struct {\n int flags; /* The ACL key permission types for this key pattern */\n sds pattern; /* The pattern to match keys against */\n} keyPattern;\n\n/* Create a new key pattern. */\nkeyPattern *ACLKeyPatternCreate(sds pattern, int flags) {\n keyPattern *new = (keyPattern *) zmalloc(sizeof(keyPattern));\n new->pattern = pattern;\n new->flags = flags;\n return new;\n}\n\n/* Free a key pattern and internal structures. */\nvoid ACLKeyPatternFree(keyPattern *pattern) {\n sdsfree(pattern->pattern);\n zfree(pattern);\n}\n\n/* Method for passwords/pattern comparison used for the user->passwords list\n * so that we can search for items with listSearchKey(). */\nint ACLListMatchKeyPattern(void *a, void *b) {\n return sdscmp(((keyPattern *) a)->pattern,((keyPattern *) b)->pattern) == 0;\n}\n\n/* Method to free list elements from ACL users password/patterns lists. */\nvoid ACLListFreeKeyPattern(void *item) {\n ACLKeyPatternFree(item);\n}\n\n/* Method to duplicate list elements from ACL users password/patterns lists. */\nvoid *ACLListDupKeyPattern(void *item) {\n keyPattern *old = (keyPattern *) item;\n return ACLKeyPatternCreate(sdsdup(old->pattern), old->flags);\n}\n\n/* Append the string representation of a key pattern onto the\n * provided base string. */\nsds sdsCatPatternString(sds base, keyPattern *pat) {\n if (pat->flags == ACL_ALL_PERMISSION) {\n base = sdscatlen(base,\"~\",1);\n } else if (pat->flags == ACL_READ_PERMISSION) {\n base = sdscatlen(base,\"%R~\",3);\n } else if (pat->flags == ACL_WRITE_PERMISSION) {\n base = sdscatlen(base,\"%W~\",3);\n } else {\n serverPanic(\"Invalid key pattern flag detected\");\n }\n return sdscatsds(base, pat->pattern);\n}\n\n/* Create an empty selector with the provided set of initial\n * flags. The selector will be default have no permissions. */\naclSelector *ACLCreateSelector(int flags) {\n aclSelector *selector = zmalloc(sizeof(aclSelector));\n selector->flags = flags | server.acl_pubsub_default;\n selector->patterns = listCreate();\n selector->channels = listCreate();\n selector->allowed_firstargs = NULL;\n selector->command_rules = sdsempty();\n\n listSetMatchMethod(selector->patterns,ACLListMatchKeyPattern);\n listSetFreeMethod(selector->patterns,ACLListFreeKeyPattern);\n listSetDupMethod(selector->patterns,ACLListDupKeyPattern);\n listSetMatchMethod(selector->channels,ACLListMatchSds);\n listSetFreeMethod(selector->channels,ACLListFreeSds);\n listSetDupMethod(selector->channels,ACLListDupSds);\n memset(selector->allowed_commands,0,sizeof(selector->allowed_commands));\n\n return selector;\n}\n\n/* Cleanup the provided selector, including all interior structures. */\nvoid ACLFreeSelector(aclSelector *selector) {\n listRelease(selector->patterns);\n listRelease(selector->channels);\n sdsfree(selector->command_rules);\n ACLResetFirstArgs(selector);\n zfree(selector);\n}\n\n/* Create an exact copy of the provided selector. */\naclSelector *ACLCopySelector(aclSelector *src) {\n aclSelector *dst = zmalloc(sizeof(aclSelector));\n dst->flags = src->flags;\n dst->patterns = listDup(src->patterns);\n dst->channels = listDup(src->channels);\n dst->command_rules = sdsdup(src->command_rules);\n memcpy(dst->allowed_commands,src->allowed_commands,\n sizeof(dst->allowed_commands));\n dst->allowed_firstargs = NULL;\n /* Copy the allowed first-args array of array of SDS strings. */\n if (src->allowed_firstargs) {\n for (int j = 0; j < USER_COMMAND_BITS_COUNT; j++) {\n if (!(src->allowed_firstargs[j])) continue;\n for (int i = 0; src->allowed_firstargs[j][i]; i++) {\n ACLAddAllowedFirstArg(dst, j, src->allowed_firstargs[j][i]);\n }\n }\n }\n return dst;\n}\n\n/* List method for freeing a selector */\nvoid ACLListFreeSelector(void *a) {\n ACLFreeSelector((aclSelector *) a);\n}\n\n/* List method for duplicating a selector */\nvoid *ACLListDuplicateSelector(void *src) {\n return ACLCopySelector((aclSelector *)src);\n}\n\n/* All users have an implicit root selector which\n * provides backwards compatibility to the old ACLs-\n * permissions. */\naclSelector *ACLUserGetRootSelector(user *u) {\n serverAssert(listLength(u->selectors));\n aclSelector *s = (aclSelector *) listNodeValue(listFirst(u->selectors));\n serverAssert(s->flags & SELECTOR_FLAG_ROOT);\n return s;\n}\n\n/* Create a new user with the specified name, store it in the list\n * of users (the Users global radix tree), and returns a reference to\n * the structure representing the user.\n *\n * If the user with such name already exists NULL is returned. */\nuser *ACLCreateUser(const char *name, size_t namelen) {\n if (raxFind(Users,(unsigned char*)name,namelen,NULL)) return NULL;\n user *u = zmalloc(sizeof(*u));\n u->name = sdsnewlen(name,namelen);\n atomicSet(u->flags, USER_FLAG_DISABLED | USER_FLAG_SANITIZE_PAYLOAD);\n u->passwords = listCreate();\n u->acl_string = NULL;\n listSetMatchMethod(u->passwords,ACLListMatchSds);\n listSetFreeMethod(u->passwords,ACLListFreeSds);\n listSetDupMethod(u->passwords,ACLListDupSds);\n\n u->selectors = listCreate();\n listSetFreeMethod(u->selectors,ACLListFreeSelector);\n listSetDupMethod(u->selectors,ACLListDuplicateSelector);\n\n /* Add the initial root selector */\n aclSelector *s = ACLCreateSelector(SELECTOR_FLAG_ROOT);\n listAddNodeHead(u->selectors, s);\n\n raxInsert(Users,(unsigned char*)name,namelen,u,NULL);\n return u;\n}\n\n/* This function should be called when we need an unlinked \"fake\" user\n * we can use in order to validate ACL rules or for other similar reasons.\n * The user will not get linked to the Users radix tree. The returned\n * user should be released with ACLFreeUser() as usually. */\nuser *ACLCreateUnlinkedUser(void) {\n char username[64];\n for (int j = 0; ; j++) {\n snprintf(username,sizeof(username),\"__fakeuser:%d__\",j);\n user *fakeuser = ACLCreateUser(username,strlen(username));\n if (fakeuser == NULL) continue;\n int retval = raxRemove(Users,(unsigned char*) username,\n strlen(username),NULL);\n serverAssert(retval != 0);\n return fakeuser;\n }\n}\n\n/* Release the memory used by the user structure. Note that this function\n * will not remove the user from the Users global radix tree. */\nvoid ACLFreeUser(user *u) {\n sdsfree(u->name);\n if (u->acl_string) {\n decrRefCount(u->acl_string);\n u->acl_string = NULL;\n }\n listRelease(u->passwords);\n listRelease(u->selectors);\n zfree(u);\n}\n\n/* Generic version of ACLFreeUser. */\nvoid ACLFreeUserGeneric(void *u) {\n ACLFreeUser((user *)u);\n}\n\n/* When a user is deleted we need to cycle the active\n * connections in order to kill all the pending ones that\n * are authenticated with such user. */\nvoid ACLFreeUserAndKillClients(user *u) {\n listIter li;\n listNode *ln;\n listRewind(server.clients,&li);\n while ((ln = listNext(&li)) != NULL) {\n client *c = listNodeValue(ln);\n if (c->user == u) {\n /* We'll free the connection asynchronously, so\n * in theory to set a different user is not needed.\n * However if there are bugs in Redis, soon or later\n * this may result in some security hole: it's much\n * more defensive to set the default user and put\n * it in non authenticated mode. */\n deauthenticateAndCloseClient(c);\n }\n }\n ACLFreeUser(u);\n}\n\n/* Copy the user ACL rules from the source user 'src' to the destination\n * user 'dst' so that at the end of the process they'll have exactly the\n * same rules (but the names will continue to be the original ones). */\nvoid ACLCopyUser(user *dst, user *src) {\n listRelease(dst->passwords);\n listRelease(dst->selectors);\n dst->passwords = listDup(src->passwords);\n dst->selectors = listDup(src->selectors);\n dst->flags = src->flags;\n if (dst->acl_string) {\n decrRefCount(dst->acl_string);\n }\n dst->acl_string = src->acl_string;\n if (dst->acl_string) {\n /* if src is NULL, we set it to NULL, if not, need to increment reference count */\n incrRefCount(dst->acl_string);\n }\n}\n\n/* Given a command ID, this function set by reference 'word' and 'bit'\n * so that user->allowed_commands[word] will address the right word\n * where the corresponding bit for the provided ID is stored, and\n * so that user->allowed_commands[word]&bit will identify that specific\n * bit. The function returns C_ERR in case the specified ID overflows\n * the bitmap in the user representation. */\nint ACLGetCommandBitCoordinates(uint64_t id, uint64_t *word, uint64_t *bit) {\n if (id >= USER_COMMAND_BITS_COUNT) return C_ERR;\n *word = id / sizeof(uint64_t) / 8;\n *bit = 1ULL << (id % (sizeof(uint64_t) * 8));\n return C_OK;\n}\n\n/* Check if the specified command bit is set for the specified user.\n * The function returns 1 is the bit is set or 0 if it is not.\n * Note that this function does not check the ALLCOMMANDS flag of the user\n * but just the lowlevel bitmask.\n *\n * If the bit overflows the user internal representation, zero is returned\n * in order to disallow the execution of the command in such edge case. */\nint ACLGetSelectorCommandBit(const aclSelector *selector, unsigned long id) {\n uint64_t word, bit;\n if (ACLGetCommandBitCoordinates(id,&word,&bit) == C_ERR) return 0;\n return (selector->allowed_commands[word] & bit) != 0;\n}\n\n/* When +@all or allcommands is given, we set a reserved bit as well that we\n * can later test, to see if the user has the right to execute \"future commands\",\n * that is, commands loaded later via modules. */\nint ACLSelectorCanExecuteFutureCommands(aclSelector *selector) {\n return ACLGetSelectorCommandBit(selector,USER_COMMAND_BITS_COUNT-1);\n}\n\n/* Set the specified command bit for the specified user to 'value' (0 or 1).\n * If the bit overflows the user internal representation, no operation\n * is performed. As a side effect of calling this function with a value of\n * zero, the user flag ALLCOMMANDS is cleared since it is no longer possible\n * to skip the command bit explicit test. */\nvoid ACLSetSelectorCommandBit(aclSelector *selector, unsigned long id, int value) {\n uint64_t word, bit;\n if (ACLGetCommandBitCoordinates(id,&word,&bit) == C_ERR) return;\n if (value) {\n selector->allowed_commands[word] |= bit;\n } else {\n selector->allowed_commands[word] &= ~bit;\n selector->flags &= ~SELECTOR_FLAG_ALLCOMMANDS;\n }\n}\n\n/* Remove a rule from the retained command rules. Always match rules\n * verbatim, but also remove subcommand rules if we are adding or removing the \n * entire command. */\nvoid ACLSelectorRemoveCommandRule(aclSelector *selector, sds new_rule) {\n size_t new_len = sdslen(new_rule);\n char *existing_rule = selector->command_rules;\n\n /* Loop over the existing rules, trying to find a rule that \"matches\"\n * the new rule. If we find a match, then remove the command from the string by\n * copying the later rules over it. */\n while(existing_rule[0]) {\n /* The first character of the rule is +/-, which we don't need to compare. */\n char *copy_position = existing_rule;\n existing_rule += 1;\n\n /* Assume a trailing space after a command is part of the command, like '+get ', so trim it\n * as well if the command is removed. */\n char *rule_end = strchr(existing_rule, ' ');\n if (!rule_end) {\n /* This is the last rule, so move it to the end of the string. */\n rule_end = existing_rule + strlen(existing_rule);\n\n /* This approach can leave a trailing space if the last rule is removed,\n * but only if it's not the first rule, so handle that case. */\n if (copy_position != selector->command_rules) copy_position -= 1;\n }\n char *copy_end = rule_end;\n if (*copy_end == ' ') copy_end++;\n\n /* Exact match or the rule we are comparing is a subcommand denoted by '|' */\n size_t existing_len = rule_end - existing_rule;\n if (!memcmp(existing_rule, new_rule, min(existing_len, new_len))) {\n if ((existing_len == new_len) || (existing_len > new_len && (existing_rule[new_len]) == '|')) {\n /* Copy the remaining rules starting at the next rule to replace the rule to be\n * deleted, including the terminating NULL character. */\n memmove(copy_position, copy_end, strlen(copy_end) + 1);\n existing_rule = copy_position;\n continue;\n }\n }\n existing_rule = copy_end;\n }\n\n /* There is now extra padding at the end of the rules, so clean that up. */\n sdsupdatelen(selector->command_rules);\n}\n\n/* This function is resopnsible for updating the command_rules struct so that relative ordering of\n * commands and categories is maintained and can be reproduced without loss. */\nvoid ACLUpdateCommandRules(aclSelector *selector, const char *rule, int allow) {\n sds new_rule = sdsnew(rule);\n sdstolower(new_rule);\n\n ACLSelectorRemoveCommandRule(selector, new_rule);\n if (sdslen(selector->command_rules)) selector->command_rules = sdscat(selector->command_rules, \" \");\n selector->command_rules = sdscatfmt(selector->command_rules, allow ? \"+%S\" : \"-%S\", new_rule);\n sdsfree(new_rule);\n}\n\n/* This function is used to allow/block a specific command.\n * Allowing/blocking a container command also applies for its subcommands */\nvoid ACLChangeSelectorPerm(aclSelector *selector, struct redisCommand *cmd, int allow) {\n unsigned long id = cmd->id;\n ACLSetSelectorCommandBit(selector,id,allow);\n ACLResetFirstArgsForCommand(selector,id);\n if (cmd->subcommands_dict) {\n dictEntry *de;\n dictIterator di;\n dictInitSafeIterator(&di, cmd->subcommands_dict);\n while((de = dictNext(&di)) != NULL) {\n struct redisCommand *sub = (struct redisCommand *)dictGetVal(de);\n ACLSetSelectorCommandBit(selector,sub->id,allow);\n }\n dictResetIterator(&di);\n }\n}\n\n/* This is like ACLSetSelectorCommandBit(), but instead of setting the specified\n * ID, it will check all the commands in the category specified as argument,\n * and will set all the bits corresponding to such commands to the specified\n * value. Since the category passed by the user may be non existing, the\n * function returns C_ERR if the category was not found, or C_OK if it was\n * found and the operation was performed. */\nvoid ACLSetSelectorCommandBitsForCategory(dict *commands, aclSelector *selector, uint64_t cflag, int value) {\n dictIterator di;\n dictEntry *de;\n dictInitIterator(&di, commands);\n while ((de = dictNext(&di)) != NULL) {\n struct redisCommand *cmd = dictGetVal(de);\n if (cmd->acl_categories & cflag) {\n ACLChangeSelectorPerm(selector,cmd,value);\n }\n if (cmd->subcommands_dict) {\n ACLSetSelectorCommandBitsForCategory(cmd->subcommands_dict, selector, cflag, value);\n }\n }\n dictResetIterator(&di);\n}\n\n/* This function is responsible for recomputing the command bits for all selectors of the existing users.\n * It uses the 'command_rules', a string representation of the ordered categories and commands, \n * to recompute the command bits. */\nvoid ACLRecomputeCommandBitsFromCommandRulesAllUsers(void) {\n raxIterator ri;\n raxStart(&ri,Users);\n raxSeek(&ri,\"^\",NULL,0);\n while(raxNext(&ri)) {\n user *u = ri.data;\n listIter li;\n listNode *ln;\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *selector = (aclSelector *) listNodeValue(ln);\n int argc = 0;\n sds *argv = sdssplitargs(selector->command_rules, &argc);\n serverAssert(argv != NULL);\n /* Checking selector's permissions for all commands to start with a clean state. */\n if (ACLSelectorCanExecuteFutureCommands(selector)) {\n int res = ACLSetSelector(selector,\"+@all\",-1);\n serverAssert(res == C_OK);\n } else {\n int res = ACLSetSelector(selector,\"-@all\",-1);\n serverAssert(res == C_OK);\n }\n\n /* Apply all of the commands and categories to this selector. */\n for(int i = 0; i < argc; i++) {\n int res = ACLSetSelector(selector, argv[i], sdslen(argv[i]));\n serverAssert(res == C_OK);\n }\n sdsfreesplitres(argv, argc);\n }\n }\n raxStop(&ri);\n\n}\n\nint ACLSetSelectorCategory(aclSelector *selector, const char *category, int allow) {\n uint64_t cflag = ACLGetCommandCategoryFlagByName(category + 1);\n if (!cflag) return C_ERR;\n\n ACLUpdateCommandRules(selector, category, allow);\n\n /* Set the actual command bits on the selector. */\n ACLSetSelectorCommandBitsForCategory(server.orig_commands, selector, cflag, allow);\n return C_OK;\n}\n\nvoid ACLCountCategoryBitsForCommands(dict *commands, aclSelector *selector, unsigned long *on, unsigned long *off, uint64_t cflag) {\n dictIterator di;\n dictEntry *de;\n dictInitIterator(&di, commands);\n while ((de = dictNext(&di)) != NULL) {\n struct redisCommand *cmd = dictGetVal(de);\n if (cmd->acl_categories & cflag) {\n if (ACLGetSelectorCommandBit(selector,cmd->id))\n (*on)++;\n else\n (*off)++;\n }\n if (cmd->subcommands_dict) {\n ACLCountCategoryBitsForCommands(cmd->subcommands_dict, selector, on, off, cflag);\n }\n }\n dictResetIterator(&di);\n}\n\n/* Return the number of commands allowed (on) and denied (off) for the user 'u'\n * in the subset of commands flagged with the specified category name.\n * If the category name is not valid, C_ERR is returned, otherwise C_OK is\n * returned and on and off are populated by reference. */\nint ACLCountCategoryBitsForSelector(aclSelector *selector, unsigned long *on, unsigned long *off,\n const char *category)\n{\n uint64_t cflag = ACLGetCommandCategoryFlagByName(category);\n if (!cflag) return C_ERR;\n\n *on = *off = 0;\n ACLCountCategoryBitsForCommands(server.orig_commands, selector, on, off, cflag);\n return C_OK;\n}\n\n/* This function returns an SDS string representing the specified selector ACL\n * rules related to command execution, in the same format you could set them\n * back using ACL SETUSER. The function will return just the set of rules needed\n * to recreate the user commands bitmap, without including other user flags such\n * as on/off, passwords and so forth. The returned string always starts with\n * the +@all or -@all rule, depending on the user bitmap, and is followed, if\n * needed, by the other rules needed to narrow or extend what the user can do. */\nsds ACLDescribeSelectorCommandRules(aclSelector *selector) {\n sds rules = sdsempty();\n\n /* We use this fake selector as a \"sanity\" check to make sure the rules\n * we generate have the same bitmap as those on the current selector. */\n aclSelector *fake_selector = ACLCreateSelector(0);\n\n /* Here we want to understand if we should start with +@all or -@all.\n * Note that when starting with +@all and subtracting, the user\n * will be able to execute future commands, while -@all and adding will just\n * allow the user the run the selected commands and/or categories.\n * How do we test for that? We use the trick of a reserved command ID bit\n * that is set only by +@all (and its alias \"allcommands\"). */\n if (ACLSelectorCanExecuteFutureCommands(selector)) {\n rules = sdscat(rules,\"+@all \");\n ACLSetSelector(fake_selector,\"+@all\",-1);\n } else {\n rules = sdscat(rules,\"-@all \");\n ACLSetSelector(fake_selector,\"-@all\",-1);\n }\n\n /* Apply all of the commands and categories to the fake selector. */\n int argc = 0;\n sds *argv = sdssplitargs(selector->command_rules, &argc);\n serverAssert(argv != NULL);\n\n for(int i = 0; i < argc; i++) {\n int res = ACLSetSelector(fake_selector, argv[i], -1);\n serverAssert(res == C_OK);\n }\n if (sdslen(selector->command_rules)) {\n rules = sdscatfmt(rules, \"%S \", selector->command_rules);\n }\n sdsfreesplitres(argv, argc);\n\n /* Trim the final useless space. */\n sdsrange(rules,0,-2);\n\n /* This is technically not needed, but we want to verify that now the\n * predicted bitmap is exactly the same as the user bitmap, and abort\n * otherwise, because aborting is better than a security risk in this\n * code path. */\n if (memcmp(fake_selector->allowed_commands,\n selector->allowed_commands,\n sizeof(selector->allowed_commands)) != 0)\n {\n serverLog(LL_WARNING,\n \"CRITICAL ERROR: User ACLs don't match final bitmap: '%s'\",\n redactLogCstr(rules));\n serverPanic(\"No bitmap match in ACLDescribeSelectorCommandRules()\");\n }\n ACLFreeSelector(fake_selector);\n return rules;\n}\n\nsds ACLDescribeSelector(aclSelector *selector) {\n listIter li;\n listNode *ln;\n sds res = sdsempty();\n /* Key patterns. */\n if (selector->flags & SELECTOR_FLAG_ALLKEYS) {\n res = sdscatlen(res,\"~* \",3);\n } else {\n listRewind(selector->patterns,&li);\n while((ln = listNext(&li))) {\n keyPattern *thispat = (keyPattern *)listNodeValue(ln);\n res = sdsCatPatternString(res, thispat);\n res = sdscatlen(res,\" \",1);\n }\n }\n\n /* Pub/sub channel patterns. */\n if (selector->flags & SELECTOR_FLAG_ALLCHANNELS) {\n res = sdscatlen(res,\"&* \",3);\n } else {\n res = sdscatlen(res,\"resetchannels \",14);\n listRewind(selector->channels,&li);\n while((ln = listNext(&li))) {\n sds thispat = listNodeValue(ln);\n res = sdscatlen(res,\"&\",1);\n res = sdscatsds(res,thispat);\n res = sdscatlen(res,\" \",1);\n }\n }\n\n /* Command rules. */\n sds rules = ACLDescribeSelectorCommandRules(selector);\n res = sdscatsds(res,rules);\n sdsfree(rules);\n return res;\n}\n\n/* This is similar to ACLDescribeSelectorCommandRules(), however instead of\n * describing just the user command rules, everything is described: user\n * flags, keys, passwords and finally the command rules obtained via\n * the ACLDescribeSelectorCommandRules() function. This is the function we call\n * when we want to rewrite the configuration files describing ACLs and\n * in order to show users with ACL LIST. */\nrobj *ACLDescribeUser(user *u) {\n if (u->acl_string) {\n incrRefCount(u->acl_string);\n return u->acl_string;\n }\n\n sds res = sdsempty();\n\n /* Flags. */\n for (int j = 0; ACLUserFlags[j].flag; j++) {\n if (u->flags & ACLUserFlags[j].flag) {\n res = sdscat(res,ACLUserFlags[j].name);\n res = sdscatlen(res,\" \",1);\n }\n }\n\n /* Passwords. */\n listIter li;\n listNode *ln;\n listRewind(u->passwords,&li);\n while((ln = listNext(&li))) {\n sds thispass = listNodeValue(ln);\n res = sdscatlen(res,\"#\",1);\n res = sdscatsds(res,thispass);\n res = sdscatlen(res,\" \",1);\n }\n\n /* Selectors (Commands and keys) */\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *selector = (aclSelector *) listNodeValue(ln);\n sds default_perm = ACLDescribeSelector(selector);\n if (selector->flags & SELECTOR_FLAG_ROOT) {\n res = sdscatfmt(res, \"%s\", default_perm);\n } else {\n res = sdscatfmt(res, \" (%s)\", default_perm);\n }\n sdsfree(default_perm);\n }\n\n u->acl_string = createObject(OBJ_STRING, res);\n /* because we are returning it, have to increase count */\n incrRefCount(u->acl_string);\n\n return u->acl_string;\n}\n\n/* Get a command from the original command table, that is not affected\n * by the command renaming operations: we base all the ACL work from that\n * table, so that ACLs are valid regardless of command renaming. */\nstruct redisCommand *ACLLookupCommand(const char *name) {\n struct redisCommand *cmd;\n sds sdsname = sdsnew(name);\n cmd = lookupCommandBySdsLogic(server.orig_commands,sdsname);\n sdsfree(sdsname);\n return cmd;\n}\n\n/* Flush the array of allowed first-args for the specified user\n * and command ID. */\nvoid ACLResetFirstArgsForCommand(aclSelector *selector, unsigned long id) {\n if (selector->allowed_firstargs && selector->allowed_firstargs[id]) {\n for (int i = 0; selector->allowed_firstargs[id][i]; i++)\n sdsfree(selector->allowed_firstargs[id][i]);\n zfree(selector->allowed_firstargs[id]);\n selector->allowed_firstargs[id] = NULL;\n }\n}\n\n/* Flush the entire table of first-args. This is useful on +@all, -@all\n * or similar to return back to the minimal memory usage (and checks to do)\n * for the user. */\nvoid ACLResetFirstArgs(aclSelector *selector) {\n if (selector->allowed_firstargs == NULL) return;\n for (int j = 0; j < USER_COMMAND_BITS_COUNT; j++) {\n if (selector->allowed_firstargs[j]) {\n for (int i = 0; selector->allowed_firstargs[j][i]; i++)\n sdsfree(selector->allowed_firstargs[j][i]);\n zfree(selector->allowed_firstargs[j]);\n }\n }\n zfree(selector->allowed_firstargs);\n selector->allowed_firstargs = NULL;\n}\n\n/* Add a first-arg to the list of subcommands for the user 'u' and\n * the command id specified. */\nvoid ACLAddAllowedFirstArg(aclSelector *selector, unsigned long id, const char *sub) {\n /* If this is the first first-arg to be configured for\n * this user, we have to allocate the first-args array. */\n if (selector->allowed_firstargs == NULL) {\n selector->allowed_firstargs = zcalloc(USER_COMMAND_BITS_COUNT * sizeof(sds*));\n }\n\n /* We also need to enlarge the allocation pointing to the\n * null terminated SDS array, to make space for this one.\n * To start check the current size, and while we are here\n * make sure the first-arg is not already specified inside. */\n long items = 0;\n if (selector->allowed_firstargs[id]) {\n while(selector->allowed_firstargs[id][items]) {\n /* If it's already here do not add it again. */\n if (!strcasecmp(selector->allowed_firstargs[id][items],sub))\n return;\n items++;\n }\n }\n\n /* Now we can make space for the new item (and the null term). */\n items += 2;\n selector->allowed_firstargs[id] = zrealloc(selector->allowed_firstargs[id], sizeof(sds)*items);\n selector->allowed_firstargs[id][items-2] = sdsnew(sub);\n selector->allowed_firstargs[id][items-1] = NULL;\n}\n\n/* Create an ACL selector from the given ACL operations, which should be \n * a list of space separate ACL operations that starts and ends \n * with parentheses.\n *\n * If any of the operations are invalid, NULL will be returned instead\n * and errno will be set corresponding to the interior error. */\naclSelector *aclCreateSelectorFromOpSet(const char *opset, size_t opsetlen) {\n serverAssert(opset[0] == '(' && opset[opsetlen - 1] == ')');\n aclSelector *s = ACLCreateSelector(0);\n\n int argc = 0;\n sds trimmed = sdsnewlen(opset + 1, opsetlen - 2);\n sds *argv = sdssplitargs(trimmed, &argc);\n for (int i = 0; i < argc; i++) {\n if (ACLSetSelector(s, argv[i], sdslen(argv[i])) == C_ERR) {\n ACLFreeSelector(s);\n s = NULL;\n goto cleanup;\n }\n }\n\ncleanup:\n sdsfreesplitres(argv, argc);\n sdsfree(trimmed);\n return s;\n}\n\n/* Set a selector's properties with the provided 'op'.\n *\n * + Allow the execution of that command.\n * May be used with `|` for allowing subcommands (e.g \"+config|get\")\n * - Disallow the execution of that command.\n * May be used with `|` for blocking subcommands (e.g \"-config|set\")\n * +@ Allow the execution of all the commands in such category\n * with valid categories are like @admin, @set, @sortedset, ...\n * and so forth, see the full list in the server.c file where\n * the Redis command table is described and defined.\n * The special category @all means all the commands, but currently\n * present in the server, and that will be loaded in the future\n * via modules.\n * +|first-arg Allow a specific first argument of an otherwise\n * disabled command. Note that this form is not\n * allowed as negative like -SELECT|1, but\n * only additive starting with \"+\".\n * allcommands Alias for +@all. Note that it implies the ability to execute\n * all the future commands loaded via the modules system.\n * nocommands Alias for -@all.\n * ~ Add a pattern of keys that can be mentioned as part of\n * commands. For instance ~* allows all the keys. The pattern\n * is a glob-style pattern like the one of KEYS.\n * It is possible to specify multiple patterns.\n * %R~ Add key read pattern that specifies which keys can be read\n * from.\n * %W~ Add key write pattern that specifies which keys can be\n * written to.\n * allkeys Alias for ~*\n * resetkeys Flush the list of allowed keys patterns.\n * & Add a pattern of channels that can be mentioned as part of\n * Pub/Sub commands. For instance &* allows all the channels. The\n * pattern is a glob-style pattern like the one of PSUBSCRIBE.\n * It is possible to specify multiple patterns.\n * allchannels Alias for &*\n * resetchannels Flush the list of allowed channel patterns.\n */\nint ACLSetSelector(aclSelector *selector, const char* op, size_t oplen) {\n if (!strcasecmp(op,\"allkeys\") ||\n !strcasecmp(op,\"~*\"))\n {\n selector->flags |= SELECTOR_FLAG_ALLKEYS;\n listEmpty(selector->patterns);\n } else if (!strcasecmp(op,\"resetkeys\")) {\n selector->flags &= ~SELECTOR_FLAG_ALLKEYS;\n listEmpty(selector->patterns);\n } else if (!strcasecmp(op,\"allchannels\") ||\n !strcasecmp(op,\"&*\"))\n {\n selector->flags |= SELECTOR_FLAG_ALLCHANNELS;\n listEmpty(selector->channels);\n } else if (!strcasecmp(op,\"resetchannels\")) {\n selector->flags &= ~SELECTOR_FLAG_ALLCHANNELS;\n listEmpty(selector->channels);\n } else if (!strcasecmp(op,\"allcommands\") ||\n !strcasecmp(op,\"+@all\"))\n {\n memset(selector->allowed_commands,255,sizeof(selector->allowed_commands));\n selector->flags |= SELECTOR_FLAG_ALLCOMMANDS;\n sdsclear(selector->command_rules);\n ACLResetFirstArgs(selector);\n } else if (!strcasecmp(op,\"nocommands\") ||\n !strcasecmp(op,\"-@all\"))\n {\n memset(selector->allowed_commands,0,sizeof(selector->allowed_commands));\n selector->flags &= ~SELECTOR_FLAG_ALLCOMMANDS;\n sdsclear(selector->command_rules);\n ACLResetFirstArgs(selector);\n } else if (op[0] == '~' || op[0] == '%') {\n if (selector->flags & SELECTOR_FLAG_ALLKEYS) {\n errno = EEXIST;\n return C_ERR;\n }\n int flags = 0;\n size_t offset = 1;\n if (op[0] == '%') {\n int perm_ok = 1;\n for (; offset < oplen; offset++) {\n if (toupper(op[offset]) == 'R' && !(flags & ACL_READ_PERMISSION)) {\n flags |= ACL_READ_PERMISSION;\n } else if (toupper(op[offset]) == 'W' && !(flags & ACL_WRITE_PERMISSION)) {\n flags |= ACL_WRITE_PERMISSION;\n } else if (op[offset] == '~') {\n offset++;\n break;\n } else {\n perm_ok = 0;\n break;\n }\n }\n if (!flags || !perm_ok) {\n errno = EINVAL;\n return C_ERR;\n }\n } else {\n flags = ACL_ALL_PERMISSION;\n }\n\n if (ACLStringHasSpaces(op+offset,oplen-offset)) {\n errno = EINVAL;\n return C_ERR;\n }\n keyPattern *newpat = ACLKeyPatternCreate(sdsnewlen(op+offset,oplen-offset), flags);\n listNode *ln = listSearchKey(selector->patterns,newpat);\n /* Avoid re-adding the same key pattern multiple times. */\n if (ln == NULL) {\n listAddNodeTail(selector->patterns,newpat);\n } else {\n ((keyPattern *)listNodeValue(ln))->flags |= flags;\n ACLKeyPatternFree(newpat);\n }\n selector->flags &= ~SELECTOR_FLAG_ALLKEYS;\n } else if (op[0] == '&') {\n if (selector->flags & SELECTOR_FLAG_ALLCHANNELS) {\n errno = EISDIR;\n return C_ERR;\n }\n if (ACLStringHasSpaces(op+1,oplen-1)) {\n errno = EINVAL;\n return C_ERR;\n }\n sds newpat = sdsnewlen(op+1,oplen-1);\n listNode *ln = listSearchKey(selector->channels,newpat);\n /* Avoid re-adding the same channel pattern multiple times. */\n if (ln == NULL)\n listAddNodeTail(selector->channels,newpat);\n else\n sdsfree(newpat);\n selector->flags &= ~SELECTOR_FLAG_ALLCHANNELS;\n } else if (op[0] == '+' && op[1] != '@') {\n if (strrchr(op,'|') == NULL) {\n struct redisCommand *cmd = ACLLookupCommand(op+1);\n if (cmd == NULL) {\n errno = ENOENT;\n return C_ERR;\n }\n ACLChangeSelectorPerm(selector,cmd,1);\n ACLUpdateCommandRules(selector,cmd->fullname,1);\n } else {\n /* Split the command and subcommand parts. */\n char *copy = zstrdup(op+1);\n char *sub = strrchr(copy,'|');\n sub[0] = '\\0';\n sub++;\n\n struct redisCommand *cmd = ACLLookupCommand(copy);\n\n /* Check if the command exists. We can't check the\n * first-arg to see if it is valid. */\n if (cmd == NULL) {\n zfree(copy);\n errno = ENOENT;\n return C_ERR;\n }\n\n /* We do not support allowing first-arg of a subcommand */\n if (cmd->parent) {\n zfree(copy);\n errno = ECHILD;\n return C_ERR;\n }\n\n /* The subcommand cannot be empty, so things like DEBUG|\n * are syntax errors of course. */\n if (strlen(sub) == 0) {\n zfree(copy);\n errno = EINVAL;\n return C_ERR;\n }\n\n if (cmd->subcommands_dict) {\n /* If user is trying to allow a valid subcommand we can just add its unique ID */\n cmd = ACLLookupCommand(op+1);\n if (cmd == NULL) {\n zfree(copy);\n errno = ENOENT;\n return C_ERR;\n }\n ACLChangeSelectorPerm(selector,cmd,1);\n } else {\n /* If user is trying to use the ACL mech to block SELECT except SELECT 0 or\n * block DEBUG except DEBUG OBJECT (DEBUG subcommands are not considered\n * subcommands for now) we use the allowed_firstargs mechanism. */\n\n /* Add the first-arg to the list of valid ones. */\n serverLog(LL_WARNING, \"Deprecation warning: Allowing a first arg of an otherwise \"\n \"blocked command is a misuse of ACL and may get disabled \"\n \"in the future (offender: +%s)\", redactLogCstr(op+1));\n ACLAddAllowedFirstArg(selector,cmd->id,sub);\n }\n ACLUpdateCommandRules(selector,op+1,1);\n zfree(copy);\n }\n } else if (op[0] == '-' && op[1] != '@') {\n struct redisCommand *cmd = ACLLookupCommand(op+1);\n if (cmd == NULL) {\n errno = ENOENT;\n return C_ERR;\n }\n ACLChangeSelectorPerm(selector,cmd,0);\n ACLUpdateCommandRules(selector,cmd->fullname,0);\n } else if ((op[0] == '+' || op[0] == '-') && op[1] == '@') {\n int bitval = op[0] == '+' ? 1 : 0;\n if (ACLSetSelectorCategory(selector,op+1,bitval) == C_ERR) {\n errno = ENOENT;\n return C_ERR;\n }\n } else {\n errno = EINVAL;\n return C_ERR;\n }\n return C_OK;\n}\n\n/* Set user properties according to the string \"op\". The following\n * is a description of what different strings will do:\n *\n * on Enable the user: it is possible to authenticate as this user.\n * off Disable the user: it's no longer possible to authenticate\n * with this user, however the already authenticated connections\n * will still work.\n * skip-sanitize-payload RESTORE dump-payload sanitization is skipped.\n * sanitize-payload RESTORE dump-payload is sanitized (default).\n * > Add this password to the list of valid password for the user.\n * For example >mypass will add \"mypass\" to the list.\n * This directive clears the \"nopass\" flag (see later).\n * # Add this password hash to the list of valid hashes for\n * the user. This is useful if you have previously computed\n * the hash, and don't want to store it in plaintext.\n * This directive clears the \"nopass\" flag (see later).\n * < Remove this password from the list of valid passwords.\n * ! Remove this hashed password from the list of valid passwords.\n * This is useful when you want to remove a password just by\n * hash without knowing its plaintext version at all.\n * nopass All the set passwords of the user are removed, and the user\n * is flagged as requiring no password: it means that every\n * password will work against this user. If this directive is\n * used for the default user, every new connection will be\n * immediately authenticated with the default user without\n * any explicit AUTH command required. Note that the \"resetpass\"\n * directive will clear this condition.\n * resetpass Flush the list of allowed passwords. Moreover removes the\n * \"nopass\" status. After \"resetpass\" the user has no associated\n * passwords and there is no way to authenticate without adding\n * some password (or setting it as \"nopass\" later).\n * reset Performs the following actions: resetpass, resetkeys, resetchannels,\n * allchannels (if acl-pubsub-default is set), off, clearselectors, -@all.\n * The user returns to the same state it has immediately after its creation.\n * () Create a new selector with the options specified within the\n * parentheses and attach it to the user. Each option should be\n * space separated. The first character must be ( and the last\n * character must be ).\n * clearselectors Remove all of the currently attached selectors. \n * Note this does not change the \"root\" user permissions,\n * which are the permissions directly applied onto the\n * user (outside the parentheses).\n * \n * Selector options can also be specified by this function, in which case\n * they update the root selector for the user.\n *\n * The 'op' string must be null terminated. The 'oplen' argument should\n * specify the length of the 'op' string in case the caller requires to pass\n * binary data (for instance the >password form may use a binary password).\n * Otherwise the field can be set to -1 and the function will use strlen()\n * to determine the length.\n *\n * The function returns C_OK if the action to perform was understood because\n * the 'op' string made sense. Otherwise C_ERR is returned if the operation\n * is unknown or has some syntax error.\n *\n * When an error is returned, errno is set to the following values:\n *\n * EINVAL: The specified opcode is not understood or the key/channel pattern is\n * invalid (contains non allowed characters).\n * ENOENT: The command name or command category provided with + or - is not\n * known.\n * EEXIST: You are adding a key pattern after \"*\" was already added. This is\n * almost surely an error on the user side.\n * EISDIR: You are adding a channel pattern after \"*\" was already added. This is\n * almost surely an error on the user side.\n * ENODEV: The password you are trying to remove from the user does not exist.\n * EBADMSG: The hash you are trying to add is not a valid hash.\n * ECHILD: Attempt to allow a specific first argument of a subcommand\n */\nint ACLSetUser(user *u, const char *op, ssize_t oplen) {\n /* as we are changing the ACL, the old generated string is now invalid */\n if (u->acl_string) {\n decrRefCount(u->acl_string);\n u->acl_string = NULL;\n }\n\n if (oplen == -1) oplen = strlen(op);\n if (oplen == 0) return C_OK; /* Empty string is a no-operation. */\n if (!strcasecmp(op,\"on\")) {\n atomicSet(u->flags, (u->flags | USER_FLAG_ENABLED) & ~USER_FLAG_DISABLED);\n } else if (!strcasecmp(op,\"off\")) {\n atomicSet(u->flags, (u->flags | USER_FLAG_DISABLED) & ~USER_FLAG_ENABLED);\n } else if (!strcasecmp(op,\"skip-sanitize-payload\")) {\n atomicSet(u->flags, (u->flags | USER_FLAG_SANITIZE_PAYLOAD_SKIP) & ~USER_FLAG_SANITIZE_PAYLOAD);\n } else if (!strcasecmp(op,\"sanitize-payload\")) {\n atomicSet(u->flags, (u->flags | USER_FLAG_SANITIZE_PAYLOAD) & ~USER_FLAG_SANITIZE_PAYLOAD_SKIP);\n } else if (!strcasecmp(op,\"nopass\")) {\n atomicSet(u->flags, u->flags | USER_FLAG_NOPASS);\n listEmpty(u->passwords);\n } else if (!strcasecmp(op,\"resetpass\")) {\n atomicSet(u->flags, u->flags & ~USER_FLAG_NOPASS);\n listEmpty(u->passwords);\n } else if (op[0] == '>' || op[0] == '#') {\n sds newpass;\n if (op[0] == '>') {\n newpass = ACLHashPassword((unsigned char*)op+1,oplen-1);\n } else {\n if (ACLCheckPasswordHash((unsigned char*)op+1,oplen-1) == C_ERR) {\n errno = EBADMSG;\n return C_ERR;\n }\n newpass = sdsnewlen(op+1,oplen-1);\n }\n\n listNode *ln = listSearchKey(u->passwords,newpass);\n /* Avoid re-adding the same password multiple times. */\n if (ln == NULL)\n listAddNodeTail(u->passwords,newpass);\n else\n sdsfree(newpass);\n atomicSet(u->flags, u->flags & ~USER_FLAG_NOPASS);\n } else if (op[0] == '<' || op[0] == '!') {\n sds delpass;\n if (op[0] == '<') {\n delpass = ACLHashPassword((unsigned char*)op+1,oplen-1);\n } else {\n if (ACLCheckPasswordHash((unsigned char*)op+1,oplen-1) == C_ERR) {\n errno = EBADMSG;\n return C_ERR;\n }\n delpass = sdsnewlen(op+1,oplen-1);\n }\n listNode *ln = listSearchKey(u->passwords,delpass);\n sdsfree(delpass);\n if (ln) {\n listDelNode(u->passwords,ln);\n } else {\n errno = ENODEV;\n return C_ERR;\n }\n } else if (op[0] == '(' && op[oplen - 1] == ')') {\n aclSelector *selector = aclCreateSelectorFromOpSet(op, oplen);\n if (!selector) {\n /* No errorno set, propagate it from interior error. */\n return C_ERR;\n }\n listAddNodeTail(u->selectors, selector);\n return C_OK;\n } else if (!strcasecmp(op,\"clearselectors\")) {\n listIter li;\n listNode *ln;\n listRewind(u->selectors,&li);\n /* There has to be a root selector */\n serverAssert(listNext(&li));\n while((ln = listNext(&li))) {\n listDelNode(u->selectors, ln);\n }\n return C_OK;\n } else if (!strcasecmp(op,\"reset\")) {\n serverAssert(ACLSetUser(u,\"resetpass\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"resetkeys\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"resetchannels\",-1) == C_OK);\n if (server.acl_pubsub_default & SELECTOR_FLAG_ALLCHANNELS)\n serverAssert(ACLSetUser(u,\"allchannels\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"off\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"sanitize-payload\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"clearselectors\",-1) == C_OK);\n serverAssert(ACLSetUser(u,\"-@all\",-1) == C_OK);\n } else {\n aclSelector *selector = ACLUserGetRootSelector(u);\n if (ACLSetSelector(selector, op, oplen) == C_ERR) {\n return C_ERR;\n }\n }\n return C_OK;\n}\n\n/* Return a description of the error that occurred in ACLSetUser() according to\n * the errno value set by the function on error. */\nconst char *ACLSetUserStringError(void) {\n const char *errmsg = \"Wrong format\";\n if (errno == ENOENT)\n errmsg = \"Unknown command or category name in ACL\";\n else if (errno == EINVAL)\n errmsg = \"Syntax error\";\n else if (errno == EEXIST)\n errmsg = \"Adding a pattern after the * pattern (or the \"\n \"'allkeys' flag) is not valid and does not have any \"\n \"effect. Try 'resetkeys' to start with an empty \"\n \"list of patterns\";\n else if (errno == EISDIR)\n errmsg = \"Adding a pattern after the * pattern (or the \"\n \"'allchannels' flag) is not valid and does not have any \"\n \"effect. Try 'resetchannels' to start with an empty \"\n \"list of channels\";\n else if (errno == ENODEV)\n errmsg = \"The password you are trying to remove from the user does \"\n \"not exist\";\n else if (errno == EBADMSG)\n errmsg = \"The password hash must be exactly 64 characters and contain \"\n \"only lowercase hexadecimal characters\";\n else if (errno == EALREADY)\n errmsg = \"Duplicate user found. A user can only be defined once in \"\n \"config files\";\n else if (errno == ECHILD)\n errmsg = \"Allowing first-arg of a subcommand is not supported\";\n return errmsg;\n}\n\n/* Create the default user, this has special permissions. */\nuser *ACLCreateDefaultUser(void) {\n user *new = ACLCreateUser(\"default\",7);\n ACLSetUser(new,\"+@all\",-1);\n ACLSetUser(new,\"~*\",-1);\n ACLSetUser(new,\"&*\",-1);\n ACLSetUser(new,\"on\",-1);\n ACLSetUser(new,\"nopass\",-1);\n return new;\n}\n\n/* Initialization of the ACL subsystem. */\nvoid ACLInit(void) {\n Users = raxNew();\n UsersToLoad = listCreate();\n ACLInitCommandCategories();\n listSetMatchMethod(UsersToLoad, ACLListMatchLoadedUser);\n ACLLog = listCreate();\n DefaultUser = ACLCreateDefaultUser();\n}\n\n/* Check the username and password pair and return C_OK if they are valid,\n * otherwise C_ERR is returned and errno is set to:\n *\n * EINVAL: if the username-password do not match.\n * ENOENT: if the specified user does not exist at all.\n */\nint ACLCheckUserCredentials(robj *username, robj *password) {\n user *u = ACLGetUserByName(username->ptr,sdslen(username->ptr));\n if (u == NULL) {\n errno = ENOENT;\n return C_ERR;\n }\n\n /* Disabled users can't login. */\n if (u->flags & USER_FLAG_DISABLED) {\n errno = EINVAL;\n return C_ERR;\n }\n\n /* If the user is configured to don't require any password, we\n * are already fine here. */\n if (u->flags & USER_FLAG_NOPASS) return C_OK;\n\n /* Check all the user passwords for at least one to match. */\n listIter li;\n listNode *ln;\n listRewind(u->passwords,&li);\n sds hashed = ACLHashPassword(password->ptr,sdslen(password->ptr));\n while((ln = listNext(&li))) {\n sds thispass = listNodeValue(ln);\n if (!time_independent_strcmp(hashed, thispass, HASH_PASSWORD_LEN)) {\n sdsfree(hashed);\n return C_OK;\n }\n }\n sdsfree(hashed);\n\n /* If we reached this point, no password matched. */\n errno = EINVAL;\n return C_ERR;\n}\n\n/* If `err` is provided, this is added as an error reply to the client.\n * Otherwise, the standard Auth error is added as a reply. */\nvoid addAuthErrReply(client *c, robj *err) {\n if (clientHasPendingReplies(c)) return;\n if (!err) {\n addReplyError(c, \"-WRONGPASS invalid username-password pair or user is disabled.\");\n return;\n }\n addReplyError(c, err->ptr);\n}\n\n/* This is like ACLCheckUserCredentials(), however if the user/pass\n * are correct, the connection is put in authenticated state and the\n * connection user reference is populated.\n *\n * The return value is AUTH_OK on success (valid username / password pair) & AUTH_ERR otherwise. */\nint checkPasswordBasedAuth(client *c, robj *username, robj *password) {\n if (ACLCheckUserCredentials(username,password) == C_OK) {\n c->authenticated = 1;\n c->user = ACLGetUserByName(username->ptr,sdslen(username->ptr));\n moduleNotifyUserChanged(c);\n return AUTH_OK;\n } else {\n addACLLogEntry(c,ACL_DENIED_AUTH,(c->flags & CLIENT_MULTI) ? ACL_LOG_CTX_MULTI : ACL_LOG_CTX_TOPLEVEL,0,username->ptr,NULL);\n return AUTH_ERR;\n }\n}\n\n/* Attempt authenticating the user - first through module based authentication,\n * and then, if needed, with normal password based authentication.\n * Returns one of the following codes:\n * AUTH_OK - Indicates that authentication succeeded.\n * AUTH_ERR - Indicates that authentication failed.\n * AUTH_BLOCKED - Indicates module authentication is in progress through a blocking implementation.\n */\nint ACLAuthenticateUser(client *c, robj *username, robj *password, robj **err) {\n int result = checkModuleAuthentication(c, username, password, err);\n /* If authentication was not handled by any Module, attempt normal password based auth. */\n if (result == AUTH_NOT_HANDLED) {\n result = checkPasswordBasedAuth(c, username, password);\n }\n return result;\n}\n\n/* For ACL purposes, every user has a bitmap with the commands that such\n * user is allowed to execute. In order to populate the bitmap, every command\n * should have an assigned ID (that is used to index the bitmap). This function\n * creates such an ID: it uses sequential IDs, reusing the same ID for the same\n * command name, so that a command retains the same ID in case of modules that\n * are unloaded and later reloaded.\n *\n * The function does not take ownership of the 'cmdname' SDS string.\n * */\nunsigned long ACLGetCommandID(sds cmdname) {\n sds lowername = sdsdup(cmdname);\n sdstolower(lowername);\n if (commandId == NULL) commandId = raxNew();\n void *id;\n if (raxFind(commandId,(unsigned char*)lowername,sdslen(lowername),&id)) {\n sdsfree(lowername);\n return (unsigned long)id;\n }\n raxInsert(commandId,(unsigned char*)lowername,strlen(lowername),\n (void*)nextid,NULL);\n sdsfree(lowername);\n unsigned long thisid = nextid;\n nextid++;\n\n /* We never assign the last bit in the user commands bitmap structure,\n * this way we can later check if this bit is set, understanding if the\n * current ACL for the user was created starting with a +@all to add all\n * the possible commands and just subtracting other single commands or\n * categories, or if, instead, the ACL was created just adding commands\n * and command categories from scratch, not allowing future commands by\n * default (loaded via modules). This is useful when rewriting the ACLs\n * with ACL SAVE. */\n if (nextid == USER_COMMAND_BITS_COUNT-1) nextid++;\n return thisid;\n}\n\n/* Clear command id table and reset nextid to 0. */\nvoid ACLClearCommandID(void) {\n if (commandId) raxFree(commandId);\n commandId = NULL;\n nextid = 0;\n}\n\n/* Return an username by its name, or NULL if the user does not exist. */\nuser *ACLGetUserByName(const char *name, size_t namelen) {\n void *myuser = NULL;\n raxFind(Users,(unsigned char*)name,namelen,&myuser);\n return myuser;\n}\n\n/* =============================================================================\n * ACL permission checks\n * ==========================================================================*/\n\n/* Check if the key can be accessed by the selector.\n *\n * If the selector can access the key, ACL_OK is returned, otherwise\n * ACL_DENIED_KEY is returned. */\nstatic int ACLSelectorCheckKey(aclSelector *selector, const char *key, int keylen, int keyspec_flags) {\n /* The selector can access any key */\n if (selector->flags & SELECTOR_FLAG_ALLKEYS) return ACL_OK;\n\n listIter li;\n listNode *ln;\n listRewind(selector->patterns,&li);\n\n int key_flags = 0;\n if (keyspec_flags & CMD_KEY_ACCESS) key_flags |= ACL_READ_PERMISSION;\n if (keyspec_flags & CMD_KEY_INSERT) key_flags |= ACL_WRITE_PERMISSION;\n if (keyspec_flags & CMD_KEY_DELETE) key_flags |= ACL_WRITE_PERMISSION;\n if (keyspec_flags & CMD_KEY_UPDATE) key_flags |= ACL_WRITE_PERMISSION;\n\n /* Is given key represent a prefix of a set of keys */\n int prefix = keyspec_flags & CMD_KEY_PREFIX;\n\n /* Test this key against every pattern. */\n while((ln = listNext(&li))) {\n keyPattern *pattern = listNodeValue(ln);\n if ((pattern->flags & key_flags) != key_flags)\n continue;\n size_t plen = sdslen(pattern->pattern);\n if (prefix) {\n if (prefixmatch(pattern->pattern,plen,key,keylen,0))\n return ACL_OK;\n } else {\n if (stringmatchlen(pattern->pattern, plen, key, keylen, 0))\n return ACL_OK;\n }\n }\n return ACL_DENIED_KEY;\n}\n\n/* Checks if the provided selector selector has access specified in flags\n * to all keys in the keyspace. For example, CMD_KEY_READ access requires either\n * '%R~*', '~*', or allkeys to be granted to the selector. Returns 1 if all \n * the access flags are satisfied with this selector or 0 otherwise.\n */\nstatic int ACLSelectorHasUnrestrictedKeyAccess(aclSelector *selector, int flags) {\n /* The selector can access any key */\n if (selector->flags & SELECTOR_FLAG_ALLKEYS) return 1;\n\n listIter li;\n listNode *ln;\n listRewind(selector->patterns,&li);\n\n int access_flags = 0;\n if (flags & CMD_KEY_ACCESS) access_flags |= ACL_READ_PERMISSION;\n if (flags & CMD_KEY_INSERT) access_flags |= ACL_WRITE_PERMISSION;\n if (flags & CMD_KEY_DELETE) access_flags |= ACL_WRITE_PERMISSION;\n if (flags & CMD_KEY_UPDATE) access_flags |= ACL_WRITE_PERMISSION;\n\n /* Test this key against every pattern. */\n while((ln = listNext(&li))) {\n keyPattern *pattern = listNodeValue(ln);\n if ((pattern->flags & access_flags) != access_flags)\n continue;\n if (!strcmp(pattern->pattern,\"*\")) {\n return 1;\n }\n }\n return 0;\n}\n\n/* Checks a channel against a provided list of channels. The is_pattern \n * argument should only be used when subscribing (not when publishing)\n * and controls whether the input channel is evaluated as a channel pattern\n * (like in PSUBSCRIBE) or a plain channel name (like in SUBSCRIBE). \n * \n * Note that a plain channel name like in PUBLISH or SUBSCRIBE can be\n * matched against ACL channel patterns, but the pattern provided in PSUBSCRIBE\n * can only be matched as a literal against an ACL pattern (using plain string compare). */\nstatic int ACLCheckChannelAgainstList(list *reference, const char *channel, int channellen, int is_pattern) {\n listIter li;\n listNode *ln;\n\n listRewind(reference, &li);\n while((ln = listNext(&li))) {\n sds pattern = listNodeValue(ln);\n size_t plen = sdslen(pattern);\n /* Channel patterns are matched literally against the channels in\n * the list. Regular channels perform pattern matching. */\n if ((is_pattern && !strcmp(pattern,channel)) || \n (!is_pattern && stringmatchlen(pattern,plen,channel,channellen,0)))\n {\n return ACL_OK;\n }\n }\n return ACL_DENIED_CHANNEL;\n}\n\n/* To prevent duplicate calls to getKeysResult, a cache is maintained\n * in between calls to the various selectors. */\ntypedef struct {\n int keys_init;\n getKeysResult keys;\n} aclKeyResultCache;\n\nvoid initACLKeyResultCache(aclKeyResultCache *cache) {\n cache->keys_init = 0;\n}\n\nvoid cleanupACLKeyResultCache(aclKeyResultCache *cache) {\n if (cache->keys_init) getKeysFreeResult(&(cache->keys));\n}\n\n/* Check if the command is ready to be executed according to the\n * ACLs associated with the specified selector.\n *\n * If the selector can execute the command ACL_OK is returned, otherwise\n * ACL_DENIED_CMD, ACL_DENIED_KEY, or ACL_DENIED_CHANNEL is returned: the first in case the\n * command cannot be executed because the selector is not allowed to run such\n * command, the second and third if the command is denied because the selector is trying\n * to access a key or channel that are not among the specified patterns. */\nstatic int ACLSelectorCheckCmd(aclSelector *selector, struct redisCommand *cmd, robj **argv, int argc, int *keyidxptr, aclKeyResultCache *cache) {\n uint64_t id = cmd->id;\n int ret;\n if (!(selector->flags & SELECTOR_FLAG_ALLCOMMANDS) && !(cmd->flags & CMD_NO_AUTH)) {\n /* If the bit is not set we have to check further, in case the\n * command is allowed just with that specific first argument. */\n if (ACLGetSelectorCommandBit(selector,id) == 0) {\n /* Check if the first argument matches. */\n if (argc < 2 ||\n selector->allowed_firstargs == NULL ||\n selector->allowed_firstargs[id] == NULL)\n {\n return ACL_DENIED_CMD;\n }\n\n long subid = 0;\n while (1) {\n if (selector->allowed_firstargs[id][subid] == NULL)\n return ACL_DENIED_CMD;\n int idx = cmd->parent ? 2 : 1;\n if (!strcasecmp(argv[idx]->ptr,selector->allowed_firstargs[id][subid]))\n break; /* First argument match found. Stop here. */\n subid++;\n }\n }\n }\n\n /* Check if the user can execute commands explicitly touching the keys\n * mentioned in the command arguments. */\n if (!(selector->flags & SELECTOR_FLAG_ALLKEYS) && doesCommandHaveKeys(cmd)) {\n if (!(cache->keys_init)) {\n cache->keys = (getKeysResult) GETKEYS_RESULT_INIT;\n getKeysFromCommandWithSpecs(cmd, argv, argc, GET_KEYSPEC_DEFAULT, &(cache->keys));\n cache->keys_init = 1;\n }\n getKeysResult *result = &(cache->keys);\n keyReference *resultidx = result->keys;\n for (int j = 0; j < result->numkeys; j++) {\n int idx = resultidx[j].pos;\n ret = ACLSelectorCheckKey(selector, argv[idx]->ptr, sdslen(argv[idx]->ptr), resultidx[j].flags);\n if (ret != ACL_OK) {\n if (keyidxptr) *keyidxptr = resultidx[j].pos;\n return ret;\n }\n }\n }\n\n /* Check if the user can execute commands explicitly touching the channels\n * mentioned in the command arguments */\n const int channel_flags = CMD_CHANNEL_PUBLISH | CMD_CHANNEL_SUBSCRIBE;\n if (!(selector->flags & SELECTOR_FLAG_ALLCHANNELS) && doesCommandHaveChannelsWithFlags(cmd, channel_flags)) {\n getKeysResult channels = (getKeysResult) GETKEYS_RESULT_INIT;\n getChannelsFromCommand(cmd, argv, argc, &channels);\n keyReference *channelref = channels.keys;\n for (int j = 0; j < channels.numkeys; j++) {\n int idx = channelref[j].pos;\n if (!(channelref[j].flags & channel_flags)) continue;\n int is_pattern = channelref[j].flags & CMD_CHANNEL_PATTERN;\n int ret = ACLCheckChannelAgainstList(selector->channels, argv[idx]->ptr, sdslen(argv[idx]->ptr), is_pattern);\n if (ret != ACL_OK) {\n if (keyidxptr) *keyidxptr = channelref[j].pos;\n getKeysFreeResult(&channels);\n return ret;\n }\n }\n getKeysFreeResult(&channels);\n }\n return ACL_OK;\n}\n\n/* Check if the key can be accessed by the client according to\n * the ACLs associated with the specified user according to the\n * keyspec access flags.\n *\n * If the user can access the key, ACL_OK is returned, otherwise\n * ACL_DENIED_KEY is returned. */\nint ACLUserCheckKeyPerm(user *u, const char *key, int keylen, int flags) {\n listIter li;\n listNode *ln;\n\n /* If there is no associated user, the connection can run anything. */\n if (u == NULL) return ACL_OK;\n\n /* Check all of the selectors */\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n if (ACLSelectorCheckKey(s, key, keylen, flags) == ACL_OK) {\n return ACL_OK;\n }\n }\n return ACL_DENIED_KEY;\n}\n\n/* Checks if the user can execute the given command with the added restriction\n * it must also have the access specified in flags to any key in the key space. \n * For example, CMD_KEY_READ access requires either '%R~*', '~*', or allkeys to be \n * granted in addition to the access required by the command. Returns 1 \n * if the user has access or 0 otherwise.\n */\nint ACLUserCheckCmdWithUnrestrictedKeyAccess(user *u, struct redisCommand *cmd, robj **argv, int argc, int flags) {\n listIter li;\n listNode *ln;\n int local_idxptr;\n\n /* If there is no associated user, the connection can run anything. */\n if (u == NULL) return 1;\n\n /* For multiple selectors, we cache the key result in between selector\n * calls to prevent duplicate lookups. */\n aclKeyResultCache cache;\n initACLKeyResultCache(&cache);\n\n /* Check each selector sequentially */\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n int acl_retval = ACLSelectorCheckCmd(s, cmd, argv, argc, &local_idxptr, &cache);\n if (acl_retval == ACL_OK && ACLSelectorHasUnrestrictedKeyAccess(s, flags)) {\n cleanupACLKeyResultCache(&cache);\n return 1;\n }\n }\n cleanupACLKeyResultCache(&cache);\n return 0;\n}\n\n/* Check if the channel can be accessed by the client according to\n * the ACLs associated with the specified user.\n *\n * If the user can access the key, ACL_OK is returned, otherwise\n * ACL_DENIED_CHANNEL is returned. */\nint ACLUserCheckChannelPerm(user *u, sds channel, int is_pattern) {\n listIter li;\n listNode *ln;\n\n /* If there is no associated user, the connection can run anything. */\n if (u == NULL) return ACL_OK;\n\n /* Check all of the selectors */\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n /* The selector can run any keys */\n if (s->flags & SELECTOR_FLAG_ALLCHANNELS) return ACL_OK;\n\n /* Otherwise, loop over the selectors list and check each channel */\n if (ACLCheckChannelAgainstList(s->channels, channel, sdslen(channel), is_pattern) == ACL_OK) {\n return ACL_OK;\n }\n }\n return ACL_DENIED_CHANNEL;\n}\n\n/* Lower level API that checks if a specified user is able to execute a given command.\n *\n * If the command fails an ACL check, idxptr will be to set to the first argv entry that\n * causes the failure, either 0 if the command itself fails or the idx of the key/channel\n * that causes the failure */\nint ACLCheckAllUserCommandPerm(user *u, struct redisCommand *cmd, robj **argv, int argc, getKeysResult *key_result, int *idxptr) {\n listIter li;\n listNode *ln;\n\n /* If there is no associated user, the connection can run anything. */\n if (u == NULL) return ACL_OK;\n\n /* Quick check if the user has all permissions, return early if so. */\n if (likely(listFirst(u->selectors) != NULL)) {\n aclSelector *s = listNodeValue(listFirst(u->selectors));\n const uint32_t all_perms = SELECTOR_FLAG_ALLCOMMANDS |\n SELECTOR_FLAG_ALLKEYS |\n SELECTOR_FLAG_ALLCHANNELS;\n if ((s->flags & all_perms) == all_perms) return ACL_OK;\n }\n\n /* We have to pick a single error to log, the logic for picking is as follows:\n * 1) If no selector can execute the command, return the command.\n * 2) Return the last key or channel that no selector could match. */\n int relevant_error = ACL_DENIED_CMD;\n int local_idxptr = 0, last_idx = 0;\n\n /* For multiple selectors, we cache the key result in between selector\n * calls to prevent duplicate lookups. */\n aclKeyResultCache cache;\n initACLKeyResultCache(&cache);\n if (key_result) {\n cache.keys = *key_result;\n cache.keys_init = 1;\n }\n\n /* Check each selector sequentially */\n listRewind(u->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n int acl_retval = ACLSelectorCheckCmd(s, cmd, argv, argc, &local_idxptr, &cache);\n if (acl_retval == ACL_OK) {\n if (!key_result) cleanupACLKeyResultCache(&cache);\n return ACL_OK;\n }\n if (acl_retval > relevant_error ||\n (acl_retval == relevant_error && local_idxptr > last_idx))\n {\n relevant_error = acl_retval;\n last_idx = local_idxptr;\n }\n }\n\n *idxptr = last_idx;\n if (!key_result) cleanupACLKeyResultCache(&cache);\n return relevant_error;\n}\n\n/* High level API for checking if a client can execute the queued up command */\nint ACLCheckAllPerm(client *c, int *idxptr) {\n return ACLCheckAllUserCommandPerm(c->user, c->cmd, c->argv, c->argc, getClientCachedKeyResult(c), idxptr);\n}\n\n/* If 'new' can access all channels 'original' could then return NULL;\n Otherwise return a list of channels that the new user can access */\nlist *getUpcomingChannelList(user *new, user *original) {\n listIter li, lpi;\n listNode *ln, *lpn;\n\n /* Optimization: we check if any selector has all channel permissions. */\n listRewind(new->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n if (s->flags & SELECTOR_FLAG_ALLCHANNELS) return NULL;\n }\n\n /* Next, check if the new list of channels\n * is a strict superset of the original. This is done by\n * created an \"upcoming\" list of all channels that are in\n * the new user and checking each of the existing channels\n * against it. */\n list *upcoming = listCreate();\n listRewind(new->selectors,&li);\n while((ln = listNext(&li))) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n listRewind(s->channels, &lpi);\n while((lpn = listNext(&lpi))) {\n listAddNodeTail(upcoming, listNodeValue(lpn));\n }\n }\n\n int match = 1;\n listRewind(original->selectors,&li);\n while((ln = listNext(&li)) && match) {\n aclSelector *s = (aclSelector *) listNodeValue(ln);\n /* If any of the original selectors has the all-channels permission, but\n * the new ones don't (this is checked earlier in this function), then the\n * new list is not a strict superset of the original. */\n if (s->flags & SELECTOR_FLAG_ALLCHANNELS) {\n match = 0;\n break;\n }\n listRewind(s->channels, &lpi);\n while((lpn = listNext(&lpi)) && match) {\n if (!listSearchKey(upcoming, listNodeValue(lpn))) {\n match = 0;\n break;\n }\n }\n }\n\n if (match) {\n /* All channels were matched, no need to kill clients. */\n listRelease(upcoming);\n return NULL;\n }\n\n return upcoming;\n}\n\n/* Check if the client should be killed because it is subscribed to channels that were\n * permitted in the past, are not in the `upcoming` channel list. */\nint ACLShouldKillPubsubClient(client *c, list *upcoming) {\n robj *o;\n int kill = 0;\n\n if (getClientType(c) == CLIENT_TYPE_PUBSUB) {\n /* Check for pattern violations. */\n dictIterator di;\n dictEntry *de;\n dictInitIterator(&di, c->pubsub_patterns);\n while (!kill && ((de = dictNext(&di)) != NULL)) {\n o = dictGetKey(de);\n int res = ACLCheckChannelAgainstList(upcoming, o->ptr, sdslen(o->ptr), 1);\n kill = (res == ACL_DENIED_CHANNEL);\n }\n dictResetIterator(&di);\n\n /* Check for channel violations. */\n if (!kill) {\n /* Check for global channels violation. */\n dictInitIterator(&di, c->pubsub_channels);\n\n while (!kill && ((de = dictNext(&di)) != NULL)) {\n o = dictGetKey(de);\n int res = ACLCheckChannelAgainstList(upcoming, o->ptr, sdslen(o->ptr), 0);\n kill = (res == ACL_DENIED_CHANNEL);\n }\n dictResetIterator(&di);\n }\n if (!kill) {\n /* Check for shard channels violation. */\n dictInitIterator(&di, c->pubsubshard_channels);\n while (!kill && ((de = dictNext(&di)) != NULL)) {\n o = dictGetKey(de);\n int res = ACLCheckChannelAgainstList(upcoming, o->ptr, sdslen(o->ptr), 0);\n kill = (res == ACL_DENIED_CHANNEL);\n }\n dictResetIterator(&di);\n }\n\n if (kill) {\n return 1;\n }\n }\n return 0;\n}\n\n/* Check if the user's existing pub/sub clients violate the ACL pub/sub\n * permissions specified via the upcoming argument, and kill them if so. */\nvoid ACLKillPubsubClientsIfNeeded(user *new, user *original) {\n /* Do nothing if there are no subscribers. */\n if (pubsubTotalSubscriptions() == 0)\n return;\n\n list *channels = getUpcomingChannelList(new, original);\n /* If the new user's pubsub permissions are a strict superset of the original, return early. */\n if (!channels)\n return;\n\n listIter li;\n listNode *ln;\n\n /* Permissions have changed, so we need to iterate through all\n * the clients and disconnect those that are no longer valid.\n * Scan all connected clients to find the user's pub/subs. */\n listRewind(server.clients,&li);\n while ((ln = listNext(&li)) != NULL) {\n client *c = listNodeValue(ln);\n if (c->user != original)\n continue;\n if (ACLShouldKillPubsubClient(c, channels))\n deauthenticateAndCloseClient(c);\n }\n\n listRelease(channels);\n}\n\n/* =============================================================================\n * ACL loading / saving functions\n * ==========================================================================*/\n\n\n/* Selector definitions should be sent as a single argument, however\n * we will be lenient and try to find selector definitions spread \n * across multiple arguments since it makes for a simpler user experience\n * for ACL SETUSER as well as when loading from conf files. \n * \n * This function takes in an array of ACL operators, excluding the username,\n * and merges selector operations that are spread across multiple arguments. The return\n * value is a new SDS array, with length set to the passed in merged_argc. Arguments \n * that are untouched are still duplicated. If there is an unmatched parenthesis, NULL \n * is returned and invalid_idx is set to the argument with the start of the opening\n * parenthesis. */\nsds *ACLMergeSelectorArguments(sds *argv, int argc, int *merged_argc, int *invalid_idx) {\n *merged_argc = 0;\n int open_bracket_start = -1;\n\n sds *acl_args = (sds *) zmalloc(sizeof(sds) * argc);\n\n sds selector = NULL;\n for (int j = 0; j < argc; j++) {\n char *op = argv[j];\n\n if (open_bracket_start == -1 &&\n (op[0] == '(' && op[sdslen(op) - 1] != ')')) {\n selector = sdsdup(argv[j]);\n open_bracket_start = j;\n continue;\n }\n\n if (open_bracket_start != -1) {\n selector = sdscatfmt(selector, \" %s\", op);\n if (op[sdslen(op) - 1] == ')') {\n open_bracket_start = -1;\n acl_args[*merged_argc] = selector; \n (*merged_argc)++;\n }\n continue;\n }\n\n acl_args[*merged_argc] = sdsdup(argv[j]);\n (*merged_argc)++;\n }\n\n if (open_bracket_start != -1) {\n for (int i = 0; i < *merged_argc; i++) sdsfree(acl_args[i]);\n zfree(acl_args);\n sdsfree(selector);\n if (invalid_idx) *invalid_idx = open_bracket_start;\n return NULL;\n }\n\n return acl_args;\n}\n\n/* takes an acl string already split on spaces and adds it to the given user\n * if the user object is NULL, will create a user with the given username\n *\n * Returns an error as an sds string if the ACL string is not parsable\n */\nsds ACLStringSetUser(user *u, sds username, sds *argv, int argc) {\n serverAssert(u != NULL || username != NULL);\n\n sds error = NULL;\n\n int merged_argc = 0, invalid_idx = 0;\n sds *acl_args = ACLMergeSelectorArguments(argv, argc, &merged_argc, &invalid_idx);\n\n if (!acl_args) {\n return sdscatfmt(sdsempty(),\n \"Unmatched parenthesis in acl selector starting \"\n \"at '%s'.\", (char *) argv[invalid_idx]);\n }\n\n /* Create a temporary user to validate and stage all changes against\n * before applying to an existing user or creating a new user. If all\n * arguments are valid the user parameters will all be applied together.\n * If there are any errors then none of the changes will be applied. */\n user *tempu = ACLCreateUnlinkedUser();\n if (u) {\n ACLCopyUser(tempu, u);\n }\n\n for (int j = 0; j < merged_argc; j++) {\n if (ACLSetUser(tempu,acl_args[j],(ssize_t) sdslen(acl_args[j])) != C_OK) {\n const char *errmsg = ACLSetUserStringError();\n error = sdscatfmt(sdsempty(),\n \"Error in ACL SETUSER modifier '%s': %s\",\n (char*)acl_args[j], errmsg);\n goto cleanup;\n }\n }\n\n /* Existing pub/sub clients authenticated with the user may need to be\n * disconnected if (some of) their channel permissions were revoked. */\n if (u) {\n ACLKillPubsubClientsIfNeeded(tempu, u);\n }\n\n /* Overwrite the user with the temporary user we modified above. */\n if (!u) {\n u = ACLCreateUser(username,sdslen(username));\n }\n serverAssert(u != NULL);\n\n ACLCopyUser(u, tempu);\n\ncleanup:\n ACLFreeUser(tempu);\n for (int i = 0; i < merged_argc; i++) {\n sdsfree(acl_args[i]);\n }\n zfree(acl_args);\n\n return error;\n}\n\n/* Given an argument vector describing a user in the form:\n *\n * user ... ACL rules and flags ...\n *\n * this function validates, and if the syntax is valid, appends\n * the user definition to a list for later loading.\n *\n * The rules are tested for validity and if there obvious syntax errors\n * the function returns C_ERR and does nothing, otherwise C_OK is returned\n * and the user is appended to the list.\n *\n * Note that this function cannot stop in case of commands that are not found\n * and, in that case, the error will be emitted later, because certain\n * commands may be defined later once modules are loaded.\n *\n * When an error is detected and C_ERR is returned, the function populates\n * by reference (if not set to NULL) the argc_err argument with the index\n * of the argv vector that caused the error. */\nint ACLAppendUserForLoading(sds *argv, int argc, int *argc_err) {\n if (argc < 2 || strcasecmp(argv[0],\"user\")) {\n if (argc_err) *argc_err = 0;\n return C_ERR;\n }\n\n if (listSearchKey(UsersToLoad, argv[1])) {\n if (argc_err) *argc_err = 1;\n errno = EALREADY;\n return C_ERR; \n }\n\n /* Merged selectors before trying to process */\n int merged_argc;\n sds *acl_args = ACLMergeSelectorArguments(argv + 2, argc - 2, &merged_argc, argc_err);\n\n if (!acl_args) {\n return C_ERR;\n }\n\n /* Try to apply the user rules in a fake user to see if they\n * are actually valid. */\n user *fakeuser = ACLCreateUnlinkedUser();\n\n for (int j = 0; j < merged_argc; j++) {\n if (ACLSetUser(fakeuser,acl_args[j],sdslen(acl_args[j])) == C_ERR) {\n if (errno != ENOENT) {\n ACLFreeUser(fakeuser);\n if (argc_err) *argc_err = j;\n for (int i = 0; i < merged_argc; i++) sdsfree(acl_args[i]);\n zfree(acl_args);\n return C_ERR;\n }\n }\n }\n\n /* Rules look valid, let's append the user to the list. */\n sds *copy = zmalloc(sizeof(sds)*(merged_argc + 2));\n copy[0] = sdsdup(argv[1]);\n for (int j = 0; j < merged_argc; j++) copy[j+1] = sdsdup(acl_args[j]);\n copy[merged_argc + 1] = NULL;\n listAddNodeTail(UsersToLoad,copy);\n ACLFreeUser(fakeuser);\n for (int i = 0; i < merged_argc; i++) sdsfree(acl_args[i]);\n zfree(acl_args);\n return C_OK;\n}\n\n/* This function will load the configured users appended to the server\n * configuration via ACLAppendUserForLoading(). On loading errors it will\n * log an error and return C_ERR, otherwise C_OK will be returned. */\nint ACLLoadConfiguredUsers(void) {\n listIter li;\n listNode *ln;\n listRewind(UsersToLoad,&li);\n while ((ln = listNext(&li)) != NULL) {\n sds *aclrules = listNodeValue(ln);\n sds username = aclrules[0];\n\n if (ACLStringHasSpaces(aclrules[0],sdslen(aclrules[0]))) {\n serverLog(LL_WARNING,\"Spaces not allowed in ACL usernames\");\n return C_ERR;\n }\n\n user *u = ACLCreateUser(username,sdslen(username));\n if (!u) {\n /* Only valid duplicate user is the default one. */\n serverAssert(!strcmp(username, \"default\"));\n u = ACLGetUserByName(\"default\",7);\n ACLSetUser(u,\"reset\",-1);\n }\n\n /* Load every rule defined for this user. */\n for (int j = 1; aclrules[j]; j++) {\n if (ACLSetUser(u,aclrules[j],sdslen(aclrules[j])) != C_OK) {\n const char *errmsg = ACLSetUserStringError();\n serverLog(LL_WARNING,\"Error loading ACL rule '%s' for \"\n \"the user named '%s': %s\",\n redactLogCstr(aclrules[j]),redactLogCstr(aclrules[0]),errmsg);\n return C_ERR;\n }\n }\n\n /* Having a disabled user in the configuration may be an error,\n * warn about it without returning any error to the caller. */\n if (u->flags & USER_FLAG_DISABLED) {\n serverLog(LL_NOTICE, \"The user '%s' is disabled (there is no \"\n \"'on' modifier in the user description). Make \"\n \"sure this is not a configuration error.\",\n redactLogCstr(aclrules[0]));\n }\n }\n return C_OK;\n}\n\n/* This function loads the ACL from the specified filename: every line\n * is validated and should be either empty, a comment, or in the format\n * used to specify users in the redis.conf configuration or in the ACL file,\n * that is:\n *\n * user ... rules ...\n *\n * Lines starting with '#' are treated as comments and ignored. Note that\n * comments will be lost after ACL SAVE rewrites the file. Empty lines are\n * also allowed.\n *\n * One important part of implementing ACL LOAD, that uses this function, is\n * to avoid ending with broken rules if the ACL file is invalid for some\n * reason, so the function will attempt to validate the rules before loading\n * each user. For every line that will be found broken the function will\n * collect an error message.\n *\n * IMPORTANT: If there is at least a single error, nothing will be loaded\n * and the rules will remain exactly as they were.\n *\n * At the end of the process, if no errors were found in the whole file then\n * NULL is returned. Otherwise an SDS string describing in a single line\n * a description of all the issues found is returned. */\nsds ACLLoadFromFile(const char *filename) {\n FILE *fp;\n char buf[1024];\n\n /* Open the ACL file. */\n if ((fp = fopen(filename,\"r\")) == NULL) {\n sds errors = sdscatprintf(sdsempty(),\n \"Error loading ACLs, opening file '%s': %s\",\n filename, strerror(errno));\n return errors;\n }\n\n /* Load the whole file as a single string in memory. */\n sds acls = sdsempty();\n while(fgets(buf,sizeof(buf),fp) != NULL)\n acls = sdscat(acls,buf);\n fclose(fp);\n\n /* Split the file into lines and attempt to load each line. */\n int totlines;\n sds *lines, errors = sdsempty();\n lines = sdssplitlen(acls,strlen(acls),\"\\n\",1,&totlines);\n sdsfree(acls);\n\n /* We do all the loading in a fresh instance of the Users radix tree,\n * so if there are errors loading the ACL file we can rollback to the\n * old version. */\n rax *old_users = Users;\n Users = raxNew();\n\n /* Load each line of the file. */\n for (int i = 0; i < totlines; i++) {\n sds *argv;\n int argc;\n int linenum = i+1;\n\n lines[i] = sdstrim(lines[i],\" \\t\\r\\n\");\n\n /* Skip blank lines and comments */\n if (lines[i][0] == '\\0' || lines[i][0] == '#') continue;\n\n /* Split into arguments */\n argv = sdssplitlen(lines[i],sdslen(lines[i]),\" \",1,&argc);\n if (argv == NULL) {\n errors = sdscatprintf(errors,\n \"%s:%d: unbalanced quotes in acl line. \",\n server.acl_filename, linenum);\n continue;\n }\n\n /* Skip this line if the resulting command vector is empty. */\n if (argc == 0) {\n sdsfreesplitres(argv,argc);\n continue;\n }\n\n /* The line should start with the \"user\" keyword. */\n if (strcmp(argv[0],\"user\") || argc < 2) {\n errors = sdscatprintf(errors,\n \"%s:%d should start with user keyword followed \"\n \"by the username. \", server.acl_filename,\n linenum);\n sdsfreesplitres(argv,argc);\n continue;\n }\n\n /* Spaces are not allowed in usernames. */\n if (ACLStringHasSpaces(argv[1],sdslen(argv[1]))) {\n errors = sdscatprintf(errors,\n \"'%s:%d: username '%s' contains invalid characters. \",\n server.acl_filename, linenum, argv[1]);\n sdsfreesplitres(argv,argc);\n continue;\n }\n\n user *u = ACLCreateUser(argv[1],sdslen(argv[1]));\n\n /* If the user already exists we assume it's an error and abort. */\n if (!u) {\n errors = sdscatprintf(errors,\"WARNING: Duplicate user '%s' found on line %d. \", argv[1], linenum);\n sdsfreesplitres(argv,argc);\n continue;\n }\n\n /* Finally process the options and validate they can\n * be cleanly applied to the user. If any option fails\n * to apply, the other values won't be applied since\n * all the pending changes will get dropped. */\n int merged_argc;\n sds *acl_args = ACLMergeSelectorArguments(argv + 2, argc - 2, &merged_argc, NULL);\n if (!acl_args) {\n errors = sdscatprintf(errors,\n \"%s:%d: Unmatched parenthesis in selector definition.\",\n server.acl_filename, linenum);\n }\n\n int syntax_error = 0;\n for (int j = 0; j < merged_argc; j++) {\n acl_args[j] = sdstrim(acl_args[j],\"\\t\\r\\n\");\n if (ACLSetUser(u,acl_args[j],sdslen(acl_args[j])) != C_OK) {\n const char *errmsg = ACLSetUserStringError();\n if (errno == ENOENT) {\n /* For missing commands, we print out more information since\n * it shouldn't contain any sensitive information. */\n errors = sdscatprintf(errors,\n \"%s:%d: Error in applying operation '%s': %s. \",\n server.acl_filename, linenum, acl_args[j], errmsg);\n } else if (syntax_error == 0) {\n /* For all other errors, only print out the first error encountered\n * since it might affect future operations. */\n errors = sdscatprintf(errors,\n \"%s:%d: %s. \",\n server.acl_filename, linenum, errmsg);\n syntax_error = 1;\n }\n }\n }\n\n for (int i = 0; i < merged_argc; i++) sdsfree(acl_args[i]);\n zfree(acl_args);\n\n /* Apply the rule to the new users set only if so far there\n * are no errors, otherwise it's useless since we are going\n * to discard the new users set anyway. */\n if (sdslen(errors) != 0) {\n sdsfreesplitres(argv,argc);\n continue;\n }\n\n sdsfreesplitres(argv,argc);\n }\n\n sdsfreesplitres(lines,totlines);\n\n /* Check if we found errors and react accordingly. */\n if (sdslen(errors) == 0) {\n /* The default user pointer is referenced in different places: instead\n * of replacing such occurrences it is much simpler to copy the new\n * default user configuration in the old one. */\n user *new_default = ACLGetUserByName(\"default\",7);\n if (!new_default) {\n new_default = ACLCreateDefaultUser();\n }\n\n ACLCopyUser(DefaultUser,new_default);\n ACLFreeUser(new_default);\n raxInsert(Users,(unsigned char*)\"default\",7,DefaultUser,NULL);\n raxRemove(old_users,(unsigned char*)\"default\",7,NULL);\n\n /* If there are some subscribers, we need to check if we need to drop some clients. */\n rax *user_channels = NULL;\n if (pubsubTotalSubscriptions() > 0) {\n user_channels = raxNew();\n }\n\n listIter li;\n listNode *ln;\n\n listRewind(server.clients,&li);\n while ((ln = listNext(&li)) != NULL) {\n client *c = listNodeValue(ln);\n /* a MASTER client can do everything (and user = NULL) so we can skip it */\n if (c->flags & CLIENT_MASTER)\n continue;\n user *original = c->user;\n list *channels = NULL;\n user *new = ACLGetUserByName(c->user->name, sdslen(c->user->name));\n if (new && user_channels) {\n if (!raxFind(user_channels, (unsigned char*)(new->name), sdslen(new->name), (void**)&channels)) {\n channels = getUpcomingChannelList(new, original);\n raxInsert(user_channels, (unsigned char*)(new->name), sdslen(new->name), channels, NULL);\n }\n }\n /* When the new channel list is NULL, it means the new user's channel list is a superset of the old user's list. */\n if (!new || (channels && ACLShouldKillPubsubClient(c, channels))) {\n deauthenticateAndCloseClient(c);\n continue;\n }\n c->user = new;\n }\n\n if (user_channels)\n raxFreeWithCallback(user_channels, listReleaseGeneric);\n raxFreeWithCallback(old_users, ACLFreeUserGeneric);\n sdsfree(errors);\n return NULL;\n } else {\n raxFreeWithCallback(Users, ACLFreeUserGeneric);\n Users = old_users;\n errors = sdscat(errors,\"WARNING: ACL errors detected, no change to the previously active ACL rules was performed\");\n return errors;\n }\n}\n\n/* Generate a copy of the ACLs currently in memory in the specified filename.\n * Returns C_OK on success or C_ERR if there was an error during the I/O.\n * When C_ERR is returned a log is produced with hints about the issue. */\nint ACLSaveToFile(const char *filename) {\n sds acl = sdsempty();\n int fd = -1;\n sds tmpfilename = NULL;\n int retval = C_ERR;\n\n /* Let's generate an SDS string containing the new version of the\n * ACL file. */\n raxIterator ri;\n raxStart(&ri,Users);\n raxSeek(&ri,\"^\",NULL,0);\n while(raxNext(&ri)) {\n user *u = ri.data;\n /* Return information in the configuration file format. */\n sds user = sdsnew(\"user \");\n user = sdscatsds(user,u->name);\n user = sdscatlen(user,\" \",1);\n robj *descr = ACLDescribeUser(u);\n user = sdscatsds(user,descr->ptr);\n decrRefCount(descr);\n acl = sdscatsds(acl,user);\n acl = sdscatlen(acl,\"\\n\",1);\n sdsfree(user);\n }\n raxStop(&ri);\n\n /* Create a temp file with the new content. */\n tmpfilename = sdsnew(filename);\n tmpfilename = sdscatfmt(tmpfilename,\".tmp-%i-%I\",\n (int) getpid(),commandTimeSnapshot());\n if ((fd = open(tmpfilename,O_WRONLY|O_CREAT,0644)) == -1) {\n serverLog(LL_WARNING,\"Opening temp ACL file for ACL SAVE: %s\",\n strerror(errno));\n goto cleanup;\n }\n\n /* Write it. */\n size_t offset = 0;\n while (offset < sdslen(acl)) {\n ssize_t written_bytes = write(fd,acl + offset,sdslen(acl) - offset);\n if (written_bytes <= 0) {\n if (errno == EINTR) continue;\n serverLog(LL_WARNING,\"Writing ACL file for ACL SAVE: %s\",\n strerror(errno));\n goto cleanup;\n }\n offset += written_bytes;\n }\n if (redis_fsync(fd) == -1) {\n serverLog(LL_WARNING,\"Syncing ACL file for ACL SAVE: %s\",\n strerror(errno));\n goto cleanup;\n }\n close(fd); fd = -1;\n\n /* Let's replace the new file with the old one. */\n if (rename(tmpfilename,filename) == -1) {\n serverLog(LL_WARNING,\"Renaming ACL file for ACL SAVE: %s\",\n strerror(errno));\n goto cleanup;\n }\n if (fsyncFileDir(filename) == -1) {\n serverLog(LL_WARNING,\"Syncing ACL directory for ACL SAVE: %s\",\n strerror(errno));\n goto cleanup;\n }\n sdsfree(tmpfilename); tmpfilename = NULL;\n retval = C_OK; /* If we reached this point, everything is fine. */\n\ncleanup:\n if (fd != -1) close(fd);\n if (tmpfilename) unlink(tmpfilename);\n sdsfree(tmpfilename);\n sdsfree(acl);\n return retval;\n}\n\n/* This function is called once the server is already running, modules are\n * loaded, and we are ready to start, in order to load the ACLs either from\n * the pending list of users defined in redis.conf, or from the ACL file.\n * The function will just exit with an error if the user is trying to mix\n * both the loading methods. */\nvoid ACLLoadUsersAtStartup(void) {\n if (server.acl_filename[0] != '\\0' && listLength(UsersToLoad) != 0) {\n serverLog(LL_WARNING,\n \"Configuring Redis with users defined in redis.conf and at \"\n \"the same setting an ACL file path is invalid. This setup \"\n \"is very likely to lead to configuration errors and security \"\n \"holes, please define either an ACL file or declare users \"\n \"directly in your redis.conf, but not both.\");\n exit(1);\n }\n\n if (ACLLoadConfiguredUsers() == C_ERR) {\n serverLog(LL_WARNING,\n \"Critical error while loading ACLs. Exiting.\");\n exit(1);\n }\n\n if (server.acl_filename[0] != '\\0') {\n sds errors = ACLLoadFromFile(server.acl_filename);\n if (errors) {\n serverLog(LL_WARNING,\n \"Aborting Redis startup because of ACL errors: %s\", errors);\n sdsfree(errors);\n exit(1);\n }\n }\n}\n\n/* =============================================================================\n * ACL log\n * ==========================================================================*/\n\n#define ACL_LOG_GROUPING_MAX_TIME_DELTA 60000\n\n/* This structure defines an entry inside the ACL log. */\ntypedef struct ACLLogEntry {\n uint64_t count; /* Number of times this happened recently. */\n int reason; /* Reason for denying the command. ACL_DENIED_*. */\n int context; /* Toplevel, Lua or MULTI/EXEC? ACL_LOG_CTX_*. */\n sds object; /* The key name or command name. */\n sds username; /* User the client is authenticated with. */\n mstime_t ctime; /* Milliseconds time of last update to this entry. */\n sds cinfo; /* Client info (last client if updated). */\n long long entry_id; /* The pair (entry_id, timestamp_created) is a unique identifier of this entry \n * in case the node dies and is restarted, it can detect that if it's a new series. */\n mstime_t timestamp_created; /* UNIX time in milliseconds at the time of this entry's creation. */\n} ACLLogEntry;\n\n/* This function will check if ACL entries 'a' and 'b' are similar enough\n * that we should actually update the existing entry in our ACL log instead\n * of creating a new one. */\nint ACLLogMatchEntry(ACLLogEntry *a, ACLLogEntry *b) {\n if (a->reason != b->reason) return 0;\n if (a->context != b->context) return 0;\n mstime_t delta = a->ctime - b->ctime;\n if (delta < 0) delta = -delta;\n if (delta > ACL_LOG_GROUPING_MAX_TIME_DELTA) return 0;\n if (sdscmp(a->object,b->object) != 0) return 0;\n if (sdscmp(a->username,b->username) != 0) return 0;\n return 1;\n}\n\n/* Release an ACL log entry. */\nvoid ACLFreeLogEntry(void *leptr) {\n ACLLogEntry *le = leptr;\n sdsfree(le->object);\n sdsfree(le->username);\n sdsfree(le->cinfo);\n zfree(le);\n}\n\n/* Update the relevant counter by the reason */\nvoid ACLUpdateInfoMetrics(int reason){\n if (reason == ACL_DENIED_AUTH) {\n server.acl_info.user_auth_failures++;\n } else if (reason == ACL_DENIED_CMD) {\n server.acl_info.invalid_cmd_accesses++;\n } else if (reason == ACL_DENIED_KEY) {\n server.acl_info.invalid_key_accesses++;\n } else if (reason == ACL_DENIED_CHANNEL) {\n server.acl_info.invalid_channel_accesses++;\n } else if (reason == ACL_INVALID_TLS_CERT_AUTH) {\n server.acl_info.acl_access_denied_tls_cert++;\n } else {\n serverPanic(\"Unknown ACL_DENIED encoding\");\n }\n}\n\nstatic void trimACLLogEntriesToMaxLen(void) {\n while(listLength(ACLLog) > server.acllog_max_len) {\n listNode *ln = listLast(ACLLog);\n ACLLogEntry *le = listNodeValue(ln);\n ACLFreeLogEntry(le);\n listDelNode(ACLLog,ln);\n }\n}\n\n/* Adds a new entry in the ACL log, making sure to delete the old entry\n * if we reach the maximum length allowed for the log. This function attempts\n * to find similar entries in the current log in order to bump the counter of\n * the log entry instead of creating many entries for very similar ACL\n * rules issues.\n *\n * The argpos argument is used when the reason is ACL_DENIED_KEY or \n * ACL_DENIED_CHANNEL, since it allows the function to log the key or channel\n * name that caused the problem.\n *\n * The last 2 arguments are a manual override to be used, instead of any of the automatic\n * ones which depend on the client and reason arguments (use NULL for default).\n *\n * If `object` is not NULL, this functions takes over it.\n */\nvoid addACLLogEntry(client *c, int reason, int context, int argpos, sds username, sds object) {\n /* Update ACL info metrics */\n ACLUpdateInfoMetrics(reason);\n \n if (server.acllog_max_len == 0) {\n trimACLLogEntriesToMaxLen();\n return;\n }\n \n /* Create a new entry. */\n struct ACLLogEntry *le = zmalloc(sizeof(*le));\n le->count = 1;\n le->reason = reason;\n le->username = sdsdup(username ? username : c->user->name);\n le->ctime = commandTimeSnapshot();\n le->entry_id = ACLLogEntryCount;\n le->timestamp_created = le->ctime;\n\n if (object) {\n le->object = object;\n } else {\n switch(reason) {\n case ACL_DENIED_CMD: le->object = sdsdup(c->cmd->fullname); break;\n case ACL_DENIED_KEY: le->object = sdsdup(c->argv[argpos]->ptr); break;\n case ACL_DENIED_CHANNEL: le->object = sdsdup(c->argv[argpos]->ptr); break;\n case ACL_DENIED_AUTH: le->object = sdsdup(c->argv[0]->ptr); break;\n default: le->object = sdsempty();\n }\n }\n\n /* if we have a real client from the network, use it (could be missing on module timers) */\n client *realclient = server.current_client? server.current_client : c;\n\n le->cinfo = catClientInfoString(sdsempty(),realclient);\n le->context = context;\n\n /* Try to match this entry with past ones, to see if we can just\n * update an existing entry instead of creating a new one. */\n long toscan = 10; /* Do a limited work trying to find duplicated. */\n listIter li;\n listNode *ln;\n listRewind(ACLLog,&li);\n ACLLogEntry *match = NULL;\n while (toscan-- && (ln = listNext(&li)) != NULL) {\n ACLLogEntry *current = listNodeValue(ln);\n if (ACLLogMatchEntry(current,le)) {\n match = current;\n listDelNode(ACLLog,ln);\n listAddNodeHead(ACLLog,current);\n break;\n }\n }\n\n /* If there is a match update the entry, otherwise add it as a\n * new one. */\n if (match) {\n /* We update a few fields of the existing entry and bump the\n * counter of events for this entry. */\n sdsfree(match->cinfo);\n match->cinfo = le->cinfo;\n match->ctime = le->ctime;\n match->count++;\n\n /* Release the old entry. */\n le->cinfo = NULL;\n ACLFreeLogEntry(le);\n } else {\n /* Add it to our list of entries. We'll have to trim the list\n * to its maximum size. */\n ACLLogEntryCount++; /* Incrementing the entry_id count to make each record in the log unique. */\n listAddNodeHead(ACLLog, le);\n trimACLLogEntriesToMaxLen();\n }\n}\n\nsds getAclErrorMessage(int acl_res, user *user, struct redisCommand *cmd, sds errored_val, int verbose) {\n switch (acl_res) {\n case ACL_DENIED_CMD:\n return sdscatfmt(sdsempty(), \"User %S has no permissions to run \"\n \"the '%S' command\", user->name, cmd->fullname);\n case ACL_DENIED_KEY:\n if (verbose) {\n return sdscatfmt(sdsempty(), \"User %S has no permissions to access \"\n \"the '%S' key\", user->name, errored_val);\n } else {\n return sdsnew(\"No permissions to access a key\");\n }\n case ACL_DENIED_CHANNEL:\n if (verbose) {\n return sdscatfmt(sdsempty(), \"User %S has no permissions to access \"\n \"the '%S' channel\", user->name, errored_val);\n } else {\n return sdsnew(\"No permissions to access a channel\");\n }\n }\n serverPanic(\"Reached deadcode on getAclErrorMessage\");\n}\n\n/* =============================================================================\n * ACL related commands\n * ==========================================================================*/\n\n/* ACL CAT category */\nvoid aclCatWithFlags(client *c, dict *commands, uint64_t cflag, int *arraylen) {\n dictEntry *de;\n dictIterator di;\n dictInitIterator(&di, commands);\n while ((de = dictNext(&di)) != NULL) {\n struct redisCommand *cmd = dictGetVal(de);\n if (cmd->acl_categories & cflag) {\n addReplyBulkCBuffer(c, cmd->fullname, sdslen(cmd->fullname));\n (*arraylen)++;\n }\n\n if (cmd->subcommands_dict) {\n aclCatWithFlags(c, cmd->subcommands_dict, cflag, arraylen);\n }\n }\n dictResetIterator(&di);\n}\n\n/* Add the formatted response from a single selector to the ACL GETUSER\n * response. This function returns the number of fields added. \n * \n * Setting verbose to 1 means that the full qualifier for key and channel\n * permissions are shown.\n */\nint aclAddReplySelectorDescription(client *c, aclSelector *s) {\n listIter li;\n listNode *ln;\n\n /* Commands */\n addReplyBulkCString(c,\"commands\");\n sds cmddescr = ACLDescribeSelectorCommandRules(s);\n addReplyBulkSds(c,cmddescr);\n \n /* Key patterns */\n addReplyBulkCString(c,\"keys\");\n if (s->flags & SELECTOR_FLAG_ALLKEYS) {\n addReplyBulkCBuffer(c,\"~*\",2);\n } else {\n sds dsl = sdsempty();\n listRewind(s->patterns,&li);\n while((ln = listNext(&li))) {\n keyPattern *thispat = (keyPattern *) listNodeValue(ln);\n if (ln != listFirst(s->patterns)) dsl = sdscat(dsl, \" \");\n dsl = sdsCatPatternString(dsl, thispat);\n }\n addReplyBulkSds(c, dsl);\n }\n\n /* Pub/sub patterns */\n addReplyBulkCString(c,\"channels\");\n if (s->flags & SELECTOR_FLAG_ALLCHANNELS) {\n addReplyBulkCBuffer(c,\"&*\",2);\n } else {\n sds dsl = sdsempty();\n listRewind(s->channels,&li);\n while((ln = listNext(&li))) {\n sds thispat = listNodeValue(ln);\n if (ln != listFirst(s->channels)) dsl = sdscat(dsl, \" \");\n dsl = sdscatfmt(dsl, \"&%S\", thispat);\n }\n addReplyBulkSds(c, dsl);\n }\n return 3;\n}\n\n/* ACL -- show and modify the configuration of ACL users.\n * ACL HELP\n * ACL LOAD\n * ACL SAVE\n * ACL LIST\n * ACL USERS\n * ACL CAT []\n * ACL SETUSER ... acl rules ...\n * ACL DELUSER [...]\n * ACL GETUSER \n * ACL GENPASS []\n * ACL WHOAMI\n * ACL LOG [ | RESET]\n */\nvoid aclCommand(client *c) {\n char *sub = c->argv[1]->ptr;\n if (!strcasecmp(sub,\"setuser\") && c->argc >= 3) {\n /* Initially redact all of the arguments to not leak any information\n * about the user. */\n for (int j = 2; j < c->argc; j++) {\n redactClientCommandArgument(c, j);\n }\n\n sds username = c->argv[2]->ptr;\n /* Check username validity. */\n if (ACLStringHasSpaces(username,sdslen(username))) {\n addReplyError(c, \"Usernames can't contain spaces or null characters\");\n return;\n }\n\n user *u = ACLGetUserByName(username,sdslen(username));\n\n sds *temp_argv = zmalloc(c->argc * sizeof(sds));\n for (int i = 3; i < c->argc; i++) temp_argv[i-3] = c->argv[i]->ptr;\n\n sds error = ACLStringSetUser(u, username, temp_argv, c->argc - 3);\n zfree(temp_argv);\n if (error == NULL) {\n addReply(c,shared.ok);\n } else {\n addReplyErrorSdsSafe(c, error);\n }\n return;\n } else if (!strcasecmp(sub,\"deluser\") && c->argc >= 3) {\n /* Initially redact all the arguments to not leak any information\n * about the users. */\n for (int j = 2; j < c->argc; j++) redactClientCommandArgument(c, j);\n\n int deleted = 0;\n for (int j = 2; j < c->argc; j++) {\n sds username = c->argv[j]->ptr;\n if (!strcmp(username,\"default\")) {\n addReplyError(c,\"The 'default' user cannot be removed\");\n return;\n }\n }\n\n for (int j = 2; j < c->argc; j++) {\n sds username = c->argv[j]->ptr;\n user *u;\n if (raxRemove(Users,(unsigned char*)username,\n sdslen(username),\n (void**)&u))\n {\n ACLFreeUserAndKillClients(u);\n deleted++;\n }\n }\n addReplyLongLong(c,deleted);\n } else if (!strcasecmp(sub,\"getuser\") && c->argc == 3) {\n /* Redact the username to not leak any information about the user. */\n redactClientCommandArgument(c, 2);\n\n user *u = ACLGetUserByName(c->argv[2]->ptr,sdslen(c->argv[2]->ptr));\n if (u == NULL) {\n addReplyNull(c);\n return;\n }\n\n void *ufields = addReplyDeferredLen(c);\n int fields = 3;\n\n /* Flags */\n addReplyBulkCString(c,\"flags\");\n void *deflen = addReplyDeferredLen(c);\n int numflags = 0;\n for (int j = 0; ACLUserFlags[j].flag; j++) {\n if (u->flags & ACLUserFlags[j].flag) {\n addReplyBulkCString(c,ACLUserFlags[j].name);\n numflags++;\n }\n }\n setDeferredSetLen(c,deflen,numflags);\n\n /* Passwords */\n addReplyBulkCString(c,\"passwords\");\n addReplyArrayLen(c,listLength(u->passwords));\n listIter li;\n listNode *ln;\n listRewind(u->passwords,&li);\n while((ln = listNext(&li))) {\n sds thispass = listNodeValue(ln);\n addReplyBulkCBuffer(c,thispass,sdslen(thispass));\n }\n /* Include the root selector at the top level for backwards compatibility */\n fields += aclAddReplySelectorDescription(c, ACLUserGetRootSelector(u));\n\n /* Describe all of the selectors on this user, including duplicating the root selector */\n addReplyBulkCString(c,\"selectors\");\n addReplyArrayLen(c, listLength(u->selectors) - 1);\n listRewind(u->selectors,&li);\n serverAssert(listNext(&li));\n while((ln = listNext(&li))) {\n void *slen = addReplyDeferredLen(c);\n int sfields = aclAddReplySelectorDescription(c, (aclSelector *)listNodeValue(ln));\n setDeferredMapLen(c, slen, sfields);\n } \n setDeferredMapLen(c, ufields, fields);\n } else if ((!strcasecmp(sub,\"list\") || !strcasecmp(sub,\"users\")) &&\n c->argc == 2)\n {\n int justnames = !strcasecmp(sub,\"users\");\n addReplyArrayLen(c,raxSize(Users));\n raxIterator ri;\n raxStart(&ri,Users);\n raxSeek(&ri,\"^\",NULL,0);\n while(raxNext(&ri)) {\n user *u = ri.data;\n if (justnames) {\n addReplyBulkCBuffer(c,u->name,sdslen(u->name));\n } else {\n /* Return information in the configuration file format. */\n sds config = sdsnew(\"user \");\n config = sdscatsds(config,u->name);\n config = sdscatlen(config,\" \",1);\n robj *descr = ACLDescribeUser(u);\n config = sdscatsds(config,descr->ptr);\n decrRefCount(descr);\n addReplyBulkSds(c,config);\n }\n }\n raxStop(&ri);\n } else if (!strcasecmp(sub,\"whoami\") && c->argc == 2) {\n if (c->user != NULL) {\n addReplyBulkCBuffer(c,c->user->name,sdslen(c->user->name));\n } else {\n addReplyNull(c);\n }\n } else if (server.acl_filename[0] == '\\0' &&\n (!strcasecmp(sub,\"load\") || !strcasecmp(sub,\"save\")))\n {\n addReplyError(c,\"This Redis instance is not configured to use an ACL file. You may want to specify users via the ACL SETUSER command and then issue a CONFIG REWRITE (assuming you have a Redis configuration file set) in order to store users in the Redis configuration.\");\n return;\n } else if (!strcasecmp(sub,\"load\") && c->argc == 2) {\n sds errors = ACLLoadFromFile(server.acl_filename);\n if (errors == NULL) {\n addReply(c,shared.ok);\n } else {\n addReplyError(c,errors);\n sdsfree(errors);\n }\n } else if (!strcasecmp(sub,\"save\") && c->argc == 2) {\n if (ACLSaveToFile(server.acl_filename) == C_OK) {\n addReply(c,shared.ok);\n } else {\n addReplyError(c,\"There was an error trying to save the ACLs. \"\n \"Please check the server logs for more \"\n \"information\");\n }\n } else if (!strcasecmp(sub,\"cat\") && c->argc == 2) {\n void *dl = addReplyDeferredLen(c);\n int j;\n for (j = 0; ACLCommandCategories[j].flag != 0; j++)\n addReplyBulkCString(c,ACLCommandCategories[j].name);\n setDeferredArrayLen(c,dl,j);\n } else if (!strcasecmp(sub,\"cat\") && c->argc == 3) {\n uint64_t cflag = ACLGetCommandCategoryFlagByName(c->argv[2]->ptr);\n if (cflag == 0) {\n addReplyErrorFormat(c, \"Unknown category '%.128s'\", (char*)c->argv[2]->ptr);\n return;\n }\n int arraylen = 0;\n void *dl = addReplyDeferredLen(c);\n aclCatWithFlags(c, server.orig_commands, cflag, &arraylen);\n setDeferredArrayLen(c,dl,arraylen);\n } else if (!strcasecmp(sub,\"genpass\") && (c->argc == 2 || c->argc == 3)) {\n #define GENPASS_MAX_BITS 4096\n char pass[GENPASS_MAX_BITS/8*2]; /* Hex representation. */\n long bits = 256; /* By default generate 256 bits passwords. */\n\n if (c->argc == 3 && getLongFromObjectOrReply(c,c->argv[2],&bits,NULL)\n != C_OK) return;\n\n if (bits <= 0 || bits > GENPASS_MAX_BITS) {\n addReplyErrorFormat(c,\n \"ACL GENPASS argument must be the number of \"\n \"bits for the output password, a positive number \"\n \"up to %d\",GENPASS_MAX_BITS);\n return;\n }\n\n long chars = (bits+3)/4; /* Round to number of characters to emit. */\n getRandomHexChars(pass,chars);\n addReplyBulkCBuffer(c,pass,chars);\n } else if (!strcasecmp(sub,\"log\") && (c->argc == 2 || c->argc ==3)) {\n long count = 10; /* Number of entries to emit by default. */\n\n /* Parse the only argument that LOG may have: it could be either\n * the number of entries the user wants to display, or alternatively\n * the \"RESET\" command in order to flush the old entries. */\n if (c->argc == 3) {\n if (!strcasecmp(c->argv[2]->ptr,\"reset\")) {\n listSetFreeMethod(ACLLog,ACLFreeLogEntry);\n listEmpty(ACLLog);\n listSetFreeMethod(ACLLog,NULL);\n addReply(c,shared.ok);\n return;\n } else if (getLongFromObjectOrReply(c,c->argv[2],&count,NULL)\n != C_OK)\n {\n return;\n }\n if (count < 0) count = 0;\n }\n\n /* Fix the count according to the number of entries we got. */\n if ((size_t)count > listLength(ACLLog))\n count = listLength(ACLLog);\n\n addReplyArrayLen(c,count);\n listIter li;\n listNode *ln;\n listRewind(ACLLog,&li);\n mstime_t now = commandTimeSnapshot();\n while (count-- && (ln = listNext(&li)) != NULL) {\n ACLLogEntry *le = listNodeValue(ln);\n addReplyMapLen(c,10);\n addReplyBulkCString(c,\"count\");\n addReplyLongLong(c,le->count);\n\n addReplyBulkCString(c,\"reason\");\n char *reasonstr;\n switch(le->reason) {\n case ACL_DENIED_CMD: reasonstr=\"command\"; break;\n case ACL_DENIED_KEY: reasonstr=\"key\"; break;\n case ACL_DENIED_CHANNEL: reasonstr=\"channel\"; break;\n case ACL_DENIED_AUTH: reasonstr=\"auth\"; break;\n case ACL_INVALID_TLS_CERT_AUTH: reasonstr = \"tls-cert\"; break;\n default: reasonstr=\"unknown\";\n }\n addReplyBulkCString(c,reasonstr);\n\n addReplyBulkCString(c,\"context\");\n char *ctxstr;\n switch(le->context) {\n case ACL_LOG_CTX_TOPLEVEL: ctxstr=\"toplevel\"; break;\n case ACL_LOG_CTX_MULTI: ctxstr=\"multi\"; break;\n case ACL_LOG_CTX_LUA: ctxstr=\"lua\"; break;\n case ACL_LOG_CTX_MODULE: ctxstr=\"module\"; break;\n default: ctxstr=\"unknown\";\n }\n addReplyBulkCString(c,ctxstr);\n\n addReplyBulkCString(c,\"object\");\n addReplyBulkCBuffer(c,le->object,sdslen(le->object));\n addReplyBulkCString(c,\"username\");\n addReplyBulkCBuffer(c,le->username,sdslen(le->username));\n addReplyBulkCString(c,\"age-seconds\");\n double age = (double)(now - le->ctime)/1000;\n addReplyDouble(c,age);\n addReplyBulkCString(c,\"client-info\");\n addReplyBulkCBuffer(c,le->cinfo,sdslen(le->cinfo));\n addReplyBulkCString(c, \"entry-id\");\n addReplyLongLong(c, le->entry_id);\n addReplyBulkCString(c, \"timestamp-created\");\n addReplyLongLong(c, le->timestamp_created);\n addReplyBulkCString(c, \"timestamp-last-updated\");\n addReplyLongLong(c, le->ctime);\n }\n } else if (!strcasecmp(sub,\"dryrun\") && c->argc >= 4) {\n struct redisCommand *cmd;\n user *u = ACLGetUserByName(c->argv[2]->ptr,sdslen(c->argv[2]->ptr));\n if (u == NULL) {\n addReplyErrorFormat(c, \"User '%s' not found\", (char *)c->argv[2]->ptr);\n return;\n }\n\n if ((cmd = lookupCommand(c->argv + 3, c->argc - 3)) == NULL) {\n addReplyErrorFormat(c, \"Command '%s' not found\", (char *)c->argv[3]->ptr);\n return;\n }\n\n if ((cmd->arity > 0 && cmd->arity != c->argc-3) ||\n (c->argc-3 < -cmd->arity))\n {\n addReplyErrorFormat(c,\"wrong number of arguments for '%s' command\", cmd->fullname);\n return;\n }\n\n int idx;\n int result = ACLCheckAllUserCommandPerm(u, cmd, c->argv + 3, c->argc - 3, NULL, &idx);\n if (result != ACL_OK) {\n sds err = getAclErrorMessage(result, u, cmd, c->argv[idx+3]->ptr, 1);\n addReplyBulkSds(c, err);\n return;\n }\n\n addReply(c,shared.ok);\n } else if (c->argc == 2 && !strcasecmp(sub,\"help\")) {\n const char *help[] = {\n\"CAT []\",\n\" List all commands that belong to , or all command categories\",\n\" when no category is specified.\",\n\"DELUSER [ ...]\",\n\" Delete a list of users.\",\n\"DRYRUN [ ...]\",\n\" Returns whether the user can execute the given command without executing the command.\",\n\"GETUSER \",\n\" Get the user's details.\",\n\"GENPASS []\",\n\" Generate a secure 256-bit user password. The optional `bits` argument can\",\n\" be used to specify a different size.\",\n\"LIST\",\n\" Show users details in config file format.\",\n\"LOAD\",\n\" Reload users from the ACL file.\",\n\"LOG [ | RESET]\",\n\" Show the ACL log entries.\",\n\"SAVE\",\n\" Save the current config to the ACL file.\",\n\"SETUSER [ ...]\",\n\" Create or modify a user with the specified attributes.\",\n\"USERS\",\n\" List all the registered usernames.\",\n\"WHOAMI\",\n\" Return the current connection username.\",\nNULL\n };\n addReplyHelp(c,help);\n } else {\n addReplySubcommandSyntaxError(c);\n }\n}\n\nvoid addReplyCommandCategories(client *c, struct redisCommand *cmd) {\n int flagcount = 0;\n void *flaglen = addReplyDeferredLen(c);\n for (int j = 0; ACLCommandCategories[j].flag != 0; j++) {\n if (cmd->acl_categories & ACLCommandCategories[j].flag) {\n addReplyStatusFormat(c, \"@%s\", ACLCommandCategories[j].name);\n flagcount++;\n }\n }\n setDeferredSetLen(c, flaglen, flagcount);\n}\n\n/* When successful, initiates an internal connection, that is able to execute\n * internal commands (see CMD_INTERNAL). */\nstatic void internalAuth(client *c) {\n if (!server.cluster_enabled) {\n addReplyError(c, \"Cannot authenticate as an internal connection on non-cluster instances\");\n return;\n }\n\n sds password = c->argv[2]->ptr;\n\n /* Get internal secret. */\n size_t len = -1;\n const char *internal_secret = clusterGetSecret(&len);\n if (sdslen(password) != len) {\n addReplyError(c, \"-WRONGPASS invalid internal password\");\n return;\n }\n if (!time_independent_strcmp((char *)internal_secret, (char *)password, len)) {\n c->flags |= CLIENT_INTERNAL;\n /* No further authentication is needed. */\n c->authenticated = 1;\n /* Set the user to the unrestricted user, if it is not already set (default). */\n if (c->user != NULL) {\n c->user = NULL;\n moduleNotifyUserChanged(c);\n }\n addReply(c, shared.ok);\n } else {\n addReplyError(c, \"-WRONGPASS invalid internal password\");\n }\n}\n\n/* AUTH \n * AUTH (Redis >= 6.0 form)\n *\n * When the user is omitted it means that we are trying to authenticate\n * against the default user. */\nvoid authCommand(client *c) {\n /* Only two or three argument forms are allowed. */\n if (c->argc > 3) {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n /* Always redact the second argument */\n redactClientCommandArgument(c, 1);\n\n /* Handle the two different forms here. The form with two arguments\n * will just use \"default\" as username. */\n robj *username, *password;\n if (c->argc == 2) {\n /* Mimic the old behavior of giving an error for the two argument\n * form if no password is configured. */\n if (DefaultUser->flags & USER_FLAG_NOPASS) {\n addReplyError(c,\"AUTH called without any password \"\n \"configured for the default user. Are you sure \"\n \"your configuration is correct?\");\n return;\n }\n\n username = shared.default_username; \n password = c->argv[1];\n } else {\n username = c->argv[1];\n password = c->argv[2];\n redactClientCommandArgument(c, 2);\n\n /* Handle internal authentication commands.\n * Note: No user-defined ACL user can have this username (no spaces\n * allowed), thus no conflicts with ACL possible. */\n if (!strcmp(username->ptr, \"internal connection\")) {\n internalAuth(c);\n return;\n }\n }\n\n robj *err = NULL;\n int result = ACLAuthenticateUser(c, username, password, &err);\n if (result == AUTH_OK) {\n addReply(c, shared.ok);\n } else if (result == AUTH_ERR) {\n addAuthErrReply(c, err);\n }\n if (err) decrRefCount(err);\n}\n\n/* Set the password for the \"default\" ACL user. This implements supports for\n * requirepass config, so passing in NULL will set the user to be nopass. */\nvoid ACLUpdateDefaultUserPassword(sds password) {\n ACLSetUser(DefaultUser,\"resetpass\",-1);\n if (password) {\n sds aclop = sdscatlen(sdsnew(\">\"), password, sdslen(password));\n ACLSetUser(DefaultUser,aclop,sdslen(aclop));\n sdsfree(aclop);\n } else {\n ACLSetUser(DefaultUser,\"nopass\",-1);\n }\n}\n" }, { "path": "src/adlist.c", "content": "/* adlist.c - A generic doubly linked list implementation\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n\n#include \n#include \"adlist.h\"\n#include \"zmalloc.h\"\n\n/* Create a new list. The created list can be freed with\n * listRelease(), but private value of every node need to be freed\n * by the user before to call listRelease(), or by setting a free method using\n * listSetFreeMethod.\n *\n * On error, NULL is returned. Otherwise the pointer to the new list. */\nlist *listCreate(void)\n{\n struct list *list;\n\n if ((list = zmalloc(sizeof(*list))) == NULL)\n return NULL;\n list->head = list->tail = NULL;\n list->len = 0;\n list->dup = NULL;\n list->free = NULL;\n list->match = NULL;\n return list;\n}\n\n/* Remove all the elements from the list without destroying the list itself. */\nvoid listEmpty(list *list)\n{\n unsigned long len;\n listNode *current, *next;\n\n current = list->head;\n len = list->len;\n while(len--) {\n next = current->next;\n if (list->free) list->free(current->value);\n zfree(current);\n current = next;\n }\n list->head = list->tail = NULL;\n list->len = 0;\n}\n\n/* Free the whole list.\n *\n * This function can't fail. */\nvoid listRelease(list *list)\n{\n if (!list)\n return;\n listEmpty(list);\n zfree(list);\n}\n\n/* Generic version of listRelease. */\nvoid listReleaseGeneric(void *list) {\n listRelease((struct list*)list);\n}\n\n/* Add a new node to the list, to head, containing the specified 'value'\n * pointer as value.\n *\n * On error, NULL is returned and no operation is performed (i.e. the\n * list remains unaltered).\n * On success the 'list' pointer you pass to the function is returned. */\nlist *listAddNodeHead(list *list, void *value)\n{\n listNode *node;\n\n if ((node = zmalloc(sizeof(*node))) == NULL)\n return NULL;\n node->value = value;\n listLinkNodeHead(list, node);\n return list;\n}\n\n/*\n * Add a node that has already been allocated to the head of list\n */\nvoid listLinkNodeHead(list* list, listNode *node) {\n if (list->len == 0) {\n list->head = list->tail = node;\n node->prev = node->next = NULL;\n } else {\n node->prev = NULL;\n node->next = list->head;\n list->head->prev = node;\n list->head = node;\n }\n list->len++;\n}\n\n/* Add a new node to the list, to tail, containing the specified 'value'\n * pointer as value.\n *\n * On error, NULL is returned and no operation is performed (i.e. the\n * list remains unaltered).\n * On success the 'list' pointer you pass to the function is returned. */\nlist *listAddNodeTail(list *list, void *value)\n{\n listNode *node;\n\n if ((node = zmalloc(sizeof(*node))) == NULL)\n return NULL;\n node->value = value;\n listLinkNodeTail(list, node);\n return list;\n}\n\n/*\n * Add a node that has already been allocated to the tail of list\n */\nvoid listLinkNodeTail(list *list, listNode *node) {\n if (list->len == 0) {\n list->head = list->tail = node;\n node->prev = node->next = NULL;\n } else {\n node->prev = list->tail;\n node->next = NULL;\n list->tail->next = node;\n list->tail = node;\n }\n list->len++;\n}\n\nlist *listInsertNode(list *list, listNode *old_node, void *value, int after) {\n listNode *node;\n\n if ((node = zmalloc(sizeof(*node))) == NULL)\n return NULL;\n node->value = value;\n if (after) {\n node->prev = old_node;\n node->next = old_node->next;\n if (list->tail == old_node) {\n list->tail = node;\n }\n } else {\n node->next = old_node;\n node->prev = old_node->prev;\n if (list->head == old_node) {\n list->head = node;\n }\n }\n if (node->prev != NULL) {\n node->prev->next = node;\n }\n if (node->next != NULL) {\n node->next->prev = node;\n }\n list->len++;\n return list;\n}\n\n/* Remove the specified node from the specified list.\n * The node is freed. If free callback is provided the value is freed as well.\n *\n * This function can't fail. */\nvoid listDelNode(list *list, listNode *node)\n{\n listUnlinkNode(list, node);\n if (list->free) list->free(node->value);\n zfree(node);\n}\n\n/*\n * Remove the specified node from the list without freeing it.\n */\nvoid listUnlinkNode(list *list, listNode *node) {\n if (node->prev)\n node->prev->next = node->next;\n else\n list->head = node->next;\n if (node->next)\n node->next->prev = node->prev;\n else\n list->tail = node->prev;\n\n node->next = NULL;\n node->prev = NULL;\n\n list->len--;\n}\n\n/* Returns a list iterator 'iter'. After the initialization every\n * call to listNext() will return the next element of the list.\n *\n * This function can't fail. */\nvoid listInitIterator(listIter *iter, list *list, int direction)\n{\n if (direction == AL_START_HEAD)\n iter->next = list->head;\n else\n iter->next = list->tail;\n iter->direction = direction;\n}\n\n/* Create an iterator in the list private iterator structure */\nvoid listRewind(list *list, listIter *li) {\n li->next = list->head;\n li->direction = AL_START_HEAD;\n}\n\nvoid listRewindTail(list *list, listIter *li) {\n li->next = list->tail;\n li->direction = AL_START_TAIL;\n}\n\n/* Return the next element of an iterator.\n * It's valid to remove the currently returned element using\n * listDelNode(), but not to remove other elements.\n *\n * The function returns a pointer to the next element of the list,\n * or NULL if there are no more elements, so the classical usage\n * pattern is:\n *\n * iter = listGetIterator(list,);\n * while ((node = listNext(iter)) != NULL) {\n * doSomethingWith(listNodeValue(node));\n * }\n *\n * */\nlistNode *listNext(listIter *iter)\n{\n listNode *current = iter->next;\n\n if (current != NULL) {\n if (iter->direction == AL_START_HEAD)\n iter->next = current->next;\n else\n iter->next = current->prev;\n }\n return current;\n}\n\n/* Duplicate the whole list. On out of memory NULL is returned.\n * On success a copy of the original list is returned.\n *\n * The 'Dup' method set with listSetDupMethod() function is used\n * to copy the node value. Otherwise the same pointer value of\n * the original node is used as value of the copied node.\n *\n * The original list both on success or error is never modified. */\nlist *listDup(list *orig)\n{\n list *copy;\n listIter iter;\n listNode *node;\n\n if ((copy = listCreate()) == NULL)\n return NULL;\n copy->dup = orig->dup;\n copy->free = orig->free;\n copy->match = orig->match;\n listRewind(orig, &iter);\n while((node = listNext(&iter)) != NULL) {\n void *value;\n\n if (copy->dup) {\n value = copy->dup(node->value);\n if (value == NULL) {\n listRelease(copy);\n return NULL;\n }\n } else {\n value = node->value;\n }\n \n if (listAddNodeTail(copy, value) == NULL) {\n /* Free value if dup succeed but listAddNodeTail failed. */\n if (copy->free) copy->free(value);\n\n listRelease(copy);\n return NULL;\n }\n }\n return copy;\n}\n\n/* Search the list for a node matching a given key.\n * The match is performed using the 'match' method\n * set with listSetMatchMethod(). If no 'match' method\n * is set, the 'value' pointer of every node is directly\n * compared with the 'key' pointer.\n *\n * On success the first matching node pointer is returned\n * (search starts from head). If no matching node exists\n * NULL is returned. */\nlistNode *listSearchKey(list *list, void *key)\n{\n listIter iter;\n listNode *node;\n\n listRewind(list, &iter);\n while((node = listNext(&iter)) != NULL) {\n if (list->match) {\n if (list->match(node->value, key)) {\n return node;\n }\n } else {\n if (key == node->value) {\n return node;\n }\n }\n }\n return NULL;\n}\n\n/* Return the element at the specified zero-based index\n * where 0 is the head, 1 is the element next to head\n * and so on. Negative integers are used in order to count\n * from the tail, -1 is the last element, -2 the penultimate\n * and so on. If the index is out of range NULL is returned. */\nlistNode *listIndex(list *list, long index) {\n listNode *n;\n\n if (index < 0) {\n index = (-index)-1;\n n = list->tail;\n while(index-- && n) n = n->prev;\n } else {\n n = list->head;\n while(index-- && n) n = n->next;\n }\n return n;\n}\n\n/* Rotate the list removing the tail node and inserting it to the head. */\nvoid listRotateTailToHead(list *list) {\n if (listLength(list) <= 1) return;\n\n /* Detach current tail */\n listNode *tail = list->tail;\n list->tail = tail->prev;\n list->tail->next = NULL;\n /* Move it as head */\n list->head->prev = tail;\n tail->prev = NULL;\n tail->next = list->head;\n list->head = tail;\n}\n\n/* Rotate the list removing the head node and inserting it to the tail. */\nvoid listRotateHeadToTail(list *list) {\n if (listLength(list) <= 1) return;\n\n listNode *head = list->head;\n /* Detach current head */\n list->head = head->next;\n list->head->prev = NULL;\n /* Move it as tail */\n list->tail->next = head;\n head->next = NULL;\n head->prev = list->tail;\n list->tail = head;\n}\n\n/* Add all the elements of the list 'o' at the end of the\n * list 'l'. The list 'other' remains empty but otherwise valid. */\nvoid listJoin(list *l, list *o) {\n if (o->len == 0) return;\n\n o->head->prev = l->tail;\n\n if (l->tail)\n l->tail->next = o->head;\n else\n l->head = o->head;\n\n l->tail = o->tail;\n l->len += o->len;\n\n /* Setup other as an empty list. */\n o->head = o->tail = NULL;\n o->len = 0;\n}\n\n/* Initializes the node's value and sets its pointers\n * so that it is initially not a member of any list.\n */\nvoid listInitNode(listNode *node, void *value) {\n node->prev = NULL;\n node->next = NULL;\n node->value = value;\n}\n" }, { "path": "src/adlist.h", "content": "/* adlist.h - A generic doubly linked list implementation\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#ifndef __ADLIST_H__\n#define __ADLIST_H__\n\n/* Node, List, and Iterator are the only data structures used currently. */\n\ntypedef struct listNode {\n struct listNode *prev;\n struct listNode *next;\n void *value;\n} listNode;\n\ntypedef struct listIter {\n listNode *next;\n int direction;\n} listIter;\n\ntypedef struct list {\n listNode *head;\n listNode *tail;\n void *(*dup)(void *ptr);\n void (*free)(void *ptr);\n int (*match)(void *ptr, void *key);\n unsigned long len;\n} list;\n\n/* Functions implemented as macros */\n#define listLength(l) ((l)->len)\n#define listFirst(l) ((l)->head)\n#define listLast(l) ((l)->tail)\n#define listPrevNode(n) ((n)->prev)\n#define listNextNode(n) ((n)->next)\n#define listNodeValue(n) ((n)->value)\n\n#define listSetDupMethod(l,m) ((l)->dup = (m))\n#define listSetFreeMethod(l,m) ((l)->free = (m))\n#define listSetMatchMethod(l,m) ((l)->match = (m))\n\n#define listGetDupMethod(l) ((l)->dup)\n#define listGetFreeMethod(l) ((l)->free)\n#define listGetMatchMethod(l) ((l)->match)\n\n/* Prototypes */\nlist *listCreate(void);\nvoid listRelease(list *list);\nvoid listReleaseGeneric(void *list);\nvoid listEmpty(list *list);\nlist *listAddNodeHead(list *list, void *value);\nlist *listAddNodeTail(list *list, void *value);\nlist *listInsertNode(list *list, listNode *old_node, void *value, int after);\nvoid listDelNode(list *list, listNode *node);\nvoid listInitIterator(listIter *iter, list *list, int direction);\nlistNode *listNext(listIter *iter);\nlist *listDup(list *orig);\nlistNode *listSearchKey(list *list, void *key);\nlistNode *listIndex(list *list, long index);\nvoid listRewind(list *list, listIter *li);\nvoid listRewindTail(list *list, listIter *li);\nvoid listRotateTailToHead(list *list);\nvoid listRotateHeadToTail(list *list);\nvoid listJoin(list *l, list *o);\nvoid listInitNode(listNode *node, void *value);\nvoid listLinkNodeHead(list *list, listNode *node);\nvoid listLinkNodeTail(list *list, listNode *node);\nvoid listUnlinkNode(list *list, listNode *node);\n\n/* Directions for iterators */\n#define AL_START_HEAD 0\n#define AL_START_TAIL 1\n\n#endif /* __ADLIST_H__ */\n" }, { "path": "src/ae.c", "content": "/* A simple event-driven programming library. Originally I wrote this code\n * for the Jim's event-loop (Jim is a Tcl interpreter) but later translated\n * it in form of a library for easy reuse.\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"ae.h\"\n#include \"anet.h\"\n#include \"redisassert.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"zmalloc.h\"\n#include \"config.h\"\n\n/* Include the best multiplexing layer supported by this system.\n * The following should be ordered by performances, descending. */\n#ifdef HAVE_EVPORT\n#include \"ae_evport.c\"\n#else\n #ifdef HAVE_EPOLL\n #include \"ae_epoll.c\"\n #else\n #ifdef HAVE_KQUEUE\n #include \"ae_kqueue.c\"\n #else\n #include \"ae_select.c\"\n #endif\n #endif\n#endif\n\n#define INITIAL_EVENT 1024\naeEventLoop *aeCreateEventLoop(int setsize) {\n aeEventLoop *eventLoop;\n int i;\n\n monotonicInit(); /* just in case the calling app didn't initialize */\n\n if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;\n eventLoop->nevents = setsize < INITIAL_EVENT ? setsize : INITIAL_EVENT;\n eventLoop->events = zmalloc(sizeof(aeFileEvent)*eventLoop->nevents);\n eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*eventLoop->nevents);\n if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;\n eventLoop->setsize = setsize;\n eventLoop->timeEventHead = NULL;\n eventLoop->timeEventNextId = 0;\n eventLoop->stop = 0;\n eventLoop->maxfd = -1;\n eventLoop->beforesleep = NULL;\n eventLoop->aftersleep = NULL;\n eventLoop->flags = 0;\n memset(eventLoop->privdata, 0, sizeof(eventLoop->privdata));\n if (aeApiCreate(eventLoop) == -1) goto err;\n /* Events with mask == AE_NONE are not set. So let's initialize the\n * vector with it. */\n for (i = 0; i < eventLoop->nevents; i++)\n eventLoop->events[i].mask = AE_NONE;\n return eventLoop;\n\nerr:\n if (eventLoop) {\n zfree(eventLoop->events);\n zfree(eventLoop->fired);\n zfree(eventLoop);\n }\n return NULL;\n}\n\n/* Return the current set size. */\nint aeGetSetSize(aeEventLoop *eventLoop) {\n return eventLoop->setsize;\n}\n\n/*\n * Tell the event processing to change the wait timeout as soon as possible.\n *\n * Note: it just means you turn on/off the global AE_DONT_WAIT.\n */\nvoid aeSetDontWait(aeEventLoop *eventLoop, int noWait) {\n if (noWait)\n eventLoop->flags |= AE_DONT_WAIT;\n else\n eventLoop->flags &= ~AE_DONT_WAIT;\n}\n\n/* Resize the maximum set size of the event loop.\n * If the requested set size is smaller than the current set size, but\n * there is already a file descriptor in use that is >= the requested\n * set size minus one, AE_ERR is returned and the operation is not\n * performed at all.\n *\n * Otherwise AE_OK is returned and the operation is successful. */\nint aeResizeSetSize(aeEventLoop *eventLoop, int setsize) {\n if (setsize == eventLoop->setsize) return AE_OK;\n if (eventLoop->maxfd >= setsize) return AE_ERR;\n if (aeApiResize(eventLoop,setsize) == -1) return AE_ERR;\n\n eventLoop->setsize = setsize;\n\n /* If the current allocated space is larger than the requested size,\n * we need to shrink it to the requested size. */\n if (setsize < eventLoop->nevents) {\n eventLoop->events = zrealloc(eventLoop->events,sizeof(aeFileEvent)*setsize);\n eventLoop->fired = zrealloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);\n eventLoop->nevents = setsize;\n }\n return AE_OK;\n}\n\nvoid aeDeleteEventLoop(aeEventLoop *eventLoop) {\n aeApiFree(eventLoop);\n zfree(eventLoop->events);\n zfree(eventLoop->fired);\n\n /* Free the time events list. */\n aeTimeEvent *next_te, *te = eventLoop->timeEventHead;\n while (te) {\n next_te = te->next;\n if (te->finalizerProc)\n te->finalizerProc(eventLoop, te->clientData);\n zfree(te);\n te = next_te;\n }\n zfree(eventLoop);\n}\n\nvoid aeStop(aeEventLoop *eventLoop) {\n eventLoop->stop = 1;\n}\n\nint aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,\n aeFileProc *proc, void *clientData)\n{\n if (fd >= eventLoop->setsize) {\n errno = ERANGE;\n return AE_ERR;\n }\n\n /* Resize the events and fired arrays if the file\n * descriptor exceeds the current number of events. */\n if (unlikely(fd >= eventLoop->nevents)) {\n int newnevents = eventLoop->nevents;\n newnevents = (newnevents * 2 > fd + 1) ? newnevents * 2 : fd + 1;\n newnevents = (newnevents > eventLoop->setsize) ? eventLoop->setsize : newnevents;\n eventLoop->events = zrealloc(eventLoop->events, sizeof(aeFileEvent) * newnevents);\n eventLoop->fired = zrealloc(eventLoop->fired, sizeof(aeFiredEvent) * newnevents);\n\n /* Initialize new slots with an AE_NONE mask */\n for (int i = eventLoop->nevents; i < newnevents; i++)\n eventLoop->events[i].mask = AE_NONE;\n eventLoop->nevents = newnevents;\n }\n\n aeFileEvent *fe = &eventLoop->events[fd];\n\n if (aeApiAddEvent(eventLoop, fd, mask) == -1)\n return AE_ERR;\n fe->mask |= mask;\n if (mask & AE_READABLE) fe->rfileProc = proc;\n if (mask & AE_WRITABLE) fe->wfileProc = proc;\n fe->clientData = clientData;\n if (fd > eventLoop->maxfd)\n eventLoop->maxfd = fd;\n return AE_OK;\n}\n\nvoid aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)\n{\n if (fd >= eventLoop->setsize) return;\n aeFileEvent *fe = &eventLoop->events[fd];\n if (fe->mask == AE_NONE) return;\n\n /* We want to always remove AE_BARRIER if set when AE_WRITABLE\n * is removed. */\n if (mask & AE_WRITABLE) mask |= AE_BARRIER;\n\n aeApiDelEvent(eventLoop, fd, mask);\n fe->mask = fe->mask & (~mask);\n if (fd == eventLoop->maxfd && fe->mask == AE_NONE) {\n /* Update the max fd */\n int j;\n\n for (j = eventLoop->maxfd-1; j >= 0; j--)\n if (eventLoop->events[j].mask != AE_NONE) break;\n eventLoop->maxfd = j;\n }\n}\n\nvoid *aeGetFileClientData(aeEventLoop *eventLoop, int fd) {\n if (fd >= eventLoop->setsize) return NULL;\n aeFileEvent *fe = &eventLoop->events[fd];\n if (fe->mask == AE_NONE) return NULL;\n\n return fe->clientData;\n}\n\nint aeGetFileEvents(aeEventLoop *eventLoop, int fd) {\n if (fd >= eventLoop->setsize) return 0;\n aeFileEvent *fe = &eventLoop->events[fd];\n\n return fe->mask;\n}\n\nlong long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,\n aeTimeProc *proc, void *clientData,\n aeEventFinalizerProc *finalizerProc)\n{\n long long id = eventLoop->timeEventNextId++;\n aeTimeEvent *te;\n\n te = zmalloc(sizeof(*te));\n if (te == NULL) return AE_ERR;\n te->id = id;\n te->when = getMonotonicUs() + milliseconds * 1000;\n te->timeProc = proc;\n te->finalizerProc = finalizerProc;\n te->clientData = clientData;\n te->prev = NULL;\n te->next = eventLoop->timeEventHead;\n te->refcount = 0;\n if (te->next)\n te->next->prev = te;\n eventLoop->timeEventHead = te;\n return id;\n}\n\nint aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)\n{\n aeTimeEvent *te = eventLoop->timeEventHead;\n while(te) {\n if (te->id == id) {\n te->id = AE_DELETED_EVENT_ID;\n return AE_OK;\n }\n te = te->next;\n }\n return AE_ERR; /* NO event with the specified ID found */\n}\n\n/* How many microseconds until the first timer should fire.\n * If there are no timers, -1 is returned.\n *\n * Note that's O(N) since time events are unsorted.\n * Possible optimizations (not needed by Redis so far, but...):\n * 1) Insert the event in order, so that the nearest is just the head.\n * Much better but still insertion or deletion of timers is O(N).\n * 2) Use a skiplist to have this operation as O(1) and insertion as O(log(N)).\n */\nstatic int64_t usUntilEarliestTimer(aeEventLoop *eventLoop) {\n aeTimeEvent *te = eventLoop->timeEventHead;\n if (te == NULL) return -1;\n\n aeTimeEvent *earliest = NULL;\n while (te) {\n if ((!earliest || te->when < earliest->when) && te->id != AE_DELETED_EVENT_ID)\n earliest = te;\n te = te->next;\n }\n\n monotime now = getMonotonicUs();\n return (now >= earliest->when) ? 0 : earliest->when - now;\n}\n\n/* Process time events */\nstatic int processTimeEvents(aeEventLoop *eventLoop) {\n int processed = 0;\n aeTimeEvent *te;\n long long maxId;\n\n te = eventLoop->timeEventHead;\n maxId = eventLoop->timeEventNextId-1;\n monotime now = getMonotonicUs();\n while(te) {\n long long id;\n\n /* Remove events scheduled for deletion. */\n if (te->id == AE_DELETED_EVENT_ID) {\n aeTimeEvent *next = te->next;\n /* If a reference exists for this timer event,\n * don't free it. This is currently incremented\n * for recursive timerProc calls */\n if (te->refcount) {\n te = next;\n continue;\n }\n if (te->prev)\n te->prev->next = te->next;\n else\n eventLoop->timeEventHead = te->next;\n if (te->next)\n te->next->prev = te->prev;\n if (te->finalizerProc) {\n te->finalizerProc(eventLoop, te->clientData);\n now = getMonotonicUs();\n }\n zfree(te);\n te = next;\n continue;\n }\n\n /* Make sure we don't process time events created by time events in\n * this iteration. Note that this check is currently useless: we always\n * add new timers on the head, however if we change the implementation\n * detail, this check may be useful again: we keep it here for future\n * defense. */\n if (te->id > maxId) {\n te = te->next;\n continue;\n }\n\n if (te->when <= now) {\n int retval;\n\n id = te->id;\n te->refcount++;\n retval = te->timeProc(eventLoop, id, te->clientData);\n te->refcount--;\n processed++;\n now = getMonotonicUs();\n if (retval != AE_NOMORE) {\n te->when = now + (monotime)retval * 1000;\n } else {\n te->id = AE_DELETED_EVENT_ID;\n }\n }\n te = te->next;\n }\n return processed;\n}\n\n/* Process every pending file event, then every pending time event\n * (that may be registered by file event callbacks just processed).\n * Without special flags the function sleeps until some file event\n * fires, or when the next time event occurs (if any).\n *\n * If flags is 0, the function does nothing and returns.\n * if flags has AE_ALL_EVENTS set, all the kind of events are processed.\n * if flags has AE_FILE_EVENTS set, file events are processed.\n * if flags has AE_TIME_EVENTS set, time events are processed.\n * if flags has AE_DONT_WAIT set, the function returns ASAP once all\n * the events that can be handled without a wait are processed.\n * if flags has AE_CALL_AFTER_SLEEP set, the aftersleep callback is called.\n * if flags has AE_CALL_BEFORE_SLEEP set, the beforesleep callback is called.\n *\n * The function returns the number of events processed. */\nint aeProcessEvents(aeEventLoop *eventLoop, int flags)\n{\n int processed = 0, numevents;\n\n /* Nothing to do? return ASAP */\n if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) return 0;\n\n /* Note that we want to call aeApiPoll() even if there are no\n * file events to process as long as we want to process time\n * events, in order to sleep until the next time event is ready\n * to fire. */\n if (eventLoop->maxfd != -1 ||\n ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {\n int j;\n struct timeval tv, *tvp = NULL; /* NULL means infinite wait. */\n int64_t usUntilTimer;\n\n if (eventLoop->beforesleep != NULL && (flags & AE_CALL_BEFORE_SLEEP))\n eventLoop->beforesleep(eventLoop);\n\n /* The eventLoop->flags may be changed inside beforesleep.\n * So we should check it after beforesleep be called. At the same time,\n * the parameter flags always should have the highest priority.\n * That is to say, once the parameter flag is set to AE_DONT_WAIT,\n * no matter what value eventLoop->flags is set to, we should ignore it. */\n if ((flags & AE_DONT_WAIT) || (eventLoop->flags & AE_DONT_WAIT)) {\n tv.tv_sec = tv.tv_usec = 0;\n tvp = &tv;\n } else if (flags & AE_TIME_EVENTS) {\n usUntilTimer = usUntilEarliestTimer(eventLoop);\n if (usUntilTimer >= 0) {\n tv.tv_sec = usUntilTimer / 1000000;\n tv.tv_usec = usUntilTimer % 1000000;\n tvp = &tv;\n }\n }\n /* Call the multiplexing API, will return only on timeout or when\n * some event fires. */\n numevents = aeApiPoll(eventLoop, tvp);\n\n /* Don't process file events if not requested. */\n if (!(flags & AE_FILE_EVENTS)) {\n numevents = 0;\n }\n\n /* After sleep callback. */\n if (eventLoop->aftersleep != NULL && flags & AE_CALL_AFTER_SLEEP)\n eventLoop->aftersleep(eventLoop);\n\n for (j = 0; j < numevents; j++) {\n int fd = eventLoop->fired[j].fd;\n aeFileEvent *fe = &eventLoop->events[fd];\n int mask = eventLoop->fired[j].mask;\n int fired = 0; /* Number of events fired for current fd. */\n\n /* Normally we execute the readable event first, and the writable\n * event later. This is useful as sometimes we may be able\n * to serve the reply of a query immediately after processing the\n * query.\n *\n * However if AE_BARRIER is set in the mask, our application is\n * asking us to do the reverse: never fire the writable event\n * after the readable. In such a case, we invert the calls.\n * This is useful when, for instance, we want to do things\n * in the beforeSleep() hook, like fsyncing a file to disk,\n * before replying to a client. */\n int invert = fe->mask & AE_BARRIER;\n\n /* Note the \"fe->mask & mask & ...\" code: maybe an already\n * processed event removed an element that fired and we still\n * didn't processed, so we check if the event is still valid.\n *\n * Fire the readable event if the call sequence is not\n * inverted. */\n if (!invert && fe->mask & mask & AE_READABLE) {\n fe->rfileProc(eventLoop,fd,fe->clientData,mask);\n fired++;\n fe = &eventLoop->events[fd]; /* Refresh in case of resize. */\n }\n\n /* Fire the writable event. */\n if (fe->mask & mask & AE_WRITABLE) {\n if (!fired || fe->wfileProc != fe->rfileProc) {\n fe->wfileProc(eventLoop,fd,fe->clientData,mask);\n fired++;\n }\n }\n\n /* If we have to invert the call, fire the readable event now\n * after the writable one. */\n if (invert) {\n fe = &eventLoop->events[fd]; /* Refresh in case of resize. */\n if ((fe->mask & mask & AE_READABLE) &&\n (!fired || fe->wfileProc != fe->rfileProc))\n {\n fe->rfileProc(eventLoop,fd,fe->clientData,mask);\n fired++;\n }\n }\n\n processed++;\n }\n }\n /* Check time events */\n if (flags & AE_TIME_EVENTS)\n processed += processTimeEvents(eventLoop);\n\n return processed; /* return the number of processed file/time events */\n}\n\n/* Wait for milliseconds until the given file descriptor becomes\n * writable/readable/exception */\nint aeWait(int fd, int mask, long long milliseconds) {\n struct pollfd pfd;\n int retmask = 0, retval;\n\n memset(&pfd, 0, sizeof(pfd));\n pfd.fd = fd;\n if (mask & AE_READABLE) pfd.events |= POLLIN;\n if (mask & AE_WRITABLE) pfd.events |= POLLOUT;\n\n if ((retval = poll(&pfd, 1, milliseconds))== 1) {\n if (pfd.revents & POLLIN) retmask |= AE_READABLE;\n if (pfd.revents & POLLOUT) retmask |= AE_WRITABLE;\n if (pfd.revents & POLLERR) retmask |= AE_WRITABLE;\n if (pfd.revents & POLLHUP) retmask |= AE_WRITABLE;\n return retmask;\n } else {\n return retval;\n }\n}\n\nvoid aeMain(aeEventLoop *eventLoop) {\n eventLoop->stop = 0;\n while (!eventLoop->stop) {\n aeProcessEvents(eventLoop, AE_ALL_EVENTS|\n AE_CALL_BEFORE_SLEEP|\n AE_CALL_AFTER_SLEEP);\n }\n}\n\nchar *aeGetApiName(void) {\n return aeApiName();\n}\n\nvoid aeSetBeforeSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *beforesleep) {\n eventLoop->beforesleep = beforesleep;\n}\n\nvoid aeSetAfterSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *aftersleep) {\n eventLoop->aftersleep = aftersleep;\n}\n" }, { "path": "src/ae.h", "content": "/* A simple event-driven programming library. Originally I wrote this code\n * for the Jim's event-loop (Jim is a Tcl interpreter) but later translated\n * it in form of a library for easy reuse.\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#ifndef __AE_H__\n#define __AE_H__\n\n#include \"monotonic.h\"\n\n#define AE_OK 0\n#define AE_ERR -1\n\n#define AE_NONE 0 /* No events registered. */\n#define AE_READABLE 1 /* Fire when descriptor is readable. */\n#define AE_WRITABLE 2 /* Fire when descriptor is writable. */\n#define AE_BARRIER 4 /* With WRITABLE, never fire the event if the\n READABLE event already fired in the same event\n loop iteration. Useful when you want to persist\n things to disk before sending replies, and want\n to do that in a group fashion. */\n\n#define AE_FILE_EVENTS (1<<0)\n#define AE_TIME_EVENTS (1<<1)\n#define AE_ALL_EVENTS (AE_FILE_EVENTS|AE_TIME_EVENTS)\n#define AE_DONT_WAIT (1<<2)\n#define AE_CALL_BEFORE_SLEEP (1<<3)\n#define AE_CALL_AFTER_SLEEP (1<<4)\n\n#define AE_NOMORE -1\n#define AE_DELETED_EVENT_ID -1\n\n/* Macros */\n#define AE_NOTUSED(V) ((void) V)\n\nstruct aeEventLoop;\n\n/* Types and data structures */\ntypedef void aeFileProc(struct aeEventLoop *eventLoop, int fd, void *clientData, int mask);\ntypedef int aeTimeProc(struct aeEventLoop *eventLoop, long long id, void *clientData);\ntypedef void aeEventFinalizerProc(struct aeEventLoop *eventLoop, void *clientData);\ntypedef void aeBeforeSleepProc(struct aeEventLoop *eventLoop);\n\n/* File event structure */\ntypedef struct aeFileEvent {\n int mask; /* one of AE_(READABLE|WRITABLE|BARRIER) */\n aeFileProc *rfileProc;\n aeFileProc *wfileProc;\n void *clientData;\n} aeFileEvent;\n\n/* Time event structure */\ntypedef struct aeTimeEvent {\n long long id; /* time event identifier. */\n monotime when;\n aeTimeProc *timeProc;\n aeEventFinalizerProc *finalizerProc;\n void *clientData;\n struct aeTimeEvent *prev;\n struct aeTimeEvent *next;\n int refcount; /* refcount to prevent timer events from being\n \t\t * freed in recursive time event calls. */\n} aeTimeEvent;\n\n/* A fired event */\ntypedef struct aeFiredEvent {\n int fd;\n int mask;\n} aeFiredEvent;\n\n/* State of an event based program */\ntypedef struct aeEventLoop {\n int maxfd; /* highest file descriptor currently registered */\n int setsize; /* max number of file descriptors tracked */\n long long timeEventNextId;\n int nevents; /* Size of Registered events */\n aeFileEvent *events; /* Registered events */\n aeFiredEvent *fired; /* Fired events */\n aeTimeEvent *timeEventHead;\n int stop;\n void *apidata; /* This is used for polling API specific data */\n aeBeforeSleepProc *beforesleep;\n aeBeforeSleepProc *aftersleep;\n int flags;\n void *privdata[2];\n} aeEventLoop;\n\n/* Prototypes */\naeEventLoop *aeCreateEventLoop(int setsize);\nvoid aeDeleteEventLoop(aeEventLoop *eventLoop);\nvoid aeStop(aeEventLoop *eventLoop);\nint aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,\n aeFileProc *proc, void *clientData);\nvoid aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask);\nint aeGetFileEvents(aeEventLoop *eventLoop, int fd);\nvoid *aeGetFileClientData(aeEventLoop *eventLoop, int fd);\nlong long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds,\n aeTimeProc *proc, void *clientData,\n aeEventFinalizerProc *finalizerProc);\nint aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id);\nint aeProcessEvents(aeEventLoop *eventLoop, int flags);\nint aeWait(int fd, int mask, long long milliseconds);\nvoid aeMain(aeEventLoop *eventLoop);\nchar *aeGetApiName(void);\nvoid aeSetBeforeSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *beforesleep);\nvoid aeSetAfterSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *aftersleep);\nint aeGetSetSize(aeEventLoop *eventLoop);\nint aeResizeSetSize(aeEventLoop *eventLoop, int setsize);\nvoid aeSetDontWait(aeEventLoop *eventLoop, int noWait);\n\n#endif\n" }, { "path": "src/ae_epoll.c", "content": "/* Linux epoll(2) based ae.c module\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n\n#include \n\ntypedef struct aeApiState {\n int epfd;\n struct epoll_event *events;\n} aeApiState;\n\nstatic int aeApiCreate(aeEventLoop *eventLoop) {\n aeApiState *state = zmalloc(sizeof(aeApiState));\n\n if (!state) return -1;\n state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);\n if (!state->events) {\n zfree(state);\n return -1;\n }\n state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */\n if (state->epfd == -1) {\n zfree(state->events);\n zfree(state);\n return -1;\n }\n anetCloexec(state->epfd);\n eventLoop->apidata = state;\n return 0;\n}\n\nstatic int aeApiResize(aeEventLoop *eventLoop, int setsize) {\n aeApiState *state = eventLoop->apidata;\n\n state->events = zrealloc(state->events, sizeof(struct epoll_event)*setsize);\n return 0;\n}\n\nstatic void aeApiFree(aeEventLoop *eventLoop) {\n aeApiState *state = eventLoop->apidata;\n\n close(state->epfd);\n zfree(state->events);\n zfree(state);\n}\n\nstatic int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n struct epoll_event ee = {0}; /* avoid valgrind warning */\n /* If the fd was already monitored for some event, we need a MOD\n * operation. Otherwise we need an ADD operation. */\n int op = eventLoop->events[fd].mask == AE_NONE ?\n EPOLL_CTL_ADD : EPOLL_CTL_MOD;\n\n ee.events = 0;\n mask |= eventLoop->events[fd].mask; /* Merge old events */\n if (mask & AE_READABLE) ee.events |= EPOLLIN;\n if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;\n ee.data.fd = fd;\n if (epoll_ctl(state->epfd,op,fd,&ee) == -1) return -1;\n return 0;\n}\n\nstatic void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask) {\n aeApiState *state = eventLoop->apidata;\n struct epoll_event ee = {0}; /* avoid valgrind warning */\n int mask = eventLoop->events[fd].mask & (~delmask);\n\n ee.events = 0;\n if (mask & AE_READABLE) ee.events |= EPOLLIN;\n if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;\n ee.data.fd = fd;\n if (mask != AE_NONE) {\n epoll_ctl(state->epfd,EPOLL_CTL_MOD,fd,&ee);\n } else {\n /* Note, Kernel < 2.6.9 requires a non null event pointer even for\n * EPOLL_CTL_DEL. */\n epoll_ctl(state->epfd,EPOLL_CTL_DEL,fd,&ee);\n }\n}\n\nstatic int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {\n aeApiState *state = eventLoop->apidata;\n int retval, numevents = 0;\n\n retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,\n tvp ? (tvp->tv_sec*1000 + (tvp->tv_usec + 999)/1000) : -1);\n if (retval > 0) {\n int j;\n\n numevents = retval;\n for (j = 0; j < numevents; j++) {\n int mask = 0;\n struct epoll_event *e = state->events+j;\n\n if (e->events & EPOLLIN) mask |= AE_READABLE;\n if (e->events & EPOLLOUT) mask |= AE_WRITABLE;\n if (e->events & EPOLLERR) mask |= AE_WRITABLE|AE_READABLE;\n if (e->events & EPOLLHUP) mask |= AE_WRITABLE|AE_READABLE;\n eventLoop->fired[j].fd = e->data.fd;\n eventLoop->fired[j].mask = mask;\n }\n } else if (retval == -1 && errno != EINTR) {\n panic(\"aeApiPoll: epoll_wait, %s\", strerror(errno));\n }\n\n return numevents;\n}\n\nstatic char *aeApiName(void) {\n return \"epoll\";\n}\n" }, { "path": "src/ae_evport.c", "content": "/* ae.c module for illumos event ports.\n *\n * Copyright (c) 2012, Joyent, Inc. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n\nstatic int evport_debug = 0;\n\n/*\n * This file implements the ae API using event ports, present on Solaris-based\n * systems since Solaris 10. Using the event port interface, we associate file\n * descriptors with the port. Each association also includes the set of poll(2)\n * events that the consumer is interested in (e.g., POLLIN and POLLOUT).\n *\n * There's one tricky piece to this implementation: when we return events via\n * aeApiPoll, the corresponding file descriptors become dissociated from the\n * port. This is necessary because poll events are level-triggered, so if the\n * fd didn't become dissociated, it would immediately fire another event since\n * the underlying state hasn't changed yet. We must re-associate the file\n * descriptor, but only after we know that our caller has actually read from it.\n * The ae API does not tell us exactly when that happens, but we do know that\n * it must happen by the time aeApiPoll is called again. Our solution is to\n * keep track of the last fds returned by aeApiPoll and re-associate them next\n * time aeApiPoll is invoked.\n *\n * To summarize, in this module, each fd association is EITHER (a) represented\n * only via the in-kernel association OR (b) represented by pending_fds and\n * pending_masks. (b) is only true for the last fds we returned from aeApiPoll,\n * and only until we enter aeApiPoll again (at which point we restore the\n * in-kernel association).\n */\n#define MAX_EVENT_BATCHSZ 512\n\ntypedef struct aeApiState {\n int portfd; /* event port */\n uint_t npending; /* # of pending fds */\n int pending_fds[MAX_EVENT_BATCHSZ]; /* pending fds */\n int pending_masks[MAX_EVENT_BATCHSZ]; /* pending fds' masks */\n} aeApiState;\n\nstatic int aeApiCreate(aeEventLoop *eventLoop) {\n int i;\n aeApiState *state = zmalloc(sizeof(aeApiState));\n if (!state) return -1;\n\n state->portfd = port_create();\n if (state->portfd == -1) {\n zfree(state);\n return -1;\n }\n anetCloexec(state->portfd);\n\n state->npending = 0;\n\n for (i = 0; i < MAX_EVENT_BATCHSZ; i++) {\n state->pending_fds[i] = -1;\n state->pending_masks[i] = AE_NONE;\n }\n\n eventLoop->apidata = state;\n return 0;\n}\n\nstatic int aeApiResize(aeEventLoop *eventLoop, int setsize) {\n (void) eventLoop;\n (void) setsize;\n /* Nothing to resize here. */\n return 0;\n}\n\nstatic void aeApiFree(aeEventLoop *eventLoop) {\n aeApiState *state = eventLoop->apidata;\n\n close(state->portfd);\n zfree(state);\n}\n\nstatic int aeApiLookupPending(aeApiState *state, int fd) {\n uint_t i;\n\n for (i = 0; i < state->npending; i++) {\n if (state->pending_fds[i] == fd)\n return (i);\n }\n\n return (-1);\n}\n\n/*\n * Helper function to invoke port_associate for the given fd and mask.\n */\nstatic int aeApiAssociate(const char *where, int portfd, int fd, int mask) {\n int events = 0;\n int rv, err;\n\n if (mask & AE_READABLE)\n events |= POLLIN;\n if (mask & AE_WRITABLE)\n events |= POLLOUT;\n\n if (evport_debug)\n fprintf(stderr, \"%s: port_associate(%d, 0x%x) = \", where, fd, events);\n\n rv = port_associate(portfd, PORT_SOURCE_FD, fd, events,\n (void *)(uintptr_t)mask);\n err = errno;\n\n if (evport_debug)\n fprintf(stderr, \"%d (%s)\\n\", rv, rv == 0 ? \"no error\" : strerror(err));\n\n if (rv == -1) {\n fprintf(stderr, \"%s: port_associate: %s\\n\", where, strerror(err));\n\n if (err == EAGAIN)\n fprintf(stderr, \"aeApiAssociate: event port limit exceeded.\");\n }\n\n return rv;\n}\n\nstatic int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n int fullmask, pfd;\n\n if (evport_debug)\n fprintf(stderr, \"aeApiAddEvent: fd %d mask 0x%x\\n\", fd, mask);\n\n /*\n * Since port_associate's \"events\" argument replaces any existing events, we\n * must be sure to include whatever events are already associated when\n * we call port_associate() again.\n */\n fullmask = mask | eventLoop->events[fd].mask;\n pfd = aeApiLookupPending(state, fd);\n\n if (pfd != -1) {\n /*\n * This fd was recently returned from aeApiPoll. It should be safe to\n * assume that the consumer has processed that poll event, but we play\n * it safer by simply updating pending_mask. The fd will be\n * re-associated as usual when aeApiPoll is called again.\n */\n if (evport_debug)\n fprintf(stderr, \"aeApiAddEvent: adding to pending fd %d\\n\", fd);\n state->pending_masks[pfd] |= fullmask;\n return 0;\n }\n\n return (aeApiAssociate(\"aeApiAddEvent\", state->portfd, fd, fullmask));\n}\n\nstatic void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n int fullmask, pfd;\n\n if (evport_debug)\n fprintf(stderr, \"del fd %d mask 0x%x\\n\", fd, mask);\n\n pfd = aeApiLookupPending(state, fd);\n\n if (pfd != -1) {\n if (evport_debug)\n fprintf(stderr, \"deleting event from pending fd %d\\n\", fd);\n\n /*\n * This fd was just returned from aeApiPoll, so it's not currently\n * associated with the port. All we need to do is update\n * pending_mask appropriately.\n */\n state->pending_masks[pfd] &= ~mask;\n\n if (state->pending_masks[pfd] == AE_NONE)\n state->pending_fds[pfd] = -1;\n\n return;\n }\n\n /*\n * The fd is currently associated with the port. Like with the add case\n * above, we must look at the full mask for the file descriptor before\n * updating that association. We don't have a good way of knowing what the\n * events are without looking into the eventLoop state directly. We rely on\n * the fact that our caller has already updated the mask in the eventLoop.\n */\n\n /* We always remove the specified events from the current mask,\n * regardless of whether eventLoop->events[fd].mask has been updated yet. */\n fullmask = eventLoop->events[fd].mask & ~mask;\n if (fullmask == AE_NONE) {\n /*\n * We're removing *all* events, so use port_dissociate to remove the\n * association completely. Failure here indicates a bug.\n */\n if (evport_debug)\n fprintf(stderr, \"aeApiDelEvent: port_dissociate(%d)\\n\", fd);\n\n if (port_dissociate(state->portfd, PORT_SOURCE_FD, fd) != 0) {\n perror(\"aeApiDelEvent: port_dissociate\");\n abort(); /* will not return */\n }\n } else if (aeApiAssociate(\"aeApiDelEvent\", state->portfd, fd,\n fullmask) != 0) {\n /*\n * ENOMEM is a potentially transient condition, but the kernel won't\n * generally return it unless things are really bad. EAGAIN indicates\n * we've reached a resource limit, for which it doesn't make sense to\n * retry (counter-intuitively). All other errors indicate a bug. In any\n * of these cases, the best we can do is to abort.\n */\n abort(); /* will not return */\n }\n}\n\nstatic int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {\n aeApiState *state = eventLoop->apidata;\n struct timespec timeout, *tsp;\n uint_t mask, i;\n uint_t nevents;\n port_event_t event[MAX_EVENT_BATCHSZ];\n\n /*\n * If we've returned fd events before, we must re-associate them with the\n * port now, before calling port_get(). See the block comment at the top of\n * this file for an explanation of why.\n */\n for (i = 0; i < state->npending; i++) {\n if (state->pending_fds[i] == -1)\n /* This fd has since been deleted. */\n continue;\n\n if (aeApiAssociate(\"aeApiPoll\", state->portfd,\n state->pending_fds[i], state->pending_masks[i]) != 0) {\n /* See aeApiDelEvent for why this case is fatal. */\n abort();\n }\n\n state->pending_masks[i] = AE_NONE;\n state->pending_fds[i] = -1;\n }\n\n state->npending = 0;\n\n if (tvp != NULL) {\n timeout.tv_sec = tvp->tv_sec;\n timeout.tv_nsec = tvp->tv_usec * 1000;\n tsp = &timeout;\n } else {\n tsp = NULL;\n }\n\n /*\n * port_getn can return with errno == ETIME having returned some events (!).\n * So if we get ETIME, we check nevents, too.\n */\n nevents = 1;\n if (port_getn(state->portfd, event, MAX_EVENT_BATCHSZ, &nevents,\n tsp) == -1 && (errno != ETIME || nevents == 0)) {\n if (errno == ETIME || errno == EINTR)\n return 0;\n\n /* Any other error indicates a bug. */\n panic(\"aeApiPoll: port_getn, %s\", strerror(errno));\n }\n\n state->npending = nevents;\n\n for (i = 0; i < nevents; i++) {\n mask = 0;\n if (event[i].portev_events & POLLIN)\n mask |= AE_READABLE;\n if (event[i].portev_events & POLLOUT)\n mask |= AE_WRITABLE;\n\n eventLoop->fired[i].fd = event[i].portev_object;\n eventLoop->fired[i].mask = mask;\n\n if (evport_debug)\n fprintf(stderr, \"aeApiPoll: fd %d mask 0x%x\\n\",\n (int)event[i].portev_object, mask);\n\n state->pending_fds[i] = event[i].portev_object;\n state->pending_masks[i] = (uintptr_t)event[i].portev_user;\n }\n\n return nevents;\n}\n\nstatic char *aeApiName(void) {\n return \"evport\";\n}\n" }, { "path": "src/ae_kqueue.c", "content": "/* Kqueue(2)-based ae.c module\n *\n * Copyright (C) 2009 Harish Mallipeddi - harish.mallipeddi@gmail.com\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of Redis nor the names of its contributors may be used\n * to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\n\n#include \n#include \n#include \n\ntypedef struct aeApiState {\n int kqfd;\n struct kevent *events;\n\n /* Events mask for merge read and write event.\n * To reduce memory consumption, we use 2 bits to store the mask\n * of an event, so that 1 byte will store the mask of 4 events. */\n char *eventsMask; \n} aeApiState;\n\n#define EVENT_MASK_MALLOC_SIZE(sz) (((sz) + 3) / 4)\n#define EVENT_MASK_OFFSET(fd) ((fd) % 4 * 2)\n#define EVENT_MASK_ENCODE(fd, mask) (((mask) & 0x3) << EVENT_MASK_OFFSET(fd))\n\nstatic inline int getEventMask(const char *eventsMask, int fd) {\n return (eventsMask[fd/4] >> EVENT_MASK_OFFSET(fd)) & 0x3;\n}\n\nstatic inline void addEventMask(char *eventsMask, int fd, int mask) {\n eventsMask[fd/4] |= EVENT_MASK_ENCODE(fd, mask);\n}\n\nstatic inline void resetEventMask(char *eventsMask, int fd) {\n eventsMask[fd/4] &= ~EVENT_MASK_ENCODE(fd, 0x3);\n}\n\nstatic int aeApiCreate(aeEventLoop *eventLoop) {\n aeApiState *state = zmalloc(sizeof(aeApiState));\n\n if (!state) return -1;\n state->events = zmalloc(sizeof(struct kevent)*eventLoop->setsize);\n if (!state->events) {\n zfree(state);\n return -1;\n }\n state->kqfd = kqueue();\n if (state->kqfd == -1) {\n zfree(state->events);\n zfree(state);\n return -1;\n }\n anetCloexec(state->kqfd);\n state->eventsMask = zmalloc(EVENT_MASK_MALLOC_SIZE(eventLoop->setsize));\n memset(state->eventsMask, 0, EVENT_MASK_MALLOC_SIZE(eventLoop->setsize));\n eventLoop->apidata = state;\n return 0;\n}\n\nstatic int aeApiResize(aeEventLoop *eventLoop, int setsize) {\n aeApiState *state = eventLoop->apidata;\n\n state->events = zrealloc(state->events, sizeof(struct kevent)*setsize);\n state->eventsMask = zrealloc(state->eventsMask, EVENT_MASK_MALLOC_SIZE(setsize));\n memset(state->eventsMask, 0, EVENT_MASK_MALLOC_SIZE(setsize));\n return 0;\n}\n\nstatic void aeApiFree(aeEventLoop *eventLoop) {\n aeApiState *state = eventLoop->apidata;\n\n close(state->kqfd);\n zfree(state->events);\n zfree(state->eventsMask);\n zfree(state);\n}\n\nstatic int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n struct kevent evs[2];\n int nch = 0;\n\n if (mask & AE_READABLE) EV_SET(evs + nch++, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);\n if (mask & AE_WRITABLE) EV_SET(evs + nch++, fd, EVFILT_WRITE, EV_ADD, 0, 0, NULL);\n\n return kevent(state->kqfd, evs, nch, NULL, 0, NULL);\n}\n\nstatic void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n struct kevent evs[2];\n int nch = 0;\n\n if (mask & AE_READABLE) EV_SET(evs + nch++, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);\n if (mask & AE_WRITABLE) EV_SET(evs + nch++, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);\n\n kevent(state->kqfd, evs, nch, NULL, 0, NULL);\n}\n\nstatic int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {\n aeApiState *state = eventLoop->apidata;\n int retval, numevents = 0;\n\n if (tvp != NULL) {\n struct timespec timeout;\n timeout.tv_sec = tvp->tv_sec;\n timeout.tv_nsec = tvp->tv_usec * 1000;\n retval = kevent(state->kqfd, NULL, 0, state->events, eventLoop->setsize,\n &timeout);\n } else {\n retval = kevent(state->kqfd, NULL, 0, state->events, eventLoop->setsize,\n NULL);\n }\n\n if (retval > 0) {\n int j;\n\n /* Normally we execute the read event first and then the write event.\n * When the barrier is set, we will do it reverse.\n * \n * However, under kqueue, read and write events would be separate\n * events, which would make it impossible to control the order of\n * reads and writes. So we store the event's mask we've got and merge\n * the same fd events later. */\n for (j = 0; j < retval; j++) {\n struct kevent *e = state->events+j;\n int fd = e->ident;\n int mask = 0; \n\n if (e->filter == EVFILT_READ) mask = AE_READABLE;\n else if (e->filter == EVFILT_WRITE) mask = AE_WRITABLE;\n addEventMask(state->eventsMask, fd, mask);\n }\n\n /* Re-traversal to merge read and write events, and set the fd's mask to\n * 0 so that events are not added again when the fd is encountered again. */\n numevents = 0;\n for (j = 0; j < retval; j++) {\n struct kevent *e = state->events+j;\n int fd = e->ident;\n int mask = getEventMask(state->eventsMask, fd);\n\n if (mask) {\n eventLoop->fired[numevents].fd = fd;\n eventLoop->fired[numevents].mask = mask;\n resetEventMask(state->eventsMask, fd);\n numevents++;\n }\n }\n } else if (retval == -1 && errno != EINTR) {\n panic(\"aeApiPoll: kevent, %s\", strerror(errno));\n }\n\n return numevents;\n}\n\nstatic char *aeApiName(void) {\n return \"kqueue\";\n}\n" }, { "path": "src/ae_select.c", "content": "/* Select()-based ae.c module.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n\n#include \n#include \n\ntypedef struct aeApiState {\n fd_set rfds, wfds;\n /* We need to have a copy of the fd sets as it's not safe to reuse\n * FD sets after select(). */\n fd_set _rfds, _wfds;\n} aeApiState;\n\nstatic int aeApiCreate(aeEventLoop *eventLoop) {\n aeApiState *state = zmalloc(sizeof(aeApiState));\n\n if (!state) return -1;\n FD_ZERO(&state->rfds);\n FD_ZERO(&state->wfds);\n eventLoop->apidata = state;\n return 0;\n}\n\nstatic int aeApiResize(aeEventLoop *eventLoop, int setsize) {\n AE_NOTUSED(eventLoop);\n /* Just ensure we have enough room in the fd_set type. */\n if (setsize >= FD_SETSIZE) return -1;\n return 0;\n}\n\nstatic void aeApiFree(aeEventLoop *eventLoop) {\n zfree(eventLoop->apidata);\n}\n\nstatic int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n\n if (mask & AE_READABLE) FD_SET(fd,&state->rfds);\n if (mask & AE_WRITABLE) FD_SET(fd,&state->wfds);\n return 0;\n}\n\nstatic void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask) {\n aeApiState *state = eventLoop->apidata;\n\n if (mask & AE_READABLE) FD_CLR(fd,&state->rfds);\n if (mask & AE_WRITABLE) FD_CLR(fd,&state->wfds);\n}\n\nstatic int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {\n aeApiState *state = eventLoop->apidata;\n int retval, j, numevents = 0;\n\n memcpy(&state->_rfds,&state->rfds,sizeof(fd_set));\n memcpy(&state->_wfds,&state->wfds,sizeof(fd_set));\n\n retval = select(eventLoop->maxfd+1,\n &state->_rfds,&state->_wfds,NULL,tvp);\n if (retval > 0) {\n for (j = 0; j <= eventLoop->maxfd; j++) {\n int mask = 0;\n aeFileEvent *fe = &eventLoop->events[j];\n\n if (fe->mask == AE_NONE) continue;\n if (fe->mask & AE_READABLE && FD_ISSET(j,&state->_rfds))\n mask |= AE_READABLE;\n if (fe->mask & AE_WRITABLE && FD_ISSET(j,&state->_wfds))\n mask |= AE_WRITABLE;\n eventLoop->fired[numevents].fd = j;\n eventLoop->fired[numevents].mask = mask;\n numevents++;\n }\n } else if (retval == -1 && errno != EINTR) {\n panic(\"aeApiPoll: select, %s\", strerror(errno));\n }\n\n return numevents;\n}\n\nstatic char *aeApiName(void) {\n return \"select\";\n}\n" }, { "path": "src/anet.c", "content": "/* anet.c -- Basic TCP socket stuff made a bit less boring\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"fmacros.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"anet.h\"\n#include \"config.h\"\n#include \"util.h\"\n\n#define UNUSED(x) (void)(x)\n\nstatic void anetSetError(char *err, const char *fmt, ...)\n{\n va_list ap;\n\n if (!err) return;\n va_start(ap, fmt);\n vsnprintf(err, ANET_ERR_LEN, fmt, ap);\n va_end(ap);\n}\n\nint anetGetError(int fd) {\n int sockerr = 0;\n socklen_t errlen = sizeof(sockerr);\n\n if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)\n sockerr = errno;\n return sockerr;\n}\n\nint anetSetBlock(char *err, int fd, int non_block) {\n int flags;\n\n /* Set the socket blocking (if non_block is zero) or non-blocking.\n * Note that fcntl(2) for F_GETFL and F_SETFL can't be\n * interrupted by a signal. */\n if ((flags = fcntl(fd, F_GETFL)) == -1) {\n anetSetError(err, \"fcntl(F_GETFL): %s\", strerror(errno));\n return ANET_ERR;\n }\n\n /* Check if this flag has been set or unset, if so,\n * then there is no need to call fcntl to set/unset it again. */\n if (!!(flags & O_NONBLOCK) == !!non_block)\n return ANET_OK;\n\n if (non_block)\n flags |= O_NONBLOCK;\n else\n flags &= ~O_NONBLOCK;\n\n if (fcntl(fd, F_SETFL, flags) == -1) {\n anetSetError(err, \"fcntl(F_SETFL,O_NONBLOCK): %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\nint anetNonBlock(char *err, int fd) {\n return anetSetBlock(err,fd,1);\n}\n\nint anetBlock(char *err, int fd) {\n return anetSetBlock(err,fd,0);\n}\n\n/* Enable the FD_CLOEXEC on the given fd to avoid fd leaks.\n * This function should be invoked for fd's on specific places\n * where fork + execve system calls are called. */\nint anetCloexec(int fd) {\n int r;\n int flags;\n\n do {\n r = fcntl(fd, F_GETFD);\n } while (r == -1 && errno == EINTR);\n\n if (r == -1 || (r & FD_CLOEXEC))\n return r;\n\n flags = r | FD_CLOEXEC;\n\n do {\n r = fcntl(fd, F_SETFD, flags);\n } while (r == -1 && errno == EINTR);\n\n return r;\n}\n\n/* Enable TCP keep-alive mechanism to detect dead peers,\n * TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT will be set accordingly. */\nint anetKeepAlive(char *err, int fd, int interval)\n{\n int enabled = 1;\n if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &enabled, sizeof(enabled)))\n {\n anetSetError(err, \"setsockopt SO_KEEPALIVE: %s\", strerror(errno));\n return ANET_ERR;\n }\n\n int idle;\n int intvl;\n int cnt;\n\n /* There are platforms that are expected to support the full mechanism of TCP keep-alive,\n * we want the compiler to emit warnings of unused variables if the preprocessor directives\n * somehow fail, and other than those platforms, just omit these warnings if they happen.\n */\n#if !(defined(_AIX) || defined(__APPLE__) || defined(__DragonFly__) || \\\n defined(__FreeBSD__) || defined(__illumos__) || defined(__linux__) || \\\n defined(__NetBSD__) || defined(__sun))\n UNUSED(interval);\n UNUSED(idle);\n UNUSED(intvl);\n UNUSED(cnt);\n#endif\n\n#ifdef __sun\n /* The implementation of TCP keep-alive on Solaris/SmartOS is a bit unusual\n * compared to other Unix-like systems.\n * Thus, we need to specialize it on Solaris.\n *\n * There are two keep-alive mechanisms on Solaris:\n * - By default, the first keep-alive probe is sent out after a TCP connection is idle for two hours.\n * If the peer does not respond to the probe within eight minutes, the TCP connection is aborted.\n * You can alter the interval for sending out the first probe using the socket option TCP_KEEPALIVE_THRESHOLD\n * in milliseconds or TCP_KEEPIDLE in seconds.\n * The system default is controlled by the TCP ndd parameter tcp_keepalive_interval. The minimum value is ten seconds.\n * The maximum is ten days, while the default is two hours. If you receive no response to the probe,\n * you can use the TCP_KEEPALIVE_ABORT_THRESHOLD socket option to change the time threshold for aborting a TCP connection.\n * The option value is an unsigned integer in milliseconds. The value zero indicates that TCP should never time out and\n * abort the connection when probing. The system default is controlled by the TCP ndd parameter tcp_keepalive_abort_interval.\n * The default is eight minutes.\n *\n * - The second implementation is activated if socket option TCP_KEEPINTVL and/or TCP_KEEPCNT are set.\n * The time between each consequent probes is set by TCP_KEEPINTVL in seconds.\n * The minimum value is ten seconds. The maximum is ten days, while the default is two hours.\n * The TCP connection will be aborted after certain amount of probes, which is set by TCP_KEEPCNT, without receiving response.\n */\n\n idle = interval;\n if (idle < 10) idle = 10; // kernel expects at least 10 seconds\n if (idle > 10*24*60*60) idle = 10*24*60*60; // kernel expects at most 10 days\n\n /* `TCP_KEEPIDLE`, `TCP_KEEPINTVL`, and `TCP_KEEPCNT` were not available on Solaris\n * until version 11.4, but let's take a chance here. */\n#if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL) && defined(TCP_KEEPCNT)\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle))) {\n anetSetError(err, \"setsockopt TCP_KEEPIDLE: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n\n intvl = idle/3;\n if (intvl < 10) intvl = 10; /* kernel expects at least 10 seconds */\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl))) {\n anetSetError(err, \"setsockopt TCP_KEEPINTVL: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n\n cnt = 3;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt))) {\n anetSetError(err, \"setsockopt TCP_KEEPCNT: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#else\n /* Fall back to the first implementation of tcp-alive mechanism for older Solaris,\n * simulate the tcp-alive mechanism on other platforms via `TCP_KEEPALIVE_THRESHOLD` + `TCP_KEEPALIVE_ABORT_THRESHOLD`.\n */\n idle *= 1000; // kernel expects milliseconds\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, &idle, sizeof(idle))) {\n anetSetError(err, \"setsockopt TCP_KEEPINTVL: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n\n /* Note that the consequent probes will not be sent at equal intervals on Solaris,\n * but will be sent using the exponential backoff algorithm. */\n int time_to_abort = idle;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, &time_to_abort, sizeof(time_to_abort))) {\n anetSetError(err, \"setsockopt TCP_KEEPCNT: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#endif\n\n return ANET_OK;\n\n#endif\n\n#ifdef TCP_KEEPIDLE\n /* Default settings are more or less garbage, with the keepalive time\n * set to 7200 by default on Linux and other Unix-like systems.\n * Modify settings to make the feature actually useful. */\n\n /* Send first probe after interval. */\n idle = interval;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle))) {\n anetSetError(err, \"setsockopt TCP_KEEPIDLE: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#elif defined(TCP_KEEPALIVE)\n /* Darwin/macOS uses TCP_KEEPALIVE in place of TCP_KEEPIDLE. */\n idle = interval;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &idle, sizeof(idle))) {\n anetSetError(err, \"setsockopt TCP_KEEPALIVE: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#endif\n\n#ifdef TCP_KEEPINTVL\n /* Send next probes after the specified interval. Note that we set the\n * delay as interval / 3, as we send three probes before detecting\n * an error (see the next setsockopt call). */\n intvl = interval/3;\n if (intvl == 0) intvl = 1;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl))) {\n anetSetError(err, \"setsockopt TCP_KEEPINTVL: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#endif\n\n#ifdef TCP_KEEPCNT\n /* Consider the socket in error state after three we send three ACK\n * probes without getting a reply. */\n cnt = 3;\n if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt))) {\n anetSetError(err, \"setsockopt TCP_KEEPCNT: %s\\n\", strerror(errno));\n return ANET_ERR;\n }\n#endif\n\n return ANET_OK;\n}\n\nstatic int anetSetTcpNoDelay(char *err, int fd, int val)\n{\n if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) == -1)\n {\n anetSetError(err, \"setsockopt TCP_NODELAY: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\nint anetEnableTcpNoDelay(char *err, int fd)\n{\n return anetSetTcpNoDelay(err, fd, 1);\n}\n\nint anetDisableTcpNoDelay(char *err, int fd)\n{\n return anetSetTcpNoDelay(err, fd, 0);\n}\n\n/* Set the socket send timeout (SO_SNDTIMEO socket option) to the specified\n * number of milliseconds, or disable it if the 'ms' argument is zero. */\nint anetSendTimeout(char *err, int fd, long long ms) {\n struct timeval tv;\n\n tv.tv_sec = ms/1000;\n tv.tv_usec = (ms%1000)*1000;\n if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) == -1) {\n anetSetError(err, \"setsockopt SO_SNDTIMEO: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\n/* Set the socket receive timeout (SO_RCVTIMEO socket option) to the specified\n * number of milliseconds, or disable it if the 'ms' argument is zero. */\nint anetRecvTimeout(char *err, int fd, long long ms) {\n struct timeval tv;\n\n tv.tv_sec = ms/1000;\n tv.tv_usec = (ms%1000)*1000;\n if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) == -1) {\n anetSetError(err, \"setsockopt SO_RCVTIMEO: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\n/* Resolve the hostname \"host\" and set the string representation of the\n * IP address into the buffer pointed by \"ipbuf\".\n *\n * If flags is set to ANET_IP_ONLY the function only resolves hostnames\n * that are actually already IPv4 or IPv6 addresses. This turns the function\n * into a validating / normalizing function.\n *\n * If the flag ANET_PREFER_IPV4 is set, IPv4 is preferred over IPv6.\n * If the flag ANET_PREFER_IPV6 is set, IPv6 is preferred over IPv4.\n * */\nint anetResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len,\n int flags)\n{\n struct addrinfo hints, *info;\n int rv;\n\n memset(&hints,0,sizeof(hints));\n if (flags & ANET_IP_ONLY) hints.ai_flags = AI_NUMERICHOST;\n hints.ai_family = AF_UNSPEC;\n if (flags & ANET_PREFER_IPV4 && !(flags & ANET_PREFER_IPV6)) {\n hints.ai_family = AF_INET;\n } else if (flags & ANET_PREFER_IPV6 && !(flags & ANET_PREFER_IPV4)) {\n hints.ai_family = AF_INET6;\n }\n hints.ai_socktype = SOCK_STREAM; /* specify socktype to avoid dups */\n\n rv = getaddrinfo(host, NULL, &hints, &info);\n if (rv != 0 && hints.ai_family != AF_UNSPEC) {\n /* Try the other IP version. */\n hints.ai_family = (hints.ai_family == AF_INET) ? AF_INET6 : AF_INET;\n rv = getaddrinfo(host, NULL, &hints, &info);\n }\n if (rv != 0) {\n anetSetError(err, \"%s\", gai_strerror(rv));\n return ANET_ERR;\n }\n if (info->ai_family == AF_INET) {\n struct sockaddr_in *sa = (struct sockaddr_in *)info->ai_addr;\n inet_ntop(AF_INET, &(sa->sin_addr), ipbuf, ipbuf_len);\n } else {\n struct sockaddr_in6 *sa = (struct sockaddr_in6 *)info->ai_addr;\n inet_ntop(AF_INET6, &(sa->sin6_addr), ipbuf, ipbuf_len);\n }\n\n freeaddrinfo(info);\n return ANET_OK;\n}\n\nstatic int anetSetReuseAddr(char *err, int fd) {\n int yes = 1;\n /* Make sure connection-intensive things like the redis benchmark\n * will be able to close/open sockets a zillion of times */\n if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {\n anetSetError(err, \"setsockopt SO_REUSEADDR: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\nstatic int anetCreateSocket(char *err, int domain) {\n int s;\n if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {\n anetSetError(err, \"creating socket: %s\", strerror(errno));\n return ANET_ERR;\n }\n\n /* Make sure connection-intensive things like the redis benchmark\n * will be able to close/open sockets a zillion of times */\n if (anetSetReuseAddr(err,s) == ANET_ERR) {\n close(s);\n return ANET_ERR;\n }\n return s;\n}\n\n#define ANET_CONNECT_NONE 0\n#define ANET_CONNECT_NONBLOCK 1\n#define ANET_CONNECT_BE_BINDING 2 /* Best effort binding. */\nstatic int anetTcpGenericConnect(char *err, const char *addr, int port,\n const char *source_addr, int flags)\n{\n int s = ANET_ERR, rv;\n char portstr[6]; /* strlen(\"65535\") + 1; */\n struct addrinfo hints, *servinfo, *bservinfo, *p, *b;\n\n snprintf(portstr,sizeof(portstr),\"%d\",port);\n memset(&hints,0,sizeof(hints));\n hints.ai_family = AF_UNSPEC;\n hints.ai_socktype = SOCK_STREAM;\n\n if ((rv = getaddrinfo(addr,portstr,&hints,&servinfo)) != 0) {\n anetSetError(err, \"%s\", gai_strerror(rv));\n return ANET_ERR;\n }\n for (p = servinfo; p != NULL; p = p->ai_next) {\n /* Try to create the socket and to connect it.\n * If we fail in the socket() call, or on connect(), we retry with\n * the next entry in servinfo. */\n if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)\n continue;\n if (anetSetReuseAddr(err,s) == ANET_ERR) goto error;\n if (flags & ANET_CONNECT_NONBLOCK && anetNonBlock(err,s) != ANET_OK)\n goto error;\n if (source_addr) {\n int bound = 0;\n /* Using getaddrinfo saves us from self-determining IPv4 vs IPv6 */\n if ((rv = getaddrinfo(source_addr, NULL, &hints, &bservinfo)) != 0)\n {\n anetSetError(err, \"%s\", gai_strerror(rv));\n goto error;\n }\n for (b = bservinfo; b != NULL; b = b->ai_next) {\n if (bind(s,b->ai_addr,b->ai_addrlen) != -1) {\n bound = 1;\n break;\n }\n }\n freeaddrinfo(bservinfo);\n if (!bound) {\n anetSetError(err, \"bind: %s\", strerror(errno));\n goto error;\n }\n }\n if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {\n /* If the socket is non-blocking, it is ok for connect() to\n * return an EINPROGRESS error here. */\n if (errno == EINPROGRESS && flags & ANET_CONNECT_NONBLOCK)\n goto end;\n close(s);\n s = ANET_ERR;\n continue;\n }\n\n /* If we ended an iteration of the for loop without errors, we\n * have a connected socket. Let's return to the caller. */\n goto end;\n }\n if (p == NULL)\n anetSetError(err, \"creating socket: %s\", strerror(errno));\n\nerror:\n if (s != ANET_ERR) {\n close(s);\n s = ANET_ERR;\n }\n\nend:\n freeaddrinfo(servinfo);\n\n /* Handle best effort binding: if a binding address was used, but it is\n * not possible to create a socket, try again without a binding address. */\n if (s == ANET_ERR && source_addr && (flags & ANET_CONNECT_BE_BINDING)) {\n return anetTcpGenericConnect(err,addr,port,NULL,flags);\n } else {\n return s;\n }\n}\n\nint anetTcpNonBlockConnect(char *err, const char *addr, int port)\n{\n return anetTcpGenericConnect(err,addr,port,NULL,ANET_CONNECT_NONBLOCK);\n}\n\nint anetTcpNonBlockBestEffortBindConnect(char *err, const char *addr, int port,\n const char *source_addr)\n{\n return anetTcpGenericConnect(err,addr,port,source_addr,\n ANET_CONNECT_NONBLOCK|ANET_CONNECT_BE_BINDING);\n}\n\nint anetUnixGenericConnect(char *err, const char *path, int flags)\n{\n int s;\n struct sockaddr_un sa;\n\n if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)\n return ANET_ERR;\n\n sa.sun_family = AF_LOCAL;\n redis_strlcpy(sa.sun_path,path,sizeof(sa.sun_path));\n if (flags & ANET_CONNECT_NONBLOCK) {\n if (anetNonBlock(err,s) != ANET_OK) {\n close(s);\n return ANET_ERR;\n }\n }\n if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {\n if (errno == EINPROGRESS &&\n flags & ANET_CONNECT_NONBLOCK)\n return s;\n\n anetSetError(err, \"connect: %s\", strerror(errno));\n close(s);\n return ANET_ERR;\n }\n return s;\n}\n\nstatic int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len, int backlog, mode_t perm) {\n if (bind(s,sa,len) == -1) {\n anetSetError(err, \"bind: %s\", strerror(errno));\n close(s);\n return ANET_ERR;\n }\n\n if (sa->sa_family == AF_LOCAL && perm)\n chmod(((struct sockaddr_un *) sa)->sun_path, perm);\n\n if (listen(s, backlog) == -1) {\n anetSetError(err, \"listen: %s\", strerror(errno));\n close(s);\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\nstatic int anetV6Only(char *err, int s) {\n int yes = 1;\n if (setsockopt(s,IPPROTO_IPV6,IPV6_V6ONLY,&yes,sizeof(yes)) == -1) {\n anetSetError(err, \"setsockopt: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n}\n\nstatic int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backlog)\n{\n int s = -1, rv;\n char _port[6]; /* strlen(\"65535\") */\n struct addrinfo hints, *servinfo, *p;\n\n snprintf(_port,6,\"%d\",port);\n memset(&hints,0,sizeof(hints));\n hints.ai_family = af;\n hints.ai_socktype = SOCK_STREAM;\n hints.ai_flags = AI_PASSIVE; /* No effect if bindaddr != NULL */\n if (bindaddr && !strcmp(\"*\", bindaddr))\n bindaddr = NULL;\n if (af == AF_INET6 && bindaddr && !strcmp(\"::*\", bindaddr))\n bindaddr = NULL;\n\n if ((rv = getaddrinfo(bindaddr,_port,&hints,&servinfo)) != 0) {\n anetSetError(err, \"%s\", gai_strerror(rv));\n return ANET_ERR;\n }\n for (p = servinfo; p != NULL; p = p->ai_next) {\n if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)\n continue;\n\n if (af == AF_INET6 && anetV6Only(err,s) == ANET_ERR) goto error;\n if (anetSetReuseAddr(err,s) == ANET_ERR) goto error;\n if (anetListen(err,s,p->ai_addr,p->ai_addrlen,backlog,0) == ANET_ERR) s = ANET_ERR;\n goto end;\n }\n if (p == NULL) {\n anetSetError(err, \"unable to bind socket, errno: %d\", errno);\n goto error;\n }\n\nerror:\n if (s != -1) close(s);\n s = ANET_ERR;\nend:\n freeaddrinfo(servinfo);\n return s;\n}\n\nint anetTcpServer(char *err, int port, char *bindaddr, int backlog)\n{\n return _anetTcpServer(err, port, bindaddr, AF_INET, backlog);\n}\n\nint anetTcp6Server(char *err, int port, char *bindaddr, int backlog)\n{\n return _anetTcpServer(err, port, bindaddr, AF_INET6, backlog);\n}\n\nint anetUnixServer(char *err, char *path, mode_t perm, int backlog)\n{\n int s;\n struct sockaddr_un sa;\n\n if (strlen(path) > sizeof(sa.sun_path)-1) {\n anetSetError(err,\"unix socket path too long (%zu), must be under %zu\", strlen(path), sizeof(sa.sun_path));\n return ANET_ERR;\n }\n if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)\n return ANET_ERR;\n\n memset(&sa,0,sizeof(sa));\n sa.sun_family = AF_LOCAL;\n redis_strlcpy(sa.sun_path,path,sizeof(sa.sun_path));\n if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa),backlog,perm) == ANET_ERR)\n return ANET_ERR;\n return s;\n}\n\n/* Accept a connection and also make sure the socket is non-blocking, and CLOEXEC.\n * returns the new socket FD, or -1 on error. */\nstatic int anetGenericAccept(char *err, int s, struct sockaddr *sa, socklen_t *len) {\n int fd;\n do {\n /* Use the accept4() call on linux to simultaneously accept and\n * set a socket as non-blocking. */\n#ifdef HAVE_ACCEPT4\n fd = accept4(s, sa, len, SOCK_NONBLOCK | SOCK_CLOEXEC);\n#else\n fd = accept(s,sa,len);\n#endif\n } while(fd == -1 && errno == EINTR);\n if (fd == -1) {\n anetSetError(err, \"accept: %s\", strerror(errno));\n return ANET_ERR;\n }\n#ifndef HAVE_ACCEPT4\n if (anetCloexec(fd) == -1) {\n anetSetError(err, \"anetCloexec: %s\", strerror(errno));\n close(fd);\n return ANET_ERR;\n }\n if (anetNonBlock(err, fd) != ANET_OK) {\n close(fd);\n return ANET_ERR;\n }\n#endif\n return fd;\n}\n\n/* Accept a connection and also make sure the socket is non-blocking, and CLOEXEC.\n * returns the new socket FD, or -1 on error. */\nint anetTcpAccept(char *err, int serversock, char *ip, size_t ip_len, int *port) {\n int fd;\n struct sockaddr_storage sa;\n socklen_t salen = sizeof(sa);\n if ((fd = anetGenericAccept(err,serversock,(struct sockaddr*)&sa,&salen)) == ANET_ERR)\n return ANET_ERR;\n\n if (sa.ss_family == AF_INET) {\n struct sockaddr_in *s = (struct sockaddr_in *)&sa;\n if (ip) inet_ntop(AF_INET,(void*)&(s->sin_addr),ip,ip_len);\n if (port) *port = ntohs(s->sin_port);\n } else {\n struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;\n if (ip) inet_ntop(AF_INET6,(void*)&(s->sin6_addr),ip,ip_len);\n if (port) *port = ntohs(s->sin6_port);\n }\n return fd;\n}\n\n/* Accept a connection and also make sure the socket is non-blocking, and CLOEXEC.\n * returns the new socket FD, or -1 on error. */\nint anetUnixAccept(char *err, int s) {\n int fd;\n struct sockaddr_un sa;\n socklen_t salen = sizeof(sa);\n if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)\n return ANET_ERR;\n\n return fd;\n}\n\nint anetFdToString(int fd, char *ip, size_t ip_len, int *port, int remote) {\n struct sockaddr_storage sa;\n socklen_t salen = sizeof(sa);\n\n if (remote) {\n if (getpeername(fd, (struct sockaddr *)&sa, &salen) == -1) goto error;\n } else {\n if (getsockname(fd, (struct sockaddr *)&sa, &salen) == -1) goto error;\n }\n\n if (sa.ss_family == AF_INET) {\n struct sockaddr_in *s = (struct sockaddr_in *)&sa;\n if (ip) {\n if (inet_ntop(AF_INET,(void*)&(s->sin_addr),ip,ip_len) == NULL)\n goto error;\n }\n if (port) *port = ntohs(s->sin_port);\n } else if (sa.ss_family == AF_INET6) {\n struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;\n if (ip) {\n if (inet_ntop(AF_INET6,(void*)&(s->sin6_addr),ip,ip_len) == NULL)\n goto error;\n }\n if (port) *port = ntohs(s->sin6_port);\n } else if (sa.ss_family == AF_UNIX) {\n if (ip) {\n int res = snprintf(ip, ip_len, \"/unixsocket\");\n if (res < 0 || (unsigned int) res >= ip_len) goto error;\n }\n if (port) *port = 0;\n } else {\n goto error;\n }\n return 0;\n\nerror:\n if (ip) {\n if (ip_len >= 2) {\n ip[0] = '?';\n ip[1] = '\\0';\n } else if (ip_len == 1) {\n ip[0] = '\\0';\n }\n }\n if (port) *port = 0;\n return -1;\n}\n\n/* Create a pipe buffer with given flags for read end and write end.\n * Note that it supports the file flags defined by pipe2() and fcntl(F_SETFL),\n * and one of the use cases is O_CLOEXEC|O_NONBLOCK. */\nint anetPipe(int fds[2], int read_flags, int write_flags) {\n int pipe_flags = 0;\n#ifdef HAVE_PIPE2\n /* When possible, try to leverage pipe2() to apply flags that are common to both ends.\n * There is no harm to set O_CLOEXEC to prevent fd leaks. */\n pipe_flags = O_CLOEXEC | (read_flags & write_flags);\n if (pipe2(fds, pipe_flags)) {\n /* Fail on real failures, and fallback to simple pipe if pipe2 is unsupported. */\n if (errno != ENOSYS && errno != EINVAL)\n return -1;\n pipe_flags = 0;\n } else {\n /* If the flags on both ends are identical, no need to do anything else. */\n if ((O_CLOEXEC | read_flags) == (O_CLOEXEC | write_flags))\n return 0;\n /* Clear the flags which have already been set using pipe2. */\n read_flags &= ~pipe_flags;\n write_flags &= ~pipe_flags;\n }\n#endif\n\n /* When we reach here with pipe_flags of 0, it means pipe2 failed (or was not attempted),\n * so we try to use pipe. Otherwise, we skip and proceed to set specific flags below. */\n if (pipe_flags == 0 && pipe(fds))\n return -1;\n\n /* File descriptor flags.\n * Currently, only one such flag is defined: FD_CLOEXEC, the close-on-exec flag. */\n if (read_flags & O_CLOEXEC)\n if (fcntl(fds[0], F_SETFD, FD_CLOEXEC))\n goto error;\n if (write_flags & O_CLOEXEC)\n if (fcntl(fds[1], F_SETFD, FD_CLOEXEC))\n goto error;\n\n /* File status flags after clearing the file descriptor flag O_CLOEXEC. */\n read_flags &= ~O_CLOEXEC;\n if (read_flags)\n if (fcntl(fds[0], F_SETFL, read_flags))\n goto error;\n write_flags &= ~O_CLOEXEC;\n if (write_flags)\n if (fcntl(fds[1], F_SETFL, write_flags))\n goto error;\n\n return 0;\n\nerror:\n close(fds[0]);\n close(fds[1]);\n return -1;\n}\n\nint anetSetSockMarkId(char *err, int fd, uint32_t id) {\n#ifdef HAVE_SOCKOPTMARKID\n if (setsockopt(fd, SOL_SOCKET, SOCKOPTMARKID, (void *)&id, sizeof(id)) == -1) {\n anetSetError(err, \"setsockopt: %s\", strerror(errno));\n return ANET_ERR;\n }\n return ANET_OK;\n#else\n UNUSED(fd);\n UNUSED(id);\n anetSetError(err,\"anetSetSockMarkid unsupported on this platform\");\n return ANET_OK;\n#endif\n}\n\nint anetIsFifo(char *filepath) {\n struct stat sb;\n if (stat(filepath, &sb) == -1) return 0;\n return S_ISFIFO(sb.st_mode);\n}\n\n/* This function must be called after accept4() fails. It returns 1 if 'err'\n * indicates accepted connection faced an error, and it's okay to continue\n * accepting next connection by calling accept4() again. Other errors either\n * indicate programming errors, e.g. calling accept() on a closed fd or indicate\n * a resource limit has been reached, e.g. -EMFILE, open fd limit has been\n * reached. In the latter case, caller might wait until resources are available.\n * See accept4() documentation for details. */\nint anetAcceptFailureNeedsRetry(int err) {\n if (err == ECONNABORTED)\n return 1;\n\n#if defined(__linux__)\n /* For details, see 'Error Handling' section on\n * https://man7.org/linux/man-pages/man2/accept.2.html */\n if (err == ENETDOWN || err == EPROTO || err == ENOPROTOOPT ||\n err == EHOSTDOWN || err == ENONET || err == EHOSTUNREACH ||\n err == EOPNOTSUPP || err == ENETUNREACH)\n {\n return 1;\n }\n#endif\n return 0;\n}\n" }, { "path": "src/anet.h", "content": "/* anet.c -- Basic TCP socket stuff made a bit less boring\n *\n * Copyright (c) 2006-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#ifndef ANET_H\n#define ANET_H\n\n#include \n\n#define ANET_OK 0\n#define ANET_ERR -1\n#define ANET_ERR_LEN 256\n\n/* Flags used with certain functions. */\n#define ANET_NONE 0\n#define ANET_IP_ONLY (1<<0)\n#define ANET_PREFER_IPV4 (1<<1)\n#define ANET_PREFER_IPV6 (1<<2)\n\n#if defined(__sun) || defined(_AIX)\n#define AF_LOCAL AF_UNIX\n#endif\n\n#ifdef _AIX\n#undef ip_len\n#endif\n\nint anetTcpNonBlockConnect(char *err, const char *addr, int port);\nint anetTcpNonBlockBestEffortBindConnect(char *err, const char *addr, int port, const char *source_addr);\nint anetResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len, int flags);\nint anetTcpServer(char *err, int port, char *bindaddr, int backlog);\nint anetTcp6Server(char *err, int port, char *bindaddr, int backlog);\nint anetUnixServer(char *err, char *path, mode_t perm, int backlog);\nint anetTcpAccept(char *err, int serversock, char *ip, size_t ip_len, int *port);\nint anetUnixAccept(char *err, int serversock);\nint anetNonBlock(char *err, int fd);\nint anetBlock(char *err, int fd);\nint anetCloexec(int fd);\nint anetEnableTcpNoDelay(char *err, int fd);\nint anetDisableTcpNoDelay(char *err, int fd);\nint anetSendTimeout(char *err, int fd, long long ms);\nint anetRecvTimeout(char *err, int fd, long long ms);\nint anetFdToString(int fd, char *ip, size_t ip_len, int *port, int remote);\nint anetKeepAlive(char *err, int fd, int interval);\nint anetFormatAddr(char *fmt, size_t fmt_len, char *ip, int port);\nint anetPipe(int fds[2], int read_flags, int write_flags);\nint anetSetSockMarkId(char *err, int fd, uint32_t id);\nint anetGetError(int fd);\nint anetIsFifo(char *filepath);\nint anetAcceptFailureNeedsRetry(int err);\n\n#endif\n" }, { "path": "src/aof.c", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \"bio.h\"\n#include \"rio.h\"\n#include \"functions.h\"\n#include \"cluster_asm.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid freeClientArgv(client *c);\noff_t getAppendOnlyFileSize(sds filename, int *status);\noff_t getBaseAndIncrAppendOnlyFilesSize(aofManifest *am, int *status);\nint getBaseAndIncrAppendOnlyFilesNum(aofManifest *am);\nint aofFileExist(char *filename);\nint rewriteAppendOnlyFile(char *filename);\naofManifest *aofLoadManifestFromFile(sds am_filepath);\nvoid aofManifestFreeAndUpdate(aofManifest *am);\nvoid aof_background_fsync_and_close(int fd);\n\n/* When we call 'startAppendOnly', we will create a temp INCR AOF, and rename\n * it to the real INCR AOF name when the AOFRW is done, so if want to know the\n * accurate start offset of the INCR AOF, we need to record it when we create\n * the temp INCR AOF. This variable is used to record the start offset, and\n * set the start offset of the real INCR AOF when the AOFRW is done. */\nstatic long long tempIncAofStartReplOffset = 0;\n\n/* ----------------------------------------------------------------------------\n * AOF Manifest file implementation.\n *\n * The following code implements the read/write logic of AOF manifest file, which\n * is used to track and manage all AOF files.\n *\n * Append-only files consist of three types:\n *\n * BASE: Represents a Redis snapshot from the time of last AOF rewrite. The manifest\n * file contains at most a single BASE file, which will always be the first file in the\n * list.\n *\n * INCR: Represents all write commands executed by Redis following the last successful\n * AOF rewrite. In some cases it is possible to have several ordered INCR files. For\n * example:\n * - During an on-going AOF rewrite\n * - After an AOF rewrite was aborted/failed, and before the next one succeeded.\n *\n * HISTORY: After a successful rewrite, the previous BASE and INCR become HISTORY files.\n * They will be automatically removed unless garbage collection is disabled.\n *\n * The following is a possible AOF manifest file content:\n *\n * file appendonly.aof.2.base.rdb seq 2 type b\n * file appendonly.aof.1.incr.aof seq 1 type h\n * file appendonly.aof.2.incr.aof seq 2 type h\n * file appendonly.aof.3.incr.aof seq 3 type h\n * file appendonly.aof.4.incr.aof seq 4 type i\n * file appendonly.aof.5.incr.aof seq 5 type i\n * ------------------------------------------------------------------------- */\n\n/* Naming rules. */\n#define BASE_FILE_SUFFIX \".base\"\n#define INCR_FILE_SUFFIX \".incr\"\n#define RDB_FORMAT_SUFFIX \".rdb\"\n#define AOF_FORMAT_SUFFIX \".aof\"\n#define MANIFEST_NAME_SUFFIX \".manifest\"\n#define TEMP_FILE_NAME_PREFIX \"temp-\"\n\n/* AOF manifest key. */\n#define AOF_MANIFEST_KEY_FILE_NAME \"file\"\n#define AOF_MANIFEST_KEY_FILE_SEQ \"seq\"\n#define AOF_MANIFEST_KEY_FILE_TYPE \"type\"\n#define AOF_MANIFEST_KEY_FILE_STARTOFFSET \"startoffset\"\n#define AOF_MANIFEST_KEY_FILE_ENDOFFSET \"endoffset\"\n\n/* Create an empty aofInfo. */\naofInfo *aofInfoCreate(void) {\n aofInfo *ai = zcalloc(sizeof(aofInfo));\n ai->start_offset = -1;\n ai->end_offset = -1;\n return ai;\n}\n\n/* Free the aofInfo structure (pointed to by ai) and its embedded file_name. */\nvoid aofInfoFree(aofInfo *ai) {\n serverAssert(ai != NULL);\n if (ai->file_name) sdsfree(ai->file_name);\n zfree(ai);\n}\n\n/* Deep copy an aofInfo. */\naofInfo *aofInfoDup(aofInfo *orig) {\n serverAssert(orig != NULL);\n aofInfo *ai = aofInfoCreate();\n ai->file_name = sdsdup(orig->file_name);\n ai->file_seq = orig->file_seq;\n ai->file_type = orig->file_type;\n ai->start_offset = orig->start_offset;\n ai->end_offset = orig->end_offset;\n return ai;\n}\n\n/* Format aofInfo as a string and it will be a line in the manifest.\n *\n * When update this format, make sure to update redis-check-aof as well. */\nsds aofInfoFormat(sds buf, aofInfo *ai) {\n sds filename_repr = NULL;\n\n if (sdsneedsrepr(ai->file_name))\n filename_repr = sdscatrepr(sdsempty(), ai->file_name, sdslen(ai->file_name));\n\n sds ret = sdscatprintf(buf, \"%s %s %s %lld %s %c\",\n AOF_MANIFEST_KEY_FILE_NAME, filename_repr ? filename_repr : ai->file_name,\n AOF_MANIFEST_KEY_FILE_SEQ, ai->file_seq,\n AOF_MANIFEST_KEY_FILE_TYPE, ai->file_type);\n\n if (ai->start_offset != -1) {\n ret = sdscatprintf(ret, \" %s %lld\", AOF_MANIFEST_KEY_FILE_STARTOFFSET, ai->start_offset);\n if (ai->end_offset != -1) {\n ret = sdscatprintf(ret, \" %s %lld\", AOF_MANIFEST_KEY_FILE_ENDOFFSET, ai->end_offset);\n }\n }\n\n ret = sdscatlen(ret, \"\\n\", 1);\n sdsfree(filename_repr);\n\n return ret;\n}\n\n/* Method to free AOF list elements. */\nvoid aofListFree(void *item) {\n aofInfo *ai = (aofInfo *)item;\n aofInfoFree(ai);\n}\n\n/* Method to duplicate AOF list elements. */\nvoid *aofListDup(void *item) {\n return aofInfoDup(item);\n}\n\n/* Create an empty aofManifest, which will be called in `aofLoadManifestFromDisk`. */\naofManifest *aofManifestCreate(void) {\n aofManifest *am = zcalloc(sizeof(aofManifest));\n am->incr_aof_list = listCreate();\n am->history_aof_list = listCreate();\n listSetFreeMethod(am->incr_aof_list, aofListFree);\n listSetDupMethod(am->incr_aof_list, aofListDup);\n listSetFreeMethod(am->history_aof_list, aofListFree);\n listSetDupMethod(am->history_aof_list, aofListDup);\n return am;\n}\n\n/* Free the aofManifest structure (pointed to by am) and its embedded members. */\nvoid aofManifestFree(aofManifest *am) {\n if (am->base_aof_info) aofInfoFree(am->base_aof_info);\n if (am->incr_aof_list) listRelease(am->incr_aof_list);\n if (am->history_aof_list) listRelease(am->history_aof_list);\n zfree(am);\n}\n\nsds getAofManifestFileName(void) {\n return sdscatprintf(sdsempty(), \"%s%s\", server.aof_filename,\n MANIFEST_NAME_SUFFIX);\n}\n\nsds getTempAofManifestFileName(void) {\n return sdscatprintf(sdsempty(), \"%s%s%s\", TEMP_FILE_NAME_PREFIX,\n server.aof_filename, MANIFEST_NAME_SUFFIX);\n}\n\nsds appendAofInfoFromList(sds buf, list *aofList) {\n listNode *ln;\n listIter li;\n\n listRewind(aofList, &li);\n while ((ln = listNext(&li)) != NULL) {\n aofInfo *ai = (aofInfo*)ln->value;\n buf = aofInfoFormat(buf, ai);\n }\n\n return buf;\n}\n\n/* Returns the string representation of aofManifest pointed to by am.\n *\n * The string is multiple lines separated by '\\n', and each line represents\n * an AOF file.\n *\n * Each line is space delimited and contains 6 fields, as follows:\n * \"file\" [filename] \"seq\" [sequence] \"type\" [type]\n *\n * Where \"file\", \"seq\" and \"type\" are keywords that describe the next value,\n * [filename] and [sequence] describe file name and order, and [type] is one\n * of 'b' (base), 'h' (history) or 'i' (incr).\n *\n * The base file, if exists, will always be first, followed by history files,\n * and incremental files.\n */\nsds getAofManifestAsString(aofManifest *am) {\n serverAssert(am != NULL);\n\n sds buf = sdsempty();\n\n /* 1. Add BASE File information, it is always at the beginning\n * of the manifest file. */\n if (am->base_aof_info) {\n buf = aofInfoFormat(buf, am->base_aof_info);\n }\n\n /* 2. Add HISTORY type AOF information. */\n buf = appendAofInfoFromList(buf, am->history_aof_list);\n\n /* 3. Add INCR type AOF information. */\n buf = appendAofInfoFromList(buf, am->incr_aof_list);\n\n return buf;\n}\n\n/* Load the manifest information from the disk to `server.aof_manifest`\n * when the Redis server start.\n *\n * During loading, this function does strict error checking and will abort\n * the entire Redis server process on error (I/O error, invalid format, etc.)\n *\n * If the AOF directory or manifest file do not exist, this will be ignored\n * in order to support seamless upgrades from previous versions which did not\n * use them.\n */\nvoid aofLoadManifestFromDisk(void) {\n server.aof_manifest = aofManifestCreate();\n if (!dirExists(server.aof_dirname)) {\n serverLog(LL_DEBUG, \"The AOF directory %s doesn't exist\", server.aof_dirname);\n return;\n }\n\n sds am_name = getAofManifestFileName();\n sds am_filepath = makePath(server.aof_dirname, am_name);\n if (!fileExist(am_filepath)) {\n serverLog(LL_DEBUG, \"The AOF manifest file %s doesn't exist\", am_name);\n sdsfree(am_name);\n sdsfree(am_filepath);\n return;\n }\n\n aofManifest *am = aofLoadManifestFromFile(am_filepath);\n if (am) aofManifestFreeAndUpdate(am);\n sdsfree(am_name);\n sdsfree(am_filepath);\n}\n\n/* Generic manifest loading function, used in `aofLoadManifestFromDisk` and redis-check-aof tool. */\n#define MANIFEST_MAX_LINE 1024\naofManifest *aofLoadManifestFromFile(sds am_filepath) {\n const char *err = NULL;\n long long maxseq = 0;\n\n aofManifest *am = aofManifestCreate();\n FILE *fp = fopen(am_filepath, \"r\");\n if (fp == NULL) {\n serverLog(LL_WARNING, \"Fatal error: can't open the AOF manifest \"\n \"file %s for reading: %s\", am_filepath, strerror(errno));\n exit(1);\n }\n\n char buf[MANIFEST_MAX_LINE+1];\n sds *argv = NULL;\n int argc;\n aofInfo *ai = NULL;\n\n sds line = NULL;\n int linenum = 0;\n\n while (1) {\n if (fgets(buf, MANIFEST_MAX_LINE+1, fp) == NULL) {\n if (feof(fp)) {\n if (linenum == 0) {\n err = \"Found an empty AOF manifest\";\n goto loaderr;\n } else {\n break;\n }\n } else {\n err = \"Read AOF manifest failed\";\n goto loaderr;\n }\n }\n\n linenum++;\n\n /* Skip comments lines */\n if (buf[0] == '#') continue;\n\n if (strchr(buf, '\\n') == NULL) {\n err = \"The AOF manifest file contains too long line\";\n goto loaderr;\n }\n\n line = sdstrim(sdsnew(buf), \" \\t\\r\\n\");\n if (!sdslen(line)) {\n err = \"Invalid AOF manifest file format\";\n goto loaderr;\n }\n\n argv = sdssplitargs(line, &argc);\n /* 'argc < 6' was done for forward compatibility. */\n if (argv == NULL || argc < 6 || (argc % 2)) {\n err = \"Invalid AOF manifest file format\";\n goto loaderr;\n }\n\n ai = aofInfoCreate();\n for (int i = 0; i < argc; i += 2) {\n if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_FILE_NAME)) {\n ai->file_name = sdsnew(argv[i+1]);\n if (!pathIsBaseName(ai->file_name)) {\n err = \"File can't be a path, just a filename\";\n goto loaderr;\n }\n } else if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_FILE_SEQ)) {\n ai->file_seq = atoll(argv[i+1]);\n } else if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_FILE_TYPE)) {\n ai->file_type = (argv[i+1])[0];\n } else if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_FILE_STARTOFFSET)) {\n ai->start_offset = atoll(argv[i+1]);\n } else if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_FILE_ENDOFFSET)) {\n ai->end_offset = atoll(argv[i+1]);\n }\n /* else if (!strcasecmp(argv[i], AOF_MANIFEST_KEY_OTHER)) {} */\n }\n\n /* We have to make sure we load all the information. */\n if (!ai->file_name || !ai->file_seq || !ai->file_type) {\n err = \"Invalid AOF manifest file format\";\n goto loaderr;\n }\n\n sdsfreesplitres(argv, argc);\n argv = NULL;\n\n if (ai->file_type == AOF_FILE_TYPE_BASE) {\n if (am->base_aof_info) {\n err = \"Found duplicate base file information\";\n goto loaderr;\n }\n am->base_aof_info = ai;\n am->curr_base_file_seq = ai->file_seq;\n } else if (ai->file_type == AOF_FILE_TYPE_HIST) {\n listAddNodeTail(am->history_aof_list, ai);\n } else if (ai->file_type == AOF_FILE_TYPE_INCR) {\n if (ai->file_seq <= maxseq) {\n err = \"Found a non-monotonic sequence number\";\n goto loaderr;\n }\n listAddNodeTail(am->incr_aof_list, ai);\n am->curr_incr_file_seq = ai->file_seq;\n maxseq = ai->file_seq;\n } else {\n err = \"Unknown AOF file type\";\n goto loaderr;\n }\n\n sdsfree(line);\n line = NULL;\n ai = NULL;\n }\n\n fclose(fp);\n return am;\n\nloaderr:\n /* Sanitizer suppression: may report a false positive if we goto loaderr\n * and exit(1) without freeing these allocations. */\n if (argv) sdsfreesplitres(argv, argc);\n if (ai) aofInfoFree(ai);\n\n serverLog(LL_WARNING, \"\\n*** FATAL AOF MANIFEST FILE ERROR ***\\n\");\n if (line) {\n serverLog(LL_WARNING, \"Reading the manifest file, at line %d\\n\", linenum);\n serverLog(LL_WARNING, \">>> '%s'\\n\", line);\n }\n serverLog(LL_WARNING, \"%s\\n\", err);\n exit(1);\n}\n\n/* Deep copy an aofManifest from orig.\n *\n * In `backgroundRewriteDoneHandler` and `openNewIncrAofForAppend`, we will\n * first deep copy a temporary AOF manifest from the `server.aof_manifest` and\n * try to modify it. Once everything is modified, we will atomically make the\n * `server.aof_manifest` point to this temporary aof_manifest.\n */\naofManifest *aofManifestDup(aofManifest *orig) {\n serverAssert(orig != NULL);\n aofManifest *am = zcalloc(sizeof(aofManifest));\n\n am->curr_base_file_seq = orig->curr_base_file_seq;\n am->curr_incr_file_seq = orig->curr_incr_file_seq;\n am->dirty = orig->dirty;\n\n if (orig->base_aof_info) {\n am->base_aof_info = aofInfoDup(orig->base_aof_info);\n }\n\n am->incr_aof_list = listDup(orig->incr_aof_list);\n am->history_aof_list = listDup(orig->history_aof_list);\n serverAssert(am->incr_aof_list != NULL);\n serverAssert(am->history_aof_list != NULL);\n return am;\n}\n\n/* Change the `server.aof_manifest` pointer to 'am' and free the previous\n * one if we have. */\nvoid aofManifestFreeAndUpdate(aofManifest *am) {\n serverAssert(am != NULL);\n if (server.aof_manifest) aofManifestFree(server.aof_manifest);\n server.aof_manifest = am;\n}\n\n/* Called in `backgroundRewriteDoneHandler` to get a new BASE file\n * name, and mark the previous (if we have) BASE file as HISTORY type.\n *\n * BASE file naming rules: `server.aof_filename`.seq.base.format\n *\n * for example:\n * appendonly.aof.1.base.aof (server.aof_use_rdb_preamble is no)\n * appendonly.aof.1.base.rdb (server.aof_use_rdb_preamble is yes)\n */\nsds getNewBaseFileNameAndMarkPreAsHistory(aofManifest *am) {\n serverAssert(am != NULL);\n if (am->base_aof_info) {\n serverAssert(am->base_aof_info->file_type == AOF_FILE_TYPE_BASE);\n am->base_aof_info->file_type = AOF_FILE_TYPE_HIST;\n listAddNodeHead(am->history_aof_list, am->base_aof_info);\n }\n\n char *format_suffix = server.aof_use_rdb_preamble ?\n RDB_FORMAT_SUFFIX:AOF_FORMAT_SUFFIX;\n\n aofInfo *ai = aofInfoCreate();\n ai->file_name = sdscatprintf(sdsempty(), \"%s.%lld%s%s\", server.aof_filename,\n ++am->curr_base_file_seq, BASE_FILE_SUFFIX, format_suffix);\n ai->file_seq = am->curr_base_file_seq;\n ai->file_type = AOF_FILE_TYPE_BASE;\n am->base_aof_info = ai;\n am->dirty = 1;\n return am->base_aof_info->file_name;\n}\n\n/* Get a new INCR type AOF name.\n *\n * INCR AOF naming rules: `server.aof_filename`.seq.incr.aof\n *\n * for example:\n * appendonly.aof.1.incr.aof\n */\nsds getNewIncrAofName(aofManifest *am, long long start_reploff) {\n aofInfo *ai = aofInfoCreate();\n ai->file_type = AOF_FILE_TYPE_INCR;\n ai->file_name = sdscatprintf(sdsempty(), \"%s.%lld%s%s\", server.aof_filename,\n ++am->curr_incr_file_seq, INCR_FILE_SUFFIX, AOF_FORMAT_SUFFIX);\n ai->file_seq = am->curr_incr_file_seq;\n ai->start_offset = start_reploff;\n listAddNodeTail(am->incr_aof_list, ai);\n am->dirty = 1;\n return ai->file_name;\n}\n\n/* Get temp INCR type AOF name. */\nsds getTempIncrAofName(void) {\n return sdscatprintf(sdsempty(), \"%s%s%s\", TEMP_FILE_NAME_PREFIX, server.aof_filename,\n INCR_FILE_SUFFIX);\n}\n\n/* Get the last INCR AOF name or create a new one. */\nsds getLastIncrAofName(aofManifest *am) {\n serverAssert(am != NULL);\n\n /* If 'incr_aof_list' is empty, just create a new one. */\n if (!listLength(am->incr_aof_list)) {\n return getNewIncrAofName(am, server.master_repl_offset);\n }\n\n /* Or return the last one. */\n listNode *lastnode = listIndex(am->incr_aof_list, -1);\n aofInfo *ai = listNodeValue(lastnode);\n return ai->file_name;\n}\n\n/* Called in `backgroundRewriteDoneHandler`. when AOFRW success, This\n * function will change the AOF file type in 'incr_aof_list' from\n * AOF_FILE_TYPE_INCR to AOF_FILE_TYPE_HIST, and move them to the\n * 'history_aof_list'.\n */\nvoid markRewrittenIncrAofAsHistory(aofManifest *am) {\n serverAssert(am != NULL);\n if (!listLength(am->incr_aof_list)) {\n return;\n }\n\n listNode *ln;\n listIter li;\n\n listRewindTail(am->incr_aof_list, &li);\n\n /* \"server.aof_fd != -1\" means AOF enabled, then we must skip the\n * last AOF, because this file is our currently writing. */\n if (server.aof_fd != -1) {\n ln = listNext(&li);\n serverAssert(ln != NULL);\n }\n\n /* Move aofInfo from 'incr_aof_list' to 'history_aof_list'. */\n while ((ln = listNext(&li)) != NULL) {\n aofInfo *ai = (aofInfo*)ln->value;\n serverAssert(ai->file_type == AOF_FILE_TYPE_INCR);\n\n aofInfo *hai = aofInfoDup(ai);\n hai->file_type = AOF_FILE_TYPE_HIST;\n listAddNodeHead(am->history_aof_list, hai);\n listDelNode(am->incr_aof_list, ln);\n }\n\n am->dirty = 1;\n}\n\n/* Write the formatted manifest string to disk. */\nint writeAofManifestFile(sds buf) {\n int ret = C_OK;\n ssize_t nwritten;\n int len;\n\n sds am_name = getAofManifestFileName();\n sds am_filepath = makePath(server.aof_dirname, am_name);\n sds tmp_am_name = getTempAofManifestFileName();\n sds tmp_am_filepath = makePath(server.aof_dirname, tmp_am_name);\n\n int fd = open(tmp_am_filepath, O_WRONLY|O_TRUNC|O_CREAT, 0644);\n if (fd == -1) {\n serverLog(LL_WARNING, \"Can't open the AOF manifest file %s: %s\",\n tmp_am_name, strerror(errno));\n\n ret = C_ERR;\n goto cleanup;\n }\n\n len = sdslen(buf);\n while(len) {\n nwritten = write(fd, buf, len);\n\n if (nwritten < 0) {\n if (errno == EINTR) continue;\n\n serverLog(LL_WARNING, \"Error trying to write the temporary AOF manifest file %s: %s\",\n tmp_am_name, strerror(errno));\n\n ret = C_ERR;\n goto cleanup;\n }\n\n len -= nwritten;\n buf += nwritten;\n }\n\n if (redis_fsync(fd) == -1) {\n serverLog(LL_WARNING, \"Fail to fsync the temp AOF file %s: %s.\",\n tmp_am_name, strerror(errno));\n\n ret = C_ERR;\n goto cleanup;\n }\n\n if (rename(tmp_am_filepath, am_filepath) != 0) {\n serverLog(LL_WARNING,\n \"Error trying to rename the temporary AOF manifest file %s into %s: %s\",\n tmp_am_name, am_name, strerror(errno));\n\n ret = C_ERR;\n goto cleanup;\n }\n\n /* Also sync the AOF directory as new AOF files may be added in the directory */\n if (fsyncFileDir(am_filepath) == -1) {\n serverLog(LL_WARNING, \"Fail to fsync AOF directory %s: %s.\",\n am_filepath, strerror(errno));\n\n ret = C_ERR;\n goto cleanup;\n }\n\ncleanup:\n if (fd != -1) close(fd);\n sdsfree(am_name);\n sdsfree(am_filepath);\n sdsfree(tmp_am_name);\n sdsfree(tmp_am_filepath);\n return ret;\n}\n\n/* Persist the aofManifest information pointed to by am to disk. */\nint persistAofManifest(aofManifest *am) {\n if (am->dirty == 0) {\n return C_OK;\n }\n\n sds amstr = getAofManifestAsString(am);\n int ret = writeAofManifestFile(amstr);\n sdsfree(amstr);\n if (ret == C_OK) am->dirty = 0;\n return ret;\n}\n\n/* Called in `loadAppendOnlyFiles` when we upgrade from a old version redis.\n *\n * 1) Create AOF directory use 'server.aof_dirname' as the name.\n * 2) Use 'server.aof_filename' to construct a BASE type aofInfo and add it to\n * aofManifest, then persist the manifest file to AOF directory.\n * 3) Move the old AOF file (server.aof_filename) to AOF directory.\n *\n * If any of the above steps fails or crash occurs, this will not cause any\n * problems, and redis will retry the upgrade process when it restarts.\n */\nvoid aofUpgradePrepare(aofManifest *am) {\n serverAssert(!aofFileExist(server.aof_filename));\n\n /* Create AOF directory use 'server.aof_dirname' as the name. */\n if (dirCreateIfMissing(server.aof_dirname) == -1) {\n serverLog(LL_WARNING, \"Can't open or create append-only dir %s: %s\",\n server.aof_dirname, strerror(errno));\n exit(1);\n }\n\n /* Manually construct a BASE type aofInfo and add it to aofManifest. */\n if (am->base_aof_info) aofInfoFree(am->base_aof_info);\n aofInfo *ai = aofInfoCreate();\n ai->file_name = sdsnew(server.aof_filename);\n ai->file_seq = 1;\n ai->file_type = AOF_FILE_TYPE_BASE;\n am->base_aof_info = ai;\n am->curr_base_file_seq = 1;\n am->dirty = 1;\n\n /* Persist the manifest file to AOF directory. */\n if (persistAofManifest(am) != C_OK) {\n exit(1);\n }\n\n /* Move the old AOF file to AOF directory. */\n sds aof_filepath = makePath(server.aof_dirname, server.aof_filename);\n if (rename(server.aof_filename, aof_filepath) == -1) {\n serverLog(LL_WARNING,\n \"Error trying to move the old AOF file %s into dir %s: %s\",\n server.aof_filename,\n server.aof_dirname,\n strerror(errno));\n sdsfree(aof_filepath);\n exit(1);\n }\n sdsfree(aof_filepath);\n\n serverLog(LL_NOTICE, \"Successfully migrated an old-style AOF file (%s) into the AOF directory (%s).\",\n server.aof_filename, server.aof_dirname);\n}\n\n/* When AOFRW success, the previous BASE and INCR AOFs will\n * become HISTORY type and be moved into 'history_aof_list'.\n *\n * The function will traverse the 'history_aof_list' and submit\n * the delete task to the bio thread.\n */\nint aofDelHistoryFiles(void) {\n if (server.aof_manifest == NULL ||\n server.aof_disable_auto_gc == 1 ||\n !listLength(server.aof_manifest->history_aof_list))\n {\n return C_OK;\n }\n\n listNode *ln;\n listIter li;\n\n listRewind(server.aof_manifest->history_aof_list, &li);\n while ((ln = listNext(&li)) != NULL) {\n aofInfo *ai = (aofInfo*)ln->value;\n serverAssert(ai->file_type == AOF_FILE_TYPE_HIST);\n serverLog(LL_NOTICE, \"Removing the history file %s in the background\", ai->file_name);\n sds aof_filepath = makePath(server.aof_dirname, ai->file_name);\n bg_unlink(aof_filepath);\n sdsfree(aof_filepath);\n listDelNode(server.aof_manifest->history_aof_list, ln);\n }\n\n server.aof_manifest->dirty = 1;\n return persistAofManifest(server.aof_manifest);\n}\n\n/* Used to clean up temp INCR AOF when AOFRW fails. */\nvoid aofDelTempIncrAofFile(void) {\n sds aof_filename = getTempIncrAofName();\n sds aof_filepath = makePath(server.aof_dirname, aof_filename);\n serverLog(LL_NOTICE, \"Removing the temp incr aof file %s in the background\", aof_filename);\n bg_unlink(aof_filepath);\n sdsfree(aof_filepath);\n sdsfree(aof_filename);\n return;\n}\n\n/* Called after `loadDataFromDisk` when redis start. If `server.aof_state` is\n * 'AOF_ON', It will do three things:\n * 1. Force create a BASE file when redis starts with an empty dataset\n * 2. Open the last opened INCR type AOF for writing, If not, create a new one\n * 3. Synchronously update the manifest file to the disk\n *\n * If any of the above steps fails, the redis process will exit.\n */\nvoid aofOpenIfNeededOnServerStart(void) {\n if (server.aof_state != AOF_ON) {\n return;\n }\n\n serverAssert(server.aof_manifest != NULL);\n serverAssert(server.aof_fd == -1);\n\n if (dirCreateIfMissing(server.aof_dirname) == -1) {\n serverLog(LL_WARNING, \"Can't open or create append-only dir %s: %s\",\n server.aof_dirname, strerror(errno));\n exit(1);\n }\n\n /* If we start with an empty dataset, we will force create a BASE file. */\n size_t incr_aof_len = listLength(server.aof_manifest->incr_aof_list);\n if (!server.aof_manifest->base_aof_info && !incr_aof_len) {\n sds base_name = getNewBaseFileNameAndMarkPreAsHistory(server.aof_manifest);\n sds base_filepath = makePath(server.aof_dirname, base_name);\n if (rewriteAppendOnlyFile(base_filepath) != C_OK) {\n exit(1);\n }\n sdsfree(base_filepath);\n serverLog(LL_NOTICE, \"Creating AOF base file %s on server start\",\n base_name);\n }\n\n /* Because we will 'exit(1)' if open AOF or persistent manifest fails, so\n * we don't need atomic modification here. */\n sds aof_name = getLastIncrAofName(server.aof_manifest);\n\n /* Here we should use 'O_APPEND' flag. */\n sds aof_filepath = makePath(server.aof_dirname, aof_name);\n server.aof_fd = open(aof_filepath, O_WRONLY|O_APPEND|O_CREAT, 0644);\n sdsfree(aof_filepath);\n if (server.aof_fd == -1) {\n serverLog(LL_WARNING, \"Can't open the append-only file %s: %s\",\n aof_name, strerror(errno));\n exit(1);\n }\n\n /* Persist our changes. */\n int ret = persistAofManifest(server.aof_manifest);\n if (ret != C_OK) {\n exit(1);\n }\n\n server.aof_last_incr_size = getAppendOnlyFileSize(aof_name, NULL);\n server.aof_last_incr_fsync_offset = server.aof_last_incr_size;\n\n if (incr_aof_len) {\n serverLog(LL_NOTICE, \"Opening AOF incr file %s on server start\", aof_name);\n } else {\n serverLog(LL_NOTICE, \"Creating AOF incr file %s on server start\", aof_name);\n }\n}\n\nint aofFileExist(char *filename) {\n sds file_path = makePath(server.aof_dirname, filename);\n int ret = fileExist(file_path);\n sdsfree(file_path);\n return ret;\n}\n\n/* Called in `rewriteAppendOnlyFileBackground`. If `server.aof_state`\n * is 'AOF_ON', It will do two things:\n * 1. Open a new INCR type AOF for writing\n * 2. Synchronously update the manifest file to the disk\n *\n * The above two steps of modification are atomic, that is, if\n * any step fails, the entire operation will rollback and returns\n * C_ERR, and if all succeeds, it returns C_OK.\n * \n * If `server.aof_state` is 'AOF_WAIT_REWRITE', It will open a temporary INCR AOF \n * file to accumulate data during AOF_WAIT_REWRITE, and it will eventually be \n * renamed in the `backgroundRewriteDoneHandler` and written to the manifest file.\n * */\nint openNewIncrAofForAppend(void) {\n serverAssert(server.aof_manifest != NULL);\n int newfd = -1;\n aofManifest *temp_am = NULL;\n sds new_aof_name = NULL;\n\n /* Only open new INCR AOF when AOF enabled. */\n if (server.aof_state == AOF_OFF) return C_OK;\n\n /* Open new AOF. */\n if (server.aof_state == AOF_WAIT_REWRITE) {\n /* Use a temporary INCR AOF file to accumulate data during AOF_WAIT_REWRITE. */\n new_aof_name = getTempIncrAofName();\n tempIncAofStartReplOffset = server.master_repl_offset;\n } else {\n /* Dup a temp aof_manifest to modify. */\n temp_am = aofManifestDup(server.aof_manifest);\n new_aof_name = sdsdup(getNewIncrAofName(temp_am, server.master_repl_offset));\n }\n sds new_aof_filepath = makePath(server.aof_dirname, new_aof_name);\n newfd = open(new_aof_filepath, O_WRONLY|O_TRUNC|O_CREAT, 0644);\n sdsfree(new_aof_filepath);\n if (newfd == -1) {\n serverLog(LL_WARNING, \"Can't open the append-only file %s: %s\",\n new_aof_name, strerror(errno));\n goto cleanup;\n }\n\n if (temp_am) {\n /* Persist AOF Manifest. */\n if (persistAofManifest(temp_am) == C_ERR) {\n goto cleanup;\n }\n }\n\n serverLog(LL_NOTICE, \"Creating AOF incr file %s on background rewrite\",\n new_aof_name);\n sdsfree(new_aof_name);\n\n /* If reaches here, we can safely modify the `server.aof_manifest`\n * and `server.aof_fd`. */\n\n /* fsync and close old aof_fd if needed. In fsync everysec it's ok to delay\n * the fsync as long as we grantee it happens, and in fsync always the file\n * is already synced at this point so fsync doesn't matter. */\n if (server.aof_fd != -1) {\n aof_background_fsync_and_close(server.aof_fd);\n server.aof_last_fsync = server.mstime;\n }\n server.aof_fd = newfd;\n\n /* Reset the aof_last_incr_size. */\n server.aof_last_incr_size = 0;\n /* Reset the aof_last_incr_fsync_offset. */\n server.aof_last_incr_fsync_offset = 0;\n /* Update `server.aof_manifest`. */\n if (temp_am) aofManifestFreeAndUpdate(temp_am);\n return C_OK;\n\ncleanup:\n if (new_aof_name) sdsfree(new_aof_name);\n if (newfd != -1) close(newfd);\n if (temp_am) aofManifestFree(temp_am);\n return C_ERR;\n}\n\n/* When we close gracefully the AOF file, we have the chance to persist the\n * end replication offset of current INCR AOF. */\nvoid updateCurIncrAofEndOffset(void) {\n if (server.aof_state != AOF_ON) return;\n serverAssert(server.aof_manifest != NULL);\n\n if (listLength(server.aof_manifest->incr_aof_list) == 0) return;\n aofInfo *ai = listNodeValue(listLast(server.aof_manifest->incr_aof_list));\n ai->end_offset = server.master_repl_offset;\n server.aof_manifest->dirty = 1;\n /* It doesn't matter if the persistence fails since this information is not\n * critical, we can get an approximate value by start offset plus file size. */\n persistAofManifest(server.aof_manifest);\n}\n\n/* After loading AOF data, we need to update the `server.master_repl_offset`\n * based on the information of the last INCR AOF, to avoid the rollback of\n * the start offset of new INCR AOF. */\nvoid updateReplOffsetAndResetEndOffset(void) {\n if (server.aof_state != AOF_ON) return;\n serverAssert(server.aof_manifest != NULL);\n\n /* If the INCR file has an end offset, we directly use it, and clear it\n * to avoid the next time we load the manifest file, we will use the same\n * offset, but the real offset may have advanced. */\n if (listLength(server.aof_manifest->incr_aof_list) == 0) return;\n aofInfo *ai = listNodeValue(listLast(server.aof_manifest->incr_aof_list));\n if (ai->end_offset != -1) {\n server.master_repl_offset = ai->end_offset;\n ai->end_offset = -1;\n server.aof_manifest->dirty = 1;\n /* We must update the end offset of INCR file correctly, otherwise we\n * may keep wrong information in the manifest file, since we continue\n * to append data to the same INCR file. */\n if (persistAofManifest(server.aof_manifest) != AOF_OK)\n exit(1);\n } else {\n /* If the INCR file doesn't have an end offset, we need to calculate\n * the replication offset by the start offset plus the file size. */\n server.master_repl_offset = (ai->start_offset == -1 ? 0 : ai->start_offset) +\n getAppendOnlyFileSize(ai->file_name, NULL);\n }\n}\n\n/* Whether to limit the execution of Background AOF rewrite.\n *\n * At present, if AOFRW fails, redis will automatically retry. If it continues\n * to fail, we may get a lot of very small INCR files. so we need an AOFRW\n * limiting measure.\n *\n * We can't directly use `server.aof_current_size` and `server.aof_last_incr_size`,\n * because there may be no new writes after AOFRW fails.\n *\n * So, we use time delay to achieve our goal. When AOFRW fails, we delay the execution\n * of the next AOFRW by 1 minute. If the next AOFRW also fails, it will be delayed by 2\n * minutes. The next is 4, 8, 16, the maximum delay is 60 minutes (1 hour).\n *\n * During the limit period, we can still use the 'bgrewriteaof' command to execute AOFRW\n * immediately.\n *\n * Return 1 means that AOFRW is limited and cannot be executed. 0 means that we can execute\n * AOFRW, which may be that we have reached the 'next_rewrite_time' or the number of INCR\n * AOFs has not reached the limit threshold.\n * */\n#define AOF_REWRITE_LIMITE_THRESHOLD 3\n#define AOF_REWRITE_LIMITE_MAX_MINUTES 60 /* 1 hour */\nint aofRewriteLimited(void) {\n static int next_delay_minutes = 0;\n static time_t next_rewrite_time = 0;\n\n if (server.stat_aofrw_consecutive_failures < AOF_REWRITE_LIMITE_THRESHOLD) {\n /* We may be recovering from limited state, so reset all states. */\n next_delay_minutes = 0;\n next_rewrite_time = 0;\n return 0;\n }\n\n /* if it is in the limiting state, then check if the next_rewrite_time is reached */\n if (next_rewrite_time != 0) {\n if (server.unixtime < next_rewrite_time) {\n return 1;\n } else {\n next_rewrite_time = 0;\n return 0;\n }\n }\n\n next_delay_minutes = (next_delay_minutes == 0) ? 1 : (next_delay_minutes * 2);\n if (next_delay_minutes > AOF_REWRITE_LIMITE_MAX_MINUTES) {\n next_delay_minutes = AOF_REWRITE_LIMITE_MAX_MINUTES;\n }\n\n next_rewrite_time = server.unixtime + next_delay_minutes * 60;\n serverLog(LL_WARNING,\n \"Background AOF rewrite has repeatedly failed and triggered the limit, will retry in %d minutes\", next_delay_minutes);\n return 1;\n}\n\n/* ----------------------------------------------------------------------------\n * AOF file implementation\n * ------------------------------------------------------------------------- */\n\n/* Return true if an AOf fsync is currently already in progress in a\n * BIO thread. */\nint aofFsyncInProgress(void) {\n /* Note that we don't care about aof_background_fsync_and_close because\n * server.aof_fd has been replaced by the new INCR AOF file fd,\n * see openNewIncrAofForAppend. */\n return bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;\n}\n\n/* Starts a background task that performs fsync() against the specified\n * file descriptor (the one of the AOF file) in another thread. */\nvoid aof_background_fsync(int fd) {\n bioCreateFsyncJob(fd, server.master_repl_offset, 1);\n}\n\n/* Close the fd on the basis of aof_background_fsync. */\nvoid aof_background_fsync_and_close(int fd) {\n bioCreateCloseAofJob(fd, server.master_repl_offset, 1);\n}\n\n/* Kills an AOFRW child process if exists */\nvoid killAppendOnlyChild(void) {\n int statloc;\n /* No AOFRW child? return. */\n if (server.child_type != CHILD_TYPE_AOF) return;\n /* Kill AOFRW child, wait for child exit. */\n serverLog(LL_NOTICE,\"Killing running AOF rewrite child: %ld\",\n (long) server.child_pid);\n if (kill(server.child_pid,SIGUSR1) != -1) {\n while(waitpid(-1, &statloc, 0) != server.child_pid);\n }\n aofRemoveTempFile(server.child_pid);\n resetChildState();\n server.aof_rewrite_time_start = -1;\n}\n\n/* Called when the user switches from \"appendonly yes\" to \"appendonly no\"\n * at runtime using the CONFIG command. */\nvoid stopAppendOnly(void) {\n serverAssert(server.aof_state != AOF_OFF);\n flushAppendOnlyFile(1);\n if (redis_fsync(server.aof_fd) == -1) {\n serverLog(LL_WARNING,\"Fail to fsync the AOF file: %s\",strerror(errno));\n } else {\n server.aof_last_fsync = server.mstime;\n }\n close(server.aof_fd);\n updateCurIncrAofEndOffset();\n\n server.aof_fd = -1;\n server.aof_selected_db = -1;\n server.aof_state = AOF_OFF;\n server.aof_rewrite_scheduled = 0;\n server.aof_last_incr_size = 0;\n server.aof_last_incr_fsync_offset = 0;\n server.fsynced_reploff = -1;\n atomicSet(server.fsynced_reploff_pending, 0);\n killAppendOnlyChild();\n sdsfree(server.aof_buf);\n server.aof_buf = sdsempty();\n}\n\n/* Called when the user switches from \"appendonly no\" to \"appendonly yes\"\n * at runtime using the CONFIG command. */\nint startAppendOnly(void) {\n serverAssert(server.aof_state == AOF_OFF);\n\n server.aof_state = AOF_WAIT_REWRITE;\n if (hasActiveChildProcess() && server.child_type != CHILD_TYPE_AOF) {\n server.aof_rewrite_scheduled = 1;\n serverLog(LL_NOTICE,\"AOF was enabled but there is already another background operation. An AOF background was scheduled to start when possible.\");\n } else if (server.in_exec){\n server.aof_rewrite_scheduled = 1;\n serverLog(LL_NOTICE,\"AOF was enabled during a transaction. An AOF background was scheduled to start when possible.\");\n } else {\n /* If there is a pending AOF rewrite, we need to switch it off and\n * start a new one: the old one cannot be reused because it is not\n * accumulating the AOF buffer. */\n if (server.child_type == CHILD_TYPE_AOF) {\n serverLog(LL_NOTICE,\"AOF was enabled but there is already an AOF rewriting in background. Stopping background AOF and starting a rewrite now.\");\n killAppendOnlyChild();\n }\n\n if (rewriteAppendOnlyFileBackground() == C_ERR) {\n server.aof_state = AOF_OFF;\n serverLog(LL_WARNING,\"Redis needs to enable the AOF but can't trigger a background AOF rewrite operation. Check the above logs for more info about the error.\");\n return C_ERR;\n }\n }\n server.aof_last_fsync = server.mstime;\n /* If AOF fsync error in bio job, we just ignore it and log the event. */\n int aof_bio_fsync_status;\n atomicGet(server.aof_bio_fsync_status, aof_bio_fsync_status);\n if (aof_bio_fsync_status == C_ERR) {\n serverLog(LL_WARNING,\n \"AOF reopen, just ignore the AOF fsync error in bio job\");\n atomicSet(server.aof_bio_fsync_status,C_OK);\n }\n\n /* If AOF was in error state, we just ignore it and log the event. */\n if (server.aof_last_write_status == C_ERR) {\n serverLog(LL_WARNING,\"AOF reopen, just ignore the last error.\");\n server.aof_last_write_status = C_OK;\n }\n return C_OK;\n}\n\nvoid startAppendOnlyWithRetry(void) {\n unsigned int tries, max_tries = 10;\n for (tries = 0; tries < max_tries; ++tries) {\n if (startAppendOnly() == C_OK)\n break;\n serverLog(LL_WARNING, \"Failed to enable AOF! Trying it again in one second.\");\n sleep(1);\n }\n if (tries == max_tries) {\n serverLog(LL_WARNING, \"FATAL: AOF can't be turned on. Exiting now.\");\n exit(1);\n }\n}\n\n/* Called after \"appendonly\" config is changed. */\nvoid applyAppendOnlyConfig(void) {\n if (!server.aof_enabled && server.aof_state != AOF_OFF) {\n stopAppendOnly();\n } else if (server.aof_enabled && server.aof_state == AOF_OFF) {\n startAppendOnlyWithRetry();\n }\n}\n\n/* This is a wrapper to the write syscall in order to retry on short writes\n * or if the syscall gets interrupted. It could look strange that we retry\n * on short writes given that we are writing to a block device: normally if\n * the first call is short, there is a end-of-space condition, so the next\n * is likely to fail. However apparently in modern systems this is no longer\n * true, and in general it looks just more resilient to retry the write. If\n * there is an actual error condition we'll get it at the next try. */\nssize_t aofWrite(int fd, const char *buf, size_t len) {\n ssize_t nwritten = 0, totwritten = 0;\n\n while(len) {\n nwritten = write(fd, buf, len);\n\n if (nwritten < 0) {\n if (errno == EINTR) continue;\n return totwritten ? totwritten : -1;\n }\n\n len -= nwritten;\n buf += nwritten;\n totwritten += nwritten;\n }\n\n return totwritten;\n}\n\n/* Write the append only file buffer on disk.\n *\n * Since we are required to write the AOF before replying to the client,\n * and the only way the client socket can get a write is entering when\n * the event loop, we accumulate all the AOF writes in a memory\n * buffer and write it on disk using this function just before entering\n * the event loop again.\n *\n * About the 'force' argument:\n *\n * When the fsync policy is set to 'everysec' we may delay the flush if there\n * is still an fsync() going on in the background thread, since for instance\n * on Linux write(2) will be blocked by the background fsync anyway.\n * When this happens we remember that there is some aof buffer to be\n * flushed ASAP, and will try to do that in the serverCron() function.\n *\n * However if force is set to 1 we'll write regardless of the background\n * fsync. */\n#define AOF_WRITE_LOG_ERROR_RATE 30 /* Seconds between errors logging. */\nvoid flushAppendOnlyFile(int force) {\n ssize_t nwritten;\n int sync_in_progress = 0;\n mstime_t latency;\n\n if (sdslen(server.aof_buf) == 0) {\n if (server.aof_last_incr_fsync_offset == server.aof_last_incr_size) {\n /* All data is fsync'd already: Update fsynced_reploff_pending just in case.\n * This is needed to avoid a WAITAOF hang in case a module used RM_Call\n * with the NO_AOF flag, in which case master_repl_offset will increase but\n * fsynced_reploff_pending won't be updated (because there's no reason, from\n * the AOF POV, to call fsync) and then WAITAOF may wait on the higher offset\n * (which contains data that was only propagated to replicas, and not to AOF) */\n if (!aofFsyncInProgress())\n atomicSet(server.fsynced_reploff_pending, server.master_repl_offset);\n } else {\n /* Check if we need to do fsync even the aof buffer is empty,\n * because previously in AOF_FSYNC_EVERYSEC mode, fsync is\n * called only when aof buffer is not empty, so if users\n * stop write commands before fsync called in one second,\n * the data in page cache cannot be flushed in time. */\n if (server.aof_fsync == AOF_FSYNC_EVERYSEC &&\n server.mstime - server.aof_last_fsync >= 1000 &&\n !(sync_in_progress = aofFsyncInProgress()))\n goto try_fsync;\n\n /* Check if we need to do fsync even the aof buffer is empty,\n * the reason is described in the previous AOF_FSYNC_EVERYSEC block,\n * and AOF_FSYNC_ALWAYS is also checked here to handle a case where\n * aof_fsync is changed from everysec to always. */\n if (server.aof_fsync == AOF_FSYNC_ALWAYS)\n goto try_fsync;\n }\n return;\n }\n\n if (server.aof_fsync == AOF_FSYNC_EVERYSEC)\n sync_in_progress = aofFsyncInProgress();\n\n if (server.aof_fsync == AOF_FSYNC_EVERYSEC && !force) {\n /* With this append fsync policy we do background fsyncing.\n * If the fsync is still in progress we can try to delay\n * the write for a couple of seconds. */\n if (sync_in_progress) {\n if (server.aof_flush_postponed_start == 0) {\n /* No previous write postponing, remember that we are\n * postponing the flush and return. */\n server.aof_flush_postponed_start = server.mstime;\n return;\n } else if (server.mstime - server.aof_flush_postponed_start < 2000) {\n /* We were already waiting for fsync to finish, but for less\n * than two seconds this is still ok. Postpone again. */\n return;\n }\n /* Otherwise fall through, and go write since we can't wait\n * over two seconds. */\n server.aof_delayed_fsync++;\n serverLog(LL_NOTICE,\"Asynchronous AOF fsync is taking too long (disk is busy?). Writing the AOF buffer without waiting for fsync to complete, this may slow down Redis.\");\n }\n }\n /* We want to perform a single write. This should be guaranteed atomic\n * at least if the filesystem we are writing is a real physical one.\n * While this will save us against the server being killed I don't think\n * there is much to do about the whole server stopping for power problems\n * or alike */\n\n if (server.aof_flush_sleep && sdslen(server.aof_buf)) {\n usleep(server.aof_flush_sleep);\n }\n\n latencyStartMonitor(latency);\n nwritten = aofWrite(server.aof_fd,server.aof_buf,sdslen(server.aof_buf));\n latencyEndMonitor(latency);\n /* We want to capture different events for delayed writes:\n * when the delay happens with a pending fsync, or with a saving child\n * active, and when the above two conditions are missing.\n * We also use an additional event name to save all samples which is\n * useful for graphing / monitoring purposes. */\n if (sync_in_progress) {\n latencyAddSampleIfNeeded(\"aof-write-pending-fsync\",latency);\n } else if (hasActiveChildProcess()) {\n latencyAddSampleIfNeeded(\"aof-write-active-child\",latency);\n } else {\n latencyAddSampleIfNeeded(\"aof-write-alone\",latency);\n }\n latencyAddSampleIfNeeded(\"aof-write\",latency);\n\n /* We performed the write so reset the postponed flush sentinel to zero. */\n server.aof_flush_postponed_start = 0;\n\n if (nwritten != (ssize_t)sdslen(server.aof_buf)) {\n static time_t last_write_error_log = 0;\n int can_log = 0;\n\n /* Limit logging rate to 1 line per AOF_WRITE_LOG_ERROR_RATE seconds. */\n if ((server.unixtime - last_write_error_log) > AOF_WRITE_LOG_ERROR_RATE) {\n can_log = 1;\n last_write_error_log = server.unixtime;\n }\n\n /* Log the AOF write error and record the error code. */\n if (nwritten == -1) {\n if (can_log) {\n serverLog(LL_WARNING,\"Error writing to the AOF file: %s\",\n strerror(errno));\n }\n server.aof_last_write_errno = errno;\n } else {\n if (can_log) {\n serverLog(LL_WARNING,\"Short write while writing to \"\n \"the AOF file: (nwritten=%lld, \"\n \"expected=%lld)\",\n (long long)nwritten,\n (long long)sdslen(server.aof_buf));\n }\n\n if (ftruncate(server.aof_fd, server.aof_last_incr_size) == -1) {\n if (can_log) {\n serverLog(LL_WARNING, \"Could not remove short write \"\n \"from the append-only file. Redis may refuse \"\n \"to load the AOF the next time it starts. \"\n \"ftruncate: %s\", strerror(errno));\n }\n } else {\n /* If the ftruncate() succeeded we can set nwritten to\n * -1 since there is no longer partial data into the AOF. */\n nwritten = -1;\n }\n server.aof_last_write_errno = ENOSPC;\n }\n\n /* Handle the AOF write error. */\n if (server.aof_fsync == AOF_FSYNC_ALWAYS) {\n /* We can't recover when the fsync policy is ALWAYS since the reply\n * for the client is already in the output buffers (both writes and\n * reads), and the changes to the db can't be rolled back. Since we\n * have a contract with the user that on acknowledged or observed\n * writes are is synced on disk, we must exit. */\n serverLog(LL_WARNING,\"Can't recover from AOF write error when the AOF fsync policy is 'always'. Exiting...\");\n exit(1);\n } else {\n /* Recover from failed write leaving data into the buffer. However\n * set an error to stop accepting writes as long as the error\n * condition is not cleared. */\n server.aof_last_write_status = C_ERR;\n\n /* Trim the sds buffer if there was a partial write, and there\n * was no way to undo it with ftruncate(2). */\n if (nwritten > 0) {\n server.aof_current_size += nwritten;\n server.aof_last_incr_size += nwritten;\n sdsrange(server.aof_buf,nwritten,-1);\n }\n return; /* We'll try again on the next call... */\n }\n } else {\n /* Successful write(2). If AOF was in error state, restore the\n * OK state and log the event. */\n if (server.aof_last_write_status == C_ERR) {\n serverLog(LL_NOTICE,\n \"AOF write error looks solved, Redis can write again.\");\n server.aof_last_write_status = C_OK;\n }\n }\n server.aof_current_size += nwritten;\n server.aof_last_incr_size += nwritten;\n\n /* Re-use AOF buffer when it is small enough. The maximum comes from the\n * arena size of 4k minus some overhead (but is otherwise arbitrary). */\n if ((sdslen(server.aof_buf)+sdsavail(server.aof_buf)) < 4000) {\n sdsclear(server.aof_buf);\n } else {\n sdsfree(server.aof_buf);\n server.aof_buf = sdsempty();\n }\n\ntry_fsync:\n /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are\n * children doing I/O in the background. */\n if (server.aof_no_fsync_on_rewrite && hasActiveChildProcess())\n return;\n\n /* Perform the fsync if needed. */\n if (server.aof_fsync == AOF_FSYNC_ALWAYS) {\n /* redis_fsync is defined as fdatasync() for Linux in order to avoid\n * flushing metadata. */\n latencyStartMonitor(latency);\n /* Let's try to get this data on the disk. To guarantee data safe when\n * the AOF fsync policy is 'always', we should exit if failed to fsync\n * AOF (see comment next to the exit(1) after write error above). */\n if (redis_fsync(server.aof_fd) == -1) {\n serverLog(LL_WARNING,\"Can't persist AOF for fsync error when the \"\n \"AOF fsync policy is 'always': %s. Exiting...\", strerror(errno));\n exit(1);\n }\n latencyEndMonitor(latency);\n latencyAddSampleIfNeeded(\"aof-fsync-always\",latency);\n server.aof_last_incr_fsync_offset = server.aof_last_incr_size;\n server.aof_last_fsync = server.mstime;\n atomicSet(server.fsynced_reploff_pending, server.master_repl_offset);\n } else if (server.aof_fsync == AOF_FSYNC_EVERYSEC &&\n server.mstime - server.aof_last_fsync >= 1000) {\n if (!sync_in_progress) {\n aof_background_fsync(server.aof_fd);\n server.aof_last_incr_fsync_offset = server.aof_last_incr_size;\n }\n server.aof_last_fsync = server.mstime;\n }\n}\n\nsds catAppendOnlyGenericCommand(sds dst, int argc, robj **argv) {\n char buf[32];\n int len, j;\n robj *o;\n\n buf[0] = '*';\n len = 1+ll2string(buf+1,sizeof(buf)-1,argc);\n buf[len++] = '\\r';\n buf[len++] = '\\n';\n dst = sdscatlen(dst,buf,len);\n\n for (j = 0; j < argc; j++) {\n o = getDecodedObject(argv[j]);\n buf[0] = '$';\n len = 1+ll2string(buf+1,sizeof(buf)-1,sdslen(o->ptr));\n buf[len++] = '\\r';\n buf[len++] = '\\n';\n dst = sdscatlen(dst,buf,len);\n dst = sdscatlen(dst,o->ptr,sdslen(o->ptr));\n dst = sdscatlen(dst,\"\\r\\n\",2);\n decrRefCount(o);\n }\n return dst;\n}\n\n/* Generate a piece of timestamp annotation for AOF if current record timestamp\n * in AOF is not equal server unix time. If we specify 'force' argument to 1,\n * we would generate one without check, currently, it is useful in AOF rewriting\n * child process which always needs to record one timestamp at the beginning of\n * rewriting AOF.\n *\n * Timestamp annotation format is \"#TS:${timestamp}\\r\\n\". \"TS\" is short of\n * timestamp and this method could save extra bytes in AOF. */\nsds genAofTimestampAnnotationIfNeeded(int force) {\n sds ts = NULL;\n\n if (force || server.aof_cur_timestamp < server.unixtime) {\n server.aof_cur_timestamp = force ? time(NULL) : server.unixtime;\n ts = sdscatfmt(sdsempty(), \"#TS:%I\\r\\n\", server.aof_cur_timestamp);\n serverAssert(sdslen(ts) <= AOF_ANNOTATION_LINE_MAX_LEN);\n }\n return ts;\n}\n\n/* Write the given command to the aof file.\n * dictid - dictionary id the command should be applied to,\n * this is used in order to decide if a `select` command\n * should also be written to the aof. Value of -1 means\n * to avoid writing `select` command in any case.\n * argv - The command to write to the aof.\n * argc - Number of values in argv\n */\nvoid feedAppendOnlyFile(int dictid, robj **argv, int argc) {\n sds buf = sdsempty();\n\n serverAssert(dictid == -1 || (dictid >= 0 && dictid < server.dbnum));\n\n /* Feed timestamp if needed */\n if (server.aof_timestamp_enabled) {\n sds ts = genAofTimestampAnnotationIfNeeded(0);\n if (ts != NULL) {\n buf = sdscatsds(buf, ts);\n sdsfree(ts);\n }\n }\n\n /* The DB this command was targeting is not the same as the last command\n * we appended. To issue a SELECT command is needed. */\n if (dictid != -1 && dictid != server.aof_selected_db) {\n char seldb[64];\n\n snprintf(seldb,sizeof(seldb),\"%d\",dictid);\n buf = sdscatprintf(buf,\"*2\\r\\n$6\\r\\nSELECT\\r\\n$%lu\\r\\n%s\\r\\n\",\n (unsigned long)strlen(seldb),seldb);\n server.aof_selected_db = dictid;\n }\n\n /* All commands should be propagated the same way in AOF as in replication.\n * No need for AOF-specific translation. */\n buf = catAppendOnlyGenericCommand(buf,argc,argv);\n\n /* Append to the AOF buffer. This will be flushed on disk just before\n * of re-entering the event loop, so before the client will get a\n * positive reply about the operation performed. */\n if (server.aof_state == AOF_ON ||\n (server.aof_state == AOF_WAIT_REWRITE && server.child_type == CHILD_TYPE_AOF))\n {\n server.aof_buf = sdscatlen(server.aof_buf, buf, sdslen(buf));\n }\n\n sdsfree(buf);\n}\n\n/* ----------------------------------------------------------------------------\n * AOF loading\n * ------------------------------------------------------------------------- */\n\n/* In Redis commands are always executed in the context of a client, so in\n * order to load the append only file we need to create a fake client. */\nstruct client *createAOFClient(void) {\n struct client *c = createClient(NULL);\n\n c->id = CLIENT_ID_AOF; /* So modules can identify it's the AOF client. */\n\n /*\n * The AOF client should never be blocked (unlike master\n * replication connection).\n * This is because blocking the AOF client might cause\n * deadlock (because potentially no one will unblock it).\n * Also, if the AOF client will be blocked just for\n * background processing there is a chance that the\n * command execution order will be violated.\n */\n c->flags = CLIENT_DENY_BLOCKING;\n\n /* We set the fake client as a slave waiting for the synchronization\n * so that Redis will not try to send replies to this client. */\n c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;\n return c;\n}\n\nstatic int truncateAppendOnlyFile(char *filename, off_t valid_up_to) {\n if (valid_up_to == -1) {\n serverLog(LL_WARNING,\"Last valid command offset is invalid\");\n return 0;\n }\n\n if (truncate(filename, valid_up_to) == -1) {\n serverLog(LL_WARNING,\"Error truncating the AOF file %s: %s\",\n filename, strerror(errno));\n return 0;\n }\n\n /* Make sure the AOF file descriptor points to the end of the\n * file after the truncate call. */\n if (server.aof_fd != -1 && lseek(server.aof_fd, 0, SEEK_END) == -1) {\n serverLog(LL_WARNING,\"Can't seek the end of the AOF file %s: %s\",\n filename, strerror(errno));\n return 0;\n }\n\n return 1; /* Success */\n}\n\n/* Replay an append log file. On success AOF_OK or AOF_TRUNCATED is returned,\n * otherwise, one of the following is returned:\n * AOF_OPEN_ERR: Failed to open the AOF file.\n * AOF_NOT_EXIST: AOF file doesn't exist.\n * AOF_EMPTY: The AOF file is empty (nothing to load).\n * AOF_FAILED: Failed to load the AOF file. */\nint loadSingleAppendOnlyFile(char *filename) {\n struct client *fakeClient;\n struct redis_stat sb;\n int old_aof_state = server.aof_state;\n long loops = 0;\n off_t valid_up_to = 0; /* Offset of latest well-formed command loaded. */\n off_t valid_before_multi = 0; /* Offset before MULTI command loaded. */\n off_t last_progress_report_size = 0;\n int ret = AOF_OK;\n\n sds aof_filepath = makePath(server.aof_dirname, filename);\n FILE *fp = fopen(aof_filepath, \"r\");\n if (fp == NULL) {\n int en = errno;\n if (redis_stat(aof_filepath, &sb) == 0 || errno != ENOENT) {\n serverLog(LL_WARNING,\"Fatal error: can't open the append log file %s for reading: %s\", filename, strerror(en));\n sdsfree(aof_filepath);\n return AOF_OPEN_ERR;\n } else {\n serverLog(LL_WARNING,\"The append log file %s doesn't exist: %s\", filename, strerror(errno));\n sdsfree(aof_filepath);\n return AOF_NOT_EXIST;\n }\n }\n\n if (fp && redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) {\n fclose(fp);\n sdsfree(aof_filepath);\n return AOF_EMPTY;\n }\n\n /* Temporarily disable AOF, to prevent EXEC from feeding a MULTI\n * to the same file we're about to read. */\n server.aof_state = AOF_OFF;\n\n client *old_cur_client = server.current_client;\n client *old_exec_client = server.executing_client;\n fakeClient = createAOFClient();\n server.current_client = server.executing_client = fakeClient;\n\n /* Check if the AOF file is in RDB format (it may be RDB encoded base AOF\n * or old style RDB-preamble AOF). In that case we need to load the RDB file \n * and later continue loading the AOF tail if it is an old style RDB-preamble AOF. */\n char sig[5]; /* \"REDIS\" */\n if (fread(sig,1,5,fp) != 5 || memcmp(sig,\"REDIS\",5) != 0) {\n /* Not in RDB format, seek back at 0 offset. */\n if (fseek(fp,0,SEEK_SET) == -1) goto readerr;\n } else {\n /* RDB format. Pass loading the RDB functions. */\n rio rdb;\n int old_style = !strcmp(filename, server.aof_filename);\n if (old_style)\n serverLog(LL_NOTICE, \"Reading RDB preamble from AOF file...\");\n else \n serverLog(LL_NOTICE, \"Reading RDB base file on AOF loading...\"); \n\n if (fseek(fp,0,SEEK_SET) == -1) goto readerr;\n rioInitWithFile(&rdb,fp);\n if (rdbLoadRio(&rdb,RDBFLAGS_AOF_PREAMBLE,NULL) != C_OK) {\n if (old_style)\n serverLog(LL_WARNING, \"Error reading the RDB preamble of the AOF file %s, AOF loading aborted\", filename);\n else\n serverLog(LL_WARNING, \"Error reading the RDB base file %s, AOF loading aborted\", filename);\n\n ret = AOF_FAILED;\n goto cleanup;\n } else {\n loadingAbsProgress(ftello(fp));\n last_progress_report_size = ftello(fp);\n if (old_style) serverLog(LL_NOTICE, \"Reading the remaining AOF tail...\");\n }\n }\n\n /* Read the actual AOF file, in REPL format, command by command. */\n while(1) {\n int argc, j;\n unsigned long len;\n robj **argv;\n char buf[AOF_ANNOTATION_LINE_MAX_LEN];\n sds argsds;\n struct redisCommand *cmd;\n\n /* Serve the clients from time to time */\n if (!(loops++ % 1024)) {\n off_t progress_delta = ftello(fp) - last_progress_report_size;\n loadingIncrProgress(progress_delta);\n last_progress_report_size += progress_delta;\n processEventsWhileBlocked();\n processModuleLoadingProgressEvent(1);\n }\n if (fgets(buf,sizeof(buf),fp) == NULL) {\n if (feof(fp)) {\n break;\n } else {\n goto readerr;\n }\n }\n if (buf[0] == '#') continue; /* Skip annotations */\n if (buf[0] != '*') goto fmterr;\n if (buf[1] == '\\0') goto readerr;\n argc = atoi(buf+1);\n if (argc < 1) goto fmterr;\n if ((size_t)argc > SIZE_MAX / sizeof(robj*)) goto fmterr;\n\n /* Load the next command in the AOF as our fake client\n * argv. */\n argv = zmalloc(sizeof(robj*)*argc);\n fakeClient->argc = argc;\n fakeClient->argv = argv;\n fakeClient->argv_len = argc;\n\n for (j = 0; j < argc; j++) {\n /* Parse the argument len. */\n char *readres = fgets(buf,sizeof(buf),fp);\n if (readres == NULL || buf[0] != '$') {\n fakeClient->argc = j; /* Free up to j-1. */\n freeClientArgv(fakeClient);\n if (readres == NULL)\n goto readerr;\n else\n goto fmterr;\n }\n len = strtol(buf+1,NULL,10);\n\n /* Read it into a string object. */\n argsds = sdsnewlen(SDS_NOINIT,len);\n if (len && fread(argsds,len,1,fp) == 0) {\n sdsfree(argsds);\n fakeClient->argc = j; /* Free up to j-1. */\n freeClientArgv(fakeClient);\n goto readerr;\n }\n argv[j] = createObject(OBJ_STRING,argsds);\n\n /* Discard CRLF. */\n if (fread(buf,2,1,fp) == 0) {\n fakeClient->argc = j+1; /* Free up to j. */\n freeClientArgv(fakeClient);\n goto readerr;\n }\n }\n\n /* Command lookup */\n cmd = lookupCommand(argv,argc);\n if (!cmd) {\n serverLog(LL_WARNING,\n \"Unknown command '%s' reading the append only file %s\",\n (char*)argv[0]->ptr, filename);\n freeClientArgv(fakeClient);\n ret = AOF_FAILED;\n goto cleanup;\n }\n\n if (cmd->proc == multiCommand) valid_before_multi = valid_up_to;\n\n /* Run the command in the context of a fake client */\n fakeClient->cmd = fakeClient->lastcmd = cmd;\n if (fakeClient->flags & CLIENT_MULTI &&\n fakeClient->cmd->proc != execCommand)\n {\n /* queueMultiCommand requires a pendingCommand, so we create a \"fake\" one here\n * for it to consume */\n pendingCommand *pcmd = zmalloc(sizeof(pendingCommand));\n initPendingCommand(pcmd);\n addPendingCommand(&fakeClient->pending_cmds, pcmd);\n\n pcmd->argc = argc;\n pcmd->argv_len = argc;\n pcmd->argv = argv;\n pcmd->cmd = cmd;\n\n /* Note: we don't have to attempt calling evalGetCommandFlags,\n * since this is AOF, the checks in processCommand are not made\n * anyway.*/\n queueMultiCommand(fakeClient, cmd->flags);\n } else {\n cmd->proc(fakeClient);\n fakeClient->all_argv_len_sum = 0; /* Otherwise no one cleans this up and we reach cleanup with it non-zero */\n }\n\n /* The fake client should not have a reply */\n serverAssert(fakeClient->bufpos == 0 &&\n listLength(fakeClient->reply) == 0);\n\n /* The fake client should never get blocked */\n serverAssert((fakeClient->flags & CLIENT_BLOCKED) == 0);\n\n /* Clean up. Command code may have changed argv/argc so we use the\n * argv/argc of the client instead of the local variables. */\n freeClientArgv(fakeClient);\n if (server.aof_load_truncated || server.aof_load_corrupt_tail_max_size) valid_up_to = ftello(fp);\n if (server.key_load_delay)\n debugDelay(server.key_load_delay);\n }\n\n /* This point can only be reached when EOF is reached without errors.\n * If the client is in the middle of a MULTI/EXEC, handle it as it was\n * a short read, even if technically the protocol is correct: we want\n * to remove the unprocessed tail and continue. */\n if (fakeClient->flags & CLIENT_MULTI) {\n serverLog(LL_WARNING,\n \"Revert incomplete MULTI/EXEC transaction in AOF file %s\", filename);\n valid_up_to = valid_before_multi;\n goto uxeof;\n }\n\nloaded_ok: /* DB loaded, cleanup and return success (AOF_OK or AOF_TRUNCATED). */\n loadingIncrProgress(ftello(fp) - last_progress_report_size);\n server.aof_state = old_aof_state;\n goto cleanup;\n\nreaderr: /* Read error. If feof(fp) is true, fall through to unexpected EOF. */\n if (!feof(fp)) {\n serverLog(LL_WARNING,\"Unrecoverable error reading the append only file %s: %s\", filename, strerror(errno));\n ret = AOF_FAILED;\n goto cleanup;\n }\n\nuxeof: /* Unexpected AOF end of file. */\n if (server.aof_load_truncated) {\n serverLog(LL_WARNING,\"!!! Warning: short read while loading the AOF file %s!!!\", filename);\n serverLog(LL_WARNING,\"!!! Truncating the AOF %s at offset %llu !!!\",\n filename, (unsigned long long) valid_up_to);\n if (truncateAppendOnlyFile(aof_filepath, valid_up_to)) {\n serverLog(LL_WARNING, \"AOF %s loaded anyway because aof-load-truncated is enabled\", aof_filepath);\n ret = AOF_TRUNCATED;\n goto loaded_ok;\n }\n }\n serverLog(LL_WARNING, \"Unexpected end of file reading the append only file %s. You can: \"\n \"1) Make a backup of your AOF file, then use ./redis-check-aof --fix . \"\n \"2) Alternatively you can set the 'aof-load-truncated' configuration option to yes and restart the server.\", filename);\n ret = AOF_FAILED;\n goto cleanup;\n\nfmterr: /* Format error. */\n /* fmterr may be caused by accidentally machine shutdown, so if the broken tail\n * is less than a specified size, try to recover it automatically */\n if (server.aof_load_corrupt_tail_max_size && sb.st_size - valid_up_to < server.aof_load_corrupt_tail_max_size) {\n serverLog(LL_WARNING,\"!!! Warning: corrupt AOF file tail!!!\");\n serverLog(LL_WARNING,\"!!! Truncating the AOF %s at offset %llu (remaining %llu) !!!\",\n aof_filepath, (unsigned long long) valid_up_to, (unsigned long long) sb.st_size - valid_up_to);\n if (truncateAppendOnlyFile(aof_filepath, valid_up_to)) {\n serverLog(LL_WARNING, \"AOF %s loaded anyway because aof-load-corrupt-tail-max-size is enabled\", aof_filepath);\n ret = AOF_BROKEN_RECOVERED;\n goto loaded_ok;\n }\n }\n serverLog(LL_WARNING, \"Bad file format reading the append only file %s at offset %llu. \\\n make a backup of your AOF file, then use ./redis-check-aof --fix . \\\n Alternatively you can set the 'aof-load-corrupt-tail-max-size' configuration option to %llu and restart the server.\",\n aof_filepath, (unsigned long long)valid_up_to, (unsigned long long) sb.st_size - valid_up_to);\n ret = AOF_FAILED;\n /* fall through to cleanup. */\n\ncleanup:\n if (fakeClient) freeClient(fakeClient);\n server.current_client = old_cur_client;\n server.executing_client = old_exec_client;\n int fd = dup(fileno(fp));\n fclose(fp);\n /* Reclaim page cache memory used by the AOF file in background. */\n if (fd >= 0) bioCreateCloseJob(fd, 0, 1);\n sdsfree(aof_filepath);\n return ret;\n}\n\n/* Load the AOF files according the aofManifest pointed by am. */\nint loadAppendOnlyFiles(aofManifest *am) {\n serverAssert(am != NULL);\n int status, ret = AOF_OK;\n long long start;\n off_t total_size = 0, base_size = 0;\n sds aof_name;\n int total_num, aof_num = 0, last_file;\n\n /* If the 'server.aof_filename' file exists in dir, we may be starting\n * from an old redis version. We will use enter upgrade mode in three situations.\n *\n * 1. If the 'server.aof_dirname' directory not exist\n * 2. If the 'server.aof_dirname' directory exists but the manifest file is missing\n * 3. If the 'server.aof_dirname' directory exists and the manifest file it contains\n * has only one base AOF record, and the file name of this base AOF is 'server.aof_filename',\n * and the 'server.aof_filename' file not exist in 'server.aof_dirname' directory\n * */\n if (fileExist(server.aof_filename)) {\n if (!dirExists(server.aof_dirname) ||\n (am->base_aof_info == NULL && listLength(am->incr_aof_list) == 0) ||\n (am->base_aof_info != NULL && listLength(am->incr_aof_list) == 0 &&\n !strcmp(am->base_aof_info->file_name, server.aof_filename) && !aofFileExist(server.aof_filename)))\n {\n aofUpgradePrepare(am);\n }\n }\n\n if (am->base_aof_info == NULL && listLength(am->incr_aof_list) == 0) {\n return AOF_NOT_EXIST;\n }\n\n total_num = getBaseAndIncrAppendOnlyFilesNum(am);\n serverAssert(total_num > 0);\n\n /* Here we calculate the total size of all BASE and INCR files in\n * advance, it will be set to `server.loading_total_bytes`. */\n total_size = getBaseAndIncrAppendOnlyFilesSize(am, &status);\n if (status != AOF_OK) {\n /* If an AOF exists in the manifest but not on the disk, we consider this to be a fatal error. */\n if (status == AOF_NOT_EXIST) status = AOF_FAILED;\n\n return status;\n } else if (total_size == 0) {\n return AOF_EMPTY;\n }\n\n startLoading(total_size, RDBFLAGS_AOF_PREAMBLE, 0);\n\n /* Load BASE AOF if needed. */\n if (am->base_aof_info) {\n serverAssert(am->base_aof_info->file_type == AOF_FILE_TYPE_BASE);\n aof_name = (char*)am->base_aof_info->file_name;\n updateLoadingFileName(aof_name);\n base_size = getAppendOnlyFileSize(aof_name, NULL);\n last_file = ++aof_num == total_num;\n start = ustime();\n ret = loadSingleAppendOnlyFile(aof_name);\n if (ret == AOF_OK || ((ret == AOF_TRUNCATED || ret == AOF_BROKEN_RECOVERED) && last_file)) {\n serverLog(LL_NOTICE, \"DB loaded from base file %s: %.3f seconds\",\n aof_name, (float)(ustime()-start)/1000000);\n }\n\n /* If the truncated file is not the last file, we consider this to be a fatal error. */\n if ((ret == AOF_TRUNCATED || ret == AOF_BROKEN_RECOVERED) && !last_file) {\n ret = AOF_FAILED;\n serverLog(LL_WARNING, \"Fatal error: the truncated file is not the last file\");\n }\n\n if (ret == AOF_OPEN_ERR || ret == AOF_FAILED) {\n goto cleanup;\n }\n }\n\n /* Load INCR AOFs if needed. */\n if (listLength(am->incr_aof_list)) {\n listNode *ln;\n listIter li;\n\n listRewind(am->incr_aof_list, &li);\n while ((ln = listNext(&li)) != NULL) {\n aofInfo *ai = (aofInfo*)ln->value;\n serverAssert(ai->file_type == AOF_FILE_TYPE_INCR);\n aof_name = (char*)ai->file_name;\n updateLoadingFileName(aof_name);\n last_file = ++aof_num == total_num;\n start = ustime();\n ret = loadSingleAppendOnlyFile(aof_name);\n if (ret == AOF_OK || ((ret == AOF_TRUNCATED || ret == AOF_BROKEN_RECOVERED) && last_file)) {\n serverLog(LL_NOTICE, \"DB loaded from incr file %s: %.3f seconds\",\n aof_name, (float)(ustime()-start)/1000000);\n }\n\n /* We know that (at least) one of the AOF files has data (total_size > 0),\n * so empty incr AOF file doesn't count as a AOF_EMPTY result */\n if (ret == AOF_EMPTY) ret = AOF_OK;\n\n /* If the truncated file is not the last file, we consider this to be a fatal error. */\n if ((ret == AOF_TRUNCATED || ret == AOF_BROKEN_RECOVERED) && !last_file) {\n ret = AOF_FAILED;\n serverLog(LL_WARNING, \"Fatal error: the truncated file is not the last file\");\n }\n\n if (ret == AOF_OPEN_ERR || ret == AOF_FAILED) {\n goto cleanup;\n }\n }\n }\n\n server.aof_current_size = total_size;\n /* Ideally, the aof_rewrite_base_size variable should hold the size of the\n * AOF when the last rewrite ended, this should include the size of the\n * incremental file that was created during the rewrite since otherwise we\n * risk the next automatic rewrite to happen too soon (or immediately if\n * auto-aof-rewrite-percentage is low). However, since we do not persist\n * aof_rewrite_base_size information anywhere, we initialize it on restart\n * to the size of BASE AOF file. This might cause the first AOFRW to be\n * executed early, but that shouldn't be a problem since everything will be\n * fine after the first AOFRW. */\n server.aof_rewrite_base_size = base_size;\n\ncleanup:\n stopLoading(ret == AOF_OK || ret == AOF_TRUNCATED);\n return ret;\n}\n\n/* ----------------------------------------------------------------------------\n * AOF rewrite\n * ------------------------------------------------------------------------- */\n\n/* Delegate writing an object to writing a bulk string or bulk long long.\n * This is not placed in rio.c since that adds the server.h dependency. */\nint rioWriteBulkObject(rio *r, robj *obj) {\n /* Avoid using getDecodedObject to help copy-on-write (we are often\n * in a child process when this function is called). */\n if (obj->encoding == OBJ_ENCODING_INT) {\n return rioWriteBulkLongLong(r,(long)obj->ptr);\n } else if (sdsEncodedObject(obj)) {\n return rioWriteBulkString(r,obj->ptr,sdslen(obj->ptr));\n } else {\n serverPanic(\"Unknown string encoding\");\n }\n}\n\n/* Emit the commands needed to rebuild a list object.\n * The function returns 0 on error, 1 on success. */\nint rewriteListObject(rio *r, robj *key, robj *o) {\n long long count = 0, items = listTypeLength(o);\n\n listTypeIterator li;\n listTypeEntry entry;\n listTypeInitIterator(&li, o, 0, LIST_TAIL);\n while (listTypeNext(&li, &entry)) {\n if (count == 0) {\n int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?\n AOF_REWRITE_ITEMS_PER_CMD : items;\n if (!rioWriteBulkCount(r,'*',2+cmd_items) ||\n !rioWriteBulkString(r,\"RPUSH\",5) ||\n !rioWriteBulkObject(r,key)) \n {\n listTypeResetIterator(&li);\n return 0;\n }\n }\n\n unsigned char *vstr;\n size_t vlen;\n long long lval;\n vstr = listTypeGetValue(&entry,&vlen,&lval);\n if (vstr) {\n if (!rioWriteBulkString(r,(char*)vstr,vlen)) {\n listTypeResetIterator(&li);\n return 0;\n }\n } else {\n if (!rioWriteBulkLongLong(r,lval)) {\n listTypeResetIterator(&li);\n return 0;\n }\n }\n if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;\n items--;\n }\n listTypeResetIterator(&li);\n return 1;\n}\n\n/* Emit the commands needed to rebuild a set object.\n * The function returns 0 on error, 1 on success. */\nint rewriteSetObject(rio *r, robj *key, robj *o) {\n long long count = 0, items = setTypeSize(o);\n setTypeIterator si;\n char *str;\n size_t len;\n int64_t llval;\n setTypeInitIterator(&si, o);\n while (setTypeNext(&si, &str, &len, &llval) != -1) {\n if (count == 0) {\n int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?\n AOF_REWRITE_ITEMS_PER_CMD : items;\n if (!rioWriteBulkCount(r,'*',2+cmd_items) ||\n !rioWriteBulkString(r,\"SADD\",4) ||\n !rioWriteBulkObject(r,key))\n {\n setTypeResetIterator(&si);\n return 0;\n }\n }\n size_t written = str ?\n rioWriteBulkString(r, str, len) : rioWriteBulkLongLong(r, llval);\n if (!written) {\n setTypeResetIterator(&si);\n return 0;\n }\n if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;\n items--;\n }\n setTypeResetIterator(&si);\n return 1;\n}\n\n/* Emit the commands needed to rebuild a sorted set object.\n * The function returns 0 on error, 1 on success. */\nint rewriteSortedSetObject(rio *r, robj *key, robj *o) {\n long long count = 0, items = zsetLength(o);\n\n if (o->encoding == OBJ_ENCODING_LISTPACK) {\n unsigned char *zl = o->ptr;\n unsigned char *eptr, *sptr;\n unsigned char *vstr;\n unsigned int vlen;\n long long vll;\n double score;\n\n eptr = lpSeek(zl,0);\n serverAssert(eptr != NULL);\n sptr = lpNext(zl,eptr);\n serverAssert(sptr != NULL);\n\n while (eptr != NULL) {\n vstr = lpGetValue(eptr,&vlen,&vll);\n score = zzlGetScore(sptr);\n\n if (count == 0) {\n int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?\n AOF_REWRITE_ITEMS_PER_CMD : items;\n\n if (!rioWriteBulkCount(r,'*',2+cmd_items*2) ||\n !rioWriteBulkString(r,\"ZADD\",4) ||\n !rioWriteBulkObject(r,key)) \n {\n return 0;\n }\n }\n if (!rioWriteBulkDouble(r,score)) return 0;\n if (vstr != NULL) {\n if (!rioWriteBulkString(r,(char*)vstr,vlen)) return 0;\n } else {\n if (!rioWriteBulkLongLong(r,vll)) return 0;\n }\n zzlNext(zl,&eptr,&sptr);\n if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;\n items--;\n }\n } else if (o->encoding == OBJ_ENCODING_SKIPLIST) {\n zset *zs = o->ptr;\n dictIterator di;\n dictEntry *de;\n\n dictInitIterator(&di, zs->dict);\n while((de = dictNext(&di)) != NULL) {\n zskiplistNode *znode = dictGetKey(de);\n sds ele = zslGetNodeElement(znode);\n double score = znode->score;\n\n if (count == 0) {\n int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?\n AOF_REWRITE_ITEMS_PER_CMD : items;\n\n if (!rioWriteBulkCount(r,'*',2+cmd_items*2) ||\n !rioWriteBulkString(r,\"ZADD\",4) ||\n !rioWriteBulkObject(r,key)) \n {\n dictResetIterator(&di);\n return 0;\n }\n }\n if (!rioWriteBulkDouble(r,score) ||\n !rioWriteBulkString(r,ele,sdslen(ele)))\n {\n dictResetIterator(&di);\n return 0;\n }\n if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;\n items--;\n }\n dictResetIterator(&di);\n } else {\n serverPanic(\"Unknown sorted zset encoding\");\n }\n return 1;\n}\n\n/* Write either the key or the value of the currently selected item of a hash.\n * The 'hi' argument passes a valid Redis hash iterator.\n * The 'what' filed specifies if to write a key or a value and can be\n * either OBJ_HASH_KEY or OBJ_HASH_VALUE.\n *\n * The function returns 0 on error, non-zero on success. */\nstatic int rioWriteHashIteratorCursor(rio *r, hashTypeIterator *hi, int what) {\n if ((hi->encoding == OBJ_ENCODING_LISTPACK) || (hi->encoding == OBJ_ENCODING_LISTPACK_EX)) {\n unsigned char *vstr = NULL;\n unsigned int vlen = UINT_MAX;\n long long vll = LLONG_MAX;\n\n hashTypeCurrentFromListpack(hi, what, &vstr, &vlen, &vll, NULL);\n if (vstr)\n return rioWriteBulkString(r, (char*)vstr, vlen);\n else\n return rioWriteBulkLongLong(r, vll);\n } else if (hi->encoding == OBJ_ENCODING_HT) {\n char *str;\n size_t len;\n hashTypeCurrentFromHashTable(hi, what, &str, &len, NULL);\n return rioWriteBulkString(r, str, len);\n }\n\n serverPanic(\"Unknown hash encoding\");\n return 0;\n}\n\n/* Emit the commands needed to rebuild a hash object.\n * The function returns 0 on error, 1 on success. */\nint rewriteHashObject(rio *r, robj *key, robj *o) {\n int res = 0; /*fail*/\n\n hashTypeIterator hi;\n long long count = 0, items = hashTypeLength(o, 0);\n\n int isHFE = hashTypeGetMinExpire(o, 0) != EB_EXPIRE_TIME_INVALID;\n hashTypeInitIterator(&hi, o);\n\n if (!isHFE) {\n while (hashTypeNext(&hi, 0) != C_ERR) {\n if (count == 0) {\n int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?\n AOF_REWRITE_ITEMS_PER_CMD : items;\n if (!rioWriteBulkCount(r, '*', 2 + cmd_items * 2) ||\n !rioWriteBulkString(r, \"HMSET\", 5) ||\n !rioWriteBulkObject(r, key))\n goto reHashEnd;\n }\n\n if (!rioWriteHashIteratorCursor(r, &hi, OBJ_HASH_KEY) ||\n !rioWriteHashIteratorCursor(r, &hi, OBJ_HASH_VALUE))\n goto reHashEnd;\n\n if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;\n items--;\n }\n } else {\n while (hashTypeNext(&hi, 0) != C_ERR) {\n\n char hmsetCmd[] = \"*4\\r\\n$5\\r\\nHMSET\\r\\n\";\n if ( (!rioWrite(r, hmsetCmd, sizeof(hmsetCmd) - 1)) ||\n (!rioWriteBulkObject(r, key)) ||\n (!rioWriteHashIteratorCursor(r, &hi, OBJ_HASH_KEY)) ||\n (!rioWriteHashIteratorCursor(r, &hi, OBJ_HASH_VALUE)) )\n goto reHashEnd;\n\n if (hi.expire_time != EB_EXPIRE_TIME_INVALID) {\n char cmd[] = \"*6\\r\\n$10\\r\\nHPEXPIREAT\\r\\n\";\n if ( (!rioWrite(r, cmd, sizeof(cmd) - 1)) ||\n (!rioWriteBulkObject(r, key)) ||\n (!rioWriteBulkLongLong(r, hi.expire_time)) ||\n (!rioWriteBulkString(r, \"FIELDS\", 6)) ||\n (!rioWriteBulkString(r, \"1\", 1)) ||\n (!rioWriteHashIteratorCursor(r, &hi, OBJ_HASH_KEY)) )\n goto reHashEnd;\n }\n }\n }\n\n res = 1; /* success */\n\nreHashEnd:\n hashTypeResetIterator(&hi);\n return res;\n}\n\n/* Helper for rewriteStreamObject() that generates a bulk string into the\n * AOF representing the ID 'id'. */\nint rioWriteBulkStreamID(rio *r,streamID *id) {\n int retval;\n\n sds replyid = sdscatfmt(sdsempty(),\"%U-%U\",id->ms,id->seq);\n retval = rioWriteBulkString(r,replyid,sdslen(replyid));\n sdsfree(replyid);\n return retval;\n}\n\n/* Helper for rewriteStreamObject(): emit the XCLAIM needed in order to\n * add the message described by 'nack' having the id 'rawid', into the pending\n * list of the specified consumer. All this in the context of the specified\n * key and group. */\nint rioWriteStreamPendingEntry(rio *r, robj *key, const char *groupname, size_t groupname_len, streamConsumer *consumer, unsigned char *rawid, streamNACK *nack) {\n /* XCLAIM 0 TIME \n RETRYCOUNT JUSTID FORCE. */\n streamID id;\n streamDecodeID(rawid,&id);\n if (rioWriteBulkCount(r,'*',12) == 0) return 0;\n if (rioWriteBulkString(r,\"XCLAIM\",6) == 0) return 0;\n if (rioWriteBulkObject(r,key) == 0) return 0;\n if (rioWriteBulkString(r,groupname,groupname_len) == 0) return 0;\n if (rioWriteBulkString(r,consumer->name,sdslen(consumer->name)) == 0) return 0;\n if (rioWriteBulkString(r,\"0\",1) == 0) return 0;\n if (rioWriteBulkStreamID(r,&id) == 0) return 0;\n if (rioWriteBulkString(r,\"TIME\",4) == 0) return 0;\n if (rioWriteBulkLongLong(r,nack->delivery_time) == 0) return 0;\n if (rioWriteBulkString(r,\"RETRYCOUNT\",10) == 0) return 0;\n if (rioWriteBulkLongLong(r,nack->delivery_count) == 0) return 0;\n if (rioWriteBulkString(r,\"JUSTID\",6) == 0) return 0;\n if (rioWriteBulkString(r,\"FORCE\",5) == 0) return 0;\n return 1;\n}\n\n/* Helper for rewriteStreamObject(): emit a single XNACK FORCE command that\n * reconstructs one or more NACKed (unowned) PEL entries sharing the same\n * delivery_count. `ids` points to an array of `count` streamIDs (at most\n * AOF_REWRITE_ITEMS_PER_CMD). Returns 0 on error, 1 on success. */\nint rioWriteStreamNackedEntries(rio *r, robj *key, const char *groupname,\n size_t groupname_len, streamID *ids,\n int count, uint64_t delivery_count) {\n serverAssert(count > 0 && count <= AOF_REWRITE_ITEMS_PER_CMD);\n\n /* XNACK FAIL IDS RETRYCOUNT FORCE\n * 6 fixed tokens before IDs + count IDs + 3 fixed tokens after. */\n if (rioWriteBulkCount(r,'*',6+count+3) == 0) return 0;\n if (rioWriteBulkString(r,\"XNACK\",5) == 0) return 0;\n if (rioWriteBulkObject(r,key) == 0) return 0;\n if (rioWriteBulkString(r,groupname,groupname_len) == 0) return 0;\n if (rioWriteBulkString(r,\"FAIL\",4) == 0) return 0;\n if (rioWriteBulkString(r,\"IDS\",3) == 0) return 0;\n if (rioWriteBulkLongLong(r,count) == 0) return 0;\n\n for (int i = 0; i < count; i++) {\n if (rioWriteBulkStreamID(r,&ids[i]) == 0) return 0;\n }\n\n if (rioWriteBulkString(r,\"RETRYCOUNT\",10) == 0) return 0;\n if (rioWriteBulkLongLong(r,delivery_count) == 0) return 0;\n if (rioWriteBulkString(r,\"FORCE\",5) == 0) return 0;\n return 1;\n}\n\n/* Helper for rewriteStreamObject(): emit the XGROUP CREATECONSUMER is\n * needed in order to create consumers that do not have any pending entries.\n * All this in the context of the specified key and group. */\nint rioWriteStreamEmptyConsumer(rio *r, robj *key, const char *groupname, size_t groupname_len, streamConsumer *consumer) {\n /* XGROUP CREATECONSUMER */\n if (rioWriteBulkCount(r,'*',5) == 0) return 0;\n if (rioWriteBulkString(r,\"XGROUP\",6) == 0) return 0;\n if (rioWriteBulkString(r,\"CREATECONSUMER\",14) == 0) return 0;\n if (rioWriteBulkObject(r,key) == 0) return 0;\n if (rioWriteBulkString(r,groupname,groupname_len) == 0) return 0;\n if (rioWriteBulkString(r,consumer->name,sdslen(consumer->name)) == 0) return 0;\n return 1;\n}\n\n/* Helper for rewriteStreamObject(): emit the XIDMPRECORD needed to\n * restore an IDMP entry for the given producer in the context of the\n * specified key. */\nint rioWriteStreamIdmpEntry(rio *r, robj *key, const char *pid, size_t pid_len, idmpEntry *entry) {\n /* XIDMPRECORD */\n if (rioWriteBulkCount(r,'*',5) == 0) return 0;\n if (rioWriteBulkString(r,\"XIDMPRECORD\",11) == 0) return 0;\n if (rioWriteBulkObject(r,key) == 0) return 0;\n if (rioWriteBulkString(r,pid,pid_len) == 0) return 0;\n if (rioWriteBulkString(r,entry->iid,entry->iid_len) == 0) return 0;\n if (rioWriteBulkStreamID(r,&entry->id) == 0) return 0;\n return 1;\n}\n\n/* Emit the commands needed to rebuild a stream object.\n * The function returns 0 on error, 1 on success. */\nint rewriteStreamObject(rio *r, robj *key, robj *o) {\n stream *s = o->ptr;\n streamID id;\n\n if (s->length) {\n /* Reconstruct the stream data using XADD commands. */\n streamIterator si;\n int64_t numfields;\n streamIteratorStart(&si,s,NULL,NULL,0);\n while(streamIteratorGetID(&si,&id,&numfields)) {\n /* Emit a two elements array for each item. The first is\n * the ID, the second is an array of field-value pairs. */\n\n /* Emit the XADD ...fields... command. */\n if (!rioWriteBulkCount(r,'*',3+numfields*2) || \n !rioWriteBulkString(r,\"XADD\",4) ||\n !rioWriteBulkObject(r,key) ||\n !rioWriteBulkStreamID(r,&id)) \n {\n streamIteratorStop(&si);\n return 0;\n }\n while(numfields--) {\n unsigned char *field, *value;\n int64_t field_len, value_len;\n streamIteratorGetField(&si,&field,&value,&field_len,&value_len);\n if (!rioWriteBulkString(r,(char*)field,field_len) ||\n !rioWriteBulkString(r,(char*)value,value_len)) \n {\n streamIteratorStop(&si);\n return 0; \n }\n }\n }\n streamIteratorStop(&si);\n } else {\n /* Use the XADD MAXLEN 0 trick to generate an empty stream if\n * the key we are serializing is an empty string, which is possible\n * for the Stream type. */\n id.ms = 0; id.seq = 1; \n if (!rioWriteBulkCount(r,'*',7) ||\n !rioWriteBulkString(r,\"XADD\",4) ||\n !rioWriteBulkObject(r,key) ||\n !rioWriteBulkString(r,\"MAXLEN\",6) ||\n !rioWriteBulkString(r,\"0\",1) ||\n !rioWriteBulkStreamID(r,&id) ||\n !rioWriteBulkString(r,\"x\",1) ||\n !rioWriteBulkString(r,\"y\",1))\n {\n return 0; \n }\n }\n\n /* Append XSETID after XADD, make sure lastid is correct,\n * in case of XDEL lastid. */\n if (!rioWriteBulkCount(r,'*',7) ||\n !rioWriteBulkString(r,\"XSETID\",6) ||\n !rioWriteBulkObject(r,key) ||\n !rioWriteBulkStreamID(r,&s->last_id) ||\n !rioWriteBulkString(r,\"ENTRIESADDED\",12) ||\n !rioWriteBulkLongLong(r,s->entries_added) ||\n !rioWriteBulkString(r,\"MAXDELETEDID\",12) ||\n !rioWriteBulkStreamID(r,&s->max_deleted_entry_id)) \n {\n return 0; \n }\n\n /* Create all the stream consumer groups. */\n if (s->cgroups) {\n raxIterator ri;\n raxStart(&ri,s->cgroups);\n raxSeek(&ri,\"^\",NULL,0);\n while(raxNext(&ri)) {\n streamCG *group = ri.data;\n /* Emit the XGROUP CREATE in order to create the group. */\n if (!rioWriteBulkCount(r,'*',7) ||\n !rioWriteBulkString(r,\"XGROUP\",6) ||\n !rioWriteBulkString(r,\"CREATE\",6) ||\n !rioWriteBulkObject(r,key) ||\n !rioWriteBulkString(r,(char*)ri.key,ri.key_len) ||\n !rioWriteBulkStreamID(r,&group->last_id) ||\n !rioWriteBulkString(r,\"ENTRIESREAD\",11) ||\n !rioWriteBulkLongLong(r,group->entries_read))\n {\n raxStop(&ri);\n return 0;\n }\n\n /* Generate XCLAIMs for each consumer that happens to\n * have pending entries. Empty consumers would be generated with\n * XGROUP CREATECONSUMER. */\n raxIterator ri_cons;\n raxStart(&ri_cons,group->consumers);\n raxSeek(&ri_cons,\"^\",NULL,0);\n while(raxNext(&ri_cons)) {\n streamConsumer *consumer = ri_cons.data;\n /* If there are no pending entries, just emit XGROUP CREATECONSUMER */\n if (raxSize(consumer->pel) == 0) {\n if (rioWriteStreamEmptyConsumer(r,key,(char*)ri.key,\n ri.key_len,consumer) == 0)\n {\n raxStop(&ri_cons);\n raxStop(&ri);\n return 0;\n }\n continue;\n }\n /* For the current consumer, iterate all the PEL entries\n * to emit the XCLAIM protocol. */\n raxIterator ri_pel;\n raxStart(&ri_pel,consumer->pel);\n raxSeek(&ri_pel,\"^\",NULL,0);\n while(raxNext(&ri_pel)) {\n streamNACK *nack = ri_pel.data;\n if (rioWriteStreamPendingEntry(r,key,(char*)ri.key,\n ri.key_len,consumer,\n ri_pel.key,nack) == 0)\n {\n raxStop(&ri_pel);\n raxStop(&ri_cons);\n raxStop(&ri);\n return 0;\n }\n }\n raxStop(&ri_pel);\n }\n raxStop(&ri_cons);\n\n /* Emit XNACK FORCE for NACKed (unowned) entries from the\n * NACK zone of the PEL time-ordered list\n * (pel_time_head..pel_nack_tail). Consecutive entries with\n * the same delivery_count are batched into a single command.\n *\n * nack_stop is the first node outside the NACK zone (or NULL\n * when the zone extends to the end of the PEL). When\n * pel_nack_tail is NULL (no NACKed entries) the guard below\n * skips the whole block. */\n streamNACK *nack_end = group->pel_nack_tail;\n if (nack_end != NULL) {\n streamID batch_ids[AOF_REWRITE_ITEMS_PER_CMD];\n streamNACK *nack_stop = nack_end->pel_next;\n streamNACK *nack = group->pel_time_head;\n int batch_count = 0;\n uint64_t batch_dc = 0;\n while (nack && nack != nack_stop) {\n if (batch_count == 0) batch_dc = nack->delivery_count;\n batch_ids[batch_count++] = nack->id;\n streamNACK *next = nack->pel_next;\n if (batch_count >= AOF_REWRITE_ITEMS_PER_CMD ||\n !next || next == nack_stop ||\n next->delivery_count != batch_dc)\n {\n if (rioWriteStreamNackedEntries(r,key,(char*)ri.key,\n ri.key_len,batch_ids,\n batch_count,batch_dc) == 0)\n {\n raxStop(&ri);\n return 0;\n }\n batch_count = 0;\n }\n nack = next;\n }\n }\n }\n raxStop(&ri);\n }\n\n /* Emit XCFGSET to restore per-stream IDMP configuration if it differs\n * from the server defaults, so that AOF rewrite preserves custom settings. */\n if (s->idmp_duration != (uint64_t)server.stream_idmp_duration ||\n s->idmp_max_entries != (uint64_t)server.stream_idmp_maxsize)\n {\n if (!rioWriteBulkCount(r,'*',6) ||\n !rioWriteBulkString(r,\"XCFGSET\",7) ||\n !rioWriteBulkObject(r,key) ||\n !rioWriteBulkString(r,\"IDMP-DURATION\",13) ||\n !rioWriteBulkLongLong(r,s->idmp_duration) ||\n !rioWriteBulkString(r,\"IDMP-MAXSIZE\",12) ||\n !rioWriteBulkLongLong(r,s->idmp_max_entries))\n {\n return 0;\n }\n }\n\n /* Emit XIDMPRECORD for each IDMP entry. Entries whose stream ID no\n * longer exists (removed by XDEL/trim) are skipped, since\n * xidmprecordCommand() rejects references to missing IDs and would\n * cause AOF replay errors. */\n if (s->idmp_producers) {\n raxIterator ri_idmp;\n raxStart(&ri_idmp,s->idmp_producers);\n raxSeek(&ri_idmp,\"^\",NULL,0);\n while(raxNext(&ri_idmp)) {\n idmpProducer *producer = ri_idmp.data;\n for (idmpEntry *entry = producer->idmp_head; entry != NULL; entry = entry->next) {\n if (!streamEntryExists(s, &entry->id)) continue;\n if (rioWriteStreamIdmpEntry(r,key,(char*)ri_idmp.key,\n ri_idmp.key_len,entry) == 0)\n {\n raxStop(&ri_idmp);\n return 0;\n }\n }\n }\n raxStop(&ri_idmp);\n }\n\n return 1;\n}\n\nint rewriteGCRAObject(rio *r, robj *key, robj *o) {\n long long val;\n getLongLongFromGCRAObject(o, &val);\n\n /* GCRASETVALUE */\n if (rioWriteBulkCount(r,'*',3) == 0) return 0;\n if (rioWriteBulkString(r,\"GCRASETVALUE\",12) == 0) return 0;\n if (rioWriteBulkObject(r,key) == 0) return 0;\n if (rioWriteBulkLongLong(r,val) == 0) return 0;\n return 1;\n}\n\n/* Call the module type callback in order to rewrite a data type\n * that is exported by a module and is not handled by Redis itself.\n * The function returns 0 on error, 1 on success. */\nint rewriteModuleObject(rio *r, robj *key, robj *o, int dbid) {\n RedisModuleIO io;\n moduleValue *mv = o->ptr;\n moduleType *mt = mv->type;\n moduleInitIOContext(&io, &mt->entity, r, key, dbid);\n mt->aof_rewrite(&io,key,mv->value);\n if (io.ctx) {\n moduleFreeContext(io.ctx);\n zfree(io.ctx);\n }\n return io.error ? 0 : 1;\n}\n\nstatic int rewriteFunctions(rio *aof) {\n dict *functions = functionsLibGet();\n dictIterator iter;\n dictEntry *entry = NULL;\n dictInitIterator(&iter, functions);\n while ((entry = dictNext(&iter))) {\n functionLibInfo *li = dictGetVal(entry);\n if (rioWrite(aof, \"*3\\r\\n\", 4) == 0) goto werr;\n char function_load[] = \"$8\\r\\nFUNCTION\\r\\n$4\\r\\nLOAD\\r\\n\";\n if (rioWrite(aof, function_load, sizeof(function_load) - 1) == 0) goto werr;\n if (rioWriteBulkString(aof, li->code, sdslen(li->code)) == 0) goto werr;\n }\n dictResetIterator(&iter);\n return 1;\n\nwerr:\n dictResetIterator(&iter);\n return 0;\n}\n\nint rewriteObject(rio *r, robj *key, robj *o, int dbid, long long expiretime) {\n /* Save the key and associated value */\n if (o->type == OBJ_STRING) {\n /* Emit a SET command */\n static const char cmd[]=\"*3\\r\\n$3\\r\\nSET\\r\\n\";\n if (rioWrite(r,cmd,sizeof(cmd)-1) == 0) return C_ERR;\n /* Key and value */\n if (rioWriteBulkObject(r,key) == 0) return C_ERR;\n if (rioWriteBulkObject(r,o) == 0) return C_ERR;\n } else if (o->type == OBJ_LIST) {\n if (rewriteListObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_SET) {\n if (rewriteSetObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_ZSET) {\n if (rewriteSortedSetObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_HASH) {\n if (rewriteHashObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_STREAM) {\n if (rewriteStreamObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_GCRA) {\n if (rewriteGCRAObject(r,key,o) == 0) return C_ERR;\n } else if (o->type == OBJ_MODULE) {\n if (rewriteModuleObject(r,key,o,dbid) == 0) return C_ERR;\n } else {\n serverPanic(\"Unknown object type\");\n }\n\n /* Save the expire time */\n if (expiretime != -1) {\n static const char cmd[]=\"*3\\r\\n$9\\r\\nPEXPIREAT\\r\\n\";\n if (rioWrite(r,cmd,sizeof(cmd)-1) == 0) return C_ERR;\n if (rioWriteBulkObject(r,key) == 0) return C_ERR;\n if (rioWriteBulkLongLong(r,expiretime) == 0) return C_ERR;\n }\n\n /* If modules metadata is available */\n if ((getModuleMetaBits(o->metabits)) && (keyMetaOnAof(r, key, o, dbid) == 0))\n return C_ERR;\n\n return C_OK;\n}\n\nint rewriteAppendOnlyFileRio(rio *aof) {\n dictEntry *de;\n int j;\n long key_count = 0;\n long long updated_time = 0;\n unsigned long long skipped = 0;\n kvstoreIterator kvs_it;\n\n /* Record timestamp at the beginning of rewriting AOF. */\n if (server.aof_timestamp_enabled) {\n sds ts = genAofTimestampAnnotationIfNeeded(1);\n if (rioWrite(aof,ts,sdslen(ts)) == 0) { sdsfree(ts); goto werr; }\n sdsfree(ts);\n }\n\n if (rewriteFunctions(aof) == 0) goto werr;\n\n for (j = 0; j < server.dbnum; j++) {\n char selectcmd[] = \"*2\\r\\n$6\\r\\nSELECT\\r\\n\";\n redisDb *db = server.db + j;\n if (kvstoreSize(db->keys) == 0) continue;\n\n /* SELECT the new DB */\n if (rioWrite(aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;\n if (rioWriteBulkLongLong(aof,j) == 0) goto werr;\n\n kvstoreIteratorInit(&kvs_it, db->keys);\n int last_slot = -1;\n /* Iterate this DB writing every entry */\n while((de = kvstoreIteratorNext(&kvs_it)) != NULL) {\n long long expiretime;\n size_t aof_bytes_before_key = aof->processed_bytes;\n int curr_slot = kvstoreIteratorGetCurrentDictIndex(&kvs_it);\n\n /* In cluster mode, dismiss bucket arrays of the previous slot\n * which won't be accessed again, to avoid CoW. */\n if (server.cluster_enabled && curr_slot != last_slot) {\n if (server.in_fork_child && last_slot != -1)\n dismissDictBucketsMemory(kvstoreGetDict(db->keys, last_slot));\n last_slot = curr_slot;\n }\n\n /* Get the value object (of type kvobj) */\n kvobj *o = dictGetKV(de);\n \n /* Get the expire time */\n expiretime = kvobjGetExpire(o);\n\n /* Skip keys that are being trimmed */\n if (server.cluster_enabled && isSlotInTrimJob(curr_slot)) {\n skipped++;\n continue;\n }\n \n /* Set on stack string object for key */\n robj key;\n initStaticStringObject(key, kvobjGetKey(o));\n\n if (rewriteObject(aof, &key, o, j, expiretime) == C_ERR) goto werr2;\n\n /* In fork child process, we can try to release memory back to the\n * OS and possibly avoid or decrease COW. We give the dismiss\n * mechanism a hint about an estimated size of the object we stored. */\n size_t dump_size = aof->processed_bytes - aof_bytes_before_key;\n if (server.in_fork_child && dump_size > server.page_size/2)\n dismissObject(o, dump_size);\n\n /* Update info every 1 second (approximately).\n * in order to avoid calling mstime() on each iteration, we will\n * check the diff every 1024 keys */\n if ((key_count++ & 1023) == 0) {\n long long now = mstime();\n if (now - updated_time >= 1000) {\n sendChildInfo(CHILD_INFO_TYPE_CURRENT_INFO, key_count, \"AOF rewrite\");\n updated_time = now;\n }\n }\n\n /* Delay before next key if required (for testing) */\n if (server.rdb_key_save_delay)\n debugDelay(server.rdb_key_save_delay);\n }\n kvstoreIteratorReset(&kvs_it);\n\n /* Dismiss bucket arrays of kvstore in standalone mode. */\n if (server.in_fork_child && !server.cluster_enabled)\n dismissKvstoreBucketsMemory(db->keys);\n }\n serverLog(LL_NOTICE, \"AOF rewrite done, %ld keys saved, %llu keys skipped.\", key_count, skipped);\n return C_OK;\n\nwerr2:\n kvstoreIteratorReset(&kvs_it);\nwerr:\n return C_ERR;\n}\n\n/* Write a sequence of commands able to fully rebuild the dataset into\n * \"filename\". Used both by REWRITEAOF and BGREWRITEAOF.\n *\n * In order to minimize the number of commands needed in the rewritten\n * log Redis uses variadic commands when possible, such as RPUSH, SADD\n * and ZADD. However at max AOF_REWRITE_ITEMS_PER_CMD items per time\n * are inserted using a single command. */\nint rewriteAppendOnlyFile(char *filename) {\n rio aof;\n FILE *fp = NULL;\n char tmpfile[256];\n\n /* Note that we have to use a different temp name here compared to the\n * one used by rewriteAppendOnlyFileBackground() function. */\n snprintf(tmpfile,256,\"temp-rewriteaof-%d.aof\", (int) getpid());\n fp = fopen(tmpfile,\"w\");\n if (!fp) {\n serverLog(LL_WARNING, \"Opening the temp file for AOF rewrite in rewriteAppendOnlyFile(): %s\", strerror(errno));\n return C_ERR;\n }\n\n rioInitWithFile(&aof,fp);\n\n if (server.aof_rewrite_incremental_fsync) {\n rioSetAutoSync(&aof,REDIS_AUTOSYNC_BYTES);\n rioSetReclaimCache(&aof,1);\n }\n\n startSaving(RDBFLAGS_AOF_PREAMBLE);\n\n if (server.aof_use_rdb_preamble) {\n int error;\n if (rdbSaveRio(SLAVE_REQ_NONE,&aof,&error,RDBFLAGS_AOF_PREAMBLE,NULL) == C_ERR) {\n errno = error;\n goto werr;\n }\n } else {\n if (rewriteAppendOnlyFileRio(&aof) == C_ERR) goto werr;\n }\n\n /* Make sure data will not remain on the OS's output buffers */\n if (fflush(fp)) goto werr;\n if (fsync(fileno(fp))) goto werr;\n if (reclaimFilePageCache(fileno(fp), 0, 0) == -1) {\n /* A minor error. Just log to know what happens */\n serverLog(LL_NOTICE,\"Unable to reclaim page cache: %s\", strerror(errno));\n }\n if (fclose(fp)) { fp = NULL; goto werr; }\n fp = NULL;\n\n /* Use RENAME to make sure the DB file is changed atomically only\n * if the generate DB file is ok. */\n if (rename(tmpfile,filename) == -1) {\n serverLog(LL_WARNING,\"Error moving temp append only file on the final destination: %s\", strerror(errno));\n unlink(tmpfile);\n stopSaving(0);\n return C_ERR;\n }\n stopSaving(1);\n\n return C_OK;\n\nwerr:\n serverLog(LL_WARNING,\"Write error writing append only file on disk: %s\", strerror(errno));\n if (fp) fclose(fp);\n unlink(tmpfile);\n stopSaving(0);\n return C_ERR;\n}\n/* ----------------------------------------------------------------------------\n * AOF background rewrite\n * ------------------------------------------------------------------------- */\n\n/* This is how rewriting of the append only file in background works:\n *\n * 1) The user calls BGREWRITEAOF\n * 2) Redis calls this function, that forks():\n * 2a) the child rewrite the append only file in a temp file.\n * 2b) the parent open a new INCR AOF file to continue writing.\n * 3) When the child finished '2a' exists.\n * 4) The parent will trap the exit code, if it's OK, it will:\n * 4a) get a new BASE file name and mark the previous (if we have) as the HISTORY type\n * 4b) rename(2) the temp file in new BASE file name\n * 4c) mark the rewritten INCR AOFs as history type\n * 4d) persist AOF manifest file\n * 4e) Delete the history files use bio\n */\nint rewriteAppendOnlyFileBackground(void) {\n pid_t childpid;\n\n if (hasActiveChildProcess()) return C_ERR;\n\n if (dirCreateIfMissing(server.aof_dirname) == -1) {\n serverLog(LL_WARNING, \"Can't open or create append-only dir %s: %s\",\n server.aof_dirname, strerror(errno));\n server.aof_lastbgrewrite_status = C_ERR;\n return C_ERR;\n }\n\n /* We set aof_selected_db to -1 in order to force the next call to the\n * feedAppendOnlyFile() to issue a SELECT command. */\n server.aof_selected_db = -1;\n flushAppendOnlyFile(1);\n if (openNewIncrAofForAppend() != C_OK) {\n server.aof_lastbgrewrite_status = C_ERR;\n return C_ERR;\n }\n\n if (server.aof_state == AOF_WAIT_REWRITE) {\n /* Wait for all bio jobs related to AOF to drain. This prevents a race\n * between updates to `fsynced_reploff_pending` of the worker thread, belonging\n * to the previous AOF, and the new one. This concern is specific for a full\n * sync scenario where we don't wanna risk the ACKed replication offset\n * jumping backwards or forward when switching to a different master. */\n bioDrainWorker(BIO_AOF_FSYNC);\n\n /* Set the initial repl_offset, which will be applied to fsynced_reploff\n * when AOFRW finishes (after possibly being updated by a bio thread) */\n atomicSet(server.fsynced_reploff_pending, server.master_repl_offset);\n server.fsynced_reploff = 0;\n }\n\n server.stat_aof_rewrites++;\n\n if ((childpid = redisFork(CHILD_TYPE_AOF)) == 0) {\n char tmpfile[256];\n\n /* Child */\n redisSetProcTitle(\"redis-aof-rewrite\");\n redisSetCpuAffinity(server.aof_rewrite_cpulist);\n snprintf(tmpfile,256,\"temp-rewriteaof-bg-%d.aof\", (int) getpid());\n if (rewriteAppendOnlyFile(tmpfile) == C_OK) {\n serverLog(LL_NOTICE,\n \"Successfully created the temporary AOF base file %s\", tmpfile);\n sendChildCowInfo(CHILD_INFO_TYPE_AOF_COW_SIZE, \"AOF rewrite\");\n exitFromChild(0, 0);\n } else {\n exitFromChild(1, 0);\n }\n } else {\n /* Parent */\n if (childpid == -1) {\n server.aof_lastbgrewrite_status = C_ERR;\n serverLog(LL_WARNING,\n \"Can't rewrite append only file in background: fork: %s\",\n strerror(errno));\n return C_ERR;\n }\n serverLog(LL_NOTICE,\n \"Background append only file rewriting started by pid %ld\",(long) childpid);\n server.aof_rewrite_scheduled = 0;\n server.aof_rewrite_time_start = time(NULL);\n return C_OK;\n }\n return C_OK; /* unreached */\n}\n\nvoid bgrewriteaofCommand(client *c) {\n if (server.child_type == CHILD_TYPE_AOF) {\n addReplyError(c,\"Background append only file rewriting already in progress\");\n } else if (hasActiveChildProcess() || server.in_exec) {\n server.aof_rewrite_scheduled = 1;\n /* When manually triggering AOFRW we reset the count \n * so that it can be executed immediately. */\n server.stat_aofrw_consecutive_failures = 0;\n addReplyStatus(c,\"Background append only file rewriting scheduled\");\n } else if (rewriteAppendOnlyFileBackground() == C_OK) {\n addReplyStatus(c,\"Background append only file rewriting started\");\n } else {\n addReplyError(c,\"Can't execute an AOF background rewriting. \"\n \"Please check the server logs for more information.\");\n }\n}\n\nvoid aofRemoveTempFile(pid_t childpid) {\n char tmpfile[256];\n\n snprintf(tmpfile,256,\"temp-rewriteaof-bg-%d.aof\", (int) childpid);\n bg_unlink(tmpfile);\n\n snprintf(tmpfile,256,\"temp-rewriteaof-%d.aof\", (int) childpid);\n bg_unlink(tmpfile);\n}\n\n/* Get size of an AOF file.\n * The status argument is an optional output argument to be filled with\n * one of the AOF_ status values. */\noff_t getAppendOnlyFileSize(sds filename, int *status) {\n struct redis_stat sb;\n off_t size;\n mstime_t latency;\n\n sds aof_filepath = makePath(server.aof_dirname, filename);\n latencyStartMonitor(latency);\n if (redis_stat(aof_filepath, &sb) == -1) {\n if (status) *status = errno == ENOENT ? AOF_NOT_EXIST : AOF_OPEN_ERR;\n serverLog(LL_WARNING, \"Unable to obtain the AOF file %s length. stat: %s\",\n filename, strerror(errno));\n size = 0;\n } else {\n if (status) *status = AOF_OK;\n size = sb.st_size;\n }\n latencyEndMonitor(latency);\n latencyAddSampleIfNeeded(\"aof-fstat\", latency);\n sdsfree(aof_filepath);\n return size;\n}\n\n/* Get size of all AOF files referred by the manifest (excluding history).\n * The status argument is an output argument to be filled with\n * one of the AOF_ status values. */\noff_t getBaseAndIncrAppendOnlyFilesSize(aofManifest *am, int *status) {\n off_t size = 0;\n listNode *ln;\n listIter li;\n\n if (am->base_aof_info) {\n serverAssert(am->base_aof_info->file_type == AOF_FILE_TYPE_BASE);\n\n size += getAppendOnlyFileSize(am->base_aof_info->file_name, status);\n if (*status != AOF_OK) return 0;\n }\n\n listRewind(am->incr_aof_list, &li);\n while ((ln = listNext(&li)) != NULL) {\n aofInfo *ai = (aofInfo*)ln->value;\n serverAssert(ai->file_type == AOF_FILE_TYPE_INCR);\n size += getAppendOnlyFileSize(ai->file_name, status);\n if (*status != AOF_OK) return 0;\n }\n\n return size;\n}\n\nint getBaseAndIncrAppendOnlyFilesNum(aofManifest *am) {\n int num = 0;\n if (am->base_aof_info) num++;\n if (am->incr_aof_list) num += listLength(am->incr_aof_list);\n return num;\n}\n\n/* A background append only file rewriting (BGREWRITEAOF) terminated its work.\n * Handle this. */\nvoid backgroundRewriteDoneHandler(int exitcode, int bysignal) {\n if (!bysignal && exitcode == 0) {\n char tmpfile[256];\n long long now = ustime();\n sds new_base_filepath = NULL;\n sds new_incr_filepath = NULL;\n aofManifest *temp_am;\n mstime_t latency;\n\n serverLog(LL_NOTICE,\n \"Background AOF rewrite terminated with success\");\n\n snprintf(tmpfile, 256, \"temp-rewriteaof-bg-%d.aof\",\n (int)server.child_pid);\n\n serverAssert(server.aof_manifest != NULL);\n\n /* Dup a temporary aof_manifest for subsequent modifications. */\n temp_am = aofManifestDup(server.aof_manifest);\n\n /* Get a new BASE file name and mark the previous (if we have)\n * as the HISTORY type. */\n sds new_base_filename = getNewBaseFileNameAndMarkPreAsHistory(temp_am);\n serverAssert(new_base_filename != NULL);\n new_base_filepath = makePath(server.aof_dirname, new_base_filename);\n\n /* Rename the temporary aof file to 'new_base_filename'. */\n latencyStartMonitor(latency);\n if (rename(tmpfile, new_base_filepath) == -1) {\n serverLog(LL_WARNING,\n \"Error trying to rename the temporary AOF base file %s into %s: %s\",\n tmpfile,\n new_base_filepath,\n strerror(errno));\n aofManifestFree(temp_am);\n sdsfree(new_base_filepath);\n server.aof_lastbgrewrite_status = C_ERR;\n server.stat_aofrw_consecutive_failures++;\n goto cleanup;\n }\n latencyEndMonitor(latency);\n latencyAddSampleIfNeeded(\"aof-rename\", latency);\n serverLog(LL_NOTICE,\n \"Successfully renamed the temporary AOF base file %s into %s\", tmpfile, new_base_filename);\n\n /* Rename the temporary incr aof file to 'new_incr_filename'. */\n if (server.aof_state == AOF_WAIT_REWRITE) {\n /* Get temporary incr aof name. */\n sds temp_incr_aof_name = getTempIncrAofName();\n sds temp_incr_filepath = makePath(server.aof_dirname, temp_incr_aof_name);\n /* Get next new incr aof name. */\n sds new_incr_filename = getNewIncrAofName(temp_am, tempIncAofStartReplOffset);\n new_incr_filepath = makePath(server.aof_dirname, new_incr_filename);\n latencyStartMonitor(latency);\n if (rename(temp_incr_filepath, new_incr_filepath) == -1) {\n serverLog(LL_WARNING,\n \"Error trying to rename the temporary AOF incr file %s into %s: %s\",\n temp_incr_filepath,\n new_incr_filepath,\n strerror(errno));\n bg_unlink(new_base_filepath);\n sdsfree(new_base_filepath);\n aofManifestFree(temp_am);\n sdsfree(temp_incr_filepath);\n sdsfree(new_incr_filepath);\n sdsfree(temp_incr_aof_name);\n server.aof_lastbgrewrite_status = C_ERR;\n server.stat_aofrw_consecutive_failures++;\n goto cleanup;\n }\n latencyEndMonitor(latency);\n latencyAddSampleIfNeeded(\"aof-rename\", latency);\n serverLog(LL_NOTICE,\n \"Successfully renamed the temporary AOF incr file %s into %s\", temp_incr_aof_name, new_incr_filename);\n sdsfree(temp_incr_filepath);\n sdsfree(temp_incr_aof_name);\n }\n\n /* Change the AOF file type in 'incr_aof_list' from AOF_FILE_TYPE_INCR\n * to AOF_FILE_TYPE_HIST, and move them to the 'history_aof_list'. */\n markRewrittenIncrAofAsHistory(temp_am);\n\n /* Persist our modifications. */\n if (persistAofManifest(temp_am) == C_ERR) {\n bg_unlink(new_base_filepath);\n aofManifestFree(temp_am);\n sdsfree(new_base_filepath);\n if (new_incr_filepath) {\n bg_unlink(new_incr_filepath);\n sdsfree(new_incr_filepath);\n }\n server.aof_lastbgrewrite_status = C_ERR;\n server.stat_aofrw_consecutive_failures++;\n goto cleanup;\n }\n sdsfree(new_base_filepath);\n if (new_incr_filepath) sdsfree(new_incr_filepath);\n\n /* We can safely let `server.aof_manifest` point to 'temp_am' and free the previous one. */\n aofManifestFreeAndUpdate(temp_am);\n\n if (server.aof_state != AOF_OFF) {\n /* AOF enabled. */\n server.aof_current_size = getAppendOnlyFileSize(new_base_filename, NULL) + server.aof_last_incr_size;\n server.aof_rewrite_base_size = server.aof_current_size;\n }\n\n /* We don't care about the return value of `aofDelHistoryFiles`, because the history\n * deletion failure will not cause any problems. */\n aofDelHistoryFiles();\n\n server.aof_lastbgrewrite_status = C_OK;\n server.stat_aofrw_consecutive_failures = 0;\n\n serverLog(LL_NOTICE, \"Background AOF rewrite finished successfully\");\n /* Change state from WAIT_REWRITE to ON if needed */\n if (server.aof_state == AOF_WAIT_REWRITE) {\n server.aof_state = AOF_ON;\n\n /* Update the fsynced replication offset that just now become valid.\n * This could either be the one we took in startAppendOnly, or a\n * newer one set by the bio thread. */\n long long fsynced_reploff_pending;\n atomicGet(server.fsynced_reploff_pending, fsynced_reploff_pending);\n server.fsynced_reploff = fsynced_reploff_pending;\n }\n\n serverLog(LL_VERBOSE,\n \"Background AOF rewrite signal handler took %lldus\", ustime()-now);\n } else if (!bysignal && exitcode != 0) {\n server.aof_lastbgrewrite_status = C_ERR;\n server.stat_aofrw_consecutive_failures++;\n\n serverLog(LL_WARNING,\n \"Background AOF rewrite terminated with error\");\n } else {\n /* SIGUSR1 is whitelisted, so we have a way to kill a child without\n * triggering an error condition. */\n if (bysignal != SIGUSR1) {\n server.aof_lastbgrewrite_status = C_ERR;\n server.stat_aofrw_consecutive_failures++;\n }\n\n serverLog(LL_WARNING,\n \"Background AOF rewrite terminated by signal %d\", bysignal);\n }\n\ncleanup:\n aofRemoveTempFile(server.child_pid);\n /* Clear AOF buffer and delete temp incr aof for next rewrite. */\n if (server.aof_state == AOF_WAIT_REWRITE) {\n sdsfree(server.aof_buf);\n server.aof_buf = sdsempty();\n aofDelTempIncrAofFile();\n }\n server.aof_rewrite_time_last = time(NULL)-server.aof_rewrite_time_start;\n server.aof_rewrite_time_start = -1;\n /* Schedule a new rewrite if we are waiting for it to switch the AOF ON. */\n if (server.aof_state == AOF_WAIT_REWRITE)\n server.aof_rewrite_scheduled = 1;\n}\n" }, { "path": "src/asciilogo.h", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\nconst char *ascii_logo =\n\" _._ \\n\"\n\" _.-``__ ''-._ \\n\"\n\" _.-`` `. `_. ''-._ Redis Open Source \\n\"\n\" .-`` .-```. ```\\\\/ _.,_ ''-._ %s (%s/%d) %s bit\\n\"\n\" ( ' , .-` | `, ) Running in %s mode\\n\"\n\" |`-._`-...-` __...-.``-._|'` _.-'| Port: %d\\n\"\n\" | `-._ `._ / _.-' | PID: %ld\\n\"\n\" `-._ `-._ `-./ _.-' _.-' \\n\"\n\" |`-._`-._ `-.__.-' _.-'_.-'| \\n\"\n\" | `-._`-._ _.-'_.-' | https://redis.io \\n\"\n\" `-._ `-._`-.__.-'_.-' _.-' \\n\"\n\" |`-._`-._ `-.__.-' _.-'_.-'| \\n\"\n\" | `-._`-._ _.-'_.-' | \\n\"\n\" `-._ `-._`-.__.-'_.-' _.-' \\n\"\n\" `-._ `-.__.-' _.-' \\n\"\n\" `-._ _.-' \\n\"\n\" `-.__.-' \\n\\n\";\n" }, { "path": "src/atomicvar.h", "content": "/* This file implements atomic counters using c11 _Atomic, __atomic or __sync\n * macros if available, otherwise we will throw an error when compile.\n *\n * The exported interface is composed of the following macros:\n *\n * atomicIncr(var,count) -- Increment the atomic counter\n * atomicGetIncr(var,oldvalue_var,count) -- Get and increment the atomic counter\n * atomicIncrGet(var,newvalue_var,count) -- Increment and get the atomic counter new value\n * atomicDecr(var,count) -- Decrement the atomic counter\n * atomicGet(var,dstvar) -- Fetch the atomic counter value\n * atomicSet(var,value) -- Set the atomic counter value\n * atomicGetWithSync(var,value) -- 'atomicGet' with inter-thread synchronization\n * atomicSetWithSync(var,value) -- 'atomicSet' with inter-thread synchronization\n * atomicCompareExchange(type,var,expected_var,desired) -- Compare and exchange (CAS) operation\n * \n * Atomic operations on flags. \n * Flag type can be int, long, long long or their unsigned counterparts.\n * The value of the flag can be 1 or 0.\n * \n * atomicFlagGetSet(var,oldvalue_var) -- Get and set the atomic counter value\n * \n * NOTE1: __atomic* and _Atomic implementations can be actually elaborated to support any value by changing the \n * hardcoded new value passed to __atomic_exchange* from 1 to @param count\n * i.e oldvalue_var = atomic_exchange_explicit(&var, count).\n * However, in order to be compatible with the __sync functions family, we can use only 0 and 1.\n * The only exchange alternative suggested by __sync is __sync_lock_test_and_set, \n * But as described by the gnu manual for __sync_lock_test_and_set():\n * https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html\n * \"A target may support reduced functionality here by which the only valid value to store is the immediate constant 1. The exact value\n * actually stored in *ptr is implementation defined.\"\n * Hence, we can't rely on it for a any value other than 1.\n * We eventually chose to implement this method with __sync_val_compare_and_swap since it satisfies functionality needed for atomicFlagGetSet\n * (if the flag was 0 -> set to 1, if it's already 1 -> do nothing, but the final result is that the flag is set), \n * and also it has a full barrier (__sync_lock_test_and_set has acquire barrier).\n * \n * NOTE2: Unlike other atomic type, which aren't guaranteed to be lock free, c11 atomic_flag does.\n * To check whether a type is lock free, atomic_is_lock_free() can be used. \n * It can be considered to limit the flag type to atomic_flag to improve performance.\n * \n * Never use return value from the macros, instead use the AtomicGetIncr()\n * if you need to get the current value and increment it atomically, like\n * in the following example:\n *\n * long oldvalue;\n * atomicGetIncr(myvar,oldvalue,1);\n * doSomethingWith(oldvalue);\n *\n * ----------------------------------------------------------------------------\n *\n * Copyright (c) 2015-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \n#include \"config.h\"\n\n#ifndef __ATOMIC_VAR_H\n#define __ATOMIC_VAR_H\n\n/* Define redisAtomic for atomic variable. */\n#define redisAtomic\n\n/* To test Redis with Helgrind (a Valgrind tool) it is useful to define\n * the following macro, so that __sync macros are used: those can be detected\n * by Helgrind (even if they are less efficient) so that no false positive\n * is reported. */\n// #define __ATOMIC_VAR_FORCE_SYNC_MACROS\n\n/* There will be many false positives if we test Redis with Helgrind, since\n * Helgrind can't understand we have imposed ordering on the program, so\n * we use macros in helgrind.h to tell Helgrind inter-thread happens-before\n * relationship explicitly for avoiding false positives.\n *\n * For more details, please see: valgrind/helgrind.h and\n * https://www.valgrind.org/docs/manual/hg-manual.html#hg-manual.effective-use\n *\n * These macros take effect only when 'make helgrind', and you must first\n * install Valgrind in the default path configuration. */\n#ifdef __ATOMIC_VAR_FORCE_SYNC_MACROS\n#include \n#else\n#define ANNOTATE_HAPPENS_BEFORE(v) ((void) v)\n#define ANNOTATE_HAPPENS_AFTER(v) ((void) v)\n#endif\n\n#if !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && defined(__STDC_VERSION__) && \\\n (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)\n/* Use '_Atomic' keyword if the compiler supports. */\n#undef redisAtomic\n#define redisAtomic _Atomic\n/* Implementation using _Atomic in C11. */\n\n#include \n#define atomicIncr(var,count) atomic_fetch_add_explicit(&var,(count),memory_order_relaxed)\n#define atomicGetIncr(var,oldvalue_var,count) do { \\\n oldvalue_var = atomic_fetch_add_explicit(&var,(count),memory_order_relaxed); \\\n} while(0)\n#define atomicIncrGet(var, newvalue_var, count) \\\n newvalue_var = atomicIncr(var,count) + count\n#define atomicDecr(var,count) atomic_fetch_sub_explicit(&var,(count),memory_order_relaxed)\n#define atomicGet(var,dstvar) do { \\\n dstvar = atomic_load_explicit(&var,memory_order_relaxed); \\\n} while(0)\n#define atomicSet(var,value) atomic_store_explicit(&var,value,memory_order_relaxed)\n#define atomicGetWithSync(var,dstvar) do { \\\n dstvar = atomic_load_explicit(&var,memory_order_seq_cst); \\\n} while(0)\n#define atomicSetWithSync(var,value) \\\n atomic_store_explicit(&var,value,memory_order_seq_cst)\n#define atomicCompareExchange(type,var,expected_var,desired) \\\n atomic_compare_exchange_weak_explicit(&var,&expected_var,desired,memory_order_relaxed,memory_order_relaxed)\n#define atomicFlagGetSet(var,oldvalue_var) \\\n oldvalue_var = atomic_exchange_explicit(&var,1,memory_order_relaxed)\n#define REDIS_ATOMIC_API \"c11-builtin\"\n\n#elif !defined(__ATOMIC_VAR_FORCE_SYNC_MACROS) && \\\n (!defined(__clang__) || !defined(__APPLE__) || __apple_build_version__ > 4210057) && \\\n defined(__ATOMIC_RELAXED) && defined(__ATOMIC_SEQ_CST)\n/* Implementation using __atomic macros. */\n\n#define atomicIncr(var,count) __atomic_add_fetch(&var,(count),__ATOMIC_RELAXED)\n#define atomicIncrGet(var, newvalue_var, count) \\\n newvalue_var = __atomic_add_fetch(&var,(count),__ATOMIC_RELAXED)\n#define atomicGetIncr(var,oldvalue_var,count) do { \\\n oldvalue_var = __atomic_fetch_add(&var,(count),__ATOMIC_RELAXED); \\\n} while(0)\n#define atomicDecr(var,count) __atomic_sub_fetch(&var,(count),__ATOMIC_RELAXED)\n#define atomicGet(var,dstvar) do { \\\n dstvar = __atomic_load_n(&var,__ATOMIC_RELAXED); \\\n} while(0)\n#define atomicSet(var,value) __atomic_store_n(&var,value,__ATOMIC_RELAXED)\n#define atomicGetWithSync(var,dstvar) do { \\\n dstvar = __atomic_load_n(&var,__ATOMIC_SEQ_CST); \\\n} while(0)\n#define atomicSetWithSync(var,value) \\\n __atomic_store_n(&var,value,__ATOMIC_SEQ_CST)\n#define atomicCompareExchange(type,var,expected_var,desired) \\\n __atomic_compare_exchange_n(&var,&expected_var,desired,1,__ATOMIC_RELAXED,__ATOMIC_RELAXED)\n#define atomicFlagGetSet(var,oldvalue_var) \\\n oldvalue_var = __atomic_exchange_n(&var,1,__ATOMIC_RELAXED)\n#define REDIS_ATOMIC_API \"atomic-builtin\"\n\n#elif defined(HAVE_ATOMIC)\n/* Implementation using __sync macros. */\n\n#define atomicIncr(var,count) __sync_add_and_fetch(&var,(count))\n#define atomicIncrGet(var, newvalue_var, count) \\\n newvalue_var = __sync_add_and_fetch(&var,(count))\n#define atomicGetIncr(var,oldvalue_var,count) do { \\\n oldvalue_var = __sync_fetch_and_add(&var,(count)); \\\n} while(0)\n#define atomicDecr(var,count) __sync_sub_and_fetch(&var,(count))\n#define atomicGet(var,dstvar) do { \\\n dstvar = __sync_sub_and_fetch(&var,0); \\\n} while(0)\n#define atomicSet(var,value) do { \\\n while(!__sync_bool_compare_and_swap(&var,var,value)); \\\n} while(0)\n/* Actually the builtin issues a full memory barrier by default. */\n#define atomicGetWithSync(var,dstvar) do { \\\n dstvar = __sync_sub_and_fetch(&var,0,__sync_synchronize); \\\n ANNOTATE_HAPPENS_AFTER(&var); \\\n} while(0)\n#define atomicSetWithSync(var,value) do { \\\n ANNOTATE_HAPPENS_BEFORE(&var); \\\n while(!__sync_bool_compare_and_swap(&var,var,value,__sync_synchronize)); \\\n} while(0)\n#define atomicCompareExchange(type,var,expected_var,desired) ({ \\\n type _old = __sync_val_compare_and_swap(&var,expected_var,desired); \\\n int _success = (_old == expected_var); \\\n if (!_success) expected_var = _old; \\\n _success; \\\n})\n#define atomicFlagGetSet(var,oldvalue_var) \\\n oldvalue_var = __sync_val_compare_and_swap(&var,0,1)\n#define REDIS_ATOMIC_API \"sync-builtin\"\n\n#else\n#error \"Unable to determine atomic operations for your platform\"\n\n#endif\n#endif /* __ATOMIC_VAR_H */\n" }, { "path": "src/bio.c", "content": "/* Background I/O service for Redis.\n *\n * This file implements operations that we need to perform in the background.\n * Currently there are 3 operations:\n * 1) a background close(2) system call. This is needed when the process is\n * the last owner of a reference to a file closing it means unlinking it, and\n * the deletion of the file is slow, blocking the server.\n * 2) AOF fsync\n * 3) lazyfree of memory\n *\n * In the future we'll either continue implementing new things we need or\n * we'll switch to libeio. However there are probably long term uses for this\n * file as we may want to put Redis specific background tasks here.\n *\n * DESIGN\n * ------\n *\n * The design is simple: We have a structure representing a job to perform,\n * and several worker threads and job queues. Every job type is assigned to\n * a specific worker thread, and a single worker may handle several different\n * job types.\n * Every thread waits for new jobs in its queue, and processes every job\n * sequentially.\n *\n * Jobs handled by the same worker are guaranteed to be processed from the\n * least-recently-inserted to the most-recently-inserted (older jobs processed\n * first).\n *\n * To let the creator of the job to be notified about the completion of the \n * operation, it will need to submit additional dummy job, coined as\n * completion job request that will be written back eventually, by the\n * background thread, into completion job response queue. This notification\n * layout can simplify flows that might submit more than one job, such as\n * in case of FLUSHALL which for a single command submits multiple jobs. It\n * is also correct because jobs are processed in FIFO fashion.\n *\n * ----------------------------------------------------------------------------\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \"bio.h\"\n#include \n\nstatic char* bio_worker_title[] = {\n \"bio_close_file\",\n \"bio_aof\",\n \"bio_lazy_free\",\n};\n\n#define BIO_WORKER_NUM (sizeof(bio_worker_title) / sizeof(*bio_worker_title))\n\nstatic unsigned int bio_job_to_worker[] = {\n [BIO_CLOSE_FILE] = 0,\n [BIO_AOF_FSYNC] = 1,\n [BIO_CLOSE_AOF] = 1,\n [BIO_LAZY_FREE] = 2,\n [BIO_COMP_RQ_CLOSE_FILE] = 0,\n [BIO_COMP_RQ_AOF_FSYNC] = 1,\n [BIO_COMP_RQ_LAZY_FREE] = 2\n};\n\nstatic pthread_t bio_threads[BIO_WORKER_NUM];\nstatic pthread_mutex_t bio_mutex[BIO_WORKER_NUM];\nstatic pthread_cond_t bio_newjob_cond[BIO_WORKER_NUM];\nstatic list *bio_jobs[BIO_WORKER_NUM];\nstatic unsigned long bio_jobs_counter[BIO_NUM_OPS] = {0};\n\n/* The bio_comp_list is used to hold completion job responses and to handover\n * to main thread to callback as notification for job completion. Main\n * thread will be triggered to read the list by signaling via writing to a pipe */\nstatic list *bio_comp_list;\nstatic pthread_mutex_t bio_mutex_comp;\nstatic int job_comp_pipe[2]; /* Pipe used to awake the event loop */\n\ntypedef struct bio_comp_item {\n comp_fn *func; /* callback after completion job will be processed */\n uint64_t arg; /* user data to be passed to the function */\n void *ptr; /* user pointer to be passed to the function */\n} bio_comp_item;\n\n/* This structure represents a background Job. It is only used locally to this\n * file as the API does not expose the internals at all. */\ntypedef union bio_job {\n struct {\n int type; /* Job-type tag. This needs to appear as the first element in all union members. */\n } header;\n\n /* Job specific arguments.*/\n struct {\n int type;\n int fd; /* Fd for file based background jobs */\n long long offset; /* A job-specific offset, if applicable */\n unsigned need_fsync:1; /* A flag to indicate that a fsync is required before\n * the file is closed. */\n unsigned need_reclaim_cache:1; /* A flag to indicate that reclaim cache is required before\n * the file is closed. */\n } fd_args;\n\n struct {\n int type;\n lazy_free_fn *free_fn; /* Function that will free the provided arguments */\n void *free_args[]; /* List of arguments to be passed to the free function */\n } free_args;\n struct {\n int type; /* header */\n comp_fn *fn; /* callback. Handover to main thread to cb as notify for job completion */\n uint64_t arg; /* callback arguments */\n void *ptr; /* callback pointer */\n } comp_rq;\n} bio_job;\n\nvoid *bioProcessBackgroundJobs(void *arg);\nvoid bioPipeReadJobCompList(aeEventLoop *el, int fd, void *privdata, int mask);\n\n/* Make sure we have enough stack to perform all the things we do in the\n * main thread. */\n#define REDIS_THREAD_STACK_SIZE (1024*1024*4)\n\n/* Initialize the background system, spawning the thread. */\nvoid bioInit(void) {\n pthread_attr_t attr;\n pthread_t thread;\n size_t stacksize;\n unsigned long j;\n\n /* Initialization of state vars and objects */\n for (j = 0; j < BIO_WORKER_NUM; j++) {\n pthread_mutex_init(&bio_mutex[j],NULL);\n pthread_cond_init(&bio_newjob_cond[j],NULL);\n bio_jobs[j] = listCreate();\n }\n\n /* init jobs comp responses */\n bio_comp_list = listCreate();\n pthread_mutex_init(&bio_mutex_comp, NULL);\n\n /* Create a pipe for background thread to be able to wake up the redis main thread.\n * Make the pipe non blocking. This is just a best effort aware mechanism\n * and we do not want to block not in the read nor in the write half.\n * Enable close-on-exec flag on pipes in case of the fork-exec system calls in\n * sentinels or redis servers. */\n if (anetPipe(job_comp_pipe, O_CLOEXEC|O_NONBLOCK, O_CLOEXEC|O_NONBLOCK) == -1) {\n serverLog(LL_WARNING,\n \"Can't create the pipe for bio thread: %s\", strerror(errno));\n exit(1);\n }\n\n /* Register a readable event for the pipe used to awake the event loop on job completion */\n if (aeCreateFileEvent(server.el, job_comp_pipe[0], AE_READABLE,\n bioPipeReadJobCompList, NULL) == AE_ERR) {\n serverPanic(\"Error registering the readable event for the bio pipe.\");\n }\n\n /* Set the stack size as by default it may be small in some system */\n pthread_attr_init(&attr);\n pthread_attr_getstacksize(&attr,&stacksize);\n if (!stacksize) stacksize = 1; /* The world is full of Solaris Fixes */\n while (stacksize < REDIS_THREAD_STACK_SIZE) stacksize *= 2;\n pthread_attr_setstacksize(&attr, stacksize);\n\n /* Ready to spawn our threads. We use the single argument the thread\n * function accepts in order to pass the job ID the thread is\n * responsible for. */\n for (j = 0; j < BIO_WORKER_NUM; j++) {\n int err = pthread_create(&thread,&attr,bioProcessBackgroundJobs, (void*) j);\n if (err) {\n serverLog(LL_WARNING, \"Fatal: Can't initialize Background Jobs. Error message: %s\", strerror(err));\n exit(1);\n }\n bio_threads[j] = thread;\n }\n}\n\nvoid bioSubmitJob(int type, bio_job *job) {\n job->header.type = type;\n unsigned long worker = bio_job_to_worker[type];\n pthread_mutex_lock(&bio_mutex[worker]);\n listAddNodeTail(bio_jobs[worker],job);\n bio_jobs_counter[type]++;\n pthread_cond_signal(&bio_newjob_cond[worker]);\n pthread_mutex_unlock(&bio_mutex[worker]);\n}\n\nvoid bioCreateLazyFreeJob(lazy_free_fn free_fn, int arg_count, ...) {\n va_list valist;\n /* Allocate memory for the job structure and all required\n * arguments */\n bio_job *job = zmalloc(sizeof(*job) + sizeof(void *) * (arg_count));\n job->free_args.free_fn = free_fn;\n\n va_start(valist, arg_count);\n for (int i = 0; i < arg_count; i++) {\n job->free_args.free_args[i] = va_arg(valist, void *);\n }\n va_end(valist);\n bioSubmitJob(BIO_LAZY_FREE, job);\n}\n\nvoid bioCreateCompRq(bio_worker_t assigned_worker, comp_fn *func, uint64_t user_data, void *user_ptr) {\n int type;\n switch (assigned_worker) {\n case BIO_WORKER_CLOSE_FILE:\n type = BIO_COMP_RQ_CLOSE_FILE;\n break;\n case BIO_WORKER_AOF_FSYNC:\n type = BIO_COMP_RQ_AOF_FSYNC;\n break;\n case BIO_WORKER_LAZY_FREE:\n type = BIO_COMP_RQ_LAZY_FREE;\n break;\n default:\n serverPanic(\"Invalid worker type in bioCreateCompRq().\");\n }\n\n bio_job *job = zmalloc(sizeof(*job));\n job->comp_rq.fn = func;\n job->comp_rq.arg = user_data;\n job->comp_rq.ptr = user_ptr;\n bioSubmitJob(type, job);\n}\n\nvoid bioCreateCloseJob(int fd, int need_fsync, int need_reclaim_cache) {\n bio_job *job = zmalloc(sizeof(*job));\n job->fd_args.fd = fd;\n job->fd_args.need_fsync = need_fsync;\n job->fd_args.need_reclaim_cache = need_reclaim_cache;\n\n bioSubmitJob(BIO_CLOSE_FILE, job);\n}\n\nvoid bioCreateCloseAofJob(int fd, long long offset, int need_reclaim_cache) {\n bio_job *job = zmalloc(sizeof(*job));\n job->fd_args.fd = fd;\n job->fd_args.offset = offset;\n job->fd_args.need_fsync = 1;\n job->fd_args.need_reclaim_cache = need_reclaim_cache;\n\n bioSubmitJob(BIO_CLOSE_AOF, job);\n}\n\nvoid bioCreateFsyncJob(int fd, long long offset, int need_reclaim_cache) {\n bio_job *job = zmalloc(sizeof(*job));\n job->fd_args.fd = fd;\n job->fd_args.offset = offset;\n job->fd_args.need_reclaim_cache = need_reclaim_cache;\n\n bioSubmitJob(BIO_AOF_FSYNC, job);\n}\n\nvoid *bioProcessBackgroundJobs(void *arg) {\n bio_job *job;\n unsigned long worker = (unsigned long) arg;\n sigset_t sigset;\n\n /* Check that the worker is within the right interval. */\n serverAssert(worker < BIO_WORKER_NUM);\n\n redis_set_thread_title(bio_worker_title[worker]);\n\n redisSetCpuAffinity(server.bio_cpulist);\n\n makeThreadKillable();\n\n pthread_mutex_lock(&bio_mutex[worker]);\n /* Block SIGALRM so we are sure that only the main thread will\n * receive the watchdog signal. */\n sigemptyset(&sigset);\n sigaddset(&sigset, SIGALRM);\n int err = pthread_sigmask(SIG_BLOCK, &sigset, NULL);\n if (err)\n serverLog(LL_WARNING,\n \"Warning: can't mask SIGALRM in bio.c thread: %s\", strerror(err));\n\n while(1) {\n listNode *ln;\n\n /* The loop always starts with the lock hold. */\n if (listLength(bio_jobs[worker]) == 0) {\n pthread_cond_wait(&bio_newjob_cond[worker], &bio_mutex[worker]);\n continue;\n }\n /* Get the job from the queue. */\n ln = listFirst(bio_jobs[worker]);\n job = ln->value;\n /* It is now possible to unlock the background system as we know have\n * a stand alone job structure to process.*/\n pthread_mutex_unlock(&bio_mutex[worker]);\n\n /* Process the job accordingly to its type. */\n int job_type = job->header.type;\n\n if (job_type == BIO_CLOSE_FILE) {\n if (job->fd_args.need_fsync &&\n redis_fsync(job->fd_args.fd) == -1 &&\n errno != EBADF && errno != EINVAL)\n {\n serverLog(LL_WARNING, \"Fail to fsync the AOF file: %s\",strerror(errno));\n }\n if (job->fd_args.need_reclaim_cache) {\n if (reclaimFilePageCache(job->fd_args.fd, 0, 0) == -1) {\n serverLog(LL_NOTICE,\"Unable to reclaim page cache: %s\", strerror(errno));\n }\n }\n close(job->fd_args.fd);\n } else if (job_type == BIO_AOF_FSYNC || job_type == BIO_CLOSE_AOF) {\n /* The fd may be closed by main thread and reused for another\n * socket, pipe, or file. We just ignore these errno because\n * aof fsync did not really fail. */\n if (redis_fsync(job->fd_args.fd) == -1 &&\n errno != EBADF && errno != EINVAL)\n {\n int last_status;\n atomicGet(server.aof_bio_fsync_status,last_status);\n atomicSet(server.aof_bio_fsync_status,C_ERR);\n atomicSet(server.aof_bio_fsync_errno,errno);\n if (last_status == C_OK) {\n serverLog(LL_WARNING,\n \"Fail to fsync the AOF file: %s\",strerror(errno));\n }\n } else {\n atomicSet(server.aof_bio_fsync_status,C_OK);\n atomicSet(server.fsynced_reploff_pending, job->fd_args.offset);\n }\n\n if (job->fd_args.need_reclaim_cache) {\n if (reclaimFilePageCache(job->fd_args.fd, 0, 0) == -1) {\n serverLog(LL_NOTICE,\"Unable to reclaim page cache: %s\", strerror(errno));\n }\n }\n if (job_type == BIO_CLOSE_AOF)\n close(job->fd_args.fd);\n } else if (job_type == BIO_LAZY_FREE) {\n job->free_args.free_fn(job->free_args.free_args);\n } else if ((job_type == BIO_COMP_RQ_CLOSE_FILE) ||\n (job_type == BIO_COMP_RQ_AOF_FSYNC) ||\n (job_type == BIO_COMP_RQ_LAZY_FREE)) {\n bio_comp_item *comp_rsp = zmalloc(sizeof(bio_comp_item));\n comp_rsp->func = job->comp_rq.fn;\n comp_rsp->arg = job->comp_rq.arg;\n comp_rsp->ptr = job->comp_rq.ptr;\n\n /* just write it to completion job responses */\n pthread_mutex_lock(&bio_mutex_comp);\n listAddNodeTail(bio_comp_list, comp_rsp);\n pthread_mutex_unlock(&bio_mutex_comp);\n\n if (write(job_comp_pipe[1],\"A\",1) != 1) {\n /* Pipe is non-blocking, write() may fail if it's full. */\n }\n } else {\n serverPanic(\"Wrong job type in bioProcessBackgroundJobs().\");\n }\n zfree(job);\n\n /* Lock again before reiterating the loop, if there are no longer\n * jobs to process we'll block again in pthread_cond_wait(). */\n pthread_mutex_lock(&bio_mutex[worker]);\n listDelNode(bio_jobs[worker], ln);\n bio_jobs_counter[job_type]--;\n pthread_cond_signal(&bio_newjob_cond[worker]);\n }\n}\n\n/* Return the number of pending jobs of the specified type. */\nunsigned long bioPendingJobsOfType(int type) {\n unsigned int worker = bio_job_to_worker[type];\n\n pthread_mutex_lock(&bio_mutex[worker]);\n unsigned long val = bio_jobs_counter[type];\n pthread_mutex_unlock(&bio_mutex[worker]);\n\n return val;\n}\n\n/* Wait for the job queue of the worker for jobs of specified type to become empty. */\nvoid bioDrainWorker(int job_type) {\n unsigned long worker = bio_job_to_worker[job_type];\n\n pthread_mutex_lock(&bio_mutex[worker]);\n while (listLength(bio_jobs[worker]) > 0) {\n pthread_cond_wait(&bio_newjob_cond[worker], &bio_mutex[worker]);\n }\n pthread_mutex_unlock(&bio_mutex[worker]);\n}\n\n/* Kill the running bio threads in an unclean way. This function should be\n * used only when it's critical to stop the threads for some reason.\n * Currently Redis does this only on crash (for instance on SIGSEGV) in order\n * to perform a fast memory check without other threads messing with memory. */\nvoid bioKillThreads(void) {\n int err;\n unsigned long j;\n\n for (j = 0; j < BIO_WORKER_NUM; j++) {\n if (bio_threads[j] == pthread_self()) continue;\n if (bio_threads[j] && pthread_cancel(bio_threads[j]) == 0) {\n if ((err = pthread_join(bio_threads[j],NULL)) != 0) {\n serverLog(LL_WARNING,\n \"Bio worker thread #%lu can not be joined: %s\",\n j, strerror(err));\n } else {\n serverLog(LL_WARNING,\n \"Bio worker thread #%lu terminated\",j);\n }\n }\n }\n}\n\nvoid bioPipeReadJobCompList(aeEventLoop *el, int fd, void *privdata, int mask) {\n UNUSED(el);\n UNUSED(mask);\n UNUSED(privdata);\n\n char buf[128];\n list *tmp_list = NULL;\n\n while (read(fd, buf, sizeof(buf)) == sizeof(buf));\n\n /* Handle event loop events if pipe was written from event loop API */\n pthread_mutex_lock(&bio_mutex_comp);\n if (listLength(bio_comp_list)) {\n tmp_list = bio_comp_list;\n bio_comp_list = listCreate();\n }\n pthread_mutex_unlock(&bio_mutex_comp);\n\n if (!tmp_list) return;\n\n /* callback to all job completions */\n while (listLength(tmp_list)) {\n listNode *ln = listFirst(tmp_list);\n bio_comp_item *rsp = ln->value;\n listDelNode(tmp_list, ln);\n rsp->func(rsp->arg, rsp->ptr);\n zfree(rsp);\n }\n listRelease(tmp_list);\n}\n" }, { "path": "src/bio.h", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#ifndef __BIO_H\n#define __BIO_H\n\ntypedef void lazy_free_fn(void *args[]);\ntypedef void comp_fn(uint64_t user_data, void *user_ptr);\n\ntypedef enum bio_worker_t {\n BIO_WORKER_CLOSE_FILE = 0,\n BIO_WORKER_AOF_FSYNC,\n BIO_WORKER_LAZY_FREE,\n BIO_WORKER_NUM\n} bio_worker_t;\n\n/* Background job opcodes */\ntypedef enum bio_job_type_t {\n BIO_CLOSE_FILE = 0, /* Deferred close(2) syscall. */\n BIO_AOF_FSYNC, /* Deferred AOF fsync. */\n BIO_LAZY_FREE, /* Deferred objects freeing. */\n BIO_CLOSE_AOF,\n BIO_COMP_RQ_CLOSE_FILE, /* Job completion request, registered on close-file worker's queue */\n BIO_COMP_RQ_AOF_FSYNC, /* Job completion request, registered on aof-fsync worker's queue */\n BIO_COMP_RQ_LAZY_FREE, /* Job completion request, registered on lazy-free worker's queue */\n BIO_NUM_OPS\n} bio_job_type_t;\n\n/* Exported API */\nvoid bioInit(void);\nunsigned long bioPendingJobsOfType(int type);\nvoid bioDrainWorker(int job_type);\nvoid bioKillThreads(void);\nvoid bioCreateCloseJob(int fd, int need_fsync, int need_reclaim_cache);\nvoid bioCreateCloseAofJob(int fd, long long offset, int need_reclaim_cache);\nvoid bioCreateFsyncJob(int fd, long long offset, int need_reclaim_cache);\nvoid bioCreateLazyFreeJob(lazy_free_fn free_fn, int arg_count, ...);\nvoid bioCreateCompRq(bio_worker_t assigned_worker, comp_fn *func, uint64_t user_data, void *user_ptr);\n\n\n#endif\n" }, { "path": "src/bitops.c", "content": "/* Bit operations.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \"ctype.h\"\n\n#ifdef HAVE_AVX2\n/* Define __MM_MALLOC_H to prevent importing the memory aligned\n * allocation functions, which we don't use. */\n#define __MM_MALLOC_H\n#include \n#endif\n\n#ifdef HAVE_AVX512\n/* Define __MM_MALLOC_H to prevent importing the memory aligned\n * allocation functions, which we don't use. */\n#define __MM_MALLOC_H\n#include \n#endif\n\n#ifdef HAVE_AARCH64_NEON\n#include \n#endif\n\n#ifdef HAVE_AVX2\n#define BITOP_USE_AVX2 (__builtin_cpu_supports(\"avx2\"))\n#else\n#define BITOP_USE_AVX2 0\n#endif\n\n/* AArch64 NEON support is determined at compile time via HAVE_AARCH64_NEON */\n#ifdef HAVE_AVX512\n#define BITOP_USE_AVX512 (__builtin_cpu_supports(\"avx512f\"))\n#define BITOPS_USE_AVX512_POPCOUNT (__builtin_cpu_supports(\"avx512f\") && __builtin_cpu_supports(\"avx512vpopcntdq\"))\n#else\n#define BITOP_USE_AVX512 0\n#define BITOPS_USE_AVX512_POPCOUNT 0\n#endif\n\n\n/* -----------------------------------------------------------------------------\n * Helpers and low level bit functions.\n * -------------------------------------------------------------------------- */\n\n /* Shared lookup table for bit counting - maps each byte value to its popcount */\nstatic const uint8_t bitsinbyte[256] = {\n #define B2(n) n, n+1, n+1, n+2\n #define B4(n) B2(n), B2(n+1), B2(n+1), B2(n+2)\n #define B6(n) B4(n), B4(n+1), B4(n+1), B4(n+2)\n B6(0), B6(1), B6(1), B6(2)\n #undef B6\n #undef B4\n #undef B2\n};\n\n/* Count number of bits set in the binary array pointed by 's' and long\n * 'count' bytes. The implementation of this function is required to\n * work with an input string length up to 512 MB or more (server.proto_max_bulk_len) */\nATTRIBUTE_TARGET_POPCNT\nlong long redisPopcount(void *s, long count) {\n long long bits = 0;\n unsigned char *p = s;\n uint32_t *p4;\n#if defined(HAVE_POPCNT)\n int use_popcnt = __builtin_cpu_supports(\"popcnt\"); /* Check if CPU supports POPCNT instruction. */\n#else\n int use_popcnt = 0; /* Assume CPU does not support POPCNT if\n * __builtin_cpu_supports() is not available. */\n#endif\n /* Count initial bytes not aligned to 64-bit when using the POPCNT instruction,\n * otherwise align to 32-bit. */\n int align = use_popcnt ? 7 : 3;\n while ((unsigned long)p & align && count) {\n bits += bitsinbyte[*p++];\n count--;\n }\n\n if (likely(use_popcnt)) {\n /* Use separate counters to make the CPU think there are no\n * dependencies between these popcnt operations. */\n uint64_t cnt[4];\n memset(cnt, 0, sizeof(cnt));\n\n /* Count bits 32 bytes at a time by using popcnt.\n * Unroll the loop to avoid the overhead of a single popcnt per iteration,\n * allowing the CPU to extract more instruction-level parallelism.\n * Reference: https://danluu.com/assembly-intrinsics/ */\n while (count >= 32) {\n cnt[0] += __builtin_popcountll(*(uint64_t*)(p));\n cnt[1] += __builtin_popcountll(*(uint64_t*)(p + 8));\n cnt[2] += __builtin_popcountll(*(uint64_t*)(p + 16));\n cnt[3] += __builtin_popcountll(*(uint64_t*)(p + 24));\n count -= 32;\n p += 32;\n /* Prefetch with 2K stride is just enough to overlap L3 miss latency effectively\n * without causing pressure on lower memory hierarchy or polluting L1/L2 */\n redis_prefetch_read(p + 2048);\n }\n bits += cnt[0] + cnt[1] + cnt[2] + cnt[3];\n goto remain;\n }\n\n /* Count bits 28 bytes at a time */\n p4 = (uint32_t*)p;\n while(count>=28) {\n uint32_t aux1, aux2, aux3, aux4, aux5, aux6, aux7;\n\n aux1 = *p4++;\n aux2 = *p4++;\n aux3 = *p4++;\n aux4 = *p4++;\n aux5 = *p4++;\n aux6 = *p4++;\n aux7 = *p4++;\n count -= 28;\n\n aux1 = aux1 - ((aux1 >> 1) & 0x55555555);\n aux1 = (aux1 & 0x33333333) + ((aux1 >> 2) & 0x33333333);\n aux2 = aux2 - ((aux2 >> 1) & 0x55555555);\n aux2 = (aux2 & 0x33333333) + ((aux2 >> 2) & 0x33333333);\n aux3 = aux3 - ((aux3 >> 1) & 0x55555555);\n aux3 = (aux3 & 0x33333333) + ((aux3 >> 2) & 0x33333333);\n aux4 = aux4 - ((aux4 >> 1) & 0x55555555);\n aux4 = (aux4 & 0x33333333) + ((aux4 >> 2) & 0x33333333);\n aux5 = aux5 - ((aux5 >> 1) & 0x55555555);\n aux5 = (aux5 & 0x33333333) + ((aux5 >> 2) & 0x33333333);\n aux6 = aux6 - ((aux6 >> 1) & 0x55555555);\n aux6 = (aux6 & 0x33333333) + ((aux6 >> 2) & 0x33333333);\n aux7 = aux7 - ((aux7 >> 1) & 0x55555555);\n aux7 = (aux7 & 0x33333333) + ((aux7 >> 2) & 0x33333333);\n bits += ((((aux1 + (aux1 >> 4)) & 0x0F0F0F0F) +\n ((aux2 + (aux2 >> 4)) & 0x0F0F0F0F) +\n ((aux3 + (aux3 >> 4)) & 0x0F0F0F0F) +\n ((aux4 + (aux4 >> 4)) & 0x0F0F0F0F) +\n ((aux5 + (aux5 >> 4)) & 0x0F0F0F0F) +\n ((aux6 + (aux6 >> 4)) & 0x0F0F0F0F) +\n ((aux7 + (aux7 >> 4)) & 0x0F0F0F0F))* 0x01010101) >> 24;\n }\n p = (unsigned char*)p4;\n\nremain:\n /* Count the remaining bytes. */\n while(count--) bits += bitsinbyte[*p++];\n return bits;\n}\n\n#ifdef HAVE_AARCH64_NEON\n/* AArch64 optimized popcount implementation.\n * Processes the input bitmap using four NEON vector accumulators in parallel\n * to improve instruction-level parallelism and reduce the frequency of\n * scalar reductions. Each accumulator holds 16-bit partial sums that are\n * combined only once per large block (128 bytes), minimizing data movement.\n *\n * Benchmark results show this approach outperforms 2-lane implementations\n * and matches or exceeds 8-lane versions in throughput, while avoiding\n * register pressure and keeping the backend pipeline fully utilized.\n *\n * This function is now memory bound on large bitmaps, as confirmed by perf\n * profiling, with backend stalls dominated by L1/L2 data cache refills.\n */\nlong long redisPopCountAarch64(void *s, long count) {\n long long bits = 0;\n const uint8_t *p = (const uint8_t*)s;\n\n /* Align */\n while (((uintptr_t)p & 15) && count) {\n bits += bitsinbyte[*p++];\n count--;\n }\n\n /* Four vector accumulators of u16 (pairwise-accumulated byte counts). */\n uint16x8_t acc0 = vdupq_n_u16(0);\n uint16x8_t acc1 = vdupq_n_u16(0);\n uint16x8_t acc2 = vdupq_n_u16(0);\n uint16x8_t acc3 = vdupq_n_u16(0);\n\n /* Process 128B per loop to amortize reductions. */\n while (count >= 128) {\n uint8x16_t d0 = vld1q_u8(p + 0);\n uint8x16_t d1 = vld1q_u8(p + 16);\n uint8x16_t d2 = vld1q_u8(p + 32);\n uint8x16_t d3 = vld1q_u8(p + 48);\n uint8x16_t d4 = vld1q_u8(p + 64);\n uint8x16_t d5 = vld1q_u8(p + 80);\n uint8x16_t d6 = vld1q_u8(p + 96);\n uint8x16_t d7 = vld1q_u8(p +112);\n\n /* Per-byte popcount */\n uint8x16_t c0 = vcntq_u8(d0);\n uint8x16_t c1 = vcntq_u8(d1);\n uint8x16_t c2 = vcntq_u8(d2);\n uint8x16_t c3 = vcntq_u8(d3);\n uint8x16_t c4 = vcntq_u8(d4);\n uint8x16_t c5 = vcntq_u8(d5);\n uint8x16_t c6 = vcntq_u8(d6);\n uint8x16_t c7 = vcntq_u8(d7);\n\n /* Pairwise widen-add with accumulation: u8 -> u16, stay in vectors */\n acc0 = vpadalq_u8(acc0, c0);\n acc1 = vpadalq_u8(acc1, c1);\n acc2 = vpadalq_u8(acc2, c2);\n acc3 = vpadalq_u8(acc3, c3);\n\n acc0 = vpadalq_u8(acc0, c4);\n acc1 = vpadalq_u8(acc1, c5);\n acc2 = vpadalq_u8(acc2, c6);\n acc3 = vpadalq_u8(acc3, c7);\n\n p += 128;\n count -= 128;\n }\n\n /* Reduce vector accumulators to scalar once. */\n uint32x4_t s0 = vpaddlq_u16(acc0);\n uint32x4_t s1 = vpaddlq_u16(acc1);\n uint32x4_t s2 = vpaddlq_u16(acc2);\n uint32x4_t s3 = vpaddlq_u16(acc3);\n uint32x4_t s01 = vaddq_u32(s0, s1);\n uint32x4_t s23 = vaddq_u32(s2, s3);\n uint32x4_t st = vaddq_u32(s01, s23);\n uint64x2_t s64 = vpaddlq_u32(st);\n bits += (long long)(vgetq_lane_u64(s64, 0) + vgetq_lane_u64(s64, 1));\n\n /* Remaining 64B blocks (keep vector domain) */\n while (count >= 64) {\n uint8x16_t d0 = vld1q_u8(p + 0);\n uint8x16_t d1 = vld1q_u8(p + 16);\n uint8x16_t d2 = vld1q_u8(p + 32);\n uint8x16_t d3 = vld1q_u8(p + 48);\n\n uint8x16_t c0 = vcntq_u8(d0);\n uint8x16_t c1 = vcntq_u8(d1);\n uint8x16_t c2 = vcntq_u8(d2);\n uint8x16_t c3 = vcntq_u8(d3);\n\n uint64x2_t t0 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(c0)));\n uint64x2_t t1 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(c1)));\n uint64x2_t t2 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(c2)));\n uint64x2_t t3 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(c3)));\n\n uint64x2_t s = vaddq_u64(vaddq_u64(t0, t1), vaddq_u64(t2, t3));\n bits += (long long)(vgetq_lane_u64(s, 0) + vgetq_lane_u64(s, 1));\n\n p += 64;\n count -= 64;\n }\n\n /* 16B chunks */\n while (count >= 16) {\n uint8x16_t d = vld1q_u8(p);\n uint64x2_t s = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(vcntq_u8(d))));\n bits += (long long)(vgetq_lane_u64(s, 0) + vgetq_lane_u64(s, 1));\n p += 16;\n count -= 16;\n }\n\n /* Tail */\n while (count--) bits += bitsinbyte[*p++];\n\n return bits;\n}\n#endif\n\n#ifdef HAVE_AVX512\n/* AVX512 optimized version of redisPopcount using VPOPCNTDQ instruction.\n * This function requires AVX512F and AVX512VPOPCNTDQ support. */\nATTRIBUTE_TARGET_AVX512_POPCOUNT\nlong long redisPopCountAvx512(void *s, long count) {\n long long bits = 0;\n unsigned char *p = s;\n\n /* Align to 64-byte boundary for optimal AVX512 performance */\n while ((unsigned long)p & 63 && count) {\n bits += bitsinbyte[*p++];\n count--;\n }\n\n /* Process 64 bytes at a time using AVX512 */\n while (count >= 64) {\n __m512i data = _mm512_loadu_si512((__m512i*)p);\n __m512i popcnt = _mm512_popcnt_epi64(data);\n\n /* Sum all 8 64-bit popcount results */\n bits += _mm512_reduce_add_epi64(popcnt);\n\n p += 64;\n count -= 64;\n\n /* Prefetch next cache line */\n redis_prefetch_read(p + 2048);\n }\n\n /* Handle remaining bytes with scalar popcount */\n while (count >= 8) {\n bits += __builtin_popcountll(*(uint64_t*)p);\n p += 8;\n count -= 8;\n }\n\n /* Handle final bytes */\n while (count--) {\n bits += bitsinbyte[*p++];\n }\n\n return bits;\n}\n#endif\n\n#ifdef HAVE_AVX2\n/* AVX2 optimized version of redisPopcount.\n * This function requires AVX2 and POPCNT support. */\nATTRIBUTE_TARGET_AVX2_POPCOUNT\nlong long redisPopCountAvx2(void *s, long count) {\n long long bits = 0;\n unsigned char *p = s;\n\n /* Align to 8-byte boundary for 64-bit operations */\n while ((unsigned long)p & 7 && count) {\n bits += bitsinbyte[*p++];\n count--;\n }\n\n /* Use separate counters to avoid dependencies, similar to regular redisPopcount */\n uint64_t cnt[4];\n memset(cnt, 0, sizeof(cnt));\n\n /* Process 32 bytes at a time using POPCNT on 64-bit chunks */\n while (count >= 32) {\n cnt[0] += __builtin_popcountll(*(uint64_t*)(p));\n cnt[1] += __builtin_popcountll(*(uint64_t*)(p + 8));\n cnt[2] += __builtin_popcountll(*(uint64_t*)(p + 16));\n cnt[3] += __builtin_popcountll(*(uint64_t*)(p + 24));\n\n p += 32;\n count -= 32;\n\n /* Prefetch next cache line */\n redis_prefetch_read(p + 2048);\n }\n\n bits += cnt[0] + cnt[1] + cnt[2] + cnt[3];\n\n /* Handle remaining bytes with scalar popcount */\n while (count >= 8) {\n bits += __builtin_popcountll(*(uint64_t*)p);\n p += 8;\n count -= 8;\n }\n\n /* Handle final bytes */\n while (count--) {\n bits += bitsinbyte[*p++];\n }\n\n return bits;\n}\n#endif\n\n/* Automatically select the best available popcount implementation */\nstatic inline long long redisPopcountAuto(const unsigned char *p, long count) {\n#ifdef HAVE_AVX512\n if (BITOPS_USE_AVX512_POPCOUNT) {\n return redisPopCountAvx512((void*)p, count);\n }\n#endif\n#ifdef HAVE_AVX2\n if (BITOP_USE_AVX2) {\n return redisPopCountAvx2((void*)p, count);\n }\n#endif\n#ifdef HAVE_AARCH64_NEON\n return redisPopCountAarch64((void*)p, count);\n#else\n return redisPopcount((void*)p, count);\n#endif\n}\n\n/* Return the position of the first bit set to one (if 'bit' is 1) or\n * zero (if 'bit' is 0) in the bitmap starting at 's' and long 'count' bytes.\n *\n * The function is guaranteed to return a value >= 0 if 'bit' is 0 since if\n * no zero bit is found, it returns count*8 assuming the string is zero\n * padded on the right. However if 'bit' is 1 it is possible that there is\n * not a single set bit in the bitmap. In this special case -1 is returned. */\nlong long redisBitpos(void *s, unsigned long count, int bit) {\n unsigned long *l;\n unsigned char *c;\n unsigned long skipval, word = 0, one;\n long long pos = 0; /* Position of bit, to return to the caller. */\n unsigned long j;\n int found;\n\n /* Process whole words first, seeking for first word that is not\n * all ones or all zeros respectively if we are looking for zeros\n * or ones. This is much faster with large strings having contiguous\n * blocks of 1 or 0 bits compared to the vanilla bit per bit processing.\n *\n * Note that if we start from an address that is not aligned\n * to sizeof(unsigned long) we consume it byte by byte until it is\n * aligned. */\n\n /* Skip initial bits not aligned to sizeof(unsigned long) byte by byte. */\n skipval = bit ? 0 : UCHAR_MAX;\n c = (unsigned char*) s;\n found = 0;\n while((unsigned long)c & (sizeof(*l)-1) && count) {\n if (*c != skipval) {\n found = 1;\n break;\n }\n c++;\n count--;\n pos += 8;\n }\n\n /* Skip bits with full word step. */\n l = (unsigned long*) c;\n if (!found) {\n skipval = bit ? 0 : ULONG_MAX;\n while (count >= sizeof(*l)) {\n if (*l != skipval) break;\n l++;\n count -= sizeof(*l);\n pos += sizeof(*l)*8;\n }\n }\n\n /* Load bytes into \"word\" considering the first byte as the most significant\n * (we basically consider it as written in big endian, since we consider the\n * string as a set of bits from left to right, with the first bit at position\n * zero.\n *\n * Note that the loading is designed to work even when the bytes left\n * (count) are less than a full word. We pad it with zero on the right. */\n c = (unsigned char*)l;\n for (j = 0; j < sizeof(*l); j++) {\n word <<= 8;\n if (count) {\n word |= *c;\n c++;\n count--;\n }\n }\n\n /* Special case:\n * If bits in the string are all zero and we are looking for one,\n * return -1 to signal that there is not a single \"1\" in the whole\n * string. This can't happen when we are looking for \"0\" as we assume\n * that the right of the string is zero padded. */\n if (bit == 1 && word == 0) return -1;\n\n /* Last word left, scan bit by bit. The first thing we need is to\n * have a single \"1\" set in the most significant position in an\n * unsigned long. We don't know the size of the long so we use a\n * simple trick. */\n one = ULONG_MAX; /* All bits set to 1.*/\n one >>= 1; /* All bits set to 1 but the MSB. */\n one = ~one; /* All bits set to 0 but the MSB. */\n\n while(one) {\n if (((one & word) != 0) == bit) return pos;\n pos++;\n one >>= 1;\n }\n\n /* If we reached this point, there is a bug in the algorithm, since\n * the case of no match is handled as a special case before. */\n serverPanic(\"End of redisBitpos() reached.\");\n return 0; /* Just to avoid warnings. */\n}\n\n/* The following set.*Bitfield and get.*Bitfield functions implement setting\n * and getting arbitrary size (up to 64 bits) signed and unsigned integers\n * at arbitrary positions into a bitmap.\n *\n * The representation considers the bitmap as having the bit number 0 to be\n * the most significant bit of the first byte, and so forth, so for example\n * setting a 5 bits unsigned integer to value 23 at offset 7 into a bitmap\n * previously set to all zeroes, will produce the following representation:\n *\n * +--------+--------+\n * |00000001|01110000|\n * +--------+--------+\n *\n * When offsets and integer sizes are aligned to bytes boundaries, this is the\n * same as big endian, however when such alignment does not exist, its important\n * to also understand how the bits inside a byte are ordered.\n *\n * Note that this format follows the same convention as SETBIT and related\n * commands.\n */\n\nvoid setUnsignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits, uint64_t value) {\n uint64_t byte, bit, byteval, bitval, j;\n\n for (j = 0; j < bits; j++) {\n bitval = (value & ((uint64_t)1<<(bits-1-j))) != 0;\n byte = offset >> 3;\n bit = 7 - (offset & 0x7);\n byteval = p[byte];\n byteval &= ~(1 << bit);\n byteval |= bitval << bit;\n p[byte] = byteval & 0xff;\n offset++;\n }\n}\n\nvoid setSignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits, int64_t value) {\n uint64_t uv = value; /* Casting will add UINT64_MAX + 1 if v is negative. */\n setUnsignedBitfield(p,offset,bits,uv);\n}\n\nuint64_t getUnsignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits) {\n uint64_t byte, bit, byteval, bitval, j, value = 0;\n\n for (j = 0; j < bits; j++) {\n byte = offset >> 3;\n bit = 7 - (offset & 0x7);\n byteval = p[byte];\n bitval = (byteval >> bit) & 1;\n value = (value<<1) | bitval;\n offset++;\n }\n return value;\n}\n\nint64_t getSignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits) {\n int64_t value;\n union {uint64_t u; int64_t i;} conv;\n\n /* Converting from unsigned to signed is undefined when the value does\n * not fit, however here we assume two's complement and the original value\n * was obtained from signed -> unsigned conversion, so we'll find the\n * most significant bit set if the original value was negative.\n *\n * Note that two's complement is mandatory for exact-width types\n * according to the C99 standard. */\n conv.u = getUnsignedBitfield(p,offset,bits);\n value = conv.i;\n\n /* If the top significant bit is 1, propagate it to all the\n * higher bits for two's complement representation of signed\n * integers. */\n if (bits < 64 && (value & ((uint64_t)1 << (bits-1))))\n value |= ((uint64_t)-1) << bits;\n return value;\n}\n\n/* The following two functions detect overflow of a value in the context\n * of storing it as an unsigned or signed integer with the specified\n * number of bits. The functions both take the value and a possible increment.\n * If no overflow could happen and the value+increment fit inside the limits,\n * then zero is returned, otherwise in case of overflow, 1 is returned,\n * otherwise in case of underflow, -1 is returned.\n *\n * When non-zero is returned (overflow or underflow), if not NULL, *limit is\n * set to the value the operation should result when an overflow happens,\n * depending on the specified overflow semantics:\n *\n * For BFOVERFLOW_SAT if 1 is returned, *limit it is set maximum value that\n * you can store in that integer. when -1 is returned, *limit is set to the\n * minimum value that an integer of that size can represent.\n *\n * For BFOVERFLOW_WRAP *limit is set by performing the operation in order to\n * \"wrap\" around towards zero for unsigned integers, or towards the most\n * negative number that is possible to represent for signed integers. */\n\n#define BFOVERFLOW_WRAP 0\n#define BFOVERFLOW_SAT 1\n#define BFOVERFLOW_FAIL 2 /* Used by the BITFIELD command implementation. */\n\nint checkUnsignedBitfieldOverflow(uint64_t value, int64_t incr, uint64_t bits, int owtype, uint64_t *limit) {\n uint64_t max = (bits == 64) ? UINT64_MAX : (((uint64_t)1< max || (incr > 0 && incr > maxincr)) {\n if (limit) {\n if (owtype == BFOVERFLOW_WRAP) {\n goto handle_wrap;\n } else if (owtype == BFOVERFLOW_SAT) {\n *limit = max;\n }\n }\n return 1;\n } else if (incr < 0 && incr < minincr) {\n if (limit) {\n if (owtype == BFOVERFLOW_WRAP) {\n goto handle_wrap;\n } else if (owtype == BFOVERFLOW_SAT) {\n *limit = 0;\n }\n }\n return -1;\n }\n return 0;\n\nhandle_wrap:\n {\n uint64_t mask = ((uint64_t)-1) << bits;\n uint64_t res = value+incr;\n\n res &= ~mask;\n *limit = res;\n }\n return 1;\n}\n\nint checkSignedBitfieldOverflow(int64_t value, int64_t incr, uint64_t bits, int owtype, int64_t *limit) {\n int64_t max = (bits == 64) ? INT64_MAX : (((int64_t)1<<(bits-1))-1);\n int64_t min = (-max)-1;\n\n /* Note that maxincr and minincr could overflow, but we use the values\n * only after checking 'value' range, so when we use it no overflow\n * happens. 'uint64_t' cast is there just to prevent undefined behavior on\n * overflow */\n int64_t maxincr = (uint64_t)max-value;\n int64_t minincr = min-value;\n\n if (value > max || (bits != 64 && incr > maxincr) || (value >= 0 && incr > 0 && incr > maxincr))\n {\n if (limit) {\n if (owtype == BFOVERFLOW_WRAP) {\n goto handle_wrap;\n } else if (owtype == BFOVERFLOW_SAT) {\n *limit = max;\n }\n }\n return 1;\n } else if (value < min || (bits != 64 && incr < minincr) || (value < 0 && incr < 0 && incr < minincr)) {\n if (limit) {\n if (owtype == BFOVERFLOW_WRAP) {\n goto handle_wrap;\n } else if (owtype == BFOVERFLOW_SAT) {\n *limit = min;\n }\n }\n return -1;\n }\n return 0;\n\nhandle_wrap:\n {\n uint64_t msb = (uint64_t)1 << (bits-1);\n uint64_t a = value, b = incr, c;\n c = a+b; /* Perform addition as unsigned so that's defined. */\n\n /* If the sign bit is set, propagate to all the higher order\n * bits, to cap the negative value. If it's clear, mask to\n * the positive integer limit. */\n if (bits < 64) {\n uint64_t mask = ((uint64_t)-1) << bits;\n if (c & msb) {\n c |= mask;\n } else {\n c &= ~mask;\n }\n }\n *limit = c;\n }\n return 1;\n}\n\n/* Debugging function. Just show bits in the specified bitmap. Not used\n * but here for not having to rewrite it when debugging is needed. */\nvoid printBits(unsigned char *p, unsigned long count) {\n unsigned long j, i, byte;\n\n for (j = 0; j < count; j++) {\n byte = p[j];\n for (i = 0x80; i > 0; i /= 2)\n printf(\"%c\", (byte & i) ? '1' : '0');\n printf(\"|\");\n }\n printf(\"\\n\");\n}\n\n/* -----------------------------------------------------------------------------\n * Bits related string commands: GETBIT, SETBIT, BITCOUNT, BITOP.\n * -------------------------------------------------------------------------- */\n\n#define BITOP_AND 0\n#define BITOP_OR 1\n#define BITOP_XOR 2\n#define BITOP_NOT 3\n#define BITOP_DIFF 4 /* DIFF(X, A1, A2, ..., An) = X & !(A1 | A2 | ... | An) */\n#define BITOP_DIFF1 5 /* DIFF1(X, A1, A2, ..., An) = !X & (A1 | A2 | ... | An) */\n#define BITOP_ANDOR 6 /* ANDOR(X, A1, A2, ..., An) = X & (A1 | A2 | ... | An) */\n\n/* ONE(A1, A2, ..., An) = X.\n * If X[i] is the i-th bit of X then:\n * X[i] == 1 if and only if there is m such that:\n * Am[i] == 1 and Al[i] == 0 for all l != m. */\n#define BITOP_ONE 7\n\n#define BITFIELDOP_GET 0\n#define BITFIELDOP_SET 1\n#define BITFIELDOP_INCRBY 2\n\n/* This helper function used by GETBIT / SETBIT parses the bit offset argument\n * making sure an error is returned if it is negative or if it overflows\n * Redis 512 MB limit for the string value or more (server.proto_max_bulk_len).\n *\n * If the 'hash' argument is true, and 'bits is positive, then the command\n * will also parse bit offsets prefixed by \"#\". In such a case the offset\n * is multiplied by 'bits'. This is useful for the BITFIELD command. */\nint getBitOffsetFromArgument(client *c, robj *o, uint64_t *offset, int hash, int bits) {\n long long loffset;\n char *err = \"bit offset is not an integer or out of range\";\n char *p = o->ptr;\n size_t plen = sdslen(p);\n int usehash = 0;\n\n /* Handle # form. */\n if (p[0] == '#' && hash && bits > 0) usehash = 1;\n\n if (string2ll(p+usehash,plen-usehash,&loffset) == 0) {\n addReplyError(c,err);\n return C_ERR;\n }\n\n /* Adjust the offset by 'bits' for # form. */\n if (usehash) loffset *= bits;\n\n /* Limit offset to server.proto_max_bulk_len (512MB in bytes by default) */\n if (loffset < 0 || (!mustObeyClient(c) && (loffset >> 3) >= server.proto_max_bulk_len))\n {\n addReplyError(c,err);\n return C_ERR;\n }\n\n *offset = loffset;\n return C_OK;\n}\n\n/* This helper function for BITFIELD parses a bitfield type in the form\n * where sign is 'u' or 'i' for unsigned and signed, and\n * the bits is a value between 1 and 64. However 64 bits unsigned integers\n * are reported as an error because of current limitations of Redis protocol\n * to return unsigned integer values greater than INT64_MAX.\n *\n * On error C_ERR is returned and an error is sent to the client. */\nint getBitfieldTypeFromArgument(client *c, robj *o, int *sign, int *bits) {\n char *p = o->ptr;\n char *err = \"Invalid bitfield type. Use something like i16 u8. Note that u64 is not supported but i64 is.\";\n long long llbits;\n\n if (p[0] == 'i') {\n *sign = 1;\n } else if (p[0] == 'u') {\n *sign = 0;\n } else {\n addReplyError(c,err);\n return C_ERR;\n }\n\n if ((string2ll(p+1,strlen(p+1),&llbits)) == 0 ||\n llbits < 1 ||\n (*sign == 1 && llbits > 64) ||\n (*sign == 0 && llbits > 63))\n {\n addReplyError(c,err);\n return C_ERR;\n }\n *bits = llbits;\n return C_OK;\n}\n\n/* This is a helper function for commands implementations that need to write\n * bits to a string object. The command creates or pad with zeroes the string\n * so that the 'maxbit' bit can be addressed. The object is finally\n * returned. Otherwise if the key holds a wrong type NULL is returned and\n * an error is sent to the client.\n * \n * (Must provide all the arguments to the function)\n */\nstatic kvobj *lookupStringForBitCommand(client *c, uint64_t maxbit, \n size_t *strOldSize, size_t *strGrowSize) \n{\n dictEntryLink link;\n size_t byte = maxbit >> 3;\n size_t oldAllocSize = 0;\n kvobj *o = lookupKeyWriteWithLink(c->db,c->argv[1],&link);\n if (checkType(c,o,OBJ_STRING)) return NULL;\n\n if (o == NULL) {\n o = createObject(OBJ_STRING,sdsnewlen(NULL, byte+1));\n dbAddByLink(c->db,c->argv[1],&o,&link);\n *strGrowSize = byte + 1;\n *strOldSize = 0;\n } else {\n o = dbUnshareStringValue(c->db,c->argv[1],o);\n *strOldSize = sdslen(o->ptr);\n if (server.memory_tracking_enabled)\n oldAllocSize = kvobjAllocSize(o);\n o->ptr = sdsgrowzero(o->ptr,byte+1);\n if (server.memory_tracking_enabled)\n updateSlotAllocSize(c->db, getKeySlot(c->argv[1]->ptr), o, oldAllocSize, kvobjAllocSize(o));\n *strGrowSize = sdslen(o->ptr) - *strOldSize;\n }\n return o;\n}\n\n/* Return a pointer to the string object content, and stores its length\n * in 'len'. The user is required to pass (likely stack allocated) buffer\n * 'llbuf' of at least LONG_STR_SIZE bytes. Such a buffer is used in the case\n * the object is integer encoded in order to provide the representation\n * without using heap allocation.\n *\n * The function returns the pointer to the object array of bytes representing\n * the string it contains, that may be a pointer to 'llbuf' or to the\n * internal object representation. As a side effect 'len' is filled with\n * the length of such buffer.\n *\n * If the source object is NULL the function is guaranteed to return NULL\n * and set 'len' to 0. */\nunsigned char *getObjectReadOnlyString(robj *o, long *len, char *llbuf) {\n serverAssert(!o || o->type == OBJ_STRING);\n unsigned char *p = NULL;\n\n /* Set the 'p' pointer to the string, that can be just a stack allocated\n * array if our string was integer encoded. */\n if (o && o->encoding == OBJ_ENCODING_INT) {\n p = (unsigned char*) llbuf;\n if (len) *len = ll2string(llbuf,LONG_STR_SIZE,(long)o->ptr);\n } else if (o) {\n p = (unsigned char*) o->ptr;\n if (len) *len = sdslen(o->ptr);\n } else {\n if (len) *len = 0;\n }\n return p;\n}\n\n/* SETBIT key offset bitvalue */\nvoid setbitCommand(client *c) {\n char *err = \"bit is not an integer or out of range\";\n uint64_t bitoffset;\n ssize_t byte, bit;\n int byteval, bitval;\n long on;\n\n if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset,0,0) != C_OK)\n return;\n\n if (getLongFromObjectOrReply(c,c->argv[3],&on,err) != C_OK)\n return;\n\n /* Bits can only be set or cleared... */\n if (on & ~1) {\n addReplyError(c,err);\n return;\n }\n\n size_t strOldSize, strGrowSize;\n kvobj *o = lookupStringForBitCommand(c, bitoffset, &strOldSize, &strGrowSize);\n if (o == NULL) return;\n\n /* Get current values */\n byte = bitoffset >> 3;\n byteval = ((uint8_t*)o->ptr)[byte];\n bit = 7 - (bitoffset & 0x7);\n bitval = byteval & (1 << bit);\n\n /* Either it is newly created, changed length, or the bit changes before and after.\n * Note that the bitval here is actually a decimal number.\n * So we need to use `!!` to convert it to 0 or 1 for comparison. */\n if (strGrowSize || (!!bitval != on)) {\n /* Update byte with new bit value. */\n byteval &= ~(1 << bit);\n byteval |= ((on & 0x1) << bit);\n ((uint8_t*)o->ptr)[byte] = byteval;\n keyModified(c,c->db,c->argv[1],o,1);\n notifyKeyspaceEvent(NOTIFY_STRING,\"setbit\",c->argv[1],c->db->id);\n server.dirty++;\n\n /* If this is not a new key (old size not 0) and size changed, then \n * update the keysizes histogram. Otherwise, the histogram already \n * updated in lookupStringForBitCommand() by calling dbAdd(). */\n if ((strOldSize > 0) && (strGrowSize != 0))\n updateKeysizesHist(c->db, OBJ_STRING, strOldSize, strOldSize + strGrowSize);\n }\n\n /* Return original value. */\n addReply(c, bitval ? shared.cone : shared.czero);\n}\n\n/* GETBIT key offset */\nvoid getbitCommand(client *c) {\n char llbuf[32];\n uint64_t bitoffset;\n size_t byte, bit;\n size_t bitval = 0;\n\n if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset,0,0) != C_OK)\n return;\n\n kvobj *kv = lookupKeyReadOrReply(c, c->argv[1], shared.czero);\n if (kv == NULL || checkType(c,kv,OBJ_STRING)) return;\n\n byte = bitoffset >> 3;\n bit = 7 - (bitoffset & 0x7);\n if (sdsEncodedObject(kv)) {\n if (byte < sdslen(kv->ptr))\n bitval = ((uint8_t*)kv->ptr)[byte] & (1 << bit);\n } else {\n if (byte < (size_t)ll2string(llbuf,sizeof(llbuf),(long)kv->ptr))\n bitval = llbuf[byte] & (1 << bit);\n }\n\n addReply(c, bitval ? shared.cone : shared.czero);\n}\n\n#ifdef HAVE_AVX2\n/* Compute the given bitop operation using AVX2 intrinsics.\n * Return how many bytes were successfully processed, as AVX2 operates on\n * 256-bit registers so if `minlen` is not a multiple of 32 some of the bytes\n * will be skipped. They will be taken care for in the unoptimized loop in the\n * main bitopCommand function. */\nATTRIBUTE_TARGET_AVX2\nunsigned long bitopCommandAVX(unsigned char **keys, unsigned char *res, \n unsigned long op, unsigned long numkeys,\n unsigned long minlen)\n{\n const unsigned long step = sizeof(__m256i);\n\n unsigned long i;\n unsigned long processed = 0;\n unsigned char *res_start = res;\n unsigned char *fst_key = keys[0];\n\n if (minlen < step) {\n return 0;\n }\n\n const __m256i max256 = _mm256_set1_epi64x(-1);\n const __m256i zero256 = _mm256_set1_epi64x(0);\n\n switch (op) {\n case BITOP_AND:\n while (minlen >= step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)(keys[0]+processed));\n\n for (i = 1; i < numkeys; i++) {\n __m256i lkey = _mm256_lddqu_si256((__m256i*)(keys[i]+processed));\n lres = _mm256_and_si256(lres, lkey);\n }\n _mm256_storeu_si256((__m256i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n /* Unlike other operations that do the same with all source keys\n * DIFF, DIFF1 and ANDOR all compute the disjunction of all the source keys\n * but the first one. We first store that disjunction in `lres` and later\n * compute the final operation using the first source key. */\n case BITOP_DIFF:\n case BITOP_DIFF1:\n case BITOP_ANDOR:\n case BITOP_OR:\n while (minlen >= step) {\n __m256i lres = (op == BITOP_OR) ?\n _mm256_lddqu_si256((__m256i*)(keys[0]+processed)) :\n zero256;\n\n for (i = 1; i < numkeys; i++) {\n __m256i lkey = _mm256_lddqu_si256((__m256i*)(keys[i]+processed));\n lres = _mm256_or_si256(lres, lkey);\n }\n _mm256_storeu_si256((__m256i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_XOR:\n while (minlen >= step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)(keys[0]+processed));\n\n for (i = 1; i < numkeys; i++) {\n __m256i lkey = _mm256_lddqu_si256((__m256i*)(keys[i]+processed));\n lres = _mm256_xor_si256(lres, lkey);\n }\n _mm256_storeu_si256((__m256i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_NOT:\n while (minlen >= step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)(keys[0]+processed));\n lres = _mm256_xor_si256(lres, max256);\n _mm256_storeu_si256((__m256i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_ONE:\n while (minlen >= step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)(keys[0]+processed));\n __m256i common_bits = zero256;\n\n for (i = 1; i < numkeys; i++) {\n __m256i lkey = _mm256_lddqu_si256((__m256i*)(keys[i]+processed));\n __m256i common = _mm256_and_si256(lres, lkey);\n common_bits = _mm256_or_si256(common_bits, common);\n\n lres = _mm256_xor_si256(lres, lkey);\n }\n lres = _mm256_andnot_si256(common_bits, lres);\n _mm256_storeu_si256((__m256i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n default:\n break;\n }\n\n res = res_start;\n switch (op) {\n case BITOP_DIFF:\n for (i = 0; i < processed; i += step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)res);\n __m256i fkey = _mm256_lddqu_si256((__m256i*)fst_key);\n\n lres = _mm256_andnot_si256(lres, fkey);\n _mm256_storeu_si256((__m256i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n case BITOP_DIFF1:\n for (i = 0; i < processed; i += step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)res);\n __m256i fkey = _mm256_lddqu_si256((__m256i*)fst_key);\n\n lres = _mm256_andnot_si256(fkey, lres);\n _mm256_storeu_si256((__m256i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n case BITOP_ANDOR:\n for (i = 0; i < processed; i += step) {\n __m256i lres = _mm256_lddqu_si256((__m256i*)res);\n __m256i fkey = _mm256_lddqu_si256((__m256i*)fst_key);\n\n lres = _mm256_and_si256(fkey, lres);\n _mm256_storeu_si256((__m256i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n default:\n break;\n }\n\n return processed;\n}\n#endif /* HAVE_AVX2 */\n\n#ifdef HAVE_AVX512\n/* Compute the given bitop operation using AVX512 intrinsics.\n * Return how many bytes were successfully processed, as AVX512 operates on\n * 512-bit registers so if `minlen` is not a multiple of 64 some of the bytes\n * will be skipped. They will be taken care for in the unoptimized loop in the\n * main bitopCommand function. */\nATTRIBUTE_TARGET_AVX512\nunsigned long bitopCommandAVX512(unsigned char **keys, unsigned char *res, \n unsigned long op, unsigned long numkeys,\n unsigned long minlen)\n{\n const unsigned long step = sizeof(__m512i); /* 64 bytes */\n\n unsigned long i;\n unsigned long processed = 0;\n unsigned char *res_start = res;\n unsigned char *fst_key = keys[0];\n\n if (minlen < step) {\n return 0;\n }\n\n const __m512i max512 = _mm512_set1_epi64(-1);\n const __m512i zero512 = _mm512_set1_epi64(0);\n switch (op) {\n case BITOP_AND:\n while (minlen >= step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)(keys[0]+processed));\n\n for (i = 1; i < numkeys; i++) {\n __m512i lkey = _mm512_loadu_si512((__m512i*)(keys[i]+processed));\n lres = _mm512_and_si512(lres, lkey);\n }\n _mm512_storeu_si512((__m512i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n /* Unlike other operations that do the same with all source keys\n * DIFF, DIFF1 and ANDOR all compute the disjunction of all the source keys\n * but the first one. We first store that disjunction in `lres` and later\n * compute the final operation using the first source key. */\n case BITOP_DIFF:\n case BITOP_DIFF1:\n case BITOP_ANDOR:\n case BITOP_OR:\n while (minlen >= step) {\n __m512i lres = (op == BITOP_OR) ?\n _mm512_loadu_si512((__m512i*)(keys[0]+processed)) :\n zero512;\n\n for (i = 1; i < numkeys; i++) {\n __m512i lkey = _mm512_loadu_si512((__m512i*)(keys[i]+processed));\n lres = _mm512_or_si512(lres, lkey);\n }\n _mm512_storeu_si512((__m512i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_XOR:\n while (minlen >= step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)(keys[0]+processed));\n\n for (i = 1; i < numkeys; i++) {\n __m512i lkey = _mm512_loadu_si512((__m512i*)(keys[i]+processed));\n lres = _mm512_xor_si512(lres, lkey);\n }\n _mm512_storeu_si512((__m512i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_NOT:\n while (minlen >= step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)(keys[0]+processed));\n lres = _mm512_xor_si512(lres, max512);\n _mm512_storeu_si512((__m512i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n case BITOP_ONE:\n while (minlen >= step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)(keys[0]+processed));\n __m512i common_bits = zero512;\n\n for (i = 1; i < numkeys; i++) {\n __m512i lkey = _mm512_loadu_si512((__m512i*)(keys[i]+processed));\n /* common_bits |= (lres & lkey): ternary-logic with imm8 0xEA == c|(a&b)\n * (a=lres, b=lkey, c=common_bits), replacing a separate AND+OR. */\n common_bits = _mm512_ternarylogic_epi32(lres, lkey, common_bits, 0xEA);\n\n lres = _mm512_xor_si512(lres, lkey);\n }\n lres = _mm512_andnot_si512(common_bits, lres);\n _mm512_storeu_si512((__m512i*)res, lres);\n res += step;\n processed += step;\n minlen -= step;\n }\n break;\n default:\n break;\n }\n\n res = res_start;\n switch (op) {\n case BITOP_DIFF:\n for (i = 0; i < processed; i += step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)res);\n __m512i fkey = _mm512_loadu_si512((__m512i*)fst_key);\n\n lres = _mm512_andnot_si512(lres, fkey);\n _mm512_storeu_si512((__m512i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n case BITOP_DIFF1:\n for (i = 0; i < processed; i += step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)res);\n __m512i fkey = _mm512_loadu_si512((__m512i*)fst_key);\n\n lres = _mm512_andnot_si512(fkey, lres);\n _mm512_storeu_si512((__m512i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n case BITOP_ANDOR:\n for (i = 0; i < processed; i += step) {\n __m512i lres = _mm512_loadu_si512((__m512i*)res);\n __m512i fkey = _mm512_loadu_si512((__m512i*)fst_key);\n\n lres = _mm512_and_si512(fkey, lres);\n _mm512_storeu_si512((__m512i*)res, lres);\n\n res += step;\n fst_key += step;\n }\n break;\n default:\n break;\n }\n\n return processed;\n}\n#endif /* HAVE_AVX512 */\n\n/* BITOP op_name target_key src_key1 src_key2 src_key3 ... src_keyN */\nREDIS_NO_SANITIZE(\"alignment\")\nvoid bitopCommand(client *c) {\n char *opname = c->argv[1]->ptr;\n robj *targetkey = c->argv[2];\n unsigned long op, j, numkeys;\n robj **objects; /* Array of source objects. */\n unsigned char **src; /* Array of source strings pointers. */\n unsigned long *len, maxlen = 0; /* Array of length of src strings,\n and max len. */\n unsigned long minlen = 0; /* Min len among the input keys. */\n unsigned char *res = NULL; /* Resulting string. */\n\n /* Parse the operation name. */\n if ((opname[0] == 'a' || opname[0] == 'A') && !strcasecmp(opname,\"and\"))\n op = BITOP_AND;\n else if((opname[0] == 'o' || opname[0] == 'O') && !strcasecmp(opname,\"or\"))\n op = BITOP_OR;\n else if((opname[0] == 'x' || opname[0] == 'X') && !strcasecmp(opname,\"xor\"))\n op = BITOP_XOR;\n else if((opname[0] == 'n' || opname[0] == 'N') && !strcasecmp(opname,\"not\"))\n op = BITOP_NOT;\n else if ((opname[0] == 'd' || opname[0] == 'D') && !strcasecmp(opname,\"diff\"))\n op = BITOP_DIFF;\n else if ((opname[0] == 'd' || opname[0] == 'D') && !strcasecmp(opname,\"diff1\"))\n op = BITOP_DIFF1;\n else if ((opname[0] == 'a' || opname[0] == 'A') && !strcasecmp(opname,\"andor\"))\n op = BITOP_ANDOR;\n else if ((opname[0] == 'o' || opname[0] == 'O') && !strcasecmp(opname,\"one\"))\n op = BITOP_ONE;\n else {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n\n /* Sanity check: NOT accepts only a single key argument. */\n if (op == BITOP_NOT && c->argc != 4) {\n addReplyError(c,\"BITOP NOT must be called with a single source key.\");\n return;\n }\n\n if ((op == BITOP_DIFF || op == BITOP_DIFF1 || op == BITOP_ANDOR) && c->argc < 5) {\n sds opname_upper = sdsnew(opname);\n sdstoupper(opname_upper);\n addReplyErrorFormat(c,\"BITOP %s must be called with at least two source keys.\", opname_upper);\n sdsfree(opname_upper);\n return;\n }\n\n /* Lookup keys, and store pointers to the string objects into an array. */\n numkeys = c->argc - 3;\n src = zmalloc(sizeof(unsigned char*) * numkeys);\n len = zmalloc(sizeof(long) * numkeys);\n objects = zmalloc(sizeof(robj*) * numkeys);\n for (j = 0; j < numkeys; j++) {\n kvobj *kv = lookupKeyRead(c->db, c->argv[j + 3]);\n /* Handle non-existing keys as empty strings. */\n if (kv == NULL) {\n objects[j] = NULL;\n src[j] = NULL;\n len[j] = 0;\n minlen = 0;\n continue;\n }\n /* Return an error if one of the keys is not a string. */\n if (checkType(c, kv, OBJ_STRING)) {\n unsigned long i;\n for (i = 0; i < j; i++) {\n if (objects[i])\n decrRefCount(objects[i]);\n }\n zfree(src);\n zfree(len);\n zfree(objects);\n return;\n }\n objects[j] = getDecodedObject(kv);\n src[j] = objects[j]->ptr;\n len[j] = sdslen(objects[j]->ptr);\n if (len[j] > maxlen) maxlen = len[j];\n if (j == 0 || len[j] < minlen) minlen = len[j];\n }\n\n /* Compute the bit operation, if at least one string is not empty. */\n if (maxlen) {\n res = (unsigned char*) sdsnewlen(NULL,maxlen);\n unsigned char output, byte, disjunction, common_bits;\n unsigned long i;\n int useAVX = 0;\n\n /* Number of bytes processed from each source key */\n j = 0;\n\n#if defined(HAVE_AVX512)\n if (BITOP_USE_AVX512 && (minlen >= 10000) && (numkeys >= 8)) {\n j = bitopCommandAVX512(src, res, op, numkeys, minlen);\n\n serverAssert(minlen >= j);\n minlen -= j;\n\n useAVX = 1;\n }\n#endif\n\n#if defined(HAVE_AVX2)\n if (!useAVX && BITOP_USE_AVX2) {\n j = bitopCommandAVX(src, res, op, numkeys, minlen);\n\n serverAssert(minlen >= j);\n minlen -= j;\n\n useAVX = 1;\n }\n#endif\n\n#if !defined(USE_ALIGNED_ACCESS)\n /* If no SIMD path was used (no AVX2/AVX512), fall back \n * to a word-at-a-time fast path that is still much better \n * than the byte-by-byte loop below. On ARM we skip this since \n * it would cause GCC to emit multiple-word load/store ops\n * not supported even on ARM >= v6. */\n if (!useAVX && minlen >= sizeof(unsigned long)*4) {\n\n unsigned long **lp = (unsigned long**)src;\n unsigned long *lres = (unsigned long*) res;\n\n /* Index over the unsigned long version of the source keys */\n size_t k = 0;\n\n /* Unlike other operations that do the same with all source keys\n * DIFF, DIFF1 and ANDOR all compute the disjunction of all the\n * source keys but the first one. We first store that disjunction\n * in `lres` and later compute the final operation using the first\n * source key. */\n if (op != BITOP_DIFF && op != BITOP_DIFF1 && op != BITOP_ANDOR)\n memcpy(lres,src[0],minlen);\n\n /* Different branches per different operations for speed (sorry). */\n if (op == BITOP_AND) {\n while(minlen >= sizeof(unsigned long)*4) {\n for (i = 1; i < numkeys; i++) {\n lres[0] &= lp[i][k+0];\n lres[1] &= lp[i][k+1];\n lres[2] &= lp[i][k+2];\n lres[3] &= lp[i][k+3];\n }\n k+=4;\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n }\n } else if (op == BITOP_OR) {\n while(minlen >= sizeof(unsigned long)*4) {\n for (i = 1; i < numkeys; i++) {\n lres[0] |= lp[i][k+0];\n lres[1] |= lp[i][k+1];\n lres[2] |= lp[i][k+2];\n lres[3] |= lp[i][k+3];\n }\n k+=4;\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n }\n } else if (op == BITOP_XOR) {\n while(minlen >= sizeof(unsigned long)*4) {\n for (i = 1; i < numkeys; i++) {\n lres[0] ^= lp[i][k+0];\n lres[1] ^= lp[i][k+1];\n lres[2] ^= lp[i][k+2];\n lres[3] ^= lp[i][k+3];\n }\n k+=4;\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n }\n } else if (op == BITOP_NOT) {\n while(minlen >= sizeof(unsigned long)*4) {\n lres[0] = ~lres[0];\n lres[1] = ~lres[1];\n lres[2] = ~lres[2];\n lres[3] = ~lres[3];\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n }\n } else if (op == BITOP_DIFF || op == BITOP_DIFF1 || op == BITOP_ANDOR) {\n size_t processed = 0;\n while(minlen >= sizeof(unsigned long)*4) {\n for (i = 1; i < numkeys; i++) {\n lres[0] |= lp[i][k+0];\n lres[1] |= lp[i][k+1];\n lres[2] |= lp[i][k+2];\n lres[3] |= lp[i][k+3];\n }\n k+=4;\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n processed += sizeof(unsigned long)*4;\n }\n\n lres = (unsigned long*) res;\n unsigned long *first_key = (unsigned long*)src[0];\n switch (op) {\n case BITOP_DIFF:\n for (i = 0; i < processed; i += sizeof(unsigned long)*4) {\n lres[0] = (first_key[0] & ~lres[0]);\n lres[1] = (first_key[1] & ~lres[1]);\n lres[2] = (first_key[2] & ~lres[2]);\n lres[3] = (first_key[3] & ~lres[3]);\n lres+=4;\n first_key += 4;\n }\n break;\n case BITOP_DIFF1:\n for (i = 0; i < processed; i += sizeof(unsigned long)*4) {\n lres[0] = (~first_key[0] & lres[0]);\n lres[1] = (~first_key[1] & lres[1]);\n lres[2] = (~first_key[2] & lres[2]);\n lres[3] = (~first_key[3] & lres[3]);\n lres+=4;\n first_key += 4;\n }\n break;\n case BITOP_ANDOR:\n for (i = 0; i < processed; i += sizeof(unsigned long)*4) {\n lres[0] = (first_key[0] & lres[0]);\n lres[1] = (first_key[1] & lres[1]);\n lres[2] = (first_key[2] & lres[2]);\n lres[3] = (first_key[3] & lres[3]);\n lres+=4;\n first_key += 4;\n }\n break;\n }\n } else if (op == BITOP_ONE) {\n unsigned long lcommon_bits[4];\n\n while(minlen >= sizeof(unsigned long)*4) {\n memset(lcommon_bits, 0, sizeof(lcommon_bits));\n\n for (i = 1; i < numkeys; i++) {\n lcommon_bits[0] |= (lres[0] & lp[i][k+0]);\n lcommon_bits[1] |= (lres[1] & lp[i][k+1]);\n lcommon_bits[2] |= (lres[2] & lp[i][k+2]);\n lcommon_bits[3] |= (lres[3] & lp[i][k+3]);\n\n lres[0] ^= lp[i][k+0];\n lres[1] ^= lp[i][k+1];\n lres[2] ^= lp[i][k+2];\n lres[3] ^= lp[i][k+3];\n }\n\n lres[0] &= ~lcommon_bits[0];\n lres[1] &= ~lcommon_bits[1];\n lres[2] &= ~lcommon_bits[2];\n lres[3] &= ~lcommon_bits[3];\n\n k+=4;\n lres+=4;\n j += sizeof(unsigned long)*4;\n minlen -= sizeof(unsigned long)*4;\n }\n }\n }\n#endif /* !defined(USE_ALIGNED_ACCESS) */\n\n /* j is set to the next byte to process by the previous loop. */\n for (; j < maxlen; j++) {\n output = (len[0] <= j) ? 0 : src[0][j];\n if (op == BITOP_NOT) output = ~output;\n disjunction = 0;\n common_bits = 0;\n\n for (i = 1; i < numkeys; i++) {\n int skip = 0;\n byte = (len[i] <= j) ? 0 : src[i][j];\n switch(op) {\n case BITOP_AND:\n output &= byte;\n skip = (output == 0);\n break;\n case BITOP_OR:\n output |= byte;\n skip = (output == 0xff);\n break;\n case BITOP_XOR: output ^= byte; break;\n\n /* For DIFF, DIFF1 and ANDOR we compute the disjunction of all\n * key arguments except the first one. After that we do their\n * respective bit op on said first arg and that disjunction.\n * */\n case BITOP_DIFF:\n case BITOP_DIFF1:\n case BITOP_ANDOR:\n disjunction |= byte;\n skip = (disjunction == 0xff);\n break;\n\n /* BITOP ONE dest key_1 [key_2...]\n * If dest[i] is the i-th bit of dest then:\n * dest[i] == 1 if and only if there is j such that key_j[i] == 1\n * and key_n[i] == 0 for all n != j.\n *\n * In order to compute that on each step we track which bits\n * were seen in more than one key and store that in a helper\n * variable. Then the operation is just XOR but on each step we\n * nullify the bits that are set in the helper.\n * Logically, this operation is the same as nullifying the\n * helper bits only once at the end, but performance-wise it had\n * no significant benefit and makes the code only more unclear.\n *\n * e.g:\n * 0001 0111 # key1\n * 0010 0110 # key2\n *\n * 0011 0001 # intermediate1\n * 0000 0110 # helper\n * 0011 0001 # intermediate1 & ~helper\n *\n * 0100 1101 # key3\n *\n * 0111 1100 # intermediate2\n * 0000 0111 # helper\n * 0111 1000 # intermediate2 & ~helper\n * ---------\n * 0111 1000 # result\n * */\n case BITOP_ONE:\n common_bits |= (output & byte);\n output ^= byte;\n output &= ~common_bits;\n skip = (common_bits == 0xff);\n break;\n default:\n break;\n }\n\n if (skip) {\n break;\n }\n }\n\n switch(op) {\n case BITOP_DIFF:\n res[j] = (output & ~disjunction);\n break;\n case BITOP_DIFF1:\n res[j] = (~output & disjunction);\n break;\n case BITOP_ANDOR:\n res[j] = (output & disjunction);\n break;\n default:\n res[j] = output;\n break;\n }\n }\n }\n for (j = 0; j < numkeys; j++) {\n if (objects[j])\n decrRefCount(objects[j]);\n }\n zfree(src);\n zfree(len);\n zfree(objects);\n\n /* Store the computed value into the target key */\n if (maxlen) {\n robj *o = createObject(OBJ_STRING, res);\n setKey(c, c->db, targetkey, &o, 0);\n notifyKeyspaceEvent(NOTIFY_STRING,\"set\",targetkey,c->db->id);\n server.dirty++;\n } else if (dbDelete(c->db,targetkey)) {\n keyModified(c,c->db,targetkey,NULL,1);\n notifyKeyspaceEvent(NOTIFY_GENERIC,\"del\",targetkey,c->db->id);\n server.dirty++;\n }\n addReplyLongLong(c,maxlen); /* Return the output string length in bytes. */\n}\n\n/* BITCOUNT key [start end [BIT|BYTE]] */\nvoid bitcountCommand(client *c) {\n kvobj *o;\n long long start, end;\n long strlen;\n unsigned char *p;\n char llbuf[LONG_STR_SIZE];\n int isbit = 0;\n unsigned char first_byte_neg_mask = 0, last_byte_neg_mask = 0;\n\n /* Parse start/end range if any. */\n if (c->argc == 4 || c->argc == 5) {\n if (getLongLongFromObjectOrReply(c,c->argv[2],&start,NULL) != C_OK)\n return;\n if (getLongLongFromObjectOrReply(c,c->argv[3],&end,NULL) != C_OK)\n return;\n if (c->argc == 5) {\n if (!strcasecmp(c->argv[4]->ptr,\"bit\")) isbit = 1;\n else if (!strcasecmp(c->argv[4]->ptr,\"byte\")) isbit = 0;\n else {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n }\n /* Lookup, check for type. */\n o = lookupKeyRead(c->db, c->argv[1]);\n if (checkType(c, o, OBJ_STRING)) return;\n p = getObjectReadOnlyString(o,&strlen,llbuf);\n long long totlen = strlen;\n\n /* Make sure we will not overflow */\n serverAssert(totlen <= LLONG_MAX >> 3);\n\n /* Convert negative indexes */\n if (start < 0 && end < 0 && start > end) {\n addReply(c,shared.czero);\n return;\n }\n if (isbit) totlen <<= 3;\n if (start < 0) start = totlen+start;\n if (end < 0) end = totlen+end;\n if (start < 0) start = 0;\n if (end < 0) end = 0;\n if (end >= totlen) end = totlen-1;\n if (isbit && start <= end) {\n /* Before converting bit offset to byte offset, create negative masks\n * for the edges. */\n first_byte_neg_mask = ~((1<<(8-(start&7)))-1) & 0xFF;\n last_byte_neg_mask = (1<<(7-(end&7)))-1;\n start >>= 3;\n end >>= 3;\n }\n } else if (c->argc == 2) {\n /* Lookup, check for type. */\n o = lookupKeyRead(c->db, c->argv[1]);\n if (checkType(c, o, OBJ_STRING)) return;\n p = getObjectReadOnlyString(o,&strlen,llbuf);\n /* The whole string. */\n start = 0;\n end = strlen-1;\n } else {\n /* Syntax error. */\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n\n /* Return 0 for non existing keys. */\n if (o == NULL) {\n addReply(c, shared.czero);\n return;\n }\n\n /* Precondition: end >= 0 && end < strlen, so the only condition where\n * zero can be returned is: start > end. */\n if (start > end) {\n addReply(c,shared.czero);\n } else {\n long bytes = (long)(end-start+1);\n long long count;\n\n /* Use the best available popcount implementation */\n count = redisPopcountAuto(p+start, bytes);\n\n if (first_byte_neg_mask != 0 || last_byte_neg_mask != 0) {\n unsigned char firstlast[2] = {0, 0};\n /* We may count bits of first byte and last byte which are out of\n * range. So we need to subtract them. Here we use a trick. We set\n * bits in the range to zero. So these bit will not be excluded. */\n if (first_byte_neg_mask != 0) firstlast[0] = p[start] & first_byte_neg_mask;\n if (last_byte_neg_mask != 0) firstlast[1] = p[end] & last_byte_neg_mask;\n\n /* Use the same popcount implementation for consistency */\n count -= redisPopcountAuto(firstlast, 2);\n }\n addReplyLongLong(c,count);\n }\n}\n\n/* BITPOS key bit [start [end [BIT|BYTE]]] */\nvoid bitposCommand(client *c) {\n kvobj *o;\n long long start, end;\n long bit, strlen;\n unsigned char *p;\n char llbuf[LONG_STR_SIZE];\n int isbit = 0, end_given = 0;\n unsigned char first_byte_neg_mask = 0, last_byte_neg_mask = 0;\n\n /* Parse the bit argument to understand what we are looking for, set\n * or clear bits. */\n if (getLongFromObjectOrReply(c,c->argv[2],&bit,NULL) != C_OK)\n return;\n if (bit != 0 && bit != 1) {\n addReplyError(c, \"The bit argument must be 1 or 0.\");\n return;\n }\n\n /* Parse start/end range if any. */\n if (c->argc == 4 || c->argc == 5 || c->argc == 6) {\n if (getLongLongFromObjectOrReply(c,c->argv[3],&start,NULL) != C_OK)\n return;\n if (c->argc == 6) {\n if (!strcasecmp(c->argv[5]->ptr,\"bit\")) isbit = 1;\n else if (!strcasecmp(c->argv[5]->ptr,\"byte\")) isbit = 0;\n else {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n }\n if (c->argc >= 5) {\n if (getLongLongFromObjectOrReply(c,c->argv[4],&end,NULL) != C_OK)\n return;\n end_given = 1;\n }\n\n /* Lookup, check for type. */\n o = lookupKeyRead(c->db, c->argv[1]);\n if (checkType(c, o, OBJ_STRING)) return;\n p = getObjectReadOnlyString(o, &strlen, llbuf);\n\n /* Make sure we will not overflow */\n long long totlen = strlen;\n serverAssert(totlen <= LLONG_MAX >> 3);\n\n if (c->argc < 5) {\n if (isbit) end = (totlen<<3) + 7;\n else end = totlen-1;\n }\n\n if (isbit) totlen <<= 3;\n /* Convert negative indexes */\n if (start < 0) start = totlen+start;\n if (end < 0) end = totlen+end;\n if (start < 0) start = 0;\n if (end < 0) end = 0;\n if (end >= totlen) end = totlen-1;\n if (isbit && start <= end) {\n /* Before converting bit offset to byte offset, create negative masks\n * for the edges. */\n first_byte_neg_mask = ~((1<<(8-(start&7)))-1) & 0xFF;\n last_byte_neg_mask = (1<<(7-(end&7)))-1;\n start >>= 3;\n end >>= 3;\n }\n } else if (c->argc == 3) {\n /* Lookup, check for type. */\n o = lookupKeyRead(c->db, c->argv[1]);\n if (checkType(c,o,OBJ_STRING)) return;\n p = getObjectReadOnlyString(o,&strlen,llbuf);\n\n /* The whole string. */\n start = 0;\n end = strlen-1;\n } else {\n /* Syntax error. */\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n\n /* If the key does not exist, from our point of view it is an infinite\n * array of 0 bits. If the user is looking for the first clear bit return 0,\n * If the user is looking for the first set bit, return -1. */\n if (o == NULL) {\n addReplyLongLong(c, bit ? -1 : 0);\n return;\n }\n\n /* For empty ranges (start > end) we return -1 as an empty range does\n * not contain a 0 nor a 1. */\n if (start > end) {\n addReplyLongLong(c, -1);\n } else {\n long bytes = end-start+1;\n long long pos;\n unsigned char tmpchar;\n if (first_byte_neg_mask) {\n if (bit) tmpchar = p[start] & ~first_byte_neg_mask;\n else tmpchar = p[start] | first_byte_neg_mask;\n /* Special case, there is only one byte */\n if (last_byte_neg_mask && bytes == 1) {\n if (bit) tmpchar = tmpchar & ~last_byte_neg_mask;\n else tmpchar = tmpchar | last_byte_neg_mask;\n }\n pos = redisBitpos(&tmpchar,1,bit);\n /* If there are no more bytes or we get valid pos, we can exit early */\n if (bytes == 1 || (pos != -1 && pos != 8)) goto result;\n start++;\n bytes--;\n }\n /* If the last byte has not bits in the range, we should exclude it */\n long curbytes = bytes - (last_byte_neg_mask ? 1 : 0);\n if (curbytes > 0) {\n pos = redisBitpos(p+start,curbytes,bit);\n /* If there is no more bytes or we get valid pos, we can exit early */\n if (bytes == curbytes || (pos != -1 && pos != (long long)curbytes<<3)) goto result;\n start += curbytes;\n bytes -= curbytes;\n }\n if (bit) tmpchar = p[end] & ~last_byte_neg_mask;\n else tmpchar = p[end] | last_byte_neg_mask;\n pos = redisBitpos(&tmpchar,1,bit);\n\n result:\n /* If we are looking for clear bits, and the user specified an exact\n * range with start-end, we can't consider the right of the range as\n * zero padded (as we do when no explicit end is given).\n *\n * So if redisBitpos() returns the first bit outside the range,\n * we return -1 to the caller, to mean, in the specified range there\n * is not a single \"0\" bit. */\n if (end_given && bit == 0 && pos == (long long)bytes<<3) {\n addReplyLongLong(c,-1);\n return;\n }\n if (pos != -1) pos += (long long)start<<3; /* Adjust for the bytes we skipped. */\n addReplyLongLong(c,pos);\n }\n}\n\n/* BITFIELD key subcommand-1 arg ... subcommand-2 arg ... subcommand-N ...\n *\n * Supported subcommands:\n *\n * GET \n * SET \n * INCRBY \n * OVERFLOW [WRAP|SAT|FAIL]\n */\n\n#define BITFIELD_FLAG_NONE 0\n#define BITFIELD_FLAG_READONLY (1<<0)\n\nstruct bitfieldOp {\n uint64_t offset; /* Bitfield offset. */\n int64_t i64; /* Increment amount (INCRBY) or SET value */\n int opcode; /* Operation id. */\n int owtype; /* Overflow type to use. */\n int bits; /* Integer bitfield bits width. */\n int sign; /* True if signed, otherwise unsigned op. */\n};\n\n/* This implements both the BITFIELD command and the BITFIELD_RO command\n * when flags is set to BITFIELD_FLAG_READONLY: in this case only the\n * GET subcommand is allowed, other subcommands will return an error. */\nvoid bitfieldGeneric(client *c, int flags) {\n kvobj *o;\n uint64_t bitoffset;\n int j, numops = 0, changes = 0;\n size_t strOldSize = 0, strGrowSize = 0;\n struct bitfieldOp *ops = NULL; /* Array of ops to execute at end. */\n int owtype = BFOVERFLOW_WRAP; /* Overflow type. */\n int readonly = 1;\n uint64_t highest_write_offset = 0;\n\n for (j = 2; j < c->argc; j++) {\n int remargs = c->argc-j-1; /* Remaining args other than current. */\n char *subcmd = c->argv[j]->ptr; /* Current command name. */\n int opcode; /* Current operation code. */\n long long i64 = 0; /* Signed SET value. */\n int sign = 0; /* Signed or unsigned type? */\n int bits = 0; /* Bitfield width in bits. */\n\n if (!strcasecmp(subcmd,\"get\") && remargs >= 2)\n opcode = BITFIELDOP_GET;\n else if (!strcasecmp(subcmd,\"set\") && remargs >= 3)\n opcode = BITFIELDOP_SET;\n else if (!strcasecmp(subcmd,\"incrby\") && remargs >= 3)\n opcode = BITFIELDOP_INCRBY;\n else if (!strcasecmp(subcmd,\"overflow\") && remargs >= 1) {\n char *owtypename = c->argv[j+1]->ptr;\n j++;\n if (!strcasecmp(owtypename,\"wrap\"))\n owtype = BFOVERFLOW_WRAP;\n else if (!strcasecmp(owtypename,\"sat\"))\n owtype = BFOVERFLOW_SAT;\n else if (!strcasecmp(owtypename,\"fail\"))\n owtype = BFOVERFLOW_FAIL;\n else {\n addReplyError(c,\"Invalid OVERFLOW type specified\");\n zfree(ops);\n return;\n }\n continue;\n } else {\n addReplyErrorObject(c,shared.syntaxerr);\n zfree(ops);\n return;\n }\n\n /* Get the type and offset arguments, common to all the ops. */\n if (getBitfieldTypeFromArgument(c,c->argv[j+1],&sign,&bits) != C_OK) {\n zfree(ops);\n return;\n }\n\n if (getBitOffsetFromArgument(c,c->argv[j+2],&bitoffset,1,bits) != C_OK){\n zfree(ops);\n return;\n }\n\n if (opcode != BITFIELDOP_GET) {\n readonly = 0;\n if (highest_write_offset < bitoffset + bits - 1)\n highest_write_offset = bitoffset + bits - 1;\n /* INCRBY and SET require another argument. */\n if (getLongLongFromObjectOrReply(c,c->argv[j+3],&i64,NULL) != C_OK){\n zfree(ops);\n return;\n }\n }\n\n /* Populate the array of operations we'll process. */\n ops = zrealloc(ops,sizeof(*ops)*(numops+1));\n ops[numops].offset = bitoffset;\n ops[numops].i64 = i64;\n ops[numops].opcode = opcode;\n ops[numops].owtype = owtype;\n ops[numops].bits = bits;\n ops[numops].sign = sign;\n numops++;\n\n j += 3 - (opcode == BITFIELDOP_GET);\n }\n\n if (readonly) {\n /* Lookup for read is ok if key doesn't exit, but errors\n * if it's not a string. */\n o = lookupKeyRead(c->db,c->argv[1]);\n if (o != NULL && checkType(c,o,OBJ_STRING)) {\n zfree(ops);\n return;\n }\n } else {\n if (flags & BITFIELD_FLAG_READONLY) {\n zfree(ops);\n addReplyError(c, \"BITFIELD_RO only supports the GET subcommand\");\n return;\n }\n\n /* Lookup by making room up to the farthest bit reached by\n * this operation. */\n if ((o = lookupStringForBitCommand(c,\n highest_write_offset,&strOldSize,&strGrowSize)) == NULL) {\n zfree(ops);\n return;\n }\n }\n\n addReplyArrayLen(c,numops);\n\n /* Actually process the operations. */\n for (j = 0; j < numops; j++) {\n struct bitfieldOp *thisop = ops+j;\n\n /* Execute the operation. */\n if (thisop->opcode == BITFIELDOP_SET ||\n thisop->opcode == BITFIELDOP_INCRBY)\n {\n /* SET and INCRBY: We handle both with the same code path\n * for simplicity. SET return value is the previous value so\n * we need fetch & store as well. */\n\n /* We need two different but very similar code paths for signed\n * and unsigned operations, since the set of functions to get/set\n * the integers and the used variables types are different. */\n if (thisop->sign) {\n int64_t oldval, newval, wrapped, retval;\n int overflow;\n\n oldval = getSignedBitfield(o->ptr,thisop->offset,\n thisop->bits);\n\n if (thisop->opcode == BITFIELDOP_INCRBY) {\n overflow = checkSignedBitfieldOverflow(oldval,\n thisop->i64,thisop->bits,thisop->owtype,&wrapped);\n newval = overflow ? wrapped : oldval + thisop->i64;\n retval = newval;\n } else {\n newval = thisop->i64;\n overflow = checkSignedBitfieldOverflow(newval,\n 0,thisop->bits,thisop->owtype,&wrapped);\n if (overflow) newval = wrapped;\n retval = oldval;\n }\n\n /* On overflow of type is \"FAIL\", don't write and return\n * NULL to signal the condition. */\n if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {\n addReplyLongLong(c,retval);\n setSignedBitfield(o->ptr,thisop->offset,\n thisop->bits,newval);\n\n if (strGrowSize || (oldval != newval))\n changes++;\n } else {\n addReplyNull(c);\n }\n } else {\n /* Initialization of 'wrapped' is required to avoid\n * false-positive warning \"-Wmaybe-uninitialized\" */\n uint64_t oldval, newval, retval, wrapped = 0;\n int overflow;\n\n oldval = getUnsignedBitfield(o->ptr,thisop->offset,\n thisop->bits);\n\n if (thisop->opcode == BITFIELDOP_INCRBY) {\n newval = oldval + thisop->i64;\n overflow = checkUnsignedBitfieldOverflow(oldval,\n thisop->i64,thisop->bits,thisop->owtype,&wrapped);\n if (overflow) newval = wrapped;\n retval = newval;\n } else {\n newval = thisop->i64;\n overflow = checkUnsignedBitfieldOverflow(newval,\n 0,thisop->bits,thisop->owtype,&wrapped);\n if (overflow) newval = wrapped;\n retval = oldval;\n }\n /* On overflow of type is \"FAIL\", don't write and return\n * NULL to signal the condition. */\n if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {\n addReplyLongLong(c,retval);\n setUnsignedBitfield(o->ptr,thisop->offset,\n thisop->bits,newval);\n\n if (strGrowSize || (oldval != newval))\n changes++;\n } else {\n addReplyNull(c);\n }\n }\n } else {\n /* GET */\n unsigned char buf[9];\n long strlen = 0;\n unsigned char *src = NULL;\n char llbuf[LONG_STR_SIZE];\n\n if (o != NULL)\n src = getObjectReadOnlyString(o,&strlen,llbuf);\n\n /* For GET we use a trick: before executing the operation\n * copy up to 9 bytes to a local buffer, so that we can easily\n * execute up to 64 bit operations that are at actual string\n * object boundaries. */\n memset(buf,0,9);\n int i;\n uint64_t byte = thisop->offset >> 3;\n for (i = 0; i < 9; i++) {\n if (src == NULL || i+byte >= (uint64_t)strlen) break;\n buf[i] = src[i+byte];\n }\n\n /* Now operate on the copied buffer which is guaranteed\n * to be zero-padded. */\n if (thisop->sign) {\n int64_t val = getSignedBitfield(buf,thisop->offset-(byte*8),\n thisop->bits);\n addReplyLongLong(c,val);\n } else {\n uint64_t val = getUnsignedBitfield(buf,thisop->offset-(byte*8),\n thisop->bits);\n addReplyLongLong(c,val);\n }\n }\n }\n\n if (changes) {\n\n /* If this is not a new key (old size not 0) and size changed, then \n * update the keysizes histogram. Otherwise, the histogram already \n * updated in lookupStringForBitCommand() by calling dbAdd(). */\n if ((strOldSize > 0) && (strGrowSize != 0))\n updateKeysizesHist(c->db, OBJ_STRING, strOldSize, strOldSize + strGrowSize);\n \n keyModified(c,c->db,c->argv[1],o,1);\n notifyKeyspaceEvent(NOTIFY_STRING,\"setbit\",c->argv[1],c->db->id);\n server.dirty += changes;\n }\n zfree(ops);\n}\n\nvoid bitfieldCommand(client *c) {\n bitfieldGeneric(c, BITFIELD_FLAG_NONE);\n}\n\nvoid bitfieldroCommand(client *c) {\n bitfieldGeneric(c, BITFIELD_FLAG_READONLY);\n}\n\n#ifdef REDIS_TEST\n/* Test function to verify popcount implementations */\nint bitopsTest(int argc, char **argv, int flags) {\n UNUSED(argc);\n UNUSED(argv);\n UNUSED(flags);\n\n /* Test data with known popcount values */\n unsigned char test_data[] = {0xFF, 0x00, 0xAA, 0x55, 0xF0, 0x0F, 0x33, 0xCC};\n int expected_bits = 8 + 0 + 4 + 4 + 4 + 4 + 4 + 4; /* = 32 bits */\n\n long long result_regular = redisPopcount(test_data, sizeof(test_data));\n\n printf(\"Regular popcount: %lld (expected: %d)\\n\", result_regular, expected_bits);\n\n if (result_regular != expected_bits) {\n printf(\"FAIL: Regular popcount mismatch\\n\");\n return 1;\n }\n\n#ifdef HAVE_AVX2\n if (BITOP_USE_AVX2) {\n long long result_avx2 = redisPopCountAvx2(test_data, sizeof(test_data));\n printf(\"AVX2 popcount: %lld (expected: %d)\\n\", result_avx2, expected_bits);\n\n if (result_avx2 != expected_bits) {\n printf(\"FAIL: AVX2 popcount mismatch\\n\");\n return 1;\n }\n } else {\n printf(\"AVX2 not supported on this CPU\\n\");\n }\n#else\n printf(\"AVX2 not compiled in\\n\");\n#endif\n\n#ifdef HAVE_AVX512\n if (BITOP_USE_AVX512) {\n long long result_avx512 = redisPopCountAvx512(test_data, sizeof(test_data));\n printf(\"AVX512 popcount: %lld (expected: %d)\\n\", result_avx512, expected_bits);\n\n if (result_avx512 != expected_bits) {\n printf(\"FAIL: AVX512 popcount mismatch\\n\");\n return 1;\n }\n } else {\n printf(\"AVX512 not supported on this CPU\\n\");\n }\n#else\n printf(\"AVX512 not compiled in\\n\");\n#endif\n\n#ifdef HAVE_AARCH64_NEON\n {\n long long result_aarch64 = redisPopCountAarch64(test_data, sizeof(test_data));\n printf(\"AArch64 NEON popcount: %lld (expected: %d)\\n\", result_aarch64, expected_bits);\n\n if (result_aarch64 != expected_bits) {\n printf(\"FAIL: AArch64 NEON popcount mismatch\\n\");\n return 1;\n }\n }\n#else\n printf(\"AArch64 NEON not available\\n\");\n#endif\n printf(\"All popcount tests passed!\\n\");\n return 0;\n}\n#endif\n" }, { "path": "src/blocked.c", "content": "/* blocked.c - generic support for blocking operations like BLPOP & WAIT.\n *\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Copyright (c) 2024-present, Valkey contributors.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n *\n * Portions of this file are available under BSD3 terms; see REDISCONTRIBUTIONS for more information.\n *\n * ---------------------------------------------------------------------------\n *\n * API:\n *\n * blockClient() set the CLIENT_BLOCKED flag in the client, and set the\n * specified block type 'btype' filed to one of BLOCKED_* macros.\n *\n * unblockClient() unblocks the client doing the following:\n * 1) It calls the btype-specific function to cleanup the state.\n * 2) It unblocks the client by unsetting the CLIENT_BLOCKED flag.\n * 3) It puts the client into a list of just unblocked clients that are\n * processed ASAP in the beforeSleep() event loop callback, so that\n * if there is some query buffer to process, we do it. This is also\n * required because otherwise there is no 'readable' event fired, we\n * already read the pending commands. We also set the CLIENT_UNBLOCKED\n * flag to remember the client is in the unblocked_clients list.\n *\n * processUnblockedClients() is called inside the beforeSleep() function\n * to process the query buffer from unblocked clients and remove the clients\n * from the blocked_clients queue.\n *\n * replyToBlockedClientTimedOut() is called by the cron function when\n * a client blocked reaches the specified timeout (if the timeout is set\n * to 0, no timeout is processed).\n * It usually just needs to send a reply to the client.\n *\n * When implementing a new type of blocking operation, the implementation\n * should modify unblockClient() and replyToBlockedClientTimedOut() in order\n * to handle the btype-specific behavior of this two functions.\n * If the blocking operation waits for certain keys to change state, the\n * clusterRedirectBlockedClientIfNeeded() function should also be updated.\n */\n\n#include \"server.h\"\n#include \"slowlog.h\"\n#include \"latency.h\"\n#include \"monotonic.h\"\n#include \"cluster_slot_stats.h\"\n\n/* forward declarations */\nstatic void unblockClientWaitingData(client *c);\nstatic void handleClientsBlockedOnKey(readyList *rl);\nstatic void unblockClientOnKey(client *c, robj *key);\nstatic void moduleUnblockClientOnKey(client *c, robj *key);\nstatic void releaseBlockedEntry(client *c, dictEntry *de, int remove_key);\n\nvoid initClientBlockingState(client *c) {\n c->bstate.btype = BLOCKED_NONE;\n c->bstate.timeout = 0;\n c->bstate.keys = dictCreate(&objectKeyHeapPointerValueDictType);\n c->bstate.numreplicas = 0;\n c->bstate.reploffset = 0;\n c->bstate.unblock_on_nokey = 0;\n c->bstate.async_rm_call_handle = NULL;\n}\n\n/* Block a client for the specific operation type. Once the CLIENT_BLOCKED\n * flag is set client query buffer is not longer processed, but accumulated,\n * and will be processed when the client is unblocked. */\nvoid blockClient(client *c, int btype) {\n /* Master client should never be blocked unless pause or module */\n serverAssert(!(c->flags & CLIENT_MASTER &&\n btype != BLOCKED_MODULE &&\n btype != BLOCKED_LAZYFREE &&\n btype != BLOCKED_POSTPONE &&\n btype != BLOCKED_POSTPONE_TRIM));\n\n c->flags |= CLIENT_BLOCKED;\n c->bstate.btype = btype;\n if (!(c->flags & CLIENT_MODULE)) server.blocked_clients++; /* We count blocked client stats on regular clients and not on module clients */\n server.blocked_clients_by_type[btype]++;\n addClientToTimeoutTable(c);\n}\n\n/* Usually when a client is unblocked due to being blocked while processing some command\n * he will attempt to reprocess the command which will update the statistics.\n * However in case the client was timed out or in case of module blocked client is being unblocked\n * the command will not be reprocessed and we need to make stats update.\n * This function will make updates to the commandstats, slowlog and monitors.*/\nvoid updateStatsOnUnblock(client *c, long blocked_us, long reply_us, int had_errors){\n const ustime_t total_cmd_duration = c->duration + blocked_us + reply_us;\n clusterSlotStatsAddCpuDuration(c, total_cmd_duration);\n c->lastcmd->microseconds += total_cmd_duration;\n c->lastcmd->calls++;\n c->commands_processed++;\n server.stat_numcommands++;\n if (had_errors)\n c->lastcmd->failed_calls++;\n if (server.latency_tracking_enabled)\n updateCommandLatencyHistogram(&(c->lastcmd->latency_histogram), total_cmd_duration*1000);\n /* Log the command into the Slow log if needed. */\n slowlogPushCurrentCommand(c, c->lastcmd, total_cmd_duration);\n c->duration = 0;\n /* Log the reply duration event. */\n latencyAddSampleIfNeeded(\"command-unblocking\",reply_us/1000);\n}\n\n/* This function is called in the beforeSleep() function of the event loop\n * in order to process the pending input buffer of clients that were\n * unblocked after a blocking operation. */\nvoid processUnblockedClients(void) {\n listNode *ln;\n client *c;\n\n while (listLength(server.unblocked_clients)) {\n ln = listFirst(server.unblocked_clients);\n serverAssert(ln != NULL);\n c = ln->value;\n listDelNode(server.unblocked_clients,ln);\n c->flags &= ~CLIENT_UNBLOCKED;\n\n /* Reset the client for a new query, unless the client has pending command to process. */\n if (!(c->flags & CLIENT_PENDING_COMMAND)) {\n freeClientOriginalArgv(c);\n /* Clients that are not blocked on keys are not reprocessed so we must\n * call reqresAppendResponse here (for clients blocked on key,\n * unblockClientOnKey is called, which eventually calls processCommand,\n * which calls reqresAppendResponse) */\n prepareForNextCommand(c, 0);\n }\n\n if (c->flags & CLIENT_MODULE) {\n if (!(c->flags & CLIENT_BLOCKED)) {\n moduleCallCommandUnblockedHandler(c);\n }\n continue;\n }\n\n /* Process remaining data in the input buffer, unless the client\n * is blocked again. Actually processInputBuffer() checks that the\n * client is not blocked before to proceed, but things may change and\n * the code is conceptually more correct this way. */\n if (!(c->flags & CLIENT_BLOCKED)) {\n /* If we have a queued command, execute it now. */\n if (processPendingCommandAndInputBuffer(c) == C_ERR) {\n c = NULL;\n }\n }\n beforeNextClient(c);\n }\n}\n\n/* This function will schedule the client for reprocessing at a safe time.\n *\n * This is useful when a client was blocked for some reason (blocking operation,\n * CLIENT PAUSE, or whatever), because it may end with some accumulated query\n * buffer that needs to be processed ASAP:\n *\n * 1. When a client is blocked, its readable handler is still active.\n * 2. However in this case it only gets data into the query buffer, but the\n * query is not parsed or executed once there is enough to proceed as\n * usually (because the client is blocked... so we can't execute commands).\n * 3. When the client is unblocked, without this function, the client would\n * have to write some query in order for the readable handler to finally\n * call processQueryBuffer*() on it.\n * 4. With this function instead we can put the client in a queue that will\n * process it for queries ready to be executed at a safe time.\n */\nvoid queueClientForReprocessing(client *c) {\n /* The client may already be into the unblocked list because of a previous\n * blocking operation, don't add back it into the list multiple times. */\n if (!(c->flags & CLIENT_UNBLOCKED)) {\n c->flags |= CLIENT_UNBLOCKED;\n listAddNodeTail(server.unblocked_clients,c);\n }\n}\n\n/* Unblock a client calling the right function depending on the kind\n * of operation the client is blocking for. */\nvoid unblockClient(client *c, int queue_for_reprocessing) {\n if (c->bstate.btype == BLOCKED_LIST ||\n c->bstate.btype == BLOCKED_ZSET ||\n c->bstate.btype == BLOCKED_STREAM) {\n unblockClientWaitingData(c);\n } else if (c->bstate.btype == BLOCKED_WAIT || c->bstate.btype == BLOCKED_WAITAOF) {\n unblockClientWaitingReplicas(c);\n } else if (c->bstate.btype == BLOCKED_MODULE) {\n if (moduleClientIsBlockedOnKeys(c)) unblockClientWaitingData(c);\n unblockClientFromModule(c);\n } else if (c->bstate.btype == BLOCKED_POSTPONE || c->bstate.btype == BLOCKED_POSTPONE_TRIM) {\n listDelNode(server.postponed_clients,c->postponed_list_node);\n c->postponed_list_node = NULL;\n } else if (c->bstate.btype == BLOCKED_SHUTDOWN) {\n /* No special cleanup. */\n } else if (c->bstate.btype == BLOCKED_LAZYFREE) {\n /* No special cleanup. */\n } else {\n serverPanic(\"Unknown btype in unblockClient().\");\n }\n\n\n /* Clear the flags, and put the client in the unblocked list so that\n * we'll process new commands in its query buffer ASAP. */\n if (!(c->flags & CLIENT_MODULE)) server.blocked_clients--; /* We count blocked client stats on regular clients and not on module clients */\n server.blocked_clients_by_type[c->bstate.btype]--;\n c->flags &= ~CLIENT_BLOCKED;\n c->bstate.btype = BLOCKED_NONE;\n c->bstate.unblock_on_nokey = 0;\n removeClientFromTimeoutTable(c);\n if (queue_for_reprocessing) queueClientForReprocessing(c);\n}\n\n/* Check if the specified client can be safely timed out using\n * unblockClientOnTimeout(). */\nint blockedClientMayTimeout(client *c) {\n if (c->bstate.btype == BLOCKED_MODULE) {\n return moduleBlockedClientMayTimeout(c);\n }\n\n if (c->bstate.btype == BLOCKED_LIST ||\n c->bstate.btype == BLOCKED_ZSET ||\n c->bstate.btype == BLOCKED_STREAM ||\n c->bstate.btype == BLOCKED_WAIT ||\n c->bstate.btype == BLOCKED_WAITAOF)\n {\n return 1;\n }\n return 0;\n}\n\n/* This function gets called when a blocked client timed out in order to\n * send it a reply of some kind. After this function is called,\n * unblockClient() will be called with the same client as argument. */\nvoid replyToBlockedClientTimedOut(client *c) {\n if (c->bstate.btype == BLOCKED_LAZYFREE) {\n /* SFLUSH: reply with empty array, FLUSH*: reply with OK */\n if (c->cmd && c->cmd->proc == sflushCommand)\n addReplyArrayLen(c, 0);\n else\n addReply(c, shared.ok); /* No reason lazy-free to fail */\n } else if (c->bstate.btype == BLOCKED_LIST ||\n c->bstate.btype == BLOCKED_ZSET ||\n c->bstate.btype == BLOCKED_STREAM) {\n addReplyNullArray(c);\n updateStatsOnUnblock(c, 0, 0, 0);\n } else if (c->bstate.btype == BLOCKED_WAIT) {\n addReplyLongLong(c,replicationCountAcksByOffset(c->bstate.reploffset));\n } else if (c->bstate.btype == BLOCKED_WAITAOF) {\n addReplyArrayLen(c,2);\n addReplyLongLong(c,server.fsynced_reploff >= c->bstate.reploffset);\n addReplyLongLong(c,replicationCountAOFAcksByOffset(c->bstate.reploffset));\n } else if (c->bstate.btype == BLOCKED_MODULE) {\n moduleBlockedClientTimedOut(c);\n } else {\n serverPanic(\"Unknown btype in replyToBlockedClientTimedOut().\");\n }\n}\n\n/* If one or more clients are blocked on the SHUTDOWN command, this function\n * sends them an error reply and unblocks them. */\nvoid replyToClientsBlockedOnShutdown(void) {\n if (server.blocked_clients_by_type[BLOCKED_SHUTDOWN] == 0) return;\n listNode *ln;\n listIter li;\n listRewind(server.clients, &li);\n while((ln = listNext(&li))) {\n client *c = listNodeValue(ln);\n if (c->flags & CLIENT_BLOCKED && c->bstate.btype == BLOCKED_SHUTDOWN) {\n c->duration = 0;\n addReplyError(c, \"Errors trying to SHUTDOWN. Check logs.\");\n unblockClient(c, 1);\n }\n }\n}\n\n/* Mass-unblock clients because something changed in the instance that makes\n * blocking no longer safe. For example clients blocked in list operations\n * in an instance which turns from master to slave is unsafe, so this function\n * is called when a master turns into a slave.\n *\n * The semantics is to send an -UNBLOCKED error to the client, disconnecting\n * it at the same time. */\nvoid disconnectAllBlockedClients(void) {\n listNode *ln;\n listIter li;\n\n listRewind(server.clients,&li);\n while((ln = listNext(&li))) {\n client *c = listNodeValue(ln);\n\n if (c->flags & CLIENT_BLOCKED) {\n /* POSTPONEd clients are an exception, when they'll be unblocked, the\n * command processing will start from scratch, and the command will\n * be either executed or rejected. (unlike LIST blocked clients for\n * which the command is already in progress in a way. */\n if (c->bstate.btype == BLOCKED_POSTPONE || c->bstate.btype == BLOCKED_POSTPONE_TRIM)\n continue;\n\n if (c->bstate.btype == BLOCKED_LAZYFREE) {\n /* SFLUSH: reply with empty array, FLUSH*: reply with OK */\n if (c->cmd && c->cmd->proc == sflushCommand)\n addReplyArrayLen(c, 0);\n else\n addReply(c, shared.ok);\n updateStatsOnUnblock(c, 0, 0, 0);\n c->flags &= ~CLIENT_PENDING_COMMAND;\n unblockClient(c, 1);\n } else {\n\n unblockClientOnError(c,\n \"-UNBLOCKED force unblock from blocking operation, \"\n \"instance state changed (master -> replica?)\");\n }\n c->flags |= CLIENT_CLOSE_AFTER_REPLY;\n }\n }\n}\n\n/* This function should be called by Redis every time a single command,\n * a MULTI/EXEC block, or a Lua script, terminated its execution after\n * being called by a client. It handles serving clients blocked in all scenarios\n * where a specific key access requires to block until that key is available.\n *\n * All the keys with at least one client blocked that are signaled as ready\n * are accumulated into the server.ready_keys list. This function will run\n * the list and will serve clients accordingly.\n * Note that the function will iterate again and again (for example as a result of serving BLMOVE\n * we can have new blocking clients to serve because of the PUSH side of BLMOVE.)\n *\n * This function is normally \"fair\", that is, it will serve clients\n * using a FIFO behavior. However this fairness is violated in certain\n * edge cases, that is, when we have clients blocked at the same time\n * in a sorted set and in a list, for the same key (a very odd thing to\n * do client side, indeed!). Because mismatching clients (blocking for\n * a different type compared to the current key type) are moved in the\n * other side of the linked list. However as long as the key starts to\n * be used only for a single type, like virtually any Redis application will\n * do, the function is already fair. */\nvoid handleClientsBlockedOnKeys(void) {\n\n /* In case we are already in the process of unblocking clients we should\n * not make a recursive call, in order to prevent breaking fairness. */\n static int in_handling_blocked_clients = 0;\n if (in_handling_blocked_clients)\n return;\n in_handling_blocked_clients = 1;\n\n /* This function is called only when also_propagate is in its basic state\n * (i.e. not from call(), module context, etc.) */\n serverAssert(server.also_propagate.numops == 0);\n\n /* If a command being unblocked causes another command to get unblocked,\n * like a BLMOVE would do, then the new unblocked command will get processed\n * right away rather than wait for later. */\n while(listLength(server.ready_keys) != 0) {\n list *l;\n\n /* Point server.ready_keys to a fresh list and save the current one\n * locally. This way as we run the old list we are free to call\n * signalKeyAsReady() that may push new elements in server.ready_keys\n * when handling clients blocked into BLMOVE. */\n l = server.ready_keys;\n server.ready_keys = listCreate();\n\n while(listLength(l) != 0) {\n listNode *ln = listFirst(l);\n readyList *rl = ln->value;\n\n /* First of all remove this key from db->ready_keys so that\n * we can safely call signalKeyAsReady() against this key. */\n dictDelete(rl->db->ready_keys,rl->key);\n\n handleClientsBlockedOnKey(rl);\n\n /* Free this item. */\n decrRefCount(rl->key);\n zfree(rl);\n listDelNode(l,ln);\n }\n listRelease(l); /* We have the new list on place at this point. */\n }\n in_handling_blocked_clients = 0;\n}\n\n/* Set a client in blocking mode for the specified key, with the specified timeout.\n * The 'type' argument is BLOCKED_LIST,BLOCKED_ZSET or BLOCKED_STREAM depending on the kind of operation we are\n * waiting for an empty key in order to awake the client. The client is blocked\n * for all the 'numkeys' keys as in the 'keys' argument.\n * The client will unblocked as soon as one of the keys in 'keys' value was updated.\n * the parameter unblock_on_nokey can be used to force client to be unblocked even in the case the key\n * is updated to become unavailable, either by type change (override), deletion or swapdb */\nvoid blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeout, int unblock_on_nokey) {\n dictEntry *db_blocked_entry, *db_blocked_existing_entry, *client_blocked_entry;\n list *l;\n int j;\n\n if (!(c->flags & CLIENT_REEXECUTING_COMMAND)) {\n /* If the client is re-processing the command, we do not set the timeout\n * because we need to retain the client's original timeout. */\n c->bstate.timeout = timeout;\n }\n\n for (j = 0; j < numkeys; j++) {\n /* If the key already exists in the dictionary ignore it. */\n if (!(client_blocked_entry = dictAddRaw(c->bstate.keys,keys[j],NULL))) {\n continue;\n }\n incrRefCount(keys[j]);\n\n /* And in the other \"side\", to map keys -> clients */\n db_blocked_entry = dictAddRaw(c->db->blocking_keys,keys[j], &db_blocked_existing_entry);\n\n /* In case key[j] did not have blocking clients yet, we need to create a new list */\n if (db_blocked_entry != NULL) {\n l = listCreate();\n dictSetVal(c->db->blocking_keys, db_blocked_entry, l);\n incrRefCount(keys[j]);\n } else {\n l = dictGetVal(db_blocked_existing_entry);\n }\n listAddNodeTail(l,c);\n dictSetVal(c->bstate.keys,client_blocked_entry,listLast(l));\n\n /* We need to add the key to blocking_keys_unblock_on_nokey, if the client\n * wants to be awakened if key is deleted (like XREADGROUP) */\n if (unblock_on_nokey) {\n db_blocked_entry = dictAddRaw(c->db->blocking_keys_unblock_on_nokey, keys[j], &db_blocked_existing_entry);\n if (db_blocked_entry) {\n incrRefCount(keys[j]);\n dictSetUnsignedIntegerVal(db_blocked_entry, 1);\n } else {\n dictIncrUnsignedIntegerVal(db_blocked_existing_entry, 1);\n }\n }\n }\n c->bstate.unblock_on_nokey = unblock_on_nokey;\n /* Currently we assume key blocking will require reprocessing the command.\n * However in case of modules, they have a different way to handle the reprocessing\n * which does not require setting the pending command flag */\n if (btype != BLOCKED_MODULE)\n c->flags |= CLIENT_PENDING_COMMAND;\n blockClient(c,btype);\n}\n\n/* Helper function to unblock a client that's waiting in a blocking operation such as BLPOP.\n * Internal function for unblockClient() */\nstatic void unblockClientWaitingData(client *c) {\n dictEntry *de;\n dictIterator di;\n\n if (dictSize(c->bstate.keys) == 0)\n return;\n\n dictInitIterator(&di, c->bstate.keys);\n /* The client may wait for multiple keys, so unblock it for every key. */\n while((de = dictNext(&di)) != NULL) {\n releaseBlockedEntry(c, de, 0);\n }\n dictResetIterator(&di);\n dictEmpty(c->bstate.keys, NULL);\n}\n\nstatic blocking_type getBlockedTypeByType(int type) {\n switch (type) {\n case OBJ_LIST: return BLOCKED_LIST;\n case OBJ_ZSET: return BLOCKED_ZSET;\n case OBJ_MODULE: return BLOCKED_MODULE;\n case OBJ_STREAM: return BLOCKED_STREAM;\n default: return BLOCKED_NONE;\n }\n}\n\n/* If the specified key has clients blocked waiting for list pushes, this\n * function will put the key reference into the server.ready_keys list.\n * Note that db->ready_keys is a hash table that allows us to avoid putting\n * the same key again and again in the list in case of multiple pushes\n * made by a script or in the context of MULTI/EXEC.\n *\n * The list will be finally processed by handleClientsBlockedOnKeys() */\nstatic void signalKeyAsReadyLogic(redisDb *db, robj *key, int type, int deleted) {\n readyList *rl;\n\n /* Quick returns. */\n int btype = getBlockedTypeByType(type);\n if (btype == BLOCKED_NONE) {\n /* The type can never block. */\n return;\n }\n if (!server.blocked_clients_by_type[btype] &&\n !server.blocked_clients_by_type[BLOCKED_MODULE]) {\n /* No clients block on this type. Note: Blocked modules are represented\n * by BLOCKED_MODULE, even if the intention is to wake up by normal\n * types (list, zset, stream), so we need to check that there are no\n * blocked modules before we do a quick return here. */\n return;\n }\n\n if (deleted) {\n /* Key deleted and no clients blocking for this key? No need to queue it. */\n if (dictFind(db->blocking_keys_unblock_on_nokey,key) == NULL)\n return;\n /* Note: if we made it here it means the key is also present in db->blocking_keys */\n } else {\n /* No clients blocking for this key? No need to queue it. */\n if (dictFind(db->blocking_keys,key) == NULL)\n return;\n }\n\n dictEntry *de, *existing;\n de = dictAddRaw(db->ready_keys, key, &existing);\n if (de) {\n /* We add the key in the db->ready_keys dictionary in order\n * to avoid adding it multiple times into a list with a simple O(1)\n * check. */\n incrRefCount(key);\n } else {\n /* Key was already signaled? No need to queue it again. */\n return;\n }\n\n /* Ok, we need to queue this key into server.ready_keys. */\n rl = zmalloc(sizeof(*rl));\n rl->key = key;\n rl->db = db;\n incrRefCount(key);\n listAddNodeTail(server.ready_keys,rl);\n}\n\n/* Helper function to wrap the logic of removing a client blocked key entry\n * In this case we would like to do the following:\n * 1. unlink the client from the global DB locked client list\n * 2. remove the entry from the global db blocking list in case the list is empty\n * 3. in case the global list is empty, also remove the key from the global dict of keys\n * which should trigger unblock on key deletion\n * 4. remove key from the client blocking keys list - NOTE, since client can be blocked on lots of keys,\n * but unblocked when only one of them is triggered, we would like to avoid deleting each key separately\n * and instead clear the dictionary in one-shot. this is why the remove_key argument is provided\n * to support this logic in unblockClientWaitingData\n */\nstatic void releaseBlockedEntry(client *c, dictEntry *de, int remove_key) {\n list *l;\n listNode *pos;\n void *key;\n dictEntry *unblock_on_nokey_entry;\n\n key = dictGetKey(de);\n pos = dictGetVal(de);\n /* Remove this client from the list of clients waiting for this key. */\n l = dictFetchValue(c->db->blocking_keys, key);\n serverAssertWithInfo(c,key,l != NULL);\n listUnlinkNode(l,pos);\n /* If the list is empty we need to remove it to avoid wasting memory\n * We will also remove the key (if exists) from the blocking_keys_unblock_on_nokey dict.\n * However, in case the list is not empty, we will have to still perform reference accounting\n * on the blocking_keys_unblock_on_nokey and delete the entry in case of zero reference.\n * Why? because it is possible that some more clients are blocked on the same key but without\n * require to be triggered on key deletion, we do not want these to be later triggered by the\n * signalDeletedKeyAsReady. */\n if (listLength(l) == 0) {\n dictDelete(c->db->blocking_keys, key);\n dictDelete(c->db->blocking_keys_unblock_on_nokey,key);\n } else if (c->bstate.unblock_on_nokey) {\n unblock_on_nokey_entry = dictFind(c->db->blocking_keys_unblock_on_nokey,key);\n /* it is not possible to have a client blocked on nokey with no matching entry */\n serverAssertWithInfo(c,key,unblock_on_nokey_entry != NULL);\n if (!dictIncrUnsignedIntegerVal(unblock_on_nokey_entry, -1)) {\n /* in case the count is zero, we can delete the entry */\n dictDelete(c->db->blocking_keys_unblock_on_nokey,key);\n }\n }\n if (remove_key)\n dictDelete(c->bstate.keys, key);\n}\n\nvoid signalKeyAsReady(redisDb *db, robj *key, int type) {\n signalKeyAsReadyLogic(db, key, type, 0);\n}\n\nvoid signalDeletedKeyAsReady(redisDb *db, robj *key, int type) {\n signalKeyAsReadyLogic(db, key, type, 1);\n}\n\n/* Helper function for handleClientsBlockedOnKeys(). This function is called\n * whenever a key is ready. we iterate over all the clients blocked on this key\n * and try to re-execute the command (in case the key is still available). */\nstatic void handleClientsBlockedOnKey(readyList *rl) {\n\n /* We serve clients in the same order they blocked for\n * this key, from the first blocked to the last. */\n dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);\n\n if (de) {\n list *clients = dictGetVal(de);\n listNode *ln;\n listIter li;\n listRewind(clients,&li);\n\n /* Avoid processing more than the initial count so that we're not stuck\n * in an endless loop in case the reprocessing of the command blocks again. */\n long count = listLength(clients);\n while ((ln = listNext(&li)) && count--) {\n client *receiver = listNodeValue(ln);\n kvobj *o = lookupKeyReadWithFlags(rl->db, rl->key, LOOKUP_NOEFFECTS);\n /* 1. In case new key was added/touched we need to verify it satisfy the\n * blocked type, since we might process the wrong key type.\n * 2. We want to serve clients blocked on module keys\n * regardless of the object type: we don't know what the\n * module is trying to accomplish right now.\n * 3. In case of XREADGROUP call we will want to unblock on any change in object type\n * or in case the key was deleted, since the group is no longer valid. */\n if ((o != NULL && (receiver->bstate.btype == getBlockedTypeByType(o->type))) ||\n (o != NULL && (receiver->bstate.btype == BLOCKED_MODULE)) ||\n (receiver->bstate.unblock_on_nokey))\n {\n if (receiver->bstate.btype != BLOCKED_MODULE)\n unblockClientOnKey(receiver, rl->key);\n else\n moduleUnblockClientOnKey(receiver, rl->key);\n }\n }\n }\n}\n\n/* block a client due to wait command */\nvoid blockForReplication(client *c, mstime_t timeout, long long offset, long numreplicas) {\n c->bstate.timeout = timeout;\n c->bstate.reploffset = offset;\n c->bstate.numreplicas = numreplicas;\n listAddNodeHead(server.clients_waiting_acks,c);\n blockClient(c,BLOCKED_WAIT);\n}\n\n/* block a client due to waitaof command */\nvoid blockForAofFsync(client *c, mstime_t timeout, long long offset, int numlocal, long numreplicas) {\n c->bstate.timeout = timeout;\n c->bstate.reploffset = offset;\n c->bstate.numreplicas = numreplicas;\n c->bstate.numlocal = numlocal;\n listAddNodeHead(server.clients_waiting_acks,c);\n blockClient(c,BLOCKED_WAITAOF);\n}\n\n/* Postpone client from executing a command. For example the server might be busy\n * requesting to avoid processing clients commands which will be processed later\n * when the it is ready to accept them. */\nvoid blockPostponeClientWithType(client *c, int btype) {\n serverAssert(btype == BLOCKED_POSTPONE || btype == BLOCKED_POSTPONE_TRIM);\n c->bstate.timeout = 0;\n blockClient(c, btype);\n listAddNodeTail(server.postponed_clients, c);\n c->postponed_list_node = listLast(server.postponed_clients);\n /* Mark this client to execute its command */\n c->flags |= CLIENT_PENDING_COMMAND;\n}\n\n/* Postpone client from executing a command. */\nvoid blockPostponeClient(client *c) {\n blockPostponeClientWithType(c, BLOCKED_POSTPONE);\n}\n\n/* Block client due to shutdown command */\nvoid blockClientShutdown(client *c) {\n blockClient(c, BLOCKED_SHUTDOWN);\n}\n\n/* Unblock a client once a specific key became available for it.\n * This function will remove the client from the list of clients blocked on this key\n * and also remove the key from the dictionary of keys this client is blocked on.\n * in case the client has a command pending it will process it immediately. */\nstatic void unblockClientOnKey(client *c, robj *key) {\n dictEntry *de;\n\n de = dictFind(c->bstate.keys, key);\n releaseBlockedEntry(c, de, 1);\n\n /* Only in case of blocking API calls, we might be blocked on several keys.\n however we should force unblock the entire blocking keys */\n serverAssert(c->bstate.btype == BLOCKED_STREAM ||\n c->bstate.btype == BLOCKED_LIST ||\n c->bstate.btype == BLOCKED_ZSET);\n\n /* We need to unblock the client before calling processCommandAndResetClient\n * because it checks the CLIENT_BLOCKED flag */\n unblockClient(c, 0);\n /* In case this client was blocked on keys during command\n * we need to re process the command again */\n if (c->flags & CLIENT_PENDING_COMMAND) {\n c->flags &= ~CLIENT_PENDING_COMMAND;\n c->flags |= CLIENT_REEXECUTING_COMMAND;\n /* We want the command processing and the unblock handler (see RM_Call 'K' option)\n * to run atomically, this is why we must enter the execution unit here before\n * running the command, and exit the execution unit after calling the unblock handler (if exists).\n * Notice that we also must set the current client so it will be available\n * when we will try to send the client side caching notification (done on 'afterCommand'). */\n client *old_client = server.current_client;\n server.current_client = c;\n enterExecutionUnit(1, 0);\n processCommandAndResetClient(c);\n if (!(c->flags & CLIENT_BLOCKED)) {\n if (c->flags & CLIENT_MODULE) {\n moduleCallCommandUnblockedHandler(c);\n } else {\n queueClientForReprocessing(c);\n }\n }\n exitExecutionUnit();\n afterCommand(c);\n /* Clear the CLIENT_REEXECUTING_COMMAND flag after the proc is executed. */\n c->flags &= ~CLIENT_REEXECUTING_COMMAND;\n server.current_client = old_client;\n }\n}\n\n/* Unblock a client blocked on the specific key from module context.\n * This function will try to serve the module call, and in case it succeeds,\n * it will add the client to the list of module unblocked clients which will\n * be processed in moduleHandleBlockedClients. */\nstatic void moduleUnblockClientOnKey(client *c, robj *key) {\n long long prev_error_replies = server.stat_total_error_replies;\n client *old_client = server.current_client;\n server.current_client = c;\n monotime replyTimer;\n elapsedStart(&replyTimer);\n\n if (moduleTryServeClientBlockedOnKey(c, key)) {\n updateStatsOnUnblock(c, 0, elapsedUs(replyTimer), server.stat_total_error_replies != prev_error_replies);\n moduleUnblockClient(c);\n }\n /* We need to call afterCommand even if the client was not unblocked\n * in order to propagate any changes that could have been done inside\n * moduleTryServeClientBlockedOnKey */\n afterCommand(c);\n server.current_client = old_client;\n}\n\n/* Unblock a client which is currently Blocked on and provided a timeout.\n * The implementation will first reply to the blocked client with null response\n * or, in case of module blocked client the timeout callback will be used.\n * In this case since we might have a command pending\n * we want to remove the pending flag to indicate we already responded to the\n * command with timeout reply. */\nvoid unblockClientOnTimeout(client *c) {\n /* The client has been unlocked (in the moduleUnblocked list), return ASAP. */\n if (c->bstate.btype == BLOCKED_MODULE && isModuleClientUnblocked(c)) return;\n\n replyToBlockedClientTimedOut(c);\n if (c->flags & CLIENT_PENDING_COMMAND)\n c->flags &= ~CLIENT_PENDING_COMMAND;\n unblockClient(c, 1);\n}\n\n/* Unblock a client which is currently Blocked with error.\n * If err_str is provided it will be used to reply to the blocked client */\nvoid unblockClientOnError(client *c, const char *err_str) {\n if (err_str)\n addReplyError(c, err_str);\n updateStatsOnUnblock(c, 0, 0, 1);\n if (c->flags & CLIENT_PENDING_COMMAND)\n c->flags &= ~CLIENT_PENDING_COMMAND;\n unblockClient(c, 1);\n}\n\nvoid blockedBeforeSleep(void) {\n /* Handle precise timeouts of blocked clients. */\n handleBlockedClientsTimeout();\n\n /* Handle for expired pending entries. */\n handleClaimableStreamEntries();\n\n /* Unblock all the clients blocked for synchronous replication\n * in WAIT or WAITAOF. */\n if (listLength(server.clients_waiting_acks))\n processClientsWaitingReplicas();\n\n /* Try to process blocked clients every once in while.\n *\n * Example: A module calls RM_SignalKeyAsReady from within a timer callback\n * (So we don't visit processCommand() at all).\n *\n * This may unblock clients, so must be done before processUnblockedClients */\n handleClientsBlockedOnKeys();\n\n /* Check if there are clients unblocked by modules that implement\n * blocking commands. */\n if (moduleCount())\n moduleHandleBlockedClients();\n\n /* Try to process pending commands for clients that were just unblocked. */\n if (listLength(server.unblocked_clients))\n processUnblockedClients();\n}\n" }, { "path": "src/call_reply.c", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \"call_reply.h\"\n\n#define REPLY_FLAG_ROOT (1<<0)\n#define REPLY_FLAG_PARSED (1<<1)\n#define REPLY_FLAG_RESP3 (1<<2)\n\n/* --------------------------------------------------------\n * An opaque struct used to parse a RESP protocol reply and\n * represent it. Used when parsing replies such as in RM_Call\n * or Lua scripts.\n * -------------------------------------------------------- */\nstruct CallReply {\n void *private_data;\n sds original_proto; /* Available only for root reply. */\n const char *proto;\n size_t proto_len;\n int type; /* REPLY_... */\n int flags; /* REPLY_FLAG... */\n size_t len; /* Length of a string, or the number elements in an array. */\n union {\n const char *str; /* String pointer for string and error replies. This\n * does not need to be freed, always points inside\n * a reply->proto buffer of the reply object or, in\n * case of array elements, of parent reply objects. */\n struct {\n const char *str;\n const char *format;\n } verbatim_str; /* Reply value for verbatim string */\n long long ll; /* Reply value for integer reply. */\n double d; /* Reply value for double reply. */\n struct CallReply *array; /* Array of sub-reply elements. used for set, array, map, and attribute */\n } val;\n list *deferred_error_list; /* list of errors in sds form or NULL */\n struct CallReply *attribute; /* attribute reply, NULL if not exists */\n};\n\nstatic void callReplySetSharedData(CallReply *rep, int type, const char *proto, size_t proto_len, int extra_flags) {\n rep->type = type;\n rep->proto = proto;\n rep->proto_len = proto_len;\n rep->flags |= extra_flags;\n}\n\nstatic void callReplyNull(void *ctx, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_NULL, proto, proto_len, REPLY_FLAG_RESP3);\n}\n\nstatic void callReplyNullBulkString(void *ctx, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_NULL, proto, proto_len, 0);\n}\n\nstatic void callReplyNullArray(void *ctx, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_NULL, proto, proto_len, 0);\n}\n\nstatic void callReplyBulkString(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_STRING, proto, proto_len, 0);\n rep->len = len;\n rep->val.str = str;\n}\n\nstatic void callReplyError(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_ERROR, proto, proto_len, 0);\n rep->len = len;\n rep->val.str = str;\n}\n\nstatic void callReplySimpleStr(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_STRING, proto, proto_len, 0);\n rep->len = len;\n rep->val.str = str;\n}\n\nstatic void callReplyLong(void *ctx, long long val, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_INTEGER, proto, proto_len, 0);\n rep->val.ll = val;\n}\n\nstatic void callReplyDouble(void *ctx, double val, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_DOUBLE, proto, proto_len, REPLY_FLAG_RESP3);\n rep->val.d = val;\n}\n\nstatic void callReplyVerbatimString(void *ctx, const char *format, const char *str, size_t len, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_VERBATIM_STRING, proto, proto_len, REPLY_FLAG_RESP3);\n rep->len = len;\n rep->val.verbatim_str.str = str;\n rep->val.verbatim_str.format = format;\n}\n\nstatic void callReplyBigNumber(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_BIG_NUMBER, proto, proto_len, REPLY_FLAG_RESP3);\n rep->len = len;\n rep->val.str = str;\n}\n\nstatic void callReplyBool(void *ctx, int val, const char *proto, size_t proto_len) {\n CallReply *rep = ctx;\n callReplySetSharedData(rep, REDISMODULE_REPLY_BOOL, proto, proto_len, REPLY_FLAG_RESP3);\n rep->val.ll = val;\n}\n\nstatic void callReplyParseCollection(ReplyParser *parser, CallReply *rep, size_t len, const char *proto, size_t elements_per_entry) {\n rep->len = len;\n rep->val.array = zcalloc(elements_per_entry * len * sizeof(CallReply));\n for (size_t i = 0; i < len * elements_per_entry; i += elements_per_entry) {\n for (size_t j = 0 ; j < elements_per_entry ; ++j) {\n rep->val.array[i + j].private_data = rep->private_data;\n parseReply(parser, rep->val.array + i + j);\n rep->val.array[i + j].flags |= REPLY_FLAG_PARSED;\n if (rep->val.array[i + j].flags & REPLY_FLAG_RESP3) {\n /* If one of the sub-replies is RESP3, then the current reply is also RESP3. */\n rep->flags |= REPLY_FLAG_RESP3;\n }\n }\n }\n rep->proto = proto;\n rep->proto_len = parser->curr_location - proto;\n}\n\nstatic void callReplyAttribute(ReplyParser *parser, void *ctx, size_t len, const char *proto) {\n CallReply *rep = ctx;\n rep->attribute = zcalloc(sizeof(CallReply));\n\n /* Continue parsing the attribute reply */\n rep->attribute->len = len;\n rep->attribute->type = REDISMODULE_REPLY_ATTRIBUTE;\n callReplyParseCollection(parser, rep->attribute, len, proto, 2);\n rep->attribute->flags |= REPLY_FLAG_PARSED | REPLY_FLAG_RESP3;\n rep->attribute->private_data = rep->private_data;\n\n /* Continue parsing the reply */\n parseReply(parser, rep);\n\n /* In this case we need to fix the proto address and len, it should start from the attribute */\n rep->proto = proto;\n rep->proto_len = parser->curr_location - proto;\n rep->flags |= REPLY_FLAG_RESP3;\n}\n\nstatic void callReplyArray(ReplyParser *parser, void *ctx, size_t len, const char *proto) {\n CallReply *rep = ctx;\n rep->type = REDISMODULE_REPLY_ARRAY;\n callReplyParseCollection(parser, rep, len, proto, 1);\n}\n\nstatic void callReplySet(ReplyParser *parser, void *ctx, size_t len, const char *proto) {\n CallReply *rep = ctx;\n rep->type = REDISMODULE_REPLY_SET;\n callReplyParseCollection(parser, rep, len, proto, 1);\n rep->flags |= REPLY_FLAG_RESP3;\n}\n\nstatic void callReplyMap(ReplyParser *parser, void *ctx, size_t len, const char *proto) {\n CallReply *rep = ctx;\n rep->type = REDISMODULE_REPLY_MAP;\n callReplyParseCollection(parser, rep, len, proto, 2);\n rep->flags |= REPLY_FLAG_RESP3;\n}\n\nstatic void callReplyParseError(void *ctx) {\n CallReply *rep = ctx;\n rep->type = REDISMODULE_REPLY_UNKNOWN;\n}\n\n/* Recursively free the current call reply and its sub-replies. */\nstatic void freeCallReplyInternal(CallReply *rep) {\n if (rep->type == REDISMODULE_REPLY_ARRAY || rep->type == REDISMODULE_REPLY_SET) {\n for (size_t i = 0 ; i < rep->len ; ++i) {\n freeCallReplyInternal(rep->val.array + i);\n }\n zfree(rep->val.array);\n }\n\n if (rep->type == REDISMODULE_REPLY_MAP || rep->type == REDISMODULE_REPLY_ATTRIBUTE) {\n for (size_t i = 0 ; i < rep->len ; ++i) {\n freeCallReplyInternal(rep->val.array + i * 2);\n freeCallReplyInternal(rep->val.array + i * 2 + 1);\n }\n zfree(rep->val.array);\n }\n\n if (rep->attribute) {\n freeCallReplyInternal(rep->attribute);\n zfree(rep->attribute);\n }\n}\n\n/* Free the given call reply and its children (in case of nested reply) recursively.\n * If private data was set when the CallReply was created it will not be freed, as it's\n * the caller's responsibility to free it before calling freeCallReply(). */\nvoid freeCallReply(CallReply *rep) {\n if (!(rep->flags & REPLY_FLAG_ROOT)) {\n return;\n }\n if (rep->flags & REPLY_FLAG_PARSED) {\n if (rep->type == REDISMODULE_REPLY_PROMISE) {\n zfree(rep);\n return;\n }\n freeCallReplyInternal(rep);\n }\n sdsfree(rep->original_proto);\n if (rep->deferred_error_list)\n listRelease(rep->deferred_error_list);\n zfree(rep);\n}\n\nCallReply *callReplyCreatePromise(void *private_data) {\n CallReply *res = zmalloc(sizeof(*res));\n res->type = REDISMODULE_REPLY_PROMISE;\n /* Mark the reply as parsed so there will be not attempt to parse\n * it when calling reply API such as freeCallReply.\n * Also mark the reply as root so freeCallReply will not ignore it. */\n res->flags |= REPLY_FLAG_PARSED | REPLY_FLAG_ROOT;\n res->private_data = private_data;\n return res;\n}\n\nstatic const ReplyParserCallbacks DefaultParserCallbacks = {\n .null_callback = callReplyNull,\n .bulk_string_callback = callReplyBulkString,\n .null_bulk_string_callback = callReplyNullBulkString,\n .null_array_callback = callReplyNullArray,\n .error_callback = callReplyError,\n .simple_str_callback = callReplySimpleStr,\n .long_callback = callReplyLong,\n .array_callback = callReplyArray,\n .set_callback = callReplySet,\n .map_callback = callReplyMap,\n .double_callback = callReplyDouble,\n .bool_callback = callReplyBool,\n .big_number_callback = callReplyBigNumber,\n .verbatim_string_callback = callReplyVerbatimString,\n .attribute_callback = callReplyAttribute,\n .error = callReplyParseError,\n};\n\n/* Parse the buffer located in rep->original_proto and update the CallReply\n * structure to represent its contents. */\nstatic void callReplyParse(CallReply *rep) {\n if (rep->flags & REPLY_FLAG_PARSED) {\n return;\n }\n\n ReplyParser parser = {.curr_location = rep->proto, .callbacks = DefaultParserCallbacks};\n\n parseReply(&parser, rep);\n rep->flags |= REPLY_FLAG_PARSED;\n}\n\n/* Return the call reply type (REDISMODULE_REPLY_...). */\nint callReplyType(CallReply *rep) {\n if (!rep) return REDISMODULE_REPLY_UNKNOWN;\n callReplyParse(rep);\n return rep->type;\n}\n\n/* Return reply string as buffer and len. Applicable to:\n * - REDISMODULE_REPLY_STRING\n * - REDISMODULE_REPLY_ERROR\n *\n * The return value is borrowed from CallReply, so it must not be freed\n * explicitly or used after CallReply itself is freed.\n *\n * The returned value is not NULL terminated and its length is returned by\n * reference through len, which must not be NULL.\n */\nconst char *callReplyGetString(CallReply *rep, size_t *len) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_STRING &&\n rep->type != REDISMODULE_REPLY_ERROR) return NULL;\n if (len) *len = rep->len;\n return rep->val.str;\n}\n\n/* Return a long long reply value. Applicable to:\n * - REDISMODULE_REPLY_INTEGER\n */\nlong long callReplyGetLongLong(CallReply *rep) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_INTEGER) return LLONG_MIN;\n return rep->val.ll;\n}\n\n/* Return a double reply value. Applicable to:\n * - REDISMODULE_REPLY_DOUBLE\n */\ndouble callReplyGetDouble(CallReply *rep) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_DOUBLE) return LLONG_MIN;\n return rep->val.d;\n}\n\n/* Return a reply Boolean value. Applicable to:\n * - REDISMODULE_REPLY_BOOL\n */\nint callReplyGetBool(CallReply *rep) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_BOOL) return INT_MIN;\n return rep->val.ll;\n}\n\n/* Return reply length. Applicable to:\n * - REDISMODULE_REPLY_STRING\n * - REDISMODULE_REPLY_ERROR\n * - REDISMODULE_REPLY_ARRAY\n * - REDISMODULE_REPLY_SET\n * - REDISMODULE_REPLY_MAP\n * - REDISMODULE_REPLY_ATTRIBUTE\n */\nsize_t callReplyGetLen(CallReply *rep) {\n callReplyParse(rep);\n switch(rep->type) {\n case REDISMODULE_REPLY_STRING:\n case REDISMODULE_REPLY_ERROR:\n case REDISMODULE_REPLY_ARRAY:\n case REDISMODULE_REPLY_SET:\n case REDISMODULE_REPLY_MAP:\n case REDISMODULE_REPLY_ATTRIBUTE:\n return rep->len;\n default:\n return 0;\n }\n}\n\nstatic CallReply *callReplyGetCollectionElement(CallReply *rep, size_t idx, int elements_per_entry) {\n if (idx >= rep->len * elements_per_entry) return NULL; // real len is rep->len * elements_per_entry\n return rep->val.array+idx;\n}\n\n/* Return a reply array element at a given index. Applicable to:\n * - REDISMODULE_REPLY_ARRAY\n *\n * The return value is borrowed from CallReply, so it must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nCallReply *callReplyGetArrayElement(CallReply *rep, size_t idx) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_ARRAY) return NULL;\n return callReplyGetCollectionElement(rep, idx, 1);\n}\n\n/* Return a reply set element at a given index. Applicable to:\n * - REDISMODULE_REPLY_SET\n *\n * The return value is borrowed from CallReply, so it must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nCallReply *callReplyGetSetElement(CallReply *rep, size_t idx) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_SET) return NULL;\n return callReplyGetCollectionElement(rep, idx, 1);\n}\n\nstatic int callReplyGetMapElementInternal(CallReply *rep, size_t idx, CallReply **key, CallReply **val, int type) {\n callReplyParse(rep);\n if (rep->type != type) return C_ERR;\n if (idx >= rep->len) return C_ERR;\n if (key) *key = callReplyGetCollectionElement(rep, idx * 2, 2);\n if (val) *val = callReplyGetCollectionElement(rep, idx * 2 + 1, 2);\n return C_OK;\n}\n\n/* Retrieve a map reply key and value at a given index. Applicable to:\n * - REDISMODULE_REPLY_MAP\n *\n * The key and value are returned by reference through key and val,\n * which may also be NULL if not needed.\n *\n * Returns C_OK on success or C_ERR if reply type mismatches, or if idx is out\n * of range.\n *\n * The returned values are borrowed from CallReply, so they must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nint callReplyGetMapElement(CallReply *rep, size_t idx, CallReply **key, CallReply **val) {\n return callReplyGetMapElementInternal(rep, idx, key, val, REDISMODULE_REPLY_MAP);\n}\n\n/* Return reply attribute, or NULL if it does not exist. Applicable to all replies.\n *\n * The returned values are borrowed from CallReply, so they must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nCallReply *callReplyGetAttribute(CallReply *rep) {\n return rep->attribute;\n}\n\n/* Retrieve attribute reply key and value at a given index. Applicable to:\n * - REDISMODULE_REPLY_ATTRIBUTE\n *\n * The key and value are returned by reference through key and val,\n * which may also be NULL if not needed.\n *\n * Returns C_OK on success or C_ERR if reply type mismatches, or if idx is out\n * of range.\n *\n * The returned values are borrowed from CallReply, so they must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nint callReplyGetAttributeElement(CallReply *rep, size_t idx, CallReply **key, CallReply **val) {\n return callReplyGetMapElementInternal(rep, idx, key, val, REDISMODULE_REPLY_MAP);\n}\n\n/* Return a big number reply value. Applicable to:\n * - REDISMODULE_REPLY_BIG_NUMBER\n *\n * The returned values are borrowed from CallReply, so they must not be freed\n * explicitly or used after CallReply itself is freed.\n *\n * The return value is guaranteed to be a big number, as described in the RESP3\n * protocol specifications.\n *\n * The returned value is not NULL terminated and its length is returned by\n * reference through len, which must not be NULL.\n */\nconst char *callReplyGetBigNumber(CallReply *rep, size_t *len) {\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_BIG_NUMBER) return NULL;\n *len = rep->len;\n return rep->val.str;\n}\n\n/* Return a verbatim string reply value. Applicable to:\n * - REDISMODULE_REPLY_VERBATIM_STRING\n *\n * If format is non-NULL, the verbatim reply format is also returned by value.\n *\n * The optional output argument can be given to get a verbatim reply\n * format, or can be set NULL if not needed.\n *\n * The return value is borrowed from CallReply, so it must not be freed\n * explicitly or used after CallReply itself is freed.\n *\n * The returned value is not NULL terminated and its length is returned by\n * reference through len, which must not be NULL.\n */\nconst char *callReplyGetVerbatim(CallReply *rep, size_t *len, const char **format){\n callReplyParse(rep);\n if (rep->type != REDISMODULE_REPLY_VERBATIM_STRING) return NULL;\n *len = rep->len;\n if (format) *format = rep->val.verbatim_str.format;\n return rep->val.verbatim_str.str;\n}\n\n/* Return the current reply blob.\n *\n * The return value is borrowed from CallReply, so it must not be freed\n * explicitly or used after CallReply itself is freed.\n */\nconst char *callReplyGetProto(CallReply *rep, size_t *proto_len) {\n *proto_len = rep->proto_len;\n return rep->proto;\n}\n\n/* Return CallReply private data, as set by the caller on callReplyCreate().\n */\nvoid *callReplyGetPrivateData(CallReply *rep) {\n return rep->private_data;\n}\n\n/* Return true if the reply or one of it sub-replies is RESP3 formatted. */\nint callReplyIsResp3(CallReply *rep) {\n return rep->flags & REPLY_FLAG_RESP3;\n}\n\n/* Returns a list of errors in sds form, or NULL. */\nlist *callReplyDeferredErrorList(CallReply *rep) {\n return rep->deferred_error_list;\n}\n\n/* Create a new CallReply struct from the reply blob.\n *\n * The function will own the reply blob, so it must not be used or freed by\n * the caller after passing it to this function.\n *\n * The reply blob will be freed when the returned CallReply struct is later\n * freed using freeCallReply().\n *\n * The deferred_error_list is an optional list of errors that are present\n * in the reply blob, if given, this function will take ownership on it.\n *\n * The private_data is optional and can later be accessed using\n * callReplyGetPrivateData().\n *\n * NOTE: The parser used for parsing the reply and producing CallReply is\n * designed to handle valid replies created by Redis itself. IT IS NOT\n * DESIGNED TO HANDLE USER INPUT and using it to parse invalid replies is\n * unsafe.\n */\nCallReply *callReplyCreate(sds reply, list *deferred_error_list, void *private_data) {\n CallReply *res = zmalloc(sizeof(*res));\n res->flags = REPLY_FLAG_ROOT;\n res->original_proto = reply;\n res->proto = reply;\n res->proto_len = sdslen(reply);\n res->private_data = private_data;\n res->attribute = NULL;\n res->deferred_error_list = deferred_error_list;\n return res;\n}\n\n/* Create a new CallReply struct from the reply blob representing an error message.\n * Automatically creating deferred_error_list and set a copy of the reply in it.\n * Refer to callReplyCreate for detailed explanation.\n * Reply string can come in one of two forms:\n * 1. A protocol reply starting with \"-CODE\" and ending with \"\\r\\n\"\n * 2. A plain string, in which case this function adds the protocol header and footer. */\nCallReply *callReplyCreateError(sds reply, void *private_data) {\n sds err_buff = reply;\n if (err_buff[0] != '-') {\n err_buff = sdscatfmt(sdsempty(), \"-ERR %S\\r\\n\", reply);\n sdsfree(reply);\n }\n list *deferred_error_list = listCreate();\n listSetFreeMethod(deferred_error_list, sdsfreegeneric);\n listAddNodeTail(deferred_error_list, sdsnew(err_buff));\n return callReplyCreate(err_buff, deferred_error_list, private_data);\n}\n" }, { "path": "src/call_reply.h", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#ifndef SRC_CALL_REPLY_H_\n#define SRC_CALL_REPLY_H_\n\n#include \"resp_parser.h\"\n\ntypedef struct CallReply CallReply;\ntypedef void (*RedisModuleOnUnblocked)(void *ctx, CallReply *reply, void *private_data);\n\nCallReply *callReplyCreate(sds reply, list *deferred_error_list, void *private_data);\nCallReply *callReplyCreateError(sds reply, void *private_data);\nint callReplyType(CallReply *rep);\nconst char *callReplyGetString(CallReply *rep, size_t *len);\nlong long callReplyGetLongLong(CallReply *rep);\ndouble callReplyGetDouble(CallReply *rep);\nint callReplyGetBool(CallReply *rep);\nsize_t callReplyGetLen(CallReply *rep);\nCallReply *callReplyGetArrayElement(CallReply *rep, size_t idx);\nCallReply *callReplyGetSetElement(CallReply *rep, size_t idx);\nint callReplyGetMapElement(CallReply *rep, size_t idx, CallReply **key, CallReply **val);\nCallReply *callReplyGetAttribute(CallReply *rep);\nint callReplyGetAttributeElement(CallReply *rep, size_t idx, CallReply **key, CallReply **val);\nconst char *callReplyGetBigNumber(CallReply *rep, size_t *len);\nconst char *callReplyGetVerbatim(CallReply *rep, size_t *len, const char **format);\nconst char *callReplyGetProto(CallReply *rep, size_t *len);\nvoid *callReplyGetPrivateData(CallReply *rep);\nint callReplyIsResp3(CallReply *rep);\nlist *callReplyDeferredErrorList(CallReply *rep);\nvoid freeCallReply(CallReply *rep);\nCallReply *callReplyCreatePromise(void *private_data);\n\n#endif /* SRC_CALL_REPLY_H_ */\n" }, { "path": "src/childinfo.c", "content": "/*\n * Copyright (c) 2016-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"server.h\"\n#include \n#include \n\ntypedef struct {\n size_t keys;\n size_t cow;\n monotime cow_updated;\n double progress;\n childInfoType information_type; /* Type of information */\n} child_info_data;\n\n/* Open a child-parent channel used in order to move information about the\n * RDB / AOF saving process from the child to the parent (for instance\n * the amount of copy on write memory used) */\nvoid openChildInfoPipe(void) {\n if (anetPipe(server.child_info_pipe, O_NONBLOCK, 0) == -1) {\n /* On error our two file descriptors should be still set to -1,\n * but we call anyway closeChildInfoPipe() since can't hurt. */\n closeChildInfoPipe();\n } else {\n server.child_info_nread = 0;\n }\n}\n\n/* Close the pipes opened with openChildInfoPipe(). */\nvoid closeChildInfoPipe(void) {\n if (server.child_info_pipe[0] != -1 ||\n server.child_info_pipe[1] != -1)\n {\n close(server.child_info_pipe[0]);\n close(server.child_info_pipe[1]);\n server.child_info_pipe[0] = -1;\n server.child_info_pipe[1] = -1;\n server.child_info_nread = 0;\n }\n}\n\n/* Send save data to parent. */\nvoid sendChildInfoGeneric(childInfoType info_type, size_t keys, double progress, char *pname) {\n if (server.child_info_pipe[1] == -1) return;\n\n static monotime cow_updated = 0;\n static uint64_t cow_update_cost = 0;\n static size_t cow = 0;\n static size_t peak_cow = 0;\n static size_t update_count = 0;\n static unsigned long long sum_cow = 0;\n\n child_info_data data = {0}; /* zero everything, including padding to satisfy valgrind */\n\n /* When called to report current info, we need to throttle down CoW updates as they\n * can be very expensive. To do that, we measure the time it takes to get a reading\n * and schedule the next reading to happen not before time*CHILD_COW_COST_FACTOR\n * passes. */\n\n monotime now = getMonotonicUs();\n if (info_type != CHILD_INFO_TYPE_CURRENT_INFO ||\n !cow_updated ||\n now - cow_updated > cow_update_cost * CHILD_COW_DUTY_CYCLE)\n {\n cow = zmalloc_get_private_dirty(-1);\n cow_updated = getMonotonicUs();\n cow_update_cost = cow_updated - now;\n if (cow > peak_cow) peak_cow = cow;\n sum_cow += cow;\n update_count++;\n\n int cow_info = (info_type != CHILD_INFO_TYPE_CURRENT_INFO);\n if (cow || cow_info) {\n serverLog(cow_info ? LL_NOTICE : LL_VERBOSE,\n \"Fork CoW for %s: current %zu MB, peak %zu MB, average %llu MB\",\n pname, cow>>20, peak_cow>>20, (sum_cow/update_count)>>20);\n }\n }\n\n data.information_type = info_type;\n data.keys = keys;\n data.cow = cow;\n data.cow_updated = cow_updated;\n data.progress = progress;\n\n ssize_t wlen = sizeof(data);\n\n if (write(server.child_info_pipe[1], &data, wlen) != wlen) {\n /* Failed writing to parent, it could have been killed, exit. */\n serverLog(LL_WARNING,\"Child failed reporting info to parent, exiting. %s\", strerror(errno));\n exitFromChild(1, 0);\n }\n}\n\n/* Update Child info. */\nvoid updateChildInfo(childInfoType information_type, size_t cow, monotime cow_updated, size_t keys, double progress) {\n if (cow > server.stat_current_cow_peak) server.stat_current_cow_peak = cow;\n\n if (information_type == CHILD_INFO_TYPE_CURRENT_INFO) {\n server.stat_current_cow_bytes = cow;\n server.stat_current_cow_updated = cow_updated;\n server.stat_current_save_keys_processed = keys;\n if (progress != -1) server.stat_module_progress = progress;\n } else if (information_type == CHILD_INFO_TYPE_AOF_COW_SIZE) {\n server.stat_aof_cow_bytes = server.stat_current_cow_peak;\n } else if (information_type == CHILD_INFO_TYPE_RDB_COW_SIZE) {\n server.stat_rdb_cow_bytes = server.stat_current_cow_peak;\n } else if (information_type == CHILD_INFO_TYPE_MODULE_COW_SIZE) {\n server.stat_module_cow_bytes = server.stat_current_cow_peak;\n }\n}\n\n/* Read child info data from the pipe.\n * if complete data read into the buffer, \n * data is stored into *buffer, and returns 1.\n * otherwise, the partial data is left in the buffer, waiting for the next read, and returns 0. */\nint readChildInfo(childInfoType *information_type, size_t *cow, monotime *cow_updated, size_t *keys, double* progress) {\n /* We are using here a static buffer in combination with the server.child_info_nread to handle short reads */\n static child_info_data buffer;\n ssize_t wlen = sizeof(buffer);\n\n /* Do not overlap */\n if (server.child_info_nread == wlen) server.child_info_nread = 0;\n\n int nread = read(server.child_info_pipe[0], (char *)&buffer + server.child_info_nread, wlen - server.child_info_nread);\n if (nread > 0) {\n server.child_info_nread += nread;\n }\n\n /* We have complete child info */\n if (server.child_info_nread == wlen) {\n *information_type = buffer.information_type;\n *cow = buffer.cow;\n *cow_updated = buffer.cow_updated;\n *keys = buffer.keys;\n *progress = buffer.progress;\n return 1;\n } else {\n return 0;\n }\n}\n\n/* Receive info data from child. */\nvoid receiveChildInfo(void) {\n if (server.child_info_pipe[0] == -1) return;\n\n size_t cow;\n monotime cow_updated;\n size_t keys;\n double progress;\n childInfoType information_type;\n\n /* Drain the pipe and update child info so that we get the final message. */\n while (readChildInfo(&information_type, &cow, &cow_updated, &keys, &progress)) {\n updateChildInfo(information_type, cow, cow_updated, keys, progress);\n }\n}\n" }, { "path": "src/chk.c", "content": "/* Implementation of a topK structure using CuckooHeavyKeeper algorithm\n *\n * Implementation is based on the paper \"Cuckoo Heavy Keeper and the balancing\n * act of maintaining heavy hitters in stream processing\" by Vinh Quang Ngo and\n * Marina Papatriantafilou. Also, the accompanying C++ implementation was used\n * as a reference point: https://github.com/vinhqngo5/Cuckoo_Heavy_Keeper\n * Main changes are addition of a min-heap so we can keep names of the top K\n * elements - idea comes from RedisBloom's TopK structure.\n *\n * Copyright (c) 2026-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"chk.h\"\n#include \"redisassert.h\"\n#include \"zmalloc.h\"\n#include \"xxhash.h\"\n\n#include \n#include \n#include \n\n/* Lobby to heavy item promotion threshold */\n#define LOBBY_PROMOTION_THRESHOLD 16\n\n#ifndef static_assert\n#define static_assert(expr, lit) extern char __static_assert_failure[(expr) ? 1:-1]\n#endif\n\nstatic_assert(LOBBY_PROMOTION_THRESHOLD < CHK_LUT_SIZE,\n \"Lobby promotion threshold should be less then the LUT size to \"\n \"ensure constant operations during decayCounter!\");\n\n/* After a heavy item is demoted is starts recursively kicking out other heavy\n * items in the case it should stay heavy (defined by isHeavyHitter). In\n * principle this process could go over all the items in the chkTopK's tables\n * so it's artificially limited by this constant. */\n#define MAX_KICKS 16\n\n/* An item is defined as heavy hitter if its count is more or equal to x * N\n * where x is a threshold constant (HEAVY_RATIO) and N is the total count the\n * chkTopK structure has accumulated. See the paper for more info. */\n#define HEAVY_RATIO 0.008\n\n/* A unique seed for the items when storing them in the heap so it's not related\n * to the cuckoo's hashes. Also, we don't need the less-bit hash here as the\n * heap does not take much memory so we avoid needless possible collisions. */\n#define HEAP_SEED 1919\n\ntypedef struct {\n size_t idx[CHK_NUM_TABLES];\n fingerprint_t fp;\n} fpAndIdx;\n\n#define min(a, b) ((a) < (b) ? (a) : (b))\n\n/* Heap operations */\nstatic chkHeapBucket *chkCheckExistInHeap(chkTopK *topk, const char *item, int itemlen, uint64_t fp) {\n for (int32_t i = topk->k - 1; i >= 0; --i) {\n chkHeapBucket *bucket = topk->heap + i;\n if (bucket->fp == fp && bucket->item &&\n sdslen(bucket->item) == (size_t)itemlen &&\n memcmp(bucket->item, item, itemlen) == 0)\n {\n return bucket;\n }\n }\n return NULL;\n}\n\nvoid chkHeapifyDown(chkHeapBucket *array, size_t len, size_t start) {\n size_t child = start;\n\n if (len < 2 || (len - 2) / 2 < child) {\n return;\n }\n child = 2 * child + 1;\n if ((child + 1) < len && (array[child].count > array[child + 1].count)) {\n ++child;\n }\n if (array[child].count > array[start].count) {\n return;\n }\n\n chkHeapBucket top = {0};\n top = array[start];\n do {\n memcpy(&array[start], &array[child], sizeof(chkHeapBucket));\n start = child;\n\n if ((len - 2) / 2 < child) {\n break;\n }\n child = 2 * child + 1;\n\n if ((child + 1) < len && (array[child].count > array[child + 1].count)) {\n ++child;\n }\n } while (array[child].count < top.count);\n memcpy(&array[start], &top, sizeof(chkHeapBucket));\n}\n\n/*-----------------------------------------------------------------------------\n * chkTopK operations\n *----------------------------------------------------------------------------*/\n\n/* Create the chkTopK structure. Note, CHK paper recommends decay=1.08.\n * numbuckets must be a power of 2. Recommended size for numbuckets is at least\n * 7 or 8 times k. */\nchkTopK *chkTopKCreate(int k, int numbuckets, double decay) {\n /* Number of buckets need to be a power of 2 for better performance - we\n * have better cache locality of the tables and faster table indices\n * calculations. */\n assert(k > 0 && (numbuckets & (numbuckets - 1)) == 0);\n\n size_t usable = 0;\n chkTopK *topk = zcalloc_usable(sizeof(chkTopK), &usable);\n topk->alloc_size += usable;\n\n for (int i = 0; i < CHK_NUM_TABLES; ++i) {\n topk->tables[i] = zcalloc_usable(sizeof(chkBucket) * numbuckets, &usable);\n topk->alloc_size += usable;\n }\n\n topk->heap = zcalloc_usable(sizeof(chkHeapBucket) * k, &usable);\n topk->alloc_size += usable;\n\n topk->decay = decay;\n topk->inv_decay = 1. / decay;\n topk->k = k;\n topk->numbuckets = numbuckets;\n\n topk->lut_decay_exp[0] = 0;\n topk->lut_min_decay[0] = 0;\n topk->lut_decay_prob[0] = 0;\n for (int i = 1; i < CHK_LUT_SIZE + 1; ++i) {\n topk->lut_decay_exp[i] = topk->lut_decay_exp[i - 1] + pow(topk->decay, i - 1);\n topk->lut_min_decay[i] = topk->lut_decay_exp[i] - topk->lut_decay_exp[i - 1];\n topk->lut_decay_prob[i] = pow(topk->inv_decay, i);\n }\n\n return topk;\n}\n\n/* Release chkTopK resources */\nvoid chkTopKRelease(chkTopK *topk) {\n size_t usable;\n for (int i = 0; i < CHK_NUM_TABLES; ++i) {\n zfree_usable(topk->tables[i], &usable);\n topk->alloc_size -= usable;\n }\n for (int i = 0; i < topk->k; ++i) {\n if (topk->heap[i].item) {\n topk->alloc_size -= sdsAllocSize(topk->heap[i].item);\n sdsfree(topk->heap[i].item);\n }\n }\n zfree_usable(topk->heap, &usable);\n topk->alloc_size -= usable;\n debugAssert(topk->alloc_size == zmalloc_usable_size(topk));\n\n zfree(topk);\n}\n\nstatic inline int generateAltIdx(fingerprint_t fp, int idx, int numbuckets) {\n return (idx ^ (0x5bd1e995 * (size_t)fp)) & (numbuckets - 1);\n}\n\nfpAndIdx generateItemFpAndIdxs(chkTopK *topk, char *item, int itemlen) {\n uint64_t hash = XXH3_64bits_withSeed(item, itemlen, 0);\n\n fpAndIdx res;\n res.fp = (hash & 0xFFFF); /* Only use 16 bits for fingerprint */\n\n /* Note numbuckets are a power of 2 so we don't use modulo for index calc */\n res.idx[0] = (hash >> 32) & (topk->numbuckets - 1);\n for (int i = 1; i < CHK_NUM_TABLES; ++i) {\n res.idx[i] = generateAltIdx(res.fp, res.idx[i-1], topk->numbuckets);\n }\n\n return res;\n}\n\ntypedef struct {\n int table_idx;\n int pos;\n} checkEntryRes;\n\n/* Check if `item` is a heavy entry. If so we bump its count. If not - we make\n * it a heavy entry immediately if there is an empty spot, thus skipping the\n * lobby as an optimization. */\ncheckEntryRes checkHeavyEntries(chkTopK *topk, fpAndIdx item, counter_t weight) {\n int empty_table_idx = -1;\n int empty_pos = -1;\n\n for (int i = 0; i < CHK_NUM_TABLES; ++i) {\n int idx = item.idx[i];\n\n chkBucket *bucket = &topk->tables[i][idx];\n for (int j = 0; j < CHK_HEAVY_ENTRIES_PER_BUCKET; ++j) {\n chkHeavyEntry *e = &bucket->heavy_entries[j];\n if (e->count > 0) {\n if (e->fp == item.fp) {\n e->count += weight;\n\n checkEntryRes res = { i, j };\n return res;\n }\n } else if (empty_table_idx == -1) {\n empty_table_idx = i;\n empty_pos = j;\n }\n }\n }\n\n if (empty_table_idx == -1) {\n checkEntryRes res = { -1, -1 };\n return res;\n }\n\n /* If there is an empty slot in the heavy entries just put the item there\n * instead of going through the lobby first (optimization as per the paper) */\n int idx = item.idx[empty_table_idx];\n chkHeavyEntry *e = &topk->tables[empty_table_idx][idx].heavy_entries[empty_pos];\n e->fp = item.fp;\n e->count = weight;\n\n checkEntryRes res = {empty_table_idx, empty_pos};\n return res;\n}\n\n/* A heavy hitter is defined by the paper as an item with counter more or equal\n * to phi * N, where phi is a constant and N is the total count the structure\n * has recorded up to that point */\nint isHeavyHitter(chkTopK *topk, counter_t cnt) {\n return cnt >= (topk->total * HEAVY_RATIO);\n}\n\n/* After a lobby item is promoted it may be placed on a heavy item's spot. The\n * latter is kicked out, but it may recursively kick out another heavy item.\n * The process is limited by MAX_KICKS and also by the fact that during updates\n * one of the kicked out items may have its counter decayed so much - it's not\n * passing the heavy item threshold (see isHeavyHitter). */\nvoid kickout(chkTopK *topk, chkHeavyEntry entry, int idx, int table_idx) {\n for (int i = 0; i < MAX_KICKS; ++i) {\n /* Do not try to swap with any entries if we don't reach the heavy\n * hitter threshold */\n if (!isHeavyHitter(topk, entry.count)) return;\n\n /* Find the heavy entry in the alt bucket in the other table with\n * minimum count. If there is empty entry there just occupy it, else\n * recursively kick the minimal one out.\n * To find the alt bucket we need to compute the alt index from the\n * fingerprint of the kicked-out entry. */\n table_idx = 1 - table_idx;\n idx = generateAltIdx(entry.fp, idx, topk->numbuckets);\n\n chkBucket *bucket = &topk->tables[table_idx][idx];\n counter_t min = (counter_t)-1;\n int min_pos = -1;\n for (int j = 0; j < CHK_HEAVY_ENTRIES_PER_BUCKET; ++j) {\n chkHeavyEntry *e = &bucket->heavy_entries[j];\n if (e->count == 0) {\n *e = entry;\n return;\n }\n if (e->count < min) {\n min = e->count;\n min_pos = j;\n }\n }\n\n chkHeavyEntry old_entry = bucket->heavy_entries[min_pos];\n bucket->heavy_entries[min_pos] = entry;\n entry = old_entry;\n }\n}\n\n/* When a lobby entry's counter passes the promotion threshold we try to promote\n * it with some probability. See the paper for more details. If promotion is\n * successful the lobby entry may kick out a heavy one - see kickout() */\nint tryPromoteAndKickout(chkTopK *topk, fpAndIdx item, counter_t new_count,\n int table_idx)\n{\n int idx = item.idx[table_idx];\n chkBucket *bucket = &topk->tables[table_idx][idx];\n counter_t min = (counter_t)-1; /* counter_t is unsigned */\n int min_idx = -1;\n\n /* We search for heavy item bucket of the promoted lobby entry. We may have\n * an empty space which we immediately occupy. Otherwise we choose the\n * bucket with lowest counter */\n for (int i = 0; i < CHK_HEAVY_ENTRIES_PER_BUCKET; ++i) {\n if (bucket->heavy_entries[i].count == 0) {\n bucket->heavy_entries[i].fp = item.fp;\n bucket->heavy_entries[i].count = new_count;\n return i;\n }\n if (bucket->heavy_entries[i].count < min) {\n min = bucket->heavy_entries[i].count;\n min_idx = i;\n }\n }\n\n /* If the heavy entry that is going to be kicked out has a counter lower\n * than the lobby's one we always kick it out */\n if (min > new_count) {\n double prob = (new_count - LOBBY_PROMOTION_THRESHOLD) /\n (double)(min - LOBBY_PROMOTION_THRESHOLD);\n\n if ((rand() / (double)RAND_MAX) >= prob) return -1;\n }\n\n chkHeavyEntry to_kickout = bucket->heavy_entries[min_idx];\n /* Note, that here the promoted item keeps the old count as per the paper */\n bucket->heavy_entries[min_idx].fp = bucket->lobby_entry.fp;\n\n bucket->lobby_entry.count = 0;\n bucket->lobby_entry.fp = 0;\n\n kickout(topk, to_kickout, idx, table_idx);\n\n return min_idx;\n}\n\n/* Check if an item is a lobby entry */\ncheckEntryRes checkLobbyEntries(chkTopK *topk, fpAndIdx item, counter_t weight) {\n for (int i = 0; i < CHK_NUM_TABLES; ++i) {\n int idx = item.idx[i];\n\n chkBucket *bucket = &topk->tables[i][idx];\n chkLobbyEntry *e = &bucket->lobby_entry;\n\n /* No match or empty lobby entry */\n if (e->fp != item.fp || e->count == 0) continue;\n\n /* If we don't cross the threshold just update the counter */\n uint64_t new_count = (uint64_t)e->count + weight;\n if (new_count < LOBBY_PROMOTION_THRESHOLD) {\n e->count = (uint16_t)new_count;\n\n checkEntryRes res = { i, -1 };\n return res;\n }\n\n /* Try to promote the entry to heavy entry if we crossed the threshold.\n * Else just set the counter to the value of the threshold */\n int kickout_pos = tryPromoteAndKickout(topk, item, new_count, i);\n if (kickout_pos != -1) {\n checkEntryRes res = {i, kickout_pos};\n return res;\n }\n\n e->count = LOBBY_PROMOTION_THRESHOLD;\n checkEntryRes res = { i, -1 };\n return res;\n }\n\n checkEntryRes res = { -1, -1 };\n return res;\n}\n\n/* Probability to decay cnt with 1.\n * Equal to pow(decay, -cnt) */\nstatic inline double getDecayProb(chkTopK *topk, counter_t cnt) {\n if (cnt < CHK_LUT_SIZE) {\n return topk->lut_decay_prob[cnt];\n }\n\n return pow(topk->lut_decay_prob[CHK_LUT_SIZE],\n ((double)cnt / (CHK_LUT_SIZE))) *\n topk->lut_decay_prob[cnt % (CHK_LUT_SIZE)];\n}\n\n/* Expected decay steps to decay cnt to 0.\n * Equal to sum(pow(decay, i)) for i in [0; cnt] */\nstatic inline double getExpDecayCount(chkTopK *topk, lobby_counter_t cnt) {\n return topk->lut_decay_exp[cnt];\n}\n\n/* Expected minimum decay steps to decay cnt with 1. Since probability is\n * pow(decay, -cnt) it's equal to pow(decay, cnt) */\nstatic inline double getMinDecayCount(chkTopK *topk, counter_t cnt) {\n if (cnt < CHK_LUT_SIZE) {\n return topk->lut_min_decay[cnt];\n }\n\n return pow(topk->lut_min_decay[CHK_LUT_SIZE],\n ((double)cnt / (CHK_LUT_SIZE))) *\n topk->lut_min_decay[cnt % (CHK_LUT_SIZE)];\n}\n\n/* When there is a hash-collission between lobby entries we decay the existing\n * lobby entry with the weight of the new one. Return the counter after decaying. */\nlobby_counter_t chkDecayCounter(chkTopK *topk, lobby_counter_t cnt, counter_t weight) {\n if (weight == 0) return cnt;\n\n /* Unweighted update - just decay with probability pow(decay, -cnt) */\n if (weight == 1) {\n double prob = getDecayProb(topk, (counter_t)cnt);\n if ((rand() / (double)RAND_MAX) < prob) {\n return cnt - 1;\n }\n return cnt;\n }\n\n /* For weighted updates we simulate multiple unweighted ones */\n\n /* Weight is smaller than the minimum amount of decay steps required to\n * decay the counter with probability of 100% so again we roll the dice */\n double min_decay = getMinDecayCount(topk, cnt);\n if (weight < (counter_t)min_decay) {\n double prob = weight / min_decay;\n if ((rand() / (double)RAND_MAX) < prob) {\n return cnt - 1;\n }\n return cnt;\n }\n\n /* Weight is more than the expected amount of decay steps to decay the\n * counter to 0. */\n double exp_decays = getExpDecayCount(topk, cnt);\n if (weight >= (counter_t)exp_decays)\n return 0;\n\n /* Weight is large enough to decay the counter to cnt - X where 0 < X < cnt.\n * We binary search for the largest value `C` such that:\n *\n * (expected decay ops for `C`) >= (expected decay ops for `cnt`) - `weight`\n * i.e lut_decay_exp[C] + weight >= lut_decay_exp[cnt]\n *\n * Note that since cnt is a lobby counter it will necessarily be less or\n * equal than LOBBY_PROMOTION_THRESHOLD, so although we binary search this\n * is a O(1) operation */\n int left = 0;\n int right = cnt;\n while (left < right) {\n int mid = left + (right - left) / 2;\n\n if (topk->lut_decay_exp[mid] + weight >= topk->lut_decay_exp[cnt]) {\n right = mid;\n } else {\n left = mid + 1;\n }\n }\n\n return left;\n}\n\n/* Update weighted item. If another one was expelled from the topK list -\n * return it. Caller is responsible for releasing it */\nsds chkTopKUpdate(chkTopK *topk, char *item, int itemlen, counter_t weight)\n{\n if (weight == 0) return NULL;\n\n topk->total += weight;\n\n /* Generate a fingerprint and indices for both cuckoo tables. */\n fpAndIdx itemFpIdx = generateItemFpAndIdxs(topk, item, itemlen);\n\n /* Check if the item is amongst the heavy entries. If so we just update its\n * counter. */\n checkEntryRes res = checkHeavyEntries(topk, itemFpIdx, weight);\n if (res.table_idx != -1) {\n goto update_heap;\n }\n\n /* If the item is not already heavy it may be in the lobby. If so we'll\n * increase its counter and promote it to a heavy entry if it passes the\n * threshold */\n res = checkLobbyEntries(topk, itemFpIdx, weight);\n if (res.table_idx != -1) {\n goto update_heap;\n }\n\n /* Item is not tracked at all. Check for empty lobby entries - if there is\n * any - place the item there. The weight may be higher than the promotional\n * threshold in which case we'll try to promote it. */\n for (int i = 0; i < CHK_NUM_TABLES; ++i) {\n int idx = itemFpIdx.idx[i];\n chkBucket *bucket = &topk->tables[i][idx];\n if (bucket->lobby_entry.count == 0) {\n bucket->lobby_entry.fp = itemFpIdx.fp;\n\n res.table_idx = i;\n res.pos = -1;\n\n if (weight < LOBBY_PROMOTION_THRESHOLD) {\n bucket->lobby_entry.count = weight;\n } else {\n int kickout_pos = tryPromoteAndKickout(topk, itemFpIdx, weight, i);\n if (kickout_pos != -1) {\n res.pos = kickout_pos;\n } else {\n bucket->lobby_entry.count = LOBBY_PROMOTION_THRESHOLD;\n }\n }\n\n goto update_heap;\n }\n }\n \n /* If there are no empty lobby entries choose a table deterministically,\n * decay its lobby counter and update */\n int table_idx = itemFpIdx.fp & 1;\n int idx = itemFpIdx.idx[table_idx];\n\n chkLobbyEntry *e = &topk->tables[table_idx][idx].lobby_entry;\n\n /* new_count is the count of `e` after decaying it with weight */\n lobby_counter_t new_count = chkDecayCounter(topk, e->count, weight);\n\n /* if the chosen lobby entry has decayed its counter to 0, it's replaced by\n * the new entry. Note, in that case the new entry has it's weight\n * decreased by the approximate amount of decay operations needed to decay\n * the old entry. */\n if (new_count == 0) {\n e->fp = itemFpIdx.fp;\n counter_t exp_decay_cnt = getExpDecayCount(topk, e->count);\n e->count = exp_decay_cnt >= weight ?\n 1 : (lobby_counter_t)min(255, weight - exp_decay_cnt);\n } else {\n e->count = new_count;\n }\n\n if (e->count >= LOBBY_PROMOTION_THRESHOLD) {\n int kickout_pos = tryPromoteAndKickout(topk, itemFpIdx, e->count, table_idx);\n if (kickout_pos != -1) {\n res.table_idx = table_idx;\n res.pos = kickout_pos;\n }\n }\n\n /* After a change in the structure has occurred we check if we also need to\n * update the heap - i.e bump a new item in it, or reorder an old item if\n * it's counter went up. */\nupdate_heap:\n if (res.table_idx == -1 || res.pos == -1)\n return NULL;\n\n table_idx = res.table_idx;\n idx = itemFpIdx.idx[table_idx];\n\n counter_t heap_min = topk->heap[0].count;\n chkHeavyEntry *entry = &topk->tables[table_idx][idx].heavy_entries[res.pos];\n \n if (entry->count < heap_min)\n return NULL;\n \n /* Heap uses different hash than the cuckoo tables */\n uint64_t fp = XXH3_64bits_withSeed(item, itemlen, HEAP_SEED);\n chkHeapBucket *itemHeapPtr = chkCheckExistInHeap(topk, item, itemlen, fp);\n if (itemHeapPtr != NULL) {\n itemHeapPtr->count = entry->count;\n chkHeapifyDown(topk->heap, topk->k, itemHeapPtr - topk->heap);\n } else {\n /* We know the new entry has bigger count than the min-element so it's\n * safe to expel it. */\n sds expelled = topk->heap[0].item;\n if (expelled) topk->alloc_size -= sdsAllocSize(expelled);\n\n topk->heap[0].count = entry->count;\n topk->heap[0].fp = fp;\n topk->heap[0].item = sdsnewlen(item, itemlen);\n topk->alloc_size += sdsAllocSize(topk->heap[0].item);\n\n chkHeapifyDown(topk->heap, topk->k, 0);\n return expelled;\n }\n\n return NULL;\n}\n\nint cmpchkHeapBucket(const void *tmp1, const void *tmp2) {\n const chkHeapBucket *res1 = tmp1;\n const chkHeapBucket *res2 = tmp2;\n return res1->count < res2->count ? 1 : res1->count > res2->count ? -1 : 0;\n}\n\n/* Get an ordered by count list of topk->k elements inside the topk object.\n *\n * NOTE, the returned array is a copy of the internal heap stored by `topk`. The\n * caller is responsible for releasing it after use. The elements of the array\n * share their `item` pointers with the internal topk->heap buckets so one must\n * not use it after `topk` is released. */\nchkHeapBucket *chkTopKList(chkTopK *topk) {\n chkHeapBucket *list = zmalloc(sizeof(chkHeapBucket) * topk->k);\n memcpy(list, topk->heap, sizeof(chkHeapBucket) * topk->k);\n qsort(list, topk->k, sizeof(*list), cmpchkHeapBucket);\n return list;\n}\n\nsize_t chkTopKGetMemoryUsage(chkTopK *topk) {\n if (!topk) return 0;\n\n return topk->alloc_size;\n}\n\n#ifdef REDIS_TEST\n\n#include \n#include \"testhelp.h\"\n\n#define UNUSED(x) (void)(x)\n\nstatic int findItemInList(chkHeapBucket *list, int k, const char *item, int itemlen) {\n for (int i = 0; i < k; i++) {\n if (list[i].item != NULL &&\n sdslen(list[i].item) == (size_t)itemlen &&\n memcmp(list[i].item, item, itemlen) == 0) {\n return i;\n }\n }\n return -1;\n}\n\nstatic int verifyListSorted(chkHeapBucket *list, int k) {\n for (int i = 0; i < k - 1; i++) {\n if (list[i].item == NULL) continue;\n if (list[i + 1].item == NULL) continue;\n if (list[i].count < list[i + 1].count) {\n return 0;\n }\n }\n return 1;\n}\n\nstatic void chkTopKUpdateAndFreeExpelled(chkTopK *topk, const char *item, int itemlen, counter_t weight) {\n sds expelled = chkTopKUpdate(topk, (char *)item, itemlen, weight);\n if (expelled) sdsfree(expelled);\n}\n\nstatic void testBasicTopK(void) {\n int k = 5;\n int numbuckets = 64;\n double decay = 0.9;\n\n chkTopK *topk = chkTopKCreate(k, numbuckets, decay);\n test_cond(\"Create topk structure\", topk != NULL);\n\n if (topk == NULL) return;\n\n chkTopKUpdateAndFreeExpelled(topk, \"item1\", 5, 100);\n chkTopKUpdateAndFreeExpelled(topk, \"item2\", 5, 200);\n chkTopKUpdateAndFreeExpelled(topk, \"item3\", 5, 150);\n chkTopKUpdateAndFreeExpelled(topk, \"item4\", 5, 50);\n chkTopKUpdateAndFreeExpelled(topk, \"item5\", 5, 300);\n chkTopKUpdateAndFreeExpelled(topk, \"item6\", 5, 75);\n\n chkHeapBucket *list = chkTopKList(topk);\n test_cond(\"chkTopKList returns non-NULL\", list != NULL);\n\n if (list == NULL) {\n chkTopKRelease(topk);\n return;\n }\n\n test_cond(\"TopK list is sorted in descending order\", verifyListSorted(list, k));\n\n int idx1 = findItemInList(list, k, \"item5\", 5);\n int idx2 = findItemInList(list, k, \"item2\", 5);\n int idx3 = findItemInList(list, k, \"item3\", 5);\n\n test_cond(\"Heaviest items are in the list\", idx1 != -1 && idx2 != -1 && idx3 != -1);\n\n test_cond(\"item5 has the highest count\", idx1 == 0);\n\n zfree(list);\n chkTopKRelease(topk);\n}\n\nstatic void testHeavierElementsReplaceLighter(void) {\n int k = 5;\n int numbuckets = 64;\n double decay = 0.9;\n\n chkTopK *topk = chkTopKCreate(k, numbuckets, decay);\n test_cond(\"Create topk structure for replacement test\", topk != NULL);\n\n if (topk == NULL) return;\n\n chkTopKUpdateAndFreeExpelled(topk, \"light1\", 6, 50);\n chkTopKUpdateAndFreeExpelled(topk, \"light2\", 6, 60);\n chkTopKUpdateAndFreeExpelled(topk, \"light3\", 6, 70);\n chkTopKUpdateAndFreeExpelled(topk, \"light4\", 6, 80);\n chkTopKUpdateAndFreeExpelled(topk, \"light5\", 6, 90);\n\n chkHeapBucket *list1 = chkTopKList(topk);\n test_cond(\"Initial topk list is not NULL\", list1 != NULL);\n\n if (list1 == NULL) {\n chkTopKRelease(topk);\n return;\n }\n\n int light1_idx = findItemInList(list1, k, \"light1\", 6);\n int light2_idx = findItemInList(list1, k, \"light2\", 6);\n int light3_idx = findItemInList(list1, k, \"light3\", 6);\n int light4_idx = findItemInList(list1, k, \"light4\", 6);\n int light5_idx = findItemInList(list1, k, \"light5\", 6);\n\n test_cond(\"light1 is in initial topk list\", light1_idx != -1);\n test_cond(\"light2 is in initial topk list\", light2_idx != -1);\n test_cond(\"light3 is in initial topk list\", light3_idx != -1);\n test_cond(\"light4 is in initial topk list\", light4_idx != -1);\n test_cond(\"light5 is in initial topk list\", light5_idx != -1);\n\n zfree(list1);\n\n chkTopKUpdateAndFreeExpelled(topk, \"heavy1\", 6, 500);\n chkTopKUpdateAndFreeExpelled(topk, \"heavy2\", 6, 600);\n\n chkHeapBucket *list2 = chkTopKList(topk);\n test_cond(\"Updated topk list is not NULL\", list2 != NULL);\n\n if (list2 == NULL) {\n chkTopKRelease(topk);\n return;\n }\n\n int heavy1_idx = findItemInList(list2, k, \"heavy1\", 6);\n int heavy2_idx = findItemInList(list2, k, \"heavy2\", 6);\n\n test_cond(\"heavy1 is in updated topk list\", heavy1_idx != -1);\n test_cond(\"heavy2 is in updated topk list\", heavy2_idx != -1);\n\n light1_idx = findItemInList(list2, k, \"light1\", 6);\n light2_idx = findItemInList(list2, k, \"light2\", 6);\n light3_idx = findItemInList(list2, k, \"light3\", 6);\n light4_idx = findItemInList(list2, k, \"light4\", 6);\n light5_idx = findItemInList(list2, k, \"light5\", 6);\n\n int light_items_remaining = (light1_idx != -1 ? 1 : 0) +\n (light2_idx != -1 ? 1 : 0) +\n (light3_idx != -1 ? 1 : 0) +\n (light4_idx != -1 ? 1 : 0) +\n (light5_idx != -1 ? 1 : 0);\n\n test_cond(\"Some lighter items remain in the list after adding heavier ones\",\n light_items_remaining > 0);\n\n zfree(list2);\n chkTopKRelease(topk);\n}\n\nstatic void testManySmallWeightUpdates(void) {\n int k = 2;\n int numbuckets = 64;\n double decay = 0.9;\n\n chkTopK *topk = chkTopKCreate(k, numbuckets, decay);\n test_cond(\"Create topk structure for small weight updates test\", topk != NULL);\n\n if (topk == NULL) return;\n\n chkTopKUpdateAndFreeExpelled(topk, \"item0\", 5, 50);\n chkTopKUpdateAndFreeExpelled(topk, \"item1\", 5, 100);\n\n chkHeapBucket *list1 = chkTopKList(topk);\n test_cond(\"Topk list after adding item0 and item1 is not NULL\", list1 != NULL);\n\n if (list1 == NULL) {\n chkTopKRelease(topk);\n return;\n }\n\n int item0_idx1 = findItemInList(list1, k, \"item0\", 5);\n int item1_idx1 = findItemInList(list1, k, \"item1\", 5);\n\n test_cond(\"item0 and item1 are in topk after initial updates\",\n item0_idx1 != -1 && item1_idx1 != -1);\n\n zfree(list1);\n\n for (int i = 0; i < 100; i++) {\n chkTopKUpdateAndFreeExpelled(topk, \"item2\", 5, 1);\n }\n\n chkHeapBucket *list2 = chkTopKList(topk);\n test_cond(\"Topk list after many small updates is not NULL\", list2 != NULL);\n\n if (list2 == NULL) {\n chkTopKRelease(topk);\n return;\n }\n\n int item0_idx2 = findItemInList(list2, k, \"item0\", 5);\n int item1_idx2 = findItemInList(list2, k, \"item1\", 5);\n int item2_idx2 = findItemInList(list2, k, \"item2\", 5);\n\n test_cond(\"item1 and item2 are in topk, item0 is not\",\n item1_idx2 != -1 && item2_idx2 != -1 && item0_idx2 == -1);\n\n counter_t item1_count = 0;\n counter_t item2_count = 0;\n if (item1_idx2 != -1) item1_count = list2[item1_idx2].count;\n if (item2_idx2 != -1) item2_count = list2[item2_idx2].count;\n\n test_cond(\"item1 and item2 have similar weights\", item1_count > 0 && item2_count > 0 && \n (item1_count > item2_count ? item1_count - item2_count : item2_count - item1_count) < 5);\n\n zfree(list2);\n chkTopKRelease(topk);\n}\n\nint chkTopKTest(int argc, char *argv[], int flags) {\n UNUSED(argc);\n UNUSED(argv);\n UNUSED(flags);\n\n testBasicTopK();\n testHeavierElementsReplaceLighter();\n testManySmallWeightUpdates();\n\n return 0;\n}\n\n#endif /* REDIS_TEST */\n" }, { "path": "src/chk.h", "content": "/* Implementation of a topK structure using CuckooHeavyKeeper algorithm\n *\n * Implementation is based on the paper \"Cuckoo Heavy Keeper and the balancing\n * act of maintaining heavy hitters in stream processing\" by Vinh Quang Ngo and\n * Marina Papatriantafilou. Also, the accompanying C++ implementation was used\n * as a reference point: https://github.com/vinhqngo5/Cuckoo_Heavy_Keeper\n * Main changes are addition of a min-heap so we can keep names of the top K\n * elements - idea comes from RedisBloom's TopK structure.\n *\n * Copyright (c) 2026-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#pragma once\n\n#include \"sds.h\"\n\n#include \n#include \n\n#define CHK_LUT_SIZE 256\n#define CHK_HEAVY_ENTRIES_PER_BUCKET 2\n#define CHK_NUM_TABLES 2\n\ntypedef uint64_t counter_t;\ntypedef uint16_t fingerprint_t;\ntypedef uint8_t lobby_counter_t;\n\ntypedef struct {\n counter_t count;\n fingerprint_t fp;\n} chkHeavyEntry;\n\ntypedef struct {\n fingerprint_t fp;\n lobby_counter_t count;\n} chkLobbyEntry;\n\ntypedef struct {\n chkHeavyEntry heavy_entries[CHK_HEAVY_ENTRIES_PER_BUCKET];\n chkLobbyEntry lobby_entry;\n} chkBucket;\n\ntypedef struct {\n counter_t count;\n sds item;\n uint64_t fp; /* Fingerprint used to identify the item. Internal use only */\n} chkHeapBucket;\n\ntypedef struct chkTopK {\n chkBucket *tables[CHK_NUM_TABLES]; /* Cuckoo tables */\n chkHeapBucket *heap; /* Min-heap for storing top-K item's names */\n\n size_t alloc_size; /* Used for memory tracking only */\n\n /* Expected number of operations to decay count i to 0 */\n double lut_decay_exp[CHK_LUT_SIZE + 1];\n\n /* Minimum number of decay operations to decay count i with 1 */\n double lut_min_decay[CHK_LUT_SIZE + 1];\n\n /* Probability of decaying i with 1. As per paper probability is decay^-i\n * but we actually store (1/decay)^i for faster computation. */\n double lut_decay_prob[CHK_LUT_SIZE + 1];\n\n double decay; /* Decay constant */\n double inv_decay; /* Cache 1/decay for faster computations */\n\n counter_t total; /* Total recorded count for all updates */\n\n int k;\n int numbuckets;\n} chkTopK;\n\nchkTopK *chkTopKCreate(int k, int numbuckets, double decay);\nvoid chkTopKRelease(chkTopK *topk);\nsds chkTopKUpdate(chkTopK *topk, char *item, int itemlen, counter_t weight);\nchkHeapBucket *chkTopKList(chkTopK *topk);\nsize_t chkTopKGetMemoryUsage(chkTopK *topk);\n\n#ifdef REDIS_TEST\n\nint chkTopKTest(int argc, char *argv[], int flags);\n\n#endif /* REDIS_TEST */\n" }, { "path": "src/cli_commands.c", "content": "#include \n#include \"cli_commands.h\"\n\n/* Definitions to configure commands.c to generate the above structs. */\n#define MAKE_CMD(name,summary,complexity,since,doc_flags,replaced,deprecated,group,group_enum,history,num_history,tips,num_tips,function,arity,flags,acl,key_specs,key_specs_num,get_keys,numargs) name,summary,group,since,numargs\n#define MAKE_ARG(name,type,key_spec_index,token,summary,since,flags,numsubargs,deprecated_since) name,type,token,since,flags,numsubargs\n#define COMMAND_ARG cliCommandArg\n#define COMMAND_STRUCT commandDocs\n#define SKIP_CMD_HISTORY_TABLE\n#define SKIP_CMD_TIPS_TABLE\n#define SKIP_CMD_KEY_SPECS_TABLE\n\n#include \"commands.def\"\n" }, { "path": "src/cli_commands.h", "content": "/* This file is used by redis-cli in place of server.h when including commands.c\n * It contains alternative structs which omit the parts of the commands table\n * that are not suitable for redis-cli, e.g. the command proc. */\n\n#ifndef __REDIS_CLI_COMMANDS_H\n#define __REDIS_CLI_COMMANDS_H\n\n#include \n#include \"commands.h\"\n\n/* Syntax specifications for a command argument. */\ntypedef struct cliCommandArg {\n char *name;\n redisCommandArgType type;\n char *token;\n char *since;\n int flags;\n int numsubargs;\n struct cliCommandArg *subargs;\n const char *display_text;\n\n /*\n * For use at runtime.\n * Fields used to keep track of input word matches for command-line hinting.\n */\n int matched; /* How many input words have been matched by this argument? */\n int matched_token; /* Has the token been matched? */\n int matched_name; /* Has the name been matched? */\n int matched_all; /* Has the whole argument been consumed (no hint needed)? */\n} cliCommandArg;\n\n/* Command documentation info used for help output */\nstruct commandDocs {\n char *name;\n char *summary;\n char *group;\n char *since;\n int numargs;\n cliCommandArg *args; /* An array of the command arguments. */\n struct commandDocs *subcommands;\n char *params; /* A string describing the syntax of the command arguments. */\n};\n\nextern struct commandDocs redisCommandTable[];\n\n#endif\n" }, { "path": "src/cli_common.c", "content": "/* CLI (command line interface) common methods\n * \n * Copyright (c) 2020-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n */\n\n#include \"fmacros.h\"\n#include \"cli_common.h\"\n#include \"version.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include /* Use hiredis' sds compat header that maps sds calls to their hi_ variants */\n#include /* use sds.h from hiredis, so that only one set of sds functions will be present in the binary */\n#include \n#include \n#include \n#ifdef USE_OPENSSL\n#include \n#include \n#include \n#endif\n\n#define UNUSED(V) ((void) V)\n\nchar *redisGitSHA1(void);\nchar *redisGitDirty(void);\n\n/* Wrapper around redisSecureConnection to avoid hiredis_ssl dependencies if\n * not building with TLS support.\n */\nint cliSecureConnection(redisContext *c, cliSSLconfig config, const char **err) {\n#ifdef USE_OPENSSL\n static SSL_CTX *ssl_ctx = NULL;\n\n if (!ssl_ctx) {\n ssl_ctx = SSL_CTX_new(SSLv23_client_method());\n if (!ssl_ctx) {\n *err = \"Failed to create SSL_CTX\";\n goto error;\n }\n SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);\n SSL_CTX_set_verify(ssl_ctx, config.skip_cert_verify ? SSL_VERIFY_NONE : SSL_VERIFY_PEER, NULL);\n\n if (config.cacert || config.cacertdir) {\n if (!SSL_CTX_load_verify_locations(ssl_ctx, config.cacert, config.cacertdir)) {\n *err = \"Invalid CA Certificate File/Directory\";\n goto error;\n }\n } else {\n if (!SSL_CTX_set_default_verify_paths(ssl_ctx)) {\n *err = \"Failed to use default CA paths\";\n goto error;\n }\n }\n\n if (config.cert && !SSL_CTX_use_certificate_chain_file(ssl_ctx, config.cert)) {\n *err = \"Invalid client certificate\";\n goto error;\n }\n\n if (config.key && !SSL_CTX_use_PrivateKey_file(ssl_ctx, config.key, SSL_FILETYPE_PEM)) {\n *err = \"Invalid private key\";\n goto error;\n }\n if (config.ciphers && !SSL_CTX_set_cipher_list(ssl_ctx, config.ciphers)) {\n *err = \"Error while configuring ciphers\";\n goto error;\n }\n#ifdef TLS1_3_VERSION\n if (config.ciphersuites && !SSL_CTX_set_ciphersuites(ssl_ctx, config.ciphersuites)) {\n *err = \"Error while setting cypher suites\";\n goto error;\n }\n#endif\n }\n\n SSL *ssl = SSL_new(ssl_ctx);\n if (!ssl) {\n *err = \"Failed to create SSL object\";\n return REDIS_ERR;\n }\n\n if (config.sni && !SSL_set_tlsext_host_name(ssl, config.sni)) {\n *err = \"Failed to configure SNI\";\n SSL_free(ssl);\n return REDIS_ERR;\n }\n\n return redisInitiateSSL(c, ssl);\n\nerror:\n SSL_CTX_free(ssl_ctx);\n ssl_ctx = NULL;\n return REDIS_ERR;\n#else\n (void) config;\n (void) c;\n (void) err;\n return REDIS_OK;\n#endif\n}\n\n/* Wrapper around hiredis to allow arbitrary reads and writes.\n *\n * We piggybacks on top of hiredis to achieve transparent TLS support,\n * and use its internal buffers so it can co-exist with commands\n * previously/later issued on the connection.\n *\n * Interface is close to enough to read()/write() so things should mostly\n * work transparently.\n */\n\n/* Write a raw buffer through a redisContext. If we already have something\n * in the buffer (leftovers from hiredis operations) it will be written\n * as well.\n */\nssize_t cliWriteConn(redisContext *c, const char *buf, size_t buf_len)\n{\n int done = 0;\n\n /* Append data to buffer which is *usually* expected to be empty\n * but we don't assume that, and write.\n */\n c->obuf = sdscatlen(c->obuf, buf, buf_len);\n if (redisBufferWrite(c, &done) == REDIS_ERR) {\n if (!(c->flags & REDIS_BLOCK))\n errno = EAGAIN;\n\n /* On error, we assume nothing was written and we roll back the\n * buffer to its original state.\n */\n if (sdslen(c->obuf) > buf_len)\n sdsrange(c->obuf, 0, -(buf_len+1));\n else\n sdsclear(c->obuf);\n\n return -1;\n }\n\n /* If we're done, free up everything. We may have written more than\n * buf_len (if c->obuf was not initially empty) but we don't have to\n * tell.\n */\n if (done) {\n sdsclear(c->obuf);\n return buf_len;\n }\n\n /* Write was successful but we have some leftovers which we should\n * remove from the buffer.\n *\n * Do we still have data that was there prior to our buf? If so,\n * restore buffer to it's original state and report no new data was\n * written.\n */\n if (sdslen(c->obuf) > buf_len) {\n sdsrange(c->obuf, 0, -(buf_len+1));\n return 0;\n }\n\n /* At this point we're sure no prior data is left. We flush the buffer\n * and report how much we've written.\n */\n size_t left = sdslen(c->obuf);\n sdsclear(c->obuf);\n return buf_len - left;\n}\n\n/* Wrapper around OpenSSL (libssl and libcrypto) initialisation\n */\nint cliSecureInit(void)\n{\n#ifdef USE_OPENSSL\n ERR_load_crypto_strings();\n SSL_load_error_strings();\n SSL_library_init();\n#endif\n return REDIS_OK;\n}\n\n/* Create an sds from stdin */\nsds readArgFromStdin(void) {\n char buf[1024];\n sds arg = sdsempty();\n\n while(1) {\n int nread = read(fileno(stdin),buf,1024);\n\n if (nread == 0) break;\n else if (nread == -1) {\n perror(\"Reading from standard input\");\n exit(1);\n }\n arg = sdscatlen(arg,buf,nread);\n }\n return arg;\n}\n\n/* Create an sds array from argv, either as-is or by dequoting every\n * element. When quoted is non-zero, may return a NULL to indicate an\n * invalid quoted string.\n *\n * The caller should free the resulting array of sds strings with\n * sdsfreesplitres().\n */\nsds *getSdsArrayFromArgv(int argc,char **argv, int quoted) {\n sds *res = sds_malloc(sizeof(sds) * argc);\n\n for (int j = 0; j < argc; j++) {\n if (quoted) {\n sds unquoted = unquoteCString(argv[j]);\n if (!unquoted) {\n while (--j >= 0) sdsfree(res[j]);\n sds_free(res);\n return NULL;\n }\n res[j] = unquoted;\n } else {\n res[j] = sdsnew(argv[j]);\n }\n }\n\n return res;\n}\n\n/* Unquote a null-terminated string and return it as a binary-safe sds. */\nsds unquoteCString(char *str) {\n int count;\n sds *unquoted = sdssplitargs(str, &count);\n sds res = NULL;\n\n if (unquoted && count == 1) {\n res = unquoted[0];\n unquoted[0] = NULL;\n }\n\n if (unquoted)\n sdsfreesplitres(unquoted, count);\n\n return res;\n}\n\n\n/* URL-style percent decoding. */\n#define isHexChar(c) (isdigit(c) || ((c) >= 'a' && (c) <= 'f'))\n#define decodeHexChar(c) (isdigit(c) ? (c) - '0' : (c) - 'a' + 10)\n#define decodeHex(h, l) ((decodeHexChar(h) << 4) + decodeHexChar(l))\n\nstatic sds percentDecode(const char *pe, size_t len) {\n const char *end = pe + len;\n sds ret = sdsempty();\n const char *curr = pe;\n\n while (curr < end) {\n if (*curr == '%') {\n if ((end - curr) < 2) {\n fprintf(stderr, \"Incomplete URI encoding\\n\");\n exit(1);\n }\n\n char h = tolower(*(++curr));\n char l = tolower(*(++curr));\n if (!isHexChar(h) || !isHexChar(l)) {\n fprintf(stderr, \"Illegal character in URI encoding\\n\");\n exit(1);\n }\n char c = decodeHex(h, l);\n ret = sdscatlen(ret, &c, 1);\n curr++;\n } else {\n ret = sdscatlen(ret, curr++, 1);\n }\n }\n\n return ret;\n}\n\n/* Parse a URI and extract the server connection information.\n * URI scheme is based on the provisional specification[1] excluding support\n * for query parameters. Valid URIs are:\n * scheme: \"redis://\"\n * authority: [[ \":\"] \"@\"] [ [\":\" ]]\n * path: [\"/\" []]\n *\n * [1]: https://www.iana.org/assignments/uri-schemes/prov/redis */\nvoid parseRedisUri(const char *uri, const char* tool_name, cliConnInfo *connInfo, int *tls_flag) {\n#ifdef USE_OPENSSL\n UNUSED(tool_name);\n#else\n UNUSED(tls_flag);\n#endif\n\n const char *scheme = \"redis://\";\n const char *tlsscheme = \"rediss://\";\n const char *curr = uri;\n const char *end = uri + strlen(uri);\n const char *userinfo, *username, *port, *host, *path;\n\n /* URI must start with a valid scheme. */\n if (!strncasecmp(tlsscheme, curr, strlen(tlsscheme))) {\n#ifdef USE_OPENSSL\n *tls_flag = 1;\n curr += strlen(tlsscheme);\n#else\n fprintf(stderr,\"rediss:// is only supported when %s is compiled with OpenSSL\\n\", tool_name);\n exit(1);\n#endif\n } else if (!strncasecmp(scheme, curr, strlen(scheme))) {\n curr += strlen(scheme);\n } else {\n fprintf(stderr,\"Invalid URI scheme\\n\");\n exit(1);\n }\n if (curr == end) return;\n\n /* Extract user info. */\n if ((userinfo = strchr(curr,'@'))) {\n if ((username = strchr(curr, ':')) && username < userinfo) {\n connInfo->user = percentDecode(curr, username - curr);\n curr = username + 1;\n }\n\n connInfo->auth = percentDecode(curr, userinfo - curr);\n curr = userinfo + 1;\n }\n if (curr == end) return;\n\n /* Extract host and port. */\n path = strchr(curr, '/');\n if (*curr != '/') {\n host = path ? path - 1 : end;\n if (*curr == '[') {\n curr += 1;\n if ((port = strchr(curr, ']'))) {\n if (*(port+1) == ':') {\n connInfo->hostport = atoi(port + 2);\n }\n host = port - 1;\n }\n } else {\n if ((port = strchr(curr, ':'))) {\n connInfo->hostport = atoi(port + 1);\n host = port - 1;\n }\n }\n sdsfree(connInfo->hostip);\n connInfo->hostip = sdsnewlen(curr, host - curr + 1);\n }\n curr = path ? path + 1 : end;\n if (curr == end) return;\n\n /* Extract database number. */\n connInfo->input_dbnum = atoi(curr);\n}\n\nvoid freeCliConnInfo(cliConnInfo connInfo){\n if (connInfo.hostip) sdsfree(connInfo.hostip);\n if (connInfo.auth) sdsfree(connInfo.auth);\n if (connInfo.user) sdsfree(connInfo.user);\n}\n\n/*\n * Escape a Unicode string for JSON output (--json), following RFC 7159:\n * https://datatracker.ietf.org/doc/html/rfc7159#section-7\n*/\nsds escapeJsonString(sds s, const char *p, size_t len) {\n s = sdscatlen(s,\"\\\"\",1);\n while(len--) {\n switch(*p) {\n case '\\\\':\n case '\"':\n s = sdscatprintf(s,\"\\\\%c\",*p);\n break;\n case '\\n': s = sdscatlen(s,\"\\\\n\",2); break;\n case '\\f': s = sdscatlen(s,\"\\\\f\",2); break;\n case '\\r': s = sdscatlen(s,\"\\\\r\",2); break;\n case '\\t': s = sdscatlen(s,\"\\\\t\",2); break;\n case '\\b': s = sdscatlen(s,\"\\\\b\",2); break;\n default:\n s = sdscatprintf(s,*(unsigned char *)p <= 0x1f ? \"\\\\u%04x\" : \"%c\",*p);\n }\n p++;\n }\n return sdscatlen(s,\"\\\"\",1);\n}\n\nsds cliVersion(void) {\n sds version = sdscatprintf(sdsempty(), \"%s\", REDIS_VERSION);\n\n /* Add git commit and working tree status when available. */\n if (strtoll(redisGitSHA1(),NULL,16)) {\n version = sdscatprintf(version, \" (git:%s\", redisGitSHA1());\n if (strtoll(redisGitDirty(),NULL,10))\n version = sdscatprintf(version, \"-dirty\");\n version = sdscat(version, \")\");\n }\n return version;\n}\n\n/* This is a wrapper to call redisConnect or redisConnectWithTimeout. */\nredisContext *redisConnectWrapper(const char *ip, int port, const struct timeval tv) {\n if (tv.tv_sec == 0 && tv.tv_usec == 0) {\n return redisConnect(ip, port);\n } else {\n return redisConnectWithTimeout(ip, port, tv);\n }\n}\n\n/* This is a wrapper to call redisConnectUnix or redisConnectUnixWithTimeout. */\nredisContext *redisConnectUnixWrapper(const char *path, const struct timeval tv) {\n if (tv.tv_sec == 0 && tv.tv_usec == 0) {\n return redisConnectUnix(path);\n } else {\n return redisConnectUnixWithTimeout(path, tv);\n }\n}\n" }, { "path": "src/cli_common.h", "content": "#ifndef __CLICOMMON_H\n#define __CLICOMMON_H\n\n#include \n#include /* Use hiredis' sds compat header that maps sds calls to their hi_ variants */\n\ntypedef struct cliSSLconfig {\n /* Requested SNI, or NULL */\n char *sni;\n /* CA Certificate file, or NULL */\n char *cacert;\n /* Directory where trusted CA certificates are stored, or NULL */\n char *cacertdir;\n /* Skip server certificate verification. */\n int skip_cert_verify;\n /* Client certificate to authenticate with, or NULL */\n char *cert;\n /* Private key file to authenticate with, or NULL */\n char *key;\n /* Preferred cipher list, or NULL (applies only to <= TLSv1.2) */\n char* ciphers;\n /* Preferred ciphersuites list, or NULL (applies only to TLSv1.3) */\n char* ciphersuites;\n} cliSSLconfig;\n\n\n/* server connection information object, used to describe an ip:port pair, db num user input, and user:pass. */\ntypedef struct cliConnInfo {\n char *hostip;\n int hostport;\n int input_dbnum;\n char *auth;\n char *user;\n} cliConnInfo;\n\nint cliSecureConnection(redisContext *c, cliSSLconfig config, const char **err);\n\nssize_t cliWriteConn(redisContext *c, const char *buf, size_t buf_len);\n\nint cliSecureInit(void);\n\nsds readArgFromStdin(void);\n\nsds *getSdsArrayFromArgv(int argc,char **argv, int quoted);\n\nsds unquoteCString(char *str);\n\nvoid parseRedisUri(const char *uri, const char* tool_name, cliConnInfo *connInfo, int *tls_flag);\n\nvoid freeCliConnInfo(cliConnInfo connInfo);\n\nsds escapeJsonString(sds s, const char *p, size_t len);\n\nsds cliVersion(void);\n\nredisContext *redisConnectWrapper(const char *ip, int port, const struct timeval tv);\nredisContext *redisConnectUnixWrapper(const char *path, const struct timeval tv);\n\n#endif /* __CLICOMMON_H */\n" }, { "path": "src/cluster.c", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Copyright (c) 2024-present, Valkey contributors.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n *\n * Portions of this file are available under BSD3 terms; see REDISCONTRIBUTIONS for more information.\n */\n\n/*\n * cluster.c contains the common parts of a clustering\n * implementation, the parts that are shared between\n * any implementation of Redis clustering.\n */\n\n#include \"server.h\"\n#include \"cluster.h\"\n#include \"cluster_asm.h\"\n#include \"cluster_slot_stats.h\"\n\n#include \n#include \"bio.h\"\n\n/* -----------------------------------------------------------------------------\n * Key space handling\n * -------------------------------------------------------------------------- */\n\n/* If it can be inferred that the given glob-style pattern, as implemented in\n * stringmatchlen() in util.c, only can match keys belonging to a single slot,\n * that slot is returned. Otherwise -1 is returned. */\nint patternHashSlot(char *pattern, int length) {\n int s = -1; /* index of the first '{' */\n\n for (int i = 0; i < length; i++) {\n if (pattern[i] == '*' || pattern[i] == '?' || pattern[i] == '[') {\n /* Wildcard or character class found. Keys can be in any slot. */\n return -1;\n } else if (pattern[i] == '\\\\') {\n /* Escaped character. Computing slot in this case is not\n * implemented. We would need a temp buffer. */\n return -1;\n } else if (s == -1 && pattern[i] == '{') {\n /* Opening brace '{' found. */\n s = i;\n } else if (s >= 0 && pattern[i] == '}' && i == s + 1) {\n /* Empty tag '{}' found. The whole key is hashed. Ignore braces. */\n s = -2;\n } else if (s >= 0 && pattern[i] == '}') {\n /* Non-empty tag '{...}' found. Hash what's between braces. */\n return crc16(pattern + s + 1, i - s - 1) & 0x3FFF;\n }\n }\n\n /* The pattern matches a single key. Hash the whole pattern. */\n return crc16(pattern, length) & 0x3FFF;\n}\n\nint getSlotOrReply(client *c, robj *o) {\n long long slot;\n\n if (getLongLongFromObject(o,&slot) != C_OK ||\n slot < 0 || slot >= CLUSTER_SLOTS)\n {\n addReplyError(c,\"Invalid or out of range slot\");\n return -1;\n }\n return (int) slot;\n}\n\nConnectionType *connTypeOfCluster(void) {\n if (server.tls_cluster) {\n return connectionTypeTls();\n }\n\n return connectionTypeTcp();\n}\n\n/* -----------------------------------------------------------------------------\n * DUMP, RESTORE and MIGRATE commands\n * -------------------------------------------------------------------------- */\n\n/* Generates a DUMP-format representation of the object 'o', adding it to the\n * io stream pointed by 'rio'. This function can't fail. */\nvoid createDumpPayload(rio *payload, robj *o, robj *key, int dbid, int skip_checksum) {\n unsigned char buf[2];\n uint64_t crc = 0;\n\n /* Serialize the object in an RDB-like format. It consist of an object type\n * byte followed by the serialized object. This is understood by RESTORE. */\n rioInitWithBuffer(payload,sdsempty());\n\n /* Save key metadata if present without (handles TTL separately via command args) */\n if (getModuleMetaBits(o->metabits))\n serverAssert(rdbSaveKeyMetadata(payload, key, o, dbid) != -1);\n serverAssert(rdbSaveObjectType(payload,o));\n serverAssert(rdbSaveObject(payload,o,key,dbid));\n\n /* Write the footer, this is how it looks like:\n * ----------------+---------------------+---------------+\n * ... RDB payload | 2 bytes RDB version | 8 bytes CRC64 |\n * ----------------+---------------------+---------------+\n * RDB version and CRC are both in little endian.\n */\n\n /* RDB version */\n buf[0] = RDB_VERSION & 0xff;\n buf[1] = (RDB_VERSION >> 8) & 0xff;\n payload->io.buffer.ptr = sdscatlen(payload->io.buffer.ptr,buf,2);\n\n /* If crc checksum is disabled, crc is set to 0 and no checksum validation\n * will be performed on RESTORE. */\n if (!skip_checksum) {\n /* CRC64 */\n crc = crc64(0,(unsigned char*)payload->io.buffer.ptr,\n sdslen(payload->io.buffer.ptr));\n memrev64ifbe(&crc);\n }\n payload->io.buffer.ptr = sdscatlen(payload->io.buffer.ptr,&crc,8);\n}\n\n/* Verify that the RDB version of the dump payload matches the one of this Redis\n * instance and that the checksum is ok.\n * If the DUMP payload looks valid C_OK is returned, otherwise C_ERR\n * is returned. If rdbver_ptr is not NULL, its populated with the value read\n * from the input buffer. */\nint verifyDumpPayload(unsigned char *p, size_t len, uint16_t *rdbver_ptr) {\n unsigned char *footer;\n uint16_t rdbver;\n uint64_t crc;\n\n /* At least 2 bytes of RDB version and 8 of CRC64 should be present. */\n if (len < 10) return C_ERR;\n footer = p+(len-10);\n\n /* Set and verify RDB version. */\n rdbver = (footer[1] << 8) | footer[0];\n if (rdbver_ptr) {\n *rdbver_ptr = rdbver;\n }\n if (rdbver > RDB_VERSION) return C_ERR;\n\n if (server.skip_checksum_validation)\n return C_OK;\n\n uint64_t crc_payload;\n memcpy(&crc_payload, footer+2, 8);\n if (crc_payload == 0) /* No checksum. */\n return C_OK;\n\n /* Verify CRC64 */\n crc = crc64(0,p,len-8);\n memrev64ifbe(&crc);\n return crc == crc_payload ? C_OK : C_ERR;\n}\n\n/* DUMP keyname\n * DUMP is actually not used by Redis Cluster but it is the obvious\n * complement of RESTORE and can be useful for different applications. */\nvoid dumpCommand(client *c) {\n kvobj *o;\n rio payload;\n\n /* Check if the key is here. */\n if ((o = lookupKeyRead(c->db,c->argv[1])) == NULL) {\n addReplyNull(c);\n return;\n }\n\n /* Create the DUMP encoded representation. */\n createDumpPayload(&payload,o,c->argv[1],c->db->id,0);\n\n /* Transfer to the client */\n addReplyBulkSds(c,payload.io.buffer.ptr);\n return;\n}\n\n/* RESTORE key ttl serialized-value [REPLACE] [ABSTTL] [IDLETIME seconds] [FREQ frequency] */\nvoid restoreCommand(client *c) {\n long long ttl, lfu_freq = -1, lru_idle = -1, lru_clock = -1;\n rio payload;\n int j, type, replace = 0, absttl = 0;\n robj *obj;\n\n /* Parse additional options */\n for (j = 4; j < c->argc; j++) {\n int additional = c->argc-j-1;\n if (!strcasecmp(c->argv[j]->ptr,\"replace\")) {\n replace = 1;\n } else if (!strcasecmp(c->argv[j]->ptr,\"absttl\")) {\n absttl = 1;\n } else if (!strcasecmp(c->argv[j]->ptr,\"idletime\") && additional >= 1 &&\n lfu_freq == -1)\n {\n if (getLongLongFromObjectOrReply(c,c->argv[j+1],&lru_idle,NULL)\n != C_OK) return;\n if (lru_idle < 0) {\n addReplyError(c,\"Invalid IDLETIME value, must be >= 0\");\n return;\n }\n lru_clock = LRU_CLOCK();\n j++; /* Consume additional arg. */\n } else if (!strcasecmp(c->argv[j]->ptr,\"freq\") && additional >= 1 &&\n lru_idle == -1)\n {\n if (getLongLongFromObjectOrReply(c,c->argv[j+1],&lfu_freq,NULL)\n != C_OK) return;\n if (lfu_freq < 0 || lfu_freq > 255) {\n addReplyError(c,\"Invalid FREQ value, must be >= 0 and <= 255\");\n return;\n }\n j++; /* Consume additional arg. */\n } else {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n }\n\n /* Make sure this key does not already exist here... */\n robj *key = c->argv[1];\n kvobj *oldval = lookupKeyWrite(c->db,key);\n int oldtype = oldval ? oldval->type : -1;\n if (!replace && oldval) {\n addReplyErrorObject(c,shared.busykeyerr);\n return;\n }\n\n /* Check if the TTL value makes sense */\n if (getLongLongFromObjectOrReply(c,c->argv[2],&ttl,NULL) != C_OK) {\n return;\n } else if (ttl < 0) {\n addReplyError(c,\"Invalid TTL value, must be >= 0\");\n return;\n }\n\n /* Verify RDB version and data checksum. */\n if (verifyDumpPayload(c->argv[3]->ptr,sdslen(c->argv[3]->ptr),NULL) == C_ERR)\n {\n addReplyError(c,\"DUMP payload version or checksum are wrong\");\n return;\n }\n\n rioInitWithBuffer(&payload,c->argv[3]->ptr);\n\n /* Initialize metadata spec to collect metadata+expiry from payload. */\n KeyMetaSpec keymeta;\n keyMetaSpecInit(&keymeta);\n\n /* Compute TTL early so we can add it to metadata spec in correct order */\n if (ttl) {\n if (!absttl) ttl+=commandTimeSnapshot();\n keyMetaSpecAdd(&keymeta, KEY_META_ID_EXPIRE, ttl);\n }\n\n /* With metadata, type = RDB_OPCODE_KEY_META. Layout: [,],, */\n type = rdbLoadType(&payload);\n if (rdbResolveKeyType(&payload, &type, c->db->id, &keymeta) == -1) {\n addReplyError(c,\"Bad data format\");\n return;\n }\n\n /* Load the object */\n if ((obj = rdbLoadObject(type,&payload,key->ptr,c->db->id,NULL)) == NULL)\n {\n keyMetaSpecCleanup(&keymeta);\n addReplyError(c,\"Bad data format\");\n return;\n }\n\n /* Remove the old key if needed. */\n int deleted = 0;\n if (replace)\n deleted = dbDelete(c->db,key);\n\n if (ttl && checkAlreadyExpired(ttl)) {\n if (deleted) {\n robj *aux = server.lazyfree_lazy_server_del ? shared.unlink : shared.del;\n rewriteClientCommandVector(c, 2, aux, key);\n keyModified(c,c->db,key,NULL,1);\n notifyKeyspaceEvent(NOTIFY_GENERIC,\"del\",key,c->db->id);\n server.dirty++;\n }\n /* Update the stats, see setGenericCommand for details. */\n server.stat_expiredkeys++;\n keyMetaSpecCleanup(&keymeta);\n decrRefCount(obj);\n addReply(c, shared.ok);\n return;\n }\n\n /* Create the key and set the TTL if any */\n kvobj *kv = dbAddInternal(c->db, key, &obj, NULL, &keymeta);\n\n /* Save type: kv may be reallocated by module callbacks during notifyKeyspaceEvent below. */\n int kvtype = kv->type;\n\n /* If minExpiredField was set, then the object is hash with expiration\n * on fields and need to register it in global HFE DS */\n if (kvtype == OBJ_HASH) {\n uint64_t minExpiredField = hashTypeGetMinExpire(kv, 1);\n if (minExpiredField != EB_EXPIRE_TIME_INVALID)\n estoreAdd(c->db->subexpires, getKeySlot(key->ptr), kv, minExpiredField);\n }\n\n if (kvtype == OBJ_STREAM)\n streamKeyLoaded(c->db, key, kv);\n\n if (ttl) {\n if (!absttl) {\n /* Propagate TTL as absolute timestamp */\n robj *ttl_obj = createStringObjectFromLongLong(ttl);\n rewriteClientCommandArgument(c,2,ttl_obj);\n decrRefCount(ttl_obj);\n rewriteClientCommandArgument(c,c->argc,shared.absttl);\n }\n }\n objectSetLRUOrLFU(kv, lfu_freq, lru_idle, lru_clock, 1000);\n keyModified(c,c->db,key,NULL,1);\n notifyKeyspaceEvent(NOTIFY_GENERIC,\"restore\",key,c->db->id);\n KSN_INVALIDATE_KVOBJ(kv);\n\n /* If we deleted a key that means REPLACE parameter was passed and the\n * destination key existed. */\n if (deleted) {\n notifyKeyspaceEvent(NOTIFY_OVERWRITTEN, \"overwritten\", key, c->db->id);\n if (oldtype != kvtype) {\n notifyKeyspaceEvent(NOTIFY_TYPE_CHANGED, \"type_changed\", key, c->db->id);\n }\n }\n addReply(c,shared.ok);\n server.dirty++;\n}\n/* MIGRATE socket cache implementation.\n *\n * We take a map between host:ip and a TCP socket that we used to connect\n * to this instance in recent time.\n * This sockets are closed when the max number we cache is reached, and also\n * in serverCron() when they are around for more than a few seconds. */\n#define MIGRATE_SOCKET_CACHE_ITEMS 64 /* max num of items in the cache. */\n#define MIGRATE_SOCKET_CACHE_TTL 10 /* close cached sockets after 10 sec. */\n\ntypedef struct migrateCachedSocket {\n connection *conn;\n long last_dbid;\n time_t last_use_time;\n} migrateCachedSocket;\n\n/* Return a migrateCachedSocket containing a TCP socket connected with the\n * target instance, possibly returning a cached one.\n *\n * This function is responsible of sending errors to the client if a\n * connection can't be established. In this case -1 is returned.\n * Otherwise on success the socket is returned, and the caller should not\n * attempt to free it after usage.\n *\n * If the caller detects an error while using the socket, migrateCloseSocket()\n * should be called so that the connection will be created from scratch\n * the next time. */\nmigrateCachedSocket* migrateGetSocket(client *c, robj *host, robj *port, long timeout) {\n connection *conn;\n sds name = sdsempty();\n migrateCachedSocket *cs;\n\n /* Check if we have an already cached socket for this ip:port pair. */\n name = sdscatlen(name,host->ptr,sdslen(host->ptr));\n name = sdscatlen(name,\":\",1);\n name = sdscatlen(name,port->ptr,sdslen(port->ptr));\n cs = dictFetchValue(server.migrate_cached_sockets,name);\n if (cs) {\n sdsfree(name);\n cs->last_use_time = server.unixtime;\n return cs;\n }\n\n /* No cached socket, create one. */\n if (dictSize(server.migrate_cached_sockets) == MIGRATE_SOCKET_CACHE_ITEMS) {\n /* Too many items, drop one at random. */\n dictEntry *de = dictGetRandomKey(server.migrate_cached_sockets);\n cs = dictGetVal(de);\n connClose(cs->conn);\n zfree(cs);\n dictDelete(server.migrate_cached_sockets,dictGetKey(de));\n }\n\n /* Create the connection */\n conn = connCreate(server.el, connTypeOfCluster());\n if (connBlockingConnect(conn, host->ptr, atoi(port->ptr), timeout)\n != C_OK) {\n addReplyError(c,\"-IOERR error or timeout connecting to the client\");\n connClose(conn);\n sdsfree(name);\n return NULL;\n }\n connEnableTcpNoDelay(conn);\n\n /* Add to the cache and return it to the caller. */\n cs = zmalloc(sizeof(*cs));\n cs->conn = conn;\n\n cs->last_dbid = -1;\n cs->last_use_time = server.unixtime;\n dictAdd(server.migrate_cached_sockets,name,cs);\n return cs;\n}\n\n/* Free a migrate cached connection. */\nvoid migrateCloseSocket(robj *host, robj *port) {\n sds name = sdsempty();\n migrateCachedSocket *cs;\n\n name = sdscatlen(name,host->ptr,sdslen(host->ptr));\n name = sdscatlen(name,\":\",1);\n name = sdscatlen(name,port->ptr,sdslen(port->ptr));\n cs = dictFetchValue(server.migrate_cached_sockets,name);\n if (!cs) {\n sdsfree(name);\n return;\n }\n\n connClose(cs->conn);\n zfree(cs);\n dictDelete(server.migrate_cached_sockets,name);\n sdsfree(name);\n}\n\nvoid migrateCloseTimedoutSockets(void) {\n dictIterator di;\n dictEntry *de;\n\n dictInitSafeIterator(&di, server.migrate_cached_sockets);\n while((de = dictNext(&di)) != NULL) {\n migrateCachedSocket *cs = dictGetVal(de);\n\n if ((server.unixtime - cs->last_use_time) > MIGRATE_SOCKET_CACHE_TTL) {\n connClose(cs->conn);\n zfree(cs);\n dictDelete(server.migrate_cached_sockets,dictGetKey(de));\n }\n }\n dictResetIterator(&di);\n}\n\n/* MIGRATE host port key dbid timeout [COPY | REPLACE | AUTH password |\n * AUTH2 username password]\n *\n * On in the multiple keys form:\n *\n * MIGRATE host port \"\" dbid timeout [COPY | REPLACE | AUTH password |\n * AUTH2 username password] KEYS key1 key2 ... keyN */\nvoid migrateCommand(client *c) {\n migrateCachedSocket *cs;\n int copy = 0, replace = 0, j;\n char *username = NULL;\n char *password = NULL;\n long timeout;\n long dbid;\n robj **kvArray = NULL; /* Objects to migrate. */\n robj **keyArray = NULL; /* Key names. */\n robj **newargv = NULL; /* Used to rewrite the command as DEL ... keys ... */\n rio cmd, payload;\n int may_retry = 1;\n int write_error = 0;\n int argv_rewritten = 0;\n\n /* To support the KEYS option we need the following additional state. */\n int first_key = 3; /* Argument index of the first key. */\n int num_keys = 1; /* By default only migrate the 'key' argument. */\n\n /* Parse additional options */\n for (j = 6; j < c->argc; j++) {\n int moreargs = (c->argc-1) - j;\n if (!strcasecmp(c->argv[j]->ptr,\"copy\")) {\n copy = 1;\n } else if (!strcasecmp(c->argv[j]->ptr,\"replace\")) {\n replace = 1;\n } else if (!strcasecmp(c->argv[j]->ptr,\"auth\")) {\n if (!moreargs) {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n j++;\n password = c->argv[j]->ptr;\n redactClientCommandArgument(c,j);\n } else if (!strcasecmp(c->argv[j]->ptr,\"auth2\")) {\n if (moreargs < 2) {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n username = c->argv[++j]->ptr;\n redactClientCommandArgument(c,j);\n password = c->argv[++j]->ptr;\n redactClientCommandArgument(c,j);\n } else if (!strcasecmp(c->argv[j]->ptr,\"keys\")) {\n if (sdslen(c->argv[3]->ptr) != 0) {\n addReplyError(c,\n \"When using MIGRATE KEYS option, the key argument\"\n \" must be set to the empty string\");\n return;\n }\n first_key = j+1;\n num_keys = c->argc - j - 1;\n break; /* All the remaining args are keys. */\n } else {\n addReplyErrorObject(c,shared.syntaxerr);\n return;\n }\n }\n\n /* Sanity check */\n if (getLongFromObjectOrReply(c,c->argv[5],&timeout,NULL) != C_OK ||\n getLongFromObjectOrReply(c,c->argv[4],&dbid,NULL) != C_OK)\n {\n return;\n }\n if (timeout <= 0) timeout = 1000;\n\n /* Check if the keys are here. If at least one key is to migrate, do it\n * otherwise if all the keys are missing reply with \"NOKEY\" to signal\n * the caller there was nothing to migrate. We don't return an error in\n * this case, since often this is due to a normal condition like the key\n * expiring in the meantime. */\n kvArray = zrealloc(kvArray,sizeof(kvobj*)*num_keys);\n keyArray = zrealloc(keyArray,sizeof(robj*)*num_keys);\n int num_exists = 0;\n\n for (j = 0; j < num_keys; j++) {\n if ((kvArray[num_exists] = lookupKeyRead(c->db,c->argv[first_key+j])) != NULL) {\n keyArray[num_exists] = c->argv[first_key+j];\n num_exists++;\n }\n }\n num_keys = num_exists;\n if (num_keys == 0) {\n zfree(kvArray); zfree(keyArray);\n addReplySds(c,sdsnew(\"+NOKEY\\r\\n\"));\n return;\n }\n\n try_again:\n write_error = 0;\n\n /* Connect */\n cs = migrateGetSocket(c,c->argv[1],c->argv[2],timeout);\n if (cs == NULL) {\n zfree(kvArray); zfree(keyArray);\n return; /* error sent to the client by migrateGetSocket() */\n }\n\n rioInitWithBuffer(&cmd,sdsempty());\n\n /* Authentication */\n if (password) {\n int arity = username ? 3 : 2;\n serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',arity));\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,\"AUTH\",4));\n if (username) {\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,username,\n sdslen(username)));\n }\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,password,\n sdslen(password)));\n }\n\n /* Send the SELECT command if the current DB is not already selected. */\n int select = cs->last_dbid != dbid; /* Should we emit SELECT? */\n if (select) {\n serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',2));\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,\"SELECT\",6));\n serverAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,dbid));\n }\n\n int non_expired = 0; /* Number of keys that we'll find non expired.\n Note that serializing large keys may take some time\n so certain keys that were found non expired by the\n lookupKey() function, may be expired later. */\n\n /* Create RESTORE payload and generate the protocol to call the command. */\n for (j = 0; j < num_keys; j++) {\n long long ttl = 0;\n long long expireat = kvobjGetExpire(kvArray[j]);\n\n if (expireat != -1) {\n ttl = expireat-commandTimeSnapshot();\n if (ttl < 0) {\n continue;\n }\n if (ttl < 1) ttl = 1;\n }\n\n /* Relocate valid (non expired) keys and values into the array in successive\n * positions to remove holes created by the keys that were present\n * in the first lookup but are now expired after the second lookup. */\n kvArray[non_expired] = kvArray[j];\n keyArray[non_expired++] = keyArray[j];\n\n serverAssertWithInfo(c,NULL,\n rioWriteBulkCount(&cmd,'*',replace ? 5 : 4));\n\n if (server.cluster_enabled)\n serverAssertWithInfo(c,NULL,\n rioWriteBulkString(&cmd,\"RESTORE-ASKING\",14));\n else\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,\"RESTORE\",7));\n serverAssertWithInfo(c,NULL,sdsEncodedObject(keyArray[j]));\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,keyArray[j]->ptr,\n sdslen(keyArray[j]->ptr)));\n serverAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,ttl));\n\n /* Emit the payload argument, that is the serialized object using\n * the DUMP format. */\n createDumpPayload(&payload,kvArray[j],keyArray[j],dbid,0);\n serverAssertWithInfo(c,NULL,\n rioWriteBulkString(&cmd,payload.io.buffer.ptr,\n sdslen(payload.io.buffer.ptr)));\n sdsfree(payload.io.buffer.ptr);\n\n /* Add the REPLACE option to the RESTORE command if it was specified\n * as a MIGRATE option. */\n if (replace)\n serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,\"REPLACE\",7));\n }\n\n /* Fix the actual number of keys we are migrating. */\n num_keys = non_expired;\n\n /* Transfer the query to the other node in 64K chunks. */\n errno = 0;\n {\n sds buf = cmd.io.buffer.ptr;\n size_t pos = 0, towrite;\n int nwritten = 0;\n\n while ((towrite = sdslen(buf)-pos) > 0) {\n towrite = (towrite > (64*1024) ? (64*1024) : towrite);\n nwritten = connSyncWrite(cs->conn,buf+pos,towrite,timeout);\n if (nwritten != (signed)towrite) {\n write_error = 1;\n goto socket_err;\n }\n pos += nwritten;\n }\n }\n\n char buf0[1024]; /* Auth reply. */\n char buf1[1024]; /* Select reply. */\n char buf2[1024]; /* Restore reply. */\n\n /* Read the AUTH reply if needed. */\n if (password && connSyncReadLine(cs->conn, buf0, sizeof(buf0), timeout) <= 0)\n goto socket_err;\n\n /* Read the SELECT reply if needed. */\n if (select && connSyncReadLine(cs->conn, buf1, sizeof(buf1), timeout) <= 0)\n goto socket_err;\n\n /* Read the RESTORE replies. */\n int error_from_target = 0;\n int socket_error = 0;\n int del_idx = 1; /* Index of the key argument for the replicated DEL op. */\n\n /* Allocate the new argument vector that will replace the current command,\n * to propagate the MIGRATE as a DEL command (if no COPY option was given).\n * We allocate num_keys+1 because the additional argument is for \"DEL\"\n * command name itself. */\n if (!copy) newargv = zmalloc(sizeof(robj*)*(num_keys+1));\n\n for (j = 0; j < num_keys; j++) {\n if (connSyncReadLine(cs->conn, buf2, sizeof(buf2), timeout) <= 0) {\n socket_error = 1;\n break;\n }\n if ((password && buf0[0] == '-') ||\n (select && buf1[0] == '-') ||\n buf2[0] == '-')\n {\n /* On error assume that last_dbid is no longer valid. */\n if (!error_from_target) {\n cs->last_dbid = -1;\n char *errbuf;\n if (password && buf0[0] == '-') errbuf = buf0;\n else if (select && buf1[0] == '-') errbuf = buf1;\n else errbuf = buf2;\n\n error_from_target = 1;\n addReplyErrorFormat(c,\"Target instance replied with error: %s\",\n errbuf+1);\n }\n } else {\n if (!copy) {\n /* No COPY option: remove the local key, signal the change. */\n dbDelete(c->db,keyArray[j]);\n keyModified(c,c->db,keyArray[j],NULL,1);\n notifyKeyspaceEvent(NOTIFY_GENERIC,\"del\",keyArray[j],c->db->id);\n server.dirty++;\n\n /* Populate the argument vector to replace the old one. */\n newargv[del_idx++] = keyArray[j];\n incrRefCount(keyArray[j]);\n }\n }\n }\n\n /* On socket error, if we want to retry, do it now before rewriting the\n * command vector. We only retry if we are sure nothing was processed\n * and we failed to read the first reply (j == 0 test). */\n if (!error_from_target && socket_error && j == 0 && may_retry &&\n errno != ETIMEDOUT)\n {\n goto socket_err; /* A retry is guaranteed because of tested conditions.*/\n }\n\n /* On socket errors, close the migration socket now that we still have\n * the original host/port in the ARGV. Later the original command may be\n * rewritten to DEL and will be too later. */\n if (socket_error) migrateCloseSocket(c->argv[1],c->argv[2]);\n\n if (!copy) {\n /* Translate MIGRATE as DEL for replication/AOF. Note that we do\n * this only for the keys for which we received an acknowledgement\n * from the receiving Redis server, by using the del_idx index. */\n if (del_idx > 1) {\n newargv[0] = createStringObject(\"DEL\",3);\n /* Note that the following call takes ownership of newargv. */\n replaceClientCommandVector(c,del_idx,newargv);\n argv_rewritten = 1;\n } else {\n /* No key transfer acknowledged, no need to rewrite as DEL. */\n zfree(newargv);\n }\n newargv = NULL; /* Make it safe to call zfree() on it in the future. */\n }\n\n /* If we are here and a socket error happened, we don't want to retry.\n * Just signal the problem to the client, but only do it if we did not\n * already queue a different error reported by the destination server. */\n if (!error_from_target && socket_error) {\n may_retry = 0;\n goto socket_err;\n }\n\n if (!error_from_target) {\n /* Success! Update the last_dbid in migrateCachedSocket, so that we can\n * avoid SELECT the next time if the target DB is the same. Reply +OK.\n *\n * Note: If we reached this point, even if socket_error is true\n * still the SELECT command succeeded (otherwise the code jumps to\n * socket_err label. */\n cs->last_dbid = dbid;\n addReply(c,shared.ok);\n } else {\n /* On error we already sent it in the for loop above, and set\n * the currently selected socket to -1 to force SELECT the next time. */\n }\n\n sdsfree(cmd.io.buffer.ptr);\n zfree(kvArray); zfree(keyArray); zfree(newargv);\n return;\n\n/* On socket errors we try to close the cached socket and try again.\n * It is very common for the cached socket to get closed, if just reopening\n * it works it's a shame to notify the error to the caller. */\n socket_err:\n /* Cleanup we want to perform in both the retry and no retry case.\n * Note: Closing the migrate socket will also force SELECT next time. */\n sdsfree(cmd.io.buffer.ptr);\n\n /* If the command was rewritten as DEL and there was a socket error,\n * we already closed the socket earlier. While migrateCloseSocket()\n * is idempotent, the host/port arguments are now gone, so don't do it\n * again. */\n if (!argv_rewritten) migrateCloseSocket(c->argv[1],c->argv[2]);\n zfree(newargv);\n newargv = NULL; /* This will get reallocated on retry. */\n\n /* Retry only if it's not a timeout and we never attempted a retry\n * (or the code jumping here did not set may_retry to zero). */\n if (errno != ETIMEDOUT && may_retry) {\n may_retry = 0;\n goto try_again;\n }\n\n /* Cleanup we want to do if no retry is attempted. */\n zfree(kvArray); zfree(keyArray);\n addReplyErrorSds(c, sdscatprintf(sdsempty(),\n \"-IOERR error or timeout %s to target instance\",\n write_error ? \"writing\" : \"reading\"));\n return;\n}\n\n/* Cluster node sanity check. Returns C_OK if the node id\n * is valid an C_ERR otherwise. */\nint verifyClusterNodeId(const char *name, int length) {\n if (length != CLUSTER_NAMELEN) return C_ERR;\n for (int i = 0; i < length; i++) {\n if (name[i] >= 'a' && name[i] <= 'z') continue;\n if (name[i] >= '0' && name[i] <= '9') continue;\n return C_ERR;\n }\n return C_OK;\n}\n\nint isValidAuxChar(int c) {\n return isalnum(c) || (strchr(\"!#$%&()*+:;<>?@[]^{|}~\", c) == NULL);\n}\n\nint isValidAuxString(char *s, unsigned int length) {\n for (unsigned i = 0; i < length; i++) {\n if (!isValidAuxChar(s[i])) return 0;\n }\n return 1;\n}\n\nvoid clusterCommandMyId(client *c) {\n char *name = clusterNodeGetName(getMyClusterNode());\n if (name) {\n addReplyBulkCBuffer(c,name, CLUSTER_NAMELEN);\n } else {\n addReplyError(c, \"No ID yet\");\n }\n}\n\nchar* getMyClusterId(void) {\n return clusterNodeGetName(getMyClusterNode());\n}\n\nvoid clusterCommandMyShardId(client *c) {\n char *sid = clusterNodeGetShardId(getMyClusterNode());\n if (sid) {\n addReplyBulkCBuffer(c,sid, CLUSTER_NAMELEN);\n } else {\n addReplyError(c, \"No shard ID yet\");\n }\n}\n\n/* When a cluster command is called, we need to decide whether to return TLS info or\n * non-TLS info by the client's connection type. However if the command is called by\n * a Lua script or RM_call, there is no connection in the fake client, so we use\n * server.current_client here to get the real client if available. And if it is not\n * available (modules may call commands without a real client), we return the default\n * info, which is determined by server.tls_cluster. */\nstatic int shouldReturnTlsInfo(void) {\n if (server.current_client && server.current_client->conn) {\n return connIsTLS(server.current_client->conn);\n } else {\n return server.tls_cluster;\n }\n}\n\nunsigned int countKeysInSlot(unsigned int slot) {\n return kvstoreDictSize(server.db->keys, slot);\n}\n\n/* Add detailed information of a node to the output buffer of the given client. */\nvoid addNodeDetailsToShardReply(client *c, clusterNode *node) {\n\n int reply_count = 0;\n char *hostname;\n void *node_replylen = addReplyDeferredLen(c);\n\n addReplyBulkCString(c, \"id\");\n addReplyBulkCBuffer(c, clusterNodeGetName(node), CLUSTER_NAMELEN);\n reply_count++;\n\n if (clusterNodeTcpPort(node)) {\n addReplyBulkCString(c, \"port\");\n addReplyLongLong(c, clusterNodeTcpPort(node));\n reply_count++;\n }\n\n if (clusterNodeTlsPort(node)) {\n addReplyBulkCString(c, \"tls-port\");\n addReplyLongLong(c, clusterNodeTlsPort(node));\n reply_count++;\n }\n\n addReplyBulkCString(c, \"ip\");\n addReplyBulkCString(c, clusterNodeIp(node));\n reply_count++;\n\n addReplyBulkCString(c, \"endpoint\");\n addReplyBulkCString(c, clusterNodePreferredEndpoint(node));\n reply_count++;\n\n hostname = clusterNodeHostname(node);\n if (hostname != NULL && *hostname != '\\0') {\n addReplyBulkCString(c, \"hostname\");\n addReplyBulkCString(c, hostname);\n reply_count++;\n }\n\n long long node_offset;\n if (clusterNodeIsMyself(node)) {\n node_offset = clusterNodeIsSlave(node) ? replicationGetSlaveOffset() : server.master_repl_offset;\n } else {\n node_offset = clusterNodeReplOffset(node);\n }\n\n addReplyBulkCString(c, \"role\");\n addReplyBulkCString(c, clusterNodeIsSlave(node) ? \"replica\" : \"master\");\n reply_count++;\n\n addReplyBulkCString(c, \"replication-offset\");\n addReplyLongLong(c, node_offset);\n reply_count++;\n\n addReplyBulkCString(c, \"health\");\n const char *health_msg = NULL;\n if (clusterNodeIsFailing(node)) {\n health_msg = \"fail\";\n } else if (clusterNodeIsSlave(node) && node_offset == 0) {\n health_msg = \"loading\";\n } else {\n health_msg = \"online\";\n }\n addReplyBulkCString(c, health_msg);\n reply_count++;\n\n setDeferredMapLen(c, node_replylen, reply_count);\n}\n\nstatic clusterNode *clusterGetMasterFromShard(void *shard_handle) {\n clusterNode *n = NULL;\n void *node_it = clusterShardHandleGetNodeIterator(shard_handle);\n while((n = clusterShardNodeIteratorNext(node_it)) != NULL) {\n if (!clusterNodeIsFailing(n)) {\n break;\n }\n }\n clusterShardNodeIteratorFree(node_it);\n if (!n) return NULL;\n return clusterNodeGetMaster(n);\n}\n\n/* Add the shard reply of a single shard based off the given primary node. */\nvoid addShardReplyForClusterShards(client *c, void *shard_handle) {\n serverAssert(clusterGetShardNodeCount(shard_handle) > 0);\n addReplyMapLen(c, 2);\n addReplyBulkCString(c, \"slots\");\n\n /* Use slot_info_pairs from the primary only */\n clusterNode *master_node = clusterGetMasterFromShard(shard_handle);\n\n if (master_node && clusterNodeHasSlotInfo(master_node)) {\n serverAssert((clusterNodeSlotInfoCount(master_node) % 2) == 0);\n addReplyArrayLen(c, clusterNodeSlotInfoCount(master_node));\n for (int i = 0; i < clusterNodeSlotInfoCount(master_node); i++)\n addReplyLongLong(c, (unsigned long)clusterNodeSlotInfoEntry(master_node, i));\n } else {\n /* If no slot info pair is provided, the node owns no slots */\n addReplyArrayLen(c, 0);\n }\n\n addReplyBulkCString(c, \"nodes\");\n addReplyArrayLen(c, clusterGetShardNodeCount(shard_handle));\n void *node_it = clusterShardHandleGetNodeIterator(shard_handle);\n for (clusterNode *n = clusterShardNodeIteratorNext(node_it); n != NULL; n = clusterShardNodeIteratorNext(node_it)) {\n addNodeDetailsToShardReply(c, n);\n clusterFreeNodesSlotsInfo(n);\n }\n clusterShardNodeIteratorFree(node_it);\n}\n\n/* Add to the output buffer of the given client, an array of slot (start, end)\n * pair owned by the shard, also the primary and set of replica(s) along with\n * information about each node. */\nvoid clusterCommandShards(client *c) {\n addReplyArrayLen(c, clusterGetShardCount());\n /* This call will add slot_info_pairs to all nodes */\n clusterGenNodesSlotsInfo(0);\n dictIterator *shard_it = clusterGetShardIterator();\n for(void *shard_handle = clusterNextShardHandle(shard_it); shard_handle != NULL; shard_handle = clusterNextShardHandle(shard_it)) {\n addShardReplyForClusterShards(c, shard_handle);\n }\n clusterFreeShardIterator(shard_it);\n}\n\nvoid clusterCommandHelp(client *c) {\n const char *help[] = {\n \"COUNTKEYSINSLOT \",\n \" Return the number of keys in .\",\n \"GETKEYSINSLOT \",\n \" Return key names stored by current node in a slot.\",\n \"INFO\",\n \" Return information about the cluster.\",\n \"KEYSLOT \",\n \" Return the hash slot for .\",\n \"MYID\",\n \" Return the node id.\",\n \"MYSHARDID\",\n \" Return the node's shard id.\",\n \"NODES\",\n \" Return cluster configuration seen by node. Output format:\",\n \" ...\",\n \"REPLICAS \",\n \" Return replicas.\",\n \"SLOTS\",\n \" Return information about slots range mappings. Each range is made of:\",\n \" start, end, master and replicas IP addresses, ports and ids\",\n \"SLOT-STATS\",\n \" Return an array of slot usage statistics for slots assigned to the current node.\",\n \"SHARDS\",\n \" Return information about slot range mappings and the nodes associated with them.\",\n NULL\n };\n\n addExtendedReplyHelp(c, help, clusterCommandExtendedHelp());\n}\n\nvoid clusterCommand(client *c) {\n if (server.cluster_enabled == 0) {\n addReplyError(c,\"This instance has cluster support disabled\");\n return;\n }\n\n if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,\"help\")) {\n clusterCommandHelp(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"nodes\") && c->argc == 2) {\n /* CLUSTER NODES */\n /* Report TLS ports to TLS client, and report non-TLS port to non-TLS client. */\n sds nodes = clusterGenNodesDescription(c, 0, shouldReturnTlsInfo());\n addReplyVerbatim(c,nodes,sdslen(nodes),\"txt\");\n sdsfree(nodes);\n } else if (!strcasecmp(c->argv[1]->ptr,\"myid\") && c->argc == 2) {\n /* CLUSTER MYID */\n clusterCommandMyId(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"myshardid\") && c->argc == 2) {\n /* CLUSTER MYSHARDID */\n clusterCommandMyShardId(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"slots\") && c->argc == 2) {\n /* CLUSTER SLOTS */\n clusterCommandSlots(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"shards\") && c->argc == 2) {\n /* CLUSTER SHARDS */\n clusterCommandShards(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"info\") && c->argc == 2) {\n /* CLUSTER INFO */\n\n sds info = genClusterInfoString();\n\n /* Produce the reply protocol. */\n addReplyVerbatim(c,info,sdslen(info),\"txt\");\n sdsfree(info);\n } else if (!strcasecmp(c->argv[1]->ptr,\"keyslot\") && c->argc == 3) {\n /* CLUSTER KEYSLOT */\n sds key = c->argv[2]->ptr;\n\n addReplyLongLong(c,keyHashSlot(key,sdslen(key)));\n } else if (!strcasecmp(c->argv[1]->ptr,\"countkeysinslot\") && c->argc == 3) {\n /* CLUSTER COUNTKEYSINSLOT */\n long long slot;\n\n if (getLongLongFromObjectOrReply(c,c->argv[2],&slot,NULL) != C_OK)\n return;\n if (slot < 0 || slot >= CLUSTER_SLOTS) {\n addReplyError(c,\"Invalid slot\");\n return;\n }\n\n if (!clusterCanAccessKeysInSlot(slot)) {\n addReplyLongLong(c, 0);\n return;\n }\n addReplyLongLong(c,countKeysInSlot(slot));\n } else if (!strcasecmp(c->argv[1]->ptr,\"getkeysinslot\") && c->argc == 4) {\n /* CLUSTER GETKEYSINSLOT */\n long long maxkeys, slot;\n\n if (getLongLongFromObjectOrReply(c,c->argv[2],&slot,NULL) != C_OK)\n return;\n if (getLongLongFromObjectOrReply(c,c->argv[3],&maxkeys,NULL)\n != C_OK)\n return;\n if (slot < 0 || slot >= CLUSTER_SLOTS || maxkeys < 0) {\n addReplyError(c,\"Invalid slot or number of keys\");\n return;\n }\n\n if (!clusterCanAccessKeysInSlot(slot)) {\n addReplyArrayLen(c, 0);\n return;\n }\n\n unsigned int keys_in_slot = countKeysInSlot(slot);\n unsigned int numkeys = maxkeys > keys_in_slot ? keys_in_slot : maxkeys;\n addReplyArrayLen(c,numkeys);\n kvstoreDictIterator kvs_di;\n dictEntry *de = NULL;\n kvstoreInitDictIterator(&kvs_di, server.db->keys, slot);\n for (unsigned int i = 0; i < numkeys; i++) {\n de = kvstoreDictIteratorNext(&kvs_di);\n serverAssert(de != NULL);\n sds sdskey = kvobjGetKey(dictGetKV(de));\n addReplyBulkCBuffer(c, sdskey, sdslen(sdskey));\n }\n kvstoreResetDictIterator(&kvs_di);\n } else if ((!strcasecmp(c->argv[1]->ptr,\"slaves\") ||\n !strcasecmp(c->argv[1]->ptr,\"replicas\")) && c->argc == 3) {\n /* CLUSTER SLAVES */\n /* CLUSTER REPLICAS */\n clusterNode *n = clusterLookupNode(c->argv[2]->ptr, sdslen(c->argv[2]->ptr));\n int j;\n\n /* Lookup the specified node in our table. */\n if (!n) {\n addReplyErrorFormat(c,\"Unknown node %s\", (char*)c->argv[2]->ptr);\n return;\n }\n\n if (clusterNodeIsSlave(n)) {\n addReplyError(c,\"The specified node is not a master\");\n return;\n }\n\n /* Report TLS ports to TLS client, and report non-TLS port to non-TLS client. */\n addReplyArrayLen(c, clusterNodeNumSlaves(n));\n for (j = 0; j < clusterNodeNumSlaves(n); j++) {\n sds ni = clusterGenNodeDescription(c, clusterNodeGetSlave(n, j), shouldReturnTlsInfo());\n addReplyBulkCString(c,ni);\n sdsfree(ni);\n }\n } else if (!strcasecmp(c->argv[1]->ptr, \"migration\")) {\n clusterMigrationCommand(c);\n } else if (!strcasecmp(c->argv[1]->ptr,\"syncslots\") && c->argc >= 3) {\n clusterSyncSlotsCommand(c);\n } else if(!clusterCommandSpecial(c)) {\n addReplySubcommandSyntaxError(c);\n return;\n }\n}\n\n/* Extract slot number from keys in a keys_result structure and return to caller.\n * Returns:\n * - The slot number if all keys belong to the same slot\n * - INVALID_CLUSTER_SLOT if there are no keys or cluster is disabled\n * - CLUSTER_CROSSSLOT if keys belong to different slots (cross-slot error) */\nint extractSlotFromKeysResult(robj **argv, getKeysResult *keys_result) {\n if (keys_result->numkeys == 0 || !server.cluster_enabled)\n return INVALID_CLUSTER_SLOT;\n\n int first_slot = INVALID_CLUSTER_SLOT;\n for (int j = 0; j < keys_result->numkeys; j++) {\n robj *this_key = argv[keys_result->keys[j].pos];\n int this_slot = (int)keyHashSlot((char*)this_key->ptr, sdslen(this_key->ptr));\n\n if (first_slot == INVALID_CLUSTER_SLOT)\n first_slot = this_slot;\n else if (first_slot != this_slot) {\n return CLUSTER_CROSSSLOT;\n }\n }\n return first_slot;\n}\n\n/* Return the pointer to the cluster node that is able to serve the command.\n * For the function to succeed the command should only target either:\n *\n * 1) A single key (even multiple times like RPOPLPUSH mylist mylist).\n * 2) Multiple keys in the same hash slot, while the slot is stable (no\n * resharding in progress).\n *\n * On success the function returns the node that is able to serve the request.\n * If the node is not 'myself' a redirection must be performed. The kind of\n * redirection is specified setting the integer passed by reference\n * 'error_code', which will be set to CLUSTER_REDIR_ASK or\n * CLUSTER_REDIR_MOVED.\n *\n * When the node is 'myself' 'error_code' is set to CLUSTER_REDIR_NONE.\n *\n * If the command fails NULL is returned, and the reason of the failure is\n * provided via 'error_code', which will be set to:\n *\n * CLUSTER_REDIR_CROSS_SLOT if the request contains multiple keys that\n * don't belong to the same hash slot.\n *\n * CLUSTER_REDIR_UNSTABLE if the request contains multiple keys\n * belonging to the same slot, but the slot is not stable (in migration or\n * importing state, likely because a resharding is in progress).\n *\n * CLUSTER_REDIR_DOWN_UNBOUND if the request addresses a slot which is\n * not bound to any node. In this case the cluster global state should be\n * already \"down\" but it is fragile to rely on the update of the global state,\n * so we also handle it here.\n *\n * CLUSTER_REDIR_TRIMMING if the request addresses a slot that is being trimmed.\n *\n * CLUSTER_REDIR_DOWN_STATE and CLUSTER_REDIR_DOWN_RO_STATE if the cluster is\n * down but the user attempts to execute a command that addresses one or more keys. */\nclusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot,\n getKeysResult *keys_result, uint8_t read_error, uint64_t cmd_flags, int *error_code)\n{\n clusterNode *myself = getMyClusterNode();\n clusterNode *n = NULL;\n robj *firstkey = NULL;\n int multiple_keys = 0;\n multiState *ms, _ms;\n pendingCommand mc;\n pendingCommand *mcp = &mc;\n int i, slot = 0, migrating_slot = 0, importing_slot = 0, missing_keys = 0,\n existing_keys = 0;\n int pubsubshard_included = 0; /* Flag to indicate if a pubsub shard cmd is included. */\n\n /* Allow any key to be set if a module disabled cluster redirections. */\n if (server.cluster_module_flags & CLUSTER_MODULE_FLAG_NO_REDIRECTION)\n return myself;\n\n /* Set error code optimistically for the base case. */\n if (error_code) *error_code = CLUSTER_REDIR_NONE;\n\n /* Modules can turn off Redis Cluster redirection: this is useful\n * when writing a module that implements a completely different\n * distributed system. */\n\n /* We handle all the cases as if they were EXEC commands, so we have\n * a common code path for everything */\n if (cmd->proc == execCommand) {\n /* If CLIENT_MULTI flag is not set EXEC is just going to return an\n * error. */\n if (!(c->flags & CLIENT_MULTI)) return myself;\n ms = &c->mstate;\n } else {\n /* In order to have a single codepath create a fake Multi State\n * structure if the client is not in MULTI/EXEC state, this way\n * we have a single codepath below. */\n ms = &_ms;\n _ms.commands = &mcp;\n _ms.count = 1;\n\n /* Properly initialize the fake pendingCommand */\n initPendingCommand(&mc);\n mc.argv = argv;\n mc.argc = argc;\n mc.cmd = cmd;\n mc.slot = hashslot ? *hashslot : INVALID_CLUSTER_SLOT;\n mc.read_error = read_error;\n if (keys_result) {\n mc.keys_result = *keys_result;\n mc.flags |= PENDING_CMD_KEYS_RESULT_VALID;\n }\n }\n\n /* Check that all the keys are in the same hash slot, and obtain this\n * slot and the node associated. */\n for (i = 0; i < ms->count; i++) {\n struct redisCommand *mcmd;\n robj **margv;\n int margc, j;\n keyReference *keyindex;\n\n pendingCommand *pcmd = ms->commands[i];\n\n mcmd = pcmd->cmd;\n margc = pcmd->argc;\n margv = pcmd->argv;\n\n /* Only valid for sharded pubsub as regular pubsub can operate on any node and bypasses this layer. */\n if (!pubsubshard_included &&\n doesCommandHaveChannelsWithFlags(mcmd, CMD_CHANNEL_PUBLISH | CMD_CHANNEL_SUBSCRIBE))\n {\n pubsubshard_included = 1;\n }\n\n /* If we have a cached keys result from preprocessCommand(), use it.\n * Otherwise, extract keys result. */\n int use_cache_keys_result = pcmd->flags & PENDING_CMD_KEYS_RESULT_VALID;\n getKeysResult result = GETKEYS_RESULT_INIT;\n if (use_cache_keys_result)\n result = pcmd->keys_result;\n else\n getKeysFromCommand(mcmd,margv,margc,&result);\n keyindex = result.keys;\n\n for (j = 0; j < result.numkeys; j++) {\n /* The command has keys and was checked for cross-slot between its keys in preprocessCommand() */\n if (pcmd->read_error == CLIENT_READ_CROSS_SLOT) {\n /* Error: multiple keys from different slots. */\n if (!use_cache_keys_result) getKeysFreeResult(&result);\n if (error_code)\n *error_code = CLUSTER_REDIR_CROSS_SLOT;\n return NULL;\n }\n\n robj *thiskey = margv[keyindex[j].pos];\n int thisslot = pcmd->slot;\n if (thisslot == INVALID_CLUSTER_SLOT)\n thisslot = keyHashSlot((char*)thiskey->ptr, sdslen(thiskey->ptr));\n\n if (firstkey == NULL) {\n /* This is the first key we see. Check what is the slot\n * and node. */\n firstkey = thiskey;\n slot = thisslot;\n n = getNodeBySlot(slot);\n\n /* Error: If a slot is not served, we are in \"cluster down\"\n * state. However the state is yet to be updated, so this was\n * not trapped earlier in processCommand(). Report the same\n * error to the client. */\n if (n == NULL) {\n if (!use_cache_keys_result) getKeysFreeResult(&result);\n if (error_code)\n *error_code = CLUSTER_REDIR_DOWN_UNBOUND;\n return NULL;\n }\n\n /* If we are migrating or importing this slot, we need to check\n * if we have all the keys in the request (the only way we\n * can safely serve the request, otherwise we return a TRYAGAIN\n * error). To do so we set the importing/migrating state and\n * increment a counter for every missing key. */\n if (n == myself &&\n getMigratingSlotDest(slot) != NULL)\n {\n migrating_slot = 1;\n } else if (getImportingSlotSource(slot) != NULL) {\n importing_slot = 1;\n }\n } else {\n /* If it is not the first key/channel, make sure it is exactly\n * the same key/channel as the first we saw. */\n if (slot != thisslot) {\n /* Error: multiple keys from different slots. */\n if (!use_cache_keys_result) getKeysFreeResult(&result);\n if (error_code)\n *error_code = CLUSTER_REDIR_CROSS_SLOT;\n return NULL;\n }\n if (importing_slot && !multiple_keys && !equalStringObjects(firstkey,thiskey)) {\n /* Flag this request as one with multiple different\n * keys/channels when the slot is in importing state. */\n multiple_keys = 1;\n }\n }\n\n /* Migrating / Importing slot? Count keys we don't have.\n * If it is pubsubshard command, it isn't required to check\n * the channel being present or not in the node during the\n * slot migration, the channel will be served from the source\n * node until the migration completes with CLUSTER SETSLOT \n * NODE . */\n int flags = LOOKUP_NOTOUCH | LOOKUP_NOSTATS | LOOKUP_NONOTIFY | LOOKUP_NOEXPIRE;\n if ((migrating_slot || importing_slot) && !pubsubshard_included)\n {\n if (lookupKeyReadWithFlags(&server.db[0], thiskey, flags) == NULL) missing_keys++;\n else existing_keys++;\n }\n }\n if (!use_cache_keys_result) getKeysFreeResult(&result);\n }\n\n /* No key at all in command? then we can serve the request\n * without redirections or errors in all the cases. */\n if (n == NULL) return myself;\n\n /* Cluster is globally down but we got keys? We only serve the request\n * if it is a read command and when allow_reads_when_down is enabled. */\n if (!isClusterHealthy()) {\n if (pubsubshard_included) {\n if (!server.cluster_allow_pubsubshard_when_down) {\n if (error_code) *error_code = CLUSTER_REDIR_DOWN_STATE;\n return NULL;\n }\n } else if (!server.cluster_allow_reads_when_down) {\n /* The cluster is configured to block commands when the\n * cluster is down. */\n if (error_code) *error_code = CLUSTER_REDIR_DOWN_STATE;\n return NULL;\n } else if (cmd_flags & CMD_WRITE) {\n /* The cluster is configured to allow read only commands */\n if (error_code) *error_code = CLUSTER_REDIR_DOWN_RO_STATE;\n return NULL;\n } else {\n /* Fall through and allow the command to be executed:\n * this happens when server.cluster_allow_reads_when_down is\n * true and the command is not a write command */\n }\n }\n\n /* Return the hashslot by reference. */\n if (hashslot) *hashslot = slot;\n\n /* MIGRATE always works in the context of the local node if the slot\n * is open (migrating or importing state). We need to be able to freely\n * move keys among instances in this case. */\n if ((migrating_slot || importing_slot) && cmd->proc == migrateCommand)\n return myself;\n\n /* If we don't have all the keys and we are migrating the slot, send\n * an ASK redirection or TRYAGAIN. */\n if (migrating_slot && missing_keys) {\n /* If we have keys but we don't have all keys, we return TRYAGAIN */\n if (existing_keys) {\n if (error_code) *error_code = CLUSTER_REDIR_UNSTABLE;\n return NULL;\n } else {\n if (error_code) *error_code = CLUSTER_REDIR_ASK;\n return getMigratingSlotDest(slot);\n }\n }\n\n /* If we are receiving the slot, and the client correctly flagged the\n * request as \"ASKING\", we can serve the request. However if the request\n * involves multiple keys and we don't have them all, the only option is\n * to send a TRYAGAIN error. */\n if (importing_slot &&\n (c->flags & CLIENT_ASKING || cmd_flags & CMD_ASKING))\n {\n if (multiple_keys && missing_keys) {\n if (error_code) *error_code = CLUSTER_REDIR_UNSTABLE;\n return NULL;\n } else {\n return myself;\n }\n }\n\n /* Handle the read-only client case reading from a slave: if this\n * node is a slave and the request is about a hash slot our master\n * is serving, we can reply without redirection. */\n int is_write_command = (cmd_flags & CMD_WRITE) ||\n (c->cmd->proc == execCommand && (c->mstate.cmd_flags & CMD_WRITE));\n if (((c->flags & CLIENT_READONLY) || pubsubshard_included) &&\n !is_write_command &&\n clusterNodeIsSlave(myself) &&\n clusterNodeGetSlaveof(myself) == n)\n {\n return myself;\n }\n\n /* If this node is responsible for the slot and is currently trimming it,\n * SFLUSH may have triggered active trimming and it could still be in progress.\n * Here we reject any write commands as no writes should be accepted for\n * trimming slots while active trimming is in progress. */\n if (n == myself && is_write_command && isSlotInTrimJob(slot)) {\n if (error_code) *error_code = CLUSTER_REDIR_TRIMMING;\n return NULL;\n }\n\n /* Base case: just return the right node. However, if this node is not\n * myself, set error_code to MOVED since we need to issue a redirection. */\n if (n != myself && error_code) *error_code = CLUSTER_REDIR_MOVED;\n return n;\n}\n\n/* Send the client the right redirection code, according to error_code\n * that should be set to one of CLUSTER_REDIR_* macros.\n *\n * If CLUSTER_REDIR_ASK or CLUSTER_REDIR_MOVED error codes\n * are used, then the node 'n' should not be NULL, but should be the\n * node we want to mention in the redirection. Moreover hashslot should\n * be set to the hash slot that caused the redirection. */\nvoid clusterRedirectClient(client *c, clusterNode *n, int hashslot, int error_code) {\n if (error_code == CLUSTER_REDIR_CROSS_SLOT) {\n addReplyError(c,\"-CROSSSLOT Keys in request don't hash to the same slot\");\n } else if (error_code == CLUSTER_REDIR_UNSTABLE) {\n /* The request spawns multiple keys in the same slot,\n * but the slot is not \"stable\" currently as there is\n * a migration or import in progress. */\n addReplyError(c,\"-TRYAGAIN Multiple keys request during rehashing of slot\");\n } else if (error_code == CLUSTER_REDIR_DOWN_STATE) {\n addReplyError(c,\"-CLUSTERDOWN The cluster is down\");\n } else if (error_code == CLUSTER_REDIR_DOWN_RO_STATE) {\n addReplyError(c,\"-CLUSTERDOWN The cluster is down and only accepts read commands\");\n } else if (error_code == CLUSTER_REDIR_DOWN_UNBOUND) {\n addReplyError(c,\"-CLUSTERDOWN Hash slot not served\");\n } else if (error_code == CLUSTER_REDIR_MOVED ||\n error_code == CLUSTER_REDIR_ASK)\n {\n /* Report TLS ports to TLS client, and report non-TLS port to non-TLS client. */\n int port = clusterNodeClientPort(n, shouldReturnTlsInfo());\n addReplyErrorSds(c,sdscatprintf(sdsempty(),\n \"-%s %d %s:%d\",\n (error_code == CLUSTER_REDIR_ASK) ? \"ASK\" : \"MOVED\",\n hashslot, clusterNodePreferredEndpoint(n), port));\n } else if (error_code == CLUSTER_REDIR_TRIMMING) {\n addReplyError(c,\"-TRYAGAIN Slot is being trimmed\");\n } else {\n serverPanic(\"getNodeByQuery() unknown error.\");\n }\n}\n\n/* This function is called by the function processing clients incrementally\n * to detect timeouts, in order to handle the following case:\n *\n * 1) A client blocks with BLPOP or similar blocking operation.\n * 2) The master migrates the hash slot elsewhere or turns into a slave.\n * 3) The client may remain blocked forever (or up to the max timeout time)\n * waiting for a key change that will never happen.\n *\n * If the client is found to be blocked into a hash slot this node no\n * longer handles, the client is sent a redirection error, and the function\n * returns 1. Otherwise 0 is returned and no operation is performed. */\nint clusterRedirectBlockedClientIfNeeded(client *c) {\n clusterNode *myself = getMyClusterNode();\n if (c->flags & CLIENT_BLOCKED &&\n (c->bstate.btype == BLOCKED_LIST ||\n c->bstate.btype == BLOCKED_ZSET ||\n c->bstate.btype == BLOCKED_STREAM ||\n c->bstate.btype == BLOCKED_MODULE))\n {\n dictEntry *de;\n dictIterator di;\n\n /* If the cluster is down, unblock the client with the right error.\n * If the cluster is configured to allow reads on cluster down, we\n * still want to emit this error since a write will be required\n * to unblock them which may never come. */\n if (!isClusterHealthy()) {\n clusterRedirectClient(c,NULL,0,CLUSTER_REDIR_DOWN_STATE);\n return 1;\n }\n\n /* If the client is blocked on module, but not on a specific key,\n * don't unblock it (except for the CLUSTER_FAIL case above). */\n if (c->bstate.btype == BLOCKED_MODULE && !moduleClientIsBlockedOnKeys(c))\n return 0;\n\n /* All keys must belong to the same slot, so check first key only. */\n dictInitIterator(&di, c->bstate.keys);\n if ((de = dictNext(&di)) != NULL) {\n robj *key = dictGetKey(de);\n int slot = keyHashSlot((char*)key->ptr, sdslen(key->ptr));\n clusterNode *node = getNodeBySlot(slot);\n\n /* if the client is read-only and attempting to access key that our\n * replica can handle, allow it. */\n if ((c->flags & CLIENT_READONLY) &&\n !(c->lastcmd->flags & CMD_WRITE) &&\n clusterNodeIsSlave(myself) && clusterNodeGetSlaveof(myself) == node)\n {\n node = myself;\n }\n\n /* We send an error and unblock the client if:\n * 1) The slot is unassigned, emitting a cluster down error.\n * 2) The slot is not handled by this node, nor being imported. */\n if (node != myself && getImportingSlotSource(slot) == NULL)\n {\n if (node == NULL) {\n clusterRedirectClient(c,NULL,0,\n CLUSTER_REDIR_DOWN_UNBOUND);\n } else {\n clusterRedirectClient(c,node,slot,\n CLUSTER_REDIR_MOVED);\n }\n dictResetIterator(&di);\n return 1;\n }\n }\n dictResetIterator(&di);\n }\n return 0;\n}\n\n/* Returns an indication if the replica node is fully available\n * and should be listed in CLUSTER SLOTS response.\n * Returns 1 for available nodes, 0 for nodes that have\n * not finished their initial sync, in failed state, or are\n * otherwise considered not available to serve read commands. */\nstatic int isReplicaAvailable(clusterNode *node) {\n if (clusterNodeIsFailing(node)) {\n return 0;\n }\n long long repl_offset = clusterNodeReplOffset(node);\n if (clusterNodeIsMyself(node)) {\n /* Nodes do not update their own information\n * in the cluster node list. */\n repl_offset = replicationGetSlaveOffset();\n }\n return (repl_offset != 0);\n}\n\nvoid addNodeToNodeReply(client *c, clusterNode *node) {\n char* hostname = clusterNodeHostname(node);\n addReplyArrayLen(c, 4);\n if (server.cluster_preferred_endpoint_type == CLUSTER_ENDPOINT_TYPE_IP) {\n addReplyBulkCString(c, clusterNodeIp(node));\n } else if (server.cluster_preferred_endpoint_type == CLUSTER_ENDPOINT_TYPE_HOSTNAME) {\n if (hostname != NULL && hostname[0] != '\\0') {\n addReplyBulkCString(c, hostname);\n } else {\n addReplyBulkCString(c, \"?\");\n }\n } else if (server.cluster_preferred_endpoint_type == CLUSTER_ENDPOINT_TYPE_UNKNOWN_ENDPOINT) {\n addReplyNull(c);\n } else {\n serverPanic(\"Unrecognized preferred endpoint type\");\n }\n\n /* Report TLS ports to TLS client, and report non-TLS port to non-TLS client. */\n addReplyLongLong(c, clusterNodeClientPort(node, shouldReturnTlsInfo()));\n addReplyBulkCBuffer(c, clusterNodeGetName(node), CLUSTER_NAMELEN);\n\n /* Add the additional endpoint information, this is all the known networking information\n * that is not the preferred endpoint. Note the logic is evaluated twice so we can\n * correctly report the number of additional network arguments without using a deferred\n * map, an assertion is made at the end to check we set the right length. */\n int length = 0;\n if (server.cluster_preferred_endpoint_type != CLUSTER_ENDPOINT_TYPE_IP) {\n length++;\n }\n if (server.cluster_preferred_endpoint_type != CLUSTER_ENDPOINT_TYPE_HOSTNAME\n && hostname != NULL && hostname[0] != '\\0')\n {\n length++;\n }\n addReplyMapLen(c, length);\n\n if (server.cluster_preferred_endpoint_type != CLUSTER_ENDPOINT_TYPE_IP) {\n addReplyBulkCString(c, \"ip\");\n addReplyBulkCString(c, clusterNodeIp(node));\n length--;\n }\n if (server.cluster_preferred_endpoint_type != CLUSTER_ENDPOINT_TYPE_HOSTNAME\n && hostname != NULL && hostname[0] != '\\0')\n {\n addReplyBulkCString(c, \"hostname\");\n addReplyBulkCString(c, hostname);\n length--;\n }\n serverAssert(length == 0);\n}\n\nvoid addNodeReplyForClusterSlot(client *c, clusterNode *node, int start_slot, int end_slot) {\n int i, nested_elements = 3; /* slots (2) + master addr (1) */\n for (i = 0; i < clusterNodeNumSlaves(node); i++) {\n if (!isReplicaAvailable(clusterNodeGetSlave(node, i))) continue;\n nested_elements++;\n }\n addReplyArrayLen(c, nested_elements);\n addReplyLongLong(c, start_slot);\n addReplyLongLong(c, end_slot);\n addNodeToNodeReply(c, node);\n\n /* Remaining nodes in reply are replicas for slot range */\n for (i = 0; i < clusterNodeNumSlaves(node); i++) {\n /* This loop is copy/pasted from clusterGenNodeDescription()\n * with modifications for per-slot node aggregation. */\n if (!isReplicaAvailable(clusterNodeGetSlave(node, i))) continue;\n addNodeToNodeReply(c, clusterNodeGetSlave(node, i));\n nested_elements--;\n }\n serverAssert(nested_elements == 3); /* Original 3 elements */\n}\n\nvoid clusterCommandSlots(client * c) {\n /* Format: 1) 1) start slot\n * 2) end slot\n * 3) 1) master IP\n * 2) master port\n * 3) node ID\n * 4) 1) replica IP\n * 2) replica port\n * 3) node ID\n * ... continued until done\n */\n clusterNode *n = NULL;\n int num_masters = 0, start = -1;\n void *slot_replylen = addReplyDeferredLen(c);\n\n for (int i = 0; i <= CLUSTER_SLOTS; i++) {\n /* Find start node and slot id. */\n if (n == NULL) {\n if (i == CLUSTER_SLOTS) break;\n n = getNodeBySlot(i);\n start = i;\n continue;\n }\n\n /* Add cluster slots info when occur different node with start\n * or end of slot. */\n if (i == CLUSTER_SLOTS || n != getNodeBySlot(i)) {\n addNodeReplyForClusterSlot(c, n, start, i-1);\n num_masters++;\n if (i == CLUSTER_SLOTS) break;\n n = getNodeBySlot(i);\n start = i;\n }\n }\n setDeferredArrayLen(c, slot_replylen, num_masters);\n}\n\n/* -----------------------------------------------------------------------------\n * Cluster functions related to serving / redirecting clients\n * -------------------------------------------------------------------------- */\n\n/* The ASKING command is required after a -ASK redirection.\n * The client should issue ASKING before to actually send the command to\n * the target instance. See the Redis Cluster specification for more\n * information. */\nvoid askingCommand(client *c) {\n if (server.cluster_enabled == 0) {\n addReplyError(c,\"This instance has cluster support disabled\");\n return;\n }\n c->flags |= CLIENT_ASKING;\n addReply(c,shared.ok);\n}\n\n/* The READONLY command is used by clients to enter the read-only mode.\n * In this mode slaves will not redirect clients as long as clients access\n * with read-only commands to keys that are served by the slave's master. */\nvoid readonlyCommand(client *c) {\n if (server.cluster_enabled == 0) {\n addReplyError(c,\"This instance has cluster support disabled\");\n return;\n }\n c->flags |= CLIENT_READONLY;\n addReply(c,shared.ok);\n}\n\n/* Remove all the keys in the specified hash slot.\n * The number of removed items is returned. */\nunsigned int clusterDelKeysInSlot(unsigned int hashslot, int by_command) {\n unsigned int j = 0;\n\n if (!kvstoreDictSize(server.db->keys, (int) hashslot))\n return 0;\n\n kvstoreDictIterator kvs_di;\n dictEntry *de = NULL;\n kvstoreInitDictSafeIterator(&kvs_di, server.db->keys, (int) hashslot);\n while((de = kvstoreDictIteratorNext(&kvs_di)) != NULL) {\n enterExecutionUnit(1, 0);\n sds sdskey = kvobjGetKey(dictGetKV(de));\n robj *key = createStringObject(sdskey, sdslen(sdskey));\n dbDelete(&server.db[0], key);\n\n keyModified(NULL, &server.db[0], key, NULL, 1);\n if (by_command) {\n /* Keys are deleted by a command (trimslots), we need to notify the\n * keyspace event. Though, we don't need to propagate the DEL\n * command, as the command (trimslots) will be propagated. */\n notifyKeyspaceEvent(NOTIFY_GENERIC, \"del\", key, server.db[0].id);\n } else {\n /* Propagate the DEL command */\n propagateDeletion(&server.db[0], key, server.lazyfree_lazy_server_del);\n /* The keys are not actually logically deleted from the database,\n * just moved to another node. The modules needs to know that these\n * keys are no longer available locally, so just send the keyspace\n * notification to the modules, but not to clients. */\n moduleNotifyKeyspaceEvent(NOTIFY_GENERIC, \"del\", key, server.db[0].id, NULL, 0);\n }\n exitExecutionUnit();\n postExecutionUnitOperations();\n decrRefCount(key);\n j++;\n server.dirty++;\n }\n kvstoreResetDictIterator(&kvs_di);\n return j;\n}\n\n/* Delete the keys in the slot ranges. Returns the number of deleted items */\nunsigned int clusterDelKeysInSlotRangeArray(slotRangeArray *slots, int by_command) {\n unsigned int j = 0;\n for (int i = 0; i < slots->num_ranges; i++) {\n for (int slot = slots->ranges[i].start; slot <= slots->ranges[i].end; slot++) {\n j += clusterDelKeysInSlot(slot, by_command);\n }\n }\n return j;\n}\n\nint clusterIsMySlot(int slot) {\n return getMyClusterNode() == getNodeBySlot(slot);\n}\n\nvoid replySlotsFlush(client *c, slotRangeArray *slots) {\n addReplyArrayLen(c, slots->num_ranges);\n for (int i = 0 ; i < slots->num_ranges ; i++) {\n addReplyArrayLen(c, 2);\n addReplyLongLong(c, slots->ranges[i].start);\n addReplyLongLong(c, slots->ranges[i].end);\n }\n}\n\n/* Normalizes (sorts and merges adjacent ranges), checks that slot ranges are\n * well-formed and non-overlapping. */\nint slotRangeArrayNormalizeAndValidate(slotRangeArray *slots, sds *err) {\n unsigned char used_slots[CLUSTER_SLOTS] = {0};\n\n if (slots->num_ranges <= 0 || slots->num_ranges >= CLUSTER_SLOTS) {\n *err = sdscatprintf(sdsempty(), \"invalid number of slot ranges: %d\", slots->num_ranges);\n return C_ERR;\n }\n\n /* Sort and merge adjacent slot ranges. */\n slotRangeArraySortAndMerge(slots);\n\n for (int i = 0; i < slots->num_ranges; i++) {\n if (slots->ranges[i].start >= CLUSTER_SLOTS ||\n slots->ranges[i].end >= CLUSTER_SLOTS)\n {\n *err = sdscatprintf(sdsempty(), \"slot range is out of range: %d-%d\",\n slots->ranges[i].start, slots->ranges[i].end);\n return C_ERR;\n }\n\n if (slots->ranges[i].start > slots->ranges[i].end) {\n *err = sdscatprintf(sdsempty(), \"start slot number %d is greater than end slot number %d\",\n slots->ranges[i].start, slots->ranges[i].end);\n return C_ERR;\n }\n\n for (int j = slots->ranges[i].start; j <= slots->ranges[i].end; j++) {\n if (used_slots[j]) {\n *err = sdscatprintf(sdsempty(), \"Slot %d specified multiple times\", j);\n return C_ERR;\n }\n used_slots[j]++;\n }\n }\n return C_OK;\n}\n\n/* Create a slot range array with the specified number of ranges. */\nslotRangeArray *slotRangeArrayCreate(int num_ranges) {\n slotRangeArray *slots = zcalloc(sizeof(slotRangeArray) + num_ranges * sizeof(slotRange));\n slots->num_ranges = num_ranges;\n return slots;\n}\n\n/* Duplicate the slot range array. */\nslotRangeArray *slotRangeArrayDup(slotRangeArray *slots) {\n slotRangeArray *dup = slotRangeArrayCreate(slots->num_ranges);\n memcpy(dup->ranges, slots->ranges, sizeof(slotRange) * slots->num_ranges);\n return dup;\n}\n\n/* Set the slot range at the specified index. */\nvoid slotRangeArraySet(slotRangeArray *slots, int idx, int start, int end) {\n slots->ranges[idx].start = start;\n slots->ranges[idx].end = end;\n}\n\n/* Create a slot range string in the format of: \"1000-2000 3000-4000 ...\" */\nsds slotRangeArrayToString(slotRangeArray *slots) {\n sds s = sdsempty();\n if (slots == NULL || slots->num_ranges == 0) return s;\n\n for (int i = 0; i < slots->num_ranges; i++) {\n slotRange *sr = &slots->ranges[i];\n s = sdscatprintf(s, \"%d-%d \", sr->start, sr->end);\n }\n sdssetlen(s, sdslen(s) - 1);\n s[sdslen(s)] = '\\0';\n\n return s;\n}\n\n/* Parse a slot range string in the format \"1000-2000 3000-4000 ...\" into a slotRangeArray.\n * Returns a new slotRangeArray on success, NULL on failure. */\nslotRangeArray *slotRangeArrayFromString(sds data) {\n int num_ranges;\n long long start, end;\n slotRangeArray *slots = NULL;\n if (!data || sdslen(data) == 0) return NULL;\n\n sds *parts = sdssplitlen(data, sdslen(data), \" \", 1, &num_ranges);\n if (num_ranges <= 0) goto err;\n\n slots = slotRangeArrayCreate(num_ranges);\n\n /* Parse each slot range */\n for (int i = 0; i < num_ranges; i++) {\n char *dash = strchr(parts[i], '-');\n if (!dash) goto err;\n\n if (string2ll(parts[i], dash - parts[i], &start) == 0 ||\n string2ll(dash + 1, sdslen(parts[i]) - (dash - parts[i]) - 1, &end) == 0)\n goto err;\n slotRangeArraySet(slots, i, start, end);\n }\n\n /* Validate all ranges */\n sds err_msg = NULL;\n if (slotRangeArrayNormalizeAndValidate(slots, &err_msg) != C_OK) {\n if (err_msg) sdsfree(err_msg);\n goto err;\n }\n sdsfreesplitres(parts, num_ranges);\n return slots;\n\nerr:\n if (slots) slotRangeArrayFree(slots);\n sdsfreesplitres(parts, num_ranges);\n return NULL;\n}\n\nstatic int compareSlotRange(const void *a, const void *b) {\n const slotRange *sa = a;\n const slotRange *sb = b;\n if (sa->start < sb->start) return -1;\n if (sa->start > sb->start) return 1;\n return 0;\n}\n\n/* Sort slot ranges by start slot and merge adjacent ranges.\n * Adjacent means: prev.end + 1 == next.start.\n * e.g. 1000-2000 2001-3000 0-100 => 0-100 1000-3000\n *\n * Note: Overlapping ranges are not merged.*/\nvoid slotRangeArraySortAndMerge(slotRangeArray *slots) {\n if (!slots || slots->num_ranges <= 1) return;\n\n qsort(slots->ranges, slots->num_ranges, sizeof(slotRange), compareSlotRange);\n\n int idx = 0;\n for (int i = 1; i < slots->num_ranges; i++) {\n if (slots->ranges[idx].end + 1 == slots->ranges[i].start)\n slots->ranges[idx].end = slots->ranges[i].end;\n else\n slots->ranges[++idx] = slots->ranges[i];\n }\n slots->num_ranges = idx + 1;\n}\n\n/* Compare two slot range arrays, return 1 if equal, 0 otherwise */\nint slotRangeArrayIsEqual(slotRangeArray *slots1, slotRangeArray *slots2) {\n slotRangeArraySortAndMerge(slots1);\n slotRangeArraySortAndMerge(slots2);\n\n if (slots1->num_ranges != slots2->num_ranges) return 0;\n\n for (int i = 0; i < slots1->num_ranges; i++) {\n if (slots1->ranges[i].start != slots2->ranges[i].start ||\n slots1->ranges[i].end != slots2->ranges[i].end) {\n return 0;\n }\n }\n return 1;\n}\n\n/* Add a slot to the slot range array.\n * Usage:\n * slotRangeArray *slots = NULL\n * slots = slotRangeArrayAppend(slots, 1000);\n * slots = slotRangeArrayAppend(slots, 1001);\n * slots = slotRangeArrayAppend(slots, 1003);\n * slots = slotRangeArrayAppend(slots, 1004);\n * slots = slotRangeArrayAppend(slots, 1005);\n *\n * Result: 1000-1001, 1003-1005\n * Note: `slot` must be greater than the previous slot.\n * */\nslotRangeArray *slotRangeArrayAppend(slotRangeArray *slots, int slot) {\n if (slots == NULL) {\n slots = slotRangeArrayCreate(4);\n slots->ranges[0].start = slot;\n slots->ranges[0].end = slot;\n slots->num_ranges = 1;\n return slots;\n }\n\n serverAssert(slots->num_ranges >= 0 && slots->num_ranges <= CLUSTER_SLOTS);\n serverAssert(slot > slots->ranges[slots->num_ranges - 1].end);\n\n /* Check if we can extend the last range */\n slotRange *last = &slots->ranges[slots->num_ranges - 1];\n if (slot == last->end + 1) {\n last->end = slot;\n return slots;\n }\n\n /* Calculate current capacity and reallocate if needed */\n int cap = (int) ((zmalloc_size(slots) - sizeof(slotRangeArray)) / sizeof(slotRange));\n if (slots->num_ranges >= cap)\n slots = zrealloc(slots, sizeof(slotRangeArray) + sizeof(slotRange) * cap * 2);\n\n /* Add new single-slot range */\n slots->ranges[slots->num_ranges].start = slot;\n slots->ranges[slots->num_ranges].end = slot;\n slots->num_ranges++;\n\n return slots;\n}\n\n/* Returns 1 if the slot range array contains the given slot, 0 otherwise. */\nint slotRangeArrayContains(slotRangeArray *slots, unsigned int slot) {\n for (int i = 0; i < slots->num_ranges; i++)\n if (slots->ranges[i].start <= slot && slots->ranges[i].end >= slot)\n return 1;\n return 0;\n}\n\n/* Free the slot range array. */\nvoid slotRangeArrayFree(slotRangeArray *slots) {\n zfree(slots);\n}\n\n/* Generic version of slotRangeArrayFree(). */\nvoid slotRangeArrayFreeGeneric(void *slots) {\n slotRangeArrayFree(slots);\n}\n\n/* Returns the number of keys in the given slot ranges. */\nunsigned long long getKeyCountInSlotRangeArray(slotRangeArray *slots) {\n if (!slots) return 0;\n\n unsigned long long key_count = 0;\n for (int i = 0; i < slots->num_ranges; i++) {\n for (int j = slots->ranges[i].start; j <= slots->ranges[i].end; j++) {\n key_count += countKeysInSlot(j);\n }\n }\n return key_count;\n}\n\n/* Slot range array iterator */\nslotRangeArrayIter *slotRangeArrayGetIterator(slotRangeArray *slots) {\n slotRangeArrayIter *it = zmalloc(sizeof(*it));\n it->slots = slots;\n it->range_index = 0;\n it->cur_slot = slots->num_ranges > 0 ? slots->ranges[0].start : -1;\n return it;\n}\n\n/* Returns the next slot in the array, or -1 if there are no more slots. */\nint slotRangeArrayNext(slotRangeArrayIter *it) {\n if (it->range_index >= it->slots->num_ranges) return -1;\n\n if (it->cur_slot < it->slots->ranges[it->range_index].end) {\n it->cur_slot++;\n } else {\n it->range_index++;\n if (it->range_index < it->slots->num_ranges)\n it->cur_slot = it->slots->ranges[it->range_index].start;\n else\n it->cur_slot = -1; /* finished */\n }\n return it->cur_slot;\n}\n\nint slotRangeArrayGetCurrentSlot(slotRangeArrayIter *it) {\n return it->cur_slot;\n}\n\nvoid slotRangeArrayIteratorFree(slotRangeArrayIter *it) {\n zfree(it);\n}\n\n/* Parse slot range pairs from argv starting at `pos`.\n * `argc` is the argument count, `pos` is the first slot argument index.\n * Returns a slotRangeArray or NULL on error. */\nslotRangeArray *parseSlotRangesOrReply(client *c, int argc, int pos) {\n int start, end, count;\n slotRangeArray *slots;\n\n /* Ensure there is at least one (start,end) slot range pairs. */\n if (argc < 0 || pos < 0 || pos >= argc || (argc - pos) < 2 || ((argc - pos) % 2) != 0) {\n addReplyErrorArity(c);\n return NULL;\n }\n\n count = (argc - pos) / 2;\n slots = slotRangeArrayCreate(count);\n slots->num_ranges = 0;\n\n for (int j = pos; j < argc; j += 2) {\n if ((start = getSlotOrReply(c, c->argv[j])) == -1 ||\n (end = getSlotOrReply(c, c->argv[j + 1])) == -1)\n {\n slotRangeArrayFree(slots);\n return NULL;\n }\n slotRangeArraySet(slots, slots->num_ranges, start, end);\n slots->num_ranges++;\n }\n\n sds err = NULL;\n if (slotRangeArrayNormalizeAndValidate(slots, &err) != C_OK) {\n addReplyErrorSds(c, err);\n slotRangeArrayFree(slots);\n return NULL;\n }\n return slots;\n}\n\n/* Return 1 if the keys in the slot can be accessed, 0 otherwise. */\nint clusterCanAccessKeysInSlot(int slot) {\n /* If not in cluster mode, all keys are accessible */\n if (server.cluster_enabled == 0) return 1;\n\n /* If the slot is being imported under old slot migration approach, we should\n * allow to list keys from the slot as previously. */\n if (getImportingSlotSource(slot)) return 1;\n\n /* If using atomic slot migration, check if the slot belongs to the current\n * node or its master, return 1 if so. */\n clusterNode *myself = getMyClusterNode();\n if (clusterNodeIsSlave(myself)) {\n clusterNode *master = clusterNodeGetMaster(myself);\n if (master && clusterNodeCoversSlot(master, slot))\n return 1;\n } else {\n if (clusterNodeCoversSlot(myself, slot))\n return 1;\n }\n return 0;\n}\n\n/* Return the slot ranges that belong to the current node or its master. */\nslotRangeArray *clusterGetLocalSlotRanges(void) {\n slotRangeArray *slots = NULL;\n\n if (!server.cluster_enabled) {\n slots = slotRangeArrayCreate(1);\n slotRangeArraySet(slots, 0, 0, CLUSTER_SLOTS - 1);\n return slots;\n }\n\n clusterNode *master = clusterNodeGetMaster(getMyClusterNode());\n if (master) {\n for (int i = 0; i < CLUSTER_SLOTS; i++) {\n if (clusterNodeCoversSlot(master, i))\n slots = slotRangeArrayAppend(slots, i);\n }\n }\n return slots ? slots : slotRangeArrayCreate(0);\n}\n\n/* Partially flush destination DB in a cluster node, based on the slot range.\n *\n * Usage: SFLUSH [ ]* [SYNC|ASYNC]\n *\n * Redis will flush the slots that belong to this node and reply with the flushed \n * slot ranges. If no slot is flushed, an empty array will be returned.\n * \n * e.g. Node owns slot 100-200, user issues SFLUSH 50 150\n * Redis will flush slot 100-150 and reply with [100,150]\n * \n * If possible, SFLUSH SYNC will be run as blocking ASYNC as an \n * optimization.\n */\nvoid sflushCommand(client *c) {\n int flags = EMPTYDB_NO_FLAGS, argc = c->argc;\n int trim_method = ASM_TRIM_METHOD_NONE;\n\n if (server.cluster_enabled == 0) {\n addReplyError(c,\"This instance has cluster support disabled\");\n return;\n }\n\n /* check if last argument is SYNC or ASYNC */\n if (!strcasecmp(c->argv[c->argc-1]->ptr,\"sync\")) {\n flags = EMPTYDB_NO_FLAGS;\n argc--;\n } else if (!strcasecmp(c->argv[c->argc-1]->ptr,\"async\")) {\n flags = EMPTYDB_ASYNC;\n argc--;\n } else if (server.lazyfree_lazy_user_flush) {\n flags = EMPTYDB_ASYNC;\n }\n\n /* parse the slot range */\n if (argc % 2 == 0) {\n addReplyErrorArity(c);\n return;\n }\n\n /* Parse slot ranges from the command arguments. */\n slotRangeArray *slots = parseSlotRangesOrReply(c, argc, 1);\n if (!slots) return;\n\n /* If client is AOF or master, we must obey the slot ranges. */\n int must_obey = mustObeyClient(c);\n\n /* Iterate and find the slot ranges that belong to this node. Save them in\n * a new slotRangeArray. It is allocated on heap since there is a chance\n * that FLUSH SYNC will be running as blocking ASYNC and only later reply\n * with slot ranges */\n slotRangeArray *myslots = NULL;\n for (int i = 0; i < slots->num_ranges; i++) {\n for (int j = slots->ranges[i].start; j <= slots->ranges[i].end; j++) {\n if (must_obey || clusterIsMySlot(j)) {\n myslots = slotRangeArrayAppend(myslots, j);\n }\n }\n }\n\n /* If no slots belong to this node, return empty array. */\n if (myslots == NULL) {\n addReplyArrayLen(c, 0);\n slotRangeArrayFree(slots);\n return;\n }\n slotRangeArrayFree(slots);\n \n /* takes ownership of myslots */\n asmTrimCtx *trim_ctx = asmTrimCtxCreate(myslots, server.db[0].keys);\n\n /* If the selected slots are exactly the same as the local slots, we can\n * simply flush the entire DB by flushCommandCommon. */\n slotRangeArray *local_slots = clusterGetLocalSlotRanges();\n int all_slots_covered = slotRangeArrayIsEqual(myslots, local_slots);\n slotRangeArrayFree(local_slots);\n if (all_slots_covered) {\n /* If not flush as blocking async, then reply immediately */\n if (flushCommandCommon(c, FLUSH_TYPE_SLOTS, flags, trim_ctx) == 0) {\n replySlotsFlush(c, trim_ctx->slots);\n }\n asmTrimCtxRelease(trim_ctx);\n return;\n }\n\n /* Cancel all ASM tasks that overlap with the given slot ranges. */\n clusterAsmCancelBySlotRangeArray(myslots, c->argv[0]->ptr);\n\n /* In case of SYNC, check if we can optimize and run it in bg as blocking ASYNC */\n int blocking_async = 0;\n if ((!(flags & EMPTYDB_ASYNC)) && (!(c->flags & CLIENT_AVOID_BLOCKING_ASYNC_FLUSH))) {\n flags |= EMPTYDB_ASYNC; /* Run as ASYNC */\n blocking_async = 1;\n }\n\n /* Trim the slots if running in async mode and not loading from AOF,\n * otherwise delete the keys synchronously. */\n if (flags & EMPTYDB_ASYNC && server.loading == 0) {\n /* Update dirty stats before trimming. */\n server.dirty += getKeyCountInSlotRangeArray(myslots);\n /* Pass client id for active trim to unblock client when trim completes. */\n trim_method = asmTrimSlots(trim_ctx, blocking_async ? c->id : CLIENT_ID_NONE, 0);\n } else {\n clusterDelKeysInSlotRangeArray(myslots, 1);\n }\n\n /* Without the forceCommandPropagation, when DB was already empty,\n * SFLUSH will not be replicated nor put into the AOF. */\n forceCommandPropagation(c, PROPAGATE_REPL | PROPAGATE_AOF);\n\n /* Handle waiting for trim job to complete in case of blocking async flush.\n * Block the client and schedule completion callback based on trim method:\n * - BG trim uses BIO lazyfree worker to trim the slots, so schedule a new\n * BIO lazyfree worker to wait for completion, then unblock client and reply.\n * - Active trim works in cron job of the main thread, it will automatically\n * unblock client and reply in active trim completion. */\n if (blocking_async && trim_method != ASM_TRIM_METHOD_NONE) {\n blockClientForAsyncFlush(c);\n } else {\n /* Reply with slot ranges that were flushed. SYNC and ASYNC mode will be\n * replied here immediately. */\n replySlotsFlush(c, trim_ctx->slots);\n }\n\n asmTrimCtxRelease(trim_ctx); /* if bg trim, released later by kvsAsyncFreeDoneCB() */\n}\n\n/* The READWRITE command just clears the READONLY command state. */\nvoid readwriteCommand(client *c) {\n if (server.cluster_enabled == 0) {\n addReplyError(c,\"This instance has cluster support disabled\");\n return;\n }\n c->flags &= ~CLIENT_READONLY;\n addReply(c,shared.ok);\n}\n\n/* Resets transient cluster stats that we expose via INFO or other means that we want\n * to reset via CONFIG RESETSTAT. The function is also used in order to\n * initialize these fields in clusterInit() at server startup. */\nvoid resetClusterStats(void) {\n if (!server.cluster_enabled) return;\n\n clusterSlotStatResetAll();\n}\n\n/* This function is called at server startup in order to initialize cluster data\n * structures that are shared between the different cluster implementations. */\nvoid clusterCommonInit(void) {\n resetClusterStats();\n asmInit();\n}\n\n/* This function is called after the node startup in order to check if there\n * are any slots that we have keys for, but are not assigned to us. If so,\n * we delete the keys. */\nvoid clusterDeleteKeysInUnownedSlots(void) {\n if (clusterNodeIsSlave(getMyClusterNode())) return;\n\n /* Check that all the slots we have keys for are assigned to us. Otherwise,\n * delete the keys. */\n for (int i = 0; i < CLUSTER_SLOTS; i++) {\n /* Skip if: no keys in the slot, it's our slot, or we are importing it. */\n if (!countKeysInSlot(i) ||\n clusterIsMySlot(i) ||\n getImportingSlotSource(i))\n {\n continue;\n }\n\n serverLog(LL_NOTICE, \"I have keys for slot %d, but the slot is \"\n \"assigned to another node. \"\n \"Deleting keys in the slot.\", i);\n /* With atomic slot migration, it is safe to drop keys from slots\n * that are not owned. This will not result in data loss under the\n * legacy slot migration approach either, since the importing state\n * has already been persisted in node.conf. */\n clusterDelKeysInSlot(i, 0);\n }\n}\n\n\n/* This function is called after the node startup in order to verify that data\n * loaded from disk is in agreement with the cluster configuration:\n *\n * 1) If we find keys about hash slots we have no responsibility for, the\n * following happens:\n * A) If no other node is in charge according to the current cluster\n * configuration, we add these slots to our node.\n * B) If according to our config other nodes are already in charge for\n * this slots, we set the slots as IMPORTING from our point of view\n * in order to justify we have those slots, and in order to make\n * redis-cli aware of the issue, so that it can try to fix it.\n * 2) If we find data in a DB different than DB0 we return C_ERR to\n * signal the caller it should quit the server with an error message\n * or take other actions.\n *\n * The function always returns C_OK even if it will try to correct\n * the error described in \"1\". However if data is found in DB different\n * from DB0, C_ERR is returned.\n *\n * The function also uses the logging facility in order to warn the user\n * about desynchronizations between the data we have in memory and the\n * cluster configuration. */\nint verifyClusterConfigWithData(void) {\n /* Return ASAP if a module disabled cluster redirections. In that case\n * every master can store keys about every possible hash slot. */\n if (server.cluster_module_flags & CLUSTER_MODULE_FLAG_NO_REDIRECTION)\n return C_OK;\n\n /* If this node is a slave, don't perform the check at all as we\n * completely depend on the replication stream. */\n if (clusterNodeIsSlave(getMyClusterNode())) return C_OK;\n\n /* Make sure we only have keys in DB0. */\n for (int i = 1; i < server.dbnum; i++) {\n if (kvstoreSize(server.db[i].keys)) return C_ERR;\n }\n\n /* Take over slots that we have keys for, but are assigned to no one. */\n clusterClaimUnassignedSlots();\n /* Delete keys in unowned slots */\n clusterDeleteKeysInUnownedSlots();\n return C_OK;\n}\n" }, { "path": "src/cluster.h", "content": "/*\n * Copyright (c) 2009-Present, Redis Ltd.\n * All rights reserved.\n *\n * Copyright (c) 2024-present, Valkey contributors.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n *\n * Portions of this file are available under BSD3 terms; see REDISCONTRIBUTIONS for more information.\n */\n\n#ifndef __CLUSTER_H\n#define __CLUSTER_H\n\n/*-----------------------------------------------------------------------------\n * Redis cluster exported API.\n *----------------------------------------------------------------------------*/\n\n#define CLUSTER_SLOT_MASK_BITS 14 /* Number of bits used for slot id. */\n#define CLUSTER_SLOTS (1< redis: initiates/advances/cancels ASM operations\n * - clusterAsmOnEvent(...) redis -> impl: notifies state changes\n *\n * Generic steps for an alternative implementation:\n * - On destination side, implementation calls clusterAsmProcess(ASM_EVENT_IMPORT_START)\n * to start an import operation.\n * - Redis calls clusterAsmOnEvent() when an ASM event occurs.\n * - On the source side, Redis will call clusterAsmOnEvent(ASM_EVENT_HANDOFF_PREP)\n * when slots are ready to be handed off and the write pause is needed.\n * - Implementation stops the traffic to the slots and calls clusterAsmProcess(ASM_EVENT_HANDOFF)\n * - On the destination side, Redis calls clusterAsmOnEvent(ASM_EVENT_TAKEOVER)\n * when destination node is ready to take over the slot, waiting for ownership change.\n * - Cluster implementation updates the config and calls clusterAsmProcess(ASM_EVENT_DONE)\n * to notify Redis that the slots ownership has changed.\n *\n * Sequence diagram for import:\n * - Note: shows only the events that cluster implementation needs to react.\n *\n * ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐\n * │ Destination │ │ Destination │ │ Source │ │ Source │\n * │ Cluster impl │ │ Master │ │ Master │ │ Cluster impl │\n * └───────┬───────┘ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘\n * │ │ │ │\n * │ ASM_EVENT_IMPORT_START │ │ │\n * ├─────────────────────────────►│ │ │\n * │ │ CLUSTER SYNCSLOTS │ │\n * │ ├────────────────────────►│ │\n * │ │ │ │\n * │ │ SNAPSHOT(restore cmds) │ │\n * │ │◄────────────────────────┤ │\n * │ │ Repl stream │ │\n * │ │◄────────────────────────┤ │\n * │ │ │ ASM_EVENT_HANDOFF_PREP │\n * │ │ ├────────────────────────────►│\n * │ │ │ ASM_EVENT_HANDOFF │\n * │ │ │◄────────────────────────────┤\n * │ │ Drain repl stream │ │\n * │ │◄────────────────────────┤ │\n * │ ASM_EVENT_TAKEOVER │ │ │\n * │◄─────────────────────────────┤ │ │\n * │ │ │ │\n * │ ASM_EVENT_DONE │ │ │\n * ├─────────────────────────────►│ │ ASM_EVENT_DONE │\n * │ │ │◄────────────────────────────┤\n * │ │ │ │\n */\n\n#define ASM_EVENT_IMPORT_START 1 /* Start a new import operation (destination side) */\n#define ASM_EVENT_CANCEL 2 /* Cancel an ongoing import/migrate operation (source and destination side) */\n#define ASM_EVENT_HANDOFF_PREP 3 /* Slot is ready to be handed off to the destination shard (source side) */\n#define ASM_EVENT_HANDOFF 4 /* Notify that the slot can be handed off (source side) */\n#define ASM_EVENT_TAKEOVER 5 /* Ready to take over the slot, waiting for config change (destination side) */\n#define ASM_EVENT_DONE 6 /* Notify that import/migrate is completed, config is updated (source and destination side) */\n\n#define ASM_EVENT_IMPORT_PREP 7 /* Import is about to start, the implementation may reject by returning C_ERR */\n#define ASM_EVENT_IMPORT_STARTED 8 /* Import started */\n#define ASM_EVENT_IMPORT_FAILED 9 /* Import failed */\n#define ASM_EVENT_IMPORT_COMPLETED 10 /* Import completed (config updated) */\n#define ASM_EVENT_MIGRATE_PREP 11 /* Migrate is about to start, the implementation may reject by returning C_ERR */\n#define ASM_EVENT_MIGRATE_STARTED 12 /* Migrate started */\n#define ASM_EVENT_MIGRATE_FAILED 13 /* Migrate failed */\n#define ASM_EVENT_MIGRATE_COMPLETED 14 /* Migrate completed (config updated) */\n\n\n/* Called by cluster implementation to request an ASM operation. (cluster impl --> redis)\n * Valid values for 'event':\n * ASM_EVENT_IMPORT_START\n * ASM_EVENT_CANCEL\n * ASM_EVENT_HANDOFF\n * ASM_EVENT_DONE\n *\n * For ASM_EVENT_IMPORT_START, 'task_id' should be a unique string.\n * For other events (ASM_EVENT_CANCEL, ASM_EVENT_HANDOFF, ASM_EVENT_DONE),\n * 'task_id' should match the ID from the corresponding import operation.\n * Usage:\n * char *task_id = malloc(CLUSTER_NAMELEN + 1);\n * getRandomHexChars(task_id, CLUSTER_NAMELEN);\n * task_id[CLUSTER_NAMELEN] = '\\0';\n *\n * slotRangeArray *slots = slotRangeArrayCreate(1);\n * slotRangeArraySet(slots, 0, 0, 1000);\n *\n * const char *err = NULL;\n * int ret = clusterAsmProcess(task_id, ASM_EVENT_IMPORT_START, slots, &err);\n * zfree(task_id);\n * slotRangeArrayFree(slots);\n *\n * if (ret != C_OK) {\n * perror(err);\n * return;\n * }\n *\n * For ASM_EVENT_CANCEL, if `task_id` is NULL, all tasks will be cancelled.\n * If `arg` parameter is provided, it should be a pointer to an int. It will be\n * set to the number of tasks cancelled.\n *\n * Return value:\n * - Returns C_OK on success, C_ERR on failure and 'err' will be set to the\n * error message.\n *\n * Memory management:\n * - There is no ownership transfer of 'task_id', 'err' or `slotRangeArray`.\n * - `task_id` and `slotRangeArray` should be allocated and be freed by the\n * caller. Redis internally will make a copy of these.\n * - `err` is allocated by Redis and should NOT be freed by the caller.\n **/\nint clusterAsmProcess(const char *task_id, int event, void *arg, char **err);\n\n/* Called when an ASM event occurs to notify the cluster implementation. (redis --> cluster impl)\n *\n * `arg` will point to a `slotRangeArray` for the following events:\n * ASM_EVENT_IMPORT_PREP\n * ASM_EVENT_IMPORT_STARTED\n * ASM_EVENT_MIGRATE_PREP\n * ASM_EVENT_MIGRATE_STARTED\n * ASM_EVENT_HANDOFF_PREP\n *\n * Memory management:\n * - Redis owns the `task_id` and `slotRangeArray`.\n *\n * Returns C_OK on success.\n *\n * If the cluster implementation returns C_ERR for ASM_EVENT_IMPORT_PREP or\n * ASM_EVENT_MIGRATE_PREP, operation will not start.\n **/\nint clusterAsmOnEvent(const char *task_id, int event, void *arg);\n\n#endif /* __CLUSTER_H */\n" }, { "path": "src/cluster_asm.c", "content": "/* \n * Copyright (c) 2025-Present, Redis Ltd.\n * All rights reserved.\n *\n * Licensed under your choice of (a) the Redis Source Available License 2.0\n * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the\n * GNU Affero General Public License v3 (AGPLv3).\n * \n * cluster_asm.c -- Atomic slot migration implementation for cluster\n * \n * TERMINOLOGY:\n * - SOURCE: The node that currently owns the slots (sending data away)\n * - DESTINATION: The node that will own the slots (receiving data)\n *\n * Example: Moving slots 0-100 from Node A to Node B\n * - Node A = SOURCE (has the data, will lose ownership)\n * - Node B = DESTINATION (will receive data, will gain ownership)\n *\n * Migration Flow:\n * 1. DESTINATION initiates: CLUSTER MIGRATION IMPORT \n * (Operator runs command on Node B, the receiving node)\n *\n * 2. SOURCE forks and sends slot snapshot (RESTORE commands) via RDB channel\n * (Node A creates snapshot of slots 0-100)\n *\n * 3. SOURCE streams incremental changes via main channel\n * (Node A forwards new writes to Node B while snapshot is being sent)\n *\n * 4. DESTINATION applies snapshot and buffers incremental changes\n * (Node B receives snapshot, buffers ongoing writes)\n *\n * 5. SOURCE pauses writes when destination catches up\n * (Node A stops accepting writes for slots 0-100 when Node B is nearly caught up)\n *\n * 6. DESTINATION drains buffer and takes ownership\n * (Node B applies final buffered commands, updates config to own slots 0-100)\n *\n * 7. Config updated atomically via cluster bus\n * (All nodes learn: slots 0-100 now belong to Node B)\n *\n * 8. SOURCE trims migrated keys (background or active)\n * (Node A deletes keys from slots 0-100 since it no longer owns them)\n *\n */\n\n#include \"server.h\"\n#include \"cluster.h\"\n#include \"functions.h\"\n#include \"cluster_asm.h\"\n#include \"cluster_slot_stats.h\"\n#include \"bio.h\"\n\n/* Operation types: import (destination side) or migrate (source side) */\n#define ASM_IMPORT (1 << 1)\n#define ASM_MIGRATE (1 << 2)\n\n/* Trimming methods for cleaning up migrated keys */\n#define ASM_DEBUG_TRIM_DEFAULT 0 /* Auto-select based on module subscriptions and client tracking */\n#define ASM_DEBUG_TRIM_NONE 1 /* No trimming (for testing) */\n#define ASM_DEBUG_TRIM_BG 2 /* Background trim: hand off to BIO thread (fast, non-blocking) */\n#define ASM_DEBUG_TRIM_ACTIVE 3 /* Active trim: delete in main thread cron (slow, fires notifications) */\n\n#define ASM_AOF_MIN_ITEMS_PER_KEY 512 /* Minimum number of items per key to use AOF format encoding */\n\n/* ASM Task: Represents a single slot migration operation.\n * Each task tracks the complete lifecycle of migrating one or more slot ranges\n * from a source node to a destination node. The task exists on both sides but\n * with different states (import states on destination, migrate states on source).\n */\ntypedef struct asmTask {\n sds id; /* Task ID */\n int operation; /* Either ASM_IMPORT or ASM_MIGRATE */\n slotRangeArray *slots; /* List of slot ranges for this migration task */\n int state; /* Current state of the task */\n int dest_state; /* Destination node's main state (approximate) */\n char source[CLUSTER_NAMELEN]; /* Source node name */\n char dest[CLUSTER_NAMELEN]; /* Destination node name */\n connection *main_channel_conn; /* Main channel connection */\n connection *rdb_channel_conn; /* RDB channel connection */\n int rdb_channel_state; /* State of the RDB channel */\n unsigned long long dest_offset; /* Destination offset */\n unsigned long long source_offset; /* Source offset */\n int cross_slot_during_propagating; /* If cross-slot commands are encountered during propagating */\n int stream_eof_during_streaming; /* If STREAM-EOF is received during streaming buffer */\n replDataBuf sync_buffer; /* Buffer for the stream */\n client *main_channel_client; /* Client for the main channel on the source side */\n client *rdb_channel_client; /* Client for the RDB channel on the source side */\n long long retry_count; /* Number of retries for this task */\n mstime_t create_time; /* Task creation time */\n mstime_t start_time; /* Task start time */\n mstime_t end_time; /* Task end time */\n mstime_t paused_time; /* The time when the slot writes were paused */\n mstime_t dest_slots_snapshot_time; /* The time when the destination starts applying the slot snapshot */\n mstime_t dest_accum_applied_time; /* The time when the destination finishes applying the accumulated buffer */\n sds error; /* Error message for this task */\n redisOpArray *pre_snapshot_module_cmds; /* Module commands to be propagated at the beginning of slot migration */\n} asmTask;\n\ntypedef struct activeTrimJob {\n slotRangeArray *slots; /* Slots being trimmed */\n uint64_t client_id; /* Client ID waiting for active trim completion (0 if none) */\n int migration_cleanup; /* Whether this is a migration cleanup of slots no longer owned */\n} activeTrimJob;\n\n/* ASM Manager: Global singleton that manages all ASM operations.\n * Coordinates migration tasks, trim jobs, and maintains statistics. */\nstruct asmManager {\n list *tasks; /* List of asmTask to be processed */\n list *archived_tasks; /* List of archived asmTask */\n list *pending_trim_jobs; /* List of pending trim jobs (due to write pause) */\n list *active_trim_jobs; /* List of active trim jobs */\n slotRangeArrayIter *active_trim_it; /* Iterator of the current active trim job */\n size_t sync_buffer_peak; /* Peak size of sync buffer */\n asmTask *master_task; /* The task that is currently active on the master */\n\n /* Fail point injection for debugging */\n int debug_fail_channel; /* Channel where the task will fail */\n int debug_fail_state; /* State where the task will fail */\n int debug_trim_method; /* Method to trim the buffer */\n int debug_active_trim_delay; /* Sleep before trimming each key */\n\n /* Background trim tracking */\n size_t bg_trim_running; /* Number of bg trim jobs in progress */\n\n /* Active trim stats */\n unsigned long long active_trim_started; /* Number of times active trim was started */\n unsigned long long active_trim_completed; /* Number of times active trim was completed */\n unsigned long long active_trim_cancelled; /* Number of times active trim was cancelled */\n unsigned long long active_trim_current_job_keys; /* Total number of keys to trim in the current job */\n unsigned long long active_trim_current_job_trimmed; /* Number of keys trimmed in the current job */\n};\n\nenum asmState {\n /* Common state */\n ASM_NONE = 0,\n ASM_CONNECTING,\n ASM_AUTH_REPLY,\n ASM_CANCELED,\n ASM_FAILED,\n ASM_COMPLETED,\n\n /* Import state */\n ASM_SEND_HANDSHAKE,\n ASM_HANDSHAKE_REPLY,\n ASM_SEND_SYNCSLOTS,\n ASM_SYNCSLOTS_REPLY,\n ASM_INIT_RDBCHANNEL,\n ASM_ACCUMULATE_BUF,\n ASM_READY_TO_STREAM,\n ASM_STREAMING_BUF,\n ASM_WAIT_STREAM_EOF,\n ASM_TAKEOVER,\n\n /* Migrate state */\n ASM_WAIT_RDBCHANNEL,\n ASM_WAIT_BGSAVE_START,\n ASM_SEND_BULK_AND_STREAM,\n ASM_SEND_STREAM,\n ASM_HANDOFF_PREP,\n ASM_HANDOFF,\n ASM_STREAM_EOF,\n\n /* RDB channel state */\n ASM_RDBCHANNEL_REQUEST,\n ASM_RDBCHANNEL_REPLY,\n ASM_RDBCHANNEL_TRANSFER,\n};\n\nenum asmChannel {\n ASM_IMPORT_MAIN_CHANNEL = 1, /* Main channel for the import task */\n ASM_IMPORT_RDB_CHANNEL, /* RDB channel for the import task */\n ASM_MIGRATE_MAIN_CHANNEL, /* Main channel for the migrate task */\n ASM_MIGRATE_RDB_CHANNEL /* RDB channel for the migrate task */\n};\n\n/* Global ASM manager */\nstruct asmManager *asmManager = NULL;\n\n/* replication.c */\nchar *sendCommand(connection *conn, ...);\nchar *sendCommandArgv(connection *conn, int argc, char **argv, size_t *argv_lens);\nchar *receiveSynchronousResponse(connection *conn);\nConnectionType *connTypeOfReplication(void);\nint startBgsaveForReplication(int mincapa, int req);\nvoid createReplicationBacklogIfNeeded(void);\n/* cluster.c */\nvoid createDumpPayload(rio *payload, robj *o, robj *key, int dbid, int skip_checksum);\n/* cluster_asm.c */\nstatic void asmStartImportTask(asmTask *task);\nstatic void asmTaskCancel(asmTask *task, const char *reason);\nstatic void asmSyncBufferReadFromConn(connection *conn);\nstatic void propagateTrimSlots(slotRangeArray *slots);\nvoid asmTrimJobSchedule(slotRangeArray *slots);\nvoid asmTrimJobProcessPending(void);\nvoid asmCancelPendingTrimJobs(void);\nvoid asmTriggerActiveTrim(slotRangeArray *slots, uint64_t client_id, int migration_cleanup);\nvoid asmActiveTrimEnd(void);\nint asmIsAnyTrimJobOverlaps(slotRangeArray *slots);\nvoid asmTrimSlotsIfNotOwned(slotRangeArray *slots);\nvoid asmNotifyStateChange(asmTask *task, int event);\nvoid activeTrimJobFreeMethod(void *ptr);\n\nvoid asmInit(void) {\n asmManager = zcalloc(sizeof(*asmManager));\n asmManager->tasks = listCreate();\n asmManager->archived_tasks = listCreate();\n asmManager->pending_trim_jobs = listCreate();\n asmManager->sync_buffer_peak = 0;\n asmManager->master_task = NULL;\n asmManager->debug_fail_channel = -1;\n asmManager->debug_fail_state = -1;\n asmManager->debug_trim_method = ASM_DEBUG_TRIM_DEFAULT;\n asmManager->debug_active_trim_delay = 0;\n asmManager->active_trim_jobs = listCreate();\n asmManager->active_trim_started = 0;\n asmManager->active_trim_completed = 0;\n asmManager->active_trim_cancelled = 0;\n listSetFreeMethod(asmManager->active_trim_jobs, activeTrimJobFreeMethod);\n}\n\nchar *asmTaskStateToString(int state) {\n switch (state) {\n case ASM_NONE: return \"none\";\n case ASM_CONNECTING: return \"connecting\";\n case ASM_AUTH_REPLY: return \"auth-reply\";\n case ASM_CANCELED: return \"canceled\";\n case ASM_FAILED: return \"failed\";\n case ASM_COMPLETED: return \"completed\";\n\n /* Import state */\n case ASM_SEND_HANDSHAKE: return \"send-handshake\";\n case ASM_HANDSHAKE_REPLY: return \"handshake-reply\";\n case ASM_SEND_SYNCSLOTS: return \"send-syncslots\";\n case ASM_SYNCSLOTS_REPLY: return \"syncslots-reply\";\n case ASM_INIT_RDBCHANNEL: return \"init-rdbchannel\";\n case ASM_ACCUMULATE_BUF: return \"accumulate-buffer\";\n case ASM_READY_TO_STREAM: return \"ready-to-stream\";\n case ASM_STREAMING_BUF: return \"streaming-buffer\";\n case ASM_WAIT_STREAM_EOF: return \"wait-stream-eof\";\n case ASM_TAKEOVER: return \"takeover\";\n \n /* Migrate state */\n case ASM_WAIT_RDBCHANNEL: return \"wait-rdbchannel\";\n case ASM_WAIT_BGSAVE_START: return \"wait-bgsave-start\";\n case ASM_SEND_BULK_AND_STREAM: return \"send-bulk-and-stream\";\n case ASM_SEND_STREAM: return \"send-stream\";\n case ASM_HANDOFF_PREP: return \"handoff-prep\";\n case ASM_HANDOFF: return \"handoff\";\n case ASM_STREAM_EOF: return \"stream-eof\";\n\n /* RDB channel state */\n case ASM_RDBCHANNEL_REQUEST: return \"rdbchannel-request\";\n case ASM_RDBCHANNEL_REPLY: return \"rdbchannel-reply\";\n case ASM_RDBCHANNEL_TRANSFER: return \"rdbchannel-transfer\";\n\n default: return \"unknown\";\n }\n serverAssert(0); /* Unreachable */\n}\n\nconst char *asmChannelToString(int channel) {\n switch (channel) {\n case ASM_IMPORT_MAIN_CHANNEL: return \"import-main-channel\";\n case ASM_IMPORT_RDB_CHANNEL: return \"import-rdb-channel\";\n case ASM_MIGRATE_MAIN_CHANNEL: return \"migrate-main-channel\";\n case ASM_MIGRATE_RDB_CHANNEL: return \"migrate-rdb-channel\";\n default: return \"unknown\";\n }\n}\n\nint asmDebugSetFailPoint(char *channel, char *state) {\n if (!asmManager) {\n serverLog(LL_WARNING, \"ASM manager is not initialized\");\n return C_ERR;\n }\n asmManager->debug_fail_channel = -1;\n asmManager->debug_fail_state = -1;\n if (!channel && !state) return C_ERR;\n if (sdslen(channel) == 0 && sdslen(state) == 0) {\n serverLog(LL_WARNING, \"ASM fail point is cleared\");\n return C_OK;\n }\n\n for (int i = ASM_IMPORT_MAIN_CHANNEL; i <= ASM_MIGRATE_RDB_CHANNEL; i++) {\n if (!strcasecmp(channel, asmChannelToString(i))) {\n asmManager->debug_fail_channel = i;\n break;\n }\n }\n if (asmManager->debug_fail_channel == -1) return C_ERR;\n\n for (int i = ASM_NONE; i <= ASM_RDBCHANNEL_TRANSFER; i++) {\n if (!strcasecmp(state, asmTaskStateToString(i))) {\n asmManager->debug_fail_state = i;\n break;\n }\n }\n if (asmManager->debug_fail_state == -1) return C_ERR;\n\n serverLog(LL_NOTICE, \"ASM fail point set: channel=%s, state=%s\", channel, state);\n return C_OK;\n}\n\nint asmDebugSetTrimMethod(const char *method, int active_trim_delay) {\n if (!asmManager) {\n serverLog(LL_WARNING, \"ASM manager is not initialized\");\n return C_ERR;\n }\n int prev = asmManager->debug_trim_method;\n if (!strcasecmp(method, \"default\")) asmManager->debug_trim_method = ASM_DEBUG_TRIM_DEFAULT;\n else if (!strcasecmp(method, \"none\")) asmManager->debug_trim_method = ASM_DEBUG_TRIM_NONE;\n else if (!strcasecmp(method, \"bg\")) asmManager->debug_trim_method = ASM_DEBUG_TRIM_BG;\n else if (!strcasecmp(method, \"active\")) asmManager->debug_trim_method = ASM_DEBUG_TRIM_ACTIVE;\n else return C_ERR;\n\n /* If we are switching from none to default, delete all the keys in the\n * slots we don't own */\n if (prev == ASM_DEBUG_TRIM_NONE && asmManager->debug_trim_method != ASM_DEBUG_TRIM_NONE) {\n for (int i = 0; i < CLUSTER_SLOTS; i++)\n if (!clusterIsMySlot(i))\n clusterDelKeysInSlot(i, 0);\n }\n asmManager->debug_active_trim_delay = active_trim_delay;\n serverLog(LL_NOTICE, \"ASM trim method was set=%s, active_trim_delay=%d\", method, active_trim_delay);\n return C_OK;\n}\n\nint asmDebugIsFailPointActive(int channel, int state) {\n if (!asmManager) return 0; /* ASM manager not initialized */\n if (asmManager->debug_fail_channel == channel && asmManager->debug_fail_state == state) {\n serverLog(LL_NOTICE, \"ASM fail point active: channel=%s, state=%s\",\n asmChannelToString(channel), asmTaskStateToString(state));\n return 1;\n }\n return 0;\n}\n\nsds asmCatInfoString(sds info) {\n int active_tasks = 0;\n\n listIter li;\n listNode *ln;\n listRewind(asmManager->tasks, &li);\n while ((ln = listNext(&li)) != NULL) {\n asmTask *task = listNodeValue(ln);\n if (task->operation == ASM_IMPORT ||\n (task->operation == ASM_MIGRATE && task->state != ASM_FAILED))\n {\n active_tasks++;\n }\n }\n\n return sdscatprintf(info ? info : sdsempty(),\n \"cluster_slot_migration_active_tasks:%d\\r\\n\"\n \"cluster_slot_migration_active_trim_running:%lu\\r\\n\"\n \"cluster_slot_migration_active_trim_current_job_keys:%llu\\r\\n\"\n \"cluster_slot_migration_active_trim_current_job_trimmed:%llu\\r\\n\"\n \"cluster_slot_migration_stats_active_trim_started:%llu\\r\\n\"\n \"cluster_slot_migration_stats_active_trim_completed:%llu\\r\\n\"\n \"cluster_slot_migration_stats_active_trim_cancelled:%llu\\r\\n\",\n active_tasks,\n listLength(asmManager->active_trim_jobs),\n asmManager->active_trim_current_job_keys,\n asmManager->active_trim_current_job_trimmed,\n asmManager->active_trim_started,\n asmManager->active_trim_completed,\n asmManager->active_trim_cancelled);\n}\n\nvoid asmTaskReset(asmTask *task) {\n task->state = ASM_NONE;\n task->dest_state = ASM_NONE;\n task->rdb_channel_state = ASM_NONE;\n task->main_channel_conn = NULL;\n task->rdb_channel_conn = NULL;\n task->dest_offset = 0;\n task->source_offset = 0;\n task->stream_eof_during_streaming = 0;\n task->cross_slot_during_propagating = 0;\n replDataBufInit(&task->sync_buffer);\n task->main_channel_client = NULL;\n task->rdb_channel_client = NULL;\n task->paused_time = 0;\n task->dest_slots_snapshot_time = 0;\n task->dest_accum_applied_time = 0;\n task->pre_snapshot_module_cmds = NULL;\n}\n\nasmTask *asmTaskCreate(const char *task_id) {\n asmTask *task = zcalloc(sizeof(*task));\n task->error = sdsempty();\n asmTaskReset(task);\n task->slots = NULL;\n task->retry_count = 0;\n task->create_time = server.mstime;\n task->start_time = -1;\n task->end_time = -1;\n if (task_id) {\n task->id = sdsnew(task_id);\n } else {\n task->id = sdsnewlen(NULL, CLUSTER_NAMELEN);\n getRandomHexChars(task->id, CLUSTER_NAMELEN);\n }\n\n return task;\n}\n\nvoid asmTaskFree(asmTask *task) {\n replDataBufClear(&task->sync_buffer);\n sdsfree(task->id);\n slotRangeArrayFree(task->slots);\n sdsfree(task->error);\n zfree(task);\n}\n\n/* Convert the task state to the corresponding event. */\nint asmTaskStateToEvent(asmTask *task) {\n if (task->operation == ASM_IMPORT) {\n if (task->state == ASM_COMPLETED) return ASM_EVENT_IMPORT_COMPLETED;\n else if (task->state == ASM_FAILED) return ASM_EVENT_IMPORT_FAILED;\n else return ASM_EVENT_IMPORT_STARTED;\n } else {\n if (task->state == ASM_COMPLETED) return ASM_EVENT_MIGRATE_COMPLETED;\n else if (task->state == ASM_FAILED) return ASM_EVENT_MIGRATE_FAILED;\n else return ASM_EVENT_MIGRATE_STARTED;\n }\n}\n\n/* Serialize ASM task information into a string for transmission to replicas.\n * Format: \"task_id:source_node:dest_node:operation:state:slot_ranges\"\n * Where slot_ranges is in the format \"1000-2000 3000-4000 ...\" */\nsds asmTaskSerialize(asmTask *task) {\n sds serialized = sdsempty();\n\n /* Add task ID */\n serialized = sdscatprintf(serialized, \"%s:\", task->id);\n\n /* Add source node ID (40 chars) */\n serialized = sdscatlen(serialized, task->source, CLUSTER_NAMELEN);\n serialized = sdscat(serialized, \":\");\n\n /* Add destination node ID (40 chars) */\n serialized = sdscatlen(serialized, task->dest, CLUSTER_NAMELEN);\n serialized = sdscat(serialized, \":\");\n\n /* Add operation type */\n serialized = sdscatprintf(serialized, \"%s:\", task->operation == ASM_IMPORT ?\n \"import\" : \"migrate\");\n\n /* Add current state */\n serialized = sdscatprintf(serialized, \"%s:\", asmTaskStateToString(task->state));\n\n /* Add slot ranges sds */\n sds slots_str = slotRangeArrayToString(task->slots);\n serialized = sdscatprintf(serialized, \"%s\", slots_str);\n sdsfree(slots_str);\n\n return serialized;\n}\n\n/* Deserialize ASM task information from a string and create a complete asmTask.\n * Format: \"task_id:source_node:dest_node:operation:state:slot_ranges\"\n * Returns a new asmTask on success, NULL on failure. */\nasmTask *asmTaskDeserialize(sds data) {\n int count, idx = 0;\n asmTask *task = NULL;\n if (!data || sdslen(data) == 0) return NULL;\n\n sds *parts = sdssplitlen(data, sdslen(data), \":\", 1, &count);\n if (count < 6) goto err;\n\n /* Parse task ID */\n if (sdslen(parts[idx]) == 0) goto err;\n task = asmTaskCreate(parts[idx]);\n if (!task) goto err;\n idx++;\n\n /* Parse source node ID */\n if (sdslen(parts[idx]) != CLUSTER_NAMELEN) goto err;\n memcpy(task->source, parts[idx], CLUSTER_NAMELEN);\n idx++;\n\n /* Parse destination node ID */\n if (sdslen(parts[idx]) != CLUSTER_NAMELEN) goto err;\n memcpy(task->dest, parts[idx], CLUSTER_NAMELEN);\n idx++;\n\n /* Parse operation type */\n if (!strcasecmp(parts[idx], \"import\")) {\n task->operation = ASM_IMPORT;\n } else if (!strcasecmp(parts[idx], \"migrate\")) {\n task->operation = ASM_MIGRATE;\n } else {\n goto err;\n }\n idx++;\n\n /* Parse state */\n task->state = ASM_NONE; /* Default state */\n for (int state = ASM_NONE; state <= ASM_RDBCHANNEL_TRANSFER; state++) {\n if (!strcasecmp(parts[idx], asmTaskStateToString(state))) {\n task->state = state;\n break;\n }\n }\n idx++;\n\n /* Parse slot ranges */\n task->slots = slotRangeArrayFromString(parts[idx]);\n if (!task->slots) goto err;\n idx++;\n\n /* Ignore any extra fields for future compatibility */\n\n sdsfreesplitres(parts, count);\n return task;\n\nerr:\n if (task) asmTaskFree(task);\n sdsfreesplitres(parts, count);\n return NULL;\n}\n\n/* Notify replicas about ASM task information to maintain consistency during\n * slot migration. This function sends a CLUSTER SYNCSLOTS CONF ASM-TASK command\n * to all connected replicas with the serialized task information. */\nvoid asmNotifyReplicasStateChange(struct asmTask *task) {\n if (!server.cluster_enabled || !clusterNodeIsMaster(getMyClusterNode())) return;\n\n /* Create command arguments for CLUSTER SYNCSLOTS CONF ASM-TASK */\n robj *argv[5];\n argv[0] = createStringObject(\"CLUSTER\", 7);\n argv[1] = createStringObject(\"SYNCSLOTS\", 9);\n argv[2] = createStringObject(\"CONF\", 4);\n argv[3] = createStringObject(\"ASM-TASK\", 8);\n argv[4] = createObject(OBJ_STRING, asmTaskSerialize(task));\n\n /* Send the command to all replicas */\n replicationFeedSlaves(server.slaves, -1, argv, 5);\n\n /* Clean up command objects */\n for (int i = 0; i < 5; i++) {\n decrRefCount(argv[i]);\n }\n}\n\n/* Dump the active import ASM task information. */\nsds asmDumpActiveImportTask(void) {\n if (!server.cluster_enabled) return NULL;\n\n /* For replica, dump the master active task. */\n if (clusterNodeIsSlave(getMyClusterNode()) &&\n asmManager->master_task &&\n asmManager->master_task->state != ASM_FAILED &&\n asmManager->master_task->state != ASM_COMPLETED)\n {\n return asmTaskSerialize(asmManager->master_task);\n }\n\n /* For master, dump the first active task. */\n if (!asmManager || listLength(asmManager->tasks) == 0) return NULL;\n asmTask *task = listNodeValue(listFirst(asmManager->tasks));\n if (task->state == ASM_NONE || task->state == ASM_FAILED ||\n task->state == ASM_COMPLETED) return NULL;\n\n return asmTaskSerialize(task);\n}\n\nsize_t asmGetPeakSyncBufferSize(void) {\n if (!asmManager) return 0;\n /* Compute peak sync buffer usage. The current task's peak may not\n * reflect in asmManager->sync_buffer_peak immediately. */\n size_t peak = asmManager->sync_buffer_peak;\n asmTask *task = listFirst(asmManager->tasks) ?\n listNodeValue(listFirst(asmManager->tasks)) : NULL;\n if (task && task->operation == ASM_IMPORT)\n peak = max(task->sync_buffer.peak, asmManager->sync_buffer_peak);\n \n return peak;\n}\n\nsize_t asmGetImportInputBufferSize(void) {\n if (!asmManager || listLength(asmManager->tasks) == 0) return 0;\n\n asmTask *task = listNodeValue(listFirst(asmManager->tasks));\n if (task->operation == ASM_IMPORT)\n return task->sync_buffer.mem_used;\n\n return 0;\n}\n\nsize_t asmGetMigrateOutputBufferSize(void) {\n if (!asmManager || listLength(asmManager->tasks) == 0) return 0;\n\n asmTask *task = listNodeValue(listFirst(asmManager->tasks));\n if (task->operation == ASM_MIGRATE && task->main_channel_client)\n return getClientOutputBufferMemoryUsage(task->main_channel_client);\n\n return 0;\n}\n\n/* Returns the ASM task with the given ID, or NULL if no such task exists. */\nstatic asmTask *asmLookupTaskAt(list *tasks, const char *id) {\n listIter li;\n listNode *ln;\n\n listRewind(tasks, &li);\n while ((ln = listNext(&li)) != NULL) {\n asmTask *task = listNodeValue(ln);\n if (!strcmp(task->id, id)) return task;\n }\n return NULL;\n}\n\n/* Returns the ASM task with the given ID, or NULL if no such task exists. */\nasmTask *asmLookupTaskById(const char *id) {\n return asmLookupTaskAt(asmManager->tasks, id);\n}\n\n/* Returns the ASM task that is identical to the given slot range array, or NULL\n * if no such task exists. */\nasmTask *asmLookupTaskBySlotRangeArray(slotRangeArray *slots) {\n listIter li;\n listNode *ln;\n\n listRewind(asmManager->tasks, &li);\n while ((ln = listNext(&li)) != NULL) {\n asmTask *task = listNodeValue(ln);\n if (slotRangeArrayIsEqual(task->slots, slots))\n return task;\n }\n return NULL;\n}\n\n/* Returns the slot range array for the given task ID */\nslotRangeArray *asmTaskGetSlotRanges(const char *task_id) {\n asmTask *task = NULL;\n if (!task_id || (task = asmLookupTaskById(task_id)) == NULL) return NULL;\n\n return task->slots;\n}\n\n/* Returns 1 if the slot range array overlaps with the given slot range. */\nstatic int slotRangeArrayOverlaps(slotRangeArray *slots, slotRange *req) {\n for (int i = 0; i < slots->num_ranges; i++) {\n slotRange *sr = &slots->ranges[i];\n if (sr->start <= req->end && sr->end >= req->start)\n return 1;\n }\n return 0;\n}\n\n/* Returns 1 if the two slot range arrays overlap, 0 otherwise. */\nstatic int slotRangeArraysOverlap(slotRangeArray *slots1, slotRangeArray *slots2) {\n for (int i = 0; i < slots1->num_ranges; i++) {\n slotRange *sr1 = &slots1->ranges[i];\n if (slotRangeArrayOverlaps(slots2, sr1)) return 1;\n }\n return 0;\n}\n\n/* Returns the ASM task that overlaps with the given slot range, or NULL if\n * no such task exists. */\nstatic asmTask *lookupAsmTaskBySlotRange(slotRange *req) {\n listIter li;\n listNode *ln;\n\n listRewind(asmManager->tasks, &li);\n while ((ln = listNext(&li)) != NULL) {\n asmTask *task = listNodeValue(ln);\n if (slotRangeArrayOverlaps(task->slots, req))\n return task;\n }\n return NULL;\n}\n\n/* Validates the given slot ranges for a migration task:\n * - Ensures the current node is a master.\n * - Verifies all slots are in a STABLE state.\n * - Confirms all slots belong to a single source node.\n * - Confirms no ongoing import task that overlaps with the slot ranges.\n *\n * Returns the source node if validation succeeds.\n * Otherwise, returns NULL and sets 'err' variable. */\nstatic clusterNode *validateImportSlotRanges(slotRangeArray *slots, sds *err, asmTask *current) {\n clusterNode *source = NULL;\n\n *err = NULL;\n\n /* Ensure this is a master node */\n if (!clusterNodeIsMaster(getMyClusterNode())) {\n *err = sdsnew(\"slot migration not allowed on replica.\");\n goto out;\n }\n\n /* Ensure no manual migration is in progress. */\n for (int i = 0; i < CLUSTER_SLOTS; i++) {\n if (getImportingSlotSource(i) != NULL ||\n getMigratingSlotDest(i) != NULL)\n {\n *err = sdsnew(\"all slot states must be STABLE to start a slot migration task.\");\n goto out;\n }\n }\n\n for (int i = 0; i < slots->num_ranges; i++) {\n slotRange *sr = &slots->ranges[i];\n\n /* Ensure no import task overlaps with this slot range.\n * Skip check current task that is running for this slot range. */\n asmTask *task = lookupAsmTaskBySlotRange(sr);\n if (task && task != current && task->operation == ASM_IMPORT) {\n *err = sdscatprintf(sdsempty(),\n \"overlapping import exists for slot range: %d-%d\",\n sr->start, sr->end);\n goto out;\n }\n\n /* Validate if we can start migration task for this slot range. */\n for (int j = sr->start; j <= sr->end; j++) {\n clusterNode *node = getNodeBySlot(j);\n if (node == NULL) {\n *err = sdscatprintf(sdsempty(), \"slot has no owner: %d\", j);\n goto out;\n }\n\n if (!source) {\n source = node;\n } else if (source != node) {\n *err = sdsnew(\"slots belong to different source nodes\");\n goto out;\n }\n }\n }\n\nout:\n return *err ? NULL : source;\n}\n\n/* Returns 1 if a task with the specified operation is in progress, 0 otherwise. */\nstatic int asmTaskInProgress(int operation) {\n listIter li;\n listNode *ln;\n\n if (!asmManager || listLength(asmManager->tasks) == 0) return 0;\n\n listRewind(asmManager->tasks, &li);\n while ((ln = listNext(&li)) != NULL) {\n asmTask *task = listNodeValue(ln);\n if (task->operation == operation) return 1;\n }\n return 0;\n}\n\n/* Returns 1 if a migrate task is in progress, 0 otherwise. */\nint asmMigrateInProgress(void) {\n return asmTaskInProgress(ASM_MIGRATE);\n}\n\n/* Returns 1 if an import task is in progress, 0 otherwise. */\nint asmImportInProgress(void) {\n return asmTaskInProgress(ASM_IMPORT);\n}\n\n/* Returns 1 if the task is in a state where it can receive replication stream\n* for the slot range, 0 otherwise. */\ninline static int asmCanFeedMigrationClient(asmTask *task) {\n return task->operation == ASM_MIGRATE &&\n !task->cross_slot_during_propagating &&\n (task->state == ASM_SEND_BULK_AND_STREAM ||\n task->state == ASM_SEND_STREAM ||\n task->state == ASM_HANDOFF_PREP);\n}\n\n/* Feed the migration client with the replication stream for the slot range. */\nvoid asmFeedMigrationClient(robj **argv, int argc) {\n asmTask *task = NULL;\n\n if (server.cluster_enabled == 0 || listLength(asmManager->tasks) == 0)\n return;\n\n /* Check if there is a migrate task that can receive replication stream. */\n task = listNodeValue(listFirst(asmManager->tasks));\n if (!asmCanFeedMigrationClient(task)) return;\n\n /* Ensure all arguments are converted to string encoding if necessary,\n * since getSlotFromCommand expects them to be string-encoded.\n * Generally the arguments are string-encoded, but we may rewrite\n * the command arguments to integer encoding. */\n for (int i = 0; i < argc; i++) {\n if (!sdsEncodedObject(argv[i])) {\n serverAssert(argv[i]->encoding == OBJ_ENCODING_INT);\n robj *old = argv[i];\n argv[i] = createStringObjectFromLongLongWithSds((long)old->ptr);\n decrRefCount(old);\n }\n }\n\n /* Check if the command belongs to the slot range. */\n struct redisCommand *cmd = lookupCommand(argv, argc);\n serverAssert(cmd);\n\n int slot = getSlotFromCommand(cmd, argv, argc);\n\n /* If the command does not have keys, skip it now.\n * SELECT is not propagated, since we only support a single db in cluster mode.\n * MULTI/EXEC is not needed, since transaction semantics are unnecessary\n * before the slot handoff.\n * FUNCTION subcommands should be executed on all nodes, so here we skip it,\n * and even propagating them may cause an error when executing.\n *\n * NOTICE: if some keyless commands should be propagated to the destination,\n * we should identify them here and send. */\n if (slot == INVALID_CLUSTER_SLOT) return;\n\n /* Generally we reject cross-slot commands before executing, but module may\n * replicate this kind of command, so we check again. To guarantee data\n * consistency, we cancel the task if we encounter a cross-slot command. */\n if (slot == CLUSTER_CROSSSLOT) {\n /* We cannot cancel the task directly here, since it may lead to a recursive\n * call: asmTaskCancel() --> moduleFireServerEvent() --> moduleFreeContext()\n * --> postExecutionUnitOperations() --> propagateNow(). Even worse, this\n * could result in propagating pending commands to the replication stream twice.\n * To avoid this, we simply set a flag here, cancel the task in beforeSleep. */\n task->cross_slot_during_propagating = 1;\n return;\n }\n\n /* Check if the slot belongs to the task's slot range. */\n slotRange sr = {slot, slot};\n if (!slotRangeArrayOverlaps(task->slots, &sr)) return;\n\n if (unlikely(asmDebugIsFailPointActive(ASM_MIGRATE_MAIN_CHANNEL, task->state)))\n freeClientAsync(task->main_channel_client);\n\n /* Feed main channel with the command. */\n client *c = task->main_channel_client;\n size_t prev_bytes = getNormalClientPendingReplyBytes(c);\n\n addReplyArrayLen(c, argc);\n for (int i = 0; i < argc; i++)\n addReplyBulk(c, argv[i]);\n\n /* Update the task's source offset to reflect the bytes sent. */\n task->source_offset += (getNormalClientPendingReplyBytes(c) - prev_bytes);\n}\n\nasmTask *asmCreateImportTask(const char *task_id, slotRangeArray *slots, sds *err) {\n clusterNode *source;\n\n *err = NULL;\n /* Validate that the slot ranges are valid and that migration can be\n * initiated for them. */\n source = validateImportSlotRanges(slots, err, NULL);\n if (!source)\n goto err;\n\n if (source == getMyClusterNode()) {\n *err = sdsnew(\"this node is already the owner of the slot range\");\n goto err;\n }\n\n /* Only support a single task at a time now. */\n if (listLength(asmManager->tasks) != 0) {\n asmTask *current = listNodeValue(listFirst(asmManager->tasks));\n if (current->state == ASM_FAILED) {\n /* We can create a new import task only if the current one is failed,\n * cancel the failed task to create a new one. */\n asmTaskCancel(current, \"new import requested\");\n } else {\n *err = sdsnew(\"another ASM task is already in progress\");\n goto err;\n }\n }\n /* There should be no task in progress. */\n serverAssert(listLength(asmManager->tasks) == 0);\n\n /* Create a slot migration task */\n asmTask *task = asmTaskCreate(task_id);\n task->slots = slots;\n task->state = ASM_NONE;\n task->operation = ASM_IMPORT;\n memcpy(task->source, clusterNodeGetName(source), CLUSTER_NAMELEN);\n memcpy(task->dest, getMyClusterId(), CLUSTER_NAMELEN);\n\n listAddNodeTail(asmManager->tasks, task);\n sds slots_str = slotRangeArrayToString(slots);\n serverLog(LL_NOTICE, \"Import task %s created: src=%.40s, dest=%.40s, slots=%s\",\n task->id, task->source, task->dest, slots_str);\n sdsfree(slots_str);\n\n return task;\n\nerr:\n slotRangeArrayFree(slots);\n return NULL;\n}\n\n/* CLUSTER MIGRATION IMPORT \n *\n * Sent by operator to the destination node to start the migration. */\nstatic void clusterMigrationCommandImport(client *c) {\n /* Validate slot range arg count */\n int remaining = c->argc - 3;\n if (remaining == 0 || remaining % 2 != 0) {\n addReplyErrorArity(c);\n return;\n }\n\n slotRangeArray *slots = parseSlotRangesOrReply(c, c->argc, 3);\n if (!slots) return;\n\n sds err = NULL;\n asmTask *task = asmCreateImportTask(NULL, slots, &err);\n if (!task) {\n addReplyErrorSds(c, err);\n return;\n }\n\n addReplyBulkCString(c, task->id);\n}\n\n/* CLUSTER MIGRATION CANCEL [ID | ALL]\n * - Reply: Number of cancelled tasks\n *\n * Cancels import tasks that overlap with the specified slot ranges.\n * Multiple tasks may be cancelled. */\nstatic void clusterMigrationCommandCancel(client *c) {\n sds task_id = NULL;\n int num_cancelled = 0;\n\n /* Validate slot range arg count */\n if (c->argc != 4 && c->argc != 5) {\n addReplyErrorArity(c);\n return;\n }\n\n if (!strcasecmp(c->argv[3]->ptr, \"id\")) {\n if (c->argc != 5) {\n addReplyErrorArity(c);\n return;\n }\n task_id = c->argv[4]->ptr;\n } else if (!strcasecmp(c->argv[3]->ptr, \"all\")) {\n if (c->argc != 4) {\n addReplyErrorArity(c);\n return;\n }\n } else {\n addReplyError(c, \"unknown argument\");\n return;\n }\n\n num_cancelled = clusterAsmCancel(task_id, \"user request\");\n addReplyLongLong(c, num_cancelled);\n}\n\n/* Reply with the status of the task. */\nstatic void replyTaskStatus(client *c, asmTask *task) {\n mstime_t p = 0;\n\n addReplyMapLen(c, 12);\n addReplyBulkCString(c, \"id\");\n addReplyBulkCString(c, task->id);\n addReplyBulkCString(c, \"slots\");\n addReplyBulkSds(c, slotRangeArrayToString(task->slots));\n addReplyBulkCString(c, \"source\");\n addReplyBulkCBuffer(c, task->source, CLUSTER_NAMELEN);\n addReplyBulkCString(c, \"dest\");\n addReplyBulkCBuffer(c, task->dest, CLUSTER_NAMELEN);\n addReplyBulkCString(c, \"operation\");\n addReplyBulkCString(c, task->operation == ASM_IMPORT ? \"import\" : \"migrate\");\n addReplyBulkCString(c, \"state\");\n addReplyBulkCString(c, asmTaskStateToString(task->state));\n addReplyBulkCString(c, \"last_error\");\n addReplyBulkCBuffer(c, task->error, sdslen(task->error));\n addReplyBulkCString(c, \"retries\");\n addReplyLongLong(c, task->retry_count);\n addReplyBulkCString(c, \"create_time\");\n addReplyLongLong(c, task->create_time);\n addReplyBulkCString(c, \"start_time\");\n addReplyLongLong(c, task->start_time);\n addReplyBulkCString(c, \"end_time\");\n addReplyLongLong(c, task->end_time);\n\n if (task->operation == ASM_MIGRATE && task->state == ASM_COMPLETED)\n p = task->end_time - task->paused_time;\n addReplyBulkCString(c, \"write_pause_ms\");\n addReplyLongLong(c, p);\n}\n\n/* CLUSTER MIGRATION STATUS [ID | ALL]\n * - Reply: Array of atomic slot migration tasks */\nstatic void clusterMigrationCommandStatus(client *c) {\n listIter li;\n listNode *ln;\n\n if (c->argc != 4 && c->argc != 5) {\n addReplyErrorArity(c);\n return;\n }\n\n if (!strcasecmp(c->argv[3]->ptr, \"id\")) {\n if (c->argc != 5) {\n addReplyErrorArity(c);\n return;\n }\n sds id = c->argv[4]->ptr;\n asmTask *task = asmLookupTaskAt(asmManager->tasks, id);\n if (!task) task = asmLookupTaskAt(asmManager->archived_tasks, id);\n if (!task) {\n addReplyArrayLen(c, 0);\n return;\n }\n\n addReplyArrayLen(c, 1);\n replyTaskStatus(c, task);\n } else if (!strcasecmp(c->argv[3]->ptr, \"all\")) {\n if (c->argc != 4) {\n addReplyErrorArity(c);\n return;\n }\n addReplyArrayLen(c, listLength(asmManager->tasks) +\n listLength(asmManager->archived_tasks));\n listRewind(asmManager->tasks, &li);\n while ((ln = listNext(&li)) != NULL)\n replyTaskStatus(c, listNodeValue(ln));\n\n listRewind(asmManager->archived_tasks, &li);\n while ((ln = listNext(&li)) != NULL)\n replyTaskStatus(c, listNodeValue(ln));\n } else {\n addReplyError(c, \"unknown argument\");\n return;\n }\n}\n\n/* CLUSTER MIGRATION\n * |\n * STATUS [ID | ALL] |\n * CANCEL [ID | ALL]>\n*/\nvoid clusterMigrationCommand(client *c) {\n if (c->argc < 4) {\n addReplyErrorArity(c);\n return;\n }\n\n if (strcasecmp(c->argv[2]->ptr, \"import\") == 0) {\n clusterMigrationCommandImport(c);\n } else if (strcasecmp(c->argv[2]->ptr, \"status\") == 0) {\n clusterMigrationCommandStatus(c);\n } else if (strcasecmp(c->argv[2]->ptr, \"cancel\") == 0) {\n clusterMigrationCommandCancel(c);\n } else {\n addReplyError(c, \"unknown argument\");\n }\n}\n\n/* Returns the address of the node in the format \"ip:port\". */\nstatic const char *getNodeAddressStr(const char *node_id, int len) {\n serverAssert(node_id != NULL);\n static char buf[NET_HOST_PORT_STR_LEN];\n\n clusterNode *n = clusterLookupNode(node_id, len);\n char *ip = n ? clusterNodeIp(n) : \"?\";\n int port = n ? (server.tls_replication ? clusterNodeTlsPort(n) :\n clusterNodeTcpPort(n)) : 0;\n formatAddr(buf, sizeof(buf), ip, port);\n return buf;\n}\n\n/* Log a human-readable message for ASM task lifecycle events. */\nvoid asmLogTaskEvent(asmTask *task, int event) {\n sds str = slotRangeArrayToString(task->slots);\n\n switch (event) {\n case ASM_EVENT_IMPORT_STARTED:\n serverLog(LL_NOTICE, \"Import task %s started for slots: %s, source address: %s\",\n task->id, str, getNodeAddressStr(task->source, CLUSTER_NAMELEN));\n break;\n case ASM_EVENT_IMPORT_FAILED:\n serverLog(LL_NOTICE, \"Import task %s failed for slots: %s\", task->id, str);\n break;\n case ASM_EVENT_TAKEOVER:\n serverLog(LL_NOTICE, \"Import task %s is ready to takeover slots: %s\", task->id, str);\n break;\n case ASM_EVENT_IMPORT_COMPLETED:\n serverLog(LL_NOTICE, \"Import task %s completed for slots: %s (imported %llu keys)\",\n task->id, str, getKeyCountInSlotRangeArray(task->slots));\n break;\n case ASM_EVENT_MIGRATE_STARTED:\n serverLog(LL_NOTICE, \"Migrate task %s started for slots: %s, destination address: %s, (number of keys at start: %llu)\",\n task->id, str, getNodeAddressStr(task->dest, CLUSTER_NAMELEN), getKeyCountInSlotRangeArray(task->slots));\n break;\n case ASM_EVENT_MIGRATE_FAILED:\n serverLog(LL_NOTICE, \"Migrate task %s failed for slots: %s\", task->id, str);\n break;\n case ASM_EVENT_HANDOFF_PREP:\n serverLog(LL_NOTICE, \"Migrate task %s preparing to handoff for slots: %s\", task->id, str);\n break;\n case ASM_EVENT_MIGRATE_COMPLETED:\n serverLog(LL_NOTICE, \"Migrate task %s completed for slots: %s (migrated %llu keys)\",\n task->id, str, getKeyCountInSlotRangeArray(task->slots));\n break;\n default:\n break;\n }\n\n sdsfree(str);\n}\n\n/* Notify the state change to the module and the cluster implementation. */\nvoid asmNotifyStateChange(asmTask *task, int event) {\n RedisModuleClusterSlotMigrationInfo info = {\n .version = REDISMODULE_CLUSTER_SLOT_MIGRATION_INFO_VERSION,\n .task_id = task->id,\n .slots = (RedisModuleSlotRangeArray *) task->slots\n };\n memcpy(info.source_node_id, task->source, CLUSTER_NAMELEN);\n memcpy(info.destination_node_id, task->dest, CLUSTER_NAMELEN);\n\n int module_event = -1;\n if (event == ASM_EVENT_IMPORT_STARTED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_IMPORT_STARTED;\n else if (event == ASM_EVENT_IMPORT_COMPLETED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_IMPORT_COMPLETED;\n else if (event == ASM_EVENT_IMPORT_FAILED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_IMPORT_FAILED;\n else if (event == ASM_EVENT_MIGRATE_STARTED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_MIGRATE_STARTED;\n else if (event == ASM_EVENT_MIGRATE_COMPLETED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_MIGRATE_COMPLETED;\n else if (event == ASM_EVENT_MIGRATE_FAILED) module_event = REDISMODULE_SUBEVENT_CLUSTER_SLOT_MIGRATION_MIGRATE_FAILED;\n serverAssert(module_event != -1);\n\n moduleFireServerEvent(REDISMODULE_EVENT_CLUSTER_SLOT_MIGRATION, module_event, &info);\n serverLog(LL_DEBUG, \"Fire cluster asm module event, task %s: state=%s\",\n task->id, asmTaskStateToString(task->state));\n\n if (clusterNodeIsMaster(getMyClusterNode())) {\n /* Notify the cluster impl only if it is a real active import task. */\n if (task != asmManager->master_task) {\n asmLogTaskEvent(task, event);\n clusterAsmOnEvent(task->id, event, task->slots);\n }\n asmNotifyReplicasStateChange(task); /* Propagate state change to replicas */\n }\n}\n\nvoid asmImportSetFailed(asmTask *task) {\n serverAssert(task->operation == ASM_IMPORT);\n if (task->state == ASM_FAILED) return;\n\n /* If we are in the RDB channel transfer state, we need to\n * close the client that was created for the RDB channel. */\n if (task->rdb_channel_conn && task->rdb_channel_state == ASM_RDBCHANNEL_TRANSFER) {\n client *c = connGetPrivateData(task->rdb_channel_conn);\n serverAssert(c->task == task);\n task->rdb_channel_conn = NULL;\n c->task = NULL;\n c->flags &= ~CLIENT_MASTER;\n freeClientAsync(c);\n }\n\n /* If in the wait stream EOF or streaming buffer state, we need to close the\n * client that was created for the main channel. */\n if (task->main_channel_conn &&\n (task->state == ASM_STREAMING_BUF || task->state == ASM_WAIT_STREAM_EOF))\n {\n client *c = connGetPrivateData(task->main_channel_conn);\n serverAssert(c->task == task);\n task->main_channel_conn = NULL;\n c->task = NULL;\n c->flags &= ~CLIENT_MASTER;\n freeClientAsync(c);\n }\n\n /* Close the connections */\n if (task->rdb_channel_conn) connClose(task->rdb_channel_conn);\n if (task->main_channel_conn) connClose(task->main_channel_conn);\n task->rdb_channel_conn = NULL;\n task->main_channel_conn = NULL;\n\n /* Clear the replication data buffer */\n asmManager->sync_buffer_peak = max(asmManager->sync_buffer_peak, task->sync_buffer.peak);\n replDataBufClear(&task->sync_buffer);\n\n /* Mark the task as failed and notify the cluster */\n task->state = ASM_FAILED;\n asmNotifyStateChange(task, ASM_EVENT_IMPORT_FAILED);\n /* This node may become replica, only master can setup new slot trimming jobs. */\n if (clusterNodeIsMaster(getMyClusterNode()))\n asmTrimJobSchedule(task->slots);\n}\n\nvoid asmMigrateSetFailed(asmTask *task) {\n serverAssert(task->operation == ASM_MIGRATE);\n if (task->state == ASM_FAILED) return;\n\n /* Close the RDB and main channel clients*/\n if (task->rdb_channel_client) {\n task->rdb_channel_client->task = NULL;\n freeClientAsync(task->rdb_channel_client);\n task->rdb_channel_client = NULL;\n }\n if (task->main_channel_client) {\n task->main_channel_client->task = NULL;\n freeClientAsync(task->main_channel_client);\n task->main_channel_client = NULL;\n }\n\n /* Actually it is not necessary to clear the sync buffer here,\n * to make asmTaskReset work properly after migrate task failed */\n replDataBufClear(&task->sync_buffer);\n\n /* Mark the task as failed and notify the cluster */\n task->state = ASM_FAILED;\n asmNotifyStateChange(task, ASM_EVENT_MIGRATE_FAILED);\n}\n\nvoid asmTaskSetFailed(asmTask *task, const char *fmt, ...) {\n va_list ap;\n sds error = sdsempty();\n\n /* Set the error message */\n va_start(ap, fmt);\n error = sdscatvprintf(error, fmt, ap);\n va_end(ap);\n error = sdscatprintf(error, \" (state: %s, rdb_channel_state: %s)\",\n asmTaskStateToString(task->state),\n asmTaskStateToString(task->rdb_channel_state));\n sdsfree(task->error);\n task->error = error;\n\n /* Log the error */\n sds slots_str = slotRangeArrayToString(task->slots);\n serverLog(LL_WARNING, \"%s task %s failed: slots=%s, err=%s\",\n task->operation == ASM_IMPORT ? \"Import\" : \"Migrate\",\n task->id, slots_str, task->error);\n sdsfree(slots_str);\n\n if (task->operation == ASM_IMPORT)\n asmImportSetFailed(task);\n else\n asmMigrateSetFailed(task);\n}\n\n/* The task is completed or canceled. Update stats and move it to\n * the archived list. */\nvoid asmTaskFinalize(asmTask *task) {\n listNode *ln = listFirst(asmManager->tasks);\n serverAssert(ln->value == task);\n\n task->end_time = server.mstime;\n\n if (task->operation == ASM_IMPORT) {\n asmManager->sync_buffer_peak = max(asmManager->sync_buffer_peak,\n task->sync_buffer.peak);\n replDataBufClear(&task->sync_buffer); /* Not used, so save memory */\n }\n\n /* Move the task to the archived list */\n listUnlinkNode(asmManager->tasks, ln);\n listLinkNodeHead(asmManager->archived_tasks, ln);\n}\n\nstatic void asmTaskCancel(asmTask *task, const char *reason) {\n if (task->state == ASM_CANCELED) return;\n\n asmTaskSetFailed(task, \"Cancelled due to %s\", reason);\n task->state = ASM_CANCELED;\n asmTaskFinalize(task);\n}\n\nvoid asmImportTakeover(asmTask *task) {\n serverAssert(task->state == ASM_WAIT_STREAM_EOF ||\n task->state == ASM_STREAMING_BUF);\n\n if (unlikely(asmDebugIsFailPointActive(ASM_IMPORT_MAIN_CHANNEL, ASM_TAKEOVER))) {\n /* Do not take over slots to test timeout scenario. */\n return;\n }\n\n /* Free the main channel connection since it is no longer needed. */\n serverAssert(task->main_channel_conn != NULL);\n client *c = connGetPrivateData(task->main_channel_conn);\n c->task = NULL;\n c->flags &= ~CLIENT_MASTER;\n freeClientAsync(c);\n task->main_channel_conn = NULL;\n\n task->state = ASM_TAKEOVER;\n asmLogTaskEvent(task, ASM_EVENT_TAKEOVER);\n clusterAsmOnEvent(task->id, ASM_EVENT_TAKEOVER, task->slots);\n}\n\nvoid asmCallbackOnFreeClient(client *c) {\n asmTask *task = c->task;\n if (!task) return;\n\n /* If the RDB channel connection is closed, mark the task as failed. */\n if (c->conn && task->rdb_channel_conn == c->conn) {\n /* We create the client only when transferring data on the RDB channel */\n serverAssert(task->rdb_channel_state == ASM_RDBCHANNEL_TRANSFER);\n task->rdb_channel_conn = NULL; /* Will be freed by freeClient */\n c->flags &= ~CLIENT_MASTER;\n asmTaskSetFailed(task, \"RDB channel - Connection is closed\");\n return;\n }\n\n if (c->conn && task->main_channel_conn == c->conn) {\n /* After or in the process of streaming buffer to DB, a client will be\n * created based on the main channel connection. */\n serverAssert(task->state == ASM_STREAMING_BUF ||\n task->state == ASM_WAIT_STREAM_EOF);\n task->main_channel_conn = NULL; /* Will be freed by freeClient */\n c->flags &= ~CLIENT_MASTER;\n asmTaskSetFailed(task, \"Main channel - Connection is closed\");\n return;\n }\n\n if (c == task->rdb_channel_client) {\n /* TODO: Detect whether the bgsave is completed successfully and\n * update the state properly. */\n task->rdb_channel_state = ASM_COMPLETED;\n /* We may not have detected whether the child process has exited yet,\n * so we can't determine whether the client has completed the slots\n * snapshot transfer. If the RDB channel is interrupted unexpectedly,\n * the destination side will also close the main channel.\n * So here we just reset the RDB channel client of task. */\n task->rdb_channel_client = NULL;\n return;\n }\n\n /* If the main channel client is closed, we need to mark the task as failed\n * and clean up the RDB channel client if it exists. */\n if (c == task->main_channel_client) {\n task->main_channel_client = NULL;\n /* The rdb channel client will be cleaned up */\n asmTaskSetFailed(task, \"Main and RDB channel clients are disconnected.\");\n return;\n }\n}\n\n/* Sends an AUTH command to the source node using the internal secret.\n * Returns an error string if the command fails, or NULL on success. */\nchar *asmSendInternalAuth(connection *conn) {\n size_t len = 0;\n const char *internal_secret = clusterGetSecret(&len);\n serverAssert(internal_secret != NULL);\n\n sds secret = sdsnewlen(internal_secret, len);\n char *err = sendCommand(conn, \"AUTH\", \"internal connection\", secret, NULL);\n sdsfree(secret);\n return err;\n}\n\n/* Handles the RDB channel sync with the source node.\n * This function is called when the RDB channel is established\n * and ready to sync with the source node. */\nvoid asmRdbChannelSyncWithSource(connection *conn) {\n asmTask *task = connGetPrivateData(conn);\n char *err = NULL;\n sds task_error_msg = NULL;\n\n /* Check for errors in the socket: after a non blocking connect() we\n * may find that the socket is in error state. */\n if (connGetState(conn) != CONN_STATE_CONNECTED)\n goto error;\n\n /* Check if the task is in a fail point state */\n if (unlikely(asmDebugIsFailPointActive(ASM_IMPORT_RDB_CHANNEL, task->rdb_channel_state))) {\n char buf[1];\n /* Simulate a failure by shutting down the connection. On some operating\n * systems (e.g. Linux), the socket's receive buffer is not flushed\n * immediately, so we issue a dummy read to drain any pending data and\n * surface the error condition.\n * using shutdown() instead of connShutdown() because connTLSShutdown()\n * will free the connection directly, which is not what we want. */\n shutdown(conn->fd, SHUT_RDWR);\n connRead(conn, buf, 1);\n }\n\n if (task->rdb_channel_state == ASM_CONNECTING) {\n connSetReadHandler(conn, asmRdbChannelSyncWithSource);\n connSetWriteHandler(conn, NULL);\n\n /* Send AUTH command to source node using internal auth */\n err = asmSendInternalAuth(conn);\n if (err) goto write_error;\n task->rdb_channel_state = ASM_AUTH_REPLY;\n return;\n }\n\n if (task->rdb_channel_state == ASM_AUTH_REPLY) {\n err = receiveSynchronousResponse(conn);\n /* The source node did not reply */\n if (err == NULL) goto no_response_error;\n\n /* Check `+OK` reply */\n if (!strcmp(err, \"+OK\")) {\n sdsfree(err);\n err = NULL;\n task->rdb_channel_state = ASM_RDBCHANNEL_REQUEST;\n serverLog(LL_NOTICE, \"Source node replied to AUTH command, syncslots rdb channel operation can continue...\");\n } else {\n task_error_msg = sdscatprintf(sdsempty(),\n \"Error reply to AUTH from source: %s\", err);\n sdsfree(err);\n goto error;\n }\n }\n\n if (task->rdb_channel_state == ASM_RDBCHANNEL_REQUEST) {\n err = sendCommand(conn, \"CLUSTER\", \"SYNCSLOTS\", \"RDBCHANNEL\", task->id, NULL);\n if (err) goto write_error;\n task->rdb_channel_state = ASM_RDBCHANNEL_REPLY;\n return;\n }\n\n if (task->rdb_channel_state == ASM_RDBCHANNEL_REPLY) {\n err = receiveSynchronousResponse(conn);\n /* The source node did not reply */\n if (err == NULL) goto no_response_error;\n\n /* Ignore ‘\\n' sent from the source node to keep the connection alive. */\n if (sdslen(err) == 0) {\n serverLog(LL_DEBUG, \"Received an empty line in RDBCHANNEL reply, slots snapshot delivery will start later\");\n sdsfree(err);\n return;\n }\n\n /* Check `+SLOTSSNAPSHOT` reply */\n if (!strncmp(err, \"+SLOTSSNAPSHOT\", strlen(\"+SLOTSSNAPSHOT\"))) {\n sdsfree(err);\n err = NULL;\n task->state = ASM_ACCUMULATE_BUF;\n /* The main channel buffers pending commands. */\n connSetReadHandler(task->main_channel_conn, asmSyncBufferReadFromConn);\n\n task->rdb_channel_state = ASM_RDBCHANNEL_TRANSFER;\n client *c = createClient(conn);\n c->flags |= (CLIENT_MASTER | CLIENT_INTERNAL | CLIENT_ASM_IMPORTING);\n c->querybuf = sdsempty();\n c->authenticated = 1;\n c->user = NULL;\n c->task = task;\n serverLog(LL_NOTICE,\n \"Source node replied to SLOTSSNAPSHOT, syncing slots snapshot can continue...\");\n } else {\n task_error_msg = sdscatprintf(sdsempty(),\n \"Error reply to CLUSTER SYNCSLOTS RDBCHANNEL from the source: %s\", err);\n sdsfree(err);\n goto error;\n }\n return;\n }\n return;\n\nno_response_error:\n task_error_msg = sdsnew(\"Source node did not respond to command during RDBCHANNELSYNCSLOTS handshake\");\n /* Fall through to regular error handling */\n\nerror:\n asmTaskSetFailed(task, \"RDB channel - Failed to sync with the source node: %s\",\n task_error_msg ? task_error_msg : connGetLastError(conn));\n sdsfree(task_error_msg);\n return;\n\nwrite_error: /* Handle sendCommand() errors. */\n task_error_msg = sdscatprintf(sdsempty(), \"Failed to send command to the source node: %s\", err);\n sdsfree(err);\n goto error;\n}\n\nchar *asmSendSlotRangesSync(connection *conn, asmTask *task) {\n /* Prepare CLUSTER SYNCSLOTS SYNC command */\n serverAssert(task->slots->num_ranges <= CLUSTER_SLOTS);\n int argc = task->slots->num_ranges * 2 + 4;\n char **args = zcalloc(sizeof(char*) * argc);\n size_t *lens = zcalloc(sizeof(size_t) * argc);\n\n args[0] = \"CLUSTER\";\n args[1] = \"SYNCSLOTS\";\n args[2] = \"SYNC\";\n args[3] = task->id;\n lens[0] = strlen(\"CLUSTER\");\n lens[1] = strlen(\"SYNCSLOTS\");\n lens[2] = strlen(\"SYNC\");\n lens[3] = sdslen(task->id);\n\n int i = 4;\n for (int j = 0; j < task->slots->num_ranges; j++) {\n slotRange *sr = &task->slots->ranges[j];\n args[i] = sdscatprintf(sdsempty(), \"%d\", sr->start);\n lens[i] = sdslen(args[i]);\n args[i+1] = sdscatprintf(sdsempty(), \"%d\", sr->end);\n lens[i+1] = sdslen(args[i+1]);\n i += 2;\n }\n serverAssert(i == argc);\n\n /* Send command to source node */\n char *err = sendCommandArgv(conn, argc, args, lens);\n\n /* Free allocated memory */\n for (int j = 4; j < argc; j++) {\n sdsfree(args[j]);\n }\n zfree(args);\n zfree(lens);\n\n return err;\n}\n\nvoid asmSyncWithSource(connection *conn) {\n asmTask *task = connGetPrivateData(conn);\n char *err = NULL;\n\n /* Some task errors are not network issues, we record them explicitly. */\n sds task_error_msg = NULL;\n\n /* Check for errors in the socket: after a non blocking connect() we\n * may find that the socket is in error state. */\n if (connGetState(conn) != CONN_STATE_CONNECTED)\n goto error;\n\n /* Check if the fail point is active for this channel and state */\n if (unlikely(asmDebugIsFailPointActive(ASM_IMPORT_MAIN_CHANNEL, task->state))) {\n char buf[1];\n shutdown(conn->fd, SHUT_RDWR);\n connRead(conn, buf, 1);\n }\n\n if (task->state == ASM_CONNECTING) {\n connSetReadHandler(conn, asmSyncWithSource);\n connSetWriteHandler(conn, NULL);\n /* Send AUTH command to source node using internal auth */\n err = asmSendInternalAuth(conn);\n if (err) goto write_error;\n task->state = ASM_AUTH_REPLY;\n return;\n }\n\n if (task->state == ASM_AUTH_REPLY) {\n err = receiveSynchronousResponse(conn);\n /* The source node did not reply */\n if (err == NULL) goto no_response_error;\n\n /* Check `+OK` reply */\n if (!strcmp(err, \"+OK\")) {\n sdsfree(err);\n err = NULL;\n task->state = ASM_SEND_HANDSHAKE;\n serverLog(LL_NOTICE, \"Source node replied to AUTH command, syncslots can continue...\");\n } else {\n task_error_msg = sdscatprintf(sdsempty(),\n \"Error reply to AUTH from the source: %s\", err);\n sdsfree(err);\n goto error;\n }\n }\n\n if (task->state == ASM_SEND_HANDSHAKE) {\n sds node_id = sdsnewlen(clusterNodeGetName(getMyClusterNode()), CLUSTER_NAMELEN);\n err = sendCommand(conn, \"CLUSTER\", \"SYNCSLOTS\", \"CONF\", \"NODE-ID\", node_id, NULL);\n sdsfree(node_id);\n if (err) goto write_error;\n task->state = ASM_HANDSHAKE_REPLY;\n return;\n }\n\n if (task->state == ASM_HANDSHAKE_REPLY) {\n err = receiveSynchronousResponse(conn);\n /* The source node did not reply */\n if (err == NULL) goto no_response_error;\n\n /* Check `+OK` reply */\n if (!strcmp(err, \"+OK\")) {\n sdsfree(err);\n err = NULL;\n task->state = ASM_SEND_SYNCSLOTS;\n serverLog(LL_NOTICE, \"Source node replied to SYNCSLOTS CONF command, syncslots can continue...\");\n } else {\n task_error_msg = sdscatprintf(sdsempty(),\n \"Error reply to CLUSTER SYNCSLOTS CONF from the source: %s\", err);\n sdsfree(err);\n goto error;\n }\n }\n\n if (task->state == ASM_SEND_SYNCSLOTS) {\n err = asmSendSlotRangesSync(conn, task);\n if (err) goto write_error;\n\n task->state = ASM_SYNCSLOTS_REPLY;\n return;\n }\n\n if (task->state == ASM_SYNCSLOTS_REPLY) {\n err = receiveSynchronousResponse(conn);\n /* The source node did not reply */\n if (err == NULL) goto no_response_error;\n\n /* Check `+RDBCHANNELSYNCSLOTS` reply */\n if (!strncmp(err, \"+RDBCHANNELSYNCSLOTS\", strlen(\"+RDBCHANNELSYNCSLOTS\"))) {\n sdsfree(err);\n err = NULL;\n task->state = ASM_INIT_RDBCHANNEL;\n serverLog(LL_NOTICE,\n \"Source node replied to SYNCSLOTS SYNC, syncslots can continue...\");\n } else if (!strncmp(err, \"-NOTREADY\", strlen(\"-NOTREADY\"))) {\n /* The source-side cluster is temporarily not ready to start a\n * migration and replied -NOTREADY. We could fail this attempt and\n * let the import task start another attempt later but that could\n * trigger unnecessary cleanup in the cluster implementation.\n * Instead, we'll retry sending SYNCSLOTS later in asmCron(). */\n sdsfree(err);\n task->state = ASM_SEND_SYNCSLOTS;\n serverLog(LL_NOTICE,\n \"Source node replied to SYNCSLOTS SYNC with -NOTREADY, will retry later...\");\n return;\n } else {\n task_error_msg = sdscatprintf(sdsempty(),\n \"Error reply to CLUSTER SYNCSLOTS SYNC from the source: %s\", err);\n sdsfree(err);\n goto error;\n }\n }\n\n if (task->state == ASM_INIT_RDBCHANNEL) {\n /* Create RDB channel connection */\n clusterNode *source_node = clusterLookupNode(task->source, CLUSTER_NAMELEN);\n if (!source_node) {\n task_error_msg = sdscatfmt(sdsempty(), \"Source node %.40s was not found\", task->source);\n goto error;\n }\n char *ip = clusterNodeIp(source_node);\n int port = server.tls_replication ? clusterNodeTlsPort(source_node) :\n clusterNodeTcpPort(source_node);\n task->rdb_channel_conn = connCreate(server.el, connTypeOfReplication());\n if (connConnect(task->rdb_channel_conn, ip, port,\n server.bind_source_addr, asmRdbChannelSyncWithSource) == C_ERR)\n {\n serverLog(LL_WARNING, \"Unable to connect to the source node: %s\",\n connGetLastError(task->rdb_channel_conn));\n goto error;\n }\n task->rdb_channel_state = ASM_CONNECTING;\n connSetPrivateData(task->rdb_channel_conn, task);\n serverLog(LL_NOTICE,\n \"RDB channel connection to source node %.40s established, waiting for AUTH reply...\",\n task->source);\n\n /* Main channel waits for the new event */\n connSetReadHandler(conn, NULL);\n return;\n }\n return;\n\nno_response_error:\n serverLog(LL_WARNING, \"Source node did not respond to command during SYNCSLOTS handshake\");\n /* Fall through to regular error handling */\n\nerror:\n asmTaskSetFailed(task, \"Main channel - Failed to sync with source node: %s\",\n task_error_msg ? task_error_msg : connGetLastError(conn));\n sdsfree(task_error_msg);\n return;\n\nwrite_error: /* Handle sendCommand() errors. */\n serverLog(LL_WARNING, \"Failed to send command to source node: %s\", err);\n sdsfree(err);\n goto error;\n}\n\nint asmImportSendACK(asmTask *task) {\n serverAssert(task->operation == ASM_IMPORT && task->state == ASM_WAIT_STREAM_EOF);\n serverLog(LL_DEBUG, \"Destination node applied offset is %lld\", task->dest_offset);\n\n char offset[64];\n ull2string(offset, sizeof(offset), task->dest_offset);\n\n char *err = sendCommand(task->main_channel_conn, \"CLUSTER\", \"SYNCSLOTS\", \"ACK\",\n asmTaskStateToString(task->state), offset, NULL);\n if (err) {\n asmTaskSetFailed(task, \"Main channel - Failed to send ACK: %s\", err);\n sdsfree(err);\n return C_ERR;\n }\n return C_OK;\n}\n\n/* Called when the RDB channel begins sending the snapshot.\n * From this point on, the main channel also starts sending incremental streams. */\nvoid asmSlotSnapshotAndStreamStart(struct asmTask *task) {\n if (task == NULL || task->state != ASM_WAIT_BGSAVE_START) return;\n\n if (unlikely(asmDebugIsFailPointActive(ASM_MIGRATE_RDB_CHANNEL, task->state))) {\n shutdown(task->rdb_channel_client->conn->fd, SHUT_RDWR);\n return;\n }\n task->main_channel_client->replstate = SLAVE_STATE_SEND_BULK_AND_STREAM;\n\n task->state = ASM_SEND_BULK_AND_STREAM;\n task->rdb_channel_state = ASM_RDBCHANNEL_TRANSFER;\n\n /* From the source node's perspective, the destination node begins to accumulate\n * the buffer while the RDB channel starts applying the slot snapshot data. */\n task->dest_state = ASM_ACCUMULATE_BUF;\n task->dest_slots_snapshot_time = server.mstime;\n}\n\n/* Called when the RDB channel has succeeded in sending the snapshot. */\nvoid asmSlotSnapshotSucceed(struct asmTask *task) {\n if (task == NULL || task->state != ASM_SEND_BULK_AND_STREAM) return;\n\n /* The destination starts sending ACKs to keep the main channel alive after\n * receiving the snapshot, so here we need to update the last interaction\n * time to avoid false timeout. */\n task->main_channel_client->lastinteraction = server.unixtime;\n\n task->state = ASM_SEND_STREAM;\n task->rdb_channel_state = ASM_COMPLETED;\n}\n\n/* Called when the RDB channel fails to send the snapshot. */\nvoid asmSlotSnapshotFailed(struct asmTask *task) {\n if (task == NULL || task->state != ASM_SEND_BULK_AND_STREAM) return;\n\n asmTaskSetFailed(task, \"RDB channel - Failed to send slots snapshot\");\n}\n\n/* CLUSTER SYNCSLOTS SNAPSHOT-EOF\n *\n * This command is sent by the source node to the destination node to indicate\n * that the slots snapshot has ended. */\nvoid clusterSyncSlotsSnapshotEOF(client *c) {\n /* This client is RDB channel connection. */\n asmTask *task = c->task;\n if (!task || task->rdb_channel_state != ASM_RDBCHANNEL_TRANSFER ||\n c->conn != task->rdb_channel_conn)\n {\n /* Unexpected SNAPSHOT-EOF command */\n serverLog(LL_WARNING, \"Unexpected CLUSTER SYNCSLOTS SNAPSHOT-EOF command: \"\n \"rdb_channel_state=%s\",\n asmTaskStateToString(task ? task->rdb_channel_state : ASM_NONE));\n freeClientAsync(c);\n return;\n }\n\n /* RDB channel state: ASM_RDBCHANNEL_TRANSFER */\n if (unlikely(asmDebugIsFailPointActive(ASM_IMPORT_RDB_CHANNEL, task->rdb_channel_state))) {\n freeClientAsync(c); /* Simulate a failure */\n return;\n }\n\n /* Clear the RDB channel connection */\n task->rdb_channel_conn = NULL;\n task->rdb_channel_state = ASM_COMPLETED;\n serverLog(LL_NOTICE, \"RDB channel snapshot transfer completed for the import task.\");\n\n /* Free the RDB channel connection. */\n c->task = NULL;\n c->flags &= ~CLIENT_MASTER;\n freeClientAsync(c);\n\n /* Will start streaming the buffer to DB, don't start here since now\n * we are in the context of executing command, otherwise, redis will\n * generate a big MULTI-EXEC including all the commands in the buffer.\n * just update the state here, and do it in beforeSleep(). */\n task->state = ASM_READY_TO_STREAM;\n connSetReadHandler(task->main_channel_conn, NULL);\n}\n\n/* CLUSTER SYNCSLOTS STREAM-EOF\n *\n * This command is sent by the source node to the destination node to indicate\n * that the slot sync stream has ended and the slots can be handed off. */\nvoid clusterSyncSlotsStreamEOF(client *c) {\n asmTask *task = c->task;\n\n if (!task || task->operation != ASM_IMPORT) {\n serverLog(LL_WARNING, \"Unexpected CLUSTER SYNCSLOTS STREAM-EOF command\");\n freeClientAsync(c);\n return;\n }\n\n if (task->state == ASM_STREAMING_BUF) {\n /* We are still streaming the buffer to DB, mark the EOF received, and we\n * can take over after streaming is EOF. Since we may release the context\n * in asmImportTakeover, this breaks the context for streaming buffer. */\n task->stream_eof_during_streaming = 1;\n serverLog(LL_NOTICE, \"CLUSTER SYNCSLOTS STREAM-EOF received during streaming buffer\");\n return;\n }\n\n if (task->state != ASM_WAIT_STREAM_EOF) {\n serverLog(LL_WARNING, \"Unexpected CLUSTER SYNCSLOTS STREAM-EOF state: %s\",\n asmTaskStateToString(task->state));\n freeClientAsync(c);\n return;\n }\n serverLog(LL_NOTICE, \"CLUSTER SYNCSLOTS STREAM-EOF received when waiting for STREAM-EOF\");\n\n /* STREAM-EOF received, the source is ready to handoff, takeover now. */\n asmImportTakeover(task);\n}\n\n/* Start the import task. */\nstatic void asmStartImportTask(asmTask *task) {\n if (task->operation != ASM_IMPORT || task->state != ASM_NONE) return;\n sds slots_str = slotRangeArrayToString(task->slots);\n\n /* Sanity check: Clean up any keys that exist in slots not owned by this node.\n * This handles cases where users previously migrated slots using legacy method\n * but left behind orphaned keys, or maybe cluster missed cleaning up during\n * previous operations, which could interfere with the ASM import process. */\n asmTrimSlotsIfNotOwned(task->slots);\n\n /* Check if there is any trim job in progress for the slot ranges.\n * We can't start the import task since the trim job will modify the data.*/\n int trim_in_progress = asmIsAnyTrimJobOverlaps(task->slots);\n\n /* Notify the cluster implementation to prepare for the import task. */\n int impl_ret = clusterAsmOnEvent(task->id, ASM_EVENT_IMPORT_PREP, task->slots);\n\n /* We do not start the import task if trim is disabled by module. */\n int disabled_by_module = server.cluster_module_trim_disablers > 0;\n\n static int start_blocked_logged = 0;\n /* Cannot start import task since pause action is performed. Otherwise, we\n * will break the promise that no writes are performed during the pause. */\n if (isPausedActions(PAUSE_ACTION_CLIENT_ALL) ||\n isPausedActions(PAUSE_ACTION_CLIENT_WRITE) ||\n trim_in_progress ||\n impl_ret != C_OK ||\n disabled_by_module)\n {\n const char *reason = disabled_by_module ? \"trim is disabled by module\" :\n impl_ret != C_OK ? \"cluster is not ready\" :\n trim_in_progress ? \"trim in progress for some of the slots\" :\n \"server paused\";\n if (start_blocked_logged == 0) {\n serverLog(LL_WARNING, \"Can not start import task %s for slots: %s due to %s\",\n task->id, slots_str, reason);\n start_blocked_logged = 1;\n }\n sdsfree(slots_str);\n return;\n }\n start_blocked_logged = 0; /* Reset the log flag */\n\n /* Detect if the cluster topology is changed. We should cancel the task if\n * we can not schedule it, and update the source node if needed. */\n sds err = NULL;\n clusterNode *source = validateImportSlotRanges(task->slots, &err, task);\n if (!source) {\n asmTaskCancel(task, err);\n sdsfree(slots_str);\n sdsfree(err);\n return;\n }\n /* Now I'm the owner of the slot range, cancel the import task. */\n if (source == getMyClusterNode()) {\n asmTaskCancel(task, \"slots owned by myself now\");\n sdsfree(slots_str);\n return;\n }\n /* Change the source node if needed. */\n if (memcmp(task->source, clusterNodeGetName(source), CLUSTER_NAMELEN)) {\n memcpy(task->source, clusterNodeGetName(source), CLUSTER_NAMELEN);\n serverLog(LL_NOTICE, \"Import task %s source node changed: slots=%s, \"\n \"new_source=%.40s\", task->id, slots_str, clusterNodeGetName(source));\n }\n sdsfree(slots_str);\n\n task->state = ASM_CONNECTING;\n task->start_time = server.mstime;\n asmNotifyStateChange(task, ASM_EVENT_IMPORT_STARTED);\n\n task->main_channel_conn = connCreate(server.el, connTypeOfReplication());\n char *ip = clusterNodeIp(source);\n int port = server.tls_replication ? clusterNodeTlsPort(source) :\n clusterNodeTcpPort(source);\n if (connConnect(task->main_channel_conn, ip, port, server.bind_source_addr,\n asmSyncWithSource) == C_ERR)\n {\n asmTaskSetFailed(task, \"Main channel - Failed to connect to source node: %s\",\n connGetLastError(task->main_channel_conn));\n return;\n }\n connSetPrivateData(task->main_channel_conn, task);\n}\n\nvoid clusterSyncSlotsCommand(client *c) {\n /* Only internal clients are allowed to execute this command to avoid\n * potential attack, since some state changes are not well protected,\n * external clients may damage the slot migration state. */\n if (!(c->flags & (CLIENT_INTERNAL | CLIENT_MASTER))) {\n addReplyError(c, \"CLUSTER SYNCSLOTS subcommands are only allowed for internal clients\");\n c->flags |= CLIENT_CLOSE_AFTER_REPLY;\n return;\n }\n\n /* On replica, only allow master client to execute CONF subcommand. */\n if (!clusterNodeIsMaster(getMyClusterNode())) {\n if (!(c->flags & CLIENT_MASTER)) {\n /* Not master client, reject all subcommands and close the connection. */\n addReplyError(c, \"CLUSTER SYNCSLOTS subcommands are only allowed for master\");\n c->flags |= CLIENT_CLOSE_AFTER_REPLY;\n return;\n } else {\n /* Only allow CONF subcommand on replica. */\n if (strcasecmp(c->argv[2]->ptr, \"conf\")) return;\n }\n }\n\n if (!strcasecmp(c->argv[2]->ptr, \"sync\") && c->argc >= 6) {\n /* CLUSTER SYNCSLOTS SYNC [ ] */\n if (c->argc % 2 == 1) {\n addReplyErrorArity(c);\n return;\n }\n\n slotRangeArray *slots = parseSlotRangesOrReply(c, c->argc, 4);\n if (!slots) return;\n\n /* Validate that the slot ranges are valid and that migration can be\n * initiated for them. */\n sds err = NULL;\n clusterNode *source = validateImportSlotRanges(slots, &err, NULL);\n if (!source) {\n addReplyErrorSds(c, err);\n slotRangeArrayFree(slots);\n return;\n }\n\n /* Check if the source node is the same as the current node. */\n if (source != getMyClusterNode()) {\n addReplyError(c, \"This node is not the owner of the slots\");\n slotRangeArrayFree(slots);\n return;\n }\n\n /* Verify the destination node is known and is a master. */\n if (c->node_id) {\n clusterNode *dest = clusterLookupNode(c->node_id, CLUSTER_NAMELEN);\n if (dest == NULL || !clusterNodeIsMaster(dest)) {\n addReplyErrorFormat(c, \"Destination node %.40s is not a master\", c->node_id);\n slotRangeArrayFree(slots);\n return;\n }\n }\n\n /* Check if there is any trim job in progress for the slot ranges.\n * We can't start the migrate task since the trim job will modify the data.*/\n if (asmIsAnyTrimJobOverlaps(slots)) {\n addReplyError(c, \"Trim job in progress for the slots\");\n slotRangeArrayFree(slots);\n return;\n }\n\n sds task_id = c->argv[3]->ptr;\n /* Notify the cluster implementation to prepare for the migrate task. */\n if (clusterAsmOnEvent(task_id, ASM_EVENT_MIGRATE_PREP, slots) != C_OK ||\n asmDebugIsFailPointActive(ASM_MIGRATE_MAIN_CHANNEL, ASM_NONE))\n {\n addReplyError(c, \"-NOTREADY Cluster is not ready to migrate slots\");\n slotRangeArrayFree(slots);\n return;\n }\n\n /* We do not start the migrate task if trim is disabled by module. */\n int disabled_by_module = server.cluster_module_trim_disablers > 0;\n if (disabled_by_module) {\n addReplyError(c, \"Trim is disabled by module\");\n slotRangeArrayFree(slots);\n return;\n }\n\n asmTask *task = listLength(asmManager->tasks) == 0 ? NULL :\n listNodeValue(listFirst(asmManager->tasks));\n if (task && !strcmp(task->id, task_id) &&\n task->operation == ASM_MIGRATE && task->state == ASM_FAILED &&\n slotRangeArrayIsEqual(slots, task->slots) &&\n memcmp(task->dest, c->node_id, CLUSTER_NAMELEN) == 0)\n {\n /* Reuse the failed task */\n asmTaskReset(task);\n slotRangeArrayFree(task->slots); /* Will be set again later */\n task->retry_count++;\n } else if (task) {\n if (task->state == ASM_FAILED) {\n /* We can create a new migrate task only if the current one is\n * failed, cancel the failed task to create a new one. */\n asmTaskCancel(task, \"new migration requested\");\n task = NULL;\n } else {\n addReplyError(c, \"Another ASM task is already in progress\");\n slotRangeArrayFree(slots);\n return;\n }\n }\n\n /* Create the migrate slots task and add it to the list,\n * otherwise reuse the existing one */\n if (task == NULL) {\n task = asmTaskCreate(task_id);\n task->start_time = server.mstime; /* Start immediately */\n serverAssert(listLength(asmManager->tasks) == 0);\n listAddNodeTail(asmManager->tasks, task);\n }\n\n task->slots = slots;\n task->operation = ASM_MIGRATE;\n memcpy(task->source, clusterNodeGetName(getMyClusterNode()), CLUSTER_NAMELEN);\n if (c->node_id) memcpy(task->dest, c->node_id, CLUSTER_NAMELEN);\n\n task->main_channel_client = c;\n c->task = task;\n\n /* We mark the main channel client as a replica, so this client is limited\n * by the client output buffer settings for replicas. The replstate has\n * no real significance, just to prevent it from going online. */\n c->flags |= (CLIENT_SLAVE | CLIENT_ASM_MIGRATING);\n c->replstate = SLAVE_STATE_WAIT_RDB_CHANNEL;\n if (server.repl_disable_tcp_nodelay)\n connDisableTcpNoDelay(c->conn); /* Non-critical if it fails. */\n listAddNodeTail(server.slaves, c);\n createReplicationBacklogIfNeeded();\n\n /* Wait for RDB channel to be ready */\n task->state = ASM_WAIT_RDBCHANNEL;\n\n sds slots_str = slotRangeArrayToString(slots);\n serverLog(LL_NOTICE, \"Migrate task %s created: src=%.40s, dest=%.40s, slots=%s\",\n task->id, task->source, task->dest, slots_str);\n sdsfree(slots_str);\n\n asmNotifyStateChange(task, ASM_EVENT_MIGRATE_STARTED);\n\n /* Keep the client in the main thread to avoid data races between the\n * connWrite call below and the client's event handler in IO threads. */\n if (c->tid != IOTHREAD_MAIN_THREAD_ID) keepClientInMainThread(c);\n\n /* addReply*() is not suitable for clients in SLAVE_STATE_WAIT_RDB_CHANNEL state. */\n if (connWrite(c->conn, \"+RDBCHANNELSYNCSLOTS\\r\\n\", 22) != 22)\n freeClientAsync(c);\n } else if (!strcasecmp(c->argv[2]->ptr, \"rdbchannel\") && c->argc == 4) {\n /* CLUSTER SYNCSLOTS RDBCHANNEL */\n sds task_id = c->argv[3]->ptr;\n if (sdslen(task_id) != CLUSTER_NAMELEN) {\n addReplyError(c, \"Invalid task id\");\n return;\n }\n\n if (listLength(asmManager->tasks) == 0) {\n addReplyError(c, \"No slot migration task in progress\");\n return;\n }\n\n asmTask *task = listNodeValue(listFirst(asmManager->tasks));\n if (task->operation != ASM_MIGRATE || task->state != ASM_WAIT_RDBCHANNEL ||\n strcmp(task->id, task_id) != 0)\n {\n addReplyError(c, \"Another migration task is already in progress\");\n return;\n }\n\n if (unlikely(asmDebugIsFailPointActive(ASM_MIGRATE_MAIN_CHANNEL, task->state))) {\n /* Close the main channel client before rdb channel client connects */\n if (task->main_channel_client)\n freeClient(task->main_channel_client);\n }\n\n /* The main channel client must be present when setting RDB channel client */\n if (task->main_channel_client == NULL) {\n /* Maybe the main channel connection is closed. */\n addReplyError(c, \"Main channel connection is not established\");\n return;\n }\n\n /* Mark the client as a slave to generate slots snapshot */\n c->flags |= (CLIENT_SLAVE | CLIENT_REPL_RDB_CHANNEL | CLIENT_REPL_RDBONLY | CLIENT_ASM_MIGRATING);\n c->slave_capa |= SLAVE_CAPA_EOF;\n c->slave_req |= (SLAVE_REQ_SLOTS_SNAPSHOT | SLAVE_REQ_RDB_CHANNEL);\n c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;\n c->repldbfd = -1;\n if (server.repl_disable_tcp_nodelay)\n connDisableTcpNoDelay(c->conn); /* Non-critical if it fails. */\n listAddNodeTail(server.slaves, c);\n\n /* Wait for bgsave to start for slots sync */\n task->state = ASM_WAIT_BGSAVE_START;\n task->rdb_channel_state = ASM_WAIT_BGSAVE_START;\n task->rdb_channel_client = c;\n c->task = task;\n\n /* Keep the client in the main thread to avoid data races between the\n * connWrite call in startBgsaveForReplication and the client's event\n * handler in IO threads. */\n if (c->tid != IOTHREAD_MAIN_THREAD_ID) keepClientInMainThread(c);\n\n if (!hasActiveChildProcess()) {\n startBgsaveForReplication(c->slave_capa, c->slave_req);\n } else {\n serverLog(LL_NOTICE, \"BGSAVE for slots snapshot sync delayed\");\n }\n } else if (!strcasecmp(c->argv[2]->ptr, \"snapshot-eof\") && c->argc == 3) {\n /* CLUSTER SYNCSLOTS SNAPSHOT-EOF */\n clusterSyncSlotsSnapshotEOF(c);\n } else if (!strcasecmp(c->argv[2]->ptr, \"stream-eof\") && c->argc == 3) {\n /* CLUSTER SYNCSLOTS STREAM-EOF */\n clusterSyncSlotsStreamEOF(c);\n } else if (!strcasecmp(c->argv[2]->ptr, \"ack\") && c->argc == 5) {\n /* CLUSTER SYNCSLOTS ACK */\n long long offset;\n int dest_state;\n\n if (!strcasecmp(c->argv[3]->ptr, asmTaskStateToString(ASM_STREAMING_BUF))) {\n dest_state = ASM_STREAMING_BUF;\n } else if (!strcasecmp(c->argv[3]->ptr, asmTaskStateToString(ASM_WAIT_STREAM_EOF))) {\n dest_state = ASM_WAIT_STREAM_EOF;\n } else {\n return; /* Not support now. */\n }\n\n if ((getLongLongFromObject(c->argv[4], &offset) != C_OK))\n return;\n\n if (c->task && c->task->operation == ASM_MIGRATE) {\n /* Update the state and ACKed offset from destination. */\n asmTask *task = c->task;\n task->dest_state = dest_state;\n if (task->dest_offset > (unsigned long long) offset) {\n serverLog(LL_WARNING, \"CLUSTER SYNCSLOTS ACK received, dest state: %s, \"\n \"but offset %lld is less than the current dest offset %lld\",\n asmTaskStateToString(dest_state), offset, task->dest_offset);\n return;\n }\n task->dest_offset = offset;\n /* Detailed ACK progress log (for debugging handoff/drain issues). */\n serverLog(LL_DEBUG, \"CLUSTER SYNCSLOTS ACK received, dest state: %s, \"\n \"updated dest offset to %lld, source offset: %lld\",\n asmTaskStateToString(dest_state), task->dest_offset, task->source_offset);\n\n /* Record the time when the destination finishes applying the accumulated buffer */\n if (task->dest_state == ASM_WAIT_STREAM_EOF && task->dest_accum_applied_time == 0)\n task->dest_accum_applied_time = server.mstime;\n\n /* Pause write if needed */\n if (task->state == ASM_SEND_BULK_AND_STREAM || task->state == ASM_SEND_STREAM) {\n /* Pause writes on the main channel if the lag is less than the threshold. */\n if (task->dest_offset + server.asm_handoff_max_lag_bytes >= task->source_offset) {\n if (unlikely(asmDebugIsFailPointActive(ASM_MIGRATE_MAIN_CHANNEL, ASM_HANDOFF_PREP)))\n return; /* Do not enter handoff prep state for testing buffer drain timeout. */\n\n serverLog(LL_NOTICE, \"The applied offset lag %lld is less than the threshold %lld, \"\n \"pausing writes for slot handoff\",\n task->source_offset - task->dest_offset,\n server.asm_handoff_max_lag_bytes);\n task->state = ASM_HANDOFF_PREP;\n asmLogTaskEvent(task, ASM_EVENT_HANDOFF_PREP);\n clusterAsmOnEvent(task->id, ASM_EVENT_HANDOFF_PREP, task->slots);\n }\n }\n }\n } else if (!strcasecmp(c->argv[2]->ptr, \"fail\") && c->argc == 4) {\n /* CLUSTER SYNCSLOTS FAIL */\n return; /* This is a no-op, just to handle the command syntax. */\n } else if (!strcasecmp(c->argv[2]->ptr, \"conf\") && c->argc >= 5) {\n /* CLUSTER SYNCSLOTS CONF