lib-during/sync-task.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 SYNC_TASK_H
#define SYNC_TASK_H

//#define SC_DURING_DEBUG
#define SC_CALL_USES_ASYNC_REQUEST_UPDATE

#include <systemc>
#include <boost/thread.hpp>
#include "utils/io-lock.h"
#ifdef SC_CALL_USES_ASYNC_REQUEST_UPDATE
#include "async-event-queue.h"
#endif

class sync_task {
private:
        sync_task(const sync_task &) {};

private:
        bool wait_task(sc_core::sc_time &remaining_time) {
                boost::unique_lock<boost::mutex> lock(m_mutex);
                while ((!m_done) 
                       && m_remaining_time == sc_core::SC_ZERO_TIME
                       && m_sc_function.empty())
                        m_cond_systemc.wait(lock);
                if (!m_sc_function.empty()) {
                        // If we reach this point, it means the
                        // separate thread is waiting for
                        // m_sc_function_executed to be notified, and
                        // no one else is accessing m_sc_function.
                        // It's safe to unlock the mutex.
                        // It's actually needed, because m_sc_function
                        // may call sc_core::wait(), which will
                        // trigger a context-switch and may never
                        // terminate (e.g. if simulation terminates
                        // before wait() returns), hence never unlock
                        // the lock. If it is the case, the simulation
                        // deadlocks when trying to interrupt threads.
                        lock.unlock();
                        m_sc_function();
                        // We must re-lock before setting m_sc_function
                        lock.lock();
                        m_sc_function = NULL;
                        m_sc_function_executed.notify_one();
                }
                // If there's no catchup ongoing, just advance
                // SystemC time till the end of the task. If
                // there's a timed catchup, we can let SystemC
                // time advance only until the date required
                // by the catchup. This way, catchup will
                // terminate faster.
                remaining_time = m_remaining_time - m_catch_up_time;
                return m_done;
        }

private:
        void consume_remaining_time(sc_core::sc_time &remaining_time) {
                // remaining_time is passed as argument to make it a
                // local variable. This is needed to be able to call
                // sc_core::wait outside the critical section.
                D_COUT << "// TEST-IGNORE: Remaining time to consume: "
                       << remaining_time << std::endl;
                // At this point, m_remaining_time starts
                // being "optimistic": the actual
                // simulation advances, and
                // m_remaining_time doesn't reduce. It reduces
                // right after in consume_remaining_time().
#ifdef SC_CALL_USES_ASYNC_REQUEST_UPDATE
                sc_core::sc_time before = sc_core::sc_time_stamp();
                sc_core::wait(remaining_time, m_systemc_synchro_ev);
                const sc_core::sc_time &time_waited = sc_core::sc_time_stamp() - before;
#else
                sc_core::wait(remaining_time);
                const sc_core::sc_time &time_waited = remaining_time;
#endif
                {
                        boost::unique_lock<boost::mutex> lock(m_mutex);
                        m_remaining_time -= time_waited;
                }
                m_cond_catch_up.notify_one();
        }

public:
        sync_task(const boost::function<void()> & routine,
                  const sc_core::sc_time & t = sc_core::SC_ZERO_TIME)
                : m_routine(routine),
                  m_done(false),
                  m_remaining_time(t),
                  m_catch_up_time(sc_core::SC_ZERO_TIME)
                {/* */};

        void wait_for_completion() {
                sc_core::sc_time remaining_time;
                bool done;
                do {
                        done = this->wait_task(remaining_time);
                        consume_remaining_time(remaining_time);
                        // if done == true, then it has been true
                        // since the exit of wait(), and nothing has
                        // been executed that can have interfered with
                        // consume_remaining_time().
                } while (!done);
        }

        void extra_time(const sc_core::sc_time & t) {
                {
                        boost::unique_lock<boost::mutex> lock(m_mutex);
                        m_remaining_time += t;
                }
                D_COUT << "// TEST-IGNORE: extra_time(" << t << ") => "
                       << m_remaining_time << std::endl;
                m_cond_systemc.notify_one();
        }

        void catch_up(const sc_core::sc_time & t) {
                boost::unique_lock<boost::mutex> lock(m_mutex);
                m_catch_up_time = t;
                // m_catch_up_time is used by wait(...), but we don't
                // need to notify the condition, since the use of
                // m_catch_up_time is just an optimization and is not
                // blocking the process (it is not a "condition").
                // We're protected by m_mutex, so concurrent
                // accesses are OK.
                D_COUT << "// TEST-IGNORE: entering catch up (" << t << ")" << std::endl;

                while (!(m_remaining_time <= m_catch_up_time)) {
                        m_cond_catch_up.wait(lock);
                }
                m_catch_up_time = sc_core::SC_ZERO_TIME;
                D_COUT << "// TEST-IGNORE: leaving catch up" << std::endl;
        }

        void sc_call(const boost::function<void()> & f) {
                boost::unique_lock<boost::mutex> lock(m_mutex);
                m_sc_function = f;
#ifdef SC_CALL_USES_ASYNC_REQUEST_UPDATE
                // Give the SystemC process a chance to execute us
                // ASAP. This may interrupt the ongoing call to
                // sc_core::wait on the SystemC side.
                m_async_event_queue.async_notify_event(m_systemc_synchro_ev);
#endif
                m_cond_systemc.notify_one();
                do {
                        D_COUT << "// TEST-IGNORE: sc_call: wait(lock) id = "
                               << boost::this_thread::get_id() << std::endl;
                        m_sc_function_executed.wait(lock);
                } while (!m_sc_function.empty());
        }

        void process() {
                m_routine();
                {
                        boost::unique_lock<boost::mutex> lock(m_mutex);
                        m_done = true;
                        // We cannot release the lock here, otherwise
                        // the destructor could be run concurrently
                        // with this notify(), causing a crash: if the
                        // task runs very fast, it can set m_done
                        // before the SystemC thread enters the
                        // critical section in wait(), which would
                        // therefore exit immediately, and let the
                        // caller destroy the task while we call
                        // notify_one().
                        m_cond_systemc.notify_one();
                }
        }
public:
        void wait_nosc() {
                sc_core::sc_time time;
                bool done = wait_task(time);
                (void)done; // suppress warning with NDEBUG
                assert(done == true);
                assert(time == sc_core::SC_ZERO_TIME);
        }
private:
        boost::function<void()> m_routine;

        bool m_done;
        sc_core::sc_time m_remaining_time;
        boost::condition_variable m_cond_systemc;
        boost::mutex m_mutex;

        boost::condition_variable m_sc_function_executed;
        boost::function<void()> m_sc_function;
#ifdef SC_CALL_USES_ASYNC_REQUEST_UPDATE
        // Instanciating this event is not thread-safe.
        sc_core::sc_event m_systemc_synchro_ev;
        static async_event_queue m_async_event_queue;
#endif

        boost::condition_variable m_cond_catch_up;
        sc_core::sc_time m_catch_up_time;
        /* @} */
};

#endif // SYNC_TASK_H