Thread: SSE math

Indeed, some compilers can generate SSE code. In the past, I have tested this out with not-so-great results. But that's not to say that the latest versions aren't working better.

Generally, using inline assembler is the best way to achieve good results, in my experience. Most compilers generate rather awkward results.

If you don't kind locking down your code to Intel only, you could use Intels compiler - it is probably the best for x86. Unfortunately, it means "can not run on AMD" executable files. It is also an expensive compiler, but I believe you can "try it out" for something like 30 days for free. It should be enough to show if it's improving your code or not.

--
Mats

There is a standard set of Intel Intrinsics for SSE. This is supported by VC, gcc, and the Intel compiler. It's a step up from writing assembler by hand, but you still remain in control of the exact instruction sequences.

See:

How to Vectorize Code Using Intrinsics on 32-Bit Intel® Architecture - Intel® Software Network

Originally Posted by brewbuck

There is a standard set of Intel Intrinsics for SSE. This is supported by VC, gcc, and the Intel compiler. It's a step up from writing assembler by hand, but you still remain in control of the exact instruction sequences.

See:

How to Vectorize Code Using Intrinsics on 32-Bit Intel® Architecture - Intel® Software Network

And does gcc generate sensible code when using these. Past versions of MS compilers produce rather AWFUL code (mostly because it kept using the same registers for every single intrinsic function, and thus spilling/filling to/from memory for every line of intrinsic. But it may be better in gcc, and it may be better in 2008 - I haven't tried.

--
Mats

Or you are doing something wrong (very pessimized code). I typically only get 2x-3x speed up with -O3 compared to -O0. But of course, it can differ greatly between different scenarios, and fast code (unoptimized) isn't necessarily good. Just make sure you are not pessimizing prematurely.

And last time I checked, the Intel compiler is free (as in beer) on Linux, and commercial (with a timed trial) on Windows (and requires Visual Studio). Strange eh?

been using C less than two months, so I have no idea what gcc does

To find that out, you will probably need to use the -S switch to get gcc to output assembly, and read that (and of course, you need to learn assembly language before that). Leave that to matsp for now, just focus on C .

Originally Posted by cyberfish

Or you are doing something wrong (very pessimized code). I typically only get 2x-3x speed up with -O3 compared to -O0. But of course, it can differ greatly between different scenarios,

Just for reference, with the testing I did in this thread last week on (eg) this basic task:

Code:

int check_digit (char c) {
	return ((c>='0') && (c<='9'));
}

The difference between -O3 and no flag was > 400%. Testing ctype.h's isdigit() the difference was even more severe (1200%).

Originally Posted by KBriggs

Yeah I saw that one. I would dearly love to get a good understanding of gcc's inner workings, but I suspect that it is still a fair bit beyond my current experience

I just started reading "Compilers: Principles, Techniques, & Tools". I should be thru that in a few years, and ready to start hacking the source big time

Originally Posted by KBriggs

Yeah I saw that one. I would dearly love to get a good understanding of gcc's inner workings, but I suspect that it is still a fair bit beyond my current experience

If you understand x86 assembly language (even a little bit), you can always look at the code gcc is producing. Instead of the -c compile switch, use -S. gcc will produce a .s assembly file instead of a .o object file.

Adding the --fverbose-asm flag will insert some commentary into the code to make it (a little) easier to figure out what's what. With optimizations turned all the way up, the code can be difficult to map back to the source, but it's possible.

I do it a lot -- if you need guidance, ask.

Originally Posted by KBriggs

I don't know any assembly at all,

Niether do I, but I think it is fairly simple (then gets complicated fast). It is all sets of instructions like

MOV R1, varx

where "MOV" is the instruction, R1 is a destination register, then memory variables to apply this to (aside: I guess those are in the symbol table??)

so it could be:

ADD R1, R2, varx

which would be like, add R2+varx and store the result in R1.

Start with that and google. I'm sure there are some basic tutorials around...