new GC

src/genode_env/disk_backend.h

@@ -39,7 +39,7 @@ class Phantom::Disk_backend
 
     Genode::Env &_env;
     Genode::Heap &_heap;
-    Genode::Entrypoint _ep{_env, 2*1024*sizeof(long) , "disk_ep", Genode::Affinity::Location()};
+    Genode::Entrypoint _ep{_env, 30*1024*sizeof(long) , "disk_ep", Genode::Affinity::Location()};
     Genode::Allocator_avl _block_alloc{&_heap};
 
     struct DJob : Block::Connection<DJob>::Job
@@ -315,4 +315,4 @@ class Phantom::Disk_backend
     // }
 };
 
-#endif
+#endif

src/genode_env/main.cc

@@ -36,6 +36,11 @@ void setup_adapters(Env &env)
 	Phantom::main_obj = &local_main;
 }
 
+Genode::size_t Component::stack_size() {
+    return 60 * 1024 * sizeof(long);
+}
+
+
 void test_adapters()
 {
 	log("Checking if main_obj is initialized");
@@ -209,4 +214,4 @@ void Component::construct(Env &env)
 // int main()
 // {
 // 	log("What are we doing here???");
-// }
+// }

src/include/kernel/config.h

@@ -17,6 +17,7 @@
 
 #define NEW_TASK_BAR 1
 
+#define N_OBJMEM_PAGES ((1024L*1024*32)/4096)
 
 #define UHCI_INTERRUPT 0
 #define OHCI_INTERRUPT 1

src/include/phantom_disk.h

@@ -102,6 +102,9 @@ typedef struct phantom_disk_superblock
 
     disk_page_no_t              snap_to_free;   // snap that is yet to free
 
+    disk_page_no_t              snap_reading;
+    disk_page_no_t              snap_already_read;
+
     u_int32_t                   magic2;         // 32 bits  - DISK_STRUCT_MAGIC_SUPER_2
 
     disk_page_no_t              boot_list;                      // List of blocks with bootloader image or 0.

src/include/vm/alloc.h

@@ -43,7 +43,13 @@ void debug_catch_object(const char *msg, pvm_object_storage_t *p);
 
 // gc
 
+pvm_object_t pvm_get_gc_buffer(void);
+pvm_object_t pvm_consume_gc_buffer_old(void);
+void pvm_swap_gc_buffers(void); 
+
 void run_gc(void);
+void run_gc_on_snap(void);
+void run_gc_incremental(pvm_object_t cycle_candidates);
 
 // Make sure this object won't be deleted with refcount dec
 // used on sys global objects
@@ -60,12 +66,15 @@ void do_ref_dec_p(pvm_object_storage_t *p); // for deferred refdec
 
 
 
+
 // ------------------------------------------------------------
 // shared between alloc.c and gc.c
 
 // Gigant lock for now. TODO
 extern hal_mutex_t  *vm_alloc_mutex;
 
+extern hal_mutex_t *vm_read_snap_mutex;
+void init_gc();
 
 void * get_pvm_object_space_start(void);
 void * get_pvm_object_space_end(void);

src/include/vm/object.h

@@ -156,11 +156,13 @@ void             pvm_set_field( pvm_object_t , unsigned int no, pvm_object_t val
 // Need it here? It will be called by usual set field ones...
 pvm_object_t     pvm_get_array_ofield(pvm_object_t o, unsigned int slot  );
 void             pvm_set_array_ofield(pvm_object_t o, unsigned int slot, pvm_object_t value );
+void             pvm_set_field_norefdec( pvm_object_t o, unsigned int slot, pvm_object_t value );
 
 int              get_array_size(pvm_object_t array);
 #define pvm_get_array_size get_array_size
 void             pvm_append_array(pvm_object_t array, pvm_object_t value_to_append );
 void             pvm_pop_array(pvm_object_t array, pvm_object_t value_to_pop );
+void             pvm_clear_array(pvm_object_t array);
 
 // Debug
 

src/include/vm/root.h

@@ -108,7 +108,8 @@ struct pvm_root_t
     pvm_object_t           root_dir;               // Root object directory
     pvm_object_t           kernel_stats;           // Persisent kernel statistics
     pvm_object_t           class_dir;              // .internal.directory of all classes used - class load cache - TODO must use weak refs or cleanup on ref cnt == 1
-
+    pvm_object_t           gc_buffer;              // array of candidates for garbage collection
+    pvm_object_t           gc_buffer_old;              // array of candidates for garbage collection
 };
 
 extern struct pvm_root_t pvm_root;
@@ -267,7 +268,11 @@ extern struct pvm_root_t pvm_root;
 
 #define PVM_ROOT_CLASS_DIR 73
 
-#define PVM_ROOT_OBJECTS_COUNT (PVM_ROOT_CLASS_DIR+30)
+#define PVM_ROOT_GC_BUFFER 74
+
+#define PVM_ROOT_GC_BUFFER_OLD 75
+
+#define PVM_ROOT_OBJECTS_COUNT (PVM_ROOT_GC_BUFFER_OLD+30)
 
 
 

src/phantom/isomem/fsck.c

@@ -593,35 +593,63 @@ static void free_blocklist_page_snap_worker(disk_page_no_t toFree, int flags)
     pager_free_blocklist_page_locked( toFree );
 }
 
-void phantom_free_snap(
-                       disk_page_no_t old_snap_start,
-                       disk_page_no_t curr_snap_start,
-                       disk_page_no_t new_snap_start
-                      )
-{
-    if( old_snap_start == 0 )
-    {
-        SHOW_FLOW0( 0, "*** No old snap, skip list deletion ***");
-        return;
-    }
 
-    SHOW_FLOW0( 0, "*** freeing old snap ***");
+void phantom_free_snap(
+    disk_page_no_t* to_free_arr, int to_free_arr_len,
+    disk_page_no_t* actual_arr, int actual_arr_len
+) {
     fsck_create_map();
 
-    fsck_list_justadd_as_free( old_snap_start );
-    fsck_list_justadd_as_used( curr_snap_start );
-    fsck_list_justadd_as_used( new_snap_start );
-
+    for (int i = 0; i < to_free_arr_len; i++) {
+        if (to_free_arr[i] != 0) {
+            ph_printf("Free old snap blk: %ld\n", (long)to_free_arr[i]);
+            fsck_list_justadd_as_free(to_free_arr[i]);
+        }
+    }
 
-    // go through list, free pages that are finally free in map
+    for (int i = 0; i < actual_arr_len; i++) {
+        if (actual_arr[i] != 0) {
+            ph_printf("Mark new snap blk: %ld\n", (long)actual_arr[i]);
+            fsck_list_justadd_as_used(actual_arr[i]);
+        }
+    }
+
     iterate_map(free_snap_worker, MAP_FREE);
     iterate_map(free_blocklist_page_snap_worker, MAP_LIST_NODE);
     pager_commit_active_free_list();
-
     fsck_delete_map();
-
 }
 
+// void phantom_free_snap(
+//                        disk_page_no_t old_snap_start,
+//                        disk_page_no_t curr_snap_start,
+//                        disk_page_no_t new_snap_start,
+//                        disk_page_no_t snap_reading
+//                       )
+// {
+//     if( old_snap_start == 0 )
+//     {
+//         SHOW_FLOW0( 0, "*** No old snap, skip list deletion ***");
+//         return;
+//     }
+
+//     SHOW_FLOW0( 0, "*** freeing old snap ***");
+    // fsck_create_map();
+
+//     fsck_list_justadd_as_free( old_snap_start );
+//     fsck_list_justadd_as_used( curr_snap_start );
+//     fsck_list_justadd_as_used( new_snap_start );
+//     fsck_list_justadd_as_used( snap_reading );
+
+//     // go through list, free pages that are finally free in map
+//     iterate_map(free_snap_worker, MAP_FREE);
+//     iterate_map(free_blocklist_page_snap_worker, MAP_LIST_NODE);
+//     pager_commit_active_free_list();
+
+//     fsck_delete_map();
+
+// }
+
 
 
 

src/phantom/isomem/genode_threads.c

@@ -65,6 +65,7 @@ phantom_thread_t *get_current_thread()
 
 tid_t get_current_tid(void)
 {
+    ph_printf("get_current_tid\n");
     _stub_print();
     return (int)pthread_self();
 }
@@ -191,4 +192,4 @@ errno_t t_set_snapper_flag(void)
 //     // Threads do not work in this mode
 // }
 
-#endif
+#endif

src/phantom/isomem/main.c

@@ -244,6 +244,7 @@ int phantom_main_entry_point(int argc, char **argv, char **envp)
 
     // heap_init_mutex(); // After threads // OK
     pvm_alloc_threaded_init(); // After threads // OK
+    init_gc();
 
     // Scheduler is contolled by Genode
     /*

src/phantom/isomem/pager.h

@@ -128,12 +128,10 @@ void        pager_start_io();
 void        phantom_fsck(int do_rebuild );
 
 
-void        phantom_free_snap(
-        disk_page_no_t old_snap_start,
-        disk_page_no_t curr_snap_start,
-        disk_page_no_t new_snap_start
+void phantom_free_snap(
+    disk_page_no_t* to_free_arr, int to_free_arr_len,
+    disk_page_no_t* actual_arr, int actual_arr_len
 );
 
-
 #endif // PAGER_H
 

src/phantom/isomem/vm_cn_udp.c

@@ -113,6 +113,7 @@ errno_t cn_udp_init( struct data_area_4_connection *c, struct data_area_4_thread
     SHOW_FLOW( 1, "connect udp %s", suffix );
 
     struct cn_udp_volatile *vp = c->v_kernel_state;
+    (void) vp;
 
 #if HAVE_NET
     int rc = udp_open( &vp->udp_endpoint );

src/phantom/isomem/vm_connect.c

@@ -424,8 +424,8 @@ errno_t phantom_connect_object( struct data_area_4_connection *da, struct data_a
             da->v_kernel_state = 0;
 
         // now create object for persistent state
-
-        if(te->persistent_state_size)
+        // since this function also restarts connection, this may already be created
+        if(te->persistent_state_size && da->p_kernel_state == NULL)
         {
             pvm_object_t bo = pvm_create_binary_object( te->persistent_state_size, 0);
             if( pvm_isnull(bo) )
@@ -436,15 +436,10 @@ errno_t phantom_connect_object( struct data_area_4_connection *da, struct data_a
                 return ENOMEM;
             }
 
-            // XXX : the object is created at each re-connect, so added refdec to free
-            //  old objects. The real question : why do we recreate it in the first place?
-            // also probably worth to make sure contents of objects are not used anywhere... although it is not incref'ed so...
-            ref_dec_o(da->p_kernel_state_object);
             da->p_kernel_state_object = bo;
             struct data_area_4_binary *bda = pvm_object_da( bo, binary );
 
             da->p_kernel_state = &(bda->data);
-
         }
         else
             da->p_kernel_state = 0;

src/phantom/isomem/vm_map.c

@@ -214,6 +214,29 @@ static inline void page_touch_history_arg(vm_page *p, int arg)
 
 static void    page_fault( vm_page *p, int  is_writing );
 
+// merge with addr_to_vm_page? 
+long addr_to_page_index(unsigned long addr)
+{
+    addr -= (addr_t)vm_map_start_of_virtual_address_space;
+
+    if( addr >= (((unsigned long)vm_map_vm_page_count) * __MEM_PAGE))
+        return -1;
+
+    return addr / __MEM_PAGE;
+}
+
+int addr_to_page_offset(unsigned long addr)
+{
+    addr -= (addr_t)vm_map_start_of_virtual_address_space;
+
+    if( addr >= (((unsigned long)vm_map_vm_page_count) * __MEM_PAGE))
+        return -1;
+
+    return addr % __MEM_PAGE;
+}
+
+vm_page *get_vm_page(unsigned long index) { return &vm_map_map[index]; }
+
 static vm_page *addr_to_vm_page(unsigned long addr, struct trap_state *ts)
 {
     // ph_printf("addr_raw=%X\n", addr);
@@ -1458,11 +1481,16 @@ void do_snapshot(void)
 
     if(enabled) hal_sti();
 
+    pvm_count_allocated_objects();
+
     phantom_snapper_reenable_threads();
 #if USE_SNAP_WAIT
     signal_snap_snap_passed(); // or before enabling threads?
 #endif
 
+    pvm_swap_gc_buffers(); // merge into 1 function??
+    pvm_object_t cycle_candidates = pvm_consume_gc_buffer_old();
+
     // YES, YES, YES, Snap is nearly done.
 
     // Here we have to wait a little and start processing pages manually
@@ -1488,6 +1516,8 @@ void do_snapshot(void)
 
     // TODO - free prev snap first! -- (why?)
 
+    run_gc_incremental(cycle_candidates);
+
     disk_page_no_t new_snap_head = 0;
 
 
@@ -1657,23 +1687,39 @@ static int request_snap_flag = 0;
 static int seconds_between_snaps = 5;
 
 static void free_old_snapshot() {
-    if (pager_superblock_ptr()->snap_to_free == 0) return;
-
+    hal_mutex_lock(vm_read_snap_mutex);
     disk_page_no_t to_free = pager_superblock_ptr()->snap_to_free;
+    disk_page_no_t snap_already_read = pager_superblock_ptr()->snap_already_read;
+    ph_printf("snap_to_free: %d, snap_already_read: %d\n", to_free, snap_already_read);
+    if (to_free == 0 && snap_already_read == 0) {
+        hal_mutex_unlock(vm_read_snap_mutex);
+        return;
+    }
+    disk_page_no_t snap_reading = pager_superblock_ptr()->snap_reading;
+    ph_printf("snap_reading: %d\n", snap_reading);
+
     disk_page_no_t actual1 = pager_superblock_ptr()->prev_snap;
     disk_page_no_t actual2 = pager_superblock_ptr()->last_snap;
+    disk_page_no_t actual3 = (snap_reading == actual1 || snap_reading == actual2) ? 0 : snap_reading;
+    disk_page_no_t actual_arr[] = { actual1, actual2, actual3 };
 
-    phantom_free_snap( to_free, actual1, actual2 );
-    pager_superblock_ptr()->snap_to_free = 0;
+    disk_page_no_t free1 = to_free;
+    disk_page_no_t free2 = (snap_already_read != free1) ? snap_already_read : 0;
+    disk_page_no_t free_arr[] = { free1, free2 };
+
+    phantom_free_snap(free_arr, 2, actual_arr, 3);
 
+    ph_printf("we returned from phantom_free_snap\n");
+    pager_superblock_ptr()->snap_to_free = 0;
+    pager_superblock_ptr()->snap_already_read = 0;
     // Force all io to complete BEFORE updating superblock
     pager_fence();
-
     pager_update_superblock();
 
     pager_free_blocklist_pages();
     pager_commit_active_free_list();
     pager_update_superblock();
+    hal_mutex_unlock(vm_read_snap_mutex);
 }
 
 static void vm_map_snapshot_thread(void)
@@ -1685,7 +1731,7 @@ static void vm_map_snapshot_thread(void)
     {
         SHOW_FLOW0( 1, "Snapshot loop");
         SHOW_FLOW(0, "%d %d %d", stop_lazy_pageout_thread, vm_regular_snaps_enabled, request_snap_flag);
-        
+
         free_old_snapshot();
 
         if( stop_lazy_pageout_thread )

src/phantom/isomem/vm_map.h

@@ -175,6 +175,9 @@ void       	vm_page_req_pageout();
 
     void                vm_map_wait_for_finish(void);
 
+    long addr_to_page_index(unsigned long addr);
+    int addr_to_page_offset(unsigned long addr);
+
 //extern vm_map_impl   vm_map;
 
 /*