---

Hejsa

Hvad betyder "double-word aligned" ?

Jeg er igang med at lege lidt med en autokorrelations-funktion som ligger i
et bibliotek og får ingen fejl når jeg compiler, men resultatet (altså den
udregnede autokorrelation) er forkert.

Her er koden:

#include "dspf_sp_autocor.h"

void main()
{

int nr=16;
int nx=16;

float r[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
float x[16]={1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0};

DSPF_sp_autocor (r,x,nx, nr);
while(1);
}


Er der nogen der kan fortælle mig hvad jeg gør forkert?

Dokumentationen for funktionen står på side 29 i følgende PDF:

http://users.cybercity.dk/~dsl159353/USERGUIDE.pdf

Tak

---

> Hvad betyder "double-word aligned" ?

Jeg vil gætte på at der menes 8-bytes alignment. Det kan man sætte op i
compileren, f.eks. i MSVC hedder det struct member alignment.

Leo Havmøller.

---

Leo Havmøller wrote:
>>Hvad betyder "double-word aligned" ?
> Jeg vil gætte på at der menes 8-bytes alignment. Det kan man sætte op i
> compileren, f.eks. i MSVC hedder det struct member alignment.

Et word er 2 bytes, så double-word er altså 4 bytes. 8 bytes hedder
quad-word. Double-word alignment betyder altså at 4 går op i variablens
adresse.

Ivan Johansen

---

Hej

Jeg har lavet programmet lidt om nu. Får ingen compilerfejl og ingen
warnings, men
resultatet er stadigvæk forkert....Kan I hjælpe?

Her er sourcekoden:

#include "dspf_sp_autocor.h"

struct Auto
{
float r;
const float x;
};

void main()
{

int nr=16;
int nx=16;

float r[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
const float x[16]={1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0};

DSPF_sp_autocor(r,x,nx, nr);

while(1);
}

----------------------------------------


> Et word er 2 bytes, så double-word er altså 4 bytes. 8 bytes hedder
> quad-word. Double-word alignment betyder altså at 4 går op i variablens
> adresse.
>
> Ivan Johansen

---

Joe wrote:
> Jeg har lavet programmet lidt om nu. Får ingen compilerfejl og ingen
> warnings, men
> resultatet er stadigvæk forkert....Kan I hjælpe?

Prøv at læse dokumentationen en gang til.

> int nr=16;
> int nx=16;
>
> float r[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
> const float x[16]={1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0};
>
> DSPF_sp_autocor(r,x,nx, nr);

For x står der:
"Pointer to input array of length nx+nr. Input data must be
padded with nr consecutive zeros at the beginning."

I din kode har x ikke en længde på nx+nr=32 og det starter heller ikke
med nr=16 nuller.

Ivan Johansen

---

Hej

Tak skal du ha....Jeg har rettet koden til så der nu står:

#include "dspf_sp_autocor.h"
void main()
{
// length nr, length multiple of 4
float r_out[12]={0,0,0,0,0,0,0,0,0,0,0,0};
// length nx+nr, zeropad with nr zeros, length multiple of 2
float x_in[20]={0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8};
DSPF_sp_autocor(r_out,x_in,20,12);
while(1);
}

Jeg har checket i memory og der står følgende resultat:

204,168,133,118,70,44,23,16

Resultatet '118' og '16' er forkert. Er der nogen der kan gennemskue
hvorfor?

Matlab siger at autokorrelationen for vektoren:

x=[1 2 3 4 5 6 7 8]

er:

204,168,133,100,70,44,23,8


Tak på forhånd..

-----------------------------------



>
> Prøv at læse dokumentationen en gang til.
>
> For x står der:
> "Pointer to input array of length nx+nr. Input data must be
> padded with nr consecutive zeros at the beginning."
>
> I din kode har x ikke en længde på nx+nr=32 og det starter heller ikke med
> nr=16 nuller.
>
> Ivan Johansen

---

Joe wrote:
> Jeg har checket i memory og der står følgende resultat:
>
> 204,168,133,118,70,44,23,16
>
> Resultatet '118' og '16' er forkert. Er der nogen der kan gennemskue
> hvorfor?
>
> Matlab siger at autokorrelationen for vektoren:
>
> x=[1 2 3 4 5 6 7 8]
>
> er:
>
> 204,168,133,100,70,44,23,8

Ud fra dokumentationen ser det ud til at Matlab har ret. Prøv at
kontrollere at alignment i compileren er sat til double-word (4 bytes).
Prøv eventuelt med andre tal for at se om det altid er de samme
placeringer som er forkerte.

Ivan Johansen

---

"Joe" <JoeNOSPAM@yahoo.com> wrote in message
news:429ba54c$0$78279$157c6196@dreader1.cybercity.dk...
> Hejsa
>
> Hvad betyder "double-word aligned" ?

double word er 4 bytes.
Hvis en variabel eller struktur are "double-word aligned" betyder at dens
adresse er delelig med 4.

Hardware mæssigt betyder det at hvis CPU'en har 32 bit databus, så en kan et
double-word hentes på een gang hvis den er double-word aligned.
Hvis den ikke er double-word aligned så skal den hentes af 2 gange og sættes
sammen.
Nogle 32 bit CPU'er kan slet ikke hente en 32 bit integer hvis den ikke er
double-word aligned - det giver "bus error" og stopper processoren.

Generelt vil compileren sikre at man overholder CPU'ens krav til alignment,
men man _kan_ snyde den:
void* vp = something();
(float*) vp = 13.5; // Alignment ???

Alignment i strukturer kan typisk styres med compiler options..

[8<8<8<]
> void main()

"main" returnerer int - og har altid gjort det

> {
>
> int nr=16;
> int nx=16;
>
> float r[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
> float x[16]={1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0};

Hvorfor bruger du ikke "nr" og "nx" når de er defineret ?
Eller endnu bedre: lader compileren beregne array størrelsen for dig - den
er bedre til det og man slipper af med redundant kode der skal
vedligeholdes:
float r[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
float x[]={1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0};

int nr=sizeof(r)/sizeof(r[0]);
int nx=sizeof(x)/sizeof(x[0]);

[8<8<8<]
> Er der nogen der kan fortælle mig hvad jeg gør forkert?

Der læser dokumentationen forkert

>
> Dokumentationen for funktionen står på side 29 i følgende PDF:
>
> http://users.cybercity.dk/~dsl159353/USERGUIDE.pdf

Der står:
x Pointer to input array of length nx+nr. Input data must be
padded with nr consecutive zeros at the beginning.

int main()
{
float r[]={0,0,0,0,0,0,0,0}; // result array
float d[]={1,2,3,4,5,6,7,8}; // data array
float x[sizeof(r)/sizeof(r[0]) + sizeof(d)/sizeof(d[0])]; // extra
array
int nr=sizeof(r)/sizeof(r[0]);
int nd=sizeof(d)/sizeof(d[0]);
int i;
for(i = 0; i != nr; ++i)
x[i] = 0;
for(i = 0; i != nd; ++i)
x[nr+i] = d[i];

DSPF_sp_autocor (r,x,nr, nd);

return 0;
}

eller
int main()
{
float r[]={0,0,0,0,0,0,0,0};
float x[] = {0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8};
int nr=sizeof(r)/sizeof(r[0]);
int nx=sizeof(x)/sizeof(x[0]) - nr;

DSPF_sp_autocor (r,x,nr, nx);

return 0;
}

så er det program vist enig med Mathlab.

Venlig hilsen

Mogens Hansen

---

Hej Mogens

Først vil jeg lige sige tak for den engagerede indsats....det er sgu dejligt
at der findes mennesker som dig

Jeg har prøvet koden, men jeg får følgende resultat i memory:

7,20,38,70,85,112,140

Matlab svarer:

204,168,133,100,70,44,23,8

Jeg kan altså ikke forstå hvad der går galt?

Håber at det er et problem der kan løses?

---

fik det endelig løst.....her er den korrekte source-kode --- man ved jo
aldrig om der er andre der på et tidspunkt får samme problem

#include "dspf_sp_autocor.h"

#pragma DATA_ALIGN(r_out, 8)
// length nr, length multiple of 4
float r_out[12]={0,0,0,0,0,0,0,0,0,0,0,0};

#pragma DATA_ALIGN(x_in, 8)
// length nx+nr, zeropad with nr zeros, length multiple of 2
float x_in[20]={0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8};

void main()
{
DSPF_sp_autocor(r_out,x_in,20,12);
while(1);
}

---

forstår dog ikke hvorfor jeg skal bruge "8" som align-argument??!?!


>
> #pragma DATA_ALIGN(r_out, 8)
> // length nr, length multiple of 4
> float r_out[12]={0,0,0,0,0,0,0,0,0,0,0,0};
>
>

---

Hej Joe.

> forstår dog ikke hvorfor jeg skal bruge "8" som align-argument??!?!

>> #pragma DATA_ALIGN(r_out, 8)
>> // length nr, length multiple of 4
>> float r_out[12]={0,0,0,0,0,0,0,0,0,0,0,0};

Det er fordi CPU'en du arbejder med har en word størrelse på 32 bit, så i
denne arkitektur er en doubleword grænse 64 bit eller 8 bytes.
Det står faktisk bag i dokumentet du henviser til i din første mail.

Faktisk er det en mere korrekt (oprindelig) anvendelse af WORD begrebet, end
den der har fået udbredelse via de gamle PC compilere hvor words var 16 bit.
For WORD betegner traditionelt den bitbredde det er mest naturligt for CPU
arkitekturen at bearbejde.

Vore dages PC'er har også en naturlig WORD størrelse på 32 bit, men mange
gør lige som Mogens og sætter lighedstegn mellem begrebet WORD og 16 uanset
hvilken arkitektur der er tale om.
Det er nok ikke fair at bebrejde nogen denne anvendelse af begrebet WORD,
men det er altså et begreb man sagtens kan risikere har en anden værdi end
hvad man ville forvente.

med venlig hilsen
Jesper Wolf Jespersen