Hi,
While working on a D project which heavily uses the lazy
algorithms for ranges I noticed a sudden huge increase in the
compilation time and the produced binary size.
I chased down the offending change to just a small change in one
line of the code which made the resulting binary to jump from
18MB to over 400MB.
The code that produces the large binary actually failed to link
using DMD on osx (works on linux). The link command just consumes
all the CPU and never completes. Using LDC on osx just failed to
compile. ldc was using all the CPU and never completing.
There is also a very big difference between passing -unittest and
not passing it.
I was able to shrink the code down to the following:
import std.range.primitives;
import std.range : chain, choose, repeat, chooseAmong, takeOne;
import std.algorithm.iteration : joiner , map;
import std.range.interfaces : InputRange, inputRangeObject;
import std.conv : text;
struct AType {
string id;
Annotation[] annotations;
TypeArgument[] typeArguments;
}
struct Annotation {
string type;
}
struct TypeArgument {
AType refType;
}
struct PrimaryValue {
int type;
}
struct FieldDecl {
AType type;
string id;
PrimaryValue[] values;
}
struct MethodDecl {
string name;
AType returnType;
FieldDecl[] params;
}
auto toCharsArray(R)(R r, string sep = "\n", string tail = "\n")
if (isInputRange!R) {
return choose(r.empty, "", chain(r.joiner(sep), tail));
}
auto toChars(Annotation uda) {
return chain("@", uda.type);
}
InputRange!(ElementType!string) toChars(TypeArgument ta) {
auto r = chain("", ta.refType.id);
with (ta.refType) {
auto tArgs = choose(typeArguments.empty, "",
chain("!(",
typeArguments.map!(toChars).joiner(", "), ")"));
return chain(id, tArgs).inputRangeObject();
}
}
auto toChars(AType t) {
auto udas = t.annotations.map!(toChars).toCharsArray();
auto tArgs = choose(t.typeArguments.empty, "",
chain("!(",
t.typeArguments.map!(toChars).joiner(", "), ")"));
return chain(udas, t.id, tArgs);
}
/// PrimaryValue
auto toChars(PrimaryValue pv) {
return chooseAmong(pv.type, "val", "val");
}
auto toCharsSingleOrArray(R)(R r) if (isInputRange!R) {
return choose(r.length == 1,
r.takeOne.map!(toChars).joiner(),
chain("[", r.map!(toChars).joiner(", "), "]")
);
}
auto toCharsBare(FieldDecl f) {
auto def = chain(f.type.toChars, " ", f.id);
return choose(f.values.empty,
def,
chain(def, " = ",
toCharsSingleOrArray(f.values)));
}
auto toChars(FieldDecl f) {
return chain("", f.toCharsBare());
}
auto toChars(MethodDecl m) {
//Just changing the line bellow to have map!(toChars) reduces
the binary size
//to 18MB from 403MB
auto prms = chain("(",
m.params.map!(toCharsBare).toCharsArray(", ", ""), ")");
return chain(" ", m.name, prms, ";");
}
unittest {
AType t1 = {id : "Foo"};
FieldDecl f1 = {type : t1, id : "f1"};
MethodDecl m1 = {name : "m", returnType : t1 };
assert(!m1.toChars().text().empty); // removing this line
drops the size by half
}
void main() { }
I am compiling this with:
# dmd -g -debug -unittest
I have marked the line that needs to be changed for the code size
to drop significantly. What is interesting is that the using
toChars should be more complex than using toCharsBare since the
former calls the latter but the binary size just explodes when
using toCharsBare.
I apologize for the long code segment.
