int main(){
// struct node *ptr1;
ptr = NULL;
for(int i=1; i<=10; i++){
struct node *temp = (struct node*)malloc(sizeof(struct node*));
temp -> value=i;
temp -> next=NULL;
insertIntoLL(temp);
}
struct node *temp = (struct node*)malloc(sizeof(struct node*));
temp -> value=4;
temp -> next=NULL;
insertIntoLL(temp);
struct node *temp1 = (struct node*)malloc(sizeof(struct node*));
temp1 -> value=11;
temp1 -> next=NULL;
insertIntoLL(temp1);
struct node* runner = ptr;
int a[20];
int length = 0, j;
}
SmallArena::ThreadBlockCache::~ThreadBlockCache() {
LOCK_REGION(heap->lock);
for (int i = 0; i < NUM_BUCKETS; i++) {
while (Block* b = cache_free_heads[i]) {
removeFromLLAndNull(b);
insertIntoLL(&small->heads[i], b);
}
while (Block* b = cache_full_heads[i]) {
removeFromLLAndNull(b);
insertIntoLL(&small->full_heads[i], b);
}
}
}
GCAllocation* SmallArena::_alloc(size_t rounded_size, int bucket_idx) {
Block** free_head = &heads[bucket_idx];
Block** full_head = &full_heads[bucket_idx];
static __thread ThreadBlockCache* cache = NULL;
if (!cache)
cache = thread_caches.get();
Block** cache_head = &cache->cache_free_heads[bucket_idx];
// static __thread int gc_allocs = 0;
// if (++gc_allocs == 128) {
// static StatCounter sc_total("gc_allocs");
// sc_total.log(128);
// gc_allocs = 0;
//}
while (true) {
while (Block* cache_block = *cache_head) {
GCAllocation* rtn = _allocFromBlock(cache_block);
if (rtn)
return rtn;
removeFromLLAndNull(cache_block);
insertIntoLL(&cache->cache_full_heads[bucket_idx], cache_block);
}
// Not very useful to count the cache misses if we don't count the total attempts:
// static StatCounter sc_fallback("gc_allocs_cachemiss");
// sc_fallback.log();
LOCK_REGION(heap->lock);
assert(*cache_head == NULL);
// should probably be called allocBlock:
Block* myblock = _claimBlock(rounded_size, &heads[bucket_idx]);
assert(myblock);
assert(!myblock->next);
assert(!myblock->prev);
// printf("%d claimed new block %p with %d objects\n", threading::gettid(), myblock, myblock->numObjects());
insertIntoLL(cache_head, myblock);
}
}
void SmallArena::freeUnmarked(std::vector<Box*>& weakly_referenced) {
thread_caches.forEachValue([this, &weakly_referenced](ThreadBlockCache* cache) {
for (int bidx = 0; bidx < NUM_BUCKETS; bidx++) {
Block* h = cache->cache_free_heads[bidx];
// Try to limit the amount of unused memory a thread can hold onto;
// currently pretty dumb, just limit the number of blocks in the free-list
// to 50. (blocks in the full list don't need to be limited, since we're sure
// that the thread had just actively used those.)
// Eventually may want to come up with some scrounging system.
// TODO does this thread locality even help at all?
for (int i = 0; i < 50; i++) {
if (h)
h = h->next;
else
break;
}
if (h) {
removeFromLLAndNull(h);
insertIntoLL(&heads[bidx], h);
}
Block** chain_end = _freeChain(&cache->cache_free_heads[bidx], weakly_referenced);
_freeChain(&cache->cache_full_heads[bidx], weakly_referenced);
while (Block* b = cache->cache_full_heads[bidx]) {
removeFromLLAndNull(b);
insertIntoLL(chain_end, b);
}
}
});
for (int bidx = 0; bidx < NUM_BUCKETS; bidx++) {
Block** chain_end = _freeChain(&heads[bidx], weakly_referenced);
_freeChain(&full_heads[bidx], weakly_referenced);
while (Block* b = full_heads[bidx]) {
removeFromLLAndNull(b);
insertIntoLL(chain_end, b);
}
}
}
int main(){
// struct node *ptr1;
ptr = NULL;
for(int i=1; i<=10; i++){
struct node *temp = (struct node*)malloc(sizeof(struct node*));
temp -> value=i;
temp -> next=NULL;
insertIntoLL(temp);
}
struct node *temp = (struct node*)malloc(sizeof(struct node*));
temp -> value=4;
temp -> next=NULL;
insertIntoLL(temp);
struct node *temp1 = (struct node*)malloc(sizeof(struct node*));
temp1 -> value=11;
temp1 -> next=NULL;
insertIntoLL(temp1);
struct node *runner1, *runner2;
runner1 = runner2 = ptr;
while(runner1!=NULL){
runner2 = runner1->next;
while(runner2!=NULL){
if(runner1->value==runner2->value){
delete1(runner2->value);
runner2=runner2->next;
}
runner2=runner2->next;
}
runner1=runner1->next;
}
printLL();
}
GCAllocation* LargeArena::alloc(size_t size) {
registerGCManagedBytes(size);
LOCK_REGION(heap->lock);
// printf ("allocLarge %zu\n", size);
LargeObj* obj = _alloc(size + sizeof(GCAllocation) + sizeof(LargeObj));
obj->size = size;
nullNextPrev(obj);
insertIntoLL(&head, obj);
return obj->data;
}
