github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #196 from VectorCamp/feature/prepare-5.4.11

Browse Source 
Feature/prepare 5.4.11
This commit is contained in:
Konstantinos Margaritis 2023-11-20 07:37:14 +02:00 committed by GitHub
commit 574e525c46
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 191 additions and 724 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CHANGELOG-vectorscan.md
View File

@ -2,6 +2,22 @@
This is a list of notable changes to Vectorscan, in reverse chronological order. For Hyperscan Changelog, check CHANGELOG.md
## [5.4.11] 2023-11-19
- Refactor CMake build system to be much more modular.
- version in hs.h fell out of sync again #175
- Fix compile failures with recent compilers, namely clang-15 and gcc-13
- Fix clang 15,16 compilation errors on all platforms, refactor CMake build system #181
- Fix signed/unsigned char issue on Arm with Ragel generated code.
- Correct set_source_files_properties usage #189
- Fix build failure on Ubuntu 20.04
- Support building on Ubuntu 20.04 #180
- Require pkg-config during Cmake
- make pkgconfig a requirement #188
- Fix segfault on Fat runtimes with SVE2 code
- Move VERM16 enums to the end of the list #191
- Update README.md, add CHANGELOG-vectorscan.md and Contributors-vectorscan.md files
## [5.4.10] 2023-09-23
- Fix compilation with libcxx 16 by @rschu1ze in #144
- Fix use-of-uninitialized-value due to getData128() by @azat in #148

7
CMakeLists.txt
View File

@ -4,7 +4,7 @@ project (vectorscan C CXX)
set (HS_MAJOR_VERSION 5)
set (HS_MINOR_VERSION 4)
set (HS_PATCH_VERSION 10)
set (HS_PATCH_VERSION 11)
set (HS_VERSION ${HS_MAJOR_VERSION}.${HS_MINOR_VERSION}.${HS_PATCH_VERSION})
string (TIMESTAMP BUILD_DATE "%Y-%m-%d")
@ -94,8 +94,9 @@ if (BUILD_STATIC_LIBS)
message(STATUS "Building static libraries")
endif()
if (NOT BUILD_SHARED_LIBS)
# build static libs
if (NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
# if none are set build static libs
message(STATUS "Neither shared nor static libraries were requested, building static libraries")
set(BUILD_STATIC_LIBS ON)
endif ()

25
Contributors-vectorscan.md Normal file
View File

@ -0,0 +1,25 @@
394 Konstantinos Margaritis <konstantinos@vectorcamp.gr>
59 apostolos <apostolos.tapsas@vectorcamp.gr>
25 Hong, Yang A <yang.a.hong@intel.com>
19 George Wort <george.wort@arm.com>
16 Chang, Harry <harry.chang@intel.com>
7 Danila Kutenin <danilak@google.com>
7 Wang Xiang W <xiang.w.wang@intel.com>
6 Alex Bondarev <abondarev84@gmail.com>
5 Konstantinos Margaritis <konma@vectorcamp.gr>
3 Duncan Bellamy <dunk@denkimushi.com>
2 Azat Khuzhin <a3at.mail@gmail.com>
2 Jan Henning <jan.thilo.henning@sap.com>
1 BigRedEye <mail@bigredeye.me>
1 Daniel Kutenin <kutdanila@yandex.ru>
1 Danila Kutenin <kutdanila@yandex.ru>
1 Liu Zixian <hdu_sdlzx@163.com>
1 Mitchell Wasson <miwasson@cisco.com>
1 Piotr Skamruk <piotr.skamruk@gmail.com>
1 Robbie Williamson <robbie.williamson@arm.com>
1 Robert Schulze <robert@clickhouse.com>
1 Walt Stoneburner <wls@wwco.com>
1 Zhu,Wenjun <wenjun.zhu@intel.com>
1 hongyang7 <yang.a.hong@intel.com>
1 jplaisance <jeffplaisance@gmail.com>
1 liquidaty <info@liquidaty.com>

638
Jenkinsfile vendored
View File

@ -1,638 +0,0 @@
pipeline {
agent none
stages {
stage("Build") {
failFast true
parallel {
stage("Release/SSE") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-SSE', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=no -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-release-SSE/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-release-SSE/bin/unit-hyperscan'
}
}
}
}
stage("Release/AVX2") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-AVX2', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-release-AVX2/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-release-AVX2/bin/unit-hyperscan'
}
}
}
}
stage("Release/AVX512") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-AVX512', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-release-AVX512/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-release-AVX512/bin/unit-hyperscan'
}
}
}
}
stage("Release/FAT") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-fat', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=yes', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Test") {
steps {
sh 'build-release-fat/bin/unit-hyperscan'
}
}
}
}
stage("Debug/SSE") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-SSE', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=no -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-debug-SSE/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-debug-SSE/bin/unit-hyperscan'
}
}
}
}
stage("Debug/AVX2") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-AVX2', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-debug-AVX2/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-debug-AVX2/bin/unit-hyperscan'
}
}
}
}
stage("Debug/AVX512") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-AVX512', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-debug-AVX512/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-debug-AVX512/bin/unit-hyperscan'
}
}
}
}
stage("Debug/FAT") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-fat', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=yes', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Test") {
steps {
sh 'build-debug-fat/bin/unit-hyperscan'
}
}
}
}
stage("Release/ARM") {
agent { label "arm" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-arm', buildType: 'Release', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-release-arm/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-release-arm/bin/unit-hyperscan'
}
}
}
}
stage("Debug/ARM") {
agent { label "arm" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-arm', buildType: 'Debug', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-debug-arm/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-debug-arm/bin/unit-hyperscan'
}
}
}
}
stage("Release/Power") {
agent { label "power" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-release-power', buildType: 'Release', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-release-power/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-release-power/bin/unit-hyperscan'
}
}
}
}
stage("Debug/Power") {
agent { label "power" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
steps {
cmakeBuild buildDir: 'build-debug-power', buildType: 'Debug', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-debug-power/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-debug-power/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/SSE") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-SSE', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=no -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-release-SSE/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-release-SSE/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/AVX2") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-AVX2', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-release-AVX2/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-release-AVX2/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/AVX512") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-AVX512', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-release-AVX512/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-release-AVX512/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/FAT") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-fat', buildType: 'Release', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=yes', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Test") {
steps {
sh 'build-clang-release-fat/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/SSE") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-SSE', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=no -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-debug-SSE/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-debug-SSE/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/AVX2") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-AVX2', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=no -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-debug-AVX2/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-debug-AVX2/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/AVX512") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-AVX512', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=no', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-debug-AVX512/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-debug-AVX512/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/FAT") {
agent { label "x86" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-fat', buildType: 'Debug', cleanBuild: true, cmakeArgs: '-DBUILD_AVX2=yes -DBUILD_AVX512=yes -DFAT_RUNTIME=yes', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Test") {
steps {
sh 'build-clang-debug-fat/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/ARM") {
agent { label "arm" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-arm', buildType: 'Release', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-release-arm/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-release-arm/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/ARM") {
agent { label "arm" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-arm', buildType: 'Debug', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-debug-arm/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-debug-arm/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Release/Power") {
agent { label "power" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-release-power', buildType: 'Release', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-release-power/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-release-power/bin/unit-hyperscan'
}
}
}
}
stage("Clang-Debug/Power") {
agent { label "power" }
stages {
stage("Git checkout") {
steps {
checkout([$class: 'GitSCM', branches: [[name: '${sha1}']], extensions: [], userRemoteConfigs: [[refspec: '+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*', url: 'https://github.com/VectorCamp/vectorscan.git']]])
}
}
stage("Build") {
environment {
CC="clang"
CXX="clang++"
}
steps {
cmakeBuild buildDir: 'build-clang-debug-power', buildType: 'Debug', cleanBuild: true, cmakeArgs: '', installation: 'InSearchPath', steps: [[args: '--parallel 4', withCmake: true]]
}
}
stage("Unit Test") {
steps {
sh 'build-clang-debug-power/bin/unit-internal'
}
}
stage("Test") {
steps {
sh 'build-clang-debug-power/bin/unit-hyperscan'
}
}
}
}
}
}
}
}

182
README.md
View File

@ -1,80 +1,180 @@
# Vectorscan?
# About Vectorscan
A fork of Intel's Hyperscan, modified to run on more platforms. Currently ARM NEON/ASIMD
is 100% functional, and Power VSX are in development. ARM SVE2 will be implemented when
harwdare becomes accessible to the developers. More platforms will follow in the future,
on demand/request.
is 100% functional, and Power VSX are in development. ARM SVE2 support is in ongoing with
access to hardware now. More platforms will follow in the future.
Vectorscan will follow Intel's API and internal algorithms where possible, but will not
hesitate to make code changes where it is thought of giving better performance or better
portability. In addition, the code will be gradually simplified and made more uniform and
all architecture specific -currently Intel- #ifdefs will be removed and abstracted away.
# Why the fork?
# Why was there a need for a fork?
Originally, the ARM porting was supposed to be merged into Intel's own Hyperscan, and 2
Pull Requests had been made to the project for this reason ([1], [2]). Unfortunately, the
Originally, the ARM porting was intended to be merged into Intel's own Hyperscan, and relevant
Pull Requests were made to the project for this reason. Unfortunately, the
PRs were rejected for now and the forseeable future, thus we have created Vectorscan for
our own multi-architectural and opensource collaborative needs.
# What is Hyperscan?
The recent license change of Hyperscan makes Vectorscan even more relevant for the FLOSS ecosystem.
Hyperscan is a high-performance multiple regex matching library. It follows the
# What is Vectorscan/Hyperscan/?
Hyperscan and by extension Vectorscan is a high-performance multiple regex matching library. It follows the
regular expression syntax of the commonly-used libpcre library, but is a
standalone library with its own C API.
Hyperscan uses hybrid automata techniques to allow simultaneous matching of
Hyperscan/Vectorscan uses hybrid automata techniques to allow simultaneous matching of
large numbers (up to tens of thousands) of regular expressions and for the
matching of regular expressions across streams of data.
Vectorscan is typically used in a DPI library stack, just like Hyperscan.
# Compiling for SVE
The following cmake variables can be set in order to target Arm's Scalable
Vector Extension. They are listed in ascending order of strength, with cmake
detecting whether the feature is available in the compiler and falling back to
a weaker version if not. Only one of these variables needs to be set as weaker
variables will be implied as set.
- `BUILD_SVE`
- `BUILD_SVE2`
- `BUILD_SVE2_BITPERM`
# Documentation
Information on building the Hyperscan library and using its API is available in
the [Developer Reference Guide](http://intel.github.io/hyperscan/dev-reference/).
# License
Vectorscan, like Hyperscan is licensed under the BSD License. See the LICENSE file in the
project repository.
Vectorscan follows a BSD License like the original Hyperscan (up to 5.4).
Vectorscan continues to be an open source project and we are committed to keep it that way.
See the LICENSE file in the project repository.
## Hyperscan License Change after 5.4
According to
[Accelerate Snort Performance with Hyperscan and Intel Xeon Processors on Public Clouds](https://networkbuilders.intel.com/docs/networkbuilders/accelerate-snort-performance-with-hyperscan-and-intel-xeon-processors-on-public-clouds-1680176363.pdf) versions of Hyperscan later than 5.4 are
going to be closed-source:
> The latest open-source version (BSD-3 license) of Hyperscan on Github is 5.4. Intel conducts continuous internal
> development and delivers new Hyperscan releases under Intel Proprietary License (IPL) beginning from 5.5 for interested
> customers. Please contact authors to learn more about getting new Hyperscan releases.
# Versioning
The `master` branch on Github will always contain the most recent release of
The `master` branch on Github will always contain the most recent stable release of
Hyperscan. Each version released to `master` goes through QA and testing before
it is released; if you're a user, rather than a developer, this is the version
you should be using.
Further development towards the next release takes place on the `develop`
branch.
branch. All PRs are first made against the develop branch and if the pass the [Vectorscan CI](https://buildbot-ci.vectorcamp.gr/#/grid), then they get merged. Similarly with PRs from develop to master.
# Get Involved
# Compatibility with Hyperscan
Vectorscan aims to be ABI and API compatible with the last open source version of Intel Hyperscan 5.4.
After careful consideration we decided that we will **NOT** aim to achieving compatibility with later Hyperscan versions 5.5/5.6 that have extended Hyperscan's API.
If keeping up to date with latest API of Hyperscan, you should talk to Intel and get a license to use that.
However, we intend to extend Vectorscan's API with user requested changes or API extensions and improvements that we think are best for the project.
# Installation
## Debian/Ubuntu
On recent Debian/Ubuntu systems, vectorscan should be directly available for installation:
```
$ sudo apt install libvectorscan5
```
Or to install the devel package you can install `libvectorscan-dev` package:
```
$ sudo apt install libvectorscan-dev
```
For other distributions/OSes please check the [Wiki](https://github.com/VectorCamp/vectorscan/wiki/Installation-from-package)
# Build Instructions
The build system has recently been refactored to be more modular and easier to extend. For that reason,
some small but necessary changes were made that might break compatibility with how Hyperscan was built.
## Install Common Dependencies
### Debian/Ubuntu
In order to build on Debian/Ubuntu make sure you install the following build-dependencies
```
$ sudo apt build-essential cmake ragel pkg-config libsqlite3-dev libpcap-dev
```
### Other distributions
TBD
### MacOS X (M1/M2/M3 CPUs only)
Assuming an existing HomeBrew installation:
```
% brew install boost cmake gcc libpcap pkg-config ragel sqlite
```
## Configure & build
In order to configure with `cmake` first create and cd into a build directory:
```
$ mkdir build
$ cd build
```
Then call `cmake` from inside the `build` directory:
```
$ cmake ../
```
Common options for Cmake are:
* `-DBUILD_STATIC_LIBS=[On|Off]` Build static libraries
* `-DBUILD_SHARED_LIBS=[On|Off]` Build shared libraries (if none are set static libraries are built by default)
* `-DCMAKE_BUILD_TYPE=[Release|Debug|RelWithDebInfo|MinSizeRel]` Configure build type and determine optimizations and certain features.
* `-DUSE_CPU_NATIVE=[On|Off]` Native CPU detection is off by default, however it is possible to build a performance-oriented non-fat library tuned to your CPU
* `-DFAT_RUNTIME=[On|Off]` Fat Runtime is only available for X86 32-bit/64-bit and AArch64 architectures and only on Linux. It is incompatible with `Debug` type and `USE_CPU_NATIVE`.
### Specific options for X86 32-bit/64-bit (Intel/AMD) CPUs
* `-DBUILD_AVX2=[On|Off]` Enable code for AVX2.
* `-DBUILD_AVX512=[On|Off]` Enable code for AVX512. Implies `BUILD_AVX2`.
* `-DBUILD_AVX512VBMI=[On|Off]` Enable code for AVX512 with VBMI extension. Implies `BUILD_AVX512`.
### Specific options for Arm 64-bit CPUs
* `-DBUILD_SVE=[On|Off]` Enable code for SVE, like on AWS Graviton3 CPUs. Not much code is ported just for SVE , but enabling SVE code production, does improve code generation, see [Benchmarks](https://github.com/VectorCamp/vectorscan/wiki/Benchmarks).
* `-DBUILD_SVE2=[On|Off]` Enable code for SVE2, implies `BUILD_SVE`. Most non-Neon code is written for SVE2
* `-DBUILD_SVE2_BITPERM=[On|Off]` Enable code for SVE2_BITPERM harwdare feature, implies `BUILD_SVE2`.
## Other options
* `SANITIZE=[address|memory|undefined]` (experimental) Use `libasan` sanitizer to detect possible bugs. For now only `address` is tested. This will eventually be integrated in the CI.
## Build
If `cmake` has completed successfully you can run `make` in the same directory, if you have a multi-core system with `N` cores, running
```
$ make -j <N>
```
will speed up the process. If all goes well, you should have the vectorscan library compiled.
# Contributions
The official homepage for Vectorscan is at [www.github.com/VectorCamp/vectorscan](https://www.github.com/VectorCamp/vectorscan).
# Vectorscan Development
All development of Vectorscan is done in public.
# Original Hyperscan links
The official homepage for Hyperscan is at [www.hyperscan.io](https://www.hyperscan.io).
For reference, the official homepage for Hyperscan is at [www.hyperscan.io](https://www.hyperscan.io).
If you have questions or comments, we encourage you to [join the mailing
list](https://lists.01.org/mailman/listinfo/hyperscan). Bugs can be filed by
sending email to the list, or by creating an issue on Github.
# Hyperscan Documentation
If you wish to contact the Hyperscan team at Intel directly, without posting
publicly to the mailing list, send email to
[hyperscan@intel.com](mailto:hyperscan@intel.com).
Information on building the Hyperscan library and using its API is available in
the [Developer Reference Guide](http://intel.github.io/hyperscan/dev-reference/).
[1]: https://github.com/intel/hyperscan/pull/272
[2]: https://github.com/intel/hyperscan/pull/287
And you can find the source code [on Github](https://github.com/intel/hyperscan).
For Intel Hyperscan related issues and questions, please follow the relevant links there.

22
cmake/arm64-cross.cmake
View File

@ -1,22 +0,0 @@
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_SYSTEM_PROCESSOR "aarch64")
# specify the cross compiler
set(CMAKE_C_COMPILER "$ENV{CROSS}gcc")
set(CMAKE_CXX_COMPILER "$ENV{CROSS}g++")
# where is the target environment
set(CMAKE_SYSROOT $ENV{CROSS_SYS})
set(Boost_INCLUDE_DIR $ENV{BOOST_PATH})
# for libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(THREADS_PTHREAD_ARG "2" CACHE STRING "Result from TRY_RUN" FORCE)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -falign-functions=16 -falign-jumps=16 -falign-labels=16 -falign-loops=16" CACHE STRING "" FORCE)
set(GNUCC_ARCH "armv8.2-a+fp16+simd+rcpc+dotprod+crypto")
set(TUNE_FLAG "neoverse-n1")

6
cmake/osdetection.cmake
View File

@ -11,7 +11,11 @@ message("Checking Fat Runtime Requirements...")
if (FAT_RUNTIME AND NOT LINUX)
message(FATAL_ERROR "Fat runtime is only supported on Linux OS")
endif()
if (USE_CPU_NATIVE AND FAT_RUNTIME)
message(FATAL_ERROR "Fat runtime is not compatible with Native CPU detection")
endif()
if (FAT_RUNTIME AND LINUX)
if (NOT (ARCH_IA32 OR ARCH_X86_64 OR ARCH_AARCH64))
message(FATAL_ERROR "Fat runtime is only supported on Intel and Aarch64 architectures")

19
cmake/setenv-arm64-cross.sh
View File

@ -1,19 +0,0 @@
#!/bin/bash
export BOOST_VERSION=1_57_0
export BOOST_DOT_VERSION=${BOOST_VERSION//_/.}
export CROSS=<arm-cross-compiler-dir>/bin/aarch64-linux-gnu-
export CROSS_SYS=<arm-cross-compiler-system-dir>
# if [ ! -d "boost_$BOOST_VERSION" ];
# then
# wget -O boost_$BOOST_VERSION.tar.gz https://sourceforge.net/projects/boost/files/boost/$BOOST_DOT_VERSION/boost_$BOOST_VERSION.tar.gz/download
# tar xf boost_$BOOST_VERSION.tar.gz
# fi
if [ ! -d "pcre-8.45" ];
then
wget -O pcre-8.45.tar.bz2 https://sourceforge.net/projects/pcre/files/pcre/8.45/pcre-8.45.tar.bz2/download
tar xf pcre-8.45.tar.bz2
export PCRE_SOURCE=1
fi
export BOOST_PATH=<boost-source-dir>