optimisation_config_type Derived Type

type, public, extends(abstract_config_type) :: optimisation_config_type

Used to represent the input configuration for GS2's optimisation procedure. When turned on, GS2 performs a scan for the given input file, varying different optimisation flags. Results of this scan are reported in .optim. The optimal parameters are stored, allowing a user to run the same input file with optimised parameters in the same execution. A user can also choose to continue with a less-than-optimal set of parameters which satisfy other constraints.


Contents


Components

Type Visibility Attributes Name Initial
logical, public :: exist = .false.

Does the related namelist exist in the target input file?

integer, public :: index = 0

Used to hold the specific index of numbered namelists

logical, public :: skip_read = .false.

Do we want to skip the read step in init?

logical, public :: skip_broadcast = .false.

Do we want to skip the broadcast step in init?

logical, public :: auto = .true.

When true, automatically continues GS2 to run the input file with the optimised parameters.

logical, public :: estimate_timing_error = .true.

Estimate the absolute and relative errors in timing data FIXME: Why would we want this to be false? On small core counts it doesn't seem like a big overhead.

real, public :: max_imbalance = -1.0

The maximum fraction of unused procs to allow in the optimisation scan.

integer, public :: max_unused_procs = 0

The maximum number of unused procs to allow in the optimisation scan.

logical, public :: measure_all = .false.

When true, use the "advance" timer. When false, use the "timestep" timer.

real, public :: min_efficiency = -1.0

The minimum efficiency (relative to the optimal parameters) considered when looking for a constrained set of parameters. A negative value implies only the optimal parameters are considered.

integer, public :: nstep_measure = 5

The number of timestep to use in the timing experiments. Must be greater than 1

logical, public :: on = .false.

Set true to turn on optimisation procedure

logical, public :: warm_up = .false.

When true, perform a few runs before beginning the timing experiment


Type-Bound Procedures

procedure, public, :: is_initialised => is_initialised_generic

procedure, public, :: init => init_generic

  • private subroutine init_generic(self, name, requires_index, index)

    Fully initialise the config object

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(inout) :: self
    character(len=*), intent(in), optional :: name
    logical, intent(in), optional :: requires_index
    integer, intent(in), optional :: index

procedure, public, :: setup => setup_generic

  • private subroutine setup_generic(self, name, requires_index, index)

    Do some standard setup/checking

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(inout) :: self
    character(len=*), intent(in), optional :: name
    logical, intent(in), optional :: requires_index
    integer, intent(in), optional :: index

procedure, public, :: write_namelist_header

  • private subroutine write_namelist_header(self, unit)

    Write the namelist header for this instance

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self
    integer, intent(in) :: unit

procedure, public, :: get_name => get_name_generic

  • private function get_name_generic(self)

    Returns the namelist name. Not very useful at the moment but may want to do more interesting things in the future

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self

    Return Value character(len=CONFIG_MAX_NAME_LEN)

procedure, public, :: get_requires_index => get_requires_index_generic

  • private function get_requires_index_generic(self)

    Returns the requires_index value. Allows access whilst keeping the variable private

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self

    Return Value logical

procedure, public, nopass :: write_namelist_footer

  • private subroutine write_namelist_footer(unit)

    Write the namelist footer

    Arguments

    Type IntentOptional Attributes Name
    integer, intent(in) :: unit
  • private subroutine write_key_val_string(key, val, unit)

    Writes a {key,val} pair where the value is of type character

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: key
    character(len=*), intent(in) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_real(key, val, unit)

    Writes a {key,val} pair where the value is of type real

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: key
    real, intent(in) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_complex(key, val, unit)

    Writes a {key,val} pair where the value is of type complex

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: key
    complex, intent(in) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_integer(key, val, unit)

    Writes a {key,val} pair where the value is of type integer

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: key
    integer, intent(in) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_logical(key, val, unit)

    Writes a {key,val} pair where the value is of type logical

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: key
    logical, intent(in) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_real_array(self, key, val, unit)

    Writes a {key,val} pair where the value is of type real array

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self
    character(len=*), intent(in) :: key
    real, intent(in), dimension(:) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_complex_array(self, key, val, unit)

    Writes a {key,val} pair where the value is of type complex array

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self
    character(len=*), intent(in) :: key
    complex, intent(in), dimension(:) :: val
    integer, intent(in) :: unit
  • private subroutine write_key_val_integer_array(self, key, val, unit)

    Writes a {key,val} pair where the value is of type integer array

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_config_type), intent(in) :: self
    character(len=*), intent(in) :: key
    integer, intent(in), dimension(:) :: val
    integer, intent(in) :: unit

procedure, public :: read => read_optimisation_config

procedure, public :: write => write_optimisation_config

  • private subroutine write_optimisation_config(self, unit)

    Writes out a namelist representing the current state of the config object

    Arguments

    Type IntentOptional Attributes Name
    class(optimisation_config_type), intent(in) :: self
    integer, intent(in), optional :: unit

procedure, public :: reset => reset_optimisation_config

procedure, public :: broadcast => broadcast_optimisation_config

procedure, public, nopass :: get_default_name => get_default_name_optimisation_config

procedure, public, nopass :: get_default_requires_index => get_default_requires_index_optimisation_config

Source Code

  type, extends(abstract_config_type) :: optimisation_config_type
     ! namelist : optimisation_config
     ! indexed : false     
     !> When true, automatically continues GS2 to run the input file with the
     !> optimised parameters.
     logical :: auto = .true.
     !> Estimate the absolute and relative errors in timing data
     !> FIXME: Why would we want this to be false? On small core counts it
     !> doesn't seem like a big overhead.
     logical :: estimate_timing_error = .true.
     !> The maximum fraction of unused procs to allow in the optimisation
     !> scan.
     real :: max_imbalance = -1.0
     !> The maximum number of unused procs to allow in the optimisation scan.
     integer :: max_unused_procs = 0
     !> When true, use the "advance" timer.
     !> When false, use the "timestep" timer.
     logical :: measure_all = .false.
     !> The minimum efficiency (relative to the optimal parameters)
     !> considered when looking for a constrained set of parameters.
     !> A negative value implies only the optimal parameters are considered.
     real :: min_efficiency = -1.0
     !> The number of timestep to use in the timing experiments. Must
     !> be greater than 1
     integer :: nstep_measure = 5
     !> Set true to turn on optimisation procedure
     logical :: on = .false.
     !> When true, perform a few runs before beginning the timing experiment
     logical :: warm_up = .false.
   contains
     procedure, public :: read => read_optimisation_config
     procedure, public :: write => write_optimisation_config
     procedure, public :: reset => reset_optimisation_config
     procedure, public :: broadcast => broadcast_optimisation_config
     procedure, public, nopass :: get_default_name => get_default_name_optimisation_config
     procedure, public, nopass :: get_default_requires_index => get_default_requires_index_optimisation_config
  end type optimisation_config_type