Memory Management in Tight Spaces

By Dave Kelly

Of major concern in any program development is that of memory management. This is especially true on the 128K Macintosh. MSBasic leaves only about 14K free program space to work with. However, on the 512K Mac there is over 330K free program space. If you are disappointed by the memory limitations there are some ways which you may get around some of the limitations.

There are three different areas of memory which you can have control over:

• The stack

• The Heap

• BASIC’s data segment

The Stack and the Heap

Macintosh applications can allocate and release memory by using the stack or the heap. The stack is used to temporarily store information telling BASIC where to return to from GOSUBs, FOR NEXT loops, WHILE WEND, subprogram calls and nested user defined functions. The Macintosh ROM routines require alot of stack space depending on the number of levels of nesting of controls (such as BUTTONS, EDIT FIELDS). The information on the stack is stored in LIFO (last-in-first-out) order. The last item put on the stack is always the first to be removed. The information is always released at the top of the stack, never in the middle, so there can never be blank “holes” in the stack. As in figure 1, the stack starts at a fixed address in high memory and as information is added to the stack it grows toward low memory (top of stack).

The heap contains blocks of memory which are allocated and released as needed by the Macintosh Operating System’s Memory Manager. The Memory Manager keeps track of the heap section of memory and “compacts” the heap if necessary in order to conserve the heap space. If you notice when you load BASIC only a part of BASIC loads at a time. Part of BASIC is in memory, and the rest is in sections that are loaded into memory as needed. Because the heap is smaller on the 128K Mac, there is considerably more disk access involved as sections of BASIC are swapped in and out of the heap. Whenever you use any of the Macintosh “features” such as MENU, BUTTON, EDIT FIELD, PICTURE, SOUND, WAVE, or WINDOW, a part of the heap is used to keep track of these “resources”. Open desk accessories also use a portion of the heap. The heap starts at low memory and adds blocks toward high memory. After a program has been running for awhile the heap will become fragmented with “holes” in the middle as various resources are released. By closing WINDOWs, MENUs and closing desk applications memory can be made available in the stack for other resources. The SOUND/WAVE buffer can be released (1024 bytes of heap) by using a WAVE 0 statement when it is no longer needed. Also a PICTURE ON immediately followed by PICTURE OFF will reclaim memory which was used by a previous picture that was in the heap. The Memory Manager will compact the contents of the heap.

One note on the speed of your programs as it pertains to the heap. I have found that when first defining EDIT FIELD and BUTTON controls that it takes longer the first time through the program while the heap allocates memory to keep the BUTTON and EDIT FIELD resources. Re-opening a window that had been closed which contains buttons and edit fields will use the same resources which were previously allocated in the heap. There are always two heap areas in memory: the system heap, which is used by the Toolbox and Operating System, and the application heap, which is used by the application program (in our case the application is MSBASIC).

The BASIC data segment area of memory is the area used to store the BASIC program and variables. This area also contains area for file buffers for opened files.

CLEAR AND FRE(n)

MSBASIC has provided the CLEAR statement to allocate memory to the three areas of RAM mentioned above. The CLEAR statement adjusts the number of bytes reserved for the stack and the data segment. The syntax is:

CLEAR [,[data-segment-size ][, stack-size ]]

The remaining RAM is left for the heap space. The heap space is calculated by taking the total amount of RAM (128K or 512K) minus the data segment size and the stack size ( heap = Total RAM - ( data-segment-size + stack-size )). For most programs on a 512K Mac it is not necessary to use the CLEAR statement, but it is needed for many programs to run on the 128K Mac. You should keep this in mind if you intend for your programs to run on any Mac (128K or 512K). You can use the statement FRE(n ) to find out how much free memory is available in each part of RAM. FRE(-1) returns the amount of free memory in the heap. FRE (-2) returns the amount of stack which has never been used. By using this value the program can be adjusted using CLEAR to use memory the most efficiently. Be sure that the worst case is used when fine tuning the memory. If (n ) is (“ “) or any other number (except -1 or -2) the expression returns the number of free bytes available in BASIC’s data segment. All of the FRE statements will compact string space. Each time a string is defined in BASIC part of the data segment area of memory is used. After swapping and shuffling strings around in your program the data segment becomes full of strings, most of which are no longer needed. For example if a string A$ is assigned as “MACINTOSH” and then reassigned as “MACTUTOR” , new space is allotted for “MACTUTOR” but the old string still exists in memory. A$ would only point to the most recent assignment of A$. By using the FRE( n ) statement, garbage collection is done and all the currently assigned strings are compacted in the data segment of memory.

USING RUN OR CHAIN

If you find that using the CLEAR statement still doesn’t give you enough memory you can split your program into subprograms and load in each program as needed. The RUN statement may be used to load and execute another BASIC program. The syntax is RUN filename[,R]. The R added to the end of the statement will cause all open data files to remain open. The problem with using the RUN statements is that when RUN executes all variables are erased. This means that all variables which are needed in the next program segment would need to be saved (temporarily) to the disk. RUN is best used to load new programs that are independent from the calling program.

To preserve your variables you should use the CHAIN statement. The syntax is: CHAIN [ MERGE ]filespec [,[expression ] [,ALL ][, DELETE range ]]] . The MERGE statement appends the called program to the end of the program currently in memory. The called program must have been saved as an ASCII file for this to work. filespec is the specification (disk name and filename) and expression is an expression or line number which tells BASIC where to start executing the called program. An alphanumeric label may not be used as this expression. If you use the ALL option, all the variables in the current program in memory are passed to the called program. The DELETE statement is used to delete lines of program currently in memory to make room for the called program. The BASIC manual is clear describing the syntax used here.

CHOOSING YOUR FILENAME

Some of these statements may seem to be somewhat trivial, but it takes some planning to determine when and how each section of program should be loaded and executed. The program FILE$ Demo demonstrates a way that the user can select which program or file to use. The function FILE$(n [,prompt-string ]) is supplied by MSBASIC to allow various types of files to be selected using the mini-finder dialog box. I’m sure that we are familiar with it from using it in most applications.

Fig. 1 Selection of file types

The parameter n is a number 0 or 1. FILE$(0) calls a dialog box which prompts the user for the name of a file. The prompt-string is displayed as the default filename. This is useful when you want to let the user decide which filename to use to save data to the disk. FILE$(1) calls up the mini-finder dialog box and prompts the user to select a filename in the list. You can use this to select files in either disk drive or on other disks. Both commands return the name of the file selected. This filename can then be used to load or save data or to call a new program. The prompt- string in the FILE$(1) statement contains a list of the file types, 4 characters per type. The file type is attached to the filename in the directory and the finder uses it to know what kind of file each icon represents.

In the demo program a window opens and asks for the user to select the type or types that should be included in the file selection. This way certain types of files could be screened out. The basic stores files as TEXT, but the type may be changed by using the NAME statement. In this way you could use a special type that “belongs” only to your program. If no types are selected in the demo program, then the prompt-string is blank and all types are selected. After the desired type buttons are selected selecting the “Select Files” button will execute the FILE$(1) statement and the mini-finder dialog box will appear. Select a filename and push the open button and you can see the format that is returned by the FILE$(1) statement. There are many possible ways that this could be used which are left to you to decide for your particular programing application.

Any particular topic that you would like to see covered in MacTutor? Write to us!

Fig. 2  Standard File Interface
‘    FILE$() Demo 
‘    by David Kelly
‘    ©MACTUTOR 1985

‘ Erase menus
FOR i=1 TO 5
    MENU i,0,0,””
NEXT
WINDOW 1,,(15,40)-(495,245),2

‘ initialize button status flags
FOR i=1 TO 7
    btn(i)=1
NEXT
Begin:   ‘Set up button controls
BUTTON 1,btn(1),”MacWrite Files”,  (119,15)-(237,30),3

Fig. 3 Program output

BUTTON 2,btn(2),”Text Files”, (119,40)-(200,55),3
BUTTON 3,btn(3),”MSBASIC 1.0 Files”, (119,65)-(252,80),3
BUTTON 4,btn(4),”MSBASIC 2.0 Decimal Files”,(119,90)-(307,105),3
BUTTON 5,btn(5),”MSBASIC 2.0 Binary  Files”,(119,115)-(317,130),3
BUTTON 6,btn(6),”MacPaint Files”,  (119,140)-(233,155),3
BUTTON 7,btn(7),”Applications”,    (119,165)-(219,180),3
BUTTON 8,1,”Select Files”,(363,87)-(448,121)
BUTTON 9,1,”Abort”,(363,131)-(448,165)
‘ Wait for button push
loop:WHILE DIALOG(0) <>1:WEND
        buttonpushed=DIALOG(1)
        IF buttonpushed=8 THEN seefiles
        IF buttonpushed=9 THEN WINDOW  CLOSE 1:MENU RESET:END
        IF btn(buttonpushed)=1 THEN  btn(buttonpushed)=2 ELSE  
 btn(buttonpushed)=1
        BUTTON buttonpushed,btn(buttonpushed)
GOTO loop
seefiles:

‘    MSBA    Basic 1.0
‘    MSBB    Basic 2.0 Decimal version
‘    MSBC    Basic 2.0 Binary version
‘    TEXT    Text file
‘    APPL    Application
‘    PNTG    MacPaint File
‘    WORD    MacWrite File
‘    MPRJ    MacProject File
‘ Other types may be added 

type$=””
IF btn(1)=2 THEN type$=type$+”WORD”
IF btn(2)=2 THEN type$=type$+”TEXT”
IF btn(3)=2 THEN type$=type$+”MSBA”
IF btn(4)=2 THEN type$=type$+”MSBB”
IF btn(5)=2 THEN type$=type$+”MSBC”
IF btn(6)=2 THEN type$=type$+”PNTG”
IF btn(7)=2 THEN type$=type$+”APPL”
selection$=FILES$(1,type$)
IF selection$=””THEN loop

‘ Close buttons
FOR i=1 TO 9
        BUTTON CLOSE i
NEXT

PRINT “You have selected “;
CALL TEXTFACE(1)
PRINT selection$
CALL TEXTFACE(0)
PRINT “Types =”;type$
BUTTON 1,1,”More”,(363,87)-(448,121)
BUTTON 2,1,”Abort”,(363,131)-(448,165)

‘ Wait for button push
WHILE DIALOG(0) <>1:WEND
        buttonpushed=DIALOG(1)
        IF buttonpushed=1 THEN CLS
     GOTO Begin
        WINDOW CLOSE 1:MENU RESET:END