69 #include "SystemInterpreter.hpp"
72 #include "SysFileSystem.hpp"
79 #define RESTORE_CLASS(name, className) The##name##Class = (className *)RexxBehaviour::getPrimitiveBehaviour(T_##name)->restoreClass();
87 #define LiveStackSize 16370
89 #define SaveStackSize 10
90 #define SaveStackAllocSize 500
92 #define MaxImageSize 1800000
109 va_start(args, message);
110 vprintf(message, args);
111 if (outfile != NULL) {
112 vfprintf(outfile, message, args);
255 outFile = fopen(
"memory.prf",
"wb");
274 ObjEnd = (
void **)((
char *)objectRef + objectRef->
getObjectSize());
275 for (dmpPtr = (
void **)objectRef; dmpPtr <= ObjEnd ; dmpPtr++)
277 logMemoryCheck(outfile,
" >Parent Dump -->%p %p %p %p \n", *dmpPtr, *(dmpPtr+1), *(dmpPtr+2), *(dmpPtr+3));
383 markObject->
live(liveMark);
499 verboseMessage(
"Calling runUninits from RexxMemory::collectAndUninit\n");
539 verboseMessage(
"Leaving runUninits immediatly because recursive call\n");
571 activity->
run(dispatcher);
594 verboseMessage(
"Leaving runUninits (was called when pendingUninits=%d)\n", pendingUninits_onEntry);
747 printf(
"Allocating a new segment of %d bytes\n", requestedBytes);
753 printf(
"Allocating boundary a new segment of %d bytes\n", requestedBytes);
790 printf(
"Allocating large boundary new segment of %d bytes for request of %d\n", allocationBytes, requestedBytes);
824 char *objectPointer, *endPointer;
827 size_t primitiveTypeNum;
841 while (objectPointer < endPointer)
868 primitiveTypeNum = ((
RexxObject *)objectPointer)->behaviour->getClassType();
886 objectPointer += ((
RexxObject *)objectPointer)->getObjectSize();
1182 totalSize = objSize * count;
1240 prototype = largeObject;
1248 for (i=1 ;i < count ; i++ )
1254 arrayOfObjects->
put(largeObject, i);
1256 largeObject = (
RexxObject *)((
char *)largeObject + objSize);
1260 arrayOfObjects->
put(largeObject, i);
1265 return arrayOfObjects;
1289 size_t deadObjectSize = shrinkObj->
getObjectSize() - newSize;
1292 newDeadObj =
new ((
void *)((
char *)shrinkObj + newSize))
DeadObject (deadObjectSize);
1300 if (deadObjectSize != 0)
1315 size_t allocationLength)
1350 if (largeObject != NULL)
1525 memcpy((
void *)bufferReference, (
void *)markObject, size);
1527 bufferReference->clearObjectMark();
1544 bufferReference->setPrimitive();
1568 const char *outFileName;
1572 const char *objectClassName;
1580 outfile = fopen(outFileName,
"wb");
1581 logMemoryCheck(outfile,
"Found non Object at %p, being marked from %p\n",markObject, pMarkObject);
1607 className = markObject->
id();
1609 objectClassName =
"";
1614 printf(
"-->Parent node was marking offset '%ld'x \n", (
char *)pMarkObject - (
char *)markObject);
1617 logMemoryCheck(outfile,
"Parent node is at %p, of type %s(%d) \n",
1618 markObject, objectClassName, markObject->behaviour->getClassType());
1629 printf(
"All data has been captured in file %s \n", outFileName);
1697 _imageStats.
clear();
1781 image = fopen(imageTarget == NULL ?
BASEIMAGE : imageTarget,
"wb");
1790 printf(
"Object stats for this image save are \n");
1792 printf(
"\n\n Total bytes for this image %lu bytes \n",
image_offset);
1814 printf(
"Dumping object memory to orexdump.dmp\n");
1816 dumpfile = fopen(
"orexdump.dmp",
"wb");
1819 printf(
"Creating dump key file in orexdump.key\n");
1821 keyfile = fopen(
"orexdump.key",
"w");
1822 fprintf(keyfile,
"/* Object REXX dump key file */\n");
1823 fprintf(keyfile,
"memoryaddr = %p\n",
this);
1824 fprintf(keyfile,
"marker = %d\n",
markWord);
1835 fprintf(keyfile,
"Pool addr.%d = %p\n", i,
currentPool);
1877 bool restoreimagesave;
1885 printf(
"Comparing old2new with the current system.\n");
1910 printf(
"object: %p, type: %lu, is extra in old2new.\n\n",
1919 if (count != testcount)
1921 printf(
"object: %p, type: %lu, has an incorrect refcount.\n",
1923 printf(
"Refcount for object is %ld, should be %ld.\n\n", count, testcount);
1926 tempold2new->
remove(index);
1933 for (j = tempold2new->
first();
1935 j = tempold2new->
next(j))
1937 printf(
"object: %p, type: %lu, is missing from old2new.\n\n",
1944 printf(
"Dumping object memory.\n");
2056 printf(
"******** error in memory_setoref, unable to decrement refcount\n");
2057 printf(
"Naughty object reference is from: %p\n", oldValueLoc);
2058 printf(
"Naughty object reference is at: %p\n", index);
2087 return *oldValueLoc = value;
2095 const char *fileName,
2105 const char *outFileName;
2114 outfile = fopen(outFileName,
"wb");
2115 logMemoryCheck(outfile,
"The Setter object at %p is invalid...\n");
2123 outfile = fopen(outFileName,
"wb");
2124 logMemoryCheck(outfile,
"The Setter object at %p attempted to put a non object %p, at offset %p\n",setter, value, (
char *)index - (
char *)setter);
2125 logMemoryCheck(outfile,
" A dump of the Setting object follows: \n");
2133 outfile = fopen(outFileName,
"wb");
2134 logMemoryCheck(outfile,
"The Setter object at %p has tried to store at offset, which is outside his object range\n",setter, (
char *)index - (
char *)setter);
2135 logMemoryCheck(outfile,
" A dump of the Setting object follows: \n");
2144 logMemoryCheck(outfile,
" The error occurred in line %u of file %s\n", lineNum, fileName);
2145 printf(
"The dump data has been written to file %s \n",outFileName);
2150 return(setter->
isOldSpace() ? (this->setOref(index, value)) : (*index = value));
2190 _imageStats.
clear();
2221 while (pool != NULL)
void reportException(wholenumber_t error)
RexxArray * new_array(size_t s)
RexxIdentityTable * new_identity_table()
RexxInteger * new_integer(wholenumber_t v)
#define MemorySegmentOverhead
size_t roundSegmentBoundary(size_t n)
#define LargeBlockThreshold
#define TheMemoryBehaviour
#define TheBehaviourBehaviour
#define TheStackBehaviour
#define TheObjectBehaviour
#define TheCommonRetrievers
#define TheFunctionsDirectory
#define Error_Logical_value_method
#define Error_System_resources
bool SysAccessPool(MemorySegmentPool **pool)
#define SaveStackAllocSize
static void logMemoryCheck(FILE *outfile, const char *message,...)
#define RESTORE_CLASS(name, className)
#define memory_mark(oref)
size_t roundObjectBoundary(size_t n)
#define ObjectNeedsMarking(oref)
size_t roundLargeObjectAllocation(size_t n)
#define MinimumObjectSize
#define memory_mark_general(oref)
size_t roundObjectResize(size_t n)
RexxString * new_proxy(const char *name)
RexxString * new_string(const char *s, stringsizeB_t bl, sizeC_t cl=-1)
static void liveGeneral(int reason)
static RexxActivity *volatile currentActivity
GlobalProtectedObject * next
RexxObject * protectedObject
static void logicError(const char *desc)
static void liveGeneral(int reason)
RexxObject * allocateObject(size_t allocationLength)
virtual void dumpMemoryProfile(FILE *outfile)
RexxObject * handleAllocationFailure(size_t allocationLength)
MemorySegment * newLargeSegment(size_t minSize)
MemorySegment * newSegment(size_t minSize)
static MemorySegmentPool * createPool()
MemorySegmentPool * nextPool()
void dumpSegments(FILE *keyfile, FILE *dumpfile)
bool isInSegmentSet(RexxObject *object)
void addSegment(MemorySegment *segment, bool createDeadObject=1)
void gatherStats(MemoryStats *memStats, SegmentStats *stats)
virtual DeadObject * donateObject(size_t allocationLength)
virtual MemorySegment * donateSegment(size_t allocationLength)
virtual void addDeadObject(DeadObject *object)
void printSavedImageStats()
virtual void dumpMemoryProfile(FILE *outfile)
RexxObject * handleAllocationFailure(size_t allocationLength)
RexxObject * allocateObject(size_t allocationLength)
RexxObject * allocateObject(size_t allocationLength)
void markOldSpaceObjects()
static void liveGeneral(int reason)
static void live(size_t liveMark)
static RexxArray * getImageData()
static void initializeThreadContext()
void put(RexxObject *eref, size_t pos)
RexxObject * get(size_t pos)
static RexxBehaviour * restoreSavedPrimitiveBehaviour(RexxBehaviour *b)
void restore(RexxBehaviour *)
RexxBehaviour * getSavedPrimitiveBehaviour()
static RexxBehaviour * getPrimitiveBehaviour(size_t index)
static RexxBehaviour primitiveBehaviours[]
static void createInstance()
RexxObject * at(RexxString *)
RexxObject * put(RexxObject *, RexxString *)
RexxObject * value(HashLink pos)
HashLink next(HashLink pos)
RexxObject * index(HashLink pos)
virtual RexxObject * put(RexxObject *, RexxObject *)
virtual RexxObject * get(RexxObject *key)
virtual RexxObject * remove(RexxObject *key)
static void createInstance()
wholenumber_t incrementValue()
RexxObject * getValue(RexxActivation *)
wholenumber_t decrementValue()
void setBehaviour(RexxBehaviour *b)
void setObjectSize(size_t s)
void setObjectLive(size_t markword)
bool isObjectLive(size_t mark)
virtual RexxString * stringValue()
bool isObjectDead(size_t mark)
RexxBehaviour * behaviour
RexxBehaviour * getObjectType()
static RexxDirectory * functionsDir
void setEnvelope(RexxEnvelope *)
void markObjectsMain(RexxObject *)
void addWeakReference(WeakReference *ref)
RexxIdentityTable * old2new
static RexxDirectory * environment
void saveImageMark(RexxObject *markObject, RexxObject **pMarkObject)
void discardHoldObject(RexxInternalObject *obj)
RexxSaveStack * saveStack
MemorySegmentPool * firstPool
void removeUninitObject(RexxObject *obj)
void orphanCheckMark(RexxObject *markObject, RexxObject **pMarkObject)
bool objectReferenceOK(RexxObject *o)
@ saveArray_COMMON_RETRIEVERS
void initialize(bool restoringImage, const char *imageTarget)
void memoryPoolAdded(MemorySegmentPool *)
RexxObject * setParms(RexxObject *, RexxObject *)
void saveImage(const char *imageTarget)
RexxIdentityTable * uninitTable
void restoreObjectMark(RexxObject *markObject, RexxObject **pMarkObject)
WeakReference * weakReferenceList
static RexxDirectory * globalStrings
RexxObject * saveObject(RexxInternalObject *saveObj)
static void createImage(const char *imageTarget)
RexxObject * newObject(size_t size)
static SysMutex unflattenMutex
NormalSegmentSet newSpaceNormalSegments
MemorySegment * newSegment(size_t requestLength, size_t minLength)
static void * virtualFunctionTable[]
void killOrphans(RexxObject *)
bool inSharedObjectStorage(RexxObject *obj)
RexxObject * setDump(RexxObject *)
RexxObject * makeProxy(RexxEnvelope *)
static RexxArray * saveStrings()
MemorySegment * newLargeSegment(size_t requestLength, size_t minLength)
bool isPendingUninit(RexxObject *obj)
RexxArray * newObjects(size_t size, size_t count, size_t objectType)
RexxVariable * variableCache
RexxStack * getFlattenStack()
void addUninitObject(RexxObject *obj)
RexxObject * popLiveStack()
static void createLocks()
static RexxDirectory * system
void restoreMark(RexxObject *markObject, RexxObject **pMarkObject)
OldSpaceSegmentSet oldSpaceSegments
static void restoreStrings(RexxArray *stringArray)
void setUpMemoryTables(RexxIdentityTable *old2newTable)
void collectAndUninit(bool clearStack)
RexxObject * holdObject(RexxInternalObject *obj)
void pushLiveStack(RexxObject *obj)
RexxObject * dumpImageStats()
GlobalProtectedObject * protectedObjects
static SysMutex envelopeMutex
static void buildVirtualFunctionTable()
void liveGeneral(int reason)
bool inObjectStorage(RexxObject *obj)
LargeSegmentSet newSpaceLargeSegments
void logObjectStats(RexxObject *obj)
static RexxString * getGlobalName(const char *value)
void returnFlattenStack()
RexxObject * checkSetOref(RexxObject *, RexxObject **, RexxObject *, const char *, int)
char * allocateImageBuffer(size_t size)
void unflattenMark(RexxObject *markObject, RexxObject **pMarkObject)
static RexxDirectory * commonRetrievers
RexxIdentityTable * saveTable
void setObjectOffset(size_t offset)
RexxObject * oldObject(size_t size)
void verboseMessage(const char *message)
void dumpObject(RexxObject *objectRef, FILE *outfile)
void checkWeakReferences()
static RexxDirectory * kernel
static SysMutex flattenMutex
RexxObject * setOref(void *index, RexxObject *value)
RexxObject * temporaryObject(size_t size)
RexxStack * originalLiveStack
void reSize(RexxObject *, size_t)
MemorySegmentPool * currentPool
void pushSaveStack(RexxObject *obj)
void flatten(RexxEnvelope *)
void scavengeSegmentSets(MemorySegmentSet *requester, size_t allocationLength)
void logVerboseOutput(const char *message, void *sub1, void *sub2)
void initializeNewObject(size_t size, size_t mark, void *vft, RexxBehaviour *b)
void liveGeneral(int reason)
RexxClass * classObject()
void copyEntries(RexxStack *other)
RexxObject * push(RexxObject *obj)
const char * getStringData()
RexxObject * replace(RexxObject *newValue, HashLink pos)
static const char * getTempFileName()
void release(const char *ds, int di)
bool requestImmediate(const char *ds, int di)
void request(const char *ds, int di)
static void liveGeneral(int reason)
static void loadImage(char **imageBuffer, size_t *imageSize)
RexxObject * referentObject
WeakReference * nextReferenceList