EH>
  > begin
  >  writeln( memavail); { write the number of remaining free bytes }
  >  getmem( p, 4);      { allocate 4 bytes }
  >  writeln( memavail); { write the number of remaining free bytes after alloc
  >  freemem( p, 4);     { release the 4 bytes again }
  >  writeln( memavail); { again remaining }
  > end.
  >
  > this program outputs:
  >
  > 774430
  > 774500
  > 774430
EH>

  Always remember that most languages allocate memory in one big block
  from the operating system, and them suballocate smaller amounts from
  that block as and when the application asks for them.

  Borland C++ for OS/2 is a good example.  Internally it allocates
  memory from OS/2 in 4Mb chunks, and then malloc() parcels it out in
  smaller chunks.

  This has two effects.  Firstly, the first call to allocate memory will
  request this large chunk from the operating system, and OS/2 will see
  no more allocation requests until that has all been used.  And
  secondly, as far as OS/2 is concerned, the application is allocating
  memory in 4Mb chunks, and so will report it that way.

  Your memavail function in PASCAL is probably going straight to OS/2 to
  obtain the size of the largest free memory block (not a good
  indication of how much memory is actually free, BTW), whereas getmem()
  is doing some internal voodoo much like I have described so that it
  doesn't have to call OS/2 on each memory allocation.

  Note that the amount of memory left to an application on a
  multitasking system with virtual memory is not a very useful figure,
  as the user is perfectly entitled to suddenly crank up Lotus Notes in
  the background, and bang go several megabytes of memory that only
  seconds ago were reported to your program as being available for use.

  > JdeBP <
___
 X MegaMail 2.10 #0:

--- Maximus/2 2.01wb