orcasim::modeling::Memory Class Reference

This class models a memory module. More...

#include <Memory.hpp>

Inheritance diagram for orcasim::modeling::Memory:

Public Member Functions
	Memory (std::string name, uint32_t size, uint32_t base=0, bool wipe=false, std::string binname="")
	Construct a new Memory object. More...
	~Memory ()
	Destroy the Memory object. More...
void	Write (uint32_t addr, MemoryType *data, uint32_t length)
	Writes data to the memory. More...
void	Read (uint32_t addr, MemoryType *buffer, uint32_t length)
	Reads data from a given memory location. More...
void	LoadBin (std::string filename, MemoryAddr base, uint32_t size)
	Loads the content of a given file to the memory. More...
void	SaveBin (std::string filename, MemoryAddr base, uint32_t size)
	Write the contents of memory cells into a binary file. More...
void	Wipe ()
	Write zeroes to the whole addressable memory space. More...
void	Wipe (MemoryAddr base, uint32_t length)
	Write zeroes to a region of the memory. More...
void	Dump (uint32_t base, uint32_t length)
	Display the contents of the memory on the output. More...
void	Dump ()
	Display the contents of the whole memory on the output. More...
MemoryType &	operator[] (MemoryAddr addr)
	Shorthand access for the Read method using operator overloading on '[]' operator. More...
MemoryAddr	GetBase ()
	(getter) Gets the base address, which is the first addressable memory cell in the module. More...
MemoryAddr	GetSize ()
	(getter) Gets the size (alternatively, length) of the memory module, representing the number of addressable cells. More...
MemoryAddr	GetLastAddr ()
	Get the address of the last addressable memory cell. More...
MemoryType *	GetMap (MemoryAddr addr)
	Gets a pointer of MemoryType type that points to the cell in address <addr>. More...
a name that identifies the model, advisably not empty.
Default ctor.
std::string	GetName ()
	Getter method for the <_name> field. More...
void	SetName (std::string s)
	Setter method for the <_name> field. More...

Private Attributes
MemoryType *	_mem
	The _mem attribute is an array of MemoryType elements, where MemoryType is the smalled memory unit that can be read or writen to the memory. More...
MemoryAddr	_length
	The _length attribute denotes the number of cells of the memory module. More...
MemoryAddr	_base
	The _base attribute indicates the first address of the memory module, an offset. More...

Detailed Description

This class models a memory module.

The module has no clock as it is an UntimedModel *

Definition at line 55 of file Memory.hpp.

Constructor & Destructor Documentation

Memory()

Memory::Memory	(	std::string	name,
		uint32_t	size,
		uint32_t	base = 0,
		bool	wipe = false,
		std::string	binname = ""
	)

Construct a new Memory object.

Parameters

name	A string name to identify the object. There is no restriction on object names.
size	The number of cells to be emulated. The size of cell is defined by the MemoryType type.
base	(optional) The base address for the emulated memory space. Default value is zero.
wipe	(optional) If set to true, erase memory cells after class instantiation, writing zero to each cell. Default behavior
binname	(optional)

Definition at line 36 of file Memory.cpp.

                                  : UntimedModel(name) {
    // creates a new array of MemoryType elements (must be disposed by dctor.)
    _mem = new MemoryType[size];

    // set internal fields
    _length = size;
    _base = sram_base;

    // if wipe is true, write zeroes to the whole addressable space
    if (wipe) this->Wipe();

    // if a binary file is provided, load that file into the base address
    if (binname != "")
        this->LoadBin(binname, _base, _length);

    #ifdef MEMORY_ENABLE_COUNTERS
    // if counters are enabled, initiate the respective signals
    // please note that these signals are not mapped to anywhere yet
    _counter_nstore = new Signal<uint32_t>(GetName() + ".counters.store");
    _counter_nload = new Signal<uint32_t>(GetName() + ".counters.load");

    // reset counters (must!)
    _counter_nstore->Write(0);
    _counter_nload->Write(0);
    #endif
}

~Memory()

Memory::~Memory

(

)

Destroy the Memory object.

Definition at line 289 of file Memory.cpp.

                {
    // delete all cells
    delete [] _mem;

    #ifdef MEMORY_ENABLE_COUNTERS
    // delete signals that hold counters
    delete(_counter_nstore);
    delete(_counter_nload);
    #endif
}

Member Function Documentation

Dump() [1/2]

void Memory::Dump	(	uint32_t	base,
		uint32_t	length
	)

Display the contents of the memory on the output.

Data will be displayed as hexadecimal values.

Parameters

base	The first address to display
length	The number of cells to display

Definition at line 259 of file Memory.cpp.

                                                {
    uint32_t k, l;

    // mask is necessary to correct a bug(?) when printing
    // negative hexas.
    uint32_t mask = 0x000000FF;
    int8_t ch;

    // print in lines containing 16 bytes
    for (k = 0; k < length; k += 16) {
        // print the address
        printf("\n%08x ", base + k);
        for (l = 0; l < 16; l++) {
            printf("%02x ", _mem[k + l + (base - _base)] & mask);
            if (l == 7) putchar(' ');
        }

        // print the data in ascii ("." is printed when no ascii char exists)
        printf(" |");
        for (l = 0; l < 16; l++) {
            ch = _mem[k + l + (base - _base)];
            if ((ch >= 32) && (ch <= 126))
                putchar(ch);
            else
                putchar('.');
        }
        putchar('|');
    }
}

Dump() [2/2]

void Memory::Dump

(

)

Display the contents of the whole memory on the output.

Definition at line 255 of file Memory.cpp.

                  {
    this->Dump(0, _length);
}

GetBase()

MemoryAddr Memory::GetBase

(

)

(getter) Gets the base address, which is the first addressable memory cell in the module.

Returns

MemoryAddr The address of the first memory cell.

Definition at line 173 of file Memory.cpp.

                           {
    return _base;
}

GetLastAddr()

MemoryAddr Memory::GetLastAddr

(

)

Get the address of the last addressable memory cell.

The address is given by (base + length - 1).

Returns

MemoryAddr The address of the last cell.

Definition at line 183 of file Memory.cpp.

                               {
    return (_base + _length) - 1;
}

GetMap()

MemoryType * Memory::GetMap

(

MemoryAddr

addr

)

Gets a pointer of MemoryType type that points to the cell in address <addr>.

Although the pointer points to a single cell, neighbor cells can be accessed by incrementing on the pointer. Please note that this method bypassed the encapsuling methods Write and Read, and its use should be avoided for data manipulation purpose.

Parameters

addr	The addres to which the pointer must point to.

Returns

MemoryType* A pointer to the given address.

Definition at line 144 of file Memory.cpp.

                                          {
    #ifdef MEMORY_MAP_ADDRESS_CHECKING
    // check whether we're trying to get the pointer
    // to a cell whose address is lower than the base
    // address
    if (addr < _sram_base) {
        stringstream s;
        s << this->GetName() << ": unable to map from to addr (0x" << std::hex
            << addr << ") lower than sram base.";
        throw std::runtime_error(s.str());
    }

    // check whether we're trying to get the pointer
    // to a cell whose address is higher than the last
    // address
    if (addr > GetLastAddr()) {
        stringstream s;
        s << this->GetName() << ": unable to map from to addr (0x" << std::hex
            << addr << ") higher than last mapped address of (0x" << std::hex
            << GetLastAddr() << ").";
        throw std::runtime_error(s.str());
    }
    #endif

    // return the address to the requested cell
    return &(_mem[addr - _base]);
}

GetName()

std::string Model::GetName ( )

inherited

Getter method for the <_name> field.

Definition at line 34 of file Model.cpp.

                         {
    return _name;
}

GetSize()

uint32_t Memory::GetSize

(

)

(getter) Gets the size (alternatively, length) of the memory module, representing the number of addressable cells.

Returns

MemoryAddr The number of addressable cells.

Definition at line 178 of file Memory.cpp.

                         {
    return _length;
}

LoadBin()

void Memory::LoadBin	(	std::string	filename,
		MemoryAddr	base,
		uint32_t	size
	)

Loads the content of a given file to the memory.

File contents are treated as binaray data.

Parameters

filename	Name of the file to be read.
location	Location of the memory area in which the contents of the loaded file will be put.

Definition at line 222 of file Memory.cpp.

                                                                     {
    // try to open the file
    std::ifstream f(filename, std::ios::binary | std::ios::in | std::ios::out);

    // if we could open the file properly, load it at the base address
    if (f.is_open()) {
        f.read(reinterpret_cast<char*>(&_mem[base -_base]),
            sizeof(_mem[0]) * size);
        f.close();

    // if could not open the file, throw exception
    } else {
        std::string err_msg = this->GetName() + ": unable to load '"
            + filename + "'.";
        throw std::runtime_error(err_msg);
    }
}

operator[]()

MemoryType& orcasim::modeling::Memory::operator[] ( MemoryAddr  addr )

inline

Shorthand access for the Read method using operator overloading on '[]' operator.

On contrary of Read method, this operator is capable of returning only a single memory cell value. Please note that its counter for writing is not implemented.

Parameters

addr	The address of the cell to read from

Returns

MemoryType The value stored in the request cell

Definition at line 192 of file Memory.hpp.

                                            {
        return _mem[_base + addr];
    }

Read()

void Memory::Read	(	uint32_t	addr,
		MemoryType *	buffer,
		uint32_t	length
	)

Reads data from a given memory location.

Parameters

addr	Location to read from.
buffer	Buffer to where the read data will be copied.
length	Length of the data that will be copyied from memory to the buffer.

Definition at line 111 of file Memory.cpp.

                                                                      {
    #ifdef MEMORY_READ_ADDRESS_CHECKING
    // check whether we'are trying to read from an address
    // lower than the base address
    if (addr < _sram_base) {
        stringstream s;
        s << this->GetName() << ": unable to read from addr (0x" << std::hex
            << addr << ") lower than sram base.";
        throw std::runtime_error(s.str());
    }

    // check whether we're trying to read from an address
    // higher than the last address
    if ((addr + length) - 1 > GetLastAddr()) {
        stringstream s;
        s << this->GetName() << ": unable to read from addr (0x" << std::hex
            << addr << ") higher than last mapped address of (0x" << std::hex
            << GetLastAddr() << ").";
        throw std::runtime_error(s.str());
    }
    #endif

    // read data from memory
    // @TODO(ad): check whether this has the best performance
    for (uint32_t i = 0; i < length; i++)
        buffer[i] = _mem[(addr - _base) + i];

    #ifdef MEMORY_ENABLE_COUNTERS
    // increment number of loades into nstore counter
    _counter_nload->Inc(1);
    #endif
}

SaveBin()

void Memory::SaveBin	(	std::string	filename,
		MemoryAddr	base,
		uint32_t	size
	)

Write the contents of memory cells into a binary file.

Parameters

filename	file name, overwrites file is it exists already
size	number of memory cells to save
addr	address of the first cell to save

Definition at line 240 of file Memory.cpp.

                                                                     {
    std::ofstream f(filename, std::ifstream::binary);

    if (f.is_open()) {
        f.write(reinterpret_cast<char*>(&_mem[base -_base]),
            sizeof(_mem[0]) * size);
        f.close();
    } else {
        std::string err_msg = this->GetName() +
            ": unable to save'" + filename + "'.";
        throw std::runtime_error(err_msg);
    }
}

SetName()

void Model::SetName ( std::string  s )

inherited

Setter method for the <_name> field.

Parameters

s	Value to be set

Definition at line 38 of file Model.cpp.

                                        {
    _name = name;
}

Wipe() [1/2]

void Memory::Wipe

(

)

Write zeroes to the whole addressable memory space.

Definition at line 189 of file Memory.cpp.

                  {
    this->Wipe(_base, _length);
}

Wipe() [2/2]

void Memory::Wipe	(	MemoryAddr	base,
		uint32_t	length
	)

Write zeroes to a region of the memory.

Parameters

base	The starting address, will be the first address to be writen
length	Number of cells to write zeroes to. Cells will follow the position of the base cell.

Definition at line 193 of file Memory.cpp.

                                                {
    #ifdef MEMORY_WRITE_ADDRESS_CHECKING
    // base must be less than the last address
    if (base < _base)
        throw std::runtime_error(this->GetName() +
            ": unable to wipe from base (" + std::to_string(base) +
            ") lower than sram base .");

    // base must be less than the last address
    if (base > GetLastAddr())
        throw std::runtime_error(this->GetName() +
            ": unable to wipe from base (" + std::to_string(base) +
            ") higher than sram base .");

    // base + size cannot go further than the last address
    if (base + size > GetLastAddr())
        throw std::runtime_error(this->GetName() +
            ": unable to wipe that much length (" + std::to_string(size) +
            ") higher than sram base + length.");
    #endif

    // get the pointer to the desired base
    MemoryType* range_ptr = _mem + (base - _base);

    // write zeros to the data to up to <size> cells.
    for (uint32_t i = 0; i < size; i++)
        range_ptr[i] = 0;
}

Write()

void Memory::Write	(	uint32_t	addr,
		MemoryType *	data,
		uint32_t	length
	)

Writes data to the memory.

Parameters

addr	Address of the first cell to receive the data. If data is largen than a single cell, neighbor cells will be writen.
data	A pointers of MemoryType that indicates the beggining of data to be copied.
length	Number of cells to write

Definition at line 75 of file Memory.cpp.

                                                                     {
    #ifdef MEMORY_WRITE_ADDRESS_CHECKING
    // check whether we're trying to access an address
    // lower than the base address
    if (addr < _sram_base) {
        stringstream s;
        s << this->GetName() << ": unable to write to addr (0x" << std::hex
            << addr << ") lower than sram base.";

        throw std::runtime_error(s.str());
    }

    // check whether we're trying to access and address
    // higher than the last address
    if ((addr + length -1) > GetLastAddr()) {
        stringstream s;
        s << this->GetName() << ": unable to write to addr (0x" << std::hex
            << addr << ") higher than last mapped address of (0x" << std::hex
            << GetLastAddr() << ").";
        throw std::runtime_error(s.str());
    }
    #endif

    #ifdef MEMORY_ENABLE_COUNTERS
    // increment number of stores into nstore counter
    _counter_nstore->Inc(1);
    #endif

    // write data to the memory
    // @TODO(ad): check whether this has the best performance
    for (uint32_t i = 0; i < length; i++) {
        _mem[addr - _base] = data[i];
        addr++;
    }
}

Member Data Documentation

_base

MemoryAddr orcasim::modeling::Memory::_base

private

The _base attribute indicates the first address of the memory module, an offset.

Since this model can only address contiguous cells, one may use multiple memory models to emulate a non-contiguous space.

Definition at line 80 of file Memory.hpp.

_length

MemoryAddr orcasim::modeling::Memory::_length

private

The _length attribute denotes the number of cells of the memory module.

The total number of memory space is given by sizeof(MemoryType) * _length (in bytes).

Definition at line 71 of file Memory.hpp.

_mem

MemoryType* orcasim::modeling::Memory::_mem

private

The _mem attribute is an array of MemoryType elements, where MemoryType is the smalled memory unit that can be read or writen to the memory.

Definition at line 63 of file Memory.hpp.

---

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

• orcasim-modeling/include/Memory.hpp
• orcasim-modeling/src/Memory.cpp