FLOP นับสำหรับฟังก์ชั่นห้องสมุด

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

โดยฟังก์ชั่นพิเศษเราหมายถึงสิ่งที่ชอบ:

• ประสบการณ์ ()
• sqrt ()
• บาป / cos / สีน้ำตาล ()

ซึ่งมักจะมีให้โดยไลบรารีระบบ

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

แน่นอนว่าการสนทนาทั้งหมดนี้ขึ้นอยู่กับสถาปัตยกรรมเป็นอย่างมาก สำหรับการสนทนานี้เราสามารถ จำกัด ตัวเราให้เป็นสถาปัตยกรรมที่มีวัตถุประสงค์ทั่วไปแบบทั่วไปและยกเว้นสิ่งที่มีหน่วยฟังก์ชั่นพิเศษ (GPU ฯลฯ )

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

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

การดำเนินการจุดลอยตัวที่สนับสนุนฮาร์ดแวร์

ชิปนี้รองรับคำแนะนำAVXดังนั้นการลงทะเบียนมีความยาว 32 ไบต์ (ถือ 4 คู่) สถาปัตยกรรม superscalar ช่วยให้คำแนะนำในการทับซ้อนกับคำสั่งทางคณิตศาสตร์ส่วนใหญ่ใช้เวลาไม่กี่รอบให้เสร็จสมบูรณ์แม้ว่าคำสั่งใหม่อาจจะสามารถเริ่มในรอบถัดไป ความหมายเหล่านี้มักจะมีตัวย่อโดยการเขียน latency / inverse throughput ค่า 5/2 จะหมายถึงว่าคำสั่งใช้เวลา 5 รอบเพื่อให้เสร็จสมบูรณ์ แต่คุณสามารถเริ่มต้นคำสั่งใหม่ทุกรอบอื่น ๆ (สมมติว่าตัวถูกดำเนินการมีอยู่แล้วดังนั้นจึงไม่มีข้อมูล พึ่งพาและไม่รอหน่วยความจำ)

มีหน่วยคำนวณเลขทศนิยมสามหน่วยต่อหนึ่งคอร์ แต่หน่วยที่สามไม่เกี่ยวข้องกับการสนทนาของเราเราจะเรียกหน่วย A และ M ที่เกี่ยวข้องสองอันเนื่องจากฟังก์ชันหลักคือการเพิ่มและการคูณ ตัวอย่างคำแนะนำ (ดูตารางของ Agner Fog )

• vaddpd: บรรจุเพิ่มแล้วครอบครองยูนิต A สำหรับ 1 รอบความเร็วในการตอบสนอง / ผกผันคือ 3/1
• vmulpd: การคูณที่บรรจุแล้ว, ยูนิต M, 5/1
• vmaxpd: เลือกขนาดสูงสุดที่เลือกไว้, หน่วย A, 3/1
• vdivpd: แบ่งการบรรจุหน่วย M (และ A), 21/20 ถึง 45/44 ขึ้นอยู่กับอินพุต
• vsqrtpd: รากที่สองที่อัดแน่น A และ M บางตัว 21/21 ถึง 43/43 ขึ้นอยู่กับอินพุต
• vrsqrtps: บรรจุสแควร์รูตแบบ reciprocal ที่มีความแม่นยำต่ำสำหรับอินพุตที่มีความแม่นยำเดียว (8 floats)

ความหมายที่แม่นยำสำหรับสิ่งที่สามารถทับซ้อนกับvdivpdและvsqrtpdมีความละเอียดอ่อนและ AFAIK ไม่ใช่เอกสารทุกที่ ในการใช้งานส่วนใหญ่ฉันคิดว่ามีความเป็นไปได้น้อยที่จะทับซ้อนแม้ว่าข้อความในคู่มือแนะนำว่าหลายเธรดอาจมีความเป็นไปได้มากกว่าสำหรับการทับซ้อนในคำแนะนำนี้ เราสามารถกดจุดสูงสุดได้หากเราเริ่มต้นvaddpdและvmulpdทุกรอบรวมเป็น 8 flops ต่อรอบ เมทริกซ์หนาแน่นเมทริกซ์คูณ ( dgemm) สามารถเข้าใกล้จุดยอดนี้ได้พอสมควร

เมื่อนับ flops สำหรับคำแนะนำพิเศษฉันจะดูจำนวน FPU ที่ถูกครอบครอง สมมติว่าอาร์กิวเมนต์ในช่วงอินพุตของคุณvdivpdใช้เวลาโดยเฉลี่ย 24 รอบเพื่อให้เสร็จสมบูรณ์ครอบครองหน่วย M แต่การเพิ่มสามารถ (ถ้ามี) จะดำเนินการพร้อมกันครึ่งรอบ FPU มีความสามารถในการแสดงผล 24 แบบทวีคูณและ 24 ภาพเพิ่มเติมในระหว่างรอบเหล่านั้น ( ผสมผสานกันอย่างสมบูรณ์vaddpdและvmulpd) แต่ด้วย a vdivpdสิ่งที่ดีที่สุดที่เราทำได้คือเพิ่มอีก 12 รายการ ถ้าเราคิดว่าวิธีที่ดีที่สุดในการแบ่งคือใช้ฮาร์ดแวร์ (สมเหตุสมผล) เราอาจนับvdivpd"flops" ที่บรรจุ 36 รายการซึ่งบ่งชี้ว่าเราควรนับจำนวนสเกลาร์แต่ละตัวเป็น 36 "flops"

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

y *= (3 - x*y*y)*0.5;

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

ฟังก์ชันคณิตศาสตร์ที่มีในไลบรารี

เราสามารถนำฮิวริสติกที่คล้ายกันไปใช้กับฟังก์ชั่นคณิตศาสตร์ที่มีในห้องสมุด คุณสามารถสร้างโปรไฟล์เพื่อกำหนดจำนวนคำสั่ง SSE แต่ตามที่เราได้กล่าวไปแล้วนั่นไม่ใช่เรื่องราวทั้งหมดและโปรแกรมที่ใช้เวลาทั้งหมดในการประเมินฟังก์ชั่นพิเศษอาจไม่ปรากฏว่าใกล้เคียงกับจุดสูงสุดซึ่งอาจเป็นจริง แต่ไม่ใช่ ไม่มีประโยชน์สำหรับการบอกคุณว่าเวลาทั้งหมดอยู่ในการควบคุมของคุณใน FPU

ฉันขอแนะนำให้ใช้ห้องสมุดคณิตศาสตร์เวกเตอร์ที่ดีเป็นพื้นฐาน (เช่น VML ของ Intel ส่วนของ MKL) วัดจำนวนรอบสำหรับการโทรแต่ละครั้งและคูณด้วยจำนวนครั้งสูงสุดที่ทำได้ผ่านจำนวนรอบนั้น ดังนั้นถ้าเลขชี้กำลังบรรจุนั้นใช้เวลา 50 รอบในการประเมินให้นับเป็น 100 flops คูณความกว้างของรีจิสเตอร์ น่าเสียดายที่ห้องสมุดคณิตศาสตร์เวคเตอร์บางครั้งยากที่จะโทรหาและไม่มีฟังก์ชั่นพิเศษทั้งหมดดังนั้นคุณอาจลงเอยด้วยการทำคณิตศาสตร์สเกลาร์ซึ่งในกรณีนี้คุณจะนับสเกลาร์เชิงสมมติฐานของเราเป็น 100 flops (แม้ว่ามันอาจจะยังคง 50 รอบดังนั้นคุณจะได้รับ 25% ของ "ยอด" ถ้าใช้เวลาทั้งหมดเพื่อประเมินเลขชี้กำลังเหล่านี้)

ตามที่คนอื่นพูดถึงคุณสามารถนับรอบและตัวนับเหตุการณ์ฮาร์ดแวร์โดยใช้ PAPI หรืออินเทอร์เฟซต่าง ๆ สำหรับการนับรอบอย่างง่ายคุณสามารถอ่านตัวนับรอบได้โดยตรงโดยใช้rdtscคำแนะนำพร้อมตัวอย่างข้อมูลประกอบแบบอินไลน์

คุณสามารถนับพวกเขาในระบบจริงโดยใช้PAPIซึ่งให้สิทธิ์การเข้าถึงตัวนับฮาร์ดแวร์และโปรแกรมทดสอบอย่างง่าย ส่วนต่อประสาน PAPI ที่ฉันชอบคือIPM (Integrated Performance Monitor) แต่มีวิธีแก้ไขปัญหาอื่น ( เช่นTAU ) สิ่งนี้ควรให้การเปรียบเทียบระหว่าง method กับ method มีความเสถียร

ฉันจะตอบคำถามนี้ราวกับว่าคุณถาม:

"ฉันจะวิเคราะห์เปรียบเทียบหรือทำนายประสิทธิภาพของอัลกอริทึมที่ต้องอาศัยฟังก์ชั่นพิเศษอย่างหนักแทนการนับ FLOP คูณเพิ่มแบบพกพาแบบดั้งเดิมที่มาจากพีชคณิตเชิงเส้นเชิงตัวเลข"

ฉันเห็นด้วยกับข้อแรกของคุณว่าประสิทธิภาพของฟังก์ชั่นพิเศษมากมายนั้นขึ้นอยู่กับสถาปัตยกรรมและถึงแม้ว่าคุณจะสามารถปฏิบัติหน้าที่แต่ละฟังก์ชั่นเหล่านี้ว่ามีค่าใช้จ่ายคงที่ขนาดของค่าคงที่จะแตกต่างกัน บริษัท แต่มีสถาปัตยกรรมที่แตกต่างกัน (ดูตารางเวลาการสอนของ Agner Fogสำหรับการอ้างอิง)

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

1. ความสามารถในการปรับขนาด - อัลกอริทึมที่มีงานที่สามารถนำไปปฏิบัติได้อย่างมีประสิทธิภาพบนสถาปัตยกรรมแบบคู่ขนานจะครองเวทีการคำนวณทางวิทยาศาสตร์สำหรับอนาคตอันใกล้ อัลกอริธึมที่มี "scalability" ที่ดีกว่าไม่ว่าจะเป็นการสื่อสารที่ต่ำกว่าไม่ต้องการการซิงโครไนซ์หรือโหลดบาลานซ์ตามธรรมชาติที่ดีกว่าอาจใช้ฟังก์ชั่นพิเศษที่ช้ากว่าและช้าลงสำหรับกระบวนการจำนวนน้อย ของโปรเซสเซอร์เพิ่มขึ้น

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

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

ทำไมต้องนับ flops เพียงนับรอบสำหรับการดำเนินการทุกครั้งและคุณจะมีสิ่งที่เป็นสากล