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 17:04
       
      @Cyprian fajny instruktażowy kod :]

      Wklejaj go też może w BB kody tego forum? Fajnie się czyta :]
      • 2:
         
        CommentAuthorCyprian
      • CommentTime16 Apr 2020 18:04
       
      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 18:04 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 12:04
       
      Polling rejestru KBCODE jest błędem, albowiem jego wartość jest sensowna tylko wtedy gdy naciśnięto jakiś klawisz.
      • 5:
         
        CommentAuthorCyprian
      • CommentTime17 Apr 2020 12:04
       
      @antrykot ok, co proponujesz zamiast tego?
      • 6:
         
        CommentAuthorshanti77
      • CommentTime17 Apr 2020 12:04 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 13:04
       
      dzięki
      • 8:
         
        CommentAuthorjhusak
      • CommentTime18 Apr 2020 09:04 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 18:04 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 19:05 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 20:05
       
      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 21:05 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 18:06
       
      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. >