Ejemplo n.º 1
0
    void do_test(void (this_type::*test_func)())
    {
        Lock lock(m);

        locked=false;
        done=false;

        boost::thread t(test_func,this);

        try
        {
            {
                boost::mutex::scoped_lock lk(done_mutex);
                BOOST_CHECK(!done_cond.timed_wait(lk, boost::posix_time::seconds(1),
                                                 boost::bind(&this_type::is_done,this)));
            }
            lock.unlock();
            {
                boost::mutex::scoped_lock lk(done_mutex);
                BOOST_CHECK(done_cond.timed_wait(lk, boost::posix_time::seconds(1),
                                                 boost::bind(&this_type::is_done,this)));
            }
            t.join();
            BOOST_CHECK(locked);
        }
        catch(...)
        {
            lock.unlock();
            t.join();
            throw;
        }
    }
Ejemplo n.º 2
0
int main()
{
#if defined(BOOST_THREAD_PLATFORM_PTHREAD)

  for (int i=0; i<3; ++i)
  {
    const time_t now_time = ::time(0);
    const time_t wait_time = now_time+1;
    time_t end_time;
    assert(now_time < wait_time);

    boost::unique_lock<boost::mutex> lk(mtx);
    //const bool res =
    (void)cv.timed_wait(lk, from_time_t(wait_time));
    end_time = ::time(0);
    std::cerr << "now_time =" << now_time << " \n";
    std::cerr << "end_time =" << end_time << " \n";
    std::cerr << "wait_time=" << wait_time << " \n";
    std::cerr << "now_time =" << from_time_t(now_time) << " \n";
    std::cerr << "end_time =" << from_time_t(end_time) << " \n";
    std::cerr << "wait_time=" << from_time_t(wait_time) << " \n";
    std::cerr << end_time - wait_time << " \n";
    assert(end_time >= wait_time);
    std::cerr << " OK\n";
  }
#endif
  return 0;
}
    void operator()()
    {
        Lock lock(m);

        typedef test_initially_unlocked_if_other_thread_has_lock<Mutex,Lock> this_type;

        boost::thread t(&this_type::locking_thread,this);

        try
        {
            {
                boost::mutex::scoped_lock lk(done_mutex);
                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
                                                 boost::bind(&this_type::is_done,this)));
                BOOST_CHECK(!locked);
            }

            lock.unlock();
            t.join();
        }
        catch(...)
        {
            lock.unlock();
            t.join();
            throw;
        }
    }
Ejemplo n.º 4
0
 void relative_timed_wait_with_predicate()
 {
     boost::unique_lock<boost::mutex> lock(mutex);
     if(cond_var.timed_wait(lock,boost::posix_time::seconds(timeout_seconds),check_flag(flag)) && flag)
     {
         ++woken;
     }
 }
Ejemplo n.º 5
0
bool timedWaitOnMutex(boost::condition_variable &waitCond, boost::mutex &waitMutex, int secs, int msecs)
{
	boost::posix_time::ptime waitTime(boost::posix_time::microsec_clock::universal_time());
	waitTime += boost::posix_time::seconds(secs);
	waitTime += boost::posix_time::millisec(msecs);

	boost::unique_lock<boost::mutex> lock(waitMutex);
	return waitCond.timed_wait(lock, waitTime) == false;
}
Ejemplo n.º 6
0
 void timed_wait_with_predicate()
 {
     boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);
     boost::unique_lock<boost::mutex> lock(mutex);
     if(cond_var.timed_wait(lock,timeout,check_flag(flag)) && flag)
     {
         ++woken;
     }
 }
Ejemplo n.º 7
0
 /*!
  * The auto flusher ensures that buffers are force committed when
  * the user has not called get_new() within a certain time window.
  */
 void auto_flush(void)
 {
     boost::mutex::scoped_lock lock(_mutex);
     const bool timeout = not _cond.timed_wait(lock, AUTOFLUSH_TIMEOUT);
     if (timeout and _ok_to_auto_flush and _last_send_buff and _bytes_in_buffer != 0)
     {
         _last_send_buff->commit(_bytes_in_buffer);
         _last_send_buff.reset();
     }
 }
Ejemplo n.º 8
0
 void do_transaction(int comm_state) {
     lock_t lock(mtx_);
     comm_state_ = comm_state;
     lock.unlock();
     my_io_service_.send(tx_);
     lock.lock();
     while(comm_state_!=CST_IDLE){
         if(!rx_cond_var_.timed_wait(lock, boost::posix_time::milliseconds(op_timeout_ms_))){
             throw OperationTimeoutExcept();
         }
     }
 }
Ejemplo n.º 9
0
 BOOLEAN timed_wait_and_pop ( Data& value, INT64 millsec )
 {
    boost::system_time const timeout=boost::get_system_time() + 
          boost::posix_time::milliseconds(millsec);
    boost::mutex::scoped_lock lock ( _mutex ) ;
    while ( _queue.empty () )
       if ( !_cond.timed_wait ( lock, timeout ) )
          return FALSE ;
    value = _queue.front () ;
    _queue.pop () ;
    return TRUE ;
 }
Ejemplo n.º 10
0
    void timed_wait_without_predicate()
    {
        boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);

        boost::unique_lock<boost::mutex> lock(mutex);
        while(!flag)
        {
            if(!cond_var.timed_wait(lock,timeout))
            {
                return;
            }
        }
        ++woken;
    }
    bool timed_wait(Duration d)
    {
        boost::system_time const target=boost::get_system_time()+d;

        boost::unique_lock<boost::mutex> l(m);
        while(!flag)
        {
            if(!cond.timed_wait(l,target))
            {
                return flag;
            }
        }
        return true;
    }
Ejemplo n.º 12
0
 int wait(const boost::system_time& wait_until_abs_time, int* old_val = NULL) {
     #if 0
     if (old_val && *old_val != m_count) {
         *old_val = m_count;
         return 0;
     }
     #endif
     scoped_lock g(m_lock);
     try {
         return m_cond.timed_wait(g, wait_until_abs_time) ? 0 : ETIMEDOUT;
     } catch (std::exception&) {
         return -1;
     }
 }
Ejemplo n.º 13
0
        bool timed_lock_shared(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
            boost::mutex::scoped_lock lk(state_change);

            while(state.exclusive || state.exclusive_waiting_blocked)
            {
                if(!shared_cond.timed_wait(lk,timeout))
                {
                    return false;
                }
            }
            ++state.shared_count;
            return true;
        }
Ejemplo n.º 14
0
/**
 * Worker thread proc for Timer objects.
 */
void Timer::TimerThreadProc(void)
{
	Utility::SetThreadName("Timer Thread");

	for (;;) {
		boost::mutex::scoped_lock lock(l_Mutex);

		typedef boost::multi_index::nth_index<TimerSet, 1>::type NextTimerView;
		NextTimerView& idx = boost::get<1>(l_Timers);

		/* Wait until there is at least one timer. */
		while (idx.empty() && !l_StopThread)
			l_CV.wait(lock);

		if (l_StopThread)
			break;

		NextTimerView::iterator it = idx.begin();
		Timer::Ptr timer = it->lock();

		if (!timer) {
			/* Remove the timer from the list if it's not alive anymore. */
			idx.erase(it);
			continue;
		}

		double wait = timer->m_Next - Utility::GetTime();

		if (wait > 0) {
			/* Make sure the timer we just examined can be destroyed while we're waiting. */
			timer.reset();

			/* Wait for the next timer. */
			l_CV.timed_wait(lock, boost::posix_time::milliseconds(wait * 1000));

			continue;
		}

		/* Remove the timer from the list so it doesn't get called again
		 * until the current call is completed. */
		l_Timers.erase(timer);

		lock.unlock();

		/* Asynchronously call the timer. */
		Utility::QueueAsyncCallback(boost::bind(&Timer::Call, timer));
	}
}
Ejemplo n.º 15
0
    bool wait_and_pop(T& data, boost::posix_time::microseconds waitTime)
    {
        boost::system_time            timeout = boost::get_system_time() + waitTime;
        boost::mutex::scoped_lock     lockHandle(mutexHandle);

        if (condFlag.timed_wait(lockHandle, timeout,
                                isEmpty(&queueHandle))) {
            data = queueHandle.front();
            queueHandle.pop();
            condFlag.notify_all();

            return true;
        }
        else {
            return false;
        }
    }
Ejemplo n.º 16
0
    bool detectFiducialsServiceCallback(cob_object_detection_msgs::DetectObjects::Request &req,
                                        cob_object_detection_msgs::DetectObjects::Response &res)
    {
        ROS_DEBUG("[fiducials] Service Callback");

        // Connect to image topics
        bool result = false;
        synchronizer_received_ = false;
        connectCallback();

        // Wait for data
        {
            boost::mutex::scoped_lock lock( mutexQ_);
            boost::system_time const timeout=boost::get_system_time()+ boost::posix_time::milliseconds(5000);

            ROS_INFO("[fiducials] Waiting for image data");
            if (condQ_.timed_wait(lock, timeout))
                ROS_INFO("[fiducials] Waiting for image data [OK]");
            else
            {
                ROS_WARN("[fiducials] Could not receive image data from ApproximateTime synchronizer");
                return false;
            }

            // Wait for data (at least 5 seconds)
            //int nSecPassed = 0;
            //float nSecIncrement = 0.5;
            //while (!synchronizer_received_ && nSecPassed < 10)
            //{
            //	ros::Duration(nSecIncrement).sleep();
            //	nSecPassed += nSecIncrement;
            //	ROS_INFO("[fiducials] Waiting");
            //}

            //if (!synchronizer_received_)
            //{
            //	ROS_WARN("[fiducials] Could not receive image data");
            //	return false;
            //}

            result = detectFiducials(res.object_list, color_mat_8U3_);
        }
        disconnectCallback();

        return result;
    }
Ejemplo n.º 17
0
        bool timed_lock(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
            boost::mutex::scoped_lock lk(state_change);

            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
                if(!exclusive_cond.timed_wait(lk,timeout))
                {
                    if(state.shared_count || state.exclusive)
                    {
                        state.exclusive_waiting_blocked=false;
                        exclusive_cond.notify_one();
                        return false;
                    }
                    break;
                }
            }
            state.exclusive=true;
            return true;
        }
Ejemplo n.º 18
0
void CGpio::Do_Work()
{
	int interruptNumber = NO_INTERRUPT;
	boost::posix_time::milliseconds duration(12000);
	std::vector<int> triggers;

	_log.Log(LOG_NORM,"GPIO: Worker started...");

	while (!m_stoprequested) {
#ifndef WIN32
		boost::mutex::scoped_lock lock(interruptQueueMutex);
		if (!interruptCondition.timed_wait(lock, duration)) {
			//_log.Log(LOG_NORM, "GPIO: Updating heartbeat");
			mytime(&m_LastHeartbeat);
		} else {
			while (!gpioInterruptQueue.empty()) {
				interruptNumber = gpioInterruptQueue.front();
				triggers.push_back(interruptNumber);
				gpioInterruptQueue.erase(gpioInterruptQueue.begin());
				_log.Log(LOG_NORM, "GPIO: Acknowledging interrupt for GPIO %d.", interruptNumber);
			}
		}
		lock.unlock();

		if (m_stoprequested) {
			break;
		}

    	while (!triggers.empty()) {
		interruptNumber = triggers.front();
		triggers.erase(triggers.begin());
		CGpio::ProcessInterrupt(interruptNumber);
		}
#else
		sleep_milliseconds(100);
#endif
	}
	_log.Log(LOG_NORM,"GPIO: Worker stopped...");
}
Ejemplo n.º 19
0
void Main::loop(const string & device) {
	LOG4CPLUS_TRACE_STR(logger, "Main::loop()");

	struct sigaction action;

	action.sa_handler = &Main::signalHandler;
	action.sa_flags = SA_RESETHAND;
	sigemptyset(&action.sa_mask);

	int restart = false;

	do
	{
		/* Get logicalAddress after openning device */
		logicalAddress = cec.open(device);
		LOG4CPLUS_INFO(logger, "Address \"" << logicalAddress << "\"");
		if ( logicalAddress != CECDEVICE_UNKNOWN)
		    running = true;

		/* install signals */
		sigaction (SIGHUP,  &action, NULL);
		sigaction (SIGINT,  &action, NULL);
		sigaction (SIGTERM, &action, NULL);

		if (makeActive) {
			cec.makeActive();
		}

		do
		{
			boost::unique_lock<boost::mutex> libcec_lock(libcec_sync);

			while( running && !commands.empty() )
			{
				Command cmd = commands.front();
				switch( cmd.command )
				{
					case COMMAND_STANDBY:
						if( ! onStandbyCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Standby: Running \"" << onStandbyCommand << "\"");
							int ret = system(onStandbyCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Standby command failed: " << ret);
							
						}
						else
						{
							onCecKeyPress( CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION );
						}
						break;
					case COMMAND_ACTIVE:
						makeActive = true;
						if( ! onActivateCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Activated: Running \"" << onActivateCommand << "\"");
							int ret = system(onActivateCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Activate command failed: " << ret);
						}
						break;
					case COMMAND_INACTIVE:
						makeActive = false;
						if( ! onDeactivateCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Deactivated: Running \"" << onDeactivateCommand << "\"");
							int ret = system(onDeactivateCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Deactivate command failed: " << ret);
						}
						break;
					case COMMAND_KEYPRESS:
						onCecKeyPress( cmd.keycode );
						break;
					case COMMAND_RESTART:
						running = false;
						restart = true;
						break;
					case COMMAND_EXIT:
						running = false;
						break;
				}
				commands.pop();
			}
			int retriesRemaining = 3;
			while( running && !libcec_cond.timed_wait(libcec_lock, boost::posix_time::seconds(43)) )
			{
				// Since libcec's CAdapterPingThread::Process() tries pinging 3 times before raising a
				// connection lost alert, lets also make 3 attempts otherwise we'll stop running
				// before our alert handling gets a chance to do its job
				bool pinged = false;
				if( retriesRemaining > 0 && !(pinged = cec.ping()) )
				{
					--retriesRemaining;
					boost::this_thread::sleep(boost::posix_time::milliseconds(CEC_DEFAULT_TRANSMIT_RETRY_WAIT));
				}
				else
				{
					running = pinged;
				}
			}
		}
		while( running );

		/* reset signals */
		signal (SIGHUP,  SIG_DFL);
		signal (SIGINT,  SIG_DFL);
		signal (SIGTERM, SIG_DFL);

		cec.close(!restart);
	}
	while( restart );
}
Ejemplo n.º 20
0
void Main::loop(const string & device) {
	LOG4CPLUS_TRACE_STR(logger, "Main::loop()");

	struct sigaction action;

	action.sa_handler = &Main::signalHandler;
	action.sa_flags = SA_RESETHAND;
	sigemptyset(&action.sa_mask);

	int restart = false;

	do
	{
		cec.open(device);

		running = true;

		/* install signals */
		sigaction (SIGHUP,  &action, NULL);
		sigaction (SIGINT,  &action, NULL);
		sigaction (SIGTERM, &action, NULL);

		if (makeActive) {
			cec.makeActive();
		}

		do
		{
			boost::unique_lock<boost::mutex> libcec_lock(libcec_sync);

			while( running && !commands.empty() )
			{
				Command cmd = commands.front();
				switch( cmd.command )
				{
					case COMMAND_STANDBY:
						if( ! onStandbyCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Standby: Running \"" << onStandbyCommand << "\"");
							int ret = system(onStandbyCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Standby command failed: " << ret);
							
						}
						else
						{
							onCecKeyPress( CEC_USER_CONTROL_CODE_POWER );
						}
						break;
					case COMMAND_ACTIVE:
						makeActive = true;
						if( ! onActivateCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Activated: Running \"" << onActivateCommand << "\"");
							int ret = system(onActivateCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Activate command failed: " << ret);
						}
						break;
					case COMMAND_INACTIVE:
						makeActive = false;
						if( ! onDeactivateCommand.empty() )
						{
							LOG4CPLUS_DEBUG(logger, "Deactivated: Running \"" << onDeactivateCommand << "\"");
							int ret = system(onDeactivateCommand.c_str());
                            if( ret )
                                LOG4CPLUS_ERROR(logger, "Deactivate command failed: " << ret);
						}
						break;
					case COMMAND_KEYPRESS:
						onCecKeyPress( cmd.keycode );
						break;
					case COMMAND_RESTART:
						running = false;
						restart = true;
						break;
					case COMMAND_EXIT:
						running = false;
						break;
				}
				commands.pop();
			}
			while( running && !libcec_cond.timed_wait(libcec_lock, boost::posix_time::seconds(43)) )
			{
				running = cec.ping();
			}
		}
		while( running );

		/* reset signals */
		signal (SIGHUP,  SIG_DFL);
		signal (SIGINT,  SIG_DFL);
		signal (SIGTERM, SIG_DFL);

		cec.close(!restart);
	}
	while( restart );
}
Ejemplo n.º 21
0
        static void durThread() {
            Client::initThread("journal");

            bool samePartition = true;
            try {
                const std::string dbpathDir =
                    boost::filesystem::path(storageGlobalParams.dbpath).string();
                samePartition = onSamePartition(getJournalDir().string(), dbpathDir);
            }
            catch(...) {

            }

            while (shutdownRequested.loadRelaxed() == 0) {
                unsigned ms = storageGlobalParams.journalCommitInterval;
                if( ms == 0 ) { 
                    ms = samePartition ? 100 : 30;
                }

                unsigned oneThird = (ms / 3) + 1; // +1 so never zero

                try {
                    stats.rotate();

                    boost::mutex::scoped_lock lock(flushMutex);

                    // commit sooner if one or more getLastError j:true is pending
                    for (unsigned i = 0; i <= 2; i++) {
                        if (flushRequested.timed_wait(lock,
                                                      Milliseconds(oneThird))) {
                            // Someone forced a flush
                            break;
                        }

                        if (commitJob._notify.nWaiting())
                            break;
                        if (commitJob.bytes() > UncommittedBytesLimit / 2)
                            break;
                    }

                    OperationContextImpl txn;

                    // Waits for all active operations to drain and won't let new ones start. This
                    // should be optimized to allow readers in (see SERVER-15262).
                    AutoAcquireFlushLockForMMAPV1Commit flushLock(txn.lockState());

                    groupCommit();
                    remapPrivateView();
                }
                catch(std::exception& e) {
                    log() << "exception in durThread causing immediate shutdown: " << e.what() << endl;
                    mongoAbort("exception in durThread");
                }
                catch (...) {
                    log() << "unhandled exception in durThread causing immediate shutdown" << endl;
                    mongoAbort("unhandled exception in durThread");
                }
            }

            cc().shutdown();
        }