ฉันจะเขียน micro-benchmark ที่ถูกต้องใน Java ได้อย่างไร

คุณเขียน (และรัน) เกณฑ์มาตรฐานขนาดเล็กที่ถูกต้องใน Java ได้อย่างไร

ฉันกำลังมองหาตัวอย่างโค้ดและความคิดเห็นที่แสดงถึงสิ่งต่าง ๆ ที่ควรพิจารณา

ตัวอย่าง: เกณฑ์มาตรฐานควรวัดเวลา / การวนซ้ำหรือการวนซ้ำ / เวลาและทำไม?

ที่เกี่ยวข้อง: การเปรียบเทียบเกณฑ์มาตรฐานของนาฬิกาจับเวลายอมรับได้หรือไม่

เคล็ดลับเกี่ยวกับการเขียนมาตรฐานขนาดเล็กจากผู้สร้าง Java HotSpot :

กฎที่ 0:อ่านกระดาษที่มีชื่อเสียงบน JVMs และการวัดระดับไมโคร หนึ่งที่ดีคือไบรอันเก๊ 2005 อย่าคาดหวังมากเกินไปจากการวัดแบบไมโคร พวกเขาวัดเฉพาะช่วงประสิทธิภาพการทำงานของ JVM ที่ จำกัด

กฎที่ 1:รวมขั้นตอนการอุ่นเครื่องที่รันเคอร์เนลทดสอบของคุณตลอดทางเสมอเพียงพอที่จะทริกเกอร์การเริ่มต้นและการรวบรวมทั้งหมดก่อนช่วงเวลา (การวนซ้ำน้อยลงก็โอเคในช่วงวอร์มอัพกฎของหัวแม่มือคือการวนซ้ำภายในหลายหมื่นครั้ง)

กฎข้อที่ 2:เรียกใช้เสมอกับ-XX:+PrintCompilation, -verbose:gcฯลฯ เพื่อให้คุณสามารถตรวจสอบว่าคอมไพเลอร์และส่วนอื่น ๆ ของ JVM ยังไม่ได้ทำผลงานที่ไม่คาดคิดในช่วงระยะเวลาของคุณ

กฎข้อที่ 2.1:พิมพ์ข้อความที่จุดเริ่มต้นและจุดสิ้นสุดของการกำหนดเวลาและการอุ่นเครื่องเพื่อให้คุณสามารถตรวจสอบว่าไม่มีผลลัพธ์จากกฎ 2 ในช่วงระยะเวลา

กฎข้อที่ 3:ระวังความแตกต่างระหว่าง-clientและ-server, และ OSR และการคอมไพล์ปกติ -XX:+PrintCompilationธงรายงานรวบรวม OSR Trouble$1::run @ 2 (41 bytes)กับที่เข้าสู่ระบบเพื่อแสดงถึงจุดเริ่มต้นที่ไม่ได้เริ่มต้นตัวอย่างเช่น: ต้องการเซิร์ฟเวอร์ไปยังไคลเอนต์และ OSR ปกติหากคุณอยู่หลังประสิทธิภาพที่ดีที่สุด

กฎข้อที่ 4:ระวังผลกระทบการเริ่มต้น อย่าพิมพ์เป็นครั้งแรกในระหว่างช่วงเวลาของคุณเนื่องจากโหลดการพิมพ์และเริ่มต้นคลาส อย่าโหลดคลาสใหม่นอกระยะ warmup (หรือเฟสการรายงานขั้นสุดท้าย) เว้นแต่คุณจะทำการทดสอบคลาสที่โหลดโดยเฉพาะ (และในกรณีนั้นจะโหลดเฉพาะคลาสทดสอบเท่านั้น) กฎข้อที่ 2 เป็นบรรทัดแรกของการป้องกันผลกระทบดังกล่าว

กฎข้อที่ 5:ระวังการ deoptimization และการคอมไพล์ซ้ำ อย่าใช้โค้ดพา ธ ใด ๆ เป็นครั้งแรกในช่วงเวลาเนื่องจากคอมไพเลอร์อาจขยะและคอมไพล์โค้ดใหม่ตามข้อสันนิษฐานในแง่ดีก่อนหน้านี้ว่าพา ธ นั้นจะไม่ถูกใช้เลย กฎข้อที่ 2 เป็นบรรทัดแรกของการป้องกันผลกระทบดังกล่าว

กฎข้อที่ 6:ใช้เครื่องมือที่เหมาะสมเพื่ออ่านใจของคอมไพเลอร์และคาดว่าจะประหลาดใจกับโค้ดที่สร้างขึ้น ตรวจสอบโค้ดด้วยตัวเองก่อนสร้างทฤษฎีเกี่ยวกับสิ่งที่ทำให้บางอย่างเร็วขึ้นหรือช้าลง

กฎข้อที่ 7:ลดเสียงรบกวนในการวัดของคุณ รันเกณฑ์มาตรฐานของคุณบนเครื่องที่เงียบและรันหลายครั้งโดยทิ้งค่าผิดปกติ ใช้-Xbatchเพื่อคอมไพเลอร์ซีเรียล-XX:CICompilerCount=1ไลซ์เซชั่นกับแอพพลิเคชั่นและพิจารณาการตั้งค่าเพื่อป้องกันคอมไพเลอร์ไม่ให้ทำงานควบคู่กันไป พยายามอย่างดีที่สุดเพื่อลดค่าใช้จ่าย GC, ตั้งค่าXmx(ใหญ่พอ) เท่ากับXmsและใช้UseEpsilonGCหากมี

กฎข้อที่ 8:ใช้ไลบรารีสำหรับการวัดประสิทธิภาพของคุณเนื่องจากอาจมีประสิทธิภาพมากกว่าและดีบั๊กสำหรับวัตถุประสงค์นี้เพียงอย่างเดียวแล้ว เช่นJMH , คาลิปเปอร์หรือบิลและพอล UCSD มาตรฐานที่ดีเยี่ยมสำหรับ Java

ฉันรู้ว่าคำถามนี้ได้รับการทำเครื่องหมายว่าตอบแล้ว แต่ฉันต้องการพูดถึงห้องสมุดสองแห่งที่ช่วยให้เราเขียนเกณฑ์มาตรฐานขนาดเล็ก

Caliper จาก Google

แบบฝึกหัดเริ่มต้น

1. http://codingjunkie.net/micro-benchmarking-with-caliper/
2. http://vertexlabs.co.uk/blog/caliper

JMH จาก OpenJDK

แบบฝึกหัดเริ่มต้น

1. หลีกเลี่ยงการเปรียบเทียบกับ JVM
2. http://nitschinger.at/Using-JMH-for-Java-Microbenchmarking
3. http://java-performance.info/jmh/

สิ่งสำคัญสำหรับการเปรียบเทียบ Java คือ:

• อุ่นเครื่อง JIT ครั้งแรกโดยใช้รหัสหลายครั้งก่อนที่เวลามัน
• ตรวจสอบให้แน่ใจว่าคุณรันนานพอที่จะสามารถวัดผลลัพธ์ในหน่วยวินาทีหรือ (ดีกว่า) นับสิบวินาที
• ในขณะที่คุณไม่สามารถโทรSystem.gc()ระหว่างการทำซ้ำได้เป็นความคิดที่ดีที่จะเรียกใช้ระหว่างการทดสอบเพื่อให้การทดสอบแต่ละครั้งหวังว่าจะได้พื้นที่หน่วยความจำที่ "สะอาด" เพื่อใช้งาน (ใช่gc()เป็นคำใบ้มากกว่าการรับประกัน แต่มีโอกาสมากที่มันจะเก็บขยะในประสบการณ์ของฉัน)
• ฉันชอบที่จะแสดงการทำซ้ำและเวลาและคะแนนของเวลา / การทำซ้ำซึ่งสามารถปรับสัดส่วนเพื่อให้อัลกอริทึม "ดีที่สุด" ได้รับคะแนน 1.0 และอื่น ๆ ได้คะแนนในแบบที่สัมพันธ์กัน ซึ่งหมายความว่าคุณสามารถเรียกใช้อัลกอริธึมทั้งหมดเป็นเวลานานโดยเปลี่ยนแปลงทั้งจำนวนการวนซ้ำและเวลา แต่ยังคงได้รับผลลัพธ์ที่เปรียบเทียบกันได้

ฉันแค่อยู่ในขั้นตอนการเขียนบล็อกเกี่ยวกับการออกแบบเฟรมเวิร์กการเปรียบเทียบใน. NET ฉันมีคู่ของโพสต์ก่อนหน้านี้ซึ่งอาจจะสามารถที่จะทำให้คุณมีความคิดบางอย่าง - ไม่ได้ทุกอย่างจะมีความเหมาะสมของหลักสูตร แต่บางส่วนของมันอาจจะเป็น

jmhเป็นส่วนเสริมล่าสุดของ OpenJDK และเขียนโดยวิศวกรด้านประสิทธิภาพจาก Oracle ดูคุ้มค่าแน่นอน

jmh เป็นชุดควบคุม Java สำหรับการสร้างการทำงานและการวิเคราะห์เกณฑ์มาตรฐานนาโน / ไมโคร / มาโครที่เขียนด้วยภาษาจาวาและภาษาอื่น ๆ ที่กำหนดเป้าหมาย JVM

ชิ้นที่น่าสนใจมากของข้อมูลที่ฝังอยู่ในความคิดเห็นทดสอบตัวอย่าง

ดูสิ่งนี้ด้วย:

• หลีกเลี่ยงการเปรียบเทียบกับ JVM
• การหารือเกี่ยวกับจุดแข็งหลักของ JMH

มาตรฐานควรวัดเวลา / การทำซ้ำหรือการทำซ้ำ / เวลาและทำไม?

ขึ้นอยู่กับสิ่งที่คุณพยายามทดสอบ

หากคุณสนใจเวลาแฝงให้ใช้เวลา / การวนซ้ำและหากคุณสนใจปริมาณงานให้ใช้การทำซ้ำ / เวลา

หากคุณพยายามเปรียบเทียบอัลกอริธึมสองอย่างให้ทำอย่างน้อยสองมาตรฐานสำหรับแต่ละวิธีการสลับลำดับ เช่น:

for(i=1..n)
  alg1();
for(i=1..n)
  alg2();
for(i=1..n)
  alg2();
for(i=1..n)
  alg1();

ฉันพบความแตกต่างที่เห็นได้ชัดเจน (บางครั้ง 5-10%) ในรันไทม์ของอัลกอริทึมเดียวกันในรอบที่แตกต่างกัน ..

ตรวจสอบให้แน่ใจว่าnมีขนาดใหญ่มากดังนั้นเวลารันไทม์ของแต่ละลูปจะน้อยกว่า 10 วินาทีเป็นอย่างน้อย ยิ่งมีการวนซ้ำมากเท่าไรตัวเลขที่สำคัญยิ่งขึ้นในเวลามาตรฐานของคุณและความน่าเชื่อถือของข้อมูลก็จะยิ่งมากขึ้นเท่านั้น

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

มีข้อผิดพลาดที่เป็นไปได้มากมายสำหรับการเขียนไมโครมาตรฐานใน Java

ขั้นแรก: คุณต้องคำนวณด้วยเหตุการณ์ทุกประเภทที่ต้องใช้เวลามากขึ้นหรือน้อยลงในการสุ่ม: การรวบรวมขยะผลการแคช (ของระบบปฏิบัติการสำหรับไฟล์และ CPU สำหรับหน่วยความจำ), IO เป็นต้น

ที่สอง: คุณไม่สามารถเชื่อถือความแม่นยำของเวลาที่วัดได้ในช่วงเวลาสั้น ๆ

ประการที่สาม: JVM ปรับโค้ดของคุณให้เหมาะสมขณะดำเนินการ ดังนั้นการรันที่ต่างกันในอินสแตนซ์ JVM เดียวกันจะกลายเป็นเร็วขึ้นและเร็วขึ้น

คำแนะนำของฉัน: ทำให้การวัดประสิทธิภาพของคุณทำงานได้ในไม่กี่วินาทีซึ่งมีความน่าเชื่อถือมากกว่ารันไทม์มากกว่ามิลลิวินาที อุ่นเครื่อง JVM (หมายถึงการรันเกณฑ์มาตรฐานอย่างน้อยหนึ่งครั้งโดยไม่มีการวัดว่า JVM สามารถรันการปรับให้เหมาะสม) และเรียกใช้เกณฑ์มาตรฐานของคุณหลายครั้ง (อาจจะ 5 ครั้ง) และรับค่ามัธยฐาน รัน micro-benchmark ทุกตัวใน JVM-instance ใหม่ (เรียกใช้ Java มาตรฐานใหม่ทุกครั้ง) มิฉะนั้นเอฟเฟกต์การเพิ่มประสิทธิภาพของ JVM จะส่งผลต่อการทดสอบในภายหลัง อย่าดำเนินการสิ่งต่าง ๆ ที่ไม่ได้ดำเนินการใน warmup-phase (เพราะอาจทำให้คลาสโหลดและการคอมไพล์ซ้ำได้)

ควรสังเกตว่ามันอาจเป็นสิ่งสำคัญในการวิเคราะห์ผลลัพธ์ของการวัดขนาดเล็กเมื่อเปรียบเทียบการใช้งานที่แตกต่างกัน ดังนั้นควรทำการทดสอบที่สำคัญ

เพราะนี่คือการดำเนินการอาจจะได้เร็วขึ้นมากที่สุดในช่วงของการทำงานของมาตรฐานกว่าการดำเนินการA Bแต่Aอาจมีการแพร่กระจายสูงขึ้นเพื่อให้ได้รับประโยชน์จากการวัดของจะไม่เป็นอย่างมีนัยสำคัญเมื่อเทียบกับAB

ดังนั้นจึงเป็นสิ่งสำคัญที่จะต้องเขียนและเรียกใช้เกณฑ์มาตรฐานขนาดเล็กอย่างถูกต้อง แต่เพื่อวิเคราะห์อย่างถูกต้อง

เพื่อเพิ่มคำแนะนำที่ยอดเยี่ยมอื่น ๆ ฉันยังต้องคำนึงถึงสิ่งต่อไปนี้:

สำหรับซีพียูบางตัว (เช่นช่วง Intel Core i5 กับ TurboBoost) อุณหภูมิ (และจำนวนคอร์ที่ใช้งานในปัจจุบันรวมถึงเปอร์เซ็นต์การใช้งาน) จะส่งผลต่อความเร็วสัญญาณนาฬิกา เนื่องจาก CPU มีการโอเวอร์คล็อกแบบไดนามิกสิ่งนี้อาจส่งผลต่อผลลัพธ์ของคุณ ตัวอย่างเช่นหากคุณมีแอปพลิเคชันแบบเธรดเดียวความเร็วสัญญาณนาฬิกาสูงสุด (ด้วย TurboBoost) จะสูงกว่าสำหรับแอปพลิเคชันที่ใช้คอร์ทั้งหมด สิ่งนี้อาจรบกวนการเปรียบเทียบประสิทธิภาพแบบซิงเกิลและแบบมัลติเธรดในบางระบบ โปรดจำไว้ว่าอุณหภูมิและแรงดันยังมีผลต่อระยะเวลาในการรักษาความถี่เทอร์โบ

อาจเป็นสิ่งสำคัญพื้นฐานที่คุณสามารถควบคุมได้โดยตรง: ตรวจสอบให้แน่ใจว่าคุณกำลังวัดสิ่งที่ถูกต้อง! ตัวอย่างเช่นหากคุณกำลังใช้System.nanoTime()เกณฑ์มาตรฐานของรหัสเฉพาะให้โทรไปที่การมอบหมายในสถานที่ที่เหมาะสมเพื่อหลีกเลี่ยงการวัดสิ่งที่คุณไม่สนใจตัวอย่างเช่นอย่าทำ:

long startTime = System.nanoTime();
//code here...
System.out.println("Code took "+(System.nanoTime()-startTime)+"nano seconds");

ปัญหาคือคุณไม่ได้รับเวลาสิ้นสุดทันทีเมื่อรหัสเสร็จสิ้น ให้ลองทำสิ่งต่อไปนี้แทน:

final long endTime, startTime = System.nanoTime();
//code here...
endTime = System.nanoTime();
System.out.println("Code took "+(endTime-startTime)+"nano seconds");

http://opt.sourceforge.net/ Java Micro Benchmark - งานควบคุมที่จำเป็นในการกำหนดลักษณะการเปรียบเทียบประสิทธิภาพของระบบคอมพิวเตอร์บนแพลตฟอร์มที่แตกต่างกัน สามารถใช้เพื่อเป็นแนวทางในการตัดสินใจปรับให้เหมาะสมและเพื่อเปรียบเทียบการใช้งาน Java ที่แตกต่างกัน