Oberon Community Platform Forum
November 22, 2019, 05:52:20 PM *
Welcome, Guest. Please login or register.
Did you miss your activation email?

Login with username, password and session length
News:
 
   Home   Help Search Login Register  
Pages: [1]
  Print  
Author Topic: Data alignment  (Read 4282 times)
sage
Full Member
***
Posts: 170



WWW
« on: September 01, 2008, 02:07:36 PM »

I plan to implement some pieces of ray-tracing renderer using SIMD, and encounter the problem that compiler don't deals well with data alignment. And when SIMD instructions deals with unaligned data it leads to poor perfomance.
Is it the only possible and the best technique to check alignment programmatically as in following snippet from I386.ArrayBaseOptimized.Mod?
Code:
...
          ;  check FOR alignment
          MOV     ESI, EBX     ; 
          AND     ESI, 7     ;  ladr MOD 8
          CMP     ESI, 0     ;  = 0- > 64 Bit alignment
          JNE     unaligned     ;  not 64 bit aligned
          MOV     ESI, ECX     ; 
          AND     ESI, 7     ;  radr MOD 8
          CMP     ESI, 0     ;  = 0- > 64 Bit alignment
          JNE     unaligned     ;  not 64 bit aligned
          MOV     ESI, EDX     ; 
          AND     ESI, 7     ;  dadr MOD 8
          CMP     ESI, 0     ;  = 0- > 64 Bit alignment
          JNE     unaligned     ;  not 64 bit aligned
          MOV     ESI, EBX     ; 
          AND     ESI, 8     ;  16 byte alignment
          MOV     EDI, ECX     ; 
          AND     EDI, 8     ;  16 byte alignment
          CMP     ESI, EDI     ; 
          JNE     unaligned     ;  different 16 byte = 128 bit alignment OF ladr and radr
          MOV     EDI, EDX     ; 
          AND     EDI, 8     ;  16 byte alignment
          CMP     ESI, EDI     ; 
          JNE     unaligned     ;  different 16 byte = 128 bit alignment OF dadr and radr
          CMP     ESI, 8     ; 
          JNE     aligned     ;  lad, radr and dadr already 128 bit aligned
          ;  one single element processing TO achieve 128 bt alignment
          MOVSD     XMM1, [EBX]     ; 
          MOVSD     XMM0, [ECX]     ; 
          ADDSD     XMM0, XMM1     ; 
          MOVSD     [EDX], XMM0     ; 
          ADD     EBX, 8     ;  now EBX IS 16 byte aligned
          ADD     ECX, 8     ;  now EDX IS 16 byte aligned     ; 
          ADD     EDX, 8     ;  now EDX IS 16 byte aligned     ; 
          DEC     EAX     ;  one element has been processed
          aligned:
          MOV     ESI, alignedC     ; 
          INC     ESI     ; 
          MOV     alignedC, ESI     ; 
          aligned8:
          CMP     EAX, 8     ; 
          JL     aligned2     ;  len < 4- > EXIT TO singlepieces
          MOVAPD     XMM0, [EBX]     ; 
          MOVAPD     XMM1, 16[EBX]     ; 
          MOVAPD     XMM2, 32[EBX]     ; 
          MOVAPD     XMM3, 48[EBX]     ; 
          ADD     EBX, 64     ; 
          MOVAPD     XMM4, [ECX]     ; 
          MOVAPD     XMM5, 16[ECX]     ; 
          MOVAPD     XMM6, 32[ECX]     ; 
          MOVAPD     XMM7, 48[ECX]     ; 
          ADD     ECX, 64     ; 
          ADDPD     XMM0, XMM4     ; 
          ADDPD     XMM1, XMM5     ; 
          ADDPD     XMM2, XMM6     ; 
          ADDPD     XMM3, XMM7     ; 
          MOVAPD     [EDX], XMM0     ; 
          MOVAPD     16[EDX], XMM1     ; 
          MOVAPD     32[EDX], XMM2     ; 
          MOVAPD     48[EDX], XMM3     ; 
          ADD     EDX, 64     ; 
          SUB     EAX, 8     ; 
          JMP     aligned8     ; 
          ;  LOOP FOR 2 pieces aligned
          aligned2: ; 
          CMP     EAX, 2     ; 
          JL     singlepieces     ;  len < 2- > EXIT TO singlepieces
          MOVAPD     XMM0, [EBX]     ; 
          ADD     EBX, 16     ; 
          MOVAPD     XMM1, [ECX]     ; 
          ADD     ECX, 16     ; 
          ADDPD     XMM0, XMM1     ; 
          MOVAPD     [EDX], XMM0     ; 
          ADD     EDX, 16     ; 
          SUB     EAX, 2     ; 
          JMP     aligned2     ; 
          ;  LOOP FOR 8 unaligned pieces(14 pieces not better!)
          unaligned: ; 
          MOV     ESI, unalignedC     ; 
          INC     ESI     ; 
          MOV     unalignedC, ESI     ; 
          unaligned8: ; 
          CMP     EAX, 8     ; 
          JL     unaligned2     ;  len < 4- > EXIT TO singlepieces
          MOVUPD     XMM0, [EBX]     ; 
          MOVUPD     XMM1, 16[EBX]     ; 
          MOVUPD     XMM2, 32[EBX]     ; 
          MOVUPD     XMM3, 48[EBX]     ; 
          ADD     EBX, 64     ; 
          MOVUPD     XMM4, [ECX]     ; 
          MOVUPD     XMM5, 16[ECX]     ; 
          MOVUPD     XMM6, 32[ECX]     ; 
          MOVUPD     XMM7, 48[ECX]     ; 
          ADD     ECX, 64     ; 
          ADDPD     XMM0, XMM4     ; 
          ADDPD     XMM1, XMM5     ; 
          ADDPD     XMM2, XMM6     ; 
          ADDPD     XMM3, XMM7     ; 
          MOVUPD     [EDX], XMM0     ; 
          MOVUPD     16[EDX], XMM1     ; 
          MOVUPD     32[EDX], XMM2     ; 
          MOVUPD     48[EDX], XMM3     ; 
          ADD     EDX, 64     ; 
          SUB     EAX, 8     ; 
          JMP     unaligned8     ; 
          ;  LOOP FOR 2 pieces aligned
          unaligned2: ; 
          CMP     EAX, 2     ; 
          JL     singlepieces     ;  len < 2- > EXIT TO singlepieces
          MOVUPD     XMM0, [EBX]     ; 
          ADD     EBX, 16     ; 
          MOVUPD     XMM1, [ECX]     ; 
          ADD     ECX, 16     ; 
          ADDPD     XMM0, XMM1     ; 
          MOVUPD     [EDX], XMM0     ; 
          ADD     EDX, 16     ; 
          SUB     EAX, 2     ; 
          JMP     unaligned2     ; 
          ;  one piece left OR non-contiguous data
          single:
          MOV     ESI, singleC     ; 
          INC     ESI     ; 
          MOV     singleC, ESI     ; 
          singlepieces: ; 
          CMP     EAX, 0     ; 
          JLE     endL     ;  len <= 0- > EXIT
          MOVSD     XMM0, [EBX]
          ADD     EBX, linc[EBP]     ;  INC(ladr, incl)
          MOVSD     XMM1, [ECX]
          ADD     ECX, rinc[EBP]     ;  INC(ladr, incl)
          ADDSD     XMM0, XMM1     ; 
          MOVSD     [EDX], XMM0
          ADD     EDX, dinc[EBP]     ;  INC(radr, incr)
          DEC     EAX     ;  DEC(len)
...
So, if compiler will be able to provide automatic data alignment it will simplyfy the needed assembler code and make it more short and readable. Right?
So, why alignment still not implemented?
Probably, some alignment directives may be incorporateted to language, for example:
{ALIGN64}, {ALIGN128}, {ALIGN256}, ... and so on.
It will be nice if we will able to write something like:
Code:
TYPE
Vector = RECORD
x, y, z, dummy: REAL; (* SSE operates with 4 REALs in each of XMM register *)
END;
VAR
v1, v2, v3 : {ALIGN128} Vector;
va : ARRAY 10 OF {ALIGN128} Vector;
Any suggestions?

PS. Or better qualify alignment for types...
Code:
TYPE
Vector = {ALIGN128} RECORD
x, y, z, dummy: REAL; (* SSE operates with 4 REALs in each of XMM register *)
END;
« Last Edit: September 08, 2008, 07:47:58 AM by sage » Logged
Pages: [1]
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.21 | SMF © 2015, Simple Machines Valid XHTML 1.0! Valid CSS!