Soppressione avvertimento inlining

Question

Io sono sempre inling avvertimento come ad esempio:

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

Per sbarazzarsi di questo ho cambiato il makefile di rimuovere il -Winline per sbarazzarsi di questo. Non ottengo alcun preavviso inlining. Ma, io non so come saggio è di fare in materia di prestazioni. Qualcuno può per favore mi suggerisce a questo proposito?

Aggiunta qualche informazione in più:

qui è esimo avvertimento:

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

e il codice corrispondente è:

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

e da 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

L'unico "problema" è che si sta cercando di forzare il compilatore di fare qualcosa di inefficiente.

Usa ìnline piuttosto che __inline__, e rispettare le decisioni compilatori su ciò che dovrebbe o non dovrebbe essere inline. Non cercare di forzare, a meno che non hai già profilato il codice, trovato ad essere un collo di bottiglia, e ha verificato che inlining sarebbe effettivamente accelerare, piuttosto che rallentare, il codice.

Questo è essenzialmente ciò che l'avviso sta dicendo: "mi stai chiedendo di fare qualcosa di stupido che sarebbe rallentare il codice che ho intenzione di ignorarlo".

E certo, è possibile ignorare (o il silenzio) l'avvertimento, ma la soluzione migliore è solo quello di non costringerlo a fare niente di stupido, in primo luogo. Non utilizzare il compilatore __inline__-specifici, e l'uso inline se ne avete bisogno, e la fiducia al compilatore di decidere cosa in linea.

Answer 2

Rimuovi static __inline__ dalla funzione nel file di intestazione e sostituirlo con inline - la parola chiave C ++ standard. Non si dovrebbe ottenere un avvertimento con quello.

Answer 3

mi sono imbattuto qui dopo la compilazione di qualche vecchio codice con -Werror -Winline - un avvertimento che voglio per impostazione predefinita perché trova errori significativi, in cui avete dimenticato operatori di assegnazione etc

.

Tuttavia, per una particolare funzione assolutamente lo hanno bisogno di essere sempre inlined, e quindi avevo bisogno di un modo per sopprimere un avvertimento proprio per questo blocco di codice.

#pragma GCC diagnostic ignored "-Winline"

È stata la scelta più ovvia, ma in realtà non sopprimere questo avvertimento. Soluzione è quella di attributo uso always_inline:

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

Questo permetterà di eliminare il messaggio di avviso e in realtà sempre forzare inlining

Answer 4

Non vedo un problema con quello!

Non ci dovrebbe essere un ritardo di prestazioni, a quanto ho capito, coz, il compilatore considera la linea in funzione regolare!

Vedere che cosa GCC ha da dire!

-Winline
Avvisa se una funzione non può essere inline ed è stato dichiarato come inline. Anche con questa opzione, il compilatore non mettere in guardia sui fallimenti per le funzioni inline dichiarate nelle intestazioni di sistema. Il compilatore utilizza una varietà di euristiche per determinare se all'inline una funzione. Ad esempio, il compilatore tiene conto delle dimensioni della funzione che sia allineata e la quantità di incorporamento che è già stato fatto nella funzione corrente. Pertanto, i cambiamenti apparentemente insignificanti nel programma sorgente possono provocare gli avvertimenti prodotte da -Winline di apparire o scomparire.