Fragger's stupid questions, chapter 1.

[mankrip]

For some reason I always forget to ask things here... but luckly I remembered to do it now.

- Is there any difference between > and >=, speed-wise? For example:

Code: Select all

if (myvar > 1) somefunction();

Code: Select all

if (myvar >= 2) somefunction();

Just it for now, I'm busy with other things and don't remember what else I want to ask.

[semicolo]

Well it may depend on the instruction set of the processor you're using, on x86 processors there are instructions for testing > or >= with the same execution cycle numbers.

[nymus]

Another factor is the size of the immediate value eg the sh4 can only compare -127-128 so if you said >=128, the compiler (or you) would have to hack a little bit to avoid storing 128 in memory.

Such worries are not as important as a clear program. Most programs I've seen use the > notation so you should use that.

[Ex-Cyber]

-127-128

Shouldn't that be -128 - 127?

[nymus]

True.

[mankrip]

Is there any speed difference between calling a function and using the code "directly"?

Well it may depend on the instruction set of the processor you're using, on x86 processors there are instructions for testing > or >= with the same execution cycle numbers.

Thanks.

Another factor is the size of the immediate value eg the sh4 can only compare -128-127 so if you said >=128, the compiler (or you) would have to hack a little bit to avoid storing 128 in memory.

Do you mean 128 bits (FFFF FFFF hex, 4 294 967 295 dec)?

Such worries are not as important as a clear program. Most programs I've seen use the > notation so you should use that.

Thanks. It's just that I tend to be nitpick when I'm working .

[doragasu]

Is there any speed difference between calling a function and using the code "directly"?

Using the code "directly" is faster, but there's a keyword -inline- you can use before a funcion declaration for the compiler to put the code of the function "directly" where the call is, and also when you enable optimization options, compilers auto-inline functions they consider. For extremely simple things, you can also use macros instead of functions.

[nymus]

For extremely simple things, you can also use macros instead of functions.

Most programmers today frown on the use of using macros in working/executable code. Leave macros for configuration.

[doragasu]

For extremely simple things, you can also use macros instead of functions.

Most programmers today frown on the use of using macros in working/executable code. Leave macros for configuration.

I think simple macros are still pretty useful when coding for systems with limited resources (like DC, consoles like GBA, embedded systems, etc.). It's true you have to be very careful when working with macros (put all the input parameters in brackets, do all kind of castings, etc) but it it's fast, easy and works, why shouldn't I use it?

[BlackAura]

I tend to use inline functions (or methods, depending on context) when writing C++, and a mix of macros and inline functions in C, usually macros only. Inline functions aren't really as good in C as they are in C++ so macros are an acceptable alternative, provided you're careful with them (put brackets around all paramaters in the macro itself, and use each parameter once and once only to avoid unpredictable side effects). Still a little clumsy, but not too bad.

They have the added advantage that they can be (kind-of) polymorphic, so you could have a single macro that can work on multiple types, while still remaining as type safe as C ever is (which is to say, not very, but neither is C++). You can do that in C++ using either multiple functions / methods with the same name but different signatures (if you don't mind re-defining the same thing for every conceivable data type), or using templates (which is far less transparent to use). Hmm... You can tell I've been doing work with functional programming languages, can't you?

Admittedly, I wouldn't really want to use macros in C++ or Java (they're not necessary there), but for lower level languages, why not?

[doragasu]

Admittedly, I wouldn't really want to use macros in C++ or Java (they're not necessary there), but for lower level languages, why not?

I didn't know you can use macros in Java... How does a Java macro look like? (just curious).

[BlackAura]

I didn't know you can use macros in Java... How does a Java macro look like? (just curious).

Actually, you can't. But you wouldn't really want to anyway. Possibly didn't make myself clear there...

[Moi]

I know this topic is quite old but i think this link is quite interesting:

http://www.custard.org/~andrew/optimize.php

[toastman]

Is there any speed difference between calling a function and using the code "directly"?

I just want to chime in here on this because while your question was answered, I felt the "why" was left out.

Using a macro, the inline keyword, or just retyping the code whereever you need it is faster than using a function because calling a function creates a certain amount of overhead.
Normally, code executes in a linear fashion. Each instruction, one after the other. Certain instructions can jump to different locations in the code and begin execution there.
This essentially (and this is very basic) how functions work. When you call your function, memory is allocated, values are pushed on the stack, and the jump is made to your function. Your function executes, then everything happens in reverse and you may return something.
With macros, "inlining" the function, or retyping, you aren't creating that overhead. A macro or inline function replaces the function call before your code actually is processed by the compiler. Retyping the function is avoiding the issue all together and is just a manually doing what the macro and inline already do.
So yes, your code will run faster if you inline or macro your functions, however, your executable will be larger as all of those function calls will be replaced by actual code.
If space is not an issue, and you need every bit of speed you can get, then inline/macro away. However, on low memory systems, it might be wise to use functions to reduce on your program's footprint.
And the question is also, how much speed will you be gaining by doing this? Is the speed worth the larger footprint?