code page tests

source/extra/m3_test.c

@@ -46,5 +46,63 @@ int  main  (int i_argc, const char  * i_argv [])
         m3Free (ftype2);
     }
     
+    
+    Test (codepages.simple)
+    {
+        M3Environment env = { 0 };
+        M3Runtime runtime = { 0 };
+        runtime.environment = & env;
+        
+        IM3CodePage page = AcquireCodePage (& runtime);                 expect (page);
+                                                                        expect (runtime.numCodePages == 1);
+                                                                        expect (runtime.numActiveCodePages == 1);
+        
+        IM3CodePage page2 = AcquireCodePage (& runtime);                expect (page2);
+                                                                        expect (runtime.numCodePages == 2);
+                                                                        expect (runtime.numActiveCodePages == 2);
+
+        ReleaseCodePage (& runtime, page);                              expect (runtime.numCodePages == 2);
+                                                                        expect (runtime.numActiveCodePages == 1);
+
+        ReleaseCodePage (& runtime, page2);                             expect (runtime.numCodePages == 2);
+                                                                        expect (runtime.numActiveCodePages == 0);
+        
+        Runtime_Release (& runtime);                                    expect (CountCodePages (env.pagesReleased) == 2);
+        Environment_Release (& env);                                    expect (CountCodePages (env.pagesReleased) == 0);
+    }
+    
+    Test (codepages.b)
+    {
+        const u32 c_numPages = 2000;
+        IM3CodePage pages [2000] = { NULL };
+        
+        M3Environment env = { 0 };
+        M3Runtime runtime = { 0 };
+        runtime.environment = & env;
+
+        u32 numActive = 0;
+        
+        for (u32 i = 0; i < 5000000; ++i)
+        {
+            u32 index = rand () % c_numPages;   // printf ("%5u ", index);
+            
+            if (pages [index] == NULL)
+            {
+                pages [index] = AcquireCodePage (& runtime);
+                ++numActive;
+            }
+            else
+            {
+                ReleaseCodePage (& runtime, pages [index]);
+                pages [index] = NULL;
+                --numActive;
+            }
+                
+            expect (runtime.numActiveCodePages == numActive);
+        }
+        
+        printf ("num pages: %d\n", runtime.numCodePages);
+    }
+    
     return 0;
 }

source/m3_code.c

@@ -30,16 +30,20 @@ IM3CodePage  NewCodePage  (u32 i_minNumLines)
 }
 
 
-void  FreeCodePages  (IM3CodePage i_page)
+void  FreeCodePages  (IM3CodePage * io_list)
 {
-    while (i_page)
+    IM3CodePage page = * io_list;
+    
+    while (page)
     {
-        m3log (code, "free page: %d; %p; util: %3.1f%%", i_page->info.sequence, i_page, 100. * i_page->info.lineIndex / i_page->info.numLines);
+        m3log (code, "free page: %d; %p; util: %3.1f%%", page->info.sequence, page, 100. * page->info.lineIndex / page->info.numLines);
 
-        IM3CodePage next = i_page->info.next;
-        m3Free (i_page);
-        i_page = next;
+        IM3CodePage next = page->info.next;
+        m3Free (page);
+        page = next;
     }
+    
+    * io_list = NULL;
 }
 
 
@@ -96,15 +100,34 @@ IM3CodePage  PopCodePage  (IM3CodePage * i_list)
 }
 
 
-u32  CountCodePages  (IM3CodePage i_list)
+
+u32  FindCodePageEnd  (IM3CodePage i_list, IM3CodePage * o_end)
 {
     u32 numPages = 0;
+    * o_end = NULL;
     
     while (i_list)
     {
+        * o_end = i_list;
         ++numPages;
         i_list = i_list->info.next;
     }
     
     return numPages;
 }
+
+
+u32  CountCodePages  (IM3CodePage i_list)
+{
+    IM3CodePage unused;
+    return FindCodePageEnd (i_list, & unused);
+}
+
+
+IM3CodePage GetCodePageEnd  (IM3CodePage i_list)
+{
+    IM3CodePage end;
+    FindCodePageEnd (i_list, & end);
+    
+    return end;
+}

source/m3_code.h

@@ -24,17 +24,19 @@ typedef M3CodePage *    IM3CodePage;
 
 IM3CodePage             NewCodePage             (u32 i_minNumLines);
 
-void                    FreeCodePages           (IM3CodePage i_page);
+void                    FreeCodePages           (IM3CodePage * io_list);
+
 u32                     NumFreeLines            (IM3CodePage i_page);
 pc_t                    GetPageStartPC          (IM3CodePage i_page);
 pc_t                    GetPagePC               (IM3CodePage i_page);
 void                    EmitWord64_impl         (IM3CodePage i_page, u64 i_word);
 void                    EmitWord_impl           (IM3CodePage i_page, void* i_word);
 
-void                    PushCodePage            (IM3CodePage * i_list, IM3CodePage i_codePage);
-IM3CodePage             PopCodePage             (IM3CodePage * i_list);
+void                    PushCodePage            (IM3CodePage * io_list, IM3CodePage i_codePage);
+IM3CodePage             PopCodePage             (IM3CodePage * io_list);
 
-u32                     CountCodePages          (IM3CodePage i_list);
+IM3CodePage             GetCodePageEnd          (IM3CodePage i_list); // i_list = NULL is valid
+u32                     CountCodePages          (IM3CodePage i_list); // i_list = NULL is valid
 
 # ifdef DEBUG
 void                    dump_code_page            (IM3CodePage i_codePage, pc_t i_startPC);

source/m3_env.c

@@ -169,21 +169,26 @@ IM3Environment  m3_NewEnvironment  ()
 }
 
 
+void  Environment_Release  (IM3Environment i_environment)
+{
+    IM3FuncType ftype = i_environment->funcTypes;
+
+    while (ftype)
+    {
+        IM3FuncType next = ftype->next;
+        m3Free (ftype);
+        ftype = next;
+    }                                                   m3log (runtime, "freeing %d pages from environment",
+                                                               CountCodePages (i_environment->pagesReleased));
+    FreeCodePages (& i_environment->pagesReleased);
+}
+
+
 void  m3_FreeEnvironment  (IM3Environment i_environment)
 {
     if (i_environment)
     {
-        IM3FuncType ftype = i_environment->funcTypes;
-
-        while (ftype)
-        {
-            IM3FuncType next = ftype->next;
-            m3Free (ftype);
-            ftype = next;
-        }
-                                                                                    m3log (runtime, "freeing %d pages from environment", CountCodePages (i_environment->pagesReleased));
-        FreeCodePages (i_environment->pagesReleased);
-        
+        Environment_Release (i_environment);
         m3Free (i_environment);
     }
 }
@@ -252,16 +257,7 @@ IM3CodePage  Environment_AcquireCodePage (IM3Environment i_environment, u32 i_mi
 
 void  Environment_ReleaseCodePages  (IM3Environment i_environment, IM3CodePage i_codePageList)
 {
-    // find end of list
-    IM3CodePage end = i_codePageList;
-    while (end)
-    {
-        IM3CodePage next = end->info.next;
-        if (not next)
-            break;
-        
-        end = next;
-    }
+    IM3CodePage end = GetCodePageEnd (i_codePageList);
     
     if (end)
     {
@@ -341,7 +337,7 @@ void  FreeCompilationPatches  (IM3Compilation o)
 
 void  Runtime_Release  (IM3Runtime i_runtime)
 {
-    ForEachModule (i_runtime, _FreeModule, NULL);
+    ForEachModule (i_runtime, _FreeModule, NULL);                   d_m3Assert (i_runtime->numActiveCodePages == 0);
 
     Environment_ReleaseCodePages (i_runtime->environment, i_runtime->pagesOpen);
     Environment_ReleaseCodePages (i_runtime->environment, i_runtime->pagesFull);

source/m3_env.h

@@ -209,6 +209,8 @@ typedef struct M3Environment
 }
 M3Environment;
 
+void                        Environment_Release         (IM3Environment i_environment);
+
 // takes ownership of io_funcType and returns a pointer to the persistent version (could be same or different)
 void                        Environment_AddFuncType     (IM3Environment i_environment, IM3FuncType * io_funcType);