Printable View
Hi,
i am new to C programming, and want to advice you in general about good tips in order to port C code in small processors like MIPS.
for example what is a good practice in order to replace functions like malloc?
Also , is there any easy way to monitor if the program exceeds the available memory during runtime?
Generally, the advice is to write code that is portable. You achieve that with a series of "don't"s. Don't make assumptions about things like what size an integer is. Don't make assumptions about how many digits of precision a floating point variable supports. Don't make assumptions that two variables are beside each other in memory. Don't make assumptions about how data structures are laid out. Don't write complex expressions with lots of side-effects (make your expressions simple, and only change one thing at a time). Don't try to access element 5 of a 3-element array. The list of "don't" you will need to learn is quite long.
There is no good practice in C for replacing functions like malloc(). Your choices are to either use them as is, wrap them in some way that does more error checking before and after calling malloc(), not use them at all, or write dedicated code (which will probably be non-standard and non-portable) to do a similar thing. Each of those approaches has advantages and disadvantages. There is no "best".
Making the huge assumption that your code is not misbehaving in some way (e.g. not molesting pointers, so not corrupting data structures that malloc() uses internally) then malloc() will return NULL if it cannot allocate memory. If memory used exceeds memory available, then malloc() cannot allocate memory. If you want more precision than that (for example, a report how how much memory is remaining) then the techniques are non-standard and non-portable (i.e. specific to an operating system).
Thanks for the answer
basically i try to remove malloc statements by declaring normal variables of fixed size. Supposing that i know the size of the required space is it ok to change a pointer that is allocated x mount of memory into a varilable of size x? Also i want to ask what happens when malloc is used inside a function...is it correct that memory is allocated EACH time the function is called? so it would increase the memory needs siginificantly?
Quote:
Originally Posted by grumpy
Yes, with the caveat that if the space allocated is too large, it may exceed the given size of the stack (if the variable does not have static storage duration).Quote:
Originally Posted by george_g
Thanks again. Another (rather basic i guess) question:
When i compile a c program in my environment i get a message which looks like : size program + min stack = 50K
so because the total memory is configurable if i select 32K is doesn't fit , if i select i.e. 64K it's ok
But what it this space of 50K contain? Is it only the instructions of the program, or together with the space allocated for the variables?
when a program features the command int a ; how it that handled by the compiler? it is allocated on runtime only? compile time? both?
Quote:
Originally Posted by laserlight
> But what it this space of 50K contain? Is it only the instructions of the program, or together with the space allocated for the variables?
It probably means everything (except dynamic memory allocation), if you're just loading this onto a bare board.
Example.
So in this example, the generated assembler of main() occupies 115 bytes (the text section), the global array msg is 12 bytes(data) and the global variable(bss) is 4 bytes.Code:$ cat foo.c
#include <stdio.h>
int global = 0;
char msg[] = "hello world";
int main ( ) {
int local = 1;
printf("%d %d %s\n", local, global, msg );
}
$ gcc -c foo.c
$ size foo.o
text data bss dec hex filename
115 12 4 131 83 foo.o
Finding out how much stack space (at compile time) is trickier.
For simple code with a straightforward call relationship, it's pretty easy to work out.
It gets harder if you have like many 20+ nested function paths, as you need to sum each call path in turn to work out what the maximum depth is.
a() -> b() -> c() -> d() -> e() might be less than x() -> y(), if say y has lots of local variables.
Things get messy though if you have recursive calls, or variable length arrays on the stack.
Your default stack size might be quite large, but you should be able to configure it down to a really small size if your code is simple enough.
So when we declare a varilable, the compiler allocates memory to the stack at that point, or just gathers information of how much memory will be allocated in runtime?
Quote:
Originally Posted by Salem