smpd.h

fortran并行计算包

    int  bNoTTY;
    SMPD_BOOL bPasswordProtect;
    char SMPDPassword[100];
    char passphrase[SMPD_PASSPHRASE_MAX_LENGTH];
    SMPD_BOOL logon;
    char UserAccount[SMPD_MAX_ACCOUNT_LENGTH];
    char UserPassword[SMPD_MAX_PASSWORD_LENGTH];
    int  cur_tag;
    int  dbg_state;
    char dbg_filename[SMPD_MAX_FILENAME];
    long dbg_file_size;
    int  have_dbs;
    char kvs_name[SMPD_MAX_DBS_NAME_LEN];
    char domain_name[SMPD_MAX_DBS_NAME_LEN];
#ifdef HAVE_WINDOWS_H
    HANDLE hCloseStdinThreadEvent;
    HANDLE hStdinThread;
#endif
#ifdef USE_PTHREAD_STDIN_REDIRECTION
    pthread_t stdin_thread;
    int stdin_read, stdin_write;
#endif
    int do_console;
    int port;
    SMPD_BOOL is_singleton_client;
    /* Port to connect back to a singleton process */
    int singleton_client_port;
    char console_host[SMPD_MAX_HOST_LENGTH];
    smpd_host_node_t *host_list;
    smpd_launch_node_t *launch_list;
    int credentials_prompt;
    int do_multi_color_output;
    int no_mpi;
    int output_exit_codes;
    int local_root;
    int use_iproot;
    int use_process_session;
    int nproc, nproc_launched, nproc_exited;
    SMPD_BOOL verbose;
    /*SMPD_BOOL shutdown, restart, validate, do_status;*/ /* built in commands */
    smpd_builtin_commands_t builtin_cmd;
#ifdef HAVE_WINDOWS_H
    BOOL bOutputInitialized;
    HANDLE hOutputMutex;
    HANDLE hLaunchProcessMutex;
#endif
#ifdef USE_WIN_MUTEX_PROTECT
    HANDLE hDBSMutex;
#endif
    smpd_database_node_t *pDatabase;
    smpd_database_node_t *pDatabaseIter;
    int nInitDBSRefCount;
    smpd_barrier_node_t *barrier_list;
#ifdef HAVE_WINDOWS_H
    SERVICE_STATUS ssStatus;
    SERVICE_STATUS_HANDLE sshStatusHandle;
    HANDLE hBombDiffuseEvent;
    HANDLE hBombThread;
#endif
    SMPD_BOOL service_stop;
    SMPD_BOOL noprompt;
    char smpd_filename[SMPD_MAX_FILENAME];
    SMPD_BOOL stdin_toall, stdin_redirecting;
    smpd_host_node_t *default_host_list, *cur_default_host;
    int cur_default_iproc;
#ifdef HAVE_WINDOWS_H
    HANDLE hSMPDDataMutex;
#endif
    char printf_buffer[SMPD_MAX_DBG_PRINTF_LENGTH];
    int state_machine_ret_val;
    SMPD_BOOL exit_on_done;
    int tree_parent;
    int tree_id;
    smpd_host_node_t *s_host_list, *s_cur_host;
    int s_cur_count;
    SMPD_BOOL use_inherited_handles;
    smpd_process_group_t *pg_list;
    SMPD_BOOL use_abort_exit_code;
    int abort_exit_code;
    SMPD_BOOL verbose_abort_output;
    int mpiexec_exit_code;
    SMPD_BOOL map0to1;
    SMPD_BOOL rsh_mpiexec;
    SMPD_BOOL mpiexec_inorder_launch;
    SMPD_BOOL mpiexec_run_local;
#ifdef HAVE_WINDOWS_H
    HANDLE timeout_thread;
#else
#ifdef HAVE_PTHREADS_H
    pthread_t timeout_thread;
#endif
#endif
    int timeout;
    MPIDU_Sock_t timeout_sock;
    MPIDU_Sock_t mpiexec_abort_sock;
    SMPD_BOOL use_pmi_server;
    char *mpiexec_argv0;
    char encrypt_prefix[SMPD_MAX_PASSWORD_LENGTH];
    SMPD_BOOL plaintext;
    SMPD_BOOL use_sspi, use_delegation, use_sspi_job_key;
#ifdef HAVE_WINDOWS_H
    PSecurityFunctionTable sec_fn;
#endif
    smpd_sspi_client_context_t *sspi_context_list;
    char job_key[SMPD_SSPI_JOB_KEY_LENGTH];
    char job_key_account[SMPD_MAX_ACCOUNT_LENGTH];
    char job_key_password[SMPD_MAX_PASSWORD_LENGTH];
    char key[SMPD_MAX_NAME_LENGTH];
    char val[SMPD_MAX_VALUE_LENGTH];
    SMPD_BOOL do_console_returns;
    char env_channel[10];
    char env_dll[SMPD_MAX_FILENAME];
    char env_wrap_dll[SMPD_MAX_FILENAME];
    smpd_delayed_spawn_node_t *delayed_spawn_queue;
    SMPD_BOOL spawning;
    int user_index;
    SMPD_BOOL prefix_output;
} smpd_global_t;

extern smpd_global_t smpd_process;


/* function prototypes */
#if defined(__cplusplus)
extern "C" {
#endif

int smpd_parse_command_args(int *argcp, char **argvp[]);
#ifdef HAVE_WINDOWS_H
char *smpd_encode_handle(char *str, HANDLE h);
HANDLE smpd_decode_handle(char *str);
#endif
void smpd_print_options(void);
int smpd_entry_point(void);
int smpd_enter_at_state(MPIDU_Sock_set_t set, smpd_state_t state);
int smpd_wait_process(smpd_pwait_t wait, int *exit_code_ptr);
int smpd_init_process(void);
int smpd_init_printf(void);
int smpd_finalize_printf(void);
int smpd_init_context(smpd_context_t *context, smpd_context_type_t type, MPIDU_Sock_set_t set, MPIDU_Sock_t sock, int id);
int smpd_init_command(smpd_command_t *cmd);
int smpd_create_context(smpd_context_type_t type, MPIDU_Sock_set_t set, MPIDU_Sock_t sock, int id, smpd_context_t **context_pptr);
int smpd_create_command(char *cmd_str, int src, int dest, int want_reply, smpd_command_t **cmd_pptr);
int smpd_create_command_copy(smpd_command_t *src_ptr, smpd_command_t **cmd_pptr);
int smpd_free_command(smpd_command_t *cmd_ptr);
int smpd_free_context(smpd_context_t *context);
int smpd_add_command_arg(smpd_command_t *cmd_ptr, char *param, char *value);
int smpd_add_command_int_arg(smpd_command_t *cmd_ptr, char *param, int value);
int smpd_add_command_binary_arg(smpd_command_t *cmd_ptr, char *param, void *buffer, int length);
int smpd_parse_command(smpd_command_t *cmd_ptr);
int smpd_post_read_command(smpd_context_t *context);
int smpd_post_write_command(smpd_context_t *context, smpd_command_t *cmd);
int smpd_package_command(smpd_command_t *cmd);
int smpd_read_string(MPIDU_Sock_t sock, char *str, int maxlen);
int smpd_write_string(MPIDU_Sock_t sock, char *str);
int smpd_read(MPIDU_Sock_t sock, void *buf, MPIDU_Sock_size_t len);
int smpd_write(MPIDU_Sock_t sock, void *buf, MPIDU_Sock_size_t len);
int smpd_dbg_printf(char *str, ...);
int smpd_err_printf(char *str, ...);
int smpd_enter_fn(char *fcname);
int smpd_exit_fn(char *fcname);
SMPD_BOOL smpd_option_on(const char *option);
int smpd_get_user_data(const char *key, char *value, int value_len);
int smpd_get_smpd_data(const char *key, char *value, int value_len);
int smpd_get_user_data_default(const char *key, char *value, int value_len);
int smpd_get_smpd_data_default(const char *key, char *value, int value_len);
int smpd_set_user_data(const char *key, const char *value);
int smpd_set_smpd_data(const char *key, const char *value);
int smpd_delete_user_data(const char *key);
int smpd_delete_smpd_data(const char *key);
int smpd_getpid(void);
char * get_sock_error_string(int error);
void smpd_get_password(char *password);
void smpd_get_account_and_password(char *account, char *password);
int smpd_get_credentials_from_parent(MPIDU_Sock_set_t set, MPIDU_Sock_t sock);
int smpd_get_smpd_password_from_parent(MPIDU_Sock_set_t set, MPIDU_Sock_t sock);
int smpd_get_opt(int *argc, char ***argv, char * flag);
int smpd_get_opt_int(int *argc, char ***argv, char * flag, int *n);
int smpd_get_opt_long(int *argc, char ***argv, char * flag, long *n);
int smpd_get_opt_double(int *argc, char ***argv, char * flag, double *d);
int smpd_get_opt_string(int *argc, char ***argv, char * flag, char *str, int len);
int smpd_get_opt_two_strings(int *argc, char ***argv, char * flag, char *str1, int len1, char *str2, int len2);
int smpd_get_win_opt_string(int *argc, char ***argv, char * flag, char *str, int len);
#ifdef HAVE_WINDOWS_H
void smpd_parse_account_domain(const char *domain_account, char *account, char *domain);
int smpd_get_user_handle(char *account, char *domain, char *password, HANDLE *handle_ptr);
int smpd_get_user_name(char *account, char *domain, char *full_domain);
int smpd_make_socket_loop(SOCKET *pRead, SOCKET *pWrite);
int smpd_make_socket_loop_choose(SOCKET *pRead, int read_overlapped, SOCKET *pWrite, int write_overlapped);
#endif
int smpd_generate_session_header(char *str, int session_id);
int smpd_interpret_session_header(char *str);
int smpd_command_destination(int dest, smpd_context_t **dest_context);
int smpd_forward_command(smpd_context_t *src, smpd_context_t *dest);
int smpd_launch_process(smpd_process_t *process, int priorityClass, int priority, int dbg, MPIDU_Sock_set_t set);
int smpd_encode_buffer(char *dest, int dest_length, const char *src, int src_length, int *num_encoded);
int smpd_decode_buffer(const char *str, char *dest, int length, int *num_decoded);
int smpd_create_process_struct(int rank, smpd_process_t **process_ptr);
int smpd_free_process_struct(smpd_process_t *process);
char * smpd_get_context_str(smpd_context_t *context);
int smpd_gen_authentication_strings(char *phrase, char *append, char *crypted);
#ifdef HAVE_WINDOWS_H
int smpd_start_win_mgr(smpd_context_t *context, SMPD_BOOL use_context_user_handle);
#else
int smpd_start_unx_mgr(smpd_context_t *context);
#endif
#ifdef HAVE_WINDOWS_H
void smpd_stdin_thread(SOCKET hWrite);
#endif
#ifdef USE_PTHREAD_STDIN_REDIRECTION
void *smpd_pthread_stdin_thread(void *p);
int smpd_cancel_stdin_thread(void);
#endif
int smpd_handle_command(smpd_context_t *context);
int smpd_create_command_from_stdin(char *str, smpd_command_t **cmd_pptr);
int smpd_handle_barrier_command(smpd_context_t *context);
int smpd_post_abort_command(char *fmt, ...);
int smpd_kill_all_processes(void);
int smpd_exit(int exitcode);
#ifdef HAVE_WINDOWS_H
void smpd_translate_win_error(int error, char *msg, int maxlen, char *prepend, ...);
#else
typedef void smpd_sig_fn_t( int );
smpd_sig_fn_t *smpd_signal( int signo, smpd_sig_fn_t func );
#endif
SMPD_BOOL smpd_get_full_path_name(const char *exe, int maxlen, char *path, char **namepart);
SMPD_BOOL smpd_search_path(const char *path, const char *exe, int maxlen, char *str);
#ifdef HAVE_WINDOWS_H
int smpd_process_from_registry(smpd_process_t *process);
int smpd_process_to_registry(smpd_process_t *process, char *actual_exe);
int smpd_clear_process_registry(void);
int smpd_validate_process_registry(void);
SMPD_BOOL smpd_read_password_from_registry(int index, char *szAccount, char *szPassword);
SMPD_BOOL smpd_save_password_to_registry(int index, const char *szAccount, const char *szPassword, SMPD_BOOL persistent);
SMPD_BOOL smpd_delete_current_password_registry_entry(int index);
int smpd_cache_password(const char *account, const char *password);
SMPD_BOOL smpd_get_cached_password(char *account, char *password);
int smpd_delete_cached_password(void);
#endif
int smpd_do_console(void);
int smpd_restart(void);
SMPD_BOOL smpd_snprintf_update(char **str_pptr, int *len_ptr, char *str_format, ...);
const char * smpd_get_state_string(smpd_state_t state);
const char * smpd_get_cmd_state_string(smpd_command_state_t state);
SMPD_BOOL smpd_command_to_string(char **str_pptr, int *len_ptr, int indent, smpd_command_t *cmd_ptr);
SMPD_BOOL smpd_process_to_string(char **str_pptr, int *len_ptr, int indent, smpd_process_t *process);
SMPD_BOOL smpd_is_affirmative(const char *str);
int smpd_hide_string_arg(char *str, const char *flag);
int smpd_get_default_hosts(void);
int smpd_lock_smpd_data(void);
int smpd_unlock_smpd_data(void);
int smpd_insert_into_dynamic_hosts(void);
int smpd_remove_from_dynamic_hosts(void);
int smpd_get_pwd_from_file(char *file_name);
int smpd_get_next_hostname(char *host, char *alt_host);
SMPD_BOOL smpd_parse_machine_file(char *file_name);
int smpd_parse_hosts_string(const char *host_str);
int smpd_get_host_id(char *host, int *id_ptr);
int smpd_get_next_host(smpd_host_node_t **host_node_pptr, smpd_launch_node_t *launch_node);
SMPD_BOOL smpd_get_argcv_from_file(FILE *fin, int *argcp, char ***argvp);
int smpd_create_cliques(smpd_launch_node_t *list);
int smpd_handle_spawn_command(smpd_context_t *context);
int smpd_handle_abort_job_command(smpd_context_t *context);
int smpd_abort_job(char *name, int rank, char *fmt, ...);
int smpd_suspend_process(smpd_process_t *process);
int smpd_kill_process(smpd_process_t *process, int exit_code);
int smpd_handle_suspend_result(smpd_command_t *cmd, char *result_str);
int smpd_watch_processes(void);
int smpd_get_hostname(char *host, int length);
int PMIX_Start_root_smpd(int nproc, char *host, int len, int *port);
int PMIX_Stop_root_smpd(void);
int smpd_hash(char *input, int input_length, char *output, int output_length);
int smpd_encrypt_data(char *input, int input_length, char *output, int output_length);
int smpd_decrypt_data(char *input, int input_length, char *output, int *output_length);
int smpd_get_all_smpd_data(smpd_data_t **data);
int smpd_create_sspi_client_context(smpd_sspi_client_context_t **new_context);
int smpd_free_sspi_client_context(smpd_sspi_client_context_t **context);
int smpd_sspi_context_init(smpd_sspi_client_context_t **sspi_context_pptr, const char *host, int port, smpd_sspi_type_t type);
int smpd_sspi_context_iter(int sspi_id, void **sspi_buffer_pptr, int *length_ptr);
SMPD_BOOL smpd_setup_scp(void);
SMPD_BOOL smpd_remove_scp(void);
int smpd_register_spn(const char *dc, const char *dn, const char *dh);
int smpd_lookup_spn(char *target, int length, const char * host, int port);
SMPD_BOOL smpd_map_user_drives(char *pszMap, char *pszAccount, char *pszPassword, char *pszError, int maxerrlength);
SMPD_BOOL smpd_unmap_user_drives(char *pszMap);
void smpd_finalize_drive_maps(void);
int smpd_append_env_option(char *str, int maxlen, const char *env_name, const char *env_val);
#ifdef HAVE_WINDOWS_H
int smpd_add_job_key(const char *key, const char *username, const char *domain, const char *full_domain);
int smpd_add_job_key_and_handle(const char *key, const char *username, const char *domain, const char *full_domain, HANDLE hUser);
int smpd_remove_job_key(const char *key);
int smpd_associate_job_key(const char *key, const char *username, const char *domain, const char *full_domain, HANDLE user_handle);
int smpd_lookup_job_key(const char *key, const char *username, HANDLE *user_handle, HANDLE *job_handle);
#endif
SMPD_BOOL smpd_verify_version(const char *challenge);
void smpd_fix_up_host_tree(smpd_host_node_t *node);
SMPD_BOOL smpd_isnumbers_with_colon(const char *str);
int smpd_add_host_to_default_list(const char *hostname);
int smpd_add_extended_host_to_default_list(const char *hostname, const char *alt_hostname, const int num_cpus);
int smpd_parse_map_string(const char *str, smpd_map_drive_node_t **list);
int smpd_delayed_spawn_enqueue(smpd_context_t *context);
int smpd_delayed_spawn_dequeue(smpd_context_t **context);
int smpd_handle_delayed_spawn_command(void);

#if defined(__cplusplus)
}
#endif

#endif