Why does does my stack overflow error occur after 518669 specifically?

Question

I created a java program to count up toward infinity:

class up {

    public static void up (int n) {
        System.out.println (n) ;    
        up (n+1) ;
}

    public static void main (String[] arg) {
        up (1) ;

}
}

i didn't actually expect it to get there but the thing that i noticed that was a bit curious was that it stopped at the same number each time: 518669

what is the significance of this number? (or of this number +1 i suppose).

(also as a bit of an aside question, I've been told that the way i format my code is bad [indentation and such] what am i doing that isn't desirable?)

Answer 1

To answer your aside, the close brace of a method is generally aligned with the start of the method. So in your cases here, in the same column as the 'p' of public.

Answer 2

There is little significance to that number itself other than apparently 518669 multiplied by whatever the stack size is for that method equals the total available stack space on your system.

Answer 3

There is nothing special about the number 518669 except that this is how many stack frames you can fit in your available memory before you run out.

There is no reason to use recursion here -- you should simply use a while loop instead.

Answer 4

That specific value isn't significant, it's a result of your local setup. That you get the same value repeatedly is significant and predictable.

Your program crashes consistently at that point because each time you're running your program, the Java Virtual Machine starts with the same parameters and then performs the same actions until the stack space is gone.

You can change both, and change the result.

You can change the max stack size available to your JVM by passing a -Xss flag, for example:

java -Xss4096k MyClass

On my machine, with my default startup parameters, I run out of stack space after 10,518 recursive calls. I think the default is 1024k for my setup.

If I set the max stack size to 4096k as above, I can get 50,777 recursive calls before a stack overflow.

You can also add more operations, or different operations to your method, consume more space per call and change the number of possible invocations.

If I add the statement MyClass myClass = new MyClass(); to the code (a local instance of MyClass per call) after your println statement, the number of calls I can make before an overflow goes down from 10,518 to 9,709 as on each call a reference to an instance of MyClass has be stored.

Answer 5

You have a finite amount of memory allocated to the call stack. It is the same amount of memory each time you run the application. So it stops counting in the same place each time, because you are out of stack memory.

As to your aside, I would format in this mannor

class up 
{
    public static void up(int n) 
    {
        System.out.println(n);    
        up(n + 1);
    }

    public static void main(String[] arg) 
    {
        up(1);

    }
}

This way it is much more clear when your blocks begin and end.

Answer 6

Space before semicolon is also unusual, space between parenthesis and method name may be controversal, I personally don't like it, because it makes spotting function calls harder (at least for me). If you are concerned, try looking for some conventions, which are standardized. E.g. Sun's standards, Checkstyle, Eclipse formatter, hydrolabs formatter etc. For the number, maybe some upper limit, or println gets buffered and till something gets printed JVM gets busy... but that is just my guess.