add backend based on gcc vector extension

Author: WolframRhodium

CMakeLists.txt

@@ -4,6 +4,7 @@ project(vs-dfttest2 VERSION 0.1 LANGUAGES CXX)
 
 set(ENABLE_CUDA ON CACHE BOOL "Whether to compile with CUDA backends")
 set(ENABLE_CPU ON CACHE BOOL "Whether to compile with x86 backends")
+set(ENABLE_GCC OFF CACHE BOOL "Whether to compile with gcc vector extension backends")
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build" FORCE)
@@ -137,3 +138,7 @@ endif() # ENABLE_CUDA
 if(ENABLE_CPU)
     add_subdirectory(cpu_source)
 endif() # ENABLE_CPU
+
+if(ENABLE_GCC)
+    add_subdirectory(gcc_source)
+endif() # ENABLE_GCC

dfttest2.py

@@ -27,7 +27,11 @@ class NVRTC:
     class CPU:
         opt: int = 0
 
-backendT = typing.Union[Backend.cuFFT, Backend.NVRTC, Backend.CPU]
+    @dataclass(frozen=False)
+    class GCC:
+        pass
+
+backendT = typing.Union[Backend.cuFFT, Backend.NVRTC, Backend.CPU, Backend.GCC]
 
 
 def init_backend(backend: backendT) -> backendT:
@@ -37,6 +41,8 @@ def init_backend(backend: backendT) -> backendT:
         backend = Backend.NVRTC()
     elif backend is Backend.CPU: # type: ignore
         backend = Backend.CPU()
+    elif backend is Backend.GCC: # type: ignore
+        backend = Backend.GCC()
     return backend
 
 
@@ -252,7 +258,7 @@ def DFTTest2(
     zero_mean = zmean
     backend = init_backend(backend)
 
-    if isinstance(backend, (Backend.CPU, Backend.NVRTC)):
+    if isinstance(backend, (Backend.CPU, Backend.NVRTC, Backend.GCC)):
         if radius not in range(4):
             raise ValueError("invalid radius (tbsize)")
         if block_size != 16:
@@ -328,6 +334,8 @@ def DFTTest2(
         rdft = core.dfttest2_nvrtc.RDFT
     elif isinstance(backend, Backend.CPU):
         rdft = core.dfttest2_cpu.RDFT
+    elif isinstance(backend, Backend.GCC):
+        rdft = core.dfttest2_gcc.RDFT
     else:
         raise TypeError("unknown backend")
 
@@ -358,6 +366,21 @@ def DFTTest2(
             window_freq=window_freq,
             opt=backend.opt
         )
+    elif isinstance(backend, Backend.GCC):
+        return core.dfttest2_gcc.DFTTest(
+            clip,
+            window=window,
+            sigma=[sigma_scalar] * (2 * radius + 1) * block_size * (block_size // 2 + 1) if sigma_is_scalar else sigma_array,
+            sigma2=sigma2,
+            pmin=pmin,
+            pmax=pmax,
+            radius=radius,
+            block_size=block_size,
+            block_step=block_step,
+            planes=planes,
+            filter_type=filter_type,
+            window_freq=window_freq
+        )
 
     if isinstance(backend, Backend.cuFFT):
         to_single = core.dfttest2_cuda.ToSingle
@@ -482,8 +505,10 @@ def select_backend(
             return Backend.NVRTC()
         elif hasattr(core, "dfttest2_cuda"):
             return Backend.cuFFT()
-        else:
+        elif hasattr(core, "dfttest2_cpu"):
             return Backend.CPU()
+        else:
+            return Backend.GCC()
     else:
         return Backend.cuFFT()
 
@@ -677,12 +702,12 @@ def DFTTest(
 
         backend: Backend implementation to use.
             All available backends can be found in the dfttest2.Backend "namespace":
-                dfttest2.Backend.{CPU, cuFFT, NVRTC}
-            
-            The CPU and NVRTC backend require sbsize=16.
+                dfttest2.Backend.{CPU, cuFFT, NVRTC, GCC}
+
+            The CPU, NVRTC and GCC backends require sbsize=16.
             The cuFFT and NVRTC backend require a CUDA-enabled system.
-            
-            Speed: NVRTC >> cuFFT > CPU
+
+            Speed: NVRTC >> cuFFT > CPU == GCC
     """
 
     if (

gcc_source/CMakeLists.txt

@@ -0,0 +1,38 @@
+add_library(dfttest2_gcc MODULE source.cpp)
+
+set_target_properties(dfttest2_gcc PROPERTIES
+    CXX_EXTENSIONS OFF
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+)
+
+target_include_directories(dfttest2_gcc PRIVATE ${VCL_HOME})
+
+if(PKG_CONFIG_FOUND AND VS_FOUND)
+    target_include_directories(dfttest2_gcc PRIVATE ${VS_INCLUDE_DIRS})
+    install(TARGETS dfttest2_gcc LIBRARY DESTINATION ${install_dir})
+else()
+    target_include_directories(dfttest2_gcc PRIVATE ${VS_INCLUDE_DIR})
+    install(TARGETS dfttest2_gcc LIBRARY DESTINATION lib)
+endif()
+
+target_include_directories(dfttest2_gcc PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/..)
+
+
+add_library(getframe_impl OBJECT getframe_impl.cpp)
+
+set_target_properties(getframe_impl PROPERTIES
+    CXX_EXTENSIONS OFF
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+)
+
+target_include_directories(getframe_impl PRIVATE ${VCL_HOME})
+
+if(PKG_CONFIG_FOUND AND VS_FOUND)
+    target_include_directories(getframe_impl PRIVATE ${VS_INCLUDE_DIRS})
+else()
+    target_include_directories(getframe_impl PRIVATE ${VS_INCLUDE_DIR})
+endif()
+
+target_link_libraries(dfttest2_gcc PRIVATE getframe_impl)

gcc_source/dfttest2_cpu.h

@@ -0,0 +1,52 @@
+#ifndef DFTTEST2_CPU_H
+#define DFTTEST2_CPU_H
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <shared_mutex>
+#include <thread>
+#include <unordered_map>
+
+#include <VapourSynth.h>
+#include <VSHelper.h>
+
+
+static void vs_aligned_free_float(float * ptr) {
+    vs_aligned_free(static_cast<void *>(ptr));
+}
+
+
+struct DFTTestThreadData {
+    uint8_t * padded; // shape: (pad_height, pad_width)
+    float * padded2; // shape: (pad_height, pad_width)
+};
+
+
+struct DFTTestData {
+    VSNodeRef * node;
+    int radius;
+    int block_size;
+    int block_step;
+    std::array<bool, 3> process;
+    bool zero_mean;
+    std::unique_ptr<float [], decltype(&vs_aligned_free_float)> window { nullptr, &vs_aligned_free_float };
+    std::unique_ptr<float [], decltype(&vs_aligned_free_float)> window_freq { nullptr, &vs_aligned_free_float };
+    std::unique_ptr<float [], decltype(&vs_aligned_free_float)> sigma { nullptr, &vs_aligned_free_float };
+    int filter_type;
+    float sigma2;
+    float pmin;
+    float pmax;
+
+    std::atomic<int> num_uninitialized_threads;
+    std::unordered_map<std::thread::id, DFTTestThreadData> thread_data;
+    std::shared_mutex thread_data_lock;
+};
+
+extern const VSFrameRef *VS_CC DFTTestGetFrame(
+    int n, int activationReason, void **instanceData, void **frameData,
+    VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi
+) noexcept;
+
+#endif // DFTTEST2_CPU_H