TFSingleton.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2026 Grok Image Compression Inc.
 *
 *    This source code is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This source code is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include <stdexcept>
#include <unordered_map>
#include <mutex>
#include <vector>
#include <cassert>
 
#include "grk_taskflow.h"

class TFSingleton
{
public:
  static void create(size_t numThreads)
  {
    std::lock_guard<std::mutex> lock(mutex_);
    numThreads = numThreads ? numThreads : std::thread::hardware_concurrency();
    if(numThreads_ == numThreads)
      return;
    numThreads_ = numThreads;
    instance_ = std::make_unique<tf::Executor>(numThreads_);
  }

  static tf::Executor& get(void)
  {
    std::lock_guard<std::mutex> lock(mutex_);
    if(!instance_)
    {
      // Initialize with default thread count if instance is null
      numThreads_ = std::thread::hardware_concurrency();
      ;
      instance_ = std::make_unique<tf::Executor>(numThreads_);
    }
    assert(instance_); // Should always be valid now
    return *instance_;
  }

  static size_t num_threads()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    return numThreads_;
  }

  static void destroy()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    instance_.reset();
  }

  static uint32_t workerId(void)
  {
    auto id = get().this_worker_id();
    return (id >= 0) ? (uint32_t)id : 0u;
  }
 
private:
  // Deleted copy constructor and assignment operator
  TFSingleton(const TFSingleton&) = delete;
  TFSingleton& operator=(const TFSingleton&) = delete;
  TFSingleton() = default;

  static std::unique_ptr<tf::Executor> instance_;

  static std::mutex mutex_;

  static size_t numThreads_;
};