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

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

  • :
  • :

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

1. Projekty / Projects  »   Języki programowania - testy

W dół

Od 151 do 163 z 163

  1. <
  2. 1
  3. 2
  4. 3
  5. 4
  6. >
    • 1: CommentAuthorzbyti
    • CommentTime16 Apr 2020
     
    @Cyprian fajny instruktażowy kod :]

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

    A8:
    // MAD Assembler

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

    Licznik	= $0a+$80
    Licznik2	= 10


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


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


    	InitHW


    	BeepOFF


    	WaitForKbd


    	lda	#Licznik2	// Test counter
    	sta	Licznik


    	BeepON


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

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

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


    //LZ4 go
    		jsr	lz4_decode


    		dec	Licznik
    		beq	Neverending_Loop


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

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

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


    //LZ4 go
    		jsr	lz4_decode


    		dec	Licznik
    		beq	Main_Loop_End


    	jmp	Main_Loop
    Main_Loop_End:


    	BeepOFF


    Neverending_Loop:
    		nop
    	jmp Neverending_Loop

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


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


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


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

    LZ4_DataC64:
    	ins "C64_IMAGE_STRIP.LZ4"
    LZ4_Data_EndC64:


    .macro InitHW
    	// lda #0
    	// sta $D400		// ANTIC OFF
    	
            lda #<DisplayList
            sta $D402
            lda #>DisplayList
            sta $D402+1
    .endm

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

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

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

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

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

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

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

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

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

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

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

    Action
    SETBLOCK(FLAGS,8190,'T)

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

    BYTE RTCLOCK2=20 ; sys timer
    BYTE RTCLOCK1=19

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

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

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

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

    PROC main()
     BYTE I=[0]

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

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

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

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

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

    Z 40 wyrysowań skoczył na 55.

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

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

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

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

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

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

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

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

      pause;
      rtClock := 0;
      
      while rtClock < 150 do begin
        drawBoard;
        inc(i);
      end;
     
      stop:=rtClock;
      
      InitGraph(0);
      writeln('Drawing iterations: ', i);
      ReadKey;
    end.
    • 12: CommentAuthorzbyti
    • CommentTime31 May 2020 zmieniony
      
    Millfork            Chessboard:   79 iterations in 150 ticks
    CC65                Chessboard:   76 iterations in 150 ticks
    Mad Pascal          Chessboard:   73 iterations in 150 ticks

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



    program chessboard;
    uses crt, graph;

    {$define FAST}

    var stop                          : byte;
        rtClock                       : byte absolute 20;
        col1                          : byte absolute 709;
        col2                          : byte absolute 710;
        colB                          : byte absolute 712;
        bmpAdr                        : word absolute 88;
        
    {$ifdef FAST}
        i                             : byte absolute $e0;
    {$else}
        i                             : byte;
    {$endif}


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

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

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

    wynik dla CHESSBOARD = 79

Od 151 do 163 z 163

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