log.f90

Go to the documentation of this file.

! Copyright (c) 2021-2024, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
!
module logger
  use comm, only : pe_rank
  use utils, only : neko_error
  use, intrinsic :: iso_fortran_env, only : stdout => output_unit, &
       stderr => error_unit
  implicit none
  private
 
  ! > Size of the log message buffer
  !! @note This adjust for the leading space applied by `write`. 80 character
  !! output log leaves 79 characters for the message.
  integer, public, parameter :: log_size = 79
 
  type, public :: log_t
     integer, private :: indent_
     integer, private :: section_id_
     integer, private :: tab_size_
     integer, private :: level_
     integer, private :: unit_
 
     character(len=LOG_SIZE), private :: section_header = ""
 
   contains
     procedure, pass(this) :: init => log_init
     procedure, pass(this) :: free => log_free
     procedure, pass(this) :: begin => log_begin
     procedure, pass(this) :: end => log_end
     procedure, pass(this) :: indent => log_indent
     procedure, pass(this) :: newline => log_newline
     procedure, pass(this) :: message => log_message
     procedure, pass(this) :: section => log_section
     procedure, pass(this) :: header => log_header
     procedure, pass(this) :: error => log_error
     procedure, pass(this) :: warning => log_warning
     procedure, pass(this) :: deprecated => log_deprecated
     procedure, pass(this) :: end_section => log_end_section
 
     procedure, private, pass(this) :: print_section_header => &
          log_print_section_header
  end type log_t
 
  type(log_t), public :: neko_log
  integer, public, parameter :: neko_log_quiet = 0
  integer, public, parameter :: neko_log_info = 1
  integer, public, parameter :: neko_log_verbose = 2
  integer, public, parameter :: neko_log_deprecation_error = 5
  integer, public, parameter :: neko_log_debug = 10
 
  character(len=50), dimension(:), allocatable :: deprecated_list
 
contains
 
  subroutine log_init(this)
    class(log_t), intent(inout) :: this
    character(len=255) :: log_level
    character(len=255) :: log_tab_size
    character(len=255) :: log_file
    integer :: envvar_len
 
    this%indent_ = 0
    this%section_id_ = 0
 
    call get_environment_variable("NEKO_LOG_TAB_SIZE", log_tab_size, envvar_len)
    if (envvar_len .gt. 0) then
       read(log_tab_size(1:envvar_len), *) this%tab_size_
    else
       this%tab_size_ = 1
    end if
 
    call get_environment_variable("NEKO_LOG_LEVEL", log_level, envvar_len)
    if (envvar_len .gt. 0) then
       read(log_level(1:envvar_len), *) this%level_
    else
       this%level_ = neko_log_info
    end if
 
    call get_environment_variable("NEKO_LOG_FILE", log_file, envvar_len)
    if (envvar_len .gt. 0) then
       open(newunit = this%unit_, file = trim(log_file), status = 'replace', &
            action = 'write')
    else
       this%unit_ = stdout
    end if
 
  end subroutine log_init
 
  subroutine log_free(this)
    class(log_t), intent(inout) :: this
 
    if (this%section_id_ .ne. 0) then
       call neko_error("Log is unbalanced")
    end if
 
    if (this%unit_ .ne. stdout) then
       close(this%unit_)
    end if
 
    this%indent_ = 0
    this%level_ = neko_log_info
    this%unit_ = -1
 
    if (allocated(deprecated_list)) then
       deallocate(deprecated_list)
    end if
 
  end subroutine log_free
 
  subroutine log_begin(this)
    class(log_t), intent(inout) :: this
 
    if (pe_rank .eq. 0) then
       this%section_id_ = this%section_id_ + 1
       this%indent_ = this%indent_ + this%tab_size_
    end if
 
  end subroutine log_begin
 
  subroutine log_end(this)
    class(log_t), intent(inout) :: this
 
    if (pe_rank .eq. 0) then
       if (this%section_id_ .eq. 0) then
          call neko_error("Log is unbalanced")
       end if
       this%section_id_ = this%section_id_ - 1
       this%indent_ = this%indent_ - this%tab_size_
    end if
 
    this%section_header = ""
 
  end subroutine log_end
 
  subroutine log_indent(this)
    class(log_t), intent(in) :: this
 
    if (pe_rank .eq. 0) then
       write(this%unit_, '(A)', advance = 'no') repeat(' ', this%indent_)
    end if
 
  end subroutine log_indent
 
  subroutine log_newline(this, lvl)
    class(log_t), intent(in) :: this
    integer, optional :: lvl
 
    integer :: lvl_
 
    if (present(lvl)) then
       lvl_ = lvl
    else
       lvl_ = neko_log_info
    end if
 
    if (lvl_ .gt. this%level_) then
       return
    end if
 
    if (pe_rank .eq. 0) then
       write(this%unit_, '(A)') ''
    end if
 
  end subroutine log_newline
 
  subroutine log_message(this, msg, lvl)
    class(log_t), intent(inout) :: this
    character(len=*), intent(in) :: msg
    integer, optional :: lvl
    integer :: lvl_
 
    if (present(lvl)) then
       lvl_ = lvl
    else
       lvl_ = neko_log_info
    end if
 
    if (lvl_ .gt. this%level_) then
       return
    end if
 
    if (len_trim(this%section_header) .gt. 0) then
       call this%print_section_header(lvl)
    end if
 
    if (pe_rank .eq. 0) then
       call this%indent()
       write(this%unit_, '(A)') trim(msg)
    end if
 
  end subroutine log_message
 
  subroutine log_header(this, version, build_info)
    class(log_t), intent(in) :: this
    character(len=*), intent(in) :: version
    character(len=*), intent(in) :: build_info
 
    if (pe_rank .eq. 0) then
       write(this%unit_, '(A)') ''
       write(this%unit_, '(1X,A)') '   _  __  ____  __ __  ____  '
       write(this%unit_, '(1X,A)') '  / |/ / / __/ / //_/ / __ \ '
       write(this%unit_, '(1X,A)') ' /    / / _/  / ,<   / /_/ / '
       write(this%unit_, '(1X,A)') '/_/|_/ /___/ /_/|_|  \____/  '
       write(this%unit_, '(A)') ''
       write(this%unit_, '(1X,A,A,A)') '(version: ', trim(version), ')'
       write(this%unit_, '(1X,A)') trim(build_info)
       write(this%unit_, '(A)') ''
    end if
 
  end subroutine log_header
 
  subroutine log_error(this, msg)
    class(log_t), intent(in) :: this
    character(len=*), intent(in) :: msg
 
    if (pe_rank .eq. 0) then
       call this%indent()
       write(stderr, '(A,A,A)') '*** ERROR: ', trim(msg), '  ***'
    end if
 
  end subroutine log_error
 
  subroutine log_warning(this, msg)
    class(log_t), intent(in) :: this
    character(len=*), intent(in) :: msg
 
    if (pe_rank .eq. 0) then
       call this%indent()
       write(this%unit_, '(A,A,A)') '*** WARNING: ', trim(msg), '  ***'
    end if
 
  end subroutine log_warning
 
  subroutine log_deprecated(this, feature, removal_version, extra_info)
    class(log_t), intent(inout) :: this
    character(len=*), intent(in) :: feature
    character(len=*), intent(in), optional :: removal_version
    character(len=*), intent(in), optional :: extra_info
    character(len=LOG_SIZE) :: msg
    character(len=50), dimension(:), allocatable :: deprecated_list_local
    integer :: i
 
    if (this%level_ .lt. neko_log_quiet) return
 
    if (.not. allocated(deprecated_list)) then
       allocate(character(len=50) :: deprecated_list(1))
       deprecated_list = trim(feature)
    else
       ! Check that the feature have not already been logged
       do i = 1, size(deprecated_list)
          if (trim(deprecated_list(i)) .eq. trim(feature)) return
       end do
 
       ! Save the feature to the list of deprecated features
       call move_alloc(deprecated_list, deprecated_list_local)
       allocate(character(len=50)::deprecated_list(size(deprecated_list_local)+1))
       deprecated_list(1:size(deprecated_list_local)) = deprecated_list_local
       deprecated_list(size(deprecated_list_local) + 1) = trim(feature)
       deallocate(deprecated_list_local)
    end if
 
    ! Construct deprecation message
    write(msg, '(A,A)') '*** DEPRECATION: ', trim(feature)
    call this%message(msg)
    write(msg, '(A,A,A)') 'The feature "', trim(feature), &
         '" is deprecated.'
    call this%message(msg)
 
    if (present(removal_version)) then
       write(msg, '(A,A,A)') 'It will be removed in version ', &
            trim(removal_version), '.'
       call this%message(msg)
    end if
 
    if (present(extra_info)) then
       call this%message(extra_info)
    end if
 
    call this%message('***')
 
    if (this%level_ .ge. neko_log_deprecation_error) then
       call neko_error('Deprecated feature used: ' // trim(feature))
    end if
 
  end subroutine log_deprecated
 
  subroutine log_section(this, msg, lvl)
    class(log_t), intent(inout) :: this
    character(len=*), intent(in) :: msg
    integer, optional :: lvl
 
    integer :: pre, pos
 
    if (len_trim(this%section_header) .gt. 0) then
       call this%print_section_header(lvl)
    end if
 
    call this%begin()
 
    if (pe_rank .eq. 0) then
       pre = (30 - len_trim(msg)) / 2
       pos = 30 - (len_trim(msg) + pre)
 
       write(this%section_header, '(A,A,A)') &
            repeat('-', pre), trim(msg), repeat('-', pos)
    end if
 
  end subroutine log_section
 
  subroutine log_print_section_header(this, lvl)
    class(log_t), intent(inout) :: this
    integer, optional :: lvl
    integer :: lvl_
 
    if (present(lvl)) then
       lvl_ = lvl
    else
       lvl_ = neko_log_info
    end if
 
    if (lvl_ .gt. this%level_) then
       return
    end if
 
    if (pe_rank .eq. 0) then
       call this%newline(lvl)
       call this%indent()
       write(this%unit_, '(A)') trim(this%section_header)
       this%section_header = ""
    end if
 
  end subroutine log_print_section_header
 
  subroutine log_end_section(this, msg, lvl)
    class(log_t), intent(inout) :: this
    character(len=*), intent(in), optional :: msg
    integer, optional :: lvl
 
    if (present(msg)) then
       call this%message(msg, lvl)
    end if
 
    call this%end()
 
  end subroutine log_end_section
 
  !
  ! Rudimentary C interface
  !
 
  subroutine log_message_c(c_msg) bind(c, name = 'log_message')
    use, intrinsic :: iso_c_binding
    character(kind=c_char), dimension(*), intent(in) :: c_msg
    character(len=LOG_SIZE) :: msg
    integer :: len
 
    if (pe_rank .eq. 0) then
       len = 0
       do
          if (c_msg(len+1) .eq. c_null_char) exit
          len = len + 1
          msg(len:len) = c_msg(len)
       end do
 
       call neko_log%message(trim(msg(1:len)))
    end if
 
  end subroutine log_message_c
 
  subroutine log_error_c(c_msg) bind(c, name = "log_error")
    use, intrinsic :: iso_c_binding
    character(kind=c_char), dimension(*), intent(in) :: c_msg
    character(len=LOG_SIZE) :: msg
    integer :: len
 
    if (pe_rank .eq. 0) then
       len = 0
       do
          if (c_msg(len+1) .eq. c_null_char) exit
          len = len + 1
          msg(len:len) = c_msg(len)
       end do
 
       call neko_log%indent()
       write(stderr, '(A,A,A)') '*** ERROR: ', trim(msg(1:len)), '  ***'
    end if
 
  end subroutine log_error_c
 
  subroutine log_warning_c(c_msg) bind(c, name = "log_warning")
    use, intrinsic :: iso_c_binding
    character(kind=c_char), dimension(*), intent(in) :: c_msg
    character(len=LOG_SIZE) :: msg
    integer :: len
 
    if (pe_rank .eq. 0) then
       len = 0
       do
          if (c_msg(len+1) .eq. c_null_char) exit
          len = len + 1
          msg(len:len) = c_msg(len)
       end do
 
       call neko_log%indent()
       write(neko_log%unit_, '(A,A,A)') &
            '*** WARNING: ', trim(msg(1:len)), '  ***'
    end if
 
  end subroutine log_warning_c
 
  subroutine log_section_c(c_msg) bind(c, name = "log_section")
    use, intrinsic :: iso_c_binding
    character(kind=c_char), dimension(*), intent(in) :: c_msg
    character(len=LOG_SIZE) :: msg
    integer :: len
 
    if (pe_rank .eq. 0) then
       len = 0
       do
          if (c_msg(len+1) .eq. c_null_char) exit
          len = len + 1
          msg(len:len) = c_msg(len)
       end do
 
       call neko_log%section(trim(msg(1:len)))
    end if
 
  end subroutine log_section_c
 
  subroutine log_end_section_c() bind(c, name = "log_end_section")
 
    call neko_log%end_section()
 
  end subroutine log_end_section_c
 
end module logger