- Timestamp:
- Sep 14, 2015, 9:42:16 AM (9 years ago)
- Location:
- branches/reconfiguration/modules/dspin_router/caba/source
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/reconfiguration/modules/dspin_router/caba/source/include/dspin_router.h
r1010 r1016 29 29 /////////////////////////////////////////////////////////////////////////// 30 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: 31 // DSPIN first flit format: 33 32 // - In case of a non-broadcast packet : 34 33 // | X | Y |---------------------------------------|BC | … … 36 35 // 37 36 // - In case of a broacast 38 // | XMIN | XMAX | YMIN | YMAX |---------------- ---|BC |39 // | 5 | 5 | 5 | 5 | flit_width - 2 2| 1 |37 // | XMIN | XMAX | YMIN | YMAX |----------------|SP|BC | 38 // | 5 | 5 | 5 | 5 | flit_width - 21| 1| 1 | 40 39 /////////////////////////////////////////////////////////////////////////// 41 40 … … 147 146 void genMoore(); 148 147 149 int xfirst_route( size_t xdest, size_t ydest);148 int route( sc_uint<flit_width> data ); 150 149 int recovery_route( size_t xdest, size_t ydest ); 151 int route( sc_uint<flit_width> data ); 150 int broadcast_route( int iter, int source, sc_uint<flit_width> data ); 151 int reallocation_route(); 152 152 153 int broadcast_route( int iter, int source, sc_uint<flit_width> data );154 153 bool is_broadcast( sc_uint<flit_width> data ); 155 sc_uint<flit_width>compute_broadcast_header( int source );154 internal_flit_t compute_broadcast_header( int source ); 156 155 157 bool is_destination_blackhole( size_t xdest, size_t ydest, int bhpos ); 156 bool is_reconfigurable(); 157 bool is_recovery_routing_enabled(); 158 bool is_reallocation_enabled(); 159 bool is_destination_blackhole( size_t xdest, size_t ydest ); 158 160 int blackhole_position(); 159 160 inline bool is_network_recovery_enable()161 {162 return (((p_recovery_cfg->read() >> 7) & 0x1) != 0);163 }164 165 inline int migration_route()166 {167 return ((p_recovery_cfg->read() >> 4) & 0x7);168 }169 170 inline bool is_reconfigurable()171 {172 return (p_recovery_cfg != NULL);173 }174 161 175 162 public: -
branches/reconfiguration/modules/dspin_router/caba/source/src/dspin_router.cpp
r1006 r1016 26 26 * 27 27 */ 28 29 ///////////////////////////////////////////////////////////////////////////30 // Implementation Note :31 // The xfirst_route(), broadcast_route() and is_broadcast() functions32 // 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 broacast38 // | XMIN | XMAX | YMIN | YMAX |----------------|SP|BC |39 // | 5 | 5 | 5 | 5 | flit_width - 21| 1| 1 |40 ///////////////////////////////////////////////////////////////////////////41 42 28 #include "../include/dspin_router.h" 43 29 #include "dspin_router_config.h" 30 31 #include <cassert> 44 32 45 33 namespace soclib { namespace caba { … … 132 120 tmpl(int)::blackhole_position() 133 121 { 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; 138 124 } 139 125 … … 141 127 tmpl(void)::bind_recovery_port(sc_signal<uint32_t> &s) 142 128 { 143 if ( !is_reconfigurable()) {129 if ( not is_reconfigurable() ) { 144 130 std::cerr << "Error in " << name() 145 131 << ": router configuration not supported." << std::endl … … 150 136 } 151 137 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 152 161 /////////////////////////////////////////////////// 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)); 159 190 } 160 191 161 192 /////////////////////////////////////////////////// 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 ) 213 223 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)) ) 218 227 return REQ_EAST; 219 } 220 else { 228 else 221 229 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)) ) 227 233 return REQ_EAST; 228 } 229 else { 234 else 230 235 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)) 235 239 return REQ_NORTH; 236 } 237 else { 240 else 238 241 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)) ) 243 245 return REQ_EAST; 244 } 245 else { 246 else 246 247 return REQ_NORTH; 247 }248 248 } 249 249 std::cout << "error: unexpected condition in function " … … 251 251 << std::endl; 252 252 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 ) 257 256 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) ) 261 260 return REQ_WEST; 262 } 263 else { 261 else 264 262 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)) ) 269 266 return REQ_NORTH; 270 } 271 else { 267 else 272 268 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)) ) 278 272 return REQ_NORTH; 279 } 280 else { 273 else 281 274 return REQ_SOUTH; 282 }283 275 } 284 276 std::cout << "error: unexpected condition in function " … … 286 278 << std::endl; 287 279 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 } 311 291 return REQ_LOCAL; 312 292 } … … 315 295 tmpl(int)::route( sc_uint<flit_width> data ) 316 296 { 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 (this322 // i s to implement the segment recoverymechanism)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)) 324 304 { 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); 346 311 } 347 312 … … 349 314 tmpl(int)::broadcast_route(int step, int source, sc_uint<flit_width> data) 350 315 { 351 const size_t lx 352 const size_t ly 316 const size_t lx = m_local_x; 317 const size_t ly = m_local_y; 353 318 const size_t xmin = (data >> (flit_width - 5 )) & 0x1F; 354 319 const size_t xmax = (data >> (flit_width - 10)) & 0x1F; 355 320 const size_t ymin = (data >> (flit_width - 15)) & 0x1F; 356 321 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; 362 342 switch(source) { 363 343 case REQ_LOCAL : … … 365 345 else if ( step == 2 ) sel = REQ_SOUTH; 366 346 else if ( step == 3 ) { 367 if ( (bh == BH_N) && (lx != 0) && (ly != 1) ) {347 if ( is_n && (lx != 0) && (ly != 1) ) 368 348 sel = REQ_NOP; 369 break; 370 } 371 sel = REQ_EAST; 349 else 350 sel = REQ_EAST; 372 351 } 373 352 else if ( step == 4 ) { 374 if ( (bh == BH_NE) && (lx != 1) && (ly != 1) ) {353 if ( is_ne && (lx != 1) && (ly != 1) ) 375 354 sel = REQ_NOP; 376 break; 377 } 378 sel = REQ_WEST; 355 else 356 sel = REQ_WEST; 379 357 } 380 358 break; … … 383 361 else if ( step == 2 ) sel = REQ_LOCAL; 384 362 else if ( step == 3 ) { 385 if ( bh == BH_SW ) {363 if ( is_sw ) 386 364 sel = REQ_EAST; 387 break; 388 } 389 sel = REQ_NOP; 365 else 366 sel = REQ_NOP; 390 367 } 391 368 else if ( step == 4 ) { 392 if ( (bh == BH_SE) && (!special || (lx == 1))) {369 if ( is_se && (!special || (lx == 1))) 393 370 sel = REQ_WEST; 394 break; 395 } 396 sel = REQ_NOP; 371 else 372 sel = REQ_NOP; 397 373 } 398 374 break; … … 401 377 else if ( step == 2 ) sel = REQ_LOCAL; 402 378 else if ( step == 3 ) { 403 if ( bh == BH_NW ) {379 if ( is_nw ) 404 380 sel = REQ_EAST; 405 break; 406 } 407 if ( (bh == BH_NE) && ((lx == 1) || (ly == 1)) ) { 381 else if ( is_ne && ((lx == 1) || (ly == 1)) ) 408 382 sel = REQ_WEST; 409 break; 410 } 411 sel = REQ_NOP; 383 else 384 sel = REQ_NOP; 412 385 } 413 386 else if ( step == 4 ) sel = REQ_NOP; … … 415 388 case REQ_EAST : 416 389 if ( step == 1 ) { 417 if ( (bh == BH_NE) && (lx != 1) && (ly != 1) ) {390 if ( is_ne && (lx != 1) && (ly != 1) ) 418 391 sel = REQ_NOP; 419 break; 420 } 421 sel = REQ_WEST; 392 else 393 sel = REQ_WEST; 422 394 } 423 395 else if ( step == 2 ) sel = REQ_NORTH; … … 427 399 case REQ_WEST : 428 400 if ( step == 1 ) { 429 if ( (bh == BH_N) && (ly != 1) ) {401 if ( is_n && (ly != 1) ) 430 402 sel = REQ_NOP; 431 break; 432 } 433 if ( (bh == BH_S) && special ) { 403 else if ( is_s && special ) 434 404 sel = REQ_NOP; 435 break; 436 } 437 sel = REQ_EAST; 405 else 406 sel = REQ_EAST; 438 407 } 439 408 else if ( step == 2 ) sel = REQ_NORTH; … … 443 412 } 444 413 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; 460 419 461 420 return sel; … … 469 428 470 429 ///////////////////////////////////////////////////////// 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; 476 443 switch (source) { 477 444 case REQ_NORTH: 478 if ( (bh == BH_NW) || (bh == BH_NE) ) { 479 header |= special; 480 } 445 if ( is_nw || is_ne ) header.data |= SPECIAL; 481 446 break; 482 447 … … 484 449 * network with the special bit set. This can arrive if an initiator 485 450 * or a local interconnect uses the broadcast header reserved bits 486 * internally and don't reset them*/451 * internally */ 487 452 case REQ_LOCAL: 488 header &= ~special;453 header.data &= ~SPECIAL; 489 454 break; 490 455 } … … 521 486 const char* bh_str[] = 522 487 { 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" 532 496 }; 533 497 534 498 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 536 509 537 510 for( size_t i = 0 ; i < 5 ; i++) // loop on input ports … … 640 613 { 641 614 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; 643 617 exit(1); 644 618 } 645 619 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); 649 621 650 622 fifo_in_read[i] = true; … … 652 624 r_buf_in[i] = header; 653 625 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; 656 628 } 657 629 else // unicast
Note: See TracChangeset
for help on using the changeset viewer.