ฉันสามารถใช้ซีพียูของ Raspberry Pi ทั้ง 4 คอร์ได้หรือไม่

ฉันสงสัยว่ามีวิธีง่ายๆในการ "เปิด" CPU ทั้งหมด 100% เพื่อให้ฉันสามารถเรียกใช้กระบวนการได้เร็วขึ้น (เช่นการคำนวณหลาม)

1) เป็นไปได้ไหม

2) มีวิธีที่ง่ายในการเปลี่ยนกลับเป็นปกติหรือไม่?

3) มีวิธีใช้ CPU ให้น้อยลงไหมถ้าต้องการ?

ฉันคิดว่าการโต้ตอบบรรทัดคำสั่งเช่น:

pi@raspberry:~ $ sudo turnOnFourCores python run.py

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

ปรับปรุง:

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

ฉันสงสัยว่ามีวิธีง่ายๆในการ "เปิด" CPU ทั้งหมด 100% เพื่อให้ฉันสามารถเรียกใช้กระบวนการได้เร็วขึ้น (เช่นการคำนวณหลาม)

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

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

พิจารณานิพจน์ทางคณิตศาสตร์อย่างง่าย ๆ ต่อไปนี้:

(4 + 2) * 17 / (3 + 6)

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

#1 a) 4 + 2 b) 6 * 17 c) 102 / 9
#2 a) 3 + 6

มีการสนับสนุนเธรด # 2 โดยการคำนวณ 3 + 6 = 9 ซึ่งใช้ในขั้นตอน C โดยใช้เธรด # 1 บันทึกเป็นขั้นตอนเดียว แต่เท่าที่ความเท่าเทียมจะได้มาที่นี่อย่างเป็นประโยชน์ ในขณะที่เธรด # 2 สามารถคำนวณ 17/9 ขณะที่ # 1 กำลังทำ 6 * 17 การทำเช่นนั้นจะไม่มีจุดหมายเพราะตอนนี้คุณมีเส้นทางที่แตกต่างกันสองเส้นทางไปยังเป้าหมายเดียวกันที่ไม่สามารถรวมกันใหม่ได้ คือ # 2 สามารถทำงาน:

b) 17 / 9 c) 1.888 * 6

และจบลงด้วยผลเช่นเดียวกับเธรด # 1 (11.333) แต่พวกเขาไม่ได้ช่วยเหลือซึ่งกันและกันนอกเหนือจากขั้นตอน A ดังนั้นการที่พวกเขาสองคนไล่ตามเป้าหมายนี้จึงเสียเวลา

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

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

^{1. แต่ดูความคิดเห็นของ Felix Dombek ด้านล่าง; ฉันไม่ใช่ผู้เชี่ยวชาญเกี่ยวกับ AI มันอาจจะเป็นที่น่าสังเกตว่าตามความเห็นของ Peter Corde ชุดคำสั่งและตัวประมวลผลร่วมสมัยสามารถใช้ประโยชน์จากระบบปฏิบัติการเพื่อเพิ่มประสิทธิภาพของเนื้อไม้อย่างประณีตในแบบคู่ขนานและท่อส่งฮาร์ดแวร์ทำเช่นนี้ แกนกลางมีมากกว่าหนึ่งสิ่งที่เกิดขึ้นดำเนินการตามกระแสคำสั่งในจุดต่าง ๆ ก่อนที่จะดำเนินการขั้นสุดท้าย) ฉันพยายามที่จะยึดติดกับหัวข้อของเธรดผู้ใช้ที่นี่เนื่องจากฉันคิดว่านั่นเป็นสิ่งที่คุณได้รับ}

ไม่มีหลาม

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

python GILไม่อนุญาตให้คุณใช้หลายคอร์อย่างมีประสิทธิภาพ

การใช้หลายคอร์ต้องเปิดเผยความขนานระดับเธรดในระบบปฏิบัติการอย่างชัดเจนซึ่งโดยปกติแล้วโปรแกรมเมอร์จะต้องเขียนโปรแกรมแบบมัลติเธรด (หรือเรียกใช้โปรแกรมแบบเธรดเดี่ยวหลายครั้งในอินพุตที่แตกต่างกันเช่นการคอมไพล์ด้วยmake -j4)

คอมไพเลอร์สำหรับบางภาษารองรับการเชื่อมโยงอัตโนมัติ ตัวอย่างเช่น C หรือ C ++ พร้อม OpenMP สามารถคอมไพล์for()วนลูปปกติในโปรแกรมที่เริ่มหลายเธรด

#pragma omp parallel for
for(int i = 0; i < 1000000; ++i)
{
   A[i] = B[i] * constant + C[i];
}

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

ที่เกี่ยวข้อง: เธรดเดี่ยวทำงานบนหลายคอร์ได้อย่างไร : คำตอบ: พวกเขาไม่ได้ แต่มีความขนานอื่น ๆ เช่นInstruction-level parallelismที่ซีพียูแกนเดี่ยวค้นหาและหาช่องทางในการรันเธรดเดี่ยวเร็วกว่าการเรียนการสอนทีละครั้ง

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

โปรดทราบว่าคำสั่งในการใช้ RPi3 ARM Cortex-A53 แกน แต่ละแกนคือ superscalar กว้าง 2 หน้า (2 คำสั่งต่อนาฬิกาตามที่ ILP อนุญาต) แต่ไม่สามารถเรียงลำดับคำสั่งใหม่เพื่อค้นหาความเท่าเทียมในระดับคำสั่งเพิ่มเติมและซ่อนความล่าช้า

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

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

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

ทั้งหมดนี้เป็นความสะดวกสบายเล็กน้อยเมื่อโค้ดของคุณทำงานช้ากว่าที่คุณต้องการ แน่นอนว่ามีสิ่งดีๆมากมายภายใต้ประทุนใน Cortex-A53 แต่มีสิ่งดีๆมากมายภายใต้ประทุนในCortex-A57 (เช่นการดำเนินการตามคำสั่งไม่เกิน 3 คำสั่งต่อนาฬิกา) และอื่น ๆ อีกมากมายใน ซีพียู x86 ตัวใหญ่เช่น Skylake (ไม่ต้องพูดถึงความแตกต่างของความเร็วสัญญาณนาฬิกา)

Cortex-A53 นั้นยอดเยี่ยมมากเมื่อเทียบกับhttps://en.wikipedia.org/wiki/Classic_RISC_pipelineเหมือนกับ MIPS ดั้งเดิมที่คุณจะได้เรียนรู้เกี่ยวกับคลาสคอมพิวเตอร์สถาปัตยกรรม แต่โดยมาตรฐานสมัยใหม่มันค่อนข้างต่ำ

นี่ไม่ใช่วิธีการทำงานของ CPU ... ทั้งหมด

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

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

หากคุณเพียงแค่ทำให้ RPi ทำสิ่งต่าง ๆ ได้มากขึ้น (เร่งคันเร่งมากขึ้น) คุณจะเห็นรูปการใช้งาน CPU สูงขึ้น ตัวอย่างเช่นดูการใช้งาน CPU เมื่อคุณเรียกใช้คำสั่งyesในหน้าต่างเทอร์มินัล (โปรดจำไว้ว่าctrl+cสิ้นสุดคำสั่งเทอร์มินัล) สิ่งนี้จะเพิ่มซีพียูของคุณ 25% เนื่องจากมันจะให้ค่าหนึ่งในสี่คอร์ของ CPU

คำตอบอื่น ๆ ให้รายละเอียดที่ดี แต่ดูเหมือนจะไม่ตอบคำถามของคุณโดยเฉพาะ

1. ใช่ถ้าโปรแกรม (และระบบปฏิบัติการ) ถูกตั้งโปรแกรมให้บัญชีสำหรับหลายคอร์ ('เธรด' เป็นคำศัพท์ในการเขียนโปรแกรมที่นี่)
2. เครื่องใช้มากหรือน้อยของแต่ละคอร์ตามที่ต้องการเพื่อทำงานให้เสร็จสมบูรณ์ ดังนั้นไม่จำเป็นต้องเปลี่ยนอะไร
3. คุณสามารถตั้งค่าขีด จำกัด การใช้งานสูงสุด แต่ไม่จำเป็นต้องใช้งานตามปกติ ดูคำตอบได้ที่นี่: - /unix/151883/limiting-processes-to-not-exceed-more-than-10-of-cpu-usage

หมายเหตุ:

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

ถ้าเป็นไปได้ฉันจะทำให้พารามิเตอร์สคริปต์และดำเนินการในกระบวนการ Python แยกต่างหาก ตัวอย่างเช่น:

cat parameters.txt | xargs -n1 -P4 python run.py

อีกทางเลือกหนึ่งคือไลบรารีหลายตัวประมวลผลที่กล่าวถึงแล้วซึ่งช่วยให้คุณสามารถประมวลผลหลามแบบ fork-and-join แต่นั่นก็ต้องให้คุณมีรายการพารามิเตอร์ (เช่นชื่อไฟล์) ที่คุณต้องการเรียกใช้การคำนวณ

ฉันคิดว่า OP อาจไม่เข้าใจแนวคิดของการเขียนโปรแกรมแบบมัลติคอร์ / มัลติเธรดอย่างเต็มที่และยากที่จะใช้ประโยชน์ได้อย่างเต็มที่ 100% ของมัลติคอร์เว้นแต่ว่าอัลกอริทึมสามารถทำให้เกิดปัญหาขนานที่น่าอับอายได้อย่างง่ายดาย

สำหรับข้อมูลเพิ่มเติมคุณสามารถอ่านเพิ่มเติมเกี่ยวกับชื่อบทความที่รู้จักกันดี "The Free Lunch Is Over" http://www.gotw.ca/publications/concurrency-ddj.htm

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

ในทางกลับกันถ้าคุณต้องการใช้สคริปต์ python คุณควรดูjoblibว่าทำงานได้ดีเมื่อคุณต้องการทำโพรเซสให้ขนานกันดังนั้นคุณจะใช้จำนวนตัวประมวลผลที่คุณต้องการ

แม้ว่าคำตอบทั้งหมดเหล่านี้จะถูกต้องในวิธีที่แตกต่างกันมันเป็นความจริงที่ระบบปฏิบัติการจะใช้แกนที่แตกต่างกันโดยอัตโนมัติเพื่อกระจายโหลด คุณสามารถเห็นสิ่งนี้ได้ด้วยโปรแกรมไพ ธ อนอย่างง่าย (temp.py พูด)

while True:
  x = 1.0

เปิดเทอร์มินัลจากเดสก์ท็อป RPi ของคุณและพิมพ์$ topซึ่งจะแสดงการทำงานของโปรเซสเซอร์ จากนั้นเปิดเทอร์มินัลอื่นpython3 temp.pyและคุณจะเห็นงาน python3 เพิ่มขึ้นเป็นเวลาประมวลผล 100% จากนั้นเปิดเทอร์มินัลอื่นแล้วทำซ้ำกระบวนการและดูว่าคุณขยับได้มากถึง 400% ดังนั้นในระดับหนึ่งตามที่ @Shadow แสดงความคิดเห็นมันเป็นเรื่องง่ายและเป็นค่าเริ่มต้น อย่างไรก็ตามการออกแบบโปรแกรมที่สามารถใช้การประมวลผลแบบขนานนั้นไม่ใช่เรื่องเล็กน้อยตามที่คนอื่นได้อธิบายไว้

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

คำตอบข้างต้นจากผู้พัฒนา Python มีแนวคิดที่ จำกัด มากในคำตอบนี้และอาจสับสนมาก แต่คำตอบคือใช่และใช่เท่านั้น!

เนื่องจาก OP ไม่ได้ระบุไพ ธ อนไว้ในคำถามของเขาฉันอยากจะแนะนำสองภาษาที่ทันสมัยกว่าซึ่งทำงานได้ดีกับ Raspberry Pi และมีวิธีการใช้งานที่ง่ายมาก

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

อีกภาษาหนึ่งคือ Go (หรือที่เรียกว่า Golang เพื่อให้ง่ายต่อการค้นหา) Go สร้างขึ้นโดยทีมงาน Google และเป็นภาษาที่เหมาะสมสำหรับผู้ใหญ่ มันง่ายที่จะสร้าง coroutines ใน Go ซึ่งพวกเขาเรียกว่า "Go routines"

ภาษาทั้งสองนี้สามารถคอมไพล์โค้ดบน Raspberry Pi แม้แต่ Pi Zero อย่างไรก็ตามทั้งคู่สามารถคอมไพล์ข้ามคอมพิวเตอร์ที่เร็วกว่าซึ่งเหมาะสำหรับโปรแกรมขนาดใหญ่