Unique constant per instantiation

if its a constant, you can do whatever maths you want in the function call. So just have a generic called "SEED" or something that then does something inside the f_generate_unique_id function.

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_misc.all;
use ieee.numeric_std.all;
entity rand_test is
  generic 
  (
    SEED  : positive := 22553362
  );
  
  port
  (
    a : in  std_logic;
    b : out std_logic
  );
    
end entity rand_test;
architecture test of rand_test is
  function set_init_val return std_logic_vector is
    
    use ieee.math_real.all;  --for uniform procedure
    
    variable rand         : real;
    variable seed1, seed2 : positive := SEED;
    variable result       : integer;
      
  begin
    uniform(seed1, seed2, rand);
    result := integer(((rand - 0.5) *2.0) * real(integer'high));  --makes random range from integer'low to integer'high by making "rand" range -1 to +1
    
    return std_logic_vector( to_signed(result, 32));
  end function;
  constant C_MYID : std_logic_vector := set_init_val;
  
begin
  b <= a and and_reduce(C_MYID);
  
end test;

The point is that there should be no seed generic. I want a user of the component to be able to copy-paste the instantiation around the project and they still get unique numbers. Otherwise I could just require a unique number as generic parameter.

Hmm, ok, you've set me a challenge....

And the answer is - no. I tried putting a shared variable inside a package with a function that incremented the SV and then returned it. It complained saying my constant wasnt constant (well, technically it is!). I tried to trick it by returning a constant from the fuynction based on the SV, but it wasnt having that either.

BTW: Modelsim has no problems with the code that Quartus doesnt like:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
package temp_pkg is
  impure function set_init_val return signed;
end package;
package body temp_pkg is
  shared variable num : integer := 0;
  impure function set_init_val return signed is
    constant A : integer := num;
  begin
    num := num + 1;
    
    return to_signed(A, 32);
  end function;
end package body;
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_misc.all;
use ieee.numeric_std.all;
use work.temp_pkg.all;
entity rand_test is
  generic 
  (
    SEED  : positive := 123
  );
  
  port
  (
    a : in  signed(31 downto 0);
    b : out boolean
  );
    
end entity rand_test;
architecture test of rand_test is
  constant C_MYID : SIGNED := set_init_val;
  
begin
  b <= (a > C_MYID);
  
end test;

I am somewhat leaning towards the belief that this can't be done. The problem is that a function is supposed to return a value which only depends on its inputs. AFAIK, you can only initialize a constant from a function and not from an impure function or procedure. So ... unless there is a builtin function that does this, I think I'm stuck.

But the value returned by any function is constant, and is generated when the function is called, and my impure function worked without a problem in Modelsim (which is pretty good at LRM compliance). You cannot use a procedure because it doesnt return a value (and hence has to be put in a process/function/another procedure). as it is essentially just a wrapping up of code.

One issue you would have with something like this, is that you would have no control over each component's unique ID, as it depend on the order they were elaborated in. The only way to control this would be via a generic.

I don't care about what ID they get, only that the IDs be distinct.

its constant in that its return by value, rather than reference. So when you call