Ok Simon, how about this one :

x = min( x , 100 );

or

if( x > 100 )x = 100;

And thank you Fir.

greetings

What about that one? What's the question?

Code clarity is almost the only thing that matters here, so use the one that most closely represents your intent.

For instance, if x is something that is computed in some way but we want to cap it from above for some reason, I would write

int capped_x = min(x, 100);

This is because it's easier to reason about the code if the meaning of a variable doesn't change through its lifetime, and if it has a descriptive name.

Do yourself a favor and stop thinking of micro-optimizations that won't make a difference.

I agree with that it is not important except of the tight processing

loops - but there maybe this is important but it leads to good level

of knowing assembly level code - the thing that i ew would like to

know and i would like to talk here with some asm knowing people

but maybe they are hard to find today (also in www world there seem

to be hard to find good and easy materials /tutorials today learning

how to hand optymize procedures in asm

as to opinions if this would result in general optymisations - some say no (and they belive compiler produce code better than you do) - some say yes (and they say that still compiler are silly to produce uneffective

code sometimes -

I tend to belive the later in some special cases and the first in other (maybe most) cases

- but in general i think it is worth it to be interested in this thing (depending of the thing if you want to 'waste' the time on trying

to speed up procedures or no

The point that those of us with assembly experience are trying to make is that those two code snippets are probably identical once compiled and optimized. Try it yourself and see.

sure thats why i say it should be bringed to good level of asembly 'know-how' and maybe speaking more of choising of assembly opperands not c syntax(*) (and this is only important in suitable central loop cases you my never encounter or just dont care)

(*) there was a topic recently about this things i was asking for

http://www.gamedev.net/topic/650824-x86-jumps-in-assembly/

(I am interested in such things though i got a little time to study it

very good :C )

@ Madhed : What is meaned with high level optimalisation ?
something that is repeated 1000 times i am worrying about, if that is called low level optimalisation, then i am very confused.

"Level" means "height", and it's used metaphorical in many different ways. In one case "high level of optimization" refers to the compiler settings, where the different settings are called levels, and "high level" means "with most optimizations turned on". In the other case, worrying about the performance of some small piece of code inside a loop is called "low-level optimization", and here "level" refers to the abstraction level, where "low" means "close to the hardware" and "high" means "close to some human understanding of the situation, unconcerned with the details of how things are ultimately implemented".

A bunch of us here do know assembly language, and my knowledge of assembly language doesn't change my advice: You should write the code in the form that is most expressive. The compiler will generally do a very good job of mapping that into efficient code. If you have a program that is too slow and a profiler that tells you that you need to worry about how much time you are spending evaluating `min', you can try a few alternatives blindly to see what makes the program faster. Or, if you know some assembly language, you can look at the assembly output of your compiler and see if it is using conditional jumps; if that's the case, you can try to write the code in other ways where it might be easier for the compiler to realize that it can use conditional MOV instructions. If your hardware doesn't support conditional MOV instructions, you might be able to implement branch-less code yourself, doing something like this:

  unsigned mask = -(x > 100);
  mask &= (x ^ 100);
  x ^= mask;

I have changed code in critical parts of a program to avoid branches in the past, but you should only consider doing such things after the profiler tells you to. If you still haven't gotten that point by now, perhaps you are trolling us.

as to opinions if this would result in general optymisations - some say no (and they belive compiler produce code better than you do) - some say yes (and they say that still compiler are silly to produce uneffective

code sometimes -

Why does the compiler make float to int as fast as the assembly code i got from www.musicdsp.org ?

So having ASM is needed in my opinion.

i do not understand the aboove question :u

as to float -> int casting

when i was using borland55 on pentium4 (i did it not so long time ago)

it had a terribly slow float->int conversions so i was even using nasm

like here

__m128 maximum = _mm_max_ss(_mm_max_ss(a, b), c);

You are approaching programming the wrong way. Start by getting yourself some books on C++ and follow their advice. Start programming some simple games. Read more. Then when you start making more advanced games it might be natural to think of these kind of optimization (It probably wont be necessary though). By that time your Celeron CPU will be dead.

People on here have a lot of experience so do yourself a favor and listen to their advice.

Hi this is the code is use :

http://musicdsp.org/archive.php?classid=5#56

int truncate(float flt)
{
int i;
static const double half = 0.5f;
_asm
{
fld flt
fsub half
fistp i
}
return i
}

quite fine, i could use it too (on oldcompilers), go on with that