2

I've been doing some tests with Valgrind to understand how functions are translated by the compiler and have found that, sometimes, functions written on different files perform poorly compared to functions written on the same source file due to not being inlined.

Considering I have different files, each containing functions related to a particular area and all files share a common header declaring all functions, is this expected?

Why doesn't the compiler inline them when they are written on different files but does when they are on the same page?

If this behavior starts to cause performance issues, what is the recommended course of action, put all of the functions on the same file manually before compiling?

example:

//source 1
    void foo(char *str1, char *str2)
    {
        //here goes the code
    }

//source 2
    void *bar(int something, char *somethingElse)
    {
        //bar code
        foo(variableInsideBar, anotherVariableCreatedInsideBar);
        return variableInsideBar;
    }

Sample performance cost:

On different files: 29920

Both on the same file: 8704

For bigger functions it is not as pronounced, but still happens.

Improve this question

3 Answers 3

Reset to default
2

If you are using gcc you should try the options -combine and -fwhole-program and pass all the source files to the compiler in one invocation. Traditionally different C files are compiled separately, but it is becoming more common to optimize cross compilation units (files).

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

The MS version of this options is /gl It's worth noting that on large projects these options can completely destroy iteration times. I don't know about gcc but in the MS tool chain linking is single threaded, so you end up with 30+ minute link times with no means of speeding them up.
1

The compiler proper cannot inline functions defined in different translation units simply because it cannot see the definitions of these functions, i.e. it cannot see the source code for these functions. Historically, C compilers (and the language itself) were built around the principles of independent translation. Each translation unit is compiled from source code into an object code completely independently form other translation units. Only at the very last stage of translation all these disjoint pieces of object code are assembled together into a final program by so called linker. But in a traditional compiler implementation at that point it is already too late to inline anything.

As you probably know, the language-level support for function inlining says that in order for a function to be "inlinable" in some translation unit it has to be defined in that translation unit, i.e. the source code for its body should be visible to the compiler in that translation unit. This requirement stems directly from the aforementioned principle of independent translation.

Many modern compilers are gradually introducing features that overcome the limitations of the classic pure independent translation. They implement features like global optimizations which allow various optimizations that cross the boundaries of translation units. That potentially includes the ability to inline functions defined in other translation units. Consult your compiler documentation in order to see whether it can inline functions across translation units and how to enable this sort of optimizations.

The reason such global optimizations are usually disabled by default is that they can significantly increase the translation time.

Improve this answer

Comments

-1

Wow, how you noticed that. I think that's because then you compile something, at first compiler turn one c file to one object file without looking at any other files. After it made object file, it doesn't apply any optimisations.

I don't think it costs much perfomance.

Improve this answer

2 Comments

It happens, even with optimizations on the highest level, all functions declared on the header, and compiling all at the same time.
Then compiler compiles source to object file, he only look for this one c file, and constants with function declarations from headers. It doesn't know the code of functions used, he only know how to call them, and just leave info for linker to link that function later. It can't inline that code, he doesn't even know it on this stage. You can simply copy it in if you want.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.