Matteproblem i C

[AndersG]

Det skulle vara intressant att se på den genererade koden. Kan någon berätta hur man får MCC18 att putta ut en ASM fil spå man slipper syna .o filen?

[Icecap]

Alltså... 82 klockar för att flytta dessa bits. Sett överordnat ÄR det många men låt oss bena upp det lite.
8 flyttningar ger runt 10 klockar/bit. Det är 4 bytes, CARRY ska nollas inför varje flytt, indexpekare ska laddas osv så jag tror inte att det är C18 som knasar sig men vad jag vet är den "ej optimerande" utan betalt licens.

Antalet klockar för alla dessa operationer verkar mycket vettigt men "i programmet" är det mycket som kan kännas onödigt. En optimering hade kanske omvandlat det hela till att flytta 3 bytes och nolla en fjärde.

Och låt oss inte slåss om vem som har mest choklad på skjortan, det hela uppgår till att du (kanske) har ett underutnyttjat område i din AD-omvandlare, det första steg för att få full upplösning är just att minska upplösningen på ingångsvärden, i detta fall vid att expandera det använde AD-området. Och om det ger bättre upplösning att räkna med fler "decimaler" inblandat är självklart något man får kontrollera i varje fall, som du själv skriver är det inte entydigt värd det.

I vissa fall är det ett enkelt sätt att få allt man vill ha OCH undvika flyttal och deras långsamma rutiner, i andra fall kan det knappast löna sig då ingångsvärden knappast medger bättre upplösning.

[AndersG]

Äh.. Det var ju bara att öppna "Disassembly" fönstret. Märks att jag bara programmerat assembler på PIC de senaste halvåret:

Kod: Markera allt

4:                 void main(){
5:                 if( a == b)
   002    0100     MOVLB 0
   004    5162     MOVF 0x62, W, BANKED
   006    1960     XORWF 0x60, W, BANKED
   008    E102     BNZ 0xe
   00A    5163     MOVF 0x63, W, BANKED
   00C    1961     XORWF 0x61, W, BANKED
   00E    E103     BNZ 0x16
6:                 {
7:                   c = 1;
   010    0E01     MOVLW 0x1
   012    6F64     MOVWF 0x64, BANKED
   014    6B65     CLRF 0x65, BANKED
8:                 }
9:                 // ex2
10:                if(a^b == 0)
   016    5162     MOVF 0x62, W, BANKED
   018    1163     IORWF 0x63, W, BANKED
   01A    E002     BZ 0x20
   01C    0E00     MOVLW 0
   01E    D001     BRA 0x22
   020    0E01     MOVLW 0x1
   022    6E02     MOVWF 0x2, ACCESS
   024    6A03     CLRF 0x3, ACCESS
   026    BE02     BTFSC 0x2, 0x7, ACCESS
   028    6803     SETF 0x3, ACCESS
   02A    5160     MOVF 0x60, W, BANKED
   02C    1802     XORWF 0x2, W, ACCESS
   02E    6E00     MOVWF 0, ACCESS
   030    5161     MOVF 0x61, W, BANKED
   032    1803     XORWF 0x3, W, ACCESS
   034    6E01     MOVWF 0x1, ACCESS
   036    5000     MOVF 0, W, ACCESS
   038    1001     IORWF 0x1, W, ACCESS
   03A    E003     BZ 0x42
11:                { 
12:                  c = 1;
   03C    0E01     MOVLW 0x1
   03E    6F64     MOVWF 0x64, BANKED
   040    6B65     CLRF 0x65, BANKED
13:                }
14:                }

[dangraf]

När jag kör simulatorn i mplab så kan man få upp "disassemblylisting" där jag plockade ut koden för just shift operationen

Kod: Markera allt

2626    0E04     MOVLW 0x4
2628    CFDB     MOVFF 0xfdb, 0
262A    F000     NOP
262C    0E05     MOVLW 0x5
262E    CFDB     MOVFF 0xfdb, 0x1
2630    F001     NOP
2632    0E06     MOVLW 0x6
2634    CFDB     MOVFF 0xfdb, 0x2
2636    F002     NOP
2638    0E07     MOVLW 0x7
263A    CFDB     MOVFF 0xfdb, 0x3
263C    F003     NOP
263E    0E08     MOVLW 0x8
2640    90D8     BCF 0xfd8, 0, ACCESS
2642    3203     RRCF 0x3, F, ACCESS
2644    3202     RRCF 0x2, F, ACCESS
2646    3201     RRCF 0x1, F, ACCESS
2648    3200     RRCF 0, F, ACCESS
264A    06E8     DECF 0xfe8, F, ACCESS
264C    E1F9     BNZ 0x2640
264E    0E02     MOVLW 0x2
2650    C000     MOVFF 0, 0xfdb
2652    FFDB     NOP
2654    0E03     MOVLW 0x3
2656    C001     MOVFF 0x1, 0xfdb
2658    FFDB     NOP

All optimering är påslagen förutom "PROCEDURAL ABSTRACTION" som är den ena optimeringen som inte är tillgänglig i studentversionen. all anann otimering är tillgänglig i båda versionerna

klippt ur manualen:

PROCEDURAL ABSTRACTION
MPLAB C18, like most compilers, frequently generates code sequences that appear
multiple times in a single object file. This optimization reduces the size of the generated
code by creating a procedure containing the repeated code and replacing the copies
with a call to the procedure. Procedural abstraction is performed across all functions in
a given code section

tror ni att shift operationen hade otimerats på annat sätt om denna otimering var tillgänglig?

Det där med ^ måste jag erkänna att jag var lite för snabb på tangentbordet. Denna optimering gäller bara för 8-bitars tal, inte för 16-bitars.