Esempio n. 1
0
    void ClientCursor::staticYield(int micros, const StringData& ns, const Record* rec) {
        bool haveReadLock = Lock::isReadLocked();

        killCurrentOp.checkForInterrupt( false );
        {
            auto_ptr<LockMongoFilesShared> lk;
            if ( rec ) {
                // need to lock this else rec->touch won't be safe file could disappear
                lk.reset( new LockMongoFilesShared() );
            }

            dbtempreleasecond unlock;
            if ( unlock.unlocked() ) {
                if ( haveReadLock ) {
                    // This sleep helps reader threads yield to writer threads.
                    // Without this, the underlying reader/writer lock implementations
                    // are not sufficiently writer-greedy.
#ifdef _WIN32
                    SwitchToThread();
#else
                    if ( micros == 0 ) {
                        yieldOrSleepFor1Microsecond();
                    }
                    else {
                        sleepmicros(1);
                    }
#endif
                }
                else {
                    if ( micros == -1 ) {
                        sleepmicros(Client::recommendedYieldMicros());
                    }
                    else if ( micros == 0 ) {
                        yieldOrSleepFor1Microsecond();
                    }
                    else if ( micros > 0 ) {
                        sleepmicros( micros );
                    }
                }

            }
            else if ( Listener::getTimeTracker() == 0 ) {
                // we aren't running a server, so likely a repair, so don't complain
            }
            else {
                CurOp * c = cc().curop();
                while ( c->parent() )
                    c = c->parent();
                warning() << "ClientCursor::yield can't unlock b/c of recursive lock"
                          << " ns: " << ns 
                          << " top: " << c->info()
                          << endl;
            }

            if ( rec )
                rec->touch();

            lk.reset(0); // need to release this before dbtempreleasecond
        }
    }
Esempio n. 2
0
	void CStressManager::DisconnectAll()
	{	
		Zion::Map<_U32, CStressClient*>::iterator i;
		_U32 count = 1;
		while(count>0)
		{
			count = 0;
			A_MUTEX_LOCK(&m_mtxLocker);
			for(i=m_mapClients.begin(); i!=m_mapClients.end(); i++)
			{
				i->second->Logout();
				if(i->second->GetClient()->GetState()!=CClient::STATE_NA && i->second->GetClient()->GetState()!=CClient::STATE_FAILED) count++;
			}
			A_MUTEX_UNLOCK(&m_mtxLocker);
			SwitchToThread();

			if(!CClientApp::GetDefault()->IsThread())
			{
				CClientApp::GetDefault()->Tick();
			}
		}

		for(i=m_mapClients.begin(); i!=m_mapClients.end(); i++)
		{
			delete i->second;
		}
		m_mapClients.clear();
	}
Esempio n. 3
0
static int initWinSock(void)
{
    WORD wVersionRequested;  
    WSADATA wsaData; 
    int i; 

    static LONG volatile initialized = 0;
    
    wVersionRequested = MAKEWORD(1, 1); 
    if (InterlockedCompareExchange((LPLONG) &initialized,1L,0L) == 0L) {
	/* FIXME not terminate, just a message?! */
	if ((i = WSAStartup(wVersionRequested, &wsaData))) {
	    EI_TRACE_ERR1("ei_connect_init",
			  "ERROR: can't initialize windows sockets: %d",i);
	    initialized = 2L;
	    return 0;
	}
	
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) { 
	    EI_TRACE_ERR0("initWinSock","ERROR: this version of windows "
			  "sockets not supported");
	    WSACleanup(); 
	    initialized = 2L;
	    return 0;
	}
	initialized = 3L;
    } else while (initialized < 2) {
	SwitchToThread();
    }
    return (int) (initialized - 2);
}
static __inline void fast_enter_critical_section(struct threadpool *tp)
{
	sync_t *sync = (sync_t *) tp;

	while (!TryEnterCriticalSection(&sync->critsec))
		SwitchToThread();
}
Esempio n. 5
0
void rathread_yield(){
#ifdef WIN32
	SwitchToThread();
#else
	sched_yield();
#endif
}//end: rathread_yield()
Esempio n. 6
0
void CBufferOutputAudioEngine::Play()
{
		//BufferTrace("CBufferOutputAudioEngine::Play()....\n");
		if (!m_bFilled && m_mapOutputAudioBuf.size() < (1.0f*BUFFER_PERSEC_AUDIO_NUMBER*BUFFER_OUTPUT_ONMIC_AUDIO_MAX_LIMIT)/1000){
			return ;
		}

		if (!m_bFilled) {
			m_fLastPlayTime = GetTickCount();
			m_iStartPlayCount = 0;
			m_bFilled = true;
		}
		if (m_mapOutputAudioBuf.size() < 1 || (GetTickCount() - m_lastRecvTime) > 1000*10){//10s钟没有收到数据 超时 刷新
			MutexLocker locker(&m_mutex);//播放线程 网络线程 m_mapOutputAudioBuf
			ResetStatus();
			return;
		}

		IsCanCalcRecvRate()?m_fRecvRate = CalcRecevRate():NULL;
		m_fSendRate = CanCalcPlayRate();

		//ErrTrace("CBufferOutputAudioEngine::Play() m_mapOutputAudioBuf.size()=%d,seq=%d,m_fRecvRate=%f,m_fSendRate=%f\n",m_mapOutputAudioBuf.size(),m_iMaxSequenceId - m_iMinSequenceId+1,m_fRecvRate,m_fSendRate);

		unsigned int iLimit = 0;
		DWORD dwCurrTime = GetTickCount();
		while (m_fLastPlayTime < dwCurrTime && ++iLimit<5)
		{
			m_fLastPlayTime += m_fSendRate;
			m_iStartPlayCount++;
			PlayPackets();
			SwitchToThread();
		}
		CheckPacket();
		RefreshStatus();
}
Esempio n. 7
0
BOOL StopIoTimer(LPTIMER lpTimer, BOOL bSkipActive)
{
    //	Sanity check
    if (!lpTimer) return 0;

    for (;;)
    {
        switch (InterlockedExchange(&lpTimer->lStatus, TIMER_CANCEL))
        {
        case TIMER_CANCEL:
        case TIMER_ACTIVE:
            //	Timer procedure is currently active
            if (bSkipActive) return -1;
            SwitchToThread();
            break;
        case TIMER_WAIT:
            //	Timer is in wait state
            EnterCriticalSection(&csIoTimer);
            //	Remove timer if it has not been posted
            if (lpTimer->lStatus != TIMER_QUEUED) DeleteIoTimer(lpTimer);
            LeaveCriticalSection(&csIoTimer);
            Free(lpTimer);
            return 0;
        case TIMER_INACTIVE:
            //	Timer is inactive
            Free(lpTimer);
            return 1;
        case TIMER_QUEUED:
            return 0;
        }
    }
}
Esempio n. 8
0
SO_PUBLIC void
Thread_Yield(void) {
#ifdef _MSC_VER
	SwitchToThread();
#else
	pthread_yield();
#endif
}
Esempio n. 9
0
static void os_yield(void)
{
#if defined(WIN32)
	SwitchToThread();
#else
	sched_yield();
#endif
}
Esempio n. 10
0
/*
 * -------------------------------------------------------------------
 * Allow another thread to execute. If no other threads are runable this
 * is not guarenteed to actually rest.
 * ------------------------------------------------------------------- */
void thread_rest ( void ) {
#if defined( HAVE_THREAD )
#if defined( HAVE_POSIX_THREAD )
#else // Win32
    SwitchToThread( );
#endif
#endif
}
teUtilsStatus eUtils_ThreadYield(void)
{
#ifndef WIN32
    sched_yield();
#else
    SwitchToThread();
#endif
    return E_UTILS_OK;
}
Esempio n. 12
0
    void yieldOrSleepFor1Microsecond() {
#ifdef _WIN32
        SwitchToThread();
#elif defined(__linux__)
        pthread_yield();
#else
        sleepmicros(1);
#endif
    }
Esempio n. 13
0
int sched_yield()
{
  /* http://stackoverflow.com/questions/1383943/switchtothread-vs-sleep1
     SwitchToThread(); was here. Unsure what's better for us, just trying.. */

  if(!SwitchToThread())
      Sleep(0);
  return 0;
}
Esempio n. 14
0
//The functions below should thread the while loop
static UINT bg1(LPVOID that) {
	while (*lenref == 0) SwitchToThread();//sync (by using another long * as a temp)
	fileDefault = CString(buff);
	if (FileOpen(false)) {
		run((CKODEKDlg *)that, ACTION_DECOMPRESS);
		return 0;
	}
	run((CKODEKDlg *)that, END);
	return -1;
}
Esempio n. 15
0
VOID
WINAPI
DoWaitForReaders(IN PWAH_SEARCH_TABLE Table,
                 IN PVLONG Counter)
{
    HANDLE EventHandle;

    /* Do a context switch */
    SwitchToThread();

    /* Check if the counter is above one */
    if (*Counter > 0)
    {
        /* 
         * This shouldn't happen unless priorities are messed up. Do a wait so
         * that the threads with lower priority will get their chance now.
         */
        if (!ghWriterEvent)
        {
            /* We don't even have an event! Allocate one manually... */
            EventHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
            if (EventHandle)
            {
                /* Save the event handle atomically */
                if ((InterlockedCompareExchangePointer((PVOID*)&ghWriterEvent,
                                                       EventHandle,
                                                       NULL)))
                {
                    /* Someone beat us to it, close ours */
                    CloseHandle(EventHandle);
                }
            }
            else
            {
                /* Things couldn't get worse for us. Do a last-resort hack */
                while (*Counter > 0) Sleep(10);
            }
        }

        /* 
         * Our event is ready. Tell the others to signal us by making sure
         * that the last counter will be -1, notifying the last thread of our
         * request.
         */
        if (InterlockedDecrement(Counter) >= 0)
        {
            /* Keep looping */
            do
            {
                /* Wait in tiny bursts, so we can catch the PulseEvent */
                WaitForSingleObject(ghWriterEvent, 10);
            } while (*Counter >= 0);
        }
    }
}
Esempio n. 16
0
	void WaitForWriteCapacity(int amt)
	{
		for (; ; )
		{
			//dont return when available == amt because then we would consume the buffer and be unable to distinguish between full and empty
			if (Available() > amt)
				return;
			//this is a greedy spinlock.
			SwitchToThread();
		}
	}
Esempio n. 17
0
/*
 * -------------------------------------------------------------------
 * Allow another thread to execute. If no other threads are runable this
 * is not guarenteed to actually rest.
 * ------------------------------------------------------------------- */
void thread_rest ( void ) {
#if defined( HAVE_THREAD )
#if defined( HAVE_POSIX_THREAD )
    // TODO add checks for sched_yield or pthread_yield and call that
    // if available
    usleep( 0 );
#else // Win32
    SwitchToThread( );
#endif
#endif
}
Esempio n. 18
0
void
sys_thread_switch (struct sys_thread *td)
{
  sys_vm2_leave(td);
#ifndef _WIN32
  sched_yield();
#else
  SwitchToThread();
#endif
  sys_vm2_enter(td);
}
Esempio n. 19
0
bool Tick()
{
	bool DoNextTick = true;

	DoNextTick = TickSim();

	TickRender();

	SwitchToThread();

	return DoNextTick;
}
Esempio n. 20
0
void rtw_yield_os()
{
#ifdef PLATFORM_LINUX
	yield();
#endif
#ifdef PLATFORM_FREEBSD
	yield();
#endif
#ifdef PLATFORM_WINDOWS
	SwitchToThread();
#endif
}
Esempio n. 21
0
/**
* \ingroup atomvm
* \b atomvmCtrlIntRequest
*
* This is an atomvm controll function used by a controlling thread(s)
* and must not be called from the atom virtual machine.
*
* This function requests an interrupt service routine to be called in the
* context of the atom virtual machine.
*
* The call will block while a previously scheduled interrupt is in progress.
*
* @param[in] atomvm Handle to the virtual machine created by atomvmCtrlInit.
* @param[in] isr The address of the interrupt service routine. The routine must use
* the default calling convention of the compiler.
*
* @return None
*/
void
atomvmCtrlIntRequest (HATOMVM atomvm, uint32_t isr)
{
    PATOMVM         patomvm = (PATOMVM) atomvm ;

    WaitForSingleObject (patomvm->atomvm_int_complete, INFINITE) ;
    while (InterlockedCompareExchange ((volatile uint32_t *)&patomvm->isr, isr, 0) != 0) {
		SwitchToThread() ;
	}
    SetEvent (patomvm->atomvm_int) ;

}
Esempio n. 22
0
									// Yield processing time to other threads
		inline static void			Yield				()
									{
#ifdef _WIN32
# if AX_ASYNC_MSWIN_SWITCHTOTHREAD_ENABLED
										SwitchToThread();
# else
										Sleep( 0 );
# endif
#else
										sched_yield();
#endif
									}
Esempio n. 23
0
/**
 * Once-only initialization.
 * @param  once_control The control variable which initialized to PTHREAD_ONCE_INIT.
 * @param  init_routine The initialization code which executed at most once.
 * @return Always return 0.
 */
int pthread_once(pthread_once_t *once_control, void (* init_routine)(void))
{
    if (atomic_cmpxchg((long volatile *) once_control, 1, 0) == 0) {
        init_routine();
        *(volatile int *) once_control = 2;
    } else {
        while(*(volatile int *) once_control != 2)
            SwitchToThread();
    }

    return 0;
}
Esempio n. 24
0
bool Launch( SimpleString& CommandLine )
{
	if( g_NumWarnings > 0 )
	{
		AddStatus( SimpleString::PrintF( "\nContentSyncer finished with %d warnings.\n\nPress Enter to continue.", g_NumWarnings ), g_StatusColor );

		// Mini loop in here, ugh!
		for(;;)
		{
			g_Keyboard->Tick( 0.0f );

			if( GetForegroundWindow() == GetConsoleWindow() )
			{
				if( g_Keyboard->OnRise( Keyboard::EB_Enter ) )
				{
					break;
				}
			}

			TickRender();
			SwitchToThread();
		}
	}

	STARTUPINFO StartupInfo;
	PROCESS_INFORMATION ProcessInfo;

	ZeroMemory( &StartupInfo, sizeof( StartupInfo ) );
	StartupInfo.cb = sizeof( StartupInfo );

	ZeroMemory( &ProcessInfo, sizeof( ProcessInfo ) );

	// See Process Creation Flags
	DWORD Flags =
		CREATE_DEFAULT_ERROR_MODE |		// Don't inherit error mode
		CREATE_NEW_CONSOLE;				// Create new console (DETACHED_PROCESS also means this console isn't inherited; but a new console must be created with AllocConsole)

	BOOL Result = CreateProcess(
		NULL,						// Application name (optional--use the first argument from command line if NULL)
		CommandLine.MutableCStr(),	// Command line (optional, includes application name)
		NULL,						// Process attributes (optional pointer to a SECURITY_ATTRIBUTES)
		NULL,						// Thread attributes (optional pointer to a SECURITY_ATTRIBUTES)
		FALSE,						// Inherit handles
		Flags,						// Creation flags (see Process Creation Flags)
		NULL,						// Environment block (optional void*)
		NULL,						// Current directory (optional string)
		&StartupInfo,				// Startup info
		&ProcessInfo				// Process info
		);

	return Result == TRUE;
}
Esempio n. 25
0
/*
 * __wt_yield --
 *	Yield the thread of control.
 */
void
__wt_yield(void)
{
	/*
	 * Yielding the processor isn't documented as a memory barrier, and it's
	 * a reasonable expectation to have. There's no reason not to explicitly
	 * include a barrier since we're giving up the CPU, and ensures callers
	 * aren't ever surprised.
	 */
	WT_FULL_BARRIER();

	SwitchToThread();
}
static DWORD WINAPI Work(PVOID args){

	Times = GetTickCount();
	while(i++<1000000){
		
		SwitchToThread();
		
	}
	Total += GetTickCount() - Times;
	_tprintf(_T("1 000 000 Context Switch in diferent process  %.5f  ms\n"),Total/1000000);
	return 0;

}
Esempio n. 27
0
	int WaitForSomethingToRead()
	{
		for (; ; )
		{
			int available = Size();
			if (available > 0)
				return available;
			//this is a greedy spinlock.
			SwitchToThread();
			//NOTE: it's annoying right now because libsnes processes die and eat a whole core.
			//we need to gracefully exit somehow
		}
	}
void flext::Sleep(double s)
{
    if(s <= 0) return;
#if FLEXT_OS == FLEXT_OS_WIN
#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x400
#if 0
    LARGE_INTEGER liDueTime;
    liDueTime.QuadPart = (LONGLONG)(-1.e7*s);

    // Create a waitable timer.
    HANDLE hTimer = CreateWaitableTimer(NULL,TRUE,NULL);
    if(hTimer) {
        if(SetWaitableTimer(hTimer,&liDueTime,0,NULL,NULL,0))
            // Wait for the timer.
            WaitForSingleObject(hTimer,INFINITE); // != WAIT_OBJECT_0)
        else
            ::Sleep((long)(s*1000.));
        CloseHandle(hTimer);
    }
    else
#else
    LARGE_INTEGER cnt;
    if(perffrq && QueryPerformanceCounter(&cnt)) {
        LONGLONG dst = (LONGLONG)(cnt.QuadPart+perffrq*s);
        for(;;) {
            SwitchToThread(); // while waiting switch to another thread
            QueryPerformanceCounter(&cnt);
            if(cnt.QuadPart > dst) break;
        }
    }
    else
#endif
#endif
        // last resort....
        ::Sleep((long)(s*1000.));
#elif FLEXT_OS == FLEXT_OS_LINUX || FLEXT_OS == FLEXT_OS_IRIX || FLEXT_OSAPI == FLEXT_OSAPI_MAC_MACH // POSIX
    usleep((long)(s*1000000.));
#elif FLEXT_OS == FLEXT_OS_MAC // that's just for OS9 & Carbon!
    UnsignedWide tick;
    Microseconds(&tick);
    double target = tick.hi*((double)(1L<<((sizeof tick.lo)*4))*(double)(1L<<((sizeof tick.lo)*4)))+tick.lo+s*1.e6; 
    for(;;) {
        // this is just a loop running until the time has passed - stone age (but we yield at least)
        Microseconds(&tick);
        if(target <= tick.hi*((double)(1L<<((sizeof tick.lo)*4))*(double)(1L<<((sizeof tick.lo)*4)))+tick.lo) break;
        YieldToAnyThread(); // yielding surely reduces the timing precision (but we're civilized)
    }
#else
    #error Not implemented
#endif
}
Esempio n. 29
0
BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s)
{
	UINT16 lengthSourceDescriptor;

	if (rdp->state == CONNECTION_STATE_ACTIVE)
		rdp->deactivation_reactivation = TRUE;
	else
		rdp->deactivation_reactivation = FALSE;

	/*
	 * Windows XP can send short DEACTIVATE_ALL PDU that doesn't contain
	 * the following fields.
	 */
	if (Stream_GetRemainingLength(s) > 0)
	{
		do
		{
			if (Stream_GetRemainingLength(s) < 4)
				break;

			Stream_Read_UINT32(s, rdp->settings->ShareId); /* shareId (4 bytes) */

			if (Stream_GetRemainingLength(s) < 2)
				break;

			Stream_Read_UINT16(s, lengthSourceDescriptor); /* lengthSourceDescriptor (2 bytes) */

			if (Stream_GetRemainingLength(s) < lengthSourceDescriptor)
				break;

			Stream_Seek(s, lengthSourceDescriptor); /* sourceDescriptor (should be 0x00) */
		}
		while (0);
	}

	rdp_client_transition_to_state(rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE);

	while (rdp->state != CONNECTION_STATE_ACTIVE)
	{
		if (rdp_check_fds(rdp) < 0)
			return FALSE;

		if (freerdp_shall_disconnect(rdp->instance))
			break;

		SwitchToThread();
	}

	return TRUE;
}
Esempio n. 30
0
/*
 * -------------------------------------------------------------------
 * Allow another thread to execute. If no other threads are runable this
 * is not guarenteed to actually rest.
 * ------------------------------------------------------------------- */
void thread_rest ( void ) {
#if defined( HAVE_THREAD )
#if defined( HAVE_POSIX_THREAD )
#if defined( _POSIX_PRIORITY_SCHEDULING )
    sched_yield();
#else
    usleep( 0 );
#endif

#else // Win32
    SwitchToThread( );
#endif
#endif
}