13

I know assertions can be enabled/disabled at runtime for debugging and production, respectively. However I found that assertions also increase the size of the generated binary (about 100-200 bytes in the example below).

In C and C++, we can do this at compile time by having #define NDEBUG before #include <assert.h>.

Is there any way for the Java compiler to automatically do this? I'd like to leave them in the source code for debugging purposes later on. But I also don't want the resultant binary to be any larger than necessary (we have a size limit as design requirement).

C code:

//#define NDEBUG
#include <assert.h>

int main(void) {
    assert(0); // +200 bytes without NDEBUG, 0 with NDEBUG
    return 0;
}

Java code:

public class Test {
    public static void main(String[] args) {
        assert(System.nanoTime()==0); // increases binary size by about 200 bytes
    }
}

In response to bn.'s answer:

public class Test2 {
    public static final boolean assertions = false;

    public static void main(String[] args) {
        if(assertions) {
            assert(System.nanoTime()==0);
        }
    }
}

EDIT: In fact, it seems to me that this enabling/disabling is a more useful compile-time feature than run-time. I mean, how many end users will enable them? As far as a programmer is concerned during the debug process, he/she will likely be recompiling code anyways.

Improve this question
8
  • 1
    @EJP: For sure. What I meant was that there is a non-negligable increase caused by asserts as a whole. The precise amount certainly depends on the complexity of the statement. Commented Jun 6, 2012 at 15:45
  • 1
    If you bother with such things, you are with the wrong language. Commented Jun 6, 2012 at 15:53
  • 2
    Did you try public **final** static boolean assertions = false;? Commented Jun 6, 2012 at 15:55
  • 1
    @MiserableVariable: Aha, that did it. There was a small 50 byte overhead when I tried it. However that can probably be attributed to having to define the assertions variable. Commented Jun 6, 2012 at 16:15
  • 1
    Binary size is relatively cheap, and the JIT eliminates these at class-load time anyway. What's the point? Commented Jun 6, 2012 at 17:06

2 Answers 2

Reset to default
4

This is not possible as a built in compilation step. You can however, do this by adding conditional blocks around your assertions.

See the article "Removing all Trace of Assertions from Class Files" for more information.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Sounds like a good idea, but it actually increased the binary even more by another 50 bytes.
That doesn't make much sense since the compiler should remove the statements altogether since it is now unreachable.
@Robin if OP uses final it will reduce the size.
@MiserableVariable Are you sure? javac skips lots of sensible optimizations, possible at compile time, just because it assumes the runtime optimizer will take care of it. See this.
@bn. Your link (the meat of the answer) is gone.
2

Personally I would not do the following because of the complexity added to the source code but javac generated the exact same intermediate code for main in the following two fragments:

conditional asserts

class C {
    public final static boolean assertions = false;

    public static void main(String[] args) {
        if(assertions) {
            assert(System.nanoTime()==0);
        }
    }
}

no asserts

class C {
    public static void main(String[] args) {
    }
}

compiled code

  public static void main(java.lang.String[]);
    Code:
       0: return        
    LineNumberTable:
      line 3: 0

EDIT

In fact, it seems to me that this enabling/disabling is a more useful compile-time feature than run-time. I mean, how many end users will enable them?

Its not end users that enable them, it is the customer support that tells the end user to enable them. I do wish though they were enabled, not disabled, by default.

Improve this answer

6 Comments

Perfect thanks! I agree that it's not a very elegant solution but it does address my question.
It seems that if you put your public final static boolean assertions = false; variable on a separated class, so that you could use asserts all over your code and just change the flag on one place, you will need to recompile the whole source if that is changed (and that is desirable, since you want the variable wiped from your compiled code).
@Ivella this is because the compiler inlines public static finals.
@MiserableVariable, Exactly, so your answer doesn't prove anything, since we can get the same intermediate code when we use public static final simple-if-else no-assert.
@Pacerier I am afraid I don't understand your comment. My answer shows that using conditional asserts will in some cases result in intermediate code that is not bigger than code that does not have asserts. On the other hand, this is an old discussion so it is likely I am missing some important observation. Can you please elaborate?
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.