lib-during/during-thread.h

Go to the documentation of this file.

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

#ifndef DURING_THREAD_H
#define DURING_THREAD_H

#include "during-if.h"
#include <boost/thread.hpp>
#include "task-manager.h"
#include "async-event-queue.h"

class sc_during_thread : public sc_during_if {
public:
        sc_during_thread();

        using sc_during_if::during;
        using sc_during_if::extra_time;
        using sc_during_if::catch_up;

        void extra_time(const sc_core::sc_time & t);
        
        void catch_up(const sc_core::sc_time & t);

        void sc_call(const boost::function<void()> & f);

        void during(const sc_core::sc_time & time,
                    const boost::function<void()> & routine) {
                sync_task r(routine, time);
                boost::thread t(call_routine, &r);
                m_current_thread = &t;
                r.wait_for_completion();
                m_current_thread = NULL;
                t.join();
        }

        virtual ~sc_during_thread() {
                if (m_current_thread) {
                        // the simulation stopped, but our task didn't
                        // yet. The t.join() in during() is in the
                        // same OS thread as we are, but in a
                        // different SystemC SC_THREAD. The end of
                        // during() is never going to be executed if
                        // we reach this point => do the work
                        // ourselves.
                        m_current_thread->interrupt();
                        m_current_thread->join();
                }
        };

        mode get_mode() { return thread; }

private:
        // Unoptimized management of extra_time:
        static void call_routine(sync_task *r) {
                task_manager::get_instance()->alloc_current_task();
                task_manager::get_instance()->set_current_task(r);
                r->process();
                task_manager::get_instance()->set_current_task(NULL);
        }
        // read and written to from the SystemC thread => no need to lock.
        boost::thread *m_current_thread;
};

#endif // DURING_THREAD_H