├── .github ├── dependabot.yml └── workflows │ ├── benchmark.yml │ ├── build_and_release.yml │ └── lint.yml ├── .gitignore ├── AUTHORS.google-crc32c ├── CHANGELOG.md ├── LICENSE ├── LICENSE.google-crc32c ├── LICENSE.slice-by-8 ├── MANIFEST.in ├── README.rst ├── pyproject.toml ├── run-tests.py ├── setup.py ├── src └── crc32c │ ├── __init__.py │ ├── _crc32c.pyi │ ├── _crc32hash.py │ ├── benchmark.py │ ├── ext │ ├── _crc32c.c │ ├── checkarm.c │ ├── checkarm.h │ ├── checksse42.c │ ├── checksse42.h │ ├── common.h │ ├── crc32c.h │ ├── crc32c_adler.c │ ├── crc32c_arm64.c │ └── crc32c_sw.c │ └── py.typed └── test ├── conftest.py ├── test_benchmark.py ├── test_crc32c.py └── test_subinterpreter.py /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: "github-actions" 4 | directory: "/" 5 | schedule: 6 | interval: "weekly" 7 | -------------------------------------------------------------------------------- /.github/workflows/benchmark.yml: -------------------------------------------------------------------------------- 1 | name: Run benchmarking tool 2 | 3 | # Build on every branch push, tag push, and pull request change: 4 | on: 5 | push: 6 | pull_request: 7 | 8 | jobs: 9 | run_benchmark: 10 | name: Benchmark os=${{ matrix.os }}/sw_mode=${{ matrix.sw_mode}} 11 | runs-on: ${{ matrix.os }} 12 | strategy: 13 | matrix: 14 | os: [ubuntu-22.04, windows-2025, macos-14] 15 | sw_mode: [force, auto] 16 | 17 | steps: 18 | - uses: actions/checkout@v4 19 | 20 | - uses: actions/setup-python@v5 21 | name: Install Python 22 | with: 23 | python-version: '3.13' 24 | 25 | - name: Install tox-uv 26 | run: pip install tox-uv 27 | 28 | - name: Benchmark with 1 [GB] 10 times 29 | env: 30 | CRC32C_SW_MODE: ${{ matrix.sw_mode }} 31 | run: tox -e benchmark -- -i 10 -s 1073741824 32 | -------------------------------------------------------------------------------- /.github/workflows/build_and_release.yml: -------------------------------------------------------------------------------- 1 | name: Build and release to PyPI 2 | 3 | # Build on every branch push, tag push, and pull request change: 4 | on: 5 | push: 6 | pull_request: 7 | schedule: 8 | # 00:00 UTC every Saturday, don't bother anyone 9 | - cron: '0 0 * * 6' 10 | 11 | jobs: 12 | build_wheels: 13 | name: Build wheels on ${{matrix.arch}} for ${{ matrix.os }} 14 | runs-on: ${{ matrix.os }} 15 | strategy: 16 | matrix: 17 | os: [ubuntu-22.04, windows-2025, macos-14] 18 | arch: [auto] 19 | include: 20 | - os: ubuntu-22.04 21 | arch: aarch64 22 | 23 | steps: 24 | - uses: actions/checkout@v4 25 | 26 | - uses: docker/setup-qemu-action@v3 27 | if: ${{ matrix.arch == 'aarch64' }} 28 | name: Set up QEMU 29 | - name: Run cibuildwheel 30 | uses: pypa/cibuildwheel@v2.23.3 31 | env: 32 | CIBW_ARCHS_LINUX: ${{matrix.arch}} 33 | CIBW_TEST_REQUIRES: pytest 34 | CIBW_TEST_COMMAND: "python -u {project}/run-tests.py" 35 | CIBW_ARCHS_MACOS: "x86_64 arm64 universal2" 36 | CIBW_TEST_SKIP: '*macosx_arm64 *universal2:arm64' 37 | CIBW_BUILD_VERBOSITY: 1 38 | CIBW_ENABLE: pypy cpython-freethreading 39 | - uses: actions/upload-artifact@v4 40 | with: 41 | name: wheels-${{ matrix.os }}-${{ matrix.arch }} 42 | path: ./wheelhouse/*.whl 43 | 44 | build_sdist: 45 | name: Build source distribution 46 | runs-on: ubuntu-22.04 47 | steps: 48 | - uses: actions/checkout@v4 49 | 50 | - uses: actions/setup-python@v5 51 | name: Install Python 52 | with: 53 | python-version: '3.13' 54 | 55 | - name: Install build 56 | run: pip install build 57 | 58 | - name: Build sdist 59 | run: python -m build -s 60 | 61 | - uses: actions/upload-artifact@v4 62 | with: 63 | name: source-dist 64 | path: dist/*.tar.gz 65 | 66 | merge_artifacts: 67 | needs: [build_wheels, build_sdist] 68 | runs-on: ubuntu-latest 69 | steps: 70 | - name: Merge Artifacts 71 | uses: actions/upload-artifact/merge@v4 72 | with: 73 | name: all-artifacts 74 | 75 | 76 | upload_pypi: 77 | needs: [merge_artifacts] 78 | runs-on: ubuntu-22.04 79 | # upload to PyPI on every tag starting with 'v' 80 | if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v') 81 | steps: 82 | - uses: actions/download-artifact@v4 83 | with: 84 | name: all-artifacts 85 | path: dist 86 | 87 | - uses: pypa/gh-action-pypi-publish@master 88 | with: 89 | user: __token__ 90 | password: ${{ secrets.pypi_password }} 91 | -------------------------------------------------------------------------------- /.github/workflows/lint.yml: -------------------------------------------------------------------------------- 1 | name: Lint 2 | 3 | on: 4 | push: 5 | pull_request: 6 | schedule: 7 | # 00:00 UTC every Saturday, don't bother anyone 8 | - cron: '0 0 * * 6' 9 | 10 | jobs: 11 | Linting: 12 | runs-on: ubuntu-latest 13 | steps: 14 | - name: Setup Python 15 | uses: actions/setup-python@v4 16 | with: 17 | python-version: 3.13 18 | architecture: x64 19 | - name: Checkout 20 | uses: actions/checkout@v3 21 | - name: Install tox-uv 22 | run: pip install tox-uv 23 | - name: Run linting steps 24 | run: tox -e lint 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.so 2 | build 3 | dist 4 | *.egg-info 5 | .project 6 | .pydevproject 7 | .settings 8 | *.pyc 9 | -------------------------------------------------------------------------------- /AUTHORS.google-crc32c: -------------------------------------------------------------------------------- 1 | # This is the list of Google's CRC32C authors for copyright purposes. 2 | # 3 | # This does not necessarily list everyone who has contributed code, since in 4 | # some cases, their employer may be the copyright holder. To see the full list 5 | # of contributors, see the revision history in source control. 6 | Google Inc. 7 | 8 | Fangming Fang 9 | Vadim Skipin 10 | Rodrigo Tobar 11 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | ## Development 4 | 5 | * Use `pyproject.toml` to declare project metadata and configuration. 6 | This includes its build system (setuptools), 7 | moving most static content from `setup.py` to `pyproject.toml`, 8 | and moving the `pytest` configuration out from `pytest.ini` too. 9 | * Introduced `tox` as a job runner for development activities, 10 | good to use with `tox-uv` for easy multi-python testing. 11 | 12 | ## [2.7.1] 13 | 14 | * Actually advertise that our C extension supports 15 | sub-interpreters, and per-GIL ones for that matter. 16 | 17 | ## [2.7.post1] 18 | 19 | * Added missing test files to source distribution (#59). 20 | 21 | ## [2.7.post0] 22 | 23 | * Fixed generation of source distribution (#58). 24 | 25 | ## [2.7] 26 | 27 | * Added a `gil_relese_mode` parameter to the `CRC32CHash` constructor 28 | used by all underlying `crc32c` function calls (#51). 29 | * Added support for free-threaded Python builds, 30 | declaring that our C extension doesn't need the GIL. 31 | In free-threaded builds the `gil_release_mode` parameter doesn't have any effect. 32 | * Added `CRC32CHash.checksum` auxiliary property. 33 | * Added new ``crc32c.benchmark`` utility for simple benchmarking. 34 | * The ``crc32c`` module doesn't fail to import when ``CRC32C_SW_MODE`` is ``none`` 35 | and no hardware acceleration is found, 36 | making the act of importing the module less ackward. 37 | Now a ``RuntimeWarning`` is issued at import time instead, 38 | and a``RuntimeError`` is raised any time 39 | a checksum calculation is attempted. 40 | * Improved support in the C extension for Python sub-interpreters 41 | by keeping all global state on a per-module basis, 42 | and performing multi-phase initialisation as per PEP-489. 43 | * Skip hardware probing if the `CRC32C_SKIP_HW_PROBE` environment variable 44 | is set to `1`. 45 | * Cleaned up wheel generation so it doesn't include 46 | C extension sources after changes introduced in 2.5. 47 | 48 | ## [2.6] 49 | 50 | * Added new `crc32c.CRC32CHash` class 51 | modelled after the stdlib `hashlib` hash objects. 52 | * Drop support for Python < 3.7. 53 | 54 | ## [2.5] 55 | 56 | * Made this package PEP 561 compliant (#49). 57 | * Release GIL during the computation of the CRC32C hash. A new `gil_release_mode` argument lets users choose between always/never/automatically releasing it (#47). 58 | * Add keyword support to `crc32c` function (`crc32c(data, value=0, gil_release_mode=-1)`). 59 | * Turned ``crc32c`` from a module-only distribution into a package, 60 | and moves all sources under `src`. 61 | * Adding explicit fallthrough annotations 62 | in several ``switch`` C statements 63 | for clarity, and to avoid potential warnings (#46). 64 | * Run test against different memory alignments. 65 | * Mention explicit support for Python 3.13. 66 | * Drop support for Python 2.7. 67 | 68 | ## [2.4.1] 69 | 70 | * Fixed failure on big-endian, signed ``char`` platforms 71 | (found in SPARC, but there might be more) 72 | due to an incorrect (and unnecessary) cast 73 | from ``unsigned char *`` to ``char *`` (#43). 74 | 75 | ## [2.4] 76 | 77 | * Changed package compilation under gcc/clang 78 | to use compiler extensions to build hardware-specific functions 79 | instead of command-line options 80 | for improved portability (#31). 81 | 82 | ## [2.3.post0] 83 | 84 | * Mention explicit support for Python 3.11. 85 | * Re-generating wheels to get 3.11 versions. 86 | 87 | ## [2.3] 88 | 89 | * Improved macro definition logic and platform detection 90 | to enable building ``universal2`` binary wheels for macOS, 91 | alongside ``arm64`` and ``x86_64`` ones; 92 | added step to GitHub Actions to generate and publish them (#28). 93 | * Mention explicit support for Python 3.10. 94 | * Fixed minor compilation warning in ARM64 builds. 95 | 96 | ## [2.2.post0] 97 | 98 | * Updated GitHub Actions 99 | to produce ARM64 Linux binary wheels 100 | and publish them to PyPI. 101 | * Removed Windows python 2.7 binary wheels. 102 | There are two reasons: 103 | cibuildwheels has removed such support, 104 | our Windows user base is < %5, 105 | and our Python 2.7 user base is also < %5. 106 | 107 | ## [2.2] 108 | 109 | * Fixed software algorithm implementation 110 | to work on big endian machines (#22). 111 | Now the algorithm works correctly, 112 | with numerical (uint32_t) values 113 | still representing the correct checksum. 114 | * Added a new ``big_endian`` attribute 115 | that indicates if the currently platform 116 | is big endian or not. 117 | * Fixed compilation issues in some ARM Linux boxes (#21). 118 | 119 | ## [2.1] 120 | 121 | * Initial hardware-based implementation 122 | on ARMv8 machines (#11). 123 | * Add hardware-based implementation 124 | on x86 32bit machines. 125 | The C code was already there, 126 | but we did not include it for this architecture. 127 | As a result, 128 | 32-bit x86 wheels should run faster now. 129 | * Deprecated the ``crc32`` function 130 | in favour of the new ``crc32c`` function, 131 | which apart from the new, better name 132 | has no other changes. 133 | * Fixed minor warning. 134 | 135 | ## [2.0.1] 136 | 137 | * Changed binary distribution generation strategy, 138 | moving from a local+Travis+AppVeyor setup 139 | to a unified script using GitHub Actions. 140 | * Fixed generation of source distribution 141 | (two C source code files were missing from the tarball). 142 | This bug was introduced in 1.6, 143 | but the source code distributions found in PyPI 144 | were not affected 145 | because the environment where they were created 146 | predates the bug, 147 | and already contained references to the two missing files. 148 | 149 | ## [2.0] 150 | 151 | * Changed package import logic (#12). 152 | Instead of failing to import 153 | if hardware support is not found, 154 | the package now automatically falls back 155 | to using the software implementation, 156 | and thus can always be imported. 157 | Old behavior can still be obtained 158 | by setting ``CRC32C_SW_MODE`` to ``none``. 159 | * Fixed cross-compilation support (#10). 160 | 161 | ## [1.7] 162 | 163 | * Fixes wrong uploads to PyPI (#8). 164 | 165 | ## [1.6] 166 | 167 | * Added new ``auto`` software mode to allow automatic selection 168 | of hardware or software backend (#5). 169 | * Fixed compilation in non-Intel platforms (#6). 170 | * Added support to compile with ``icc``. 171 | 172 | ## [1.5] 173 | 174 | * Adding software implementation of ``crc32c`` algorithm, 175 | original developed by Mark Adler (#4). 176 | Software implementation is not accessible by default 177 | in order to maintain current importing logic, 178 | and is switched on by setting ``CRC32C_SW_MODE`` to ``1``. 179 | * Changed Intel's hardware-based implementation of ``crc32c`` 180 | from our own home-brewed code to Mark Adler's. 181 | 182 | ## [1.4] 183 | 184 | * Added support to compile in Windows using MSVC. 185 | * Removing experimental read/crc/write C method. 186 | * First version with binary wheels uploaded to PyPI (#2). 187 | 188 | ## [1.3] 189 | 190 | * Added support to compile in Windows using the MinGW compiler (#1). 191 | 192 | ## [1.2] 193 | 194 | * First version of ``crc32c`` doing pre- and post-masking 195 | against ``0xffffffff``. 196 | This is thus the first version of the package 197 | that is easily usable. 198 | 199 | ## [1.1] 200 | 201 | * Correct license reference. 202 | 203 | ## [1.0] 204 | 205 | * Initial release. 206 | 207 | [1.0]: https://github.com/ICRAR/crc32c/releases/tag/v1.0 208 | [1.1]: https://github.com/ICRAR/crc32c/releases/tag/v1.1 209 | [1.2]: https://github.com/ICRAR/crc32c/releases/tag/v1.2 210 | [1.3]: https://github.com/ICRAR/crc32c/releases/tag/v1.3 211 | [1.4]: https://github.com/ICRAR/crc32c/releases/tag/v1.4 212 | [1.5]: https://github.com/ICRAR/crc32c/releases/tag/v1.5 213 | [1.6]: https://github.com/ICRAR/crc32c/releases/tag/v1.6 214 | [1.7]: https://github.com/ICRAR/crc32c/releases/tag/v1.7 215 | [2.0]: https://github.com/ICRAR/crc32c/releases/tag/v2.0 216 | [2.0.1]: https://github.com/ICRAR/crc32c/releases/tag/v2.0.1 217 | [2.1]: https://github.com/ICRAR/crc32c/releases/tag/v2.1 218 | [2.2]: https://github.com/ICRAR/crc32c/releases/tag/v2.2 219 | [2.2.post0]: https://github.com/ICRAR/crc32c/releases/tag/v2.2.post0 220 | [2.3]: https://github.com/ICRAR/crc32c/releases/tag/v2.3 221 | [2.3.post0]: https://github.com/ICRAR/crc32c/releases/tag/v2.3.post0 222 | [2.4]: https://github.com/ICRAR/crc32c/releases/tag/v2.4 223 | [2.4.1]: https://github.com/ICRAR/crc32c/releases/tag/v2.4.1 224 | [2.5]: https://github.com/ICRAR/crc32c/releases/tag/v2.5 225 | [2.6]: https://github.com/ICRAR/crc32c/releases/tag/v2.6 226 | [2.7]: https://github.com/ICRAR/crc32c/releases/tag/v2.7 227 | [2.7.post0]: https://github.com/ICRAR/crc32c/releases/tag/v2.7.post0 228 | [2.7.post1]: https://github.com/ICRAR/crc32c/releases/tag/v2.7.post1 229 | [2.7.1]: https://github.com/ICRAR/crc32c/releases/tag/v2.7.1 230 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU LESSER GENERAL PUBLIC LICENSE 2 | Version 2.1, February 1999 3 | 4 | Copyright (C) 1991, 1999 Free Software Foundation, Inc. 5 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 6 | Everyone is permitted to copy and distribute verbatim copies 7 | of this license document, but changing it is not allowed. 8 | 9 | [This is the first released version of the Lesser GPL. It also counts 10 | as the successor of the GNU Library Public License, version 2, hence 11 | the version number 2.1.] 12 | 13 | Preamble 14 | 15 | The licenses for most software are designed to take away your 16 | freedom to share and change it. By contrast, the GNU General Public 17 | Licenses are intended to guarantee your freedom to share and change 18 | free software--to make sure the software is free for all its users. 19 | 20 | This license, the Lesser General Public License, applies to some 21 | specially designated software packages--typically libraries--of the 22 | Free Software Foundation and other authors who decide to use it. You 23 | can use it too, but we suggest you first think carefully about whether 24 | this license or the ordinary General Public License is the better 25 | strategy to use in any particular case, based on the explanations below. 26 | 27 | When we speak of free software, we are referring to freedom of use, 28 | not price. Our General Public Licenses are designed to make sure that 29 | you have the freedom to distribute copies of free software (and charge 30 | for this service if you wish); that you receive source code or can get 31 | it if you want it; that you can change the software and use pieces of 32 | it in new free programs; and that you are informed that you can do 33 | these things. 34 | 35 | To protect your rights, we need to make restrictions that forbid 36 | distributors to deny you these rights or to ask you to surrender these 37 | rights. These restrictions translate to certain responsibilities for 38 | you if you distribute copies of the library or if you modify it. 39 | 40 | For example, if you distribute copies of the library, whether gratis 41 | or for a fee, you must give the recipients all the rights that we gave 42 | you. You must make sure that they, too, receive or can get the source 43 | code. If you link other code with the library, you must provide 44 | complete object files to the recipients, so that they can relink them 45 | with the library after making changes to the library and recompiling 46 | it. And you must show them these terms so they know their rights. 47 | 48 | We protect your rights with a two-step method: (1) we copyright the 49 | library, and (2) we offer you this license, which gives you legal 50 | permission to copy, distribute and/or modify the library. 51 | 52 | To protect each distributor, we want to make it very clear that 53 | there is no warranty for the free library. Also, if the library is 54 | modified by someone else and passed on, the recipients should know 55 | that what they have is not the original version, so that the original 56 | author's reputation will not be affected by problems that might be 57 | introduced by others. 58 | 59 | Finally, software patents pose a constant threat to the existence of 60 | any free program. We wish to make sure that a company cannot 61 | effectively restrict the users of a free program by obtaining a 62 | restrictive license from a patent holder. Therefore, we insist that 63 | any patent license obtained for a version of the library must be 64 | consistent with the full freedom of use specified in this license. 65 | 66 | Most GNU software, including some libraries, is covered by the 67 | ordinary GNU General Public License. This license, the GNU Lesser 68 | General Public License, applies to certain designated libraries, and 69 | is quite different from the ordinary General Public License. We use 70 | this license for certain libraries in order to permit linking those 71 | libraries into non-free programs. 72 | 73 | When a program is linked with a library, whether statically or using 74 | a shared library, the combination of the two is legally speaking a 75 | combined work, a derivative of the original library. The ordinary 76 | General Public License therefore permits such linking only if the 77 | entire combination fits its criteria of freedom. The Lesser General 78 | Public License permits more lax criteria for linking other code with 79 | the library. 80 | 81 | We call this license the "Lesser" General Public License because it 82 | does Less to protect the user's freedom than the ordinary General 83 | Public License. It also provides other free software developers Less 84 | of an advantage over competing non-free programs. These disadvantages 85 | are the reason we use the ordinary General Public License for many 86 | libraries. However, the Lesser license provides advantages in certain 87 | special circumstances. 88 | 89 | For example, on rare occasions, there may be a special need to 90 | encourage the widest possible use of a certain library, so that it becomes 91 | a de-facto standard. To achieve this, non-free programs must be 92 | allowed to use the library. A more frequent case is that a free 93 | library does the same job as widely used non-free libraries. In this 94 | case, there is little to gain by limiting the free library to free 95 | software only, so we use the Lesser General Public License. 96 | 97 | In other cases, permission to use a particular library in non-free 98 | programs enables a greater number of people to use a large body of 99 | free software. For example, permission to use the GNU C Library in 100 | non-free programs enables many more people to use the whole GNU 101 | operating system, as well as its variant, the GNU/Linux operating 102 | system. 103 | 104 | Although the Lesser General Public License is Less protective of the 105 | users' freedom, it does ensure that the user of a program that is 106 | linked with the Library has the freedom and the wherewithal to run 107 | that program using a modified version of the Library. 108 | 109 | The precise terms and conditions for copying, distribution and 110 | modification follow. Pay close attention to the difference between a 111 | "work based on the library" and a "work that uses the library". The 112 | former contains code derived from the library, whereas the latter must 113 | be combined with the library in order to run. 114 | 115 | GNU LESSER GENERAL PUBLIC LICENSE 116 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 117 | 118 | 0. This License Agreement applies to any software library or other 119 | program which contains a notice placed by the copyright holder or 120 | other authorized party saying it may be distributed under the terms of 121 | this Lesser General Public License (also called "this License"). 122 | Each licensee is addressed as "you". 123 | 124 | A "library" means a collection of software functions and/or data 125 | prepared so as to be conveniently linked with application programs 126 | (which use some of those functions and data) to form executables. 127 | 128 | The "Library", below, refers to any such software library or work 129 | which has been distributed under these terms. A "work based on the 130 | Library" means either the Library or any derivative work under 131 | copyright law: that is to say, a work containing the Library or a 132 | portion of it, either verbatim or with modifications and/or translated 133 | straightforwardly into another language. (Hereinafter, translation is 134 | included without limitation in the term "modification".) 135 | 136 | "Source code" for a work means the preferred form of the work for 137 | making modifications to it. For a library, complete source code means 138 | all the source code for all modules it contains, plus any associated 139 | interface definition files, plus the scripts used to control compilation 140 | and installation of the library. 141 | 142 | Activities other than copying, distribution and modification are not 143 | covered by this License; they are outside its scope. The act of 144 | running a program using the Library is not restricted, and output from 145 | such a program is covered only if its contents constitute a work based 146 | on the Library (independent of the use of the Library in a tool for 147 | writing it). Whether that is true depends on what the Library does 148 | and what the program that uses the Library does. 149 | 150 | 1. You may copy and distribute verbatim copies of the Library's 151 | complete source code as you receive it, in any medium, provided that 152 | you conspicuously and appropriately publish on each copy an 153 | appropriate copyright notice and disclaimer of warranty; keep intact 154 | all the notices that refer to this License and to the absence of any 155 | warranty; and distribute a copy of this License along with the 156 | Library. 157 | 158 | You may charge a fee for the physical act of transferring a copy, 159 | and you may at your option offer warranty protection in exchange for a 160 | fee. 161 | 162 | 2. You may modify your copy or copies of the Library or any portion 163 | of it, thus forming a work based on the Library, and copy and 164 | distribute such modifications or work under the terms of Section 1 165 | above, provided that you also meet all of these conditions: 166 | 167 | a) The modified work must itself be a software library. 168 | 169 | b) You must cause the files modified to carry prominent notices 170 | stating that you changed the files and the date of any change. 171 | 172 | c) You must cause the whole of the work to be licensed at no 173 | charge to all third parties under the terms of this License. 174 | 175 | d) If a facility in the modified Library refers to a function or a 176 | table of data to be supplied by an application program that uses 177 | the facility, other than as an argument passed when the facility 178 | is invoked, then you must make a good faith effort to ensure that, 179 | in the event an application does not supply such function or 180 | table, the facility still operates, and performs whatever part of 181 | its purpose remains meaningful. 182 | 183 | (For example, a function in a library to compute square roots has 184 | a purpose that is entirely well-defined independent of the 185 | application. Therefore, Subsection 2d requires that any 186 | application-supplied function or table used by this function must 187 | be optional: if the application does not supply it, the square 188 | root function must still compute square roots.) 189 | 190 | These requirements apply to the modified work as a whole. If 191 | identifiable sections of that work are not derived from the Library, 192 | and can be reasonably considered independent and separate works in 193 | themselves, then this License, and its terms, do not apply to those 194 | sections when you distribute them as separate works. But when you 195 | distribute the same sections as part of a whole which is a work based 196 | on the Library, the distribution of the whole must be on the terms of 197 | this License, whose permissions for other licensees extend to the 198 | entire whole, and thus to each and every part regardless of who wrote 199 | it. 200 | 201 | Thus, it is not the intent of this section to claim rights or contest 202 | your rights to work written entirely by you; rather, the intent is to 203 | exercise the right to control the distribution of derivative or 204 | collective works based on the Library. 205 | 206 | In addition, mere aggregation of another work not based on the Library 207 | with the Library (or with a work based on the Library) on a volume of 208 | a storage or distribution medium does not bring the other work under 209 | the scope of this License. 210 | 211 | 3. You may opt to apply the terms of the ordinary GNU General Public 212 | License instead of this License to a given copy of the Library. To do 213 | this, you must alter all the notices that refer to this License, so 214 | that they refer to the ordinary GNU General Public License, version 2, 215 | instead of to this License. (If a newer version than version 2 of the 216 | ordinary GNU General Public License has appeared, then you can specify 217 | that version instead if you wish.) Do not make any other change in 218 | these notices. 219 | 220 | Once this change is made in a given copy, it is irreversible for 221 | that copy, so the ordinary GNU General Public License applies to all 222 | subsequent copies and derivative works made from that copy. 223 | 224 | This option is useful when you wish to copy part of the code of 225 | the Library into a program that is not a library. 226 | 227 | 4. You may copy and distribute the Library (or a portion or 228 | derivative of it, under Section 2) in object code or executable form 229 | under the terms of Sections 1 and 2 above provided that you accompany 230 | it with the complete corresponding machine-readable source code, which 231 | must be distributed under the terms of Sections 1 and 2 above on a 232 | medium customarily used for software interchange. 233 | 234 | If distribution of object code is made by offering access to copy 235 | from a designated place, then offering equivalent access to copy the 236 | source code from the same place satisfies the requirement to 237 | distribute the source code, even though third parties are not 238 | compelled to copy the source along with the object code. 239 | 240 | 5. A program that contains no derivative of any portion of the 241 | Library, but is designed to work with the Library by being compiled or 242 | linked with it, is called a "work that uses the Library". Such a 243 | work, in isolation, is not a derivative work of the Library, and 244 | therefore falls outside the scope of this License. 245 | 246 | However, linking a "work that uses the Library" with the Library 247 | creates an executable that is a derivative of the Library (because it 248 | contains portions of the Library), rather than a "work that uses the 249 | library". The executable is therefore covered by this License. 250 | Section 6 states terms for distribution of such executables. 251 | 252 | When a "work that uses the Library" uses material from a header file 253 | that is part of the Library, the object code for the work may be a 254 | derivative work of the Library even though the source code is not. 255 | Whether this is true is especially significant if the work can be 256 | linked without the Library, or if the work is itself a library. The 257 | threshold for this to be true is not precisely defined by law. 258 | 259 | If such an object file uses only numerical parameters, data 260 | structure layouts and accessors, and small macros and small inline 261 | functions (ten lines or less in length), then the use of the object 262 | file is unrestricted, regardless of whether it is legally a derivative 263 | work. (Executables containing this object code plus portions of the 264 | Library will still fall under Section 6.) 265 | 266 | Otherwise, if the work is a derivative of the Library, you may 267 | distribute the object code for the work under the terms of Section 6. 268 | Any executables containing that work also fall under Section 6, 269 | whether or not they are linked directly with the Library itself. 270 | 271 | 6. As an exception to the Sections above, you may also combine or 272 | link a "work that uses the Library" with the Library to produce a 273 | work containing portions of the Library, and distribute that work 274 | under terms of your choice, provided that the terms permit 275 | modification of the work for the customer's own use and reverse 276 | engineering for debugging such modifications. 277 | 278 | You must give prominent notice with each copy of the work that the 279 | Library is used in it and that the Library and its use are covered by 280 | this License. You must supply a copy of this License. If the work 281 | during execution displays copyright notices, you must include the 282 | copyright notice for the Library among them, as well as a reference 283 | directing the user to the copy of this License. Also, you must do one 284 | of these things: 285 | 286 | a) Accompany the work with the complete corresponding 287 | machine-readable source code for the Library including whatever 288 | changes were used in the work (which must be distributed under 289 | Sections 1 and 2 above); and, if the work is an executable linked 290 | with the Library, with the complete machine-readable "work that 291 | uses the Library", as object code and/or source code, so that the 292 | user can modify the Library and then relink to produce a modified 293 | executable containing the modified Library. (It is understood 294 | that the user who changes the contents of definitions files in the 295 | Library will not necessarily be able to recompile the application 296 | to use the modified definitions.) 297 | 298 | b) Use a suitable shared library mechanism for linking with the 299 | Library. A suitable mechanism is one that (1) uses at run time a 300 | copy of the library already present on the user's computer system, 301 | rather than copying library functions into the executable, and (2) 302 | will operate properly with a modified version of the library, if 303 | the user installs one, as long as the modified version is 304 | interface-compatible with the version that the work was made with. 305 | 306 | c) Accompany the work with a written offer, valid for at 307 | least three years, to give the same user the materials 308 | specified in Subsection 6a, above, for a charge no more 309 | than the cost of performing this distribution. 310 | 311 | d) If distribution of the work is made by offering access to copy 312 | from a designated place, offer equivalent access to copy the above 313 | specified materials from the same place. 314 | 315 | e) Verify that the user has already received a copy of these 316 | materials or that you have already sent this user a copy. 317 | 318 | For an executable, the required form of the "work that uses the 319 | Library" must include any data and utility programs needed for 320 | reproducing the executable from it. However, as a special exception, 321 | the materials to be distributed need not include anything that is 322 | normally distributed (in either source or binary form) with the major 323 | components (compiler, kernel, and so on) of the operating system on 324 | which the executable runs, unless that component itself accompanies 325 | the executable. 326 | 327 | It may happen that this requirement contradicts the license 328 | restrictions of other proprietary libraries that do not normally 329 | accompany the operating system. Such a contradiction means you cannot 330 | use both them and the Library together in an executable that you 331 | distribute. 332 | 333 | 7. You may place library facilities that are a work based on the 334 | Library side-by-side in a single library together with other library 335 | facilities not covered by this License, and distribute such a combined 336 | library, provided that the separate distribution of the work based on 337 | the Library and of the other library facilities is otherwise 338 | permitted, and provided that you do these two things: 339 | 340 | a) Accompany the combined library with a copy of the same work 341 | based on the Library, uncombined with any other library 342 | facilities. This must be distributed under the terms of the 343 | Sections above. 344 | 345 | b) Give prominent notice with the combined library of the fact 346 | that part of it is a work based on the Library, and explaining 347 | where to find the accompanying uncombined form of the same work. 348 | 349 | 8. You may not copy, modify, sublicense, link with, or distribute 350 | the Library except as expressly provided under this License. Any 351 | attempt otherwise to copy, modify, sublicense, link with, or 352 | distribute the Library is void, and will automatically terminate your 353 | rights under this License. However, parties who have received copies, 354 | or rights, from you under this License will not have their licenses 355 | terminated so long as such parties remain in full compliance. 356 | 357 | 9. You are not required to accept this License, since you have not 358 | signed it. However, nothing else grants you permission to modify or 359 | distribute the Library or its derivative works. These actions are 360 | prohibited by law if you do not accept this License. Therefore, by 361 | modifying or distributing the Library (or any work based on the 362 | Library), you indicate your acceptance of this License to do so, and 363 | all its terms and conditions for copying, distributing or modifying 364 | the Library or works based on it. 365 | 366 | 10. Each time you redistribute the Library (or any work based on the 367 | Library), the recipient automatically receives a license from the 368 | original licensor to copy, distribute, link with or modify the Library 369 | subject to these terms and conditions. You may not impose any further 370 | restrictions on the recipients' exercise of the rights granted herein. 371 | You are not responsible for enforcing compliance by third parties with 372 | this License. 373 | 374 | 11. If, as a consequence of a court judgment or allegation of patent 375 | infringement or for any other reason (not limited to patent issues), 376 | conditions are imposed on you (whether by court order, agreement or 377 | otherwise) that contradict the conditions of this License, they do not 378 | excuse you from the conditions of this License. If you cannot 379 | distribute so as to satisfy simultaneously your obligations under this 380 | License and any other pertinent obligations, then as a consequence you 381 | may not distribute the Library at all. For example, if a patent 382 | license would not permit royalty-free redistribution of the Library by 383 | all those who receive copies directly or indirectly through you, then 384 | the only way you could satisfy both it and this License would be to 385 | refrain entirely from distribution of the Library. 386 | 387 | If any portion of this section is held invalid or unenforceable under any 388 | particular circumstance, the balance of the section is intended to apply, 389 | and the section as a whole is intended to apply in other circumstances. 390 | 391 | It is not the purpose of this section to induce you to infringe any 392 | patents or other property right claims or to contest validity of any 393 | such claims; this section has the sole purpose of protecting the 394 | integrity of the free software distribution system which is 395 | implemented by public license practices. Many people have made 396 | generous contributions to the wide range of software distributed 397 | through that system in reliance on consistent application of that 398 | system; it is up to the author/donor to decide if he or she is willing 399 | to distribute software through any other system and a licensee cannot 400 | impose that choice. 401 | 402 | This section is intended to make thoroughly clear what is believed to 403 | be a consequence of the rest of this License. 404 | 405 | 12. If the distribution and/or use of the Library is restricted in 406 | certain countries either by patents or by copyrighted interfaces, the 407 | original copyright holder who places the Library under this License may add 408 | an explicit geographical distribution limitation excluding those countries, 409 | so that distribution is permitted only in or among countries not thus 410 | excluded. In such case, this License incorporates the limitation as if 411 | written in the body of this License. 412 | 413 | 13. The Free Software Foundation may publish revised and/or new 414 | versions of the Lesser General Public License from time to time. 415 | Such new versions will be similar in spirit to the present version, 416 | but may differ in detail to address new problems or concerns. 417 | 418 | Each version is given a distinguishing version number. If the Library 419 | specifies a version number of this License which applies to it and 420 | "any later version", you have the option of following the terms and 421 | conditions either of that version or of any later version published by 422 | the Free Software Foundation. If the Library does not specify a 423 | license version number, you may choose any version ever published by 424 | the Free Software Foundation. 425 | 426 | 14. If you wish to incorporate parts of the Library into other free 427 | programs whose distribution conditions are incompatible with these, 428 | write to the author to ask for permission. For software which is 429 | copyrighted by the Free Software Foundation, write to the Free 430 | Software Foundation; we sometimes make exceptions for this. Our 431 | decision will be guided by the two goals of preserving the free status 432 | of all derivatives of our free software and of promoting the sharing 433 | and reuse of software generally. 434 | 435 | NO WARRANTY 436 | 437 | 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO 438 | WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 439 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR 440 | OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY 441 | KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE 442 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 443 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE 444 | LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME 445 | THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 446 | 447 | 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN 448 | WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY 449 | AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU 450 | FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR 451 | CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE 452 | LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING 453 | RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A 454 | FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF 455 | SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 456 | DAMAGES. 457 | 458 | END OF TERMS AND CONDITIONS 459 | 460 | How to Apply These Terms to Your New Libraries 461 | 462 | If you develop a new library, and you want it to be of the greatest 463 | possible use to the public, we recommend making it free software that 464 | everyone can redistribute and change. You can do so by permitting 465 | redistribution under these terms (or, alternatively, under the terms of the 466 | ordinary General Public License). 467 | 468 | To apply these terms, attach the following notices to the library. It is 469 | safest to attach them to the start of each source file to most effectively 470 | convey the exclusion of warranty; and each file should have at least the 471 | "copyright" line and a pointer to where the full notice is found. 472 | 473 | 474 | Copyright (C) 475 | 476 | This library is free software; you can redistribute it and/or 477 | modify it under the terms of the GNU Lesser General Public 478 | License as published by the Free Software Foundation; either 479 | version 2.1 of the License, or (at your option) any later version. 480 | 481 | This library is distributed in the hope that it will be useful, 482 | but WITHOUT ANY WARRANTY; without even the implied warranty of 483 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 484 | Lesser General Public License for more details. 485 | 486 | You should have received a copy of the GNU Lesser General Public 487 | License along with this library; if not, write to the Free Software 488 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 489 | 490 | Also add information on how to contact you by electronic and paper mail. 491 | 492 | You should also get your employer (if you work as a programmer) or your 493 | school, if any, to sign a "copyright disclaimer" for the library, if 494 | necessary. Here is a sample; alter the names: 495 | 496 | Yoyodyne, Inc., hereby disclaims all copyright interest in the 497 | library `Frob' (a library for tweaking knobs) written by James Random Hacker. 498 | 499 | , 1 April 1990 500 | Ty Coon, President of Vice 501 | 502 | That's all there is to it! 503 | -------------------------------------------------------------------------------- /LICENSE.google-crc32c: -------------------------------------------------------------------------------- 1 | Copyright 2017, The CRC32C Authors. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | 14 | * Neither the name of Google Inc. nor the names of its 15 | contributors may be used to endorse or promote products derived from 16 | this software without specific prior written permission. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /LICENSE.slice-by-8: -------------------------------------------------------------------------------- 1 | Copyright (c) 2008,2009,2010 Massachusetts Institute of Technology. 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are 6 | met: 7 | 8 | * Redistributions of source code must retain the above copyright 9 | notice, this list of conditions and the following disclaimer. 10 | * Redistributions in binary form must reproduce the above copyright 11 | notice, this list of conditions and the following disclaimer in the 12 | documentation and/or other materials provided with the distribution. 13 | * Neither the name of the Massachusetts Institute of Technology nor 14 | the names of its contributors may be used to endorse or promote 15 | products derived from this software without specific prior written 16 | permission. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | 30 | 31 | Other portions are under the same license from Intel: 32 | http://sourceforge.net/projects/slicing-by-8/ 33 | /*++ 34 | * 35 | * Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved 36 | * 37 | * This software program is licensed subject to the BSD License, 38 | * available at http://www.opensource.org/licenses/bsd-license.html 39 | * 40 | * Abstract: The main routine 41 | * 42 | --*/ 43 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include LICENSE* 2 | include AUTHORS* 3 | include test/conftest.py 4 | include run-tests.py 5 | include pytest.ini 6 | -------------------------------------------------------------------------------- /README.rst: -------------------------------------------------------------------------------- 1 | crc32c 2 | ====== 3 | 4 | .. image:: https://github.com/ICRAR/crc32c/workflows/Build%20and%20release%20to%20PyPI/badge.svg?branch=master 5 | 6 | .. image:: https://badge.fury.io/py/crc32c.svg 7 | :target: https://badge.fury.io/py/crc32c 8 | 9 | This package implements the crc32c checksum algorithm. 10 | It automatically chooses between a hardware-based implementation 11 | (using the CRC32C SSE 4.2 instruction of Intel CPUs, 12 | and the crc32* instructions on ARMv8 CPUs), 13 | or a software-based one when no hardware support can be found. 14 | 15 | Because ``crc32c`` is in PyPI, you can install it with:: 16 | 17 | pip install crc32c 18 | 19 | Supported platforms are Linux and OSX using the gcc and clang compilers, 20 | and Windows using the Visual Studio compiler. Other compilers in 21 | Windows (MinGW for instance) might work. 22 | Binary wheels are also provided in PyPI for major platforms/architectures. 23 | 24 | The project is using certain gcc/clang compiler extensions to support 25 | building hardware-specific functions that might not be supported 26 | by older compiler versions. 27 | 28 | 29 | Usage 30 | ----- 31 | 32 | The core function exposed by this module is ``crc32c(data, value=0, gil_release_mode=-1)``. 33 | It computes the CRC32C checksum of ``data`` 34 | starting with an initial ``value`` checksum, 35 | similarly to how the built-in ``binascii.crc32`` works. 36 | It can thus be used like this: 37 | 38 | .. code-block:: python 39 | 40 | print(crc32c.crc32c(b'hello world')) 41 | # 3381945770 42 | crc = crc32c.crc32c(b'hello') 43 | print(crc32c.crc32c(b' world', value=crc)) 44 | # 3381945770 45 | 46 | In older versions, 47 | the function exposed by this module was called ``crc32``. 48 | That name is still present but deprecated, 49 | and will be removed in new versions of the library. 50 | 51 | The ``gil_release_mode`` keyword argument 52 | specifies whether a call of this library shall release or keep the Global Interpreter Lock. 53 | It can be set to the following values: 54 | 55 | * Negative: Only release the GIL when ``data`` >= 32KiB 56 | * 0: Never release the GIL 57 | * Positive: Always release the GIL 58 | 59 | The ``gil_release_mode`` parameter 60 | doesn't have any effect on free-threaded Python builds. 61 | 62 | On top of the ``crc32c`` function, 63 | a ``CRC32CHash(data=b"", gil_release_mode=-1)`` class is also offered. 64 | It is modelled after the "hash objects" of the ``hashlib`` module 65 | of the standard library. It also offers a ``checksum`` property: 66 | 67 | .. code-block:: python 68 | 69 | crc32c_hash = crc32c.CRC32CHash() 70 | crc32c_hash.update(b'hello') 71 | crc32c_hash.update(b' world') 72 | print(crc32c_hash.checksum == crc32c.crc32c(b'hello world')) 73 | # True 74 | print(crc32c_hash.digest()) 75 | # b'\xc9\x94e\xaa' 76 | digest_as_int = int.from_bytes(crc32c_hash.digest(), "big") 77 | print(digest_as_int == crc32c.crc32c(b'hello world')) 78 | # True 79 | 80 | For more details see 81 | the documentation on `hash objects `_. 82 | 83 | Additionally one can consult 84 | the following module-level values: 85 | 86 | * ``hardware_based`` indicates if the algorithm in use 87 | is software- or hardware-based. 88 | * ``big_endian`` indicates whether the platform is big endian or not. 89 | 90 | A benchmarking utility can be found 91 | when executing the ``crc32c.benchmark`` module. 92 | Consult its help with the ``-h`` flag for options. 93 | 94 | Implementation details 95 | ---------------------- 96 | 97 | By default, 98 | if your CPU doesn't have CRC32C hardware support, 99 | the package will fallback to use a software implementation 100 | of the crc32c checksum algorithm. 101 | This behavior can be changed by setting 102 | the ``CRC32C_SW_MODE`` environment variable 103 | to one of the following values: 104 | 105 | * ``auto``: same as if unset, will eventually be discontinued. 106 | * ``force``: use software implementation regardless of hardware support. 107 | * ``none``: issue a ``RuntimeWarning`` when importing the module, 108 | and a ``RuntimeError`` when executing the ``crc32c`` function, 109 | if no hardware support is found. 110 | In versions of this package up to 2.6 111 | an ``ImportError`` was raised when importing the module instead. 112 | In 1.x versions this was the default behaviour. 113 | 114 | Setting the ``CRC32C_SKIP_HW_PROBE`` to ``1`` 115 | simulates platforms without hardware support. 116 | This is available mostly for internal testing purposes. 117 | 118 | The software algorithm is based 119 | on Intel's `slice-by-8 package `_, 120 | with some adaptations done 121 | by `Evan Jones `_ 122 | and packaging provided by `Ferry Toth `_. 123 | Further adaptations were required 124 | to make the code more portable 125 | and fit for inclusion within this python package. 126 | 127 | The Intel SSE 4.2 algorithm 128 | is based on `Mark Adler's code `_, 129 | with some modifications required 130 | to make the code more portable 131 | and fit for inclusion within this python package. 132 | 133 | The ARMv8 hardware implementation 134 | is based on Google's `crc32c `_ 135 | C++ library. 136 | 137 | Copyright 138 | --------- 139 | 140 | This package is copyrighted:: 141 | 142 | ICRAR - International Centre for Radio Astronomy Research 143 | (c) UWA - The University of Western Australia, 2017 144 | Copyright by UWA (in the framework of the ICRAR) 145 | 146 | The original slice-by-8 software algorithm 147 | is copyrighted by:: 148 | 149 | Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved 150 | 151 | Further adaptations to the slice-by-8 algorithm 152 | previous to the inclusion in this package 153 | are copyrighted by:: 154 | 155 | Copyright 2008,2009,2010 Massachusetts Institute of Technology. 156 | 157 | The original Intel SSE 4.2 crc32c algorithm 158 | is copyrighted by:: 159 | 160 | Copyright (C) 2013 Mark Adler 161 | 162 | The crc32c ARMv8 hardware code 163 | is copyrighted by:: 164 | 165 | Copyright 2017 The CRC32C Authors 166 | 167 | A copy of the `AUTHORS `_ file 168 | from Google's crc32c project 169 | as it was at the time of copying the code 170 | is included in this repository. 171 | 172 | License 173 | ------- 174 | 175 | This package is licensed under `the LGPL-2.1 license `_. 176 | 177 | The original slice-by-8 software algorithm 178 | is licensed under `the 2-clause BSD licence 179 | `_. 180 | 181 | Further modifications to the slice-by-8 software algorithm 182 | are licensed under `a 3-clause BSD licence `_ 183 | 184 | The original Intel SSE 4.2 crc32c algorithm's code 185 | is licensed under a custom license 186 | embedded in the ``crc32c_adler.c`` file. 187 | 188 | The original crc32c ARMv8 hardware code 189 | is licensed under `a 3-clause BSD license `_. 190 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools >= 61.0"] 3 | build-backend = "setuptools.build_meta" 4 | 5 | [project] 6 | name = "crc32c" 7 | version = "2.7.1" 8 | authors = [ 9 | { name = "Rodrigo Tobar", email = "rtobar@icrar.org" }, 10 | ] 11 | description = "A python package implementing the crc32c algorithm in hardware and software" 12 | readme = "README.rst" 13 | license = { text = "LGPL-2.1-or-later" } 14 | requires-python = ">=3.7" 15 | classifiers = [ 16 | # There's no more specific classifier for LGPLv2.1+ 17 | "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)", 18 | "Operating System :: OS Independent", 19 | "Programming Language :: C", 20 | "Programming Language :: Python :: 3.7", 21 | "Programming Language :: Python :: 3.8", 22 | "Programming Language :: Python :: 3.9", 23 | "Programming Language :: Python :: 3.10", 24 | "Programming Language :: Python :: 3.11", 25 | "Programming Language :: Python :: 3.12", 26 | "Programming Language :: Python :: 3.13", 27 | ] 28 | urls.github = "https://github.com/ICRAR/crc32c" 29 | urls.changelog = "https://github.com/ICRAR/crc32c/blob/master/CHANGELOG.md" 30 | urls.issues = "https://github.com/ICRAR/crc32c/issues" 31 | 32 | [dependency-groups] 33 | test = [ 34 | "pytest", 35 | ] 36 | lint = [ 37 | "black", 38 | "isort", 39 | "mypy", 40 | ] 41 | 42 | [tool.pytest.ini_options] 43 | markers = [ 44 | "calculates_crc32c: Mark a test as needing crc32c working" 45 | ] 46 | 47 | [tool.tox] 48 | requires = ["tox>=4.23"] 49 | env_list = [ 50 | "py3.8", 51 | "py3.9", 52 | "py3.10", 53 | "py3.11", 54 | "py3.12", 55 | "py3.13", 56 | ] 57 | 58 | [tool.tox.env_run_base] 59 | description = "Run test under {base_python}" 60 | labels = ["test"] 61 | commands = [["{env_python}", "-u", "run-tests.py"]] 62 | dependency_groups = ["test"] 63 | passenv = ["CRC32C_SW_MODE"] 64 | 65 | [tool.tox.env.benchmark] 66 | description = "Run basic benckmark" 67 | labels = ["benchmark"] 68 | commands = [["{env_python}", "-m", "crc32c.benchmark", { replace = "posargs", extend = true }]] 69 | passenv = ["CRC32C_SW_MODE"] 70 | parallel_show_output = true 71 | 72 | [tool.tox.env.lint] 73 | description = "Run linting checks" 74 | labels = ["lint"] 75 | commands = [ 76 | ["mypy", "--strict", "src", "test"], 77 | ["black", "--check", "src", "test"], 78 | ["isort", "--profile", "black", "--check", "--diff", "src", "test"], 79 | ] 80 | dependency_groups = ["lint", "test"] 81 | package = "skip" 82 | changedir = "{toxinidir}" 83 | -------------------------------------------------------------------------------- /run-tests.py: -------------------------------------------------------------------------------- 1 | import os 2 | import subprocess as sp 3 | import sys 4 | 5 | SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) 6 | 7 | 8 | def run(cmd): 9 | print(" ".join(cmd)) 10 | sp.check_call(cmd) 11 | 12 | 13 | def run_tests(crc32c_sw_mode): 14 | os.environ["CRC32C_SW_MODE"] = crc32c_sw_mode 15 | os.environ["CRC32C_SKIP_HW_PROBE"] = ["0", "1"][crc32c_sw_mode == "none"] 16 | message = "# Tests for CRC32C_SW_MODE: %s #" % crc32c_sw_mode 17 | hashes = "#" * len(message) 18 | print("\n" + hashes) 19 | print(message) 20 | print(hashes + "\n") 21 | run([sys.executable, "-m", "pytest", "-v", os.path.join(SCRIPT_DIR, "test")]) 22 | 23 | 24 | def main(): 25 | run_tests("auto") 26 | run_tests("force") 27 | run_tests("none") 28 | 29 | 30 | if __name__ == "__main__": 31 | main() 32 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | # 2 | # ICRAR - International Centre for Radio Astronomy Research 3 | # (c) UWA - The University of Western Australia, 2014 4 | # Copyright by UWA (in the framework of the ICRAR) 5 | # All rights reserved 6 | # 7 | # This library is free software; you can redistribute it and/or 8 | # modify it under the terms of the GNU Lesser General Public 9 | # License as published by the Free Software Foundation; either 10 | # version 2.1 of the License, or (at your option) any later version. 11 | # 12 | # This library is distributed in the hope that it will be useful, 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | # Lesser General Public License for more details. 16 | # 17 | # You should have received a copy of the GNU Lesser General Public 18 | # License along with this library; if not, write to the Free Software 19 | # Foundation, Inc., 59 Temple Place, Suite 330, Boston, 20 | # MA 02111-1307 USA 21 | # 22 | import glob 23 | 24 | from setuptools import Extension, setup 25 | 26 | crcmod_ext = Extension( 27 | "crc32c._crc32c", 28 | depends=glob.glob("src/crc32c/ext/*.h"), 29 | language="c", 30 | sources=glob.glob("src/crc32c/ext/*.c"), 31 | include_dirs=["src/cc32c/ext/"], 32 | ) 33 | 34 | setup( 35 | package_data={"crc32c": ["*.pyi", "py.typed", "ext/*.h"]}, 36 | ext_modules=[crcmod_ext], 37 | ) 38 | -------------------------------------------------------------------------------- /src/crc32c/__init__.py: -------------------------------------------------------------------------------- 1 | # Explicitly "import ... as" to make mypy --strict happy 2 | from ._crc32c import big_endian as big_endian 3 | from ._crc32c import crc32 as crc32 4 | from ._crc32c import crc32c as crc32c 5 | from ._crc32c import hardware_based as hardware_based 6 | from ._crc32hash import CRC32CHash as CRC32CHash 7 | -------------------------------------------------------------------------------- /src/crc32c/_crc32c.pyi: -------------------------------------------------------------------------------- 1 | from typing_extensions import Buffer 2 | 3 | big_endian: int 4 | hardware_based: bool 5 | 6 | def crc32(data: Buffer, value: int = 0, gil_release_mode: int = -1) -> int: ... 7 | def crc32c(data: Buffer, value: int = 0, gil_release_mode: int = -1) -> int: ... 8 | -------------------------------------------------------------------------------- /src/crc32c/_crc32hash.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | from typing import TYPE_CHECKING 4 | 5 | from ._crc32c import crc32c 6 | 7 | if TYPE_CHECKING: 8 | from typing_extensions import Buffer, Self 9 | 10 | 11 | class CRC32CHash: 12 | """Wrapper class for crc32c. Tries to conform to the interface of `hashlib` classes.""" 13 | 14 | @property 15 | def digest_size(self) -> int: 16 | """ 17 | The size of the resulting hash in bytes. 18 | """ 19 | return 4 20 | 21 | @property 22 | def block_size(self) -> int: 23 | """ 24 | The internal block size of the hash algorithm in bytes. 25 | """ 26 | return 1 27 | 28 | @property 29 | def name(self) -> str: 30 | """ 31 | The canonical name of this hash, 32 | """ 33 | return "crc32c" 34 | 35 | @property 36 | def checksum(self) -> int: 37 | """ 38 | The checksum calculated so far. Not part of the hashlib interface. 39 | """ 40 | return self._checksum 41 | 42 | def __init__(self, data: Buffer = b"", gil_release_mode: int = -1) -> None: 43 | """ 44 | Initialise the hash object with an optional bytes-like object. 45 | Uses the given GIL release mode on each checksum calculation. 46 | """ 47 | self._checksum = crc32c(data, gil_release_mode=gil_release_mode) 48 | self._gil_release_mode = gil_release_mode 49 | 50 | def update(self, data: Buffer) -> None: 51 | """ 52 | Update the hash object with the bytes-like object. 53 | Repeated calls are equivalent to a single call with the concatenation of all the arguments: 54 | m.update(a); m.update(b) is equivalent to m.update(a+b). 55 | """ 56 | self._checksum = crc32c( 57 | data, self._checksum, gil_release_mode=self._gil_release_mode 58 | ) 59 | 60 | def digest(self) -> bytes: 61 | """ 62 | Return the digest of the data passed to the update() method so far. 63 | This is a bytes object of size digest_size which may contain bytes in the whole range from 0 to 255. 64 | """ 65 | return self._checksum.to_bytes(4, "big") 66 | 67 | def hexdigest(self) -> str: 68 | """ 69 | Like digest() except the digest is returned as a string object of double length, 70 | containing only hexadecimal digits. 71 | This may be used to exchange the value safely in email or other non-binary environments. 72 | """ 73 | return self.digest().hex() 74 | 75 | def copy(self) -> Self: 76 | """ 77 | Return a copy (“clone”) of the hash object. This can be used to efficiently compute 78 | the digests of data sharing a common initial substring. 79 | """ 80 | res = type(self)() 81 | res._checksum = self._checksum 82 | res._gil_release_mode = self._gil_release_mode 83 | return res 84 | -------------------------------------------------------------------------------- /src/crc32c/benchmark.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import time 3 | import typing 4 | 5 | from ._crc32c import crc32c 6 | 7 | DEFAULT_SIZE = 100 * 1024 * 1024 8 | DEFAULT_ITERATIONS = 10 9 | 10 | 11 | def run(size: int, iterations: int) -> typing.Tuple[float, int]: 12 | data = b" " * size 13 | start = time.monotonic() 14 | evaluations = 0 15 | while True: 16 | evaluations += iterations 17 | [crc32c(data) for _ in range(iterations)] 18 | duration = time.monotonic() - start 19 | if duration > 0: 20 | break 21 | return duration, evaluations 22 | 23 | 24 | def main() -> None: 25 | 26 | parser = argparse.ArgumentParser() 27 | parser.add_argument( 28 | "-s", 29 | "--size", 30 | type=int, 31 | help=f"Amount of bytes to checksum, defaults to {DEFAULT_SIZE}", 32 | default=DEFAULT_SIZE, 33 | ) 34 | parser.add_argument( 35 | "-i", 36 | "--iterations", 37 | type=int, 38 | help=f"Number of times the checksum should we run over the data, defaults to {DEFAULT_ITERATIONS}", 39 | default=DEFAULT_ITERATIONS, 40 | ) 41 | 42 | options = parser.parse_args() 43 | duration, evaluations = run(options.size, options.iterations) 44 | size_mb = options.size / 1024 / 1024 45 | avg_speed_gbs = size_mb / 1024 * evaluations / duration 46 | print( 47 | f"crc32c ran at {avg_speed_gbs:.3f} [GB/s] when checksuming {size_mb:.3f} [MB] {evaluations} times" 48 | ) 49 | 50 | 51 | if __name__ == "__main__": 52 | main() 53 | -------------------------------------------------------------------------------- /src/crc32c/ext/_crc32c.c: -------------------------------------------------------------------------------- 1 | /* 2 | * This module provides crc32c checksum (http://www.rfc-editor.org/rfc/rfc3385.txt) 3 | * based on the Intel CRC32 instruction 4 | * provided in the Intel SSE4.2 instruction set 5 | * 6 | * ICRAR - International Centre for Radio Astronomy Research 7 | * (c) UWA - The University of Western Australia, 2014 8 | * Copyright by UWA (in the framework of the ICRAR) 9 | * All rights reserved 10 | * 11 | * This library is free software; you can redistribute it and/or 12 | * modify it under the terms of the GNU Lesser General Public 13 | * License as published by the Free Software Foundation; either 14 | * version 2.1 of the License, or (at your option) any later version. 15 | * 16 | * This library is distributed in the hope that it will be useful, 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 | * Lesser General Public License for more details. 20 | * 21 | * You should have received a copy of the GNU Lesser General Public 22 | * License along with this library; if not, write to the Free Software 23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 24 | * MA 02111-1307 USA 25 | * 26 | */ 27 | 28 | #include 29 | 30 | #include "checkarm.h" 31 | #include "checksse42.h" 32 | #include "common.h" 33 | #include "crc32c.h" 34 | 35 | #define MIN_BUFSIZE_FOR_AUTOMATIC_RELEASE 32 * 1024 /* threshold for GIL release is 32KiB */ 36 | 37 | /* Used in other files so needs global visibility */ 38 | int is_big_endian; 39 | 40 | typedef struct _CRC32CState { 41 | crc_function crc_fn; 42 | } CRC32CState; 43 | 44 | CRC32CState *get_state(PyObject *module) 45 | { 46 | return (CRC32CState *)PyModule_GetState(module); 47 | } 48 | 49 | static inline int crc32c_inline(crc_function crc_fn, uint32_t crc, unsigned char *bin_data, Py_ssize_t len) { 50 | int result; 51 | crc ^= 0xffffffff; 52 | result = crc_fn(crc, bin_data, len); 53 | result ^= 0xffffffff; 54 | return result; 55 | } 56 | 57 | static 58 | PyObject* crc32c_crc32c(PyObject *module, PyObject *args, PyObject *kwargs) { 59 | Py_buffer pbin; 60 | unsigned char *bin_data = NULL; 61 | uint32_t crc = 0U, result; 62 | int gil_release_mode = -1; 63 | 64 | static char *kwlist[] = {"data", "value", "gil_release_mode", NULL}; 65 | 66 | /* In python 3 we accept only bytes-like objects */ 67 | const char *format ="y*|Ii:crc32"; 68 | 69 | crc_function crc_fn = get_state(module)->crc_fn; 70 | if (!crc_fn) { 71 | PyErr_SetString( 72 | PyExc_RuntimeError, 73 | "crc32c: software mode disabled and no hardware acceleration found, can't calculate checksum" 74 | ); 75 | return NULL; 76 | } 77 | 78 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, format, kwlist, &pbin, &crc, &gil_release_mode) ) 79 | return NULL; 80 | 81 | bin_data = pbin.buf; 82 | #ifndef Py_GIL_DISABLED 83 | if ((gil_release_mode < 0 && pbin.len >= MIN_BUFSIZE_FOR_AUTOMATIC_RELEASE) || gil_release_mode >= 1) 84 | { 85 | Py_BEGIN_ALLOW_THREADS 86 | result = crc32c_inline(crc_fn, crc, bin_data, pbin.len); 87 | Py_END_ALLOW_THREADS 88 | } 89 | else 90 | #endif 91 | { 92 | result = crc32c_inline(crc_fn, crc, bin_data, pbin.len); 93 | } 94 | 95 | PyBuffer_Release(&pbin); 96 | return PyLong_FromUnsignedLong(result); 97 | } 98 | 99 | static 100 | PyObject *crc32c_crc32(PyObject *self, PyObject *args, PyObject *kwargs) 101 | { 102 | if (PyErr_WarnEx(PyExc_DeprecationWarning, 103 | "crc32c.crc32 will be eventually removed, use crc32c.crc32c instead", 104 | 1) == -1) { 105 | return NULL; 106 | } 107 | return crc32c_crc32c(self, args, kwargs); 108 | } 109 | 110 | /* The different values the SW mode preference can take */ 111 | enum crc32c_sw_mode { 112 | UNSPECIFIED, 113 | AUTO, 114 | FORCE, 115 | NONE 116 | }; 117 | 118 | static enum crc32c_sw_mode get_sw_mode(void) 119 | { 120 | char *sw_mode = getenv("CRC32C_SW_MODE"); 121 | if (sw_mode == NULL) { 122 | return UNSPECIFIED; 123 | } 124 | else if (!strcmp(sw_mode, "auto")) { 125 | return AUTO; 126 | } 127 | else if (!strcmp(sw_mode, "force")) { 128 | return FORCE; 129 | } 130 | else if (!strcmp(sw_mode, "none")) { 131 | return NONE; 132 | } 133 | return UNSPECIFIED; 134 | } 135 | 136 | #ifdef CRC32C_CAN_PROBE_HW 137 | static int get_skip_hw_probe(void) 138 | { 139 | char *skip_hw_probe = getenv("CRC32C_SKIP_HW_PROBE"); 140 | if (skip_hw_probe == NULL) { 141 | return 0; 142 | } 143 | return !strcmp(skip_hw_probe, "1"); 144 | } 145 | #endif 146 | 147 | static PyMethodDef CRC32CMethods[] = { 148 | {"crc32", (PyCFunction)crc32c_crc32, METH_VARARGS | METH_KEYWORDS, "Calculate crc32c incrementally (deprecated)"}, 149 | {"crc32c", (PyCFunction)crc32c_crc32c, METH_VARARGS | METH_KEYWORDS, "Calculate crc32c incrementally"}, 150 | {NULL, NULL, 0, NULL} /* Sentinel */ 151 | }; 152 | 153 | static int crc32c_mod_exec(PyObject *module); 154 | 155 | static PyModuleDef_Slot CRC32CSlots[] = { 156 | {Py_mod_exec, crc32c_mod_exec}, 157 | #if PY_VERSION_HEX >= 0x030C0000 158 | {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, 159 | #endif 160 | #ifdef Py_GIL_DISABLED 161 | {Py_mod_gil, Py_MOD_GIL_NOT_USED}, 162 | #endif 163 | {0, NULL} 164 | }; 165 | 166 | static const char *no_hw_or_sw_error_msg = "\n\n" 167 | "Hardware extensions providing a crc32c hardware instruction are not available in\n" 168 | "your processor. This package comes with a software implementation, but this\n" 169 | "support has been opted out because the CRC32C_SW_MODE environment variable is\n" 170 | "set to \"none\", and therefore any checksum calculation will result in a\n" 171 | "RuntimeError. CRC32C_SW_MODE can take one of the following values:\n" 172 | " * If unset: use the software implementation if no hardware support is found\n" 173 | " * 'auto': as above, but will eventually be discontinued\n" 174 | " * 'force': use software implementation regardless of hardware support.\n" 175 | " * 'none': fail if no hardware support is found.\n"; 176 | 177 | static struct PyModuleDef crc32c_def = { 178 | .m_base = PyModuleDef_HEAD_INIT, 179 | .m_name = "_crc32c", 180 | .m_doc = "crc32c implementation in hardware and software", 181 | .m_size = sizeof(CRC32CState), 182 | .m_methods = CRC32CMethods, 183 | .m_slots = CRC32CSlots, 184 | .m_traverse = NULL, 185 | .m_clear = NULL, 186 | .m_free = NULL, 187 | }; 188 | 189 | PyMODINIT_FUNC PyInit__crc32c(void) 190 | { 191 | return PyModuleDef_Init(&crc32c_def); 192 | } 193 | 194 | static int crc32c_mod_exec(PyObject *module) { 195 | PyObject *hardware_based; 196 | enum crc32c_sw_mode sw_mode; 197 | const uint32_t n = 1; 198 | #ifdef CRC32C_CAN_PROBE_HW 199 | int skip_hw_probe; 200 | #endif 201 | 202 | sw_mode = get_sw_mode(); 203 | #ifdef CRC32C_CAN_PROBE_HW 204 | skip_hw_probe = get_skip_hw_probe(); 205 | #endif 206 | crc_function crc_fn = NULL; 207 | if (sw_mode == FORCE) { 208 | crc_fn = _crc32c_sw_slicing_by_8; 209 | hardware_based = Py_False; 210 | } 211 | #if defined(IS_INTEL) 212 | else if (!skip_hw_probe && _crc32c_intel_probe()) { 213 | crc_fn = _crc32c_hw_adler; 214 | crc32c_init_hw_adler(); 215 | hardware_based = Py_True; 216 | } 217 | #elif defined(IS_ARM) && (defined(__linux__) || defined(linux)) 218 | else if (!skip_hw_probe && _crc32c_arm64_probe()) { 219 | crc_fn = _crc32c_hw_arm64; 220 | hardware_based = Py_True; 221 | } 222 | #endif 223 | else if (sw_mode == UNSPECIFIED || sw_mode == AUTO) { 224 | crc_fn = _crc32c_sw_slicing_by_8; 225 | hardware_based = Py_False; 226 | } 227 | else if (sw_mode == NONE) { 228 | if (PyErr_WarnEx(PyExc_RuntimeWarning, 229 | no_hw_or_sw_error_msg, 230 | 1) == -1) { 231 | return -1; 232 | } 233 | hardware_based = Py_False; 234 | } 235 | 236 | is_big_endian = (*(const char *)(&n) == 0); 237 | 238 | Py_INCREF(hardware_based); 239 | get_state(module)->crc_fn = crc_fn; 240 | if (PyModule_AddObject(module, "hardware_based", hardware_based) < 0) { 241 | return -1; 242 | } 243 | if (PyModule_AddIntConstant(module, "big_endian", is_big_endian) < 0) { 244 | return -1; 245 | } 246 | return 0; 247 | } 248 | -------------------------------------------------------------------------------- /src/crc32c/ext/checkarm.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Linux-specific AArch64 CRC32 instruction probing implementation 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2020 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | * 24 | */ 25 | 26 | #include "common.h" 27 | 28 | #if defined(IS_ARM) && (defined(__linux__) || defined(linux)) 29 | 30 | #include 31 | 32 | #ifndef HWCAP_CRC32 33 | /* see arch/arm64/include/uapi/asm/hwcap.h */ 34 | #define HWCAP_CRC32 (1 << 7) 35 | #endif 36 | 37 | int _crc32c_arm64_probe(void) 38 | { 39 | unsigned long auxval; 40 | auxval = getauxval(AT_HWCAP); 41 | return (auxval & HWCAP_CRC32) != 0; 42 | } 43 | 44 | #endif 45 | -------------------------------------------------------------------------------- /src/crc32c/ext/checkarm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Header file for the Linux-specific AArch64 CRC32 instruction probing implementation 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2022 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | */ 24 | 25 | #ifndef _CHECKARM_H_ 26 | #define _CHECKARM_H_ 27 | 28 | int _crc32c_arm64_probe(void); 29 | 30 | #endif -------------------------------------------------------------------------------- /src/crc32c/ext/checksse42.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Intel SSE 4.2 instruction probing implementation 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2014 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | * 24 | */ 25 | 26 | #include "common.h" 27 | 28 | #if defined(IS_INTEL) 29 | 30 | #if defined(_MSC_VER) 31 | #include 32 | 33 | int _crc32c_intel_probe(void) 34 | { 35 | int info[4]; 36 | __cpuid(info, 1); 37 | return (info[2] & (1 << 20)) != 0; 38 | } 39 | 40 | #elif defined(__GNUC__) 41 | #include 42 | 43 | int _crc32c_intel_probe(void) 44 | { 45 | unsigned int eax, ebx, ecx = 0, edx; 46 | __get_cpuid(1, &eax, &ebx, &ecx, &edx); 47 | return (ecx & (1 << 20)) != 0; 48 | } 49 | 50 | #else 51 | int _crc32c_intel_probe(void) { 52 | 53 | unsigned int ecx; 54 | 55 | asm ("movl $1, %%eax;" 56 | "cpuid;" 57 | "movl %%ecx, %0;" 58 | : "=r"(ecx) // outputs 59 | : // inputs 60 | : "eax", "ebx", "ecx", "edx"); // clobber 61 | 62 | return (ecx & (1 << 20)) != 0; 63 | } 64 | #endif // defined(_MSC_VER) 65 | 66 | #endif // defined(IS_INTEL) -------------------------------------------------------------------------------- /src/crc32c/ext/checksse42.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Header file for the SSE 4.2 probing implementation 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2014 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | */ 24 | 25 | #ifndef _CHECKSSE42_H_ 26 | #define _CHECKSSE42_H_ 27 | 28 | int _crc32c_intel_probe(void); 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/crc32c/ext/common.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Common macro definitions 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2014 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | * 24 | */ 25 | 26 | #ifndef _COMMON_H_ 27 | #define _COMMON_H_ 28 | 29 | #if defined(__x86_64__) || defined(_M_X64) || defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86) 30 | # define IS_INTEL 31 | #elif defined(__aarch64__) || defined(_M_ARM64) 32 | # define IS_ARM 33 | #endif 34 | 35 | #if defined(IS_INTEL) || (defined(IS_ARM) && (defined(__linux__) || defined(linux))) 36 | # define CRC32C_CAN_PROBE_HW 37 | #endif 38 | 39 | /* inline support (it's not a keyword in MSVC for C code) */ 40 | #if defined(_MSC_VER) 41 | # define CRC32C_INLINE __inline 42 | #else 43 | # define CRC32C_INLINE inline 44 | #endif 45 | 46 | /* switch case fallthrough annotation support */ 47 | #if defined(__STDC_VERSION__) && defined(__has_c_attribute) 48 | # if __has_c_attribute(fallthrough) && __STDC_VERSION__ >= __has_c_attribute(fallthrough) 49 | # define CRC32C_FALLTHROUGH [[fallthrough]] 50 | # endif 51 | #endif 52 | #if !defined(CRC32C_FALLTHROUGH) && defined(__has_attribute) 53 | # if __has_attribute(__fallthrough__) 54 | # define CRC32C_FALLTHROUGH __attribute__((__fallthrough__)) 55 | # endif 56 | #endif 57 | #if !defined(CRC32C_FALLTHROUGH) 58 | # define CRC32C_FALLTHROUGH (void)0 59 | #endif 60 | 61 | /* 32/64 bit detection */ 62 | #if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) ||\ 63 | (defined(_MSC_VER) && defined(_M_AMD64)) 64 | # define CRC32C_IS_64_BITS 65 | #else 66 | # undef CRC32C_IS_64_BITS 67 | #endif 68 | 69 | /* uint64_t / uint32_t / uint16_t definitions */ 70 | #if !defined(_MSC_VER) || (MSC_VER >= 1800) 71 | # include 72 | #else 73 | # include 74 | typedef unsigned __int64 uint64_t; 75 | 76 | # if ULONG_MAX == (0xffffffffUL) 77 | typedef unsigned long uint32_t; 78 | # elif UINT_MAX == (0xffffffffUL) 79 | typedef unsigned int uint32_t; 80 | # else 81 | # error "Unsupported platform" 82 | # endif 83 | 84 | # if UINT_MAX == (0xffffUL) 85 | typedef unsigned int uint16_t; 86 | # elif USHRT_MAX == (0xffffUL) 87 | typedef unsigned short uint16_t; 88 | # else 89 | # error "Unsupported platform" 90 | # endif 91 | 92 | #endif 93 | 94 | /* size_t definition */ 95 | #include 96 | 97 | /* crc32c function signature */ 98 | typedef uint32_t (* crc_function)(uint32_t crc, unsigned const char *data, unsigned long length); 99 | 100 | /* Are we big endian? */ 101 | extern int is_big_endian; 102 | 103 | #endif // _COMMON_H_ 104 | -------------------------------------------------------------------------------- /src/crc32c/ext/crc32c.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Definition of crc32c checksum implementation 3 | * 4 | * ICRAR - International Centre for Radio Astronomy Research 5 | * (c) UWA - The University of Western Australia, 2014 6 | * Copyright by UWA (in the framework of the ICRAR) 7 | * All rights reserved 8 | * 9 | * This library is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * This library is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with this library; if not, write to the Free Software 21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 | * MA 02111-1307 USA 23 | * 24 | */ 25 | 26 | #ifndef _CRC32C_H_ 27 | #define _CRC32C_H_ 28 | 29 | #include "common.h" 30 | 31 | void crc32c_init_hw_adler(void); 32 | uint32_t _crc32c_hw_arm64(uint32_t crc, const unsigned char* data, unsigned long length); 33 | uint32_t _crc32c_hw_adler(uint32_t crc, const unsigned char* data, unsigned long length); 34 | uint32_t _crc32c_sw_slicing_by_8(uint32_t crc, const unsigned char *data, unsigned long length); 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/crc32c/ext/crc32c_adler.c: -------------------------------------------------------------------------------- 1 | /* crc32c.c -- compute CRC-32C using the Intel crc32 instruction 2 | * Copyright (C) 2013 Mark Adler 3 | * Version 1.1 1 Aug 2013 Mark Adler 4 | * 5 | * Adapted by Rodrigo Tobar for inclusion in the crc32c python package 6 | */ 7 | 8 | /* 9 | This software is provided 'as-is', without any express or implied 10 | warranty. In no event will the author be held liable for any damages 11 | arising from the use of this software. 12 | 13 | Permission is granted to anyone to use this software for any purpose, 14 | including commercial applications, and to alter it and redistribute it 15 | freely, subject to the following restrictions: 16 | 17 | 1. The origin of this software must not be misrepresented; you must not 18 | claim that you wrote the original software. If you use this software 19 | in a product, an acknowledgment in the product documentation would be 20 | appreciated but is not required. 21 | 2. Altered source versions must be plainly marked as such, and must not be 22 | misrepresented as being the original software. 23 | 3. This notice may not be removed or altered from any source distribution. 24 | 25 | Mark Adler 26 | madler@alumni.caltech.edu 27 | */ 28 | 29 | /* Use hardware CRC instruction on Intel SSE 4.2 processors. This computes a 30 | CRC-32C, *not* the CRC-32 used by Ethernet and zip, gzip, etc. A software 31 | version is provided as a fall-back, as well as for speed comparisons. */ 32 | 33 | /* Version history: 34 | 1.0 10 Feb 2013 First version 35 | 1.1 1 Aug 2013 Correct comments on why three crc instructions in parallel 36 | */ 37 | 38 | /* Altered version 39 | * This version modified to fit into the benchmarking code retrieved from 40 | * http://www.evanjones.ca/crc32c.html 41 | * 1.2 20 Mar 2016 Ferry Toth - Fit into benchmarking 42 | * 1.3 07 May 2016 Ferry Toth - Applied some speed ups by putting more CRC32 in the short and long loop 43 | * - Moved crc32q into macro's and put alternative code there for 32bit operation 44 | */ 45 | 46 | #include "common.h" 47 | 48 | #if defined(IS_INTEL) 49 | 50 | #if defined(__GNUC__) 51 | # define ATTR_CRC32 __attribute__ ((target("sse4.2"))) 52 | #else 53 | # define ATTR_CRC32 54 | #endif 55 | 56 | /* 57 | * MSVC/icc don't have __builtin_ia32_crc32_* functions. Instead they have 58 | * the _mm_crc32_* intrinsics, which accomplish the same at the end of the day 59 | */ 60 | #if defined(_MSC_VER) || defined(__ICC) 61 | # include 62 | # define __builtin_ia32_crc32qi _mm_crc32_u8 63 | # define __builtin_ia32_crc32hi _mm_crc32_u16 64 | # define __builtin_ia32_crc32si _mm_crc32_u32 65 | # define __builtin_ia32_crc32di _mm_crc32_u64 66 | #endif /* defined(_MSC_VER) || defined(__ICC) */ 67 | 68 | /* CRC-32C (iSCSI) polynomial in reversed bit order. */ 69 | #define POLY 0x82f63b78 70 | 71 | /* Multiply a matrix times a vector over the Galois field of two elements, 72 | GF(2). Each element is a bit in an unsigned integer. mat must have at 73 | least as many entries as the power of two for most significant one bit in 74 | vec. */ 75 | static CRC32C_INLINE uint32_t gf2_matrix_times ( uint32_t *mat, uint32_t vec ) 76 | { 77 | uint32_t sum; 78 | 79 | sum = 0; 80 | while ( vec ) { 81 | if ( vec & 1 ) 82 | sum ^= *mat; 83 | vec >>= 1; 84 | mat++; 85 | } 86 | return sum; 87 | } 88 | 89 | /* Multiply a matrix by itself over GF(2). Both mat and square must have 32 90 | rows. */ 91 | static CRC32C_INLINE void gf2_matrix_square ( uint32_t *square, uint32_t *mat ) 92 | { 93 | int n; 94 | 95 | for ( n = 0; n < 32; n++ ) 96 | square[n] = gf2_matrix_times ( mat, mat[n] ); 97 | } 98 | 99 | /* Construct an operator to apply len zeros to a crc. len must be a power of 100 | two. If len is not a power of two, then the result is the same as for the 101 | largest power of two less than len. The result for len == 0 is the same as 102 | for len == 1. A version of this routine could be easily written for any 103 | len, but that is not needed for this application. */ 104 | static void crc32c_zeros_op ( uint32_t *even, size_t len ) 105 | { 106 | int n; 107 | uint32_t row; 108 | uint32_t odd[32]; /* odd-power-of-two zeros operator */ 109 | 110 | /* put operator for one zero bit in odd */ 111 | odd[0] = POLY; /* CRC-32C polynomial */ 112 | row = 1; 113 | for ( n = 1; n < 32; n++ ) { 114 | odd[n] = row; 115 | row <<= 1; 116 | } 117 | 118 | /* put operator for two zero bits in even */ 119 | gf2_matrix_square ( even, odd ); 120 | 121 | /* put operator for four zero bits in odd */ 122 | gf2_matrix_square ( odd, even ); 123 | 124 | /* first square will put the operator for one zero byte (eight zero bits), 125 | in even -- next square puts operator for two zero bytes in odd, and so 126 | on, until len has been rotated down to zero */ 127 | do { 128 | gf2_matrix_square ( even, odd ); 129 | len >>= 1; 130 | if ( len == 0 ) 131 | return; 132 | gf2_matrix_square ( odd, even ); 133 | len >>= 1; 134 | } while ( len ); 135 | 136 | /* answer ended up in odd -- copy to even */ 137 | for ( n = 0; n < 32; n++ ) 138 | even[n] = odd[n]; 139 | } 140 | 141 | /* Take a length and build four lookup tables for applying the zeros operator 142 | for that length, byte-by-byte on the operand. */ 143 | static void crc32c_zeros ( uint32_t zeros[][256], size_t len ) 144 | { 145 | uint32_t n; 146 | uint32_t op[32]; 147 | 148 | crc32c_zeros_op ( op, len ); 149 | for ( n = 0; n < 256; n++ ) { 150 | zeros[0][n] = gf2_matrix_times ( op, n ); 151 | zeros[1][n] = gf2_matrix_times ( op, n << 8 ); 152 | zeros[2][n] = gf2_matrix_times ( op, n << 16 ); 153 | zeros[3][n] = gf2_matrix_times ( op, n << 24 ); 154 | } 155 | } 156 | 157 | 158 | /* Apply the zeros operator table to crc. */ 159 | static CRC32C_INLINE uint32_t crc32c_shift ( uint32_t zeros[][256], uint32_t crc ) 160 | { 161 | return zeros[0][crc & 0xff] ^ zeros[1][ ( crc >> 8 ) & 0xff] ^ 162 | zeros[2][ ( crc >> 16 ) & 0xff] ^ zeros[3][crc >> 24]; 163 | } 164 | 165 | /* Block sizes for three-way parallel crc computation. LONG and SHORT must 166 | both be powers of two. The associated string constants must be set 167 | accordingly, for use in constructing the assembler instructions. */ 168 | #define LONG 8192 169 | #define LONGx1 "8192" 170 | #define LONGx2 "16384" 171 | #define SHORT 256 172 | #define SHORTx1 "256" 173 | #define SHORTx2 "512" 174 | 175 | /* Tables for hardware crc that shift a crc by LONG and SHORT zeros. */ 176 | static uint32_t crc32c_long[4][256]; 177 | static uint32_t crc32c_short[4][256]; 178 | 179 | /* Initialize tables for shifting crcs. */ 180 | void crc32c_init_hw_adler( void ) 181 | { 182 | crc32c_zeros ( crc32c_long, LONG ); 183 | crc32c_zeros ( crc32c_short, SHORT ); 184 | } 185 | 186 | #ifndef CRC32C_IS_64_BITS 187 | #define CRCtriplet(crc, buf, size, i) \ 188 | crc ## 0 = __builtin_ia32_crc32si(crc ## 0, *(uint32_t*) (buf + i)); \ 189 | crc ## 1 = __builtin_ia32_crc32si(crc ## 1, *(uint32_t*) (buf + i + size)); \ 190 | crc ## 2 = __builtin_ia32_crc32si(crc ## 2, *(uint32_t*) (buf + i + 2 * size)); \ 191 | crc ## 0 = __builtin_ia32_crc32si(crc ## 0, *(uint32_t*) (buf + sizeof(uint32_t) + i)); \ 192 | crc ## 1 = __builtin_ia32_crc32si(crc ## 1, *(uint32_t*) (buf + sizeof(uint32_t) + i + size)); \ 193 | crc ## 2 = __builtin_ia32_crc32si(crc ## 2, *(uint32_t*) (buf + sizeof(uint32_t) + i + 2 * size)); 194 | #else 195 | #define CRCtriplet(crc, buf, size, i) \ 196 | crc ## 0 = __builtin_ia32_crc32di(crc ## 0, *(uint64_t*) (buf + i)); \ 197 | crc ## 1 = __builtin_ia32_crc32di(crc ## 1, *(uint64_t*) (buf + i + size)); \ 198 | crc ## 2 = __builtin_ia32_crc32di(crc ## 2, *(uint64_t*) (buf + i + 2 * size)); 199 | #endif 200 | 201 | 202 | #ifndef CRC32C_IS_64_BITS 203 | #define CRCsinglet(crc, buf) \ 204 | crc = __builtin_ia32_crc32si(crc, *(uint32_t*)buf); \ 205 | crc = __builtin_ia32_crc32si(crc, *(uint32_t*)(buf + sizeof(uint32_t))); \ 206 | buf+= 2 *sizeof(uint32_t); 207 | #else 208 | #define CRCsinglet(crc, buf) crc = __builtin_ia32_crc32di(crc, *(uint64_t*)buf); buf+= sizeof(uint64_t); 209 | #endif 210 | 211 | /* Compute CRC-32C using the Intel hardware instruction. */ 212 | ATTR_CRC32 uint32_t _crc32c_hw_adler(uint32_t crc, const unsigned char *buf, unsigned long len) 213 | { 214 | const unsigned char *next = buf; 215 | const unsigned char *end; 216 | unsigned short count; 217 | 218 | #ifndef CRC32C_IS_64_BITS 219 | uint32_t crc0, crc1, crc2; 220 | #else 221 | uint64_t crc0, crc1, crc2; /* need to be 64 bits for crc32q */ 222 | #endif 223 | uint32_t crc32bit; 224 | 225 | crc32bit = crc; 226 | // in len > 256 compute the crc for up to seven leading bytes to bring the data pointer to an eight-byte boundary 227 | if ( len > 128 ) { 228 | unsigned char align = ( 8 - ( uintptr_t ) next ) % 8; // byte to boundary 229 | len -= align; 230 | if ( ( align % 2 ) != 0 ) crc32bit = __builtin_ia32_crc32qi ( crc32bit, *next ); 231 | next += align; 232 | switch ( align / 2 ) { 233 | case 3: 234 | crc32bit = __builtin_ia32_crc32hi ( crc32bit, * ( uint16_t* ) ( next - 6 ) ); // 6 char, remain 4 235 | CRC32C_FALLTHROUGH; 236 | case 2: 237 | crc32bit = __builtin_ia32_crc32si ( crc32bit, * ( uint32_t* ) ( next - 4 ) ); // 4 char, remain 0 238 | break; 239 | case 1: 240 | crc32bit = __builtin_ia32_crc32hi ( crc32bit, * ( uint16_t* ) ( next - 2 ) ); // 2 char, remain 0 241 | break; 242 | case 0: 243 | break; 244 | } 245 | }; 246 | 247 | /* compute the crc on sets of LONG*3 bytes, executing three independent crc 248 | instructions, each on LONG bytes -- this is optimized for the Nehalem, 249 | Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a 250 | throughput of one crc per cycle, but a latency of three cycles */ 251 | 252 | crc0 = crc32bit; 253 | while ( len >= LONG*3 ) { 254 | crc1 = 0; 255 | crc2 = 0; 256 | end = next + LONG; 257 | do { 258 | CRCtriplet ( crc, next, LONG, 0 ); 259 | CRCtriplet ( crc, next, LONG, 8 ); 260 | CRCtriplet ( crc, next, LONG, 16 ); 261 | CRCtriplet ( crc, next, LONG, 24 ); 262 | next += 32; 263 | } while ( next < end ); 264 | crc0 = crc32c_shift ( crc32c_long, (uint32_t)crc0 ) ^ crc1; 265 | crc0 = crc32c_shift ( crc32c_long, (uint32_t)crc0 ) ^ crc2; 266 | next += LONG*2; 267 | len -= LONG*3; 268 | } 269 | 270 | /* do the same thing, but now on SHORT*3 blocks for the remaining data less 271 | than a LONG*3 block */ 272 | while ( len >= SHORT*3 ) { 273 | crc1 = 0; 274 | crc2 = 0; 275 | end = next + SHORT; 276 | do { 277 | CRCtriplet ( crc, next, SHORT, 0 ); 278 | CRCtriplet ( crc, next, SHORT, 8 ); 279 | CRCtriplet ( crc, next, SHORT, 16 ); 280 | CRCtriplet ( crc, next, SHORT, 24 ); 281 | next += 32; 282 | } while ( next < end ); 283 | crc0 = crc32c_shift ( crc32c_short, (uint32_t)crc0 ) ^ crc1; 284 | crc0 = crc32c_shift ( crc32c_short, (uint32_t)crc0 ) ^ crc2; 285 | next += SHORT*2; 286 | len -= SHORT*3; 287 | } 288 | 289 | /* compute the crc on the remaining eight-byte units less than a SHORT*3 290 | block */ 291 | 292 | // use Duff's device, a for() loop inside a switch() statement. This is Legal 293 | if ( ( count = ( len - ( len & 7 ) ) ) >= 8 ) { // needs to execute crc at least once 294 | unsigned short n; 295 | len -= count; 296 | count /= 8; // count number of crc32di 297 | n = ( count + 15 ) / 16; 298 | switch ( count % 16 ) { 299 | case 0: 300 | do { 301 | CRCsinglet ( crc0, next ); 302 | CRC32C_FALLTHROUGH; 303 | case 15: 304 | CRCsinglet ( crc0, next ); 305 | CRC32C_FALLTHROUGH; 306 | case 14: 307 | CRCsinglet ( crc0, next ); 308 | CRC32C_FALLTHROUGH; 309 | case 13: 310 | CRCsinglet ( crc0, next ); 311 | CRC32C_FALLTHROUGH; 312 | case 12: 313 | CRCsinglet ( crc0, next ); 314 | CRC32C_FALLTHROUGH; 315 | case 11: 316 | CRCsinglet ( crc0, next ); 317 | CRC32C_FALLTHROUGH; 318 | case 10: 319 | CRCsinglet ( crc0, next ); 320 | CRC32C_FALLTHROUGH; 321 | case 9: 322 | CRCsinglet ( crc0, next ); 323 | CRC32C_FALLTHROUGH; 324 | case 8: 325 | CRCsinglet ( crc0, next ); 326 | CRC32C_FALLTHROUGH; 327 | case 7: 328 | CRCsinglet ( crc0, next ); 329 | CRC32C_FALLTHROUGH; 330 | case 6: 331 | CRCsinglet ( crc0, next ); 332 | CRC32C_FALLTHROUGH; 333 | case 5: 334 | CRCsinglet ( crc0, next ); 335 | CRC32C_FALLTHROUGH; 336 | case 4: 337 | CRCsinglet ( crc0, next ); 338 | CRC32C_FALLTHROUGH; 339 | case 3: 340 | CRCsinglet ( crc0, next ); 341 | CRC32C_FALLTHROUGH; 342 | case 2: 343 | CRCsinglet ( crc0, next ); 344 | CRC32C_FALLTHROUGH; 345 | case 1: 346 | CRCsinglet ( crc0, next ); 347 | } while ( --n > 0 ); 348 | } 349 | }; 350 | 351 | /* compute the crc for up to seven trailing bytes */ 352 | crc32bit = (uint32_t)crc0; 353 | if ( ( len % 2 ) != 0 ) crc32bit = __builtin_ia32_crc32qi ( crc32bit, * ( next ) ); // 1 char, remain even 354 | next += len; 355 | switch ( len / 2 ) { 356 | case 3: 357 | crc32bit = __builtin_ia32_crc32hi ( crc32bit, * ( uint16_t* ) ( next - 6 ) ); // 2 char, remain 4 358 | CRC32C_FALLTHROUGH; 359 | case 2: 360 | crc32bit = __builtin_ia32_crc32si ( crc32bit, * ( uint32_t* ) ( next - 4 ) ); // 4 char, remain 0 361 | break; 362 | case 1: 363 | crc32bit = __builtin_ia32_crc32hi ( crc32bit, * ( uint16_t* ) ( next - 2 ) ); // 2 char, remain 0 364 | break; 365 | case 0: 366 | break; 367 | } 368 | return ( uint32_t ) crc32bit; 369 | } 370 | 371 | #endif // defined(IS_INTEL) 372 | -------------------------------------------------------------------------------- /src/crc32c/ext/crc32c_arm64.c: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The CRC32C Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE.google-crc32c file. See the AUTHORS.google-crc32c file 4 | // for names of contributors. 5 | 6 | // In a separate source file to allow this accelerated CRC32C function to be 7 | // compiled with the appropriate compiler flags to enable ARM NEON CRC32C 8 | // instructions. 9 | 10 | // This implementation is based on https://github.com/google/leveldb/pull/490. 11 | // 12 | // Adjusted from https://github.com/google/crc32c to be fit for inclusion 13 | // into this python package 14 | 15 | #include "common.h" 16 | 17 | #if defined(IS_ARM) && (defined(__linux__) || defined(linux)) 18 | 19 | #if defined(__GNUC__) 20 | # pragma GCC target ("+crc+crypto") 21 | #endif 22 | 23 | #include 24 | #include 25 | 26 | #include 27 | #include 28 | 29 | #define KBYTES 1032 30 | #define SEGMENTBYTES 256 31 | 32 | // compute 8bytes for each segment parallelly 33 | #define CRC32C32BYTES(P, IND) \ 34 | do { \ 35 | crc1 = __crc32cd( \ 36 | crc1, *((const uint64_t *)(P) + (SEGMENTBYTES / 8) * 1 + (IND))); \ 37 | crc2 = __crc32cd( \ 38 | crc2, *((const uint64_t *)(P) + (SEGMENTBYTES / 8) * 2 + (IND))); \ 39 | crc3 = __crc32cd( \ 40 | crc3, *((const uint64_t *)(P) + (SEGMENTBYTES / 8) * 3 + (IND))); \ 41 | crc0 = __crc32cd( \ 42 | crc0, *((const uint64_t *)(P) + (SEGMENTBYTES / 8) * 0 + (IND))); \ 43 | } while (0); 44 | 45 | // compute 8*8 bytes for each segment parallelly 46 | #define CRC32C256BYTES(P, IND) \ 47 | do { \ 48 | CRC32C32BYTES((P), (IND)*8 + 0) \ 49 | CRC32C32BYTES((P), (IND)*8 + 1) \ 50 | CRC32C32BYTES((P), (IND)*8 + 2) \ 51 | CRC32C32BYTES((P), (IND)*8 + 3) \ 52 | CRC32C32BYTES((P), (IND)*8 + 4) \ 53 | CRC32C32BYTES((P), (IND)*8 + 5) \ 54 | CRC32C32BYTES((P), (IND)*8 + 6) \ 55 | CRC32C32BYTES((P), (IND)*8 + 7) \ 56 | } while (0); 57 | 58 | // compute 4*8*8 bytes for each segment parallelly 59 | #define CRC32C1024BYTES(P) \ 60 | do { \ 61 | CRC32C256BYTES((P), 0) \ 62 | CRC32C256BYTES((P), 1) \ 63 | CRC32C256BYTES((P), 2) \ 64 | CRC32C256BYTES((P), 3) \ 65 | (P) += 4 * SEGMENTBYTES; \ 66 | } while (0) 67 | 68 | 69 | uint32_t _crc32c_hw_arm64(uint32_t crc, const uint8_t *data, size_t size) { 70 | int64_t length = size; 71 | uint32_t crc0, crc1, crc2, crc3; 72 | uint64_t t0, t1, t2; 73 | 74 | // k0=CRC(x^(3*SEGMENTBYTES*8)), k1=CRC(x^(2*SEGMENTBYTES*8)), 75 | // k2=CRC(x^(SEGMENTBYTES*8)) 76 | const poly64_t k0 = 0x8d96551c, k1 = 0xbd6f81f8, k2 = 0xdcb17aa4; 77 | 78 | while (length >= KBYTES) { 79 | crc0 = crc; 80 | crc1 = 0; 81 | crc2 = 0; 82 | crc3 = 0; 83 | 84 | // Process 1024 bytes in parallel. 85 | CRC32C1024BYTES(data); 86 | 87 | // Merge the 4 partial CRC32C values. 88 | t2 = (uint64_t)vmull_p64(crc2, k2); 89 | t1 = (uint64_t)vmull_p64(crc1, k1); 90 | t0 = (uint64_t)vmull_p64(crc0, k0); 91 | crc = __crc32cd(crc3, *(uint64_t *)data); 92 | data += sizeof(uint64_t); 93 | crc ^= __crc32cd(0, t2); 94 | crc ^= __crc32cd(0, t1); 95 | crc ^= __crc32cd(0, t0); 96 | 97 | length -= KBYTES; 98 | } 99 | 100 | while (length >= 8) { 101 | crc = __crc32cd(crc, *(uint64_t *)data); 102 | data += 8; 103 | length -= 8; 104 | } 105 | 106 | if (length & 4) { 107 | crc = __crc32cw(crc, *(uint32_t *)data); 108 | data += 4; 109 | } 110 | 111 | if (length & 2) { 112 | crc = __crc32ch(crc, *(uint16_t *)data); 113 | data += 2; 114 | } 115 | 116 | if (length & 1) { 117 | crc = __crc32cb(crc, *data); 118 | } 119 | 120 | return crc; 121 | } 122 | 123 | #endif 124 | -------------------------------------------------------------------------------- /src/crc32c/ext/crc32c_sw.c: -------------------------------------------------------------------------------- 1 | // Copyright 2008,2009,2010 Massachusetts Institute of Technology. 2 | // All rights reserved. Use of this source code is governed by a 3 | // BSD-style license that can be found in the LICENSE.slice-by-8 file. 4 | 5 | // Implementations adapted from Intel's Slicing By 8 Sourceforge Project 6 | // http://sourceforge.net/projects/slicing-by-8/ 7 | /* 8 | * Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved 9 | * 10 | * 11 | * This software program is licensed subject to the BSD License, 12 | * available at http://www.opensource.org/licenses/bsd-license.html. 13 | * 14 | * Abstract: 15 | * 16 | * Tables for software CRC generation 17 | */ 18 | 19 | 20 | /* Tables generated with code like the following: 21 | 22 | #define CRCPOLY 0x82f63b78 // reversed 0x1EDC6F41 23 | #define CRCINIT 0xFFFFFFFF 24 | 25 | void init() { 26 | for (uint32_t i = 0; i <= 0xFF; i++) { 27 | uint32_t x = i; 28 | for (uint32_t j = 0; j < 8; j++) 29 | x = (x>>1) ^ (CRCPOLY & (-(int32_t)(x & 1))); 30 | g_crc_slicing[0][i] = x; 31 | } 32 | 33 | for (uint32_t i = 0; i <= 0xFF; i++) { 34 | uint32_t c = g_crc_slicing[0][i]; 35 | for (uint32_t j = 1; j < 8; j++) { 36 | c = g_crc_slicing[0][c & 0xFF] ^ (c >> 8); 37 | g_crc_slicing[j][i] = c; 38 | } 39 | } 40 | } 41 | */ 42 | 43 | #include "crc32c.h" 44 | 45 | /* 46 | * The following CRC lookup table was generated automagically 47 | * using the following model parameters: 48 | * 49 | * Generator Polynomial = ................. 0x1EDC6F41 50 | * Generator Polynomial Length = .......... 32 bits 51 | * Reflected Bits = ....................... TRUE 52 | * Table Generation Offset = .............. 32 bits 53 | * Number of Slices = ..................... 8 slices 54 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 55 | * Directory Name = ....................... .\ 56 | * File Name = ............................ 8x256_tables.c 57 | */ 58 | 59 | const uint32_t crc_tableil8_o32[256] = 60 | { 61 | 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 62 | 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 63 | 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 64 | 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 65 | 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 66 | 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 67 | 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 68 | 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 69 | 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 70 | 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 71 | 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 72 | 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 73 | 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 74 | 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 75 | 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 76 | 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 77 | 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 78 | 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 79 | 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 80 | 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 81 | 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 82 | 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 83 | 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 84 | 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 85 | 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 86 | 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 87 | 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 88 | 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 89 | 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 90 | 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 91 | 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 92 | 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 93 | }; 94 | 95 | /* 96 | * end of the CRC lookup table crc_tableil8_o32 97 | */ 98 | 99 | 100 | 101 | /* 102 | * The following CRC lookup table was generated automagically 103 | * using the following model parameters: 104 | * 105 | * Generator Polynomial = ................. 0x1EDC6F41 106 | * Generator Polynomial Length = .......... 32 bits 107 | * Reflected Bits = ....................... TRUE 108 | * Table Generation Offset = .............. 32 bits 109 | * Number of Slices = ..................... 8 slices 110 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 111 | * Directory Name = ....................... .\ 112 | * File Name = ............................ 8x256_tables.c 113 | */ 114 | 115 | const uint32_t crc_tableil8_o40[256] = 116 | { 117 | 0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899, 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945, 118 | 0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21, 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD, 119 | 0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918, 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4, 120 | 0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0, 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C, 121 | 0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B, 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47, 122 | 0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823, 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF, 123 | 0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A, 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6, 124 | 0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2, 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E, 125 | 0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D, 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41, 126 | 0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25, 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9, 127 | 0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C, 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0, 128 | 0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4, 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78, 129 | 0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F, 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43, 130 | 0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27, 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB, 131 | 0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E, 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2, 132 | 0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6, 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A, 133 | 0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260, 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC, 134 | 0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8, 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004, 135 | 0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1, 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D, 136 | 0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059, 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185, 137 | 0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162, 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE, 138 | 0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA, 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306, 139 | 0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3, 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F, 140 | 0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B, 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287, 141 | 0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464, 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8, 142 | 0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC, 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600, 143 | 0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5, 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439, 144 | 0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D, 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781, 145 | 0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766, 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA, 146 | 0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE, 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502, 147 | 0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7, 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B, 148 | 0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F, 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483 149 | }; 150 | 151 | /* 152 | * end of the CRC lookup table crc_tableil8_o40 153 | */ 154 | 155 | 156 | 157 | /* 158 | * The following CRC lookup table was generated automagically 159 | * using the following model parameters: 160 | * 161 | * Generator Polynomial = ................. 0x1EDC6F41 162 | * Generator Polynomial Length = .......... 32 bits 163 | * Reflected Bits = ....................... TRUE 164 | * Table Generation Offset = .............. 32 bits 165 | * Number of Slices = ..................... 8 slices 166 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 167 | * Directory Name = ....................... .\ 168 | * File Name = ............................ 8x256_tables.c 169 | */ 170 | 171 | const uint32_t crc_tableil8_o48[256] = 172 | { 173 | 0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073, 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469, 174 | 0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6, 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC, 175 | 0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9, 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3, 176 | 0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C, 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726, 177 | 0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67, 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D, 178 | 0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2, 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8, 179 | 0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED, 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7, 180 | 0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828, 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32, 181 | 0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA, 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0, 182 | 0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F, 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75, 183 | 0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20, 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A, 184 | 0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5, 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF, 185 | 0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE, 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4, 186 | 0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B, 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161, 187 | 0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634, 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E, 188 | 0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1, 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB, 189 | 0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730, 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A, 190 | 0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5, 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF, 191 | 0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA, 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0, 192 | 0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F, 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065, 193 | 0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24, 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E, 194 | 0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1, 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB, 195 | 0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE, 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4, 196 | 0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B, 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71, 197 | 0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9, 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3, 198 | 0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C, 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36, 199 | 0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63, 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79, 200 | 0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6, 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC, 201 | 0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD, 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7, 202 | 0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238, 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622, 203 | 0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177, 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D, 204 | 0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2, 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8 205 | }; 206 | 207 | /* 208 | * end of the CRC lookup table crc_tableil8_o48 209 | */ 210 | 211 | 212 | 213 | /* 214 | * The following CRC lookup table was generated automagically 215 | * using the following model parameters: 216 | * 217 | * Generator Polynomial = ................. 0x1EDC6F41 218 | * Generator Polynomial Length = .......... 32 bits 219 | * Reflected Bits = ....................... TRUE 220 | * Table Generation Offset = .............. 32 bits 221 | * Number of Slices = ..................... 8 slices 222 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 223 | * Directory Name = ....................... .\ 224 | * File Name = ............................ 8x256_tables.c 225 | */ 226 | 227 | const uint32_t crc_tableil8_o56[256] = 228 | { 229 | 0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939, 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA, 230 | 0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF, 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C, 231 | 0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804, 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7, 232 | 0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2, 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11, 233 | 0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2, 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41, 234 | 0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54, 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7, 235 | 0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F, 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C, 236 | 0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69, 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A, 237 | 0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE, 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D, 238 | 0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538, 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB, 239 | 0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3, 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610, 240 | 0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405, 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6, 241 | 0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255, 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6, 242 | 0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3, 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040, 243 | 0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368, 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B, 244 | 0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E, 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D, 245 | 0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006, 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5, 246 | 0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0, 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213, 247 | 0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B, 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8, 248 | 0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD, 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E, 249 | 0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D, 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E, 250 | 0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B, 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698, 251 | 0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0, 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443, 252 | 0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656, 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5, 253 | 0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1, 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12, 254 | 0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07, 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4, 255 | 0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC, 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F, 256 | 0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A, 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9, 257 | 0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A, 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99, 258 | 0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C, 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F, 259 | 0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57, 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4, 260 | 0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1, 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842 261 | }; 262 | 263 | /* 264 | * end of the CRC lookup table crc_tableil8_o56 265 | */ 266 | 267 | 268 | 269 | /* 270 | * The following CRC lookup table was generated automagically 271 | * using the following model parameters: 272 | * 273 | * Generator Polynomial = ................. 0x1EDC6F41 274 | * Generator Polynomial Length = .......... 32 bits 275 | * Reflected Bits = ....................... TRUE 276 | * Table Generation Offset = .............. 32 bits 277 | * Number of Slices = ..................... 8 slices 278 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 279 | * Directory Name = ....................... .\ 280 | * File Name = ............................ 8x256_tables.c 281 | */ 282 | 283 | const uint32_t crc_tableil8_o64[256] = 284 | { 285 | 0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4, 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44, 286 | 0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65, 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5, 287 | 0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127, 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97, 288 | 0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6, 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406, 289 | 0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3, 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13, 290 | 0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32, 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082, 291 | 0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470, 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0, 292 | 0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1, 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151, 293 | 0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A, 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA, 294 | 0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB, 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B, 295 | 0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89, 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539, 296 | 0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018, 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8, 297 | 0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D, 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD, 298 | 0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C, 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C, 299 | 0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE, 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E, 300 | 0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F, 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF, 301 | 0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8, 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18, 302 | 0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39, 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089, 303 | 0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B, 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB, 304 | 0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA, 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A, 305 | 0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF, 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F, 306 | 0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E, 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE, 307 | 0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C, 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C, 308 | 0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD, 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D, 309 | 0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06, 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6, 310 | 0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497, 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27, 311 | 0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5, 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065, 312 | 0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544, 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4, 313 | 0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51, 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1, 314 | 0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0, 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70, 315 | 0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82, 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532, 316 | 0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013, 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3 317 | }; 318 | 319 | /* 320 | * end of the CRC lookup table crc_tableil8_o64 321 | */ 322 | 323 | 324 | 325 | /* 326 | * The following CRC lookup table was generated automagically 327 | * using the following model parameters: 328 | * 329 | * Generator Polynomial = ................. 0x1EDC6F41 330 | * Generator Polynomial Length = .......... 32 bits 331 | * Reflected Bits = ....................... TRUE 332 | * Table Generation Offset = .............. 32 bits 333 | * Number of Slices = ..................... 8 slices 334 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 335 | * Directory Name = ....................... .\ 336 | * File Name = ............................ 8x256_tables.c 337 | */ 338 | 339 | const uint32_t crc_tableil8_o72[256] = 340 | { 341 | 0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA, 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD, 342 | 0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5, 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2, 343 | 0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4, 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93, 344 | 0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB, 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C, 345 | 0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57, 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20, 346 | 0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548, 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F, 347 | 0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69, 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E, 348 | 0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576, 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201, 349 | 0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031, 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746, 350 | 0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E, 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59, 351 | 0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F, 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778, 352 | 0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810, 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67, 353 | 0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC, 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB, 354 | 0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3, 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4, 355 | 0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682, 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5, 356 | 0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D, 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA, 357 | 0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C, 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B, 358 | 0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413, 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364, 359 | 0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32, 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45, 360 | 0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D, 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A, 361 | 0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81, 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6, 362 | 0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E, 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9, 363 | 0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF, 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8, 364 | 0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0, 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7, 365 | 0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7, 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090, 366 | 0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8, 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F, 367 | 0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9, 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE, 368 | 0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6, 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1, 369 | 0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A, 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D, 370 | 0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975, 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02, 371 | 0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154, 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623, 372 | 0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B, 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C 373 | }; 374 | 375 | /* 376 | * end of the CRC lookup table crc_tableil8_o72 377 | */ 378 | 379 | 380 | 381 | /* 382 | * The following CRC lookup table was generated automagically 383 | * using the following model parameters: 384 | * 385 | * Generator Polynomial = ................. 0x1EDC6F41 386 | * Generator Polynomial Length = .......... 32 bits 387 | * Reflected Bits = ....................... TRUE 388 | * Table Generation Offset = .............. 32 bits 389 | * Number of Slices = ..................... 8 slices 390 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 391 | * Directory Name = ....................... .\ 392 | * File Name = ............................ 8x256_tables.c 393 | */ 394 | 395 | const uint32_t crc_tableil8_o80[256] = 396 | { 397 | 0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558, 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089, 398 | 0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B, 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA, 399 | 0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE, 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F, 400 | 0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD, 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C, 401 | 0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5, 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334, 402 | 0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6, 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67, 403 | 0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43, 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992, 404 | 0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110, 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1, 405 | 0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222, 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3, 406 | 0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71, 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0, 407 | 0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884, 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55, 408 | 0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7, 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006, 409 | 0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F, 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E, 410 | 0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC, 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D, 411 | 0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39, 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8, 412 | 0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A, 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB, 413 | 0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC, 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D, 414 | 0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF, 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E, 415 | 0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A, 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB, 416 | 0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59, 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988, 417 | 0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811, 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0, 418 | 0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542, 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093, 419 | 0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7, 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766, 420 | 0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4, 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35, 421 | 0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6, 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907, 422 | 0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185, 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454, 423 | 0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670, 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1, 424 | 0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23, 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2, 425 | 0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B, 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA, 426 | 0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238, 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9, 427 | 0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD, 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C, 428 | 0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E, 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F 429 | }; 430 | 431 | /* 432 | * end of the CRC lookup table crc_tableil8_o80 433 | */ 434 | 435 | 436 | 437 | /* 438 | * The following CRC lookup table was generated automagically 439 | * using the following model parameters: 440 | * 441 | * Generator Polynomial = ................. 0x1EDC6F41 442 | * Generator Polynomial Length = .......... 32 bits 443 | * Reflected Bits = ....................... TRUE 444 | * Table Generation Offset = .............. 32 bits 445 | * Number of Slices = ..................... 8 slices 446 | * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 447 | * Directory Name = ....................... .\ 448 | * File Name = ............................ 8x256_tables.c 449 | */ 450 | 451 | const uint32_t crc_tableil8_o88[256] = 452 | { 453 | 0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769, 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504, 454 | 0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3, 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE, 455 | 0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD, 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0, 456 | 0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07, 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A, 457 | 0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0, 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D, 458 | 0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A, 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447, 459 | 0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44, 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929, 460 | 0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E, 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3, 461 | 0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B, 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36, 462 | 0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881, 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC, 463 | 0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF, 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782, 464 | 0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135, 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358, 465 | 0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2, 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF, 466 | 0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18, 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75, 467 | 0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076, 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B, 468 | 0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC, 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1, 469 | 0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D, 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360, 470 | 0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7, 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA, 471 | 0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9, 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4, 472 | 0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63, 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E, 473 | 0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494, 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9, 474 | 0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E, 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223, 475 | 0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20, 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D, 476 | 0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA, 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97, 477 | 0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F, 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852, 478 | 0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5, 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88, 479 | 0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B, 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6, 480 | 0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751, 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C, 481 | 0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6, 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB, 482 | 0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C, 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911, 483 | 0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612, 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F, 484 | 0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8, 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5 485 | }; 486 | 487 | /* 488 | * end of the CRC lookup table crc_tableil8_o88 489 | */ 490 | 491 | uint32_t _crc32c_sw_slicing_by_8(uint32_t crc, unsigned const char* data, unsigned long length) 492 | { 493 | unsigned const char* p_buf = data; 494 | size_t initial_bytes = (sizeof(uint32_t) - (intptr_t)p_buf) & (sizeof(uint32_t) - 1); 495 | size_t li; 496 | size_t running_length; 497 | size_t end_bytes; 498 | uint32_t term1; 499 | uint32_t term2; 500 | 501 | // Handle leading misaligned bytes 502 | if (length < initial_bytes) { 503 | initial_bytes = length; 504 | } 505 | for (li = 0; li < initial_bytes; li++) { 506 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 507 | } 508 | 509 | length -= initial_bytes; 510 | running_length = length & ~(sizeof(uint64_t) - 1); 511 | end_bytes = length - running_length; 512 | 513 | if (is_big_endian) { 514 | for (li = 0; li < running_length/8; li++) { 515 | crc ^= (*p_buf++); 516 | crc ^= (*p_buf++) << 8; 517 | crc ^= (*p_buf++) << 16; 518 | crc ^= (*p_buf++) << 24; 519 | term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 520 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 521 | term2 = crc >> 16; 522 | crc = term1 ^ 523 | crc_tableil8_o72[term2 & 0x000000FF] ^ 524 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 525 | crc ^= crc_tableil8_o56[*p_buf++]; 526 | crc ^= crc_tableil8_o48[*p_buf++]; 527 | crc ^= crc_tableil8_o40[*p_buf++]; 528 | crc ^= crc_tableil8_o32[*p_buf++]; 529 | } 530 | } 531 | else { 532 | for (li = 0; li < running_length/8; li++) { 533 | crc ^= *(uint32_t*) p_buf; 534 | p_buf += 4; 535 | term1 = crc_tableil8_o88[crc & 0x000000FF] ^ 536 | crc_tableil8_o80[(crc >> 8) & 0x000000FF]; 537 | term2 = crc >> 16; 538 | crc = term1 ^ 539 | crc_tableil8_o72[term2 & 0x000000FF] ^ 540 | crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; 541 | term1 = crc_tableil8_o56[(*(uint32_t *)p_buf) & 0x000000FF] ^ 542 | crc_tableil8_o48[((*(uint32_t *)p_buf) >> 8) & 0x000000FF]; 543 | 544 | term2 = (*(uint32_t *)p_buf) >> 16; 545 | crc = crc ^ term1 ^ 546 | crc_tableil8_o40[term2 & 0x000000FF] ^ 547 | crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; 548 | p_buf += 4; 549 | } 550 | } 551 | 552 | for (li = 0; li < end_bytes; li++) { 553 | crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); 554 | } 555 | 556 | return crc; 557 | } 558 | -------------------------------------------------------------------------------- /src/crc32c/py.typed: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ICRAR/crc32c/6ec76c274ff2dcb70de3a89d657d1150553a9dc6/src/crc32c/py.typed -------------------------------------------------------------------------------- /test/conftest.py: -------------------------------------------------------------------------------- 1 | # 2 | # ICRAR - International Centre for Radio Astronomy Research 3 | # (c) UWA - The University of Western Australia, 2024 4 | # Copyright by UWA (in the framework of the ICRAR) 5 | # All rights reserved 6 | # 7 | # This library is free software; you can redistribute it and/or 8 | # modify it under the terms of the GNU Lesser General Public 9 | # License as published by the Free Software Foundation; either 10 | # version 2.1 of the License, or (at your option) any later version. 11 | # 12 | # This library is distributed in the hope that it will be useful, 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | # Lesser General Public License for more details. 16 | # 17 | # You should have received a copy of the GNU Lesser General Public 18 | # License along with this library; if not, write to the Free Software 19 | # Foundation, Inc., 59 Temple Place, Suite 330, Boston, 20 | # MA 02111-1307 USA 21 | # 22 | 23 | import time 24 | 25 | import pytest 26 | 27 | import crc32c 28 | 29 | 30 | def _crc32c_is_available() -> bool: 31 | try: 32 | crc32c.crc32c(b"dummy") 33 | return True 34 | except RuntimeError: 35 | return False 36 | 37 | 38 | @pytest.fixture 39 | def crc32c_is_available() -> bool: 40 | return _crc32c_is_available() 41 | 42 | 43 | @pytest.fixture(autouse=True) 44 | def skip_if_crc32c_unavailable( 45 | request: pytest.FixtureRequest, crc32c_is_available: bool 46 | ) -> None: 47 | if request.node.get_closest_marker("calculates_crc32c") and not crc32c_is_available: 48 | pytest.skip("crc32c is not available on this platform") 49 | 50 | 51 | def pytest_sessionstart(session: pytest.Session) -> None: 52 | print("crc32c is big endian? ", crc32c.big_endian) 53 | print("crc32c is hardware based? ", crc32c.hardware_based) 54 | -------------------------------------------------------------------------------- /test/test_benchmark.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | import sys 3 | 4 | import pytest 5 | 6 | 7 | @pytest.mark.calculates_crc32c 8 | def test_benchmark() -> None: 9 | out = subprocess.check_output([sys.executable, "-m", "crc32c.benchmark"]) 10 | assert b"crc32c ran at" in out 11 | -------------------------------------------------------------------------------- /test/test_crc32c.py: -------------------------------------------------------------------------------- 1 | # 2 | # ICRAR - International Centre for Radio Astronomy Research 3 | # (c) UWA - The University of Western Australia, 2018 4 | # Copyright by UWA (in the framework of the ICRAR) 5 | # All rights reserved 6 | # 7 | # This library is free software; you can redistribute it and/or 8 | # modify it under the terms of the GNU Lesser General Public 9 | # License as published by the Free Software Foundation; either 10 | # version 2.1 of the License, or (at your option) any later version. 11 | # 12 | # This library is distributed in the hope that it will be useful, 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | # Lesser General Public License for more details. 16 | # 17 | # You should have received a copy of the GNU Lesser General Public 18 | # License along with this library; if not, write to the Free Software 19 | # Foundation, Inc., 59 Temple Place, Suite 330, Boston, 20 | # MA 02111-1307 USA 21 | # 22 | 23 | from __future__ import annotations 24 | 25 | import os 26 | import struct 27 | import warnings 28 | from typing import Generator, List, NamedTuple 29 | 30 | import pytest 31 | 32 | import crc32c 33 | 34 | 35 | def test_software_mode(crc32c_is_available: bool) -> None: 36 | """Check that the CRC32C_SW_MODE has intended consequences""" 37 | sw_mode = os.environ.get("CRC32C_SW_MODE") 38 | if sw_mode == "force": 39 | assert not crc32c.hardware_based 40 | if sw_mode == "none" and crc32c_is_available: 41 | assert crc32c.hardware_based 42 | 43 | 44 | def ulonglong_as_bytes(x: int) -> bytes: 45 | return struct.pack(" bytes: 49 | return struct.pack(" bytes: 53 | return struct.pack(" bytes: 57 | return struct.pack(" Generator[bytes, None, None]: 61 | length = len(x) 62 | for i in range(0, length, size): 63 | yield x[i : min(i + size, length)] 64 | 65 | 66 | def as_individual_bytes(x: bytes) -> Generator[bytes, None, None]: 67 | for b in x: 68 | yield bytes([b]) 69 | 70 | 71 | @pytest.mark.calculates_crc32c 72 | class TestMisc: 73 | 74 | def test_zero(self) -> None: 75 | assert 0 == crc32c.crc32c(b"") 76 | 77 | def test_keyword(self) -> None: 78 | assert 10 == crc32c.crc32c(b"", value=10) 79 | 80 | def test_gil_behaviour(self) -> None: 81 | def _test(data: bytes) -> None: 82 | expected = crc32c.crc32c(data) 83 | assert expected == crc32c.crc32c(data, gil_release_mode=-1) 84 | assert expected == crc32c.crc32c(data, gil_release_mode=0) 85 | assert expected == crc32c.crc32c(data, gil_release_mode=1) 86 | 87 | _test(b"this_doesnt_release_the_gil_by_default") 88 | _test(b"this_releases_the_gil_by_default" * 1024 * 1024) 89 | 90 | def test_crc32_deprecated(self) -> None: 91 | with warnings.catch_warnings(record=True) as warns: 92 | crc32c.crc32(b"") 93 | assert 1 == len(warns) 94 | with warnings.catch_warnings(record=True) as warns: 95 | crc32c.crc32c(b"") 96 | assert 0 == len(warns) 97 | 98 | def test_msvc_examples(self) -> None: 99 | # Examples taken from MSVC's online examples. 100 | # Values are not xor'd in the examples though, so we do it here 101 | max32 = 0xFFFFFFFF 102 | 103 | def assert_msvc_vals(b: bytes, crc: int, expected_crc: int) -> None: 104 | assert expected_crc ^ max32 == crc32c.crc32c(b, crc ^ max32) 105 | 106 | assert_msvc_vals(uchar_as_bytes(100), 1, 1412925310) 107 | assert_msvc_vals(ushort_as_bytes(1000), 1, 3870914500) 108 | assert_msvc_vals(uint_as_bytes(50000), 1, 971731851) 109 | assert_msvc_vals(ulonglong_as_bytes(0x88889999EEEE3333), 0x5555AAAA, 0x16F57621) 110 | 111 | 112 | class CRCTestValue(NamedTuple): 113 | name: str 114 | data: bytes 115 | crc: int 116 | 117 | 118 | test_values: List[CRCTestValue] = [ 119 | CRCTestValue("Numbers1", b"123456789", 0xE3069283), 120 | CRCTestValue("Numbers2", b"23456789", 0xBFE92A83), 121 | CRCTestValue("Phrase", b"The quick brown fox jumps over the lazy dog", 0x22620404), 122 | CRCTestValue( 123 | "LongPhrase", 124 | b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc omni virtuti vitium contrario nomine opponitur. " 125 | b"Conferam tecum, quam cuique verso rem subicias; Te ipsum, dignissimum maioribus tuis, voluptasne induxit, ut adolescentulus eriperes " 126 | b"P. Conclusum est enim contra Cyrenaicos satis acute, nihil ad Epicurum. Duo Reges: constructio interrete. Tum Torquatus: Prorsus, inquit, assentior;\n" 127 | b"Quando enim Socrates, qui parens philosophiae iure dici potest, quicquam tale fecit? Sed quid sentiat, non videtis. Haec quo modo conveniant, non " 128 | b"sane intellego. Sed ille, ut dixi, vitiose. Dic in quovis conventu te omnia facere, ne doleas. Quod si ita se habeat, non possit beatam praestare " 129 | b"vitam sapientia. Quis suae urbis conservatorem Codrum, quis Erechthei filias non maxime laudat? Primum divisit ineleganter; Huic mori optimum esse " 130 | b"propter desperationem sapientiae, illi propter spem vivere.", 131 | 0xFCB7575A, 132 | ), 133 | CRCTestValue("Empty", b"", 0x0), 134 | ] 135 | 136 | 137 | @pytest.mark.calculates_crc32c 138 | class TestCRC32CHash: 139 | def test_misc(self) -> None: 140 | crc32c_hash = crc32c.CRC32CHash() 141 | 142 | assert crc32c_hash.digest_size == 4 143 | assert crc32c_hash.name == "crc32c" 144 | assert len(crc32c_hash.digest()) == crc32c_hash.digest_size 145 | assert len(crc32c_hash.hexdigest()) == crc32c_hash.digest_size * 2 146 | 147 | def test_initial_value(self) -> None: 148 | crc32c_hash = crc32c.CRC32CHash() 149 | crc32c_hash.update(b"hello world") 150 | expected = crc32c_hash.digest() 151 | 152 | crc32c_hash = crc32c.CRC32CHash(b"hello") 153 | crc32c_hash.update(b" world") 154 | assert expected == crc32c_hash.digest() 155 | 156 | def test_copy(self) -> None: 157 | crc32c_hash = crc32c.CRC32CHash() 158 | crc32c_hash_copy = crc32c_hash.copy() 159 | 160 | assert crc32c_hash.digest() == crc32c_hash_copy.digest() 161 | assert crc32c_hash.hexdigest() == crc32c_hash_copy.hexdigest() 162 | assert id(crc32c_hash) != id(crc32c_hash_copy) 163 | 164 | crc32c_hash.update(b"1") 165 | assert crc32c_hash.digest() != crc32c_hash_copy.digest() 166 | assert crc32c_hash.hexdigest() != crc32c_hash_copy.hexdigest() 167 | 168 | crc32c_hash_copy.update(b"2") 169 | assert crc32c_hash.digest() != crc32c_hash_copy.digest() 170 | assert crc32c_hash.hexdigest() != crc32c_hash_copy.hexdigest() 171 | 172 | @pytest.mark.parametrize( 173 | "data,crc", 174 | [pytest.param(value.data, value.crc, id=value.name) for value in test_values], 175 | ) 176 | class TestSpecificValues: 177 | @staticmethod 178 | def _check_values(crc32c_hash: crc32c.CRC32CHash, crc: int) -> None: 179 | assert crc32c_hash.checksum == crc 180 | assert int.from_bytes(crc32c_hash.digest(), "big") == crc 181 | assert len(crc32c_hash.digest()) == 4 182 | assert int(crc32c_hash.hexdigest(), 16) == crc 183 | assert len(crc32c_hash.hexdigest()) == 8 184 | 185 | def test_piece_by_piece(self, data: bytes, crc: int) -> None: 186 | crc32c_hash = crc32c.CRC32CHash() 187 | for x in as_individual_bytes(data): 188 | crc32c_hash.update(x) 189 | self._check_values(crc32c_hash, crc) 190 | 191 | def test_all(self, data: bytes, crc: int) -> None: 192 | self._check_values(crc32c.CRC32CHash(data), crc) 193 | 194 | 195 | @pytest.mark.calculates_crc32c 196 | @pytest.mark.parametrize( 197 | "data,checksum", 198 | [pytest.param(value.data, value.crc, id=value.name) for value in test_values], 199 | ) 200 | class TestCRC32CValues: 201 | 202 | def test_all(self, data: bytes, checksum: int) -> None: 203 | assert checksum == crc32c.crc32c(data) 204 | 205 | def test_piece_by_piece(self, data: bytes, checksum: int) -> None: 206 | c = 0 207 | for x in as_individual_bytes(data): 208 | c = crc32c.crc32c(x, c) 209 | assert checksum == c 210 | 211 | def test_by_different_chunk_lenghts(self, data: bytes, checksum: int) -> None: 212 | for chunk_size in range(1, 33): 213 | c = 0 214 | for chunk in batched(data, chunk_size): 215 | c = crc32c.crc32c(bytes(chunk), c) 216 | assert checksum == c 217 | 218 | def test_by_different_memory_offsets(self, data: bytes, checksum: int) -> None: 219 | for offset in range(16): 220 | view = memoryview(data) 221 | c = crc32c.crc32c(view[0:offset]) 222 | c = crc32c.crc32c(view[offset:], c) 223 | assert checksum == c, ( 224 | "Invalid checksum when splitting at offset %d" % offset 225 | ) 226 | -------------------------------------------------------------------------------- /test/test_subinterpreter.py: -------------------------------------------------------------------------------- 1 | import contextlib 2 | from typing import Iterable, Tuple, no_type_check 3 | 4 | import pytest 5 | 6 | import crc32c 7 | 8 | try: 9 | from test.support.interpreters import Interpreter # type: ignore 10 | from test.support.interpreters import create, queues 11 | except ImportError: 12 | pytest.skip("No sub-interpreter support", allow_module_level=True) 13 | 14 | 15 | @pytest.fixture(name="interpreter") 16 | def interpreter_fixture() -> Iterable[Interpreter]: 17 | interpreter = create() 18 | with contextlib.closing(interpreter): 19 | yield interpreter 20 | 21 | 22 | def test_crc32c_can_be_loaded(interpreter: Interpreter) -> None: 23 | interpreter.exec("import crc32c") 24 | # all good, no exception raised 25 | 26 | 27 | @pytest.mark.calculates_crc32c 28 | def test_crc32c_can_run(interpreter: Interpreter) -> None: 29 | 30 | queue = queues.create() 31 | VALUE = b"test" 32 | interpreter.prepare_main(queue_id=queue.id, value_in=VALUE) 33 | 34 | @no_type_check 35 | def crc32c_in_subinterpreter() -> None: 36 | from test.support.interpreters.queues import Queue # type: ignore 37 | 38 | import crc32c 39 | 40 | queue = Queue(queue_id) 41 | value_out = crc32c.crc32c(value_in) 42 | queue.put(value_out) 43 | 44 | thread = interpreter.call_in_thread(crc32c_in_subinterpreter) 45 | result = queue.get(timeout=5) 46 | thread.join() 47 | assert result == crc32c.crc32c(VALUE) 48 | --------------------------------------------------------------------------------