การวิเคราะห์อัลกอริทึมโดยการนับฟลอพล้าสมัยหรือไม่

ในหลักสูตรการวิเคราะห์เชิงตัวเลขของฉันฉันเรียนรู้ที่จะวิเคราะห์ประสิทธิภาพของอัลกอริทึมโดยการนับจำนวนของการดำเนินการจุดลอยตัว (flops) ที่พวกเขาต้องการเทียบกับขนาดของปัญหา ตัวอย่างเช่นในข้อความของ Trefethen & Bau ใน Numerical Linear Algebra มีแม้กระทั่งรูปภาพที่ดูแบบ 3 มิติของจำนวนฟล็อป

ตอนนี้มันเป็นแฟชั่นที่จะกล่าวว่า "flops ฟรี" เพราะเวลาแฝงของหน่วยความจำในการดึงข้อมูลใด ๆ ที่ไม่ได้อยู่ในแคชนั้นยิ่งใหญ่กว่าค่าใช้จ่ายของ flop แต่เรายังสอนนักเรียนให้นับจำนวนอย่างน้อยในหลักสูตรการวิเคราะห์เชิงตัวเลข เราควรสอนพวกเขาให้นับการเข้าถึงหน่วยความจำแทนหรือไม่ เราจำเป็นต้องเขียนตำราใหม่หรือไม่ หรือการเข้าถึงหน่วยความจำเฉพาะเกินไปที่จะใช้เวลากับเครื่อง? แนวโน้มระยะยาวจะเป็นอย่างไรในแง่ของการไม่ว่าจะเป็น flops หรือการเข้าถึงหน่วยความจำเป็นคอขวด?

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

$\beta$$F_{\mathrm{max}}$$B_{\mathrm{max}}$$\frac{F_{\mathrm{max}}}{\beta} > B_{\mathrm{max}}$$B_{\mathrm{max}}\beta > F_{\mathrm{max}}$

ฉันคิดว่าการนับการเข้าถึงหน่วยความจำเป็นสิ่งจำเป็น แต่เราควรคำนึงถึง:

• จำเป็นต้องใช้หน่วยความจำท้องถิ่นเท่าใด

• เราเห็นพ้องด้วยกันได้มากแค่ไหน

จากนั้นคุณสามารถเริ่มวิเคราะห์อัลกอริทึมสำหรับฮาร์ดแวร์ที่ทันสมัย

$O(N^4)$$O(N)$$O(N \log N)$$O(N^2)$

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

แน่นอนว่าคำตอบนั้นขึ้นอยู่กับว่าคอขวดเป็นซีพียูหรือแบนด์วิดธ์ของหน่วยความจำ สำหรับอัลกอริทึมจำนวนมากที่ทำงานกับชุดข้อมูลขนาดใดก็ได้ตามปกติคอขวดมักเป็นแบนด์วิดท์หน่วยความจำเนื่องจากชุดข้อมูลไม่พอดีกับแคชของ CPU

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

Knuth ใช้คำว่าgigamemsในเล่มที่ 4A ของ TAOCP เมื่อทำการวิเคราะห์ BDDs ฉันไม่แน่ใจว่าเขาใช้มันในเล่มก่อนหน้าหรือไม่ เขาแสดงความคิดเห็นดังกล่าวเกี่ยวกับการยืนการทดสอบเวลาในการบรรยายต้นคริสต์มาสประจำปีของเขาในปี 2010

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

วิธีที่คุณกำหนดค่าใช้จ่ายของอัลกอริทึมนั้นขึ้นอยู่กับ "ระดับ" ของการคำนวณทางวิทยาศาสตร์ที่คุณทำงานและปัญหาที่คุณพิจารณา (แคบหรือกว้าง)

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

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

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

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

ฉันคิดว่ามันเป็นการดีที่จะปรับท่าทางของวิทยาศาสตร์คอมพิวเตอร์เชิงทฤษฎี: ในที่สุดการปรับปรุงความซับซ้อนเชิงอัลกอริธึมของอัลกอริทึมจะให้ผลตอบแทนมากกว่าการเพิ่มประสิทธิภาพแบบไมโครของโค้ดบางบรรทัดที่มีอยู่ ดังนั้นการนับ FLOP ยังคงเป็นที่ต้องการ

ฉันปฏิเสธเสมอที่จะคิดถึงการนับฟล็อปการเข้าถึงหน่วยความจำหรืออะไรก็ตามที่คุณมี นั่นเป็นแนวคิดจากปี 1960 เมื่อสิ่งที่คุณทำได้รับมาอย่างดีเยี่ยมและวิธีที่คุณทำเพื่อเพิ่มประสิทธิภาพอัลกอริธึมเท่านั้น คิดว่าการแก้ปัญหาองค์ประกอบ จำกัด บน xyz mesh โดยใช้การกำจัดแบบเกาส์ของ Jacobi ซ้ำ

ตอนนี้คุณสามารถปรับให้เหมาะกับสิ่งนี้ลงในนรกและประหยัด flops สองสามครั้งได้รับ 10% ของเวลาทำงาน หรือคุณอาจคิดถึงการใช้วิธีการแบบหลายค่าและตัวสร้างบล็อกพื้นฐานที่เหมาะสมโดยเพิ่มขึ้นเป็น 10 เท่าในเวลาทำงาน นี่คือสิ่งที่เราควรฝึกให้นักเรียนทำ - คิดเกี่ยวกับอัลกอริธึมชั้นนอกที่ซับซ้อนอะไรที่จะทำให้คุณได้รับมากกว่าการพยายามหาอัลกอริธึมที่ดีกว่า เจ้านายของคุณ (คีย์ส) มีสไลด์ที่กำลังดำเนินการอยู่ในการคำนวณ MHD ซึ่งทำให้จุดนี้ค่อนข้างชัดเจน

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

abstractions ดังกล่าวมีประโยชน์เป็นเครื่องมือการเรียนรู้หรือไม่ ใช่เช่นเดียวกับแบบจำลองมากมายที่ใช้สำหรับการสอนพวกเขามีประโยชน์ตราบใดที่วางอยู่ข้างๆความเข้าใจในข้อ จำกัด ของตัวแบบ กลศาสตร์แบบคลาสสิกนั้นดีตราบใดที่คุณเห็นคุณค่าว่ามันจะไม่ทำงานบนสเกลของระยะทางขนาดเล็กหรือความเร็วสูง ...

ไม่ตอบคำถามของคุณจริงๆ แต่การเพิ่มตัวแปรอื่นให้พิจารณา: สิ่งที่ต้องคำนึงถึงคือคุณสมบัติของภาษาการเขียนโปรแกรม ตัวอย่างเช่น Python sortใช้อัลกอริทึมTimsortที่ได้รับการออกแบบ (ท่ามกลางคุณสมบัติที่ดีอื่น ๆ ) เพื่อลดจำนวนการเปรียบเทียบซึ่งอาจช้าสำหรับวัตถุ Python ในทางตรงกันข้ามการเปรียบเทียบสองลอยใน C ++ นั้นเร็วมาก แต่การสลับมันมีราคาแพงกว่าดังนั้นพวกมันจึงใช้อัลกอริธึมอื่น

ตัวอย่างอื่น ๆ คือการจัดสรรหน่วยความจำแบบไดนามิก (เล็กน้อยในรายการ Python รวดเร็วในเวลารันไทม์และเวลาของนักพัฒนาเพียง.append()) vs FORTRAN หรือ C โดยที่แม้ว่าจะเป็นไปได้และเร็วขึ้นเมื่อนำไปใช้อย่างถูกต้อง ดูPython เร็วกว่า FORTRAN