HRESULT __stdcall CStopwatchClassFactory::CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
{
	HRESULT hr;
	CStopwatch* pStopwatch = new CStopwatch;

	hr = pStopwatch->QueryInterface(riid, ppvObject);
	if (FAILED(hr))
	{
		delete pStopwatch;
	}

	return hr;
}
예제 #2
0
bool
CCondVarBase::wait(CStopwatch& timer, double timeout) const
{
	// check timeout against timer
	if (timeout >= 0.0) {
		timeout -= timer.getTime();
		if (timeout < 0.0)
			return false;
	}
	return wait(timeout);
}
예제 #3
0
void BaseApp::Run()
{
	CStopwatch timer;
	int sum = 0;
	int counter = 0;

	int deltaTime = 0;
	while (1)
	{
		timer.Start();
		if (kbhit())
		{
			KeyPressed (getch());
			if (!FlushConsoleInputBuffer(mConsoleIn))
				cout<<"FlushConsoleInputBuffer failed with error "<<GetLastError();
		}

		UpdateF((float)deltaTime / 1000.0f);
		Render();
		Sleep(1);

		while (1)
		{
			deltaTime = timer.Now();
			if (deltaTime > 20)
				break;
		}

		sum += deltaTime;
		counter++;
		if (sum >= 1000)
		{
			TCHAR  szbuff[255];
			StringCchPrintf(szbuff, 255, TEXT("FPS: %d"), counter);
			SetConsoleTitle(szbuff);

			counter = 0;
			sum = 0;
		}
	}
}
예제 #4
0
void MeasureConcurrentOperation(
   TCHAR* operationName, DWORD nThreads, OPERATIONFUNC operationFunc) {
   HANDLE* phThreads = new HANDLE[nThreads];

   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
   for (DWORD currentThread = 0; currentThread < nThreads; currentThread++) {
      phThreads[currentThread] = 
         CreateThread(NULL, 0, ThreadIterationFunction, operationFunc, 0, NULL);
   }
   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);

   CStopwatch watch;
   WaitForMultipleObjects(nThreads, phThreads, TRUE, INFINITE);
   __int64 elapsedTime = watch.Now();
   _tprintf(
	   TEXT("Threads=%u, Milliseconds=%u, Test=%s\n"), 
      nThreads, (DWORD)elapsedTime, operationName);

   // Don't forget to clean up the thread handles
   for (DWORD currentThread = 0; currentThread < nThreads; currentThread++) {
      CloseHandle(phThreads[currentThread]);
   }
   delete phThreads;
}
예제 #5
0
bool GLoadToken::LoadBuffer(const TCHAR* strFileName)
{
	CStopwatch stopwatch;
	TCHAR Drive[MAX_PATH];
	TCHAR Dir[MAX_PATH];
	TCHAR FName[MAX_PATH];
	TCHAR Ext[MAX_PATH];
	_tsplitpath(strFileName, Drive, Dir, FName, Ext);
	m_szDirName = Drive;
	m_szDirName += Dir;
	m_szName = FName;
	m_szName += Ext;

	LARGE_INTEGER FileSize;
	m_hHandle = CreateFile(strFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL, NULL);
	if (m_hHandle != INVALID_HANDLE_VALUE)
	{
		GetFileSizeEx(m_hHandle, &FileSize);
		UINT cBytes = FileSize.LowPart;

		SAFE_NEW_ARRAY(m_pmbStaticMeshData, char, cBytes);
		if (!m_pmbStaticMeshData)
		{
			DeleteBuffer();
			return false;//E_OUTOFMEMORY;
		}

		DWORD dwBytesRead;
		if (!ReadFile(m_hHandle, m_pmbStaticMeshData, cBytes, &dwBytesRead, NULL))
		{
			DeleteBuffer();
			return false;
		}
		//SetFilePointer( m_hHandle, 0, 0, FILE_BEGIN );				
	}
	else
	{
		return false;
	}

	TCHAR* szMeshData = NULL;
	TCHAR* SearchString = NULL;
	size_t convertedChars = 0;
	SAFE_NEW_ARRAY(m_pwcStaticMeshData, TCHAR, FileSize.LowPart);
	if (mbstowcs_s(&convertedChars, m_pwcStaticMeshData, FileSize.LowPart, m_pmbStaticMeshData, _TRUNCATE) == 0)
	{
		DeleteBuffer();
		return false;
	}
	if (m_pwcStaticMeshData)
	{
		SAFE_DELETE_ARRAY(m_pmbStaticMeshData);
		m_pwcTokenData = m_pwcStaticMeshData;
		m_pwcSearchData = m_pwcStaticMeshData;
	}

	CloseHandle(m_hHandle);
	m_hHandle = 0;

	BeginToken();
	stopwatch.Output(L"GLoadToken::LoadBuffer");
	return true;
}
예제 #6
0
	void CEngine::RunGameLoop()
	{
		// Enter the message loop
		MSG msg;
		ZeroMemory(&msg, sizeof(msg));
#ifdef USE_DISP_FPS
		char text[256] = {"\0"};
#endif
		while (msg.message != WM_QUIT)
		{
			if (PeekMessage(&msg, nullptr, 0U, 0U, PM_REMOVE))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
			else {
#ifdef USE_DISP_FPS
				CStopwatch sw;
				sw.Start();
#endif
				GameTime().Update();
				//キー入力を更新。
				m_keyInput.Update();

				m_skinModelDataResources.Update();

				m_physicsWorld.Update();

				CRenderContext& topRenderContext = m_renderContextArray[0];
				CRenderContext& lastRenderContext = m_renderContextArray[m_numRenderContext - 1];

				topRenderContext.SetRenderTarget(0, &m_mainRenderTarget[m_currentMainRenderTarget]);
				//topRenderContext.SetRenderTarget(0, &m_backBufferRT);
				topRenderContext.SetRenderTarget(1, NULL);
				
				CGameObjectManager& goMgr = CGameObjectManager::Instance();
				goMgr.Execute(
					m_renderContextArray.get(), 
					m_numRenderContext, 
					m_renderContextMap.get(),
					m_preRender,
					m_postEffect
				);
				lastRenderContext.SetRenderTarget(0, &m_backBufferRT);
				lastRenderContext.Clear(0, nullptr, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
					D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0
				);
				CopyMainRenderTargetToBackBuffer(lastRenderContext);

				m_pD3DDevice->BeginScene();
				//レンダリングコマンドのサブミット
				for( int i = 0; i < m_numRenderContext; i++ ){
					m_renderContextArray[i].SubmitCommandBuffer();
				}
				// 描画

#ifdef USE_DISP_FPS
				m_fpsFont.Draw(text, 0, 0);
#endif
				m_pD3DDevice->EndScene();
				m_pD3DDevice->Present(nullptr, nullptr, nullptr, nullptr);
				
				//
#ifdef USE_DISP_FPS
				sw.Stop();
				sprintf(text, "fps = %lf\n", 1.0f / sw.GetElapsed());
#endif


			}
		}
	}
예제 #7
0
bool		GGbsModel::Init(TCHAR* strFileName, TCHAR* strShaderName) {

	HRESULT hr = S_OK;

	//파싱, 필요한 처리 시작.
	CStopwatch stopwatch;


	//I_AseParser
	I_GbsParser.InitGbsModel(strFileName, this);

	//필요한 처리 끝.
	stopwatch.Output(L"Init()");


	// Create the sample state
	D3D11_SAMPLER_DESC sampDesc;
	ZeroMemory(&sampDesc, sizeof(sampDesc));
	sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
	sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
	sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
	sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
	sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
	sampDesc.MinLOD = 0;
	sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
	hr = g_pd3dDevice->CreateSamplerState(&sampDesc, m_pSamplerLinear.GetAddressOf());
	if (FAILED(hr))
		return hr;




	// Compile the vertex shader
	ID3DBlob* pVSBlob = NULL;
	hr = CompileShaderFromFile(strShaderName, "VS", "vs_4_0", &pVSBlob);
	if (FAILED(hr))
	{
		MessageBox(NULL,
			L"The FX file cannot be compiled.  Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
		return hr;
	}

	// Create the vertex shader
	hr = g_pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, m_pVertexShader.GetAddressOf());
	if (FAILED(hr))
	{
		pVSBlob->Release();
		return hr;
	}

	// Define the input layout
	D3D11_INPUT_ELEMENT_DESC layout[] =
	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "COLOR",    0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0 },
	};
	UINT numElements = ARRAYSIZE(layout);

	// Create the input layout
	hr = g_pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(),
		pVSBlob->GetBufferSize(), m_pVertexLayout.GetAddressOf());
	pVSBlob->Release();
	if (FAILED(hr))
		return hr;

	// Set the input layout
	g_pImmediateContext->IASetInputLayout(m_pVertexLayout.Get());

	// Compile the pixel shader
	ID3DBlob* pPSBlob = NULL;
	hr = CompileShaderFromFile(strShaderName, "PS", "ps_4_0", &pPSBlob);
	if (FAILED(hr))
	{
		MessageBox(NULL,
			L"The FX file cannot be compiled.  Please run this executable from the directory that contains the FX file.", L"Error", MB_OK);
		return hr;
	}

	// Create the pixel shader
	hr = g_pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, m_pPixelShader.GetAddressOf());
	pPSBlob->Release();
	if (FAILED(hr))
		return hr;


	

	if (m_vGeomObj.size() == 1)
		SingleModelInit();
	else
		MultiModelInit();

	


	return true;
};
예제 #8
0
void
CFileChunker::sendFileChunks(char* filename, IEventQueue* events, void* eventTarget)
{
	std::fstream file(reinterpret_cast<char*>(filename), std::ios::in | std::ios::binary);

	if (!file.is_open()) {
		throw runtime_error("failed to open file");
	}

	// check file size
	file.seekg (0, std::ios::end);
	size_t size = (size_t)file.tellg();

	// send first message (file size)
	CString fileSize = intToString(size);
	size_t sizeLength = fileSize.size();
	CFileChunk* sizeMessage = new CFileChunk(sizeLength + 2);
	char* chunkData = sizeMessage->m_chunk;

	chunkData[0] = kFileStart;
	memcpy(&chunkData[1], fileSize.c_str(), sizeLength);
	chunkData[sizeLength + 1] = '\0';
	events->addEvent(CEvent(events->forIScreen().fileChunkSending(), eventTarget, sizeMessage));

	// send chunk messages with a fixed chunk size
	size_t sentLength = 0;
	size_t chunkSize = m_chunkSize;
	CStopwatch stopwatch;
	stopwatch.start();
	file.seekg (0, std::ios::beg);
	while (true) {
		if (stopwatch.getTime() > PAUSE_TIME_HACK) {
			// make sure we don't read too much from the mock data.
			if (sentLength + chunkSize > size) {
				chunkSize = size - sentLength;
			}

			// for fileChunk->m_chunk, the first byte is the chunk mark, last is \0
			CFileChunk* fileChunk = new CFileChunk(chunkSize + 2);
			char* chunkData = fileChunk->m_chunk;

			chunkData[0] = kFileChunk;
			file.read(&chunkData[1], chunkSize);
			chunkData[chunkSize + 1] = '\0';
			events->addEvent(CEvent(events->forIScreen().fileChunkSending(), eventTarget, fileChunk));

			sentLength += chunkSize;
			file.seekg (sentLength, std::ios::beg);

			if (sentLength == size) {
				break;
			}

			stopwatch.reset();
		}
	}

	// send last message
	CFileChunk* transferFinished = new CFileChunk(2);
	chunkData = transferFinished->m_chunk;

	chunkData[0] = kFileEnd;
	chunkData[1] = '\0';
	events->addEvent(CEvent(events->forIScreen().fileChunkSending(), eventTarget, transferFinished));

	file.close();
}
예제 #9
0
파일: main.cpp 프로젝트: schreiberx/ipmo
int main(int argc, char *argv[])
{
	int max_threads = -1;
	int use_invasic = 1;

	if (argc > 1)
		use_invasic = atoi(argv[1]);

	if (use_invasic)
		std::cout << "INVASIC ACTIVATED" << std::endl;
	else
		std::cout << "INVASIC NOT ACTIVATED" << std::endl;

	int verbose_level = 0;
	if (argc > 2)
		verbose_level = atoi(argv[2]);

	/*
	 * initialize MPI
	 */
	int rank, size;
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	MPI_Comm_size(MPI_COMM_WORLD, &size);

	if (size == 1)
	{
		std::cout << "run with `mpirun -n 2 ./build/client_mpi_tbb_release [use invasic (0/1)] [verbose level (-99 for fancy graphics)]`" << std::endl;
		return -1;
	}

	CWorldScheduler_threaded *cWorldScheduler_threaded;

	if (use_invasic > 0)
	{
		/*
		 * allocate & start iPMO server for 1st rank on numa-domain
		 */
		if (rank == 0)
		{
			if (use_invasic == 1)
			{
				cWorldScheduler_threaded = new CWorldScheduler_threaded;

				std::cout << "RANK 0: starting worldscheduler" << std::endl;
				cWorldScheduler_threaded->start(-1, verbose_level, true);
			}
		}

		/*
		 * WAIT FOR WORLD SCHEDULER!
		 */
		MPI_Barrier(MPI_COMM_WORLD);

		/*
		 * initialize iPMO client
		 */
#if USE_OMP
		cPmo = new CPMO_OMP(max_threads);
#else
		cPmo = new CPMO_TBB(max_threads);
#endif

		// initial setup request
		cPmo->invade_blocking(1, 1024, 0, nullptr, (float)1);
	}


	CStopwatch cStopwatch;

	cStopwatch.start();

	/*
	 * start simulation
	 */
	for (int t = 0; t < 100; t++)
	{
		if (rank == 0)
			std::cout << "Timestep: " << t << std::endl;

		// compute some workload
		int workload = (t*((rank+size-1)%size) + (100-t)*rank) % 100;

		// for 4 cores only on my laptop, a linear imbalance is not working on dual-core systems
		workload *= workload;

		std::cout << "    > rank " << rank << " workload: " << workload << std::endl;

		if (use_invasic > 0)
		{
			// is some message about optimizations available?
			cPmo->reinvade_nonblocking();

			// request resource update with new workload
			cPmo->invade_nonblocking(1, 1024, 0, nullptr, (float)workload);
		}


		int n;
		if (use_invasic > 0)
		{
			n = cPmo->getNumberOfThreads();
		}
		else
		{
			n = sysconf(_SC_NPROCESSORS_ONLN)/size;
		}

		/*
		 * spread some bogus workload across n threads
		 */
#if USE_OMP
	#pragma omp parallel for schedule(static, 1)

		for (int i = 0; i < n; i++)
		{
			CDummyWorkload::doSomeSqrt(991290391.0, workload/n);
		}

#else

		tbb::parallel_for(
				0, n, 1,
				[workload,n](int i)
				{
					CDummyWorkload::doSomeSqrt(991290391.0, workload/n);
				}
		);

#endif

		std::cout << "    > rank " << rank << " finished" << std::endl;

		// do some stupid barrier
		MPI_Barrier(MPI_COMM_WORLD);
	}


	double t = cStopwatch.getTimeSinceStart();
	std::cout << "runtime: " << t << std::endl;

	if (use_invasic > 0)
	{
//		NEVER MIX retreat() with nonblocking invade/reinvade!
//	    cPmo_TBB->retreat();

		/*
		 * free iPMO client
		 */
		delete cPmo;

		// wait for all clients to shutdown iPMO
		MPI_Barrier(MPI_COMM_WORLD);

		/*
		 * free iPMO server
		 */
		if (rank == 0)
		{
			if (use_invasic == 1)
				delete cWorldScheduler_threaded;
		}
	}

	MPI_Finalize();

	return EXIT_SUCCESS;
}
bool
CXWindowsPrimaryScreen::showWindow()
{
	assert(m_window != None);

	CDisplayLock display(m_screen);

	// raise and show the input window
	XMapRaised(display, m_window);

	// grab the mouse and keyboard.  keep trying until we get them.
	// if we can't grab one after grabbing the other then ungrab
	// and wait before retrying.  give up after s_timeout seconds.
	static const double s_timeout = 1.0;
	int result;
	CStopwatch timer;
	do {
		// keyboard first
		do {
			result = XGrabKeyboard(display, m_window, True,
								GrabModeAsync, GrabModeAsync, CurrentTime);
			assert(result != GrabNotViewable);
			if (result != GrabSuccess) {
				LOG((CLOG_DEBUG2 "waiting to grab keyboard"));
				ARCH->sleep(0.05);
				if (timer.getTime() >= s_timeout) {
					LOG((CLOG_DEBUG2 "grab keyboard timed out"));
					XUnmapWindow(display, m_window);
					return false;
				}
			}
		} while (result != GrabSuccess);
		LOG((CLOG_DEBUG2 "grabbed keyboard"));

		// now the mouse
		result = XGrabPointer(display, m_window, True, 0,
								GrabModeAsync, GrabModeAsync,
								m_window, None, CurrentTime);
		assert(result != GrabNotViewable);
		if (result != GrabSuccess) {
			// back off to avoid grab deadlock
			XUngrabKeyboard(display, CurrentTime);
			LOG((CLOG_DEBUG2 "ungrabbed keyboard, waiting to grab pointer"));
			ARCH->sleep(0.05);
			if (timer.getTime() >= s_timeout) {
				LOG((CLOG_DEBUG2 "grab pointer timed out"));
				XUnmapWindow(display, m_window);
				return false;
			}
		}
	} while (result != GrabSuccess);
	LOG((CLOG_DEBUG1 "grabbed pointer and keyboard"));

	return true;
}