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;
}
