generate: लूप से स्थिर परिपथ बनाना

लूप इंस्टेंस बनाता है, क्लॉक चक्र नहीं

genvar/generate निष्पादन से पहले स्थिर संरचना दोहराते हैं। always_comb लूप प्रक्रियात्मक गणना बताता है जिसका हार्डवेयर संश्लेषण तय करता है। कोई अपने आप हर क्लॉक एक iteration नहीं बताता; क्रमिक प्रक्रिया को अवस्था और नियंत्रक चाहिए। packed बस को LANES शब्दों में बाँटते हैं, हर शब्द W बिट और अलग parity रखता है। दोनों पैरामीटर धनात्मक हैं।

module lane_parity #(
  parameter integer W = 8,
  parameter integer LANES = 3
) (
  input  logic [W*LANES-1:0] data,
  output logic [LANES-1:0] parity
);
  genvar lane;
  generate
    for (lane = 0; lane < LANES; lane = lane + 1) begin : g_lane
      wire [W-1:0] word_data;
      assign word_data = data[lane*W +: W];
      assign parity[lane] = ^word_data;
    end
  endgenerate
endmodule

data[base +: W], base से बढ़ते सूचकांकों की ओर W बिट चुनता है; W स्थिर है। W=8, LANES=3 पर 7:0 lane 0,15:8 lane 1 और 23:16 lane 2 है। g_lane स्थिर पदानुक्रम देता है, जैसे g_lane[1].word_data।

lane क्रम पढ़ें

data=24'h03_01_80 में lane 0 से 80,01,03 हैं। Parity 1,1,0 से parity[2:0]=011 बनता है। बायाँ byte lane 2 है। सूचकांक, दिखावट और प्रेषण अलग रखें। सभी एक साथ गणना करते हैं, रजिस्टर विलंब नहीं है। अधिक LANES से तर्क बढ़ता है, चक्र नहीं; fanout, routing और भौतिक timing अलग जाँच हैं।

generate-if स्थिर संरचना चुनता है

शर्त स्थिर है, जैसे रजिस्टर जोड़ने का पैरामीटर। गतिशील सिग्नल संयोजन या क्लॉक ब्लॉक में जाता है। रजिस्टर जोड़ना वैध समय बदलता है, इसलिए अनुबंध और checker बदलें। बस बंद करने को शून्य न दें:[−1:0] सुरक्षित शून्य-चौड़ाई वस्तु नहीं। कॉन्फ़िगरेशन अस्वीकार करें या स्थिर शाखा में स्पष्ट इंटरफ़ेस बनाए रखें।

अभ्यास: बदली lane पकड़ें

उदाहरण जाँचें, फिर हर lane में एक बिट चालू करें: केवल संबंधित parity बदले। दो चालू बिट सम parity 0 देते हैं। हर lane में समान डेटा होने से बदली slice छिपती है। संदर्भ में lane संख्यात्मक रूप से निकालकर 1 गिनें। W=1,8 और LANES=1,3 से न्यूनतम, byte और पदानुक्रम जाँचें। फिर parity रजिस्टर में रखें और reset, enable तथा वर्तमान या पिछले किनारे पर पकड़ी बस से तुलना तय करें।