Beispiel #1
0
//DESCRIPTION:
// This function creates the completion port and the requested number of threads.
// If threads creation fails, the successfully created threads' handles are closed before returning.
//
//INPUT:
// nbOfThreads - the number of threads to create
// pWorkerThreads - the ouput pointer to the thread handle array
// pAsync_config - the config struct
//
//OUTPUT:
// TRUE for success
// FALSE for error
//
BOOL AsyncFuzzer::InitializeThreadsAndCompletionPort()
{
    BOOL bResult = FALSE;

    hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)NULL, 0);
    if(hIocp) {
        // Associate the device handle to iocp
        bResult = (NULL!=CreateIoCompletionPort(hDev, hIocp, 0, 0));
        if(bResult) {
            // Configure io completion port
            bResult = SetFileCompletionNotificationModes(hDev, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
            if(bResult) {
                bResult = CreateThreads();
                if(!bResult){
                    TPRINT(VERBOSITY_ERROR, _T("Failed to create worker threads\n"));
                }
            }
            else {
                TPRINT(VERBOSITY_ERROR, _T("Failed to configure iocompletion port with error %#.8x\n"), GetLastError());
            }
        }
        else {
            TPRINT(VERBOSITY_ERROR, _T("Failed to associate device with iocompletion port with error %#.8x\n"), GetLastError());
        }
    }
    else {
        TPRINT(VERBOSITY_ERROR, _T("Failed to create I/O completion port with error %#.8x\n"), GetLastError());
    }
    return bResult;
}
Beispiel #2
0
bool SocketMgr::StartNetwork(boost::asio::io_service& service, std::string const& bindIp, uint16 port, uint16 threads)
{
    _threadCount = threads;

    if (_threadCount <= 0)
    {
        std::cout << "Network.Threads is wrong in your config file" << std::endl;
        return false;
    }

    try
    {
        _acceptor = new AsyncAcceptor(service, bindIp, port);
    }
    catch (boost::system::system_error const& err)
    {
        std::cout << "Exception caught in SocketMgr.StartNetwork (" << bindIp.c_str() << ":" << port << "): " << err.what();
        return false;
    }

    _acceptor->AsyncAcceptManaged(&OnSocketAccept);

    _threads = CreateThreads();

    for (int32 i = 0; i < _threadCount; ++i)
        _threads[i].Start();

    return true;
}
Beispiel #3
0
bool WaitObjectContainer::Wait(unsigned long milliseconds)
{
	if (m_noWait || m_handles.empty())
		return true;

	if (m_handles.size() > MAXIMUM_WAIT_OBJECTS)
	{
		// too many wait objects for a single WaitForMultipleObjects call, so use multiple threads
		static const unsigned int WAIT_OBJECTS_PER_THREAD = MAXIMUM_WAIT_OBJECTS-1;
		unsigned int nThreads = (m_handles.size() + WAIT_OBJECTS_PER_THREAD - 1) / WAIT_OBJECTS_PER_THREAD;
		if (nThreads > MAXIMUM_WAIT_OBJECTS)	// still too many wait objects, maybe implement recursive threading later?
			throw Err("WaitObjectContainer: number of wait objects exceeds limit");
		CreateThreads(nThreads);
		DWORD error = S_OK;
		
		for (unsigned int i=0; i<m_threads.size(); i++)
		{
			WaitingThreadData &thread = *m_threads[i];
			while (!thread.waitingToWait)	// spin until thread is in the initial "waiting to wait" state
				Sleep(0);
			if (i<nThreads)
			{
				thread.waitHandles = &m_handles[i*WAIT_OBJECTS_PER_THREAD];
				thread.count = STDMIN(WAIT_OBJECTS_PER_THREAD, m_handles.size() - i*WAIT_OBJECTS_PER_THREAD);
				thread.error = &error;
			}
			else
				thread.count = 0;
		}

		ResetEvent(m_stopWaiting);
		PulseEvent(m_startWaiting);

		DWORD result = ::WaitForSingleObject(m_stopWaiting, milliseconds);
		if (result == WAIT_OBJECT_0)
		{
			if (error == S_OK)
				return true;
			else
				throw Err("WaitObjectContainer: WaitForMultipleObjects failed with error " + IntToString(error));
		}
		SetEvent(m_stopWaiting);
		if (result == WAIT_TIMEOUT)
			return false;
		else
			throw Err("WaitObjectContainer: WaitForSingleObject failed with error " + IntToString(::GetLastError()));
	}
	else
	{
		DWORD result = ::WaitForMultipleObjects(m_handles.size(), &m_handles[0], FALSE, milliseconds);
		if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + m_handles.size())
			return true;
		else if (result == WAIT_TIMEOUT)
			return false;
		else
			throw Err("WaitObjectContainer: WaitForMultipleObjects failed with error " + IntToString(::GetLastError()));
	}
}
void FrameScheduler::DoOneFrame()
{
    RunAllMonopolies();
    CreateThreads();
    RunMainThreadWork();
    JoinAllThreads();
    ResetAllWorkUnits();
    WaitUntilNextFrame();
}
Beispiel #5
0
CThreadsManager::CThreadsManager( void )
{
	m_dwPoolSize	= 0;
	m_dwBusyNum		= 0;
	m_dwTestCount	= 0;
	CreateThreads( THREADS_POOL_SIZE );
	OspSemBCreate(&m_hSem);
//	m_iter = m_ThreadMap.begin();
}
Beispiel #6
0
// FIXME: This should probably just take in the FrSimCRegs instead of connecting via 
//        a path
FricXactor::FricXactor(std::string name, FricIf *intf) :
  FrVmXactor(name),
  inChan("inChan", 1),
  outChan("outChan", 1),
  _sif(FrSimIface::getSimIface()),
  _intf(intf)
{
  CreateThreads();
}
Beispiel #7
0
/*
	RunTest

		This function runs a particular test for a number of times and reports the result.

	Parameters
		func	A function with the test
		str		A string with the test name

	Return Value
		None. This function prints the result

*/
void RunTest( void * ( * func)( void * ), char * str )
{
	// ------------------ Local Variables --------------------

		int testnum;
		int passedtests;
		double timesum;
		pthread_t *threads;
		ThreadParameters_t *threadparameters;

	// ------------------- Initialization -------------------

		passedtests = 0;
		timesum = 0;
		printf( "Now running [%s]\n", str );

	// ------------------- Run Tests ------------------------

		for ( testnum = 0; testnum < REPEATTESTS; testnum++ )
		{

			my_mutex_init( &gMutex );
			my_barrier_init( &gBarrier, gP );

			CreateThreads( &threads, gP, func, &threadparameters );
			JoinThreads( &threads, gP, &threadparameters );

			my_mutex_destroy( &gMutex );
			my_barrier_destroy( &gBarrier );

			timesum += gElapsedTime;
			if ( gCorrectTest )
			{
				passedtests++;
				printf( "+" ); fflush( stdout );
			}
			else
			{
				printf( "-" ); fflush( stdout );
			}
		}

		timesum /= REPEATTESTS;


	// ------------------- Print Outcome ---------------------
		printf( "\nTests passed: %d of %d. Average Time = %f (sec)\n", passedtests, REPEATTESTS, 
			 timesum );
}
Beispiel #8
0
void CThreadsManager::RunTask( CTaskObject* pTaskObject )
{
	if (FALSE == EnterLock())
	{
		return;
	}
	
	//float fBusyNum = m_dwBusyNum * 100 / THRESHOLD_VALUE;
	if ( m_dwBusyNum<<1 >= m_dwPoolSize )
	{
		CreateThreads( THREADS_STEP_INC );
	}
	
	BOOL32 bFind = FALSE;
	// 直接从上一次的下一个开始查找
//	++m_iter;
//	for (; m_iter != m_ThreadMap.end(); ++m_iter)
//	{
//		CThreadInfo* pInfo = m_iter->second;
//		if (FALSE == pInfo->HasTask())
//		{
//			pInfo->SetTask( pTaskObject );
//			bFind = TRUE;
//			break;
//		}
//		++g_FindCount;
//	}

	// 如果没有找到,则从头开始找
//	if (FALSE == bFind)
//	{
    ThreadMap::iterator iter;
		for (iter = m_ThreadMap.begin(); iter != m_ThreadMap.end(); ++iter)
		{
			CThreadInfo* pInfo = iter->second;
			if (FALSE == pInfo->HasTask())
			{
				pInfo->SetTask( pTaskObject );
				break;
			}
			++g_FindCount;
		}
//	}

	LeaveLock();

	++m_dwBusyNum;
}
Beispiel #9
0
void ReadTorrentFile(char filename[]){
	FILE* f = fopen(filename, "r");
	char lines[3][20];
	int i,length;

	for(i=0;i<3;i++){
		fgets(lines[i],sizeof(lines[i]),f);
		length = strlen(lines[i]) - 1;
		if (lines[i][length] == '\n'){
			lines[i][length] = '\0';
		}
	}	
	int hub = ConnectToHub(lines[0],lines[1]);
	if (hub){
		pthread_t t;
		pthread_create(&t,NULL,(void*)PrintSize,NULL);
		
		GetNodList(hub);
		CreateThreads(lines[2]);
	}
}
Beispiel #10
0
int WINAPI WinMain( HINSTANCE hInstance, 
					HINSTANCE hPrevInstance, 
					LPSTR lpCmdLine, 
					int nCmdShow)
{
	Psx *psx = Psx::GetInstance();

	CoInitialize(0);

	if (!CreateMainWindows(psx)) {
		return 1;
	}

	CreateThreads(psx);

	DWORD start = timeGetTime();
	static char title[256];

	while (!psx->quit) {
		if (psx->cpu->state == PSX_CPU_RUNNING) {
			if (timeGetTime()-start > 1000) {
				float speed = ((float)psx->cpu->mTotalCycles / Psx::CPU_CLOCK) * 100.0;
				sprintf_s(title, 256, "%.2f fps (%.2f%%)", (speed / 100.0) * 60.0, speed);
				SetWindowText(psx->mDispWnd->GetHwnd(), title);

				start = timeGetTime();
				psx->cpu->mTotalCycles = 0;
			}
		} else {
			SetWindowText(psx->mDispWnd->GetHwnd(), "Paused");
		}

		Window::ProcessMessages();
		Sleep(10);
	}

	return psx->mMainWnd->GetMsg().wParam;
}
Beispiel #11
0
bool WaitObjectContainer::Wait(unsigned long milliseconds)
{
	if (m_noWait || (m_handles.empty() && !m_firstEventTime))
	{
		SetLastResult(LASTRESULT_NOWAIT);
		return true;
	}

	bool timeoutIsScheduledEvent = false;

	if (m_firstEventTime)
	{
		double timeToFirstEvent = SaturatingSubtract(m_firstEventTime, m_eventTimer.ElapsedTimeAsDouble());

		if (timeToFirstEvent <= milliseconds)
		{
			milliseconds = (unsigned long)timeToFirstEvent;
			timeoutIsScheduledEvent = true;
		}

		if (m_handles.empty() || !milliseconds)
		{
			if (milliseconds)
				Sleep(milliseconds);
			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
			return timeoutIsScheduledEvent;
		}
	}

	if (m_handles.size() > MAXIMUM_WAIT_OBJECTS)
	{
		// too many wait objects for a single WaitForMultipleObjects call, so use multiple threads
		static const unsigned int WAIT_OBJECTS_PER_THREAD = MAXIMUM_WAIT_OBJECTS-1;
		unsigned int nThreads = (unsigned int)((m_handles.size() + WAIT_OBJECTS_PER_THREAD - 1) / WAIT_OBJECTS_PER_THREAD);
		if (nThreads > MAXIMUM_WAIT_OBJECTS)	// still too many wait objects, maybe implement recursive threading later?
			throw Err("WaitObjectContainer: number of wait objects exceeds limit");
		CreateThreads(nThreads);
		DWORD error = S_OK;
		
		for (unsigned int i=0; i<m_threads.size(); i++)
		{
			WaitingThreadData &thread = *m_threads[i];
			while (!thread.waitingToWait)	// spin until thread is in the initial "waiting to wait" state
				Sleep(0);
			if (i<nThreads)
			{
				thread.waitHandles = &m_handles[i*WAIT_OBJECTS_PER_THREAD];
				thread.count = UnsignedMin(WAIT_OBJECTS_PER_THREAD, m_handles.size() - i*WAIT_OBJECTS_PER_THREAD);
				thread.error = &error;
			}
			else
				thread.count = 0;
		}

		ResetEvent(m_stopWaiting);
		PulseEvent(m_startWaiting);

		DWORD result = ::WaitForSingleObject(m_stopWaiting, milliseconds);
		if (result == WAIT_OBJECT_0)
		{
			if (error == S_OK)
				return true;
			else
				throw Err("WaitObjectContainer: WaitForMultipleObjects in thread failed with error " + IntToString(error));
		}
		SetEvent(m_stopWaiting);
		if (result == WAIT_TIMEOUT)
		{
			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
			return timeoutIsScheduledEvent;
		}
		else
			throw Err("WaitObjectContainer: WaitForSingleObject failed with error " + IntToString(::GetLastError()));
	}
	else
	{
#if TRACE_WAIT
		static Timer t(Timer::MICROSECONDS);
		static unsigned long lastTime = 0;
		unsigned long timeBeforeWait = t.ElapsedTime();
#endif
		DWORD result = ::WaitForMultipleObjects((DWORD)m_handles.size(), &m_handles[0], FALSE, milliseconds);
#if TRACE_WAIT
		if (milliseconds > 0)
		{
			unsigned long timeAfterWait = t.ElapsedTime();
			OutputDebugString(("Handles " + IntToString(m_handles.size()) + ", Woke up by " + IntToString(result-WAIT_OBJECT_0) + ", Busied for " + IntToString(timeBeforeWait-lastTime) + " us, Waited for " + IntToString(timeAfterWait-timeBeforeWait) + " us, max " + IntToString(milliseconds) + "ms\n").c_str());
			lastTime = timeAfterWait;
		}
#endif
		if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + m_handles.size())
		{
			if (result == m_lastResult)
				m_sameResultCount++;
			else
			{
				m_lastResult = result;
				m_sameResultCount = 0;
			}
			return true;
		}
		else if (result == WAIT_TIMEOUT)
		{
			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
			return timeoutIsScheduledEvent;
		}
		else
			throw Err("WaitObjectContainer: WaitForMultipleObjects failed with error " + IntToString(::GetLastError()));
	}
}
static int usb_rtusb_init_device(struct net_device *net_dev)
{
	PRTMP_ADAPTER   pAd = (PRTMP_ADAPTER)  RTMP_OS_NETDEV_GET_PRIV(net_dev);
	NDIS_STATUS     Status = NDIS_STATUS_SUCCESS;
	UCHAR           TmpPhy;
	
	DBGPRINT(RT_DEBUG_TRACE, "%s-->\n", __FUNCTION__);

	// init mediastate to disconnected
	OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED);
	
	//bottom half data is assign at  each task_scheduler
	tasklet_init(&pAd->rx_bh, RTUSBBulkRxHandle, (unsigned long)pAd);
	
	// Initialize pAd->PortCfg to manufacture default
	PortCfgInit(pAd);


	// Init  RTMP_ADAPTER CmdQElements
	Status = RTMPInitAdapterBlock(pAd); //always success
	if (Status != NDIS_STATUS_SUCCESS)
	{
		return Status;
	}

	//
	// Init send data structures and related parameters
	//
	Status = NICInitTransmit(pAd);      //if fail clean itself
	if (Status != NDIS_STATUS_SUCCESS)
	{
		return Status;
	}

	//
	// Init receive data structures and related parameters
	//
	Status = NICInitRecv(pAd);
	if (Status != NDIS_STATUS_SUCCESS)
	{
		goto out;
	}
	

	// Wait for hardware stable
	{
		ULONG MacCsr0 = 0, Index = 0;
		
		do
		{
			Status = RTUSBReadMACRegister(pAd, MAC_CSR0, &MacCsr0);

			if (MacCsr0 != 0)
				break;
			
			RTMPusecDelay(1000);
		} while (Index++ < 1000);
		DBGPRINT(RT_DEBUG_TRACE, "Init: MAC_CSR0=0x%08x, Status=0x%08x\n", MacCsr0, Status);
	}

	// Load 8051 firmware
	Status = NICLoadFirmware(pAd);
	if(Status != NDIS_STATUS_SUCCESS)
	{
		goto out;
	}

	// Initialize Asics
	NICInitializeAsic(pAd);

#ifdef BLOCK_NET_IF
	initblockQueueTab(pAd);
#endif // BLOCK_NET_IF //

	// Read RaConfig profile parameters 
#ifdef  READ_PROFILE_FROM_FILE 
	RTMPReadParametersFromFile(pAd);
#endif

	//
	// Read additional info from NIC such as MAC address
	// This function must called after register CSR base address
	//
#ifdef	INIT_FROM_EEPROM
	NICReadEEPROMParameters(pAd);
	NICInitAsicFromEEPROM(pAd);
#endif
	RTUSBWriteHWMACAddress(pAd);

	// external LNA has different R17 base
	if (pAd->NicConfig2.field.ExternalLNA)
	{
		pAd->BbpTuning.R17LowerBoundA += 0x10;
		pAd->BbpTuning.R17UpperBoundA += 0x10;
		pAd->BbpTuning.R17LowerBoundG += 0x10;
		pAd->BbpTuning.R17UpperBoundG += 0x10;
	}

	// hardware initialization after all parameters are acquired from
	// Registry or E2PROM
	TmpPhy = pAd->PortCfg.PhyMode;
	pAd->PortCfg.PhyMode = 0xff;
	RTMPSetPhyMode(pAd, TmpPhy);
	// max desired rate might be reset as call phymode setup, so set TxRate again
	if (pAd->PortCfg.DefaultMaxDesiredRate == 0)
		RTMPSetDesiredRates(pAd, -1);
	else
		RTMPSetDesiredRates(pAd, (LONG) (RateIdToMbps[pAd->PortCfg.DefaultMaxDesiredRate - 1] * 1000000));

	//
	// initialize MLME
	//
	Status = MlmeInit(pAd);
	if(Status != NDIS_STATUS_SUCCESS)
	{
		goto out;
	}

	// mlmethread & RTUSBCmd flag restart
	mlme_kill = 0;
	RTUSBCmd_kill =0;
	CreateThreads(net_dev);

	// at every open handler, copy mac address.
	COPY_MAC_ADDR(pAd->net_dev->dev_addr, pAd->CurrentAddress);

	// USB_ID info for UI
	pAd->VendorDesc = 0x148F2573;

	DBGPRINT(RT_DEBUG_TRACE, "%s<--\n", __FUNCTION__);

	return 0;

out:
	ReleaseAdapter(pAd, TRUE, FALSE);
	return Status;

}
Beispiel #13
0
int main(int argc, char **argv)
#endif
{
    PLOptStatus os;
    PRIntn duration = DEFAULT_DURATION;
    PRUint32 totalCount, highCount = 0, lowCount = 0;
	PLOptState *opt = PL_CreateOptState(argc, argv, "hdc:");

    debug_out = PR_STDOUT;
    oneSecond = PR_SecondsToInterval(1);

	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
    {
		if (PL_OPT_BAD == os) continue;
        switch (opt->option)
        {
        case 'd':  /* debug mode */
			debug_mode = PR_TRUE;
            break;
        case 'c':  /* test duration */
			duration = atoi(opt->value);
            break;
        case 'h':  /* help message */
         default:
			Help();
			return 2;
        }
    }
	PL_DestroyOptState(opt);
    PR_STDIO_INIT();

    if (duration == 0) duration = DEFAULT_DURATION;

    RudimentaryTests();

    printf("Priority test: running for %d seconds\n\n", duration);

    (void)PerSecond(PR_IntervalNow());
    totalCount = PerSecond(PR_IntervalNow());

    PR_SetThreadPriority(PR_GetCurrentThread(), PR_PRIORITY_URGENT);

    if (debug_mode)
    {
        PR_fprintf(debug_out,
		    "The high priority thread should get approximately three\n");
        PR_fprintf( debug_out,
		    "times what the low priority thread manages. A maximum of \n");
        PR_fprintf( debug_out, "%d cycles are available.\n\n", totalCount);
    }

    duration = (duration + 4) / 5;
    CreateThreads(&lowCount, &highCount);
    while (duration--)
    {
        PRIntn loop = 5;
        while (loop--) PR_Sleep(oneSecond);
        if (debug_mode)
            PR_fprintf(debug_out, "high : low :: %d : %d\n", highCount, lowCount);
    }


    PR_ProcessExit((failed) ? 1 : 0);

	PR_NOT_REACHED("You can't get here -- but you did!");
	return 1;  /* or here */

}  /* main */