FPGA: นับถอยหลังหรือนับถอยหลัง?

ฉันเรียนรู้ที่จะใช้ FPGA (คณะกรรมการพัฒนา Papilio ซึ่งมี xilinx spartan3e โดยใช้ vhdl)

ฉันต้องแบ่งพัลส์ที่เข้ามาด้วยหมายเลข (รหัสยาก)

ฉันสามารถเห็น 3 ตัวเลือก - คร่าวๆเป็น pseudocode (ใช้ 10 นับเป็นตัวอย่าง):

1. เริ่มต้นเป็น 0 เมื่อการเพิ่มขึ้นของขอบการป้อนข้อมูลเพิ่มขึ้น 1 เปรียบเทียบกับ 10 ถ้ามันเท่ากันให้รีเซ็ตเป็น 0 และทริกเกอร์เอาท์พุทพัลส์
2. เริ่มต้นที่ 10 เมื่ออินพุทขอบเพิ่มขึ้นลดลง 1 เปรียบเทียบกับ 0; หากเท่ากันให้รีเซ็ตเป็น 10 และทริกเกอร์เอาท์พุทพัลส์
3. เริ่มต้นที่ 9 แต่ให้แน่ใจว่ามีบิตนำหน้า "0" อย่างน้อย 1 ซึ่งเป็นบิตเอาต์พุตของฉัน บนอินพุตที่เพิ่มขึ้นขอบลดลง 1 บนขอบที่เพิ่มขึ้นของบิตเอาท์พุทรีเซ็ต

รอบการปฏิบัติหน้าที่ไม่สำคัญ

เป็นหนึ่งในสิ่งเหล่านี้ดีกว่าคนอื่น ๆ ? มีวิธีที่ดีกว่าที่ฉันไม่เคยคิดมาก่อนหรือไม่?

มีวิธี "มาตรฐาน" ที่จะให้ผู้รวบรวมโอกาสที่ดีที่สุดในการเพิ่มประสิทธิภาพหรือไม่

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

ต้องบอกว่าฉันเชื่อว่าตัวเลือก 3 จะดีที่สุด ตัวเลือกที่ 1 และ 2 มีเกตตัวเปรียบเทียบ / หรือไประหว่างเคาน์เตอร์เพื่อให้สามารถส่งสัญญาณว่าได้ถึงหมายเลขเป้าหมายแล้ว ตัวเลือกที่ 2 อาจเร็วกว่า 1 เล็กน้อยเนื่องจากทุกอย่างสามารถตรงหรือเข้าด้วยกันโดยไม่มีอินเวอร์เตอร์ แต่คุณจะพบกับความแตกต่างของเทคโนโลยีขนาดเล็กซึ่งอาจเร็วกว่า AND และหรือ XOR

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

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

อีกตัวเลือกหนึ่งจะเริ่มต้นการนับถึง 6 (= 2 ⁴ - 10) นับและตั้งค่าใหม่เมื่อมีการเปิดใช้งานการดำเนินการส่งออก (เช่น FFs เป็นคนทั้งหมด)

ข้อดีของการทำเช่นนี้คือไม่ต้องใช้ FF พิเศษและ FGPAs จำนวนมากได้ทุ่มเทตรรกะเสริมเพื่อเร่งความเร็วการดำเนินการพกพาชนิดนี้ในเคาน์เตอร์หรือวงจรบวก

ขึ้นอยู่กับ ตัวอย่างเช่นความล่าช้าในการแพร่กระจายของ flip-flop สำหรับ 0 → 1 และ 1 → 0 อาจแตกต่างกันและดังนั้นความล่าช้าในการเปลี่ยนผ่านของตัวนับสำหรับ 000 → 001 และ 001 → 000 อาจแตกต่างกันเล็กน้อย อาจสูงหรือต่ำกว่าทั้งนี้ขึ้นอยู่กับเทคโนโลยี cmos ที่ใช้ใน FPGA ดังนั้นคุณต้องสังเคราะห์และหาว่าอันไหนที่มีประสิทธิภาพการจับเวลาดีกว่า

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

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

$N-1$

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