Unterdrückende inlining Warnung

Question

Ich erhalte inling Warnung wie:

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

Dies Um loszuwerden änderte ich das Makefile die -Winline Entfernen dieser loszuwerden. Ich erhalte keine inlining Warnung. Aber ich weiß nicht, wie klug ist es in Bezug auf Leistung zu tun. Kann mir jemand bitte vorschlagen darüber?

hinzugefügt einige weitere Informationen:

Hier ist th Warnung:

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

und der entsprechende Code ist:

von 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   }

und von 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

Das einzige „Problem“ ist, dass man die Compiler zu zwingen, ist versucht, etwas ineffizient zu tun.

Verwenden ìnline statt __inline__ und respektieren Sie die Compiler Entscheidungen darüber, was sollte oder nicht inlined werden sollte. Versuchen Sie nicht, um es zu zwingen, es sei denn, Sie den Code bereits profiliert haben, fand es einen Engpass sein, und Nachweis erbracht, dass inlining tatsächlich beschleunigen würde, anstatt langsam nach unten, den Code.

Das ist im Wesentlichen, was die Warnung sagt: „Sie mich fragen, etwas zu tun dumm, die den Code verlangsamen würde ich werde es ignorieren“.

Und sicher, können Sie (oder Stille) die Warnung ignorieren, aber die beste Lösung ist einfach nicht zu zwingen, etwas dumm in erster Linie zu tun. Verwenden Sie nicht den Compiler-spezifischen __inline__ und Verwendung inline, wenn Sie es brauchen, und vertrauen den Compiler zu entscheiden, was zu inline.

Answer 2

Remove static __inline__ aus der Funktion in der Header-Datei und ersetzen Sie es mit inline - das C ++ Standard-Schlüsselwort. Sie sollen nicht eine Warnung mit, dass bekommen.

Answer 3

Ich stolperte hier, nachdem er einigen alten Code mit Werror -Winline Kompilieren - eine Warnung, dass ich standardmäßig will, weil es erhebliche Fehler findet, wo Sie Zuweisungsoperator usw. vergessen haben

.

jedoch für eine bestimmte Funktion ich es unbedingt brauche immer inlined werden, und somit brauchte ich einen Weg, um eine Warnung nur für diesen Codeblock zu unterdrücken.

#pragma GCC diagnostic ignored "-Winline"

war die offensichtliche Wahl, aber es ist tatsächlich unterdrückt diese Warnung nicht. Lösung ist die Verwendung Attribut always_inline:

inline bool function() __attribute__((always_inline));
inline bool function() { /*something*/ };

Dies wird loszuwerden, die Warnung erhalten und eigentlich immer zwingen inlining

Answer 4

Ich sehe nicht ein Problem damit!

Es sollte kein Leistungsverzögerung sein, wie ich sie verstehe, Coz, die Compiler behandelt die Inline als normale Funktion!

Sehen Sie, was GCC zu sagen hat!

-Winline
Warnen, wenn eine Funktion nicht inlined werden kann, und es wurde als inline deklariert. Auch bei dieser Option wird der Compiler nicht über Fehler zu Inline-Funktionen in System-Header erklärt warnen. Der Compiler verwendet eine Vielzahl von Heuristiken, ob oder nicht, um zu bestimmen, eine Funktion inline. Zum Beispiel nimmt der Compiler berücksichtigt die Größe der Funktion inlined wird und die Menge an inlining, dass bereits in der aktuellen Funktion geschehen. Daher scheinbar unbedeutende Änderungen im Quellprogramm können die Warnungen verursachen durch -Winline erzeugt erscheinen oder verschwinden.