Peano
Loading...
Searching...
No Matches
exahype2.solvers.fv.EnclaveTasking.EnclaveTasking Class Reference

Enclave tasking variant of the Finite Volume scheme. More...

Inheritance diagram for exahype2.solvers.fv.EnclaveTasking.EnclaveTasking:
Collaboration diagram for exahype2.solvers.fv.EnclaveTasking.EnclaveTasking:

Public Member Functions

 __init__ (self, name, patch_size, overlap, unknowns, auxiliary_variables, min_volume_h, max_volume_h, plot_grid_properties, bool pde_terms_without_state, kernel_namespace)
 Not so nice.
 
 create_data_structures (self)
 This routine does not really add new data, but it heavily tailors when data are stored, exchanged, ... Each generator has some guard attributes, i.e., some guards, which control when data is stored, sent, received.
 
 create_action_sets (self)
 Adaptive mesh handing.
 
 set_implementation (self, boundary_conditions, refinement_criterion, initial_conditions, memory_location, use_split_loop, additional_action_set_includes, additional_user_includes)
 If you pass in User_Defined, then the generator will create C++ stubs that you have to befill manually.
 
 add_entries_to_text_replacement_dictionary (self, d)
 d: Dictionary of string to string in/out argument
 
 add_actions_to_create_grid (self, step, evaluate_refinement_criterion)
 The boundary information is set only once.
 
 add_actions_to_init_grid (self, step)
 Add all the action sets to init grid.
 
 add_actions_to_perform_time_step (self, step)
 Add enclave aspect to time stepping.
 
 add_implementation_files_to_project (self, namespace, output, dimensions, subdirectory="")
 The ExaHyPE project will call this operation when it sets up the overall environment.
 
 switch_storage_scheme (self, Storage cell_data_storage, Storage face_data_storage)
 By default, we hold all data on the heap using smart pointers.
 
- Public Member Functions inherited from exahype2.solvers.fv.FV.FV
 __str__ (self)
 
 get_min_number_of_spacetree_levels (self, domain_size)
 
 get_max_number_of_spacetree_levels (self, domain_size)
 
 get_coarsest_number_of_patches (self, domain_size)
 
 get_finest_number_of_patches (self, domain_size)
 
 get_coarsest_number_of_finite_volumes (self, domain_size)
 
 get_finest_number_of_finite_volumes (self, domain_size)
 
 get_coarsest_volume_size (self, domain_size)
 
 get_finest_volume_size (self, domain_size)
 
 create_readme_descriptor (self, domain_offset, domain_size)
 
 user_action_set_includes (self)
 Add further includes to this property, if your action sets require some additional routines from other header files.
 
 user_solver_includes (self)
 Add further includes to this property, if your solver requires some additional routines from other header files.
 
 add_user_action_set_includes (self, value)
 Add further includes to this property, if your action sets require some additional routines from other header files.
 
 add_user_solver_includes (self, value)
 Add further includes to this property, if your solver requires some additional routines from other header files.
 
 get_name_of_global_instance (self)
 
 add_to_Peano4_datamodel (self, datamodel, verbose)
 Add all required data to the Peano project's datamodel so it is properly built up.
 
 add_use_data_statements_to_Peano4_solver_step (self, step)
 Tell Peano what data to move around.
 
 plot_description (self)
 
 plot_description (self, description)
 Add a proper description to the plots.
 
 add_actions_to_plot_solution (self, step, output_path)
 Add action sets to plot solution step.
 
 set_solver_constants (self, datastring)
 
 add_solver_constants (self, datastring)
 
 unknowns (self)
 
 patch_size (self)
 
 auxiliary_variables (self)
 
 patch_size (self, value)
 
 unknowns (self, value)
 
 auxiliary_variables (self, value)
 
 preprocess_reconstructed_patch (self)
 
 preprocess_reconstructed_patch (self, kernel)
 Set a new processing kernel.
 
 name (self)
 
 postprocess_updated_patch (self)
 
 postprocess_updated_patch (self, kernel)
 Define a postprocessing routine over the data.
 
 overlap (self)
 
 overlap (self, value)
 
 interpolation (self)
 
 interpolation (self, value)
 
 restriction (self)
 
 restriction (self, value)
 

Data Fields

 enclave_task_priority
 
 make_copy_of_enclave_task_data
 
- Data Fields inherited from exahype2.solvers.fv.FV.FV
 select_dofs_to_print
 

Protected Member Functions

 _create_guards (self)
 All the internal logic depends on guards, i.e., boolean predicates.
 
 _optimise_patch_storage_for_global_time_stepping (self)
 Make storage and loading more restrictive such that enclave data are not held in-between primary and secondary sweep.
 
 _enclave_task_name (self)
 
- Protected Member Functions inherited from exahype2.solvers.fv.FV.FV
 _provide_cell_data_to_compute_kernels_default_guard (self)
 Default logic when to create cell data or not.
 
 _provide_face_data_to_compute_kernels_default_guard (self)
 
 _store_cell_data_default_guard (self)
 Extend the guard via ands only.
 
 _load_cell_data_default_guard (self)
 Extend the guard via ands only.
 
 _store_face_data_default_guard (self)
 Extend the guard via ands only.
 
 _load_face_data_default_guard (self)
 Extend the guard via ands only.
 
 _unknown_identifier (self)
 
 _get_default_includes (self)
 
 _init_dictionary_with_default_parameters (self, d)
 This one is called by all algorithmic steps before I invoke add_entries_to_text_replacement_dictionary().
 

Protected Attributes

 _name
 
 _fused_compute_kernel_call_stateless_cpu
 
 _fused_compute_kernel_call_stateless_gpu
 
 _solver_template_file_class_name
 
 _initialisation_sweep_guard
 
 _first_iteration_after_initialisation_guard
 
 _primary_sweep_guard
 
 _primary_sweep_or_plot_guard
 
 _primary_or_initialisation_sweep_guard
 
 _primary_or_grid_construction_or_initialisation_sweep_guard
 
 _secondary_sweep_guard
 
 _secondary_sweep_or_grid_construction_guard
 
 _secondary_sweep_or_grid_initialisation_guard
 
 _secondary_sweep_or_grid_initialisation_or_plot_guard
 
 _action_set_update_cell
 
 _action_set_merge_enclave_task_outcome
 
 _boundary_conditions_implementation
 
 _refinement_criterion_implementation
 
 _initial_conditions_implementation
 
 _reconstructed_array_memory_location
 
 _use_split_loop
 
- Protected Attributes inherited from exahype2.solvers.fv.FV.FV
 _name
 
 _min_volume_h
 
 _max_volume_h
 
 _plot_grid_properties
 
 _patch_size
 
 _overlap
 
 _use_var_shortcut
 
 _variable_names
 
 _variable_pos
 
 _unknowns
 
 _auxiliary_variables
 
 _solver_constants
 
 _user_action_set_includes
 
 _user_solver_includes
 
 _reconstructed_array_memory_location
 
 _solver_template_file_class_name
 
 _plot_description
 
 _action_set_initial_conditions
 
 _action_set_initial_conditions_for_grid_construction
 
 _action_set_AMR
 
 _action_set_AMR_throughout_grid_construction
 
 _action_set_AMR_commit_without_further_analysis
 
 _action_set_handle_boundary
 
 _action_set_project_patch_onto_faces
 
 _action_set_roll_over_update_of_faces
 
 _action_set_copy_new_faces_onto_old_faces
 
 _action_set_couple_resolution_transitions_and_handle_dynamic_mesh_refinement
 
 _action_set_postprocess_solution
 
 _action_set_preprocess_solution
 
 _compute_time_step_size
 
 _compute_new_time_step_size
 
 _preprocess_reconstructed_patch
 
 _postprocess_updated_patch
 
 _compute_kernel_call
 
 _compute_kernel_call_stateless
 
 _pde_terms_without_state
 
 _compute_eigenvalue
 
 _abstract_solver_user_declarations
 
 _abstract_solver_user_definitions
 
 _solver_user_declarations
 
 _solver_user_definitions
 
 _start_time_step_implementation
 
 _finish_time_step_implementation
 
 _constructor_implementation
 
 _boundary_conditions_implementation
 
 _refinement_criterion_implementation
 
 _initial_conditions_implementation
 
 _interpolation
 
 _restriction
 
 _kernel_namespace
 
 _baseline_action_set_descend_invocation_order
 
 _cell_data_storage
 
 _face_data_storage
 
 _eigenvalues_implementation
 
 _flux_implementation
 
 _ncp_implementation
 
 _source_term_implementation
 
 _patch
 
 _patch_overlap_old
 
 _patch_overlap_new
 
 _patch_overlap_update
 
 _cell_label
 
 _face_label
 
 _action_set_update_face_label
 
 _action_set_update_cell_label
 
 _action_set_update_cell
 

Detailed Description

Enclave tasking variant of the Finite Volume scheme.

The concept of (enclave) tasking within ExaHyPE solvers is described in detail in the generic enclave discussion of ExaHyPE. This class is a prototype realisation of this concept which other solvers then specialise for particular numerical schemes.

The class basically replaces the standard "update a cell" action set with an action set that might or might not spawn a task. In return, it adds a further action set which merges the arising task outcomes into the actual mesh structure. By default, we use peano4::datamanagement::CellMarker::willBeEnclaveCell() and peano4::datamanagement::CellMarker::hasBeenEnclaveCell() to guide the decision whether to spawn a task or not. You can overwrite this decision by redefining the corresponding entry in the dictionary befilled by add_entries_to_text_replacement_dictionary().

Task priorities

Use the attributes self.enclave_task_priority to change the priority of the task. This value can either be a string that C++ can evaluate into a priority or a plain numerical value. I set it to

   self.enclave_task_priority  = "tarch::multicore::Task::DefaultPriority-1"

by default.

Definition at line 293 of file EnclaveTasking.py.

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _create_guards()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._create_guards ( self)
protected

All the internal logic depends on guards, i.e., boolean predicates.

We want to be able to alter them in subclasses, but we need a certain baseline. It is defined in this routine.

Definition at line 368 of file EnclaveTasking.py.

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_data_structures().

Here is the caller graph for this function:

◆ _enclave_task_name()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._enclave_task_name ( self)
protected

Definition at line 826 of file EnclaveTasking.py.

References SBH.Limiter._name, dastgen2.attributes.Attribute.Attribute._name, dastgen2.attributes.BooleanArray.BooleanArray._name, dastgen2.attributes.Enumeration.Enumeration._name, exahype2.solvers.aderdg.ADERDG.ADERDG._name, exahype2.solvers.elliptic.AMRMarker.AMRMarker._name, exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells._name, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._name, exahype2.solvers.fv.FV.FV._name, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._name, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._name, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._name, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._name, exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep._name, exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray._name, peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray._name, solvers.api.Solver.Solver._name, mghype::matrixfree::solvers::Solver._name, api.solvers.Solver.Solver._name, and tarch::services::ServiceRepository::ServiceEntry._name.

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

◆ _optimise_patch_storage_for_global_time_stepping()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._optimise_patch_storage_for_global_time_stepping ( self)
protected

Make storage and loading more restrictive such that enclave data are not held in-between primary and secondary sweep.

If you work with global time stepping, you know that each enclave cell will be updated per grid traversal duo. Consequently, every enclave cell's data doesn't have to be stored in-between two grid traversals - we know that it is currently outsourced to a task.

Things are different if we use local time stepping, as there will always be cells that are currently processed, and then there are cells which are not updated and which we consequently should keep.

If you want to have this optimisation, you have to call this routine explicitly in create_data_structures(). By default, we always store the patches all the time.

If we work with smart pointers, it is a bad idea to call this routine, as the enclave framework does not(!) use smart pointers. So we rely on the fact that someone holds the raw pointers alive. If we don't store data here, we run risk that the smart pointer becomes zero and the underlying memory is freed while the enclave task still works against it.

As I don't know what storage scheme we employ, I decided to disable this routine. Notably as I don't think storing makes much of a difference if data are held on the heap anyway.

Definition at line 532 of file EnclaveTasking.py.

Referenced by exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.create_data_structures(), and exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking.create_data_structures().

Here is the caller graph for this function:

◆ add_actions_to_create_grid()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_create_grid ( self,
step,
evaluate_refinement_criterion )

The boundary information is set only once.

It is therefore important that we ues the face label and initialise it properly.

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 753 of file EnclaveTasking.py.

References SBH.Limiter._name, dastgen2.attributes.Attribute.Attribute._name, dastgen2.attributes.BooleanArray.BooleanArray._name, dastgen2.attributes.Enumeration.Enumeration._name, exahype2.solvers.aderdg.ADERDG.ADERDG._name, exahype2.solvers.elliptic.AMRMarker.AMRMarker._name, exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells._name, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._name, exahype2.solvers.fv.FV.FV._name, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._name, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._name, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._name, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._name, exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep._name, exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray._name, peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray._name, solvers.api.Solver.Solver._name, mghype::matrixfree::solvers::Solver._name, api.solvers.Solver.Solver._name, tarch::services::ServiceRepository::ServiceEntry._name, and exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_create_grid().

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_create_grid().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_actions_to_init_grid()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_init_grid ( self,
step )

Add all the action sets to init grid.

The AMR stuff has to be the very first thing. Actually, the AMR routines' interpolation doesn't play any role here. But the restriction indeed is very important, as we have to get the face data for BCs et al. The action set order is inverted while we ascend within the tree again. Therefore, we add the AMR action set first which means it will be called last when we go from fine to coarse levels within the tree.

Ordering

The order of the action sets is preserved throughout the steps down within the tree hierarchy. It is inverted throughout the backrolling.

This is what we want to achieve:

  • Project solution onto faces. This happens in touchCellLastTime(). See exahype2.solvers.fv.actionsets.ProjectPatchOntoFaces for comments. The project will end up in QUpdate.
  • Roll updates over on the faces from QUpdate into Q_new. This is done by RollOverUpdateFace, which requires in turn that the getUpdated() flag is set. As the roll-over plugs into touchFaceLastTime(), it will always be called after the projection, since the latter is a cell operation.
  • Copy new face data Q_new into old face data Q_old, as this is the initial sweep, i.e. the old face data otherwise might hold rubbish. This is a backup operation realised through the action set BackupPatchOverlap. This one plugs into touchFaceLastTime() too. Therefore, it is important that its priority is smaller than the one of the roll-over, since we invert the call order for the touch-last events.
  • Restrict the data to the coarser level if we are on a hanging face.
  • The postprocessing is the very last thing. It does not matter if it plugs into touchCellFirstTime() or touchCellLastTime(). As we invert the order when we backtrace, the postprocessing will have completed before we invoke _action_set_project_patch_onto_faces, i.e. any update will be projected onto the faces.

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 760 of file EnclaveTasking.py.

References SBH.Limiter._name, dastgen2.attributes.Attribute.Attribute._name, dastgen2.attributes.BooleanArray.BooleanArray._name, dastgen2.attributes.Enumeration.Enumeration._name, exahype2.solvers.aderdg.ADERDG.ADERDG._name, exahype2.solvers.elliptic.AMRMarker.AMRMarker._name, exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells._name, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._name, exahype2.solvers.fv.FV.FV._name, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._name, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._name, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._name, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._name, exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep._name, exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray._name, peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray._name, solvers.api.Solver.Solver._name, mghype::matrixfree::solvers::Solver._name, api.solvers.Solver.Solver._name, tarch::services::ServiceRepository::ServiceEntry._name, and exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_init_grid().

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_init_grid().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_actions_to_perform_time_step()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_perform_time_step ( self,
step )

Add enclave aspect to time stepping.

There's a bunch of different things to do to extend my standard solver into an enclave solver. In this operation, we add the runtime logic, i.e., what happens at which point.

We need additional action sets that are triggered throughout the traversal in every second time step. I call this one task_based_implementation_primary_iteration or secondary, respectively. One wraps the implementation of _HandleCellTemplate into a task, the other communicates with the task bookkeeping only. Both rely on additional labels within the cell. We therefore end up with three new action sets: reconstruct_patch_and_apply_FV_kernel, exahype2.grid.UpdateCellLabel and roll_over_enclave_task_results.

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 765 of file EnclaveTasking.py.

References exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._action_set_merge_enclave_task_outcome, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._action_set_merge_enclave_task_outcome, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._action_set_merge_enclave_task_outcome, and exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_perform_time_step().

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_perform_time_step().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_entries_to_text_replacement_dictionary()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_entries_to_text_replacement_dictionary ( self,
d )

d: Dictionary of string to string in/out argument

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 710 of file EnclaveTasking.py.

References exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.riemann.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.riemann.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_cpu, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.riemann.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.riemann.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking._fused_compute_kernel_call_stateless_gpu, SBH.Limiter._name, dastgen2.attributes.Attribute.Attribute._name, dastgen2.attributes.BooleanArray.BooleanArray._name, dastgen2.attributes.Enumeration.Enumeration._name, exahype2.solvers.aderdg.ADERDG.ADERDG._name, exahype2.solvers.elliptic.AMRMarker.AMRMarker._name, exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells._name, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._name, exahype2.solvers.fv.FV.FV._name, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._name, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._name, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._name, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._name, exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep._name, exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps._name, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._name, peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray._name, peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray._name, solvers.api.Solver.Solver._name, mghype::matrixfree::solvers::Solver._name, api.solvers.Solver.Solver._name, tarch::services::ServiceRepository::ServiceEntry._name, SBH.Limiter.enclave_task_priority, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.enclave_task_priority, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.enclave_task_priority, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.enclave_task_priority, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.make_copy_of_enclave_task_data, exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.make_copy_of_enclave_task_data, and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.make_copy_of_enclave_task_data.

Referenced by exahype2.solvers.aderdg.ADERDG.ADERDG._generate_kernels(), exahype2.solvers.fv.FV.FV.add_actions_to_perform_time_step(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_perform_time_step(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_actions_to_plot_solution(), exahype2.solvers.fv.FV.FV.add_actions_to_plot_solution(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_plot_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_implementation_files_to_project(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_implementation_files_to_project(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

◆ add_implementation_files_to_project()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_implementation_files_to_project ( self,
namespace,
output,
dimensions,
subdirectory = "" )

The ExaHyPE project will call this operation when it sets up the overall environment.

This routine is typically not invoked by a user.

output: peano4.output.Output

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 786 of file EnclaveTasking.py.

References exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._enclave_task_name(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._enclave_task_name(), exahype2.solvers.aderdg.ADERDG.ADERDG._init_dictionary_with_default_parameters(), exahype2.solvers.aderdg.SingleSweep.SingleSweep._init_dictionary_with_default_parameters(), exahype2.solvers.fv.FV.FV._init_dictionary_with_default_parameters(), exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._init_dictionary_with_default_parameters(), exahype2.solvers.limiting.StaticLimiting.StaticLimiting._init_dictionary_with_default_parameters(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._init_dictionary_with_default_parameters(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_entries_to_text_replacement_dictionary(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.add_entries_to_text_replacement_dictionary(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.fv.FV.FV.add_entries_to_text_replacement_dictionary(), exahype2.solvers.fv.SingleSweep.SingleSweep.add_entries_to_text_replacement_dictionary(), exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting.add_entries_to_text_replacement_dictionary(), exahype2.solvers.limiting.StaticLimiting.StaticLimiting.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.fd4.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.fd4.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_implementation_files_to_project(), exahype2.solvers.aderdg.ADERDG.ADERDG.user_action_set_includes, exahype2.solvers.fv.FV.FV.user_action_set_includes(), exahype2.solvers.fv.musclhancock.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.user_action_set_includes(), exahype2.solvers.fv.riemann.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.user_action_set_includes(), exahype2.solvers.fv.riemann.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.riemann.GlobalFixedTimeStep.GlobalFixedTimeStep.user_action_set_includes(), exahype2.solvers.fv.riemann.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.user_action_set_includes(), exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.rusanov.GlobalFixedTimeStep.GlobalFixedTimeStep.user_action_set_includes(), exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.fv.SingleSweep.SingleSweep.user_action_set_includes(), exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting.user_action_set_includes, exahype2.solvers.limiting.StaticLimiting.StaticLimiting.user_action_set_includes, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.user_action_set_includes(), exahype2.solvers.rkdg.rusanov.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.user_action_set_includes(), exahype2.solvers.rkdg.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.rkdg.rusanov.GlobalFixedTimeStep.GlobalFixedTimeStep.user_action_set_includes(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.user_action_set_includes(), exahype2.solvers.rkfd.fd4.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep.user_action_set_includes(), exahype2.solvers.rkfd.fd4.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep.user_action_set_includes(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.user_action_set_includes(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.user_action_set_includes(), exahype2.solvers.aderdg.ADERDG.ADERDG.user_solver_includes, exahype2.solvers.fv.FV.FV.user_solver_includes(), exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting.user_solver_includes, exahype2.solvers.limiting.StaticLimiting.StaticLimiting.user_solver_includes, exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.user_solver_includes(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.user_solver_includes().

Referenced by exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

◆ create_action_sets()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_action_sets ( self)

Adaptive mesh handing.

Adaptive meshes require us to clear the patch overlaps and to restrict/interpolate. Obviously, there's no need to do this for a refined faces. So we can eliminate these cases a priori. Furthermore, we clear faces only in the primary sweep. We know that either the primary sweep (for skeleton) or the secondary sweep (for enclaves) will write in proper data into anything that's cleared, and we know that restriction only has to happen after the primary sweep, as all cells next to an adaptivity boundary are skeleton cells.

As pointed out, both interpolation and restriction are to be active for the first sweep only. We interpolate into hanging faces, and we have to restrict immediately again as they are non-persistent. The projection onto the (hanging) faces is also happening directly in the primary sweep, as the cells adjacent to the hanging face are skeleton cells.

AMR and adjust cell have to be there always, i.e., also throughout the grid construction. But the criterion is something that we only evaluate in the secondary sweep. That's when we have an updated/changed time step. If we identify coarsening and refinement instructions in the secondary sweep, the next primary one will actually see them and trigger the update. That is, the subsequent secondary switch will actually implement the grid changes, and we can evaluate the criteria again.

For dynamic AMR, this implies that we have to ensure that all changed grid parts are labelled as skeleton cells. This way, we can implement the AMR properly, we ensure that all the enclaves run in parallel, and we know that all data is held persistently on the stacks.

Reimplemented from exahype2.solvers.fv.FV.FV.

Reimplemented in kernel_testbed.CCZ4Solver, SBH.Limiter, SBH.FVSolver, exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking, and exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking.

Definition at line 573 of file EnclaveTasking.py.

References exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_action_sets().

Referenced by mgccz4.MGCCZ4Solver.add_derivative_calculation(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_kernel_optimisations(), ccz4.CCZ4Solver.add_Psi4W(), exahype2.solvers.fv.FV.FV.auxiliary_variables(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.auxiliary_variables(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.auxiliary_variables(), exahype2.solvers.elliptic.AMRMarker.AMRMarker.couple_with_FV_solver(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_action_sets(), exahype2.solvers.fv.FV.FV.interpolation(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.interpolation(), exahype2.solvers.fv.FV.FV.overlap(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.overlap(), exahype2.solvers.fv.FV.FV.patch_size(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.patch_size(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.postprocess_updated_cell(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_final_linear_combination(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_Runge_Kutta_step(), exahype2.solvers.aderdg.ADERDG.ADERDG.postprocess_updated_patch(), exahype2.solvers.fv.FV.FV.postprocess_updated_patch(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.postprocess_updated_patch(), exahype2.solvers.aderdg.ADERDG.ADERDG.preprocess_reconstructed_patch(), exahype2.solvers.fv.FV.FV.preprocess_reconstructed_patch(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.preprocess_reconstructed_patch(), exahype2.solvers.fv.FV.FV.restriction(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.restriction(), exahype2.solvers.aderdg.ADERDG.ADERDG.set_implementation(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.set_implementation(), exahype2.solvers.aderdg.ADERDG.ADERDG.switch_storage_scheme(), exahype2.solvers.fv.FV.FV.switch_storage_scheme(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.switch_storage_scheme(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.switch_storage_scheme(), exahype2.solvers.fv.FV.FV.unknowns(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.unknowns(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.unknowns().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ create_data_structures()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_data_structures ( self)

This routine does not really add new data, but it heavily tailors when data are stored, exchanged, ... Each generator has some guard attributes, i.e., some guards, which control when data is stored, sent, received.

The routine takes these guards and rewires them to the local guards of this object. If you alter these guards further, you have to alter them before you invoke this class' create_data_structures().

Reimplemented from exahype2.solvers.fv.FV.FV.

Reimplemented in exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking, and exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking.

Definition at line 505 of file EnclaveTasking.py.

References exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._create_guards(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._first_iteration_after_initialisation_guard, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._first_iteration_after_initialisation_guard, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._initialisation_sweep_guard, exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps._initialisation_sweep_guard, exahype2.solvers.fv.FV.FV._patch_overlap_new, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._patch_overlap_new, exahype2.solvers.fv.FV.FV._patch_overlap_old, exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._patch_overlap_old, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._primary_sweep_or_plot_guard, exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._primary_sweep_or_plot_guard, exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._secondary_sweep_or_grid_initialisation_or_plot_guard, and exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_data_structures().

Referenced by mgccz4.MGCCZ4Solver.add_derivative_calculation(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_kernel_optimisations(), ccz4.CCZ4Solver.add_Psi4W(), exahype2.solvers.fv.FV.FV.auxiliary_variables(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.auxiliary_variables(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.auxiliary_variables(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.create_data_structures(), exahype2.solvers.fv.FV.FV.interpolation(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.interpolation(), exahype2.solvers.fv.FV.FV.overlap(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.overlap(), exahype2.solvers.fv.FV.FV.patch_size(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.patch_size(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.postprocess_updated_cell(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_final_linear_combination(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_Runge_Kutta_step(), exahype2.solvers.aderdg.ADERDG.ADERDG.postprocess_updated_patch(), exahype2.solvers.fv.FV.FV.postprocess_updated_patch(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.postprocess_updated_patch(), exahype2.solvers.aderdg.ADERDG.ADERDG.preprocess_reconstructed_patch(), exahype2.solvers.fv.FV.FV.preprocess_reconstructed_patch(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.preprocess_reconstructed_patch(), exahype2.solvers.fv.FV.FV.restriction(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.restriction(), exahype2.solvers.aderdg.ADERDG.ADERDG.set_implementation(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.set_implementation(), exahype2.solvers.aderdg.ADERDG.ADERDG.switch_storage_scheme(), exahype2.solvers.fv.FV.FV.switch_storage_scheme(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.switch_storage_scheme(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.switch_storage_scheme(), exahype2.solvers.fv.FV.FV.unknowns(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.unknowns(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.unknowns().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_implementation()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.set_implementation ( self,
boundary_conditions,
refinement_criterion,
initial_conditions,
memory_location,
use_split_loop,
additional_action_set_includes,
additional_user_includes )

If you pass in User_Defined, then the generator will create C++ stubs that you have to befill manually.

If you pass in None_Implementation, it will create nop, i.e., no implementation or defaults. Any other string is copied 1:1 into the implementation. If you pass in None, then the set value so far won't be overwritten.

Reimplemented in exahype2.solvers.fv.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking, exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking, exahype2.solvers.fv.riemann.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking, and exahype2.solvers.fv.riemann.GlobalFixedTimeStepWithEnclaveTasking.GlobalFixedTimeStepWithEnclaveTasking.

Definition at line 664 of file EnclaveTasking.py.

Referenced by SBH.FVSolver.__init__(), ccz4.CCZ4Solver.__init__(), CCZ4Solver.CCZ4Solver_FV_GlobalAdaptiveTimeStep.__init__(), CCZ4Solver.CCZ4Solver_FV_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__(), CCZ4Solver.CCZ4Solver_FD4_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__(), CCZ4Solver.CCZ4Solver_FD4_GlobalAdaptiveTimeStep.__init__(), CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__(), and CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStep.__init__().

Here is the caller graph for this function:

◆ switch_storage_scheme()

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.switch_storage_scheme ( self,
Storage cell_data_storage,
Storage face_data_storage )

By default, we hold all data on the heap using smart pointers.

You can explicitly switch to storage on the call stack or heap using raw pointers.

See also
create_data_structures()

Reimplemented from exahype2.solvers.fv.FV.FV.

Definition at line 830 of file EnclaveTasking.py.

Field Documentation

◆ _action_set_merge_enclave_task_outcome

◆ _action_set_update_cell

◆ _boundary_conditions_implementation

◆ _first_iteration_after_initialisation_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._first_iteration_after_initialisation_guard
protected

◆ _fused_compute_kernel_call_stateless_cpu

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._fused_compute_kernel_call_stateless_cpu
protected

◆ _fused_compute_kernel_call_stateless_gpu

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._fused_compute_kernel_call_stateless_gpu
protected

◆ _initial_conditions_implementation

◆ _initialisation_sweep_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._initialisation_sweep_guard
protected

◆ _name

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._name
protected

Definition at line 340 of file EnclaveTasking.py.

Referenced by exahype2.solvers.aderdg.ADERDG.ADERDG.__str__(), exahype2.solvers.elliptic.AMRMarker.AMRMarker.__str__(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.__str__(), exahype2.solvers.fv.FV.FV.__str__(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.__str__(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.__str__(), solvers.api.Solver.Solver.__str__(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._enclave_task_name(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking._enclave_task_name(), dastgen2.attributes.Enumeration.Enumeration._enum_name(), exahype2.solvers.aderdg.ADERDG.ADERDG._generate_kernels(), exahype2.solvers.aderdg.ADERDG.ADERDG._init_dictionary_with_default_parameters(), exahype2.solvers.fv.FV.FV._init_dictionary_with_default_parameters(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._init_dictionary_with_default_parameters(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters(), exahype2.solvers.aderdg.ADERDG.ADERDG._interpolate_face_data_default_guard(), exahype2.solvers.aderdg.SingleSweep.SingleSweep._interpolate_face_data_default_guard(), SBH.Limiter._load_cell_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._load_cell_data_default_guard(), exahype2.solvers.fv.FV.FV._load_cell_data_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._load_cell_data_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._load_cell_data_default_guard(), SBH.Limiter._load_face_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._load_face_data_default_guard(), exahype2.solvers.fv.FV.FV._load_face_data_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._load_face_data_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._load_face_data_default_guard(), SBH.Limiter._provide_cell_data_to_compute_kernels_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._provide_cell_data_to_compute_kernels_default_guard(), exahype2.solvers.fv.FV.FV._provide_cell_data_to_compute_kernels_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._provide_cell_data_to_compute_kernels_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._provide_cell_data_to_compute_kernels_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._provide_face_data_to_compute_kernels_default_guard(), exahype2.solvers.fv.FV.FV._provide_face_data_to_compute_kernels_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._provide_face_data_to_compute_kernels_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._provide_face_data_to_compute_kernels_default_guard(), exahype2.solvers.aderdg.SingleSweep.SingleSweep._restrict_face_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._store_boundary_data_default_guard(), SBH.Limiter._store_cell_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._store_cell_data_default_guard(), exahype2.solvers.fv.FV.FV._store_cell_data_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._store_cell_data_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._store_cell_data_default_guard(), SBH.Limiter._store_face_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._store_face_data_default_guard(), exahype2.solvers.fv.FV.FV._store_face_data_default_guard(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._store_face_data_default_guard(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._store_face_data_default_guard(), exahype2.solvers.aderdg.ADERDG.ADERDG._unknown_identifier(), exahype2.solvers.elliptic.AMRMarker.AMRMarker._unknown_identifier(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells._unknown_identifier(), exahype2.solvers.fv.FV.FV._unknown_identifier(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._unknown_identifier(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._unknown_identifier(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_create_grid(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_actions_to_init_grid(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_actions_to_plot_solution(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.add_actions_to_plot_solution(), exahype2.solvers.fv.FV.FV.add_actions_to_plot_solution(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_plot_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution(), exahype2.solvers.fv.EnclaveTasking.EnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_entries_to_text_replacement_dictionary(), exahype2.solvers.aderdg.ADERDG.ADERDG.add_implementation_files_to_project(), exahype2.solvers.elliptic.AMRMarker.AMRMarker.add_to_Peano4_datamodel(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.add_to_Peano4_datamodel(), SBH.Limiter.create_action_sets(), exahype2.solvers.aderdg.SingleSweep.SingleSweep.create_action_sets(), exahype2.solvers.fv.rusanov.LocalTimeStepWithEnclaveTasking.LocalTimeStepWithEnclaveTasking.create_action_sets(), exahype2.solvers.fv.rusanov.SubcyclingAdaptiveTimeStepWithEnclaveTasking.SubcyclingAdaptiveTimeStepWithEnclaveTasking.create_action_sets(), exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStep.SubcyclingFixedTimeStep.create_action_sets(), exahype2.solvers.fv.rusanov.SubcyclingFixedTimeStepWithEnclaveTasking.SubcyclingFixedTimeStepWithEnclaveTasking.create_action_sets(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets(), exahype2.solvers.fv.SingleSweep.SingleSweep.create_data_structures(), exahype2.solvers.rkfd.OneSweepPerRungeKuttaStep.OneSweepPerRungeKuttaStep.create_data_structures(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.create_data_structures(), exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.create_data_structures(), dastgen2.attributes.Attribute.Attribute.get_accessor_name(), dastgen2.attributes.BooleanArray.BooleanArray.get_constructor_arguments(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_constructor_arguments(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_constructor_arguments(), api.solvers.CollocatedLowOrderDiscretisation.AssemblePetscMatrix.get_constructor_body(), dastgen2.attributes.BooleanArray.BooleanArray.get_first_plain_C_attribute(), dastgen2.attributes.DoubleArray.DoubleArray.get_first_plain_C_attribute(), dastgen2.attributes.IntegerArray.IntegerArray.get_first_plain_C_attribute(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_first_plain_C_attribute(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_first_plain_C_attribute(), dastgen2.attributes.Boolean.Boolean.get_method_body(), dastgen2.attributes.BooleanArray.BooleanArray.get_method_body(), dastgen2.attributes.Double.Double.get_method_body(), dastgen2.attributes.DoubleArray.DoubleArray.get_method_body(), dastgen2.attributes.Enumeration.Enumeration.get_method_body(), dastgen2.attributes.Integer.Integer.get_method_body(), dastgen2.attributes.IntegerArray.IntegerArray.get_method_body(), dastgen2.attributes.String.String.get_method_body(), dastgen2.attributes.UserDefinedType.UserDefinedType.get_method_body(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_method_body(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_method_body(), dastgen2.attributes.BooleanArray.BooleanArray.get_methods(), dastgen2.attributes.DoubleArray.DoubleArray.get_methods(), dastgen2.attributes.IntegerArray.IntegerArray.get_methods(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_methods(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_methods(), exahype2.solvers.aderdg.ADERDG.ADERDG.get_name_of_global_instance(), exahype2.solvers.elliptic.AMRMarker.AMRMarker.get_name_of_global_instance(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.get_name_of_global_instance(), exahype2.solvers.fv.FV.FV.get_name_of_global_instance(), exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_name_of_global_instance(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.get_name_of_global_instance(), dastgen2.attributes.Boolean.Boolean.get_plain_C_attributes(), dastgen2.attributes.BooleanArray.BooleanArray.get_plain_C_attributes(), dastgen2.attributes.Double.Double.get_plain_C_attributes(), dastgen2.attributes.DoubleArray.DoubleArray.get_plain_C_attributes(), dastgen2.attributes.Integer.Integer.get_plain_C_attributes(), dastgen2.attributes.IntegerArray.IntegerArray.get_plain_C_attributes(), dastgen2.attributes.String.String.get_plain_C_attributes(), dastgen2.attributes.UserDefinedType.UserDefinedType.get_plain_C_attributes(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_plain_C_attributes(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_plain_C_attributes(), dastgen2.attributes.String.String.get_setter_getter_name(), dastgen2.attributes.Boolean.Boolean.get_to_string(), dastgen2.attributes.BooleanArray.BooleanArray.get_to_string(), dastgen2.attributes.Double.Double.get_to_string(), dastgen2.attributes.DoubleArray.DoubleArray.get_to_string(), dastgen2.attributes.Enumeration.Enumeration.get_to_string(), dastgen2.attributes.Integer.Integer.get_to_string(), dastgen2.attributes.IntegerArray.IntegerArray.get_to_string(), dastgen2.attributes.UserDefinedType.UserDefinedType.get_to_string(), peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray.get_to_string(), peano4.dastgen2.Peano4IntegerArray.Peano4IntegerArray.get_to_string(), dastgen2.attributes.Attribute.Attribute.name(), exahype2.solvers.elliptic.ConstrainedPoissonEquationForMarkerOnCells.ConstrainedPoissonEquationForMarkerOnCells.name(), exahype2.solvers.fv.FV.FV.name(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.name(), solvers.api.Solver.Solver.name(), api.solvers.Solver.Solver.name(), solvers.api.Solver.Solver.typename(), and api.solvers.Solver.Solver.typename().

◆ _primary_or_grid_construction_or_initialisation_sweep_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._primary_or_grid_construction_or_initialisation_sweep_guard
protected

Definition at line 438 of file EnclaveTasking.py.

◆ _primary_or_initialisation_sweep_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._primary_or_initialisation_sweep_guard
protected

Definition at line 428 of file EnclaveTasking.py.

◆ _primary_sweep_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._primary_sweep_guard
protected

Definition at line 399 of file EnclaveTasking.py.

◆ _primary_sweep_or_plot_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._primary_sweep_or_plot_guard
protected

◆ _reconstructed_array_memory_location

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._reconstructed_array_memory_location
protected

Definition at line 688 of file EnclaveTasking.py.

◆ _refinement_criterion_implementation

◆ _secondary_sweep_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._secondary_sweep_guard
protected

Definition at line 450 of file EnclaveTasking.py.

◆ _secondary_sweep_or_grid_construction_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._secondary_sweep_or_grid_construction_guard
protected

Definition at line 460 of file EnclaveTasking.py.

◆ _secondary_sweep_or_grid_initialisation_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._secondary_sweep_or_grid_initialisation_guard
protected

Definition at line 475 of file EnclaveTasking.py.

◆ _secondary_sweep_or_grid_initialisation_or_plot_guard

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._secondary_sweep_or_grid_initialisation_or_plot_guard
protected

◆ _solver_template_file_class_name

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._solver_template_file_class_name
protected

◆ _use_split_loop

exahype2.solvers.fv.EnclaveTasking.EnclaveTasking._use_split_loop
protected

Definition at line 690 of file EnclaveTasking.py.

◆ enclave_task_priority

◆ make_copy_of_enclave_task_data


The documentation for this class was generated from the following file: