int main()
{
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
    BOOST_TEST(test1 == 0);
    while (test1 == 0)
      cv.wait(lk);
    BOOST_TEST(test1 != 0);
    test2 = 1;
    lk.unlock();
    cv.notify_one();
    t.join();
  }
  test1 = 0;
  test2 = 0;
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
    BOOST_TEST(test1 == 0);
    while (test1 == 0)
      cv.wait(lk);
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
  }

  return boost::report_errors();
}
Example #2
0
	virtual ~NetworkCacheLayer() {
		cleanup = true; // Prevents doFetch (callback for NameLookup) from starting a new download.
		std::list<DownloadHandler::TransferDataPtr> pendingDelete;
		{
			boost::unique_lock<boost::mutex> transfer_lock(mActiveTransferLock);
			for (std::list<RequestInfo>::iterator iter = mActiveTransfers.begin();
					iter != mActiveTransfers.end();
					++iter) {
				if ((*iter).httpreq) {
					pendingDelete.push_back((*iter).httpreq);
				}
			}
		}
		std::list<DownloadHandler::TransferDataPtr>::iterator iter;
		for (iter = pendingDelete.begin();
				iter != pendingDelete.end();
				++iter) {
			(*iter)->abort();
		}
		{
			boost::unique_lock<boost::mutex> transfer_lock(mActiveTransferLock);
			while (!mActiveTransfers.empty()) {
				mCleanupCV.wait(transfer_lock);
			}
		}
	}
Example #3
0
 void wait() {
     boost::unique_lock<boost::mutex> lock ( mutex_ );
     while ( count_ == 0 ) {
         condition_.wait ( lock );
     }
     --count_;
 }
Example #4
0
int main( int argc, char* argv[] )
{
	TA_Base_Test::CBoostLogger BoostLogger;
	BOOST_LOG_FUNCTION();


	TA_Base_Test::CTestCase* pTestCase = new TA_Base_Test::CTestCase();

	if (1 == g_runAsServer)
	{
		pTestCase->runTestCase_ForServer();
	}
	else
	{
		pTestCase->runTestCase_ForClient();
	}
	//

	//sleep
	{	
		boost::mutex::scoped_lock lock(g_mutexMainRun);
		g_conditionMainRun.wait(lock);
	}

	delete pTestCase;
	pTestCase = NULL;


	return 0;
}
Example #5
0
 void wait()
 {
     boost::mutex::scoped_lock lock(mutex_);
     while(!count_)
         condition_.wait(lock);
     --count_;
 }
Example #6
0
void WorkManagerImpl::WaitForWork()
{
    boost::unique_lock<boost::mutex> lock(m_dispatchermutex);
    while(m_workreq <= 0) m_condition.wait(lock);
    m_workreq--;
    if(m_workreq < 0) m_workreq = 0;
}
Example #7
0
	TaskPtr pull() {
		boost::unique_lock<boost::mutex> lock(_mutex);
		while (_running) {
			std::cout << "pull 0" << std::endl;
			if (!_tasks.empty()) {
				std::cout << "pull A" << std::endl;

				TaskPtr task = _tasks.front();
				_tasks.pop_front();
				return task;
			} else {
				std::cout << "pull B" << std::endl;
				_no_task.wait(lock);
				std::cout << "pull C" << std::endl;
			}
		}
		while (!_running) {
			std::cout << "pull 1" << std::endl;
			if (!_tasks.empty()) {
				std::cout << "pull D" << std::endl;
				TaskPtr task = _tasks.front();
				_tasks.pop_front();
				return task;
			} else {
				std::cout << "pull E" << std::endl;
				return TaskPtr();
			}
		}
		return TaskPtr();
	}
Example #8
0
boost::shared_ptr< const MapsBuffer::MapsRgb > 
MapsBuffer::getFront(bool print)
{
  boost::shared_ptr< const MapsBuffer::MapsRgb > depth_rgb;
  {
    boost::mutex::scoped_lock buff_lock (bmutex_);
    while (buffer_.empty ())
    {
      if (is_done)
        break;
      {
        boost::mutex::scoped_lock io_lock (io_mutex);
              //std::cout << "No data in buffer_ yet or buffer is empty." << std::endl;
      }
      buff_empty_.wait (buff_lock);
    }
    depth_rgb = buffer_.front ();
    buffer_.pop_front ();
  }
  
  if(print)
    PCL_INFO("%d maps left in the buffer...\n", buffer_.size ());
  
  return (depth_rgb);
}
void displayThreadLoop()
{
	printf("started image display thread!\n");
	boost::unique_lock<boost::mutex> lock(openCVdisplayMutex);
	while(imageThreadKeepRunning)
	{
		openCVdisplaySignal.wait(lock);

		if(!imageThreadKeepRunning)
			break;

		while(displayQueue.size() > 0)
		{
			if(!displayQueue.back().autoSize)
			{
				if(openWindows.find(displayQueue.back().name) == openWindows.end())
				{
					cv::namedWindow(displayQueue.back().name, cv::WINDOW_NORMAL);
					cv::resizeWindow(displayQueue.back().name, displayQueue.back().img.cols, displayQueue.back().img.rows);
					openWindows.insert(displayQueue.back().name);
				}
			}
			cv::imshow(displayQueue.back().name, displayQueue.back().img);
			cv::waitKey(1);
			displayQueue.pop_back();
		}
	}
	cv::destroyAllWindows();
	openWindows.clear();

	printf("ended image display thread!\n");
}
Example #10
0
    void consumeToLog()
    {
        while (true)
        {
            try
            {
                typename LogObject::SmartPtr logObj;
                {
                    boost::mutex::scoped_lock lock(_qMutex);

                    while (_queue.size() == 0)
                    {
                        if (_isStopping)
                        {
                            std::cout << " Stopping consumeToLog Thread. " << std::endl;
                            return;
                        }
                        _qCondVar.wait(lock);
                    }

                    // Get the entry
                    logObj = _queue.front();
                    _queue.pop();
                }
                printLogObject(logObj);
            }
            catch (const boost::thread_interrupted& err)
            {
                std::cout << " Log::consumeToLog() - Got Interrupt Signal. " << _queue.size() << std::endl;
            }
        }//while
    }
    void record_thread_loop(void)
    {
        int buffer_no = 0;

        /* open log file*/
        FILE *logfile = fopen("fwrite_thread_testlog.log","w");
        BOOST_REQUIRE_MESSAGE(logfile != NULL, "Could not open logfile!");

        boost::unique_lock<boost::mutex> lock(mutex);

        while(record_thread_running)
        {
            record_trigger.wait(lock);
            if(buffer_no < 2)
            {
                active_buffer = &string_buffer_2;
                fwrite(string_buffer_1.c_str(), sizeof(char), string_buffer_1.length(), logfile);
                string_buffer_1.clear();
                buffer_no = 2;
            }
            else
            {
                active_buffer = &string_buffer_1;
                fwrite(string_buffer_2.c_str(), sizeof(char), string_buffer_2.length(), logfile);
                string_buffer_2.clear();
                buffer_no = 1;
            }
        }
        fclose(logfile);
    }
Example #12
0
void slave_thread(int id)
{
    printf("    +++ slave thread %d: starting\n", id);

    while (true)
    {
        boost::unique_lock<boost::mutex> lock(data_ready_mutex);
        while (!data_ready)
        {
            data_ready_cond.wait(lock);
        }
        data_ready = false;

        unsigned work_unit;
        {
            boost::lock_guard<boost::mutex> lock(work_queue_mutex);
            if (work_queue.size() == 0)
                abort();
            work_unit = work_queue.back();
            work_queue.pop_back();
        }
        printf("        slave thread %d: got work unit %u\n", id, work_unit);

        // Pretend to work
        boost::chrono::milliseconds sleepDuration(3);
        boost::this_thread::sleep_for(sleepDuration);
    }

    printf("    --- slave thread %d: finished\n", id);
}
Example #13
0
static void status_paused_wait(Recog *recog, void *dummy) {

	boost::unique_lock<boost::mutex> lock(pause_mutex);

	pause_variable.wait(lock);

}
    void record_thread_loop(void)
    {
        int buffer_no = 0;
        std::ofstream logfile;

        /* open log file*/
        logfile.open ("stream_thread_testlog.log", ios::out);
        if (!logfile.is_open())
        {
            cout << "Could not open logfile!" << endl;
        }

        boost::unique_lock<boost::mutex> lock(mutex);

        while(datagen_thread_running)
        {
            record_trigger.wait(lock);
            if(buffer_no < 2)
            {
                active_buffer = &string_buffer_2;
                logfile << string_buffer_1;
                string_buffer_1.clear();
                buffer_no = 2;
            }
            else
            {
                active_buffer = &string_buffer_1;
                logfile << string_buffer_2;
                string_buffer_2.clear();
                buffer_no = 1;
            }
        }
        logfile.close();
    }
Example #15
0
int main(int argc, char* argv[])
{
    if (argc < 3) {
        cout << "Usage: " << argv[0] << " <host> <port> [magic_bytes=0xd9b4bef9ul]" << endl
             << "  Pings a bitcoin-like node and gets the version information." << endl;
        return 0;
    }
    uint16_t port = strtoul(argv[2], NULL, 10);

    NetworkAddress address(NODE_NETWORK, DEFAULT_Ipv6, port);

    CoinNodeSocket nodeSocket;

    try {
        nodeSocket.open(MessageHandler, listener_network::MAGIC_BYTES, listener_network::PROTOCOL_VERSION, argv[1], port);
        nodeSocket.doHandshake(listener_network::PROTOCOL_VERSION, NODE_NETWORK, time(NULL), address, address, 0, "", 0);
        nodeSocket.waitOnHandshakeComplete();

        boost::unique_lock<boost::mutex> lock(mutex);
        while (!bGotVersion) gotVersion.wait(lock);
    }
    catch (const exception& e) {
        cout << e.what() << endl;
    }
}
bool PresentationEngineManager::startDocument( const std::string &file ) {
	LDEBUG( "PresentationEngineManager", "Start document: doc=%s", file.c_str() );

	if (formatter()) {
		_sys->enqueue( boost::bind( &PresentationEngineManager::stopDocument, this ) );
		{ //	Wait for compare
			boost::unique_lock<boost::mutex> lock( _stopMutex );
			while (!_stopped) {
				_stopWakeup.wait( lock );
			}
			_stopped = false;
		}

	}

	//	Init settings module
	player::settings::init();

	initFormatter( file );
	if (!formatter()->parseDocument()) {
		LWARN( "PresentationEngineManager", "parseDocument fail" );
		return false;
	}

	//	Play formatter
	_sys->enqueue( boost::bind( &FormatterMediator::play, formatter() ) );

	return true;
}
Example #17
0
 void pop(T &result)
 {
     boost::unique_lock<boost::mutex> u(m);
     c.wait(u, [&]{return !q.empty();} );
     result = move_if_noexcept(q.front());
     q.pop();
 }
 void operator()()
 {
     boost::unique_lock<boost::mutex> lk(mut);
     while(!done)
     {
         cond.wait(lk);
     }
 }
 void wait()
 {
     boost::unique_lock<boost::mutex> l(m);
     while(!flag)
     {
         cond.wait(l);
     }
 }
 void operator()()
 {
     boost::mutex::scoped_lock lk(mut);
     while(!done)
     {
         cond.wait(lk);
     }
 }
Example #21
0
 void wait_and_pop ( Data& value )
 {
    boost::mutex::scoped_lock lock ( _mutex ) ;
    while ( _queue.empty () )
       _cond.wait ( lock ) ;
    value = _queue.front () ;
    _queue.pop () ;
 }
 void wait()
 {
     boost::mutex::scoped_lock l(m);
     while(!flag)
     {
         cond.wait(l);
     }
 }
	unsigned long long waitAndGetFrontElement(T* &pFrontData) {
		boost::mutex::scoped_lock lock(_mutex);
		while (_queue.empty()) {
			_conditionVar.wait(lock);
		}
		pFrontData = _queue.front().data;
		return _queue.front().pushedTime;
	}
 void wait_with_predicate()
 {
     boost::unique_lock<boost::mutex> lock(mutex);
     cond_var.wait(lock,check_flag(flag));
     if(flag)
     {
         ++woken;
     }
 }
void wait_for_data_to_process()
{
	boost::unique_lock<boost::mutex> unique_lock(mutex);
	while(!data_ready)
	{
		condition_variable.wait(unique_lock);
	}
	process_data();
}
Example #26
0
 void operator()()
 {
     boost::unique_lock<boost::mutex> lock(mutex_);
     while (!terminated_)
     {
         io_service_.run();
         condition_.wait(lock);
     }
 }
 void wait_without_predicate()
 {
     boost::unique_lock<boost::mutex> lock(mutex);
     while(!flag)
     {
         cond_var.wait(lock);
     }
     ++woken;
 }
Example #28
0
 int wait(int* old_val = NULL) {
     if (old_val && *old_val != m_count) {
         *old_val = m_count;
         return 0;
     }
     scoped_lock g(m_lock);
     try { m_cond.wait(g); } catch(...) { return -1; }
     return 0;
 }
Example #29
0
    // for data queue
    void wait_and_push(T data)
    {
        boost::mutex::scoped_lock     lockHandle(mutexHandle);

        condFlag.wait(lockHandle, isFull(&queueHandle, sizeMax));
        queueHandle.push(data);
        lockHandle.unlock();
        condFlag.notify_all();
    }
Example #30
0
int main(int argc, char* argv[])
{
	StringVec args = StringVec(argv, argv + argc);
	if(argc > 1 && !argumentsHandler(args))
		return 0;

	std::set_new_handler(allocationHandler);
	ServiceManager servicer;
	g_config.startup();

#ifdef __OTSERV_ALLOCATOR_STATS__
	boost::thread(boost::bind(&allocatorStatsThread, (void*)NULL));
	// TODO: shutdown this thread?
#endif
#ifdef __EXCEPTION_TRACER__
	ExceptionHandler mainExceptionHandler;
	mainExceptionHandler.InstallHandler();
#endif
#ifndef WINDOWS

	// ignore sigpipe...
	struct sigaction sigh;
	sigh.sa_handler = SIG_IGN;
	sigh.sa_flags = 0;

	sigemptyset(&sigh.sa_mask);
	sigaction(SIGPIPE, &sigh, NULL);

	// register signals
	signal(SIGHUP, signalHandler); //save
	signal(SIGTRAP, signalHandler); //clean
	signal(SIGCHLD, signalHandler); //refresh
	signal(SIGUSR1, signalHandler); //close server
	signal(SIGUSR2, signalHandler); //open server
	signal(SIGCONT, signalHandler); //reload all
	signal(SIGQUIT, signalHandler); //save & shutdown
	signal(SIGTERM, signalHandler); //shutdown
#endif

	OutputHandler::getInstance();
	Dispatcher::getInstance().addTask(createTask(boost::bind(otserv, args, &servicer)));

	g_loaderSignal.wait(g_loaderUniqueLock);
	if(servicer.isRunning())
	{
		std::clog << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " server Online!" << std::endl << std::endl;
		servicer.run();
	}
	else
		std::clog << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " server Offline! No services available..." << std::endl << std::endl;

#ifdef __EXCEPTION_TRACER__
	mainExceptionHandler.RemoveHandler();
#endif
	return 0;
}