המילה $vec$ אינה מילה שמורה ולכן $1$ לא נכון.
אנו רוצים וקטור באורך 8 ולא 9 ולכן $3$ לא נכון.
כעת יש לנו שתי אפשרויות - אפשרות $2$ לא נותנת שגיאות קומפילציה אבל היא לא מגדירה מערך כמו שאנחנו רוצים - אז אל תעשו את זה.
לכן, התשובה הנכונה היא $4$.

יצוג מספרים

ב-$SystemVerilog$, בגלל שאנחנו עובדים בחוטים אנו יכולים לעבוד רק עם $0$ ו-$1$ אך בני אדם לא אוהבים לעבוד בבינארית, אלא אוהבים לעבוד בבסיס $10$.
לשם כך, ב-$SystemVerilog$ לכל מספר נוכל להגדיר את מספר הביטים שהוא יקח, האם הוא בעל סימן, באיזה בסיס הוא כך:

<width'><signed><radix> value

כאשר הברירת מחדל לערכים אלה היא אורך של 322 ביטים, מספר ללא סימן המייוצג בבסיס 10.
האופציות שיש לנו ל-$radix$ הן:

• בינארי - $b \; or\; B$
• בסיס שמונה - $o\; or\; O$
• עשרוני - $d\; or\; D$
• הקסה - $h\; or\;H$

logic [7:0] out; 
logic [3:0] A; 
out = {{4{1'b0}}, A[3:0]};

פעולות על ביטים

ישנן כמה פעולות בינאריות/אונריות שאנו יכולים לבצע על ביטים והן:

1. שער 'וגם': $\&$
2. שער 'או': $|$
3. שער היפוך($NOT$): $\sim$
4. שער $XOR$: ^
5. שער $XNOR$: ^ או ^

הפעולות נעשות על ביטים יחידים בלבד!

הזזות ביטים

נוכל להזיז ביטים ימינה עם $>>$ או שמאלה עם $<<$.

a = 4'b1010;
b = a << 2; // b = 4'b1000
c = a >> 1; // c = 4'b0101

קדימות פעולות

בניית מודולים

לצערנו, לא כל המודולים שאנחנו רוצים שיהיו קיימים, קיימים. לכן, נדרש לדעת איך לממש בעצמנו מודול.

השמות

כאן אנו מחברים חוטים ואומרים באופן די מפורש מה הערך שאנו רוצים שיתקבל.

logic  signal;
assign signal = 1'b0;

ברגע שאנו עושים את זה אנחנו בעצם לקחנו את החוט שלנו וחיברנו אותו למקור מתח המוציא את הערך הנתון - במקרה הזה הוא 0.
אם ננסה גם לחבר עכשיו מתח גבוה אז בעצם המחשב יתפוצץ.

logic  signal1;
logic  signal2;
assign = signal2 = signal1;

פה אנחנו פשוט מאריכים את החוט $signal1$ עד לחוט $signal2$.
זה לא נשמע מאוד שימושי אך בהמשך נראה מתי זה כן יהיה שימושי.

module and_module (
	output logic Z,
	input  logic A,
	input  logic B
);
	assign Z = (A & B) | C;
endmodule

תהליכים

נוכל להשתמש במילה $initial$ כדי להגדיר בלוק אשר מה שיש בו יקרה רק פעם אחת.

initial begin
	<statement1>;
	#time_to_wait
	<statement2>;
	#time_to_wait
	...
end

module mymodule_tb;
	logic a;
	logic out;
	mymodule uut (
		.a(a),
		.out(out)
	);
	
	initial begin
		a = 1'b0;
		#5
		a = 1'b1;
		#5
		a = 1'b0;
	end
endmodule

נוכל בנוסף להשתמש במילה $always\_comb$ אשר מאפשר לנו לבצע דברים שמתקיימים תמיד.
זה עוזר לנו לממש חומרה כדי להגיד שהדבר הזה תמיד קיים שם.

always_comb begin
	<statement1>;
	<statement1>;
end

כאשר אנו ממשים חומרה עם $always\_comb$ זה כמו לעשות $assign$.
בסדנאות הבאות אנו נראה איך זה בדיוק שונה.

module add_module (
	output logic Z,
	input  logic A,
	input  logic B
);
	always_comb begin
		Z = A & B;
	end
endmodule

module shift_module (
	output logic [3:0] out,
	input  logic [3:0] a
);
	always_comb begin
		out = a << 2;
	end
endmodule

פרמטרים

פרמטרים הם בעצם משתנים שניתן להכניס למודולים ומאפשרים לנו לשנות את התנהגות המודול באופן דינמי.
הפרמטרים הם לא באמת חוט אלא הוא איזשהו תכונה של האלמנטים הפיזיים.

הגדרה:

module module_name ( 
	output logic out1, 
	..., 
	input logic in1 
); 

parameter param1 = 1; 
parameter param2 = 2; 
parameter param3 = 3; 
... 
endmodule

שימוש:

module_name #( 
	.param1(value1), 
	.param2(value2), 
	.param3(value3) 
) instname ( 
	.in1(in1), 
	... 
	.out1(out1)
);

module shift_N ( 
	output logic [3:0] out, 
	input  logic [3:0] a 
); 
	parameter N = 1; 
	always_comb begin 
		out = a << N; 
	end 
endmodule

module shifts ( 
	output logic [3:0] b, 
	output logic [3:0] c, 
	input logic [3:0] a 
); 
	shift_N #( 
		.N(2) 
	) shift_inst1 ( 
		.a(a), 
		.out(b) 
	); 
	shift_N #( 
		.N(3) 
	) shift_inst2 ( 
		.a(a), 
		.out(c) 
	); 
endmodule

קבועים

נוכל להגדיר קבועים כך:

localparam <param_name> = <param_value>;

עיבוד מקבילי בשפות תיאור תוכנה

module my_module ( 
	output logic c 
); 
	logic a; 
	logic b; 
	assign c = a | b; 
	assign a = 1'b0; 
	assign b = 1'b1; 
endmodule

module mux (
	output logic out,
	output logic outn,
	input logic [1:0] in,
	input logic sel
);
	logic out1, out2, selb;
	
	and a1 (out1, in[0], sel);
	not i1 (selb, sel);
	and a2 (out2, in[1], selb);
	always_comb begin
		out = out1 | out2;
	end
	assign outn = ~out;
endmodule