void long_freelist() {
Busy_Header* b[20];
for(int i = 0; i < 20; i++){
b[i] = malloc(i);
assert_addr_equal(get_freelist(), find_next(b[i]));
assert_addr_equal(get_freelist()->prev, NULL);
}
Free_Header *freelist0 = get_freelist();
for( int i = 0; i <20 ; i++){
free(b[i]);
assert_addr_equal(get_freelist(), b[i]);
if (i+1 < 20)
assert_addr_equal(find_next(get_freelist()), b[i+1]);
assert_addr_equal(get_freelist()->prev, NULL);
}
//last free causes a merge
Heap_Info info = verify_heap();
assert_equal(info.busy, 0);
assert_equal(info.free, 20);
assert_equal(info.busy_size + info.free_size, get_heap_info().heap_size); // out of heap
assert_addr_equal(get_freelist(), b[19]);
assert_addr_equal(find_next(get_freelist()), get_heap_base() + info.heap_size); //out of heap
assert_addr_equal(((Free_Header *)b[0])->next, NULL); //end
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
gc_begin_func();
STRING(s1);
STRING(s2);
STRING(t);
bool s1t;
bool s2t;
s1 = String_new("hellp");
s2 = String_new("aello");
t = String_new("hello");
s1t = str_gt(s1,t);
if (s1t) {
gt_msg(s1,t);
}
else {
le_msg(s1,t);
}
s2t = str_gt(s2,t);
if (s2t) {
gt_msg(s2,t);
}
else {
le_msg(s2,t);
}
gc_end_func();
gc();
Heap_Info info = get_heap_info();
if ( info.live!=0 ) fprintf(stderr, "%d objects remain after collection\n", info.live);
gc_shutdown();
return 0;
}
/**
* @ingroup EnvRuntimeInformationDetail
* @brief Function <b>get_heap_usage</b> returns the number of bytes used by the heap.
*
* @return a <b>size_t</b> value of the number of bytes used by
* the heap.
*/
inline size_t get_heap_usage() {
size_t heap_size = 0;
size_t largest_free = 0;
get_heap_info(heap_size, largest_free);
return heap_size;
}
void rtems_resource_snapshot_take(rtems_resource_snapshot *snapshot)
{
uint32_t *active = &snapshot->active_posix_keys;
size_t i;
memset(snapshot, 0, sizeof(*snapshot));
_RTEMS_Lock_allocator();
_Thread_Kill_zombies();
get_heap_info(RTEMS_Malloc_Heap, &snapshot->heap_info);
get_heap_info(&_Workspace_Area, &snapshot->workspace_info);
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
active [i] = _Objects_Active_count(objects_info_table[i]);
}
_RTEMS_Unlock_allocator();
snapshot->active_posix_key_value_pairs = get_active_posix_key_value_pairs();
snapshot->open_files = open_files();
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
gc_begin_func();
int argc;
STRING(argv);
argc = 1;
argv = String_new("hello world");
print_string(String_add(argv,String_from_int(argc)));
gc_end_func();
gc();
Heap_Info info = get_heap_info();
if ( info.live!=0 ) fprintf(stderr, "%d objects remain after collection\n", info.live);
gc_shutdown();
return 0;
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
gc_begin_func();
int x;
double y;
x = 1;
y = (3.14 + x);
printf("%1.2f\n", y);
gc_end_func();
gc();
Heap_Info info = get_heap_info();
if ( info.live!=0 ) fprintf(stderr, "%d objects remain after collection\n", info.live);
gc_shutdown();
return 0;
}
//allocate 10 consecutive chunks, free from the back to the front
//should fuse the heap to one free chunk
void fuse_to_one() {
Busy_Header* b[10];
for(int i = 0; i < 10; i++){
b[i] = malloc(100);
assert_addr_equal(get_freelist(), find_next(b[i]));
assert_addr_equal(get_freelist()->prev, NULL);
}
Free_Header *freelist0 = get_freelist();
for( int i = 9; i >= 0 ; i--){
free(b[i]);
assert_addr_equal(get_freelist(), b[i]);
assert_addr_equal(get_freelist()->prev, NULL);
}
Heap_Info info = verify_heap();
assert_equal(info.busy, 0);
assert_equal(info.free, 1);
assert_equal(info.busy_size + info.free_size, get_heap_info().heap_size);
assert_addr_equal(find_next(get_freelist()), get_heap_base() + info.heap_size);
assert_addr_equal(freelist0->next, NULL);
}
//skip first free chunk, which is not big enough
void search_along_list() {
printf("after allocation:\n");
Busy_Header* b[4];
for(int i = 0; i < 4; i++){
b[i] = malloc(450);
printf("b[%d]: %p\n", i, b[i]);
}
assert_equal(b[0]->size & SIZEMASK, request2size(450));
assert_equal(b[1]->size & SIZEMASK, request2size(450));
assert_equal(b[2]->size & SIZEMASK, request2size(450));
assert_equal(b[3]->size & SIZEMASK, request2size(450));
Free_Header* f4 = find_next(b[3]);
printf("head: %p\n", f4);
Heap_Info info = verify_heap();
assert_equal(info.busy, 4);
assert_equal(info.free, 1);
assert_equal(info.busy_size, 1824);
assert_equal(info.free_size, 176);
assert_addr_equal(get_freelist(), f4);
assert_addr_equal(get_freelist()->next, NULL);
assert_addr_equal(get_freelist()->prev, NULL);
//after malloc, free b3, b0
free(b[3]);
free(b[0]);
Busy_Header *skip = malloc(600);
printf("after malloc(600)\n");
Free_Header *head = get_freelist();
print_both_ways(head);
info = verify_heap();
assert_equal(info.busy, 3);
assert_equal(info.free, 2);
assert_equal(info.busy_size + info.free_size, get_heap_info().heap_size);
}
void
bar(PVector_ptr x)
{
gc_begin_func();
set_ith(x, 1 - 1, 100);
print_vector(x);
gc_end_func();
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
gc_begin_func();
VECTOR(x);
x = Vector_new((double[]) {
1, 2, 3}, 3);
bar(PVector_copy(x));
set_ith(x, 2 - 1, 99);
print_vector(x);
gc_end_func();
gc();
Heap_Info info = get_heap_info();
if (info.live != 0)
fprintf(stderr, "%d objects remain after collection\n", info.live);
gc_shutdown();
return 0;
}
Heap_Info verify_heap() {
Heap_Info info = get_heap_info();
assert_equal(info.heap_size, HEAP_SIZE);
assert_equal(info.heap_size, info.busy_size+info.free_size);
return info;
}
static void gc_check()
{
gc();
Heap_Info info = get_heap_info();
if ( info.live!=0 ) fprintf(stderr, "%d objects remain after collection\n", info.live);
}
//split chunk
void split_chunk(){
printf("after allocation:\n");
Busy_Header* b[4];
for(int i = 0; i < 4; i++){
b[i] = malloc(450);
printf("b[%d]: %p\n", i, b[i]);
}
assert_equal(b[0]->size & SIZEMASK, request2size(450));
assert_equal(b[1]->size & SIZEMASK, request2size(450));
assert_equal(b[2]->size & SIZEMASK, request2size(450));
assert_equal(b[3]->size & SIZEMASK, request2size(450));
Free_Header* f4 = find_next(b[3]);
printf("head: %p\n", f4);
Heap_Info info = verify_heap();
assert_equal(info.busy, 4);
assert_equal(info.free, 1);
assert_equal(info.busy_size, 1824);
assert_equal(info.free_size, 176);
assert_addr_equal(get_freelist(), f4);
assert_addr_equal(get_freelist()->next, NULL);
assert_addr_equal(get_freelist()->prev, NULL);
free(b[2]);
info = verify_heap();
assert_equal(info.busy, 3);
assert_equal(info.free, 2);
assert_equal(info.busy_size, 1368);
assert_equal(info.free_size, 632);
assert_addr_equal(get_freelist(), b[2]);
assert_addr_equal(get_freelist()->next, f4);
assert_addr_equal(get_freelist()->next->next, NULL);
assert_addr_equal(f4->prev, b[2]);
assert_addr_equal(f4->prev->prev, NULL);
printf("after free b[2]\n");
Free_Header *head = get_freelist();
print_both_ways(head);
free(b[0]);
info = verify_heap();
assert_equal(info.busy, 2);
assert_equal(info.free, 3);
assert_equal(info.busy_size, 912);
assert_equal(info.free_size, 1088);
assert_addr_equal(get_freelist(), b[0]);
assert_addr_equal(get_freelist()->next, b[2]);
assert_addr_equal(get_freelist()->next->next, f4);
assert_addr_equal(get_freelist()->next->next->next, NULL);
assert_addr_equal(f4->prev, b[2]);
assert_addr_equal(f4->prev->prev, b[0]);
assert_addr_equal(f4->prev->prev->prev, NULL);
printf("after free b[0]\n");
head = get_freelist();
print_both_ways(head);
Busy_Header *split = malloc(200);
printf("after malloc(200)\n");
head = get_freelist();
print_both_ways(head);
assert_addr_equal(split, get_heap_base());
Free_Header *newhead = get_freelist();
assert_addr_equal(find_next(split),newhead);
assert_addr_equal(get_freelist(), find_next(split));
assert_addr_equal(get_freelist()->next, b[2]);
assert_addr_equal(get_freelist()->next->next, f4);
assert_addr_equal(get_freelist()->next->next->next, NULL);
assert_addr_equal(f4->prev, b[2]);
assert_addr_equal(f4->prev->prev, newhead);
assert_addr_equal(f4->prev->prev->prev, NULL);
info = verify_heap();
assert_equal(info.busy, 3);
assert_equal(info.free, 3);
assert_equal(info.busy_size + info.free_size, get_heap_info().heap_size); // out of heap*/
}
