WIP

Based on #26941

This is proposal of mechanism allowing to pass OpenCV parallel_for backend to HAL. This is just rough draft, details are up for discussion.

The proposal

Pass HAL_Context structure containing funciton pointer to parallel_for to those HAL functions which might require it (are not called inside cv::parallel_for in OpenCV)

struct HAL_Context {
    void (*parallel_for_fn)(
        int tasks, // Q: should we split it into begin/end too?
        void (*body_callback)(int start, int end, void* data), // callback function to be provided by HAL
        void* data); // data will be passed to callback
        // Q: do we need 'stripes' argument?
        // Q: do we need to pass number of threads and backend name/id?
}; // NOTE: using struct allows extending it in the future without breaking API
// Q: do we need to version the structure in addition?

HAL functions would then accept context as an argument:

int cv_hal_lut(HAL_Context * ctx, ...); // Q: should context be a pointer or maybe a reference?
// NOTE: we can add extra function/overload instead of modifiyng existing one

Notes:

• some extra work is required to wrap cv::parallel_for_ in C-like API and take a pointer to pass to HAL - context creation can be extracted and reused (e.g. in hal_replacement.hpp)

Another approach

We can also use unified initialization mechanism:

int cv_hal_init(HAL_Context * ctx);

OpenCV would call this function at some point and provide similar context structure or a set of arguments.
Possible call points:

• on library load (Q: does it work with static library and application? would it work after dynamic library unload/load?)
• before first call to HAL (should be wrapped in a singletone and added before each HAL call) (Q: can it affect performance?)

Q: do we need cv_hal_free or something similar?
Q: in case when we have multiple HALs, should we call init for each one?
Q: potential problem if we pass extra data (e.g. number of threads) via context - then we should re-init HAL if this data changes. Or HAL should assume extra level of indirection - it can only store pointer/reference to context, but should not copy it.