void *ThreadMain(void *arg) { printf("Thread started. You should see the WebGL canvas fade from black to red.\n"); EmscriptenWebGLContextAttributes attr; emscripten_webgl_init_context_attributes(&attr); attr.explicitSwapControl = EM_TRUE; ctx = emscripten_webgl_create_context(0, &attr); emscripten_webgl_make_context_current(ctx); double color = 0; for(int i = 0; i < 100; ++i) { color += 0.01; glClearColor(color, 0, 0, 1); glClear(GL_COLOR_BUFFER_BIT); EMSCRIPTEN_RESULT r = emscripten_webgl_commit_frame(); assert(r == EMSCRIPTEN_RESULT_SUCCESS); double now = emscripten_get_now(); while(emscripten_get_now() - now < 16) /*no-op*/; } emscripten_webgl_make_context_current(0); emscripten_webgl_destroy_context(ctx); emscripten_atomic_store_u32(&threadRunning, 0); printf("Thread quit\n"); pthread_exit(0); }
void sleep(int msecs) { // Test two different variants of sleeping to verify // against bug https://bugzilla.mozilla.org/show_bug.cgi?id=1131757 #ifdef SPINLOCK_TEST double t0 = emscripten_get_now(); double t1 = t0 + (double)msecs; while(emscripten_get_now() < t1) ; #else usleep(msecs*1000); #endif }
int main() { time_elapsed = emscripten_get_now(); http* http1 = new http("https://github.com",http::REQUEST_GET,"emscripten_master.zip"); http1->runRequest("/kripken/emscripten/archive/master.zip",http::ASSYNC_THREAD); http* http2 = new http("https://github.com",http::REQUEST_GET,"wolfviking_master.zip"); http2->runRequest("/wolfviking0/image.js/archive/master.zip",http::ASSYNC_THREAD); http2->abortRequest(); http* http3 = new http("https://raw.github.com",http::REQUEST_GET); http3->runRequest("/kripken/emscripten/master/LICENSE",http::ASSYNC_THREAD); num_request ++; emscripten_async_call(wait_http,http1,500); num_request ++; emscripten_async_call(wait_http,http2,500); num_request ++; emscripten_async_call(wait_http,http3,500); /* Http* http4 = new Http("http://www.---.com",Http::REQUEST_POST); http4->addValue("app","123"); http4->runRequest("/test.php",Http::ASSYNC_THREAD); num_request ++; emscripten_async_call(wait_http,http4,500); */ emscripten_set_main_loop(wait_https, 0, 0); }
tick_t Clock::Tick() { #if defined(ANDROID) struct timespec res; clock_gettime(CLOCK_REALTIME, &res); return 1000000000ULL*res.tv_sec + (tick_t)res.tv_nsec; #elif defined(EMSCRIPTEN) // emscripten_get_now() returns a wallclock time as a float in milliseconds (1e-3). // scale it to microseconds (1e-6) and return as a tick. return (tick_t)(((double)emscripten_get_now()) * 1e3); // return (tick_t)clock(); #elif defined(WIN32) LARGE_INTEGER ddwTimer; QueryPerformanceCounter(&ddwTimer); return ddwTimer.QuadPart; #elif defined(_POSIX_MONOTONIC_CLOCK) timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return (tick_t)t.tv_sec * 1000 * 1000 * 1000 + (tick_t)t.tv_nsec; #elif defined(_POSIX_C_SOURCE) || defined(__APPLE__) timeval t; gettimeofday(&t, NULL); return (tick_t)t.tv_sec * 1000 * 1000 + (tick_t)t.tv_usec; #else return (tick_t)clock(); #endif }
long long get_time_nsec() { #ifdef EMSCRIPTEN return emscripten_get_now() * 1000000; #else #ifdef APPLE if (!orwl_timestart) { mach_timebase_info_data_t tb = { 0 }; mach_timebase_info(&tb); orwl_timebase = tb.numer; orwl_timebase /= tb.denom; orwl_timestart = mach_absolute_time(); } struct timespec t; double diff = (mach_absolute_time() - orwl_timestart) * orwl_timebase; t.tv_sec = diff * ORWL_NANO; t.tv_nsec = diff - (t.tv_sec * ORWL_GIGA); return t.tv_nsec; #elif defined(_TINSPIRE) #else struct timespec sp; clock_gettime(CLOCK_MONOTONIC, &sp); return sp.tv_sec * 1000000000 + sp.tv_nsec; #endif #endif }
void wait_https() { if (num_request == 0) { printf("End of all download ... %fs\n",(emscripten_get_now() - time_elapsed) / 1000.f); emscripten_cancel_main_loop(); REPORT_RESULT(0); } }
void *mandelbrot_thread(void *arg) { int idx = (int)arg; for(;;) { emscripten_futex_wait(&tasksPending[idx], 0, INFINITY); emscripten_atomic_store_u32(&tasksPending[idx], 0); double t0 = emscripten_get_now(); int ni; if (use_sse) ni = ComputeMandelbrot_SSE(mandelReal, mandelImag, outputImage, sizeof(float)*W, sizeof(uint32_t)*W, 0, idx, numTasks, W, H, left, top, incrX, incrY, numItersDoneOnCanvas, numItersPerFrame); else ni = ComputeMandelbrot(mandelReal, mandelImag, outputImage, sizeof(float)*W, sizeof(uint32_t)*W, 0, idx, numTasks, W, H, left, top, incrX, incrY, numItersDoneOnCanvas, numItersPerFrame); //emscripten_atomic_add_u32(&numIters, ni); double t1 = emscripten_get_now(); numIters[idx] += ni; timeSpentInMandelbrot[idx] += t1-t0; emscripten_atomic_add_u32(&tasksDone, 1); emscripten_futex_wake(&tasksDone, 9999); } }
osd_ticks_t osd_ticks(void) { #ifdef SDLMAME_EMSCRIPTEN return (osd_ticks_t)(emscripten_get_now() * 1000.0); #else struct timeval tp; static osd_ticks_t start_sec = 0; gettimeofday(&tp, NULL); if (start_sec==0) start_sec = tp.tv_sec; return (tp.tv_sec - start_sec) * (osd_ticks_t) 1000000 + tp.tv_usec; #endif }
tick_t Clock::Tick() { //android #if defined(ANDROID) struct timespec res; clock_gettime(CLOCK_REALTIME, &res); return 1000000000ULL*res.tv_sec + (tick_t)res.tv_nsec; //android #elif defined(EMSCRIPTEN) #ifdef _TICK_IS_FLOAT return (tick_t)emscripten_get_now(); #else // emscripten_get_now() returns a wallclock time as a float in milliseconds (1e-3). // scale it to microseconds (1e-6) and return as a tick. return (tick_t)(((double)emscripten_get_now()) * 1e3); #endif #elif defined(WIN32) LARGE_INTEGER ddwTimer; BOOL success = QueryPerformanceCounter(&ddwTimer); assume(success != 0); MARK_UNUSED(success); return ddwTimer.QuadPart; #elif defined(__APPLE__) return mach_absolute_time(); #elif defined(_POSIX_MONOTONIC_CLOCK) timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return (tick_t)t.tv_sec * 1000 * 1000 * 1000 + (tick_t)t.tv_nsec; #elif defined(_POSIX_C_SOURCE) timeval t; gettimeofday(&t, NULL); return (tick_t) t.tv_sec * 1000 * 1000 + (tick_t) t.tv_usec; #else return (tick_t)clock(); #endif }
void looper() { static double frame0 = emscripten_get_now(); double start = emscripten_get_now(); ++numFrames; printf("Frame %d\n", numFrames); if (numFrames == 10) { double now = emscripten_get_now(); double msecsPerFrame = (now - frame0) / (numFrames-1); // Sub one to account for intervals vs endpoints printf("Avg. msecs/frame: %f\n", msecsPerFrame); #ifdef REPORT_RESULT int result = (msecsPerFrame > 350 && msecsPerFrame < 650); // Expecting 500msecs/frame, but allow a lot of leeway. Bad value would be 900msecs/frame (400msecs of processing below and 500msecs of delay) REPORT_RESULT(); #endif emscripten_cancel_main_loop(); } // Busy wait 400 msecs. double now = start; while (now - start < 400) { now = emscripten_get_now(); } }
int64_t getHPCounter() { #if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT LARGE_INTEGER li; // Performance counter value may unexpectedly leap forward // http://support.microsoft.com/kb/274323 QueryPerformanceCounter(&li); int64_t i64 = li.QuadPart; #elif BX_PLATFORM_ANDROID struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); int64_t i64 = now.tv_sec*INT64_C(1000000000) + now.tv_nsec; #elif BX_PLATFORM_EMSCRIPTEN int64_t i64 = int64_t(1000.0f * emscripten_get_now() ); #elif !BX_PLATFORM_NONE struct timeval now; gettimeofday(&now, 0); int64_t i64 = now.tv_sec*INT64_C(1000000) + now.tv_usec; #else BX_CHECK(false, "Not implemented!"); int64_t i64 = UINT64_MAX; #endif // BX_PLATFORM_ return i64; }
void BusySleep(double msecs) { double t0 = emscripten_get_now(); while(emscripten_get_now() < t0 + msecs); }
double Timer::getCurrent() { return emscripten_get_now() / 1000.0; }
static double time_sec() { return emscripten_get_now() * 1.0e-3; }