Thread: mystery seg fault o' tha day

I have a function that I'm using to shuffle the nodes in a linked list. It takes a pointer to the head node and the length of the list as an argument. It works fine, repeatedly, on all kinds of lists UNLESS the list length is slightly over 1 million (which is several hundred megs out of 2G local RAM). Then the whole program seg faults immediately after the shuffle is called. gdb will just point to the first real instruction in the function as the culprit:

Code:

node *shuffle (node *head, int len) { 
        int i, X, r;
        node *ray[len], *tmp;
        printf("shuffle()..."); fflush(stdout);

gdb sez:
Program received signal SIGSEGV, Segmentation fault.
0x0000000000402d2b in shuffle (head=0x605010, len=1050000) at linklist.c:543
543 printf("shuffle()..."); fflush(stdout);

1,000,000 okay. 1,050,000 no good! Note that shuffle()... does not even print!

Originally Posted by tabstop

That's because the failure happens when node *ray[len] completely fails to fit on the stack.

Why? Shouldn't the stack fit node *ray[len]?

The stack is nowhere near 2G. It might be 2MB. You would be better off doing malloc for your ray array.

Originally Posted by Dino

The stack is nowhere near 2G. It might be 2MB. You would be better off doing malloc for your ray array.

You mean I actually have to go:

Code:

node **ray=malloc(len*sizeof(node*));
free(ray);

well, it works anyway.

Yes, that sort of thing would work. The reason it crashes on the call to printf is that when you call printf is the first time you actually WRITE outside of the stack-space (to store the arguments to printf, or if you have tuned it perfectly, on the actual call instruction when it pushes the return address onto the stack).

The rule is that if you have LARGE objects, they go on the heap. Small objects, on stack. Now, what is a small or large object? Large is certainly anything bigger than a few kilobytes. Small objects are anything up to a few dozen bytes. The stuff in between is in the "grey area" where we you'd have to decide from instance to instance whether it is right to use the stack or the heap.

Note also that if you don't know (like in this example, where len is a parameter to the function), and it is POSSIBLE that the size is LARGE, then you should use the heap, even if sometimes the object is actually in the small category [or have two variants of the code - one for small size and one for large size].

Note that running out of stack is a BAD thing to do - there is no (good) way you can recover from a "out of stack" fault, besides exiting the thread/process.

--
Mats