atarionline.pl Action! (+ benchmarks comparision) - 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.

4. Programowanie / Programming  »   Action! (+ benchmarks comparision)

W dół

Od 101 do 150 z 242

  1. <
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. >
    • 1: CommentAuthortebe
    • CommentTime21 Feb 2020 zmieniony
     
    DOS II 6.4 jeden z popularniejszych w swoim czasie
    • 2: CommentAuthorilmenit
    • CommentTime21 Feb 2020 zmieniony
     
    @zbyti - trzeba by zerknąć na kody wynikowe kompilatorów i zobaczyć czemu tak jest, ale dla Chessboard CC65 robi fajną optymalizację dostępu do kolejnych bajtów przez wskaźnik, co może być powodem szybkości w tym teście:
    000059r 1               ; p2[0] = 255;
    000059r 1               ;
    000059r 1  A9 FF        	lda     #$FF
    00005Br 1  A0 00        	ldy     #$00
    00005Dr 1  91 rr        	sta     (regbank+2),y
    00005Fr 1               ;
    00005Fr 1               ; p2[1] = 255;
    00005Fr 1               ;
    00005Fr 1  C8           	iny
    000060r 1  91 rr        	sta     (regbank+2),y
    000062r 1               ;
    000062r 1               ; p2[2] = 255;
    000062r 1               ;
    000062r 1  C8           	iny
    000063r 1  91 rr        	sta     (regbank+2),y
    • 3: CommentAuthorilmenit
    • CommentTime21 Feb 2020 zmieniony
     
    @tebe - to jakiś błąd. Będzie trzeba podebugować i zobaczyć czemu, bo w kodzie sprawdzającym jest warunek .ifdef __ATARIXL__, a domyślna konfiguracja to "nie XL" według dokumentacji:
    ->link<-
    Dla niej takie sprawdzenie nie powinno mieć miejsca. To jest dla konfiguracji, która robi przemieszanie w pamięci, aby był jeden większy ciągły blok pamięci ->link<-
    • 4: CommentAuthorzbyti
    • CommentTime21 Feb 2020 zmieniony
     
    PL65 & YoshPlus :]

    Jeszcze czekam na wyniki Quick 2.2 i zamykam temat tabelki.

    INCLUDE D:TERMINAL.LIB

    INT a,b,i
    CONST none=255
    BYTE CH=764, stop
    BYTE RTCLOCK=20

    MAIN()
    BEGIN
      RTCLOCK=0

      WHILE RTCLOCK < 100 DO
        a=a+1
        b=a
        b=b+1
        a=b
        i=i+1
      ENDWHILE

      stop=RTCLOCK
      WRITE(i) WRTLN(" iterations")
      WHILE CH=none DO ENDWHILE CH=none
    END

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 5: CommentAuthorzbyti
    • CommentTime21 Feb 2020 zmieniony
     
    [.] napisałem jakiś bzdury, @antrykot zwrócił mi na to uwagę w next p, zamianst p graficzka :]

    • 6: CommentAuthorantrykot
    • CommentTime21 Feb 2020 zmieniony
     
    Przecież jest podręcznik, ten co go Zientara splagiatował w cyklu o Action!
    • 7: CommentAuthorzbyti
    • CommentTime21 Feb 2020 zmieniony
     
    Podręcznik? To bardziej repetytorium, czytałem, chyba, że chodzi Ci o coś innego niż Języki Programowania Tom 2.

    Chodzi o te ->link<- materiały?

    Czy ten manual ->link<-

    @antrykot faktycznie, manual jest na 210 stron (nowszy na 344) - zapomniałem o nim, mój błąd.

    Raczej chodzi mi o książkę z nauką programowania w przykładach jakich jest wiele do BASIC'a na A8/C64.

    EDIT:
    @antrykot masz rację mam kiepską kopię w djvu która na oko wygląda jak tłumaczenie manuala z linku powyżej.
  8.  
    @jhusak

    dokładnie tak Kuba, mam wrażenie, że spadek szybkości Action! to jednoprzebiegowość kompilacji, która nie wyciska siódmych potów wydajności, ale generuje krótki kod wynikowy.

    @zbyti

    nie miałem jeszcze czasu przejrzeć wszystkiego ale jest tak:
    - jest pdf nazwany manualem i on ma... 40 stron łącznie ze stronami typu tytułowa i strona na copyrights. W kategorii manuali myślałem, że nic nie przebije zlepku notatek pt. manual dołączany oryginalnie do Action! - a jednak. Są obrazy dwóch dyskietek - dwustronne czyli 4 pliki łącznie. Mam nadzieję, że tam będzie trochę więcej niż ten manual :)
    • 9: CommentAuthorzbyti
    • CommentTime21 Feb 2020 zmieniony
     
    PL65 w teście przerysowań szachownicy na ilość w czasie 3 sekund :]

    INCLUDE D:TERMINAL.LIB
    INCLUDE D:GRAPHICS.LIB

    CONST NONE=255

    INT SAVMSC=88

    BYTE CH=764
    BYTE RTCLOCK=20,STOP
    BYTE COL1=709
    BYTE COL2=710
    BYTE COL4=712

    PROC DRAWBOARD()
    INT I1B,I2B,I3B
    POINTER SCREEN
    BYTE CELL BASED SCREEN
    BEGIN
      SCREEN=SAVMSC
      FOR I3B=1 TO 8 DO
        FOR I2B=1 TO 24 DO
          FOR I1B=1 TO 4 DO
            CELL=255
            SCREEN=SCREEN+1
            CELL=255
            SCREEN=SCREEN+1
            CELL=255
            SCREEN=SCREEN+4
          NEXT
          SCREEN=SCREEN+16
        NEXT
        IF (I3B AND 1) = 0 THEN SCREEN=SCREEN-3 ELSE SCREEN=SCREEN+3 ENDIF
      NEXT
    END

    MAIN()
    BYTE ITERS=0
    BEGIN
      GRAPHICS(8+16)
      COL1=1
      COL2=11
      COL4=12

      RTCLOCK=0
      WHILE RTCLOCK < 150 DO
        DRAWBOARD()
        ITERS=ITERS+1
      ENDWHILE
      STOP=RTCLOCK

      GRAPHICS(0)
      WRITE(ITERS) WRTLN(" iterations")
      WHILE CH=NONE DO ENDWHILE CH=NONE
    END

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
  10.  
    @zbyti: I did send you an E-Mail with Quick 2.1... not sure if it is any faster than the type-in listing V1.6.
    • 11: CommentAuthorzbyti
    • CommentTime21 Feb 2020
     
    @CharlieChaplin thank you! I'll test it ;]
    • 12: CommentAuthorzbyti
    • CommentTime21 Feb 2020 zmieniony
     
    Zachęcony wersją Quick 2.1 od naszego kolegi z Niemiec sięgnąłem od razu po wersję 2.2.

    Na początek YoshPlus. Na oko widać, że jest ~25% szybciej w stosunku do 1.6 :]

    Wynik wersji Quick 2.1 i 2.2 okazał się być identyczny.

    BYTE
    [
      RT=20
    ]
    WORD
    [
     A,B,I
    ]
    MAIN
      I=0
      RT=0
      WHILE RT<100
        ADD(A,1,A)
        B=A
        ADD(B,1,B)
        A=B
        ADD(I,1,I)
      WEND
      ?("ITERATIONS: ",I)
    ENDMAIN

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 13: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    @tooloudtoowide chcesz to obadaj, ja doszedłem do tego miejsca i straciłem nerwy do tego narzędzia. Nie potrafię sensownie edytować tego na H6 a na samym A8 to mordęga.

    Vi informuje, że coś z końcówką takiego pliku tekstowego jest nie halo. Ty ponoć możesz wklejać ze schowka kod, więc spróbuj, ja pod Ubuntu wraz z atari800 nie mam takiej możliwości.

    Według mnie, poniższy kod, powinien wyrysować szachownicę, ale chociaż SCREEN zwiększa się to POKE nie rysuje nic po za pierwszą linią.

    Nie chce mi się nad tym siedzieć. Bardzo niewygodny język, nawet nie ma pętli FOR. Faktycznie tak jak napisano na polskim wiki "Action! dla ubogich" ->link<-

    W załączniku źródła na ATR.
  14.  
    wkleiłem, ale rzeczywiście jest coś z kodem - ja niestety dzisiaj w pracy więc nie posiedzę nad tym :(
    • 15: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    No ciekaw jestem co tam może być.

    Pętla IB1 wykonuje się prawidłowo, ale IB2 już nie daje widocznych na ekranie rezultatów.

    Może błąd kompilatora? Ale ponoć w narzędziu "nie ma znanych błędów" a przecież przez 20 lat ktoś by na to wpadł.

    • 16: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    OK, wziąłem ciepłą kąpiel i dotarło do mnie...

    Używam while zamiast for a kod przepisywałem z tego co zrobiłem w PL65. Muszę iteratory zerować! Wychodzi pisanie po nocy...

    Ale ze mnie matoł... :]
    • 17: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    No to teraz mam zagadkę dlaczego 8+16 nie daje mi pełnego ekranu graficznego?

    Kod działa z wersją Quick 1.6 i 2.2.

    EDIT:
    Chyba już wiem, w tym języku .GRAPHICS(8+16) 8+16 trzeba mieć wcześniej wyliczone za pomocą ADD albo od razu wpisać wynik.
    • 18: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    Dorzucam wyniki uzyskane w Chessboard Bench dla Quick 1.6 i 2.2.

    Quick-Sourcetext
    H6:BOARD.QIK    
    ----------------
    Length: $0330

    Free  : $743B
    ----------------



    INCLUDE
    [
      D:GRAPH.LIB
    ]

    BYTE
    [
      RTC=20
      COL1=709
      COL2=710
      COL4=712
      GM,STOP,L1B
    ]

    WORD
    [
      SAVMSC=88
    ]

    MAIN
      UNSIGN
      L1B=0  
      ADD(8,16,GM)
      .GRAPHICS(GM)
      COL1=1
      COL2=11
      COL4=12
      RTC=0
      WHILE RTC<150  
        .DRAWBOARD
        ADD(L1B,1,L1B)
      WEND
      STOP=RTC
      .GRAPHICS(0)
      ?("ITERATIONS IN 150 TICKS: ", L1B)
    ENDMAIN

    PROC DRAWBOARD
    BYTE
    [
      I1B,I2B,I3B,C,Z
    ]
    WORD
    [
      SC
    ]
    BEGIN
      SC=SAVMSC
      C=255
      I3B=0
      I2B=0
      I1B=0
      WHILE I3B<8
        WHILE I2B<24
          WHILE I1B<4
            POKE(SC,C)
            ADD(SC,1,SC)
            POKE(SC,C)
            ADD(SC,1,SC)
            POKE(SC,C)
            ADD(SC,4,SC)
            I1B+
          WEND
          I1B=0
          ADD(SC,16,SC)
          I2B+
        WEND
        I2B=0
        I3B+
        AND(I3B,1,Z)
        IF Z=0
          SUB(SC,3,SC)
        ELSE
          ADD(SC,3,SC)
        ENDIF
      WEND
    ENDPROC

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    Quick 2.2       Chessboard: 27 iterations in 150 ticks
    Quick 1.6       Chessboard: 16 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 19: CommentAuthorilmenit
    • CommentTime22 Feb 2020 zmieniony
     
    W wolnej chwili spróbuję dorzucić Millforka do benchmarków, bo język wygląda wyjątkowo obiecująco.
    • 20: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    @ilmenit było by fajnie:)

    Millfork idzie w ciekawym dla mnie kierunku ->link<-

    Mam prośbę, nie spróbował byś zrobić testów także dla ->link<- tak dla porównania? Ja wrzuciłem natywnego Pascal CLSN to i natywne C by się przydało.

    Może być ciekawie bo np. Lightspeed C ma optymalizator skompilowanego kodu :]

    Tylko YoshPlus na początek, gdyby przypadkiem się okazało, że jest szybki to pozostałe.

    Dla mnie PL65 jest granicą, jeżeli coś przebije go w YoshPlus to robię pozostałe. FORTH mnie po prostu zaciekawił dlatego ma SIEVE ;)

    Oczywiście jak znajdziesz czas :]
    • 21:
       
      CommentAuthorpirx
    • CommentTime22 Feb 2020
     
    Był jeszcze bardzo ciekawy Atalan ->link<-
    Niestety Rudla Kudla porzucił projekt z 8 lat temu, szkoda, bo język miał trochę nowoczesnych rozwiązań.
    Szybkości nie ma co testować, bo w ogóle Rudla jeszcze nie zaczął optymalizacji.
    • 22: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    No to jak tak się bawimy to Effectus idzie na tapetę ;)

    Tyle, że ani Chessboard ani SIEVE jakie napisałem w Action! nie kompilują się, i na ten moment nie chce mi się dociekać jak to obejść.

    Może jakby autor Effectusa tu zaglądał coś by poradził, ale chyba jest teraz zajęty czym innym.

    Osobiście uważam, że jakby doholował Effectus do finału to było by coś wspaniałego :]

    Ktoś ma kontakt i da znać autorowi, że może się dopisać do benchmarku z wynikami? @Kaz pisałeś, że masz kontakt, może zainteresujesz gościa tym wątkiem i dostarczy nam kod który się kompiluje?

    EDIT:
    Przetestowałem z 5 metod rysowania szachownicy w Effectusie (sposobem jaki tu jest stosowany) i wszystko zawiodło. Ewidentnie język nie jest gotowy nawet do zabawy.

    Niepotrzebnie znajduje się w tabeli, z następnych edycji go usunę.

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Effectus 0.3.1 YoshPlus: 33944 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    Quick 2.2       Chessboard: 27 iterations in 150 ticks
    Quick 1.6       Chessboard: 16 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 23: CommentAuthortebe
    • CommentTime22 Feb 2020 zmieniony
     
    ->link<-

    benchmarki Millforka, porównanie z CC65, Ilmenit będzie miał żal do autora za mało efektywny kod C ;)

    romsum i fib stamtąd wziąłem
    • 24: CommentAuthorzbyti
    • CommentTime22 Feb 2020 zmieniony
     
    @tebe nie dam rady sam przepisać na wszystkie dotychczas użyte przeze mnie języki tych benchmarków.

    Jak kogoś interesują dodatkowe testy to nie powstrzymuję :]
    • 25: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    Napisałem SIEVE dla QUICK bo nie znalazłem na dysku z "demami" do niego. Trochę musiałem pokombinować bo QUICK nie tylko nie ma pętli FOR ale np. ARRAY jest ograniczony do rozmiaru 256 i generalnie robi za STRING ;) więc nie mogłem z niego skorzystać tak jak w każdym innym użytym tutaj języku.

    Tak czy inaczej udało mi się napisać ten benchmark i z mojej strony jest już chyba komplet testów które chciałem wykonać.

    W sumie poznałem podstawy 5 nowych języków na małe A8 - było fajnie! :]

    Najbardziej podoba mi się na ten moment:

    1. Action!
    2. Mad Pascal
    3. PL65
    4. Quick
    5. FORTH

    Mad Pascal jest wciąż rozwijany i jest praktyczniejszą opcją więc powyższa lista to raczej kwestia składni która podoba mi się bardziej od pascalowej ;)

    Szybkość CC65 do mnie przemawia ale nie znam C. Fajne jest zwłaszcza to (jak przez przypadek pokazał stary kod w teście SIEVE MADS), że jak się nie jest wymiataczem to pisanie od razu w ASM nie musi dać najszybszych procedur. Kompilatory Mad Pascala, CC65 czy Action! robią z naszych programów wysokiego poziomu naprawdę dobry kod maszynowy! :]

    EDIT:
    Dorzuciłem wynik SIEVE dla MP bez deklarowania zmiennych na stronie zerowej.

    Quick-Sourcetext
    H6:SIEVE.QIK    
    ----------------
    Length: $02B2

    Free  : $74B9
    ----------------

    BYTE
    [
      RT1=19
      RT2=20
      J,F
    ]

    WORD
    [
      PRIME,COUNT,STOP
      K,I,IA,Z,P1
    ]

    MAIN
      J=0
      RT1=0
      RT2=0

      WHILE J<10
        J+

        IA=32768
        PRIME=0
        COUNT=0
        K=0

        WHILE IA<40958
          POKE(IA,1)
          ADD(IA,1,IA)
        WEND

        IA=32768
        WHILE IA<40958
          SUB(IA,32768,I)
          PEEK(IA,F)
          IF F=1
            ADD(I,I,P1)
            ADD(P1,3,PRIME)
            ADD(PRIME,I,K)
            WHILE K<=8190
              ADD(K,32768,Z)
              POKE(Z,0)
              ADD(K,PRIME,K)    
            WEND
            ADD(COUNT,1,COUNT)
          ENDIF
          ADD(IA,1,IA)
        WEND

      WEND

      MULT(RT1,256,STOP)
      ADD(STOP,RT2,STOP)  
      ?(COUNT, " PRIMES")
      ?(STOP, " TICKS IN 10 INTERATIONS")
    ENDMAIN

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    Fast Basic FBI YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    Quick 2.2       Chessboard: 27 iterations in 150 ticks
    Quick 1.6       Chessboard: 16 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Mad Pascal         SIEVE:  739 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    Quick 1.6          SIEVE: 2022 ticks in 10 iterations
    Quick 2.2          SIEVE: 2199 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 26: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    No to jeszcze krótkie "sprawdzam".

    W niemieckim podręczniku (broszurze) do Quick 2.0, który możemy znaleźć na atariwiki.org ->link<- czytamy:

    But are The Quick programs really that fast? We have a small one for that Benchmark test written: With the help of the "Sieve of Eratosthenes" the first should be in 1889 Prime numbers are determined. The corresponding basic program takes 363 seconds for this, while the QUICK program ends after 6 seconds!

    W teście napisanym przeze mnie (nie znalazłem źródeł implementujących SIEVE w Quick) w jednym przebiegu mamy takie czasy:

    Quick 1.6 : 202 ticks - 4,04 sek.
    Quick 2.2 : 220 ticks - 4,40 sek

    Więc z trochę przyspieszyłem ;)

    Nosiłem się z zamiarem kupna tego pakietu Quick za $5 ale niemożliwość pisania na H6 bo pliki modyfikowane w zewnętrznych edytorach Quick nie czyta poprawnie, ograniczenia względem Action! oraz 2x wolniejszy od niego kod sprawiają, że zapał mi ostygł.

    Może kupię jak @tooloudtoowide pozytywnie zrecenzuje pakiet jako całość? Albo sam znajdę coś unikalnego w tej produkcji co skłoni mnie do zakupu.
    • 27: CommentAuthorilmenit
    • CommentTime23 Feb 2020
     
    Aktualnie testy Millforka muszą niestety poczekać, bo przy kompilowaniu bardziej skomplikowanych programów na platformę a8, niż te w przykładach, kompilator się wywala :-(
    • 28: CommentAuthorilmenit
    • CommentTime23 Feb 2020 zmieniony
     
    @tebe - to nie żal do autora, ale próba zwiększenia obiektywizmu testów ;)
    W wolniejszej chwili napiszę artka o tym jak pisać efektywnie w C (z użyciem CC65 na 6502), bo patrząc na różne przykłady (nie tylko z Millforka) i co w nich jest (post-increment, skryte rzutowanie typów, zmienne tymczasowe zamiast stałych, skomplikowane ify zamiast masek bitowych, tablice struktur) mam wrażenie, że taka wiedza odchodzi w zapomnienie.
    • 29: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    @ilmenit a może machniesz YoshPlus w Lightspeed C, Deep Blue C na A8?
    • 30: CommentAuthorilmenit
    • CommentTime23 Feb 2020
     
    @zbyti - niestety, nie w najbliższym czasie. Forever Party się zbliża i chcę dokończyć co na ten event.
    • 31: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    @ilmenit szkoda, spróbuję sam. To powodzenia życzę w kończeniu produkcji na party! :]

    Jak napiszesz artykuł o którym wspominasz to ja się wtedy nauczę C. Do tego czasu Mad Pascal będzie tłuczony u mnie na warsztacie ;)
  32.  
    @zbyti, kupiłem ten cały pakiet za 7EUR, bardziej z ciekawości niż jakiejkolwiek potrzeby. Tak jak już pisałem - w Action! próbuję na siłę "bo tak" i bo to jedna z rzeczy z kupki wstydu z lat 80tych. cc65 jest dla mnie jedyną sensowną alternatywą w tej chwili z racji tego, że staram się używać z88dk do pewnych projektów (choć wolałbym asm - tylko tutaj kuleje bardzo brak doświadczenia z tym).

    Opiszę całą zawartość pakietu - bo niewiele wynika z tych lakonicznych opisów na stronie sprzedawcy. Quick jest chyba łatwiejszą wersją niż Action! przy przeskakiwaniu bezpośrednio z BASICa, ale brakuje tutaj jednej podstawowej rzeczy - społeczności czyli ludzi, których możesz zapytać "dlaczego nie działa i jak zrobić, żeby działało". W przypadku Action! powstało jednak sporo dokumentacji, które pomagają.
    • 33: CommentAuthorilmenit
    • CommentTime23 Feb 2020 zmieniony
     
    MadPascal to też bardzo dobra opcja i te X procent różnicy w szybkości nie robi aż takiej różnicy, biorąc pod uwagę, że i tak krytyczne czasowo rzeczy warto przepisać na asm :)
    • 34: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    @tooloudtoowide chętnie przeczytam opis tego pakietu

    @ilmenit gdybym umiał przepisać w asm rzeczy krytyczne czasowo to... ;) Ale od czegoś trzeba zacząć :] Języki wysokiego poziomu i takie zabawy pozwolą mi oswoić się z mapą pamięci A8 i ze specyfiką układów graficznych A8.

    A jak już się nauczę tego co potrzebuje to w tym czasie Mad Pascal zrobi kolejny krok naprzód :]
    • 35: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    W instrukcji Quick jeden przebieg w SIEVE dla BASIC trwa 363 sekund.

    Ciekawe o co chodzi na poniższym? Tak czy inaczej różnica nie jest tak duża jak w przypadku Quick czy Action! z tych natywnych.
    • 36: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    Lightspeed C & SIEVE kod był na drugiej dyskietce programu.
    /* PRIME.C */
    /* The sieve of Eratoshenes Prime number benchmark */
      
    #define TRUE 1
    #define FALSE 0
    #define SIZE 8190
    #define COUNT 10
      
    char flags[SIZE+1];
      
    main() $(
      int i,prime,k,count,iter;
      printf("%d iteration%s\n",COUNT,(COUNT == 1) ? "." : "s.");
      fast(); /* turn off the screen */
      clrtime(); /* reset the system clock */
      for(iter=1;iter <= COUNT;++iter) $(
        count=0;
        for(i=0;i <= SIZE;++i) flags[i]=TRUE; /* could use setblock(flags,SIZE,1); */
        for(i=0;i <= SIZE;++i) $(
          if(flags[i]) $(
            prime=i+i+3;
            for(k=i+prime;k<=SIZE;k += prime) flags[k]=FALSE;
            ++count;
          $)
        $)
      $)
      k=gtime()/60; /* time in seconds */
      slow(); /* turn on the screen */
      printf("%d primes in %d seconds\n",count,k);
    $)

    Według informacji (co widać wyżej) na okładce podręcznika kod wykonuje się 4:49 a w źródle widać, że chodzi o 10 iteracji i to przy wyłączonym ekranie.

    W takim razie nie będę sprawdzał natywnego C na A8.

    Dziwi mnie tylko rozbieżność między czasem podanym na okładacie Lightspeed C dla BASIC a tym co podając twórcy Quick. Bo wyniki mocno się różnią.
    • 37: CommentAuthorzbyti
    • CommentTime23 Feb 2020 zmieniony
     
    Dla zainteresowanych biblioteki dla Action! przygotowane przez twórców Lightspeed C na .atr wraz w opisem wyjętym z instrukcji.

    Do działania wymagany jest Lightspeed DOS.
    • 38: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    FastBasic 4.0 FBI czyli na liczbach całkowitych w teście SIEVE:

    ? "Starting!"
    NumIter = 10
    sTime = TIME
    ' Arrays are initialized to 0
    DIM A(8190) Byte
    FOR Iter= 1 TO NumIter
      MSET Adr(A), 8190, 0
      Count = 0
      FOR I = 0 TO 8190
        IF NOT A(I)
          Prime = I + I + 3
          FOR K = I + Prime TO 8190 STEP Prime
            A(K) = 1
          NEXT K
          INC Count
        ENDIF
      NEXT I
    NEXT Iter

    eTime = TIME
    ? "End."
    ? "Elapsed time: "; eTime-sTime; " in "; NumIter; " iterations."
    ? "Found "; Count; " primes."

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    FastBasic FBI  YoshPlus:  1458 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    Quick 2.2       Chessboard: 27 iterations in 150 ticks
    Quick 1.6       Chessboard: 16 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Mad Pascal         SIEVE:  739 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    Quick 1.6          SIEVE: 2022 ticks in 10 iterations
    Quick 2.2          SIEVE: 2199 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    FastBasic FBI      SIEVE: 6312 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 39: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    To jeszcze update YoshPlus dla FastBasic 4.0.

    CC65           YoshPlus: 41844 iterations in 100 ticks
    Mad Pascal     YoshPlus: 35572 iterations in 100 ticks
    Action!        YoshPlus: 33239 iterations in 100 ticks
    Quick 2.2      YoshPlus: 21320 iterations in 100 ticks
    Quick 1.6      YoshPlus: 16242 iterations in 100 ticks
    PL65           YoshPlus:  4708 iterations in 100 ticks
    FastBasic FBI  YoshPlus:  2427 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:   715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:   487 iterations in 100 ticks

    CC65            Chessboard: 76 iterations in 150 ticks
    Mad Pascal      Chessboard: 40 iterations in 150 ticks
    Action!         Chessboard: 35 iterations in 150 ticks
    Quick 2.2       Chessboard: 27 iterations in 150 ticks
    Quick 1.6       Chessboard: 16 iterations in 150 ticks
    PL65            Chessboard: 12 iterations in 150 ticks

    MADS (opt)         SIEVE:  440 ticks in 10 iterations
    CC65 (opt)         SIEVE:  602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:  644 ticks in 10 iterations
    Mad Pascal         SIEVE:  739 ticks in 10 iterations
    Action!            SIEVE: 1003 ticks in 10 iterations
    Quick 1.6          SIEVE: 2022 ticks in 10 iterations
    Quick 2.2          SIEVE: 2199 ticks in 10 iterations
    PL65               SIEVE: 3853 ticks in 10 iterations
    FastBasic FBI      SIEVE: 6312 ticks in 10 iterations
    fig-Forth 1.1      SIEVE: 8482 ticks in 10 iterations
    • 40: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    Mamy pytanie.

    Quick 2.2 SIEVE: 2199 to wynik uzyskany przy kompilacji do RAM podczas pracy z narzędziem.

    SIEVE skompilowane do COM ma już różne czasy w zależności spod jakiego DOS jest uruchamiany.

    Pod Sarta DOS X 4.48 wynik jest 2892 tików a pod OSS DOS XL 2.35 to 2483. Czyli wolniej niż w "środowisku Quick", do tego jest znacząca różnica między DOS-ami.

    Jak to wytłumaczyć?
    • 41: CommentAuthortebe
    • CommentTime24 Feb 2020
     
    jak tłumaczyć? a masz na początku synchronizację z ramką? bez tego za każdym razem zaczynasz od innego miejsca w czasie

    kiedy odpalasz bezpośrednio z PC to nie ma znaczenia, ale na prawdziwym sprzęcie będzie miało znaczenie
    • 42: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    @tebe wszystko na emulatorze atari800.

    Co prawda masz rację z tą synchronizacją, ale jako jedyny zwróciłeś na to uwagę. Widziałem wiele oryginalnych benchmarków w różnych językach jakimi się bawiłem w tym wątku i nikt tego nie robi :]

    Poniżej SIEVE w Qick 2.2. Pierwszy ekran to kod kompilowany do RAM, dwa pozostałe skompilowane do COM i puszczone pod różnymi DOS-ami.

    .atr jakby ktoś sam chciał się przekonać w załączniku.

    Sparta DOS X oddaj wynik chyba po przełączeniu się w jakieś turbo.

    Wyniki są powtarzalne, przy wielokrotnym puszczeniu bez restartu komputera. Co najwyżej brak synchronizacji mogłoby skutkować od kilku do kilkudziesięciu ramek różnicy ale na pewno nie kilkuset, nie?
    • 43: CommentAuthorantrykot
    • CommentTime24 Feb 2020
     
    Masz race condition przy zerowaniu zegara i przy odczycie też.
    • 44: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    Chmmm...

    Pod Sparta DOS X coś idzie nie tak bo znalazł więcej liczb pierwszych!

    Dopiero zauważyłem, że zamiast 1899 jest ich tam 1926 czyli wynik niepoprawny.

    To by oznaczało, że Sparta nadpisuje tablicę z flagami w pamięci... Albo wartość którejś ze zmiennych.

    Ja sobie zajmuję pamięć z ręki na "tablicę" od $8000 do $9FFE.

    Jak Sparta robi coś w tym obszarze to może zmienić wynik. Tylko to chyba nie jest DOS z multitasking więc kiedy miałby to zrobić?

    To jest przestrzeń na coś rezerwowana? Mam ustawione Atari 130XE + 320 Rambo.

    EDIT: po ustawieniu Atari 800XL 64KB i użyciu Sparty ten sam błąd.

    Jeszcze inny DOS i wynik prawidłowy a czas jak po kompilacji do RAM.
    • 45: CommentAuthortebe
    • CommentTime24 Feb 2020 zmieniony
     
    pod Spartą, uruchamiaj przez X
    X filename
    • 46: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    @tebe dzięki, z tym X już program działa bez "turbo" i poprawnie.

    To teraz tylko ten DOS II+ odstaje od reszty, ale po prostu go oleję na przyszłość ;)
    • 47: CommentAuthorilmenit
    • CommentTime24 Feb 2020
     
    czym się w Sparcie różni X od nie X?
    • 48: CommentAuthormono
    • CommentTime24 Feb 2020
     
    X odłącza Spartę w związku z czym ładuje wyłącznie standardowe .COM/.XEX ponieważ nie ma wtedy funkcji SDX.
    • 49: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    Nie miałem o tym pojęcia.
    LOAD /X will execute the file under the control of X.COM (equivalent to the command 'X fname').

    @mono ale dlaczego bez X zaburza pracę programu i daje zły wynik w zliczonych liczbach pierwszy?
    • 50: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    Tabelka by nie była zupełna bez żółwika :]

    435,4 sekundy na jeden przebieg.

    Kod przepisany z ANALOG 84/2 z kursu Action! Ponoć autor art. twierdzi, że można go przyspieszyć o 30% ale nie podał jak. Ja z kodem nic nie kombinowałem bo wygląda na taką samą implementację jak w pozostałych językach.

    Kod puszczony 1x, do tabelki idzie wynik pomnożony przez 10, i tak leciałem na F12 w atari800 ;)

    435,4 sekundy na jeden przebieg.

    CC65           YoshPlus:   41844 iterations in 100 ticks
    Mad Pascal     YoshPlus:   35572 iterations in 100 ticks
    Action!        YoshPlus:   33239 iterations in 100 ticks
    Quick 2.2      YoshPlus:   21320 iterations in 100 ticks
    Quick 1.6      YoshPlus:   16242 iterations in 100 ticks
    PL65           YoshPlus:    4708 iterations in 100 ticks
    FastBasic FBI  YoshPlus:    2427 iterations in 100 ticks
    fig-Forth 1.1  YoshPlus:     715 iterations in 100 ticks
    CLSN Pascal    YoshPlus:     487 iterations in 100 ticks

    CC65            Chessboard:   76 iterations in 150 ticks
    Mad Pascal      Chessboard:   40 iterations in 150 ticks
    Action!         Chessboard:   35 iterations in 150 ticks
    Quick 2.2       Chessboard:   27 iterations in 150 ticks
    Quick 1.6       Chessboard:   16 iterations in 150 ticks
    PL65            Chessboard:   12 iterations in 150 ticks

    MADS (opt)         SIEVE:    440 ticks in 10 iterations
    CC65 (opt)         SIEVE:    602 ticks in 10 iterations
    Mad Pascal (opt)   SIEVE:    644 ticks in 10 iterations
    Mad Pascal         SIEVE:    739 ticks in 10 iterations
    Action!            SIEVE:   1003 ticks in 10 iterations
    Quick 1.6          SIEVE:   2022 ticks in 10 iterations
    Quick 2.2          SIEVE:   2199 ticks in 10 iterations
    PL65               SIEVE:   3853 ticks in 10 iterations
    FastBasic FBI      SIEVE:   6312 ticks in 10 iterations
    fig-Forth 1.1      SIEVE:   8482 ticks in 10 iterations
    BASIC              SIEVE: 217700 ticks in 10 iterations

Od 101 do 150 z 242

  1. <
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. >