ATNEL tech-forum

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-07T12:47:24+01:00

Dzięki Panowie, na razie skupię się na tym co napisał Kolega andrews.
Podejmę kolejną próbę przerobienia poradnika o wstawkach asemblerowych, bo czuję, że ten sposób podejścia do asemblera chyba mi najbardziej pasuje.
Spróbuję napisać plik .S z funkcją bazową tak by był czymś w rodzaju biblioteki do reszty projektu.

Statystyki: Napisane przez Zealota — 7 paź 2017, o 12:47

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T16:42:14+01:00

mirekk36 napisał(a):

Zealota napisał(a):

kod, który piszę na pewno jest mało optymalny

Ale ta funkcja którą tu pokazałeś WCALE nie jest mało optymalna ... sporo osób robi to w pętli, przy okazji przesuwając bit w zmiennej - i sprawdzając go ... ale to zawsze jest o wiele bardziej czasochłonne niż rozbicie tego na IF() jak zrobiłeś ponieważ to da o wiele optymalniejszy kod więc w jakiś sposób podświadomie to czujesz

A bo właśnie tego nauczyłem się z poradników, głównie tych o magic ledach
Bardziej pisałem o "reszcie kodu"
Zresztą, za niedługo, całość opublikuję na forum,to będzie można się zastanowić nad dodatkowymi optymalizacjami.
Sprzęt już działa, ale próbuję wycisnąć jeszcze co się da.

Statystyki: Napisane przez Zealota — 6 paź 2017, o 16:42

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T16:27:44+01:00

Ja sobie tak myślę że skoro i tak wykorzystujesz 4bity (młodsze) portu które są obok siebie to zamiast robić to na ifach, mógłbyś przypisać starszą połówkę *data po odwróceniu bitów bezpośrednio do portu. Jak szybko to zrobić? zrobic lookup table z 16 wartosciami np:

uint8_t tab[16] =
{
0,
8,
4,
12,
2,
10,
6,
14,
1,
9,
5,
13,
3,
11,
7,
15

};

wtedy odwołujesz się po indeksie i masz odwrócony bajt.

Statystyki: Napisane przez Nefarious19 — 6 paź 2017, o 16:27

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T15:51:31+01:00

Pisząc w asm, każdą z ośmiu sekwencji trwającą 5 lub 6 taktów zegara:
[syntax=asm]// w rejestrze r24 jest załadowana wartość
// wskazywana przez argument 'data'
80: 87 ff sbrs r24, 7 // 1 takt | 2 takty
82: 02 c0 rjmp .+4 // 2 takty |
84: c0 9a sbi 0x18, 0 // | 2 takty
86: 01 c0 rjmp .+2 // | 2 takty
88: c0 98 cbi 0x18, 0 // 2 takty |
// łącznie 5 taktów | 6 taktów
// i tak dla każdego z 8 bitów (czyli łącznie 48 taktów)[/syntax]
można zastąpić (przy założeniu, że wszystkie bity ustawiamy na jednym porcie i żadna procedura obsługi przerwania nie modyfikuje w międzyczasie rejestru PORTB):
[syntax=c]// w rejestrze r24 jest załadowana wartość wskazywana przez argument 'data'
// przeznaczamy np. rejestr r16 na przygotowanie wartości całego portu
in r16, PORTB // 1 takt
// powyższą sekwencję zmieniamy na
bst r24, 7 // 1 takt
bld r16, 0 // 1 takt
// łącznie 2 takty
// dla 8 bitów łącznie 16 taktów

// przygotowany rejestr r16 wpisujemy do portu
out PORTA, r16[/syntax]
Dodatkową zaletą takiego rozwiązania w niektórych przypadkach może być to, że wszystkie bity portu są zmieniane jednocześnie.
Niezależnie od tego, czy tu jest to istotne, czy nie, myślę że tu może się znaleźć pole do popisu dla asemblera.

Niestety wstawek inline assembler nie lubię pisać, więc nie wyręczę w tym względzie
Można zamiast tego skorzystać z mojego poradnika (Miksowanie kodu C i ASM przy użyciu GCC) i napisać taką funkcję w osobnym pliku.

_________________
AVR-GCC - dane w pamięci FLASH

Statystyki: Napisane przez andrews — 6 paź 2017, o 15:51

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T15:02:02+01:00

Zealota napisał(a):

kod, który piszę na pewno jest mało optymalny

Statystyki: Napisane przez mirekk36 — 6 paź 2017, o 15:02

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T14:49:38+01:00

Na razie dzięki za szczegółowy opis, temat podejmę dopiero wieczorem.
Na szybko:
- temat asemblera do tej pory "odrzucałem", ale czasem podglądam .lss i poradniki i coś za mgłą jest
- Gadżeta używam, ale rzadko, bo niestety nie chce u mnie działać z workspace, który jest na dysku sieciowym i gdy jestem zmuszony przerzucam projekty na dysk lokalny.
- kod, który piszę na pewno jest mało optymalny ale projekt na nim oparty muszę kończyć wreszcie i stąd desperackie próby "przyspieszenia", choć to trochę w ramach takiego testu i ostatecznej próby wzięcia byka za rogi (tzn asm)
- poradniki o asm oglądałem, ale niestety poddawałem się szybko, być może po tym wątku przełamię się

Statystyki: Napisane przez Zealota — 6 paź 2017, o 14:49

Re: Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T13:55:57+01:00

ja tak z marszu sam nigdy nie pamiętam ale wtedy też sam zaglądam do swoich poradników - a czy widziałeś może ten ?

https://www.youtube.com/watch?v=4jIIOERYnwY

Poza tym, kod który pokazałeś można jeszcze nieco zoptymalizować w C a co za tym idzie także w asemblerze ...

Ale zanim coś zaproponuję to zapytam bo nie pamiętam ? czy ty piszesz dobrze programy w asemblerze ? czujesz się w nim jak ryba w wodzie? Dlaczego pytam? Bo jeśli nie do końca czujesz się dobry w ASM to niestety swoją wstawką możesz to niechcący zrobić np gorzej (dłużej) niż to zrobi sam C ....

dlatego kolejne pytanie - czy sprawdzałeś plik *.lss i jak wygląda kod tej funkcji po kompilacji do ASM ? czy uważasz, że można go skrócić ? Moim zdaniem jest dość bardzo optymalny proszę:
[syntax=asm]0000007c :
7c:fc 01 movwr30, r24
7e:db 01 movwr26, r22
80:80 81 ldr24, Z
82:87 ff sbrsr24, 7
84:02 c0 rjmp.+4 ; 0x8a
86:c0 9a sbi0x18, 0; 24
88:01 c0 rjmp.+2 ; 0x8c
8a:c0 98 cbi0x18, 0; 24
8c:80 81 ldr24, Z
8e:86 ff sbrsr24, 6
90:02 c0 rjmp.+4 ; 0x96
92:c1 9a sbi0x18, 1; 24
94:01 c0 rjmp.+2 ; 0x98
96:c1 98 cbi0x18, 1; 24
98:80 81 ldr24, Z
9a:85 ff sbrsr24, 5
9c:02 c0 rjmp.+4 ; 0xa2
9e:c2 9a sbi0x18, 2; 24
a0:01 c0 rjmp.+2 ; 0xa4
a2:c2 98 cbi0x18, 2; 24
a4:80 81 ldr24, Z
a6:84 ff sbrsr24, 4
a8:02 c0 rjmp.+4 ; 0xae
aa:c3 9a sbi0x18, 3; 24
ac:01 c0 rjmp.+2 ; 0xb0
ae:c3 98 cbi0x18, 3; 24
b0:8c 91 ldr24, X
b2:83 ff sbrsr24, 3
b4:02 c0 rjmp.+4 ; 0xba
b6:c0 9a sbi0x18, 0; 24
b8:01 c0 rjmp.+2 ; 0xbc
ba:c0 98 cbi0x18, 0; 24
bc:8c 91 ldr24, X
be:82 ff sbrsr24, 2
c0:02 c0 rjmp.+4 ; 0xc6
c2:c1 9a sbi0x18, 1; 24
c4:01 c0 rjmp.+2 ; 0xc8
c6:c1 98 cbi0x18, 1; 24
c8:8c 91 ldr24, X
ca:81 ff sbrsr24, 1
cc:02 c0 rjmp.+4 ; 0xd2
ce:c2 9a sbi0x18, 2; 24
d0:01 c0 rjmp.+2 ; 0xd4
d2:c2 98 cbi0x18, 2; 24
d4:8c 91 ldr24, X
d6:80 ff sbrsr24, 0
d8:02 c0 rjmp.+4 ; 0xde
da:c3 9a sbi0x18, 3; 24
dc:08 95 ret
de:c3 98 cbi0x18, 3; 24
e0:08 95 ret[/syntax]

no ale dobrym przemyśleniem kodu w C - można go jeszcze ciut stuningować przypomnę twoja funkcja wygląda oryginalnie tak:

[syntax=c]void write_byte( uint8_t *data, uint8_t *data1 ) {

if ( *data & 0x80 ) SET0_HI; else SET0_LO;
if ( *data & 0x40 ) SET1_HI; else SET1_LO;
if ( *data & 0x20 ) SET2_HI; else SET2_LO;
if ( *data & 0x10 ) SET3_HI; else SET3_LO;

if ( *data1 & 0x08 ) SET0_HI; else SET0_LO;
if ( *data1 & 0x04 ) SET1_HI; else SET1_LO;
if ( *data1 & 0x02 ) SET2_HI; else SET2_LO;
if ( *data1 & 0x01 ) SET3_HI; else SET3_LO;
}[/syntax]

jak chodzi o to co wyżej pokazałem w ASM z pliku *.lss

No to teraz powiedz mi też czy korzystasz w ogóle np z programu Eclipse Gadget bo on też już na pierwszy rzut oka pomaga oceniać pewne nasze działania w C w aspekcie tego jak to wygląda później w ASM we flashu - zobaczmy ile pokazuje zajętości flasha w byle testowym programie pustym prawie z tą funkcją:

no to teraz pomyśl - w KAŻDYM warunku IF() odwołujesz się jakby bezpośrednio do pamięci za pomocą wskaźników *data oraz *data1. Oczywiście jak widać po kodzie ASM na górze kompilator i tak był mądry i wrzucił na początku te dane do rejestru, czyli sam zoptymalizował twoje podejście - chodzi o ten fragment:

[syntax=asm]0000007c :
7c:fc 01 movwr30, r24
7e:db 01 movwr26, r22
80:80 81 ldr24, Z
82:87 ff sbrsr24, 7
......
......[/syntax]

i później jak widzisz - już całość leci tzn jest sprawdzane z rejestru r24 a nie z RAM więc DUŻO szybciej oczywiście później jest gdzieś przeładowany znowu na potrzeby *data1

ale może by tak od razu w C to zrobić, żeby kompilator zauważył, że my sami mocno kombinujemy w celu polepszenia kodu że tak powiem, to może jeszcze lepiej uda się wymyślić mu dla nas swoją optymalizację ?

w takim razie napiszmy twoją funkcję od nowa ale właśnie na tych zasadach jak to "za twoimi" pleckami zrobił kompilator w ASM

[syntax=c]void write_byte( uint8_t *data, uint8_t *data1 ) {

register uint8_t reg = *data;

if ( reg & 0x80 ) SET0_HI; else SET0_LO;
if ( reg & 0x40 ) SET1_HI; else SET1_LO;
if ( reg & 0x20 ) SET2_HI; else SET2_LO;
if ( reg & 0x10 ) SET3_HI; else SET3_LO;

reg = *data1;

if ( reg & 0x08 ) SET0_HI; else SET0_LO;
if ( reg & 0x04 ) SET1_HI; else SET1_LO;
if ( reg & 0x02 ) SET2_HI; else SET2_LO;
if ( reg & 0x01 ) SET3_HI; else SET3_LO;
}[/syntax]

teraz widzisz co zrobiliśmy ? idąc w ślad za kompilatorem w ASM sami powołujemy sobie jedną zmienną ze specyfikatorem "register" aby dać znać kompilatorowi (poprosić go) - te stary - powołaj oddzielny rejestr i wrzuć do niego najpierw daną z *data i dalej porównuj już szybciej na tym rejestrze ... zaś w środku funkcji przeładujemy do niego *data1

no to LU! - i proszę najpierw rzut oka na Eclipse Gadgeta i banan na twarzy - micha się cieszy bo jak widzimy -12 bajtów to znaczy, że pewnie będzie lepiej (choć wiadomo - nie zawsze tak musi być)

no ok to zajrzyjmy do pliku *.lss do ASM
[syntax=asm]0000007c :
7c:fc 01 movwr30, r24
7e:80 81 ldr24, Z
80:87 ff sbrsr24, 7
82:02 c0 rjmp.+4 ; 0x88
84:c0 9a sbi0x18, 0; 24
86:01 c0 rjmp.+2 ; 0x8a
88:c0 98 cbi0x18, 0; 24
8a:86 ff sbrsr24, 6
8c:02 c0 rjmp.+4 ; 0x92
8e:c1 9a sbi0x18, 1; 24
90:01 c0 rjmp.+2 ; 0x94
92:c1 98 cbi0x18, 1; 24
94:85 ff sbrsr24, 5
96:02 c0 rjmp.+4 ; 0x9c
98:c2 9a sbi0x18, 2; 24
9a:01 c0 rjmp.+2 ; 0x9e
9c:c2 98 cbi0x18, 2; 24
9e:84 ff sbrsr24, 4
a0:02 c0 rjmp.+4 ; 0xa6
a2:c3 9a sbi0x18, 3; 24
a4:01 c0 rjmp.+2 ; 0xa8
a6:c3 98 cbi0x18, 3; 24
a8:fb 01 movwr30, r22
aa:80 81 ldr24, Z
ac:83 ff sbrsr24, 3
ae:02 c0 rjmp.+4 ; 0xb4
b0:c0 9a sbi0x18, 0; 24
b2:01 c0 rjmp.+2 ; 0xb6
b4:c0 98 cbi0x18, 0; 24
b6:82 ff sbrsr24, 2
b8:02 c0 rjmp.+4 ; 0xbe
ba:c1 9a sbi0x18, 1; 24
bc:01 c0 rjmp.+2 ; 0xc0
be:c1 98 cbi0x18, 1; 24
c0:81 ff sbrsr24, 1
c2:02 c0 rjmp.+4 ; 0xc8
c4:c2 9a sbi0x18, 2; 24
c6:01 c0 rjmp.+2 ; 0xca
c8:c2 98 cbi0x18, 2; 24
ca:80 ff sbrsr24, 0
cc:02 c0 rjmp.+4 ; 0xd2
ce:c3 9a sbi0x18, 3; 24
d0:08 95 ret
d2:c3 98 cbi0x18, 3; 24
d4:08 95 ret[/syntax]

nie wiem jak ty - ale moim zdaniem kod nie tylko jest krótszy więc zaoszczędzamy od razu ileś dodatkowych cykli zegara bo jest też bardziej optymalny od poprzedniego.

Owszem i tak obydwa pięknie posługują się NAJKRÓTSZYMI instrukcjami

sbi
cbi

na potrzeby banglowania bitami - więc nawet poprzednia wersja nie jest taka zła - no ale ta ciut lepsza

czy można jeszcze to jakoś zoptymalizować pisząc to od nowa i w całości tylko jako wstawkę ASM ? nie wiem - pewnie można - ja już dawno nie ćwiczyłem asemblera więc nie wymyślę nic na gwałt ale też mam przeczucie, że no krócej się już nie da

------------------------ [ Dodano po: 2 minutach ]

Uwaga na koniec, jeśli ta funkcja wykonuje się szybko - a tobie brakuje czasu to może też (być może - tak się tylko domyślam) być tak, że dookoła tej funkcji masz jakiegoś czaso-pożeracza - tzn np nieoptymalnie zorganizowaną jakąś pętlę gdzie tę funkcję wywołujesz itp itd

Statystyki: Napisane przez mirekk36 — 6 paź 2017, o 13:55

Funkcja ze wstawkami asemblerowymi (AVR)

2017-10-06T13:13:05+01:00

No i niestety tym razem padło na mnie
Potrzebuję ryby
Jestem wyjątkowo uodporniony na asemblera, a staram się coś poprawić pod względem prędkości.
Poniżej kod, który należałoby zastąpić wstawką asemblerową. Kluczowy problemem dla mnie jest przekazanie wartości poprzez wskaźnik.
Pokrótce chodzi o zmianę stanu pinów na PORTB, w zależności od wartości bitu (0, 1) w bajcie.
[syntax=c]#define SET0_HIPORTB |= (1<#define SET1_HIPORTB |= (1<#define SET2_HIPORTB |= (1<#define SET3_HIPORTB |= (1<
#define SET0_LOPORTB &= ~(1<#define SET1_LOPORTB &= ~(1<#define SET2_LOPORTB &= ~(1<#define SET3_LOPORTB &= ~(1<

/**************** A teraz spróbujemy w asemplerze **************************************/
void write_byte( uint8_t *data, uint8_t *data1 ) {

if ( *data & 0x80 ) SET0_HI; else SET0_LO;
if ( *data & 0x40 )SET1_HI; else SET1_LO;
if ( *data & 0x20 )SET2_HI; else SET2_LO;
if ( *data & 0x10 )SET3_HI; else SET3_LO;

if ( *data1 & 0x08 )SET0_HI; else SET0_LO;
if ( *data1 & 0x04 )SET1_HI; else SET1_LO;
if ( *data1 & 0x02 )SET2_HI; else SET2_LO;
if ( *data1 & 0x01 )SET3_HI; else SET3_LO;

// A tu to samo ale w asemblerze :)
asm volatile(
" "
" "
" "
);[/syntax]

Jeśli ktoś miałby chwilkę i trochę chęci, to bardzo proszę o wsparcie.
W razie pytań jestem do dyspozycji
Dzięki z góry.

PS
Oczywiście przeglądnąłem poradniki z magick ledami, ale nie pomogły mi

Statystyki: Napisane przez Zealota — 6 paź 2017, o 13:13