inline에 대해서 (최적화)
다음 내용들을 다룹니다.
- 함수에 inline을 명시하는 것의 구체적인 효과 (중복 정의, inline 최적화)
- inline 최적화를 조절하는 방법 (변수, 옵션)
중복 정의
긴 템플릿 함수가 헤더에 있다보니 코드가 보기 안 좋아서, 선언은 클래스 내부에 나두고, 정의는 클래스 외부로 옮겼다.
템플릿 함수다 보니, 정의를 헤더에 둬야 한다. (컴파일 타임에 정의가 필요하기 때문)
class A
{
public:
int Func();
};
int A::Func() { return 0; }
근데 위 코드처럼 클래스 멤버 함수면 클래스 밖에 함수 정의를 둘 경우, 그 헤더를 다른 곳에서 include 하면 정의가 하나 더 생기면서 단일 정의 규칙(One definition rule)을 위반하기 때문에 컴파일 에러가 뜬다.
이런 경우에는 함수에 inline을 명시하면 중복 정의 문제가 해결된다. (클래스 내부에 정의되어 있는 함수들은 자동으로 inline화 된다.)
GCC 코드를 보면, ilnine을 명시하면 COMDAT을 사용하여 여러 번역 단위에서 중복 정의 가능하게 한다.
Github
/* Function literals and functions declared as `pragma(inline, true)' can
appear in multiple translation units. */
if (TREE_CODE (decl) == FUNCTION_DECL
&& (DECL_DECLARED_INLINE_P (decl) || DECL_LAMBDA_FUNCTION_P (decl)))
return d_comdat_linkage (decl);
근데 내 템플릿 함수는 inline을 붙이지 않았는데 중복 정의 문제가 생기지 않았다!
템플릿 함수는 왜 중복 정의 문제가 발생하지 않을까?
컴파일러가 컴파일 중에 모든 번역 단위(Translation Unit) (소스 코드당 하나)를 분석해서 필요로 하는 템플릿 인스턴스들을 확인한다. 그 후, 컴파일러는 그 템플릿 인스턴스들을 생성한다.
(예: foo<int>(5)를 A.cpp와 B.cpp에서 모두 사용하면, 두 번역 단위에서 각각 foo<int>의 인스턴스가 생성된다.)
분명 이런 이유로 동일한 인스턴스들이 여러 개 생기지만! 링킹 과정에서 링커가 동일한 기계어 코드를 가진 템플릿 인스턴스를 하나로 병합한다! 즉, 템플릿 인스턴스는 링커가 중복을 제거하기 때문에 inline이 없어도 괜찮다는 것이다.
inline을 명시하는 것이 인라인 최적화에 미치는 효과
그러면 inline이 템플릿 함수에는 중복 정의 문제 해결 용도로는 필요 없고, 최적화 용도로만 붙이면 되겠네. 위의 코드는 기니깐 inline 붙이지 말아야겠다. 라고 생각했다.
이에 팀원이 얘기했다.
“근데 인라인 최적화는 inline 붙이든 안 붙이든 컴파일러가 판단해서 한다는데?!”
알고 있는 내용이었지만 문득 의문이 들었다.
‘그러면 중복 정의 해결하는 거 아니면 inline을 쓸 필요가 없는 거 아닌가? 어차피 컴파일러가 알아서 하잖아. 에이 그래도 코드에 명시하면 뭔가 최적화에 영향을 주지 않을까?’
inline을 코드에 명시할 때 인라인 최적화에 영향을 주는지, 만약 준다면 어떤 영향을 주는지 궁금해졌다.
인터넷에 검색해 보면 inline을 명시하는 것은 컴파일러에게 ‘힌트’로 작용한다고만 쓰여 있고, 진짜 힌트로 작용하는지, 그 힌트를 어떻게 사용하는지에 대해 잘 안 나왔다.
그래서 오픈소스 컴파일러인 GCC 코드를 찾아보기로 했다.
GCC 코드 분석
Github에 코드가 있었다.
Github
inlining (inline 최적화)
함수 호출을 함수 본문으로 직접 대체하는 최적화 기법
inlining 여부 평가는 휴리스틱하게 진행한다. 그 과정은 주석에 잘 나와있다.
Github
주석 내용 접기/펼치기
Inlining decision heuristics
The implementation of inliner is organized as follows:
inlining heuristics limits
can_inline_edge_p allow to check that particular inlining is allowed
by the limits specified by user (allowed function growth, growth and so
on).
Functions are inlined when it is obvious the result is profitable (such
as functions called once or when inlining reduce code size).
In addition to that we perform inlining of small functions and recursive
inlining.
inlining heuristics
The inliner itself is split into two passes:
pass_early_inlining
Simple local inlining pass inlining callees into current function.
This pass makes no use of whole unit analysis and thus it can do only
very simple decisions based on local properties.
The strength of the pass is that it is run in topological order
(reverse postorder) on the callgraph. Functions are converted into SSA
form just before this pass and optimized subsequently. As a result, the
callees of the function seen by the early inliner was already optimized
and results of early inlining adds a lot of optimization opportunities
for the local optimization.
The pass handle the obvious inlining decisions within the compilation
unit - inlining auto inline functions, inlining for size and
flattening.
main strength of the pass is the ability to eliminate abstraction
penalty in C++ code (via combination of inlining and early
optimization) and thus improve quality of analysis done by real IPA
optimizers.
Because of lack of whole unit knowledge, the pass cannot really make
good code size/performance tradeoffs. It however does very simple
speculative inlining allowing code size to grow by
EARLY_INLINING_INSNS when callee is leaf function. In this case the
optimizations performed later are very likely to eliminate the cost.
pass_ipa_inline
This is the real inliner able to handle inlining with whole program
knowledge. It performs following steps:
1) inlining of small functions. This is implemented by greedy
algorithm ordering all inlinable cgraph edges by their badness and
inlining them in this order as long as inline limits allows doing so.
This heuristics is not very good on inlining recursive calls. Recursive
calls can be inlined with results similar to loop unrolling. To do so,
special purpose recursive inliner is executed on function when
recursive edge is met as viable candidate.
2) Unreachable functions are removed from callgraph. Inlining leads
to devirtualization and other modification of callgraph so functions
may become unreachable during the process. Also functions declared as
extern inline or virtual functions are removed, since after inlining
we no longer need the offline bodies.
3) Functions called once and not exported from the unit are inlined.
This should almost always lead to reduction of code size by eliminating
the need for offline copy of the function.
주석 내용 + 코드 뜯어본 내용으로 정리하면,
can_inline_edge_p : 인라인 최적화를 하기 전에 이 함수를 호출해서, 해당 함수 호출을 인라인해도 구조상으로 안전한지 정적 분석을 하는 함수.
(참고로, 컴파일 속성들을 고려해서 분석하는 can_inline_edge_by_limits_p 라는 함수도 항상 함께 호출된다.)
그 후, 휴리스틱 평가를 통해 인라이닝이 유리한 경우에 수행한다. 휴리스틱 평가는 두 단계로 이뤄진다.
1. pass_early_inlining (local)
early_inliner, early_inline_small_functions
컴파일 유닛에서 명백하게 결정되는 요소들을 inline한다.
- 코드 크기 최소화
- 코드 평탄화
이를 통해 그 이후 단계의 최적화 효과를 증대한다.
2. pass_ipa_inline (global)
ipa_inline, inline_small_functions
전체 프로그램을 분석해서 inline한다.
-
작은 함수 탐욕적(Greedy) 인라이닝
edge_badness (struct cgraph_edge *edge, bool dump)(작다고 정한 기준을 만족하는 함수들을 대상으로 해서 small function) inlining 여부를 판단하는 순서를 탐욕 알고리즘으로 결정한다. 가장 badness(이익 비용 비율의 부정)가 적은 엣지(함수 호출)를 먼저 판단한다. 이를 badness를 key로 사용한 피보나치 힙으로 구현한다. (아마도 inline 한 것이 다른 inlining 평가에 반영되니깐 최적화 확률 높은 것부터 하는 듯?)
- 인라이닝 후 사용되지 않는 함수 제거 (extern inline, devirtualization)
- 단일 호출 함수 인라이닝
피보나치 힙에 대해 접기/펼치기
Wikipedia
(피보나치 힙은 “최대 힙 크기가 n일때, 빈 자료구조부터 시작하여 합쳐서 a개의 삽입연산, 키 감소 연산과 b개의 삭제연산을 임의의 순서대로 수행했을 때 최악의 경우 O(a + b log n) 만큼의 시간이 소요됨을 의미한다. 이진 힙 또는 이항 힙이라면, 이러한 순서의 연산은 O((a + b) log n)의 시간이 소요될 것이다. 그러므로 비상수 요소에 의해 b가 a보다 작을 경우, 피보나치 힙은 이진 힙 또는 이항 힙보다 더 낫다. 두 피보나치 힙을 상수 분할 상환 시간 안에 병합하는 것 또한 가능하다. 이것은 이항 힙의 경우 병합 시간이 O(log n)만큼 소요되는데 이것보다 개선된 것이고, 이진 힙의 경우는 병합을 효율적으로 처리하지 못하는데 이에 비하면 개선된 것이다.” 라고 한다.)
DECL_DECLARED_INLINE_P
함수가 개발자에 의해 명시적으로 인라인 선언되었는지를 저장하는 플래그를 확인하는 매크로다. 이것을 사용하는 부분을 찾아보면 의문을 해결할 수 있을 것이다.
unsigned declared_inline_flag : 1;
/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
such as via the `inline' keyword in C/C++. This flag controls the linkage
semantics of 'inline' */
#define DECL_DECLARED_INLINE_P(NODE) \
(FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
/* Miscellaneous function flags. */
/* In [pragma/inline], functions decorated with `pragma(inline)' affects
whether they are inlined or not. */
if (fd->inlining == PINLINE::always)
DECL_DECLARED_INLINE_P (decl->csym) = 1;
else if (fd->inlining == PINLINE::never)
DECL_UNINLINABLE (decl->csym) = 1;
해당 매크로가 사용된 부분
/* Decide if we can inline the edge and possibly update
inline_failed reason.
We check whether inlining is possible at all and whether
caller growth limits allow doing so. */
static bool
can_inline_edge_by_limits_p (struct cgraph_edge *e, int flags)
{
//...
/* If callee is optimized for size and caller is not, allow inlining if
code shrinks or we are in param_max_inline_insns_single limit and
callee is inline (and thus likely an unified comdat).
This will allow caller to run faster. */
else if (opt_for_fn (callee->decl, optimize_size)
> opt_for_fn (caller->decl, optimize_size))
{
int growth = estimate_edge_growth (e);
if (growth > opt_for_fn (caller->decl, param_max_inline_insns_size)
&& (!DECL_DECLARED_INLINE_P (callee->decl)
&& growth >= MAX (inline_insns_single (caller, false, false),
inline_insns_auto (caller, false, false))))
{
e->inline_failed = CIF_OPTIMIZATION_MISMATCH;
inlinable = false;
}
}
//...
}
이해를 위한 관련 코드들 접기/펼치기
param_max_inline_insns_size
The maximum number of instructions when inlining for size.
/* Return estimated callee growth after inlining EDGE. */
inline int
estimate_edge_growth (struct cgraph_edge *edge)
/* Level of size optimization. */
enum optimize_size_level
{
/* Do not optimize for size. */
OPTIMIZE_SIZE_NO,
/* Optimize for size but not at extreme performance costs. */
OPTIMIZE_SIZE_BALANCED,
/* Optimize for size as much as possible. */
OPTIMIZE_SIZE_MAX
};
can_inline_edge_by_limits_p에서 피호출자를 호출자 함수 안에 inline 최적화할지 결정하는 코드의 일부이다.
- inline 최적화는 코드의 크기과 성능 사이 트레이드오프이다.
- optimize_size는 코드 크기 최적화 레벨을 뜻한다. (높을수록 코드 사이즈를 더 줄이겠다.)
일반적으로 생각했을 때, 피호출자의 코드를 크기를 줄이는 방향으로 최적화를 했을 때도 성능을 우선시하는(코드의 크기 좀 늘어나도 되는) 호출자의 인라인 최대 명령 수 조건 보다 큰 경우 inline할 필요 없다. 그래서 그 내용을 검사한다. 근데 피호출자 함수에 inline을 명시했다면, 이를 존중하여 이 내용과 상관없이 그래도 휴리스틱 평가를 해 보겠다는 것이다.
/* Decide on the inlining. We do so in the topological order to avoid
expenses on updating data structures. */
static bool
early_inline_small_functions (struct cgraph_node *node)
{
//...
for (e = node->callees; e; e = e->next_callee)
{
//...
/* Do not consider functions not declared inline. */
if (!DECL_DECLARED_INLINE_P (callee->decl)
&& !opt_for_fn (node->decl, flag_inline_small_functions)
&& !opt_for_fn (node->decl, flag_inline_functions))
continue;
//...
if (!want_early_inline_function_p (e))
continue;
//...
}
//...
}
/* Return true if we are interested in inlining small function. */
static bool
want_early_inline_function_p (struct cgraph_edge *e)
{
//...
else if (!DECL_DECLARED_INLINE_P (callee->decl)
&& !opt_for_fn (e->caller->decl, flag_inline_small_functions))
{
e->inline_failed = CIF_FUNCTION_NOT_INLINE_CANDIDATE;
report_inline_failed_reason (e);
want_inline = false;
}
//...
}
/* Return true if we are interested in inlining small function.
When REPORT is true, report reason to dump file. */
static bool
want_inline_small_function_p (struct cgraph_edge *e, bool report)
{
//...
else if (!DECL_DECLARED_INLINE_P (callee->decl)
&& !opt_for_fn (e->caller->decl, flag_inline_small_functions))
{
e->inline_failed = CIF_FUNCTION_NOT_INLINE_CANDIDATE;
want_inline = false;
}
//...
}
flag_inline_functions, flag_inline_small_functions 인라인 최적화 옵션을 쓰지 않았더라도 inline을 명시했다면 다음 검사로 넘어간다.
(inline 명시하는 것이 이 함수에서 flag_inline_functions과 flag_inline_small_functions 옵션을 쓴 것과 같은 역할을 한다.)
/* Return true if we are interested in inlining small function.
When REPORT is true, report reason to dump file. */
static bool
want_inline_small_function_p (struct cgraph_edge *e, bool report)
{
/* Do fast and conservative check if the function can be good
inline candidate. */
else if ((!DECL_DECLARED_INLINE_P (callee->decl)
&& (!e->count.ipa ().initialized_p () || !e->maybe_hot_p ()))
&& ipa_fn_summaries->get (callee)->min_size
- ipa_call_summaries->get (e)->call_stmt_size
> inline_insns_auto (e->caller, true, true))
{
e->inline_failed = CIF_MAX_INLINE_INSNS_AUTO_LIMIT;
want_inline = false;
}
}
(hot하다는 건 자주 호출한다는 것),
자주 호출 안 되고, inline 비명시인데 자동 인라인 최대 명령 값을 초과하면 inline 최적화 하지 않는다. 몇몇 최적화 변수가 inline 명시 여부(auto)에 따라 나뉘어져 있다.
이외에도 최적화 변수 auto 구분 관련 코드들이 있다.
접기/펼치기
/* EDGE is self recursive edge.
We handle two cases - when function A is inlining into itself
or when function A is being inlined into another inliner copy of function
A within function B.
In first case OUTER_NODE points to the toplevel copy of A, while
in the second case OUTER_NODE points to the outermost copy of A in B.
In both cases we want to be extra selective since
inlining the call will just introduce new recursive calls to appear. */
static bool
want_inline_self_recursive_call_p (struct cgraph_edge *edge,
struct cgraph_node *outer_node,
bool peeling,
int depth)
{
//...
int max_depth = opt_for_fn (outer_node->decl,
param_max_inline_recursive_depth_auto);
if (DECL_DECLARED_INLINE_P (edge->caller->decl))
max_depth = opt_for_fn (outer_node->decl,
param_max_inline_recursive_depth);
//...
}
/* Return true if WHERE of SIZE is a possible candidate for wrapper heuristics
in estimate_edge_badness. */
static bool
wrapper_heuristics_may_apply (struct cgraph_node *where, int size)
{
return size < (DECL_DECLARED_INLINE_P (where->decl)
? inline_insns_single (where, false, false)
: inline_insns_auto (where, false, false));
}
/* Decide on recursive inlining: in the case function has recursive calls,
inline until body size reaches given argument. If any new indirect edges
are discovered in the process, add them to *NEW_EDGES, unless NEW_EDGES
is NULL. */
static bool
recursive_inlining (struct cgraph_edge *edge,
vec<cgraph_edge *> *new_edges)
{
//...
int limit = opt_for_fn (to->decl,
param_max_inline_insns_recursive_auto);
if (DECL_DECLARED_INLINE_P (node->decl))
limit = opt_for_fn (to->decl, param_max_inline_insns_recursive);
//...
}
결론
컴파일러마다 다르겠지만 GCC는
- inline을 명시하는 것은 인라인 최적화에 영향을 준다.
- 어떤 영향을 주는가?
- inline을 명시하면 컴파일러가 이를 존중해서 좀 더 최적화 검사에 관대해진다. (일부 검사에서 이득이 없다고 판단해도 inline이 명시되어 있으면 다음 검사로 넘기는 부분이 있다.)
- 일부 최적화 플래그 옵션을 킨 것과 같은 역할이 된다. (flag_inline_functions, flag_inline_small_functions )
- 몇몇 최적화 변수가 inline 명시 여부에 따라 나뉘어져 있다 ( 예 : param_max_inline_insns_auto, param_max_inline_insns_recursive_auto, param_max_inline_recursive_depth_auto)
- inline 무분별하게 쓴다면, 초기 단계에서 탈락할 수 있는 후보들을 더 검사해야 해서 컴파일 시간이 증가할 수 있다.
컴파일 변수, 옵션을 잘 조절해서 성능과 크기 사이에 더 중요한 것을 챙길 수 있겠다!
(뭔가 요즘 게임은 용량보다 성능이라 현업에서 inline에 대해서는 최적화 레벨을 높일 것 같다. 궁금하네)
최적화 조절 (변수, 옵션)
최적화 변수
inline 관련된 최적화 변수들은 이런 것들이 있다.
접기/펼치기
-param=max-inline-functions-called-once-loop-depth=
Common Joined UInteger Var(param_inline_functions_called_once_loop_depth) Init(6) Optimization Param
Maximum loop depth of a call which is considered for inlining functions called once.
-param=max-inline-functions-called-once-insns=
Common Joined UInteger Var(param_inline_functions_called_once_insns) Init(4000) Optimization Param
Maximum combined size of caller and callee which is inlined if callee is called once.
-param=max-inline-insns-auto=
Common Joined UInteger Var(param_max_inline_insns_auto) Init(15) Optimization Param
The maximum number of instructions when automatically inlining.
-param=max-inline-insns-recursive=
Common Joined UInteger Var(param_max_inline_insns_recursive) Optimization Init(450) Param
The maximum number of instructions inline function can grow to via recursive inlining.
-param=max-inline-insns-recursive-auto=
Common Joined UInteger Var(param_max_inline_insns_recursive_auto) Optimization Init(450) Param
The maximum number of instructions non-inline function can grow to via recursive inlining.
-param=max-inline-insns-single=
Common Joined UInteger Var(param_max_inline_insns_single) Optimization Init(70) Param
The maximum number of instructions in a single function eligible for inlining.
-param=max-inline-insns-size=
Common Joined UInteger Var(param_max_inline_insns_size) Optimization Param
The maximum number of instructions when inlining for size.
-param=max-inline-insns-small=
Common Joined UInteger Var(param_max_inline_insns_small) Optimization Param
The maximum number of instructions when automatically inlining small functions.
-param=max-inline-recursive-depth=
Common Joined UInteger Var(param_max_inline_recursive_depth) Optimization Init(8) Param
The maximum depth of recursive inlining for inline functions.
-param=max-inline-recursive-depth-auto=
Common Joined UInteger Var(param_max_inline_recursive_depth_auto) Optimization Init(8) Param
The maximum depth of recursive inlining for non-inline functions.
-param=early-inlining-insns=
Common Joined UInteger Var(param_early_inlining_insns) Init(6) Optimization Param
Maximal estimated growth of function body caused by early inlining of single call.
-param=max-early-inliner-iterations=
Common Joined UInteger Var(param_early_inliner_max_iterations) Init(1) Param Optimization
The maximum number of nested indirect inlining performed by early inliner.
이 값들로 성능 vs 크기에서 성능 중시 가능.
-param=inline-heuristics-hint-percent=
Common Joined UInteger Var(param_inline_heuristics_hint_percent) Init(200) Optimization IntegerRange(100, 1000000) Param
The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable.
-param=inline-min-speedup=
Common Joined UInteger Var(param_inline_min_speedup) Init(30) Optimization IntegerRange(0, 100) Param
The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.
/* Return inlining_insns_single limit for function N. If HINT or HINT2 is true
scale up the bound. */
static int
inline_insns_single (cgraph_node *n, bool hint, bool hint2)
{
if (hint && hint2)
{
int64_t spd = opt_for_fn (n->decl, param_inline_heuristics_hint_percent);
spd = spd * spd;
if (spd > 1000000)
spd = 1000000;
return opt_for_fn (n->decl, param_max_inline_insns_single) * spd / 100;
}
if (hint || hint2)
return opt_for_fn (n->decl, param_max_inline_insns_single)
* opt_for_fn (n->decl, param_inline_heuristics_hint_percent) / 100;
return opt_for_fn (n->decl, param_max_inline_insns_single);
}
/* Return inlining_insns_auto limit for function N. If HINT or HINT2 is true
scale up the bound. */
static int
inline_insns_auto (cgraph_node *n, bool hint, bool hint2)
{
int max_inline_insns_auto = opt_for_fn (n->decl, param_max_inline_insns_auto);
if (hint && hint2)
{
int64_t spd = opt_for_fn (n->decl, param_inline_heuristics_hint_percent);
spd = spd * spd;
if (spd > 1000000)
spd = 1000000;
return max_inline_insns_auto * spd / 100;
}
if (hint || hint2)
return max_inline_insns_auto
* opt_for_fn (n->decl, param_inline_heuristics_hint_percent) / 100;
return max_inline_insns_auto;
}
hint는 간접 호출이거나, hot이거나, 반복문일 때 true
최적화 옵션
컴파일 시 사용하는 최적화 옵션에는 -01, -02, -03이 있다.
g++ -O1 -o program source.cpp 이런 식으로 컴파일한다. (-o 는 output)
이에 따른 최적화 변수의 기본 값들이 gcc 코드에 있다.
Github
접기/펼치기
static const struct default_options default_options_table[] =
{
/* -O1 and -Og optimizations. */
{ OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fipa_reference_addressable, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_freorder_blocks, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fthread_jumps, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_coalesce_vars, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fvar_tracking, NULL, 1 },
/* -O1 (and not -Og) optimizations. */
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbit_tests, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbranch_count_reg, NULL, 1 },
#if DELAY_SLOTS
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fdelayed_branch, NULL, 1 },
#endif
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fdse, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion2, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fjump_tables, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_invariants, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_stores, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fssa_phiopt, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fipa_modref, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_dse, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_pta, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
/* -O2 and -Os optimizations. */
{ OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fcode_hoisting, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fext_dce, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_bit_cp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_icf, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_ra, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_vrp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_flra_remat, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
#ifdef INSN_SCHEDULING
{ OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
#endif
{ OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fstore_merging, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_tail_merge, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fvect_cost_model_, NULL,
VECT_COST_MODEL_VERY_CHEAP },
{ OPT_LEVELS_2_PLUS, OPT_finline_functions, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_foptimize_crc, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_flate_combine_instructions, NULL, 1 },
/* -O2 and above optimizations, but not -Os or -Og. */
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_functions, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_jumps, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_labels, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_loops, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_freorder_blocks_algorithm_, NULL,
REORDER_BLOCKS_ALGORITHM_STC },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_ftree_loop_vectorize, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_ftree_slp_vectorize, NULL, 1 },
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fopenmp_target_simd_clone_, NULL,
OMP_TARGET_SIMD_CLONE_NOHOST },
#ifdef INSN_SCHEDULING
/* Only run the pre-regalloc scheduling pass if optimizing for speed. */
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
#endif
/* -O3 and -Os optimizations. */
/* -O3 optimizations. */
{ OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_floop_interchange, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_floop_unroll_and_jam, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fpeel_loops, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fsplit_loops, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fsplit_paths, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribution, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
{ OPT_LEVELS_3_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_DYNAMIC },
{ OPT_LEVELS_3_PLUS, OPT_fversion_loops_for_strides, NULL, 1 },
/* -O3 parameters. */
{ OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_auto_, NULL, 30 },
{ OPT_LEVELS_3_PLUS, OPT__param_early_inlining_insns_, NULL, 14 },
{ OPT_LEVELS_3_PLUS, OPT__param_inline_heuristics_hint_percent_, NULL, 600 },
{ OPT_LEVELS_3_PLUS, OPT__param_inline_min_speedup_, NULL, 15 },
{ OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_single_, NULL, 200 },
/* -Ofast adds optimizations to -O3. */
{ OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
{ OPT_LEVELS_FAST, OPT_fallow_store_data_races, NULL, 1 },
{ OPT_LEVELS_FAST, OPT_fsemantic_interposition, NULL, 0 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
-01 일 때는,
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
OPT_finline_functions_called_once : 단일 호출 함수 인라인 (웬만해서 원본 함수 제거되면 코드 크기 감소 + 성능 증가)
-02 일 때는,
{ OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_finline_functions, NULL, 1 },
OPT_findirect_inlining : 간접 호출(함수 포인터)를 분석해서 인라인 최적화 후보로 고려함
OPT_finline_small_functions : 작은 함수 인라인 처리
OPT_fpartial_inlining : 함수 일부만 인라인하는 기법 사용
OPT_finline_functions : 함수 인라인 처리
-03 일 때는,
{ OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_auto_, NULL, 30 },
{ OPT_LEVELS_3_PLUS, OPT__param_early_inlining_insns_, NULL, 14 },
{ OPT_LEVELS_3_PLUS, OPT__param_inline_heuristics_hint_percent_, NULL, 600 },
{ OPT_LEVELS_3_PLUS, OPT__param_inline_min_speedup_, NULL, 15 },
{ OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_single_, NULL, 200 },
OPT__param_max_inline_insns_auto_ : 자동 인라인 대상에 적합한 최대 명령어 수 (기본값 15)
OPT__param_early_inlining_insns_ : early inline에 적합한 최대 명령어 수 (기본값 6)
OPT__param_inline_heuristics_hint_percent_ : inline_insns_single, inline_insns_auto 값을 증가시키는 값이다. 간접 호출, 많이 호출, 반복문 등이면 더 크게 증가시킨다. (기본값 200)
OPT__param_inline_min_speedup_ : 인라인에 적합한 최소 성능 향상치 (기본값 30)
OPT__param_max_inline_insns_single_ : 인라인에 적합한 단일 함수의 최대 명령어 수 (기본값 70)
Leave a comment