realloc implementation without memcpy

Question

can you please check this code to see why my implementation of a realloc function without using memcpy doesn't work? I am trying to figure out a way to transfer the payload size and tags from one block to another block. I got an invalid pointer error when i tried to run this code.

How do I transfer payload from one block to another without using memcpy or any other native c memory copy functions.

void* realloc(void* ptr, size_t size) {
  BlockInfo * oldBlockInfo;
  BlockInfo* newBlockInfo;
  size_t ptrSize;
  void* newPtr;
  if(ptr == NULL){
    return malloc(size);
  }
  else{
    if(size == 0){
        free(ptr);
        return NULL;
    }
  }
  oldBlockInfo = (BlockInfo*) UNSCALED_POINTER_SUB(ptr, WORD_SIZE);
  ptrSize = SIZE(oldBlockInfo->sizeAndTags); //getting the size of the old block
  //checking size
  if (ptrSize >= size){//if old size is greater or equal return old pointer
    return ptr;
  }
  else{
    newPtr = malloc(size);
    newBlockInfo = (BlockInfo*)UNSCALED_POINTER_ADD(newPtr,WORD_SIZE); 
    ptrSize = SIZE(newBlockInfo->sizeAndTags);
    for (int i = WORD_SIZE;i<ptrSize;i+=WORD_SIZE){
      newBlockInfo ->sizeAndTags = oldBlockInfo ->sizeAndTags;
      newBlockInfo = newBlockInfo ->next;
      oldBlockInfo = oldBlockInfo ->next;
    }
  }
  //examine_heap();
  free(ptr);
  return newPtr;
}

this is an implementation of realloc with memcpy, but I can't use memcpy

void *mm_realloc (void *ptr, size_t size) {
    int minsize;
    void *newptr;

    // Allocate new block, returning NULL if not possible.

    newptr = malloc (size);
    if (newptr == NULL) return NULL;

    // Don't copy/free original block if it was NULL.

    if (ptr != NULL) {
        // Get size to copy - mm_getsize must give you the size of the current block.
        // But, if new size is smaller, only copy that much. Many implementations
        // actually reserve the 16 bytes in front of the memory to store this info, e.g.,
        // +--------+--------------------------------+
        // | Header | Your data                      |
        // +--------+--------------------------------+
        //           ^
        //           +--- this is your pointer.
        // <- This is the memory actually allocated ->

        minsize = mm_getsize (ptr);
        if (size < minsize)
           minsize = size;

        // Copy the memory, free the old block and return the new block.

        memcpy (newptr, ptr, minsize);
        free (ptr)
    }

    return newptr;
}

Why do you have `return 0;` after the comment that says "return old pointer"? — Barmar, Nov 17 '21 at 04:02
Why do you need to copy the tags to the new block? `malloc()` sets the proper tags in the new block. You should just copy the payload. — Barmar, Nov 17 '21 at 04:03
The loop should only copy the size of the old block, not the new block. — Barmar, Nov 17 '21 at 04:04
that's a good point. but I'm new to c, how do I separate the payload from the block. — Killerbee, Nov 17 '21 at 04:05
Killerbee, Why `int` with `int minsize;` and not `size_t` like `size_t size`? — chux - Reinstate Monica, Nov 17 '21 at 04:08
Why do you use `UNSCALED_POINTER_SUB()` with `ptr`, but `UNSCALED_POINTER_ADD()` with `newPtr`? — Barmar, Nov 17 '21 at 04:09
that's the way they implemented it, the bottom code is not mine. I am just trying to approximate what they did in the bottom code, without using memcpy. so my basic question is how do I transfer payload from one block to another, without using memcpy or any other native c memory copy functions. — Killerbee, Nov 17 '21 at 04:11
If everything works with `memcpy`, then just write your own `memcpy` and call it, um, `not_literally_memcpy()`. — Raymond Chen, Nov 17 '21 at 04:11

score 0 · Answer 1 · answered Nov 17 '21 at 04:17

0

You should copy just the payload of the old block into the new block. So don't overwrite ptrSize with the information about the new block, you need the old block's size. Subtract WORD_SIZE from it because you're not copying the header, since that was filled in properly by malloc().

    newPtr = malloc(size);
    ptrSize -= WORD_SIZE; // subtract the header size
    char *tempPtr = newPtr;
    for (int i = 0; i<ptrSize; i++){
      tempPtr[i] = ptr[i];
    }

answered Nov 17 '21 at 04:17

Barmar

741,623
53
500
612

I get an invalid use of void expression when I try to do that. – Killerbee Nov 17 '21 at 16:25
I don't know what your macros like `WORD_SIZE` and `UNSCALED_POINTER_ADD` do, I had to guess how they can be used. – Barmar Nov 17 '21 at 16:29

realloc implementation without memcpy

1 Answers1