In its simplest form, a constraint is nothing more than a Boolean expression with random variables where the solver is asked to find values that make the expression true. One way of thinking about how a constraint solver works is that it repeatedly tries different values until the values make the expression true, then it writes those values into the set of random variables. It\u2019s actually much more complicated than that because we want the solver to quickly converge on a solution or tell us no solution is possible without wasting a lot of time. But let\u2019s just focus on the expression evaluation.<\/p>\n
A fundamental principle that drove SystemVerilog\u2019s development was unifying semantics so that expression evaluation was identical across all facets of the language. This meant all the idiosyncrasies from Verilog\u2019s weak type and expression evaluation systems got absorbed into constraint expressions. One of the unique things that distinguishes Verilog from most other programming languages is its ability to declare variables of different bit-widths and have expressions of mixed bit-widths. The weak type system means it silently truncates and pads different bit widths without any notice of overflow or underflow. This system also has to deal with signed and unsigned arithmetic, and real to integer truncation.<\/p>\n
Let\u2019s look at the following two seemingly equivalent expressions:<\/p>\n
Expression A: Expression B: \u00a0 If we remember our elementary algebra, the division property of equality says we should be able to divide both sides of the equality in Expression A by 4 and wind up with Expression B. You would think using either expression in a constraint gives the exact same results. NOT TRUE<\/em>. Each expression has a complex series of steps for determining the bit width of an expression result and all the intermediate operations. We need to be aware of this even when we think everything has the same bit-widths.<\/p>\n For Expression A, suppose we declared X and Y as 32-bit unsigned variables (the numeric literal 4 is also considered 32-bits. Verilog has a table for every operator that specifies the resulting width its result. For all arithmetic operators the result width is the size of its largest operand, not the width of the largest possible result which would be 34 bits in this case. This means the result of The solution space for\u00a0 <\/p>\n The fix for this is making sure the width of the multiplication result is large enough not to truncate using :\u00a0 For expression B, the bit-widths are not as precarious. \u00a0But we do need to understand Verilog integer division truncates any fractional part towards 0, it does not round. That means there will be for consecutive values for Y associated with one value of X.\u00a0The solution space for\u00a0 <\/p>\n To summarize, I’ve show a simple example of how Verilog expression evaluation rules affect the solution space of your SystemVerilog constraints. So anytime you get unexpected values from the constraint solver, go back to your textbooks on Verilog or even Algebra to remember how expressions get evaluated.<\/p>\n","protected":false},"excerpt":{"rendered":" In its simplest form, a constraint is nothing more than a Boolean expression with random variables where the solver is…<\/p>\n","protected":false},"author":71589,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spanish_translation":"","french_translation":"","german_translation":"","italian_translation":"","polish_translation":"","japanese_translation":"","chinese_translation":"","footnotes":""},"categories":[1],"tags":[395,533,751,822,831],"industry":[],"product":[],"coauthors":[],"class_list":["post-13914","post","type-post","status-publish","format-standard","hentry","category-news","tag-constrained-random-simulation","tag-ieee-1800","tag-systemverilog","tag-verification-engineer","tag-verilog"],"_links":{"self":[{"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/posts\/13914","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/users\/71589"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/comments?post=13914"}],"version-history":[{"count":1,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/posts\/13914\/revisions"}],"predecessor-version":[{"id":19886,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/posts\/13914\/revisions\/19886"}],"wp:attachment":[{"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/media?parent=13914"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/categories?post=13914"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/tags?post=13914"},{"taxonomy":"industry","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/industry?post=13914"},{"taxonomy":"product","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/product?post=13914"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/verificationhorizons\/wp-json\/wp\/v2\/coauthors?post=13914"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}(X * 4) == Y
\n<\/code><\/p>\nX == (Y \/4)<\/code><\/p>\n32\u2019h40000001*32\u2019d4<\/code> gets truncated to 32\u2019h00000004<\/code>. So, the solver could choose either 32\u2019h40000001<\/code> or 32\u2019h00000001<\/code> for X when choosing the value 32'h00000004<\/code> for Y.<\/p>\n(X * 32'd4) == Y<\/code>is shown in the following table.<\/p>\n\n\n
\n X<\/th>\n Y<\/th>\n<\/tr>\n \n 32'h00000000<\/code><\/td>\n32'h00000000<\/code><\/td>\n<\/tr>\n\n 32'h00000001<\/code><\/td>\n32'h00000004<\/code><\/td>\n<\/tr>\n\n 32'h00000002<\/code><\/td>\n32'h00000008<\/code><\/td>\n<\/tr>\n\n \u2026<\/td>\n<\/tr>\n \n 32\u2019h3FFFFFFF<\/code><\/td>\n32'hFFFFFFFC<\/code><\/td>\n<\/tr>\n\n 32'h40000000<\/code><\/td>\n32'h00000000<\/code><\/td>\n<\/tr>\n\n 32'h40000001<\/code><\/td>\n32'h00000004<\/code><\/td>\n<\/tr>\n\n \u2026<\/td>\n<\/tr>\n \n 32\u2019hFFFFFFFF<\/code><\/td>\n32'hFFFFFFFC<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n(X * 34\u2019d4) == Y<\/code>. That eliminates the overflow truncation and the second set of unexpected solutions.<\/p>\nX == (Y \/ 4)<\/code> is shown in the following table.<\/p>\n\n\n
\n X<\/th>\n Y<\/th>\n<\/tr>\n \n 32'h00000000<\/code><\/td>\n32'h00000000<\/code><\/td>\n<\/tr>\n\n 32'h00000000<\/code><\/td>\n32'h00000001<\/code><\/td>\n<\/tr>\n\n 32'h00000000<\/code><\/td>\n32'h00000002<\/code><\/td>\n<\/tr>\n\n 32\u2019h00000000<\/code><\/td>\n32'h00000003<\/code><\/td>\n<\/tr>\n\n 32'h40000001<\/code><\/td>\n32'h00000004<\/code><\/td>\n<\/tr>\n\n 32'h40000001<\/code><\/td>\n32'h00000005<\/code><\/td>\n<\/tr>\n\n \u2026<\/td>\n<\/tr>\n \n 32\u2019h3FFFFFFF<\/code><\/td>\n32'hFFFFFFFF<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n