{"id":455,"date":"2017-01-17T10:00:28","date_gmt":"2017-01-17T18:00:28","guid":{"rendered":"http:\/\/www.verilogpro.com\/?p=455"},"modified":"2022-09-29T00:58:36","modified_gmt":"2022-09-29T07:58:36","slug":"systemverilog-structures-unions-design","status":"publish","type":"post","link":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/","title":{"rendered":"SystemVerilog Struct and Union &#8211; for Designers too"},"content":{"rendered":"\n<p>SystemVerilog struct (ure) and union are very similar to their C programming counterparts, so you may already have a good idea of how they work. But have you tried using them in your RTL design? When used effectively, they can simplify your code and save a lot of typing. Recently, I tried incorporating SystemVerilog struct and union in new ways that I had not done before with surprisingly (or not surprisingly?) good effect. In this post I would like to share with you some tips on how you can also use them in your RTL design.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">What is a SystemVerilog Struct (ure)?<\/h2>\n\n\n\n<p>A SystemVerilog struct is a way to group several data types. The entire group can be referenced as a whole, or the individual data type can be referenced by name. It is handy in RTL coding when you have a collection of signals you need to pass around the design together, but want to retain the readability and accessibility of each separate signal.<\/p>\n\n\n\n<p>When used in RTL code, a <strong>packed<\/strong> SystemVerilog struct is the most useful. A packed struct is treated as a single vector, and each data type in the structure is represented as a bit field. The entire structure is then packed together in memory without gaps. Only packed data types and integer data types are allowed in a packed struct. Because it is defined as a vector, the entire structure can also be used as a whole with arithmetic and logical operators.<\/p>\n\n\n\n<p>An <strong>unpacked<\/strong> SystemVerilog struct, on the other hand, does not define a packing of the data types. It is tool-dependent how the structure is packed in memory. Unpacked struct probably will not synthesize by your synthesis tool, so I would avoid it in RTL code. It is, however, the default mode of a structure if the <strong>packed<\/strong> keyword is not used when defining the structure.<\/p>\n\n\n\n<p>SystemVerilog struct is often defined with the <strong>typedef<\/strong> keyword to give the structure type a name so it can be more easily reused across multiple files. Here is an example:<\/p>\n\n\n\n<pre class=\"wp-block-preformatted lang:default decode:true\">typedef enum logic[15:0]\n{\n  ADD = 16'h0000,\n  SUB = 16'h0001\n} my_opcode_t;\n\ntypedef enum logic[15:0]\n{\n  REG = 16'h0000,\n  MEM = 16'h0001\n} my_dest_t;\n\ntypedef struct packed\n{\n  my_opcode_t  opcode; \/\/ 16-bit opcode, enumerated type\n  my_dest_t    dest; \/\/ 16-bit destination, enumerated type\n  logic [15:0] opA;\n  logic [15:0] opB;\n} my_opcode_struct_t;\n\nmy_opcode_struct_t cmd1;\n\ninitial begin\n  \/\/ Access fields by name\n  cmd1.opcode &lt;= ADD;\n  cmd1.dest &lt;= REG;\n  cmd1.opA &lt;= 16'h0001;\n  cmd1.opB &lt;= 16'h0002;\n\n  \/\/ Access fields by bit position\n  cmd1[63:48] &lt;= 16'h0000\n  cmd1[47:32] &lt;= 16'h0000;\n  cmd1[31:16] &lt;= 16'h0003;\n  cmd1[15: 0] &lt;= 16'h0004;\n\n  \/\/ Assign fields at once\n  cmd1 &lt;= '{SUB, REG, 16'h0005, 16'h0006};\nend<\/pre>\n\n\n\n<script async=\"\" src=\"https:\/\/pagead2.googlesyndication.com\/pagead\/js\/adsbygoogle.js?client=ca-pub-9720137902431811\" crossorigin=\"anonymous\"><\/script>\n<ins class=\"adsbygoogle\" style=\"display:block; text-align:center;\" data-ad-layout=\"in-article\" data-ad-format=\"fluid\" data-ad-client=\"ca-pub-9720137902431811\" data-ad-slot=\"7477548078\"><\/ins>\n<script>\n     (adsbygoogle = window.adsbygoogle || []).push({});\n<\/script>\n\n\n\n<h2 class=\"wp-block-heading\">What is a SystemVerilog Union?<\/h2>\n\n\n\n<p>A SystemVerilog union allows a single piece of storage to be represented different ways using different named member types. Because there is only a single storage, only one of the data types can be used at a time. Unions can also be <strong>packed<\/strong> and <strong>unpacked<\/strong> similarly to structures. Only packed data types and integer data types can be used in packed union. All members of a packed (and untagged, which I&#8217;ll get to later) union must be the same size. Like packed structures, packed union can be used as a whole with arithmetic and logical operators, and bit fields can be extracted like from a packed array.<\/p>\n\n\n\n<p>A <strong>tagged<\/strong> union is a type-checked union. That means you can no longer write to the union using one member type, and read it back using another. Tagged union enforces type checking by inserting additional bits into the union to store how the union was initially accessed. Due to the added bits, and inability to freely refer to the same storage using different union members, I think this makes it less useful in RTL coding.<\/p>\n\n\n\n<p>Take a look at the following example, where I expand the earlier SystemVerilog struct into a union to provide a different way to access that same piece of data.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted lang:default decode:true\">typedef union packed\n{\n  my_opcode_struct_t opcode_s; \/\/ \"fields view\" to the struct\n  logic[1:0][31:0] dword; \/\/ \"dword view\" to the struct\n} my_opcode_union_t;\n\nmy_opcode_union_t cmd2;\n\ninitial begin\n  \/\/ Access opcode_s struct fields within the union\n  cmd2.opcode_s.opcode = ADD;\n  cmd2.opcode_s.dest = REG;\n  cmd2.opcode_s.opA = 16'h0001;\n  cmd2.opcode_s.opB = 16'h0002;\n\n  \/\/ Access dwords struct fields within the union\n  cmd2.dword[1] = 32'h0001_0001; \/\/ opcode=SUB, dest=MEM\n  cmd2.dword[0] = 32'h0007_0008; \/\/ opA=7, opB=8\nend\n<\/pre>\n\n\n\n<h2 class=\"wp-block-heading\">Ways to Use SystemVerilog Struct in a Design<\/h2>\n\n\n\n<p>There are many ways to incorporate SystemVerilog struct into your RTL code. Here are some common usages.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Encapsulate Fields of a Complex Type<\/h3>\n\n\n\n<p>One of the simplest uses of a structure is to encapsulate signals that are commonly used together into a single unit that can be passed around the design more easily, like the opcode structure example above. It both simplifies the RTL code and makes it more readable. Simulators like Synopsys VCS will display the fields of a structure separately on a waveform, making the structure easily readable.<\/p>\n\n\n\n<p>If you need to use the same structure in multiple modules, a tip is to put the definition of the structure (defined using <strong>typedef<\/strong>) into a SystemVerilog package, then import the package into each RTL module that requires the definition. This way you will only need to define the structure once.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">SystemVerilog Struct as a Module Port<\/h3>\n\n\n\n<p>A module port can have a SystemVerilog struct type, which makes it easy to pass the same bundle of signals into and out of multiple modules, and keep the same encapsulation throughout a design. For example a wide command bus between two modules with multiple fields can be grouped into a structure to simplify the RTL code, and to avoid having to manually decode the bits of the command bus when viewing it on a waveform (a major frustration!).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Using SystemVerilog Struct with Parameterized Data Type<\/h3>\n\n\n\n<p>A structure can be used effectively with modules that support parameterized data type. For example if a FIFO module supports parameterized data type, the entire structure can be passed into the FIFO with no further modification to the FIFO code.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted lang:default decode:true\">module simple_fifo\n(\n  parameter type DTYPE = logic[7:0],\n  parameter      DEPTH = 4\n)\n(\n  input  logic                      clk,\n  input  logic                      rst_n,\n  input  logic                      push,\n  input  logic                      pop,\n  input  DTYPE                      data_in,\n  output logic[$clog2(DEPTH+1)-1:0] count,\n  output DTYPE                      data_out\n);\n  \/\/ rest of FIFO design\nendmodule\n\nmodule testbench;\n  parameter MY_DEPTH = 4;\n\n  logic clk, rst_n, push, pop, full, empty;\n  logic [$clog2(MY_DEPTH+1)-1:0] count;\n  my_opcode_struct_t data_in, data_out;\n\n  simple_fifo\n  #(\n    .DTYPE (my_opcode_struct_t),\n    .DEPTH (MY_DEPTH)\n  )\n  my_simple_fifo (.*);\nendmodule\n<\/pre>\n\n\n\n<script async=\"\" src=\"https:\/\/pagead2.googlesyndication.com\/pagead\/js\/adsbygoogle.js?client=ca-pub-9720137902431811\" crossorigin=\"anonymous\"><\/script>\n<ins class=\"adsbygoogle\" style=\"display:block; text-align:center;\" data-ad-layout=\"in-article\" data-ad-format=\"fluid\" data-ad-client=\"ca-pub-9720137902431811\" data-ad-slot=\"7477548078\"><\/ins>\n<script>\n     (adsbygoogle = window.adsbygoogle || []).push({});\n<\/script>\n\n\n\n<h2 class=\"wp-block-heading\">Ways to Use SystemVerilog Union in a Design<\/h2>\n\n\n\n<p>Until very recently, I had not found a useful way to use a SystemVerilog union in RTL code. But I finally did in my last project! The best way to think about a SystemVerilog union is that it can give you alternative views of a common data structure. The packed union opcode example above has a &#8220;fields view&#8221; and a &#8220;dword view&#8221;, which can be referred to in different parts of a design depending on which is more convenient. For example, if the opcode needs to be buffered in a 64-bit buffer comprised of two 32-bit wide memories, then you can assign one dword from the &#8220;dword view&#8221; as the input to each memory, like this:<\/p>\n\n\n\n<pre class=\"wp-block-preformatted lang:default decode:true\">my_opcode_union_t my_opcode_in, my_opcode_out;\n\n\/\/ Toy code to assign some values into the union\nalways_comb begin\n  my_opcode_in.opcode_s.opcode = ADD;\n  my_opcode_in.opcode_s.dest   = REG;\n  my_opcode_in.opcode_s.opA    = 16'h0001;\n  my_opcode_in.opcode_s.opB    = 16'h0002;\nend\n\n\/\/ Use the \"dword view\" of the union in a generate loop\ngenerate\n  genvar gi;\n  for (gi=0; gi&lt;2; gi=gi+1) begin : gen_mem\n    \/\/ instantiate a 32-bit memory\n    mem_32 u_mem\n    (\n      .D (my_opcode_in.dword[gi]),\n      .Q (my_opcode_out.dword[gi]),\n      .*\n    );\n  end \/\/ gen_mem\nendgenerate<\/pre>\n\n\n\n<p>In my last project, I used a union this way to store a wide SystemVerilog struct into multiple 39-bit memories in parallel (32-bit data plus 7-bit SECDED encoding). The memories were divided this way such that each 32-bit dword can be individually protected by SECDED encoding so it is individually accessible by a CPU. I used a &#8220;dword view&#8221; of the union in a generate loop to feed the data into the SECDED encoders and memories. It eliminated alot of copying and pasting, and made the code much more concise!<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Conclusion<\/h2>\n\n\n\n<p>SystemVerilog struct and union are handy constructs that can encapsulate data types and simplify your RTL code. They are most effective when the structure or union types can be used throughout a design, including as module ports, and with modules that support parameterized data types.<\/p>\n\n\n\n<p>Do you have another novel way of using SystemVerilog struct and union? Leave a comment below!<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">References<\/h2>\n\n\n\n<ul><li><a href=\"https:\/\/standards.ieee.org\/getieee\/1800\/download\/1800-2012.pdf\">IEEE Standard for SystemVerilog 1800-2012<\/a><\/li><\/ul>\n\n\n\n<p>[lab_subscriber_download_form download_id=6].<\/p>\n\n\n\n\n\n\n<script async=\"\" src=\"https:\/\/pagead2.googlesyndication.com\/pagead\/js\/adsbygoogle.js?client=ca-pub-9720137902431811\" crossorigin=\"anonymous\"><\/script>\n<ins class=\"adsbygoogle\" style=\"display:block\" data-ad-format=\"autorelaxed\" data-ad-client=\"ca-pub-9720137902431811\" data-ad-slot=\"3587260091\"><\/ins>\n<script>\n     (adsbygoogle = window.adsbygoogle || []).push({});\n<\/script>\n","protected":false},"excerpt":{"rendered":"<p>SystemVerilog struct (ure) and union are very similar to their C programming counterparts, so you may already have a good idea of how they work. But have you tried using them in your RTL design? When used effectively, they can simplify your code and save a lot of typing. Recently, I tried incorporating SystemVerilog struct &#8230; <a title=\"SystemVerilog Struct and Union &#8211; for Designers too\" class=\"read-more\" href=\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\" aria-label=\"More on SystemVerilog Struct and Union &#8211; for Designers too\">Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":true,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false,"jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false}}},"categories":[3,13],"tags":[26,30,31],"jetpack_publicize_connections":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v22.6 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>SystemVerilog Struct and Union - for Designers too - Verilog Pro<\/title>\n<meta name=\"description\" content=\"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SystemVerilog Struct and Union - for Designers too - Verilog Pro\" \/>\n<meta property=\"og:description\" content=\"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\" \/>\n<meta property=\"og:site_name\" content=\"Verilog Pro\" \/>\n<meta property=\"article:published_time\" content=\"2017-01-17T18:00:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-09-29T07:58:36+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/www.verilogpro.com\/wp-content\/uploads\/2015\/09\/VLSIDesign-thumbnail.png\" \/>\n<meta name=\"author\" content=\"Jason Yu\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@jasonkky\" \/>\n<meta name=\"twitter:site\" content=\"@jasonkky\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jason Yu\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\"},\"author\":{\"name\":\"Jason Yu\",\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af\"},\"headline\":\"SystemVerilog Struct and Union &#8211; for Designers too\",\"datePublished\":\"2017-01-17T18:00:28+00:00\",\"dateModified\":\"2022-09-29T07:58:36+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\"},\"wordCount\":1137,\"commentCount\":4,\"publisher\":{\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af\"},\"keywords\":[\"FIFO\",\"struct\",\"union\"],\"articleSection\":[\"Design\",\"SystemVerilog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\",\"url\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\",\"name\":\"SystemVerilog Struct and Union - for Designers too - Verilog Pro\",\"isPartOf\":{\"@id\":\"https:\/\/www.verilogpro.com\/#website\"},\"datePublished\":\"2017-01-17T18:00:28+00:00\",\"dateModified\":\"2022-09-29T07:58:36+00:00\",\"description\":\"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.verilogpro.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SystemVerilog Struct and Union &#8211; for Designers too\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.verilogpro.com\/#website\",\"url\":\"https:\/\/www.verilogpro.com\/\",\"name\":\"Verilog Pro\",\"description\":\"Verilog and Systemverilog Resources for Design and Verification\",\"publisher\":{\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.verilogpro.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af\",\"name\":\"Jason Yu\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/a40eb502eb5e595b80498d3126bb55b5?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/a40eb502eb5e595b80498d3126bb55b5?s=96&d=mm&r=g\",\"caption\":\"Jason Yu\"},\"logo\":{\"@id\":\"https:\/\/www.verilogpro.com\/#\/schema\/person\/image\/\"},\"description\":\"Jason has 14 years' experience in the semiconductor industry, designing and verifying Solid State Drive controller SoC. His areas of work include microarchitecture and RTL design, dynamic and formal verification using UVM and Cadence JasperGold, and full-chip low power verification with UPF. Thoughts and opinions expressed in articles are personal and do not reflect that of Intel Corporation in any way.\",\"sameAs\":[\"http:\/\/www.verilogpro.com\",\"https:\/\/ca.linkedin.com\/in\/jasonkky\",\"https:\/\/x.com\/jasonkky\"],\"url\":\"https:\/\/www.verilogpro.com\/author\/jasonkkygmail-com\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"SystemVerilog Struct and Union - for Designers too - Verilog Pro","description":"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/","og_locale":"en_US","og_type":"article","og_title":"SystemVerilog Struct and Union - for Designers too - Verilog Pro","og_description":"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.","og_url":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/","og_site_name":"Verilog Pro","article_published_time":"2017-01-17T18:00:28+00:00","article_modified_time":"2022-09-29T07:58:36+00:00","og_image":[{"url":"http:\/\/www.verilogpro.com\/wp-content\/uploads\/2015\/09\/VLSIDesign-thumbnail.png"}],"author":"Jason Yu","twitter_card":"summary_large_image","twitter_creator":"@jasonkky","twitter_site":"@jasonkky","twitter_misc":{"Written by":"Jason Yu","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#article","isPartOf":{"@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/"},"author":{"name":"Jason Yu","@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af"},"headline":"SystemVerilog Struct and Union &#8211; for Designers too","datePublished":"2017-01-17T18:00:28+00:00","dateModified":"2022-09-29T07:58:36+00:00","mainEntityOfPage":{"@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/"},"wordCount":1137,"commentCount":4,"publisher":{"@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af"},"keywords":["FIFO","struct","union"],"articleSection":["Design","SystemVerilog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/","url":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/","name":"SystemVerilog Struct and Union - for Designers too - Verilog Pro","isPartOf":{"@id":"https:\/\/www.verilogpro.com\/#website"},"datePublished":"2017-01-17T18:00:28+00:00","dateModified":"2022-09-29T07:58:36+00:00","description":"SystemVerilog struct and union are effective constructs to simplify your RTL code. In this post I share some tips on how to use them in your design.","breadcrumb":{"@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.verilogpro.com\/systemverilog-structures-unions-design\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.verilogpro.com\/"},{"@type":"ListItem","position":2,"name":"SystemVerilog Struct and Union &#8211; for Designers too"}]},{"@type":"WebSite","@id":"https:\/\/www.verilogpro.com\/#website","url":"https:\/\/www.verilogpro.com\/","name":"Verilog Pro","description":"Verilog and Systemverilog Resources for Design and Verification","publisher":{"@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.verilogpro.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/b1a5fb728f2c8b49eae25c635bdac5af","name":"Jason Yu","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/a40eb502eb5e595b80498d3126bb55b5?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/a40eb502eb5e595b80498d3126bb55b5?s=96&d=mm&r=g","caption":"Jason Yu"},"logo":{"@id":"https:\/\/www.verilogpro.com\/#\/schema\/person\/image\/"},"description":"Jason has 14 years' experience in the semiconductor industry, designing and verifying Solid State Drive controller SoC. His areas of work include microarchitecture and RTL design, dynamic and formal verification using UVM and Cadence JasperGold, and full-chip low power verification with UPF. Thoughts and opinions expressed in articles are personal and do not reflect that of Intel Corporation in any way.","sameAs":["http:\/\/www.verilogpro.com","https:\/\/ca.linkedin.com\/in\/jasonkky","https:\/\/x.com\/jasonkky"],"url":"https:\/\/www.verilogpro.com\/author\/jasonkkygmail-com\/"}]}},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p6Du8T-7l","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/posts\/455"}],"collection":[{"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/comments?post=455"}],"version-history":[{"count":30,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/posts\/455\/revisions"}],"predecessor-version":[{"id":905,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/posts\/455\/revisions\/905"}],"wp:attachment":[{"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/media?parent=455"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/categories?post=455"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.verilogpro.com\/wp-json\/wp\/v2\/tags?post=455"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}