Apakah System.nanoTime () sama sekali tidak berguna?

Seperti yang didokumentasikan dalam posting blog Waspadai System.nanoTime () di Jawa , pada sistem x86, Java's System.nanoTime () mengembalikan nilai waktu menggunakan CPU penghitung khusus . Sekarang pertimbangkan kasus berikut yang saya gunakan untuk mengukur waktu panggilan:

long time1= System.nanoTime();
foo();
long time2 = System.nanoTime();
long timeSpent = time2-time1;

Sekarang dalam sistem multi-core, bisa jadi setelah mengukur waktu1, utas dijadwalkan untuk prosesor yang berbeda yang penghitungnya lebih kecil dari pada CPU sebelumnya. Dengan demikian kita bisa mendapatkan nilai dalam time2 yang kurang dari time1. Dengan demikian kita akan mendapatkan nilai negatif dalam timeSpent.

Mempertimbangkan kasus ini, bukankah itu System.nanotime cukup berguna untuk saat ini?

Saya tahu bahwa mengubah waktu sistem tidak mempengaruhi nanotime. Itu bukan masalah yang saya jelaskan di atas. Masalahnya adalah bahwa setiap CPU akan menyimpan penghitung yang berbeda sejak dihidupkan. Penghitung ini bisa lebih rendah pada CPU kedua dibandingkan dengan CPU pertama. Karena utas dapat dijadwalkan oleh OS ke CPU kedua setelah mendapatkan waktu1, nilai timeSpent mungkin salah dan bahkan negatif.

Jawaban ini ditulis pada tahun 2011 dari sudut pandang apa yang sebenarnya dilakukan oleh Sun JDK pada sistem operasi saat itu. Itu sudah lama sekali! jawaban leventov menawarkan perspektif yang lebih mutakhir.

Posting itu salah, dan nanoTimeaman. Ada komentar pada posting yang menghubungkan ke posting blog oleh David Holmes , seorang pria realtime dan concurrency di Sun. Ia mengatakan:

System.nanoTime () diimplementasikan menggunakan API QueryPerformanceCounter / QueryPerformanceFrequency [...] Mekanisme default yang digunakan oleh QPC ditentukan oleh lapisan Abstraksi Perangkat Keras (HAL) [...] Default ini berubah tidak hanya di seluruh perangkat keras tetapi juga di seluruh OS versi. Misalnya Windows XP Paket Layanan 2 mengubah hal-hal untuk menggunakan timer manajemen daya (PMTimer) daripada penghitung timestamp prosesor (TSC) karena masalah dengan TSC yang tidak disinkronkan pada prosesor yang berbeda dalam sistem SMP, dan karena faktanya frekuensinya dapat bervariasi (dan karenanya hubungannya dengan waktu yang berlalu) berdasarkan pengaturan manajemen daya.

Jadi, pada Windows, ini merupakan masalah hingga WinXP SP2, tetapi tidak sekarang.

Saya tidak dapat menemukan bagian II (atau lebih) yang berbicara tentang platform lain, tetapi artikel itu tidak menyertakan komentar bahwa Linux telah mengalami dan memecahkan masalah yang sama dengan cara yang sama, dengan tautan ke FAQ untuk clock_gettime (CLOCK_REALTIME) , yang mengatakan:

1. Apakah clock_gettime (CLOCK_REALTIME) konsisten di semua prosesor / inti? (Apakah lengkungan itu penting? Mis. Ppc, arm, x86, amd64, sparc).

Ini seharusnya atau itu dianggap kereta.

Namun, pada x86 / x86_64, dimungkinkan untuk melihat TSC freq yang tidak disinkronkan atau variabel menyebabkan inkonsistensi waktu. 2.4 kernel benar-benar tidak memiliki perlindungan terhadap hal ini, dan kernel 2.6 awal tidak terlalu baik di sini. Pada 2.6.18 dan lebih tinggi dari logika untuk mendeteksi ini lebih baik dan kami biasanya akan kembali ke sumber data yang aman.

ppc selalu memiliki timebase yang disinkronkan, sehingga seharusnya tidak menjadi masalah.

Jadi, jika tautan Holmes dapat dibaca sebagai menyiratkan nanoTimepanggilan itu clock_gettime(CLOCK_REALTIME), maka itu aman pada kernel 2.6.18 pada x86, dan selalu pada PowerPC (karena IBM dan Motorola, tidak seperti Intel, benar-benar tahu cara mendesain mikroprosesor).

Sayangnya, tidak disebutkan SPARC atau Solaris. Dan tentu saja, kami tidak tahu apa yang IBM JVM lakukan. Tapi Sun JVM di Windows dan Linux modern bisa melakukannya dengan benar.

EDIT: Jawaban ini didasarkan pada sumber yang dikutipnya. Tetapi saya masih khawatir bahwa itu mungkin benar-benar salah. Beberapa informasi terbaru akan sangat berharga. Saya baru saja menemukan tautan ke artikel empat tahun yang lebih baru tentang jam Linux yang dapat bermanfaat.

Saya melakukan sedikit pencarian dan menemukan bahwa jika seseorang menjadi jagoan maka ya itu mungkin dianggap tidak berguna ... dalam situasi tertentu ... itu tergantung pada seberapa sensitif waktu kebutuhan Anda ...

Lihatlah kutipan ini dari situs Java Sun:

Jam waktu nyata dan System.nanoTime () keduanya didasarkan pada panggilan sistem yang sama dan karenanya jam yang sama.

Dengan Java RTS, semua API berbasis waktu (misalnya, Pengatur Waktu, Utas Berkala, Pemantauan Batas Waktu, dan sebagainya) didasarkan pada pengatur waktu resolusi tinggi. Dan, bersama dengan prioritas waktu nyata, mereka dapat memastikan bahwa kode yang sesuai akan dieksekusi pada waktu yang tepat untuk kendala waktu nyata. Sebaliknya, Java SE API biasa hanya menawarkan beberapa metode yang mampu menangani waktu resolusi tinggi, tanpa jaminan eksekusi pada waktu tertentu. Menggunakan System.nanoTime () antara berbagai titik dalam kode untuk melakukan pengukuran waktu yang berlalu harus selalu akurat.

Java juga memiliki peringatan untuk metode nanoTime () :

Metode ini hanya dapat digunakan untuk mengukur waktu yang berlalu dan tidak terkait dengan gagasan lain tentang waktu sistem atau jam dinding. Nilai yang dikembalikan mewakili nanodetik sejak beberapa waktu tetap tapi sewenang-wenang (mungkin di masa depan, sehingga nilai mungkin negatif). Metode ini memberikan ketepatan nanosecond, tetapi tidak harus memiliki ketepatan nanosecond. Tidak ada jaminan yang dibuat tentang seberapa sering nilai berubah. Perbedaan panggilan berturut-turut yang rentang lebih besar dari sekitar 292,3 tahun (2 ⁶³ nanodetik) tidak akan secara akurat menghitung waktu yang berlalu karena luapan numerik.

Tampaknya satu-satunya kesimpulan yang dapat ditarik adalah bahwa nanoTime () tidak dapat diandalkan sebagai nilai yang akurat. Dengan demikian, jika Anda tidak perlu mengukur waktu yang hanya berjarak nano detik, maka metode ini cukup baik bahkan jika nilai yang dihasilkan negatif. Namun, jika Anda membutuhkan ketelitian yang lebih tinggi, mereka tampaknya menyarankan agar Anda menggunakan JAVA RTS.

Jadi untuk menjawab pertanyaan Anda ... no nanoTime () tidak berguna .... itu bukan metode yang paling bijaksana untuk digunakan dalam setiap situasi.

Tidak perlu diperdebatkan, cukup gunakan sumbernya. Di sini, SE 6 untuk Linux, buat kesimpulan sendiri:

jlong os::javaTimeMillis() {
  timeval time;
  int status = gettimeofday(&time, NULL);
  assert(status != -1, "linux error");
  return jlong(time.tv_sec) * 1000  +  jlong(time.tv_usec / 1000);
}


jlong os::javaTimeNanos() {
  if (Linux::supports_monotonic_clock()) {
    struct timespec tp;
    int status = Linux::clock_gettime(CLOCK_MONOTONIC, &tp);
    assert(status == 0, "gettime error");
    jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec);
    return result;
  } else {
    timeval time;
    int status = gettimeofday(&time, NULL);
    assert(status != -1, "linux error");
    jlong usecs = jlong(time.tv_sec) * (1000 * 1000) + jlong(time.tv_usec);
    return 1000 * usecs;
  }
}

Sejak Java 7, System.nanoTime()dijamin aman dengan spesifikasi JDK. System.nanoTime()Javadoc memperjelas bahwa semua doa yang teramati dalam JVM (yaitu, di semua utas) adalah monoton:

Nilai yang dikembalikan mewakili nanodetik sejak beberapa waktu asal tetap tetapi sewenang-wenang (mungkin di masa depan, sehingga nilai mungkin negatif). Asal yang sama digunakan oleh semua doa metode ini dalam mesin virtual Java; contoh mesin virtual lainnya cenderung menggunakan asal yang berbeda.

Implementasi JVM / JDK bertanggung jawab untuk meniadakan ketidakkonsistenan yang dapat diamati ketika utilitas OS yang mendasarinya dipanggil (misalnya yang disebutkan dalam jawaban Tom Anderson ).

Mayoritas jawaban lama lainnya untuk pertanyaan ini (ditulis pada 2009-2012) menyatakan FUD yang mungkin relevan untuk Java 5 atau Java 6 tetapi tidak lagi relevan untuk versi Jawa modern.

Perlu disebutkan, meskipun JDK menjamin nanoTime()keamanan, ada beberapa bug di OpenJDK yang membuatnya tidak menjunjung tinggi jaminan ini pada platform tertentu atau dalam keadaan tertentu (misalnya JDK-8040140 , JDK-8184271 ). Tidak ada bug terbuka (dikenal) di OpenJDK wrt nanoTime()saat ini, tetapi penemuan bug baru atau regresi dalam rilis OpenJDK yang lebih baru seharusnya tidak mengejutkan siapa pun.

Dengan mengingat hal itu, kode yang digunakan nanoTime()untuk pemblokiran waktunya, tunggu interval, batas waktu, dll. Sebaiknya memperlakukan perbedaan waktu negatif (batas waktu) sebagai nol daripada membuang pengecualian. Praktek ini juga disukai karena konsisten dengan perilaku semua metode menunggu waktunya di semua kelas di java.util.concurrent.*, misalnya Semaphore.tryAcquire(), Lock.tryLock(), BlockingQueue.poll(), dll

Meskipun demikian, nanoTime()harus tetap lebih disukai untuk menerapkan pemblokiran waktunya, tunggu interval, batas waktu, dll. currentTimeMillis()Karena yang terakhir adalah subjek dari fenomena "waktu mundur" (misalnya karena koreksi waktu server), yaitu currentTimeMillis()tidak cocok untuk mengukur interval waktu sama sekali. Lihat jawaban ini untuk informasi lebih lanjut.

Alih-alih menggunakan nanoTime()untuk pengukuran waktu eksekusi kode secara langsung, kerangka kerja benchmarking khusus dan profiler sebaiknya digunakan, misalnya JMH dan async-profiler dalam mode profil jam dinding .

Penafian: Saya adalah pengembang perpustakaan ini

Anda mungkin lebih suka ini:

http://juliusdavies.ca/nanotime/

Tapi itu menyalin file DLL atau Unix .so (objek bersama) ke direktori home pengguna saat ini sehingga dapat memanggil JNI.

Beberapa informasi latar belakang ada di situs saya di:

http://juliusdavies.ca/posix_clocks/clock_realtime_linux_faq.html

Linux mengoreksi perbedaan antara CPU, tetapi Windows tidak. Saya sarankan Anda menganggap System.nanoTime () hanya akurat sekitar 1 mikro-detik. Cara sederhana untuk mendapatkan penghitungan waktu yang lebih lama adalah dengan menelepon foo () 1000 atau lebih dan membagi waktu dengan 1000.

Sama sekali tidak berguna. Penggemar waktu yang tepat menunjukkan masalah multi-core, tetapi dalam aplikasi kata-kata sebenarnya seringkali secara radikal lebih baik daripada currentTimeMillis ().

Ketika menghitung posisi grafik dalam bingkai menyegarkan nanoTime () mengarah ke gerakan JAUH lebih halus dalam program saya.

Dan saya hanya menguji pada mesin multi-core.

Saya telah melihat waktu berlalu negatif yang dilaporkan dari menggunakan System.nanoTime (). Agar jelas, kode yang dimaksud adalah:

    long startNanos = System.nanoTime();

    Object returnValue = joinPoint.proceed();

    long elapsedNanos = System.nanoTime() - startNanos;

dan variabel 'elapsedNanos' memiliki nilai negatif. (Saya yakin bahwa panggilan perantara juga membutuhkan waktu kurang dari 293 tahun, yang merupakan titik meluap untuk nanos yang disimpan dalam waktu lama :)

Ini terjadi menggunakan IBM v1.5 JRE 64bit pada perangkat keras IBM P690 (multi-core) yang menjalankan AIX. Saya hanya melihat kesalahan ini terjadi sekali, jadi sepertinya sangat jarang. Saya tidak tahu penyebabnya - apakah ini masalah khusus perangkat keras, cacat JVM - Saya tidak tahu. Saya juga tidak tahu implikasi untuk akurasi nanoTime () secara umum.

Untuk menjawab pertanyaan awal, saya tidak berpikir nanoTime tidak berguna - ini menyediakan waktu sub-milidetik, tetapi ada risiko aktual (bukan hanya teoritis) karena tidak akurat yang perlu Anda perhitungkan.

Ini sepertinya tidak menjadi masalah pada Core 2 Duo yang menjalankan Windows XP dan JRE 1.5.0_06.

Dalam tes dengan tiga utas saya tidak melihat System.nanoTime () mundur. Prosesor sama-sama sibuk, dan utas pergi tidur sesekali untuk memancing ulir bergerak.

[EDIT] Saya kira itu hanya terjadi pada prosesor yang terpisah secara fisik, yaitu penghitung disinkronkan untuk beberapa core pada die yang sama.

Tidak, ini bukan ... Itu hanya tergantung pada CPU Anda, periksa Pengatur Waktu Presisi Tinggi untuk bagaimana / mengapa semuanya diperlakukan berbeda sesuai dengan CPU.

Pada dasarnya, baca sumber Java Anda dan periksa apa versi Anda dengan fungsi tersebut, dan jika berfungsi melawan CPU Anda akan menjalankannya.

IBM bahkan menyarankan Anda menggunakannya untuk tolok ukur kinerja (pos tahun 2008, tetapi diperbarui).

Saya menghubungkan ke apa yang pada dasarnya adalah diskusi yang sama di mana Peter Lawrey memberikan jawaban yang baik. Mengapa saya mendapatkan waktu berlalu negatif menggunakan System.nanoTime ()?

Banyak orang menyebutkan bahwa di Java System.nanoTime () dapat mengembalikan waktu negatif. Saya minta maaf karena mengulangi apa yang sudah dikatakan orang lain.

1. nanoTime () bukan jam tetapi penghitung siklus CPU.
2. Nilai pengembalian dibagi dengan frekuensi agar terlihat seperti waktu.
3. Frekuensi CPU dapat berfluktuasi.
4. Ketika utas Anda dijadwalkan pada CPU lain, ada kemungkinan mendapatkan nanoTime () yang menghasilkan perbedaan negatif. Itu logis. Penghitung di seluruh CPU tidak disinkronkan.
5. Dalam banyak kasus, Anda bisa mendapatkan hasil yang cukup menyesatkan tetapi Anda tidak akan bisa mengatakannya karena delta tidak negatif. Pikirkan tentang itu.
6. (belum dikonfirmasi) Saya pikir Anda mungkin mendapatkan hasil negatif bahkan pada CPU yang sama jika instruksi disusun ulang. Untuk mencegahnya, Anda harus menggunakan penghalang memori yang membuat cerita bersambung dari instruksi Anda.

Akan keren jika System.nanoTime () mengembalikan coreID di mana ia dieksekusi.

Java adalah lintas platform, dan nanoTime tergantung pada platform. Jika Anda menggunakan Java - saat tidak menggunakan nanoTime. Saya menemukan bug nyata di implementasi jvm yang berbeda dengan fungsi ini.

Dokumentasi Java 5 juga merekomendasikan penggunaan metode ini untuk tujuan yang sama.

Metode ini hanya dapat digunakan untuk mengukur waktu yang berlalu dan tidak terkait dengan gagasan lain tentang waktu sistem atau jam dinding.

Java 5 API Doc

Juga, System.currentTimeMillies()berubah ketika Anda mengubah jam sistem Anda, sementara System.nanoTime()tidak, sehingga yang terakhir lebih aman untuk mengukur durasi.

nanoTimesangat tidak aman untuk menentukan waktu. Saya mencobanya pada algoritma pengujian primality dasar saya dan memberikan jawaban yang secara harfiah terpisah satu sama lain untuk input yang sama. Jangan gunakan metode konyol itu. Saya membutuhkan sesuatu yang lebih akurat dan tepat daripada mendapatkan waktu milis, tetapi tidak seburuk itu nanoTime.