Elysian Shadows

eatcomics wrote:Oh, a nice comeback by Gyro. Let's see what Avan has to counter... What do you think Eatcomics?
Well I'd have to say that Gyro has this one wrapped up, and I think Avan's offense is lacking this season, but we'll just have to see... oh and the shot is up....

avansc wrote: 3. yes i said dynamically allocating memory is VERY SLOW. but it was obviously a hyperbole. I think we call can agree that allocating at map change once is negligible. you will spend more time loading images in.

MrDeathNote wrote:

avansc wrote: 3. yes i said dynamically allocating memory is VERY SLOW. but it was obviously a hyperbole. I think we call can agree that allocating at map change once is negligible. you will spend more time loading images in.

That really depends on if you have maps of different sizes, if you do then you need to reallocate every time or it kinda destroys the point of making it dynamic in the first place. If you have to reallocate every time you hit a warp that could cause problems, especially on DC and PSP.

avansc wrote:At first i was not going to reply because i dont want this to be turned into something its not, that being this scenario where im just trying to disagree with you, or forks along those lines.

1. Having the map size being varied does not mean its "fuck knows what size", just means its not static, nothing stops you from calculating the size and knowing how much memory you have left.

2.Not sure what you mean by thrashing the heap, its one allocation, of contiguous memory.

3. yes i said dynamically allocating memory is VERY SLOW. but it was obviously a hyperbole. I think we call can agree that allocating at map change once is negligible. you will spend more time loading images in.

4. Smarter, more meaningful... well thats your opinion and thats fine. not sure if wasting space is smart or meaningful.

5. Wasting stack space can adversely affect stack intensive functions.

6. 4-8 BIGGER? no sure how you get to that.

Code: Select all

#include <stdio.h>
#include <stdlib.h>

#define DEPTH 3
#define WIDTH 1024
#define HEIGHT 1024

void set(char *p, int l, int x, int y, char data)
{
	p[DEPTH*HEIGHT*l+WIDTH*y+x] = data;
}

char get(char *p, int l, int x, int y)
{
	return p[DEPTH*HEIGHT*l+WIDTH*y+x];
}

int main(int argc, char * const argv[])
{
	
	char stack[DEPTH][HEIGHT][WIDTH];
	
	printf("stack = %d\n", sizeof(stack));
	
	char* local = (char*)malloc(sizeof(char)*DEPTH*WIDTH*HEIGHT);
	char* mover = local;
	
	for(int a = 0;a < 3;a++)
		for(int b = 0;b < 1024;b++)
			for(int c = 0;c < 1024;c++)
				++mover;
	
	printf("heap = %d\n", mover - local);
	 
	getchar();
    return 0;
}

in closing i would just like to say in no way was i just trying to disagree, just said what i like to do and why.

i prefer doing ***tiles. here is why.

MrDeathNote wrote:

avansc wrote: 3. yes i said dynamically allocating memory is VERY SLOW. but it was obviously a hyperbole. I think we call can agree that allocating at map change once is negligible. you will spend more time loading images in.

That really depends on if you have maps of different sizes, if you do then you need to reallocate every time or it kinda destroys the point of making it dynamic in the first place. If you have to reallocate every time you hit a warp that could cause problems, especially on DC and PSP.

RyanPridgeon wrote:If you're heap allocating a multi dimensional array only once, wouldn't it be better to malloc all in one go then point to seperate parts?

Code: Select all

#include <stdlib.h>

int** map; // 2d map array

int main(int argc, char** argv){
    int i, width, height;
    int* memory;

    width = 5; // can be dynamic
    height = 5;

    memory = (int*)malloc(sizeof(int)*width*height); // one contiguous block of memory

    map = (int**)malloc(sizeof(int*)*width);
    for (i = 0; i < width; i++){
        map[i] = memory + i*height;
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define DEPTH 3
#define WIDTH 1024
#define HEIGHT 1024

void set(char *p, int l, int x, int y, char data)
{
   p[DEPTH*HEIGHT*l+WIDTH*y+x] = data;
}

char get(char *p, int l, int x, int y)
{
   return p[DEPTH*HEIGHT*l+WIDTH*y+x];
}

int main(int argc, char * const argv[])
{
   
   char stack[DEPTH][HEIGHT][WIDTH];
   
   printf("stack = %d\n", sizeof(stack));
   
   char* local = (char*)malloc(sizeof(char)*DEPTH*WIDTH*HEIGHT);
   char* mover = local;
   
   for(int a = 0;a < 3;a++)
      for(int b = 0;b < 1024;b++)
         for(int c = 0;c < 1024;c++)
            ++mover;
   
   printf("heap = %d\n", mover - local);
    
   getchar();
    return 0;
}

GyroVorbis wrote:I'm going to have to look at just how you're measuring the RAM usage when I get home. But that cannot be correct.

Yes, sizeof(char*) == sizeof(char********). But sizeof(char*) is 4/8bytes while sizeof(char) is just a single byte. Your method MUST use way more than mine.

char ***pmap = (char***)malloc(sizeof(char**)*Z);

pmap[z] = (char**)malloc(sizeof(char*)*Y);

pmap[z][y] = (char*)malloc(sizeof(char)*X);

avansc wrote:

GyroVorbis wrote:I'm going to have to look at just how you're measuring the RAM usage when I get home. But that cannot be correct.

Yes, sizeof(char*) == sizeof(char********). But sizeof(char*) is 4/8bytes while sizeof(char) is just a single byte. Your method MUST use way more than mine.

kk.

and yeah it confused me for a bit too,

this is how it breaks down. (i think at least)

Code: Select all

char ***pmap = (char***)malloc(sizeof(char**)*Z);

pmap*** is 3 pointers and the pointer to the identifier pmap, so thats where 32Bytes come form. (the *** has nothing to do with 3, Z is defined as being 3, and the extra 8 bytes i can only assuming is a pointer to the pmap identifier address)

so that gives us 8*4 = 32Bytes

Code: Select all

pmap[z] = (char**)malloc(sizeof(char*)*Y);

pmap[z] (can be 0 - 2, the three pointers we allocated), each one gets allocated space for 256 pointers, so
3*256*8 = 6144 Bytes or 6KB

now we are done allocating pointers, we have all the pointers we need to represent the depth and height of the map, the width are allocated as characters. IE just 1 byte.

Code: Select all

pmap[z][y] = (char*)malloc(sizeof(char)*X);

pmap[z][y] (z goes 0 to 2, y goes 0 to 255) each one gets allocated 256 bytes.

so that gives up 3*256*256*1 bytes = 196608 bytes or, 192 KB.

so, all together we have 192KB+6KB+32B, thus comes to a fraction over 198KB.