Class ParallelManager

Source/astcenc_internal_entry.h:97–324

* @brief A simple counter-based manager for parallel task execution. * * The task processing execution consists of: * * * A single-threaded init stage. * * A multi-threaded processing stage. * * A condition variable so threads can wait for processing completion. * * The init stage will be executed by the first thread to arrive in the critical section, there is * no main thread

 *     manager->term(<lambda>)
 */
class ParallelManager
{
private:
	/** @brief Lock used for critical section and condition synchronization. */
	std::mutex m_lock;

	/** @brief True if the current operation is cancelled. */
	std::atomic<bool> m_is_cancelled;

	/** @brief True if the stage init() step has been executed. */
	bool m_init_done;

	/** @brief True if the stage term() step has been executed. */
	bool m_term_done;

	/** @brief Condition variable for tracking stage processing completion. */
	std::condition_variable m_complete;

	/** @brief Number of tasks started, but not necessarily finished. */
	std::atomic<size_t> m_start_count;

	/** @brief Number of tasks finished. */
	size_t m_done_count;

	/** @brief Number of tasks that need to be processed. */
	size_t m_task_count;

	/** @brief Progress callback (optional). */
	astcenc_progress_callback m_callback;

	/** @brief Lock used for callback synchronization. */
	std::mutex m_callback_lock;

	/** @brief Minimum progress before making a callback. */
	float m_callback_min_diff;

	/** @brief Last progress callback value. */
	float m_callback_last_value;

public:
	/** @brief Create a new ParallelManager. */
	ParallelManager()
	{
		reset();
	}

	/**
	 * @brief Reset the tracker for a new processing batch.
	 *
	 * This must be called from single-threaded code before starting the multi-threaded processing
	 * operations.
	 */
	void reset()
	{
		m_init_done = false;
		m_term_done = false;
		m_is_cancelled = false;
		m_start_count = 0;