Method threadMain

external/nvImageCodec/src/thread_pool.cpp:155–230

    }

    void ThreadPool::threadMain(int thread_id, int device_id, bool set_affinity, const std::string& name) {
        setThreadName(name.c_str());
        try {
            DeviceGuard g(device_id);
#if NVML_ENABLED
            if (set_affinity) {
                const char* env_affinity = std::getenv("NVIMGCODEC_AFFINITY_MASK");
                int core = -1;
                if (env_affinity) {
                    const auto& vec = string_split(env_affinity, ',');
                    if ((size_t)thread_id < vec.size()) {
                        core = std::stoi(vec[thread_id]);
                    } else {
                        NVIMGCODEC_LOG_WARNING(Logger::get_default(),
                                               "NVIMGCODEC environment variable is set, "
                                               "but does not have enough entries: thread_id (",
                                               thread_id, ") vs #entries (", vec.size(), "). Ignoring...");
                    }
                }
                nvml::SetCPUAffinity(core);
            }
#endif
        } catch (std::exception& e) {
            tl_errors_[thread_id].push(e.what());
        } catch (...) {
            tl_errors_[thread_id].push("Caught unknown exception");
        }

        while (running_) {
            // Block on the condition to wait for work
            std::unique_lock<std::mutex> lock(mutex_);
            condition_.wait(lock, [this] { return !running_ || (!work_queue_.empty() && started_); });
            // If we're no longer running, exit the run loop
            if (!running_)
                break;

            // Get work from the queue & mark
            // this thread as active
            auto it = work_queue_.begin();

            // if no suitable work for this thread, go to sleep
            if (it == work_queue_.end())
                continue;

            Work work = std::move(*it);
            work_queue_.erase(it);
            ++active_threads_;

            // Unlock the lock
            lock.unlock();

            // If an error occurs, we save it in tl_errors_. When
            // WaitForWork is called, we will check for any errors
            // in the threads and return an error if one occured.
            try {
                work(thread_id);
            } catch (std::exception& e) {
                lock.lock();