C, 24 bit i delar

[LHelge]

Personligen hade jag valt att slösa bort ytterligare en byte och hållt mig till något mer portabelt. Typ uint32_t.

[lillahuset]

Samma här. Short long. Vad är det för för namn? Varför inte medium?
Men Hitech gjorde förmodligen den första användbara C-kompilatorn till PIC. Jag har för mig att jag betalade 7000 kr för min. Men den var ungefär 1000 ggr bättre än smäcket från CCS jag köpte av Lawicel. Lars höll på att dö när jag meddelade att kompilatorn var så kass att jag övervägde att vägra betala fakturan. Jag tror han åldrades minst ett år då.

[baron3d]

Prestandamässigt så går en 24-bits nästan dubbelt så fort som en 32-bits.

[lillahuset]

Fascinerande men inget som skulle få mig att dumpa ANSI C. Lycka till med era 24 bits variabler.

[MiaM]

Saker som körs i en mikrokontroller är väl sällan så portabelt att det är lönsamt att hålla sig till c-standarder på den här typen av grejer?

Vilket namn skulle vara bättre?
I vanlig C är ju ordningen char <= short <= int <= long
Förvisso kunde de satt char = 8 bit, short = 16 bit, int = 24 bit och long = 32 bit, men det är som gjort för svårporterad kod.
Om det är så att char = 8, short och int = 16 och long = 32 så verkar väl faktiskt short long = 24 inte så ologiskt trots allt. Fördelen med att återanvända två redan definerade ord är att slippa krock mellan ett nytt kompilatorspecifikt reserverat ord (t.ex. "medium") och kod skriven av den som inte väntar sig specialare.

[Findecanor]

För att sen dividera med 256 är det enklaste att bara hämta byte1 och byte2 och låta bli byte0.
Annars kan man ju använda / eller högerskift >> åtta gånger.

En bra kompilator borde göra om >> 8 till att hämta ut byte'arna direkt ... om det går att göra på ett snabbt sätt.

Om snabbhet/liten kod är väldigt viktigt här så skulle jag föreslå att du skriver några olika varianter -- förslagsvis varje variant i sin egen funktion. Sen kollar du vad det är för maskinkod som du får ut och väljer den variant som producerat bäst maskinkod.

[persika]

Jag har gjort 4 st olika prov:
1: a.hela /= 255 Kompilatorn gör det med en divisionsrutin. (OBS! 255)
2: a.hela /= 256 Kompilatorn är här smart och gör det med 8 st högerskift
3: a.hela /= 256 Varianten med att hämta del-byte.
4: a.hela /= 256 Samma som föregående, fast delvis i asm, optimiserad.

Övriga förutsättningar som ovan i tråden.

---------------------------------------------------------------------------
1:

Totalt programminne: 123 byte
Totalt dataminne: 18 byte
Antal instruktionscykler för division: 899

Kod: Markera allt

17:                #include "datatyper.h"
18:                
19:                
20:                void main(void)
21:                {
22:                uInt24y a;
23:                
24:                a.hela = 123456;
  078F    3040     MOVLW 0x40
  0790    00FB     MOVWF 0x7b
  0791    30E2     MOVLW 0xe2
  0792    00FC     MOVWF 0x7c
  0793    3001     MOVLW 0x1
  0794    00FD     MOVWF 0x7d
25:                a.hela /= 255;
  0795    30FF     MOVLW 0xff
  0796    00F0     MOVWF 0x70
  0797    3000     MOVLW 0
  0798    00F1     MOVWF 0x71
  0799    3000     MOVLW 0
  079A    00F2     MOVWF 0x72
  079B    087B     MOVF 0x7b, W
  079C    00F3     MOVWF 0x73
  079D    087C     MOVF 0x7c, W
  079E    00F4     MOVWF 0x74
  079F    087D     MOVF 0x7d, W
  07A0    00F5     MOVWF 0x75
  07A1    3187     MOVLP 0x7
  07A2    27AC     CALL 0x7ac
  07A3    3187     MOVLP 0x7
  07A4    0870     MOVF 0x70, W
  07A5    00FB     MOVWF 0x7b
  07A6    0871     MOVF 0x71, W
  07A7    00FC     MOVWF 0x7c
  07A8    0872     MOVF 0x72, W
  07A9    00FD     MOVWF 0x7d
26:                }
  07AA    3180     MOVLP 0

2:

Totalt programminne: 24 byte
Totalt dataminne: 7 byte
Antal instruktionscykler för division: 48

Kod: Markera allt

17:                #include "datatyper.h"
18:                
19:                
20:                void main(void)
21:                {
22:                uInt24y a;
23:                
24:                a.hela = 123456;
  07F2    3040     MOVLW 0x40
  07F3    00F0     MOVWF 0x70
  07F4    30E2     MOVLW 0xe2
  07F5    00F1     MOVWF 0x71
  07F6    3001     MOVLW 0x1
  07F7    00F2     MOVWF 0x72
25:                a.hela /= 256;
  07F8    3008     MOVLW 0x8
  07F9    36F2     LSRF 0x72, F
  07FA    0CF1     RRF 0x71, F
  07FB    0CF0     RRF 0x70, F
  07FC    0B89     DECFSZ 0x9, F
  07FD    2FF9     GOTO 0x7f9
26:                }
  07FE    3180     MOVLP 0

3:

Totalt programminne: 27 byte
Totalt dataminne: 8 byte
Antal instruktionscykler för division: 9

Kod: Markera allt

17:                #include "datatyper.h"
18:                
19:                
20:                void main(void)
21:                {
22:                uInt24y a;
23:                
24:                a.hela = 123456;
  07EF    3040     MOVLW 0x40
  07F0    00F1     MOVWF 0x71
  07F1    30E2     MOVLW 0xe2
  07F2    00F2     MOVWF 0x72
  07F3    3001     MOVLW 0x1
  07F4    00F3     MOVWF 0x73
25:                
26:                // a.hela /= 256;  
27:                a.byte0 = a.byte1;
  07F5    0872     MOVF 0x72, W
  07F6    00F0     MOVWF 0x70
  07F7    0870     MOVF 0x70, W
  07F8    00F1     MOVWF 0x71
28:                a.byte1 = a.byte2;
  07F9    0873     MOVF 0x73, W
  07FA    00F0     MOVWF 0x70
  07FB    0870     MOVF 0x70, W
  07FC    00F2     MOVWF 0x72
29:                a.byte2 = 0;
  07FD    01F3     CLRF 0x73
30:                }
  07FE    3180     MOVLP 0

4:

Totalt programminne: 23 byte
Totalt dataminne: 7 byte
Antal instruktionscykler för division: 5
Optimiserad, tagit bort den onödiga mellanlagringen i register 0x70

Kod: Markera allt

17:                #include "datatyper.h"
18:                
19:                
20:                void main(void)
21:                {
22:                uInt24y a;
23:                
24:                a.hela = 123456;
  07F3    3040     MOVLW 0x40
  07F4    00F0     MOVWF 0x70
  07F5    30E2     MOVLW 0xe2
  07F6    00F1     MOVWF 0x71
  07F7    3001     MOVLW 0x1
  07F8    00F2     MOVWF 0x72
25:                
26:                // a.hela /= 256;  
27:                // a.byte0 = a.byte1;
28:                  asm( "MOVF 0x72, W" );
  07F9    0872     MOVF 0x72, W
29:                  asm( "MOVWF 0x71" );
  07FA    00F1     MOVWF 0x71
30:                // a.byte1 = a.byte2;
31:                  asm( "MOVF 0x73, W" );
  07FB    0873     MOVF 0x73, W
32:                  asm( "MOVWF 0x72" );
  07FC    00F2     MOVWF 0x72
33:                // a.byte2 = 0;
34:                  asm( "CLRF 0x73" );
  07FD    01F3     CLRF 0x73
35:                }
  07FE    3180     MOVLP 0