home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / tt / vmem11 / vmem_prg / vmem_ass.s < prev    next >
Text File  |  1991-06-08  |  7KB  |  225 lines
  1.             EXPORT get_oldest
  2.             EXPORT search_cache
  3.             EXPORT write_test, read_test
  4.             EXPORT memcopy
  5. ;            EXPORT memfill
  6. ;            EXPORT memswap
  7.  
  8.             IMPORT cache_page, cache_age, cache_flags, age_count
  9.  
  10. ;*********************************
  11. ;* LRU-Seite im Cache ermitteln: *
  12. ;*********************************
  13. get_oldest:
  14.             move.l    D3,-(SP)            ; Register retten
  15.  
  16.             movea.l cache_age,A0        ; Zeiger auf Age-Bytes
  17.             lea        4(A0),A1            ; Zeiger+4 merken
  18.             move.l    A1,D0                ; als Offset merken
  19.             move.w    age_count,D3        ; Anzahl der LRU-Age-LONGS
  20.             subq.w    #1,D3                ; minus 1 wegen DBRA
  21.             moveq    #-1,D2                ; maximales Alter setzen
  22.  
  23. loop3:        move.l    (A0)+,D1            ; nächstes Age-Byte holen
  24.             cmp.l    D1,D2                ; aktuelles Alter < geringstes Alter
  25.             bls.b    jump3                ; nein !!
  26.             move.l    D1,D2                ; sonst Alter ersetzen
  27.             move.l    A0,D0                ; und Offset merken
  28.  
  29. jump3:        dbra    D3,loop3            ; alle Age-Bytes prüfen
  30.  
  31.             sub.l    A1,D0                ; Index berechnen
  32.             lsr.l    #2,D0                ; durch 4 (wegen LONG)
  33.             movem.l (SP)+,D3            ; Register restaurieren
  34.             rts
  35.  
  36. ;********************************
  37. ;* Suchen einer Seite im Cache: *
  38. ;********************************
  39. search_cache:
  40.             movea.l    cache_page,A0        ; Zeiger auf Cache-Seiten
  41.             lea        2(A0),A1            ; Zeiger+2 merken
  42. loop5:        cmp.w    (A0)+,D0            ; <vmempage> gefunden ?
  43.             bne.b    loop5                ; nein => weitersuchen
  44.             move.l    A0,D0                ; Index von <vmempage>
  45.             sub.l    A1,D0                ; in <cache_page> berechnen
  46.             lsr.l    #1,D0
  47.             rts
  48.  
  49. ;********************************************
  50. ;* Zählen der im Cache befindlichen Seiten: *
  51. ;********************************************
  52. write_test:
  53.             movea.l    cache_flags,A0        ; Tabellenanfang
  54.             adda.w    D0,A0                ; + Offset
  55.             clr.w    D0                    ; Zähler initialisieren
  56.             subq.w    #1,D1                ; - 1 wegen DBRA
  57. loop4:        btst    #1,(A0)+            ; Seite im Cache ?
  58.             beq        jump1                ; nein !!
  59.             addq.w    #1,D0                ; sonst zählen
  60. jump1:        dbra    D1,loop4
  61.             rts
  62.  
  63. ;**********************************************************
  64. ;* Zählen der im Cache befindlichen und der neuen Seiten: *
  65. ;**********************************************************
  66. read_test:
  67.             movea.l    cache_flags,A0        ; Tabellenanfang
  68.             adda.w    D0,A0                ; + Offset
  69.             clr.w    D0                    ; Zähler initialisieren
  70.             subq.w    #1,D1                ; - 1 wegen DBRA
  71. loop2:        move.b    (A0)+,D2
  72.             btst    #1,D2                ; Seite im Cache ?
  73.             bne        jump5                ; ja !!
  74.             btst    #0,D2                ; neue Seite ?
  75.             bne        jump4                ; nein !!
  76. jump5:        addq.w    #1,D0                ; sonst zählen
  77. jump4:        dbra    D1,loop2
  78.             rts
  79.  
  80. .ifne 0
  81.  
  82. ;***********************************
  83. ;* Füllen eines Speicherbereiches: *
  84. ;***********************************
  85. memfill:
  86.             movem.l    D3-D7/A2-A6,-(SP)    ; Register retten
  87.  
  88.             lsr.l    #8,d1                ; Anzahl Bytes
  89.             lsr.l    #2,d1                ; geteilt durch 1024
  90.             beq        mfjump1                ; = 0, dann fertig
  91.  
  92.             move.w    d1,-(SP)            ; Zähler auf Stack
  93.             
  94.             move.b    d0,d1                ; Füllwert (Byte)
  95.             lsl.w    #8,d0                ; in Long expandieren
  96.             or.w    d1,d0
  97.             move.w    d0,d1
  98.             swap    d0
  99.             move.w    d1,d0                ; in Long expandieren
  100.  
  101.             move.l    d0,d1                ; restliche Register initialisieren
  102.             move.l    d0,d2
  103.             move.l    d0,d3
  104.             move.l    d0,d4
  105.             move.l    d0,d5
  106.             move.l    d0,d6
  107.             move.l    d0,d7
  108.             move.l    d0,a1
  109.             move.l    d0,a2
  110.             move.l    d0,a3
  111.             move.l    d0,a4
  112.             move.l    d0,a5
  113.             move.l    d0,a6
  114.  
  115.             REPT 18
  116.             movem.l    d0-d7/a1-a6,-(a0)    ; 56 Bytes schreiben
  117.             ENDM
  118.             movem.l    d0-d3,-(a0)            ; 16 Bytes schreiben
  119.             
  120.             subq.w    #1,(sp)                ; Zähler verringern
  121.             bne.b    mcloop1                ; Ende erreicht ?
  122.  
  123.             addq.l    #2,SP                ; Stack korrigieren
  124. mfjump1:    movem.l    (SP)+,D3-D7/A2-A6    ; Register restaurieren
  125.             rts
  126.  
  127. .endif
  128.  
  129. ;*****************************
  130. ;* Speicherbereich kopieren: *
  131. ;*****************************
  132. memcopy:
  133.             movem.l    D3-D7/A2-A6,-(SP)    ; Register retten
  134.             moveq    #10,d1
  135.             lsr.l    d1,d0                ; Anzahl in KByte
  136.             move.w    d0,-(SP)            ; Zähler auf Stack
  137.  
  138. mcloop1:
  139.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  140.             movem.l    d0-d7/a2-a6,(a0)    ; und schreiben
  141.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  142.             movem.l    d0-d7/a2-a6,52(a0)    ; und schreiben
  143.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  144.             movem.l    d0-d7/a2-a6,104(a0)    ; und schreiben
  145.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  146.             movem.l    d0-d7/a2-a6,156(a0)    ; und schreiben
  147.  
  148.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  149.             movem.l    d0-d7/a2-a6,208(a0)    ; und schreiben
  150.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  151.             movem.l    d0-d7/a2-a6,260(a0)    ; und schreiben
  152.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  153.             movem.l    d0-d7/a2-a6,312(a0)    ; und schreiben
  154.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  155.             movem.l    d0-d7/a2-a6,364(a0)    ; und schreiben
  156.  
  157.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  158.             movem.l    d0-d7/a2-a6,416(a0)    ; und schreiben
  159.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  160.             movem.l    d0-d7/a2-a6,468(a0)    ; und schreiben
  161.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  162.             movem.l    d0-d7/a2-a6,520(a0)    ; und schreiben
  163.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  164.             movem.l    d0-d7/a2-a6,572(a0)    ; und schreiben
  165.  
  166.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  167.             movem.l    d0-d7/a2-a6,624(a0)    ; und schreiben
  168.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  169.             movem.l    d0-d7/a2-a6,676(a0)    ; und schreiben
  170.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  171.             movem.l    d0-d7/a2-a6,728(a0)    ; und schreiben
  172.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  173.             movem.l    d0-d7/a2-a6,780(a0)    ; und schreiben
  174.  
  175.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  176.             movem.l    d0-d7/a2-a6,832(a0)    ; und schreiben
  177.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  178.             movem.l    d0-d7/a2-a6,884(a0)    ; und schreiben
  179.             movem.l    (a1)+,d0-d7/a2-a6    ; 52 Bytes holen
  180.             movem.l    d0-d7/a2-a6,936(a0)    ; und schreiben
  181.             movem.l    (a1)+,d0-d7/a2        ; 36 Bytes holen
  182.             movem.l    d0-d7/a2,988(a0)    ; und schreiben
  183.  
  184.             lea        1024(a0),a0            ; Zeiger + 1024
  185.             subq.w    #1,(sp)                ; Zähler verringern
  186.             bne        mcloop1                ; Ende erreicht ?
  187.  
  188.             addq.l    #2,SP                ; Stack korrigieren
  189.  
  190.             movem.l    (SP)+,D3-D7/A2-A6    ; Register restaurieren
  191.             rts
  192.  
  193. .ifne 0
  194.  
  195. ;*********************************
  196. ;* Speicherbereiche vertauschen: *
  197. ;*********************************
  198. memswap:
  199.             movem.l    D3-D7/A2-A6,-(SP)    ; Register retten
  200.             moveq    #9,d1
  201.             lsr.l    d1,d0                ; Anzahl in 512 Byte-Blöcken
  202.             subq.w    #1,d0                ; - 1 wegen DBRA
  203.  
  204. msloop1:
  205.             REPT 21
  206.             movem.l    (a1)+,d1-d6            ; 24 Bytes holen (A)
  207.             movem.l    (a0)+,d7/a2-a6        ; 24 Bytes holen (B)
  208.             movem.l    d7/a2-a6,-24(a1)    ; 24 Bytes schreiben (B)
  209.             movem.l    d1-d6,-24(a0)        ; 24 Bytes schreiben (A)
  210.             ENDM
  211.  
  212.             move.l    (a1),d1                ; noch 8 Bytes vertauschen
  213.             move.l    (a1),d2
  214.             move.l    (a0),(a1)+
  215.             move.l    (a0),(a1)+
  216.             move.l    d1,(a0)+
  217.             move.l    d2,(a0)+
  218.  
  219.             dbra    d0,msloop1            ; Zähler verringern
  220.  
  221.             movem.l    (SP)+,D3-D7/A2-A6    ; Register restaurieren
  222.             rts
  223.  
  224. .endif
  225.