การออกแบบเฟิร์มแวร์ FPGA: ใหญ่เกินไปเท่าใด

13

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

512 ffts จาก 64 จุด
การดำเนินงานเพิ่มทวีคูณ 41210

เมื่อพิจารณา Virtex 6 FPGA ที่ใหญ่ที่สุดมีบล็อก DSP48E ประมาณ 2000 ฉันรู้ว่าฉันสามารถแบ่งปันทรัพยากรเพื่อใช้ทรัพยากรซ้ำได้หลายครั้ง เวลาดำเนินการไม่ใช่ปัญหาจริงๆเวลาประมวลผลอาจใช้เวลานานในแง่ของ FPGA

ดูที่การใช้ทรัพยากรการใช้สถาปัตยกรรม radix-2 lite ทำให้ฉันได้รับบล็อก 4dsp / การดำเนินการ FFT = 2048 บล็อก DSP รวม ~ 43k Virtex FPGA ที่ใหญ่ที่สุดมี 2k block หรือ 20 การทำงาน / mux

เห็นได้ชัดว่าการรวม mux ขนาดใหญ่เข้าไปในเนื้อผ้า ฉันจะหาจุดสูงสุดของข้อ จำกัด นี้ได้จากที่ใด ฉันไม่สามารถแชร์ทรัพยากร FPGA ได้อย่างไร้ขีด จำกัด ตัวคูณ 41210 ใหญ่เกินไปหรือไม่ ฉันจะคำนวณสิ่งที่ใหญ่เกินไปได้อย่างไร

ฉันได้ดูทรัพยากรอื่น ๆ ด้วย (สไลซ์, แบรม, ฯลฯ ) Radix-2 Lite ยังให้ 4 x 18k brams / fft = 2048 brams Xilinx FPGA ที่ใหญ่ที่สุดมี 2128 Brams เส้นเขตแดนมาก ฉันกังวลว่าการออกแบบของฉันใหญ่เกินไป

UPDATE:

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

Initial conditions -> 512 ffts -> 40k multipliers ---------|----> output data to host 

                 ^------re-calculate initial conditions----|

ข้อมูลจำเพาะ Datarate เอาท์พุท: "เร็วกว่าการจำลอง MATLAB"

การคำนวณที่ชาญฉลาดนี่คือที่ฉัน:

ขั้นตอน FFT:ง่าย ฉันสามารถใช้ 1/2/4/8 FFTs เก็บผลลัพธ์ใน SDRAM และเข้าถึงได้ในภายหลัง ค่อนข้างเล็กแม้ว่าจะใช้เวลานานก็โอเค ใช้ radix-2 lite ฉันได้รับ DSP48E 2 อันและ BRS / FFT 2 18k สตรีมมิ่งให้ 6 DSP48Es 0BRAMS / FFT ในทั้งสองกรณี 64 จุด FFT มีขนาดเล็กในข้อกำหนดทรัพยากร FPGA

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

เมื่อพิจารณาการใช้ทรัพยากรร่วมกันใน FPGA คณิตศาสตร์จะทำงานดังนี้: LUT-6 หนึ่งตัวสามารถใช้เป็น 4-way mux สูตรสำหรับ N-way, M bit mux มีดังนี้:

N*M/3 = number of luts, or N*M/12 = slices (4 LUTS/slice).

การบดตัวเลขสำหรับการนำไปใช้ของฉันไม่ได้ผลดี 90% ของตระกูล virtix-6 ไม่มีส่วนแบ่งเพียงพอที่จะแบ่งปันทรัพยากร DSP ของตนเพื่อดำเนินการ 40k

fpga vhdl xilinx

— stanri
แหล่งที่มา

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

— Chris Stratton

1

นี่ไม่ใช่ส่วนหนึ่งของคำถามของคุณ แต่ในการคำนวณทรัพยากรคุณไม่ได้ระบุขนาดของตัวถูกดำเนินการ 512 FFTs x 64 คะแนน x มีกี่บิต? ใน FPGA ขนาดตัวถูกดำเนินการขึ้นอยู่กับคุณทั้งหมดดังนั้นคุณต้องพิจารณาเมื่อทำการคำนวณขนาดของปัญหา

— โฟตอน

ฉันไม่รู้ว่าคุณรู้หรือไม่ แต่ FPGA ขนาดใหญ่เหล่านั้นค่อนข้างแพง บางคนสามารถสูงกว่า $ 5k บางทีคุณควรพิจารณาด้วยเช่นกันเว้นแต่ว่าค่าใช้จ่ายจะไม่มีปัญหา

— Gustavo Litovsky

1

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

— โฟตอน

1

คุณมีหมายเลขงบประมาณสำหรับสิ่งนี้หรือไม่? เช่นเดียวกับ Gustavo ชี้ให้เห็นว่า FPGA ระดับไฮเอนด์มีราคาแพงเช่นเดียวกับการพัฒนา PCB เพื่อรองรับ ในขณะที่ปริมาณของฮาร์ดแวร์การคำนวณและสองเท่า (หรือสี่เท่าหรือ ... ) และการใช้งานที่มีอยู่ในปัจจุบันได้รับการพิสูจน์แล้ว (?) รหัส Matlab อาจเป็นไปตามข้อกำหนดความเร็วที่กำหนด

— Photon

8

ฉันสงสัยว่ามีวิธีอื่นในการดูปัญหาหรือไม่

เล่นการประมาณค่าของคุณสำหรับการดำเนินการ 512 FFT (64 จุดแต่ละจุด) และการใช้งาน MAC 42k ... ฉันคิดว่านี่คือสิ่งที่คุณต้องการสำหรับการส่งผ่านอัลกอริทึม?

ตอนนี้คุณได้ค้นพบแกน FFT ที่ใช้หน่วย DSP 4 ตัวแล้ว ... แต่มันใช้เวลาเท่าไหร่ต่อหนึ่ง FFT (ปริมาณงานไม่ใช่ความล่าช้า) สมมุติว่า 64 หรือ 1 รอบต่อจุด จากนั้นคุณต้องดำเนินการกับ Mac 42k ให้เสร็จใน 64 รอบ - อาจจะเป็น 1k MACs ต่อรอบโดยที่ MAC แต่ละตัวจะจัดการกับ 42

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

นอกจากนี้ยังสามารถลดความแข็งแรงได้หรือไม่? ฉันมีบางกรณีที่ต้องใช้การคูณในลูปเพื่อสร้าง Quadratics (และสูงกว่า) การคลี่คลายพวกมันฉันสามารถสร้างมันซ้ำ ๆ ได้โดยไม่ต้องคูณ: ฉันค่อนข้างพอใจกับตัวเองในวันที่ฉันสร้างเอนจิ้น Difference บน FPGA!

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

นอกจากนี้ - เนื่องจากฟังดูราวกับว่าคุณไม่มีแพลตฟอร์มที่ชัดเจน - ให้พิจารณาว่าคุณสามารถแบ่งพาร์ติชันใน FPGA หลาย ๆ ... ลองดูที่บอร์ด นี้หรืออันนี้ที่มี FPGA หลายอันในแพลตฟอร์มที่สะดวก พวกเขายังมีบอร์ดพร้อมอุปกรณ์ 100 Spartan-3 ...

(ps ฉันรู้สึกผิดหวังเมื่อพวกซอฟต์แวร์ปิดคำถามอื่น - ฉันคิดว่าอย่างน้อยก็เหมาะสม)

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

การเรียงลำดับการดำเนินการ FFT ที่แตกต่างกันผ่านหน่วย FFT เดียวกันจะเรียงลำดับเอาต์พุต FFT ที่ผ่านตัวคูณนี้โดยอัตโนมัติ การหาค่าสัมประสิทธิ์ที่ถูกต้องในอินพุต MPY อื่นตอนนี้เป็นเพียงเรื่องของการจัดระเบียบที่อยู่ ROM ที่ถูกต้องในเวลาที่ถูกต้อง: ปัญหาขององค์กรมากกว่าการปวดหัวอย่างมากของ MUXes

เกี่ยวกับประสิทธิภาพการทำงาน: ฉันคิดว่า Dave Tweed เป็นคนมองโลกในแง่ร้ายโดยไม่จำเป็น - FFT ใช้การดำเนินงาน n * log (n) แต่คุณต้องเลือก O (n) หน่วยผีเสื้อและ O (logN) รอบหรือ O (logN) และ O (logN) n) รอบหรือชุดค่าผสมอื่น ๆ เพื่อให้เหมาะกับทรัพยากรและเป้าหมายความเร็วของคุณ ชุดค่าผสมหนึ่งชุดนี้อาจทำให้โครงสร้างทวีคูณแบบโพสต์ FFT ง่ายกว่าชุดอื่น ๆ ...

— Brian Drummond
แหล่งที่มา

FFT ที่นำมาใช้กับผีเสื้อฮาร์ดแวร์ตัวเดียวจะต้องใช้วงจรนาฬิกาของ NlogN สำหรับ 512 คะแนนนั่นคือผีเสื้อ 256 * 8 หรือ 2048 นาฬิกา นั่นหมายความว่า MAC 41210 (หรือ 32768?) จะต้องใช้ตัวคูณฮาร์ดแวร์ 8-10 เท่านั้นในเวลาเดียวกัน

— Dave Tweed

ฉันหมายถึง 16-20 ตัวคูณ

— Dave Tweed

ขออภัยฉันเพิ่งรู้ว่าฉันไปข้างหลัง FFT ที่เป็นแบบ indiivdual คือ 64 คะแนนดังนั้นการใช้งานแบบ single-butterfly จะต้องใช้นาฬิกา 32 * 5 = 160 MAC สามารถทำได้ด้วยตัวคูณฮาร์ดแวร์ 200-250

— Dave Tweed

นี่คือสิ่งที่ทำให้ฉันตกใจ xilinx สามารถออกแบบแกนกลางที่สามารถทำ ffts 16k / 32k ที่ต้องการการเพิ่มทวีคูณ 400k (NlogN) ได้อย่างไรและฉันยังต้องดิ้นรนกับ 41k ของฉันได้อย่างไร? จะต้องมีวิธี!

— stanri

@ เดฟ: ฉันเชื่อว่าคุณหมายถึง 160 การคูณไม่ใช่ 160 รอบแน่นอน? ไม่มีอะไรที่เป็นลำดับโดยเนื้อแท้ใน FFT ...

— Brian Drummond

2

หากปัญหานี้ไม่มีข้อ จำกัด แบบเรียลไทม์และดูเหมือนว่าจะไม่มี - คุณเพียงแค่ต้องการให้มันรัน "เร็วขึ้น" ดูเหมือนว่ามันอาจตอบสนองต่อการเร่งความเร็วของ GPU หนึ่งตัวหรือมากกว่า มีห้องสมุดซอฟต์แวร์หลายแห่งที่ทำให้เรื่องนี้ค่อนข้างตรงไปตรงมาและนี่จะเป็นเรื่องเกี่ยวกับลำดับความสำคัญได้ง่ายกว่าการไปยังฮาร์ดแวร์ FPGA ที่กำหนดเอง

เพียงแค่ Google สำหรับ "ไลบรารีที่เปิดใช้ GPU" หรือ "ไลบรารีที่เร่งความเร็ว GPU" เพื่อเริ่มต้น

— เดฟทวีด
แหล่งที่มา

น่าสนใจพอฉันพูดถึง GPU กับลูกค้าเมื่อฉันได้ยินเกี่ยวกับโครงการนี้และเขาไม่สนใจ

— stanri

@StaceyAnneRieck: เขาพูดว่าทำไม

— เดฟทวีด

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

— stanri

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

— Dave Tweed

จริงๆแล้วมันเป็นอัลกอริธึมที่ง่ายมาก ๆ มันเป็นเพียงแค่สเกลที่ทำให้มันซับซ้อน โดยทั่วไปมีดังนี้: เงื่อนไขเริ่มต้น -> 512 ffts ในแบบคู่ขนาน -> 32768 การดำเนินการคูณกับเอาต์พุต FFT -> ปรับเงื่อนไขเริ่มต้น -> ล้างและทำซ้ำ

— stanri

1

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

ฉันไม่ได้ลองใช้การออกแบบฮาร์ดแวร์ช่วยสำหรับ FFT แต่สิ่งหนึ่งที่ฉันได้ดูคือความช่วยเหลือด้านฮาร์ดแวร์สำหรับการดำเนินการทวีคูณขนาดใหญ่ (อาจใช้สำหรับการเข้ารหัส RSA) ไมโครคอนโทรลเลอร์หลายคนแม้จะเป็นฮาร์ดแวร์ที่มีการขยายตัวอย่างรวดเร็วพิเศษนั้นก็ไม่ได้มีประสิทธิภาพอย่างมากในการดำเนินการดังกล่าวเพราะพวกเขาต้องการการสับลงทะเบียนจำนวนมาก ฮาร์ดแวร์ที่ออกแบบมาเพื่อลดการแลกเปลี่ยนการลงทะเบียนสามารถบรรลุประสิทธิภาพที่ดีขึ้นมากด้วยการดำเนินการคูณที่มีความแม่นยำสูงแม้ว่าฮาร์ดแวร์เองจะไม่ซับซ้อน ตัวอย่างเช่นฮาร์ดแวร์ที่สามารถดำเนินการคูณ 16xN แบบ pipelined สองบิตในแต่ละครั้ง (เลื่อนใน multipcand ที่ต่ำกว่าสองบิตและเลื่อนออกบิตบนสองของผลลัพธ์) อาจบรรลุประสิทธิภาพที่ดีกว่าฮาร์ดแวร์ที่สามารถทำการคูณ 8x8 ในรอบเดียว แม้ว่าอดีตอาจใช้วงจรน้อยลง (และโดยอาศัยการวางท่อจะมีเส้นทางข้อมูลที่สั้นกว่า) กุญแจสำคัญคือการคิดออกว่า "วงใน" ของรหัสที่จำเป็นจะมีลักษณะอย่างไรและหาว่ามีความไร้ประสิทธิภาพใด ๆ ที่สามารถกำจัดได้อย่างง่ายดาย

— SuperCat
แหล่งที่มา

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

— stanri

0

ปัญหาเวลาในการดำเนินการของเรามีน้อยแค่ไหน?

ดูเหมือนว่าจะเป็นสถานการณ์ที่คุณควรใช้ soft-MCU, FPGA กับ hard-MCU ในตัวหรือแม้กระทั่งอุปกรณ์ MCU แยกต่างหากและทำการดำเนินการทั้งหมดของคุณให้เป็นอนุกรม

สมมติว่าคุณมีเวลาดำเนินการการทำ FFT ในซอฟต์แวร์ของคุณจะง่ายต่อการดีบักและอาจออกแบบได้ง่ายกว่าเช่นกัน

— คอนเนอร์ Wolf
แหล่งที่มา

1

การคำนวณอย่างหนักในซีพียูคอร์แบบ soft ใน FPGA นั้นมันไร้สาระ หากคุณกำลังจะทำการคำนวณในสถาปัตยกรรมโปรแกรมที่เก็บไว้ (สิ่งที่ควรพิจารณา) เนื่องจากประสิทธิภาพสูง / ดอลลาร์ฮาร์ดซีพียู (s) ที่คุณไม่จ่ายค่าปรับความเร็วของตรรกะที่ยืดหยุ่นกว่าเทียบเคียง fab- รุ่นยากตรรกะ

— Chris Stratton

@ChrisStratton - จุดดี เพิ่มหมายเหตุเพิ่มเติมให้กับเอฟเฟกต์นั้น

— Connor Wolf

1

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

— Chris Stratton

@ChrisStratton - ฉันคิดว่าสถาปัตยกรรมแบบ hard-CPU ที่พบมากที่สุดคือ ARM หรือ POWER? ในกรณีนั้นโดยทั่วไปมันเป็นซีพียูชุดสินค้า

— Connor Wolf

1

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

— Chris Stratton