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
