Forum » Programowanie
  kategorie: ANSI C, Asembler
Spis tematów w dziale Programowanie       Ostatnie wątki
opcje wątku
strony: 1 | 2 > >>
30.09.2024 21:18
[#1] [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku
Cześć,
ponieważ mam dwa bufory różnej wielkości kopiuję jeden do drugiego linia po linii.
Chciałem zapytać czy Ktoś rozpisał by mi ten kod asemblera, wygenerowany przez kompilator
ale żeby wywalić pętle i skoki. Sam nie wiem jak to zrobić za bardzo :(
Chciałbym porównać czy i o ile będzie wtedy szybciej - bo używam tego intensywnie w moim kodzie.


Tutaj link z Compiler Explorer z działającym przykłądem: http://franke.ms/cex/z/M7renn


Kod w C:
void render()
{
    // Convert position back from FP to int.
    const int y = g_bg_image__y__fp8 >> 8;

    unsigned char* background_start__ptr = g_bg_image + (y * G_BG_IMAGE__WIDTH);
    unsigned char* big_buffer__ptr = E_io__prefs.big_buffer + G_BG_IMAGE__LEFT_OFFSET + E_IO__BIG_BUFFER_HEIGHT_MARGIN * E_IO__BIG_BUFFER_WIDTH;

    for (int scanline_y = 0; scanline_y < 256; scanline_y++)
    {
        memcpy(big_buffer__ptr, background_start__ptr, G_BG_IMAGE__WIDTH);        
        
        big_buffer__ptr += E_IO__BIG_BUFFER_WIDTH;
        background_start__ptr += G_BG_IMAGE__WIDTH;
    }    
}


Kod z kompilatora:
_render:
        move.l d3,-(sp)
        move.l d2,-(sp)
        move.l _g_bg_image__y__fp8,d1
        asr.l #8,d1
        muls.l #340,d1
        add.l _g_bg_image,d1
        move.l #28726,d2
        add.l _E_io__prefs,d2
        moveq #0,d3
        not.b d3
.L3:
        move.l d1,a1
        move.l d2,a0
        moveq #4,d0
.L2:
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        dbra d0,.L2
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        add.l #448,d2
        add.l #340,d1
        dbra d3,.L3
        clr.w d3
        subq.l #1,d3
        jcc .L3
        move.l (sp)+,d2
        move.l (sp)+,d3
        rts
30.09.2024 22:37
[#2] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #1

To duze by to bylo bez petli.
Szczegolnie petlla dla D3 jest duza.
Moglo by byc za duze na cache procesora.
Dla D0 zrobilem.

_render:
        move.l d3,-(sp)
        move.l d2,-(sp)
        move.l _g_bg_image__y__fp8,d1
        asr.l #8,d1
        muls.l #340,d1
        add.l _g_bg_image,d1
        move.l #28726,d2
        add.l _E_io__prefs,d2
        moveq #0,d3
        not.b d3     ; tutaj D3= 255
.L3:
        move.l d1,a1
        move.l d2,a0
;        moveq #4,d0.      ; czyli 5 petli
.L2:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
;        dbra d0,.L2

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        add.l #448,d2
        add.l #340,d1
        dbra d3,.L3.    ; zapetlone D3+1 razy
        clr.w d3        ; a tego nie rozumiem, albo slabo juz mysle bo to bedzie D3=0
        subq.l #1,d3 ; a tu bedzie D3=-1
        jcc .L3 ; to tutaj sie zaden skok nigdy nie wykona, albo czegos nie rozumiem albo to blad w generowanym kodzie
        move.l (sp)+,d2
        move.l (sp)+,d3
        rts
30.09.2024 23:19
[#3] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Don_Adan, post #2

Dzięki, czyli 256 Linii to będzie za dużo?
30.09.2024 23:24
[#4] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@mateusz_s, post #1

Jeżeli docelowa konfiguracja to 040+ (takie masz ustawienia kompilatora)
to korzystaj z instrukcji move16 (a1)+,(a0)+ to o wiele szybsza forma kopiowania pamięci obszaru pamięci.
(jedną instrukcją kopiujesz 128 bitów ) Usunięcie pętli nie jest najlepszym rozwiązaniem, pętle powinieneś optymalizować pod cache procesora 040 po 4KB dcache icache (060 8KB).

Przy move16 256 instrukcji idealnie kopiuje 4096 B cały data cache 040 :)

Ostatnia aktualizacja: 30.09.2024 23:38:10 przez Tedy
01.10.2024 01:48
[#5] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #3

To nie bedzie 256 linii.
Tylko 256 razy tego wszystkiego co znajduje sie pomiedzy L3 a dbra, d3,L3

Nie jest jeszcze az tak duzo, ale musisz wiedziec jak cache dziala.
Mozesz porobic testy, i zobaczyc , jak jest szybciej.
Gdyby to bylo po 68000 to wtedy byloby szybciej, pod 68040 watpie,zeby bylo szybsze.
Usuniecie petli dla D0 moze byc szybsze, bo petla z D3 bedzie w cache.
01.10.2024 07:19
[#6] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Don_Adan, post #5

Zdecydowanie tak, usunięcie pętli L2.... dbra D0,l2 to podstawa, zaś pętla L3 ... dbra d3,L3 dostosowana do wielkości cache. Można jeszcze optymalizację zrobić pod pipeline 060 i uzyskać darmowy skok do L3

subq.w #1,d3
bpl.b L3

będzie szybsze niż dbra d3,L3

Ostatnia aktualizacja: 01.10.2024 07:20:31 przez Tedy
01.10.2024 11:00
[#7] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Tedy, post #4

o to ciekawe.. ale dlaczego kompilator sam tego nie zrobił skoro wie ze to 040 ?
sprobuje potem zamienić to na move16, najwyżej bede zawracał gitare że utknałem xD




Ostatnia aktualizacja: 01.10.2024 11:06:37 przez mateusz_s
01.10.2024 12:33
[#8] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #7

Z tego co pisal Kefir jak byl jeszcze aktywny to move16 to bedzie minimum 11 cykli na 16 bajtow.
A roznice robi czas dostepu do pamieci fast, w SIM-ach jest on dosc wolny.
W nowszych kartach turbo jak Warp czy TF, move16 moze byc juz wolniejsze, ale nie wiem czy ktos robil testy szybkosci.
Tak na szybko to cos takiego mozesz uzyc. D3 jest zamienione z D0.

_render:
 
        move.l d2,-(sp)
        move.l _g_bg_image__y__fp8,d1
        asr.l #8,d1
        muls.l #340,d1
        add.l _g_bg_image,d1
        move.l #28726,d2
        add.l _E_io__prefs,d2
        moveq #0,d0
        not.b d0 
        move.l d1,a1
        move.l d2,a0
.L3:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
   
        lea 448-340(a0),a0
        dbra d0,.L3
        move.l (sp)+,d2
        rts


Ogolnie to jest taki sobie kod wygenerowany przez kompilator.
Choc roznice w szybkosci nie beda duze, ale mozesz sprawdzic.
Mozna jeszcze muls.l pewnie wywalic, ale to nie jest w petli wiec nie jest krytyczne dla szybkosci.

Ostatnia aktualizacja: 01.10.2024 12:35:12 przez Don_Adan
01.10.2024 14:25
[#9] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
kiero
MorphOSAmiga

@Don_Adan, post #8

move16 ma taką zaletę że nie przerzuca danych do/z cache. Dlatego imo ciężko porównywać to do liczenia cykli normalnych instrukcji. Przy dużych blokach pamięci to imo najlepsza metoda (też do czyszczenia/wypełniania pamięci, wtedy po prostu na stosie robisz sobie mały bufor z wartościami jako źródło). Nie wywala ci wszystkiego innego z cache. Jeżeli nie masz z czym sparować tego kopiowania to imo move16 jest najlepszym rozwiązaniem na 040+.
01.10.2024 15:37
[#10] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@kiero, post #9

To moze robic roznice, ale i tak zawsze lepiej zrobic testy.
Ja nigdy move16 nie uzywalem bo nie pisalem niczego pod 68040+.

Troche pozmienialem jeszcze, wywalajac D2.
D1 tez jest wolne

_render:
 
        move.l _g_bg_image__y__fp8,d0
        asr.l #8,d0
        muls.l #340,d0
        add.l _g_bg_image,d0
 ;       move.l #28726,d2
 ;       add.l _E_io__prefs,d2

       move.l _E_io__prefs, a0
       lea 28726(a0),a0
       move.l d0,a1

        moveq #0,d0
        not.b d0 

.L3:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
   
        lea 448-340(a0),a0
        dbra d0,.L3
        rts
01.10.2024 16:04
[#11] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Don_Adan, post #10

Nie znam wypowiedzi Marka (Kefira) na którą się powołujesz ale faktycznie move16 w najlepszym czasie ma 11(1,1) najgorszym 18(1,1) zaś move.l (Ax)+,(Ay)+ 2(1,1) co daje nam x4 8(4,4). Odczyt i zapis z pamięci to wąskie gardło cpu (i nie chodzi tu tylko o piekielnie wolny chip) 4 cykle odczytu i 4 zapisu vs 1,1 robią różnicę.
Nawet fakt , iż move16 należy do grupy pOEP only nie wpływa na jego niekorzyść wobec move.l (ax)+, {,Ay)+ które czeka na zakończenie kopiowania do pamięci.

Całkowicie się zgadzam Kiero, testy na moim TF1260 są jednoznaczne move16 > movem.l > move.l Nawet demonizowane movem.l (a0)+,Dn-An jest szybsze na TF1260 od move.l (ax)+,(ay)+

w pętli zamieniłby lea x(a0),a0
na szybsze adda.w #x,a0
01.10.2024 16:27
[#12] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
asman

@Tedy, post #11

w pętli zamieniłby lea x(a0),a0
na szybsze adda.w #x,a0


Jak dobrze pamiętam na 68000 to nie ma różnicy w cyklach pomiędzy tymi instrukcjami (a w starych manualach do 68000 to jest błąd że to jest szybsze). Ja to bym dał add.l dx,a0, i poza pętlą dał move.l #x,dx.
01.10.2024 16:38
[#13] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Don_Adan, post #10

Dzięki, probowałem testować coś się skopiowało ale wywaliło błąd.
Czy jesteś w stanie zmodyfikować tą funkcję tak aby pasowała do tej definicji: 
extern void my_copy(void* _dst __asm("a0"), void* _src __asm("a1"));


(czyli wywalić tą inicjację to co jest w _render: a jako parametry żeby przyjeło gotowe bufory dla a0 i a1)

Podaje przykład, który mi działa:

extern void my_copy(void* _dst __asm("a0"), void* _src __asm("a1"));

void    G_bg_image__render()
{
    // Convert position back from FP to int.
    const int y = g_bg_image__y__fp8 >> E_IO__FP8;

    unsigned char* background_start__ptr = g_bg_image + (y * G_BG_IMAGE__WIDTH);
    unsigned char* big_buffer__ptr = E_io__prefs.big_buffer + G_BG_IMAGE__LEFT_OFFSET + E_IO__BIG_BUFFER_HEIGHT_MARGIN * E_IO__BIG_BUFFER_WIDTH;

    my_copy(big_buffer__ptr, background_start__ptr);  
}


dzialajacy kod ASM dla my_copy:

XDEF	_my_copy
	XDEF	my_copy
_my_copy
my_copy

_render:
        movem.l a2/d3/d2,-(sp)
        move.l a0,d2
        move.w #255,d3
.L3:
        move.l a1,a0
        move.l d2,a2
        moveq #4,d0
.L2:
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        dbra d0,.L2
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        add.l #448,d2
        lea (340,a1),a1
        dbra d3,.L3
        movem.l (sp)+,d2/d3/a2
        rts



Dla twojego kody zrobiłem w ten sposób, co prawda coś się wyśwtila, ale jest jakby co 2 albo 4 linie i wyskakuje co chwile żółty error
XDEF	_my_copy
	XDEF	my_copy
_my_copy
my_copy


.L3:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
   
        lea 448-340(a0),a0
        dbra d0,.L3
        rts




Ostatnia aktualizacja: 01.10.2024 16:43:46 przez mateusz_s
01.10.2024 17:04
[#14] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@asman, post #12

Masz rację jak mamy wolny rejestr to zdecydowanie lepiej add.w/l dn,a0
01.10.2024 17:23
[#15] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
kiero
MorphOSAmiga

@mateusz_s, post #13

IMO niepotrzebnie marnujesz czas. Nic nie zyskasz na takim wielkim unrollu (może poza przypadkiem kiedy uruchamiasz to na 68000).
01.10.2024 17:39
[wyróżniony] [#16] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Tedy, post #14

_render:
movem.l d2-d3/a0-a1,-(sp)

; a0 input
; a1 output
move.l #448-340-4,d2

tst.l (a0)
tst.l 16(a0)
move.w #255,d3
.L3:


rept 21 ;21 x move16
move16 (a0)+,(a1)+
endr
move.l (a0)+,(a1)+ ;a0 += 340

add.w d2,a1
subq.w #1,d3
bpl.b .L3


movem.l (sp)+,d2-d3/a0-a1
rts


nie testowałem ale powinno być git
1
01.10.2024 17:56
[#17] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@Tedy, post #11

Tutaj jest ta wypowiedz Kefira, i pare innych o move16 tez w tym samym watku jest.

link

A co do testow move16, to wedlug mnie dobrze byloby jeszcze porobic testy na 68080 i na PiStormie, bo tam moga byc inne wyniki. Przynajmniej tak mi sie wydaje.
01.10.2024 17:59
[#18] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #13

Popatrze ja to w pamieci robilem, wiec moze byc jakis moj blad.
Dawno nic nie pisalem w ASM, wszystko w glowie.
01.10.2024 18:18
[#19] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Don_Adan, post #17

Czyszczenie pamięci a kopiowanie to dwa różne systemy walutowe :)

W trakcie dyskusji podesłałeś fajny link do testów na Atari, z których wynika że move16 kopiuje szybciej.
Z moich testów na tf1260 płyną takie same wnioski.
Marek bronił poglądu w zakresie szybszego czyszczenia pamięci movem.l w stosunku do move16.
Ja takich testów nie robiłem więc się nie wypowiadam
01.10.2024 18:37
[#20] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #13

Na razie nic mi do glowy nie przychodzi.
A na C w ogole sie nie znam, Asman jest dobry w tym temacie.
Ja tam lubie miec kontrole nad tym co robie.
A kompilator jakis dziwny kod potrafi sobie wygenerowac, co widac szczegolnie na pierwszej wersji.
Zwykle jak nie wiem, gdzie jest blad to uzywam metody "prob i bledow".
Sprobuj czy to pojdzie:

XDEF	_my_copy
	XDEF	my_copy
_my_copy
my_copy

_render:
        movem.l a2/d3/d2,-(sp)
        move.l a0,d2
        move.w #255,d3
        move.l a1,a0.    ; +
.L3:
  ;      move.l a1,a0
        move.l d2,a2
        moveq #4,d0
.L2:
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        dbra d0,.L2
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        move.l (a0)+,(a2)+
        add.l #448,d2
;        lea (340,a1),a1
        dbra d3,.L3
        movem.l (sp)+,d2/d3/a2
        rts
01.10.2024 18:49
[wyróżniony] [#21] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #13

No i w tej implementacjj sa bledy:
XDEF	_my_copy
	XDEF	my_copy
_my_copy
my_copy

 move.w #255,d0 ; tego brakuje czyli licznika petli
 exg a0,a1 ; i prawdopodobnie tego tez , czyli zamiany rejestrow bo w dzialajacej wersji sa chyba odwrotnie

.L3:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
   
        lea 448-340(a0),a0
        dbra d0,.L3
        rts
1
01.10.2024 20:30
[#22] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Don_Adan, post #21

hej,

Ostatni kod Don Adan z #21
działa już prawidłowo jest nieco szybciej niż to co z kompilatora wyszło OK

Koda Tedy z #16 z move16
generalnie działa i nie zawiesza się, ale obraz jest zniekształcony i "ukośny" cały, wiec jest gdzieś mały bug,
to co działa jest zauważalnie szybsze, wiec chenie bym sprawdził działający kod :)
01.10.2024 20:52
[#23] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@mateusz_s, post #22

zastąp #448-340-4 -> #448-340 na szybko liczyłem. Jeszcze może masz adres źródła niepodzielny przez 16

Ostatnia aktualizacja: 01.10.2024 20:55:54 przez Tedy
01.10.2024 21:48
[wyróżniony] [#24] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #22

Taka wersja Tedy'ego mi sie bardziej podoba.
No ale ja jestem dziwny. 

_render:

; a0 input
; a1 output
 moveq #448-340,d1

 tst.l (a0)
 tst.l 16(a0)
 move.w #255,d0
.L3:

 rept 21 ;21 x move16
 move16 (a0)+,(a1)+
 endr

 move.l (a0)+,(a1)+  ;a0 += 340

 add.l d1,a1
 subq.w #1,d0
 bpl.b .L3
 rts
2
01.10.2024 21:52
[#25] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Don_Adan, post #24

Mnie też się bardziej podoba bez movem.l :D
Oldschool rulez !

Ostatnia aktualizacja: 01.10.2024 21:54:40 przez Tedy
1
01.10.2024 22:48
[#26] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Don_Adan

@mateusz_s, post #22

A tutaj masz jakby wersje final z pomyslem Asmana na wykorzystanie wolnego rejestru D1.
No i mozesz podac jakie wyniki osiagnales dla poszczegolnych wersji procedury kopiujacej.
Czyli kompilator, ASM i move16.

XDEF	_my_copy
	XDEF	my_copy
_my_copy
my_copy

 moveq  #448-340,D1
 move.w #255,d0 
 exg a0,a1 ;  to mozna wywalic jesli sie zamieni wszystkie "move.l (a1)+,(a0)+ " na "move.l (a0)+,(a1)+"

.L3:
        move.l (a1)+,(a0)+ ; pierwsza petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; druga petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; trzecia petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+  ; czwarta petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+

        move.l (a1)+,(a0)+ ; piata petla
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+


        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
        move.l (a1)+,(a0)+
   
        add.l d1,a0
        dbra d0,.L3
        rts
01.10.2024 23:44
[#27] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@Don_Adan, post #26

jak testować to testować wrzuć jeszcze to

_render:
movem.l d0-a6,-(sp)

; a0 input
; a1 output

tst.l (a0)
tst.l 16(a0)
move.w #255,d7
.L3:
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,48(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,96(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,144(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,192(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,240(a1)
movem.l (a0)+,d0-d6/a2-a6
movem.l d0-d6/a2-a6,288(a1) ;336
move.l (a0)+,336(a1)

adda.w #448,a1
subq.w #1,d7
bpl.b .L3

movem.l (sp)+,d0-a6
rts



Ostatnia aktualizacja: 01.10.2024 23:55:52 przez Tedy
02.10.2024 09:52
[#28] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Tedy, post #27

@Don Adan hej, dzięki dam znać, ale juz widzę że jest szybciej niż z kompilatora..

@Tedy sprawdzilem jeszcze tą wersję z #24, z 448-340, ale niestety też jest jakieś przesunięcie w finalnym wyniku, choć to co się wyświetla działa szybko.. wyrównywałem adres źródłowy i docelowy do 16, ale nie bylo roznicy sprawdze jeszcze raz jutro na innym przykladzie

edit kod z #27 działa dobrze

zaraz porobie testy

Ostatnia aktualizacja: 02.10.2024 09:57:25 przez mateusz_s
02.10.2024 12:14
[#29] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
Tedy

@mateusz_s, post #28

Może jednak wrzucaj rejestry na stos przed kopiowaniem to jednak C ;)
gdzieś później w innej części programu po kompilacji możesz mieć odwołanie do rejestrów które tu zmieniasz

movem.l d0-d1/a0-a1,-(sp)
......
movem.l (sp)+,d0-d1/a0-a1
02.10.2024 12:29
[#30] Re: [C, ASM] Kopiowanie ekranu linia po linii, pytanie o optymalizacje załączonego kodu w asm..?
mateusz_s
autor wątku

@Tedy, post #29

Hej,
Dzięki jeszcze raz Wszystkim za pomoc.

Przy okazji troche się nauczyłem dzięki tym przykłądom,
musiałem zmodyfikować te funkcje żeby kopiowały też nieco inny zakres,
i jakoś mi się udało..

Zrobilem kilka testów, niestety pod moim V1200 różnice prawie żadne,

na UAE ostatni kod z #27 był najlepszy, jednak pod V1200 był najgorszy
niestety nie mam innych sprzętów.

Jeśli ktoś ma 040 lub 060 i chciałby potestować do rzucam link do wszystkich testów:
https://filetransfer.io/data-package/dDB6NJMl#link

WYNIKI
(fps - wiecej lepiej):


--- stress test (tylko tlo)

		C+kompilator	kod z #26	kod z #24	kod z #27

UAE		41.0		42.1		46.8		48.4
V1200		36.3		36.3		36.4		33.5


--- stress test (całość)

		C+kompilator	kod z #26	kod z #24	kod z #27

UAE		41.0		43.3		56.74		57.2
V1200		36.3		36.8		36.4		33.5


--- normalny (tylko tło)

		C+kompilator	kod z #26	kod z #24	kod z #27

UAE		75.66		75.5		77.2		77.1
V1200		63.7		63.7		63.7		63.0


--- normalny (całość)

		C+kompilator	kod z #26	kod z #24	kod z #27

UAE		75.66		76.59		79.0		79.2
V1200		63.7		63.7		63.7		62.8


Ostatnia aktualizacja: 02.10.2024 12:31:00 przez mateusz_s
2
Forum » Programowanie
1 | 2 > >>
Ostatnie wątki na forum
Na stronie www.PPA.pl, podobnie jak na wielu innych stronach internetowych, wykorzystywane są tzw. cookies (ciasteczka). Służą ona m.in. do tego, aby zalogować się na swoje konto, czy brać udział w ankietach. Ze względu na nowe regulacje prawne jesteśmy zobowiązani do poinformowania Cię o tym w wyraźniejszy niż dotychczas sposób. Dalsze korzystanie z naszej strony bez zmiany ustawień przeglądarki internetowej będzie oznaczać, że zgadzasz się na ich wykorzystywanie.
OK, rozumiem