olga safonova · @olga · 96750a10 · Даниил Садырин · f056efe3 · f056efe3
--- a/src/mem.c
+++ b/src/mem.c
        length += size_from_capacity(current_block->capacity).bytes;
        if (!current_block || !current_block->next || current_block->next != block_after(current_block))
        {
+            length -= size_from_capacity(current_block->capacity).bytes;
            munmap(remember_block, length);
            remember_block = current_block;
-            length = 0;
+            length = size_from_capacity(current_block->capacity).bytes;
--- a/src/mem.c
+++ b/src/mem.c
        length += size_from_capacity(current_block->capacity).bytes;
        if (!current_block || !current_block->next || current_block->next != block_after(current_block))
--- a/src/mem.c
+++ b/src/mem.c
+    void *real_addr = map_pages(addr, real_size, MAP_FIXED_NOREPLACE);
+
+    struct region allocated_region = {};
+
+    allocated_region.extends = true;
+
+    if(real_addr == MAP_FAILED)
+    {
+        real_addr = map_pages(addr, real_size, 0);
+
+        if(real_addr == MAP_FAILED)
+        {
+            return (struct region) {};
+        }
+
+        allocated_region.extends = false;
--- a/src/mem.c
+++ b/src/mem.c

 /*  освободить всю память, выделенную под кучу */
 void heap_term( ) {
-  /*  ??? */
+    struct block_header* current_block = (struct block_header*) HEAP_START;
+    struct block_header* remember_block = current_block;
+    struct block_header* next_block = current_block;
+    size_t length = 0;
+
+    if(!next_block && current_block)
--- a/src/mem.c
+++ b/src/mem.c
+
+    if(!next_block && current_block)
+    {
+      length += size_from_capacity(current_block->capacity).bytes;
+      munmap(remember_block, length);
+      return;
+    }
+
+    while(next_block)
+    {
+        current_block = next_block;
+        next_block = current_block->next;
+
+        length += size_from_capacity(current_block->capacity).bytes;
+
+        if (!current_block || !next_block || next_block != block_after(current_block))
--- a/src/mem.c
+++ b/src/mem.c
+    if (block_splittable(block, query))
+    {
+        block_capacity capacity = { .bytes = (query > BLOCK_MIN_CAPACITY ? query : BLOCK_MIN_CAPACITY) };
+
+        block_size first_size = { size_from_capacity(capacity).bytes };
+        block_size second_size = { (block->capacity.bytes - capacity.bytes) };
+
+        void *first_block_addr = block;
+        void *second_block_addr = block->contents + capacity.bytes;
+        void *last_block_chain = block->next;
+
+        block_init(first_block_addr, first_size, second_block_addr);
+        block_init(second_block_addr, second_size, last_block_chain);
+
+        return true;
+    } else return false;
--- a/src/mem.c
+++ b/src/mem.c
 }

 static bool try_merge_with_next( struct block_header* block ) {
-  /*  ??? */
+    if(block && block->next && mergeable(block, block->next))
+    {
+        block->capacity.bytes += size_from_capacity(block->next->capacity).bytes;
+        block->next = block->next->next;
+        return true;
+    } else return false;
 }
--- a/src/mem.c
+++ b/src/mem.c
+    if(last)
+    {
+        struct region new_region = alloc_region(block_after(last), query);
+
+        if(region_is_invalid(&new_region))
+            return NULL;
+
+        last->next = new_region.addr;
+
+        if(try_merge_with_next(last))
+        {
+          return last;
+        }
+
+        return new_region.addr;
+    } else return NULL;
--- a/src/mem.c
+++ b/src/mem.c
 /*  Реализует основную логику malloc и возвращает заголовок выделенного блока */
 static struct block_header* memalloc( size_t query, struct block_header* heap_start) {
+    struct block_search_result result = try_memalloc_existing(query, heap_start);

-  /*  ??? */
-
+    if(result.type == BSR_FOUND_GOOD_BLOCK)
+    {
+        return result.block;
+    }
+    else if(result.type == BSR_REACHED_END_NOT_FOUND)
+    {
+        struct block_header *new_block = grow_heap(result.block, query);
+        result = try_memalloc_existing(query, new_block);
+    }
+    return result.block;