atarionline.pl Języki programowania - testy - Forum Atarum

Jeśli chcesz wziąć udział w dyskusjach na forum - zaloguj się. Jeżeli nie masz loginu - poproś o członkostwo.

  • :
  • :

Vanilla 1.1.4 jest produktem Lussumo. Więcej informacji: Dokumentacja, Forum.

    • 1: CommentAuthorzbyti
    • CommentTime16 Apr 2020
     
    @Cyprian fajny instruktażowy kod :]

    Wklejaj go też może w BB kody tego forum? Fajnie się czyta :]
    • 2: CommentAuthorCyprian
    • CommentTime16 Apr 2020
     
    ok spróbuję.
    aczkolwiek nie ma tam nic specjalnego

    A8:
    // MAD Assembler

    LZ4_SRC = $00+$80 // ; 25:10 (size=7c)
    LZ4_DST = $02+$80 // ; 0c:00
    LZ4_END = $04+$80 // ; 25:8c
    COUNT = $06+$80
    DELTA = $08+$80

    Licznik = $0a+$80
    Licznik2 = 10


    //; Autostart header
    org $2e0
    dta <start, >start


    //; Start of program
    org $1000
    start:
    sei // Stop Interrupt


    InitHW


    BeepOFF


    WaitForKbd


    lda #Licznik2 // Test counter
    sta Licznik


    BeepON


    //Main loop
    Main_Loop
    //LZ4 init
    lda #<LZ4_DataC64 // LZ4 Source Start
    sta LZ4_SRC
    lda #>LZ4_DataC64
    sta LZ4_SRC+1

    lda #<LZ4_Data_EndC64 // LZ4 Source End
    sta LZ4_END
    lda #>LZ4_Data_EndC64
    sta LZ4_END+1

    lda #<ScreenData // Destination
    sta LZ4_DST
    lda #>ScreenData
    sta LZ4_DST+1


    //LZ4 go
    jsr lz4_decode


    dec Licznik
    beq Neverending_Loop


    //LZ4 init
    lda #<LZ4_Data
    sta LZ4_SRC
    lda #>LZ4_Data
    sta LZ4_SRC+1

    lda #<LZ4_Data_End
    sta LZ4_END
    lda #>LZ4_Data_End
    sta LZ4_END+1

    lda #<ScreenData
    sta LZ4_DST
    lda #>ScreenData
    sta LZ4_DST+1


    //LZ4 go
    jsr lz4_decode


    dec Licznik
    beq Main_Loop_End


    jmp Main_Loop
    Main_Loop_End:


    BeepOFF


    Neverending_Loop:
    nop
    jmp Neverending_Loop

    icl "A8_LZ4_macro.asm"
    icl "lz4_decode_CK.s"


    //Data
    DisplayList
    dta $70,$70,$30 ; 20 blank lines
    dta $4F,<ScreenData,>ScreenData ; mode F @ Bitmapa
    :99 dta $0f ; x99 mode F
    dta $4F,<(ScreenData+4000),>(ScreenData+4000) ; mode F @ Bitmapa+4000
    :99 dta $0f ; x99 mode F
    dta $41,<DisplayList,>DisplayList ; waitvbl


    //; Bitmap data location
    org $2060
    ScreenData:
    ins "A8_IMAGE.RAW"


    //; LZ4 data location
    org $4000
    LZ4_Data:
    ins "A8_IMAGE_STRIP.LZ4"
    LZ4_Data_End:

    LZ4_DataC64:
    ins "C64_IMAGE_STRIP.LZ4"
    LZ4_Data_EndC64:


    .macro InitHW
    // lda #0
    // sta $D400 // ANTIC OFF

    lda #<DisplayList
    sta $D402
    lda #>DisplayList
    sta $D402+1
    .endm

    .macro BeepON
    lda #$1F
    sta $D201 // Pokey AUDC1 volume
    .endm

    .macro BeepOFF
    lda #$10
    sta $D201 // Pokey AUDC1 volume
    .endm

    .macro WaitForKbd
    WaitForKbd_Loop:
    lda $D209 // KBCODE
    cmp #33 // Space
    bne WaitForKbd_Loop // wait until SPACE
    .endm
    • 3: CommentAuthorzbyti
    • CommentTime16 Apr 2020 zmieniony
     
    @Cybrian jak wkleisz kod to masz większe szanse, że lamer się zainteresuje a doświadczony programista od razu może zobaczyć czy coś da się poprawić.

    Pobranie załącznika to jednak pare operacji więcej :]

    EDIT: komplet w załączniku oczywiście mile widziany!
    • 4: CommentAuthorantrykot
    • CommentTime17 Apr 2020
     
    Polling rejestru KBCODE jest błędem, albowiem jego wartość jest sensowna tylko wtedy gdy naciśnięto jakiś klawisz.
    • 5: CommentAuthorCyprian
    • CommentTime17 Apr 2020
     
    @antrykot ok, co proponujesz zamiast tego?
    • 6:
       
      CommentAuthorshanti77
    • CommentTime17 Apr 2020 zmieniony
     
    WaitforKbd_loop:
    lda $D20F ;SKSTAT
    and #4 ;czekaj na wciśnięcie klawisza
    bne WaitforKbd_loop
    lda $d209 ;KBCODE
    cmp #33
    bne WaitforKbd_loop
    • 7: CommentAuthorCyprian
    • CommentTime17 Apr 2020
     
    dzięki
    • 8:
       
      CommentAuthorjhusak
    • CommentTime18 Apr 2020 zmieniony
     
    Jak się na dwóch Atarkach puści tę samą muzyczkę w ten sam sposób, to dość szybko się rozjeżdżają. Słychać efekt przesunięcia i sumowania faz.

    Podobnie, jak się uruchomi Sound w basicu na te same wartości, słychać efekt rzesunięcia fazy (czy jak się to tam zwie).

    Możliwy rozjazd częstotliwości kwarców po takim szmacie czasu jeszcze bardziej potęguje efekt. Czy mógłby ktoś z dobrym oscyloskopem wziąć parę atarek i zmierzyć częstotliwość zegarów/odchylenie od wzorca?

    Aha żeby nie było, testowałem to kiedyś na w miarę nowych atarkach, takich po kilka lat od daty produkcji.
    • 9: CommentAuthorzbyti
    • CommentTime20 Apr 2020 zmieniony
     
    Postanowiłem trochę wyrównać szanse Action!

    Poprawiłem oryginalny kod benchmarku z Analoga tak aby też używał procedury bibliotecznej, jak to ma miejsce w MP i CC65, a nie pętli FOR do zapełniania tablicy jak to było w pierwszych testach.

    MP
    fillchar(flags, sizeof(flags), true);

    CC65
    memset(flags, true, sizeof(flags));

    Action
    SETBLOCK(FLAGS,8190,'T)

    Kod Action przyspieszył o ok ~20%, z 1003 spadł do 840 ramek bez zmiennych na stronie zerowej a ze 4 zmiennym na stronie zerowej przyspieszenie notujemy o ~25%, 746 ramek.

    BYTE RTCLOCK2=20 ; sys timer
    BYTE RTCLOCK1=19

    CARD COUNT=$F4,PRIME=$F6,STOP

    PROC sieve()
    BYTE ARRAY FLAGS(8190)
    CARD I=$F0,K=$F2

    PRIME=0
    COUNT=0 ; init count
    SETBLOCK(FLAGS,8190,'T)

    FOR I=0 TO 8190 ; and flags
    DO
    IF FLAGS(I)='T THEN
    PRIME=I+I+3
    K=I+PRIME
    WHILE K<=8190
    DO
    FLAGS(K)='F
    K==+PRIME
    OD
    COUNT==+1
    FI
    OD
    RETURN

    PROC main()
    BYTE I=[0]

    RTCLOCK1=0
    RTCLOCK2=0
    WHILE I<10
    DO
    sieve()
    I==+1
    OD
    STOP=RTCLOCK1 * 256 + RTCLOCK2

    PRINTF("%E %U PRIMES IN",COUNT)
    PRINTF("%E %U JIFFIES",STOP)
    PRINTF("%E %U iterations",I)
    RETURN

    Co zbliżyło Action! do Mad Pascala który optymalizowany (zmienne na stronie zerowej) wyrabiał się w 644 ramek.

    102 ramek różnicy w szybkości może wynikać z tego, że fillchar jest w MP sporo szybszy od tego z Action!

    Zejście z wynikiem w Action! o ~250 ramek jest znaczące!
    • 10: CommentAuthorzbyti
    • CommentTime31 May 2020 zmieniony
     
    Dziś wydany Mad Pascal 1.6.4 przyspieszył w teście Chessboard w stosunku do jednych z pierwszych wydań tego "numerka" ;)

    Z 40 wyrysowań skoczył na 55.

    Millfork            Chessboard:   79 iterations in 150 ticks
    CC65 Chessboard: 76 iterations in 150 ticks
    Mad Pascal Chessboard: 55 iterations in 150 ticks

    Chociaż jeszcze sprawdzę, czy @ilmenit w tym teście też nie używał strony zerowej i może różnica między kompilatorami nie jest tak wielka jakby wynikało z powyższej tabelki.

    EDIT1: przerzucenie zmiennych na ZP w MP dało wynik w tym teście o trzy wyrysowania więcej: 58.

    EDIT2: prawidłowy wynik to 73
    • 11: CommentAuthortebe
    • CommentTime31 May 2020
     
    70
    program chessboard;
    uses crt, graph;

    var i, stop : byte;
    rtClock : byte absolute 20;
    col1 : byte absolute 709;
    col2 : byte absolute 710;
    colB : byte absolute 712;
    bmpAdr : word absolute 88;

    procedure drawBoard;
    var i1b, i2b, i3b, x, color : byte;
    p : PByte absolute $e0;
    begin
    p := pointer(bmpAdr);
    for i3b := 1 to 8 do begin
    for i2b := 1 to 24 do begin

    for i1b := 1 to 4 do begin
    p[0]:= 255;
    p[1]:= 255;
    p[2]:= 255;
    Inc(p,6);
    end;
    Inc(p,16);
    end;
    if (i3b and %1) = 0 then Dec(p,3) else Inc(p,3);
    end;
    end;

    begin
    InitGraph(8 + 16);
    col1 := 1;
    col2 := 11;
    colB := 12;

    pause;
    rtClock := 0;

    while rtClock < 150 do begin
    drawBoard;
    inc(i);
    end;

    stop:=rtClock;

    InitGraph(0);
    writeln('Drawing iterations: ', i);
    ReadKey;
    end.
    • 12: CommentAuthorzbyti
    • CommentTime31 May 2020 zmieniony
     
    Millfork            Chessboard:   79 iterations in 150 ticks
    CC65 Chessboard: 76 iterations in 150 ticks
    Mad Pascal Chessboard: 73 iterations in 150 ticks

    @tebe przepraszam za brak staranności, miałem przygotowany przez siebie plik ze źródłem i nie zajrzałem do środka a tam faktycznie jedna zmienna była poza dyrektywami.



    program chessboard;
    uses crt, graph;

    {$define FAST}

    var stop : byte;
    rtClock : byte absolute 20;
    col1 : byte absolute 709;
    col2 : byte absolute 710;
    colB : byte absolute 712;
    bmpAdr : word absolute 88;

    {$ifdef FAST}
    i : byte absolute $e0;
    {$else}
    i : byte;
    {$endif}


    procedure drawBoard;
    var
    {$ifdef FAST}
    i1b : byte absolute $e1;
    i2b : byte absolute $e2;
    i3b : byte absolute $e3;
    p : PByte absolute $e4;
    {$else}
    i1b, i2b, i3b : byte;
    p : PByte;
    {$endif}
    begin
    p := pointer(bmpAdr);
    for i3b := 1 to 8 do begin
    for i2b := 1 to 24 do begin
    for i1b := 1 to 4 do begin
    p[0]:= 255;
    p[1]:= 255;
    p[2]:= 255;
    Inc(p,6);
    end;
    Inc(p,16);
    end;
    if (i3b and %1) = 0 then Dec(p,3) else Inc(p,3);
    end;
    end;

    begin
    InitGraph(8 + 16);
    col1 := 1;
    col2 := 11;
    colB := 12;

    pause;
    rtClock := 0;

    while rtClock < 150 do begin
    drawBoard;
    inc(i);
    end;

    stop:=rtClock;

    InitGraph(0);
    {$ifdef FAST}
    writeln('ZERO Page Drawing iterations: ', i);
    {$else}
    writeln('Drawing iterations: ', i);
    {$endif}
    ReadKey;
    end.
    • 13: CommentAuthortebe
    • CommentTime7 Jun 2020
     
    nowe optymalizacje dla pętli FOR zliczających malejąco DOWNTO 0, rosnąco TO 255 (licznik typu BYTE)

    wynik dla CHESSBOARD = 79