/** Event to halt the simulator if the kernel calls panic() */
BreakPCEvent *kernelPanicEvent;
+#if 0
/** Event to halt the simulator if the kernel calls die_if_kernel */
BreakPCEvent *kernelDieEvent;
+#endif
+
#endif
/**
4, vcvts2fpCode, fromInt = True)
vcvts2hCode = '''
+ destElem = 0;
FPSCR fpscr = (FPSCR) FpscrExc;
float srcFp1 = bitsToFp(srcElem1, (float)0.0);
if (flushToZero(srcFp1))
twoRegNarrowMiscInst("vcvt", "NVcvts2h", "SimdCvtOp", ("uint16_t",), vcvts2hCode)
vcvth2sCode = '''
+ destElem = 0;
FPSCR fpscr = (FPSCR) FpscrExc;
VfpSavedState state = prepFpState(VfpRoundNearest);
__asm__ __volatile__("" : "=m" (srcElem1), "=m" (destElem)
pendingStartup(false), startupVector(0),
startedUp(false), pendingUnmaskableInt(false),
pendingIPIs(0), cpu(NULL),
- intSlavePort(name() + ".int_slave", this, this, latency)
+ intSlavePort(name() + ".int_slave", this, this)
{
pioSize = PageBytes;
memset(regs, 0, sizeof(regs));
// Really only the LSB matters, but the decoder
// will sign extend it, and there's no easy way to
// specify only checking the first byte.
- -0x80: SyscallInst::int80('xc->syscall(Rax)',
- IsSyscall, IsNonSpeculative, IsSerializeAfter);
+ 0xffffffffffffff80:
+ SyscallInst::int80('xc->syscall(Rax)',
+ IsSyscall, IsNonSpeculative, IsSerializeAfter);
}
}
0x6: decode MODE_SUBMODE {
Counter max_track;
/** The number of entries in each bucket. */
Counter bucket_size;
- /** The number of buckets. Equal to (max-min)/bucket_size. */
- size_type buckets;
/** The smallest value sampled. */
Counter min_val;
* state is complete.
*/
bool traceComplete;
-
- /**
- * Used to store the Tick when the next generate should
- * occur. It is to remove a transaction as soon as we
- * enter the state.
- */
- Tick oldEmitTime;
};
/** Pointer to owner of request handler */
public:
TrafficGenPort(const std::string& name, TrafficGen& _owner)
- : QueuedMasterPort(name, &_owner, queue), queue(_owner, *this),
- owner(_owner)
+ : QueuedMasterPort(name, &_owner, queue), queue(_owner, *this)
{ }
protected:
MasterPacketQueue queue;
- // Owner of the port
- TrafficGen& owner;
-
};
TrafficGenPort port;
cxx_header = "dev/i8254xGBe.hh"
hardware_address = Param.EthernetAddr(NextEthernetAddr,
"Ethernet Hardware Address")
- use_flow_control = Param.Bool(False,
- "Should we use xon/xoff flow contorl (UNIMPLEMENTD)")
rx_fifo_size = Param.MemorySize('384kB', "Size of the rx FIFO")
tx_fifo_size = Param.MemorySize('384kB', "Size of the tx FIFO")
rx_desc_cache_size = Param.Int(64,
*/
class TsunamiIO : public BasicPioDevice
{
- private:
- struct tm tm;
protected:
IGbE::IGbE(const Params *p)
: EtherDevice(p), etherInt(NULL), drainManager(NULL),
- useFlowControl(p->use_flow_control),
rxFifo(p->rx_fifo_size), txFifo(p->tx_fifo_size), rxTick(false),
txTick(false), txFifoTick(false), rxDmaPacket(false), pktOffset(0),
fetchDelay(p->fetch_delay), wbDelay(p->wb_delay),
// The drain event if we have one
DrainManager *drainManager;
- // cached parameters from params struct
- bool useFlowControl;
-
// packet fifos
PacketFifo rxFifo;
PacketFifo txFifo;
class IntSlavePort : public MessageSlavePort
{
IntDev * device;
- Tick latency;
+
public:
IntSlavePort(const std::string& _name, MemObject* _parent,
- IntDev* dev, Tick _latency) :
- MessageSlavePort(_name, _parent), device(dev), latency(_latency)
+ IntDev* dev) :
+ MessageSlavePort(_name, _parent), device(dev)
{
}
{
public:
Consumer(ClockedObject *_em)
- : m_last_scheduled_wakeup(0), m_last_wakeup(0), em(_em)
+ : m_last_scheduled_wakeup(0), em(_em)
{
}
private:
Tick m_last_scheduled_wakeup;
std::set<Tick> m_scheduled_wakeups;
- Tick m_last_wakeup;
ClockedObject *em;
class ConsumerEvent : public Event
int m_filter_size;
int m_filter_size_bits;
- int m_count_bits;
- int m_count;
};
#endif // __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__
int m_sector_bits;
- int m_count_bits;
- int m_count;
};
#endif // __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__
int m_par_filter_size;
int m_par_filter_size_bits;
- int m_count_bits;
- int m_count;
-
int primes_list[6];// = {9323,11279,10247,30637,25717,43711};
int mults_list[6]; //= {255,29,51,3,77,43};
int adds_list[6]; //= {841,627,1555,241,7777,65391};
int m_par_filter_size;
int m_par_filter_size_bits;
- int m_count_bits;
- int m_count;
-
bool isParallel;
};
std::vector<int> m_page_filter;
int m_page_filter_size;
int m_page_filter_size_bits;
-
- int m_count_bits;
- int m_count;
};
#endif // __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__
int m_filter_size;
int m_offset;
int m_filter_size_bits;
-
- int m_count_bits;
- int m_count;
};
#endif // __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__
private:
std::vector<flit_d *> m_buffer;
- int size, max_size;
+ int max_size;
};
inline std::ostream&
private:
std::vector<flit *> m_buffer;
- int size, max_size;
+ int max_size;
};
inline std::ostream&
bool m_is_busy;
uint64_t m_data_block_mask;
DMARequest active_request;
- int num_active_requests;
};
#endif // __MEM_RUBY_SYSTEM_DMASEQUENCER_HH__
RubyPort::PioPort::PioPort(const std::string &_name,
RubyPort *_port)
- : QueuedMasterPort(_name, _port, queue), queue(*_port, *this),
- ruby_port(_port)
+ : QueuedMasterPort(_name, _port, queue), queue(*_port, *this)
{
DPRINTF(RubyPort, "creating master port on ruby sequencer %s\n", _name);
}
MasterPacketQueue queue;
- RubyPort *ruby_port;
-
public:
PioPort(const std::string &_name, RubyPort *_port);
projects / gem5.git / commitdiff