ovr_sdk: 1b39a1b46319 LibOVR/Src/Kernel/OVR

268 OVR_DEBUG_LOG(("NtQueryTimerResolution = Min %ld us, Max %ld us, Current %ld us", MinimumResolution / 10, MaximumResolution / 10, ActualResolution / 10));

269 }

270

271 FreeLibrary(hNtDll);

272 }

273 #endif

274 }

275

276 void PerformanceTimer::Shutdown()

277 {

278 DeleteCriticalSection(&TimeCS);

279

280 #if defined(OVR_OS_WIN32) // Desktop Windows only

281 MMRESULT mmr = timeEndPeriod(1);

282 OVR_ASSERT(TIMERR_NOERROR == mmr);

283 OVR_UNUSED(mmr);

284 #endif

285 }

286

287

288 uint64_t PerformanceTimer::GetTimeSeconds()

289 {

290 if (UsingVistaOrLater)

291 {

292 LARGE_INTEGER li;

293 QueryPerformanceCounter(&li);

294 OVR_ASSERT(PerfFrequencyInverse != 0); // Initialize should have been called earlier.

295 return (uint64_t)(li.QuadPart * PerfFrequencyInverse);

296 }

297

298 return (uint64_t)(GetTimeNanos() * .0000000001);

299 }

300

301

302 double PerformanceTimer::GetTimeSecondsDouble()

303 {

304 if (UsingVistaOrLater)

305 {

306 LARGE_INTEGER li;

307 QueryPerformanceCounter(&li);

308 OVR_ASSERT(PerfFrequencyInverse != 0);

309 return (li.QuadPart * PerfFrequencyInverse);

310 }

311

312 return (GetTimeNanos() * .0000000001);

313 }

314

315

316 uint64_t PerformanceTimer::GetTimeNanos()

317 {

318 uint64_t resultNanos;

319 LARGE_INTEGER li;

320

321 OVR_ASSERT(PerfFrequencyInverseNanos != 0); // Initialize should have been called earlier.

322

323 if (UsingVistaOrLater) // Includes non-desktop platforms

324 {

325 // Then we can use QPC() directly without all that extra work

326 QueryPerformanceCounter(&li);

327 resultNanos = (uint64_t)(li.QuadPart * PerfFrequencyInverseNanos);

328 }

329 else

330 {

331 // On Win32 QueryPerformanceFrequency is unreliable due to SMP and

332 // performance levels, so use this logic to detect wrapping and track

333 // high bits.

334 ::EnterCriticalSection(&TimeCS);

335

336 // Get raw value and perf counter "At the same time".

337 QueryPerformanceCounter(&li);

338

339 DWORD mmTimeMs = timeGetTime();

340 if (OldMMTimeMs > mmTimeMs)

341 MMTimeWrapCounter++;

342 OldMMTimeMs = mmTimeMs;

343

344 // Normalize to nanoseconds.

345 uint64_t perfCounterNanos = (uint64_t)(li.QuadPart * PerfFrequencyInverseNanos);

346 uint64_t mmCounterNanos = ((uint64_t(MMTimeWrapCounter) << 32) | mmTimeMs) * 1000000;

347 if (PerfMinusTicksDeltaNanos == 0)

348 PerfMinusTicksDeltaNanos = perfCounterNanos - mmCounterNanos;

349

350 // Compute result before snapping.

351 //

352 // On first call, this evaluates to:

353 // resultNanos = mmCounterNanos.

354 // Next call, assuming no wrap:

355 // resultNanos = prev_mmCounterNanos + (perfCounterNanos - prev_perfCounterNanos).

356 // After wrap, this would be:

357 // resultNanos = snapped(prev_mmCounterNanos +/- 1ms) + (perfCounterNanos - prev_perfCounterNanos).

358 //

359 resultNanos = perfCounterNanos - PerfMinusTicksDeltaNanos;

360

361 // Snap the range so that resultNanos never moves further apart then its target resolution.

362 // It's better to allow more slack on the high side as timeGetTime() may be updated at sporadically

363 // larger then 1 ms intervals even when 1 ms resolution is requested.

364 if (resultNanos > (mmCounterNanos + MMTimerResolutionNanos*2))

365 {

366 resultNanos = mmCounterNanos + MMTimerResolutionNanos*2;

367 if (resultNanos < LastResultNanos)

368 resultNanos = LastResultNanos;

369 PerfMinusTicksDeltaNanos = perfCounterNanos - resultNanos;

370 }

371 else if (resultNanos < (mmCounterNanos - MMTimerResolutionNanos))

372 {

373 resultNanos = mmCounterNanos - MMTimerResolutionNanos;

374 if (resultNanos < LastResultNanos)

375 resultNanos = LastResultNanos;

376 PerfMinusTicksDeltaNanos = perfCounterNanos - resultNanos;

377 }

378

379 LastResultNanos = resultNanos;

380 ::LeaveCriticalSection(&TimeCS);

381 }

382

383 //Tom's addition, to keep precision

384 //static uint64_t initial_time = 0;

385 //if (!initial_time) initial_time = resultNanos;

386 //resultNanos -= initial_time;

387 // FIXME: This cannot be used for cross-process timestamps

388

389 return resultNanos;

390 }

391

392

393 //------------------------------------------------------------------------

394 // *** Timer - Platform Independent functions

395

396 // Returns global high-resolution application timer in seconds.

397 double Timer::GetSeconds()

398 {

399 if(useFakeSeconds)

400 return FakeSeconds;

401

402 return Win32_PerfTimer.GetTimeSecondsDouble();

403 }

404

405

406

407 // Delegate to PerformanceTimer.

408 uint64_t Timer::GetTicksNanos()

409 {

410 if (useFakeSeconds)

411 return (uint64_t) (FakeSeconds * NanosPerSecond);

412

413 return Win32_PerfTimer.GetTimeNanos();

414 }

415 void Timer::initializeTimerSystem()

416 {

417 Win32_PerfTimer.Initialize();

418 }

419 void Timer::shutdownTimerSystem()

420 {

421 Win32_PerfTimer.Shutdown();

422 }

423

424

425

426 #elif defined(OVR_OS_MAC)

427

428

429 double Timer::TimeConvertFactorNanos = 0.0;

430 double Timer::TimeConvertFactorSeconds = 0.0;

431

432

433 //------------------------------------------------------------------------

434 // *** Standard OS Timer

435

436 // Returns global high-resolution application timer in seconds.

437 double Timer::GetSeconds()

438 {

439 if(useFakeSeconds)

440 return FakeSeconds;

441

442 OVR_ASSERT(TimeConvertFactorNanos != 0.0);

443 return (double)mach_absolute_time() * TimeConvertFactorNanos;

444 }

445

446

447 uint64_t Timer::GetTicksNanos()

448 {

449 if (useFakeSeconds)

450 return (uint64_t) (FakeSeconds * NanosPerSecond);

451

452 OVR_ASSERT(TimeConvertFactorSeconds != 0.0);

453 return (uint64_t)(mach_absolute_time() * TimeConvertFactorSeconds);

454 }

455

456 void Timer::initializeTimerSystem()

457 {

458 mach_timebase_info_data_t timeBase;

459 mach_timebase_info(&timeBase);

460 TimeConvertFactorSeconds = ((double)timeBase.numer / (double)timeBase.denom);

461 TimeConvertFactorNanos = TimeConvertFactorSeconds / 1000000000.0;

462 }

463

464 void Timer::shutdownTimerSystem()

465 {

466 // Empty for this platform.

467 }

468

469

470 #else // Posix platforms (e.g. Linux, BSD Unix)

471

472

473 bool Timer::MonotonicClockAvailable = false;

474

475

476 // Returns global high-resolution application timer in seconds.

477 double Timer::GetSeconds()

478 {

479 if(useFakeSeconds)

480 return FakeSeconds;

481

482 // http://linux/die/netman3/clock_gettime

483 #if defined(CLOCK_MONOTONIC) // If we can use clock_gettime, which has nanosecond precision...

484 if(MonotonicClockAvailable)

485 {

486 timespec ts;

487 clock_gettime(CLOCK_MONOTONIC, &ts); // Better to use CLOCK_MONOTONIC than CLOCK_REALTIME.

488 return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) / 1E9;

489 }

490 #endif

491

492 // We cannot use rdtsc because its frequency changes at runtime.

493 struct timeval tv;

494 gettimeofday(&tv, 0);

495

496 return static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) / 1E6;

497 }

498

499

500 uint64_t Timer::GetTicksNanos()

501 {

502 if (useFakeSeconds)

503 return (uint64_t) (FakeSeconds * NanosPerSecond);

504

505 #if defined(CLOCK_MONOTONIC) // If we can use clock_gettime, which has nanosecond precision...

506 if(MonotonicClockAvailable)

507 {

508 timespec ts;

509 clock_gettime(CLOCK_MONOTONIC, &ts);

510 return ((uint64_t)ts.tv_sec * 1000000000ULL) + (uint64_t)ts.tv_nsec;

511 }

512 #endif

513

514

515 // We cannot use rdtsc because its frequency changes at runtime.

516 uint64_t result;

517

518 // Return microseconds.

519 struct timeval tv;

520

521 gettimeofday(&tv, 0);

522

523 result = (uint64_t)tv.tv_sec * 1000000;

524 result += tv.tv_usec;

525

526 return result * 1000;

527 }

528

529

530 void Timer::initializeTimerSystem()

531 {

532 #if defined(CLOCK_MONOTONIC)

533 timespec ts; // We could also check for the availability of CLOCK_MONOTONIC with sysconf(_SC_MONOTONIC_CLOCK)

534 int result = clock_gettime(CLOCK_MONOTONIC, &ts);

535 MonotonicClockAvailable = (result == 0);

536 #endif

537 }

538

539 void Timer::shutdownTimerSystem()

540 {

541 // Empty for this platform.

542 }

543

544

545

546 #endif // OS-specific

547

548

549

550 } // OVR

551