Threaded.cpp

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2021 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "bio/common/Threaded.h"
#include "bio/common/Cast.h"
 
//@formatter:off
#if BIO_CPP_VERSION < 11
 #ifdef BIO_OS_IS_LINUX
 #include <unistd.h>
 #endif
#else
 #include <chrono>
#endif
//@formatter:on
 
namespace bio {
 
Threaded::Threaded()
 :
//@formatter:off
 #if BIO_CPP_VERSION < 11
 #ifdef BIO_OS_IS_LINUX
 //use m_thread default ctor
 #endif
 m_id(InvalidThreadId()),
 #else
 m_thread(NULL),
 #endif
 //@formatter:on
 m_created(false),
 m_running(false),
 m_stopRequested(false)
{
 
}
 
Threaded::~Threaded()
{
 BIO_ASSERT(!m_running);
}
 
bool Threaded::IsRunning()
{
 LockThread();
 bool ret = m_running;
 UnlockThread();
 return ret;
}
 
void Threaded::RequestStop()
{
 LockThread();
 m_stopRequested = true;
 UnlockThread();
}
 
/*static*/ void* Threaded::Worker(void* arg)
{
 Threaded* threaded = Cast< Threaded* >(arg);
 BIO_SANITIZE(threaded, ,
 return NULL);
 
 threaded->LockThread();
 threaded->m_running = true;
 threaded->UnlockThread();
 
 bool again = true;
 while (again)
 {
 bool again = threaded->Work();
 threaded->LockThread();
 again = again && threaded->m_stopRequested;
 threaded->UnlockThread();
 }
 
 threaded->LockThread();
 threaded->m_running = false;
 threaded->UnlockThread();
 
 return NULL;
}
 
Threaded::ThreadId Threaded::GetThreadId()
{
 //@formatter:off
 #if BIO_CPP_VERSION < 11
 return m_id;
 #else
 BIO_SANITIZE(m_thread,,return InvalidThreadId())
 return m_thread->get_id();
 #endif
 //@formatter:on
}
 
bool Threaded::Start()
{
 LockThread();
 bool isStopped = !m_created && !m_running;
 UnlockThread();
 //@formatter:off
 BIO_SANITIZE(!isStopped, ,return true)
 //@formatter:on
 
 //@formatter:off
 #if BIO_CPP_VERSION < 11
 BIO_SANITIZE(m_running,,return false)
 #ifdef BIO_OS_IS_LINUX
 int result = pthread_create(&m_thread, NULL, Worker, this);
 #endif
 m_created = result == 0;
 #else
 BIO_SANITIZE(m_thread,,return false)
 m_thread = new std::thread(&Threaded::Worker, this);
 m_created = true
 #endif
 //@formatter:on
 return m_created;
}
 
bool Threaded::Stop()
{
 LockThread();
 bool isStopped = !m_created && !m_running;
 UnlockThread();
 
 BIO_SANITIZE(isStopped, ,
 return true)
 //@formatter:off
 #if BIO_CPP_VERSION < 11
 m_stopRequested = true;
 #ifdef BIO_OS_IS_LINUX
 void** threadReturn;
 int result = pthread_join(m_thread, threadReturn);
 #endif
 RequestStop();
 m_created = false;
 return result == 0;
 #else
 BIO_SANITIZE(m_thread,,return true)
 RequestStop();
 m_thread->join();
 delete m_thread;
 m_thread = NULL;
 m_created = false;
 return true;
 #endif
 //@formatter:on
 
}
 
void Threaded::Sleep(TimeUS us)
{
 //@formatter:off
 #if BIO_CPP_VERSION < 11
 #ifdef BIO_OS_IS_LINUX
 usleep(us);
 #endif
 #else
 std::this_thread::sleep_for (std::chrono::microseconds(ms));
 #endif
 //@formatter:on
}
 
} //bio namespace