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: CommentAuthorurborg
    • CommentTime24 Feb 2020
     
    @zbyti
    Zoptymalizowałem lekko ten program w basicu :)
    • 2: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    @urborg nieźle! :]

    A wrzucisz jeszcze wyniki dla Turbo-BASIC XL w wersji skompilowanej i bez kompilacji?

    Wtedy podbiję tabelkę :]
    • 3: CommentAuthorxxl
    • CommentTime24 Feb 2020
     
    no ale skoro optymalizowac to zamiast:

    f.i=1to8191:flag$(i,i)="T":n.i

    prosze zapisac:

    flag$="T":flag$(8191)=flag$:flag$(2)=flag$

    zdaje sie od zawsze ten trik dziala...
    • 4: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    @xxl zaraz to przetestuję.

    Na razie w Turbo-BASIC XL mam takie wyniki jak na obrazkach. Drugi listing to kod na wzór tego co zrobiłem w Quick nie mając tam tablic.

    Umiem kod skompilować w TB ale nie potrafię za pomocą tego co pobrałem z netu użyć linkera. Wiec wyniki dla wersji nieskompilowanej.

    Skoro idziemy na szybkość to do tabelki pójdzie dla BASIC i TB kod z POKE&PEEK.

    Jak ktoś umie to linkować to kod na dyskietce w załączniku.
    • 5: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    Czysty BASIC po przejściu z dwuymiarowej tablicy na Poke&Peek. Chyba taką innowację miał na myśli autor wspomnianego art. że napisał że można szybciej.

    Sądzę, że któraś z osób śledzących ten wątek potrafi jeszcze szybciej w samym BASIC-u.

    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
    Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
    BASIC SIEVE: 170700 ticks in 10 iterations
    • 6: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    OK. Udało mi się użyć linkera do Turbo-BASIC XL. Trochę się naszukałem "czegoś" co działa "po ludzku" ;)

    No to ostateczne wyniki. Każdy inny to już jak ktoś przeprowadzi własne testy.

    Wyniki dla TB tak jak dla BASIC jeden przebieg x10.

    Skończyłem zabawę :]

    EDIT:
    Zszedłem w BASIC do około godziny na 10 powtórzeń dla SIEVE co jest zgodne z tym co napisali w swoim manualu twórcy Qick 2.0. Na okładce Lightspeed C jest dla BASIC 31 min co bardziej wygląda (co do minuty) na nieskompilowaną wersję SIEVE w TB z użyciem DIM a nie POKE&PEEK.

    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
    Turbo-BASIC XL [C] SIEVE: 16710 ticks in 10 iterations
    Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
    BASIC SIEVE: 170700 ticks in 10 iterations
    • 7: CommentAuthorurborg
    • CommentTime24 Feb 2020
     
    @zbyti

    Turbobasicem chętnie bym się pobawił w optymalizację ale dziś nie mam czasu i jutro pewnie też nie dam rady. Zdaje się że w turbo basic możnaby przyśpieszyc kod pozbywając się wszystkich instrukcji goto i zastępując je skokami do procedur.
    • 8: CommentAuthorzbyti
    • CommentTime24 Feb 2020 zmieniony
     
    @urborg to już niech zostanie tak jak jest :]

    Poniżej tabelka do "interpretacji" :D
    • 9: CommentAuthormono
    • CommentTime24 Feb 2020
     

    zbyti:

    ale dlaczego bez X zaburza pracę programu i daje zły wynik w zliczonych liczbach pierwszy?

    Trudno powiedzieć. Podeślij plik to zobaczymy co on robi. Może w SDX jest jakiś bambol.
    • 10: CommentAuthorzbyti
    • CommentTime24 Feb 2020
     
    @mono w złączniku
    • 11: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Nie testowałem ale według informacji z okładki Lightspeed C to SIEVE w 10 iteracjach i przy wyłączonym ekranie miał:

    Lightspeed C  4:49 min 14450 ticks
    Deep Blue C 9:00 min 27000 ticks
    BASIC 31:00 min 93000 ticks

    Tylko to chyba robi różnicę czy PAL czy NTSC? Nie podano. Ja na ticks przeliczyłem * 50.

    Wyłączony ekran daje (z doświadczenia w Action!) około 25% mocy więcej dla CPU.

    Ciekawe jaki magik napisał to w BASIC tak by jechało tylko 31 min?! Nawet przy wyłączonym ekranie...
    • 12: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Atalan ->link<-
    RTCLOCK@20:byte

    const SQRT_COUNT = 91

    top:0..8191
    sieve:array(top) of 0..1
    k,j,prime:top
    start,time:byte

    "Computing primes..."

    for k
    sieve(k) = 1

    RTCLOCK = 0

    for i:2..SQRT_COUNT where sieve(i) = 1
    j = i * 2
    while j<=8191
    sieve(j) = 0
    j = j + i

    time = RTCLOCK

    "Time used: [time] ticks"
    "Press Q to quit, any other key for list"

    CH = none
    until CH <> none

    for k where sieve(k) = 1 until CH = Q
    "[k]"

    CH = none

    ; Sieve of Erastosthenes
    ; Demo program for ATALAN programming language
    ;(c) 2010 Rudla Kudla
    ;
    ;This version uses bit array so it can find primes up to $ffff.

    use atari
    out rtclock1@20:byte
    out rtclock2@19:byte

    ;Maximum possible prime number.

    const max_prime = $ffff

    const bmax = max_prime/8
    count:0..max_prime

    const
    mask:array(0..7) = 1,2,4,8,16,32,64,128
    maskx:array(0..7) = %1111'1110,%1111'1101,%1111'1011,%1111'0111,%1110'1111,%1101'1111,%1011'1111,%0111'1111

    flags:array(bmax)

    rtclock1 = 0
    rtclock2 = 0

    for i:0..bmax flags(i)=$aa

    for i:3..sqrt max_prime step 2 where (flags(i/8) bitand mask(i mod 8) <> 0)
    for k:i*i..max_prime step 2*i
    flags(k/8) = flags(k/8) bitand maskx(k mod 8)

    count = 1
    for k:3..max_prime step 2 where (flags(k/8) bitand mask(k mod 8) <> 0)
    inc count

    t = rtclock2 * 256 + rtclock1

    "[count] prime numbers in [t] ticks"

    No to mamy nowego pretendenta ;) Chyba algorytm jest tutaj sprytniejszy, po nocy nie będę analizował ;)

    EDIT:
    Jak opanuję podstawy języka to przepiszę na "nasz" i wrzucę do zestawienia :]
    • 13: CommentAuthorilmenit
    • CommentTime25 Feb 2020
     
    Trzeba by przepisać na ten sam algo...
    • 14: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    @ilmenit mówisz o Atalan? Dopiero się o nim dowiedziałem, jak go ogarnę to przepiszę ;) Powyższy kod jest z dolączonych przykładów.

    Ogarniałem te z listy na stronie ->link<- a tam nie widnieje w spisie, albo coś przeoczyłem.

    No to wyedytuję post i słowo "mistrz" zamienię na "pretendent" ;)
    • 15: CommentAuthorilmenit
    • CommentTime25 Feb 2020
     
    Haha :D Zbyti, dla mnie to jeden z najciekawszych wątków od dawna!
    • 16: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    @ilmenit cieszę się bo myślałem, że nudzę starych wyjadaczy swoją amatorszczyzną ;) Dla mnie to sposób by się "oswoić" z Atari :]
    • 17: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Wersja SIEVE dla TBA z przerzuceniem wartości do zmiennych jest wolniejsza od tej z liczbami zabitymi na sztywno w interpretatorze o 16 ticks ale skompilowana już szybsza o 38 ticks dla jednego przebiegu.
    • 18: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    To jeszcze paczuszka, z większością źródeł używanych w testach jaką wrzuciłem na atariage.

    Użyte zostały oficjalne, najnowsze wydania języków na dzień 20.02.2020.
    • 19: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    O dziwo wynik, na C64 w jednym przebiegu jest praktycznie ten sam co na A8 (zakładam, że wrzucenie zmiennych na początek zrobiło podobny narzut interpreterowi jak na A8).
    • 20: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Niezła dopałka BASIC V2 na C64 to MOSpeed.

    Do obadania ->link<- i tutaj ->link<- puszczone skryptem mospeed.sh z paczki bez żadnych dodatkowych flag.

    10 rem * c64 sieve
    11 a=4096*2:c=8190:b=a+c
    12 poke 161,0:poke 162,0:count=0
    13 for i=a to b:poke i,1:next i
    14 for i=a to b
    15 if peek(i)=0 then 20
    16 ia=i-a:prime=ia+ia+3:k=ia+prime
    17 if k>c then 19
    18 poke k+a,0:k=k+prime:goto 17
    19 count=count+1
    20 next i
    21 print peek(162)+256*peek(161);" jiffies"
    22 print count;" primes"


    • 21: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Jak widzę @jhusak napisał w Atlanie grę 10 lat temu. Normalnie Leonardo, tak jak o nim mówią ;)

    Atlan dla linuxsiarzy ->link<-

    Niestety nie działa "z pudełka" :(

    Building esieve.atl...

    atari.atl(320) Syntax error: Expected instruction or string

    rule proc %A:rasterProc =
    ^

    Coś jest dokumentnie zdygane w tej wersji z GitHuba. Nie pobawię się widzę... Gość co wystawił te repo, nawrzucał zmiana dla C64 ale dla Atari coś spier...
    • 22: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Rzuciłem okiem na art. ->link<- i odnalazł się kolejny szybki BASIC, ADVAN zakończył test z wynikiem na poziomie zbliżonym do FastBasic.

    A ponoć jeszcze jest ADVAN OPTIMIZER który ma być 120x szybszy od zwykłego BASIC'a. Plasował by się wtedy zaraz za Action w naszej tabelce.

    Advan BASIC was already pretty fast. Now it's the fastest BASIC in Atari history. In our Sieve Benchmark, the Advan Optimizing Compiler is about four times faster than the MMG Compiler, six times faster than regular Advan, 20 times faster than compiled Turbo-BASIC XL and 120 times faster than uncompiled Atari BASIC. In fact, it's more than half the speed of ACTION!- that's getting real close to pure assembly language.


    Na screenach wersja regular. Algorytm chyba lekko sprawniejszy, ale nie mam siły już tego przepisywać na inne BASIC-i ;)
    • 23:
       
      CommentAuthorjhusak
    • CommentTime25 Feb 2020
     
    O co chodzi z tym Leonardem?

    Z atalanem - jest problem, bo całe repo było na svn, czyli cała historia poszła w ....
    Nie wiem, czy jest to do odzyskania.

    Natomiast po swojej stronie mam kilka "snapshotów", coś ponad 10 z różnych stadiów.

    Problem zaczął się, gdy Rudli wybuchł przyjęty model (wzorce generowanego kodu w zależności od typów parametrów) przy wprowadzaniu 3-bajtowych liczb.

    Rozmawiałem z Rudlą nt. przyjętego rozwiązania (nie używał narzędzi typu bison, byacc), napisał, że "chce mieć wszystko pod kontrolą" - jak widać kontrola mu się i tak rozjechała tak, że się znudził (czy jakoś tak) projektem.
    • 24: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    @jhusak no za Leonarda mają Cie Kaz & TDC ;) Ale nie tego z TBBT :D

    Dzięki za obszerniejsze info o Atalanie, strasznie się napaliłem ale nijak nie mogę tego uruchomić na A8 jako target :(

    -------------

    A teraz ADVAN OPTIMIZER w akcji! Gdyby zrobić 10 iteracji to wynik po przeliczeniu odpowiada temu z Action! i wynosi 1050 ticks!

    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
    Advan BASIC (opt) SIEVE: 1050 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
    Advan BASIC SIEVE: 6800 ticks in 10 iterations
    fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
    Turbo-BASIC XL [C] SIEVE: 16710 ticks in 10 iterations
    Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
    BASIC SIEVE: 170700 ticks in 10 iterations
    • 25:
       
      CommentAuthorjhusak
    • CommentTime25 Feb 2020 zmieniony
     
    A z tym esieve.atl skompilowałem starutką wersją v29 i wyszło 38 ticks na 1 obrót, co daje ~380 ticks na 10. I tak jest świetnie.
    Z tego wynika, że najprawdopodobniej podejście Rudli jest najlepsze do generowania kodu na 6502.
    Jest taka strona ->link<- pokazująca i opisująca różne rozwiązania kompilatorów wyżej czy niżejpoziomowych.
    • 26: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    @jhusak ale tam jest inny algorytm, jakbyś go przerobił na ten używany przez nas to było by to lepsze do porównania.

    Jest wyżej paczka z kodami to możesz sobaczyć sieve w kilu językach, jeżeli miałbyś czas i chęć przenieść na Atalane.

    Wiem, że tyle wychodzi bo sobie asm skompilowałem ;) Chciałem przerobić ale nie mam jak :[
    • 27:
       
      CommentAuthorjhusak
    • CommentTime25 Feb 2020
     
    Spróbuję w wolnej chwili przerobić, tylko muszę sobie przypomnieć :)
    • 28: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    No i algorytm panów od Advan Basic jest bardzo szybką opcją :] Turbo BASIC XL nieskompilowany przyspieszył o ~30% :] Za to skompilowana zwolniła :D

    Nie odmówię sobie jednak i w wolnej chwili po przepisuję ten benchmark :] Ale tabelki już nie podbijam.

    Teraz widzę, że FastBasic używa tego samego algorytmu co Advan Basic więc i tak tabelka do przepisania ;)
    • 29: CommentAuthorilmenit
    • CommentTime25 Feb 2020
     
    Problem zaczął się, gdy Rudli wybuchł przyjęty model (wzorce generowanego kodu w zależności od typów parametrów) przy wprowadzaniu 3-bajtowych liczb.

    Możesz napisać coś więcej? Podejście w Atalanie do generacji kodu było całkiem ciekawe (choć nie nowe, artykuł o podobnym sposobie z 1968 roku ->link<- ;) ).
    Kiedyś nawet myślałem, żeby do tego projektu dołączyć i zrobić superoptimizer dla 6502 na styl ->link<- . Teraz widzę, że nie byłem jedyny i już są projekty takie dla 6502 np. ->link<-
    • 30: CommentAuthorzbyti
    • CommentTime25 Feb 2020 zmieniony
     
    Podbijam prośbę @ilmenit :]

    --------------------------------------------------

    Atari Basic na nowym algo :]
    • 31: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    Sprawa okazuje się odwrotna, tylko dla Atari Basic, Turbo Basic XL (nawet usprawniając kod przepisany z ANALOGU) miałem inną implementację niż reszta paczki.

    Action! Pascal i inne mają taką jak Advan Basic czy FastBasic także co było do poprawienia to już poprawiłem, więc uzupełnię tabelkę od razu :]
    • 32: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    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
    Advan BASIC (opt) SIEVE: 1050 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
    Advan BASIC SIEVE: 6800 ticks in 10 iterations
    fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
    Turbo-BASIC XL [C] SIEVE: 16880 ticks in 10 iterations
    Turbo-BASIC XL SIEVE: 46060 ticks in 10 iterations
    BASIC SIEVE: 133960 ticks in 10 iterations
    • 33: CommentAuthorilmenit
    • CommentTime26 Feb 2020 zmieniony
     
    @zbyti - może warto by zmienić "MADS" na "Asm (MADS) (opt)"?
    • 34: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    @ilmenit zrobię tak jeżeli dostanę wyniki z innego assamblera. Na ten moment nie mam go od czego odróżniać :]

    Znalazłem właśnie fajną stronkę ->link<- szkoda, że nie zaszukałem wcześniej :]

    -----------------------------------------------------------

    Tymczasem, by sobie jednak porównać z Atalanem wklepię to:

    DIM n AS Integer, k AS Integer, limit AS Integer

    INPUT "Enter number to search to: "; limit
    DIM flags(limit) AS Integer

    FOR n = 2 TO SQR(limit)
    IF flags(n) = 0 THEN
    FOR k = n*n TO limit STEP n
    flags(k) = 1
    NEXT k
    END IF
    NEXT n

    ' Display the primes
    FOR n = 2 TO limit
    IF flags(n) = 0 THEN PRINT n; ", ";
    NEXT n
    • 35: CommentAuthorilmenit
    • CommentTime26 Feb 2020 zmieniony
     
    @zbyti - wyniki zależnie od asemblera różnić się nie będą. To w końcu kod maszynowy.

    A oto i Millfork 0.3.14, który wychodzi na prowadzenie ;)

    Chessboard nie zmienia tryby graficznego, bo nie widziałem jak to prosto w tym języku napisać (wsparcie dla Atari OS jest tam aktualnie minimalne), ale nie powinno to wpływać znacząco na wynik.

    Zaskakująco słabo wypadł test Sieve. Napiszę do autora języka, czy można jakoś zoptymalizować ten kod pozostawiając algorytm.

    Rezultaty:
    Yoshplus - 41921
    Chessboard - 79
    Sieve (opt) - 701
    Sieve (non-opt) - 791
    • 36: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    @ilmenit jutro to wrzucę w tabelę. Wyniki naprawdę zachęcające!

    Każdy assembler ta taki sam kod maszynowy? Chyba to czasem się różni, makra te sprawy, ale faktycznie jakby nie używać ficzerów to wszędzie powinno być tak samo.

    Zaimplementowałem ten kod z esieve.atl.

    Przy tym samym algorytmie Mad Pascal z optymalizacją w jednym przebiegu jest 3 ticks wolniejszy od Atalana.

    Zaimplementowałem dla pewności jeszcze w Advan Basic (bez optymalizacji i z optymalizacją). Mad Pascal jest z opt.

    Ergo. Jeżeli Atalan chce się znaleźć w naszej tabelce ktoś musi napisać SIEVE po naszemu. Albo my korygujemy.

    // Eratosthenes Sieve Benchmark

    uses crt;

    {$define FAST}

    const
    size = 8191;
    sqr_count = 91;

    var
    flags: array [0..size] of boolean;
    rtClock: byte absolute $14;

    {$ifdef FAST}
    n: word absolute $e0;
    k: word absolute $e2;
    count: word absolute $e6;
    {$else}
    n, k, count: word;
    {$endif}

    begin
    writeln('Mad Pascal');
    writeln('Eratosthenes Sieve Benchmark');

    rtClock := 0;
    fillchar(flags, sizeof(flags), true);
    for n := 2 to sqr_count do begin
    if flags[n] then begin
    k := n shl 1;
    while k <= size do begin
    flags[k] := false;
    Inc(k,n);
    end;
    end;
    end;
    writeln(rtClock, ' ticks');

    count :=0;
    for n := 2 to size do begin
    if flags[n] then Inc(count);
    end;

    writeln(count, ' primes');
    repeat until keypressed;
    end.
    • 37: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    Tak dla porządku:

    There are 1229 prime numbers between 1 and 10,000. They are given here below ->link<-

    2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973.

    Czyli powinniśmy znaleźć 1028 liczb pierwszych jeżeli ostatnią ma być 8191 :]

    To znaczy, że SIEVE z naszych testów źle liczy a ten z Atalan dobrze.

    Zastanawia mnie powszechność tej złej implementacji co oddaje 1899 liczb?
    • 38: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    Millfork              YoshPlus:41921 iterations in 100 ticks
    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

    Millfork Chessboard: 79 iterations in 150 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 2.1.0 (opt) SIEVE: 440 ticks in 10 iterations
    CC65 2.1.8 (opt) SIEVE: 602 ticks in 10 iterations
    Mad Pascal 1.6.4 (opt) SIEVE: 644 ticks in 10 iterations
    Millfork 0.3.14 (opt) SIEVE: 701 ticks in 10 iterations
    Mad Pascal 1.6.4 SIEVE: 739 ticks in 10 iterations
    Millfork 0.3.14 SIEVE: 791 ticks in 10 iterations
    Action! 3.7p SIEVE: 1003 ticks in 10 iterations
    Advan BASIC (opt) SIEVE: 1050 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 4.0 FBI SIEVE: 6312 ticks in 10 iterations
    Advan BASIC SIEVE: 6800 ticks in 10 iterations
    fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
    Turbo-BASIC XL 1.5 [C] SIEVE: 16880 ticks in 10 iterations
    Turbo-BASIC XL 1.5 SIEVE: 46060 ticks in 10 iterations
    Atari BASIC SIEVE: 133960 ticks in 10 iterations
    • 39: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    Ten algorytm na liczby pierwsze który używamy w teście jest zdecydowanie do dupy. Zbiera 956 liczb parzystych ;P czyli nie wyłapuje w tych 1899 wszystkich pierwszych a za to ma połowę parzystych :D

    To się powinno nazwyać Benchmark po prostu, bo sitem Eratosthenes na pewno nie jest.

    W wolnej chwili przepiszę w tych językach co się bawiłem na poprawny algorytm.

    Zadziwia, że w prasie i dołączonych demkach do niektórych języków programowania właśnie ten poniżej był wrzucany...

    // Fake Eratosthenes Sieve Benchmark

    uses crt, sysutils;

    {$define FAST}

    const
    size = 8191;
    iter_max = 1;

    var
    flags: array [0..size] of boolean;

    iter: byte;
    starttime: cardinal;

    {$ifdef FAST}
    i: word absolute $e0;
    k: word absolute $e2;
    prime: word absolute $e4;
    count: word absolute $e6;
    {$else}
    i, k, prime, count: word;
    {$endif}

    begin

    writeln(iter_max,' iterations');

    starttime := GetTickCount;
    fillchar(flags, sizeof(flags), true);

    i:=0; count := 0;

    while i <= size do begin

    if flags[i] then begin

    prime := i shl 1 + 3;
    k := prime + i;

    while (k <= size) do begin
    flags[k] := false;
    inc(k, prime);
    end;
    inc(count);
    end;

    inc(i);
    end;

    writeln(count, ' primes');
    writeln(GetTickCount - starttime, ' ticks');

    count := 0;
    for i := 3 to size do begin
    if flags[i] then begin
    if (i mod 2) = 0 then begin write(i,' '); inc(count) end;
    end;
    end;
    writeln('');
    writeln(count, ' even numbers count');

    repeat until keypressed;

    end.

    Tak z pamięci do których języków miałem SIEVE gotowe i to był ten Fake:

    1. FastBasic (dyskietka)
    2. Advan Basic (dyskietka)
    3. Action! (z atariwiki)
    4. PL65 (z manuala)
    5. FORTH (z atariwiki)
    6. MADS (ze źródłami)
    7. Mad Pascal (ze źródłami)
    8. Lightspeed C (dyskietka)

    Także dość powszechny jest ten zły algorytm :]
    • 40: CommentAuthortebe
    • CommentTime26 Feb 2020
     
    liczy się algorytm, skoro był ten sam to liczył to samo

    jedynie nie zgadza się nazwa algorytmu :)
    • 41: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    @tebe ale to mamy takie kuriozum jak na okładce manuala do Lightspeed C :D

    Załączony przez nich na dyskietce benchmark SIEVE to ten nasz fejk, ale porównują go do wyniku BASIC'a który u nich wyrabia się w 31 min co oznacza, że ten algo do BASIC'a musieli już mieć poprawny. Przez co wyszło, że ich język nie jest aż tak szybki w porównaniu do BASIC'a jak w istocie jest ;)

    Ale nie kompilowałem nic pod Lithspeed C więc czy swój wynik podali poprawnie to też nie wiem. Ale na oko wygląda, że tak. Skoro sami napisali, ze są około 10x wolniejsi od Action!.

    Wygląda na to, że ktoś celowo lub nie skopał w zamierzchłych czasach tego SIEVE a wiele osób skopiowało tą niepoprawną implementację nie wnikając w uzyskany wynik :]

    Taka moja teoria.

    No chyba, że na jakiejś konfie w 1978 uznano skopanego SIEVE za standard do testowania wydajności z pełną świadomością jego wady :]
    • 42: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    No to wprowadzam podział na FAKE i REAL
    • 43: CommentAuthortebe
    • CommentTime26 Feb 2020
     
    odkryłeś trupa w szafie ;)
    • 44: CommentAuthormav
    • CommentTime26 Feb 2020
     
    Podoba i jednocześnie niepokoi mnie stan zaangażowanego zbytiego ;)
    • 45: CommentAuthorzbyti
    • CommentTime26 Feb 2020
     
    @mav to jest nas dwóch :D
    • 46: CommentAuthortebe
    • CommentTime26 Feb 2020
     
    nie ma oficjalnie wydanej wersji MP 1.6.4, jest tylko 1.6.3

    wersja 1.6.4 nie uzyskuje wyniku 644 dla Fake Sieve
    • 47: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    @tebe u mnie na atari800 Ubuntu osiąga 644 i jest to wynik powtarzalny po wystartowaniu emulatora.

    Mad Pascal Compiler version 1.6.4 [2020/02/02] for 6502

    Od dłuższego czasu mam tę wersję, nie wiedziałem, że jeszcze nie jest publiczna.

    Jak dodam pause to 649. Ale praktycznie nigdzie tego nie robię. Tylko w MadP Chessboard wołam pause jeszcze. Oszacowanie mnie interesuje, przy 10 iteracjach te 5 ramek nie zmienia wyniku w tabeli.

    Proszę podaj poprawne wyniki dla właściwej wersji to zmienię.
    • 48: CommentAuthortebe
    • CommentTime26 Feb 2020
     
    przedtem w tabelce był po prostu 'Mad Pascal', teraz pojawiła się wersja, bezpieczniej bez wersji
    • 49: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    @tebe to już sam nie wiem, @ilmenit chyba chciałby z wersją.

    Ja chętnie wersję usunę bo mniej pisania ;)

    Podanie wersji pozwoli śledzić progress lub regres kompilatora.

    ----------------------------------------------

    Action! Real Sieve, jedna iteracja.

    BYTE ch=764      ; ESC = 28
    BYTE RTCLOCK2=20 ; sys timer
    BYTE RTCLOCK1=19
    BYTE ARRAY FLAGS(8191)

    PROC sieve()
    BYTE SQRCOUNT=[91]
    CARD N,K

    FOR N=0 TO 8191
    DO
    FLAGS(N)='T
    OD

    FOR N=2 TO SQRCOUNT
    DO
    IF FLAGS(N)='T THEN
    K=N*2
    WHILE K<=8191
    DO
    FLAGS(K)='F
    K==+N
    OD
    FI
    OD
    RETURN

    PROC main()
    CARD STOP,N
    CARD COUNT=[0]

    RTCLOCK1=0
    RTCLOCK2=0
    sieve()
    STOP=RTCLOCK1 * 256 + RTCLOCK2
    PRINTF("%E %U JIFFIES",STOP)

    FOR N=2 TO 8191
    DO
    IF FLAGS(N)='T THEN COUNT==+1 FI
    OD
    PRINTF("%E %U PRIMES",COUNT)

    WHILE ch=255 DO OD
    RETURN
    • 50: CommentAuthorzbyti
    • CommentTime26 Feb 2020 zmieniony
     
    Na AtariAge twórca FastBasic'a skomentował moje/nasze testy ->link<- :]

    Czyżby też się nie orientował, że SIEVE jakie dołącza do programu jest wadliwe?