Adding external constraints to class object

[eliran-arbili]

Hi,
I'm starting to play with pyvsc and I'm trying to convert some SV code we have to python.
Here is a simplified example of the code I'm trying to convert:

class base_constraints_class;
endclass

class base_rand_class;
    rand base_constraints_class constraints[$];
    function void add_constraints(base_constraints_class c);
        constraints.push_back(c);
    endfunction : add_constraints
endclass

class user_rand_class extends base_rand_class ;
    rand int a,b,d;
   
    
    constraint ab_c {
        a inside {[1:1000]};
        b inside {[1000:2000]};
        d inside {[0:5]};
    }
endclass

class user_constraints_class extends base_constraints_class;
    rand user_rand_class ptr;
    function new(user_rand_class ptr);
        this.ptr = ptr;
    endfunction
    constraint my_ptr_c {
        ptr.a == 8;
        ptr.b == 1999;
    }
endclass

module test();
    initial begin
        user_rand_class usr1 = new();
        user_constraints_class c = new(usr1);
        usr1.add_constraints(c);
        usr1.randomize();
        $display("usr1.a=%0d, usr1.b=%0d, usr1.d=%0d", usr1.a, usr1.b, usr1.d);
    end
endmodule

**Output with VCS:
usr1.a=8, usr1.b=1999, usr1.d=2**

I tried to implement same idea with pyvsc but without success so far.
Any idea what is wrong?:

@vsc.randobj
class base_constraints_class(object):
    pass


@vsc.randobj
class base_rand_class(object):
    def __init__(self, name):
        self.name = name
        self.constraints = vsc.rand_list_t(base_constraints_class(), 0)

    def add_constraints(self, c):
        self.constraints.append(c)

    
@vsc.randobj
class user_constraints_class(base_constraints_class):
    def __init__(self, ptr):
        self.ptr = vsc.rand_attr(ptr)

    @vsc.constraint
    def my_ptr_c(self):
        self.ptr.a == 8
        self.ptr.b == 1999


@vsc.randobj
class user_rand_class(base_rand_class):
    def __init__(self, name):
        super().__init__(name)
        self.a = vsc.rand_bit_t(16)
        self.b = vsc.rand_bit_t(16)


    @vsc.constraint
    def ab_c(self):
        self.a in vsc.rangelist(vsc.rng(1,1000))
        self.b in vsc.rangelist(vsc.rng(1000,2000))

    def print_fields(self):
        print(f"{self.name}: a={self.a}, b={self.b}")


def main(argv):
    usr1 = user_rand_class("user_1")
    c = user_constraints_class(usr1)
    usr1.add_constraints(c)
    usr1.randomize(debug=0)
    print("--------------------\n")
    usr1.print_fields()


if __name__ == "__main__":
    main(sys.argv[1:])

Failing on:

((self.is_declared_rand and self.rand_mode) or level==0))
RecursionError: maximum recursion depth exceeded

[alwilson]

@eliran-arbili I think your example should work, but I think the constraints list in the base_rand_class and ptr within user_constraints_class are causing recursion issues. I believe when pyvsc walks down the rand variables it keeps self-referencing via the ptr. I tried debugging in vscode and even trying to look at the object causes it to crash...

Also, wrapping up your examples in code blocks would be helpful. The double underscores and indentations for python were lost in the conversion. You can add systemverilog and python3 after the opening tripple-backticks to get syntax highlighting as well.

I've re-written your example into something that doesn't self-reference the constraints list, but hopefully is close to what you were accomplishing in SV!

@vsc.randobj
class base_constraints_class(object):
    pass

@vsc.randobj
class base_rand_class(object):
    def __init__(self, name):
        self.name = name
        self.user = vsc.rand_attr(user_rand_class(name))
        self.constraints = vsc.rand_list_t(base_constraints_class())

    def add_constraints(self, c):
        self.constraints.append(c)

@vsc.randobj
class user_constraints_class_a(base_constraints_class):
    def __init__(self, ptr):
        self.ptr = vsc.rand_attr(ptr)

    @vsc.constraint
    def my_ptr_c(self):
        self.ptr.a == 8

@vsc.randobj
class user_constraints_class_b(base_constraints_class):
    def __init__(self, ptr):
        self.ptr = vsc.rand_attr(ptr)

    @vsc.constraint
    def my_ptr_c(self):
        self.ptr.b == 1999

@vsc.randobj
class user_rand_class(object):
    def __init__(self, name):
        self.name = name
        self.a = vsc.rand_bit_t(16)
        self.b = vsc.rand_bit_t(16)

    @vsc.constraint
    def ab_c(self):
        self.a in vsc.rangelist(vsc.rng(1,1000))
        self.b in vsc.rangelist(vsc.rng(1000,2000))

    def print_fields(self):
        print(f"{self.name}: a={self.a}, b={self.b}")

def main(argv):
    usr1 = base_rand_class("user_1")
    usr1.add_constraints(user_constraints_class_a(usr1.user))
    usr1.add_constraints(user_constraints_class_b(usr1.user))
    usr1.randomize(debug=0)
    print("--------------------\n")
    usr1.user.print_fields()

if __name__ == "__main__":
    main(sys.argv[1:])

--------------------

user_1: a=8, b=1999

[eliran-arbili]

@alwilson
I edited my original post. thanks !
The relation between user_rand_class and base_rand_class must be with inheritance only.
The idea is to keep the base class generic, so unfortunately the solution will not work for me.
Logically thinking, there is indeed a recursion here since each object holds each other pointer and they both randomizing each other, but it works in all SV main simulators so somehow the solver has a stop condition that doesn't exists here.

[alwilson]

@eliran-arbili Yeah, it did lose the inheritance bit. It could work by passing the type into the class constructor, but then it's a class template/wrapper still and not inheritance. I did think of trying things with dynamic constraints. There may be a way to build up dynamic constraints and apply them all via the base class without recursion.

I looked through the PyVSC unit tests and I didn't really see anything that matches up with the style you're going for. I think there either needs to be some recursion detection PyVSC needs to do, or there's a proper way of wrapping up that ptr we aren't doing. @mballance would know! ;)

[eliran-arbili]

@alwilson
I spoke with Synopsys AE and he said that when an object has to be randomized, then there is a check if the object is already under randomize in the call stack, so in this case preventing endless recursion loop.
I wasn't able to debug the pyvsc code since for some reason it got stuck when I try to step-into the f.set_used_rand call.
So just wonder what is the root-cause analysis here and if it would get fixed.

[mballance]

Hi @eliran-arbili, @alwilson,
Thanks for digging into this one. I had a look and can confirm that, indeed, the recursion is caused by assigning user_constraints_class.ptr to an externally-constructed PyVSC object. The example works if I locally construct a user_rand_class locally to assign to the ptr field.

I'll continue looking into this, since I do expect this case to work (ie there's nothing inherently broken about the pattern).

-Matthew

[eliran-arbili]

Hi @mballance
Do you think it will be fixed anytime soon?

[mballance]

Hi @eliran-arbili, the core issue is that there's a recursive relationship between the two classes and PyVSC wasn't originally designed to support this. I had thought that it wouldn't be realistic to support this using the existing PyVSC implementation, but after revisiting, I believe it can be done. I've released version 0.8.9 that allows your testcase to run. I haven't attempted to validate that it is behaving as you expect -- it may not.

It's probably also worth revisiting what you "really" want here. The SystemVerilog implementation of dynamically-layered constraints is necessitated by the SystemVerilog language features. It's quite possible that there is a easier/simpler/lighter-weight approach enabled by Python. So, I would be interested in understanding the your usecase here!

[eliran-arbili]

Hi @mballance ,
The main goal in this design is to separate between the random variables to the constraints, thus allowing different flavors of constraints classes to be applied without the need to change anything in the random variables container class.
I have tried the new version and it seems to work on the example I provided, so much thanks for that!
I will update if I find another issues.