En el siguiente código, ¿por qué se modifica el valor semilla cada vez que ingresa al ciclo? enlace
module Tb();
integer num,seed,i,j;
initial
begin
seed = 0;
for(j = 0;j<10 ;j=j+1)
begin
num = { $random(seed) } % 10;
$write("| num=%2d |",num);
$display(" seed is %d ",seed);
end
end
endmodule
Considere los siguientes dos módulos de ejemplo:
module test_1;
integer seed_a = 123, seed_b = 123, seed_c = 123;
initial begin
$display("A1: %d", $random(seed_a));
$display("A2: %d", $random(seed_a));
$display("A3: %d", $random(seed_a));
$display("B1: %d", $random(seed_b));
$display("B2: %d", $random(seed_b));
$display("B3: %d", $random(seed_b));
$display("C1: %d", $random(seed_c));
$display("C2: %d", $random);
$display("C3: %d", $random);
$display("%d %d %d", seed_a, seed_b, seed_c);
end
endmodule
module test_2;
initial begin
$display("X1: %d", $random);
$display("X2: %d", $random);
$display("X3: %d", $random);
end
endmodule
El primero producirá el siguiente resultado:
$ iverilog -s test_1 test.v && ./a.out
A1: -2138988031
A2: 511825213
A3: -650842958
B1: -2138988031
B2: 511825213
B3: -650842958
C1: -2138988031
C2: 303379748
C3: -1064739199
1496640334 1496640334 8495488
Y el segundo el siguiente:
$ iverilog -s test_2 test.v && ./a.out
X1: 303379748
X2: -1064739199
X3: -2071669239
(El código C para $ random es parte del estándar de Verilog. Por lo tanto, debe garantizarse que los valores sean los mismos para cada implementación. Lo cual es un problema en sí mismo porque el Verilog RNG estandarizado no es muy bueno .)
¿Qué podemos ver de esto? A diferencia de la función srandom () de C stdlib que establece una variable de estado interna a la implementación aleatoria de C (C), el argumento semilla aleatorio Verilog $ hace que la variable pasada se use como variable de estado RNG. La variable de estado predeterminada interna a $ aleatoria no se ve afectada por dicha llamada a $ aleatoria. Imo el argumento "semilla" es un nombre inapropiado. Debería llamarse "estado" en su lugar.
En test_2 llamamos $ random tres veces sin un argumento semilla. Entonces vemos la secuencia de números generados por $ random cuando se usa su variable de estado interno (la variable de estado interno se inicializa a 0 btw).
En test_1 primero llamamos $ random tres veces con seed_a. Cada una de esas llamadas realizará un giro del algoritmo RNG, devolverá una variable aleatoria y establecerá seed_a al nuevo estado interno. Luego, hacemos lo mismo con seed_b y obtenemos la misma secuencia de números (y el mismo estado final en state_b).
Finalmente, tratamos de usar $ random (seed_c) en un intento de establecer la variable de estado interna y asumimos que se usará en llamadas subsiguientes, como es de esperar para un "valor de semilla" de las API de otros idiomas. pero esto falla En cambio, vemos los mismos números en las llamadas subsiguientes que obtendríamos si solo usáramos $ random por primera vez: los números subsiguientes coinciden con los números producidos por test_2.
En resumen: el argumento "semilla" para $ aleatorio no solo pasa un valor semilla, sino que especifica la variable de estado para el RNG. Por lo tanto, no solo leerá el valor semilla de este argumento sino que también escribirá su nuevo estado (también conocido como "nuevo valor semilla") en la variable. Esta es la razón por la que no puede llamar $ aleatorio con una constante como valor semilla. Debes especificar una variable.
$ random genera un entero aleatorio cada vez que se llama. Si la secuencia debe ser repetible, la primera vez que se invoca al azar Dale un argumento numérico (una semilla). De lo contrario se deriva la semilla. del reloj de la computadora.
Sintaxis
xzz = $ random [(integer)];
Por lo tanto, " semilla " se vuelve a generar en cada iteración del bucle.
Lea otras preguntas en las etiquetas verilog