1/*
2 * Copyright (c) 2012 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

--- 339 unchanged lines hidden (view full) ---

348TrafficGen::StateGraph::BaseGen::BaseGen(QueuedMasterPort& _port,
349 MasterID master_id,
350 Tick _duration)
351 : port(_port), masterID(master_id), duration(_duration)
352{
353}
354
355void
356TrafficGen::StateGraph::LinearGen::enter()
357{
358 // reset the address and the data counter
359 nextAddr = startAddr;
360 dataManipulated = 0;
361
362 // this test only needs to happen once, but cannot be performed
363 // before init() is called and the ports are connected

--- 11 unchanged lines hidden (view full) ---

375 (readPercent == 100 || random_mt.random<uint8_t>(0, 100) < readPercent);
376
377 assert((readPercent == 0 && !isRead) || (readPercent == 100 && isRead) ||
378 readPercent != 100);
379
380 DPRINTF(TrafficGen, "LinearGen::execute: %c to addr %x, size %d\n",
381 isRead ? 'r' : 'w', nextAddr, blocksize);
382
383 // Create new request
384 Request::Flags flags;
385 Request *req = new Request(nextAddr, blocksize, flags, masterID);
386
387 PacketPtr pkt = new Packet(req, isRead ? MemCmd::ReadReq :
388 MemCmd::WriteReq);
389
390 uint8_t* pkt_data = new uint8_t[req->getSize()];
391 pkt->dataDynamicArray(pkt_data);
392
393 if (!isRead) {
394 memset(pkt_data, 0xA, req->getSize());
395 }
396
397 port.schedTimingReq(pkt, curTick());
398
399 // increment the address
400 nextAddr += blocksize;
401
402 // Add the amount of data manipulated to the total
403 dataManipulated += blocksize;
404}
405
406Tick

--- 47 unchanged lines hidden (view full) ---

454 Addr addr = random_mt.random<Addr>(startAddr, endAddr - 1);
455
456 // round down to start address of block
457 addr -= addr % blocksize;
458
459 DPRINTF(TrafficGen, "RandomGen::execute: %c to addr %x, size %d\n",
460 isRead ? 'r' : 'w', addr, blocksize);
461
462 // create new request packet
463 Request::Flags flags;
464 Request *req = new Request(addr, blocksize, flags, masterID);
465
466 PacketPtr pkt = new Packet(req, isRead ? MemCmd::ReadReq :
467 MemCmd::WriteReq);
468
469 uint8_t* pkt_data = new uint8_t[req->getSize()];
470 pkt->dataDynamicArray(pkt_data);
471
472 if (!isRead) {
473 memset(pkt_data, 0xA, req->getSize());
474 }
475
476 port.schedTimingReq(pkt, curTick());
477
478 // Add the amount of data manipulated to the total
479 dataManipulated += blocksize;
480}
481
482Tick
483TrafficGen::StateGraph::RandomGen::nextExecuteTick()
484{
485 // Check to see if we have reached the data limit. If dataLimit is

--- 105 unchanged lines hidden (view full) ---

591 assert(currElement.isValid());
592
593 DPRINTF(TrafficGen, "TraceGen::execute: %c %d %d %d\n",
594 currElement.cmd.isRead() ? 'r' : 'w',
595 currElement.addr,
596 currElement.blocksize,
597 currElement.tick);
598
599 Request::Flags flags;
600 Request *req = new Request(currElement.addr + addrOffset,
601 currElement.blocksize, flags, masterID);
602
603 PacketPtr pkt = new Packet(req, currElement.cmd);
604
605 uint8_t* pkt_data = new uint8_t[req->getSize()];
606 pkt->dataDynamicArray(pkt_data);
607
608 if (currElement.cmd.isWrite()) {
609 memset(pkt_data, 0xA, req->getSize());
610 }
611
612 port.schedTimingReq(pkt, curTick());
613}
614
615void
616TrafficGen::StateGraph::TraceGen::exit() {
617 // Check if we reached the end of the trace file. If we did not
618 // then we want to generate a warning stating that not the entire
619 // trace was played.
620 if (!traceComplete) {

--- 17 unchanged lines hidden ---