La supresión de la advertencia inlining

Question

Me estoy haciendo inling advertencia, tales como:

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

Para librarse de esta he cambiado el makefile la eliminación de la -Winline para deshacerse de este. No consigo ninguna advertencia inline. Pero, no sé qué sabio es que lo haga en relación con el rendimiento. ¿Puede alguien por favor me sugieren al respecto?

añadido algo más de información:

aquí es ª advertencia:

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

y el código correspondiente es:

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

y desde 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

El único "problema" es que usted está tratando de forzar al compilador para hacer algo ineficiente.

Uso ìnline en lugar de __inline__, y respetar las decisiones compiladores sobre lo que debe o no debe ser inline. No trate de forzar, a menos que ya haya perfila el código, nos pareció que es un cuello de botella, y verificó que inlining en realidad acelerar, en lugar de desaceleración, el código.

Esto es esencialmente lo que el aviso que dice: "que me estás pidiendo que haga algo estúpido que había ralentizar el código que voy a ignorarlo".

Y, por supuesto, puede ignorar (o silencio) la advertencia, pero la mejor solución es sólo para no forzarlo a hacer nada estúpido en el primer lugar. No utilice el compilador __inline__-específica, y el uso inline si lo necesita, y confiar en que el compilador para decidir qué línea.

Answer 2

Quitar static __inline__ de la función en el archivo de cabecera y reemplazarlo con inline - C ++ estándar de palabras clave. No debería recibir un aviso con eso.

Answer 3

Me encontré aquí después de compilar un código de edad con -Werror -Winline - una advertencia de que quiero de forma predeterminada, ya que encuentra errores significativos, en las que se han olvidado los operadores de asignación, etc.

.

Sin embargo, para una función particular i absolutamente sí es necesario que sea siempre inline, y por lo tanto que necesitaba una manera de suprimir una advertencia sólo para este bloque de código.

#pragma GCC diagnostic ignored "-Winline"

fue la elección obvia, pero en realidad no suprime esta advertencia. La solución es el uso always_inline atributo:

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

Esto deshacerse de la advertencia y de hecho siempre forzar inlining

Answer 4

No veo un problema con eso!

No debería haber un retraso de rendimiento, según entiendo, coz, los compilador trata de la línea como una función regular!

Vea lo GCC tiene que decir!

-Winline
Advertir si una función no puede ser inline y fue declarado como en línea. Incluso con esta opción, el compilador no le advertirá sobre las fallas a las funciones en línea declaradas en las cabeceras del sistema. El compilador utiliza una variedad de heurística para determinar si o no a una función inline. Por ejemplo, el compilador tiene en cuenta el tamaño de la función que se está inline y la cantidad de procesos en línea que ya se ha hecho en la función actual. Por lo tanto, los cambios aparentemente insignificantes en el programa de origen pueden hacer que las advertencias producidas por -Winline a aparecer o desaparecer.