search for: superlinear

...ng the search. Memory efficiency is only half of the problem. I.e. groonga's expr.c needs 4m to build on my laptop, a 2.7GHz i7. That doesn't sound reasonable for a -O2. Unlike the GVN issue, the cases I have run into do finish after a(n unreasonable) while, so at least it is not trivially superlinear. Joerg

...ard time getting good > multithreaded performance without significant impact on the single-threaded > behavior. > > I don't really agree. > > Disagreement seconded. > For single-threaded case we are talking about constant overhead, while for > multithreaded case -- about superlinear overhead. > Having said that, if there is a *simple* way to modify the final scheme to > significantly reduce single-threaded overheads, then or course it's worth > doing. But it's not the cornerstone. > > > > > MAX is a fixed cap so even on systems with 100s of core...

Adding LLVMdev, since this is intimately related to the optimization passes. > I think this is roughly because some function level optimisations are > worse than O(N) in the number of instructions. Please profile this and mail llvmdev regarding passes with significantly superlinear behavior (e.g. O(n^2)). My understanding is that these kinds of algorithmic problems are generally considered bugs in the optimizer and will be fixed. > Roughly, a pass would calculate the cost of running on some > unit (translation unit, function), and a "goodness" estimating >...

...f of the problem. I.e. groonga's expr.c > needs 4m to build on my laptop, a 2.7GHz i7. That doesn't sound > reasonable for a -O2. Unlike the GVN issue, the cases I have run > into do > finish after a(n unreasonable) while, so at least it is not trivially > superlinear. > > > > Okay, so rather than artificially limit stuff, we should see if we can > fix the efficiency of the algorithms. > > CVP is an O(N*lattice height) pass problem. It sounds like it is being > more than that for you. (Deliberately replying up thread to skip detailed di...

...y half of the problem. I.e. groonga's expr.c > > needs 4m to build on my laptop, a 2.7GHz i7. That doesn't sound > > reasonable for a -O2. Unlike the GVN issue, the cases I have run into do > > finish after a(n unreasonable) while, so at least it is not trivially > > superlinear. > > > > > Okay, so rather than artificially limit stuff, we should see if we can fix > the efficiency of the algorithms. > > CVP is an O(N*lattice height) pass problem. It sounds like it is being more > than that for you. I assume you mean something like #BB * #varia...

...ularly since llvm can be used as a JIT. So I suspect it wouldn't be something most people would want for mainstream clang/llvm, but if might be interesting if someone were to implement some passes like this (probably out-of-tree) and see if it proves beneficial. Of course Sean's point that superlinear behaviour ought to be reported as it's probably a bug is very true, Regards, Dave -----Original Message----- From: llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu] On Behalf Of Sean Silva Sent: 23 November 2012 06:47 To: john skaller Cc: Clang; llvmdev at cs.uiuc.edu...

On Apr 17, 2014, at 2:04 PM, Chandler Carruth <chandlerc at google.com> wrote: > On Thu, Apr 17, 2014 at 1:27 PM, Justin Bogner <mail at justinbogner.com> wrote: > Chandler Carruth <chandlerc at google.com> writes: > > if (thread-ID != main's thread-ID && shard_count < std::min(MAX, NUMBER_OF_CORES)) { > > shard_count = std::min(MAX,

...ance without significant impact on the single-threaded >>> behavior. >>> > I don't really agree. >>> >>> Disagreement seconded. >>> For single-threaded case we are talking about constant overhead, while >>> for multithreaded case -- about superlinear overhead. >>> Having said that, if there is a *simple* way to modify the final scheme >>> to significantly reduce single-threaded overheads, then or course it's >>> worth doing. But it's not the cornerstone. >>> >>> >>> >>> >...

...doesn't sound > > > > > reasonable for a -O2. Unlike the GVN issue, the cases I have > > > > run > > > > into do > > > > > finish after a(n unreasonable) while, so at least it is not > > > > trivially > > > > > superlinear. > > > > > > > > > > > > > > > > > Okay, so rather than artificially limit stuff, we should see if > > > we > > > can fix > > > > the efficiency of the algorithms. > > > > > > > > CVP is...

Sorry, by debug build I actually meant asserts enabled.  Thus, this issue can show up in either a debug or release build, if asserts are enabled. On 10/26/2017 4:05 PM, Chad Rosier via llvm-dev wrote: > > Chandler/All, > > We've just started testing the new pass manager this week and we ran > into a 548x slowdown (i.e., 6.28s to 3443.83s) for one of the files > from

What are the limitations on size of matrix for MDS functions? steve -- Steve Antos Priva-Technologies 847-640-9020 x3114 cell (540)409-1231 [[alternative HTML version deleted]]

...the sequence decreases monotonically and converges to from any (positive) starting point. Speed of Convergence. Does Ostrowski¡¯s Theorem apply in this example ? What follows from it ? We can also use simple calculation here to determine the speed of converge. Show first that which implies superlinear convergence, and then show which means convergence is quadratic. Coding. (1) Write an R function newton() that applies Newton¡¯s method to a general univariate polynomial equation f (x) = 0. Use the standard iterative setup with itmax, eps, verbose. (2) Use the R package polynom to handle p...

...LLVMdev, since this is intimately related to the optimization passes. > >> I think this is roughly because some function level optimisations are >> worse than O(N) in the number of instructions. > > Please profile this and mail llvmdev regarding passes with > significantly superlinear behavior (e.g. O(n^2)). My understanding is > that these kinds of algorithmic problems are generally considered bugs > in the optimizer and will be fixed. I cannot do that yet, however here's some more info: Felix compile time: 5 seconds. C++ compile and run times: With -O3: /usr/loc...

> -----Original Message----- > From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] On Behalf Of > Krzysztof Parzyszek via llvm-dev > Sent: Monday, June 12, 2017 1:24 PM > To: llvm-dev at lists.llvm.org > Subject: Re: [llvm-dev] Open bug count passes 10,000 mark > > On 6/12/2017 3:18 PM, Robinson, Paul via llvm-dev wrote: > > > > I have been tracking this

Hi, I am new to R, and as a first exercise, I decided to try to implement an XIRR function using the secant method. I did a quick search and saw another posting that used the Bisection method but wanted to see if it was possible using the secant method. I would input a Cash Flow and Date vector as well as an initial guess. I hardcoded today's initial date so I could do checks in Excel.

...quantum non-determinism :) Either the compiler finishes and does a "reasonable job" or it takes so long the whole thing gets killed. Of course, I could re-run the compiler with a lower optimisation switch in that case. I think I might try that. > > Of course Sean's point that superlinear behaviour ought to be reported as > it's probably a bug is very true, Isn't data flow analysis O(N^3)? You cannot do proper alias analysis without it. -- john skaller skaller at users.sourceforge.net http://felix-lang.org

I'm reading a file and using the file to populate a data frame. The way the file is laid out, I need to fill in the data frame one row at a time. When I start reading my file, I don't know how many rows I will need. It's on the order of a million. Being mindful of the time expense of reallocation, I decided on a strategy of doubling the data frame size every time I needed to expand

Hi all, with the current trunk I have two major cases where clang needs more than 2GB memory for compiling programs with -O2. One is related to GVN and MemoryDependenceAnalysis and has a pending patch. The other is related to the Correlated Value Propagation and Lazy Value Information cache. Attached is a heap profile for one of the relevant test cases. Looking at the sources, I don't see any

I have noticed that LLVM doesn't seem to "like" large functions, as a general rule. Admittedly, my experience is similar with gcc, so I'm not sure it's something that can be easily fixed. And I'm probably sounding like a broken record, because I have said this before. My experience is that the time it takes to compile something is growing above linear with size of

...ntimately related to the optimization passes. >> >>> I think this is roughly because some function level optimisations are >>> worse than O(N) in the number of instructions. >> >> Please profile this and mail llvmdev regarding passes with >> significantly superlinear behavior (e.g. O(n^2)). My understanding is >> that these kinds of algorithmic problems are generally considered bugs >> in the optimizer and will be fixed. > > > I cannot do that yet, however here's some more info: > > Felix compile time: 5 seconds. > C++ compi...