runner.cpp

Go to the documentation of this file.

// Copyright (c) 2013-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/cppthread
// contact@m2osw.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
// self
//
#include    "cppthread/runner.h"
 
#include    "cppthread/guard.h"
#include    "cppthread/log.h"
#include    "cppthread/thread.h"
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
 
namespace cppthread
{
 
 
 
runner::runner(std::string const & name)
    : f_name(name)
{
    // TBD: should we forbid starting a runner without a name?
}
 
 
runner::~runner()
{
    // the thread should never be set when the runner gets deleted
    if(f_thread)
    {
        // this is a bug; it could be that the object that derived from
        // the snap_runner calls gets destroyed under the thread controller's
        // nose and that could break a lot of things.
        log << log_level_t::fatal
            << "The Snap! thread runner named \""
            << f_name
            << "\" is still marked as running when its object is being destroyed."
            << end;
        std::terminate();
    }
}
 
 
std::string const & runner::get_name() const
{
    return f_name;
}
 
 
bool runner::is_ready() const
{
    return true;
}
 
 
bool runner::continue_running() const
{
    guard lock(f_mutex);
    if(f_thread == nullptr)
    {
        return true;
    }
    return !f_thread->is_stopping();
}
 
 
void runner::enter()
{
    // there is a mutex lock in the get_thread_tid() so try to avoid a
    // potential deadlock by getting the value ahead
    //
    pid_t const tid(f_thread->get_thread_tid());
 
    log << log_level_t::info
        << "entering thread \""
        << get_name()
        << "\" #"
        << tid
        << "."
        << end;
}
 
 
void runner::leave(leave_status_t status)
{
    // there is a mutex lock in the get_thread_tid() so try to avoid a
    // potential deadlock by getting the value ahead
    //
    pid_t const tid(f_thread->get_thread_tid());
 
    log << log_level_t::info
        << "leaving thread \""
        << get_name()
        << "\" #"
        << tid
        << " with status "
        << static_cast<int>(status)     // TODO: write name too
        << "."
        << end;
}
 
 
thread * runner::get_thread() const
{
    return f_thread;
}
 
 
pid_t runner::gettid() const
{
    return f_thread->get_thread_tid();
}
 
 
 
} // namespace cppthread
// vim: ts=4 sw=4 et