pseudo_inst.cc revision 9180
1/* 2 * Copyright (c) 2010-2011 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2011 Advanced Micro Devices, Inc. 15 * Copyright (c) 2003-2006 The Regents of The University of Michigan 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions are 20 * met: redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer; 22 * redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution; 25 * neither the name of the copyright holders nor the names of its 26 * contributors may be used to endorse or promote products derived from 27 * this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Authors: Nathan Binkert 42 */ 43 44#include <fcntl.h> 45#include <unistd.h> 46 47#include <cerrno> 48#include <fstream> 49#include <string> 50 51#include "arch/kernel_stats.hh" 52#include "arch/vtophys.hh" 53#include "base/debug.hh" 54#include "base/output.hh" 55#include "config/the_isa.hh" 56#include "cpu/base.hh" 57#include "cpu/quiesce_event.hh" 58#include "cpu/thread_context.hh" 59#include "debug/Loader.hh" 60#include "debug/Quiesce.hh" 61#include "debug/WorkItems.hh" 62#include "params/BaseCPU.hh" 63#include "sim/full_system.hh" 64#include "sim/pseudo_inst.hh" 65#include "sim/serialize.hh" 66#include "sim/sim_events.hh" 67#include "sim/sim_exit.hh" 68#include "sim/stat_control.hh" 69#include "sim/stats.hh" 70#include "sim/system.hh" 71#include "sim/vptr.hh" 72 73using namespace std; 74 75using namespace Stats; 76using namespace TheISA; 77 78namespace PseudoInst { 79 80static inline void 81panicFsOnlyPseudoInst(const char *name) 82{ 83 panic("Pseudo inst \"%s\" is only available in Full System mode."); 84} 85 86void 87arm(ThreadContext *tc) 88{ 89 if (!FullSystem) 90 panicFsOnlyPseudoInst("arm"); 91 92 if (tc->getKernelStats()) 93 tc->getKernelStats()->arm(); 94} 95 96void 97quiesce(ThreadContext *tc) 98{ 99 if (!FullSystem) 100 panicFsOnlyPseudoInst("quiesce"); 101 102 if (!tc->getCpuPtr()->params()->do_quiesce) 103 return; 104 105 DPRINTF(Quiesce, "%s: quiesce()\n", tc->getCpuPtr()->name()); 106 107 tc->suspend(); 108 if (tc->getKernelStats()) 109 tc->getKernelStats()->quiesce(); 110} 111 112void 113quiesceSkip(ThreadContext *tc) 114{ 115 if (!FullSystem) 116 panicFsOnlyPseudoInst("quiesceSkip"); 117 118 BaseCPU *cpu = tc->getCpuPtr(); 119 120 if (!cpu->params()->do_quiesce) 121 return; 122 123 EndQuiesceEvent *quiesceEvent = tc->getQuiesceEvent(); 124 125 Tick resume = curTick() + 1; 126 127 cpu->reschedule(quiesceEvent, resume, true); 128 129 DPRINTF(Quiesce, "%s: quiesceSkip() until %d\n", 130 cpu->name(), resume); 131 132 tc->suspend(); 133 if (tc->getKernelStats()) 134 tc->getKernelStats()->quiesce(); 135} 136 137void 138quiesceNs(ThreadContext *tc, uint64_t ns) 139{ 140 if (!FullSystem) 141 panicFsOnlyPseudoInst("quiesceNs"); 142 143 BaseCPU *cpu = tc->getCpuPtr(); 144 145 if (!cpu->params()->do_quiesce || ns == 0) 146 return; 147 148 EndQuiesceEvent *quiesceEvent = tc->getQuiesceEvent(); 149 150 Tick resume = curTick() + SimClock::Int::ns * ns; 151 152 cpu->reschedule(quiesceEvent, resume, true); 153 154 DPRINTF(Quiesce, "%s: quiesceNs(%d) until %d\n", 155 cpu->name(), ns, resume); 156 157 tc->suspend(); 158 if (tc->getKernelStats()) 159 tc->getKernelStats()->quiesce(); 160} 161 162void 163quiesceCycles(ThreadContext *tc, uint64_t cycles) 164{ 165 if (!FullSystem) 166 panicFsOnlyPseudoInst("quiesceCycles"); 167 168 BaseCPU *cpu = tc->getCpuPtr(); 169 170 if (!cpu->params()->do_quiesce || cycles == 0) 171 return; 172 173 EndQuiesceEvent *quiesceEvent = tc->getQuiesceEvent(); 174 175 Tick resume = cpu->clockEdge(Cycles(cycles)); 176 177 cpu->reschedule(quiesceEvent, resume, true); 178 179 DPRINTF(Quiesce, "%s: quiesceCycles(%d) until %d\n", 180 cpu->name(), cycles, resume); 181 182 tc->suspend(); 183 if (tc->getKernelStats()) 184 tc->getKernelStats()->quiesce(); 185} 186 187uint64_t 188quiesceTime(ThreadContext *tc) 189{ 190 if (!FullSystem) { 191 panicFsOnlyPseudoInst("quiesceTime"); 192 return 0; 193 } 194 195 return (tc->readLastActivate() - tc->readLastSuspend()) / 196 SimClock::Int::ns; 197} 198 199uint64_t 200rpns(ThreadContext *tc) 201{ 202 return curTick() / SimClock::Int::ns; 203} 204 205void 206wakeCPU(ThreadContext *tc, uint64_t cpuid) 207{ 208 System *sys = tc->getSystemPtr(); 209 ThreadContext *other_tc = sys->threadContexts[cpuid]; 210 if (other_tc->status() == ThreadContext::Suspended) 211 other_tc->activate(); 212} 213 214void 215m5exit(ThreadContext *tc, Tick delay) 216{ 217 Tick when = curTick() + delay * SimClock::Int::ns; 218 exitSimLoop("m5_exit instruction encountered", 0, when); 219} 220 221void 222loadsymbol(ThreadContext *tc) 223{ 224 if (!FullSystem) 225 panicFsOnlyPseudoInst("loadsymbol"); 226 227 const string &filename = tc->getCpuPtr()->system->params()->symbolfile; 228 if (filename.empty()) { 229 return; 230 } 231 232 std::string buffer; 233 ifstream file(filename.c_str()); 234 235 if (!file) 236 fatal("file error: Can't open symbol table file %s\n", filename); 237 238 while (!file.eof()) { 239 getline(file, buffer); 240 241 if (buffer.empty()) 242 continue; 243 244 string::size_type idx = buffer.find(' '); 245 if (idx == string::npos) 246 continue; 247 248 string address = "0x" + buffer.substr(0, idx); 249 eat_white(address); 250 if (address.empty()) 251 continue; 252 253 // Skip over letter and space 254 string symbol = buffer.substr(idx + 3); 255 eat_white(symbol); 256 if (symbol.empty()) 257 continue; 258 259 Addr addr; 260 if (!to_number(address, addr)) 261 continue; 262 263 if (!tc->getSystemPtr()->kernelSymtab->insert(addr, symbol)) 264 continue; 265 266 267 DPRINTF(Loader, "Loaded symbol: %s @ %#llx\n", symbol, addr); 268 } 269 file.close(); 270} 271 272void 273addsymbol(ThreadContext *tc, Addr addr, Addr symbolAddr) 274{ 275 if (!FullSystem) 276 panicFsOnlyPseudoInst("addSymbol"); 277 278 char symb[100]; 279 CopyStringOut(tc, symb, symbolAddr, 100); 280 std::string symbol(symb); 281 282 DPRINTF(Loader, "Loaded symbol: %s @ %#llx\n", symbol, addr); 283 284 tc->getSystemPtr()->kernelSymtab->insert(addr,symbol); 285 debugSymbolTable->insert(addr,symbol); 286} 287 288uint64_t 289initParam(ThreadContext *tc) 290{ 291 if (!FullSystem) { 292 panicFsOnlyPseudoInst("initParam"); 293 return 0; 294 } 295 296 return tc->getCpuPtr()->system->init_param; 297} 298 299 300void 301resetstats(ThreadContext *tc, Tick delay, Tick period) 302{ 303 if (!tc->getCpuPtr()->params()->do_statistics_insts) 304 return; 305 306 307 Tick when = curTick() + delay * SimClock::Int::ns; 308 Tick repeat = period * SimClock::Int::ns; 309 310 Stats::schedStatEvent(false, true, when, repeat); 311} 312 313void 314dumpstats(ThreadContext *tc, Tick delay, Tick period) 315{ 316 if (!tc->getCpuPtr()->params()->do_statistics_insts) 317 return; 318 319 320 Tick when = curTick() + delay * SimClock::Int::ns; 321 Tick repeat = period * SimClock::Int::ns; 322 323 Stats::schedStatEvent(true, false, when, repeat); 324} 325 326void 327dumpresetstats(ThreadContext *tc, Tick delay, Tick period) 328{ 329 if (!tc->getCpuPtr()->params()->do_statistics_insts) 330 return; 331 332 333 Tick when = curTick() + delay * SimClock::Int::ns; 334 Tick repeat = period * SimClock::Int::ns; 335 336 Stats::schedStatEvent(true, true, when, repeat); 337} 338 339void 340m5checkpoint(ThreadContext *tc, Tick delay, Tick period) 341{ 342 if (!tc->getCpuPtr()->params()->do_checkpoint_insts) 343 return; 344 345 Tick when = curTick() + delay * SimClock::Int::ns; 346 Tick repeat = period * SimClock::Int::ns; 347 348 exitSimLoop("checkpoint", 0, when, repeat); 349} 350 351uint64_t 352readfile(ThreadContext *tc, Addr vaddr, uint64_t len, uint64_t offset) 353{ 354 if (!FullSystem) { 355 panicFsOnlyPseudoInst("readfile"); 356 return 0; 357 } 358 359 const string &file = tc->getSystemPtr()->params()->readfile; 360 if (file.empty()) { 361 return ULL(0); 362 } 363 364 uint64_t result = 0; 365 366 int fd = ::open(file.c_str(), O_RDONLY, 0); 367 if (fd < 0) 368 panic("could not open file %s\n", file); 369 370 if (::lseek(fd, offset, SEEK_SET) < 0) 371 panic("could not seek: %s", strerror(errno)); 372 373 char *buf = new char[len]; 374 char *p = buf; 375 while (len > 0) { 376 int bytes = ::read(fd, p, len); 377 if (bytes <= 0) 378 break; 379 380 p += bytes; 381 result += bytes; 382 len -= bytes; 383 } 384 385 close(fd); 386 CopyIn(tc, vaddr, buf, result); 387 delete [] buf; 388 return result; 389} 390 391uint64_t 392writefile(ThreadContext *tc, Addr vaddr, uint64_t len, uint64_t offset, 393 Addr filename_addr) 394{ 395 ostream *os; 396 397 // copy out target filename 398 char fn[100]; 399 std::string filename; 400 CopyStringOut(tc, fn, filename_addr, 100); 401 filename = std::string(fn); 402 403 if (offset == 0) { 404 // create a new file (truncate) 405 os = simout.create(filename, true); 406 } else { 407 // do not truncate file if offset is non-zero 408 // (ios::in flag is required as well to keep the existing data 409 // intact, otherwise existing data will be zeroed out.) 410 os = simout.openFile(simout.directory() + filename, 411 ios::in | ios::out | ios::binary); 412 } 413 if (!os) 414 panic("could not open file %s\n", filename); 415 416 // seek to offset 417 os->seekp(offset); 418 419 // copy out data and write to file 420 char *buf = new char[len]; 421 CopyOut(tc, buf, vaddr, len); 422 os->write(buf, len); 423 if (os->fail() || os->bad()) 424 panic("Error while doing writefile!\n"); 425 426 simout.close(os); 427 428 delete [] buf; 429 430 return len; 431} 432 433void 434debugbreak(ThreadContext *tc) 435{ 436 Debug::breakpoint(); 437} 438 439void 440switchcpu(ThreadContext *tc) 441{ 442 exitSimLoop("switchcpu"); 443} 444 445// 446// This function is executed when annotated work items begin. Depending on 447// what the user specified at the command line, the simulation may exit and/or 448// take a checkpoint when a certain work item begins. 449// 450void 451workbegin(ThreadContext *tc, uint64_t workid, uint64_t threadid) 452{ 453 tc->getCpuPtr()->workItemBegin(); 454 System *sys = tc->getSystemPtr(); 455 const System::Params *params = sys->params(); 456 sys->workItemBegin(threadid, workid); 457 458 DPRINTF(WorkItems, "Work Begin workid: %d, threadid %d\n", workid, 459 threadid); 460 461 // 462 // If specified, determine if this is the specific work item the user 463 // identified 464 // 465 if (params->work_item_id == -1 || params->work_item_id == workid) { 466 467 uint64_t systemWorkBeginCount = sys->incWorkItemsBegin(); 468 int cpuId = tc->getCpuPtr()->cpuId(); 469 470 if (params->work_cpus_ckpt_count != 0 && 471 sys->markWorkItem(cpuId) >= params->work_cpus_ckpt_count) { 472 // 473 // If active cpus equals checkpoint count, create checkpoint 474 // 475 exitSimLoop("checkpoint"); 476 } 477 478 if (systemWorkBeginCount == params->work_begin_ckpt_count) { 479 // 480 // Note: the string specified as the cause of the exit event must 481 // exactly equal "checkpoint" inorder to create a checkpoint 482 // 483 exitSimLoop("checkpoint"); 484 } 485 486 if (systemWorkBeginCount == params->work_begin_exit_count) { 487 // 488 // If a certain number of work items started, exit simulation 489 // 490 exitSimLoop("work started count reach"); 491 } 492 493 if (cpuId == params->work_begin_cpu_id_exit) { 494 // 495 // If work started on the cpu id specified, exit simulation 496 // 497 exitSimLoop("work started on specific cpu"); 498 } 499 } 500} 501 502// 503// This function is executed when annotated work items end. Depending on 504// what the user specified at the command line, the simulation may exit and/or 505// take a checkpoint when a certain work item ends. 506// 507void 508workend(ThreadContext *tc, uint64_t workid, uint64_t threadid) 509{ 510 tc->getCpuPtr()->workItemEnd(); 511 System *sys = tc->getSystemPtr(); 512 const System::Params *params = sys->params(); 513 sys->workItemEnd(threadid, workid); 514 515 DPRINTF(WorkItems, "Work End workid: %d, threadid %d\n", workid, threadid); 516 517 // 518 // If specified, determine if this is the specific work item the user 519 // identified 520 // 521 if (params->work_item_id == -1 || params->work_item_id == workid) { 522 523 uint64_t systemWorkEndCount = sys->incWorkItemsEnd(); 524 int cpuId = tc->getCpuPtr()->cpuId(); 525 526 if (params->work_cpus_ckpt_count != 0 && 527 sys->markWorkItem(cpuId) >= params->work_cpus_ckpt_count) { 528 // 529 // If active cpus equals checkpoint count, create checkpoint 530 // 531 exitSimLoop("checkpoint"); 532 } 533 534 if (params->work_end_ckpt_count != 0 && 535 systemWorkEndCount == params->work_end_ckpt_count) { 536 // 537 // If total work items completed equals checkpoint count, create 538 // checkpoint 539 // 540 exitSimLoop("checkpoint"); 541 } 542 543 if (params->work_end_exit_count != 0 && 544 systemWorkEndCount == params->work_end_exit_count) { 545 // 546 // If total work items completed equals exit count, exit simulation 547 // 548 exitSimLoop("work items exit count reached"); 549 } 550 } 551} 552 553} // namespace PseudoInst 554