diff options
Diffstat (limited to 'indra/lscript/lscript_execute/lscript_heapruntime.cpp')
| -rw-r--r-- | indra/lscript/lscript_execute/lscript_heapruntime.cpp | 501 |
1 files changed, 501 insertions, 0 deletions
diff --git a/indra/lscript/lscript_execute/lscript_heapruntime.cpp b/indra/lscript/lscript_execute/lscript_heapruntime.cpp new file mode 100644 index 0000000000..11bad19797 --- /dev/null +++ b/indra/lscript/lscript_execute/lscript_heapruntime.cpp @@ -0,0 +1,501 @@ +/** + * @file lscript_heapruntime.cpp + * @brief classes to manage script heap at runtime + * + * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#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 |