represent memory in c - c

Question

I am trying to write an Instruction Set Simulator in C to simulate a machine running ARM.
I need to be able to represent 4GB memory efficiently and after some digging have come to the solution of creating an array of 1024 pointers each pointing to a block of 4MB which is dynamically allocated at its first use
#define MEMSIZE 1024 //1024 * 2Mb = 4Gb
#define PAGESIZE 4194304 //4 Mb
#define PAGEEXP 22 //2^PAGEEXP = PAGESIZE
uint32_t* mem[MEMSIZE];
My question is how do I access a certain address of memory?
What I have tried is breaking the address into index and offset as below but this seems to only return 0 for both index and offset. (memAdd is the address I am trying to access)
memIdx = memAdd >> PAGEEXP;
memOfs = memAdd & PAGESIZE;
the functions I use to read/write once I have the address are below:
void memWrite(uint32_t idx, uint32_t ofs, uint32_t val)
{
if(mem[idx] == 0)
mem[idx] = malloc(PAGESIZE);
*(mem[idx] + ofs) = *(mem[idx] + ofs) & val;
}
uint32_t memRead(uint32_t idx, uint32_t ofs)
{
if(mem[idx] == 0)
return 0;
else
return *(mem[idx] + ofs);
}
these seem right in my head however I am still not 100% comfortable with pointers so this may be wrong.
Sorry if this has already been discussed somewhere but I couldnt find anything relevent to what I need ( my keywords are pretty broad)

Answer 1

Start out looking at it logically instead of at the bit level.
You have pages of 4,194,304 bytes each.
Arithmetically, then, to turn a linear address into a (page, offset) pair, you divide by 4,194,304 to get the page number, and take the remainder to get the offset into the page.
page = address / PAGESIZE;
offset = address % PAGESIZE;
Since you want to do this efficiently and these are powers of 2, you can replace division by PAGESIZE with right-shift by the base-2 logarithm of PAGESIZE, which is 22:
page = address >> PAGEEXP;
So that part of your code is correct. However, what you want to do to get the offset is to mask out all but the bits you just shifted out of the page number. To do that, you have to AND with PAGESIZE - 1.
offset = address & (PAGESIZE - 1);
This is because in binary, what you're starting with is a number that looks like this (where p is a page number bit and o is an offset bit):
address = ppppppppppoooooooooooooooooooooo
You want to get the page number and the offset number by themselves. You clearly want to shift right by 22 bits to get the page number:
page = addresss >> 22 = 0000000000000000000000pppppppppp
But if you AND with the pagesize (00000000010000000000000000000000 in binary), you'll only have one at most one 1-bit in the answer, and it will just tell you if the page number is odd or even. Not useful.
What you want to AND with is instead one bit less than that, which is binary 00000000001111111111111111111111, thus:
ppppppppppoooooooooooooooooooooo
& 00000000001111111111111111111111
-----------------------------------
= 0000000000oooooooooooooooooooooo
which is how you get the offset.
This is a general rule: if N is an integer power of 2, then division by N is the same as right-shifting by log(N)/log(2), and the remainder of such a division is given by ANDing with (N-1).

Answer 2

If PAGESIZE is a power of 2, it has only 1 bit set. Hence AND-ing it with another value can only leave zero or one bit set in the result. Two possible values. But you're using it as an array index.
Also your memWrite(uint32_t idx, uint32_t ofs, uint32_t val) function always ANDs in the value of val. Hence for example if val is uint32_max any call to this function will have no effect.
Last, not only do you not check the result of malloc() for failure, you don't initialise the memory block which is returned.
Try an approach like this (unfortunately I have been unable to test it, I have no compiler handy just now).
enum { SIM_PAGE_BITS = 22 }; // 2^22 = 4MiB
enum { SIM_MEM_PAGES = 1024 }; // 1024 * 4MiB = 4GiB
enum { SIM_PAGE_SIZE = (1<<SIM_PAGE_BITS) };
enum { SIM_PAGE_MASK = SIM_PAGE_SIZE-1 };
enum { UNINITIALISED_MEMORY_CONTENT = 0 };
enum { WORD_BYTES = sizeof(uint32_t)/sizeof(unsigned char) };
#define PAGE_OFFSET(addr) (SIM_PAGE_MASK & (uint32_t)addr)
// cast to unsigned type to avoid sign extension surprises if addr<0
#define PAGE_NUM(addr) (((uint32_t)addr) >> SIM_PAGE_BITS)
#define IS_UNALIGNED(addr) (addr & (WORD_BYTES-1))
unsigned char* mem[MEMSIZE];
uint32_t memRead(uint32_t addr) {
if (IS_UNALIGNED(addr)) return handle_unaligned_read(addr);
const uint32_t page = PAGE_NUM(addr);
if (mem[page]) {
const unsigned char *p = mem[page] + PAGE_OFFSET(addr);
return *(uint32_t*)p;
} else {
return UNINITIALISED_MEMORY_CONTENT;
}
}
void memWrite(uint32_t addr, uint32_t val) {
if (IS_UNALIGNED(addr)) return handle_unaligned_write(addr, val);
const uint32_t page = PAGE_NUM(addr);
if (!mem[page]) {
if (val == UNINITIALISED_MEMORY_CONTENT) {
return;
}
mem[page] = malloc(SIM_PAGE_SIZE);
if (!mem[page]) {
handle_out_of_memory();
}
// If UNINITIALISED_MEMORY_CONTENT is always 0 we can
// use calloc instead of malloc then memset.
memset(mem[page], UNINITIALISED_MEMORY_CONTENT, SIM_PAGE_SIZE);
}
const unsigned char *p = mem[page] + PAGE_OFFSET(addr);
*(uint32_t*)p = val;
}

Answer 3

This will do what you want. I've used smaller sizes. I've left out the error checking for clarity. It uses your scheme of using an indexer array.
#include <cstdlib>
#include <cstdio>
#include <stdint.h>
#define NUMPAGE 1024
#define NUMINTSPERPAGE 4
uint32_t* buf;
uint32_t* idx[NUMPAGE];
void InitBuf()
{
buf = (uint32_t*) calloc(NUMPAGE, NUMINTSPERPAGE * sizeof uint32_t );
for ( size_t i = 0; i < NUMPAGE; i++ )
{
idx[i] = &buf[i * NUMINTSPERPAGE * sizeof uint32_t];
}
}
void memWrite(size_t i, size_t ofs, uint32_t val)
{
idx[i][ofs] = val;
}
uint32_t memRead(size_t i, size_t ofs)
{
return idx[i][ofs];
}
int main()
{
InitBuf();
uint32_t val = 1243;
memWrite(1, 2, val);
printf("difference = %ld", val - memRead(1, 2));
getchar();
}

Answer 4

I don't believe the value of memOfs is being calculated correctly. For instance, the decimal value 4194304 represented by PAGESIZE is 0x400000 in hexadecimal, which means that after the bitwise-AND operation, you're only getting bit 22 of the original address, not the lower 22 bits. Adding that value to the 4MB page-array-pointer actually sends you beyond the end of the allocated array on the heap. Change your mask for the offset calculation to 0x3FFFFF, and then bitwise-AND that with the original memory address in order to calculate the proper offset into the page. So for instance:
memIdx = memAdd >> PAGEEXP;
memOfs = memAdd & 0x3FFFFF; //value of memOfs will be between 0 and 4194303