Remove denoise module and thirdparty OIDN.

This is replaced by a much lighter weight and faster JNLM denoiser. OIDN is still much more accurate, and may be provided as an optional backend in the future, but the JNLM denoiser seems good enough for most use cases and removing OIDN reduces the build system complexity, binary size, and build times very significantly.

1 files changed, 0 insertions, 370 deletions

diff --git a/thirdparty/oidn/mkl-dnn/src/common/utils.hpp b/thirdparty/oidn/mkl-dnn/src/common/utils.hpp
deleted file mode 100644
index d5a8ec5139..0000000000
--- a/thirdparty/oidn/mkl-dnn/src/common/utils.hpp
+++ /dev/null
@@ -1,370 +0,0 @@
-/*******************************************************************************
-* Copyright 2016-2018 Intel Corporation
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*******************************************************************************/
-
-#ifndef UTILS_HPP
-#define UTILS_HPP
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <stdint.h>
-
-#if defined(__x86_64__) || defined(_M_X64)
-#define MKLDNN_X86_64
-#endif
-
-#define MSAN_ENABLED 0
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#undef MSAN_ENABLED
-#define MSAN_ENABLED 1
-#include <sanitizer/msan_interface.h>
-#endif
-#endif
-
-#include "c_types_map.hpp"
-#include "nstl.hpp"
-#include "z_magic.hpp"
-
-namespace mkldnn {
-namespace impl {
-
-// Sanity check for 64 bits
-static_assert(sizeof(void*) == 8, "Intel(R) MKL-DNN supports 64 bit only");
-
-#define CHECK(f) do { \
-    status_t status = f; \
-    if (status != status::success) \
-    return status; \
-} while (0)
-
-#define IMPLICATION(cause, effect) (!(cause) || !!(effect))
-
-namespace utils {
-
-/* a bunch of std:: analogues to be compliant with any msvs version
- *
- * Rationale: msvs c++ (and even some c) headers contain special pragma that
- * injects msvs-version check into object files in order to abi-mismatches
- * during the static linking. This makes sense if e.g. std:: objects are passed
- * through between application and library, which is not the case for mkl-dnn
- * (since there is no any c++-rt dependent stuff, ideally...). */
-
-/* SFINAE helper -- analogue to std::enable_if */
-template<bool expr, class T = void> struct enable_if {};
-template<class T> struct enable_if<true, T> { typedef T type; };
-
-/* analogue std::conditional */
-template <bool, typename, typename> struct conditional {};
-template <typename T, typename F> struct conditional<true, T, F>
-{ typedef T type; };
-template <typename T, typename F> struct conditional<false, T, F>
-{ typedef F type; };
-
-template <bool, typename, bool, typename, typename> struct conditional3 {};
-template <typename T, typename FT, typename FF>
-struct conditional3<true, T, false, FT, FF> { typedef T type; };
-template <typename T, typename FT, typename FF>
-struct conditional3<false, T, true, FT, FF> { typedef FT type; };
-template <typename T, typename FT, typename FF>
-struct conditional3<false, T, false, FT, FF> { typedef FF type; };
-
-template <bool, typename U, U, U> struct conditional_v {};
-template <typename U, U t, U f> struct conditional_v<true, U, t, f>
-{ static constexpr U value = t; };
-template <typename U, U t, U f> struct conditional_v<false, U, t, f>
-{ static constexpr U value = f; };
-
-template <typename T> struct remove_reference { typedef T type; };
-template <typename T> struct remove_reference<T&> { typedef T type; };
-template <typename T> struct remove_reference<T&&> { typedef T type; };
-
-template <typename T>
-inline T&& forward(typename utils::remove_reference<T>::type &t)
-{ return static_cast<T&&>(t); }
-template <typename T>
-inline T&& forward(typename utils::remove_reference<T>::type &&t)
-{ return static_cast<T&&>(t); }
-
-template <typename T>
-inline typename remove_reference<T>::type zero()
-{ auto zero = typename remove_reference<T>::type(); return zero; }
-
-template <typename T, typename P>
-inline bool everyone_is(T val, P item) { return val == item; }
-template <typename T, typename P, typename... Args>
-inline bool everyone_is(T val, P item, Args... item_others) {
-    return val == item && everyone_is(val, item_others...);
-}
-
-template <typename T, typename P>
-constexpr bool one_of(T val, P item) { return val == item; }
-template <typename T, typename P, typename... Args>
-constexpr bool one_of(T val, P item, Args... item_others) {
-    return val == item || one_of(val, item_others...);
-}
-
-template <typename... Args>
-inline bool any_null(Args... ptrs) { return one_of(nullptr, ptrs...); }
-
-template<typename T>
-inline void array_copy(T *dst, const T *src, size_t size) {
-    for (size_t i = 0; i < size; ++i) dst[i] = src[i];
-}
-template<typename T>
-inline bool array_cmp(const T *a1, const T *a2, size_t size) {
-    for (size_t i = 0; i < size; ++i) if (a1[i] != a2[i]) return false;
-    return true;
-}
-template<typename T, typename U>
-inline void array_set(T *arr, const U& val, size_t size) {
-    for (size_t i = 0; i < size; ++i) arr[i] = static_cast<T>(val);
-}
-
-namespace product_impl {
-template<size_t> struct int2type{};
-
-template <typename T>
-constexpr int product_impl(const T *arr, int2type<0>) { return arr[0]; }
-
-template <typename T, size_t num>
-inline T product_impl(const T *arr, int2type<num>) {
-    return arr[0]*product_impl(arr+1, int2type<num-1>()); }
-}
-
-template <size_t num, typename T>
-inline T array_product(const T *arr) {
-    return product_impl::product_impl(arr, product_impl::int2type<num-1>());
-}
-
-template<typename T, typename R = T>
-inline R array_product(const T *arr, size_t size) {
-    R prod = 1;
-    for (size_t i = 0; i < size; ++i) prod *= arr[i];
-    return prod;
-}
-
-/** sorts an array of values using @p comparator. While sorting the array
- * of value, the function permutes an array of @p keys accordingly.
- *
- * @note The arrays of @p keys can be omitted. In this case the function
- *       sorts the array of @vals only.
- */
-template <typename T, typename U, typename F>
-inline void simultaneous_sort(T *vals, U *keys, size_t size, F comparator) {
-    if (size == 0) return;
-
-    for (size_t i = 0; i < size - 1; ++i) {
-        bool swapped = false;
-
-        for (size_t j = 0; j < size - i - 1; j++) {
-            if (comparator(vals[j], vals[j + 1]) > 0) {
-                nstl::swap(vals[j], vals[j + 1]);
-                if (keys) nstl::swap(keys[j], keys[j + 1]);
-                swapped = true;
-            }
-        }
-
-        if (swapped == false) break;
-    }
-}
-
-template <typename T, typename U>
-inline typename remove_reference<T>::type div_up(const T a, const U b) {
-    assert(b);
-    return (a + b - 1) / b;
-}
-
-template <typename T, typename U>
-inline typename remove_reference<T>::type rnd_up(const T a, const U b) {
-    return div_up(a, b) * b;
-}
-
-template <typename T, typename U>
-inline typename remove_reference<T>::type rnd_dn(const T a, const U b) {
-    return (a / b) * b;
-}
-
-template <typename T> T *align_ptr(T *ptr, uintptr_t alignment)
-{ return (T *)(((uintptr_t)ptr + alignment - 1) & ~(alignment - 1)); }
-
-template <typename T, typename U, typename V>
-inline U this_block_size(const T offset, const U max, const V block_size) {
-    assert(offset < max);
-    // TODO (Roma): can't use nstl::max() due to circular dependency... we
-    // need to fix this
-    const T block_boundary = offset + block_size;
-    if (block_boundary > max)
-        return max - offset;
-    else
-        return block_size;
-}
-
-template<typename T>
-inline T nd_iterator_init(T start) { return start; }
-template<typename T, typename U, typename W, typename... Args>
-inline T nd_iterator_init(T start, U &x, const W &X, Args &&... tuple) {
-    start = nd_iterator_init(start, utils::forward<Args>(tuple)...);
-    x = start % X;
-    return start / X;
-}
-
-inline bool nd_iterator_step() { return true; }
-template<typename U, typename W, typename... Args>
-inline bool nd_iterator_step(U &x, const W &X, Args &&... tuple) {
-    if (nd_iterator_step(utils::forward<Args>(tuple)...) ) {
-        x = (x + 1) % X;
-        return x == 0;
-    }
-    return false;
-}
-
-template<typename U, typename W, typename Y>
-inline bool nd_iterator_jump(U &cur, const U end, W &x, const Y &X)
-{
-    U max_jump = end - cur;
-    U dim_jump = X - x;
-    if (dim_jump <= max_jump) {
-        x = 0;
-        cur += dim_jump;
-        return true;
-    } else {
-        cur += max_jump;
-        x += max_jump;
-        return false;
-    }
-}
-template<typename U, typename W, typename Y, typename... Args>
-inline bool nd_iterator_jump(U &cur, const U end, W &x, const Y &X,
-        Args &&... tuple)
-{
-    if (nd_iterator_jump(cur, end, utils::forward<Args>(tuple)...)) {
-        x = (x + 1) % X;
-        return x == 0;
-    }
-    return false;
-}
-
-template <typename T>
-inline T pick(size_t i, const T &x0) { return x0; }
-template <typename T, typename ...Args>
-inline T pick(size_t i, const T &x0, Args &&... args) {
-    return i == 0 ? x0 : pick(i - 1, utils::forward<Args>(args)...);
-}
-
-template <typename T>
-T pick_by_prop_kind(prop_kind_t prop_kind, const T &val_fwd_inference,
-        const T &val_fwd_training, const T &val_bwd_d, const T &val_bwd_w) {
-    switch (prop_kind) {
-    case prop_kind::forward_inference: return val_fwd_inference;
-    case prop_kind::forward_training: return val_fwd_training;
-    case prop_kind::backward_data: return val_bwd_d;
-    case prop_kind::backward_weights: return val_bwd_w;
-    default: assert(!"unsupported prop_kind");
-    }
-    return T();
-}
-
-template <typename T>
-T pick_by_prop_kind(prop_kind_t prop_kind,
-        const T &val_fwd, const T &val_bwd_d, const T &val_bwd_w)
-{ return pick_by_prop_kind(prop_kind, val_fwd, val_fwd, val_bwd_d, val_bwd_w); }
-
-template <typename Telem, size_t Tdims>
-struct array_offset_calculator {
-    template <typename... Targs>
-    array_offset_calculator(Telem *base, Targs... Fargs) : _dims{ Fargs... }
-    {
-        _base_ptr = base;
-    }
-    template <typename... Targs>
-    inline Telem &operator()(Targs... Fargs)
-    {
-        return *(_base_ptr + _offset(1, Fargs...));
-    }
-
-private:
-    template <typename... Targs>
-    inline size_t _offset(size_t const dimension, size_t element)
-    {
-        return element;
-    }
-
-    template <typename... Targs>
-    inline size_t _offset(size_t const dimension, size_t theta, size_t element)
-    {
-        return element + (_dims[dimension] * theta);
-    }
-
-    template <typename... Targs>
-    inline size_t _offset(size_t const dimension, size_t theta, size_t element,
-            Targs... Fargs)
-    {
-        size_t t_prime = element + (_dims[dimension] * theta);
-        return _offset(dimension + 1, t_prime, Fargs...);
-    }
-
-    Telem *_base_ptr;
-    const int _dims[Tdims];
-};
-
-}
-
-int32_t fetch_and_add(int32_t *dst, int32_t val);
-inline void yield_thread() {}
-
-// Reads an environment variable 'name' and stores its string value in the
-// 'buffer' of 'buffer_size' bytes on success.
-//
-// - Returns the length of the environment variable string value (excluding
-// the terminating 0) if it is set and its contents (including the terminating
-// 0) can be stored in the 'buffer' without truncation.
-//
-// - Returns negated length of environment variable string value and writes
-// "\0" to the buffer (if it is not NULL) if the 'buffer_size' is to small to
-// store the value (including the terminating 0) without truncation.
-//
-// - Returns 0 and writes "\0" to the buffer (if not NULL) if the environment
-// variable is not set.
-//
-// - Returns INT_MIN if the 'name' is NULL.
-//
-// - Returns INT_MIN if the 'buffer_size' is negative.
-//
-// - Returns INT_MIN if the 'buffer' is NULL and 'buffer_size' is greater than
-// zero. Passing NULL 'buffer' with 'buffer_size' set to 0 can be used to
-// retrieve the length of the environment variable value string.
-//
-int getenv(const char *name, char *buffer, int buffer_size);
-// Reads an integer from the environment
-int getenv_int(const char *name, int default_value = 0);
-bool jit_dump_enabled();
-FILE *fopen(const char *filename, const char *mode);
-
-constexpr int msan_enabled = MSAN_ENABLED;
-inline void msan_unpoison(void *ptr, size_t size) {
-#if MSAN_ENABLED
-    __msan_unpoison(ptr, size);
-#endif
-}
-
-}
-}
-
-#endif
-
-// vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s