ในการเขียนโปรแกรมซอฟต์แวร์เป็นไปได้ไหมที่ทั้ง CPU และ GPU จะโหลด 100%?

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

ดังนั้นฉันสงสัย: มี GPU ที่โหลด 100% ในขณะที่ CPU อยู่ที่ 50% (ตัวอย่าง) หลีกเลี่ยงไม่ได้?

หรือแม่นยำยิ่งขึ้น: การคำนวณบางอย่างที่โดยปกติ GPU กระทำโดย CPU หากการคำนวณแรกนั้นมีการโหลด 100% ดังนั้นทั้งสองจะถึงการโหลด 100% หรือไม่

ฉันค้นหาเรื่องเล็กน้อย แต่กลับมาค่อนข้างถนัดมือ ฉันคิดและหวังว่าสิ่งนี้จะเกิดขึ้นในส่วนย่อยนี้และเปิดรับเอกสารหรือการบรรยายใด ๆ ที่คุณอาจให้ฉัน!

ในทางทฤษฎีใช่ แต่ในทางปฏิบัติแล้วมันไม่ค่อยคุ้มค่า

ทั้งซีพียูและ GPU ต่างก็มีความสมบูรณ์ดังนั้นอัลกอริทึมใด ๆ ที่สามารถคำนวณได้โดยหนึ่งสามารถคำนวณได้อีกอัน คำถามคือความรวดเร็วและความสะดวก

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

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

ไม่เกี่ยวข้องกับการเขียนโปรแกรมเกม รหัสทางวิทยาศาสตร์บางตัวสามารถใช้ทั้ง GPU และ CPU ได้

ด้วยความระมัดระวัง - และเจ็บปวด - การเขียนโปรแกรมเช่นโดยใช้OpenCLหรือCUDAคุณสามารถโหลดทั้ง GPU และ CPU ของคุณใกล้ 100% คุณอาจจะต้องเขียนโค้ดต่าง ๆ สำหรับ GPU (เรียกว่ารหัส "เคอร์เนล") และสำหรับซีพียูและรหัสกาวบางอันที่น่าเบื่อ

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

อ่านเพิ่มเติมเกี่ยวกับการใช้คอมพิวเตอร์ที่แตกต่างกัน

ดูเพิ่มเติมที่OpenACCสนับสนุนโดย GCC รุ่นล่าสุด (เช่นGCC 6ในเดือนมิถุนายน 2559)

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

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

if (expr1)
    expr2;
else
    expr3;

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

จากนั้นคุณมีคุณสมบัติ SIMD ในซีพียูซึ่งเป็นการทำงานแบบเวกเตอร์ มันเหมือนกับ GPGPU-light ในแง่ที่ว่าคุณมักจะมีเพียงสี่หรือแปดการทำงานในเวลาเดียวกัน, GPU ทำเช่น 32 หรือ 64 แต่คุณยังต้องใช้มันเพื่อเหวี่ยง FLOPS

สิ่งต่าง ๆ เช่นการแบ่งปันที่ผิดสามารถนำไปสู่ค่าใช้จ่ายในการซิงโครไนซ์สูงซึ่งมักจะแสดงเป็นโหลดเคอร์เนลใน Linux CPU ถูกใช้อย่างสมบูรณ์ แต่คุณไม่มีปริมาณงานที่มีประโยชน์มาก

ฉันได้เขียนโปรแกรมบนเครื่อง IBM Blue Gene / Q มีระดับลำดับขั้นมากมาย ( แผนผังของ Blue Gene / L ) ที่ล้าสมัยและดังนั้นจึงยากที่จะตั้งโปรแกรมได้อย่างมีประสิทธิภาพ คุณจะต้องใช้ลำดับชั้นแบบเต็มลงไปที่ SIMD และ SMT (Intel เรียก HyperThreading นี้) เพื่อรับประสิทธิภาพ

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

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

คุณอาจจะสนใจในการตรวจสอบจากServoเครื่องมือเบราว์เซอร์ได้รับการพัฒนาที่ Mozilla วิจัยและมากขึ้นโดยเฉพาะของเว็บ Render (วิดีโอ)

ในขณะที่ขยับงานจาก CPU กับ GPU แบบไดนามิกอาจจะทำไม่ได้ตามที่กล่าวไว้ในคำตอบอื่น ๆ (สะดุดตา @ ฟิลิป) ก็สามารถปฏิบัติเพื่อศึกษาภาระของ CPU / GPU ในปริมาณงานทั่วไปล่วงหน้าและสลับบางงานให้โดยทั่วไปโหลดน้อย หนึ่ง.

ในกรณีของ Web Render ความแปลกใหม่คือเบราว์เซอร์แบบดั้งเดิมทำงานส่วนใหญ่ในการสร้างการแสดงผลบน CPU (เช่น CPU ใช้ในการคำนวณว่าวัตถุใดที่จะแสดง ปกติแล้ว GPU นั้นจะดีกว่า ... ยกเว้นว่าจะมีการใช้เพียงเล็กน้อยเท่านั้น (การคัดบางส่วน, เงา, ... และข้อความ)

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

แน่นอนว่าเป้าหมายคือลดภาระให้มากที่สุดเท่าที่เป็นไปได้ของกระบวนการเรนเดอร์ไปยัง GPU ปล่อย CPU ให้ว่างเพื่อรัน Javascript, อัพเดต DOM และงานอื่น ๆ ทั้งหมด

ดังนั้นแม้จะไม่รุนแรงเท่าคำแนะนำของคุณ แต่จะไปในทิศทางของการออกแบบกลยุทธ์การคำนวณโดยคำนึงถึงทั้ง CPU และ GPU ในใจ

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

ในสถานการณ์นี้คุณสามารถทำได้ทั้งบน CPU และอัปโหลดผลลัพธ์ไปยัง GPU เพื่อแสดงผลหรือทำการคำนวณและแสดงผลบน GPU ฉันเชื่อว่าทุกวันนี้มันทำบน GPU (รู้จักกันในนาม "ฮาร์ดแวร์สกินนิ่ง"): มันสมเหตุสมผลที่จะทำเช่นนั้นเนื่องจากคุณมีการคำนวณที่ค่อนข้างง่ายที่ต้องทำการนับพันครั้งและแต่ละจุดสุดยอดสามารถคำนวณพร้อมกันตั้งแต่ผลลัพธ์ ของจุดยอด A ไม่มีผลต่อผลลัพธ์ของจุดยอด B

อย่างไรก็ตามในทางทฤษฎีคุณสามารถสลับระหว่างการทำงานกับ CPU หรือ GPU แบบไดนามิกขึ้นอยู่กับว่า GPU และ CPU มีการโอเวอร์โหลดมากเกินไป

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

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

ตัวอย่างหนึ่งในโลกแห่งความจริงคือเอนจิ้นการแสดงผลLuxRender แบบโอเพ่นซอร์สซึ่งสามารถโหลด CPU และ GPU ได้อย่างสมบูรณ์ในเวลาเดียวกัน นอกจากนี้ยังสามารถโหลด GPU หลายตัวในเวลาเดียวกันและสามารถกระจายข้ามคอมพิวเตอร์หลายเครื่อง

LuxRender ใช้OpenCLเพื่ออำนวยความสะดวกในเรื่องนี้แม้ว่าจะมีการสร้างที่ไม่มี OpenCL ก็ตาม

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

ใช่มันเป็นไปได้อย่างแน่นอน

การคำนวณใด ๆ ที่ CPU สามารถทำได้ GPU สามารถทำได้และในทางกลับกัน

แต่มันก็แปลกเพราะ:

• ความซับซ้อนทางวิศวกรรมในขณะที่สามารถเรียกใช้รหัสเดียวกันบน CPU และ GPU (เช่น CUDA) ตัวประมวลผลมีความสามารถและลักษณะการทำงานที่แตกต่างกัน หนึ่งคือ MIMD; อีก SIMD สิ่งที่รวดเร็วในอีกอันหนึ่งช้าลง (เช่นการแตกกิ่ง) ดังนั้นคุณต้องเขียนโค้ดแยกต่างหากเพื่อเพิ่มประสิทธิภาพ

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

หากคุณได้อัลกอริทึมของคุณทำงานบน GPU เพียงแค่เพิ่มความเหมาะสมสำหรับสิ่งเหล่านั้นและเพิ่มมากเท่าที่คุณต้องการ