เวลาไมโครวินาทีใน JavaScript

มีฟังก์ชันจับเวลาใด ๆ ใน JavaScript ที่มีความละเอียดระดับไมโครวินาทีหรือไม่?

ฉันรู้จักtimer.jsสำหรับ Chrome และหวังว่าจะมีวิธีแก้ปัญหาสำหรับเบราว์เซอร์ที่เป็นมิตรอื่น ๆ เช่น Firefox, Safari, Opera, Epiphany, Konqueror เป็นต้นฉันไม่สนใจที่จะสนับสนุน IE ใด ๆ แต่คำตอบรวมถึง IE ยินดีต้อนรับ.

(ด้วยความแม่นยำที่ไม่ดีของการจับเวลาในมิลลิวินาทีใน JS ฉันไม่ได้กลั้นหายใจ!)

อัปเดต: timer.js โฆษณาความละเอียดระดับไมโครวินาที แต่เพียงแค่คูณค่าการอ่านในมิลลิวินาทีด้วย 1,000 ตรวจสอบโดยการทดสอบและการตรวจสอบรหัส ผิดหวัง. : [

ตามที่กล่าวถึงในคำตอบของ Mark Rejhon มี API ที่พร้อมใช้งานในเบราว์เซอร์สมัยใหม่ที่แสดงข้อมูลเวลาความละเอียดย่อยมิลลิวินาทีไปยังสคริปต์: ตัวจับเวลาความละเอียดสูง W3Cหรือที่เรียกwindow.performance.now()ว่า

now()ดีกว่าแบบดั้งเดิมDate.getTime()ในสองวิธีที่สำคัญ:

1. now()เป็นค่าสองเท่าที่มีความละเอียดย่อยวินาทีซึ่งแสดงถึงจำนวนมิลลิวินาทีนับตั้งแต่เริ่มการนำทางของเพจ จะส่งคืนจำนวนไมโครวินาทีในเศษส่วน (เช่นค่า 1000.123 คือ 1 วินาทีและ 123 ไมโครวินาที)

2. now()เพิ่มขึ้นอย่างจำเจ นี้เป็นสิ่งสำคัญDate.getTime()ที่สามารถอาจจะกระโดดไปข้างหน้าหรือแม้กระทั่งย้อนกลับในการโทรตามมา โดยเฉพาะอย่างยิ่งหากมีการอัปเดตเวลาระบบของระบบปฏิบัติการ (เช่นการซิงโครไนซ์นาฬิกาอะตอม) Date.getTime()จะมีการอัปเดตด้วย now()รับประกันว่าจะเพิ่มขึ้นอย่างซ้ำซากจำเจอยู่เสมอดังนั้นจึงไม่ได้รับผลกระทบจากเวลาของระบบปฏิบัติการ - จะเป็นเวลานาฬิกาแขวนเสมอ (สมมติว่านาฬิกาแขวนของคุณไม่ใช่อะตอม ... )

now()สามารถนำมาใช้ในเกือบทุกสถานที่ที่new Date.getTime(), + new DateและDate.now()มี ข้อยกเว้นคือDateและnow()เวลาจะไม่ผสมกันDateตามที่ขึ้นอยู่กับunix-epoch (จำนวนมิลลิวินาทีตั้งแต่ปี 1970) ในขณะnow()ที่จำนวนมิลลิวินาทีนับตั้งแต่การนำทางหน้าเว็บของคุณเริ่มต้น (ดังนั้นจะมีขนาดเล็กกว่ามากDate)

now()ได้รับการสนับสนุนใน Chrome ที่เสถียร, Firefox 15+ และ IE10 นอกจากนี้ยังมีpolyfillsหลายชนิด

ขณะนี้มีวิธีการใหม่ในการวัดไมโครวินาทีในจาวาสคริปต์: http://gent.ilcore.com/2012/06/better-timer-for-javascript.html

อย่างไรก็ตามในอดีตฉันพบวิธีการที่หยาบคายในการรับความแม่นยำ 0.1 มิลลิวินาทีใน JavaScript โดยใช้ตัวจับเวลาเพียงมิลลิวินาที เป็นไปไม่ได้? ไม่ อ่านต่อ:

ฉันกำลังทำการทดลองที่มีความแม่นยำสูงซึ่งต้องตรวจสอบความแม่นยำของตัวจับเวลาและพบว่าฉันสามารถรับความแม่นยำ 0.1 มิลลิวินาทีได้อย่างน่าเชื่อถือกับเบราว์เซอร์บางตัวในบางระบบ

ฉันพบว่าในเว็บเบราว์เซอร์ที่เร่งด้วย GPU สมัยใหม่บนระบบที่รวดเร็ว (เช่น i7 quad core ซึ่งหลายคอร์ไม่ได้ใช้งานมีเพียงหน้าต่างเบราว์เซอร์เท่านั้น) - ตอนนี้ฉันสามารถวางใจว่าตัวจับเวลามีความแม่นยำในระดับมิลลิวินาทีได้แล้ว ในความเป็นจริงมันแม่นยำมากในระบบ i7 ที่ไม่ได้ใช้งานฉันสามารถรับมิลลิวินาทีเดียวกันได้อย่างน่าเชื่อถือมากกว่า 1,000 ครั้ง เฉพาะเมื่อฉันพยายามทำสิ่งต่างๆเช่นโหลดหน้าเว็บเพิ่มเติมหรืออื่น ๆ ความแม่นยำในระดับมิลลิวินาทีจะลดลง (และฉันสามารถตรวจจับความถูกต้องที่ลดลงของตัวเองได้สำเร็จโดยทำการตรวจสอบก่อนและหลังเวลาเพื่อดูว่า จู่ๆเวลาในการประมวลผลของฉันก็ยาวขึ้นเป็น 1 มิลลิวินาทีขึ้นไปซึ่งช่วยให้ฉันยกเลิกผลลัพธ์ที่อาจได้รับผลกระทบในทางลบจากความผันผวนของ CPU มากเกินไป)

มันแม่นยำมากในเบราว์เซอร์เร่ง GPU บางตัวบนระบบ i7 quad-core (เมื่อหน้าต่างเบราว์เซอร์เป็นหน้าต่างเดียว) ฉันพบว่าฉันต้องการเข้าถึงตัวจับเวลาที่แม่นยำ 0.1ms ใน JavaScript เนื่องจากในที่สุดความแม่นยำก็มาถึงแล้ว มีในระบบการท่องเว็บระดับไฮเอนด์บางระบบเพื่อให้ความแม่นยำในการจับเวลาดังกล่าวคุ้มค่าสำหรับแอปพลิเคชันเฉพาะบางประเภทที่ต้องการความแม่นยำสูงและแอปพลิเคชันสามารถตรวจสอบความเบี่ยงเบนความแม่นยำได้ด้วยตนเอง

เห็นได้ชัดว่าถ้าคุณทำหลายรอบคุณสามารถวิ่งได้หลายรอบ (เช่น 10 รอบ) จากนั้นหารด้วย 10 เพื่อให้ได้ความแม่นยำ 0.1 มิลลิวินาที นั่นเป็นวิธีการทั่วไปในการเพิ่มความแม่นยำ - ทำหลาย ๆ รอบแล้วหารเวลาทั้งหมดด้วยจำนวนรอบ

อย่างไรก็ตาม ... หากฉันสามารถทำการทดสอบเกณฑ์มาตรฐานได้เพียงครั้งเดียวเนื่องจากสถานการณ์ที่ผิดปกติฉันพบว่าฉันสามารถได้รับความแม่นยำ 0.1 (และบางครั้ง 0.01 มิลลิวินาที) โดยทำสิ่งนี้:

การเริ่มต้น / การสอบเทียบ:

1. รันการวนซ้ำที่ไม่ว่างเพื่อรอจนกว่าตัวจับเวลาจะเพิ่มขึ้นในอีกมิลลิวินาทีถัดไป (จัดตัวจับเวลาไปยังจุดเริ่มต้นของช่วงเวลามิลลิวินาทีถัดไป) การวนซ้ำที่ไม่ว่างนี้ใช้เวลาน้อยกว่ามิลลิวินาที
2. เรียกใช้การวนซ้ำที่ไม่ว่างเพื่อเพิ่มตัวนับในขณะที่รอให้ตัวจับเวลาเพิ่มขึ้น ตัวนับจะบอกให้คุณทราบจำนวนตัวนับที่เพิ่มขึ้นในหนึ่งมิลลิวินาที การวนซ้ำที่วุ่นวายนี้กินเวลาหนึ่งมิลลิวินาทีเต็ม
3. ทำซ้ำด้านบนจนกว่าตัวเลขจะเสถียรเป็นพิเศษ (เวลาในการโหลดคอมไพเลอร์ JIT ฯลฯ ) 4. หมายเหตุ: ความเสถียรของตัวเลขช่วยให้คุณมีความแม่นยำที่เป็นไปได้ในระบบที่ไม่ได้ใช้งาน คุณสามารถคำนวณความแปรปรวนได้หากคุณต้องการตรวจสอบความแม่นยำด้วยตนเอง ความแปรปรวนจะใหญ่กว่าในบางเบราว์เซอร์และเบราว์เซอร์อื่น ๆ จะมีขนาดเล็กกว่า ใหญ่กว่าในระบบที่เร็วกว่าและช้ากว่าในระบบที่ช้ากว่า ความสม่ำเสมอก็แตกต่างกันไป คุณสามารถบอกได้ว่าเบราว์เซอร์ใดมีความสอดคล้อง / แม่นยำมากกว่าเบราว์เซอร์อื่น ๆ ระบบที่ช้าลงและระบบที่วุ่นวายจะนำไปสู่ความแปรปรวนที่มากขึ้นระหว่างการเริ่มต้น สิ่งนี้สามารถเปิดโอกาสให้คุณแสดงข้อความเตือนหากเบราว์เซอร์ไม่ได้ให้ความแม่นยำเพียงพอที่จะอนุญาตให้วัด 0.1ms หรือ 0.01ms การเอียงของตัวตั้งเวลาอาจเป็นปัญหาได้ แต่ตัวจับเวลามิลลิวินาทีจำนวนเต็มในบางระบบจะเพิ่มขึ้นค่อนข้างแม่นยำ (ค่อนข้างถูกต้องบนจุด) ซึ่งจะส่งผลให้ค่าการปรับเทียบที่สอดคล้องกันมากซึ่งคุณสามารถเชื่อถือได้
4. บันทึกค่าตัวนับสุดท้าย (หรือค่าเฉลี่ยของการสอบเทียบสองสามครั้งล่าสุด)

การเปรียบเทียบหนึ่งรอบเพื่อความแม่นยำย่อยมิลลิวินาที:

1. เรียกใช้การวนซ้ำที่ไม่ว่างเพื่อรอจนกว่าตัวจับเวลาจะเพิ่มขึ้นในมิลลิวินาทีถัดไป การวนซ้ำที่วุ่นวายนี้ใช้เวลาน้อยกว่าหนึ่งมิลลิวินาที
2. ดำเนินงานที่คุณต้องการเพื่อเปรียบเทียบเวลาอย่างแม่นยำ
3. ตรวจสอบตัวจับเวลา สิ่งนี้ให้จำนวนเต็มมิลลิวินาที
4. เรียกใช้ลูปที่ไม่ว่างขั้นสุดท้ายเพื่อเพิ่มตัวนับในขณะที่รอให้ตัวจับเวลาเพิ่มขึ้น การวนซ้ำที่วุ่นวายนี้ใช้เวลาน้อยกว่าหนึ่งมิลลิวินาที
5. หารค่าตัวนับนี้ด้วยค่าตัวนับเดิมจากการเริ่มต้น
6. ตอนนี้คุณได้ส่วนทศนิยมของมิลลิวินาที !!!!!!!!

คำเตือน: ไม่แนะนำให้ใช้การวนซ้ำที่ไม่ว่างในเว็บเบราว์เซอร์ แต่โชคดีที่ลูปที่ไม่ว่างเหล่านี้จะทำงานน้อยกว่า 1 มิลลิวินาทีต่อครั้งและทำงานเพียงไม่กี่ครั้งเท่านั้น

ตัวแปรเช่นการคอมไพล์ JIT และความผันผวนของ CPU ทำให้เกิดความไม่ถูกต้องมหาศาล แต่ถ้าคุณเรียกใช้การกำหนดค่าเริ่มต้นหลายครั้งคุณจะมีการคอมไพล์ใหม่แบบไดนามิกเต็มรูปแบบและในที่สุดตัวนับจะตัดสินสิ่งที่ถูกต้องมาก ตรวจสอบให้แน่ใจว่าลูปที่ไม่ว่างทั้งหมดเป็นฟังก์ชันเดียวกันสำหรับทุกกรณีดังนั้นความแตกต่างของลูปที่ไม่ว่างจะไม่นำไปสู่ความแตกต่าง ตรวจสอบให้แน่ใจว่าโค้ดทั้งหมดถูกเรียกใช้งานหลาย ๆ ครั้งก่อนที่คุณจะเริ่มเชื่อถือผลลัพธ์เพื่อให้คอมไพเลอร์ JIT มีความเสถียรในการคอมไพล์แบบไดนามิกเต็มรูปแบบแล้ว (dynarec)

ในความเป็นจริงฉันได้เห็นความแม่นยำในระดับไมโครวินาทีในบางระบบ แต่ฉันก็ยังไม่วางใจ แต่ความแม่นยำ 0.1 มิลลิวินาทีดูเหมือนจะทำงานได้ค่อนข้างน่าเชื่อถือบนระบบ Quad-Core ที่ไม่ได้ใช้งานซึ่งฉันเป็นเพียงหน้าเบราว์เซอร์เท่านั้น ฉันมาถึงกรณีการทดสอบทางวิทยาศาสตร์ที่ฉันทำได้เพียงครั้งเดียว (เนื่องจากมีตัวแปรที่ไม่ซ้ำกันเกิดขึ้น) และจำเป็นต้องกำหนดเวลาแต่ละครั้งให้แม่นยำแทนที่จะหาค่าเฉลี่ยของการผ่านซ้ำหลายครั้งนั่นคือเหตุผลที่ฉันทำเช่นนี้

ฉันทำ pre-pass และ dummy pass หลายครั้ง (รวมถึงการปรับ dynarec) เพื่อตรวจสอบความน่าเชื่อถือของความแม่นยำ 0.1ms (นิ่งเป็นเวลาหลายวินาที) จากนั้นให้มือออกจากแป้นพิมพ์ / เมาส์ในขณะที่เกณฑ์มาตรฐานเกิดขึ้นจากนั้นก็ทำหลาย ๆ post-pass เพื่อตรวจสอบความน่าเชื่อถือของความแม่นยำ 0.1ms (คงที่อีกครั้ง) นอกจากนี้ยังช่วยยืนยันว่าสิ่งต่างๆเช่นการเปลี่ยนแปลงสถานะพลังงานหรือสิ่งอื่น ๆ ไม่ได้เกิดขึ้นระหว่างก่อนและหลังซึ่งขัดขวางผลลัพธ์ ทำซ้ำการทดสอบก่อนการทดสอบและการทดสอบหลังเรียนระหว่างการผ่านเกณฑ์มาตรฐานทุกครั้ง จากเรื่องนี้ฉันค่อนข้างมั่นใจว่าผลลัพธ์ในระหว่างนั้นถูกต้อง ไม่มีการรับประกันแน่นอน แต่แสดงให้เห็นว่าความแม่นยำ <0.1ms ที่แม่นยำนั้นเป็นไปได้ในบางกรณีในเว็บเบราว์เซอร์

วิธีนี้มีประโยชน์ในกรณีเฉพาะมากๆ เท่านั้น ถึงกระนั้นมันก็ไม่สามารถรับประกันได้อย่างไม่มีที่สิ้นสุด 100% คุณจะได้รับความแม่นยำที่น่าเชื่อถือและแม้แต่ความแม่นยำทางวิทยาศาสตร์เมื่อรวมกับการตรวจสอบภายในและภายนอกหลายชั้น

คำตอบคือ "ไม่" โดยทั่วไป หากคุณใช้ JavaScript ในสภาพแวดล้อมฝั่งเซิร์ฟเวอร์ (นั่นคือไม่ใช่ในเบราว์เซอร์) การเดิมพันทั้งหมดจะปิดลงและคุณสามารถลองทำอะไรก็ได้ที่คุณต้องการ

แก้ไข - คำตอบนี้เก่า มาตรฐานมีความก้าวหน้าและมีสิ่งอำนวยความสะดวกใหม่ ๆ เพื่อแก้ปัญหาเรื่องเวลาที่ถูกต้อง ถึงกระนั้นก็ควรจำไว้ว่านอกโดเมนของระบบปฏิบัติการแบบเรียลไทม์ที่แท้จริงรหัสที่ไม่ได้รับสิทธิพิเศษทั่วไปมีการควบคุมการเข้าถึงทรัพยากรการประมวลผลอย่าง จำกัด การวัดประสิทธิภาพไม่เหมือนกัน (จำเป็น) กับการทำนายประสิทธิภาพ

นี่คือตัวอย่างที่แสดงตัวจับเวลาความละเอียดสูงของฉันสำหรับnode.js :

 function startTimer() {
   const time = process.hrtime();
   return time;
 }

 function endTimer(time) {
   function roundTo(decimalPlaces, numberToRound) {
     return +(Math.round(numberToRound + `e+${decimalPlaces}`)  + `e-${decimalPlaces}`);
   }
   const diff = process.hrtime(time);
   const NS_PER_SEC = 1e9;
   const result = (diff[0] * NS_PER_SEC + diff[1]); // Result in Nanoseconds
   const elapsed = result * 0.0000010;
   return roundTo(6, elapsed); // Result in milliseconds
 }

การใช้งาน:

 const start = startTimer();

 console.log('test');

 console.log(`Time since start: ${endTimer(start)} ms`);

โดยปกติคุณอาจสามารถใช้:

 console.time('Time since start');

 console.log('test');

 console.timeEnd('Time since start');

หากคุณเป็นส่วนกำหนดเวลาของโค้ดที่เกี่ยวข้องกับการวนซ้ำคุณจะไม่สามารถเข้าถึงค่าของconsole.timeEnd()เพื่อเพิ่มผลการจับเวลาของคุณเข้าด้วยกัน คุณทำได้ แต่มันน่ารังเกียจเพราะคุณต้องฉีดค่าของตัวแปรการทำซ้ำของคุณเช่นiและตั้งเงื่อนไขเพื่อตรวจจับว่าลูปเสร็จสิ้นหรือไม่

นี่คือตัวอย่างเนื่องจากมีประโยชน์:

 const num = 10;

 console.time(`Time til ${num}`);

 for (let i = 0; i < num; i++) {
   console.log('test');
   if ((i+1) === num) { console.timeEnd(`Time til ${num}`); }
   console.log('...additional steps');
 }

อ้างอิง: https://nodejs.org/api/process.html#process_process_hrtime_time