#include <Memory.hh>

Inheritance diagram for Memory:

Collaboration diagram for Memory:

Public Types
typedef MinimumAddressableUnit	MAU

typedef MAU *	MAUTable

Public Member Functions
	Memory (ULongWord start, ULongWord end, ULongWord MAUSize, bool littleEndian_)

virtual	~Memory ()

virtual void	advanceClock ()

virtual void	write (ULongWord address, MAU data)=0

virtual Memory::MAU	read (ULongWord address)=0

virtual void	writeBE (ULongWord address, int size, ULongWord data)

virtual void	writeLE (ULongWord address, int size, ULongWord data)

void	write (ULongWord address, int size, ULongWord data)

virtual void	writeDirectlyBE (ULongWord address, int size, ULongWord data)

virtual void	writeDirectlyLE (ULongWord address, int size, ULongWord data)

void	write (ULongWord address, FloatWord data)

void	write (ULongWord address, DoubleWord data)

void	read (ULongWord address, int size, ULongWord &data)

void	read (ULongWord address, DoubleWord &data)

void	read (ULongWord address, FloatWord &data)

virtual void	writeBE (ULongWord address, FloatWord data)

virtual void	writeBE (ULongWord address, DoubleWord data)

virtual void	writeLE (ULongWord address, FloatWord data)

virtual void	writeLE (ULongWord address, DoubleWord data)

virtual void	readBE (ULongWord address, int size, ULongWord &data)

virtual void	readLE (ULongWord address, int size, ULongWord &data)

virtual void	readBE (ULongWord address, FloatWord &data)

virtual void	readBE (ULongWord address, DoubleWord &data)

virtual void	readLE (ULongWord address, FloatWord &data)

virtual void	readLE (ULongWord address, DoubleWord &data)

virtual void	reset ()

virtual void	fillWithZeros ()

virtual ULongWord	start ()

virtual ULongWord	end ()

virtual ULongWord	MAUSize ()

bool	isLittleEndian ()

Protected Member Functions
void	packBE (const Memory::MAUTable data, int size, ULongWord &value)

void	unpackBE (const ULongWord &value, int size, Memory::MAUTable data)

void	packLE (const Memory::MAUTable data, int size, ULongWord &value)

void	unpackLE (const ULongWord &value, int size, Memory::MAUTable data)

Protected Attributes
bool	littleEndian_

Private Member Functions
	Memory (const Memory &)
	Copying not allowed.

Memory &	operator= (const Memory &)
	Assignment not allowed.

void	checkRange (ULongWord startAddress, int numberOfMAUs)

Private Attributes
ULongWord	start_
	Starting point of the address space.

ULongWord	end_
	End point of the address space.

ULongWord	MAUSize_
	Size of the minimum adressable unit.

RequestQueue *	writeRequests_
	The uncommited write requests.

int	mask_
	Mask bit pattern for unpacking IntULongWord to MAUs.

Detailed Description

Memory Model interface provides methods for emulating memory access.

The interface provides methods for emulating the access to data memory by operations of the target architecture such as load and store. In addition, an interface is implemented for direct access to the memory storage for the debugging user interfaces.

The abstract base class Memory implements all functionality except for the actual write() and read() methods which write and read a single unit to the memory storage as efficiently as possible. That is left for the derived classes to implement, as it depends on the storage data structure used, etc.

Memory base class implements the correct ordering of loads and stores within the same cycle: loads in the same cycle do not see the values of the writes in that cycle. That is, the writes are committed to the memory array at cycleAdvance() call. Derived classes may loosen this behavior and let the client take care of the correct ordering of the memory accesses, as is the case with the compiled simulation engine and the DirectAccessMemory implementation it uses for simulating data memory.

The Memory abstraction deals with MAUs (commonly bytes). The client can access the Memory for storing writing doubles and floats in case it implements floating point memory operations. Interface for those is out of the abstraction level of this interface.

Definition at line 74 of file Memory.hh.

Member Typedef Documentation

◆ MAU

typedef MinimumAddressableUnit Memory::MAU

Definition at line 76 of file Memory.hh.

◆ MAUTable

typedef MAU* Memory::MAUTable

Definition at line 77 of file Memory.hh.

Constructor & Destructor Documentation

◆ Memory() [1/2]

Memory::Memory	(	ULongWord	start,
		ULongWord	end,
		ULongWord	MAUSize,
		bool	littleEndian
	)

Initializes the memory model.

The created memory model is empty. No data is allocated for its contents.

Parameters

start	First address of the memory.
end	Last address of the memory.
MAUSize	Bit width of the minimum addressable unit of the memory.

Definition at line 56 of file Memory.cc.

                                                                                   :
    littleEndian_(littleEndian), 
    start_(start), end_(end), MAUSize_(MAUSize),
    writeRequests_(new RequestQueue()) {
 
    const std::size_t maxMAUSize =
        static_cast<int>(sizeof(MinimumAddressableUnit) * BYTE_BITWIDTH);
 
    if (MAUSize_ == maxMAUSize) {
        mask_ = ~0;
    } else if (MAUSize_ > maxMAUSize) {
        std::string msg = "Maximum supported MAU width is ";
        msg += Conversion::toString(maxMAUSize);
        msg += " bits.";
        throw OutOfRange(__FILE__, __LINE__, __func__, msg);
    } else {
        mask_ = ~0u << MAUSize_;
        mask_ = ~mask_;
    }
}

References __func__, BYTE_BITWIDTH, mask_, MAUSize_, and Conversion::toString().

Here is the call graph for this function:

◆ ~Memory()

Memory::~Memory ( )

virtual

Destructor.

Definition at line 80 of file Memory.cc.

                {
    delete writeRequests_;
    writeRequests_ = NULL;
}

References writeRequests_.

◆ Memory() [2/2]

Memory::Memory ( const Memory & )

private

Copying not allowed.

Member Function Documentation

◆ advanceClock()

void Memory::advanceClock ( )

virtual

Advances clock for one cycle.

Commits all pending write requests to the memory. Cannot throw an exception, request legality is checked when request is initiated.

Reimplemented in MemoryProxy, and DirectAccessMemory.

Definition at line 819 of file Memory.cc.

                     {
 
    RequestQueue::iterator iter = writeRequests_->begin();
    while (iter != writeRequests_->end()) {
        WriteRequest* req = (*iter);
        for (int i = 0; i < req->size_; ++i) {
            write(req->address_ + i, req->data_[i]);
        }
        delete[] (*iter)->data_;
        (*iter)->data_ = NULL;
        delete (*iter);
        ++iter;
    }
 
    writeRequests_->clear();
}

References WriteRequest::address_, WriteRequest::data_, WriteRequest::size_, write(), and writeRequests_.

Referenced by MemoryProxy::advanceClock(), CmdAdvanceClock::execute(), SimulateDialog::onAdvanceClock(), DirectAccessMemory::writeBE(), MemoryGridTable::writeValue(), and MemoryGridTable::writeValue().

Here is the call graph for this function:

◆ checkRange()

void Memory::checkRange	(	ULongWord	startAddress,
		int	numberOfMAUs
	)

private

Helper for checking the legality of the memory access address range.

Does nothing in case the address range is legal, throws otherwise.

Exceptions

OutOfRange in case the range is illegal.

Definition at line 844 of file Memory.cc.

                                                           {
 
    unsigned int low = start(); 
    unsigned int high = end(); 
 
    if ((startAddress < low) || (startAddress > high - numberOfMAUs + 1)) {
        throw OutOfRange(
            __FILE__, __LINE__, __func__,
            (boost::format(
                "Memory access at %d of size %d is out of the address space.")
             % startAddress % numberOfMAUs).str());
    }
}

References __func__, end(), and start().

Referenced by readBE(), readBE(), readLE(), readLE(), writeBE(), writeBE(), writeBE(), writeDirectlyBE(), writeDirectlyLE(), writeLE(), writeLE(), and writeLE().

Here is the call graph for this function:

◆ end()

virtual ULongWord Memory::end ( )

inlinevirtual

Definition at line 117 of file Memory.hh.

117{ return end_; }

References end_.

Referenced by checkRange(), MemoryGridTable::MemoryGridTable(), and MemoryControl::setMemory().

◆ fillWithZeros()

void Memory::fillWithZeros ( )

virtual

Fills the whole memory with zeros.

This is needed due to some buggy simulated programs which expect uninitialized data to be zero. The default implementation is a slow for-loop which can be overridden with a faster one depending on the storage used.

Reimplemented in MemoryProxy, DirectAccessMemory, and IdealSRAM.

Definition at line 704 of file Memory.cc.

                      {
    for (std::size_t addr = start_; addr <= end_; ++addr) {
        write(addr, MAU(0));
    }
}

References end_, start_, and write().

Referenced by MemoryProxy::fillWithZeros().

Here is the call graph for this function:

◆ isLittleEndian()

bool Memory::isLittleEndian ( )

inline

Definition at line 120 of file Memory.hh.

120{ return littleEndian_; }

References littleEndian_.

◆ MAUSize()

virtual ULongWord Memory::MAUSize ( )

inlinevirtual

Definition at line 118 of file Memory.hh.

118{ return MAUSize_; }

References MAUSize_.

Referenced by MemoryGridTable::MemoryGridTable(), readBE(), readBE(), readLE(), readLE(), MemoryControl::setMemory(), writeBE(), writeBE(), writeLE(), and writeLE().

◆ operator=()

Memory & Memory::operator= ( const Memory & )

private

Assignment not allowed.

◆ packBE()

void Memory::packBE	(	const Memory::MAUTable	data,
		int	size,
		ULongWord &	value
	)

protected

Packs MAUs to UIntWord.

Version for static table.

Parameters

data	Data to be packed.
size	The number of MAUs.
value	The target of the packing.

Definition at line 737 of file Memory.cc.

                                                                    {
 
    value = 0;
    int shiftCount = MAUSize_ * (size - 1);
    for (int i = 0; i < size; i++) {
        value = value | (data[i] << shiftCount);
        shiftCount -= MAUSize_;
    }
}

References MAUSize_.

◆ packLE()

void Memory::packLE	(	const Memory::MAUTable	data,
		int	size,
		ULongWord &	value
	)

protected

Packs MAUs to UIntWord.

Version for static table.

Parameters

data	Data to be packed.
size	The number of MAUs.
value	The target of the packing.

Definition at line 757 of file Memory.cc.

                                                                    {
 
    value = 0;
    int shiftCount = 0;
    for (int i = 0; i < size; i++) {
        value = value | (data[i] << shiftCount);
        shiftCount += MAUSize_;
    }
}

References MAUSize_.

◆ read() [1/4]

Memory::MAU Memory::read ( ULongWord address )

pure virtual

Reads a single memory location.

Must be implemented in the derived class. No range checking. The fastest way to read the memory.

Parameters

address The address to read.

Returns: The data read.

Implemented in MemoryProxy, DirectAccessMemory, IdealSRAM, RemoteMemory, DirectAccessMemory, and IdealSRAM.

Definition at line 160 of file Memory.cc.

                        {
    return 0;
}

Referenced by CmdMem::execute(), MemoryGridTable::memoryContents(), MemoryProxy::read(), readBE(), readLE(), and write().

◆ read() [2/4]

void Memory::read	(	ULongWord	address,
		DoubleWord &	data
	)

A convenience method for reading data from the memory and interpreting it as a DoubleWord in order set by endian bit of memory.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 513 of file Memory.cc.

                                                {
    if (littleEndian_) {
        readLE(address, data);
    } else {
        readBE(address, data);
    }
}

References littleEndian_, readBE(), and readLE().

Here is the call graph for this function:

◆ read() [3/4]

void Memory::read	(	ULongWord	address,
		FloatWord &	data
	)

A convenience method for reading data from the memory and interpreting it as a FloatWord in order set by the memory.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 329 of file Memory.cc.

                                               {
    if (littleEndian_) {
        readLE(address, data);
    } else {
        readBE(address, data);
    }
}

References littleEndian_, readBE(), and readLE().

Here is the call graph for this function:

◆ read() [4/4]

void Memory::read	(	ULongWord	address,
		int	size,
		ULongWord &	data
	)

A convenience method for reading units of data from the memory.

The data is written to an UIntWord.

Parameters

address	The address to read.
count	Number of MAUs to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 663 of file Memory.cc.

                                                         {
    if (littleEndian_) {
        readLE(address, size, data);
    } else {
        readBE(address, size, data);
    }
}

References littleEndian_, readBE(), and readLE().

Here is the call graph for this function:

◆ readBE() [1/3]

void Memory::readBE	(	ULongWord	address,
		DoubleWord &	data
	)

virtual

A convenience method for reading data from the memory and interpreting it as a DoubleWord in Big Endian.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 439 of file Memory.cc.

                                                  {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "LDD works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 8;
    union castUnion {
        DoubleWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        ULongWord data;
        readBE(address + i, 1, data);
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 1
        cast.maus[i] = data;
        #else
        cast.maus[MAUS - 1 - i] = data;
        #endif        
    }
    data = cast.d;
}

References assert, MAUSize(), and readBE().

Here is the call graph for this function:

◆ readBE() [2/3]

void Memory::readBE	(	ULongWord	address,
		FloatWord &	data
	)

virtual

A convenience method for reading data from the memory and interpreting it as a FloatWord in Big Endian Format

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 247 of file Memory.cc.

                                                 {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "Loading FloatWords works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 4;
 
    checkRange(address, MAUS);
 
    union castUnion {
        FloatWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        ULongWord data;
        // one byte so endian does not matter
        readBE(address + i, 1, data);
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 1
        cast.maus[i] = data;
        #else
        cast.maus[MAUS - 1 - i] = data;
        #endif        
    }
    data = cast.d;
}

References assert, checkRange(), MAUSize(), and readBE().

Here is the call graph for this function:

◆ readBE() [3/3]

void Memory::readBE	(	ULongWord	address,
		int	size,
		ULongWord &	data
	)

virtual

A convenience method for reading units of data from the memory in Big Endian

The data is written to an UIntWord.

Parameters

address	The address to read.
count	Number of MAUs to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 640 of file Memory.cc.

                                                           {
 
    checkRange(address, size);
 
    data = 0;
    int shiftCount = MAUSize_ * (size - 1);
    for (int i = 0; i < size; i++) {
        data = data | (read(address + i) << shiftCount);
        shiftCount -= MAUSize_;
    }
}

References checkRange(), MAUSize_, and read().

Referenced by CmdMem::execute(), read(), read(), read(), readBE(), and readBE().

Here is the call graph for this function:

◆ readLE() [1/3]

void Memory::readLE	(	ULongWord	address,
		DoubleWord &	data
	)

virtual

A convenience method for reading data from the memory and interpreting it as a DoubleWord in Little Endian.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 476 of file Memory.cc.

                                                  {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "LDD works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 8;
    union castUnion {
        DoubleWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        ULongWord data;
        readLE(address + i, 1, data);
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 0
        cast.maus[i] = data;
        #else
        cast.maus[MAUS - 1 - i] = data;
        #endif        
    }
    data = cast.d;
}

References assert, MAUSize(), and readLE().

Here is the call graph for this function:

◆ readLE() [2/3]

void Memory::readLE	(	ULongWord	address,
		FloatWord &	data
	)

virtual

A convenience method for reading data from the memory and interpreting it as a FloatWord in Little Endian Format

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 288 of file Memory.cc.

                                                 {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "Loading FloatWords works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 4;
 
    checkRange(address, MAUS);
 
    union castUnion {
        FloatWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        ULongWord data;
        // one bytes so endian does not matter
        readLE(address + i, 1, data);
        // Byte order must be reversed if host is not little endian.
        #if WORDS_BIGENDIAN == 0
        cast.maus[i] = data;
        #else
        cast.maus[MAUS - 1 - i] = data;
        #endif        
    }
    data = cast.d;
}

References assert, checkRange(), MAUSize(), and readLE().

Here is the call graph for this function:

◆ readLE() [3/3]

void Memory::readLE	(	ULongWord	address,
		int	size,
		ULongWord &	data
	)

virtual

A convenience method for reading units of data from the memory in Little Endian

The data is written to an UIntWord.

Parameters

address	The address to read.
count	Number of MAUs to read.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 682 of file Memory.cc.

                                                           {
 
    checkRange(address, size);
 
    data = 0;
    long shiftCount = 0;
    for (int i = 0; i < size; i++) {
        ULongWord readByte = read(address+i);
        data = data | (readByte << shiftCount);
        shiftCount += MAUSize_;
    }
}

References checkRange(), MAUSize_, and read().

Referenced by read(), read(), read(), readLE(), and readLE().

Here is the call graph for this function:

◆ reset()

void Memory::reset ( )

virtual

Resets the memory.

Clears any pending write requests.

Reimplemented in MemoryProxy, and DirectAccessMemory.

Definition at line 716 of file Memory.cc.

              {
    RequestQueue::iterator iter = writeRequests_->begin();
    while (iter != writeRequests_->end()) {
        delete[] (*iter)->data_;
        (*iter)->data_ = NULL;
        delete (*iter);
        ++iter;
    }
    writeRequests_->clear();
}

References writeRequests_.

Referenced by MemoryProxy::reset().

◆ start()

virtual ULongWord Memory::start ( )

inlinevirtual

Definition at line 116 of file Memory.hh.

116{ return start_; }

References start_.

Referenced by checkRange(), MemoryGridTable::MemoryGridTable(), and MemoryControl::setMemory().

◆ unpackBE()

void Memory::unpackBE	(	const ULongWord &	value,
		int	size,
		Memory::MAUTable	data
	)

protected

Unpack a given UIntWord to MAUs.

Version for static table. Table is expected to be correct size, no checking is done!

Parameters

value	Value to be unpacked.
size	The number of MAUs.
data	The target of unpacking.

Definition at line 778 of file Memory.cc.

                         {
    int shiftCount = MAUSize_ * (size - 1);
    for(int i = 0; i < size; ++i) {
        data[i] = ((value >> shiftCount) & mask_);
        shiftCount -= MAUSize_;
    }
}

References mask_, and MAUSize_.

Referenced by writeBE(), and writeDirectlyBE().

◆ unpackLE()

void Memory::unpackLE	(	const ULongWord &	value,
		int	size,
		Memory::MAUTable	data
	)

protected

Unpack a given UIntWord to MAUs.

Version for static table. Table is expected to be correct size, no checking is done!

Parameters

value	Value to be unpacked.
size	The number of MAUs.
data	The target of unpacking.

Definition at line 800 of file Memory.cc.

                         {
    int shiftCount = 0;
    for(int i = 0; i < size; ++i) {
        data[i] = ((value >> shiftCount) & mask_);
        shiftCount += MAUSize_;
    }
}

References mask_, and MAUSize_.

Referenced by writeDirectlyLE(), and writeLE().

◆ write() [1/4]

void Memory::write	(	ULongWord	address,
		DoubleWord	data
	)

A convenience method for writing a DoubleWord to the memory.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 531 of file Memory.cc.

                                                {
    if (littleEndian_) {
        writeLE(address, data);
    } else {
        writeBE(address, data);
    }
}

References littleEndian_, writeBE(), and writeLE().

Here is the call graph for this function:

◆ write() [2/4]

void Memory::write	(	ULongWord	address,
		FloatWord	data
	)

References read(), and write().

Here is the call graph for this function:

◆ write() [3/4]

void Memory::write	(	ULongWord	address,
		int	count,
		ULongWord	data
	)

A convenience method for writing units of data to the memory.

The data is stored in an UIntWord.

Parameters

address	The address to write.
count	Number of MAUs to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 175 of file Memory.cc.

                                                          {
    if (littleEndian_) {
        writeLE(address, count, data);
    } else {
        writeBE(address, count, data);
    }
}

References littleEndian_, writeBE(), and writeLE().

Here is the call graph for this function:

◆ write() [4/4]

void Memory::write	(	ULongWord	address,
		MAU	data
	)

pure virtual

Writes a single memory location.

Must be implemented in the derived class. No range checking. The fastest way to write to the memory.

Parameters

address	The target address.
data	The data to write.

Implemented in MemoryProxy, IdealSRAM, RemoteMemory, DirectAccessMemory, IdealSRAM, and DirectAccessMemory.

Definition at line 95 of file Memory.cc.

                            {
    abortWithError("Must be implemented in the derived class.");
}

Referenced by advanceClock(), fillWithZeros(), MemoryProxy::read(), write(), MemoryProxy::write(), MemoryProxy::write(), writeDirectlyBE(), writeDirectlyLE(), MemoryGridTable::writeValue(), and MemoryGridTable::writeValue().

◆ writeBE() [1/3]

void Memory::writeBE	(	ULongWord	address,
		DoubleWord	data
	)

virtual

A convenience method for writing a DoubleWord to the memory in Big Endian.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 549 of file Memory.cc.

                                                  {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "LDD works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 8;
 
    checkRange(address, MAUS);
 
    union castUnion {
        DoubleWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
    cast.d = data;
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[MAUS];
    request->size_ = MAUS;
    request->address_ = address;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        UIntWord data;
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 1
        data = cast.maus[i];
        #else
        data = cast.maus[MAUS - 1 - i];
        #endif
        request->data_[i] = data;
    }
    writeRequests_->push_back(request);
}

References WriteRequest::address_, assert, checkRange(), WriteRequest::data_, MAUSize(), WriteRequest::size_, and writeRequests_.

Here is the call graph for this function:

◆ writeBE() [2/3]

void Memory::writeBE	(	ULongWord	address,
		FloatWord	data
	)

virtual

A convenience method for writing a FloatWord to the memory in Big Endian.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 347 of file Memory.cc.

                                                 {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "Writing FloatWords works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 4;
 
    checkRange(address, MAUS);
 
    union castUnion {
        FloatWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
    cast.d = data;
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[MAUS];
    request->size_ = MAUS;
    request->address_ = address;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        UIntWord data;
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 1
        data = cast.maus[i];
        #else
        data = cast.maus[MAUS - 1 - i];
        #endif
        request->data_[i] = data;
    }
    writeRequests_->push_back(request);
}

References WriteRequest::address_, assert, checkRange(), WriteRequest::data_, MAUSize(), WriteRequest::size_, and writeRequests_.

Here is the call graph for this function:

◆ writeBE() [3/3]

void Memory::writeBE	(	ULongWord	address,
		int	count,
		ULongWord	data
	)

virtual

A convenience method for writing units of data to the memory.

The data is stored in an UIntWord.

Parameters

address	The address to write.
count	Number of MAUs to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Reimplemented in DirectAccessMemory.

Definition at line 194 of file Memory.cc.

                                                            {
 
    checkRange(address, count);
 
    Memory::MAU MAUData[MAX_ACCESS_SIZE];
    unpackBE(data, count, MAUData);
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[count];
    std::memcpy(request->data_, MAUData, count*sizeof(MAU));
    request->size_ = count;
    request->address_ = address;
    writeRequests_->push_back(request);
}

References WriteRequest::address_, checkRange(), WriteRequest::data_, MAX_ACCESS_SIZE, WriteRequest::size_, unpackBE(), and writeRequests_.

Referenced by write(), write(), and DirectAccessMemory::writeBE().

Here is the call graph for this function:

◆ writeDirectlyBE()

void Memory::writeDirectlyBE	(	ULongWord	address,
		int	count,
		ULongWord	data
	)

virtual

Writes a single memory location directly without waiting to the end of the clock.

This is used in case it's important for potential other memory operations in the same cycle to see the write. This is used (at the moment solely) to simulate Compare-and-swap (CAS).

Parameters

address	The target address.
count	Number of MAUs to write.
data	The data to write.

Definition at line 112 of file Memory.cc.

                                                                    {
 
    checkRange(address, count);
 
    Memory::MAU MAUData[MAX_ACCESS_SIZE];
    unpackBE(data, count, MAUData);
 
    for (int i = 0; i < count; ++i) {
        write(address + i, MAUData[i]);
    }
}

References checkRange(), MAX_ACCESS_SIZE, unpackBE(), and write().

Here is the call graph for this function:

◆ writeDirectlyLE()

void Memory::writeDirectlyLE	(	ULongWord	address,
		int	count,
		ULongWord	data
	)

virtual

Writes a single memory location directly without waiting to the end of the clock.

This is used in case it's important for potential other memory operations in the same cycle to see the write. This is used (at the moment solely) to simulate Compare-and-swap (CAS).

Parameters

address	The target address.
count	Number of MAUs to write.
data	The data to write.

Definition at line 137 of file Memory.cc.

                                                                    {
 
    checkRange(address, count);
 
    Memory::MAU MAUData[MAX_ACCESS_SIZE];
    unpackLE(data, count, MAUData);
 
    for (int i = 0; i < count; ++i) {
        write(address + i, MAUData[i]);
    }
}

References checkRange(), MAX_ACCESS_SIZE, unpackLE(), and write().

Here is the call graph for this function:

◆ writeLE() [1/3]

void Memory::writeLE	(	ULongWord	address,
		DoubleWord	data
	)

virtual

A convenience method for writing a DoubleWord to the memory in Litle Endian

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 594 of file Memory.cc.

                                                  {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "LDD works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 8;
 
    checkRange(address, MAUS);
 
    union castUnion {
        DoubleWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
    cast.d = data;
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[MAUS];
    request->size_ = MAUS;
    request->address_ = address;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        UIntWord data;
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 0
        data = cast.maus[i];
        #else
        data = cast.maus[MAUS - 1 - i];
        #endif
        request->data_[i] = data;
    }
    writeRequests_->push_back(request);
}

References WriteRequest::address_, assert, checkRange(), WriteRequest::data_, MAUSize(), WriteRequest::size_, and writeRequests_.

Here is the call graph for this function:

◆ writeLE() [2/3]

void Memory::writeLE	(	ULongWord	address,
		FloatWord	data
	)

virtual

A convenience method for writing a FloatWord to the memory in Little Endian.

Note: Currently works only if MAU == 8 bits. asserts otherwise.

Parameters

address	The address to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 392 of file Memory.cc.

                                                 {
 
    assert(MAUSize() == sizeof(Byte)*8 && 
           "Writing FloatWords works only with byte sized MAU at the moment.");
 
    const std::size_t MAUS = 4;
 
    checkRange(address, MAUS);
 
    union castUnion {
        FloatWord d;
        Byte maus[MAUS];
    };
 
    castUnion cast;
    cast.d = data;
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[MAUS];
    request->size_ = MAUS;
    request->address_ = address;
 
    for (std::size_t i = 0; i < MAUS; ++i) {
        UIntWord data;
        // Byte order must be reversed if host is not bigendian.
        #if WORDS_BIGENDIAN == 0
        data = cast.maus[i];
        #else
        data = cast.maus[MAUS - 1 - i];
        #endif
        request->data_[i] = data;
    }
    writeRequests_->push_back(request);
}

References WriteRequest::address_, assert, checkRange(), WriteRequest::data_, MAUSize(), WriteRequest::size_, and writeRequests_.

Here is the call graph for this function:

◆ writeLE() [3/3]

void Memory::writeLE	(	ULongWord	address,
		int	count,
		ULongWord	data
	)

virtual

A convenience method for writing units of data to the memory.

The data is stored in an UIntWord.

Parameters

address	The address to write.
count	Number of MAUs to write.
data	The data to write.

Exceptions

OutOfRange in case the address is out of range of the memory.

Definition at line 221 of file Memory.cc.

                                                            {
 
    checkRange(address, count);
 
    Memory::MAU MAUData[MAX_ACCESS_SIZE];
    unpackLE(data, count, MAUData);
 
    WriteRequest* request = new WriteRequest();
    request->data_ = new MAU[count];
    std::memcpy(request->data_, MAUData, count*sizeof(MAU));
    request->size_ = count;
    request->address_ = address;
    writeRequests_->push_back(request);
}

References WriteRequest::address_, checkRange(), WriteRequest::data_, MAX_ACCESS_SIZE, WriteRequest::size_, unpackLE(), and writeRequests_.

Referenced by write(), and write().

Here is the call graph for this function:

Member Data Documentation

◆ end_

ULongWord Memory::end_

private

End point of the address space.

Definition at line 140 of file Memory.hh.

Referenced by end(), and fillWithZeros().

◆ littleEndian_

bool Memory::littleEndian_

protected

Definition at line 128 of file Memory.hh.

Referenced by isLittleEndian(), read(), read(), read(), write(), and write().

◆ mask_

int Memory::mask_

private

Mask bit pattern for unpacking IntULongWord to MAUs.

Definition at line 147 of file Memory.hh.

Referenced by Memory(), unpackBE(), and unpackLE().

◆ MAUSize_

ULongWord Memory::MAUSize_

private

Size of the minimum adressable unit.

Definition at line 142 of file Memory.hh.

Referenced by MAUSize(), Memory(), packBE(), packLE(), readBE(), readLE(), unpackBE(), and unpackLE().

◆ start_

ULongWord Memory::start_

private

Starting point of the address space.

Definition at line 138 of file Memory.hh.

Referenced by fillWithZeros(), and start().

◆ writeRequests_

RequestQueue* Memory::writeRequests_

private

The uncommited write requests.

Definition at line 145 of file Memory.hh.

Referenced by advanceClock(), reset(), writeBE(), writeBE(), writeBE(), writeLE(), writeLE(), writeLE(), and ~Memory().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MAU

◆ MAUTable

Constructor & Destructor Documentation

◆ Memory() [1/2]

◆ ~Memory()

◆ Memory() [2/2]

Member Function Documentation

◆ advanceClock()

◆ checkRange()

◆ end()

◆ fillWithZeros()

◆ isLittleEndian()

◆ MAUSize()

◆ operator=()

◆ packBE()

◆ packLE()

◆ read() [1/4]

◆ read() [2/4]

◆ read() [3/4]

◆ read() [4/4]

◆ readBE() [1/3]

◆ readBE() [2/3]

◆ readBE() [3/3]

◆ readLE() [1/3]

◆ readLE() [2/3]

◆ readLE() [3/3]

◆ reset()

◆ start()

◆ unpackBE()

◆ unpackLE()

◆ write() [1/4]

◆ write() [2/4]

◆ write() [3/4]

◆ write() [4/4]

◆ writeBE() [1/3]

◆ writeBE() [2/3]

◆ writeBE() [3/3]

◆ writeDirectlyBE()

◆ writeDirectlyLE()

◆ writeLE() [1/3]

◆ writeLE() [2/3]

◆ writeLE() [3/3]

Member Data Documentation

◆ end_

◆ littleEndian_

◆ mask_

◆ MAUSize_

◆ start_

◆ writeRequests_