inlining

问题 Do simple lambda expressions get inlined? I have a tendency (thanks to F# and other functional forays) to encapsulate repeated code present within a single function into a lambda, and call it instead. I'm curious if I'm incurring a run-time overhead as a result: var foo = a + b; var bar = a + b; vs Func<T1, T2> op = () => a + b; var foo = op(); var bar = op(); Which one costs more to run? 回答1: No. Lambda functions are not inlined but instead are stored as delegates under the hood and incur

来源： https://stackoverflow.com/questions/64285816/c-sharp-weird-method-inlining-behavior

问题 The Java-Spec guarantees that a given lamda-definition, e.g. () -> "Hello World" , is compiled/converted to exactly one implementation class (every definition, not every occurence that "looks" the same). Is there any way I can force the java-compiler/jvm to generate a new lamda-definition instead of sharing a common one? I am currently implementing a library that weaves multiple function parts into a BiFunction which suffers from mega-morphic call-sites because of the guarantees given by the

问题 Consider a function object F taking a constexpr size_t argument I struct F { template <size_t I> constexpr size_t operator()(size <I>) const { return I; } }; wrapped within a type size <I> , where (for brevity) template <size_t N> using size = std::integral_constant <size_t, N>; Of course, we could pass I directly but I want to emphasize that it is constexpr by using it as a template argument. Function F is dummy here but in reality it could do a variety of useful stuff like retrieving

问题 Why is the "someValue" variable which is readonly (but we still can change its value via reflection) output as "10", although it actually did change to 55? static class Program { static readonly int someValue = 10; static void Main(string[] args) { Console.WriteLine(someValue); // 10 typeof(Program) .GetField("someValue", BindingFlags.Static | BindingFlags.NonPublic) .SetValue(null, 55); // change readonly field via reflection to 55 Console.WriteLine(someValue); // output in console 10, //

问题 I'm trying to produce some "Hello World" size C# code snippet that would incur JIT inlining. So far I have this: class Program { static void Main(string[] args) { Console.WriteLine( GetAssembly().FullName ); Console.ReadLine(); } static Assembly GetAssembly() { return System.Reflection.Assembly.GetCallingAssembly(); } } which I compile as "Release"-"Any CPU" and "Run without debugging" from Visual Studio. It displays the name of my sample program assembly so clearly GetAssembly() is not

问题 I have the first version of a math library completed, and for the next step I'd like to turn to expression templates to improve the performance of the code. However, my initial results are different than I expected. I am compiling in MSVC 2010, in vanilla Release mode (and am okay with C++0x). Apologies in advance for the large amount of code I'll be showing you, it's as minimal as I can make it while letting people look at what I'm doing. Profiling framework: #include <algorithm> #include

问题 Considering that you're trying solely to optimize for speed, what are good heuristics for deciding whether to inline a function or not? Obviously code size should be important, but are there any other factors typically used when (say) gcc or icc is determining whether to inline a function call? Has there been any significant academic work in the area? 回答1: Wikipedia has a few paragraphs about this, with some links at the bottom: In addition to memory size and cache issues, another

问题 I am developing in C using gcc in Linux. I am organizing my small functions in .H and .C files in the following way // .H file extern int my_function( int val ); // .C file inline int my_function( int val ){ // my job..very short! } These functions are small so they are very good candidates to be inlined but I don't know if they will be for sure. I have doubt about the way I cam organizing my file and I was thinking that probably it would be better to have all my functions inlined directly

问题 The gcc documentation contains the following: When a function is both inline and static, if all calls to the function are integrated into the caller, and the function's address is never used, then the function's own assembler code is never referenced. In this case, GCC does not actually output assembler code for the function, unless you specify the option -fkeep-inline-functions. Some calls cannot be integrated for various reasons (in particular, calls that precede the function's definition