|
バイトコードと最適化 
生成されるバイトコードの比較。
組み込み型 vs 組み込み型のラッパークラス
uintとuintをラッパーしたMyUIntクラスの比較。
やはり，組み込み型のほうが圧倒的に軽い。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
-
|
-
|
!
|
!
-
|
|
!
| class MyUInt
{
MyUInt( const uint& in aVal )
{
this.mVal = aVal;
}
uint mVal;
};
void cla()
{
MyUInt i(0);
i.mVal += 1;
}
Temps: 2, 3
0 0 * PUSH 3
- 12,5 -
1 3 * SUSPEND
2 3 * VAR v1
3 4 * SetV4 v2, 0x0 (i:0, f:0)
5 4 * VAR v2
6 5 * GETREF 0
7 5 * GETREF 1
8 5 * ALLOC 0xa8cebf8, 66
- 13,5 -
11 3 * SUSPEND
12 3 * PSF v1
13 4 * CHKREF
14 4 * RDS4
15 4 * ADDSi 16
17 4 * PopRPtr
18 3 * RDR4 v2
19 3 * ADDIi v2, v2, 1
22 3 * WRTV4 v2
- 14,2 -
23 3 * SUSPEND
24 3 * PSF v1
25 4 * FREE 0xa8cebf8
27 3 * 0:
27 0 * RET 0
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
-
|
|
!
| void sca()
{
uint i = 0;
i += 1;
}
Temps: 2
0 0 * PUSH 2
- 18,5 -
1 2 * SUSPEND
2 2 * SetV4 v1, 0x0 (i:0, f:0)
- 19,5 -
4 2 * SUSPEND
5 2 * ADDIi v1, v1, 1
- 20,2 -
8 2 * SUSPEND
9 2 * 0:
9 0 * RET 0
|
非メンバ関数コール vs メンバ関数コール
非メンバ関数とメンバ関数をコールしたときの比較。
メンバ関数コールの場合，Reference確認をするために，２命令追加されるらしい。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
-
|
-
!
!
-
!
-
|
|
|
|
|
|
!
| class Class
{
void classFunc()
{
}
};
void func()
{
}
void main()
{
Class obj;
obj.classFunc();
func();
}
Temps: (main関数)
0 0 * PUSH 1
- 72,5 -
1 1 * SUSPEND
2 1 * PSF v1
3 2 * ALLOC 0xa8c3958, 60
- 74,5 -
6 1 * SUSPEND
7 1 * PSF v1
8 2 * CHKREF
9 2 * RDS4
10 2 * CALL 58 (void Class::classFunc())
- 76,5 -
12 1 * SUSPEND
13 1 * CALL 63 (void func())
- 78,2 -
15 1 * SUSPEND
16 1 * PSF v1
17 2 * FREE 0xa8c3958
19 1 * 0:
19 0 * RET 0
|
constメンバ関数コール vs 非constメンバ関数コール
どちらも変わらないようです。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
-
|
-
!
|
-
!
!
-
|
|
|
|
|
!
| class Class
{
void classFunc()
{
}
void classConstFunc()const
{
}
};
void main()
{
Class obj;
obj.classFunc();
obj.classConstFunc();
}
Temps: (main関数)
0 0 * PUSH 1
- 72,5 -
1 1 * SUSPEND
2 1 * PSF v1
3 2 * ALLOC 0xa8c7c48, 60
- 74,5 -
6 1 * SUSPEND
7 1 * PSF v1
8 2 * CHKREF
9 2 * RDS4
10 2 * CALL 58 (void Class::classFunc())
- 76,5 -
12 1 * SUSPEND
13 1 * PSF v1
14 2 * CHKREF
15 2 * RDS4
16 2 * CALL 59 (void Class::classConstFunc())
- 77,2 -
18 1 * SUSPEND
19 1 * PSF v1
20 2 * FREE 0xa8c7c48
22 1 * 0:
22 0 * RET 0
|
}}
constメンバ関数 vs 非constメンバ関数
どちらも一緒。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
-
|
-
!
|
-
!
!
| class Class
{
void classFunc()
{
}
void classConstFunc()const
{
}
};
Class::classFunc() :
0 0 * PshV4 v0
1 1 * CALLSYS 16 (void ?::?())
- 44,6 -
3 0 * SUSPEND
4 0 * 0:
4 0 * PSF v0
5 1 * FREE 0xa8c3958
7 0 * RET 1
Class::classConstFunc() :
0 0 * PshV4 v0
1 1 * CALLSYS 16 (void ?::?())
- 47,6 -
3 0 * SUSPEND
4 0 * 0:
4 0 * PSF v0
5 1 * FREE 0xa8c3958
7 0 * RET 1
|
引数にオブジェクト参照関数 vs 引数のconstオブジェクト参照関数
どちらも一緒。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
-
!
-
!
| void funcRef( Class& obj )
{
}
void funcConstRef( const Class& obj )
{
}
void funcRef( Class& obj ):
- 71,2 -
0 0 * SUSPEND
1 0 * 0:
1 0 * RET 1
void funcConstRef( const Class& obj ):
- 75,2 -
0 0 * SUSPEND
1 0 * 0:
1 0 * RET 1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
-
|
!
-
|
!
| void funcRef( Class& obj )
{
obj.classConstFunc();
}
void funcConstRef( const Class& obj )
{
obj.classConstFunc();
}
void funcRef( Class& obj ) :
- 71,5 -
0 0 * SUSPEND
1 0 * PSF v0
2 1 * CHKREF
3 1 * RDS4
4 1 * CALL 59 (void Class::classConstFunc())
- 72,2 -
6 0 * SUSPEND
7 0 * 0:
7 0 * RET 1
void funcConstRef( const Class& obj ) :
- 76,5 -
0 0 * SUSPEND
1 0 * PSF v0
2 1 * CHKREF
3 1 * RDS4
4 1 * CALL 59 (void Class::classConstFunc())
- 77,2 -
6 0 * SUSPEND
7 0 * 0:
7 0 * RET 1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
-
|
!
| void funcRef( Class& obj )
{
obj.classFunc();
}
void funcRef( Class& obj ) :
- 71,5 -
0 0 * SUSPEND
1 0 * PSF v0
2 1 * CHKREF
3 1 * RDS4
4 1 * CALL 58 (void Class::classFunc())
- 72,2 -
6 0 * SUSPEND
7 0 * 0:
7 0 * RET 1
|
引数にオブジェクト参照をとる関数コール vs 引数にconstオブジェクト参照をとる関数コール
やっぱり一緒。ついでにハンドルも比較，それは増えるらしい。
参照カウントを増やすから当たり前か。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
-
!
-
!
-
!
-
|
|
|
|
|
|
|
|
!
| void funcRef( Class& obj )
{
}
void funcConstRef( const Class& obj )
{
}
void funcHandle( Class@ obj )
{
}
void main()
{
Class obj;
funcRef( obj );
funcConstRef( obj );
funcHandle( @obj );
}
Temps: 2
0 0 * PUSH 2
- 84,5 -
1 2 * SUSPEND
2 2 * PSF v1
3 3 * ALLOC 0xa8c7768, 60
- 86,5 -
6 2 * SUSPEND
7 2 * PSF v1
8 3 * CHKREF
9 3 * RDS4
10 3 * CALL 65 (void funcRef(Class&inout))
- 88,5 -
12 2 * SUSPEND
13 2 * PSF v1
14 3 * CHKREF
15 3 * RDS4
16 3 * CALL 66 (void funcConstRef(const Class&inout))
- 90,5 -
18 2 * SUSPEND
19 2 * PSF v1
20 3 * CHKREF
21 3 * RDS4
22 3 * PSF v2
23 4 * REFCPY 0xa8c7768
25 3 * POP 1
26 2 * VAR v2
27 3 * GETOBJ 0
28 3 * CALL 67 (void funcHandle(Class@))
- 92,2 -
30 2 * SUSPEND
31 2 * PSF v1
32 3 * FREE 0xa8c7768
34 2 * 0:
34 0 * RET 0
|
引数に参照オブジェクトをとる関数 vs 引数にハンドルをとる関数
ハンドルを使うと命令が増えるらしい。参照カウント増やすからね。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
-
!
-
!
| void funcRef( Class& obj )
{
}
void funcHandle( Class@ obj )
{
}
void funcRef( Class& obj ) :
- 71,2 -
0 0 * SUSPEND
1 0 * 0:
1 0 * RET 1
void funcHandle( Class@ obj ) :
- 75,2 -
0 0 * SUSPEND
1 0 * 0:
1 0 * PSF v0
2 1 * FREE 0xa8c76a0
4 0 * RET 1
|
|
![[PukiWiki]](image/pukiwiki.png "[PukiWiki]")
