Merge pull request #19985 from fpetrogalli:disable_threads

* [build][option] Introduce `OPENCV_DISABLE_THREAD_SUPPORT` option. The option forces the library to build without thread support. * update handling of OPENCV_DISABLE_THREAD_SUPPORT - reduce amount of #if conditions * [to squash] cmake: apply mode vars in toolchains too Co-authored-by: Alexander Alekhin <alexander.a.alekhin@gmail.com>
2026-07-29 15:23:05 +04:00 · 2021-07-08 21:21:21 +01:00
parent 59ae0e0013
commit b928ebdd53
16 changed files with 435 additions and 16 deletions
@@ -14,6 +14,7 @@
 #define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_DEBUG + 1
 #include <opencv2/core/utils/logger.hpp>

+#ifndef OPENCV_DISABLE_THREAD_SUPPORT

 #ifdef CV_CXX11
 #include <mutex>
@@ -236,6 +237,171 @@ struct AsyncArray::Impl
    }
 };

+}  // namespace
+
+#else  // OPENCV_DISABLE_THREAD_SUPPORT
+
+namespace cv {
+
+// no threading
+struct AsyncArray::Impl
+{
+    int refcount;
+    void addrefFuture() CV_NOEXCEPT { refcount_future++; refcount++; }
+    void releaseFuture() CV_NOEXCEPT { refcount_future--; if (0 == --refcount) delete this; }
+    int refcount_future;
+    void addrefPromise() CV_NOEXCEPT { refcount_promise++; refcount++; } \
+    void releasePromise() CV_NOEXCEPT { refcount_promise--; if (0 == --refcount) delete this; }
+    int refcount_promise;
+
+    mutable bool has_result; // Mat, UMat or exception
+
+    mutable cv::Ptr<Mat> result_mat;
+    mutable cv::Ptr<UMat> result_umat;
+
+
+    bool has_exception;
+#if CV__EXCEPTION_PTR
+    std::exception_ptr exception;
+#endif
+    cv::Exception cv_exception;
+
+    mutable bool result_is_fetched;
+
+    bool future_is_returned;
+
+    Impl()
+        : refcount(1), refcount_future(0), refcount_promise(1)
+        , has_result(false)
+        , has_exception(false)
+        , result_is_fetched(false)
+        , future_is_returned(false)
+    {
+        // nothing
+    }
+
+    ~Impl()
+    {
+        if (has_result && !result_is_fetched)
+        {
+            CV_LOG_INFO(NULL, "Asynchronous result has not been fetched");
+        }
+    }
+
+    bool get(OutputArray dst, int64 timeoutNs) const
+    {
+        CV_Assert(!result_is_fetched);
+        if (!has_result)
+        {
+            CV_UNUSED(timeoutNs);
+            CV_Error(Error::StsError, "Result is not produced (unable to wait for result in OPENCV_DISABLE_THREAD_SUPPORT mode)");
+        }
+        if (!result_mat.empty())
+        {
+            dst.move(*result_mat.get());
+            result_mat.release();
+            result_is_fetched = true;
+            return true;
+        }
+        if (!result_umat.empty())
+        {
+            dst.move(*result_umat.get());
+            result_umat.release();
+            result_is_fetched = true;
+            return true;
+        }
+#if CV__EXCEPTION_PTR
+        if (has_exception && exception)
+        {
+            result_is_fetched = true;
+            std::rethrow_exception(exception);
+        }
+#endif
+        if (has_exception)
+        {
+            result_is_fetched = true;
+            throw cv_exception;
+        }
+        CV_Error(Error::StsInternal, "AsyncArray: invalid state of 'has_result = true'");
+        return false;
+    }
+
+    bool valid() const CV_NOEXCEPT
+    {
+        if (result_is_fetched)
+            return false;
+        if (refcount_promise == 0 && !has_result)
+            return false;
+        return true;
+    }
+
+    bool wait_for(int64 timeoutNs) const
+    {
+        CV_Assert(valid());
+        if (has_result)
+            return has_result;
+        if (timeoutNs == 0)
+            return has_result;
+        CV_Error(Error::StsError, "Unable to wait in OPENCV_DISABLE_THREAD_SUPPORT mode");
+    }
+
+    AsyncArray getArrayResult()
+    {
+        CV_Assert(refcount_future == 0);
+        AsyncArray result;
+        addrefFuture();
+        result.p = this;
+        future_is_returned = true;
+        return result;
+    }
+
+    void setValue(InputArray value)
+    {
+        if (future_is_returned && refcount_future == 0)
+            CV_Error(Error::StsError, "Associated AsyncArray has been destroyed");
+        CV_Assert(!has_result);
+        int k = value.kind();
+        if (k == _InputArray::UMAT)
+        {
+            result_umat = makePtr<UMat>();
+            value.copyTo(*result_umat.get());
+        }
+        else
+        {
+            result_mat = makePtr<Mat>();
+            value.copyTo(*result_mat.get());
+        }
+        has_result = true;
+    }
+
+#if CV__EXCEPTION_PTR
+    void setException(std::exception_ptr e)
+    {
+        if (future_is_returned && refcount_future == 0)
+            CV_Error(Error::StsError, "Associated AsyncArray has been destroyed");
+        CV_Assert(!has_result);
+        has_exception = true;
+        exception = e;
+        has_result = true;
+    }
+#endif
+
+    void setException(const cv::Exception e)
+    {
+        if (future_is_returned && refcount_future == 0)
+            CV_Error(Error::StsError, "Associated AsyncArray has been destroyed");
+        CV_Assert(!has_result);
+        has_exception = true;
+        cv_exception = e;
+        has_result = true;
+    }
+};
+
+}
+
+#endif  // OPENCV_DISABLE_THREAD_SUPPORT
+
+namespace cv {

 AsyncArray::AsyncArray() CV_NOEXCEPT
    : p(NULL)