Big update

[emilmelnikov]

• Almost all loads and stores are now aligned.
• The inner loop of conv functions now works in 2 steps: unroll up to
  the specified factor first, and finish with the unroll factor 1.
  This is similar to how LLVM unrolls loops.
• Now buffers need to be padded only up to the multiple of the vector
  size. This simplifies buffer management.
• fastfilters2::simd now communicates via separately defined structs.
• Split ufuncs into separate functions.
• Add some comments that try to explain what is going on here.
• During module import, select the fastest implementation (autotune).
• Remove kernel coefficients tests: it is enough to check that
  gaussian_smoothing is identical; can probably add C++ tests later.
• Revert back to testing on randomly sampled data.
• Add some tests for valid and invalid filter inputs.
• Improve CMakeLists.
• Add .clangd for IDEs/tools that support it (without this config
  clangd couldn't properly index Highway code).
• Move to FetchContent instead of git submodules for managing deps.

[k-dominik]

AMAZING! can't wait to check it out!!

[emilmelnikov]

AMAZING! can't wait to check it out!!

Thanks! :)

With the latest batch of changes, and after fixing possible CI issues, this PR should be ready.

I've tried to plug this into ilastik as import fastfilters2.compat as fastfilters in lazyflow/operators/opPixelFeaturesPresmoothed.py and lazyflow/operators/filterOperators.py, and it seems to work fine.

I tested it on a random 1024^3 uint8 dataset, and the speedup is not really that great, only 1.19x. This was measured in a somewhat hacky way by doing this (only the latest cumulative_time values are compared):

class OpPixelFeaturesPresmoothed(Operator):
    def __init__(self, *args, **kwargs):
        ...
        self._cumulative_time = 0

    def execute(self, slot, subindex, slot_roi, target):
        if slot == self.Features:
            ...
        elif slot == self.Output:
            t0 = time.perf_counter()
            ...
            t1 = time.perf_counter()
            self._cumulative_time += t1 - t0
            print(f"OpPixelFeaturesPresmoothed: cumulative_time = {self._cumulative_time}")

This is because main speedups came by vectorizing the border handling code in v1, but with presmoothing most borders are only 1-2 pixels long. I think it's still possible to do it better by fusing some passes together (it's easier to do if the border size is statically known), but maybe later :)

However, I suspect that we can score some easy wins by modifying block shapes. I've monitored the exact block shapes that are passed into the library, and they usually have ~32 pixels in one dim, and ~200 pixels in other dims, which is not really optimal. I'm not sure where exactly these block shapes are defined, tried to update OpFeatureSelection.setupOutputs, but the performance tanked. This is probably due to a shape mismatch in the block cache, or something like that?..

[emilmelnikov]

@k-dominik PyPI introduced a new way to publish packages: trusted publishing. It is better because you don't have to copy-paste tokens or credentials, but it needs some configuration on the part of the project owner org on PyPI.

You need to add a trusted publisher in the publishing tab.

• Owner: ilastik
• Repository name: fastfilters2
• Workflow name: release.yaml
• Environment name: pypi

Not 100% sure, but I think this is all you have to do.