search for: callsites

...gt; Ah, sorry. I missed that you're doing variadic calls, not casting > variadic function to definite ones. I think you can construct CallSite > and then iterate over the arguments grabbing their types and construct > function type after that. > So what do you think about that: // CallSites have equal signatures bool MSILWriter::cmpCallSite(CallSite A, CallSite B) { return (getCallSiteFType(A)==getCallSiteFType(B) && A.getAttributes()==B.getAttributes()); } // Comparision for std::lower_bound used in MSILWriter::printExternals() bool MSILWriter::compareCallSite(CallSite...

LLVM (2.7 release version) provides 2 implementations for inlining function callsites: - InlineSimple.cpp (-inline): inline simple callsites according to its cost analysis - InlineAlways.cpp (-always-inline): inline all callsites that are marked with "always_inline" attribute. They are both subclasses of Inline.cpp that assumes the function's defini...

On Tue, Jul 27, 2010 at 7:46 AM, Chuck Zhao <czhao at eecg.toronto.edu> wrote: >  LLVM (2.7 release version) provides 2 implementations for inlining > function callsites: > > - InlineSimple.cpp (-inline):               inline simple callsites > according to its cost analysis > - InlineAlways.cpp (-always-inline):  inline all callsites that are > marked with "always_inline" attribute. > > They are both subclasses of Inline.cpp that ass...

Hi, Artur > // CallSites have equal signatures > bool MSILWriter::cmpCallSite(CallSite A, CallSite B) { >   return (getCallSiteFType(A)==getCallSiteFType(B) && >     A.getAttributes()==B.getAttributes()); > } As it is impossible to honour argument attributes in MSIL I don't see why you should compar...

Functions in LLVM IR have a function_entry_count metadata that is attached in PGO compilation. By using the entry count together with the block frequency info, the compiler computes the profile count of call instructions based on which the hotness/coldness of callsites can be determined. Experiments have shown that using a higher threshold for hot callsites results in improved runtime performance of the generated code without significant code size increases. We propose to generate synthetic function counts for non-PGO compilation and use the counts for boosting h...

Hi all, There is a problem about how AliasSetTracker merging AliasSet's when meet UnknownInst. When adding new pointer it looks for existing AliasSet's aliased with new pointer. And merging them together. It is ok for pointers: if %A mayalias %B and %B mayalias %C then %A mayalias %C. But the same logic when adding callsite is wrong ( findAliasSetForUnknownInst). Callsite may be known

...function InlineCallPossible(). If the inlining was not performed, the reason for not inlining is recorded in the InlineReportCallSite corresponding to the CallSite. If the inlining was performed, the corresponding InlineReportCallSite is marked as inlined, and it is populated with the InlineReportCallSites corresponding to the newly exposed CallSites that were created during the inlining. The InlineReport is printed during the call to Inliner::doFinalization(). Since the compiler can run any number of optimizations between two successive calls to runOnSCC(), the Instructions corresponding to CallSi...

Hi, Artur > The interesting for me part of the CallInst is printf(i8* noalias %0, i32 > 123). > I was diging in doxygen documentation but I really can't see the easy way to > compare those instructions and again finish with reinvented (but working) > wheel ;). Ah, sorry. I missed that you're doing variadic calls, not casting variadic function to definite ones. I think you

On 7/27/2010 12:40 PM, Devang Patel wrote: > On Tue, Jul 27, 2010 at 7:46 AM, Chuck Zhao<czhao at eecg.toronto.edu> wrote: >> LLVM (2.7 release version) provides 2 implementations for inlining >> function callsites: >> >> - InlineSimple.cpp (-inline): inline simple callsites >> according to its cost analysis >> - InlineAlways.cpp (-always-inline): inline all callsites that are >> marked with "always_inline" attribute. >> >> They are both subcl...

Going to keep this RFC short and to the point: TerminatorInst doesn't pull its weight in the type system. There is essentially a single relevant API -- iterating successors. There is no other interesting aspect shared -- the interface itself just dispatches to specific instructions to be implemented. On the flip side, CallInst and InvokeInst have *massive* amounts of code shared and struggle

Hello, > So, looking for type of callee (not result, but function type!) you'll > obtain the > real "signature" of callee and if you'll strip all pointer cast you'll > obtain the "declaration" (=variadic) type of the callee. Maybe I misunderstood something but I just get the variadic declaration not the real "signature", like this: const

Hello, My team and I noticed that callsite hotness information is not preserved from compile to link step with LTO/thinLTO enabled. As a result, the link step inlining pass remains conservative when inlining callsites known to be hot (ie. without the 'HotCallSiteThreshold' which is set at 3000 by default). There are likely many cross-module inlining opportunities lost this way, and diminishes the benefit of using LTO/thinLTO+PGO together. In general, does LLVM pass profiling information through the IR...

I've been looking at inlining invokes / calls done through statepoints and I want to have a design discussion before I sink too much time into something I'll have to throw away. I'm not actively working on adding inlining support to patchpoints, but I suspect these issues are applicable towards teaching LLVM to inline through patchpoints as well. There are two distinct problems to

%294 = call float bitcast (float (float, float*)* @__gpu_modff to float ( float, i64)*)(float %293, i64 %preg.212.addr.0) as you may know, some gpu backends don't support function call. we need to make sure to inline all functions here. however, Inliner can not figure out that this is a valid callsite in this form. actually, it is. in C words, cast a function and then call should be treat as

...call is a troubling inconsistency that leaves > me unsure which results I can trust and which I cannot. Hi Ben, I just tested the example you gave, and get the same results--one set is empty, the other contains the expected single function. As Andrew mentioned, DSA handles indirect and direct callsites differently, and for direct callsites it's expected that the user simply looks at the function itself to determine what is called. In this example, we only track one callsite in test() since as far as alias analysis goes, the effects of both callsites are same, and we don't need to conside...

...gt; >> Functions in LLVM IR have a function_entry_count metadata that is >> attached in PGO compilation. By using the entry count together with the >> block frequency info, the compiler computes the profile count of call >> instructions based on which the hotness/coldness of callsites can be >> determined. Experiments have shown that using a higher threshold for hot >> callsites results in improved runtime performance of the generated code >> without significant code size increases. We propose to generate synthetic >> function counts for non-PGO compilati...

...s.llvm.org>> wrote: >> >> Hello, >> >> My team and I noticed that callsite hotness information is not >> preserved from compile to link step with LTO/thinLTO enabled. As a result, >> the link step inlining pass remains conservative when inlining callsites >> known to be hot (ie. without the 'HotCallSiteThreshold' which is set at >> 3000 by default). There are likely many cross-module inlining opportunities >> lost this way, and diminishes the benefit of using LTO/thinLTO+PGO together. >> >> >> &gt...

...u to apply (and rewrite my naive code better) and to file the issue to http://llvm.org/bugs/show_bug.cgi?id=7304 I have checked r105528 at this morning. I think the pass must be still cleaned up and rewritten. There are my two proposals for enhancement. 1) To separate Specialization(and rewriting callsites) to other module. It would be better if new module were available from other passes. 2) To separate methods discovering interests. Various (optional) heuristics would be helpful. Also I will help to contribute above someday. I had been afraid to read the discussion http://llvm.org/bugs/show_...

...and did some initial evaluation with clang and some internal benchmarks used at Google. Implementing it as described above resulted in a large size growth when the parameters are chosen to deliver performance improvement. Some ways to control size growth include applying the heuristic only for hot callsites, only for inline functions, and measuring the speedup using both caller and callee time (instead of just the latter). In any case, without profile feedback it is very likely that there is going to be a size increase when this heuristic is triggered on cold modules. With profile feedback, the absolu...

In order to detect whether CallSite is present in innermost loop, do I need to insert logic from LoopInfo pass for collecting loops, within a CallGraphSCC pass?   Is there any other approach for this?   Regards, Pankaj -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20111116/cd9d51b7/attachment.html>