void SC_TerminalClient::tick( const boost::system::error_code& error )
{
mTimer.cancel();
double secs;
lock();
bool haveNext = tickLocked( &secs );
unlock();
flush();
std::chrono::system_clock::time_point nextAbsTime;
ElapsedTimeToChrono( secs, nextAbsTime );
if (haveNext) {
mTimer.expires_at(nextAbsTime);
mTimer.async_wait(boost::bind(&SC_TerminalClient::tick, this, _1));
}
}
void SC_TerminalClient::commandLoop()
{
bool haveNext = false;
struct timespec nextAbsTime;
lockSignal();
while( shouldBeRunning() )
{
while ( mSignals ) {
int sig = mSignals;
mSignals = 0;
unlockSignal();
if (sig & sig_input) {
//postfl("input\n");
lockInput();
interpretInput();
unlockInput();
}
if (sig & sig_sched) {
//postfl("tick\n");
double secs;
lock();
haveNext = tickLocked( &secs );
unlock();
flush();
//postfl("tick -> next time = %f\n", haveNext ? secs : -1);
ElapsedTimeToTimespec( secs, &nextAbsTime );
}
if (sig & sig_stop) {
stopMain();
}
if (sig & sig_recompile) {
recompileLibrary();
}
lockSignal();
}
if( !shouldBeRunning() ) {
break;
}
else if( haveNext ) {
int result = pthread_cond_timedwait( &mCond, &mSignalMutex, &nextAbsTime );
if( result == ETIMEDOUT ) mSignals |= sig_sched;
}
else {
pthread_cond_wait( &mCond, &mSignalMutex );
}
}
unlockSignal();
}
void SC_TerminalClient::commandLoop()
{
bool haveNext = false;
struct timespec nextAbsTime;
lockSignal();
while( shouldBeRunning() )
{
while ( mSignals ) {
int sig = mSignals;
unlockSignal();
if (sig & sig_input) {
//postfl("input\n");
lockInput();
interpretInput();
// clear input signal, as we've processed anything signalled so far.
lockSignal();
mSignals &= ~sig_input;
unlockSignal();
unlockInput();
}
if (sig & sig_sched) {
//postfl("tick\n");
double secs;
lock();
haveNext = tickLocked( &secs );
// clear scheduler signal, as we've processed all items scheduled up to this time.
// and will enter the wait according to schedule.
lockSignal();
mSignals &= ~sig_sched;
unlockSignal();
unlock();
flush();
//postfl("tick -> next time = %f\n", haveNext ? secs : -1);
ElapsedTimeToTimespec( secs, &nextAbsTime );
}
if (sig & sig_stop) {
stopMain();
lockSignal();
mSignals &= ~sig_stop;
unlockSignal();
}
if (sig & sig_recompile) {
recompileLibrary();
lockSignal();
mSignals &= ~sig_recompile;
unlockSignal();
}
lockSignal();
}
if( !shouldBeRunning() ) {
break;
}
else if( haveNext ) {
int result = pthread_cond_timedwait( &mCond, &mSignalMutex, &nextAbsTime );
if( result == ETIMEDOUT ) mSignals |= sig_sched;
}
else {
pthread_cond_wait( &mCond, &mSignalMutex );
}
}
unlockSignal();
}
void SC_TerminalClient::commandLoop()
{
bool haveNext = false;
mutex_chrono::system_clock::time_point nextAbsTime;
lockSignal();
while( shouldBeRunning() ) {
while ( mSignals ) {
int sig = mSignals;
mSignals = 0;
unlockSignal();
if (sig & sig_input) {
//postfl("input\n");
lockInput();
interpretInput();
unlockInput();
}
if (sig & sig_sched) {
//postfl("tick\n");
double secs;
lock();
haveNext = tickLocked( &secs );
unlock();
flush();
//postfl("tick -> next time = %f\n", haveNext ? secs : -1);
ElapsedTimeToChrono( secs, nextAbsTime );
}
if (sig & sig_stop) {
stopMain();
}
if (sig & sig_recompile) {
recompileLibrary();
}
lockSignal();
}
if( !shouldBeRunning() ) {
break;
}
else if( haveNext ) {
unlockSignal();
{
unique_lock<SC_Lock> lock(mSignalMutex);
cv_status status = mCond.wait_until(lock, nextAbsTime);
if( status == cv_status::timeout )
mSignals |= sig_sched;
}
lockSignal();
}
else {
unlockSignal();
{
unique_lock<SC_Lock> lock(mSignalMutex);
mCond.wait(lock);
}
lockSignal();
}
}
unlockSignal();
}
