Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Implement test_realloc #284

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Implement test_realloc #284

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
38 changes: 38 additions & 0 deletions harness.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,6 +63,7 @@ static bool time_limited = false;
typedef enum {
TEST_MALLOC,
TEST_CALLOC,
TEST_REALLOC,
} alloc_t;

/* Internal functions */
Expand Down Expand Up @@ -128,6 +129,7 @@ static void *alloc(alloc_t alloc_type, size_t size)
char *msg_alloc_forbidden[] = {
"Calls to malloc are disallowed",
"Calls to calloc are disallowed",
"Calls to realloc are disallowed",
};
report_event(MSG_FATAL, "%s", msg_alloc_forbidden[alloc_type]);
return NULL;
Expand All @@ -137,6 +139,7 @@ static void *alloc(alloc_t alloc_type, size_t size)
char *msg_alloc_failure[] = {
"Malloc returning NULL",
"Calloc returning NULL",
"Realloc returning NULL",
};
report_event(MSG_WARN, "%s", msg_alloc_failure[alloc_type]);
return NULL;
Expand Down Expand Up @@ -187,6 +190,41 @@ void *test_calloc(size_t nelem, size_t elsize)
return alloc(TEST_CALLOC, nelem * elsize);
}

/*
* This function implements how to adjust the size of memory allocated
* by test_malloc or test_calloc.
*
* First, we check whether the memory is already allocated.
* If it wasn't allocated (p is NULL),
* the fucntion behaves like test_malloc, returning a newly allocated memory.
*
* Otherwise, we check the payload size of the orignal memory.
* - If new_size is less than or equal to it, return the original memory.
* - If new_size is greater than it, we allocate a new memory with new_size.
* Copy the contents from the orginal memory to the newly allocated memory
* ,and then free the original one. Finally, we return the newly one.
Comment on lines +194 to +205
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Shorten the descriptions.

*
* Reference: https://danluu.com/malloc-tutorial
*/
void *test_realloc(void *p, size_t new_size)
{
if (!p)
return alloc(TEST_REALLOC, new_size);

const block_element_t *b = find_header(p);
if (b->payload_size >= new_size)
// TODO: Free some once we implement split.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Show more about this operation.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Provide the improvements within this pull request.

Copy link
Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think the current implementation has its pros and cons. Since we do not shrink the memory size, it performs well in cases like the following:

malloc(100) -> realloc(1) -> realloc(2) -> realloc(3)

In this scenario, when we allocate a large block of memory and then reduce its size, later extensions of the memory (to a larger size) will not require additional work to handle.

Here, I propose a simple improvement:

If new_size is larger than old_size, we allocate new_size * 2 for future use.

If new_size is smaller than old_size, we check whether new_size * 2 is still smaller than old_size. If so, we allocate new memory with new_size * 2 to optimize memory usage. Otherwise, we retain the old_size.

This approach wastes some memory but reduces the number of memory copy operations when calling realloc.

Apart from the above method, I also tried implementing it using the C function realloc, but the documentation does not guarantee under what circumstances it will move the pointer (allocate new memory). This uncertainty makes it difficult to implement a noallocate_mode.

Another approach is to split the unused memory into a separate block. However, this increases the complexity of implementing test_malloc and test_free. We would need an additional field in the block to indicate whether it is free or not. In test_malloc, the simplest implementation would iterate through the list to find a free block with enough space, which increases time complexity compared to the current implementation. In test_free, to avoid excessive fragmentation, we would need to implement a function to merge adjacent free memory blocks, adding further complexity.

I am unsure whether this is worth pursuing, as this module is primarily used for detecting memory usage rather than optimizing it.

return p;

void *new_ptr = alloc(TEST_REALLOC, new_size);
if (!new_ptr)
return NULL;
memcpy(new_ptr, p, b->payload_size);
test_free(p);

return new_ptr;
}

void test_free(void *p)
{
if (noallocate_mode) {
Expand Down
3 changes: 2 additions & 1 deletion harness.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,9 +12,9 @@

void *test_malloc(size_t size);
void *test_calloc(size_t nmemb, size_t size);
void *test_realloc(void *p, size_t new_size);
void test_free(void *p);
char *test_strdup(const char *s);
/* FIXME: provide test_realloc as well */

#ifdef INTERNAL

Expand Down Expand Up @@ -56,6 +56,7 @@ void trigger_exception(char *msg);
/* Tested program use our versions of malloc and free */
#define malloc test_malloc
#define calloc test_calloc
#define realloc test_realloc
#define free test_free

/* Use undef to avoid strdup redefined error */
Expand Down
Loading