Ignore:
Timestamp:
Sep 14, 2015, 9:42:16 AM (9 years ago)
Author:
cfuguet
Message:

reconf: dspin_router

  • improve the code readability of the dspin_router model.
  • update the unitary tests of the dspin_router to support the local gateway hardware barrier, and the memory cache scratchpad mode.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/reconfiguration/modules/dspin_router/caba/source/src/dspin_router.cpp

    r1006 r1016  
    2626  *
    2727  */
    28 
    29     ///////////////////////////////////////////////////////////////////////////
    30     // Implementation Note :
    31     // The xfirst_route(), broadcast_route() and is_broadcast() functions
    32     // defined below are used to decode the DSPIN first flit format:
    33     // - In case of a non-broadcast packet :
    34     //  |   X     |   Y     |---------------------------------------|BC |
    35     //  | x_width | y_width |  flit_width - (x_width + y_width + 2) | 0 |
    36     //
    37     //  - In case of a broacast
    38     //  |  XMIN   |  XMAX   |  YMIN   |  YMAX   |----------------|SP|BC |
    39     //  |   5     |   5     |   5     |   5     | flit_width - 21| 1| 1 |
    40     ///////////////////////////////////////////////////////////////////////////
    41 
    4228#include "../include/dspin_router.h"
    4329#include "dspin_router_config.h"
     30
     31#include <cassert>
    4432
    4533namespace soclib { namespace caba {
    … …  
    132120    tmpl(int)::blackhole_position()
    133121    {
    134         if ( is_reconfigurable() ) {
    135             return p_recovery_cfg->read() & 0xF;
    136         }
    137         return BH_NONE;
     122        assert( is_reconfigurable() );
     123        return p_recovery_cfg->read() & 0xF;
    138124    }
    139125
    … …  
    141127    tmpl(void)::bind_recovery_port(sc_signal<uint32_t> &s)
    142128    {
    143         if (!is_reconfigurable()) {
     129        if ( not is_reconfigurable() ) {
    144130            std::cerr << "Error in " << name()
    145131                      << ": router configuration not supported." << std::endl
    … …  
    150136    }
    151137
     138    tmpl(bool)::is_recovery_routing_enabled()
     139    {
     140        assert( is_reconfigurable() );
     141        return (((p_recovery_cfg->read() >> 4) & 0x1) != 0);
     142    }
     143
     144    tmpl(bool)::is_reallocation_enabled()
     145    {
     146        assert( is_reconfigurable() );
     147        return (blackhole_position() != NORMAL);
     148    }
     149
     150    tmpl(int)::reallocation_route()
     151    {
     152        assert( is_reconfigurable() );
     153        return ((p_recovery_cfg->read() >> 5) & 0x7);
     154    }
     155
     156    tmpl(bool)::is_reconfigurable()
     157    {
     158        return (p_recovery_cfg != NULL);
     159    }
     160
    152161    ///////////////////////////////////////////////////
    153     tmpl(int)::xfirst_route( size_t xdest, size_t ydest )
    154     {
    155         return (xdest < m_local_x ? REQ_WEST :
    156                (xdest > m_local_x ? REQ_EAST :
    157                (ydest < m_local_y ? REQ_SOUTH :
    158                (ydest > m_local_y ? REQ_NORTH : REQ_LOCAL))));
     162    tmpl(bool)::is_destination_blackhole( size_t xdest, size_t ydest )
     163    {
     164        assert ( is_reconfigurable() );
     165
     166        const int bhpos = blackhole_position();
     167
     168        const bool is_n = (bhpos == N_OF_X);
     169        const bool is_s = (bhpos == S_OF_X);
     170        const bool is_w = (bhpos == W_OF_X);
     171        const bool is_e = (bhpos == E_OF_X);
     172        const bool is_nw = (bhpos == NW_OF_X);
     173        const bool is_ne = (bhpos == NE_OF_X);
     174        const bool is_sw = (bhpos == SW_OF_X);
     175        const bool is_se = (bhpos == SE_OF_X);
     176
     177        if ( bhpos == NORMAL ) return false;
     178
     179        size_t xhole;
     180        if      (is_nw || is_w  || is_sw) xhole = m_local_x + 1;
     181        else if (is_ne || is_se || is_e ) xhole = m_local_x - 1;
     182        else                              xhole = m_local_x;
     183
     184        size_t yhole;
     185        if      (is_sw || is_s  || is_se) yhole = m_local_y + 1;
     186        else if (is_nw || is_n  || is_ne) yhole = m_local_y - 1;
     187        else                              yhole = m_local_y;
     188
     189        return ((xdest == xhole) && (ydest == yhole));
    159190    }
    160191
    161192    ///////////////////////////////////////////////////
    162     tmpl(bool)::is_destination_blackhole( size_t xdest, size_t ydest, int bhpos )
    163     {
    164         size_t xhole, yhole;
    165         switch (bhpos) {
    166             case BH_N:
    167                 xhole = m_local_x;
    168                 yhole = m_local_y - 1;
    169                 break;
    170             case BH_NW:
    171                 xhole = m_local_x + 1;
    172                 yhole = m_local_y - 1;
    173                 break;
    174             case BH_W:
    175                 xhole = m_local_x + 1;
    176                 yhole = m_local_y;
    177                 break;
    178             case BH_SW:
    179                 xhole = m_local_x + 1;
    180                 yhole = m_local_y + 1;
    181                 break;
    182             case BH_S:
    183                 xhole = m_local_x;
    184                 yhole = m_local_y + 1;
    185                 break;
    186             case BH_SE:
    187                 xhole = m_local_x - 1;
    188                 yhole = m_local_y + 1;
    189                 break;
    190             case BH_E:
    191                 xhole = m_local_x - 1;
    192                 yhole = m_local_y;
    193                 break;
    194             case BH_NE:
    195                 xhole = m_local_x - 1;
    196                 yhole = m_local_y - 1;
    197                 break;
    198             default:
    199                 return false;
    200         }
    201 
    202         return ((xdest == xhole) && (ydest == yhole));
    203     }
    204 
    205     ///////////////////////////////////////////////////
    206     tmpl(int)::recovery_route( size_t xdest, size_t ydest )
    207     {
    208         int bhpos = blackhole_position();
    209 
    210         if ( xdest > m_local_x ) {
    211             if ( (bhpos == BH_NE) || (bhpos == BH_E) || (bhpos == BH_SE) ||
    212                  (bhpos == BH_S) ) {
     193    tmpl(int)::recovery_route( size_t dx, size_t dy )
     194    {
     195        // use normal routing (X-first) when the recovery routing is disabled
     196        int bhpos = NORMAL;
     197        bool normal = true;
     198        if (is_reconfigurable()) {
     199            assert(not is_reallocation_enabled() or
     200                   not is_destination_blackhole(dx, dy));
     201
     202            bhpos  = blackhole_position();
     203
     204            normal = (bhpos == NORMAL) or
     205                     (not is_recovery_routing_enabled() and
     206                      not is_destination_blackhole(dx, dy));
     207        }
     208
     209        const bool is_n  = not normal and (bhpos == N_OF_X);
     210        const bool is_s  = not normal and (bhpos == S_OF_X);
     211        const bool is_w  = not normal and (bhpos == W_OF_X);
     212        const bool is_e  = not normal and (bhpos == E_OF_X);
     213        const bool is_nw = not normal and (bhpos == NW_OF_X);
     214        const bool is_ne = not normal and (bhpos == NE_OF_X);
     215        const bool is_sw = not normal and (bhpos == SW_OF_X);
     216        const bool is_se = not normal and (bhpos == SE_OF_X);
     217
     218        const size_t lx = m_local_x;
     219        const size_t ly = m_local_y;
     220
     221        if ( dx > lx ) {
     222            if ( is_ne || is_e || is_se || is_s || normal )
    213223                return REQ_EAST;
    214             }
    215             else if ( bhpos == BH_N ) {
    216                 if ( (m_local_y == 1) || (m_local_x == 0) || (ydest >= m_local_y) ||
    217                      (xdest > (m_local_x + 1)) ) {
     224
     225            else if ( is_n ) {
     226                if ( (ly == 1) || (lx == 0) || (dy >= ly) || (dx > (lx + 1)) )
    218227                    return REQ_EAST;
    219                 }
    220                 else {
     228                else
    221229                    return REQ_WEST;
    222                 }
    223             }
    224             else if ( bhpos == BH_NW ) {
    225                 if ( (m_local_y == 1) || (ydest >= m_local_y) ||
    226                      (xdest > (m_local_x + 2)) ) {
     230            }
     231            else if ( is_nw ) {
     232                if ( (ly == 1) || (dy >= ly) || (dx > (lx + 2)) )
    227233                    return REQ_EAST;
    228                 }
    229                 else {
     234                else
    230235                    return REQ_SOUTH;
    231                 }
    232             }
    233             else if ( bhpos == BH_W ) {
    234                 if ( (m_local_y == 0) || (ydest > m_local_y)) {
     236            }
     237            else if ( is_w ) {
     238                if ( (ly == 0) || (dy > ly))
    235239                    return REQ_NORTH;
    236                 }
    237                 else {
     240                else
    238241                    return REQ_SOUTH;
    239                 }
    240             }
    241             else if ( bhpos == BH_SW ) {
    242                 if ( (ydest <= m_local_y) || (xdest > (m_local_x + 1)) ) {
     242            }
     243            else if ( is_sw ) {
     244                if ( (dy <= ly) || (dx > (lx + 1)) )
    243245                    return REQ_EAST;
    244                 }
    245                 else {
     246                else
    246247                    return REQ_NORTH;
    247                 }
    248248            }
    249249            std::cout << "error: unexpected condition in function "
    … …  
    251251                      << std::endl;
    252252            exit(1);
    253         }                    // end if (xdest > m_local_x)
    254         else if ( xdest < m_local_x ) {
    255             if ( (bhpos == BH_N) || (bhpos == BH_NW) || (bhpos == BH_W) ||
    256                  (bhpos == BH_SW) || (bhpos == BH_S) ) {
     253        }                    // end if (dx > lx)
     254        else if ( dx < lx ) {
     255            if ( is_n || is_nw || is_w || is_sw || is_s || normal )
    257256                return REQ_WEST;
    258             }
    259             else if ( bhpos == BH_NE ) {
    260                 if ( (xdest < (m_local_x - 1)) || (ydest >= m_local_y) ) {
     257
     258            else if ( is_ne ) {
     259                if ( (dx < (lx - 1)) || (dy >= ly) )
    261260                    return REQ_WEST;
    262                 }
    263                 else {
     261                else
    264262                    return REQ_SOUTH;
    265                 }
    266             }
    267             else if ( bhpos == BH_SE ) {
    268                 if ( (m_local_x == 1) && (ydest > (m_local_y + 1)) ) {
     263            }
     264            else if ( is_se ) {
     265                if ( (lx == 1) && (dy > (ly + 1)) )
    269266                    return REQ_NORTH;
    270                 }
    271                 else {
     267                else
    272268                    return REQ_WEST;
    273                 }
    274             }
    275             else if ( bhpos == BH_E ) {
    276                 if ( (m_local_y == 0) ||
    277                     ((m_local_x == 1) && (ydest > m_local_y)) ) {
     269            }
     270            else if ( is_e ) {
     271                if ( (ly == 0) || ((lx == 1) && (dy > ly)) )
    278272                    return REQ_NORTH;
    279                 }
    280                 else {
     273                else
    281274                    return REQ_SOUTH;
    282                 }
    283275            }
    284276            std::cout << "error: unexpected condition in function "
    … …  
    286278                      << std::endl;
    287279            exit(1);
    288         }                    // end if (xdest < m_local_x)
    289         else if ( ydest > m_local_y ) {
    290             if ( bhpos != BH_S ) {
    291                 return REQ_NORTH;
    292             }
    293             else if ( m_local_x != 0 ) {
    294                 return REQ_WEST;
    295             }
    296             else {
    297                 return REQ_EAST;
    298             }
    299         }                    // end if (ydest > m_local_y)
    300         else if ( ydest < m_local_y ) {
    301             if ( bhpos != BH_N ) {
    302                 return REQ_SOUTH;
    303             }
    304             else if ( m_local_x != 0) {
    305                 return REQ_WEST;
    306             }
    307             else {
    308                 return REQ_EAST;
    309             }
    310         }                    // end if (ydest < m_local_y)
     280        }                    // end if (dx < lx)
     281        else if ( dy > ly ) {
     282            if      ( ! is_s  ) return REQ_NORTH;
     283            else if ( lx != 0 ) return REQ_WEST;
     284            else                return REQ_EAST;
     285        }
     286        else if ( dy < ly ) {
     287            if      ( ! is_n )  return REQ_SOUTH;
     288            else if ( lx != 0)  return REQ_WEST;
     289            else                return REQ_EAST;
     290        }
    311291        return REQ_LOCAL;
    312292    }
    … …  
    315295    tmpl(int)::route( sc_uint<flit_width> data )
    316296    {
    317         size_t xdest = (size_t)(data >> m_x_shift) & m_x_mask;
    318         size_t ydest = (size_t)(data >> m_y_shift) & m_y_mask;
    319         if ( blackhole_position() != BH_NONE )
    320         {
    321             // reroute the request if its destination is the blackhole (this
    322             // is to implement the segment recovery mechanism)
    323             if ( is_destination_blackhole(xdest, ydest, blackhole_position()) )
     297        const size_t dx = (size_t)(data >> m_x_shift) & m_x_mask;
     298        const size_t dy = (size_t)(data >> m_y_shift) & m_y_mask;
     299
     300        if ( is_reconfigurable() ) {
     301            // reroute requests whose destination is the blackhole (this is to
     302            // implement the segment reallocation mechanism)
     303            if ( is_reallocation_enabled() and is_destination_blackhole(dx, dy))
    324304            {
    325                 int dir = migration_route();
    326 
    327 #if SOCLIB_MODULE_DEBUG
    328                 std::cout << "<" << name() << "> migration: "
    329                           << "route request to DIR = " << dir << std::endl;
    330 #endif
    331                 return dir;
    332             }
    333 
    334             if (is_network_recovery_enable())
    335             {
    336                 int dir = recovery_route(xdest, ydest);
    337 
    338 #if SOCLIB_MODULE_DEBUG
    339                 std::cout << "<" << name() << "> network recovery: "
    340                           << "route request to DIR = " << dir << std::endl;
    341 #endif
    342                 return dir;
    343             }
    344         }
    345         return xfirst_route(xdest, ydest);
     305                return reallocation_route();
     306            }
     307        }
     308
     309        // use the recovery routing
     310        return recovery_route(dx, dy);
    346311    }
    347312
    … …  
    349314    tmpl(int)::broadcast_route(int step, int source, sc_uint<flit_width> data)
    350315    {
    351         const size_t lx   = m_local_x;
    352         const size_t ly   = m_local_y;
     316        const size_t lx = m_local_x;
     317        const size_t ly = m_local_y;
    353318        const size_t xmin = (data >> (flit_width - 5 )) & 0x1F;
    354319        const size_t xmax = (data >> (flit_width - 10)) & 0x1F;
    355320        const size_t ymin = (data >> (flit_width - 15)) & 0x1F;
    356321        const size_t ymax = (data >> (flit_width - 20)) & 0x1F;
    357         const int    bh   = blackhole_position();
    358 
    359         int  sel = REQ_NOP;
    360         bool special = ((data & 0x2) != 0);
    361 
     322
     323        int bhpos = NORMAL;
     324        bool recovery = false;
     325        if (is_reconfigurable()) {
     326            bhpos    = blackhole_position();
     327            recovery = is_recovery_routing_enabled();
     328        }
     329
     330        const bool is_n  = recovery and (bhpos == N_OF_X);
     331        const bool is_s  = recovery and (bhpos == S_OF_X);
     332        const bool is_w  = recovery and (bhpos == W_OF_X);
     333        const bool is_e  = recovery and (bhpos == E_OF_X);
     334        const bool is_nw = recovery and (bhpos == NW_OF_X);
     335        const bool is_ne = recovery and (bhpos == NE_OF_X);
     336        const bool is_sw = recovery and (bhpos == SW_OF_X);
     337        const bool is_se = recovery and (bhpos == SE_OF_X);
     338
     339        const bool special = ((data & 0x2) != 0) and recovery;
     340
     341        int sel = REQ_NOP;
    362342        switch(source) {
    363343        case REQ_LOCAL :
    … …  
    365345            else if ( step == 2 ) sel = REQ_SOUTH;
    366346            else if ( step == 3 ) {
    367                 if ( (bh == BH_N) && (lx != 0) && (ly != 1) ) {
     347                if ( is_n && (lx != 0) && (ly != 1) )
    368348                    sel = REQ_NOP;
    369                     break;
    370                 }
    371                 sel = REQ_EAST;
     349                else
     350                    sel = REQ_EAST;
    372351            }
    373352            else if ( step == 4 ) {
    374                 if ( (bh == BH_NE) && (lx != 1) && (ly != 1) ) {
     353                if ( is_ne && (lx != 1) && (ly != 1) )
    375354                    sel = REQ_NOP;
    376                     break;
    377                 }
    378                 sel = REQ_WEST;
     355                else
     356                    sel = REQ_WEST;
    379357            }
    380358        break;
    … …  
    383361            else if ( step == 2 ) sel = REQ_LOCAL;
    384362            else if ( step == 3 ) {
    385                 if ( bh == BH_SW ) {
     363                if ( is_sw )
    386364                    sel = REQ_EAST;
    387                     break;
    388                 }
    389                 sel = REQ_NOP;
     365                else
     366                    sel = REQ_NOP;
    390367            }
    391368            else if ( step == 4 ) {
    392                 if ( (bh == BH_SE) && (!special || (lx == 1))) {
     369                if ( is_se && (!special || (lx == 1)))
    393370                    sel = REQ_WEST;
    394                     break;
    395                 }
    396                 sel = REQ_NOP;
     371                else
     372                    sel = REQ_NOP;
    397373            }
    398374        break;
    … …  
    401377            else if ( step == 2 ) sel = REQ_LOCAL;
    402378            else if ( step == 3 ) {
    403                 if ( bh == BH_NW ) {
     379                if ( is_nw )
    404380                    sel = REQ_EAST;
    405                     break;
    406                 }
    407                 if ( (bh == BH_NE) && ((lx == 1) || (ly == 1)) ) {
     381                else if ( is_ne && ((lx == 1) || (ly == 1)) )
    408382                    sel = REQ_WEST;
    409                     break;
    410                 }
    411                 sel = REQ_NOP;
     383                else
     384                    sel = REQ_NOP;
    412385            }
    413386            else if ( step == 4 ) sel = REQ_NOP;
    … …  
    415388        case REQ_EAST :
    416389            if ( step == 1 ) {
    417                 if ( (bh == BH_NE) && (lx != 1) && (ly != 1) ) {
     390                if ( is_ne && (lx != 1) && (ly != 1) )
    418391                    sel = REQ_NOP;
    419                     break;
    420                 }
    421                 sel = REQ_WEST;
     392                else
     393                    sel = REQ_WEST;
    422394            }
    423395            else if ( step == 2 ) sel = REQ_NORTH;
    … …  
    427399        case REQ_WEST :
    428400            if ( step == 1 ) {
    429                 if ( (bh == BH_N) && (ly != 1) ) {
     401                if ( is_n && (ly != 1) )
    430402                    sel = REQ_NOP;
    431                     break;
    432                 }
    433                 if ( (bh == BH_S) && special ) {
     403                else if ( is_s && special )
    434404                    sel = REQ_NOP;
    435                     break;
    436                 }
    437                 sel = REQ_EAST;
     405                else
     406                    sel = REQ_EAST;
    438407            }
    439408            else if ( step == 2 ) sel = REQ_NORTH;
    … …  
    443412        }
    444413
    445         if      ( (sel == REQ_NORTH) && !(ly < ymax) ) sel = REQ_NOP;
    446         else if ( (sel == REQ_SOUTH) && !(ly > ymin) ) sel = REQ_NOP;
    447         else if ( (sel == REQ_EAST ) && !(lx < xmax) ) sel = REQ_NOP;
    448         else if ( (sel == REQ_WEST ) && !(lx > xmin) ) sel = REQ_NOP;
    449 
    450 #if 0
    451         /* This code can be used if we want to inhibit requests to the
    452          * blackhole. However, it is not strictly necessary because the
    453          * blackhole will consume the request and will do nothing with it */
    454 
    455         if      ( (sel == REQ_NORTH) && (bh == BH_S) ) sel = REQ_NOP;
    456         else if ( (sel == REQ_SOUTH) && (bh == BH_N) ) sel = REQ_NOP;
    457         else if ( (sel == REQ_EAST ) && (bh == BH_W) ) sel = REQ_NOP;
    458         else if ( (sel == REQ_WEST ) && (bh == BH_E) ) sel = REQ_NOP;
    459 #endif
     414        // inhibit requests to the blackhole or beyond the mesh boundaries.
     415        if      ( (sel == REQ_NORTH) && (!(ly < ymax) || is_s)) sel = REQ_NOP;
     416        else if ( (sel == REQ_SOUTH) && (!(ly > ymin) || is_n)) sel = REQ_NOP;
     417        else if ( (sel == REQ_EAST ) && (!(lx < xmax) || is_w)) sel = REQ_NOP;
     418        else if ( (sel == REQ_WEST ) && (!(lx > xmin) || is_e)) sel = REQ_NOP;
    460419
    461420        return sel;
    … …  
    469428
    470429    /////////////////////////////////////////////////////////
    471     tmpl(sc_uint<flit_width>)::compute_broadcast_header(int source)
    472     {
    473         const int bh = blackhole_position();
    474         sc_uint<flit_width> header = r_fifo_in[source].read().data;
    475         sc_uint<flit_width> special = 0x2;
     430    tmpl(typename DspinRouter<flit_width>::internal_flit_t)::
     431    compute_broadcast_header(int source)
     432    {
     433        const int bhpos = blackhole_position();
     434
     435        const int is_nw = (bhpos == NW_OF_X);
     436        const int is_ne = (bhpos == NE_OF_X);
     437
     438        internal_flit_t header;
     439        header.eop = false;
     440        header.data = r_fifo_in[source].read().data;
     441
     442        const int SPECIAL = 0x2;
    476443        switch (source) {
    477444            case REQ_NORTH:
    478                 if ( (bh == BH_NW) || (bh == BH_NE) ) {
    479                     header |= special;
    480                 }
     445                if ( is_nw || is_ne ) header.data |= SPECIAL;
    481446                break;
    482447
    … …  
    484449             * network with the special bit set. This can arrive if an initiator
    485450             * or a local interconnect uses the broadcast header reserved bits
    486              * internally and don't reset them */
     451             * internally */
    487452            case REQ_LOCAL:
    488                 header &= ~special;
     453                header.data &= ~SPECIAL;
    489454                break;
    490455        }
    … …  
    521486        const char* bh_str[] =
    522487        {
    523             "BH_NONE",
    524             "BH_N",
    525             "BH_NE",
    526             "BH_E",
    527             "BH_SE",
    528             "BH_S",
    529             "BH_SW",
    530             "BH_W",
    531             "BH_NW"
     488            "N_OF_X",
     489            "NE_OF_X",
     490            "E_OF_X",
     491            "SE_OF_X",
     492            "S_OF_X",
     493            "SW_OF_X",
     494            "W_OF_X",
     495            "NW_OF_X"
    532496        };
    533497
    534498        std::cout << "DSPIN_ROUTER " << name();
    535         std::cout << " / bh = " << bh_str[blackhole_position()];
     499
     500        if ( is_reconfigurable() ) {
     501            std::cout << " / bh = " << bh_str[blackhole_position()];
     502            if (is_recovery_routing_enabled())
     503                std::cout << " / recovery_routing ";
     504            if (is_reallocation_enabled())
     505                std::cout << " / reallocation dir = "
     506                          << port_name[reallocation_route()];
     507        }
     508
    536509
    537510        for( size_t i = 0 ; i < 5 ; i++)  // loop on input ports
    … …  
    640613                            {
    641614                                std::cout << "ERROR in DSPIN_ROUTER " << name()
    642                                           << " : broadcast packet must be 2 flits" << std::endl;
     615                                          << " : broadcast packet must be 2 flits"
     616                                          << std::endl;
    643617                                exit(1);
    644618                            }
    645619
    646                             internal_flit_t header;
    647                             header.eop  = false;
    648                             header.data = compute_broadcast_header(i);
     620                            const internal_flit_t& header = compute_broadcast_header(i);
    649621
    650622                            fifo_in_read[i] = true;
    … …  
    652624                            r_buf_in[i]     = header;
    653625                            r_index_in[i]   = req_in[i];
    654                             if( req_in[i] == REQ_NOP ) r_fsm_in[i] = INFSM_REQ_SECOND;
    655                             else                       r_fsm_in[i] = INFSM_REQ_FIRST;
     626                            if ( req_in[i] == REQ_NOP ) r_fsm_in[i] = INFSM_REQ_SECOND;
     627                            else                        r_fsm_in[i] = INFSM_REQ_FIRST;
    656628                        }
    657629                        else                                  // unicast
Note: See TracChangeset for help on using the changeset viewer.