วัดประสิทธิภาพของโค้ดและสร้างพื้นฐาน

  • 8 นาที

การวัดประสิทธิภาพของโค้ดและการสร้างพื้นฐานเป็นขั้นตอนสําคัญในกระบวนการเพิ่มประสิทธิภาพ มีจุดอ้างอิงเพื่อประเมินผลลัพธ์ของการเปลี่ยนแปลงใดๆ ที่คุณทํา

สร้างพื้นฐานประสิทธิภาพ

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

ต่อไปนี้คือประเด็นสําคัญบางประการที่ต้องวัดในบรรทัดฐาน:

  • เวลาดําเนินการ (เวลาแฝง): ใช้เวลานานเท่าใดในการดําเนินการหรือกระบวนการบางอย่าง ค่านี้สามารถวัดได้สําหรับฟังก์ชันขนาดเล็ก (ตัวอย่างเช่น ใช้เวลา 5 มิลลิวินาทีในการเรียงลําดับ 10,000 รายการ) หรือสถานการณ์แบบ end-to-end (ตัวอย่างเช่น บริการตอบสนองต่อคําขอใน 250 มิลลิวินาที)

  • ปริมาณงาน: สามารถดําเนินการได้กี่ครั้งในเวลาที่กําหนด? ค่านี้เกี่ยวข้องกับแอปพลิเคชันเซิร์ฟเวอร์ (คําขอต่อวินาที) การประมวลผลแบบแบตช์ (บันทึกที่ประมวลผลต่อนาที) เป็นต้น

  • การใช้ทรัพยากร: การใช้หน่วยความจํา (ชุดการทํางาน, การจัดสรร, ความถี่ในการเก็บขยะ), การใช้งาน CPU (ตรึงคอร์ที่ 100%หรือไม่? นานแค่ไหน?), ดิสก์ I/O, I/O เครือข่าย ฯลฯ ขึ้นอยู่กับสิ่งที่รหัสทํา

  • ลักษณะความสามารถในการปรับขนาด: เมตริกข้างต้นจะเปลี่ยนแปลงอย่างไรเมื่อขนาดอินพุตเพิ่มขึ้นหรือเมื่อโหลด (ผู้ใช้พร้อมกัน) เพิ่มขึ้น คุณอาจวัดว่าฟังก์ชันใช้เวลา 0.1 มิลลิวินาทีสําหรับ 100 รายการ และ 10 มิลลิวินาทีสําหรับ 10,000 รายการ นั่นบ่งชี้ว่ามันปรับขนาดอย่างไร (ในกรณีนี้ เป็นเส้นตรงโดยประมาณกับจํานวนรายการ) พื้นฐานประเภทนี้ช่วยให้คุณเข้าใจความสามารถในการปรับขนาดและกําหนดเป้าหมาย ตัวอย่างเช่น คุณอาจต้องการให้รายการ 100,000 รายการจัดเรียงภายใน 200 มิลลิวินาที ซึ่งอาจหมายความว่าคุณต้องการอัลกอริทึมที่มีประสิทธิภาพมากขึ้นหรือการเรียงลําดับแบบขนาน

เมื่อสร้างพื้นฐาน:

  • ทําให้สภาพแวดล้อมสอดคล้องกันมากที่สุด เรียกใช้การทดสอบบนเครื่องเดียวกันภายใต้สภาวะที่คล้ายคลึงกัน (ปิดโปรแกรมพื้นหลัง ใช้บิลด์รีลีส ฯลฯ) ประสิทธิภาพอาจแตกต่างกันไปในแต่ละครั้ง การลดเสียงรบกวนให้ข้อมูลที่เชื่อถือได้มากขึ้น

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

  • ทําให้การวัดเป็นแบบอัตโนมัติหรือเขียนสคริปต์ คุณควรเรียกใช้โค้ดของคุณหลายครั้ง การมีสายรัดเกณฑ์มาตรฐานอย่างง่ายหรือใช้เครื่องมือที่ทําให้เป็นอัตโนมัติจะช่วยได้ ตัวอย่างเช่น สําหรับฟังก์ชันขนาดเล็ก คุณอาจเขียนลูปที่เรียก วัดเวลา และคํานวณค่าเฉลี่ย

  • บันทึกตัวเลข เก็บบันทึกเมตริกพื้นฐาน (เวลา หน่วยความจํา ฯลฯ) หากคุณมีการทดสอบหน่วยหรือเอาต์พุตบันทึกที่พิมพ์ข้อมูลประสิทธิภาพ ให้บันทึกไว้ สําหรับกรณีที่ไม่สําคัญการใช้สเปรดชีตหรือตารางง่ายๆเพื่อเปรียบเทียบ "ก่อนกับหลัง" จะมีประโยชน์

การวัดพื้นฐานโดยใช้นาฬิกาจับเวลา

C# เสนอ System.Diagnostics.Stopwatch คลาสซึ่งมีประโยชน์สําหรับการวัดเวลาดําเนินการของบล็อกโค้ด

ตัวอย่างเช่น สมมติว่าคุณมีวิธีการต่อไปนี้ ProcessData() ที่คุณสงสัยว่าช้า:

var sw = Stopwatch.StartNew();
ProcessData();
sw.Stop();
Console.WriteLine($"ProcessData() completed in {sw.ElapsedMilliseconds} milliseconds");

ลองนึกภาพว่ารหัสนี้พิมพ์ค่าประมาณ 120 มิลลิวินาทีอย่างสม่ําเสมอ ค่าเฉลี่ยนั้นเป็นค่าพื้นฐานของคุณภายใต้ ProcessData() เงื่อนไขการทดสอบที่คุณใช้

พื้นฐานสําหรับการใช้หน่วยความจํา

วิธีการนี้เป็น GC.GetTotalMemory การเรียกเมธอด .NET ที่ดึงจํานวนหน่วยความจําปัจจุบันที่จัดสรรโดยตัวเก็บขยะ (GC) GetTotalMemoryวิธีนี้จะบันทึกสถานะการจัดสรรหน่วยความจําปัจจุบันเมื่อเรียกใช้

คุณสามารถบันทึกการใช้หน่วยความจําได้โดยการตรวจสอบ GC.GetTotalMemory(false) ก่อนและหลังการดําเนินการ

ตัวอย่างเช่น สมมติว่าคุณมีรหัสต่อไปนี้:

long memoryBefore = GC.GetTotalMemory(forceFullCollection: true);
ProcessData();
long memoryAfter = GC.GetTotalMemory(forceFullCollection: true);
Console.WriteLine($"Memory used by ProcessData(): {memoryAfter - memoryBefore} bytes");

ถ้ารหัสนี้พิมพ์ "หน่วยความจําที่ใช้โดย ProcessData(): 50,000 ไบต์" นั่นคือจํานวนหน่วยความจําที่การดําเนินการจัดสรร (สุทธิ) ค่านี้อาจเป็นส่วนหนึ่งของพื้นฐานของคุณ โดยเฉพาะอย่างยิ่งหากคุณกังวลเกี่ยวกับหน่วยความจําหรือค่าใช้จ่ายในการเก็บขยะ

พื้นฐานตามบริบท

เส้นฐานมักจะไม่ใช่ตัวเลขเดียว คุณอาจมีพื้นฐานในระดับหนึ่งแล้วทดสอบในระดับที่ใหญ่ขึ้น เช่น:

  • การเรียงลําดับรายการ 10,000 รายการใช้เวลา 50 มิลลิวินาที (พื้นฐานที่ 10,000)
  • การเรียงลําดับรายการ 100,000 รายการใช้เวลา 800 มิลลิวินาที

ผลลัพธ์นี้บ่งชี้ว่าประสิทธิภาพลดลงเมื่ออินพุตเพิ่มขึ้น ซึ่งคาดไว้ นอกจากนี้ยังชี้ให้เห็นว่าอัลกอริทึมอาจแย่กว่า O(n log n) เนื่องจากการเพิ่มรายการด้วยปัจจัย 10 ดูเหมือนจะเพิ่มเวลาด้วยปัจจัย 16 พื้นฐานประเภทนี้ช่วยให้คุณเข้าใจความสามารถในการปรับขนาดและกําหนดเป้าหมาย

เครื่องมือและเทคนิคการวัดประสิทธิภาพ

การทําความเข้าใจประสิทธิภาพต้องมีทั้งการวัดและการวิเคราะห์ลักษณะอัลกอริทึม ก่อนที่จะเจาะลึกเครื่องมือวัด สิ่งสําคัญคือต้องเข้าใจแนวคิดด้านประสิทธิภาพหลัก:

ทําความเข้าใจความซับซ้อนของอัลกอริทึม

ความซับซ้อนของเวลาอธิบายว่ารันไทม์ของอัลกอริทึมเติบโตอย่างไรเมื่อขนาดอินพุตเพิ่มขึ้น ซึ่งโดยทั่วไปจะแสดงโดยใช้สัญกรณ์ Big O:

  • O(1) - เวลาคงที่: ประสิทธิภาพไม่เปลี่ยนแปลงตามขนาดอินพุต (ตัวอย่างเช่น การค้นหาพจนานุกรม)
  • O(n) - เวลาเชิงเส้น: ประสิทธิภาพจะเพิ่มขึ้นตามสัดส่วนตามอินพุต (เช่น การวนซ้ํารายการหนึ่งครั้ง)
  • O(n²) - เวลากําลังสอง: ประสิทธิภาพเพิ่มขึ้นตามกําลังสองของขนาดอินพุต (ตัวอย่างเช่น ลูปที่ซ้อนกัน)
  • O(log n) - เวลาลอการิทึม: ประสิทธิภาพจะเติบโตอย่างช้าๆ เมื่ออินพุตเพิ่มขึ้น (เช่น การค้นหาไบนารี)

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

การรับรู้รูปแบบประสิทธิภาพและรูปแบบการต่อต้าน

รูปแบบต่อต้านประสิทธิภาพทั่วไป ได้แก่ :

  • ปัญหาคิวรี N+1: สร้างคิวรีหนึ่งรายการเพื่อรับรายการ จากนั้นคิวรีเพิ่มเติม N สําหรับข้อมูลที่เกี่ยวข้อง
  • โครงสร้างข้อมูลที่ไม่มีประสิทธิภาพ: การใช้รายการสําหรับการค้นหาบ่อยครั้งแทนพจนานุกรมหรือชุดแฮช
  • การต่อสตริงก่อนเวลาอันควร: การสร้างสตริงขนาดใหญ่โดยใช้+=แทนStringBuilder
  • การดําเนินการแบบซิงโครนัส: การบล็อกเธรดที่มี I/O แบบซิงโครนัสเมื่อการดําเนินการแบบอะซิงโครนัสจะดีกว่า

กลยุทธ์การแคช สามารถปรับปรุงประสิทธิภาพได้อย่างมาก โดยการจัดเก็บข้อมูลที่เข้าถึงบ่อยในหน่วยความจํา เพื่อหลีกเลี่ยงการคํานวณใหม่หรือการดําเนินการ I/O ที่มีราคาแพง

จากที่เรียบง่ายไปจนถึงซับซ้อนต่อไปนี้เป็นเครื่องมือและวิธีการวัดประสิทธิภาพ:

การจับเวลาแบบแมนนวลด้วยนาฬิกาจับเวลา

เครื่องมือวัดโค้ดด้วยตนเองด้วย Stopwatch หรือแม้แต่ DateTime.UtcNow ความแตกต่างสามารถให้ข้อมูลเชิงลึกได้อย่างรวดเร็ว แนวทางนี้เป็นแบบเฉพาะกิจ แต่สามารถเข้าถึงได้และมักจะเพียงพอสําหรับการสืบสวนครั้งแรก คุณสามารถโรยบันทึกเวลารอบๆ ส่วนของโค้ด (ตัวอย่างเช่น บันทึกระยะเวลาในการสืบค้นฐานข้อมูล ระยะเวลาในการแยกวิเคราะห์ไฟล์ ฯลฯ)

การบันทึกและตัวนับ

การบันทึกเป็นแบบเฉพาะกิจ แต่สามารถเข้าถึงได้และมักจะเพียงพอสําหรับการตรวจสอบครั้งแรก คุณสามารถโรยบันทึกเวลารอบๆ ส่วนของโค้ด (ตัวอย่างเช่น บันทึกระยะเวลาในการสืบค้นฐานข้อมูล ระยะเวลาในการแยกวิเคราะห์ไฟล์ ฯลฯ)

การบันทึกเหตุการณ์และตัวชี้วัดประสิทธิภาพ

การเพิ่มการบันทึกเชิงกลยุทธ์สามารถเปิดเผยรูปแบบประสิทธิภาพและช่วยระบุปัญหาคอขวด:

  • จํานวนการดําเนินการ: บันทึกจํานวนรายการที่ประมวลผล การสืบค้นฐานข้อมูลที่ดําเนินการ หรือการเข้าชม/พลาดของแคชที่เกิดขึ้น
  • การแจกแจงเวลา: วัดขั้นตอนต่างๆ ของการดําเนินการ (ตัวอย่างเช่น "การสืบค้นฐานข้อมูล: 50 มิลลิวินาที, การประมวลผล: 20 มิลลิวินาที, การทําให้เป็นอนุกรม: 10 มิลลิวินาที")
  • การใช้ทรัพยากร: ติดตามการจัดสรรหน่วยความจํา การใช้พูลเธรด หรือเมตริกพูลการเชื่อมต่อ
  • ตัวชี้วัดประสิทธิภาพ: ตรวจสอบเวลาแฝง (เวลาตอบสนอง) ปริมาณงาน (การดําเนินการต่อวินาที) และลักษณะความสามารถในการปรับขนาด

ตัวอย่างเช่น ถ้าบันทึกของคุณแสดง "ดึงข้อมูล 1000 ระเบียนจากฐานข้อมูล" เมื่อคุณคาดว่าจะเห็นระเบียน 100 ระเบียน ความคลาดเคลื่อนอาจบ่งบอกถึงปัญหาการสืบค้น N+1 หรือตรรกะแบบสอบถามที่ไม่มีประสิทธิภาพ ในทํานองเดียวกัน การบันทึกอัตราการเข้าชมแคชสามารถช่วยประเมินประสิทธิภาพของกลยุทธ์การแคชได้

ตัวสร้างโปรไฟล์ในตัว (การวินิจฉัย Visual Studio)

Visual Studio (รุ่น Enterprise และในระดับหนึ่ง Community) มีเครื่องมือสร้างโปรไฟล์ (การใช้งาน CPU, การใช้หน่วยความจํา, ตัวสร้างโปรไฟล์ประสิทธิภาพ) คุณสามารถเรียกใช้แอปพลิเคชันของคุณภายใต้ตัวสร้างโปรไฟล์ และจะแสดงรายละเอียดของเวลา CPU ตามฟังก์ชัน หรือรายการอ็อบเจ็กต์บนฮีปและผู้ที่จัดสรร

  • โดยทั่วไปแล้วตัวสร้างโปรไฟล์ CPU จะสร้างแผนผังการเรียก ซึ่งคุณสามารถดูได้ว่าวิธีการใดใช้เวลา CPU มากที่สุด
  • ตัวสร้างโปรไฟล์หน่วยความจําสามารถถ่ายภาพสแนปช็อตเพื่อแสดงให้เห็นว่าการใช้หน่วยความจําเพิ่มขึ้นอย่างไร และวัตถุประเภทใดที่ใช้พื้นที่

การใช้ตัวสร้างโปรไฟล์มักจะทําได้ง่ายเพียงแค่คลิก "เริ่มการวินิจฉัย" และเลือกประเภทของโปรไฟล์

เครื่องมือ .NET CLI

สําหรับ .NET Core และ .NET 5+ Microsoft มีเครื่องมือบรรทัดคําสั่ง เช่น dotnet-counters, dotnet-trace, , dotnet-dump. dotnet-gcdump

  • dotnet-counters สามารถแสดงเมตริกประสิทธิภาพแบบเรียลไทม์ของแอปที่กําลังทํางานอยู่ (คอลเลกชัน GC ข้อยกเว้น การใช้พูลเธรด ฯลฯ)
  • dotnet-trace สามารถรวบรวมร่องรอยการดําเนินการของแอป ซึ่งสามารถวิเคราะห์เพื่อดูว่าเมธอดใดกําลังทํางานอยู่

เครื่องมือเหล่านี้ล้ําหน้ากว่า แต่มีค่ามากสําหรับการเจาะลึกหรือการสร้างโปรไฟล์การผลิตที่คุณไม่สามารถแนบ GUI profiler ได้

ไลบรารีไมโครเบนช์มาร์ค

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

การทดสอบประสิทธิภาพ/โหลด

สําหรับสถานการณ์ขนาดใหญ่ (เว็บแอปพลิเคชัน บริการ) คุณอาจเขียนการทดสอบโหลดหรือใช้เครื่องมือ (เช่น JMeter, k6 หรือ Visual Studio load test) เพื่อจําลองคําขอจํานวนมากหรืออินพุตขนาดใหญ่ วิธีการนี้สามารถเปิดเผยปริมาณงานและความเสถียรภายใต้ความเครียด และช่วยระบุปัญหาคอขวดที่ปรากฏในวงกว้างเท่านั้น

การตรวจสอบระบบ

ตรวจสอบพฤติกรรมโดยรวมของระบบเพื่อระบุปัญหาคอขวดของทรัพยากรและปัญหาความสามารถในการปรับขนาด:

  • รูปแบบการใช้งาน CPU: การใช้งาน CPU ที่สูงอาจบ่งบอกถึงความไร้ประสิทธิภาพของอัลกอริทึมหรือปัญหาคอขวดในการคํานวณ
  • การใช้หน่วยความจํา: การใช้หน่วยความจําที่เพิ่มขึ้นอาจบ่งบอกถึงการรั่วไหลของหน่วยความจํา โครงสร้างข้อมูลที่ไม่มีประสิทธิภาพ หรือการจัดสรรวัตถุมากเกินไป
  • เมตริก I/O: ดิสก์หรือเครือข่าย I/O สูงอาจบ่งบอกถึงรูปแบบการเข้าถึงข้อมูลที่ไม่มีประสิทธิภาพหรือการแคชที่ไม่ดี
  • การเก็บขยะ: การเก็บขยะบ่อยครั้งอาจส่งผลต่อประสิทธิภาพการทํางาน โดยเฉพาะอย่างยิ่งในการใช้งานที่มีปริมาณงานสูง

เครื่องมือเช่น ตัวจัดการ dotnet-countersงาน หรือ PerfMon บน Windows สามารถให้ข้อมูลเชิงลึกระดับระบบได้ การทําความเข้าใจเมตริกเหล่านี้จะช่วยเชื่อมโยงประสิทธิภาพระดับโค้ดกับการใช้ทรัพยากรระบบ

ตรวจสอบการปรับปรุงและหลีกเลี่ยงการถดถอย

หลังจากสร้างพื้นฐานแล้ว คุณสามารถเริ่มใช้การปรับปรุงโค้ดได้ การปรับปรุงโค้ดควรทําในวงจรของการอัปเดตโค้ดตามด้วยการวัดเพื่อดูว่าการเปลี่ยนแปลงมีผลตามที่ต้องการหรือไม่

เมื่อคุณทําการเปลี่ยนแปลง ให้วัดใหม่โดยใช้วิธีเดียวกับค่าพื้นฐานของคุณเสมอ เปรียบเทียบการวัดใหม่กับค่าพื้นฐาน

ต่อไปนี้เป็นแนวทางที่แนะนําสําหรับกระบวนการนี้:

  • เปลี่ยนทีละสิ่ง (ถ้าเป็นไปได้): ดังนั้นคุณจึงรู้ว่าอะไรทําให้เกิดการปรับปรุงหรือการถดถอย

  • เรียกใช้การทดสอบ/การวัดเดียวกันกับข้อมูลพื้นฐาน: ใช้ขั้นตอนเดียวกันและเปรียบเทียบเมตริกโดยตรง

  • หากการปรับปรุงสําเร็จ: เยี่ยมมากพิจารณาว่าตรงตามเป้าหมายหรือไม่ หากคุณต้องการเร่งความเร็ว 2 เท่าและคุณได้รับ 1.5 เท่า คุณอาจทําซ้ําเพิ่มเติม

  • หากไม่มีการปรับปรุงหรือประสิทธิภาพแย่ลง: ตรวจสอบว่าทําไม อาจเป็นเพราะการเปลี่ยนแปลงของคุณไม่ได้จัดการกับคอขวดที่แท้จริงหรือแลกเปลี่ยนต้นทุนหนึ่งกับอีกต้นทุนหนึ่ง

  • ตรวจสอบผลข้างเคียง: ผลข้างเคียงอาจรวมถึงความถูกต้องที่ไม่คาดคิดหรือปัญหาด้านประสิทธิภาพ ตัวอย่างเช่น คุณอาจเพิ่มประสิทธิภาพของ CPU แต่เห็นการใช้หน่วยความจําเพิ่มขึ้นอย่างมาก ผลข้างเคียงนั้นเป็นที่ยอมรับหรือไม่?

  • การตรวจจับการถดถอยอัตโนมัติ: การเขียนการทดสอบหน่วยประสิทธิภาพหรือเกณฑ์มาตรฐานที่ทํางานก่อนและหลังการเปลี่ยนแปลงเป็นเทคนิคทั่วไปสําหรับการตรวจหาการถดถอย แม้ว่าจะไม่ใช่ทุกทีมที่เขียนการทดสอบประสิทธิภาพ แต่ก็ไม่ใช่ความคิดที่ดีที่จะมีชุดการทดสอบประสิทธิภาพขนาดเล็ก (โดยเฉพาะอย่างยิ่งสําหรับเส้นทางวิกฤต) เพื่อให้แน่ใจว่าการเปลี่ยนแปลงใหม่จะไม่ทําให้สิ่งต่างๆ ช้าลงอย่างมาก

ใช้ GitHub Copilot เพื่อช่วยในการวัด

GitHub Copilot สามารถช่วยคุณตั้งค่าเทคนิคการวัดประสิทธิภาพ:

  • ขอตัวอย่างเวลา: "ฉันจะวัดเวลาดําเนินการของวิธี C# ได้อย่างไร" GitHub Copilot สามารถแนะนํา Stopwatch ด้วยโค้ดตัวอย่าง
  • รับคําแนะนําเกี่ยวกับโปรไฟล์: "ฉันสามารถใช้เครื่องมือใดในการทําโปรไฟล์แอปพลิเคชัน .NET ได้บ้าง" GitHub Copilot สามารถแสดงรายการเครื่องมือสร้างโปรไฟล์และกรณีการใช้งานได้
  • สร้างรหัสเกณฑ์มาตรฐาน: GitHub Copilot สามารถช่วยสร้างคลาส BenchmarkDotNet หรือสายรัดการวัดอื่นๆ

GitHub Copilot ทําหน้าที่เป็นข้อมูลอ้างอิงอย่างรวดเร็วสําหรับการใช้เทคนิคการวัดอย่างถูกต้อง

Summary

การวัดประสิทธิภาพของโค้ดและการสร้างพื้นฐานเป็นขั้นตอนสําคัญในกระบวนการเพิ่มประสิทธิภาพ ด้วยการบันทึกเวลาดําเนินการ การใช้ทรัพยากร และลักษณะความสามารถในการปรับขนาดอย่างเป็นระบบ คุณจะสร้างจุดอ้างอิงเพื่อประเมินผลกระทบของการเปลี่ยนแปลงของคุณ การใช้เทคนิคการวัดที่หลากหลาย ตั้งแต่การจับเวลาอย่างง่ายไปจนถึง Stopwatch เครื่องมือสร้างโปรไฟล์ขั้นสูง ช่วยให้คุณสามารถระบุปัญหาคอขวดได้อย่างแม่นยํา ตรวจสอบให้แน่ใจเสมอว่าการปรับปรุงประสิทธิภาพไม่กระทบต่อความถูกต้องหรือทําให้เกิดปัญหาใหม่ ด้วยวิธีการที่มีระเบียบวินัยในการวัดและการทําซ้ํา คุณสามารถปรับปรุงประสิทธิภาพของโค้ดได้อย่างมีประสิทธิภาพในขณะที่ยังคงรักษาความสมบูรณ์ไว้