Question

I am getting inling warning such as :

  warning: inlining failed in call to ‘symbol_Arity’: call is unlikely and code size would grow

To get rid of this i changed the makefile removing the -Winline to get rid of this. I don’t get any inlining warning. But , i don’t know how wise is it to do in respect of performance. Can anybody please suggest me about it?

Added some more information:

here is th warning:

search.c: In function ‘prfs_InsertInSortTheories’:
list.h:254: warning: inlining failed in call to ‘list_Delete’: call is unlikely and code size would grow
search.c:187: warning: called from here
list.h:254: warning: inlining failed in call to ‘list_Delete’: call is unlikely and code size would grow
search.c:189: warning: called from here

and the corresponding code is:

from list.h

254 static __inline__ void list_Delete(LIST L)
255 {
256   LIST Current;
257 
258   Current = L;
259   while (!list_Empty(Current)) {
260     L = list_Cdr(L);
261     list_Free(Current);
262     Current = L;
263   }

and from search.c

 176     LIST    approx;
 177     l = clause_Length(Clause);
 178     for (i = clause_FirstSuccedentLitIndex(Clause); i < l; i++) {
 179       lit = clause_GetLiteral(Clause,i);
 180       if (clause_LiteralIsMaximal(lit) &&
 181           symbol_IsBaseSort(term_TopSymbol(clause_LiteralSignedAtom(lit)))) {
 182         if (prfs_DynamicSortTheory(Search) != (SORTTHEORY)NULL
 183             && clause_NumOfSuccLits(Clause) == 1 &&
 184             clause_NumOfAnteLits(Clause) == 0)
 185           {
 186           copy = clause_Copy(Clause);
 187           list_Delete(clause_ParentClauses(copy));
 188           clause_SetParentClauses(copy,list_Nil());
 189           list_Delete(clause_ParentLiterals(copy));
 190           clause_SetParentLiterals(copy,list_Nil());
 191           clause_SetNumber(copy,clause_Number(Clause));
 192           sort_TheoryInsertClause(prfs_DynamicSortTheory(Search),Clause,
 193                                   copy,clause_GetLiteral(copy,i));
 194         }

Answer 1

The only “problem” is that you’re trying to force the compiler to do something inefficient.

Use ìnline rather than __inline__, and respect the compilers decisions on what should or should not be inlined. Don’t try to force it, unless you’ve already profiled the code, found it to be a bottleneck, and verified that inlining would actually speed up, rather than slow down, the code.

That’s essentially what the warning is saying: “you’re asking me to do something stupid that’d slow down the code. I’m going to ignore it”.

And sure, you can ignore (or silence) the warning, but the best solution is just to not force it to do anything stupid in the first place. Don’t use the compiler-specific __inline__, and use inline if you need it, and trust the compiler to decide what to inline.