SystemVerilog Streaming Operators

Reassembling a struct's fields into a flat byte stream for a serial link, or splitting a received byte stream back into a struct's fields, normally means writing the shifting and masking by hand, field by field. SystemVerilog's streaming operators, {>>{...}} and {<<{...}}, do this packing and unpacking in a single expression instead.

8 min read | Intermediate Level

What You'll Learn

• How {>>{...}} and {<<{...}} pack a group of values into a single bit stream
• What the optional slice size actually reorders, and why >> ignores it entirely
• How the same operators run in reverse to unpack a stream back into variables
• A realistic design and verification use: converting a struct to and from a byte queue

Packing Values Into a Stream

A streaming concatenation looks like an ordinary concatenation, but with a stream operator and an optional slice size right after the opening brace:

module tb;
  initial begin
    int j = { "A", "B", "C", "D" };   // packs to 32'h41424344

    bit [31:0] s1 = { >>      { j } };  // same bit order, unchanged
    bit [31:0] s2 = { << byte { j } };  // byte order reversed
    bit [31:0] s3 = { << 16   { j } };  // 16-bit halves swapped

    $display("j  = 0x%0h", j);
    $display("s1 = 0x%0h", s1);
    $display("s2 = 0x%0h", s2);
    $display("s3 = 0x%0h", s3);
  end
endmodule

Output

j  = 0x41424344
s1 = 0x41424344
s2 = 0x44434241
s3 = 0x43444142

The stream operator, >> or <<, controls the direction blocks are streamed in. >> streams left to right, which is the same order the bits already have - so it simply ignores whatever slice size is given.

<< streams right to left instead. It slices the value into blocks of the given size, starting from the right-most bit, and then reverses the order of those blocks - without reversing the bits inside each block.

That is exactly what s2 and s3 show. { << byte {j} } slices j into four 8-bit (one-byte) blocks and reverses their order, which is the standard way to flip between big-endian and little-endian byte order. { << 16 {j} } instead slices it into two 16-bit blocks and swaps those.

If no slice size is given at all, it defaults to 1 bit - so a bare {<<{expr}} reverses the individual bits of expr, not whole bytes or words.

Unpacking a Stream Back Into Variables

Putting a streaming concatenation on the left-hand side of an assignment runs the same operation in reverse - it unpacks a stream into one or more variables:

module tb;
  initial begin
    bit [31:0] stream = 32'h41424344;
    byte a, b, c, d;

    { >> { a, b, c, d } } = stream;

    $display("a = 0x%0h  b = 0x%0h  c = 0x%0h  d = 0x%0h", a, b, c, d);
  end
endmodule

Output

a = 0x41  b = 0x42  c = 0x43  d = 0x44

The source on the right supplies the bits, consumed from its most significant end first, and the variables on the left are filled in the order they are listed. If the source has more bits than the targets need, the extra low-order bits are simply left unread. If it has fewer bits than the targets need, that is an error - there is nothing left to fill the remaining variable with.

Packing a Struct Into a Byte Queue

Streaming operators work on more than just integers. A struct, array, or queue can be streamed too, which is what makes them useful for modeling a packet on a byte-wide channel:

module tb;
  typedef struct packed {
    byte addr;
    byte code;
    byte payload;
  } pkt_t;

  initial begin
    byte channel [$];   // the byte-wide channel, modeled as a queue
    byte pkt_bytes [$];
    pkt_t p, rx;
    byte rx_bytes [$];

    // Send: pack the struct's 3 bytes into a queue, then append that to the channel
    p = '{addr: 8'hA0, code: 8'h3C, payload: 8'hFF};
    pkt_bytes = { >> byte { p } };
    channel   = { channel, pkt_bytes };

    $display("p        = 0x%0h", p);
    $display("channel  = 0x%0h 0x%0h 0x%0h", channel[0], channel[1], channel[2]);

    // Receive: pop 3 bytes back off the channel and unpack them into a struct
    rx_bytes = { channel[0], channel[1], channel[2] };
    { >> byte { rx } } = rx_bytes;

    $display("rx.addr    = 0x%0h", rx.addr);
    $display("rx.code    = 0x%0h", rx.code);
    $display("rx.payload = 0x%0h", rx.payload);
  end
endmodule

Output

p        = 0xa03cff
channel  = 0xa0 0x3c 0xff
rx.addr    = 0xa0
rx.code    = 0x3c
rx.payload = 0xff

The sender's struct fields are streamed out byte by byte, in declaration order, without the sender ever writing out the individual shifts and masks for addr, code, and payload separately. The receiver does the same operation in reverse, reconstructing the struct's fields directly from the raw bytes pulled off the channel.

The same conversion is equally useful on the design side, for a serializer or deserializer that packs a wide internal bus into one byte at a time for a narrow external interface, and on the verification side, for a driver or monitor that converts between a readable transaction struct and the raw bytes actually seen on a pin-level bus.

Common Beginner Mistakes

module tb;
  initial begin
    bit [31:0] data    = 32'h12345678;
    bit [31:0] swapped = { << byte { data } };

    $display("data    = 0x%0h", data);
    $display("swapped = 0x%0h", swapped);
  end
endmodule

data    = 0x12345678
swapped = 0x78563412