Megol (golem960@gmail.com) on 1/14/11 wrote:
---------------------------
>Wilco (Wilco.Dijkstra@ntlworld.com) on 1/13/11 wrote:

>>There are multiple OSes and compilers in the x86 world. Then there is 32-bit vs
>>64-bit. So you end up porting your software anyway even when you stay in the x86 world.
>>
>Eh you don't see the difference between architectural portability and OS portability?
>Being portable between different operating systems is entirely a different matter.
>Algorithms and data structures are portable between x86 systems.

My point is that you cannot say that you do not need to think about portability at all in the x86 world. Sure, it is mostly OS portability, but x64 is definitely different in both aspects. Data structures often use compiler specific extensions for layout and so do need porting between compilers.

>>And making your software portable does not at all mean losing performance. Understanding
>>the issues will actually improve performance (eg. knowing that aligning data is good for performance on x86).
>>
>But that isn't true!

No, in general my claim is true. The fact there are a few cases where unaligned accesses can improve performance doesn't mean that making ALL aligned accesses unaligned will make code run faster.

>Look below at Richard Cownie's post. There are algorithms that can run faster on
>x86 because unaligned accesses are cheap! Within a cacheline they are very cheap,
>between cachelines they are reasonable, between aliased areas they are pretty expensive
>and between pages they can be expensive.
>Well optimized x86 code often use unaligned accesses because that's the fastest way!

So only in specific cases unaligned accesses are for free (within a portion of a cacheline). The same is true for ARM. But that doesn't mean they are faster in general, only in specific cases.

>I'm not talking about a single access, I'm talking of real code handling dynamic
>alignment in a input stream, how do you describe that in C?

If you can give me a concrete example I can explain how it's done.

>X86 != RISC processor with unaligned handling in a exception handler. Most unaligned cases are "free".

RISCs have used various techniques in the past, but nowadays it is done just like x86 (although on x86 they may be better optimized).

Wilco