From 6e6035505c73fe6539d19c452c6a283f5c4f23a8 Mon Sep 17 00:00:00 2001 From: Joel Dice Date: Tue, 3 Mar 2009 20:05:48 -0700 Subject: [PATCH] zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation. --- src/builtin.cpp | 9 ++--- src/compile.cpp | 36 +++++++++--------- src/jnienv.cpp | 24 ++++++------ src/machine.cpp | 83 ++++++++++++++++++++++++------------------ src/machine.h | 11 +++--- src/process.h | 5 +-- src/type-generator.cpp | 19 ---------- src/util.cpp | 4 +- 8 files changed, 90 insertions(+), 101 deletions(-) diff --git a/src/builtin.cpp b/src/builtin.cpp index 718b05f5cb..697a751a30 100644 --- a/src/builtin.cpp +++ b/src/builtin.cpp @@ -27,7 +27,7 @@ search(Thread* t, jstring name, object (*op)(Thread*, object), bool replaceDots) { if (LIKELY(name)) { - object n = makeByteArray(t, stringLength(t, *name) + 1, false); + object n = makeByteArray(t, stringLength(t, *name) + 1); char* s = reinterpret_cast(&byteArrayBody(t, n, 0)); stringChars(t, *name, s); @@ -406,7 +406,7 @@ Java_java_lang_reflect_Array_makeObjectArray { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeObjectArray(t, *elementType, length, true)); + return makeLocalReference(t, makeObjectArray(t, *elementType, length)); } extern "C" JNIEXPORT jint JNICALL @@ -671,7 +671,7 @@ Java_java_lang_Throwable_trace(Thread* t, jclass, jint skipCount) t->m->processor->walkStack(t, &v); - if (v.trace == 0) v.trace = makeArray(t, 0, true); + if (v.trace == 0) v.trace = makeArray(t, 0); return makeLocalReference(t, v.trace); } @@ -683,8 +683,7 @@ Java_java_lang_Throwable_resolveTrace(Thread* t, jclass, jobject trace) unsigned length = arrayLength(t, *trace); object array = makeObjectArray - (t, arrayBody(t, t->m->types, Machine::StackTraceElementType), - length, true); + (t, arrayBody(t, t->m->types, Machine::StackTraceElementType), length); PROTECT(t, array); object e = 0; diff --git a/src/compile.cpp b/src/compile.cpp index 6198eb37d3..61bb5d3c99 100644 --- a/src/compile.cpp +++ b/src/compile.cpp @@ -1568,8 +1568,7 @@ uint64_t makeBlankObjectArray(MyThread* t, object class_, int32_t length) { if (length >= 0) { - return reinterpret_cast - (makeObjectArray(t, class_, length, true)); + return reinterpret_cast(makeObjectArray(t, class_, length)); } else { object message = makeString(t, "%d", length); t->exception = makeNegativeArraySizeException(t, message); @@ -1581,7 +1580,7 @@ uint64_t makeBlankArray(MyThread* t, unsigned type, int32_t length) { if (length >= 0) { - object (*constructor)(Thread*, uintptr_t, bool); + object (*constructor)(Thread*, uintptr_t); switch (type) { case T_BOOLEAN: constructor = makeBooleanArray; @@ -1618,7 +1617,7 @@ makeBlankArray(MyThread* t, unsigned type, int32_t length) default: abort(t); } - return reinterpret_cast(constructor(t, length, true)); + return reinterpret_cast(constructor(t, length)); } else { object message = makeString(t, "%d", length); t->exception = makeNegativeArraySizeException(t, message); @@ -1698,7 +1697,7 @@ makeMultidimensionalArray2(MyThread* t, object class_, uintptr_t* countStack, } } - object array = makeArray(t, counts[0], true); + object array = makeArray(t, counts[0]); setObjectClass(t, array, class_); PROTECT(t, array); @@ -3828,10 +3827,10 @@ translateExceptionHandlerTable(MyThread* t, Compiler* c, object code, unsigned length = exceptionHandlerTableLength(t, oldTable); - object newIndex = makeIntArray(t, length * 3, false); + object newIndex = makeIntArray(t, length * 3); PROTECT(t, newIndex); - object newTable = makeArray(t, length + 1, true); + object newTable = makeArray(t, length + 1); PROTECT(t, newTable); set(t, newTable, ArrayBody, newIndex); @@ -3874,7 +3873,7 @@ translateLineNumberTable(MyThread* t, Compiler* c, object code, intptr_t start) PROTECT(t, oldTable); unsigned length = lineNumberTableLength(t, oldTable); - object newTable = makeLineNumberTable(t, length, false); + object newTable = makeLineNumberTable(t, length); for (unsigned i = 0; i < length; ++i) { LineNumber* oldLine = lineNumberTableBody(t, oldTable, i); LineNumber* newLine = lineNumberTableBody(t, newTable, i); @@ -4107,7 +4106,7 @@ finish(MyThread* t, Allocator* allocator, Context* context) FixedSizeOfArray + ((context->objectPoolCount + 1) * BytesPerWord), true); - initArray(t, pool, context->objectPoolCount + 1, false); + initArray(t, pool, context->objectPoolCount + 1); mark(t, pool, 0); set(t, pool, ArrayBody, objectPools(t)); @@ -4150,7 +4149,7 @@ finish(MyThread* t, Allocator* allocator, Context* context) codeLineNumberTable(t, code), codeMaxStack(t, code), codeMaxLocals(t, code), - 0, false); + 0); set(t, context->method, MethodCode, code); } @@ -4176,8 +4175,7 @@ finish(MyThread* t, Allocator* allocator, Context* context) unsigned size = usableFrameSizeWithParameters(t, context->method); object map = makeIntArray (t, context->traceLogCount - + ceiling(context->traceLogCount * size, 32), - false); + + ceiling(context->traceLogCount * size, 32)); assert(t, intArrayLength(t, map) == context->traceLogCount + frameObjectMapSize(t, context->method, map)); @@ -5076,7 +5074,7 @@ class MyProcessor: public Processor { return vm::makeClass (t, flags, vmFlags, arrayDimensions, fixedSize, arrayElementSize, objectMask, name, super, interfaceTable, virtualTable, fieldTable, - methodTable, staticTable, loader, vtableLength, false); + methodTable, staticTable, loader, vtableLength); } virtual void @@ -5399,7 +5397,7 @@ class MyProcessor: public Processor { if (image) { ::boot(static_cast(t), image); } else { - callTable = makeArray(t, 128, true); + callTable = makeArray(t, 128); methodTree = methodTreeSentinal = makeTreeNode(t, 0, 0, 0); set(t, methodTree, TreeNodeLeft, methodTreeSentinal); @@ -5471,7 +5469,7 @@ resizeTable(MyThread* t, object oldTable, unsigned newLength) object oldNode = 0; PROTECT(t, oldNode); - object newTable = makeArray(t, newLength, true); + object newTable = makeArray(t, newLength); PROTECT(t, newTable); for (unsigned i = 0; i < arrayLength(t, oldTable); ++i) { @@ -5532,7 +5530,7 @@ insertCallNode(MyThread* t, object node) object makeClassMap(Thread* t, unsigned* table, unsigned count, uintptr_t* heap) { - object array = makeArray(t, nextPowerOfTwo(count), true); + object array = makeArray(t, nextPowerOfTwo(count)); object map = makeHashMap(t, 0, array); PROTECT(t, map); @@ -5548,7 +5546,7 @@ object makeStaticTableArray(Thread* t, unsigned* table, unsigned count, uintptr_t* heap) { - object array = makeArray(t, count, false); + object array = makeArray(t, count); for (unsigned i = 0; i < count; ++i) { set(t, array, ArrayBody + (i * BytesPerWord), @@ -5561,7 +5559,7 @@ makeStaticTableArray(Thread* t, unsigned* table, unsigned count, object makeStringMap(Thread* t, unsigned* table, unsigned count, uintptr_t* heap) { - object array = makeArray(t, nextPowerOfTwo(count), true); + object array = makeArray(t, nextPowerOfTwo(count)); object map = makeWeakHashMap(t, 0, array); PROTECT(t, map); @@ -5577,7 +5575,7 @@ object makeCallTable(MyThread* t, uintptr_t* heap, unsigned* calls, unsigned count, uintptr_t base) { - object table = makeArray(t, nextPowerOfTwo(count), true); + object table = makeArray(t, nextPowerOfTwo(count)); PROTECT(t, table); unsigned size = 0; diff --git a/src/jnienv.cpp b/src/jnienv.cpp index 8ffb581151..976aab96f1 100644 --- a/src/jnienv.cpp +++ b/src/jnienv.cpp @@ -168,7 +168,7 @@ NewString(Thread* t, const jchar* chars, jsize size) object a = 0; if (size) { - a = makeCharArray(t, size, false); + a = makeCharArray(t, size); memcpy(&charArrayBody(t, a, 0), chars, size * sizeof(jchar)); } object s = makeString(t, a, 0, size, 0); @@ -184,7 +184,7 @@ NewStringUTF(Thread* t, const char* chars) object a = 0; unsigned size = strlen(chars); if (size) { - a = makeByteArray(t, size, false); + a = makeByteArray(t, size); memcpy(&byteArrayBody(t, a, 0), chars, size); } object s = makeString(t, a, 0, size, 0); @@ -208,7 +208,7 @@ FindClass(Thread* t, const char* name) { ENTER(t, Thread::ActiveState); - object n = makeByteArray(t, strlen(name) + 1, false); + object n = makeByteArray(t, strlen(name) + 1); replace('.', '/', name, &byteArrayBody(t, n, 0)); return makeLocalReference(t, resolveClass(t, n)); @@ -1214,7 +1214,7 @@ NewObjectArray(Thread* t, jsize length, jclass class_, jobject init) { ENTER(t, Thread::ActiveState); - object a = makeObjectArray(t, *class_, length, false); + object a = makeObjectArray(t, *class_, length); object value = (init ? *init : 0); for (jsize i = 0; i < length; ++i) { set(t, a, ArrayBody + (i * BytesPerWord), value); @@ -1244,7 +1244,7 @@ NewBooleanArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeBooleanArray(t, length, true)); + return makeLocalReference(t, makeBooleanArray(t, length)); } jbyteArray JNICALL @@ -1252,7 +1252,7 @@ NewByteArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeByteArray(t, length, true)); + return makeLocalReference(t, makeByteArray(t, length)); } jcharArray JNICALL @@ -1260,7 +1260,7 @@ NewCharArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeCharArray(t, length, true)); + return makeLocalReference(t, makeCharArray(t, length)); } jshortArray JNICALL @@ -1268,7 +1268,7 @@ NewShortArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeShortArray(t, length, true)); + return makeLocalReference(t, makeShortArray(t, length)); } jintArray JNICALL @@ -1276,7 +1276,7 @@ NewIntArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeIntArray(t, length, true)); + return makeLocalReference(t, makeIntArray(t, length)); } jlongArray JNICALL @@ -1284,7 +1284,7 @@ NewLongArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeLongArray(t, length, true)); + return makeLocalReference(t, makeLongArray(t, length)); } jfloatArray JNICALL @@ -1292,7 +1292,7 @@ NewFloatArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeFloatArray(t, length, true)); + return makeLocalReference(t, makeFloatArray(t, length)); } jdoubleArray JNICALL @@ -1300,7 +1300,7 @@ NewDoubleArray(Thread* t, jsize length) { ENTER(t, Thread::ActiveState); - return makeLocalReference(t, makeDoubleArray(t, length, true)); + return makeLocalReference(t, makeDoubleArray(t, length)); } jboolean* JNICALL diff --git a/src/machine.cpp b/src/machine.cpp index 335e9cf9d6..97f6a9fae7 100644 --- a/src/machine.cpp +++ b/src/machine.cpp @@ -453,9 +453,16 @@ postCollect(Thread* t) t->m->heap->free(t->defaultHeap, ThreadHeapSizeInBytes); t->defaultHeap = static_cast (t->m->heap->allocate(ThreadHeapSizeInBytes)); + memset(t->defaultHeap, 0, ThreadHeapSizeInBytes); #endif - t->heap = t->defaultHeap; + if (t->heap == t->defaultHeap) { + memset(t->defaultHeap, 0, t->heapIndex * BytesPerWord); + } else { + memset(t->defaultHeap, 0, ThreadHeapSizeInBytes); + t->heap = t->defaultHeap; + } + t->heapOffset = 0; t->heapIndex = 0; @@ -481,7 +488,7 @@ makeByteArray(Thread* t, const char* format, va_list a) int r = vsnprintf(buffer, Size - 1, format, a); expect(t, r >= 0 and r < Size - 1); - object s = makeByteArray(t, strlen(buffer) + 1, false); + object s = makeByteArray(t, strlen(buffer) + 1); memcpy(&byteArrayBody(t, s, 0), buffer, byteArrayLength(t, s)); return s; @@ -490,7 +497,7 @@ makeByteArray(Thread* t, const char* format, va_list a) object parseUtf8(Thread* t, Stream& s, unsigned length) { - object value = makeByteArray(t, length + 1, false); + object value = makeByteArray(t, length + 1); unsigned vi = 0; for (unsigned si = 0; si < length; ++si) { unsigned a = s.read1(); @@ -523,7 +530,7 @@ parseUtf8(Thread* t, Stream& s, unsigned length) if (vi < length) { PROTECT(t, value); - object v = makeByteArray(t, vi + 1, false); + object v = makeByteArray(t, vi + 1); memcpy(&byteArrayBody(t, v, 0), &byteArrayBody(t, value, 0), vi); value = v; } @@ -622,7 +629,7 @@ parsePool(Thread* t, Stream& s) { unsigned count = s.read2() - 1; - object pool = makeSingleton(t, count); + object pool = makeSingletonOfSize(t, count); PROTECT(t, pool); if (count) { @@ -734,7 +741,7 @@ parseInterfaceTable(Thread* t, Stream& s, object class_, object pool) if ((classFlags(t, class_) & ACC_INTERFACE) == 0) { length *= 2; } - interfaceTable = makeArray(t, length, true); + interfaceTable = makeArray(t, length); PROTECT(t, interfaceTable); unsigned i = 0; @@ -749,7 +756,7 @@ parseInterfaceTable(Thread* t, Stream& s, object class_, object pool) if (classVirtualTable(t, interface)) { // we'll fill in this table in parseMethodTable(): object vtable = makeArray - (t, arrayLength(t, classVirtualTable(t, interface)), true); + (t, arrayLength(t, classVirtualTable(t, interface))); set(t, interfaceTable, ArrayBody + (i * BytesPerWord), vtable); } @@ -778,10 +785,10 @@ parseFieldTable(Thread* t, Stream& s, object class_, object pool) unsigned staticOffset = BytesPerWord * 2; unsigned staticCount = 0; - object fieldTable = makeArray(t, count, true); + object fieldTable = makeArray(t, count); PROTECT(t, fieldTable); - object staticValueTable = makeIntArray(t, count, false); + object staticValueTable = makeIntArray(t, count); PROTECT(t, staticValueTable); uint8_t staticTypes[count]; @@ -856,7 +863,7 @@ parseFieldTable(Thread* t, Stream& s, object class_, object pool) if (staticCount) { unsigned footprint = ceiling(staticOffset - (BytesPerWord * 2), BytesPerWord); - object staticTable = makeSingleton(t, footprint); + object staticTable = makeSingletonOfSize(t, footprint); uint8_t* body = reinterpret_cast (&singletonBody(t, staticTable, 0)); @@ -901,8 +908,6 @@ parseFieldTable(Thread* t, Stream& s, object class_, object pool) default: abort(t); } - } else { - memset(body + offset, 0, size); } if (staticTypes[i] == ObjectField) { @@ -925,7 +930,7 @@ parseFieldTable(Thread* t, Stream& s, object class_, object pool) classObjectMask(t, classSuper(t, class_))); } else { object mask = makeIntArray - (t, ceiling(classFixedSize(t, class_), 32 * BytesPerWord), true); + (t, ceiling(classFixedSize(t, class_), 32 * BytesPerWord)); intArrayBody(t, mask, 0) = 1; object superMask = 0; @@ -970,13 +975,13 @@ parseCode(Thread* t, Stream& s, object pool) unsigned maxLocals = s.read2(); unsigned length = s.read4(); - object code = makeCode(t, pool, 0, 0, maxStack, maxLocals, length, false); + object code = makeCode(t, pool, 0, 0, maxStack, maxLocals, length); s.read(&codeBody(t, code, 0), length); PROTECT(t, code); unsigned ehtLength = s.read2(); if (ehtLength) { - object eht = makeExceptionHandlerTable(t, ehtLength, false); + object eht = makeExceptionHandlerTable(t, ehtLength); for (unsigned i = 0; i < ehtLength; ++i) { ExceptionHandler* eh = exceptionHandlerTableBody(t, eht, i); exceptionHandlerStart(eh) = s.read2(); @@ -997,7 +1002,7 @@ parseCode(Thread* t, Stream& s, object pool) &byteArrayBody(t, name, 0)) == 0) { unsigned lntLength = s.read2(); - object lnt = makeLineNumberTable(t, lntLength, false); + object lnt = makeLineNumberTable(t, lntLength); for (unsigned i = 0; i < lntLength; ++i) { LineNumber* ln = lineNumberTableBody(t, lnt, i); lineNumberIp(ln) = s.read2(); @@ -1094,7 +1099,7 @@ parseMethodTable(Thread* t, Stream& s, object class_, object pool) unsigned count = s.read2(); if (count) { - object methodTable = makeArray(t, count, true); + object methodTable = makeArray(t, count); PROTECT(t, methodTable); for (unsigned i = 0; i < count; ++i) { @@ -1199,13 +1204,13 @@ parseMethodTable(Thread* t, Stream& s, object class_, object pool) } else { // apparently, Object does not have any virtual methods. We // give it a vtable anyway so code doesn't break elsewhere. - object vtable = makeArray(t, 0, false); + object vtable = makeArray(t, 0); set(t, class_, ClassVirtualTable, vtable); } } else if (virtualCount) { // generate class vtable - object vtable = makeArray(t, virtualCount, true); + object vtable = makeArray(t, virtualCount); unsigned i = 0; if (classFlags(t, class_) & ACC_INTERFACE) { @@ -1384,7 +1389,7 @@ makeArrayClass(Thread* t, object spec) const char* elementSpecStart = s; while (*s and *s != ';') ++ s; - elementSpec = makeByteArray(t, s - elementSpecStart + 1, false); + elementSpec = makeByteArray(t, s - elementSpecStart + 1); memcpy(&byteArrayBody(t, elementSpec, 0), &byteArrayBody(t, spec, elementSpecStart - start), s - elementSpecStart); @@ -1394,7 +1399,7 @@ makeArrayClass(Thread* t, object spec) default: if (dimensions > 1) { char c = *s; - elementSpec = makeByteArray(t, 3, false); + elementSpec = makeByteArray(t, 3); byteArrayBody(t, elementSpec, 0) = '['; byteArrayBody(t, elementSpec, 1) = c; byteArrayBody(t, elementSpec, 2) = 0; @@ -1460,7 +1465,7 @@ bootClass(Thread* t, Machine::Type type, int superType, uint32_t objectMask, { mask = classObjectMask(t, arrayBody(t, t->m->types, superType)); } else { - mask = makeIntArray(t, 1, false); + mask = makeIntArray(t, 1); intArrayBody(t, mask, 0) = objectMask; } } else { @@ -1491,7 +1496,7 @@ bootJavaClass(Thread* t, Machine::Type type, int superType, const char* name, if (vtableLength >= 0) { PROTECT(t, class_); - vtable = makeArray(t, vtableLength, false); + vtable = makeArray(t, vtableLength); for (int i = 0; i < vtableLength; ++ i) { arrayBody(t, vtable, i) = bootMethod; } @@ -1514,11 +1519,9 @@ boot(Thread* t) m->unsafe = true; m->loader = allocate(t, sizeof(void*) * 3, true); - memset(m->loader, 0, sizeof(void*) * 2); m->types = allocate(t, pad((TypeCount + 2) * BytesPerWord), true); arrayLength(t, m->types) = TypeCount; - memset(&arrayBody(t, m->types, 0), 0, TypeCount * BytesPerWord); #include "type-initializations.cpp" @@ -1578,7 +1581,7 @@ boot(Thread* t) m->processor->boot(t, 0); - { object bootCode = makeCode(t, 0, 0, 0, 0, 0, 1, false); + { object bootCode = makeCode(t, 0, 0, 0, 0, 0, 1); codeBody(t, bootCode, 0) = impdep1; object bootMethod = makeMethod (t, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, bootCode, 0); @@ -1792,6 +1795,8 @@ Thread::Thread(Machine* m, object javaThread, Thread* parent): void Thread::init() { + memset(defaultHeap, 0, ThreadHeapSizeInBytes); + if (parent == 0) { assert(this, m->rootThread == 0); assert(this, javaThread == 0); @@ -1826,7 +1831,7 @@ Thread::init() m->monitorMap = makeWeakHashMap(this, 0, 0); - m->jniMethodTable = makeVector(this, 0, 0, false); + m->jniMethodTable = makeVector(this, 0, 0); m->localThread->set(this); } else { @@ -2063,7 +2068,10 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type, if (t->m->heapPoolIndex < ThreadHeapPoolSize) { t->heap = static_cast (t->m->heap->tryAllocate(ThreadHeapSizeInBytes)); + if (t->heap) { + memset(t->heap, 0, ThreadHeapSizeInBytes); + t->m->heapPool[t->m->heapPoolIndex++] = t->heap; t->heapOffset += t->heapIndex; t->heapIndex = 0; @@ -2099,6 +2107,8 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type, (t->m->heap->allocateFixed (allocator, ceiling(sizeInBytes, BytesPerWord), objectMask, &total)); + memset(o, 0, sizeInBytes); + cast(o, 0) = FixedMark; t->m->fixedFootprint += total; @@ -2112,6 +2122,8 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type, (t->m->heap->allocateImmortalFixed (allocator, ceiling(sizeInBytes, BytesPerWord), objectMask, &total)); + memset(o, 0, sizeInBytes); + cast(o, 0) = FixedMark; return o; @@ -2376,8 +2388,7 @@ parseClass(Thread* t, const uint8_t* data, unsigned size) 0, // methods 0, // static table t->m->loader, - 0, // vtable length - false); + 0);// vtable length PROTECT(t, class_); unsigned super = s.read2(); @@ -2526,13 +2537,13 @@ resolveObjectArrayClass(Thread* t, object elementSpec) object spec; if (byteArrayBody(t, elementSpec, 0) == '[') { - spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 1, false); + spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 1); byteArrayBody(t, spec, 0) = '['; memcpy(&byteArrayBody(t, spec, 1), &byteArrayBody(t, elementSpec, 0), byteArrayLength(t, elementSpec)); } else { - spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 3, false); + spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 3); byteArrayBody(t, spec, 0) = '['; byteArrayBody(t, spec, 1) = 'L'; memcpy(&byteArrayBody(t, spec, 2), @@ -2546,12 +2557,12 @@ resolveObjectArrayClass(Thread* t, object elementSpec) } object -makeObjectArray(Thread* t, object elementClass, unsigned count, bool clear) +makeObjectArray(Thread* t, object elementClass, unsigned count) { object arrayClass = resolveObjectArrayClass(t, className(t, elementClass)); PROTECT(t, arrayClass); - object array = makeArray(t, count, clear); + object array = makeArray(t, count); setObjectClass(t, array, arrayClass); return array; @@ -2900,7 +2911,7 @@ makeTrace(Thread* t, Processor::StackWalker* walker) virtual bool visit(Processor::StackWalker* walker) { if (trace == 0) { - trace = makeArray(t, walker->count(), true); + trace = makeArray(t, walker->count()); } object e = makeTraceElement(t, walker->method(), walker->ip()); @@ -2918,7 +2929,7 @@ makeTrace(Thread* t, Processor::StackWalker* walker) walker->walk(&v); - return v.trace ? v.trace : makeArray(t, 0, true); + return v.trace ? v.trace : makeArray(t, 0); } object @@ -2939,7 +2950,7 @@ makeTrace(Thread* t, Thread* target) t->m->processor->walkStack(target, &v); - return v.trace ? v.trace : makeArray(t, 0, true); + return v.trace ? v.trace : makeArray(t, 0); } void diff --git a/src/machine.h b/src/machine.h index 63806421f8..c2001c749b 100644 --- a/src/machine.h +++ b/src/machine.h @@ -1490,6 +1490,9 @@ ensure(Thread* t, unsigned sizeInBytes) expect(t, t->backupHeap == 0); t->backupHeap = static_cast (t->m->heap->allocate(pad(sizeInBytes))); + + memset(t->backupHeap, 0, sizeInBytes); + t->backupHeapIndex = 0; t->backupHeapSizeInWords = ceiling(sizeInBytes, BytesPerWord); } @@ -1763,8 +1766,6 @@ makeNew(Thread* t, object class_) unsigned sizeInBytes = pad(classFixedSize(t, class_)); object instance = allocate(t, sizeInBytes, classObjectMask(t, class_)); setObjectClass(t, instance, class_); - memset(&cast(instance, BytesPerWord), 0, - sizeInBytes - BytesPerWord); return instance; } @@ -2068,7 +2069,7 @@ initClass(Thread* t, object c) } object -makeObjectArray(Thread* t, object elementClass, unsigned count, bool clear); +makeObjectArray(Thread* t, object elementClass, unsigned count); object findInTable(Thread* t, object table, object name, object spec, @@ -2358,9 +2359,9 @@ singletonValue(Thread* t, object singleton, unsigned index) } inline object -makeSingleton(Thread* t, unsigned count) +makeSingletonOfSize(Thread* t, unsigned count) { - object o = makeSingleton(t, count + singletonMaskSize(count), true); + object o = makeSingleton(t, count + singletonMaskSize(count)); assert(t, singletonLength(t, o) == count + singletonMaskSize(t, o)); if (count) { singletonMask(t, o)[0] = 1; diff --git a/src/process.h b/src/process.h index 78c231b307..8689657bf3 100644 --- a/src/process.h +++ b/src/process.h @@ -167,8 +167,7 @@ populateMultiArray(Thread* t, object array, int32_t* counts, object spec = className(t, objectClass(t, array)); PROTECT(t, spec); - object elementSpec = makeByteArray - (t, byteArrayLength(t, spec) - 1, false); + object elementSpec = makeByteArray(t, byteArrayLength(t, spec) - 1); memcpy(&byteArrayBody(t, elementSpec, 0), &byteArrayBody(t, spec, 1), byteArrayLength(t, spec) - 1); @@ -177,7 +176,7 @@ populateMultiArray(Thread* t, object array, int32_t* counts, PROTECT(t, class_); for (int32_t i = 0; i < counts[index]; ++i) { - object a = makeArray(t, counts[index + 1], true); + object a = makeArray(t, counts[index + 1]); setObjectClass(t, a, class_); set(t, array, ArrayBody + (i * BytesPerWord), a); diff --git a/src/type-generator.cpp b/src/type-generator.cpp index 34a79ee5e6..fbb0db7452 100644 --- a/src/type-generator.cpp +++ b/src/type-generator.cpp @@ -1796,10 +1796,6 @@ writeConstructorParameters(Output* out, Object* t) out->write(" "); out->write(obfuscate(memberName(m))); } break; - - case Object::Array: { - out->write(", bool clear"); - } break; default: break; } @@ -1816,10 +1812,6 @@ writeConstructorArguments(Output* out, Object* t) out->write(", "); out->write(obfuscate(memberName(m))); } break; - - case Object::Array: { - out->write(", clear"); - } break; default: break; } @@ -1839,17 +1831,6 @@ writeConstructorInitializations(Output* out, Object* t) out->write(obfuscate(memberName(m))); out->write(";\n"); } break; - - case Object::Array: { - out->write(" if (clear and length) memset("); - if (memberTypeObject(m) == 0) { - out->write("&"); - } - writeAccessorName(out, m); - out->write("(t, o, 0), 0, length * "); - out->write(arrayElementSize(m)); - out->write(");\n"); - } break; default: break; } diff --git a/src/util.cpp b/src/util.cpp index 2fa3e4ae56..5483fa6c18 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -358,7 +358,7 @@ hashMapResize(Thread* t, object map, uint32_t (*hash)(Thread*, object), return; } - newArray = makeArray(t, newLength, true); + newArray = makeArray(t, newLength); if (oldArray != hashMapArray(t, map)) { // a resize was performed during a GC via the makeArray call @@ -525,7 +525,7 @@ vectorAppend(Thread* t, object vector, object value) PROTECT(t, value); object newVector = makeVector - (t, vectorSize(t, vector), max(16, vectorSize(t, vector) * 2), false); + (t, vectorSize(t, vector), max(16, vectorSize(t, vector) * 2)); if (vectorSize(t, vector)) { memcpy(&vectorBody(t, newVector, 0),