[SR-7632] Initializing an Int Array with 2000 elements takes more than 4 seconds

[swift-ci]

Previous ID	SR-7632
Radar	rdar://problem/29358447
Original Reporter	andreasw (JIRA User)
Type	Bug
Status	Closed
Resolution	Done

Environment

Ubuntu 17.10, Swift 4.1, Dell Latitude

Additional Detail from JIRA

Votes	0
Component/s	Compiler
Labels	Bug
Assignee	andreasw (JIRA)
Priority	Medium

md5: c140d89b8695a1d83b04eca03543c3fc

Issue Description:

Compilation of

let x = [0, 1, 2, 3, ..., 2000]

takes >4 seconds on my laptop.

The same in C++ with clang takes less than 0.2 seconds.

int x[] = {0, 1, 2, 3, ..., 2000}

It gets worse with 5.000 or 20.000 elements, numbers that are not unusual when working with large predefined matrices.

I generated the elements with bash:

seq -s, 2000

[belkadan]

cc @xedin

[swift-ci]

Comment by Andreas Wendleder (JIRA)

The offending functions found with perf:

+ 59,26% 8,09% swift swift [.] (anonymous namespace)::SILVerifier::visitSILInstruction
+ 58,37% 57,89% swift swift [.] swift::DominanceInfo::properlyDominates
+ 45,00% 0,24% swift swift [.] swift::SILInstructionVisitor<(anonymous namespace)::SILVerifier, void>::visit
+ 27,87% 0,02% swift swift [.] (anonymous namespace)::SILVerifier::visitSILBasicBlock
+ 25,01% 6,50% swift swift [.] swift::constraints::ConstraintGraph::gatherConstraints
+ 15,41% 2,21% swift swift [.] swift::constraints::ConstraintGraph::contractEdges
+ 12,22% 1,97% swift swift [.] llvm::SmallPtrSetImpl<swift::TypeVariableType*>::insert
+ 11,17% 6,93% swift swift [.] llvm::SmallPtrSetImplBase::insert_imp_big
+ 5,91% 5,27% swift swift [.] swift::constraints::ConstraintGraph::lookupNode
+ 4,59% 1,07% swift swift [.] swift::constraints::ConstraintSystem::checkTypeOfBinding
+ 4,07% 0,01% swift swift [.] swift::constraints::ConstraintSystem::getPotentialBindings
+ 3,48% 2,96% swift swift [.] llvm::SmallPtrSetImplBase::Grow
+ 0,94% 0,33% swift swift [.] swift::constraints::ConstraintGraphNode::getAdjacency

[swift-ci]

Comment by Andreas Wendleder (JIRA)

perf top from a release build without assertions (which also gets rid of SILVerifier):

18,72% swift [.] swift::constraints::ConstraintGraph::contractEdges()
18,66% swift [.] swift::constraints::ConstraintGraph::gatherConstraints(swift::TypeVariableType*, llvm::SmallVectorImpl<swift::constraints::Constraint*>&, swift::constraints::ConstraintGraph::GatheringKind)
16,38% swift [.] llvm::SmallPtrSetImplBase::Grow(unsigned int)
13,09% swift [.] llvm::SmallPtrSetImplBase::insert_imp_big(void const*)
11,83% swift [.] swift::constraints::ConstraintGraph::lookupNode(swift::TypeVariableType*)
5,54% swift [.] swift::constraints::ConstraintGraphNode::getAdjacency(swift::TypeVariableType*)
4,55% [kernel] [.] 0xffffffffa3400348

[xedin]

I think @rudkx has a couple of ideas how to use Type::join to optimize this. andreasw (JIRA User) meanwhile you can workaround the problem by giving array explicit contextual type.

[swift-ci]

Comment by Andreas Wendleder (JIRA)

I tried

let x: Array<Int> = [ Int(1), Int(2), ..., Int(2000) ]

which is not better (~30s). Or do you think of something else?

[swift-ci]

Comment by Andreas Wendleder (JIRA)

After reading https://forums.swift.org/t/proposal-t-literal-should-construct-t-using-the-appropriate-literal-protocol-if-possible/2861

I tried:

let x: Array<Int> = [1 as Int, 2 as Int, ..., 2000 as Int]

which takes 0,3s which is much better. With 5.000 elements it is 1,2s, for 10.000 4,4s, for my matrix size of 50.000 it is 1m58s which is still not acceptable.

[rudkx]

I believe we have quadratic or worse behavior in the constraint graph edge contraction pass, which is showing up in these cases with large numbers of elements in a statically initialized array.

[rudkx]

There is definitely extra work happening in edge contraction, but that doesn't account for all the slowness here.

[xedin]

andreasw (JIRA User) problem with both Int(X) and 1 as Int is that creates disjunctions first for initializer overrides and latter for conversion (which is easily bound so that's what there is a big different between the two), could you try let x: [Int] = [1, 2, 3, 4, ...] as well that supposed to be a more linear case?

[swift-ci]

Comment by Andreas Wendleder (JIRA)

Timings for let x: [Int] = [1, 2, 3, ..., x]

Elements	Time
1.000	0.163s
2.000	0.321s
5.000	1.465s
10.000	6.445s
20.000	28.713s
50.000	3m22.698s

Still unusable for my 50.000 element matrix. 🙁

This is a self-compiled swift with --release --no-assertions flags, otherwise it would be worse because of the SILVerifier.

The offending functions recorded with perf are:

+ 94,42% 18,36% swift swift [.] swift::constraints::ConstraintGraph::contractEdges
+ 76,45% 28,30% swift swift [.] swift::constraints::ConstraintGraph::gatherConstraints
+ 34,99% 19,50% swift swift [.] llvm::SmallPtrSetImplBase::insert_imp_big
+ 15,41% 13,66% swift swift [.] llvm::SmallPtrSetImplBase::Grow

[xedin]

Very interesting, @rudkx has an idea how to make contractEdges less expensive, because it doesn't have to iterate over type variables and gather constraints every time, instead it can iterate over constraints directly, so let's see, maybe there is an easy fix in here for this.

[xedin]

andreasw (JIRA User) I have PR for this if you want to give it a try - #16560

[swift-ci]

Comment by Andreas Wendleder (JIRA)

Much better! I would say it's usable now, but still far from clang.

Elements	Time swiftc	Time clang
1.000	0.128s	0.150s
2.000	0.166s	0.150s
5.000	0.337s	0.152s
10.000	0.794s	0.157s
20.000	2.006s	0.172s
50.000	9.632s	0.205s

Numbers generated with:

echo "let x: [Int] = [" > linear.swift; seq -s, 1000 >> linear.swift; echo "]" >> linear.swift ; time swiftc linear.swift

echo -e "#include <vector>nstd::vector<int> x{" > linear.cc; seq -s, 1000 >> linear.cc; echo "};" >> linear.cc ; time clang -c linear.cc

Thanks very much.

[swift-ci]

Comment by Andreas Wendleder (JIRA)

And for the sake of completeness the offending functions now:

+ 64,31% 64,17% swift swift [.] llvm::StringRef::find_last_of
+ 63,71% 0,07% swift swift [.] swift::Lowering::SILGenFunction::emitApply
+ 63,24% 0,01% swift swift [.] swift::SILLocation::decode
+ 63,19% 0,03% swift swift [.] llvm::SourceMgr::getLineAndColumn
+ 10,04% 0,17% swift swift [.] swift::ConstantFolder::processWorkList
+ 9,70% 0,06% swift swift [.] swift::recursivelyDeleteTriviallyDeadInstructions

[swift-ci]

Comment by Andreas Wendleder (JIRA)

This can be brought down to

Elements	Time
50.000	3.306s

when each element is written to its own line with

echo "let x: [Int] = [" > linear.swift; for i in $(seq 50000); do echo -e $i,; done >> linear.swift; echo "]" >> linear.swift ; time swiftc linear.swift

which means that the Source Manager is doing some redundant work while trying to find a newline for each element.

Maybe the Line Number Cache in SourceMgr helps.