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.

      • 1: CommentAuthortebe
      • CommentTime21 Feb 2020 11:02 zmieniony
       
      DOS II 6.4 jeden z popularniejszych w swoim czasie
      • 2: CommentAuthorilmenit
      • CommentTime21 Feb 2020 12:02 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 12:02 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 14:02 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 15:02 zmieniony
       
      [.] napisałem jakiś bzdury, @antrykot zwrócił mi na to uwagę w next p, zamianst p graficzka :]

      • 6: CommentAuthorantrykot
      • CommentTime21 Feb 2020 16:02 zmieniony
       
      Przecież jest podręcznik, ten co go Zientara splagiatował w cyklu o Action!
      • 7: CommentAuthorzbyti
      • CommentTime21 Feb 2020 16:02 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.
    1.  
      @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 18:02 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
    2.  
      @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 20:02
       
      @CharlieChaplin thank you! I'll test it ;]
      • 12: CommentAuthorzbyti
      • CommentTime21 Feb 2020 20:02 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 01:02 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.
    3.  
      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 12:02 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 14:02 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 14:02 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 15:02 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 16:02 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 16:02 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 17:02
       
      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 18:02 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 21:02 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 22:02 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 03:02 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 12:02 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 13:02
       
      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 14:02 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 14:02 zmieniony
       
      @ilmenit a może machniesz YoshPlus w Lightspeed C, Deep Blue C na A8?
      • 30: CommentAuthorilmenit
      • CommentTime23 Feb 2020 14:02
       
      @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 14:02 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 ;)
    4.  
      @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 15:02 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 16:02 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 17:02 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 18:02 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 19:02 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 02:02 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 03:02 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 03:02 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 10:02
       
      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 11:02 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 12:02
       
      Masz race condition przy zerowaniu zegara i przy odczycie też.
      • 44: CommentAuthorzbyti
      • CommentTime24 Feb 2020 12:02 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 14:02 zmieniony
       
      pod Spartą, uruchamiaj przez X
      X filename
      • 46: CommentAuthorzbyti
      • CommentTime24 Feb 2020 14:02 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 15:02
       
      czym się w Sparcie różni X od nie X?
      • 48: CommentAuthormono
      • CommentTime24 Feb 2020 16:02
       
      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 16:02 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 17:02 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