lsq_impl.hh (3647:8121d4503cbc) | lsq_impl.hh (3867:807483cfab77) |
---|---|
1/* 2 * Copyright (c) 2005-2006 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; --- 230 unchanged lines hidden (view full) --- 239 } 240} 241 242template <class Impl> 243void 244LSQ<Impl>::resetEntries() 245{ 246 if (lsqPolicy != Dynamic || numThreads > 1) { | 1/* 2 * Copyright (c) 2005-2006 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; --- 230 unchanged lines hidden (view full) --- 239 } 240} 241 242template <class Impl> 243void 244LSQ<Impl>::resetEntries() 245{ 246 if (lsqPolicy != Dynamic || numThreads > 1) { |
247 int active_threads = (*activeThreads).size(); | 247 int active_threads = activeThreads->size(); |
248 | 248 |
249 std::list<unsigned>::iterator threads = (*activeThreads).begin(); 250 std::list<unsigned>::iterator list_end = (*activeThreads).end(); 251 | |
252 int maxEntries; 253 254 if (lsqPolicy == Partitioned) { 255 maxEntries = LQEntries / active_threads; 256 } else if (lsqPolicy == Threshold && active_threads == 1) { 257 maxEntries = LQEntries; 258 } else { 259 maxEntries = LQEntries; 260 } 261 | 249 int maxEntries; 250 251 if (lsqPolicy == Partitioned) { 252 maxEntries = LQEntries / active_threads; 253 } else if (lsqPolicy == Threshold && active_threads == 1) { 254 maxEntries = LQEntries; 255 } else { 256 maxEntries = LQEntries; 257 } 258 |
262 while (threads != list_end) { 263 resizeEntries(maxEntries,*threads++); | 259 std::list<unsigned>::iterator threads = activeThreads->begin(); 260 std::list<unsigned>::iterator end = activeThreads->end(); 261 262 while (threads != end) { 263 unsigned tid = *threads++; 264 265 resizeEntries(maxEntries, tid); |
264 } 265 } 266} 267 268template<class Impl> 269void 270LSQ<Impl>::removeEntries(unsigned tid) 271{ --- 8 unchanged lines hidden (view full) --- 280 thread[tid].resizeLQ(size); 281 thread[tid].resizeSQ(size); 282} 283 284template<class Impl> 285void 286LSQ<Impl>::tick() 287{ | 266 } 267 } 268} 269 270template<class Impl> 271void 272LSQ<Impl>::removeEntries(unsigned tid) 273{ --- 8 unchanged lines hidden (view full) --- 282 thread[tid].resizeLQ(size); 283 thread[tid].resizeSQ(size); 284} 285 286template<class Impl> 287void 288LSQ<Impl>::tick() 289{ |
288 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 290 std::list<unsigned>::iterator threads = activeThreads->begin(); 291 std::list<unsigned>::iterator end = activeThreads->end(); |
289 | 292 |
290 while (active_threads != (*activeThreads).end()) { 291 unsigned tid = *active_threads++; | 293 while (threads != end) { 294 unsigned tid = *threads++; |
292 293 thread[tid].tick(); 294 } 295} 296 297template<class Impl> 298void 299LSQ<Impl>::insertLoad(DynInstPtr &load_inst) --- 29 unchanged lines hidden (view full) --- 329 330 return thread[tid].executeStore(inst); 331} 332 333template<class Impl> 334void 335LSQ<Impl>::writebackStores() 336{ | 295 296 thread[tid].tick(); 297 } 298} 299 300template<class Impl> 301void 302LSQ<Impl>::insertLoad(DynInstPtr &load_inst) --- 29 unchanged lines hidden (view full) --- 332 333 return thread[tid].executeStore(inst); 334} 335 336template<class Impl> 337void 338LSQ<Impl>::writebackStores() 339{ |
337 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 340 std::list<unsigned>::iterator threads = activeThreads->begin(); 341 std::list<unsigned>::iterator end = activeThreads->end(); |
338 | 342 |
339 while (active_threads != (*activeThreads).end()) { 340 unsigned tid = *active_threads++; | 343 while (threads != end) { 344 unsigned tid = *threads++; |
341 342 if (numStoresToWB(tid) > 0) { 343 DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores " 344 "available for Writeback.\n", tid, numStoresToWB(tid)); 345 } 346 347 thread[tid].writebackStores(); 348 } 349} 350 351template<class Impl> 352bool 353LSQ<Impl>::violation() 354{ 355 /* Answers: Does Anybody Have a Violation?*/ | 345 346 if (numStoresToWB(tid) > 0) { 347 DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores " 348 "available for Writeback.\n", tid, numStoresToWB(tid)); 349 } 350 351 thread[tid].writebackStores(); 352 } 353} 354 355template<class Impl> 356bool 357LSQ<Impl>::violation() 358{ 359 /* Answers: Does Anybody Have a Violation?*/ |
356 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 360 std::list<unsigned>::iterator threads = activeThreads->begin(); 361 std::list<unsigned>::iterator end = activeThreads->end(); |
357 | 362 |
358 while (active_threads != (*activeThreads).end()) { 359 unsigned tid = *active_threads++; | 363 while (threads != end) { 364 unsigned tid = *threads++; 365 |
360 if (thread[tid].violation()) 361 return true; 362 } 363 364 return false; 365} 366 367template<class Impl> 368int 369LSQ<Impl>::getCount() 370{ 371 unsigned total = 0; 372 | 366 if (thread[tid].violation()) 367 return true; 368 } 369 370 return false; 371} 372 373template<class Impl> 374int 375LSQ<Impl>::getCount() 376{ 377 unsigned total = 0; 378 |
373 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 379 std::list<unsigned>::iterator threads = activeThreads->begin(); 380 std::list<unsigned>::iterator end = activeThreads->end(); |
374 | 381 |
375 while (active_threads != (*activeThreads).end()) { 376 unsigned tid = *active_threads++; | 382 while (threads != end) { 383 unsigned tid = *threads++; 384 |
377 total += getCount(tid); 378 } 379 380 return total; 381} 382 383template<class Impl> 384int 385LSQ<Impl>::numLoads() 386{ 387 unsigned total = 0; 388 | 385 total += getCount(tid); 386 } 387 388 return total; 389} 390 391template<class Impl> 392int 393LSQ<Impl>::numLoads() 394{ 395 unsigned total = 0; 396 |
389 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 397 std::list<unsigned>::iterator threads = activeThreads->begin(); 398 std::list<unsigned>::iterator end = activeThreads->end(); |
390 | 399 |
391 while (active_threads != (*activeThreads).end()) { 392 unsigned tid = *active_threads++; | 400 while (threads != end) { 401 unsigned tid = *threads++; 402 |
393 total += numLoads(tid); 394 } 395 396 return total; 397} 398 399template<class Impl> 400int 401LSQ<Impl>::numStores() 402{ 403 unsigned total = 0; 404 | 403 total += numLoads(tid); 404 } 405 406 return total; 407} 408 409template<class Impl> 410int 411LSQ<Impl>::numStores() 412{ 413 unsigned total = 0; 414 |
405 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 415 std::list<unsigned>::iterator threads = activeThreads->begin(); 416 std::list<unsigned>::iterator end = activeThreads->end(); |
406 | 417 |
407 while (active_threads != (*activeThreads).end()) { 408 unsigned tid = *active_threads++; | 418 while (threads != end) { 419 unsigned tid = *threads++; 420 |
409 total += thread[tid].numStores(); 410 } 411 412 return total; 413} 414 415template<class Impl> 416int 417LSQ<Impl>::numLoadsReady() 418{ 419 unsigned total = 0; 420 | 421 total += thread[tid].numStores(); 422 } 423 424 return total; 425} 426 427template<class Impl> 428int 429LSQ<Impl>::numLoadsReady() 430{ 431 unsigned total = 0; 432 |
421 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 433 std::list<unsigned>::iterator threads = activeThreads->begin(); 434 std::list<unsigned>::iterator end = activeThreads->end(); |
422 | 435 |
423 while (active_threads != (*activeThreads).end()) { 424 unsigned tid = *active_threads++; | 436 while (threads != end) { 437 unsigned tid = *threads++; 438 |
425 total += thread[tid].numLoadsReady(); 426 } 427 428 return total; 429} 430 431template<class Impl> 432unsigned 433LSQ<Impl>::numFreeEntries() 434{ 435 unsigned total = 0; 436 | 439 total += thread[tid].numLoadsReady(); 440 } 441 442 return total; 443} 444 445template<class Impl> 446unsigned 447LSQ<Impl>::numFreeEntries() 448{ 449 unsigned total = 0; 450 |
437 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 451 std::list<unsigned>::iterator threads = activeThreads->begin(); 452 std::list<unsigned>::iterator end = activeThreads->end(); |
438 | 453 |
439 while (active_threads != (*activeThreads).end()) { 440 unsigned tid = *active_threads++; | 454 while (threads != end) { 455 unsigned tid = *threads++; 456 |
441 total += thread[tid].numFreeEntries(); 442 } 443 444 return total; 445} 446 447template<class Impl> 448unsigned --- 4 unchanged lines hidden (view full) --- 453 //else 454 return thread[tid].numFreeEntries(); 455} 456 457template<class Impl> 458bool 459LSQ<Impl>::isFull() 460{ | 457 total += thread[tid].numFreeEntries(); 458 } 459 460 return total; 461} 462 463template<class Impl> 464unsigned --- 4 unchanged lines hidden (view full) --- 469 //else 470 return thread[tid].numFreeEntries(); 471} 472 473template<class Impl> 474bool 475LSQ<Impl>::isFull() 476{ |
461 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 477 std::list<unsigned>::iterator threads = activeThreads->begin(); 478 std::list<unsigned>::iterator end = activeThreads->end(); |
462 | 479 |
463 while (active_threads != (*activeThreads).end()) { 464 unsigned tid = *active_threads++; 465 if (! (thread[tid].lqFull() || thread[tid].sqFull()) ) | 480 while (threads != end) { 481 unsigned tid = *threads++; 482 483 if (!(thread[tid].lqFull() || thread[tid].sqFull())) |
466 return false; 467 } 468 469 return true; 470} 471 472template<class Impl> 473bool 474LSQ<Impl>::isFull(unsigned tid) 475{ 476 //@todo: Change to Calculate All Entries for 477 //Dynamic Policy | 484 return false; 485 } 486 487 return true; 488} 489 490template<class Impl> 491bool 492LSQ<Impl>::isFull(unsigned tid) 493{ 494 //@todo: Change to Calculate All Entries for 495 //Dynamic Policy |
478 if( lsqPolicy == Dynamic ) | 496 if (lsqPolicy == Dynamic) |
479 return isFull(); 480 else 481 return thread[tid].lqFull() || thread[tid].sqFull(); 482} 483 484template<class Impl> 485bool 486LSQ<Impl>::lqFull() 487{ | 497 return isFull(); 498 else 499 return thread[tid].lqFull() || thread[tid].sqFull(); 500} 501 502template<class Impl> 503bool 504LSQ<Impl>::lqFull() 505{ |
488 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 506 std::list<unsigned>::iterator threads = activeThreads->begin(); 507 std::list<unsigned>::iterator end = activeThreads->end(); |
489 | 508 |
490 while (active_threads != (*activeThreads).end()) { 491 unsigned tid = *active_threads++; | 509 while (threads != end) { 510 unsigned tid = *threads++; 511 |
492 if (!thread[tid].lqFull()) 493 return false; 494 } 495 496 return true; 497} 498 499template<class Impl> --- 7 unchanged lines hidden (view full) --- 507 else 508 return thread[tid].lqFull(); 509} 510 511template<class Impl> 512bool 513LSQ<Impl>::sqFull() 514{ | 512 if (!thread[tid].lqFull()) 513 return false; 514 } 515 516 return true; 517} 518 519template<class Impl> --- 7 unchanged lines hidden (view full) --- 527 else 528 return thread[tid].lqFull(); 529} 530 531template<class Impl> 532bool 533LSQ<Impl>::sqFull() 534{ |
515 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 535 std::list<unsigned>::iterator threads = activeThreads->begin(); 536 std::list<unsigned>::iterator end = activeThreads->end(); |
516 | 537 |
517 while (active_threads != (*activeThreads).end()) { 518 unsigned tid = *active_threads++; | 538 while (threads != end) { 539 unsigned tid = *threads++; 540 |
519 if (!sqFull(tid)) 520 return false; 521 } 522 523 return true; 524} 525 526template<class Impl> --- 7 unchanged lines hidden (view full) --- 534 else 535 return thread[tid].sqFull(); 536} 537 538template<class Impl> 539bool 540LSQ<Impl>::isStalled() 541{ | 541 if (!sqFull(tid)) 542 return false; 543 } 544 545 return true; 546} 547 548template<class Impl> --- 7 unchanged lines hidden (view full) --- 556 else 557 return thread[tid].sqFull(); 558} 559 560template<class Impl> 561bool 562LSQ<Impl>::isStalled() 563{ |
542 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 564 std::list<unsigned>::iterator threads = activeThreads->begin(); 565 std::list<unsigned>::iterator end = activeThreads->end(); |
543 | 566 |
544 while (active_threads != (*activeThreads).end()) { 545 unsigned tid = *active_threads++; | 567 while (threads != end) { 568 unsigned tid = *threads++; 569 |
546 if (!thread[tid].isStalled()) 547 return false; 548 } 549 550 return true; 551} 552 553template<class Impl> --- 5 unchanged lines hidden (view full) --- 559 else 560 return thread[tid].isStalled(); 561} 562 563template<class Impl> 564bool 565LSQ<Impl>::hasStoresToWB() 566{ | 570 if (!thread[tid].isStalled()) 571 return false; 572 } 573 574 return true; 575} 576 577template<class Impl> --- 5 unchanged lines hidden (view full) --- 583 else 584 return thread[tid].isStalled(); 585} 586 587template<class Impl> 588bool 589LSQ<Impl>::hasStoresToWB() 590{ |
567 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 591 std::list<unsigned>::iterator threads = activeThreads->begin(); 592 std::list<unsigned>::iterator end = activeThreads->end(); |
568 | 593 |
569 if ((*activeThreads).empty()) | 594 if (threads == end) |
570 return false; 571 | 595 return false; 596 |
572 while (active_threads != (*activeThreads).end()) { 573 unsigned tid = *active_threads++; | 597 while (threads != end) { 598 unsigned tid = *threads++; 599 |
574 if (!hasStoresToWB(tid)) 575 return false; 576 } 577 578 return true; 579} 580 581template<class Impl> 582bool 583LSQ<Impl>::willWB() 584{ | 600 if (!hasStoresToWB(tid)) 601 return false; 602 } 603 604 return true; 605} 606 607template<class Impl> 608bool 609LSQ<Impl>::willWB() 610{ |
585 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 611 std::list<unsigned>::iterator threads = activeThreads->begin(); 612 std::list<unsigned>::iterator end = activeThreads->end(); |
586 | 613 |
587 while (active_threads != (*activeThreads).end()) { 588 unsigned tid = *active_threads++; | 614 while (threads != end) { 615 unsigned tid = *threads++; 616 |
589 if (!willWB(tid)) 590 return false; 591 } 592 593 return true; 594} 595 596template<class Impl> 597void 598LSQ<Impl>::dumpInsts() 599{ | 617 if (!willWB(tid)) 618 return false; 619 } 620 621 return true; 622} 623 624template<class Impl> 625void 626LSQ<Impl>::dumpInsts() 627{ |
600 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); | 628 std::list<unsigned>::iterator threads = activeThreads->begin(); 629 std::list<unsigned>::iterator end = activeThreads->end(); |
601 | 630 |
602 while (active_threads != (*activeThreads).end()) { 603 unsigned tid = *active_threads++; | 631 while (threads != end) { 632 unsigned tid = *threads++; 633 |
604 thread[tid].dumpInsts(); 605 } 606} | 634 thread[tid].dumpInsts(); 635 } 636} |