From 274ed0fc85e7c50fc0e551c5e376aebdb9a548f4 Mon Sep 17 00:00:00 2001
From: "Kartik K. Agaram" <vc@akkartik.com>
Date: Wed, 31 Aug 2016 14:56:33 -0700
Subject: 3288 - cleaner heuristic for cleaving

For the last couple of days I've been implicitly thinking in terms of
how many compilation units I want to generate. Might as well make that
explicit and drop the hacky ideas for approximating it.

I tried more timing experiments like the ones in commit 3281.
Conclusion: I can't have the best of both worlds:

  1. Full compilation doesn't take too much longer than with a single
  compilation unit.

  2. Incremental compilation is fast enough that there's negligible
  benefit from dropping optimization.

We're still taking on a 10s hit in full build time.

I care more about not degrading the full compilation too much, since
that gets magnified so much on the Couch's puny server. So we'll just
have to continue using CXXFLAGS=-g when we care to save a few seconds in
incremental compilation time.

A final mystery: the build time increases by 10s with the new heuristic
even though the number of calls to the compiler (and therefore the fixed
cost) is the same. Seems like separating certain functions into
different units is causing the compiler issues. Dropping from 4 to 3
compilation units eliminated the issue.

--- Appendix: Measurements
before:
  full build 4 + test: 42s
  incremental compilation with -O3: varied from 30s for mu_0.cc to 5s for mu_3.cc
    longer times benefitted from dropping -O3

after:
  full build 1 + test: 39s
  full build 2 + test: 41s
  full build 3 + test: 43s
  full build 4 + test: 52s
  full build 5 + test: 53s
  full build 6 + test: 51s
  full build 10 (9) + test: 54s
  full build 20 (16) + test: 58s
---
 cleave/cleave.cc | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'cleave')

diff --git a/cleave/cleave.cc b/cleave/cleave.cc
index 8d79f2ac..442b5fe6 100644
--- a/cleave/cleave.cc
+++ b/cleave/cleave.cc
@@ -38,9 +38,9 @@
 
 // Tune this parameter to balance time for initial vs incremental build.
 //
-//   Larger numbers -> larger/fewer compilation units -> faster initial build
-//   Smaller numbers -> smaller compilation units -> faster incremental build
-int Compilation_unit_size = 200;
+//   decrease value -> faster initial build
+//   increase value -> faster incremental build
+int Num_compilation_units = 3;
 
 #include<assert.h>
 #include<cstdlib>
@@ -115,7 +115,9 @@ size_t slurp_some_functions(const vector<string>& in, size_t start, vector<strin
     out.push_back("#include \"global_declarations_list\"");
   out.push_back("");
   size_t curr = start;
-  for (int i = 0; i < Compilation_unit_size; ++i) {
+  while (true) {
+    if (curr >= in.size()) break;
+    if (out.size() >= in.size()/Num_compilation_units) break;
     while (curr < in.size()) {
       // read functions -- lines until unindented '}'
       while (curr < in.size()) {
@@ -137,12 +139,6 @@ size_t slurp_some_functions(const vector<string>& in, size_t start, vector<strin
     }
     try_return:;
   }
-
-  // Idea: Increase the number of functions to include in the next call to
-  // slurp_some_functions.
-  // Early functions are more likely to be larger because later layers added
-  // to them.
-//?   Compilation_unit_size *= 1.5;
   return curr;
 }
 
-- 
cgit 1.4.1-2-gfad0