दो पढ़ने और एक लिखने वाले पोर्ट की रजिस्टर फाइल तथा बाइपास

दो मान एक साथ निकालने वाला भंडारण

गणना इकाई को A+B निकालने के लिए दोनों ऑपरेंड एक ही चक्र में चाहिए। 2-read/1-write रजिस्टर^{iरजिस्टर कई बिटों की अवस्था संग्रहित करता है। इस पाठ्यक्रम के तुल्यकालिक रजिस्टर निर्धारित इनपुट को क्लॉक एज पर संग्रहित करते हैं। और जानें} फाइल दो पढ़ने के पते और एक लिखने का पता देती है। यहाँ 16-बिट के आठ शब्द रखे जाते हैं और दोनों पढ़ने के परिणाम भी उर्ध्वगामी एज पर रजिस्टर होते हैं। पता चौड़ाई 3 बिट और भंडारण 8×16=128 बिट है। पता 0 सामान्य भंडारण है; उसके लिए स्थिरांक रजिस्टर का विशेष नियम नहीं है।

हर पढ़ने वाले पोर्ट का अपना enable और valid है। एक पोर्ट निष्क्रिय होने पर दूसरा पढ़ सकता है और दोनों एक ही पता भी पढ़ सकते हैं। एक साथ दो अलग पते पढ़ने की सुविधा की लागत केवल भंडारण बढ़ाने से अलग है। छोटा परिपथ फ्लिप-फ्लॉप^{iफ्लिप-फ्लॉप निर्दिष्ट क्लॉक एज पर इनपुट संग्रहित करके अगली एज तक बनाए रखता है। इनपुट को setup और hold शर्तें पूरी करनी होती हैं। और जानें} सरणी और दो चयन नेटवर्क से बन सकता है। किसी विशिष्ट RAM का उपयोग हो तो पर्याप्त पढ़ने के पोर्ट पाने के लिए भंडारण की प्रतियाँ बनाकर सभी तक एक ही लेखन पहुँचाने पर भी विचार किया जा सकता है। केवल RTL की घोषणा से यह तय नहीं होता कि संश्लेषण कौन-सा संसाधन चुनेगा।

लिखा जा रहा मान ही अभी पढ़ना हो तो

इस अनुबंध में एक ही एज पर एक ही पता पढ़ने और लिखने से नया लिखा गया डेटा उत्तर में मिलता है। सरणी अपडेट होने की प्रतीक्षा किए बिना बाइपास, wr_data को सीधे पढ़ने वाले आउटपुट के इनपुट तक पहुँचाता है। पोर्ट $i$ की टक्कर की शर्त है:

$\mathrm{rd\_en}_i=1$ होने पर उत्तर है:

$M^{-}$ एज के ठीक पहले का संग्रहीत मान है। $H_i$ हर पढ़ने के पते से स्वतंत्र तुलना करता है। एक पोर्ट की टक्कर पर दोनों आउटपुटों को लेखन डेटा भेजने से दूसरे पते का ऑपरेंड भी गलत बदल जाएगा। wr_en को शर्त से हटाने पर वास्तव में लेखन न होने वाले चक्र में भी wr_addr संयोग से मिलने पर गलत बाइपास होगा।

module regfile8x16_2r1w (
  input  logic        clk, rst, wr_en,
  input  logic [2:0]  wr_addr,
  input  logic [15:0] wr_data,
  input  logic        rd_en0, rd_en1,
  input  logic [2:0]  rd_addr0, rd_addr1,
  output logic [15:0] rd_data0, rd_data1,
  output logic        rd_valid0, rd_valid1
);
  timeunit 1ns;
  timeprecision 1ps;
  logic [15:0] mem [0:7];

  always_ff @(posedge clk) begin
    if (rst) begin
      rd_valid0 <= 1'b0;
      rd_valid1 <= 1'b0;
    end else begin
      rd_valid0 <= rd_en0;
      rd_valid1 <= rd_en1;
      if (wr_en)
        mem[wr_addr] <= wr_data;
      if (rd_en0)
        rd_data0 <= (wr_en && wr_addr == rd_addr0)
                  ? wr_data : mem[rd_addr0];
      if (rd_en1)
        rd_data1 <= (wr_en && wr_addr == rd_addr1)
                  ? wr_data : mem[rd_addr1];
    end
  end
endmodule

यह बाइपास इनपुट चयन बदलता है, लेकिन आउटपुट का रजिस्टर चरण नहीं हटाता। पता और अनुरोध एज से पहले दें, उत्तर एज के बाद देखें। अगला रजिस्टर उत्तर अगले उर्ध्वगामी एज पर ले सकता है। संयोजी पढ़ने वाली रजिस्टर फाइल बनाने पर पते से आउटपुट तक का मार्ग और विलंब अनुबंध भी बदलता है; इसे केवल छोटा कोड लिखना न मानें।

उदाहरण: केवल एक पोर्ट में टक्कर

मान लें पहले M[2]=12,M[5]=7 लिखे हैं। E0 से ठीक पहले दोनों पढ़ने के enable सक्रिय करें और rd_addr0=2,rd_addr1=5,wr_en=1,wr_addr=2,wr_data=20 दें। E0 के बाद पोर्ट 0 बाइपास हुआ 20 और पोर्ट 1 संग्रहीत 7 देता है। इन दो मान्य उत्तरों को जोड़ने पर 27 मिलता है। बिना बाइपास वाले read-first कार्यान्वयन का उत्तर 19 होगा।

E1 पर दोनों पढ़ने के पते 2 करके वहीं 30 लिखें। दोनों आउटपुट 30 हैं। E2 पर wr_en=0,wr_addr=2,wr_data=99 रखकर पता 2 पढ़ें तो दोनों आउटपुट 30 होने चाहिए। केवल पता मिलने से बाइपास करने की गलती इस एक चक्र से दिख जाती है। E3 पर rd_en0=0,rd_en1=1 हो तो पोर्ट 0 का valid=0 और पोर्ट 1 का valid=1 है।

हर स्तंभ एक उर्ध्वगामी एज^{iउदयी किनारा (rising edge) क्लॉक के 0 से 1 होने का क्षण। यह CLK=1 के पूरे स्तर-अंतराल से अलग है। और जानें} का अवलोकन है। इनपुट एज से ठीक पहले के और “एज के बाद” नाम वाली अवस्थाएँ अपडेट के ठीक बाद की हैं। स्तंभों का संरेखण नमूनों का क्रम है, भौतिक प्रसार विलंब^{iप्रसार विलंब इनपुट बदलने के बाद आउटपुट सही मान पर स्थिर होने तक का समय। तार्किक समतुल्यता और समय-संबंधी गुण अलग हैं। और जानें} नहीं। पहले से M[2]=12,M[5]=7 रखे हैं और दोनों पढ़ने के enable हमेशा 1 हैं। लिखने का पता 2 है। अंतिम स्तंभ में wr_en=0 है, इसलिए wr_data=99 बाइपास नहीं होना चाहिए।

किसका आरंभीकरण आवश्यक है

Active-high तुल्यकालिक reset लेखन रोकता है और दोनों valid को 0 करता है। सरणी और आउटपुट डेटा reset नहीं होते। इसलिए reset के बाद आउटपुट बस पुराना मान रखे तो भी valid=0 होने पर यह सामान्य है। सरणी में पहले से रखा डेटा इस RTL reset से नहीं मिटता। यदि सिस्टम reset के बाद केवल नया काम स्वीकार करता है, तो उस काम का आरंभीकरण क्रम अलग तय करें।

किसी पते पर पहली बार लिखते हुए उसी एज पर पढ़ें तो इस कार्यान्वयन का बाइपास नया मान परिभाषित कर सकता है। लेकिन बिना लिखे कभी आरंभ न हुए पते को पढ़ना अभी भी अपरिभाषित है। rd_valid अनुरोध के उत्तर का समय बताता है; यह हर पते का initialized बिट नहीं है। सामान्य पढ़ने का अपेक्षित मान बनाने से पहले सत्यापक जाँचे कि उस पते का मान ज्ञात है, और उसी एज के बाइपास को अलग सँभाले।

सत्यापन में दो पढ़ने वाले enable की चार अवस्थाएँ, पते समान या अलग, लेखन से कोई पोर्ट न टकराना, केवल पोर्ट 0, केवल पोर्ट 1 या दोनों का टकराना, लगातार लेखन और reset की प्राथमिकता शामिल हैं। कई लिखने वाले पोर्ट इस पाठ के दायरे से बाहर हैं। उन्हें जोड़ने पर पहले तय करना होगा कि एक ही पते पर दो लेखन टकराएँ तो किसे प्राथमिकता मिलेगी। पोर्ट संख्या बदलने से कार्य का अनुबंध और संसाधन लागत दोनों बदलते हैं।