Changeset d67a9a1 for src/examples/gc_no_raii/src/internal

Timestamp:

Jan 20, 2016, 1:53:17 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

00ede9e

Parents:

08a40fd

Message:

pool alloc functional

Location:

src/examples/gc_no_raii/src/internal

Files:

• collector.c (modified) (4 diffs)
• collector.h (modified) (2 diffs)
• memory_pool.h (added)
• object_header.h (modified) (1 diff)
• state.c (modified) (5 diffs)
• state.h (modified) (1 diff)

src/examples/gc_no_raii/src/internal/collector.c

@@ -1 +1 @@
 #include "collector.h"
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -7 +8 @@
 #include "fstream.h"
 
-#include "gc_tools.h"
-#include "state.h"
-// #include "memory_pool.h"
+#include "memory_pool.h"
 
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size);
@@ -69 +68 @@
         gc_object_header* obj = gc_object_header_placement_ctor(header, actual_size);
 
-        (void)obj; //remove unsused warning since this is for debug
+        // (void)obj; //remove unsused warning since this is for debug
         check(obj == get_object_ptr(data));
 
@@ -77 +76 @@
 }
 
-//      void process_reference(void** ref, std::vector<void**>& worklist)
-//      {
-//              check(!gc::gc_get_state().is_in_heap(ref));
-//
-//              if(gc_object_header* ptr = get_object_ptr(*ref))
-//              {
-//                      if(!ptr->is_forwarded)
-//                      {
-//                              copy_object(ptr);
-//
-//                              scan_object(ptr->forward, worklist);
-//
-//                              assign_reference(ref, ptr->forward);
-//                      }
-//                      else
-//                      {
-//                              //duplication to help debug
-//                              assign_reference(ref, ptr->forward);
-//                      }
-//              }
-//      }
-//
-//      void assign_reference(void** ref, gc_object_header* ptr)
-//      {
-//              void* address = (void*)(((intptr_t)ptr) + sizeof(gc_object_header));
-//
-//              write_aligned_ptr(ref, address);
-//      }
-//
-//      gc_object_header* copy_object(gc_object_header* ptr)
-//      {
-//              check(!ptr->forward);
-//              check(!ptr->is_forwarded);
-//              check(pool_of(ptr)->is_from_space());
-//
-//              memory_pool* pool = pool_of(ptr)->mirror();
-//
-//              void* new_block = pool->allocate(ptr->size, false);
-//
-//              std::memcpy(new_block, ptr, ptr->size);
-//
-//              gc_object_header* fwd_ptr = new (new_block) gc_object_header(ptr);
-//
-//              ptr->forward = fwd_ptr;
-//              ptr->is_forwarded = true;
-//
-//              return fwd_ptr;
-//      }
-//
-//      void scan_object(gc_object_header* object, std::vector<void**>& worklist)
-//      {
-//              gcpointer_base* type = object->type_chain;
-//              while(type)
-//              {
-//                      check(((intptr_t)type) > ((intptr_t)object));
-//                      check(((intptr_t)type) < ((intptr_t)((intptr_t)object) + object->size));
-//
-//                      check(gc::gc_get_state().is_in_to_space(&type->m_ptr));
-//
-//                      worklist.push_back(&type->m_ptr);
-//
-//                      type = type->m_next;
-//              }
-//      }
-// };
+void gc_process_reference(void** ref, worklist_t* worklist)
+{
+        check(!gc_is_in_heap(gc_get_state(), ref));
+
+        gc_object_header* ptr = gc_get_object_ptr(*ref);
+        if(ptr)
+        {
+                if(!ptr->is_forwarded)
+                {
+                        gc_copy_object(ptr);
+
+                        gc_scan_object(ptr->forward, worklist);
+
+                        gc_assign_reference(ref, ptr->forward);
+                }
+                else
+                {
+                        //duplication to help debug
+                        gc_assign_reference(ref, ptr->forward);
+                }
+        }
+}
+
+void gc_assign_reference(void** ref, gc_object_header* ptr)
+{
+        void* address = (void*)(((intptr_t)ptr) + sizeof(gc_object_header));
+
+        gc_write_aligned_ptr(ref, address);
+}
+
+gc_object_header* gc_copy_object(gc_object_header* ptr)
+{
+        check(!ptr->forward);
+        check(!ptr->is_forwarded);
+        check(gc_is_from_space(gc_pool_of(ptr)));
+
+        gc_memory_pool* pool = gc_pool_of(ptr)->mirror;
+
+        void* new_block = gc_pool_allocate(pool, ptr->size, true);
+
+        memcpy(new_block, ptr, ptr->size);
+
+        gc_object_header* fwd_ptr = gc_object_header_placement_copy_ctor(new_block, ptr);
+
+        ptr->forward = fwd_ptr;
+        ptr->is_forwarded = true;
+
+        return fwd_ptr;
+}
+
+void gc_scan_object(gc_object_header* object, worklist_t* worklist)
+{
+        gcpointer_t* field = object->type_chain;
+        while(field)
+        {
+                check(((intptr_t)field) > ((intptr_t)object));
+                check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));
+
+                check(gc_is_in_to_space(gc_get_state(), &type->ptr));
+
+                push_back(worklist, &field->ptr);
+
+                field = field->next;
+        }
+}

src/examples/gc_no_raii/src/internal/collector.h

@@ -12 +12 @@
 #include "internal/object_header.h"
 #include "internal/state.h"
-
-typedef int worklist_t;
+#include "tools/worklist.h"
 
 inline bool gc_is_managed(void* address)
@@ -26 +25 @@
 }
 
-inline gc_memory_pool* pool_of(void* address)
+inline gc_memory_pool* gc_pool_of(void* address)
 {
         return (struct gc_memory_pool*)(((intptr_t)address) & POOL_PTR_MASK);

src/examples/gc_no_raii/src/internal/object_header.h

@@ -31 +31 @@
 
 gc_object_header* gc_object_header_placement_ctor(void* address, size_t size);
+gc_object_header* gc_object_header_placement_copy_ctor(void* address, gc_object_header* other);

src/examples/gc_no_raii/src/internal/state.c

@@ -1 +1 @@
 #include "state.h"
+
+#include <stdlib.h>
 
 //general purpouse includes
@@ -9 +11 @@
 //gc internal includes
 // #include "globals.h"
-// #include "memory_pool.h"
+#include "memory_pool.h"
 // #include "memory_pool_iterator.h"
 // #include "object_header.h"
@@ -22 +24 @@
 //      bool no_from_space_ref(gc_state* state);
 // #endif
-//
-// void gc_state_ctor(gc_state* state)
-// {
-//      state->from_code(0)
-//      state->to_space(nullptr)
-//      state->from_space(nullptr)
-//      state->total_space(0)
-//      state->used_space(0)
-//      state->pools_table()
-//
-//      gc_allocate_pool(gc_state* state);
-// }
-//
+
+void gc_state_ctor(gc_state* state)
+{
+        state->from_code = 0;
+        state->to_space = NULL;
+        state->from_space = NULL;
+        state->total_space = 0;
+        state->used_space = 0;
+        // state->pools_table();
+
+        gc_allocate_pool(state);
+
+        state->is_initialized = true;
+}
+
 // bool state::is_in_heap(void* address) const
 // {
-//      memory_pool* target_pool = pool_of(address);
+//      memory_pool* target_pool = gc_pool_of(address);
 //
 //      auto first = pools_table.cbegin();
@@ -44 +48 @@
 //      return result != last && (*result)->is_from_space();
 // }
-//
+
 // bool state::is_in_to_space(void* address) const
 // {
@@ -55 +59 @@
 // }
 //
-// object_header* state::get_object_for_ref(void* member)
-// {
-//      intptr_t target = intptr_t(member);
-//      if(!is_in_heap(member)) return nullptr;
-//
-//      memory_pool* pool = pool_of(member);
-//      auto it = pool->iterator_for(member);
-//      auto end = pool->end();
-//
-//      while(it != end)
-//      {
-//              object_header* object = *it;
-//              {
-//                      intptr_t start = intptr_t(object);
-//                      intptr_t end = intptr_t(start + object->size);
-//                      if(start < target && end > target)
-//                      {
-//                              return object;
-//                      }
-//              }
-//              ++it;
-//      }
-//
-//      checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
-//      abort();
-//      return nullptr;
-// }
+gc_object_header* gc_get_object_for_ref(gc_state* state, void* member)
+{
+        intptr_t target = ((intptr_t)member);
+        if(!gc_is_in_heap(state, member)) return NULL;
+
+        gc_memory_pool* pool = gc_pool_of(member);
+        gc_pool_object_iterator it = gc_pool_iterator_for(pool, member);
+        gc_pool_object_iterator end = gc_pool_end(pool);
+
+        while(it != end)
+        {
+                gc_object_header* object = *it;
+                {
+                        intptr_t start = ((intptr_t)object);
+                        intptr_t end = ((intptr_t)start + object->size);
+                        if(start < target && end > target)
+                        {
+                                return object;
+                        }
+                }
+                ++it;
+        }
+
+        checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
+        abort();
+        return NULL;
+}
 //
 // void* state::try_allocate(size_t size)

src/examples/gc_no_raii/src/internal/state.h

@@ -16 +16 @@
         size_t used_space;
 
-        const struct memory_pool*       pools_table;
-        size_t                          pools_table_count;
+        // const struct memory_pool*    pools_table;
+        // size_t                               pools_table_count;
 };