Use array instead of linked list for PCR buckets

Author: ysthakur

src/main/resources/runtime/runtime.h

@@ -22,13 +22,6 @@ struct PCR
   struct PCR *next;
 };
 
-struct PCRBucket
-{
-  int scc;
-  struct PCR *pcrs;
-  struct PCRBucket *next;
-};
-
 // Common object header
 typedef struct
 {
@@ -45,7 +38,8 @@ struct FreeCell
   void (*free)(void *);
 };
 
-struct PCRBucket *pcrBuckets = NULL;
+struct PCR **pcrBuckets = NULL;
+int numSccs = 0;
 struct FreeCell *freeList = NULL;
 
 /** For dropping objects that never get assigned anywhere */
@@ -65,32 +59,15 @@ void addPCR(
     return;
   obj->addedPCR = 1;
 
-  struct PCRBucket **prev = &pcrBuckets;
-  while (*prev != NULL && (*prev)->scc < scc)
-  {
-    prev = &(*prev)->next;
-  }
-
   struct PCR *pcr = malloc(sizeof(struct PCR));
   pcr->obj = obj;
   pcr->markGray = markGray;
   pcr->scan = scan;
   pcr->collectWhite = collectWhite;
   pcr->next = NULL;
 
-  if (*prev == NULL || scc < (*prev)->scc)
-  {
-    struct PCRBucket *newBucket = malloc(sizeof(struct PCRBucket));
-    newBucket->scc = scc;
-    newBucket->pcrs = pcr;
-    newBucket->next = *prev;
-    *prev = newBucket;
-  }
-  else
-  {
-    pcr->next = (*prev)->pcrs;
-    (*prev)->pcrs = pcr;
-  }
+  pcr->next = pcrBuckets[scc];
+  pcrBuckets[scc] = pcr;
 }
 
 void removePCR(Common *obj, int scc)
@@ -99,26 +76,13 @@ void removePCR(Common *obj, int scc)
     return;
   obj->addedPCR = 0;
 
-  struct PCRBucket **prevBucket = &pcrBuckets;
-  struct PCRBucket *bucket = pcrBuckets;
-  while (bucket->scc != scc)
-  {
-    prevBucket = &bucket->next;
-    bucket = bucket->next;
-  }
-
-  struct PCR **prev = &bucket->pcrs;
-  struct PCR *head = bucket->pcrs;
+  struct PCR **prev = &pcrBuckets[scc];
+  struct PCR *head = pcrBuckets[scc];
   while (head != NULL)
   {
     if (head->obj == obj)
     {
       *prev = head->next;
-      if (bucket->pcrs == NULL) {
-        // This was the only PCR in the bucket, so remove the bucket too
-        *prevBucket = bucket->next;
-        free(bucket);
-      }
       free(head);
       return;
     }
@@ -171,20 +135,18 @@ void collectFreeList()
 
 void processAllPCRs()
 {
-  while (pcrBuckets != NULL)
+  for (int scc = 0; scc < numSccs; scc ++)
   {
-    markGrayAllPCRs(pcrBuckets->pcrs);
-    scanAllPCRs(pcrBuckets->pcrs);
+    markGrayAllPCRs(pcrBuckets[scc]);
+    scanAllPCRs(pcrBuckets[scc]);
     if (freeList != NULL)
     {
       fprintf(stderr, "Free list should be null\n");
       exit(1);
     }
-    collectWhiteAllPCRs(pcrBuckets->pcrs);
+    collectWhiteAllPCRs(pcrBuckets[scc]);
+    pcrBuckets[scc] = NULL;
     collectFreeList();
-    struct PCRBucket *next = pcrBuckets->next;
-    free(pcrBuckets);
-    pcrBuckets = next;
   }
 }
 

src/main/scala/fred/Translator.scala

@@ -31,7 +31,7 @@ object Translator {
         )
       case RcAlgo.Mine => Cycles.fromFile(file)
     }
-    val helper = Helper(typer)
+    val helper = Helper(typer, cycles)
     val (genDecls, genImpls) =
       List(Freer, Decrementer, MarkGray, Scan, ScanBlack, CollectWhite, Printer)
         .flatMap(gen => file.typeDefs.map(td => (gen.decl(td), gen.impl(td))))
@@ -378,7 +378,7 @@ object Translator {
     */
   private def tagName(ctorName: String): String = s"${ctorName}_tag"
 
-  private class Helper(typer: Typer) {
+  private class Helper(typer: Typer, cycles: Cycles) {
 
     /** Contains a mapping of mangled field names for every type */
     val mangledFieldsFor = mutable.Map.empty[TypeDef, Map[String, String]]
@@ -454,11 +454,22 @@ object Translator {
 
       val signature = s"$typeToC ${mangleFnName(fn.name.value)}($params)"
 
+      val numSccs = cycles.sccs.size
+      val allocPcrBuckets =
+        if (fn.name.value == "main")
+          indent(1)(s"""|pcrBuckets = calloc(sizeof(void *), $numSccs);
+                        |numSccs = $numSccs;""".stripMargin)
+        else ""
+
       val triggerGC =
-        if (fn.name.value == "main") indent(1)("processAllPCRs();") else ""
+        if (fn.name.value == "main")
+          indent(1)("""|processAllPCRs();
+                       |free(pcrBuckets);""".stripMargin)
+        else ""
 
       val decl = s"$signature;"
       val impl = s"""|$signature {
+                     |$allocPcrBuckets
                      |${indent(1)(paramsSetup)}
                      |${indent(1)(bodySetup)}
                      |  $typeToC $resVar = $body;

src/test/resources/snapshot/exec/basic-cycle.c

@@ -215,12 +215,26 @@ All of the stuff described above is then run 50,000 times. Here are the results:
   [Yes], [11054113602], [4.233204]
 )
 
-Again, all this tells you is that there are some cases where my algorithm can do worse than lazy mark scan.
+After using an array like I mentioned above, I ran the stupid benchmark again. Now, both algorithms have about the same performance!
+#table(
+  columns: (auto, auto, auto),
+  table.header([Lazy mark scan only?], [Timestamp counter], [Clock (s)]),
+  [No], [8890733476], [3.404776],
+  [Yes], [10184751983], [3.900381]
+)
 
 = Conclusion
 
 = Future work <future_work>
 
+== Formal verification
+
+I worry that this algorithm isn't actually sound. It would be nice to prove using Coq or something that, if you group and sort PCRs according to the SCC of their type and process each group separately in order, you'll still collect all cycles.
+
+== Applying this to newer algorithms
+
+The papers I was working off are pretty old. I'd like
+
 = Why name it #smallcaps[Fred]?
 
 I was going to name it Foo, but there's already an esolang by that name that's fairly well-known (by esolang standards). So I went to the Wikipedia page on metasyntactic variables and picked "fred." I figured that if I needed to, I could pretend that it was something meaningful, like maybe an acronym or the name of a beloved childhood pet.