Hur snabbare är uint vs float?

[DanielM]

Det tror jag inte. CubeMX är ganska tunt. Allt beror på vad man lägger dit.

Jag ska köra några simuleringar med MATLAB kod, och sedan visa vad jag ska använda för att lösa Ax=b.

Du skriver själv att det var två trådar och LCD-hantering, det innebär att det måste ligga ett RTOS i botten, oavsett vad du tror eller inte.

Men det har med att jag manuellt valde RTOS i botten. Det är ett tillval

[TomasL]

Dåså, då får du acceptera att du inte kan köra fullt ut, eftersom det hela tiden sker en switch mellan trådarna, och beroende på processor tar det tid.

[DanielM]

Om jag använder matrix algebra så kommer jag inte använda mig utav RTOS.

[TomasL]

Tja, om du skall hantera flera processer "samtidigt" behöver du ett "RTOS", må vara en enkel scheduler eller ett riktigt RTOS

[TomasL]

Oavsett, till ursprungsfrågan, uint är alltid oerhört mycket snabbare än en float.
Det enda tillfället är om du har en FPU och kan göra annat medans FPUn beräknar, å andra sidan, FPUn kan inte hantera mer än en uppsättning värden åt gången, så du måste ladda FPUn vänta eller göra annat, hämta resultatet, ladda med nästa uppsättning värden, osv.

[DanielM]

Jag funderar på unit istället för float.
Det jag ska göra är att konvertera om denna kod till C-kod. Här gäller det att minska alla instruktioner så mycket det går.

Vad denna kod gör är att den löser \(Ax=b\), men \(x\) är gles.

Varför just gles? Vad ska man ha det till?
Jo, för att vektorn \(x\) kan man använda för att indikera index på speciell data.

Låt oss säga att \(b\) är en bildvektor och \(A\) innehåller bildvektorer och du vet exakt vilket kolumn-index som tillhör bilderna.
När man löser \(Ax=b\) så kan man få reda på \(x\). Med tanke på att \(x\) är gles, dvs innehåller bara nollor och vissa stora tal, då kan man räkna ut vart dessa stora tal är och då vet man vilket index som bilden \(b\) tillhör.

Nackdel med denna metod. Den kräver beräkningar hela tiden, till skillnad från ett CNN-nätverk.
Fördel med denna metod. Den kräver ingen förträning som ett CNN-nätverk kräver. Att få ett pålitligt CNN-nätverk kan ta många dagar att få ihop med tanke på att den kräver väldigt mycket data.
En annan fördel med glesa vektorn är att precision är inte nödvändigt här. Viktigaste är att vektorn är gles.

Kod: Markera allt

function test2()
  lambda = 0.15;
  A = [1 2 3 4 5 6 7 8 9 10; 4 1 5 6 0 2 5 6 2 10; 3 5 6 1 6 8 4 2 9 5; 2 4 5 6 2 1 7 9 6 4];
  b = 1:4;
  b = b';
  x1 = linsolve(A, b)
  x2 = stls_regression(A, b, lambda)
  b1 = A*x1
  b2 = A*x2
end

function x = stls_regression(A, b, lambda)
  x = linsolve2(A, b);
  state_dimension = size(b, 2);
  for k=1:20
      smallinds = (abs(x)<lambda);     
      x(smallinds) = 0;                 
      for ind = 1:state_dimension         
        biginds = ~smallinds(:,ind);
        x(biginds,ind) = linsolve2(A(:,biginds),b(:,ind));
      end
  end
end

function x = linsolve2(A, b)
  [A, b] = backsubstitution(A'*A, A'*b);
  x = solveUp(A, b);  
end

function [x] = solveUp(A, b)
  s = length(A);
  x = zeros(s,1);
  x(s) = b(s)/A(s,s);
  for i = s-1:-1:1
    sum = 0;
    for j = s:-1:i+1
      sum = sum + A(i,j)*x(j);
    end
    x(i) = (b(i)- sum)/A(i,i);
  end
end

function [A, b] = backsubstitution(A, b)
  s = length(A);
  for j = 1:(s-1)
    for i = s:-1:j+1
      m = A(i,j)/A(j,j);
      A(i,:) = A(i,:) - m*A(j,:);
      b(i) = b(i) - m*b(j);
    end
  end
end

[TomasL]

Här gäller det att minska alla instruktioner så mycket det går.

Då måste du skriva i assembler, eftersom alla kompilatorer, oavsett om det är C eller inte, fullständigt skiter i vad du tycker.
Du kan naturligtvis slå på optimering, dock går det oftast inte att debugga koden då, och kompilatorn gör fortfarande vad den tycker är bäst, oavsett vad du tycker.
Tidskritisk kod skrivs alltid i assembler.

[DanielM]

Jag ska göra en simulering först med bilder för att avgöra hur tidskritiskt det är.

[Rick81]

Rätt svar får du genom denna kod:

Kod: Markera allt

uin32_t ticks = HAL_GetTick();
RunCalculationFloat()
printf("Float tid %d ms", HAL_GetTick() - ticks);

ticks = HAL_GetTick();
RunCalculationInt()
printf("Int tid %d ms", HAL_GetTick() - ticks);

Vill du ha uppskattning utan implementera koden så ser du här:
https://developer.arm.com/documentation ... uction-set

Int32:
* Addition - 1 klockcykel
* Subtraktion - 1 klockcykel
* Multiplikation - 1 klockcykel
* Division - 2-12klockcykler

float;
* Addition - 1 klockcykel
* Subtraktion - 1 klockcykel
* Multiplikation - 1 klockcykel
* Division - 14 klockcykler

Så ytterst tveksamt om du tjänar något märkbart på att köra int istället för float, så vida du inte bara gör en massa divisioner.

[DanielM]

Jag gör några divisioner, men mesta är bara multiplikation till 95%.

Ja, där har vi svaret. Tackar Rick81! Du löste verkligen "Hur långt är ett snöre"-frågan

[AndLi]

För M4 plattformen ja, är det den plattformen du kommer byta till? Tidigare har du väl använt M3 baserade enheter? Gäller samma tabell för dem?

[Rick81]

Aha missade TS bytt från M4 till M3...

Men STM32F3 har ju en M4 cortex kärna.

[AndLi]

Det verkar vara jag som förvirrat mig mellan STM32 familjerna och vilka som använder M3 resp M4, jag hade för mig att M3 användes i högre serier än F2...

[DanielM]

Själv har jag ingen aning hur man ska tolka M3, M4 osv. Jag kollar bara på vilka periferier som processorn har och minne samt klockfrekvens.

[hummel]

Du får läsa på om ARMs olika arkitekturer, står mycket väl dokumenterat hos ARM och ST!