Derived application interface class that spawns a simulation code using a separate process, receives a process identifier, and communicates with the spawned process through files. More...

Inheritance diagram for ProcessHandleApplicInterface:

Public Member Functions
	ProcessHandleApplicInterface (const ProblemDescDB &problem_db)
	constructor More...

	~ProcessHandleApplicInterface ()
	destructor

Public Member Functions inherited from ProcessApplicInterface
	ProcessApplicInterface (const ProblemDescDB &problem_db)
	constructor

	~ProcessApplicInterface ()
	destructor

Public Member Functions inherited from ApplicationInterface
	ApplicationInterface (const ProblemDescDB &problem_db)
	constructor

	~ApplicationInterface ()
	destructor

Public Member Functions inherited from Interface
	Interface ()
	default constructor More...

	Interface (ProblemDescDB &problem_db)
	standard constructor for envelope More...

	Interface (const Interface &interface_in)
	copy constructor More...

virtual	~Interface ()
	destructor

Interface	operator= (const Interface &interface_in)
	assignment operator

virtual int	minimum_points (bool constraint_flag) const
	returns the minimum number of points required to build a particular ApproximationInterface (used by DataFitSurrModels).

virtual int	recommended_points (bool constraint_flag) const
	returns the recommended number of points required to build a particular ApproximationInterface (used by DataFitSurrModels).

virtual void	active_model_key (const Pecos::ActiveKey &key)
	activate an approximation state based on its key

virtual void	clear_model_keys ()
	reset initial state by removing all model keys for an approximation

virtual void	approximation_function_indices (const SizetSet &approx_fn_indices)
	set the (currently active) approximation function index set

virtual void	update_approximation (const Variables &vars, const IntResponsePair &response_pr)
	updates the anchor point for an approximation

virtual void	update_approximation (const RealMatrix &samples, const IntResponseMap &resp_map)
	updates the current data points for an approximation

virtual void	update_approximation (const VariablesArray &vars_array, const IntResponseMap &resp_map)
	updates the current data points for an approximation

virtual void	append_approximation (const Variables &vars, const IntResponsePair &response_pr)
	appends a single point to an existing approximation

virtual void	append_approximation (const RealMatrix &samples, const IntResponseMap &resp_map)
	appends multiple points to an existing approximation

virtual void	append_approximation (const VariablesArray &vars_array, const IntResponseMap &resp_map)
	appends multiple points to an existing approximation

virtual void	append_approximation (const IntVariablesMap &vars_map, const IntResponseMap &resp_map)
	appends multiple points to an existing approximation

virtual void	replace_approximation (const IntResponsePair &response_pr)
	replace the response for a single point within an existing approximation

virtual void	replace_approximation (const IntResponseMap &resp_map)
	replace responses for multiple points within an existing approximation

virtual void	track_evaluation_ids (bool track)
	assigns trackEvalIds to activate tracking of evaluation ids within surrogate data, enabling id-based lookups for data replacement

virtual void	build_approximation (const RealVector &c_l_bnds, const RealVector &c_u_bnds, const IntVector &di_l_bnds, const IntVector &di_u_bnds, const RealVector &dr_l_bnds, const RealVector &dr_u_bnds)
	builds the approximation

virtual void	export_approximation ()
	export the approximation to disk

virtual void	rebuild_approximation (const BitArray &rebuild_fns)
	rebuilds the approximation after a data update

virtual void	pop_approximation (bool save_data)
	removes data from last append from the approximation

virtual void	push_approximation ()
	retrieves approximation data from a previous state (negates pop)

virtual bool	push_available ()
	queries the approximation for the ability to retrieve a previous increment

virtual void	finalize_approximation ()
	finalizes the approximation by applying all trial increments

virtual void	combine_approximation ()
	combine the current approximation with previously stored data sets

virtual void	combined_to_active (bool clear_combined=true)
	promote the combined approximation to the currently active one

virtual void	clear_inactive ()
	clear inactive approximation data

virtual bool	advancement_available ()
	query for available advancements in approximation resolution controls

virtual bool	formulation_updated () const
	query for change in approximation formulation

virtual void	formulation_updated (bool update)
	assign an updated status for approximation formulation to force rebuild

virtual Real2DArray	cv_diagnostics (const StringArray &metric_types, unsigned num_folds)
	approximation cross-validation quality metrics per response function

virtual RealArray	challenge_diagnostics (const String &metric_type, const RealMatrix &challenge_pts)
	approximation challenge data metrics per response function

virtual void	clear_current_active_data ()
	clears current data from an approximation interface

virtual void	clear_active_data ()
	clears all data from an approximation interface

virtual SharedApproxData &	shared_approximation ()
	retrieve the SharedApproxData within an ApproximationInterface

virtual std::vector< Approximation > &	approximations ()
	retrieve the Approximations within an ApproximationInterface

virtual const Pecos::SurrogateData &	approximation_data (size_t fn_index)
	retrieve the approximation data from a particular Approximation within an ApproximationInterface

virtual const RealVectorArray &	approximation_coefficients (bool normalized=false)
	retrieve the approximation coefficients from each Approximation within an ApproximationInterface

virtual void	approximation_coefficients (const RealVectorArray &approx_coeffs, bool normalized=false)
	set the approximation coefficients within each Approximation within an ApproximationInterface

virtual const RealVector &	approximation_variances (const Variables &vars)
	retrieve the approximation variances from each Approximation within an ApproximationInterface

virtual const String2DArray &	analysis_components () const
	retrieve the analysis components, if available

virtual void	discrepancy_emulation_mode (short mode)
	set discrepancy emulation mode used for approximating response differences

IntResponseMap &	response_map ()
	return rawResponseMap

void	cache_unmatched_response (int raw_id)
	migrate an unmatched response record from rawResponseMap to cachedResponseMap

void	cache_unmatched_responses ()
	migrate all remaining response records from rawResponseMap to cachedResponseMap

void	assign_rep (std::shared_ptr< Interface > interface_rep)
	assign letter or replace existing letter with a new one More...

void	assign_rep (Interface *interface_rep, bool ref_count_incr=false)
	assign letter or replace existing letter with a new one DEPRECATED, but left for library mode clients to migrate: transfers memory ownership to the contained shared_ptr; ref_count_incr is ignored More...

unsigned short	interface_type () const
	returns the interface type

const String &	interface_id () const
	returns the interface identifier

int	evaluation_id () const
	returns the value of the (total) evaluation id counter for the interface

void	fine_grained_evaluation_counters (size_t num_fns)
	set fineGrainEvalCounters to true and initialize counters if needed

void	init_evaluation_counters (size_t num_fns)
	initialize fine grained evaluation counters, sizing if needed

void	set_evaluation_reference ()
	set evaluation count reference points for the interface

void	print_evaluation_summary (std::ostream &s, bool minimal_header, bool relative_count) const
	print an evaluation summary for the interface

bool	multi_proc_eval () const
	returns a flag signaling the use of multiprocessor evaluation partitions

bool	iterator_eval_dedicated_master () const
	returns a flag signaling the use of a dedicated master processor at the iterator-evaluation scheduling level

bool	is_null () const
	function to check interfaceRep (does this envelope contain a letter?)

std::shared_ptr< Interface >	interface_rep ()
	function to return the letter

void	eval_tag_prefix (const String &eval_id_str, bool append_iface_id=true)
	set the evaluation tag prefix (does not recurse) More...

Protected Member Functions
int	synchronous_local_analysis (int analysis_id)

void	init_communicators_checks (int max_eval_concurrency)

void	set_communicators_checks (int max_eval_concurrency)

void	map_bookkeeping (pid_t pid, int fn_eval_id)
	bookkeeping of process and evaluation ids for asynchronous maps

pid_t	create_evaluation_process (bool block_flag)

virtual pid_t	create_analysis_process (bool block_flag, bool new_group)=0
	spawn a child process for an analysis component within an evaluation

virtual size_t	wait_local_analyses ()=0
	wait for asynchronous analyses on the local processor, completing at least one job

virtual size_t	test_local_analyses_send (int analysis_id)=0
	test for asynchronous analysis completions on the local processor and return results for any completions by sending messages

virtual void	join_evaluation_process_group (bool new_group)
	create (if new_group) and join the process group for asynch evaluations

virtual void	join_analysis_process_group (bool new_group)
	create (if new_group) and join the process group for asynch analyses

virtual void	evaluation_process_group_id (pid_t pgid)
	set evalProcGroupId

virtual pid_t	evaluation_process_group_id () const
	return evalProcGroupId

virtual void	analysis_process_group_id (pid_t pgid)
	set analysisProcGroupId

virtual pid_t	analysis_process_group_id () const
	return analysisProcGroupId

void	process_local_evaluation (PRPQueue &prp_queue, const pid_t pid)
	Common processing code used by {wait,test}_local_evaluations.

void	check_wait (pid_t pid, int status)
	check the exit status of a forked process and abort if an error code was returned More...

void	asynchronous_local_analyses (int start, int end, int step)
	execute analyses asynchronously on the local processor More...

void	serve_analyses_asynch ()
	serve the analysis scheduler and execute analysis jobs asynchronously More...

void	ifilter_argument_list ()
	set argList for execution of the input filter

void	ofilter_argument_list ()
	set argList for execution of the output filter

void	driver_argument_list (int analysis_id)
	set argList for execution of the specified analysis driver

void	create_command_arguments (boost::shared_array< const char * > &av, StringArray &driver_and_args)
	parse argList into argument array av suitable for passing to execvp, appending parameters and results filenames if requested by commandLineArgs More...

Protected Member Functions inherited from ProcessApplicInterface
void	derived_map (const Variables &vars, const ActiveSet &set, Response &response, int fn_eval_id)
	Called by map() and other functions to execute the simulation in synchronous mode. The portion of performing an evaluation that is specific to a derived class.

void	derived_map_asynch (const ParamResponsePair &pair)
	Called by map() and other functions to execute the simulation in asynchronous mode. The portion of performing an asynchronous evaluation that is specific to a derived class.

void	wait_local_evaluations (PRPQueue &prp_queue)
	For asynchronous function evaluations, this method is used to detect completion of jobs and process their results. It provides the processing code that is specific to derived classes. This version waits for at least one completion.

void	test_local_evaluations (PRPQueue &prp_queue)
	For asynchronous function evaluations, this method is used to detect completion of jobs and process their results. It provides the processing code that is specific to derived classes. This version is nonblocking and will return without any completions if none are immediately available.

const StringArray &	analysis_drivers () const
	retrieve the analysis drivers specification for application interfaces

void	file_cleanup () const

void	file_and_workdir_cleanup (const bfs::path &params_path, const bfs::path &results_path, const bfs::path &workdir_path, const String &tag) const

void	remove_params_results_files (const bfs::path &params_path, const bfs::path &results_path) const
	Remove (potentially autotagged for multiple programs) parameters and results files with passed root names.

void	autotag_files (const bfs::path &params_path, const bfs::path &results_path, const String &eval_id_tag) const
	Utility to automatically tag parameters and results files with passed root names (the files may already need per-program tagging) More...

virtual void	wait_local_evaluation_sequence (PRPQueue &prp_queue)=0
	version of wait_local_evaluations() managing of set of individual asynchronous evaluations

virtual void	test_local_evaluation_sequence (PRPQueue &prp_queue)=0
	version of test_local_evaluations() managing of set of individual asynchronous evaluations

void	wait_local_evaluation_batch (PRPQueue &prp_queue)
	batch version of wait_local_evaluations()

void	test_local_evaluation_batch (PRPQueue &prp_queue)
	batch version of test_local_evaluations()

void	synchronous_local_analyses (int start, int end, int step)
	execute analyses synchronously on the local processor More...

void	define_filenames (const String &eval_id_tag)
	define modified filenames from user input by handling Unix temp file and optionally tagging with given eval_id_tag

void	write_parameters_files (const Variables &vars, const ActiveSet &set, const Response &response, const int id)
	write the parameters data and response request data to one or more parameters files

void	read_results_files (Response &response, const int id, const String &eval_id_tag)
	read the response object from one or more results files using full eval_id_tag passed

bfs::path	get_workdir_name ()
	construct a work directory name (tmp or named), with optional tag

void	prepare_process_environment ()
	set PATH, environment variables, and change directory prior to fork/system/spawn More...

void	reset_process_environment ()
	reset PATH and current directory after system/spawn (workdir case) More...

Protected Member Functions inherited from ApplicationInterface
void	init_communicators (const IntArray &message_lengths, int max_eval_concurrency)
	allocate communicator partitions for concurrent evaluations within an iterator and concurrent multiprocessor analyses within an evaluation.

void	set_communicators (const IntArray &message_lengths, int max_eval_concurrency)
	set the local parallel partition data for an interface (the partitions are already allocated in ParallelLibrary).

void	init_serial ()

int	asynch_local_evaluation_concurrency () const
	return asynchLocalEvalConcurrency

short	interface_synchronization () const
	return interfaceSynchronization

bool	evaluation_cache () const
	return evalCacheFlag

bool	restart_file () const
	return evalCacheFlag

String	final_eval_id_tag (int fn_eval_id)
	form and return the final evaluation ID tag, appending iface ID if needed

void	map (const Variables &vars, const ActiveSet &set, Response &response, bool asynch_flag=false)
	Provides a "mapping" of variables to responses using a simulation. Protected due to Interface letter-envelope idiom. More...

void	manage_failure (const Variables &vars, const ActiveSet &set, Response &response, int failed_eval_id)
	manages a simulation failure using abort/retry/recover/continuation

const IntResponseMap &	synchronize ()
	executes a blocking schedule for asynchronous evaluations in the beforeSynchCorePRPQueue and returns all jobs More...

const IntResponseMap &	synchronize_nowait ()
	executes a nonblocking schedule for asynchronous evaluations in the beforeSynchCorePRPQueue and returns a partial set of completed jobs More...

void	serve_evaluations ()
	run on evaluation servers to serve the iterator master More...

void	stop_evaluation_servers ()
	used by the iterator master to terminate evaluation servers More...

bool	check_multiprocessor_analysis (bool warn)
	checks on multiprocessor analysis configuration

bool	check_asynchronous (bool warn, int max_eval_concurrency)
	checks on asynchronous configuration (for direct interfaces)

bool	check_multiprocessor_asynchronous (bool warn, int max_eval_concurrency)
	checks on asynchronous settings for multiprocessor partitions

String	final_batch_id_tag ()
	form and return the final batch ID tag

void	master_dynamic_schedule_analyses ()
	blocking dynamic schedule of all analyses within a function evaluation using message passing More...

void	serve_analyses_synch ()
	serve the master analysis scheduler and manage one synchronous analysis job at a time More...

Protected Member Functions inherited from Interface
	Interface (BaseConstructor, const ProblemDescDB &problem_db)
	constructor initializes the base class part of letter classes (BaseConstructor overloading avoids infinite recursion in the derived class constructors - Coplien, p. 139) More...

	Interface (NoDBBaseConstructor, size_t num_fns, short output_level)
	constructor initializes the base class part of letter classes (NoDBBaseConstructor used for on the fly instantiations without a DB)

void	init_algebraic_mappings (const Variables &vars, const Response &response)
	Define algebraicACVIndices, algebraicACVIds, and algebraicFnIndices.

void	asv_mapping (const ActiveSet &total_set, ActiveSet &algebraic_set, ActiveSet &core_set)
	define the evaluation requirements for algebraic_mappings() (algebraic_set) and the core Application/Approximation mapping (core_set) from the total Interface evaluation requirements (total_set)

void	asv_mapping (const ActiveSet &algebraic_set, ActiveSet &total_set)
	map an algebraic ASV back to original total ordering for asynch recovery

void	algebraic_mappings (const Variables &vars, const ActiveSet &algebraic_set, Response &algebraic_response)
	evaluate the algebraic_response using the AMPL solver library and the data extracted from the algebraic_mappings file

void	response_mapping (const Response &algebraic_response, const Response &core_response, Response &total_response)
	combine the response from algebraic_mappings() with the response from derived_map() to create the total response More...

Protected Attributes
std::map< pid_t, int >	evalProcessIdMap
	map of fork process id's to function evaluation id's for asynchronous evaluations

std::map< pid_t, int >	analysisProcessIdMap
	map of fork process id's to analysis job id's for asynchronous analyses

std::vector< std::string >	argList
	an array of strings for use with execvp(const char , char const ). These are converted to an array of const char's in fork_program().

Protected Attributes inherited from ProcessApplicInterface
bool	fileTagFlag
	flags tagging of parameter/results files

bool	fileSaveFlag
	flags retention of parameter/results files

bool	commandLineArgs
	flag indicating use of passing of filenames as command line arguments to the analysis drivers and input/output filters

std::unique_ptr< ParametersFileWriter >	paramsFileWriter
	parameters file writer

std::unique_ptr< ResultsFileReader >	resultsFileReader
	results file reader

bool	multipleParamsFiles
	flag indicating the need for separate parameters files for multiple analysis drivers

std::string	iFilterName
	the name of the input filter (input_filter user specification)

std::string	oFilterName
	the name of the output filter (output_filter user specification)

std::vector< String >	programNames
	the names of the analysis code programs (analysis_drivers user specification)

std::string	specifiedParamsFileName
	the name of the parameters file from user specification

std::string	paramsFileName
	the parameters file name actually used (modified with tagging or temp files); only valid from define_filenames to write_parameters_files

std::string	paramsFileWritten
	actual, qualified name of the params file written, possibly with workdir

std::string	specifiedResultsFileName
	the name of the results file from user specification

std::string	resultsFileName
	the results file name actually used (modified with tagging or temp files); only valid from define_filenames to write_parameters_files

std::string	resultsFileWritten
	actual, qualified name of the results file written, possibly with workdir

std::string	fullEvalId
	complete evalIdTag, possibly including hierarchical tagging and final eval id, but not program numbers, for passing to write_parameters_files

bool	allowExistingResults
	by default analysis code interfaces delete results files if they exist; user may override with this flag and we'll try to gather and only fork if needed

std::map< int, PathTriple >	fileNameMap
	Maps function evaluation ID to triples (parameters, results, and workdir) paths used in spawning function evaluations. Workdir will be empty if not created specifically for this eval.

bool	useWorkdir
	whether to use a work_directory

std::string	workDirName
	work_directory name, if specified...

bool	dirTag
	whether to tag the working directory

bool	dirSave
	whether dir_save was specified

bfs::path	curWorkdir
	active working directory for this evaluation; valid only from define_filenames to create_evaluation_process

bfs::path	createdDir
	non-empty if created for this eval; valid only from define_filenames to write_parameters_files

StringArray	linkFiles
	template directory (if specified)

StringArray	copyFiles
	template files (if specified)

bool	templateReplace
	whether to replace existing files

Protected Attributes inherited from ApplicationInterface
ParallelLibrary &	parallelLib
	reference to the ParallelLibrary object used to manage MPI partitions for the concurrent evaluations and concurrent analyses parallelism levels

bool	batchEval
	flag indicating usage of batch evaluation facilities, where a set of jobs is launched and scheduled as a unit rather than individually

bool	asynchFlag
	flag indicating usage of asynchronous evaluation

int	batchIdCntr
	maintain a count of the batches

bool	suppressOutput
	flag for suppressing output on slave processors

int	evalCommSize
	size of evalComm

int	evalCommRank
	processor rank within evalComm

int	evalServerId
	evaluation server identifier

bool	eaDedMasterFlag
	flag for dedicated master partitioning at ea level

int	analysisCommSize
	size of analysisComm

int	analysisCommRank
	processor rank within analysisComm

int	analysisServerId
	analysis server identifier

int	numAnalysisServers
	current number of analysis servers

bool	multiProcAnalysisFlag
	flag for multiprocessor analysis partitions

bool	asynchLocalAnalysisFlag
	flag for asynchronous local parallelism of analyses

int	asynchLocalAnalysisConcurrency
	limits the number of concurrent analyses in asynchronous local scheduling and specifies hybrid concurrency when message passing

int	asynchLocalEvalConcSpec
	user specification for asynchronous local evaluation concurrency

int	asynchLocalAnalysisConcSpec
	user specification for asynchronous local analysis concurrency

int	numAnalysisDrivers
	the number of analysis drivers used for each function evaluation (from the analysis_drivers interface specification)

IntSet	completionSet
	the set of completed fn_eval_id's populated by wait_local_evaluations() and test_local_evaluations()

String	failureMessage
	base message for managing failed evals; will be followed with more details in screen output

Protected Attributes inherited from Interface
unsigned short	interfaceType
	the interface type: enum for system, fork, direct, grid, or approximation

String	interfaceId
	the interface specification identifier string from the DAKOTA input file

bool	algebraicMappings
	flag for the presence of algebraic_mappings that define the subset of an Interface's parameter to response mapping that is explicit and algebraic.

bool	coreMappings
	flag for the presence of non-algebraic mappings that define the core of an Interface's parameter to response mapping (using analysis_drivers for ApplicationInterface or functionSurfaces for ApproximationInterface).

short	outputLevel
	output verbosity level: {SILENT,QUIET,NORMAL,VERBOSE,DEBUG}_OUTPUT

int	currEvalId
	identifier for the current evaluation, which may differ from the evaluation counters in the case of evaluation scheduling; used on iterator master as well as server processors. Currently, this is set prior to all invocations of derived_map() for all processors.

bool	fineGrainEvalCounters
	controls use of fn val/grad/hess counters for detailed evaluation report

int	evalIdCntr
	total interface evaluation counter

int	newEvalIdCntr
	new (non-duplicate) interface evaluation counter

int	evalIdRefPt
	iteration reference point for evalIdCntr

int	newEvalIdRefPt
	iteration reference point for newEvalIdCntr

IntArray	fnValCounter
	number of value evaluations by resp fn

IntArray	fnGradCounter
	number of gradient evaluations by resp fn

IntArray	fnHessCounter
	number of Hessian evaluations by resp fn

IntArray	newFnValCounter
	number of new value evaluations by resp fn

IntArray	newFnGradCounter
	number of new gradient evaluations by resp fn

IntArray	newFnHessCounter
	number of new Hessian evaluations by resp fn

IntArray	fnValRefPt
	iteration reference point for fnValCounter

IntArray	fnGradRefPt
	iteration reference point for fnGradCounter

IntArray	fnHessRefPt
	iteration reference point for fnHessCounter

IntArray	newFnValRefPt
	iteration reference point for newFnValCounter

IntArray	newFnGradRefPt
	iteration reference point for newFnGradCounter

IntArray	newFnHessRefPt
	iteration reference point for newFnHessCounter

IntResponseMap	rawResponseMap
	Set of responses returned by either a blocking or nonblocking schedule. More...

IntResponseMap	cachedResponseMap
	Set of available asynchronous responses completed within a blocking or nonblocking scheduler that cannot be processed in a higher level context and need to be stored for later.

StringArray	fnLabels
	response function descriptors (used in print_evaluation_summary() and derived direct interface classes); initialized in map() functions due to potential updates after construction

bool	multiProcEvalFlag
	flag for multiprocessor evaluation partitions (evalComm)

bool	ieDedMasterFlag
	flag for dedicated master partitioning at the iterator level

String	evalTagPrefix
	set of period-delimited evaluation ID tags to use in evaluation tagging

bool	appendIfaceId
	whether to append the interface ID to the prefix during map (default true)

String2DArray	analysisComponents
	Analysis components for interface types that support them.

Detailed Description

Derived application interface class that spawns a simulation code using a separate process, receives a process identifier, and communicates with the spawned process through files.

ProcessHandleApplicInterface is subclassed for fork/execvp/waitpid (Unix) and spawnvp (Windows).

Constructor & Destructor Documentation

◆ ProcessHandleApplicInterface()

ProcessHandleApplicInterface ( const ProblemDescDB & problem_db )

inline

constructor

argList sized 3 for [driver name, input file, output file]

Member Function Documentation

◆ synchronous_local_analysis()

int synchronous_local_analysis ( int analysis_id )

inlineprotectedvirtual

This code provides the derived function used by ApplicationInterface:: serve_analyses_synch() as well as a convenience function for ProcessHandleApplicInterface::synchronous_local_analyses() below.

Reimplemented from ApplicationInterface.

References ProcessHandleApplicInterface::create_analysis_process(), and ProcessHandleApplicInterface::driver_argument_list().

◆ init_communicators_checks()

void init_communicators_checks ( int max_eval_concurrency )

inlineprotectedvirtual

No derived interface plug-ins, so perform construct-time checks. However, process init issues as warnings since some contexts (e.g., EnsembleSurrModel) initialize more configurations than will be used.

Reimplemented from ApplicationInterface.

References ApplicationInterface::check_multiprocessor_analysis(), and ApplicationInterface::check_multiprocessor_asynchronous().

◆ set_communicators_checks()

void set_communicators_checks ( int max_eval_concurrency )

inlineprotectedvirtual

Process run-time issues as hard errors.

Reimplemented from ApplicationInterface.

References Dakota::abort_handler(), ApplicationInterface::check_multiprocessor_analysis(), and ApplicationInterface::check_multiprocessor_asynchronous().

◆ create_evaluation_process()

pid_t create_evaluation_process ( bool block_flag )

protectedvirtual

Manage the input filter, 1 or more analysis programs, and the output filter in blocking or nonblocking mode as governed by block_flag. In the case of a single analysis and no filters, a single fork is performed, while in other cases, an initial fork is reforked multiple times. Called from derived_map() with block_flag == BLOCK and from derived_map_asynch() with block_flag == FALL_THROUGH. Uses create_analysis_process() to spawn individual program components within the function evaluation.

Implements ProcessApplicInterface.

◆ check_wait()

void check_wait	(	pid_t	pid,
		int	status
	)

protected

check the exit status of a forked process and abort if an error code was returned

Check to see if the process terminated abnormally (WIFEXITED(status)==0) or if either execvp or the application returned a status code of -1 (WIFEXITED(status)!=0 && (signed char)WEXITSTATUS(status)==-1). If one of these conditions is detected, output a failure message and abort. Note: the application code should not return a status code of -1 unless an immediate abort of dakota is wanted. If for instance, failure capturing is to be used, the application code should write the word "FAIL" to the appropriate results file and return a status code of 0 through exit().

References Dakota::abort_handler().

Referenced by ForkApplicInterface::create_analysis_process(), SpawnApplicInterface::test_local_analyses_send(), SpawnApplicInterface::test_local_evaluation_sequence(), ForkApplicInterface::wait(), SpawnApplicInterface::wait_local_analyses(), and SpawnApplicInterface::wait_local_evaluation_sequence().

◆ asynchronous_local_analyses()

void asynchronous_local_analyses	(	int	start,
		int	end,
		int	step
	)

protected

execute analyses asynchronously on the local processor

Schedule analyses asynchronously on the local processor using a dynamic scheduling approach (start to end in step increments). Concurrency is limited by asynchLocalAnalysisConcurrency. Modeled after ApplicationInterface::asynchronous_local_evaluations(). NOTE: This function should be elevated to ApplicationInterface if and when another derived interface class supports asynchronous local analyses.

References Dakota::abort_handler(), ProcessHandleApplicInterface::analysisProcessIdMap, ApplicationInterface::asynchLocalAnalysisConcurrency, ProcessHandleApplicInterface::create_analysis_process(), ProcessHandleApplicInterface::driver_argument_list(), ApplicationInterface::numAnalysisDrivers, and ProcessHandleApplicInterface::wait_local_analyses().

Referenced by ProcessHandleApplicInterface::create_evaluation_process().

◆ serve_analyses_asynch()

void serve_analyses_asynch ( )

protected

serve the analysis scheduler and execute analysis jobs asynchronously

This code runs multiple asynch analyses on each server. It is modeled after ApplicationInterface::serve_evaluations_asynch(). NOTE: This fn should be elevated to ApplicationInterface if and when another derived interface class supports hybrid analysis parallelism.

References Dakota::abort_handler(), ProcessHandleApplicInterface::analysisProcessIdMap, ApplicationInterface::asynchLocalAnalysisConcurrency, ProcessHandleApplicInterface::create_analysis_process(), ProcessHandleApplicInterface::driver_argument_list(), ParallelLibrary::irecv_ea(), ApplicationInterface::numAnalysisDrivers, ApplicationInterface::parallelLib, ParallelLibrary::recv_ea(), ParallelLibrary::test(), and ProcessHandleApplicInterface::test_local_analyses_send().

Referenced by ProcessHandleApplicInterface::create_evaluation_process().

◆ create_command_arguments()

void create_command_arguments	(	boost::shared_array< const char * > &	av,
		StringArray &	driver_and_args
	)

protected

parse argList into argument array av suitable for passing to execvp, appending parameters and results filenames if requested by commandLineArgs

This function will split the analysis command in argList[0] based on whitespace, but preserve spaces within quoted strings, such that quoted strings can be passed as single command arguments. NOTE: This function allocates memory in av that might be implicitly freed when the child exits (control never returns to caller). driver_and_args needs to be a return argument because av will contain pointers into its c_str()'s when done.

References ProcessHandleApplicInterface::argList, ProcessApplicInterface::commandLineArgs, Dakota::substitute_params_and_results(), and WorkdirHelper::tokenize_driver().

Referenced by ForkApplicInterface::create_analysis_process(), and SpawnApplicInterface::create_analysis_process().

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

ProcessHandleApplicInterface.hpp
ProcessHandleApplicInterface.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ProcessHandleApplicInterface()

Member Function Documentation

◆ synchronous_local_analysis()

◆ init_communicators_checks()

◆ set_communicators_checks()

◆ create_evaluation_process()

◆ check_wait()

◆ asynchronous_local_analyses()

◆ serve_analyses_asynch()

◆ create_command_arguments()