Beispiel #1
0
void Application::Run()
{
	Stopwatch watch;

	// 理想状况 60 帧每秒
	const DWORD desiredDelta = 1000 / 30;
	// 上一次每帧用时
	DWORD lastDelta = desiredDelta;
	while (true)
	{
		try
		{
			watch.Restart();
			if (DoFrame()) break;
			// 本帧用时
			lastDelta = static_cast<DWORD>(watch.Stop() * 1000);
			// Sleep 剩余时间
			if (lastDelta < desiredDelta)
				Sleep(desiredDelta - lastDelta);
		}
		catch (...)
		{
			bool handled = false;
			OnUncaughtException(handled);
			// 异常未处理
			if (!handled)
				throw;
		}
	}
}
Beispiel #2
0
int main ( ) {
	using namespace Furrovine;
	using namespace Furrovine::Audio;
	using namespace Furrovine::Pipeline;
	//using namespace Furrovine::Graphics;

	const static uint32 samplerate = 48000;
	const static uint32 bitspersample = 16;
	const static uint32 channelcount = 2;

	PCMAudioData data = WavAudioLoader( )( "16bit.wav" );

	AudioDevice baseaudiodevice( bitspersample, channelcount, samplerate );
	RealtimeAudioDevice audiodevice( baseaudiodevice, milliseconds( 10 ) );
	audiodevice.AddDSP( PerChannelDelay( audiodevice.PCMDescription( ), { seconds( 0.513 ), seconds( 0.490 ) }, real( 0.25 ) ) );
	
	AudioBuffer buffer( data.Buffer(), 0, 0, 0, 0, 1 );
	audiodevice.SubmitBuffer( buffer );

	Stopwatch stopwatch;
	stopwatch.Start( );
	while ( true ) {
		double seconds = stopwatch.ElapsedSeconds( );
		
		if ( seconds < 1 )
			continue;

		//audiodevice.SubmitBuffer( buffer );
		stopwatch.Restart( );
	}

}
void Test1()
{
    DIVIDING_LINE_1('-');

    constexpr int Count = 2001001;

#if HAS_BOOST
    boost::recursive_mutex osMutex;
    ostream_t os(std::cout, osMutex);
#else
    ostream_t &os = std::cout;
#endif

    Stopwatch sw;
    sw.Start();

    ProducerConsumerContext context(os, Count, Count / 10, ENABLE_LOGGING);

    Producer p1(context, 0, Count / 2, 200);
    Producer p2(context, Count / 2, Count - Count / 2, 200);

    Consumer c1(context, Count / 3, 200);
    Consumer c2(context, Count / 3, 200);
    Consumer c3(context, Count - Count / 3 - Count / 3, 200);

    std::vector<std::thread> threads;
    threads.push_back(p1.Create());
    threads.push_back(p2.Create());
    threads.push_back(c1.Create());
    threads.push_back(c2.Create());
    threads.push_back(c3.Create());

    for (auto &t : threads)
        t.join();

    sw.Stop();
    std::cout << "Ellapsed time: " << sw.GetElapsedMilliseconds() << "ms" << std::endl;

    std::cout << "Checking if test is passed...\n";

    sw.Restart();
    bool ok = context.IsTestPassed();
    sw.Stop();

    std::cout << "It takes " << sw.GetElapsedMilliseconds() << "ms to figure out if test is passed." << std::endl;
    std::cout << "Is test passed? " << std::boolalpha << ok << std::endl;
}
    void LruCacheTest::PerfTestHelper(
        int operationCount,
        size_t capacity,
        bool enableTrim)
    {
        //SetVerifyOutput localVerifySettings(VerifyOutputSettings::LogOnlyFailures);

        size_t bucketCount = 10240;

        LruCache<wstring, TestCacheEntry> cache(enableTrim ? capacity : 0, bucketCount);

        Random rand(static_cast<int>(DateTime::Now().Ticks));
        vector<TestCacheEntrySPtr> entries;
        for (auto ix=0; ix<operationCount; ++ix)
        {
            entries.push_back(make_shared<TestCacheEntry>(GetRandomKey(rand)));
        }

        Stopwatch stopwatch;

        // Write
        
        stopwatch.Restart();
        for (auto it=entries.begin(); it!=entries.end(); ++it)
        {
            auto entry = *it;
            bool success = cache.TryPutOrGet(entry);
            VERIFY_IS_TRUE(success);
        }
        stopwatch.Stop();

        Trace.WriteInfo(
            TraceComponent, 
            "LruCache-put: operations={0} elapsed={1} throughput={2} ops/s", 
            cache.Size, 
            stopwatch.Elapsed,
            (double)cache.Size / stopwatch.ElapsedMilliseconds * 1000);

        // Read

        stopwatch.Restart();
        for (auto it=entries.begin(); it!=entries.end(); ++it)
        {
            shared_ptr<TestCacheEntry> result;
            bool success = cache.TryGet((*it)->GetKey(), result);
            VERIFY_IS_TRUE(success);
        }
        stopwatch.Stop();

        Trace.WriteInfo(
            TraceComponent, 
            "LruCache-get: operations={0} elapsed={1} throughput={2} ops/s", 
            cache.Size, 
            stopwatch.Elapsed,
            (double)cache.Size / stopwatch.ElapsedMilliseconds * 1000);

        Trace.WriteInfo(
            TraceComponent, 
            "CacheSize: {0}",
            cache.Size);
    }
Beispiel #5
0
int main(int argc, char* argv[])
{

  if (argc != 6) {
    cout << "usage: ./a.out ";
    cout << "<coupling.arg> ";
    cout << "<evo.arg> ";
    cout << "<lattice.arg> ";
    cout << "<plaquette.arg> ";
    cout << "<retherm.arg> ";
    cout << endl;
    exit(EXIT_FAILURE);
  }

  // Get/set parameters
  CouplingArg coupling_arg( argv[1] );
  double beta = coupling_arg.beta;;

  EvoArg evo_arg( argv[2] );
  int n_conf = evo_arg.n_conf;
  int n_chkpt = evo_arg.n_chkpt;
  string cfg_file_stem = evo_arg.file_stem;

  LatticeArg lattice_arg( argv[3] );
  int sites[4];
  int sitesX[4];
  for (int mu=0; mu<4; ++mu) {
    sites[mu] = lattice_arg.sites[mu];
    if (sites[mu]%2 ==0) {
      sitesX[mu] = sites[mu]/2;
    } else {
      cout << "Numer of lattice sites must be even!" << endl;
      exit(EXIT_FAILURE);
    }
  }
  enum lat_state state = lattice_arg.state;;

  PlaquetteArg plaquette_arg( argv[4] );
  int n_plaq = plaquette_arg.n_plaq;
  string plaq_file_stem = plaquette_arg.file_stem;

  RethermArg retherm_arg( argv[5]);
  int retherm_sweeps = retherm_arg.sweeps;

  std::cout << "Initializing the lattice" << "..." << std::endl;
  Lattice latticeX(sitesX);
  Lattice lattice(sites);

  std::cout << "Initializing the monster..." << endl;;
  PlaquetteMonster monster(sites, n_plaq);

  vector<double> **plaq;
  vector<double> ***plaqs;
  plaq = new vector<double> * [n_plaq];
  plaqs = new vector<double> ** [n_plaq];
  for (int i=0; i<n_plaq; ++i) {
    plaq[i] = new vector<double> [n_plaq];
    plaqs[i] = new vector<double> * [n_plaq];
    for (int j=0; j<n_plaq; ++j) {
      plaqs[i][j]= new vector<double> [retherm_sweeps];
    }
  }

  std::stringstream ss;
  ofstream file;

  cout << setprecision(15);
  Stopwatch timer;
  int conf = 0;
  do {

    timer.Restart();

    if ( conf%n_chkpt==0 ) {

      std::cout << "\t";
      ss.str(std::string());
      ss << cfg_file_stem << "-" << conf << ".bin";
      if (!latticeX.Read(ss.str()) ) {
        std::cout << "Failed to find lattice : " << std::endl;
        std::cout <<  ss.str() << std::endl;
        exit(EXIT_FAILURE);
      };

      std::cout << "\t";
      std::cout << "Computing observables..." << std::endl;

      monster.Initialize(latticeX);
      for (int m=0; m<n_plaq/2; ++m)
      for (int n=0; n<n_plaq/2; ++n) {
        plaq[m][n].push_back( 1.0-monster.MeanPlaquette(m+1,n+1) );
      }

      if (retherm_sweeps>0) {

        std::cout << "\t";
        std::cout << "Refining lattice..." << std::endl;
        if ( !InterpolatedTwoCellBoundaryRefine(latticeX, lattice) ) {
          std::cout << "Failed to refine lattice!" << std::endl;
          exit(EXIT_FAILURE);
        }

        for(int cool_sweeps=0; cool_sweeps<50; ++cool_sweeps) {
          lattice.CoolUpdate(Subsets::two_cell_bulk_checker_board);
        }

        std::cout << "\t";
        std::cout << "Performing rethermalization sweeps and computing observables..." << std::endl;
        for (int h=0; h<retherm_sweeps; ++h) {
          monster.Initialize(lattice);
          for (int m=0; m<n_plaq; ++m)
          for (int n=0; n<n_plaq; ++n) {
            plaqs[m][n][h].push_back( 1.0-monster.MeanPlaquette(m+1,n+1) );
          }
          lattice.HeatBathUpdate(beta);
        }
      }
    }
 
    std::cout << "Total time for config " << conf << " is : " << timer.ElapsedTime() << std::endl;
    ++conf;

  } while (conf < n_conf);


//// Write observables to a file ////

  for (int m=0; m<n_plaq; ++m)
  for (int n=0; n<n_plaq; ++n) {
    ss.str(std::string());
    ss << plaq_file_stem << "-" << m+1 << "_" << n+1 << ".dat";
    std::cout << "Writing observables to file : ";
    std::cout << ss.str()  << std::endl;
    file.open(ss.str().c_str());
    file << setprecision(15);
    for(int j=0; j<plaq[m][n].size(); ++j) {
      file << plaq[m][n][j] << std::endl;
    }
    file.close();
  }

  for (int m=0; m<n_plaq; ++m)
  for (int n=0; n<n_plaq; ++n)
  for (int h=0; h<retherm_sweeps; ++h) {
    ss.str(std::string());
    ss << plaq_file_stem << "-" << m+1 << "_" << n+1 << "-" << h << ".dat";
    std::cout << "Writing observables to file : ";
    std::cout << ss.str()  << std::endl;
    file.open(ss.str().c_str());
    file << setprecision(15);
    for(int j=0; j<plaqs[m][n][h].size(); ++j) {
      file << plaqs[m][n][h][j] << std::endl;
    }
    file.close();
  }

//// DONE! ////

  for (int i=0; i<n_plaq; ++i) {
    for (int j=0; j<n_plaq; ++j) { delete [] plaqs[i][j]; }
    delete [] plaq[i];
    delete [] plaqs[i];
  }
  delete [] plaq;
  delete [] plaqs;

  cout << "Congratulations on a job... done!" << endl;
  exit(EXIT_SUCCESS);

}
Beispiel #6
0
	void Engine::StartGame()
	{
		myGameIsRunning = true;

		// Close the game when we hit the close button
		myEventHost->RegisterEvent<CloseButtonPressedEvent>([=](CloseButtonPressedEvent &ev)
		{
			myGameIsRunning = false;
		});

		// Show the window
		myRenderer->GetWindow()->SetVisible(true);

		Stopwatch stopwatch;
		std::vector<RenderCommand> *currentRenderCommands = new std::vector<RenderCommand>();

		float time = 0.f;

		while (myGameIsRunning == true)
		{
			float deltaTime = stopwatch.GetElapsedSeconds();
			time += deltaTime;
			stopwatch.Restart();

			myRenderer->TriggerEvents();

			std::swap(currentRenderCommands, myNewRenderCommands);

			float progressToNextFixedUpdate = (myTimeAccumulator / myTimeStep);

			myTimeAccumulator += deltaTime;

			Matrix33f worldToViewport;
			Transformation cameraTransformation = mySceneHost->GetCurrentScene()->GetCamera().GetTransformation();

			auto gameLogicWork = myThreadPool->QueueWorkItem(std::function<void()>([=]
			{
				while (myTimeAccumulator >= myTimeStep)
				{
					myEventHost->TriggerEvent(UpdateEvent(myTimeStep));
					myEventHost->TriggerEvent(EndUpdateEvent());
					myTimeAccumulator -= myTimeStep;
				}

				myEventHost->TriggerEvent(DrawEvent());
			}));

			Vector2f windowSize = Vector2f(myRenderer->GetWindow()->GetSize());
			worldToViewport *= Matrix33f::CreateScale(2.f / windowSize.x, -2.f / windowSize.y, 1.f) * Matrix33f::CreateTranslation(-cameraTransformation.Position.x, -cameraTransformation.Position.y) * Matrix33f::CreateRotateAroundZ(cameraTransformation.Rotation);

			myRenderer->SetWorldToViewportMatrix(worldToViewport);

			myRenderer->Clear();
			RenderTarget &renderTarget = *myRenderer->GetRenderTarget();
			
			for (size_t i = 0; i < currentRenderCommands->size(); i++)
			{
				RenderCommand currentCommand = (*currentRenderCommands)[i];

				Vector2f position = currentCommand.previousPosition + (currentCommand.currentPosition - currentCommand.previousPosition) * progressToNextFixedUpdate;

				renderTarget.Render(currentCommand.texture, position);
			}
			currentRenderCommands->clear();

			myRenderer->PresentBackBuffer();

			float beginSleep = stopwatch.GetElapsedSeconds();
			std::this_thread::sleep_for(std::chrono::microseconds(1));

			// Wait for the game logic update to finish
			gameLogicWork->Wait();

			if (mySceneHost->GetCurrentScene() == nullptr)
			{
				myGameIsRunning = false;
			}
		}

		delete currentRenderCommands;

		myEventHost->TriggerEvent(ExitingEvent());
	}