バイトコードと最適化 Edit

生成されるバイトコードの比較。

組み込み型 vs 組み込み型のラッパークラス Edit

uintとuintをラッパーしたMyUIntクラスの比較。
やはり,組み込み型のほうが圧倒的に軽い。

Everything is expanded.Everything is shortened.
  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
Everything is expanded.Everything is shortened.
  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 メンバ関数コール Edit

非メンバ関数とメンバ関数をコールしたときの比較。
メンバ関数コールの場合,Reference確認をするために,2命令追加されるらしい。

Everything is expanded.Everything is shortened.
  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メンバ関数コール Edit

どちらも変わらないようです。

Everything is expanded.Everything is shortened.
  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メンバ関数 Edit

どちらも一緒。

Everything is expanded.Everything is shortened.
  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オブジェクト参照関数 Edit

どちらも一緒。

Everything is expanded.Everything is shortened.
  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
Everything is expanded.Everything is shortened.
  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
Everything is expanded.Everything is shortened.
  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オブジェクト参照をとる関数コール Edit

やっぱり一緒。ついでにハンドルも比較,それは増えるらしい。
参照カウントを増やすから当たり前か。

Everything is expanded.Everything is shortened.
  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 引数にハンドルをとる関数 Edit

ハンドルを使うと命令が増えるらしい。参照カウント増やすからね。

Everything is expanded.Everything is shortened.
  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

Reload   New Lower page making Edit Freeze Diff Upload Copy Rename   Front page List of pages Search Recent changes Backup Referer   Help   RSS of recent changes
Last-modified: (5032d)