;*--------------------------------------------------------------------------------------------------------------
;*MODULE                      TP4 - Allocation memoire
;*--------------------------------------------------------------------------------------------------------------
;* Auteur(s) :   Bénédicte NOUYOU &   Vivien HUBERT
;*
;* Formation : ESIR              Groupe: 2A
;*--------------------------------------------------------------------------------------------------------------

        .model small
        .stack
        public ALLOUER, LIBERER, libre


        .data

NBMAX           EQU 20                      ; nombre de blocs
TBASE           EQU 16                      ; tailles des blocs
bloc_t          EQU 0                       ; nombre de blocs libres consecutifs disponibles dans la zone
bloc_suivant    EQU 2                       ; adresse du bloc libre suivant

zone            DW NBMAX                    ; nb de bloc de la zone
                DW 0FFFFh                   ; zone libre, donc comme c'est la seulle a l'état initiale, on met la marque de fin
                DW (NBMAX*TBASE)/2 - 2 DUP(?)   ; allocation de la zone

libre           DW Offset zone

    ; Params de ALLOUER
allouer_t       EQU 4
allouer_ptz     EQU 6
allouer_fait    EQU 8
allouer_tparam  EQU 8

        .code

ALLOUER:
    ; sauvegarde du sommet de pile
            PUSH BP
            MOV BP, SP
    ; sauvegarde des registres
            PUSH AX BX CX DX SI

            MOV BX, libre                   ; on recupère l'endroit ou on va faire l'allocation

    ; on va chercher la première zone de taille suffisante
allouer_tq_zone_trop_petite:
    ; si on est rendu a la fin
            CMP BX, 0FFFFh
            JE allouer_plus_de_place

    ; on va comparer la taille nécessaire avec celle dispo dans la zone libre pointée par libre
            MOV AX, [BP] + allouer_t
            CMP [BX] + bloc_t , AX
            JGE allouer_zone_disponible     ; taille suffisante

    ; sinon on va regarder dans le bloc libre suivant ( adresse stockée dans libre )
            MOV CX, BX                      ; On sauvegarde la zone précédent dans CX
            MOV BX, [BX] + bloc_suivant
            JMP allouer_tq_zone_trop_petite ; on reboucle

allouer_zone_disponible:
    ; MAJ des params
            MOV SI, [BP] + allouer_ptz
            MOV [SI], BX                    ; on met a jour l'adresse de la zone
            MOV SI, [BP] + allouer_fait
            MOV byte ptr [SI], 1            ; on met a jour le booleen de retour de la fonction, NB a vrai ( i.e. 1 )

    ; On test si on utilise la totalité de la zone courante
            MOV AX, [BP] + allouer_t        ; AX recupère le nombre de bloc que l'on veut
            CMP [BX] + bloc_t, AX           ; on compare la taille dispo du bloc avec celle qu'on souhaite
            JE allouer_zone_bloc_complete

            MOV AX, [BP] + allouer_t        ; AX recupère le nombre de bloc(s) que l'on veut
            MOV DX,TBASE                    ; on affecte a dx la taille d'un bloc
            MUL DX                          ; EQU   AX <= AX * DX
                                            ;

            MOV SI, BX                      ; BX : Ancien pointeur de la zone courante
            ADD SI, AX                      ; SI : Pointeur de la nouvelle zone libre

            MOV AX, [BX] + bloc_t           ; recupère le nombre de bloc de dispo dans la zone
            SUB AX, [BP] + allouer_t        ; au quel au soustrait celui qu'on a réservé
            MOV [SI] + bloc_t, AX           ; et on met le resultat dans le nombre de bloc de dispo dans lle bloc libre suivant

            MOV AX, [BX] + bloc_suivant     ; on récupère le bloc libre d'après
            MOV [SI] + bloc_suivant, AX

            CMP BX, libre
            JNE allouer_maintenir_chainage

            MOV libre,SI
            JMP allouer_fin

allouer_maintenir_chainage:
            MOV BX,CX
            MOV [BX + bloc_suivant], SI
            JMP allouer_fin

allouer_zone_bloc_complete:
            MOV SI, [BX] + bloc_suivant

allouer_plus_de_place:
    ; MAJ du booleen de retour a faux ( i.e. 0 )
            MOV BX, [BP] + allouer_fait
            MOV byte ptr[BX], 0

allouer_fin:

            POP SI DX CX BX AX
            POP BP
            RET allouer_tparam

;----------------------------------------------------------------------------
; Procedure  LIBERER
;----------------------------------------------------------------------------
; liberer = fixe ( ent t , pointeur zone ptz )
;
;   Va liberer la zone de "t" blocs repréee par ptz
;----------------------------------------------------------------------------
        .data
    ; Params de LIBERER
liberer_t       EQU 4
liberer_ptz     EQU 6
liberer_tparam  EQU 4

        .code
LIBERER:
            PUSH BP
            MOV BP, SP
            PUSH SI CX BX AX

            MOV SI, [BP] + liberer_ptz      ; On recupere l adresse du bloc a liberer
            MOV CX, [libre]                 ; On récupère l'adresse contenu

l_cmp_bloc:
            CMP SI, CX                      ; On compare les deux adresses
            JL l_fin_recherche              ; On a trouve sa place

            MOV BX, CX                      ; Sauvegarde de cx
            MOV CX, [BX] + bloc_suivant     ; On va cherche l'adresse de l element libre suivant
            JMP l_cmp_bloc                  ; On reboucle

l_fin_recherche:
    ; On va modifier les blocs de la liste de libre
            CMP CX, 0FFFFh                  ; On verifie qu'on est pas a la fin
            JE l_fin_liste

            MOV [SI]+bloc_suivant, CX       ; On met a jour l'adress du bloc d'apres
l_fin_liste:
            MOV [BX] + bloc_suivant, SI     ; Mise a jour du pointeur sur le libre suivant
            MOV AX, [BP] + liberer_t
            MOV [SI] + bloc_suivant, AX     ; Mise de jour de la taille du nouveau bloc libre

            POP AX BX CX SI BP
            RET liberer_tparam



END