6

抽象型によってサポートされるポリモーフィズムを使用した数値最適化のためのオブジェクト指向 Fortran コードを開発しています。これは TDD の優れた実践であるため、抽象型 ですべての最適化テストを記述しようとしていclass(generic_optimizer)ますtype(newton_raphson)。

すべての最適化テストは への呼び出しを特徴としてcall my_problem%solve(...)おり、これは抽象型として定義されdeferredており、もちろん派生型ごとに異なる実装を特徴としています。

問題は、各非抽象クラスで遅延関数を として定義するとnon_overridable、次のようなセグメンテーション違反が発生することです。

Program received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()

(gdb) where
#0  0x0000000000000000 in ?? ()
#1  0x0000000000913efe in __newton_raphson_MOD_nr_solve ()
#2  0x00000000008cfafa in MAIN__ ()
#3  0x00000000008cfb2b in main ()
#4  0x0000003a3c81ed5d in __libc_start_main () from /lib64/libc.so.6
#5  0x00000000004048f9 in _start ()

non_overridable試行錯誤の末、宣言を削除するとエラーを回避できることに気付きました。この場合、それは問題ではありませんが、このコードでは 2 つのレベルのポリモーフィズムが発生する可能性が低いため、強制したかったのです。代わりに、標準の要件に違反していましたか?

エラーを再現するサンプルコードを次に示します。gfortran 5.3.0 および 6.1.0 でテストしています。

module generic_type_module
    implicit none
    private

    type, abstract, public :: generic_type
        real(8) :: some_data
        contains
        procedure (sqrt_interface), deferred :: square_root
        procedure, non_overridable           :: sqrt_test
    end type generic_type

    abstract interface
       real(8) function sqrt_interface(this,x) result(sqrtx)
          import generic_type
          class(generic_type), intent(in) :: this
          real(8), intent(in) :: x
       end function sqrt_interface
    end interface

    contains

    subroutine sqrt_test(this,x)
        class(generic_type), intent(in) :: this
        real(8), intent(in) :: x
        print *, 'sqrt(',x,') = ',this%square_root(x)
    end subroutine sqrt_test

end module generic_type_module

module actual_types_module
    use generic_type_module
    implicit none
    private

    type, public, extends(generic_type) :: crashing
       real(8) :: other_data
       contains
       procedure, non_overridable :: square_root => crashing_square_root
    end type crashing
    type, public, extends(generic_type) :: working
       real(8) :: other_data
       contains
       procedure :: square_root => working_square_root
    end type working

    contains

    real(8) function crashing_square_root(this,x) result(sqrtx)
       class(crashing), intent(in) :: this
       real(8), intent(in) :: x
       sqrtx = sqrt(x)
    end function crashing_square_root
    real(8) function working_square_root(this,x) result(sqrtx)
       class(working), intent(in) :: this
       real(8), intent(in) :: x
       sqrtx = sqrt(x)
    end function working_square_root

end module actual_types_module

program deferred_test
    use actual_types_module
    implicit none
    type(crashing) :: crashes
    type(working)  :: works

    call works%sqrt_test(2.0_8)
    call crashes%sqrt_test(2.0_8)

end program
4

1 に答える 1

1

問題を絞り込むために、OPのコードから抽象属性とデータメンバーを削除して、

module types
    implicit none

    type :: Type1
    contains
        procedure :: test
        procedure :: square => Type1_square
    endtype

    type, extends(Type1) :: Type2
    contains
       procedure, non_overridable :: square => Type2_square
    endtype

contains

    subroutine test( this, x )
        class(Type1) :: this
        real :: x
        print *, "square(", x, ") = ",this % square( x )
    end subroutine

    function Type1_square( this, x ) result( y )
       class(Type1) :: this
       real :: x, y
       y = -100      ! dummy
    end function

    function Type2_square( this, x ) result( y )
       class(Type2) :: this
       real :: x, y
       y = x**2
    end function

end module

program main
    use types
    implicit none
    type(Type1) :: t1
    type(Type2) :: t2

    call t1 % test( 2.0 )
    call t2 % test( 2.0 )
end program

このコードでは、gfortran-6 は

square(   2.00000000     ) =   -100.000000
square(   2.00000000     ) =   -100.000000

一方、ifort-{14,16} および Oracle fortran 12.5 は

square(   2.000000     ) =   -100.0000    
square(   2.000000     ) =    4.000000

また、関数をサブルーチンに置き換えてみました (どのルーチンが実際に呼び出されたかを表示するため):

    subroutine test( this, x )
        class(Type1) :: this
        real :: x, y
        call this % square( x, y )
        print *, "square(", x, ") = ", y
    end subroutine

    subroutine Type1_square( this, x, y )
        class(Type1) :: this
        real :: x, y
        print *, "Type1_square:"
        y = -100      ! dummy
    end subroutine

    subroutine Type2_square( this, x, y )
        class(Type2) :: this
        real :: x, y
        print *, "Type2_square:"
        y = x**2
    end subroutine

他のすべての部分は同じままです。次に、gfortran-6 は

Type1_square:
square(   2.00000000     ) =   -100.000000    
Type1_square:
square(   2.00000000     ) =   -100.000000

一方、ifort-{14,16} および Oracle fortran 12.5 は

Type1_square:
square(   2.000000     ) =   -100.0000    
Type2_square:
square(   2.000000     ) =    4.000000

上記のコードから削除するnon_overridableと、gfortran は他のコンパイラと同じ結果を返します。したがって、これは gfortran + に固有の問題である可能性がありますnon_overridable(上記のコードが標準に準拠している場合)...

(OP がセグメンテーション違反になった理由は、gfortranが null ポインターを持つdeferred親型 ( generic_type) 内のプロシージャーにアクセスした可能性があります。この場合、ストーリーは一貫しています。)

編集

Type1 を として宣言した場合にも、gfortran の同じ例外的な動作が発生しabstractます。具体的には、Type1 の定義を次のように変更すると、

    type, abstract :: Type1    ! now an abstract type (cannot be instantiated)
    contains
        procedure :: test
        procedure :: square => Type1_square
    endtype

そしてメインプログラムとして

program main
    use types
    implicit none
    type(Type2) :: t2

    call t2 % test( 2.0 )
end program

我々が得る

ifort-16    : square(   2.000000     ) =    4.000000    
oracle-12.5 : square( 2.0 ) =  4.0
gfortran-6  : square(   2.00000000     ) =   -100.000000

さらにsquare()Type1 を be にするdeferred(つまり、実装を指定しない) ことで、OP の場合とほぼ同等のコードを作成すると、

type, abstract :: Type1  ! now an abstract type (cannot be instantiated)
contains
    procedure :: test
    procedure(Type1_square), deferred :: square  ! has no implementation yet
endtype

abstract interface
    function Type1_square( this, x ) result( y )
        import
        class(Type1) :: this
        real :: x, y
    end function
end interface

次に、ifort-16 と Oracle-12.5 では 4.0 がcall t2 % test( 2.0 )返されますが、gfortran-6 ではセグメンテーション違反が発生します。実際、次のようにコンパイルすると

$ gfortran -fsanitize=address test.f90   # on Linux x86_64

我々が得る

ASAN:SIGSEGV    (<-- or "ASAN:DEADLYSIGNAL" on OSX 10.9)
=================================================================
==22045==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 
                (pc 0x000000000000 bp 0x7fff1d23ecd0 sp 0x7fff1d23eac8 T0)
==22045==Hint: pc points to the zero page.

square()全体として、Type1 (実装がない)のバインディング名が gfortran によって誤って呼び出されているように見えます (おそらく null ポインターを使用)。さらに重要なことはnon_overridable、Type2 の定義から外すと、gfortran も 4.0 を返します (セグメンテーション違反なし)。

于 2016-11-10T22:02:59.757 に答える