CATCH_NEXTROW()
{
ActivityTimer t(totalCycles, timeActivities, NULL);
loop {
if (eof || abortSoon)
break;
if (!prev) {
if (!global || firstNode()) {
// construct first row
RtlDynamicRowBuilder r(queryRowAllocator());
size32_t sz = helper->createDefault(r);
prev.setown(r.finalizeRowClear(sz));
}
else {
prev.setown(getFirst());
if (!prev) {
putNext(NULL); // send to next node (even though prev not got)
eof = true;
break;
}
}
}
OwnedConstThorRow next = input->ungroupedNextRow();
if (!next) {
putNext(prev); // send to next node if applicable
eof = true;
break;
}
RtlDynamicRowBuilder ret(queryRowAllocator());
size32_t sz = helper->transform(ret, prev, next, ++count);
if (sz != 0) {
dataLinkIncrement();
prev.setown(ret.finalizeRowClear(sz));
return prev.getLink();
}
}
return NULL;
}
/**********************************************************
* mm_free
* Free the block and coalesce with neighbouring blocks
* Ensure that the previous and next block pointers are
* initialized to NULL for coalescing
**********************************************************/
void mm_free(void *bp)
{
//printf("\n%d mm_free %p\n",counter++, bp);
if(bp == NULL){
return;
}
size_t size = GET_SIZE(HDRP(bp));
PUT(HDRP(bp), PACK(size,0));
PUT(FTRP(bp), PACK(size,0));
putNext(bp, NULL);
putPrev(bp, NULL);
coalesce(bp);
}
/**********************************************************
* extend_heap
* Extend the heap by "words" words, maintaining alignment
* requirements of course. Free the former epilogue block
* and reallocate its new header
* also ensure that bp's previous and next pointers are NULL
**********************************************************/
void *extend_heap(size_t words)
{
//printf(" extend_heap %zu\n",words*WSIZE);
char *bp;
size_t size;
/* Allocate an even number of words to maintain alignments */
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
if ( (bp = mem_sbrk(size)) == (void *)-1 )
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); // free block header
PUT(FTRP(bp), PACK(size, 0)); // free block footer
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); // new epilogue header
/* Initialize free list pointers */
putNext(bp, NULL);
putPrev(bp, NULL);
/* Coalesce if the previous block was free */
return coalesce(bp);
}
/**********************************************************
* place
* Mark the block as allocated
**********************************************************/
void place(void* bp, size_t asize)
{
#if DEBUG >= 3
printf(" ==place== ");
#endif
// min_size is the smallest free block possible: header(wsize) + 2*WSIZE + footer(wsize)
// aligned to DSIZE (2*WSIZE)
size_t min_size = DSIZE+OVERHEAD;
size_t free_size = GET_SIZE(HDRP(bp));
size_t bsize = asize;
uintptr_t * prev;
uintptr_t * next;
if (free_size >= asize+min_size)
{
printf(" asize %zu", asize);
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
bsize = free_size - asize;
printf(" bsize %zu \n", bsize);
void * free_bp = NEXT_BLKP(bp);
PUT(HDRP(free_bp), PACK(bsize, 0));
//printf("footer %p\n",FTRP(free_bp));
//printf("bsize %zu\n",bsize);
PUT(FTRP(free_bp), PACK(bsize, 0));
//printf("bsize in footer %zu\n",GET_SIZE(FTRP(free_bp)));
//print_heap();
/* free list */
if (flhead == fltail) { //one free block
printf("breakpoint1\n");
flhead = free_bp;
fltail = free_bp;
getNext(free_bp) = NULL;
getPrev(free_bp) = NULL;
}
else if (bp == flhead) { //more than one free block and at head
printf("breakpoint2\n");
prev = getPrev(bp);
next = getNext(bp);
flhead = free_bp;
getPrev(free_bp) = prev;
getNext(free_bp) = next;
if (prev != NULL ) {
getNext(prev) = free_bp;
}
if (next != NULL) {
getPrev(next) = free_bp;
}
}
else if (bp == fltail) {
printf("breakpoint3\n");
prev = getPrev(bp);
next = getNext(bp);
fltail = free_bp;
getPrev(free_bp) = prev;
getNext(free_bp) = next;
if (prev != NULL ) {
getNext(prev) = free_bp;
}
if (next != NULL) {
getPrev(next) = free_bp;
}
}
else {
printf("breakpoint4\n");
prev = getPrev(bp);
next = getNext(bp);
getPrev(free_bp) = prev;
getNext(free_bp) = next;
if (prev != NULL ) {
getNext(prev) = free_bp;
}
if (next != NULL) {
getPrev(next) = free_bp;
}
}
}
else //no need to split
{
printf(" no split\n");
//if (counter >= 770) print_heap();
PUT(HDRP(bp), PACK(free_size, 1));
PUT(FTRP(bp), PACK(free_size, 1));
/* free list */
if (flhead == fltail) {
printf(" 1..\n");
flhead = fltail = NULL;
}
else if (bp == flhead) {
printf(" 2..\n");
flhead = getNext(flhead);
getPrev(flhead)= NULL;
}
else if (bp == fltail) {
printf(" 3..\n");
fltail = getPrev(fltail);
putNext(fltail,NULL);
}
else {
prev = getPrev(bp);
next = getNext(bp);
if (prev!=NULL){
printf(" 4 get prev.....\n");
printf("prev's %p\n",prev);
getNext(prev) = next;
}
printf(" 4.2.....\n");
if (next!=NULL){
getPrev(next) = prev;
}
printf(" 4.3..done\n");
}
}
}
