[Back to MEMORY SWAG index] [Back to Main SWAG index] [Original]

    {
    Tel   : 7+(095) 333-9469
    E-Mail: vad@glas.apc.org

    >I'm wondering if anyone can tell me whether dynamic arrays have the same
    >64Kbyte limit per field that static arrays do? If so can ayone suggest away
    >to store data in memory that is sure to exceed this limit?

    The first way is known to all serious TP programmers.
    You could create large fragmental structure by control block.
    Example:
    }

    Type
        Large =  Array [1 .. 65520] of Byte;
        PLarge = ^Large;
        Huge = Array [1 .. 16380] of Pointer; { control block }
        PHuge = ^Huge;
    Var
       Hg : PHuge;
       MaxRow , MaxCol , r , c : Word;

    begin
         Repeat ReadLn(MaxRow , MaxCol)
         Until (MaxCol > 0) and (MaxCol <= 65520) and
                                  (MaxRow > 0) and (MaxRow <= 16380);
         GetMem(Hg , Sizeof(Pointer) * MaxRow);
         For r := 1 to MaxRow do GetMem(Hg^[r] , MaxCol);
         For r := 1 to MaxRow
         do For c := 1 to MaxCol
            do Hg^[r]^[c] := Random(255);
    end.

    {
    This method creating huge structures is using Borland in object named
    TColection.
    This method has two defects.
     * You must use big control structure consists of pointers.
     * You haven't garant of unfrugmental of this structure.
    This method have two advantages.
     * You can use standart pascal procedures & macros for operating with
       this structure (As Move, FillChar ets).
     * You can use standart TP heap menager for creating huge
       structure.

    The second way for creating huge structure. It's my own method.
    I use DOS memory menager.  I can create realy huge unfragmental
    structure. It's more complicated way. I can't use standart TP
    procedure & macros for operating with that structure, because
    this structure greater than 64Kb. For remove huge structure I
    write some procedure, function & inline macros. I used standart TP
    heap menager for allocation small control structure and used
    DOS memory menager for allocation huge data structure.
    Example:
    {$M 4096,10000,10000 <- It's very important option. Without
    this option Your program should use all DOS memory for his TP
    heap. You should write Your realy heap size. Use TpStack from
    Turbo profesional for get this value.
    }

    function dosAlloc (Size : Longint) : Pointer; assembler;
    asm
       mov   ax , word ptr Size
       mov   dx , word ptr Size[2]
       add   ax , 000Fh
       adc   dx , 0
       mov   bx , 0010h
       div   bx
       mov   bx , ax
       mov  ah , 48h
       int  21h
       jC  @@Error
       mov  dx , ax
       xor  ax , ax
       jmp  @@Exit
    @@Error:
       xor  ax , ax
       xor  dx , dx
    @@Exit:
    end;

    function dosFree (Var P) : Boolean; assembler;
    asm
       les   di , P
       mov   ax , es:[di]
       mov   dx , es:[di][2]
       mov   cl , 4
       shr   ax , cl
       add   ax , dx
       or    ax , ax
       jZ    @@Exit
       mov   es , ax
       mov   ah , 49h
       int   21h
       jNC   @@Continue
       mov   ax , False
       jmp   @@Exit
    @@Continue:
       xor    ax , ax
       les    di , P
       mov    es:[di] , ax
       mov    es:[di][2] , ax
       mov    ax , True
    @@Exit:
    end;

    function dosResize (P : Pointer; NewSize : Longint) : Boolean; assembler;
    asm
       mov   ax , False
       mov   bx , word ptr P[2]
       mov   es , bx
       or    bx , word ptr P
       jZ    @@Exit
       mov   ax , word ptr NewSize
       mov   dx , word ptr NewSize[2]
       mov   bx , 16
       div   bx
       mov   bx , ax
       or    dx , dx
       jZ    @@Margin
       inc   bx
    @@Margin:
       mov  ah , 4Ah
       int  21h
       jC  @@Error
       mov  ax , True
       jmp  @@Exit
    @@Error:
       mov  ax , False
    @@Exit:
    end;

    function dosAvail : Longint; assembler;
    asm
       mov  bx , 0FFFFh
       mov  ah , 48h
       int  21h
       mov  ax , 16
       mul  bx
    end;

    Var
       Hg : Pointer;

    begin
         Hg := dosAlloc(123456);
    end.

    {
       I don't want send more than 16Kb of my library. Because I don't test
       all procedure & function. But I can give You my idea.
       This way has one defect.
       * You should rewrite all low level memory access (As Move,
          FillChar ets.).
       This way has four advantages.
       * You can use all DOS memory functions: Allocation, Resize,
         Free (It's more powerfull that TP).
       * You recive paragraph align pointer.
       * You get unfragmental memory block.
       * You don't use big control structure.
    }

[Back to MEMORY SWAG index] [Back to Main SWAG index] [Original]