Difference between revisions of "LlGetFreeMemory"

From Second Life Wiki
Jump to navigation Jump to search
m (Word duplication)
(29 intermediate revisions by 12 users not shown)
Line 1: Line 1:
{{LSL_Function
{{LSL_Function
|func_id=225|func_sleep=0.0|func_energy=10.0
|func_id=225|func_sleep=0.0|func_energy=10.0
|func=llGetFreeMemory|return_type=integer
|func=llGetFreeMemory
|func_footnote
|return_type=integer
|func_desc
|func_desc
|return_text=that is the available heap space for the current script.
|Return_text=of the number of free bytes of memory the script can use.
|spec
|func_footer
|caveats
|spec=
This function's behavior is dependent upon the VM the script is using. [[#Mono|Mono]] is the new VM, [[#LSO|LSO]] is the old VM. The big difference between Mono and LSO is that Mono scripts run faster and can utilize four times more memory.
 
===Mono===
 
In Mono the value returned is the amount of free memory available to the script prior to garbage collection being run. This means that memory that is awaiting garbage collection counts against the scripts 64KiB allotment. In addition to this, Mono does not enforce the memory restrictions as strictly as the LSO VM did{{Footnote|http://www.langnetsymposium.com/2009/talks/17-JimPurbrick-SecondLife.html}} (with LSO it was <u>impossible</u> to exceed the 16KiB memory cap), consequently it is possible to utilize more of the free memory{{Footnote|In LSO, all types are immutable, every operation results in Heap values being duplicated, meaning <code>a = a + a;</code> resulting in 3 values of |In LSO, all types are immutable, every operation results in Heap values being duplicated, meaning a = a + a; resulting in 3 values of }}.
 
===LSO===
 
In LSO, the value returned by this function is the amount of memory that the Stack can use of the Heap has yet to allocate for itself.
 
The LSL memory space is divided into four sections: Byte-code, Stack, Free Memory, Heap. Free Memory isn't an allocated block of memory, it's just the space between Stack and Heap. The size of all four sections combined is 16384 bytes (16KiB).
 
[[String]]s, [[list]]s and [[key]]s are stored in the Heap. Heap pointers (for [[string]]s, [[list]]s & [[key]]s), [[integer]]s, [[float]]s, [[vector]]s and [[rotation]]s are all temporarily stored in the stack as the script executes.
 
As the script executes the Stack grows and shrinks in size depending upon the complexity of the expressions being executed. Likewise the Heap grows as the script executes but unlike the Stack, it never shrinks in size. When there is no free memory left for Stack or Heap to use they collide and a Stack-Heap Collision error is thrown causing the script to crash.
 
The Heap can become fragmented and blocks of memory in it can become unusable (due to their size). There is no defragment function{{Footnote|Due to the design of the LSO VM, a defragment function is impossible.}} but there are scripting techniques that can be used to reduce fragmentation.
|caveats=
*The number of free bytes the Heap can use may be greater but not less.
|constants
|constants
|examples
|examples=
Calling llGetFreeMemory can look like this:
<source lang="lsl2">
integer free_memory = llGetFreeMemory();
llOwnerSay((string)free_memory + " bytes of free memory available for allocation.");
</source>
|helpers
|helpers
|also_functions
|also_functions=
|also_events
{{LSL DefineRow||[[llGetUsedMemory]]|}}
{{LSL DefineRow||[[llScriptProfiler]]|}}|also_events
|also_tests
|also_tests
|also_articles
|also_articles
|notes
|notes=See also: the "Script run-time error" "Stack-Heap Collision" among the [[LSL Errors]]
|permission
|lso=This function does not count free memory, and the name of this function makes this function difficult for people to learn. People say this function may be redefined or superseded by another more useful function when the LSL VM moves to [[Mono]].
|negative_index
 
|cat1
We can concisely specify llGetFreeMemory in the context of the classic Unix model for a parallel task/ thread/ process. Think of the task of the script always holding 16384 bytes (16 KiB). Let the byte code and then stack grow up from the bottom, let the heap grow down from the top. llGetFreeMemory then returns the "historic lowest heap pointer minus the stack end pointer".
|cat2
 
llGetFreeMemory does not count the bytes freed, llGetFreeMemory instead counts all the bytes never yet used.
|cat1=Script
|cat2=Memory
|cat3
|cat3
|cat4
|cat4
}}
}}

Revision as of 05:58, 19 July 2020

Summary

Function: integer llGetFreeMemory( );

Returns the integer of the number of free bytes of memory the script can use.

Specification

This function's behavior is dependent upon the VM the script is using. Mono is the new VM, LSO is the old VM. The big difference between Mono and LSO is that Mono scripts run faster and can utilize four times more memory.

Mono

In Mono the value returned is the amount of free memory available to the script prior to garbage collection being run. This means that memory that is awaiting garbage collection counts against the scripts 64KiB allotment. In addition to this, Mono does not enforce the memory restrictions as strictly as the LSO VM did[1] (with LSO it was impossible to exceed the 16KiB memory cap), consequently it is possible to utilize more of the free memory.

LSO

In LSO, the value returned by this function is the amount of memory that the Stack can use of the Heap has yet to allocate for itself.

The LSL memory space is divided into four sections: Byte-code, Stack, Free Memory, Heap. Free Memory isn't an allocated block of memory, it's just the space between Stack and Heap. The size of all four sections combined is 16384 bytes (16KiB).

Strings, lists and keys are stored in the Heap. Heap pointers (for strings, lists & keys), integers, floats, vectors and rotations are all temporarily stored in the stack as the script executes.

As the script executes the Stack grows and shrinks in size depending upon the complexity of the expressions being executed. Likewise the Heap grows as the script executes but unlike the Stack, it never shrinks in size. When there is no free memory left for Stack or Heap to use they collide and a Stack-Heap Collision error is thrown causing the script to crash.

The Heap can become fragmented and blocks of memory in it can become unusable (due to their size). There is no defragment function[2] but there are scripting techniques that can be used to reduce fragmentation.

Caveats

  • The number of free bytes the Heap can use may be greater but not less.
All Issues ~ Search JIRA for related Bugs

Examples

Calling llGetFreeMemory can look like this:

integer free_memory = llGetFreeMemory();
llOwnerSay((string)free_memory + " bytes of free memory available for allocation.");

Notes

See also: the "Script run-time error" "Stack-Heap Collision" among the LSL Errors

See Also

Functions

•  llGetUsedMemory
•  llScriptProfiler

Deep Notes

LSO VM Notes

This function does not count free memory, and the name of this function makes this function difficult for people to learn. People say this function may be redefined or superseded by another more useful function when the LSL VM moves to Mono.

We can concisely specify llGetFreeMemory in the context of the classic Unix model for a parallel task/ thread/ process. Think of the task of the script always holding 16384 bytes (16 KiB). Let the byte code and then stack grow up from the bottom, let the heap grow down from the top. llGetFreeMemory then returns the "historic lowest heap pointer minus the stack end pointer".

llGetFreeMemory does not count the bytes freed, llGetFreeMemory instead counts all the bytes never yet used.

Search JIRA for related Issues

Footnotes

  1. ^ http://www.langnetsymposium.com/2009/talks/17-JimPurbrick-SecondLife.html
  2. ^ Due to the design of the LSO VM, a defragment function is impossible.

Signature

function integer llGetFreeMemory();