lib-during/thread-pool-ondemand.h

Go to the documentation of this file.

/********************************************************************
 * Copyright (C) 2012 by Verimag                                    *
 * Initial author: Matthieu Moy                                     *
 * This file must not be distributed outside Verimag                *
 ********************************************************************/

#ifndef THREAD_POOL_ONDEMAND_H
#define THREAD_POOL_ONDEMAND_H

#include <systemc>
#include "thread-pool-base.h"
#include "sync-task.h"
#include "utils/io-lock.h"

class thread_pool_ondemand : public thread_pool_base {
public:
        static thread_pool_ondemand *get_instance();
        static void delete_instance();

        void queue(sync_task *r, sc_core::sc_process_b *current = NULL) {
                D_COUT << "// TEST-IGNORE: Queuing task " << r << std::endl;
                boost::unique_lock<boost::mutex> lock(m_mut);
                if (current == NULL) {
                        current = sc_core::sc_get_curr_simcontext()
                                ->get_curr_proc_info()
                                ->process_handle;
                }
                assert(current != NULL);
                task_and_consumer &tac = m_task_map[current];
                tac.m_task = r;
                tac.m_done = (r == NULL);
                if (tac.m_thread == NULL)
                        tac.m_thread = add_thread(current);
                // Several consumers may be waiting, but not
                // necessarily for this thread => wake them all.
                // We could optimize by having one condition per item
                // it the m_task_map.
                m_cond.notify_all();
        }
private:
        sync_task *pop_task(sc_core::sc_process_b *current) {
                boost::unique_lock<boost::mutex> lock(m_mut);
                assert(current != NULL);
                task_and_consumer &tac = m_task_map[current];
                assert(tac.m_thread->get_id() == boost::this_thread::get_id());
                while(tac.m_task == NULL
                      && tac.m_done == false) {
                        m_cond.wait(lock);
                }
                sync_task *res = tac.m_task;
                tac.m_task = NULL;
                D_COUT << "// TEST-IGNORE: Got a task " << res << std::endl;
                return res;
        }

private:
        static thread_pool_ondemand *m_instance;
        thread_pool_ondemand();
        ~thread_pool_ondemand();

        sync_task *m_pending_task;

        struct task_and_consumer {
                sync_task *m_task;
                thread_ptr m_thread;
                bool m_done;
                task_and_consumer() 
                        : m_task(NULL), m_thread(NULL), m_done(false) {/* */}
        };
        
        typedef std::map<sc_core::sc_process_b *, task_and_consumer> task_map_t;
        task_map_t m_task_map;

        boost::condition_variable m_cond;
        boost::mutex m_mut;
};

#endif // THREAD_POOL_ONDEMAND_H