VectorMemoryUsage

Get memory stats for all ranks in the simulation

This vector postprocessor generates multiple output columns with one row per MPI rank

Column name	Description
`hardware_id`	Ranks with a common hardware ID share common RAM (i.e. are located on the same compute node)
`total_ram`	Total available RAM on the compute node the respective MPI rank is located on.
`physical_mem`	Physical memory the current rank uses (default unit: MBs).
`virtual_mem`	Virtual memory the current rank uses (the amount returned strongly depends on the operating system and does not reflect the physical RAM used by the simulation - default unit: MBs).
`page_faults`	Number of hard page faults encountered by the MPI rank. This number is only available on Linux systems and indicates the amount of swap activity (indicating low performance due to insufficient available RAM)
`node_utilization`	Indicates which fraction of the total RAM available on the compute node is occupied by MOOSE processes of the current simulation.

For a Postprocessor that provides min/max/average memory statistics see MemoryUsage.

Example visualizations

This VectorPostprocessor can be visualized using the VectorPostprocessorVisualizationAux AuxKernel. Both the IDs:

Refined grid

Processor id (using ProcessorIDAux)

Hardware id (i.e. compute node)

and the memory used:

Physical memory used by rank

Fraction of RAM used by the current simulation on the compute node

note

Due to differences in the data collection method, the memory consumption may be slightly different from the PerfGraphOutput.

Input Parameters

contains_complete_historyFalseSet this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation
Default:False
C++ Type:bool
Controllable:No
Description:Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation
execute_onTIMESTEP_ENDThe list of flag(s) indicating when this object should be executed, the available options include FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM.
Default:TIMESTEP_END
C++ Type:ExecFlagEnum
Options:FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM
Controllable:No
Description:The list of flag(s) indicating when this object should be executed, the available options include FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM.
mem_unitsmebibytesThe unit prefix used to report memory usage, default: Mebibytes
Default:mebibytes
C++ Type:MooseEnum
Options:bytes, kibibytes, mebibytes, gibibytes, kilobytes, megabytes, gigabytes
Controllable:No
Description:The unit prefix used to report memory usage, default: Mebibytes
parallel_typeREPLICATEDSet how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is performed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function.
Default:REPLICATED
C++ Type:MooseEnum
Options:DISTRIBUTED, REPLICATED
Controllable:No
Description:Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is performed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function.
prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
report_peak_valueTrueIf the vectorpostprocessor is executed more than once during a time step, report the aggregated peak value.
Default:True
C++ Type:bool
Controllable:No
Description:If the vectorpostprocessor is executed more than once during a time step, report the aggregated peak value.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup
outputsVector of output names where you would like to restrict the output of variables(s) associated with this object
C++ Type:std::vector<OutputName>
Controllable:No
Description:Vector of output names where you would like to restrict the output of variables(s) associated with this object
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

Input Files

(test/tests/postprocessors/memory_usage/vector_memory_usage.i)
(test/tests/outputs/debug/show_execution_userobjects.i)

(test/tests/postprocessors/memory_usage/vector_memory_usage.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 20
  ny = 20
[]

[GlobalParams]
  order = CONSTANT
  family = MONOMIAL
[]

[Variables]
  [./u]
  [../]
[]

[Adaptivity]
  [./Markers]
    [./box]
      type = BoxMarker
      bottom_left = '0.6 0.7 0'
      top_right = '0.9 0.9 0'
      inside = refine
      outside = do_nothing
    [../]
  [../]
  marker = box
[]

[Problem]
  kernel_coverage_check = false
  solve = false
[]

[VectorPostprocessors]
  [./mem]
    type = VectorMemoryUsage
    execute_on = 'INITIAL TIMESTEP_END NONLINEAR LINEAR'
    report_peak_value = true
    mem_units = kilobytes # or bytes, megabytes, gigabytes
  [../]
[]

[Executioner]
  type = Transient
  num_steps = 2
[]

[Outputs]
  csv = true
[]

(test/tests/outputs/debug/show_execution_userobjects.i)

[Mesh]
  [cmg]
    type = CartesianMeshGenerator
    dim = 2
    dx = '1.5 2.4'
    dy = '1.3 0.9'
    ix = '3 2'
    iy = '2 3'
    subdomain_id = '0 1
                    1 0'
  []
  [add_interface]
    type = SideSetsBetweenSubdomainsGenerator
    input = 'cmg'
    primary_block = 0
    paired_block = 1
    new_boundary = 'interface'
  []
  second_order = true
[]

[Functions]
  [forcing_fnu]
    type = ParsedFunction
    expression = -5.8*(x+y)+x*x*x-x+y*y*y-y
  []
  [forcing_fnv]
    type = ParsedFunction
    expression = -4
  []

  [slnu]
    type = ParsedGradFunction
    expression = x*x*x-x+y*y*y-y
    grad_x = 3*x*x-1
    grad_y = 3*y*y-1
  []
  [slnv]
    type = ParsedGradFunction
    expression = x*x+y*y
    grad_x = 2*x
    grad_y = 2*y
  []

  # NeumannBC functions
  [bc_fnut]
    type = ParsedFunction
    expression = 3*y*y-1
  []
  [bc_fnub]
    type = ParsedFunction
    expression = -3*y*y+1
  []
  [bc_fnul]
    type = ParsedFunction
    expression = -3*x*x+1
  []
  [bc_fnur]
    type = ParsedFunction
    expression = 3*x*x-1
  []
[]

[Variables]
  [u]
    order = SECOND
    family = HIERARCHIC
  []
  [v]
    order = SECOND
    family = LAGRANGE
    initial_condition = 1
  []
[]

[AuxVariables]
  [v_elem]
    order = CONSTANT
    family = MONOMIAL
  []
[]

[Kernels]
  active = 'diff1 diff2 test1 forceu forcev react'
  [diff1]
    type = Diffusion
    variable = u
  []
  [test1]
    type = CoupledConvection
    variable = u
    velocity_vector = v
  []
  [diff2]
    type = Diffusion
    variable = v
  []
  [react]
    type = Reaction
    variable = u
  []

  [forceu]
    type = BodyForce
    variable = u
    function = forcing_fnu
  []
  [forcev]
    type = BodyForce
    variable = v
    function = forcing_fnv
  []
[]

[AuxKernels]
  [set_v_elem]
    type = FunctionAux
    variable = v_elem
    # selected not to be the solution for no particular reason
    function = forcing_fnv
  []
[]

[BCs]
  [bc_v]
    type = FunctionDirichletBC
    variable = v
    function = slnv
    boundary = 'left right top bottom'
  []
  [bc_u_tb]
    type = CoupledKernelGradBC
    variable = u
    var2 = v
    vel = '0.1 0.1'
    boundary = 'top bottom left right'
  []
  [bc_ul]
    type = FunctionNeumannBC
    variable = u
    function = bc_fnul
    boundary = 'left'
  []
  [bc_ur]
    type = FunctionNeumannBC
    variable = u
    function = bc_fnur
    boundary = 'right'
  []
  [bc_ut]
    type = FunctionNeumannBC
    variable = u
    function = bc_fnut
    boundary = 'top'
  []
  [bc_ub]
    type = FunctionNeumannBC
    variable = u
    function = bc_fnub
    boundary = 'bottom'
  []
[]

[Postprocessors]
  # Global user objects
  [dofs]
    type = NumDOFs
  []
  [h]
    type = AverageElementSize
  []

  # Elemental user objects
  [L2u]
    type = ElementL2Error
    variable = u
    function = slnu
    # Testing an option
    force_preic = true
  []
  [L2v]
    type = ElementL2Error
    variable = v
    function = slnv
    # Testing an option
    force_preaux = true
  []
  [H1error]
    type = ElementH1Error
    variable = u
    function = slnu
  []
  [H1Semierror]
    type = ElementH1SemiError
    variable = u
    function = slnu
  []
  [L2v_elem]
    type = ElementL2Error
    variable = v_elem
    function = slnv
  []
  [f_integral]
    type = FunctionElementIntegral
    function = slnv
  []
  [int_v]
    type = ElementIntegralVariablePostprocessor
    variable = v
    block = 1
    execute_on = 'TIMESTEP_END transfer'
  []
  [int_v_elem]
    type = ElementIntegralVariablePostprocessor
    variable = v_elem
    block = 1
    execute_on = 'TIMESTEP_END transfer'
  []

  # Side user objects
  [integral_v]
    type = SideIntegralVariablePostprocessor
    variable = v
    boundary = 0
  []
[]

[VectorPostprocessors]
  # General UOs
  [memory]
    type = VectorMemoryUsage
  []
  [line]
    type = LineValueSampler
    variable = v
    num_points = 10
    start_point = '0 0 0'
    end_point = '0.5 0.5 0'
    sort_by = 'x'
  []

  # Nodal UOs
  [nodal_sampler_y]
    type = NodalValueSampler
    variable = v
    sort_by = 'y'
  []
  [nodal_sampler_x]
    type = NodalValueSampler
    variable = v
    sort_by = 'x'
  []

  # Element UO
  [elem_sample]
    type = ElementValueSampler
    variable = v_elem
    sort_by = 'x'
  []
[]

[UserObjects]
  # Nodal user objects
  [find_node]
    type = NearestNodeNumberUO
    point = '0.5 0.5 0'
  []

  # Side user objects
  [side_int]
    type = LayeredSideIntegral
    variable = v
    boundary = 0
    direction = y
    num_layers = 4
  []
  [side_int_2]
    type = NearestPointLayeredSideIntegral
    variable = v
    boundary = 0
    direction = x
    num_layers = 3
    points = '1 1 0'
  []

  # Interface user objects
  [values]
    type = InterfaceQpValueUserObject
    var = v
    boundary = interface
  []

  inactive = 'prime_1 prime_2'
  # Threaded general user objects
  [prime_2]
    type = PrimeProductUserObject
  []
  [prime_1]
    type = PrimeProductUserObject
  []

  # Domain user objects
  [domain_2]
    type = InterfaceDomainUserObject
    u = u
    v = v
    block = '0'
    robin_boundaries = 'left'
    interface_boundaries = 'interface'
    interface_penalty = 1e-10
    nl_abs_tol = 1e1
  []
  [domain_1]
    type = InterfaceDomainUserObject
    u = u
    v = v
    block = '0 1'
    robin_boundaries = 'left'
    interface_boundaries = 'interface'
    interface_penalty = 1e-10
    nl_abs_tol = 1e1
  []
[]

[Executioner]
  type = Steady
  solve_type = 'PJFNK'
  nl_rel_tol = 1e-10
  nl_abs_tol = 1e-10
  l_tol = 1e-5
[]

[Problem]
  kernel_coverage_check = false
[]

[MultiApps]
  active = ''
  [full_solve]
    type = FullSolveMultiApp
    execute_on = 'initial timestep_end final'
    input_files = show_execution_userobjects.i
    cli_args = 'Problem/solve=false'
  []
[]

[Transfers]
  active = ''
  [conservative]
    type = MultiAppNearestNodeTransfer
    from_multi_app = full_solve
    source_variable = v
    variable = v_elem
    from_postprocessors_to_be_preserved = int_v
    to_postprocessors_to_be_preserved = int_v_elem
  []
[]

[Debug]
  show_execution_order = 'ALWAYS INITIAL NONLINEAR LINEAR TIMESTEP_BEGIN TIMESTEP_END FINAL'
[]

Example visualizations
Input Parameters
Input Files