/* descriptor allocator when more than one word is required to describe the * pointers */ struct GGGGC_Descriptor *ggggc_allocateDescriptorL(ggc_size_t size, const ggc_size_t *pointers) { struct GGGGC_Descriptor *dd, *ret; ggc_size_t dPWords, dSize; /* the size of the descriptor */ if (pointers) dPWords = GGGGC_DESCRIPTOR_WORDS_REQ(size); else dPWords = 1; dSize = GGGGC_WORD_SIZEOF(struct GGGGC_Descriptor) + dPWords; /* get a descriptor-descriptor for the descriptor we're about to allocate */ dd = ggggc_allocateDescriptorDescriptor(dSize); /* use that to allocate the descriptor */ ret = (struct GGGGC_Descriptor *) ggggc_malloc(dd); ret->size = size; /* and set it up */ if (pointers) { memcpy(ret->pointers, pointers, sizeof(ggc_size_t) * dPWords); ret->pointers[0] |= 1; /* first word is always the descriptor pointer */ } else { ret->pointers[0] = 0; } return ret; }
/* allocate a pointer array (size is in words) */ void *ggggc_mallocPointerArray(ggc_size_t sz) { struct GGGGC_Descriptor *descriptor = ggggc_allocateDescriptorPA(sz + 1 + sizeof(struct GGGGC_Header)/sizeof(ggc_size_t)); struct GGGGC_Array *ret = (struct GGGGC_Array *) ggggc_malloc(descriptor); ret->length = sz; return ret; }
/* allocate a data array */ void *ggggc_mallocDataArray(ggc_size_t nmemb, ggc_size_t size) { ggc_size_t sz = ((nmemb*size)+sizeof(ggc_size_t)-1)/sizeof(ggc_size_t); struct GGGGC_Descriptor *descriptor = ggggc_allocateDescriptorDA(sz + 1 + sizeof(struct GGGGC_Header)/sizeof(ggc_size_t)); struct GGGGC_Array *ret = (struct GGGGC_Array *) ggggc_malloc(descriptor); ret->length = nmemb; return ret; }
void * LSRValue::createInMemory(void *classD) { LSRClassTable * classDefs = (LSRClassTable *) classD; if (!classDefs->contains(className)) { return NULL; } void * desc = classDefs->getDescriptorPointer(className); objPtr = NULL; GGC_PUSH_1(objPtr); objPtr = ggggc_malloc((struct GGGGC_Descriptor *) desc); return objPtr; }
/* allocate an object */ void *ggggc_malloc(struct GGGGC_Descriptor *descriptor) { /* FILLME */ ggc_size_t *ret = NULL; //allocate a pool if no pool if(!ggggc_fromPoolList){ ggggc_fromPoolList = newPool(1); ggggc_fromPoolList->generation = 1; totalYoungSpace += ggggc_fromPoolList->end - ggggc_fromPoolList->start; ggggc_toPoolList = newPool(1); ggggc_toPoolList->generation = 3; totalYoungSpace += ggggc_toPoolList->end - ggggc_toPoolList->start; ggggc_fromPoolTail = ggggc_fromPoolList; ggggc_toPoolTail = ggggc_toPoolList; } if(!ggggc_curToPool) ggggc_curToPool = ggggc_toPoolList; while (ggggc_curToPool){ if (ggggc_curToPool->end - ggggc_curToPool->free >= descriptor->size){ //allocate using free space ret = (ggc_size_t*)ggggc_curToPool->free; ggggc_curToPool->free += descriptor->size; setToZero(ret, descriptor->size); ((struct GGGGC_Header*)ret)->descriptor__ptr = descriptor; //totalFilled += allocationSizeRounded; return ret; } ggggc_curToPool = ggggc_curToPool -> next; } ggggc_collect(); //the descriptor used for allocate sis moved after collect if(isForwarded((ggc_size_t *)descriptor)) descriptor = (struct GGGGC_Descriptor *)(getForwardingAddress((ggc_size_t *)descriptor)); return ggggc_malloc(descriptor); //return GC_MALLOC(descriptor->size * sizeof(void*)); }
/* allocate a descriptor-descriptor for a descriptor of the given size */ struct GGGGC_Descriptor *ggggc_allocateDescriptorDescriptor(ggc_size_t size) { struct GGGGC_Descriptor tmpDescriptor, *ret; ggc_size_t ddSize; /* need one description bit for every word in the object */ ddSize = GGGGC_WORD_SIZEOF(struct GGGGC_Descriptor) + GGGGC_DESCRIPTOR_WORDS_REQ(size); /* check if we already have a descriptor */ if (ggggc_descriptorDescriptors[size]) return ggggc_descriptorDescriptors[size]; /* otherwise, need to allocate one. First lock the space */ if (ggggc_descriptorDescriptors[size]) { return ggggc_descriptorDescriptors[size]; } /* now make a temporary descriptor to describe the descriptor descriptor */ tmpDescriptor.header.descriptor__ptr = NULL; tmpDescriptor.header.extra_bits = 0; tmpDescriptor.size = ddSize; tmpDescriptor.pointers[0] = GGGGC_DESCRIPTOR_DESCRIPTION; /* allocate the descriptor descriptor */ ret = (struct GGGGC_Descriptor *) ggggc_malloc(&tmpDescriptor); /* make it correct */ ret->size = size; ret->pointers[0] = GGGGC_DESCRIPTOR_DESCRIPTION; /* put it in the list */ ggggc_descriptorDescriptors[size] = ret; GGC_PUSH_1(ggggc_descriptorDescriptors[size]); GGC_GLOBALIZE(); /* and give it a proper descriptor */ ret->header.descriptor__ptr = ggggc_allocateDescriptorDescriptor(ddSize); return ret; }
/* allocate an object */ void *ggggc_malloc(struct GGGGC_Descriptor *descriptor) { GGC_YIELD(); void * userPtr = NULL; struct GGGGC_Header header; header.descriptor__ptr = descriptor; if (!ggggc_curPool) { ggggc_curPool = ggggc_fromList = newPool(1); ggggc_toList = newPool(1); ggggc_forceCollect = 0; } ggc_size_t size = descriptor->size; if (ggggc_curPool->free + size >= ggggc_curPool->end) { if (ggggc_curPool->next) { ggggc_curPool = ggggc_curPool->next; return ggggc_malloc(descriptor); } struct GGGGC_Pool *temp = newPool(1); ggggc_curPool->next = temp; ggggc_curPool = temp; temp = newPool(1); struct GGGGC_Pool *poolIter = ggggc_toList; while(poolIter) { if (!(poolIter->next)) { poolIter->next = temp; break; } poolIter = poolIter->next; } ggggc_forceCollect = 1; } userPtr = (ggggc_curPool->free); ggggc_curPool->free += size; ((struct GGGGC_Header *) userPtr)[0] = header; ggggc_zero_object((struct GGGGC_Header*)userPtr); return userPtr; }
/* and a combined malloc/allocslot */ void *ggggc_mallocSlot(struct GGGGC_DescriptorSlot *slot) { return ggggc_malloc(ggggc_allocateDescriptorSlot(slot)); }