/**
 * \brief Executes the callback of a timer.
 *
 * Then, if the callback returns \c true, the timer is rescheduled,
 * otherwise it is discarded.
 *
 * Does nothing if the timer is already finished.
 *
 * \param timer The timer to execute.
 */
void LuaContext::do_timer_callback(const TimerPtr& timer) {

  Debug::check_assertion(timer->is_finished(), "This timer is still running");

  auto it = timers.find(timer);
  if (it != timers.end() &&
      !it->second.callback_ref.is_empty()) {
    ScopedLuaRef& callback_ref = it->second.callback_ref;
    push_ref(l, callback_ref);
    const bool success = call_function(0, 1, "timer callback");

    bool repeat = false;
    if (success) {
      repeat = lua_isboolean(l, -1) && lua_toboolean(l, -1);
      lua_pop(l, 1);
    }

    if (repeat) {
      // The callback returned true: reschedule the timer.
      timer->set_expiration_date(timer->get_expiration_date() + timer->get_initial_duration());
      if (timer->is_finished()) {
        // Already finished: this is possible if the duration is smaller than
        // the main loop stepsize.
        do_timer_callback(timer);
      }
    }
    else {
      callback_ref.clear();
      timers_to_remove.push_back(timer);
    }
  }
}

	void Bagger::buildTree(){
		int treeId;
		
		// Choose tree id
		m_chooseTree->lock();
		treeId = m_treeId++;
		m_chooseTree->unlock();

		// sorting is performed inside this constructor
		DataCachePtr myData = DataCachePtr(new DataCache(m_data,m_evaluation,m_seed));

		// create the in-bag dataset (and be sure to remember what's in bag)
		// for computing the out-of-bag error later
		DataCachePtr bagData = myData->resample(m_bagSize);
		/*bagData.reusableRandomGenerator = bagData.getRandomNumberGenerator(
				random.nextInt());*/
		m_inBag[treeId] = bagData->inBag;

		// build the classifier
		RandomTreePtr aTree = m_trees[treeId];
		aTree->data = bagData;
		TimerPtr timer = TimerPtr(new boost::timer);
		aTree->build();
		double time = timer->elapsed();

		m_chooseTree->lock();
		m_buildTime += time;
		m_totalNumNodes += aTree->getNumNodes();
		m_chooseTree->unlock();
	}

long EventLoop::earliest_expire_time()
{
    TimerPtr timer = timer_heap_.top();
    if (!timer)
        return -1;
    long delay = timer->expire_msec() - current_msec_;
    return (delay > 0) ? delay : 0;
}

	bool Time::ResumeTimer(const UInt& _uTimerID)
	{
		TimerPtr pTimer = GetTimer(_uTimerID);
		bool bResult = (NULL != pTimer);

		if (false != bResult)
		{
			bResult = pTimer->Resume();
		}

		return bResult;
	}

 TimerPtr
     Dashboard::getTimer(const std::string & theName) {
         std::map<std::string,TimerPtr>::iterator found = _myTimers.find(theName);
         if (found == _myTimers.end()) {
             TimerPtr myParent   = findParent();
             TimerPtr myNewTimer = TimerPtr(new Timer(myParent));
             _myTimers[theName]  = myNewTimer;
             myNewTimer->setName(theName);
             _mySortedTimers.push_back(std::make_pair(theName, myNewTimer));
             return myNewTimer;
         }
         return found->second;
 }

void Timer::run(TaskContextPtr taskContextPtr, const boost::system::error_code& e){
	if(e == boost::asio::error::operation_aborted){
		return ;
	}
	taskContextPtr->func_();
	if(taskContextPtr->mode == 1){
		TimerPtr  timerPtr = taskContextPtr->timerPtr_;
		timerPtr->expires_at(timerPtr->expires_at() + boost::posix_time::millisec(taskContextPtr->deadline_time));
		timerPtr->async_wait(taskContextPtr->strand_.wrap(bind(&Timer::run, this, taskContextPtr, placeholders::error)));
	}else{

	}
}

void GraphIO::loadNodes(const YAML::Node& doc, SemanticVersion version)
{
    TimerPtr timer = getProfiler()->getTimer("load graph");

    YAML::Node nodes = doc["nodes"];
    if (nodes.IsDefined()) {
        for (std::size_t i = 0, total = nodes.size(); i < total; ++i) {
            const YAML::Node& n = nodes[i];

            auto interlude = timer->step(n["uuid"].as<std::string>());
            loadNode(n, version);
        }
    }
}

void RunLoop::ProcessTimer(TimerPtr timer)
{
    if ( timer->IsCancelled() )
    {
        RemoveTimer(timer);
        return;
    }

    timer->_fn(*timer);     // DO CALLOUT

    if ( !timer->Repeats() || timer->IsCancelled() )
    {
        RemoveTimer(timer);
    }
}

int EventLoop::handle_timer_events()
{
    if (expired_timers_.empty())
        return 0;

    // handle single timer
    TimerPtr timer = expired_timers_.front();
    expired_timers_.pop_front();
    thread_pool_->promote_new_leader();
    if (timer->repeat()) {
        timer->reset(current_msec_);
        timer_heap_.schedule(timer);
    }
    timer->handle_timeout(current_msec_);
    return 1;
}

    //-------------------------------------------------------------------------
    void RTPReceiverChannelAudio::onTimer(TimerPtr timer)
    {
      ZS_LOG_DEBUG(log("timer") + ZS_PARAM("timer id", timer->getID()))

      AutoRecursiveLock lock(*this);
#define TODO 1
#define TODO 2
    }

    void TimerMonitor::monitorBegin(TimerPtr timer)
    {
      AutoRecursiveLock lock(mLock);

      if (!mThread) {
        mThread = ThreadPtr(new boost::thread(boost::ref(*getTimerMonitor().get())));
      }

      PUID timerID = timer->getID();
      mMonitoredTimers[timerID] = TimerWeakPtr(timer);
      wakeUp();
    }

	UInt Time::CreateTimer(const bool _bStart)
	{
		bool bResult = true;

		TimerPtrVec::iterator iTimer = m_vpTimers.begin();
		TimerPtrVec::iterator iEnd = m_vpTimers.end();
		TimerPtr pTimer = NULL;
		UInt uResult = 0;

		while (iEnd != iTimer)
		{
			if (false == (*iTimer)->m_bIsActive)
			{
				pTimer = *iTimer;
				break;
			}
			++iTimer;
			++uResult;
		}

		if (NULL == pTimer)
		{
			pTimer = new Timer(m_lTicksPerSeconds);
			m_vpTimers.push_back(pTimer);
		}

		if (false == _bStart)
		{
			float fTemp;
			bResult = ResetTimer(uResult, fTemp) && PauseTimer(uResult);
		}

		if (false == bResult)
		{
			pTimer->Release();
			uResult = 0xffffffff;
		}

		return uResult;
	}

    void TimerMonitor::operator()()
    {
      bool shouldShutdown = false;

#ifndef _LINUX
      pthread_setname_np("com.zslib.timer");
#endif

      do
      {
        Duration duration;
        // wait completed, do notifications from select
        {
          AutoRecursiveLock lock(mLock);
          shouldShutdown = mShouldShutdown;

          duration = fireTimers();
        }

        boost::unique_lock<boost::mutex> flagLock(mFlagLock);
        mFlagNotify.timed_wait<Duration>(flagLock, duration);

        // notify all those timers needing to be notified
      } while (!shouldShutdown);

      {
        AutoRecursiveLock lock(mLock);

        // go through timers and cancel them completely
        for (TimerMap::iterator monIter = mMonitoredTimers.begin(); monIter != mMonitoredTimers.end(); ) {
          TimerMap::iterator current = monIter;
          ++monIter;

          TimerPtr timer = current->second.lock();
          if (timer)
            timer->background(false);
        }
        mMonitoredTimers.clear();
      }
    }

    void
        Dashboard::printTimers(Table & theTable, TimerPtr theParent, const std::string & theIndent) {

            for (unsigned i = 0; i < _mySortedTimers.size(); ++i) {
                std::string & myTimerName = _mySortedTimers[i].first;
                TimerPtr myTimerPtr       = _mySortedTimers[i].second;

                if (myTimerPtr->getParent() == theParent) {
                    theTable.addRow();
                    theTable.setField("timername", theIndent + myTimerName);
                    unsigned long myCycleCount = _myGroupCounters[myTimerPtr->getGroup()].getCount();
                    if (myCycleCount) {
                        const asl::Timer & myTimer = _myCompleteCycleTimers[myTimerName];
                        theTable.setField("elapsed",as_string((double)(myTimer.getElapsed().micros())/1000.0/myCycleCount));
                        const asl::Counter & myCounter = myTimer.getCounter();
                        if (myCounter.getCount()>1) {
                            theTable.setField("intervals",as_string((myCounter.getCount()+1.0)/myCycleCount));
                            theTable.setField("persec",as_string(myCounter.getCount()/myTimer.getElapsed().seconds()));
                            theTable.setField("average",as_string(myTimer.getElapsed().micros()/1000.0/myCounter.getCount()));
                            theTable.setField("minimum",as_string(myTimer.getMin().micros()/1000.0));
                            theTable.setField("maximum",as_string(myTimer.getMax().micros()/1000.0));
                            theTable.setField("cycles",as_string(myCycleCount));
                        }
                    } else {
                        const asl::Timer & myTimer = *myTimerPtr;
                        const asl::Counter & myCounter = myTimer.getCounter();
                        theTable.setField("elapsed",as_string((double)(myTimer.getElapsed().micros())/1000.0));
                        if (myCounter.getCount()>1) {
                            theTable.setField("intervals",as_string(myCounter.getCount()));
                            theTable.setField("persec",as_string(myCounter.getCount()/myTimer.getElapsed().seconds()));
                            theTable.setField("average",as_string(myTimer.getElapsed().micros()/1000.0));
                        }
                        theTable.setField("cycles","incomplete");
                    }
                    printTimers(theTable, myTimerPtr, theIndent+"  ");
                }
            }
    }

void TimeManager::Register(TimerPtr pTimer,TimerStop bStop )
{
	uint64 nTime;
	mpTime->Get(nTime);

	TimerDataPtr ptd = new TimerData;
	ptd->pTimer = pTimer;
	ptd->nLastTime = nTime + pTimer->GetInterval();
	ptd->bStop = bStop;

	mTimeDatas.push_back(ptd);
	
	
}

    Duration TimerMonitor::fireTimers()
    {
      AutoRecursiveLock lock(mLock);

      Time time = boost::posix_time::microsec_clock::universal_time();

      Duration duration = boost::posix_time::seconds(1);

      for (TimerMap::iterator monIter = mMonitoredTimers.begin(); monIter != mMonitoredTimers.end(); )
      {
        TimerMap::iterator current = monIter;
        ++monIter;

        TimerPtr timer = (current->second).lock();
        bool done = true;

        if (timer)
          done = timer->tick(time, duration);

        if (done)
          mMonitoredTimers.erase(current);
      }
      return duration;
    }

void TaskManager::scheduleRepeated(const TimerPtr& timer) {
	_scheduler->scheduleRepeated(timer, IceUtil::Time::milliSeconds(timer->delay()));
}

	void GPUERT::deviceHandler(){
		m_devId = m_gfxMgr->createDeviceContext(m_devId);
		calculateMaxNodes(m_devId);
		initResources();

		m_constantsBagging.cb_baggingActivated = false;
		TimerPtr timerKernel = TimerPtr(new boost::timer);

		TimerPtr timer = TimerPtr(new boost::timer);
		TimerPtr timerTotal = TimerPtr(new boost::timer);

		m_internalNodes = 0, m_leafNodes = 0;
		int treesLeft = m_numTrees;
		int treesToLaunch = m_maxTreesPerIteration;
		int lastLaunch = 0;
		int checkSum = m_maxTreesPerIteration;
		int newNodes = m_maxTreesPerIteration;
		std::vector<int> checkVars(4,0);

		m_buildTime = 0;
		m_baggingTime = 0;
		m_classificationTime = 0;
		m_depth = 0;

		timerTotal->restart();
		int numIter = ceil(float(m_numTrees)/float(m_maxTreesPerIteration));
		for(unsigned int j=0; j<numIter; ++j){
			checkSum = treesToLaunch;
			newNodes = treesToLaunch;
			m_constants.cb_nodeBufferStart = 0;
			m_constants.cb_nodeIdFlip = 0;

			initResourceBatch(lastLaunch == treesToLaunch);
			lastLaunch = treesToLaunch;

			treesLeft -= treesToLaunch;
			timer->restart();
			for(unsigned int i=0; i<m_MaxDepth; ++i){
				if(i > m_depth)
					m_depth = i;

				assert(newNodes < m_maxNodesPerIteration);
				int nodeLimit = 10000;
				int innerNodes = newNodes;
				int numInnerIter = ceil(float(innerNodes)/float(nodeLimit));
				int launchCount = 0;

				m_constants.cb_availableNodes = newNodes;
				m_constants.cb_numFeatures = 0;
				timerKernel->restart();
				for(unsigned int k=0; k<m_numFeatures; ++k){
					innerNodes = newNodes;
					numInnerIter = ceil(float(innerNodes)/float(nodeLimit));
					launchCount = 0;

					// Best split kernel
					m_gfxMgr->setGPUBuffer(m_devId,m_setBufferIdsExFindSplit,m_setResourceTypesExFindSplit);
					m_gfxMgr->setGPUProgram(m_devId,m_gpuFunctionIds["RFP_ExFindSplit"]);

					innerNodes = newNodes;
					launchCount = 0;
					m_constants.cb_currentDepth = 0;
					for(unsigned int l=0; l<numInnerIter; ++l){
						launchCount = innerNodes > nodeLimit ? nodeLimit : innerNodes;
						
						m_gfxMgr->copyToGPU(m_devId,m_bufferIds["RFB_constants"],&ConstantUpdate(&m_constants,KID_ExtremeFindSplit),sizeof(m_constants));
						m_gfxMgr->launchComputation(m_devId,launchCount*thread_group_size,1,1);

						m_constants.cb_currentDepth += launchCount;
						innerNodes -= launchCount;
						if(innerNodes <= 0)
							break;
					}
					++m_constants.cb_numFeatures;
				}
				if(m_kernelSpecificTimings){
					m_gfxMgr->syncDevice(m_devId);
					m_kernelTimes[L"RFP_ExFindSplit"] += timerKernel->elapsed();
				}

				innerNodes = newNodes;
				launchCount = 0;
				m_constants.cb_currentDepth = 0;
				m_gfxMgr->setGPUBuffer(m_devId,m_setBufferIdsExMakeSplit,m_setResourceTypesExMakeSplit);
				m_gfxMgr->setGPUProgram(m_devId,m_gpuFunctionIds["RFP_ExMakeSplit"]);

				// Split data
				timerKernel->restart();
				for(unsigned int k=0; k<numInnerIter; ++k){
					launchCount = innerNodes > nodeLimit ? nodeLimit : innerNodes;
						
					m_gfxMgr->copyToGPU(m_devId,m_bufferIds["RFB_constants"],&ConstantUpdate(&m_constants,KID_ExtremeMakeSplit),sizeof(m_constants));
					m_gfxMgr->launchComputation(m_devId,launchCount*thread_group_size,1,1);

					m_constants.cb_currentDepth += launchCount;
					innerNodes -= launchCount;
					if(innerNodes <= 0)
						break;
				}
				if(m_kernelSpecificTimings){
//.........这里部分代码省略.........

void Timer::destroy(int id)
{
  TimerPtr timer = city::Timers::instance().find( id );
  if( timer.isValid() )
    timer->destroy();
}

void
TimerPriorityTest::run()
{
#ifdef _WIN32
    //
    // Test to create a timer with a given priority
    //
    try
    {
        TimerPtr t = new Timer(THREAD_PRIORITY_IDLE);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_LOWEST);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_BELOW_NORMAL);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_NORMAL);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_ABOVE_NORMAL);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_HIGHEST);
        t->destroy();

        t = new Timer(THREAD_PRIORITY_TIME_CRITICAL);
        t->destroy();
    }
    catch(...)
    {
        test(false);
    }

    //
    // Test to create a timer with priorities too high
    //
    try
    {
        TimerPtr t = new Timer(THREAD_PRIORITY_TIME_CRITICAL + 10);
        test(false);
    }
    catch(const ThreadSyscallException&)
    {
        //Expected
    }
    catch(...)
    {
        test(false);
    }

    //
    // Test to create a timer with priorities too low
    //
    try
    {
        TimerPtr t = new Timer(THREAD_PRIORITY_IDLE - 10);
        test(false);
    }
    catch(const ThreadSyscallException&)
    {
        //Expected
    }
    catch(...)
    {
        test(false);
    }

#else

    //
    // Test to create a timer with a given priority
    //
    ThreadControl c;
    try
    {
        for(int cont = 1; cont < 10; ++cont)
        {
            TimerPtr t = new Timer(cont);
        }
    }
    catch(...)
    {
        test(false);
    }

    //
    // Test to create a timer with priorities too high
    //
    for(int cont = 1; cont < 10; ++cont)
    {
        try
        {
            TimerPtr t = new Timer(300 * cont);
            test(false);
        }
        catch(const ThreadSyscallException& e)
        {
            //Expected
//.........这里部分代码省略.........