lscript_heapruntime.cpp

Go to the documentation of this file.

#if 0

#include "linden_common.h"

#include "lscript_heapruntime.h"
#include "lscript_execute.h"


/*
        String Heap Format
        Byte            Description
        0x0 - 0xnn      Single byte string including null terminator

        List Heap Format
        Byte            Description
        0x0                     Next Entry Type
                                        0: End of list
                                        1: Integer
                                        2: Floating point
                                        3: String
                                        4: Vector
                                        5: Quaternion
                                        6: List
        0x1 - 0x4       Integer, Floating Point, String Address, List Address
        or      
        0x1 - 0xd       Vector
        or      
        0x1 - 0x11      Quaternion
        . . .   

        Heap Block Format
        Byte            Description
        0x0 - 0x3       Offset to Next Block
        0x4 - 0x7       Object Reference Count
        0x8             Block Type
                                        0: Empty
                                        3: String
                                        6: List
        0x9 - 0xM       Object Data

        Heap Management

        Adding Data

        1)      Set last empty spot to zero.
        2)      Go to start of the heap (HR).
        3)      Get next 4 bytes of offset.
        4)      If zero, we've reached the end of used memory.  If empty spot is zero go to step 9.  Otherwise set base offset to 0 and go to step 9.
        5)      Skip 4 bytes.
        6)      Get next 1 byte of entry type.
        7)      If zero, this spot is empty.  If empty spot is zero, set empty spot to this address and go to step 9.  Otherwise, coalesce with last empty spot and then go to step 9.
        8)      Skip forward by offset and go to step 3.
        9)      If the spot is empty, check to see if the size needed == offset - 9.
        10)      If it does, let's drop our data into this spot.  Set reference count to 1.  Set entry type appropriately and copy the data in.  
        11)      If size needed < offset - 9 then we can stick in data and add in an empty block.
        12)      Otherwise, we need to keep looking.  Go to step 3.

        Increasing reference counts
                
        Decreasing reference counts
        1)      Set entry type to 0.
        2)      If offset is non-zero and the next entry is empty, coalesce.  Go to step 2.

        What increases reference count:
                Initial creation sets reference count to 1.
                Storing the reference increases reference count by 1.
                Pushing the reference increases reference count by 1.
                Duplicating the reference increases reference count by 1.

        What decreases the reference count:
                Popping the reference decreases reference count by 1.
 */


LLScriptHeapRunTime::LLScriptHeapRunTime()
: mLastEmpty(0), mBuffer(NULL), mCurrentPosition(0), mStackPointer(0), mHeapRegister(0), mbPrint(FALSE)
{
}

LLScriptHeapRunTime::~LLScriptHeapRunTime()
{
}

S32 LLScriptHeapRunTime::addData(char *string)
{
        if (!mBuffer)
                return 0;

        S32 size = strlen(string) + 1;
        S32 block_offset = findOpenBlock(size + HEAP_BLOCK_HEADER_SIZE);

        if (mCurrentPosition)
        {
                S32 offset = mCurrentPosition;
                if (offset + block_offset + HEAP_BLOCK_HEADER_SIZE + LSCRIPTDataSize[LST_INTEGER] >= mStackPointer)
                {
                        set_fault(mBuffer, LSRF_STACK_HEAP_COLLISION);
                        return 0;
                }
                // cool, we've found a spot!
                // set offset
                integer2bytestream(mBuffer, offset, block_offset);
                // set reference count
                integer2bytestream(mBuffer, offset, 1);
                // set type
                *(mBuffer + offset++) = LSCRIPTTypeByte[LST_STRING];
                // plug in data
                char2bytestream(mBuffer, offset, string);
                if (mbPrint)
                        printf("0x%X created ref count %d\n", mCurrentPosition - mHeapRegister, 1);

                // now, zero out next offset to prevent "trouble"
        //      offset = mCurrentPosition + size + HEAP_BLOCK_HEADER_SIZE;
        //      integer2bytestream(mBuffer, offset, 0);
        }
        return mCurrentPosition;
}

S32 LLScriptHeapRunTime::addData(U8 *list)
{
        if (!mBuffer)
                return 0;
        return 0;
}

S32 LLScriptHeapRunTime::catStrings(S32 address1, S32 address2)
{
        if (!mBuffer)
                return 0;

        S32 dataaddress1 = address1 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
        S32 dataaddress2 = address2 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;

        S32 toffset1 = dataaddress1;
        safe_heap_bytestream_count_char(mBuffer, toffset1);

        S32 toffset2 = dataaddress2;
        safe_heap_bytestream_count_char(mBuffer, toffset2);

        // calculate new string size
        S32 size1 = toffset1 - dataaddress1;
        S32 size2 = toffset2 - dataaddress2;
        S32 newbuffer = size1 + size2 - 1;

        char *temp = new char[newbuffer];

        // get the strings
        bytestream2char(temp, mBuffer, dataaddress1);
        bytestream2char(temp + size1 - 1, mBuffer, dataaddress2);

        decreaseRefCount(address1);
        decreaseRefCount(address2);

        S32 retaddress = addData(temp);

        return retaddress;
}

S32 LLScriptHeapRunTime::cmpStrings(S32 address1, S32 address2)
{
        if (!mBuffer)
                return 0;

        S32 dataaddress1 = address1 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
        S32 dataaddress2 = address2 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;

        S32 toffset1 = dataaddress1;
        safe_heap_bytestream_count_char(mBuffer, toffset1);

        S32 toffset2 = dataaddress2;
        safe_heap_bytestream_count_char(mBuffer, toffset2);

        // calculate new string size
        S32 size1 = toffset1 - dataaddress1;
        S32 size2 = toffset2 - dataaddress2;

        if (size1 != size2)
        {
                return llmin(size1, size2);
        }
        else
        {
                return strncmp((char *)(mBuffer + dataaddress1), (char *)(mBuffer + dataaddress2), size1);
        }
}

void LLScriptHeapRunTime::removeData(S32 address)
{
        if (!mBuffer)
                return;

        S32 toffset = address;
        // read past offset (relying on function side effect
        bytestream2integer(mBuffer, toffset);

        // make sure that reference count is 0
        integer2bytestream(mBuffer, toffset, 0);
        // show the block as empty
        *(mBuffer + toffset) = 0;

        // now, clean up the heap
        S32 clean = mHeapRegister;
        S32 tclean;
        S32 clean_offset;

        S32 nclean;
        S32 tnclean;
        S32 next_offset;

        U8  type;
        U8  ntype;

        for(;;)
        {
                tclean = clean;
                clean_offset = bytestream2integer(mBuffer, tclean);
                // is this block, empty?
                tclean += LSCRIPTDataSize[LST_INTEGER];
                type = *(mBuffer + tclean);
                
                if (!clean_offset)
                {
                        if (!type)
                        {
                                // we're done! if our block is empty, we can pull in the HP and zero out our offset
                                set_register(mBuffer, LREG_HP, clean);
                        }
                        return;
                }


                if (!type)
                {
                        // if we're empty, try to coalesce with the next one
                        nclean = clean + clean_offset;
                        tnclean = nclean;
                        next_offset = bytestream2integer(mBuffer, tnclean);
                        tnclean += LSCRIPTDataSize[LST_INTEGER];
                        ntype = *(mBuffer + tnclean);

                        if (!next_offset)
                        {
                                // we're done! if our block is empty, we can pull in the HP and zero out our offset
                                tclean = clean;
                                integer2bytestream(mBuffer, tclean, 0);
                                set_register(mBuffer, LREG_HP, clean);
                                return;
                        }

                        if (!ntype)
                        {
                                // hooray!  we can coalesce
                                tclean = clean;
                                integer2bytestream(mBuffer, tclean, clean_offset + next_offset);
                                // don't skip forward so that we can keep coalescing on next pass through the loop
                        }
                        else
                        {
                                clean += clean_offset;
                        }
                }
                else
                {
                        // if not, move on to the next block
                        clean += clean_offset;
                }
        }
}       

void LLScriptHeapRunTime::coalesce(S32 address1, S32 address2)
{
        // we need to bump the base offset by the second block's
        S32 toffset = address1;
        S32 offset1 = bytestream2integer(mBuffer, toffset);
        offset1 += bytestream2integer(mBuffer, address2);

        integer2bytestream(mBuffer, address1, offset1);
}

void LLScriptHeapRunTime::split(S32 address1, S32 size)
{
        S32 toffset = address1;
        S32 oldoffset = bytestream2integer(mBuffer, toffset);

        // add new offset and zero out reference count and block used
        S32 newoffset = oldoffset - size;
        S32 newblockpos = address1 + size;

        // set new offset
        integer2bytestream(mBuffer, newblockpos, newoffset);
        // zero out reference count
        integer2bytestream(mBuffer, newblockpos, 0);
        // mark as empty
        *(mBuffer + newblockpos) = 0;

        // now, change the offset of the original block
        integer2bytestream(mBuffer, address1, size + HEAP_BLOCK_HEADER_SIZE);
}

/* 

        For reference count changes, strings are easy.  For lists, we'll need to go through the lists reducing
        the reference counts for any included strings and lists

 */

void LLScriptHeapRunTime::increaseRefCount(S32 address)
{
        if (!mBuffer)
                return;

        if (!address)
        {
                // unused temp string entry
                return;
        }

        // get current reference count
        S32 toffset = address + 4;
        S32 count = bytestream2integer(mBuffer, toffset);

        count++;

        if (mbPrint)
                printf("0x%X inc ref count %d\n", address - mHeapRegister, count);

        // see which type it is
        U8 type = *(mBuffer + toffset);

        if (type == LSCRIPTTypeByte[LST_STRING])
        {
                toffset = address + 4;
                integer2bytestream(mBuffer, toffset, count);
        }
        // TO DO: put list stuff here!
        else
        {
                set_fault(mBuffer, LSRF_HEAP_ERROR);
        }
}

void LLScriptHeapRunTime::decreaseRefCount(S32 address)
{
        if (!mBuffer)
                return;

        if (!address)
        {
                // unused temp string entry
                return;
        }

        // get offset
        S32 toffset = address;
        // read past offset (rely on function side effect)
        bytestream2integer(mBuffer, toffset);

        // get current reference count
        S32 count = bytestream2integer(mBuffer, toffset);

        // see which type it is
        U8 type = *(mBuffer + toffset);

        if (type == LSCRIPTTypeByte[LST_STRING])
        {
                count--;

                if (mbPrint)
                        printf("0x%X dec ref count %d\n", address - mHeapRegister, count);

                toffset = address + 4;
                integer2bytestream(mBuffer, toffset, count);
                if (!count)
                {
                        // we can blow this one away
                        removeData(address);
                }
        }
        // TO DO: put list stuff here!
        else
        {
                set_fault(mBuffer, LSRF_HEAP_ERROR);
        }
}

// if we're going to assign a variable, we need to decrement the reference count of what we were pointing at (if anything)
void LLScriptHeapRunTime::releaseLocal(S32 address)
{
        S32 hr = get_register(mBuffer, LREG_HR);
        address = lscript_local_get(mBuffer, address);
        if (  (address >= hr)
                &&(address < hr + get_register(mBuffer, LREG_HP)))
        {
                decreaseRefCount(address);
        }
}

void LLScriptHeapRunTime::releaseGlobal(S32 address)
{
        // NOTA BENE: Global strings are referenced relative to the HR while local strings aren't
        S32 hr = get_register(mBuffer, LREG_HR);
        address = lscript_global_get(mBuffer, address) + hr;
        if (  (address >= hr)
                &&(address <  hr + get_register(mBuffer, LREG_HP)))
        {
                decreaseRefCount(address);
        }
}


// we know the following function has "unreachable code"
// don't remind us every friggin' time we compile. . . 

#if defined(_MSC_VER)
# pragma warning(disable: 4702) // unreachable code
#endif

S32 LLScriptHeapRunTime::findOpenBlock(S32 size)
{
        S32 offset;
        S32 toffset;
        U8 blocktype;

        while(1)
        {
                if (mCurrentPosition + size >= mStackPointer)
                {
                        set_fault(mBuffer, LSRF_STACK_HEAP_COLLISION);
                        mCurrentPosition = 0;
                }

                toffset = mCurrentPosition;
                offset = bytestream2integer(mBuffer, toffset);
                if (!offset)
                {
                        // we've reached the end of Heap, return this location if we'll fit
                        // do we need to coalesce with last empty space?
                        if (mLastEmpty)
                        {
                                // ok, that everything from mLastEmpty to us is empty, so we don't need a block
                                // zero out the last empty's offset and return it
                                mCurrentPosition = mLastEmpty;
                                integer2bytestream(mBuffer, mLastEmpty, 0);
                                mLastEmpty = 0;
                        }
                        // now, zero out next offset to prevent "trouble"
                        offset = mCurrentPosition + size;
                        integer2bytestream(mBuffer, offset, 0);

                        // set HP to appropriate value
                        set_register(mBuffer, LREG_HP, mCurrentPosition + size);
                        return size;
                }

                // ok, is this slot empty?
                toffset += LSCRIPTDataSize[LST_INTEGER];

                blocktype = *(mBuffer + toffset++);

                if (!blocktype)
                {
                        // Empty block, do we need to coalesce?
                        if (mLastEmpty)
                        {
                                coalesce(mLastEmpty, mCurrentPosition);
                                mCurrentPosition = mLastEmpty;
                                toffset = mCurrentPosition;
                                offset = bytestream2integer(mBuffer, toffset);
                        }

                        // do we fit in this block?
                        if (offset >= size)
                        {
                                // do we need to split the block? (only split if splitting will leave > HEAP_BLOCK_SPLIT_THRESHOLD bytes of free space)
                                if (offset - HEAP_BLOCK_SPLIT_THRESHOLD >= size)
                                {
                                        split(mCurrentPosition, size);
                                        return size;
                                }
                                else
                                        return offset;
                        }
                }
                // nothing found, keep looking
                mCurrentPosition += offset;
        }
        // fake return to prevent warnings
        mCurrentPosition = 0;
        return 0;
}

LLScriptHeapRunTime     gRunTime;
#endif

---