Lines Matching refs:size
38 #define CHECK_OBJ_AND_THROW_OOM_ERROR(object, size, space, message) \
47 ThrowOutOfMemoryError(GetJSThread(), size, message); \
48 (object) = reinterpret_cast<TaggedObject *>((space)->Allocate(size)); \
51 #define CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, space, message) \
56 ThrowOutOfMemoryError(thread, size, message); \
57 (object) = reinterpret_cast<TaggedObject *>((space)->Allocate(thread, size)); \
60 #define CHECK_MACHINE_CODE_OBJ_AND_SET_OOM_ERROR_FORT(object, size, space, desc, message) \
65 SetMachineCodeOutOfMemoryError(GetJSThread(), size, message); \
66 (object) = reinterpret_cast<TaggedObject *>((space)->Allocate(size, desc)); \
69 #define CHECK_MACHINE_CODE_OBJ_AND_SET_OOM_ERROR(object, size, space, message) \
74 SetMachineCodeOutOfMemoryError(GetJSThread(), size, message); \
75 (object) = reinterpret_cast<TaggedObject *>((space)->Allocate(size)); \
206 size_t size = hclass->GetObjectSize();
207 return AllocateYoungOrHugeObject(hclass, size);
210 TaggedObject *Heap::AllocateYoungOrHugeObject(size_t size)
212 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
214 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
215 object = AllocateHugeObject(size);
217 object = AllocateInGeneralNewSpace(size);
222 object = AllocateInGeneralNewSpace(size);
225 object = AllocateInGeneralNewSpace(size);
226 CHECK_OBJ_AND_THROW_OOM_ERROR(object, size, activeSemiSpace_, "Heap::AllocateYoungOrHugeObject");
233 TaggedObject *Heap::AllocateInGeneralNewSpace(size_t size)
236 auto object = reinterpret_cast<TaggedObject *>(edenSpace_->Allocate(size));
241 return reinterpret_cast<TaggedObject *>(activeSemiSpace_->Allocate(size));
244 TaggedObject *Heap::AllocateYoungOrHugeObject(JSHClass *hclass, size_t size)
246 auto object = AllocateYoungOrHugeObject(size);
250 OnAllocateEvent(GetEcmaVM(), object, size);
256 [[maybe_unused]] size_t size)
261 OnAllocateEvent(thread->GetEcmaVM(), object, size);
265 uintptr_t Heap::AllocateYoungSync(size_t size)
267 return activeSemiSpace_->AllocateSync(size);
294 TaggedObject *Heap::TryAllocateYoungGeneration(JSHClass *hclass, size_t size)
296 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
297 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
300 auto object = reinterpret_cast<TaggedObject *>(activeSemiSpace_->Allocate(size));
305 OnAllocateEvent(GetEcmaVM(), object, size);
312 size_t size = hclass->GetObjectSize();
313 return AllocateOldOrHugeObject(hclass, size);
316 TaggedObject *Heap::AllocateOldOrHugeObject(size_t size)
318 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
320 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
321 object = AllocateHugeObject(size);
323 object = reinterpret_cast<TaggedObject *>(oldSpace_->Allocate(size));
324 CHECK_OBJ_AND_THROW_OOM_ERROR(object, size, oldSpace_, "Heap::AllocateOldOrHugeObject");
329 TaggedObject *Heap::AllocateOldOrHugeObject(JSHClass *hclass, size_t size)
331 auto object = AllocateOldOrHugeObject(size);
334 OnAllocateEvent(GetEcmaVM(), reinterpret_cast<TaggedObject*>(object), size);
341 size_t size = hclass->GetObjectSize();
342 TaggedObject *object = AllocateReadOnlyOrHugeObject(hclass, size);
344 OnAllocateEvent(GetEcmaVM(), object, size);
349 TaggedObject *Heap::AllocateReadOnlyOrHugeObject(JSHClass *hclass, size_t size)
351 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
353 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
354 object = AllocateHugeObject(hclass, size);
356 object = reinterpret_cast<TaggedObject *>(readOnlySpace_->Allocate(size));
357 CHECK_OBJ_AND_THROW_OOM_ERROR(object, size, readOnlySpace_, "Heap::AllocateReadOnlyOrHugeObject");
361 OnAllocateEvent(GetEcmaVM(), object, size);
368 size_t size = hclass->GetObjectSize();
369 TaggedObject *object = AllocateNonMovableOrHugeObject(hclass, size);
374 OnAllocateEvent(GetEcmaVM(), object, size);
379 TaggedObject *Heap::AllocateNonMovableOrHugeObject(JSHClass *hclass, size_t size)
381 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
383 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
384 object = AllocateHugeObject(hclass, size);
386 object = reinterpret_cast<TaggedObject *>(nonMovableSpace_->CheckAndAllocate(size));
387 CHECK_OBJ_AND_THROW_OOM_ERROR(object, size, nonMovableSpace_, "Heap::AllocateNonMovableOrHugeObject");
391 OnAllocateEvent(GetEcmaVM(), object, size);
396 TaggedObject *Heap::AllocateClassClass(JSHClass *hclass, size_t size)
398 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
399 auto object = reinterpret_cast<TaggedObject *>(nonMovableSpace_->Allocate(size));
406 OnAllocateEvent(GetEcmaVM(), object, size);
411 TaggedObject *SharedHeap::AllocateClassClass(JSThread *thread, JSHClass *hclass, size_t size)
413 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
414 auto object = reinterpret_cast<TaggedObject *>(sReadOnlySpace_->Allocate(thread, size));
421 OnAllocateEvent(thread->GetEcmaVM(), object, size);
426 TaggedObject *Heap::AllocateHugeObject(size_t size)
429 CheckAndTriggerOldGC(size);
431 auto *object = reinterpret_cast<TaggedObject *>(hugeObjectSpace_->Allocate(size, thread_));
434 object = reinterpret_cast<TaggedObject *>(hugeObjectSpace_->Allocate(size, thread_));
436 // if allocate huge object OOM, temporarily increase space size to avoid vm crash
441 object = reinterpret_cast<TaggedObject *>(hugeObjectSpace_->Allocate(size, thread_));
442 ThrowOutOfMemoryError(thread_, size, "Heap::AllocateHugeObject");
443 object = reinterpret_cast<TaggedObject *>(hugeObjectSpace_->Allocate(size, thread_));
445 FatalOutOfMemoryError(size, "Heap::AllocateHugeObject");
452 TaggedObject *Heap::AllocateHugeObject(JSHClass *hclass, size_t size)
455 CheckAndTriggerOldGC(size);
456 auto object = AllocateHugeObject(size);
459 OnAllocateEvent(GetEcmaVM(), object, size);
464 TaggedObject *Heap::AllocateHugeMachineCodeObject(size_t size, MachineCodeDesc *desc)
469 size, thread_, reinterpret_cast<void *>(desc)));
472 size, thread_));
477 TaggedObject *Heap::AllocateMachineCodeObject(JSHClass *hclass, size_t size, MachineCodeDesc *desc)
480 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
484 object = (size > MAX_REGULAR_HEAP_OBJECT_SIZE) ?
485 reinterpret_cast<TaggedObject *>(AllocateHugeMachineCodeObject(size)) :
486 reinterpret_cast<TaggedObject *>(machineCodeSpace_->Allocate(size));
487 CHECK_MACHINE_CODE_OBJ_AND_SET_OOM_ERROR(object, size, machineCodeSpace_,
491 OnAllocateEvent(GetEcmaVM(), object, size);
500 if (size <= MAX_REGULAR_HEAP_OBJECT_SIZE) {
509 object = (size > MAX_REGULAR_HEAP_OBJECT_SIZE) ?
510 reinterpret_cast<TaggedObject *>(AllocateHugeMachineCodeObject(size, desc)) :
511 reinterpret_cast<TaggedObject *>(machineCodeSpace_->Allocate(size, desc, true));
512 CHECK_MACHINE_CODE_OBJ_AND_SET_OOM_ERROR_FORT(object, size, machineCodeSpace_, desc,
516 OnAllocateEvent(GetEcmaVM(), object, size);
521 uintptr_t Heap::AllocateSnapshotSpace(size_t size)
523 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
524 uintptr_t object = snapshotSpace_->Allocate(size);
526 FatalOutOfMemoryError(size, "Heap::AllocateSnapshotSpaceObject");
529 OnAllocateEvent(GetEcmaVM(), reinterpret_cast<TaggedObject *>(object), size);
534 TaggedObject *Heap::AllocateSharedNonMovableSpaceFromTlab(JSThread *thread, size_t size)
537 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
538 TaggedObject *object = reinterpret_cast<TaggedObject*>(sNonMovableTlab_->Allocate(size));
542 if (!sNonMovableTlab_->NeedNewTlab(size)) {
553 sNonMovableTlab_->Reset(begin, begin + newTlabSize, begin + size);
561 TaggedObject *Heap::AllocateSharedOldSpaceFromTlab(JSThread *thread, size_t size)
564 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
565 TaggedObject *object = reinterpret_cast<TaggedObject*>(sOldTlab_->Allocate(size));
569 if (!sOldTlab_->NeedNewTlab(size)) {
580 sOldTlab_->Reset(begin, begin + newTlabSize, begin + size);
778 // Record alive object size after shared gc and other stats
789 size_t size = hclass->GetObjectSize();
790 return AllocateNonMovableOrHugeObject(thread, hclass, size);
793 TaggedObject *SharedHeap::AllocateNonMovableOrHugeObject(JSThread *thread, JSHClass *hclass, size_t size)
795 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
796 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
797 return AllocateHugeObject(thread, hclass, size);
800 const_cast<Heap*>(thread->GetEcmaVM()->GetHeap())->AllocateSharedNonMovableSpaceFromTlab(thread, size);
802 object = reinterpret_cast<TaggedObject *>(sNonMovableSpace_->Allocate(thread, size));
803 CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, sNonMovableSpace_,
811 OnAllocateEvent(thread->GetEcmaVM(), object, size);
816 TaggedObject *SharedHeap::AllocateNonMovableOrHugeObject(JSThread *thread, size_t size)
818 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
819 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
820 return AllocateHugeObject(thread, size);
823 const_cast<Heap*>(thread->GetEcmaVM()->GetHeap())->AllocateSharedNonMovableSpaceFromTlab(thread, size);
825 object = reinterpret_cast<TaggedObject *>(sNonMovableSpace_->Allocate(thread, size));
826 CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, sNonMovableSpace_,
831 OnAllocateEvent(thread->GetEcmaVM(), object, size);
838 size_t size = hclass->GetObjectSize();
839 return AllocateOldOrHugeObject(thread, hclass, size);
842 TaggedObject *SharedHeap::AllocateOldOrHugeObject(JSThread *thread, JSHClass *hclass, size_t size)
844 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
845 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
846 return AllocateHugeObject(thread, hclass, size);
849 const_cast<Heap*>(thread->GetEcmaVM()->GetHeap())->AllocateSharedOldSpaceFromTlab(thread, size);
851 object = AllocateInSOldSpace(thread, size);
852 CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, sOldSpace_, "SharedHeap::AllocateOldOrHugeObject");
859 OnAllocateEvent(thread->GetEcmaVM(), object, size);
864 TaggedObject *SharedHeap::AllocateOldOrHugeObject(JSThread *thread, size_t size)
866 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
867 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
868 return AllocateHugeObject(thread, size);
871 const_cast<Heap*>(thread->GetEcmaVM()->GetHeap())->AllocateSharedOldSpaceFromTlab(thread, size);
873 object = AllocateInSOldSpace(thread, size);
874 CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, sOldSpace_, "SharedHeap::AllocateOldOrHugeObject");
880 TaggedObject *SharedHeap::AllocateInSOldSpace(JSThread *thread, size_t size)
886 localHeap->TryTriggerFullMarkBySharedSize(size);
888 TaggedObject *object = reinterpret_cast<TaggedObject *>(sOldSpace_->TryAllocateAndExpand(thread, size, false));
894 object = reinterpret_cast<TaggedObject *>(sOldSpace_->TryAllocateAndExpand(thread, size, true));
899 object = reinterpret_cast<TaggedObject *>(sOldSpace_->TryAllocateAndExpand(thread, size, true));
905 TaggedObject *SharedHeap::AllocateHugeObject(JSThread *thread, JSHClass *hclass, size_t size)
907 auto object = AllocateHugeObject(thread, size);
910 OnAllocateEvent(thread->GetEcmaVM(), object, size);
915 TaggedObject *SharedHeap::AllocateHugeObject(JSThread *thread, size_t size)
918 CheckHugeAndTriggerSharedGC(thread, size);
919 auto *object = reinterpret_cast<TaggedObject *>(sHugeObjectSpace_->Allocate(thread, size));
922 object = reinterpret_cast<TaggedObject *>(sHugeObjectSpace_->Allocate(thread, size));
924 // if allocate huge object OOM, temporarily increase space size to avoid vm crash
928 ThrowOutOfMemoryError(thread, size, "SharedHeap::AllocateHugeObject");
929 object = reinterpret_cast<TaggedObject *>(sHugeObjectSpace_->Allocate(thread, size));
931 FatalOutOfMemoryError(size, "SharedHeap::AllocateHugeObject");
941 size_t size = hclass->GetObjectSize();
942 return AllocateReadOnlyOrHugeObject(thread, hclass, size);
945 TaggedObject *SharedHeap::AllocateReadOnlyOrHugeObject(JSThread *thread, JSHClass *hclass, size_t size)
947 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
948 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
949 return AllocateHugeObject(thread, hclass, size);
951 auto object = reinterpret_cast<TaggedObject *>(sReadOnlySpace_->Allocate(thread, size));
952 CHECK_SOBJ_AND_THROW_OOM_ERROR(thread, object, size, sReadOnlySpace_, "SharedHeap::AllocateReadOnlyOrHugeObject");
958 TaggedObject *SharedHeap::AllocateSOldTlab(JSThread *thread, size_t size)
960 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
961 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
966 object = reinterpret_cast<TaggedObject *>(sOldSpace_->AllocateNoGCAndExpand(thread, size));
968 object = AllocateInSOldSpace(thread, size);
973 TaggedObject *SharedHeap::AllocateSNonMovableTlab(JSThread *thread, size_t size)
975 size = AlignUp(size, static_cast<size_t>(MemAlignment::MEM_ALIGN_OBJECT));
976 if (size > MAX_REGULAR_HEAP_OBJECT_SIZE) {
980 object = reinterpret_cast<TaggedObject *>(sNonMovableSpace_->Allocate(thread, size));
1039 if (vec.size() < vec.capacity() / SHRINK_FACTOR) {
1089 ECMA_BYTRACE_NAME(HITRACE_TAG_ARK, "ProcessNativeDeleteNum:" + std::to_string(nativePointerList_.size()));
1131 ECMA_BYTRACE_NAME(HITRACE_TAG_ARK, "ProcessReferencesNum:" + std::to_string(nativePointerList_.size()));