Programming

Hello ,

i have read the manual page of alloca ,
it is documented there that "alloca works similar to the malloc but it allocates memory from stack and frees automatically".

i can't get how can i use that in a program .
if i'm not wrong can i use that like :

Code:

#include<stdio.h>
#include<alloca.h>
int main()
{
        void *p;
        p=alloca(20);
        if(p==NULL)
        {
                printf("alloca failed");
                exit(1);
        }
 
        strcpy(p,"Hello");
        printf("%s\n",p);
        printf("%u\n",p);
 
        return 0;
}

and what is the advantage of such a function.

even if i use array it also allocates memory from the stack and memory will be freed automatically.

what is the more advantage its having than array.

Have a read of this:

Advantages of Alloca - The GNU C Library

Regards

One advantage of alloca() that page doesn't directly address is that alloca() allocates memory that's already under the control of the thread that's making the call, so in multi-threaded applications alloca() can be many orders of magnitude faster than malloc()-based calls.

IMO the link on that page to alloca() disadvantages doesn't stress the major disadvantage of alloca() strongly enough - running out of memory. With malloc()-based allocation, you've got to get pretty extreme before you'll run out of memory. But with alloca(), all you have to work with is the stack of the current thread, which may be quite small, and unless you've directly addressed thread stack size is probably only a few MB at most.

In other words, in order to use alloca() safely you have to really, really know how much memory your entire process is using and where all that memory is coming from.

But if you take care and know what you're doing, you can make multi-threaded apps tremendously faster using alloca().

Use of alloca is discouraged because it is system dependent...also the memory returned cant be passed to other functions since it is freed as soon as the function that calls alloca exits. With alloca portability is the biggest concern if developing apps for different platforms.

How system dependent? Linux has it, Windows has it, IRIX has it, Solaris has it, BSD has it, OSX has it, HPUX seems to have it... The only platform I can think of offhand that I can't verify is AIX, and that's a "maybe", not a "no". It seems too useful, even internally, for vendors to not implement... I will admit that some embedded platforms implement it badly(a severe error on systems with no malloc!), allowing alloca'd memory to be overwritten by further function calls, but I'm not aware of an embedded platform with threading. I suspect the kind of stack management needed for threading also lets alloca exist. You can certainly pass it to other functions if you keep in mind its scope, the exact same way you can pass references to stack variables if you keep in mind their scope. For a thread, it will be valid as long as the thread exists. Please note any platforms you know of that don't have alloca.

AIX has it too. I work primarily on AIX and HP-UX platforms and their man pages explicitly state that alloca should not be used because it's sytem dependent. Why they dont say that...perhaps because different MPUs manage stacks differently. What if one mpu had its stack growing towards high memory instead of low memory...that itself would be a portability problem.
It's more so of an issue on embedded platforms because of the limited resources...why allocate memory with alloca in each function frame when you can allocate it once with malloc and keep reusing it.
It can certainly be passed to a nested function but can't be returned from one function to another the same way that a malloc'd pointer can be.
I don't know of any platforms that don't support alloca apart from embedded OSes however as the manpages say it is system dependent. Personally I have never used alloca because it is really of no use when it cant be returned. Curious if you can come up with a scenario where it's use would be more befitting than malloc.

FWIW - solaris alloca man page:
Maybe it has to do with implementing stack frames in different architectures from a single vendor? This is from an Ultrasparc IIIi multi-cpu box.

Linux:
I added the red.