void Instrument::InstrumentLoadStore(const Instruction* instr) {
    static Counter* load_int_counter = GetCounter("Load Integer");
    static Counter* store_int_counter = GetCounter("Store Integer");
    static Counter* load_fp_counter = GetCounter("Load FP");
    static Counter* store_fp_counter = GetCounter("Store FP");

    switch (instr->Mask(LoadStoreOpMask)) {
    case STRB_w:    // Fall through.
    case STRH_w:    // Fall through.
    case STR_w:     // Fall through.
    case STR_x:
        store_int_counter->Increment();
        break;
    case STR_s:     // Fall through.
    case STR_d:
        store_fp_counter->Increment();
        break;
    case LDRB_w:    // Fall through.
    case LDRH_w:    // Fall through.
    case LDR_w:     // Fall through.
    case LDR_x:     // Fall through.
    case LDRSB_x:   // Fall through.
    case LDRSH_x:   // Fall through.
    case LDRSW_x:   // Fall through.
    case LDRSB_w:   // Fall through.
    case LDRSH_w:
        load_int_counter->Increment();
        break;
    case LDR_s:     // Fall through.
    case LDR_d:
        load_fp_counter->Increment();
        break;
    }
}

void
Control::Substitute(map<string,string>* __mapping){
switch(GetControlKind()){
   case ADaAn_FOR      :
            if(__mapping->find(GetCounter()) != __mapping->end())
               SetCounterName(__mapping->operator[](GetCounter()));
            GetForLowerBound()->Substitute(__mapping);
            GetForUpperBound()->Substitute(__mapping);
            return;
   case ADaAn_WHILE   :
            if(__mapping->find(GetCounter()) != __mapping->end())
               SetCounterName(__mapping->operator[](GetCounter()));
            GetCondition()->Substitute(__mapping);
            return;
   case ADaAn_IF      :
            GetCondition()->Substitute(__mapping);
            return;
   case ADaAn_IF_ELSE   :
            GetCondition()->Substitute(__mapping);
            return;
   }

cerr<<"Control::Rename, Fatal error(unhandled operator)";
throw(UNHANDLED_CASE);
exit(EXIT_FAILURE);
}

	void Run()
	{
		LOG_INFO("Thread [%s] Start...", m_threadName);
		int ret = 0;
		for(int i= GetCounter(); i <= m_requestCount; i= GetCounter()){
			ClientCtx* ctx = GetCtx();

			ret = m_requestCb(i, ctx, m_args);
			
			if(ret== 0){
				AtomInt_Inc(&g_errors[0]);
			}else{
				if(ret < 0){
					AtomInt_Inc(&g_errors[ERRNO_UNKNOW]);
				}else{
					AtomInt_Inc(&g_errors[ret%0xFFFF]);
				}
			}

			if(i % m_num == 0){
				double usedtime = g_now_second -g_start;
				//LOG_DEBUG("start:%.3f - now:%.3f", g_start, g_now_second);
				printf("Request %d time:%.3f\n", i, usedtime);
			}
			if(g_stop) break;
		}
		
		LOG_INFO("Thread [%s] Stop...", m_threadName);
	}

/****************************************************************************
REMARKS:
If processor does not support time stamp reading, but is at least a 386 or
above, utilize method of timing a loop of BSF instructions which take a
known number of cycles to run on i386(tm), i486(tm), and Pentium(R)
processors.
****************************************************************************/
static ulong GetBSFCpuSpeed(
    ulong cycles)
{
    CPU_largeInteger t0,t1,count_freq;
    ulong   ticks;              /* Microseconds elapsed during test     */
    ulong   current;            /* Variable to store time elapsed       */
    int     i,j,iPriority;
    ulong   lowest  = (ulong)-1;

    iPriority = SetMaxThreadPriority();
    GetCounterFrequency(&count_freq);
    for (i = 0; i < SAMPLINGS; i++) {
	GetCounter(&t0);
	for (j = 0; j < INNER_LOOPS; j++)
	    _CPU_runBSFLoop(ITERATIONS);
	GetCounter(&t1);
	current = t1.low - t0.low;
	if (current < lowest)
	    lowest = current;
	}
    RestoreThreadPriority(iPriority);

    /* Compute frequency */
    ticks = _CPU_mulDiv(lowest,1000000,count_freq.low);
    if ((ticks % count_freq.low) > (count_freq.low/2))
	ticks++;            /* Round up if necessary */
    if (ticks == 0)
	return 0;
    return ((cycles*INNER_LOOPS)/ticks);
}

 uint32_t operator()()
 {
     uint32_t const counter = GetCounter();
     if ((counter % 3) == 0)
         return m_startIndex;
     return m_startIndex + counter - 2 * (counter / 3);
 }

/* Initialize OpenGL Graphics */
void InitGL()
{
	StartCounter();
	gLastTime = GetCounter();
	// Set "clearing" or background color
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Black and opaque
}

unsigned int HighPerfTick::Tick()
{
	__int64 counter = GetCounter();
	unsigned int elapsed = (unsigned int)(counter - lastTick);
	lastTick = counter;
	return elapsed;
}

//---------------------------------------------------------------------------------
// Update from glut. Called when no more event handling.
//---------------------------------------------------------------------------------
void Idle()
{	
	static double prevTime = GetCounter();
	double tick = GetCounter() - prevTime;
	double currentTime = GetCounter();
	double deltaTime = currentTime - gLastTime;
	// Update.
	if (deltaTime > (UPDATE_MAX))
	{	
		gUpdateDeltaTime.Stop();
		glutPostRedisplay(); //everytime you are done 
		CSimpleControllers::GetInstance().Update();

		gUserUpdateProfiler.Start();
		if (gEditorMode)
		{
			EditorUpdate((float)deltaTime);			// Call user defined update.
		}
		else
		{
			Update((float)deltaTime);				// Call user defined update.
		}
		gUserUpdateProfiler.Stop();
		
		gLastTime = currentTime;		
		RECT tileClientArea;
		if (GetClientRect( MAIN_WINDOW_HANDLE, &tileClientArea))
		{
			WINDOW_WIDTH = tileClientArea.right - tileClientArea.left;
			WINDOW_HEIGHT = tileClientArea.bottom - tileClientArea.top;
		}

		if (App::GetController().CheckButton(APP_ENABLE_DEBUG_INFO_BUTTON) )
		{
			gRenderUpdateTimes = !gRenderUpdateTimes;
		}

		if (App::IsKeyPressed(APP_QUIT_KEY))
		{		
			glutLeaveMainLoop();
		}
		gUpdateDeltaTime.Start();
	}
	
}

std::string ObjectGuid::GetString() const
{
    std::ostringstream str;
    str << GetTypeName() << " (";
    if (HasEntry())
        str << "Entry: " << GetEntry() << " ";
    str << "Guid: " << GetCounter() << ")";
    return str.str();
}

// ****************************************************
// ******************* Group System *******************
// ****************************************************
Group* Battlefield::GetFreeBfRaid(TeamId TeamId)
{
    for (auto itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
        if (Group* group = sGroupMgr->GetGroupByGUID(itr->GetCounter()))
            if (!group->IsFull())
                return group;

    return nullptr;
}

Group* Battlefield::GetGroupPlayer(ObjectGuid guid, TeamId TeamId)
{
    for (auto itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
        if (Group* group = sGroupMgr->GetGroupByGUID(itr->GetCounter()))
            if (group->IsMember(guid))
                return group;

    return nullptr;
}

  uint32_t operator()()
  {
    uint32_t const counter = GetCounter();
    uint32_t const result = m_startIndex + m_counter;
    if (counter % 2 == 0)
      m_counter++;

    return result;
  }

void Instrument::VisitMoveWideImmediate(const Instruction* instr) {
    Update();
    static Counter* counter = GetCounter("Move Immediate");

    if (instr->IsMovn() && (instr->Rd() == kZeroRegCode)) {
        unsigned imm = instr->ImmMoveWide();
        HandleInstrumentationEvent(imm);
    } else {
        counter->Increment();
    }
}

std::string ObjectGuid::ToString() const
{
    std::ostringstream str;
    str << "GUID Full: 0x" << std::hex << std::setw(16) << std::setfill('0') << _guid << std::dec;
    str << " Type: " << GetTypeName();
    if (HasEntry())
        str << (IsPet() ? " Pet number: " : " Entry: ") << GetEntry() << " ";

    str << " Low: " << GetCounter();
    return str.str();
}

void Pwm_Step(void)
{
	unsigned long cur = GetCounter();
	unsigned long delta_timer = cur - gs_pwm_timer;
	unsigned int vkl_time = gs_current_percent <= 0 ? 0 :(gs_current_percent >= 100 ? g_settings.pwm_mlsec : gs_current_percent * g_settings.pwm_mlsec / 100);
	if(delta_timer >= g_settings.pwm_mlsec)
	{
		delta_timer = 0;
		gs_pwm_timer = cur;
	}
	SetRelayState(delta_timer < vkl_time);
}

void Down_Task(void)
{
	switch(GetGrapCount())//层次
	{
		case 1:
			AddCounter();
			if(GetCounter() > 4)
				SetCounter(1);
			GetMainGrap(GetCounter());
			break;
		case 2:
			Level2_Down();
			break;
		case 3:
			Level3_Down();
			break;
		case 4:
			Level4_Down();
			break;
		default:break;
	}

}

void Pid_Step(void)
{
	float pid_value;
	unsigned long cur = GetCounter();
	float delta_temperature = gs_current_temperature - g_settings.pid_level; 
	if((cur - gs_pid_timer) < g_settings.pid_mlsec)
		return;
	gs_pid_timer = cur;
	gs_intergrator_value += delta_temperature*g_settings.pid_I;
	if(gs_intergrator_value > g_settings.pid_I_limit)
		gs_intergrator_value = g_settings.pid_I_limit;
	pid_value = gs_current_percent + g_settings.pid_P*delta_temperature + gs_intergrator_value + g_settings.pid_D*delta_temperature;
	gs_current_percent = (pid_value > 100) ? 100 : pid_value;
}

void Up_Task(void)
{
	switch(GetGrapCount())//层次
	{
		case 1:
			if(GetCounter() > 1)
				SubCounter();	
			else
				SetCounter(4);				
			GetMainGrap(GetCounter());
			break;
		case 2:
			Level2_Up();
			break;
		case 3:
			Level3_Up();
			break;
		case 4:
			Level4_Up();
			break;
		default:break;
	}
	
}

double get_sort_time(int *pa, int len, void (fsort)(int * , int   ))
{
# if 0 //  计时方法1
	const clock_t begin = clock();
	 fsort(pa, len);
	 const clock_t end = clock();
	 return  (double)(end-begin)/CLOCKS_PER_SEC  ;
#endif
#if 0 // 计时方法2
	 DWORD begin = GetTickCount();
	 fsort(pa, len);
	 DWORD end = GetTickCount();

	 return end - begin;
#endif

	 StartCounter();
     fsort(pa, len);
     return  GetCounter() ;
 
}

Condition*
Control::GetRegularDomain(void){
Condition* result;
if(IsIf() || IsIfElse() || IsWhileLoop())
   {
   if(IsWhileLoop()){
      Inequation* ineq=new Inequation(new Expression(GetCounter()),FADA_GREATER_EQ,new Expression(1));
      Condition* count_ge_0 = new Condition (ineq);
      result=new Condition(count_ge_0,FADA_AND,GetCondition());
      return result;
      }
   return GetCondition();
   }
if(IsForLoop()){
   Inequation* ineq1=new Inequation ( new Expression(GetLoopCounter( )),FADA_GREATER_EQ,GetForLowerBound( ));
   Inequation* ineq2=new Inequation ( new Expression(GetLoopCounter( )),FADA_LESS_EQ,GetForUpperBound( ));
   result = new Condition( new Condition(ineq1), FADA_AND , new Condition(ineq2));
   return result;
   }
cout<<"\nControl::GetRegularDomain(void) .... inappropriate case \n";
throw(10);
}