From 90c6b51fd54954ba4dec124deb8456d015788ed3 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <mike.gerwitz@ryansg.com>
Date: Wed, 21 Jul 2021 14:53:15 -0400
Subject: [PATCH] tamer: tameld: Place constants into static section in
 executable

This is something that changed when the TAMER POC was initially created, as
I was learning Rust.  I don't recall the original reason why this was moved,
but it could have been moved back long ago.

In our systems, constants can hold tables (as matrices) with tens or
hundreds of thousands of rows, and there are a number of them in certain
projects.  As an example, the YAML-based test cases for one of our systems
went from ~2m30s to ~45s after this change was made.  Much of the cost
savings comes from saving GC.
---
 RELEASES.md                       |  4 ++++
 tamer/src/ir/asg/base.rs          | 23 +++++++++++++++--------
 tamer/src/ir/asg/section.rs       |  2 ++
 tamer/src/obj/xmle/writer/xmle.rs |  3 ++-
 4 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/RELEASES.md b/RELEASES.md
index 085229b4..1a849ca7 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -18,6 +18,10 @@ NEXT
 ====
 Compiler
 --------
+- Place constants into static section in linked executable.
+  - This was the case in the old linker before the `tameld`
+    proof-of-concept.  The benefits are significant when large constants are
+    used (e.g. for large tables of data).
 - Do not report value list optimization error on duplicate conjunctive
   predicates.
   - This doesn't emit code any differently, it merely permits the situation,
diff --git a/tamer/src/ir/asg/base.rs b/tamer/src/ir/asg/base.rs
index b7759759..4b4bd24c 100644
--- a/tamer/src/ir/asg/base.rs
+++ b/tamer/src/ir/asg/base.rs
@@ -310,6 +310,7 @@ where
                     IdentKind::RetMapHead
                     | IdentKind::RetMap
                     | IdentKind::RetMapTail => deps.retmap.push_body(ident),
+                    IdentKind::Const(_, _) => deps.consts.push_body(ident),
                     _ => deps.rater.push_body(ident),
                 },
                 None => {
@@ -387,7 +388,8 @@ mod test {
     use super::super::graph::AsgError;
     use super::*;
     use crate::ir::asg::{
-        Dim, IdentObject, TransitionError, TransitionResult, UnresolvedError,
+        DataType, Dim, IdentObject, TransitionError, TransitionResult,
+        UnresolvedError,
     };
     use crate::ir::legacyir::SymDtype;
     use crate::sym::SymbolIndex;
@@ -854,9 +856,10 @@ mod test {
     }
 
     macro_rules! assert_section_sym {
-        ( $iter:expr, $s:ident ) => {{
+        ( $iterable:expr, $s:ident ) => {{
             let mut pos = 0;
-            for obj in $iter {
+            assert_eq!($iterable.len(), $s.len());
+            for obj in $iterable.iter() {
                 let sym = obj.name().expect("missing object");
                 assert_eq!($s.get(pos), Some(sym));
 
@@ -866,7 +869,7 @@ mod test {
     }
 
     macro_rules! add_syms {
-        ($sut:ident, $base:expr, {$($dest:ident <- $name:ident: $kind:path,)*}) => {
+        ($sut:ident, $base:expr, {$($dest:ident <- $name:ident: $kind:expr,)*}) => {
             let mut i = 1;
 
             $(
@@ -890,6 +893,7 @@ mod test {
         let mut worksheet = vec![];
         let mut map = vec![];
         let mut retmap = vec![];
+        let mut consts = vec![];
 
         let base = symbol_dummy!(1, "sym1");
         let base_node = sut
@@ -899,6 +903,7 @@ mod test {
         add_syms!(sut, &base, {
             meta <- meta1: IdentKind::Meta,
             worksheet <- work1: IdentKind::Worksheet,
+            consts <- const1: IdentKind::Const(Dim::from_u8(0), DataType::Float),
             map <- map1: IdentKind::MapHead,
             map <- map2: IdentKind::Map,
             map <- map3: IdentKind::MapTail,
@@ -913,16 +918,18 @@ mod test {
             worksheet <- work2: IdentKind::Worksheet,
             map <- map6: IdentKind::MapTail,
             retmap <- retmap6: IdentKind::RetMapHead,
+            consts <- const2: IdentKind::Const(Dim::from_u8(2), DataType::Float),
         });
 
         map.push(base);
 
         let sections = sut.sort(&vec![base_node])?;
 
-        assert_section_sym!(sections.meta.iter(), meta);
-        assert_section_sym!(sections.worksheet.iter(), worksheet);
-        assert_section_sym!(sections.map.iter(), map);
-        assert_section_sym!(sections.retmap.iter(), retmap);
+        assert_section_sym!(sections.meta, meta);
+        assert_section_sym!(sections.worksheet, worksheet);
+        assert_section_sym!(sections.map, map);
+        assert_section_sym!(sections.retmap, retmap);
+        assert_section_sym!(sections.consts, consts);
 
         Ok(())
     }
diff --git a/tamer/src/ir/asg/section.rs b/tamer/src/ir/asg/section.rs
index 17eb174a..1eed78b4 100644
--- a/tamer/src/ir/asg/section.rs
+++ b/tamer/src/ir/asg/section.rs
@@ -129,6 +129,7 @@ pub struct Sections<'a, T> {
     pub params: Section<'a, T>,
     pub types: Section<'a, T>,
     pub funcs: Section<'a, T>,
+    pub consts: Section<'a, T>,
     pub rater: Section<'a, T>,
 }
 
@@ -143,6 +144,7 @@ impl<'a, T> Sections<'a, T> {
             params: Section::new(),
             types: Section::new(),
             funcs: Section::new(),
+            consts: Section::new(),
             rater: Section::new(),
         }
     }
diff --git a/tamer/src/obj/xmle/writer/xmle.rs b/tamer/src/obj/xmle/writer/xmle.rs
index 9f57ce0c..5fdee44b 100644
--- a/tamer/src/obj/xmle/writer/xmle.rs
+++ b/tamer/src/obj/xmle/writer/xmle.rs
@@ -117,7 +117,8 @@ impl<W: Write> XmleWriter<W> {
                     .write_section(sections.worksheet.iter())?
                     .write_section(sections.params.iter())?
                     .write_section(sections.types.iter())?
-                    .write_section(sections.funcs.iter())
+                    .write_section(sections.funcs.iter())?
+                    .write_section(sections.consts.iter())
             })?
             .write_element(b"l:exec", |writer| {
                 writer.write_section(sections.rater.iter())