UVM Tutorial for Candy Lovers – 26. Sequence Arbitration

最新推荐文章于 2023-06-22 20:01:30 发布
最新推荐文章于 2023-06-22 20:01:30 发布
阅读量318 收藏
点赞数 1
分类专栏： UVM Tutorial
原文链接：http://cluelogic.com/2015/04/uvm-tutorial-for-candy-lovers-sequence-arbitration/
版权

Our jelly-bean business has been doing so well that we started to receive multiple jelly-bean orders at the same time. Some customers requested expedited shipping, too. But how to prioritize the requests? It’s time to learn about sequence arbitration.

Today’s Jelly-Bean Orders

Let’s assume we received the following jelly-bean orders today:

  • Standard order — four APPLE jelly-beans
  • Priority order — four BLUEBERRY jelly-beans
  • Priority order — four BUBBLE_GUM jelly-beans
  • Overnight order — four CHOCOLATE jelly-beans

In our jelly_bean_test, we created four jelly_bean_order_sequence, one per a jelly-bean order (lines 39 to 42). Then, we set the priorities of the sequence and started them at the same time to let the sequencer arbitrate them. Note that the default priority is 100 and higher numbers indicate higher priority. In our case, we set the standard order to be 100, the priority order to be 200, and the overnight order to be 300 (lines 62 to 65).

The UVM sequencer has six arbitration modes:

The set_arbitration function of the uvm_sequencer_base class specifies which mode to use (lines 54 to 59). Let’s look at each mode one by one.

class jelly_bean_test extends uvm_test;
  `uvm_component_utils( jelly_bean_test )
 
  jelly_bean_env jb_env;
 
  //----------------------------------------------------------------------------
  // Function: new
  //----------------------------------------------------------------------------
 
  function new( string name, uvm_component parent );
    super.new( name, parent );
  endfunction: new
 
  //----------------------------------------------------------------------------
  // Function: build_phase
  //----------------------------------------------------------------------------
 
  function void build_phase( uvm_phase phase );
    super.build_phase( phase );
 
    jb_env = jelly_bean_env::type_id::create( .name( "jb_env" ), .parent( this ) );
  endfunction: build_phase
 
  //----------------------------------------------------------------------------
  // task: main_phase
  //----------------------------------------------------------------------------
 
  task main_phase( uvm_phase phase );
    jelly_bean_order_sequence standard_order_seq;
    jelly_bean_order_sequence priority_order_seq1;
    jelly_bean_order_sequence priority_order_seq2;
    jelly_bean_order_sequence overnight_order_seq;
 
    standard_order_seq  = jelly_bean_order_sequence::type_id::create( "standard_order_seq" );
    priority_order_seq1 = jelly_bean_order_sequence::type_id::create( "priority_order_seq1" );
    priority_order_seq2 = jelly_bean_order_sequence::type_id::create( "priority_order_seq2" );
    overnight_order_seq = jelly_bean_order_sequence::type_id::create( "overnight_order_seq" );
 
    assert( standard_order_seq .randomize() with { num_jelly_beans == 4; jb_flavor == APPLE;      } );
    assert( priority_order_seq1.randomize() with { num_jelly_beans == 4; jb_flavor == BLUEBERRY;  } );
    assert( priority_order_seq2.randomize() with { num_jelly_beans == 4; jb_flavor == BUBBLE_GUM; } );
    assert( overnight_order_seq.randomize() with { num_jelly_beans == 4; jb_flavor == CHOCOLATE;  } );
 
    standard_order_seq .set_starting_phase( phase );
    priority_order_seq1.set_starting_phase( phase );
    priority_order_seq2.set_starting_phase( phase );
    overnight_order_seq.set_starting_phase( phase );
 
    standard_order_seq .set_automatic_phase_objection( .value( 1 ) );
    priority_order_seq1.set_automatic_phase_objection( .value( 1 ) );
    priority_order_seq2.set_automatic_phase_objection( .value( 1 ) );
    overnight_order_seq.set_automatic_phase_objection( .value( 1 ) );
 
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_FIFO ); // default
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_RANDOM );
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_STRICT_FIFO );
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_STRICT_RANDOM );
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_WEIGHTED );
    //jb_env.jb_agent.jb_seqr.set_arbitration( UVM_SEQ_ARB_USER );
 
    fork
      standard_order_seq .start( jb_env.jb_agent.jb_seqr, .this_priority( 100 ) ); // default priority
      priority_order_seq1.start( jb_env.jb_agent.jb_seqr, .this_priority( 200 ) );
      priority_order_seq2.start( jb_env.jb_agent.jb_seqr, .this_priority( 200 ) );
      overnight_order_seq.start( jb_env.jb_agent.jb_seqr, .this_priority( 300 ) );
    join
  endtask: main_phase
 
endclass: jelly_bean_test

UVM_SEQ_ARB_FIFO

This is the default arbitration mode and probably the easiest to understand. UVM sequencer grants sequences in FIFO order regardless of their priorities. When we run the test with this mode, we should see the sequences like this:

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE

We illustrated the request FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. At step 1, the UVM sequencer selected APPLE because it was located at the front of the FIFO.
    • When the APPLE was processed, it went out of the FIFO, but since we ordered four APPLE jelly-beans, another APPLE was put into the FIFO.
    • The UVM sequencer selected BLUEBERRY at step 2 because it was located at the front of the FIFO.
    • When the BLUEBERRY was processed, it went out of the FIFO. Since we ordered four BLUEBERRY jelly-beans, another BLUEBERRY was put into the FIFO.
    • The UVM sequencer selected BUBBLE_GUM at step 3 because it was located at the front of the FIFO.
  4. Similar arbitration continued until there was no more requests to process (steps 4 to 16).

Because of round robin nature of this mode, it won’t satisfy the customers who placed a priority order or an overnight order.

                                                                  How UVM_SEQ_ARB_FIFO works

UVM_SEQ_ARB_RANDOM

This mode should be also easy to understand. It randomly grants sequences in the FIFO regardless of their priorities. When we run the test with this mode, we should see the sequences like this:

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq BLUEBERRY
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 CHOCOLATE
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BUBBLE_GUM
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq BUBBLE_GUM
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq BUBBLE_GUM
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BUBBLE_GUM
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq BLUEBERRY
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq APPLE
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq BLUEBERRY
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 APPLE
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 CHOCOLATE
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 APPLE
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 CHOCOLATE
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE

We illustrated the request FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. At step 1, the UVM sequencer randomly selected BLUEBERRY.
    • When the BLUEBERRY was processed, it went out of the FIFO, but since we ordered four BLUEBERRY jelly-beans, another BLUEBERRY was put into the FIFO.
    • The UVM sequencer happened to select this BLUEBERRY at step 2, too.
    • When the second BLUEBERRY was processed, it went out of the FIFO. Since there were two more BLUEBERRY jelly-beans to process, another BLUEBERRY was put into the FIFO.
    • The UVM sequencer selected CHOCOLATE at step 3.
  4. Similar arbitration continued until there was no more requests to process (steps 4 to 16).

Because of random nature of this mode, it won’t satisfy the customers who placed a priority order or an overnight order, either.

How UVM_SEQ_ARB_RANDOM works

UVM_SEQ_ARB_STRICT_FIFO

This mode always grants the highest priority sequence. If more than one sequence has the same priority, the sequencer grants the one closest to the front of the FIFO. When we run the test with this mode, we should see the sequences like this:

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE

We illustrated the request FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. At step 1, the UVM sequencer selected CHOCOLATE because it was the highest priority request.
    • When the CHOCOLATE was processed, it went out of the FIFO, but since we ordered four CHOCOLATE jelly-beans, another CHOCOLATE was put into the FIFO.
    • The UVM sequencer selected this CHOCOLATE again at step 2 because it was the highest priority request.
    • When the second CHOCOLATE was processed, it went out of the FIFO. Since there were two more CHOCOLATE jelly-beans to process, another CHOCOLATE was put into the FIFO.
    • The UVM sequencer selected this CHOCOLATE again at step 3 because it was the highest priority request.
  4. After all CHOCOLATE requests (overnight order) were processed, the UVM sequencer went to the BLUEBERRY and BUBBLE_GUM requests (priority orders). Because both of them had the same priority, the UVM_SEQ_ARB_STRICT_FIFO mode selected the sequence closest to the front of the FIFO (steps 5 to 12).
  5. APPLE requests (standard order) were the lowest priority, so the UVM sequencer granted them last (steps 13 to 16).

This mode will satisfy the customers who placed a priority order or an overnight order.

                                                               How UVM_SEQ_ARB_STRICT_FIFO works

UVM_SEQ_ARB_STRICT_RANDOM

Similar to the UVM_SEQ_ARB_STRICT_FIFO mode, this mode grants the highest priority sequence. The difference is that when more than one sequence has the same priority, the sequencer selects a sequence randomly from the sequences that have the same priority. When we run the test with this mode, we should see the sequences like this:

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE

We illustrated the request FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. At step 1, the UVM sequencer selected CHOCOLATE because it was the highest priority request.
    • When the CHOCOLATE was processed, it went out of the FIFO, but since we ordered four CHOCOLATE jelly-beans, another CHOCOLATE was put into the FIFO.
    • The UVM sequencer selected this CHOCOLATE again at step 2 because it was the highest priority request.
    • When the second CHOCOLATE was processed, it went out of the FIFO. Since there were two more CHOCOLATE jelly-beans to process, another CHOCOLATE was put into the FIFO.
    • The UVM sequencer selected this CHOCOLATE again at step 3 because it was the highest priority request.
  4. After all CHOCOLATE requests (overnight order) were processed, the sequencer went to the BLUEBERRY and BUBBLE_GUM requests (priority orders). Because both of them had the same priority, the UVM_SEQ_ARB_STRICT_RANDOM mode selected the sequence randomly from the two. This is the only difference between the UVM_SEQ_ARB_STRICT_FIFO and UVM_SEQ_ARB_STRICT_RANDOM modes (steps 5 to 12).
  5. APPLE requests (standard order) were the lowest priority, so the UVM sequencer granted them last (steps 13 to 16).

This mode will satisfy the customers who placed a priority order or an overnight order.

                                                           How UVM_SEQ_ARB_STRICT_RANDOM works

UVM_SEQ_ARB_WEIGHTED

This is the most complicated and misleading mode in my opinion. The idea of this mode is that the higher priority sequences will get more chance to be granted. Here is how it works under the hood: This mode totals up the priority numbers in the request FIFO. Let’s say, the sum is 800. Then, it picks a random number between 0 and 799 (800 minus 1). Then, from the front of the FIFO, it accumulates the priority number each sequence has. When the accumulated number becomes more than the randomly selected number (threshold), that sequence is selected. OK, I know you are confused. Let’s see an example.

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE

We illustrated the request FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. Firstly, the UVM sequencer totalled up the priority numbers in the FIFO. In our case it was 800 (=100+200+200+300). Then, the sequencer picked a random number between 0 and 799 (=800-1). Let’s assume the random number was 219. We call this number a threshold. The sequencer looked at the front of the FIFO, which was APPLE and its priority number was 100. Since 100 was less than the threshold (219), the sequencer continued to look at the second entry of the FIFO. The second entry was BLUEBERRY and its priority number was 200. The accumulated priority number became 300, which was greater than the threshold, so the sequencer selected the BLUEBERRY at step 1.
    • When the BLUEBERRY was processed, it went out of the FIFO, but since we ordered four BLUEBERRY jelly-beans, another BLUEBERRY was put into the FIFO.
    • The UVM sequencer repeated the same procedure as the step 1. Firstly, it totalled up the priority numbers in the FIFO, which was 800. Let’s assume the random number the sequencer picked was 37 this time. Since the priority number of the first entry of the FIFO (100) was greater than 37, the sequencer selected APPLE at step 2.
    • When the APPLE was processed, it went out of the FIFO. Since there are three more APPLE jelly-beans to process, another APPLE was put into the FIFO.
    • The UVM sequencer used the same procedure and selected BUBBLE_GUM at step 3.
  4. Similar arbitration continued until there was no more orders to process (steps 4 to 16).

This mode will give more chance to be granted to the higher priority sequencers, but not as strict as UVM_SEQ_ARB_STRICT_FIFO or UVM_SEQ_ARB_STRICT_RANDOM.

                                                          How UVM_SEQ_ARB_WEIGHTED works

UVM_SEQ_ARB_USER

If none of the above modes satisfies your need, you can create your own arbitration scheme. To do that, you need to extend the uvm_sequencer class and define its user_priority_arbitration function. As an example, we created the arbitration scheme that always selects the second entry of the FIFO if it is available. This might be quite artificial, but I hope you get the idea.

class jelly_bean_sequencer extends uvm_sequencer#( jelly_bean_transaction );
  `uvm_component_utils( jelly_bean_sequencer )
 
  //----------------------------------------------------------------------------
  // Function: new
  //----------------------------------------------------------------------------
 
  function new( string name, uvm_component parent );
    super.new( name, parent );
  endfunction: new
 
  //----------------------------------------------------------------------------
  // Function: user_priority_arbitration
  //----------------------------------------------------------------------------
 
  virtual function integer user_priority_arbitration( integer avail_sequences[$] );
    if ( avail_sequences.size() >= 2 ) return avail_sequences[1]; // second entry of the request FIFO
    else                               return avail_sequences[0];
  endfunction: user_priority_arbitration
 
endclass: jelly_bean_sequencer

When we run the test with this mode, you should see the sequences like this:

# KERNEL: UVM_INFO @   0: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  15: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @  35: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @  55: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @  75: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @  95: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 115: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 135: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 155: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 175: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq1 BLUEBERRY
# KERNEL: UVM_INFO @ 195: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] priority_order_seq2 BUBBLE_GUM
# KERNEL: UVM_INFO @ 215: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr] overnight_order_seq CHOCOLATE
# KERNEL: UVM_INFO @ 235: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 255: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 275: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE
# KERNEL: UVM_INFO @ 295: uvm_test_top.jb_env.jb_agent.jb_drvr [jb_drvr]  standard_order_seq APPLE

We illustrated the arbitration FIFO in the UVM sequencer below. The numbers in parentheses are the priority numbers we specified when we started the sequences.

  1. The top-left shows the initial FIFO state just after we started the sequences. At step 1, the UVM sequencer selected BLUEBERRY because it was in the second entry of the FIFO.
    • When the BLUEBERRY was processed, it went out of the FIFO, but since we ordered four BLUEBERRY jelly-beans, another BLUEBERRY was put into the FIFO.
    • The UVM sequencer selected BUBBLE_GUM at step 2 because it was in the second entry of the FIFO.
    • When the BUBBLE_GUM was processed, it went out of the FIFO. Since we ordered four BUBBLE_GUM jelly-beans, another BUBBLE_GUM was put into the FIFO.
    • The UVM sequencer selected CHOCOLATE at step 3 because it was in the second entry of the FIFO.
  4. Similar arbitration continued until there was no more orders to process (steps 4 to 16).

                                                                 How UVM_SEQ_ARB_USER works

This was a long article, but I hope you understand the difference between the arbitration modes.

OnePlusZero
关注
专栏目录
UVM在test组件内启动sequence/virtual sequence的方法
weixin_42147770的博客
11-17 3754
关于UVM中开启sequence的一些具体注意事项，例如在sequence中启动其他底层sequence，在用户构建的test组件内部开启测例sequence等。
uvm_objection机制
weixin_58536904的博客
01-04 778
验证平台一般会在test层通过config_db的方式指定要执行的default_seq，在启动seq的时候，会执行start函数，uvm_sequence_base中的虚函数start()调用了pre_start()→pre_body()→body()→post_body()→post_start() 函数。其中用得最多的是第二种，这种方式是UVM提倡的方式。如果用的是UVM-1.2，则可以在new函数中打开objection的开关，UVM将会自动控制objection的raise和drop；
UVM1.2究竟在UVM1.1上做了哪些升级
W1Z1Q的专栏
06-22 2503
本文总结了UVM1.2在UVM1.1上做的主要改动，这些改动对我们会有什么影响，以及如何适配这些改动。
关于seq中的starting_phase
wuqing0830的博客
12-15 2328
本文主要记录seq的staring_phase相关内容
UVM-Objection机制
weixin_56741504的博客
03-18 1350
UVM/objection/phase
uvm-tutorial-for-candy-lovers-master_TheLovers_UVM_
10-01
UVM的核心组件包括Agent、Sequence、Sequence Library、Transaction、Monitor等。Agent是UVM中最基本的单元，它包含了Driver、Sequencer、Queue和Monitor等部分，负责与DUT（Design Under Test）交互并处理事务。...
uvm-tutorial-for-candy-lovers-master.zip
12-30
从github下载的UVM入门教程。 网页版教程 http://cluelogic.com/2011/07/uvm-tutorial-for-candy-lovers-overview/ 原始地址 https://github.com/cluelogic/uvm-tutorial-for-candy-lovers
uvm_ralgen_ug_sp2.pdf
06-15
文档中的“UVM”代表“Universal Verification Methodology”，即通用验证方法学，是一种用于电子系统级验证的标准化方法和公共验证平台。该文档涉及了UVM Register Abstraction Layer (RAL) 的生成器（generator）...
uvm_users_guide_1.2.zip_UVM手册_site:www.pudn.com_uvm user guide 1
07-15
《UVM用户手册1.2版》是集成电路（IC）验证领域的一份重要参考资料，它详细介绍了统一验证方法学（Unified Verification Methodology, UVM）。UVM是一种基于SystemVerilog的验证方法，它为系统级验证提供了标准的...
ces_uvm-1.1_2011.12.rar
05-27
- **类层次**：UVM定义了一系列基类，如uvm_component、uvm_sequence、uvm_transaction等，它们构成了UVM的类层次结构，方便用户进行继承和扩展。 - **配置和连接**：UVM的配置管理器允许动态配置和连接组件，实现...
uvm_users_guide_1.1(学习uvm必备，可添加注释)
11-27
Uvm 1.1 user guide，学习uvm验证方法学必备，pdf，且可添加注释
UVM1.2 相对于UVM1.1的变化
XtremeDV
09-06 6058
新功能和更改功能 变量uvm_sequence_base::starting_phase已弃用，并由两个新方法set_starting_phase和get_starting_phase取代，这些方法阻止在phase中间修改starting_phase。此更改与UVM 1.1不向后兼容，但变量starting_phase虽然已弃用，但尚未从基类库中删除。 新方法uvm_sequence_base:...
sequence的仲裁机制
muyiwushui的博客
02-02 606
UVM支持同一时刻在同一个sequencer上启动多个sequence。同一个sequencer上的多个sequence可以设置优先级，优先级高的sequence优先发送transaction。
如何在UVM的sequence中控制objection
hh199203的博客
08-18 1454
文章目录前言一、Objections can be raised/dropped in sequence总结 前言 在张强的《UVM实战》的5.2.3节中提到，控制objection的最佳选择，是在sequence中去控制。那么如何去控制比较简洁、美观、通用性强呢，本文主要介绍如何在sequence中，有效的控制objection。 一、Objections can be raised/dropped in sequence 如下代码所示，建立一个sequence的基类，如果用的是UVM-1.2，则在
uvm_user_guide_1.2 -- ch3 开发可重用的验证组件
thompsonm的博客
04-07 847
UVM糖果爱好者教程 - 23.将Jelly Bean Taster移植到UVM 1.2
XtremeDV
06-22 970
我的第一批UVM教程（＃1至＃6）已于三年前发布。 从那以后，UVM（以及我的知识）已经发展，我一直想更新我的文章和代码。 但这并不容易，因为我的文章和代码紧密结合，读者的一些评论甚至提到了特定的代码行。UVM 1.2大约两个月前，Accellera发布了新的UVM 1.2，它激励我更新我的 jelly bean taster。 我认为是时候进行大修了。 有趣的是，我的代码几乎不需要修改。 我做的...
UVM sequence机制（3）(sequence的仲裁2)
liuwei848的博客
03-22 583
这篇主要介绍仲裁算法的使用，sequence在发送item的过程中，sequencer使用别的仲裁算法，在UVM中仲裁算法有下面这几种 typedef enum { UVM_SEQ_ARB_FIFO, UVM_SEQ_ARB_WEIGHTED, UVM_SEQ_ARB_RANDOM, UVM_SEQ_ARB_STRICT_FIFO, UVM_SEQ_ARB_STRICT_RAN...
【UVM】-- UVM调试
huxixi_2的博客
10-31 1257
uvm调试搭建
基于java的校园美食交流系统设计与实现.docx
最新发布
09-19
基于java的校园美食交流系统设计与实现.docx
uvm 中 l_uvm_reg.update(l_en_status);
06-06
在UVM中，`l_uvm_reg.update(l_en_status)`是用于更新寄存器值的方法。其中，`l_uvm_reg`是一个UVM寄存器对象，`l_en_status`是一个表示寄存器值的变量。这个方法会将新值写入到寄存器中，并更新寄存器的状态。在这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值